xjs/layer.js

(function (global, factory) {
  const LayerClass = factory();
  // Allow usage as `Layer({...})` or `new Layer()`
  // But Layer is a class. We can wrap it in a proxy or factory function.
  
  function LayerFactory(options) {
     if (options && typeof options === 'object') {
         return LayerClass.$(options);
     }
     return new LayerClass();
  }
  
  // Copy static methods (including non-enumerable class statics like `fire` / `$`)
  // Class static methods are non-enumerable by default, so Object.assign() would miss them.
  const copyStatic = (to, from) => {
    try {
      Object.getOwnPropertyNames(from).forEach((k) => {
        if (k === 'prototype' || k === 'name' || k === 'length') return;
        const desc = Object.getOwnPropertyDescriptor(from, k);
        if (!desc) return;
        Object.defineProperty(to, k, desc);
      });
    } catch (e) {
      // Best-effort fallback
      try { Object.assign(to, from); } catch {}
    }
  };
  copyStatic(LayerFactory, LayerClass);
  // Also copy prototype for instanceof checks if needed (though tricky with factory)
  LayerFactory.prototype = LayerClass.prototype;
  
  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = LayerFactory :
    typeof define === 'function' && define.amd ? define(() => LayerFactory) :
      (global.Layer = LayerFactory);
}(this, (function () {
  'use strict';

  const PREFIX = 'layer-';
  const RING_TYPES = new Set(['success', 'error', 'warning', 'info', 'question']);
  const RING_BG_PARTS_SELECTOR = `.${PREFIX}success-circular-line-left, .${PREFIX}success-circular-line-right, .${PREFIX}success-fix`;

  const normalizeOptions = (options, text, icon) => {
    if (typeof options !== 'string') return options || {};
    const o = { title: options };
    if (text) o.text = text;
    if (icon) o.icon = icon;
    return o;
  };
  
  const el = (tag, className, text) => {
    const node = document.createElement(tag);
    if (className) node.className = className;
    if (text !== undefined) node.textContent = text;
    return node;
  };
  
  const svgEl = (tag) => document.createElementNS('http://www.w3.org/2000/svg', tag);
  
  // Ensure library CSS is loaded (xjs.css)
  // - CSS is centralized in xjs.css (no runtime <style> injection).
  // - We still auto-load it for convenience/compat, since consumers may forget the <link>.
  const ensureXjsCss = () => {
    try {
      if (typeof document === 'undefined') return;
      if (!document.head) return;

      const existingHref = Array.from(document.querySelectorAll('link[rel="stylesheet"]'))
        .map((l) => (l.getAttribute('href') || '').trim())
        .find((h) => /(^|\/)xjs\.css(\?|#|$)/.test(h));
      if (existingHref) return;

      const id = 'xjs-css';
      if (document.getElementById(id)) return;

      const scripts = Array.from(document.getElementsByTagName('script'));
      const scriptSrc = scripts
        .map((s) => s && s.src)
        .find((src) => /(^|\/)(xjs|layer)\.js(\?|#|$)/.test(String(src || '')));

      let href = 'xjs.css';
      if (scriptSrc) {
        href = String(scriptSrc)
          .replace(/(^|\/)xjs\.js(\?|#|$)/, '$1xjs.css$2')
          .replace(/(^|\/)layer\.js(\?|#|$)/, '$1xjs.css$2');
      }

      const link = document.createElement('link');
      link.id = id;
      link.rel = 'stylesheet';
      link.href = href;
      document.head.appendChild(link);
    } catch {
      // ignore
    }
  };

  class Layer {
    constructor() {
      ensureXjsCss();
      this.params = {};
      this.dom = {};
      this.promise = null;
      this.resolve = null;
      this.reject = null;
      this._onKeydown = null;
    }

    // Constructor helper when called as function: const popup = Layer({...})
    static get isProxy() { return true; }
    
    // Static entry point
    static fire(options) {
      const instance = new Layer();
      return instance._fire(options);
    }
    
    // Chainable entry point (builder-style)
    // Example:
    //   Layer.$({ title: 'Hi' }).fire().then(...)
    //   Layer.$().config({ title: 'Hi' }).fire()
    static $(options) {
      const instance = new Layer();
      if (options !== undefined) instance.config(options);
      return instance;
    }
    
    // Chainable config helper (does not render until `.fire()` is called)
    config(options = {}) {
      // Support the same shorthand as Layer.fire(title, text, icon)
      options = normalizeOptions(options, arguments[1], arguments[2]);
      this.params = { ...(this.params || {}), ...options };
      return this;
    }
    
    // Instance entry point (chainable)
    fire(options) {
      const merged = (options === undefined) ? (this.params || {}) : options;
      return this._fire(merged);
    }

    _fire(options = {}) {
      options = normalizeOptions(options, arguments[1], arguments[2]);

      this.params = {
        title: '',
        text: '',
        icon: null,
        iconSize: null, // e.g. '6em' / '72px'
        confirmButtonText: 'OK',
        cancelButtonText: 'Cancel',
        showCancelButton: false,
        confirmButtonColor: '#3085d6',
        cancelButtonColor: '#aaa',
        closeOnClickOutside: true,
        closeOnEsc: true,
        iconAnimation: true,
        popupAnimation: true,
        ...options
      };

      this.promise = new Promise((resolve, reject) => {
        this.resolve = resolve;
        this.reject = reject;
      });

      this._render();
      return this.promise;
    }

    static _getXjs() {
      // Prefer xjs, fallback to animal (compat)
      const g = (typeof window !== 'undefined') ? window : (typeof globalThis !== 'undefined' ? globalThis : null);
      if (!g) return null;
      const x = g.xjs || g.animal;
      return (typeof x === 'function') ? x : null;
    }

    _render() {
      // Remove existing if any
      const existing = document.querySelector(`.${PREFIX}overlay`);
      if (existing) existing.remove();

      // Create Overlay
      this.dom.overlay = el('div', `${PREFIX}overlay`);

      // Create Popup
      this.dom.popup = el('div', `${PREFIX}popup`);
      this.dom.overlay.appendChild(this.dom.popup);

      // Icon
      if (this.params.icon) {
        this.dom.icon = this._createIcon(this.params.icon);
        this.dom.popup.appendChild(this.dom.icon);
      }

      // Title
      if (this.params.title) {
        this.dom.title = el('h2', `${PREFIX}title`, this.params.title);
        this.dom.popup.appendChild(this.dom.title);
      }

      // Content (Text / HTML / Element)
      if (this.params.text || this.params.html || this.params.content) {
        this.dom.content = el('div', `${PREFIX}content`);
        
        if (this.params.content) {
           // DOM Element or Selector
           let el = this.params.content;
           if (typeof el === 'string') el = document.querySelector(el);
           if (el instanceof Element) this.dom.content.appendChild(el); 
        } else if (this.params.html) {
           this.dom.content.innerHTML = this.params.html;
        } else {
           this.dom.content.textContent = this.params.text;
        }
        
        this.dom.popup.appendChild(this.dom.content);
      }

      // Actions
      this.dom.actions = el('div', `${PREFIX}actions`);
      
      // Cancel Button
      if (this.params.showCancelButton) {
        this.dom.cancelBtn = el('button', `${PREFIX}button ${PREFIX}cancel`, this.params.cancelButtonText);
        this.dom.cancelBtn.style.backgroundColor = this.params.cancelButtonColor;
        this.dom.cancelBtn.onclick = () => this._close(false);
        this.dom.actions.appendChild(this.dom.cancelBtn);
      }

      // Confirm Button
      this.dom.confirmBtn = el('button', `${PREFIX}button ${PREFIX}confirm`, this.params.confirmButtonText);
      this.dom.confirmBtn.style.backgroundColor = this.params.confirmButtonColor;
      this.dom.confirmBtn.onclick = () => this._close(true);
      this.dom.actions.appendChild(this.dom.confirmBtn);

      this.dom.popup.appendChild(this.dom.actions);

      // Event Listeners
      if (this.params.closeOnClickOutside) {
        this.dom.overlay.addEventListener('click', (e) => {
          if (e.target === this.dom.overlay) {
            this._close(null); // Dismiss
          }
        });
      }

      document.body.appendChild(this.dom.overlay);

      // Animation
      requestAnimationFrame(() => {
        this.dom.overlay.classList.add('show');
        this._didOpen();
      });
    }

    _createIcon(type) {
      const icon = el('div', `${PREFIX}icon ${type}`);
      const applyIconSize = (mode) => {
        if (!(this.params && this.params.iconSize)) return;
        try {
          const s = String(this.params.iconSize).trim();
          if (!s) return;
          // For SweetAlert2-style success icon, scale via font-size so all `em`-based parts remain proportional.
          if (mode === 'font') {
            const m = s.match(/^(-?\d*\.?\d+)\s*(px|em|rem)$/i);
            if (m) {
              const n = parseFloat(m[1]);
              const unit = m[2];
              if (Number.isFinite(n) && n > 0) {
                icon.style.fontSize = (n / 5) + unit; // icon is 5em wide/tall
                return;
              }
            }
          }
          // Fallback: directly size the box (works great for SVG icons)
          icon.style.width = s;
          icon.style.height = s;
        } catch {}
      };
      
      const appendRingParts = () => {
        // Use the same "success-like" ring parts for every built-in icon
        icon.appendChild(el('div', `${PREFIX}success-circular-line-left`));
        icon.appendChild(el('div', `${PREFIX}success-ring`));
        icon.appendChild(el('div', `${PREFIX}success-fix`));
        icon.appendChild(el('div', `${PREFIX}success-circular-line-right`));
      };
      
      const createInnerMarkSvg = () => {
        const svg = svgEl('svg');
        svg.setAttribute('viewBox', '0 0 80 80');
        svg.setAttribute('aria-hidden', 'true');
        svg.setAttribute('focusable', 'false');
        return svg;
      };
      
      const addMarkPath = (svg, d, extraClass) => {
        const p = svgEl('path');
        p.setAttribute('d', d);
        p.setAttribute('class', `${PREFIX}svg-mark ${PREFIX}svg-draw${extraClass ? ' ' + extraClass : ''}`);
        p.setAttribute('stroke', 'currentColor');
        svg.appendChild(p);
        return p;
      };
      
      const addDot = (svg, cx, cy) => {
        const dot = svgEl('circle');
        dot.setAttribute('class', `${PREFIX}svg-dot`);
        dot.setAttribute('cx', String(cx));
        dot.setAttribute('cy', String(cy));
        dot.setAttribute('r', '3.2');
        dot.setAttribute('fill', 'currentColor');
        svg.appendChild(dot);
        return dot;
      };
      
      const appendBuiltInInnerMark = (svg) => {
        if (type === 'error') {
          addMarkPath(svg, 'M28 28 L52 52', `${PREFIX}svg-error-left`);
          addMarkPath(svg, 'M52 28 L28 52', `${PREFIX}svg-error-right`);
        } else if (type === 'warning') {
          addMarkPath(svg, 'M40 20 L40 46', `${PREFIX}svg-warning-line`);
          addDot(svg, 40, 58);
        } else if (type === 'info') {
          addMarkPath(svg, 'M40 34 L40 56', `${PREFIX}svg-info-line`);
          addDot(svg, 40, 25);
        } else if (type === 'question') {
          addMarkPath(svg, 'M30 30 C30 23 35 19 42 19 C49 19 54 23 54 30 C54 36 50 39 46 41 C43 42 42 44 42 48 L42 52', `${PREFIX}svg-question`);
          addDot(svg, 42, 61);
        }
      };
      
      if (type === 'success') {
        // SweetAlert2-compatible DOM structure (circle + tick) for exact style parity
        //   <div class="...success-circular-line-left"></div>
        //   <div class="...success-mark"><span class="...success-line-tip"></span><span class="...success-line-long"></span></div>
        //   <div class="...success-ring"></div>
        //   <div class="...success-fix"></div>
        //   <div class="...success-circular-line-right"></div>
        icon.appendChild(el('div', `${PREFIX}success-circular-line-left`));
        const mark = el('div', `${PREFIX}success-mark`);
        mark.appendChild(el('span', `${PREFIX}success-line-tip`));
        mark.appendChild(el('span', `${PREFIX}success-line-long`));
        icon.appendChild(mark);
        icon.appendChild(el('div', `${PREFIX}success-ring`));
        icon.appendChild(el('div', `${PREFIX}success-fix`));
        icon.appendChild(el('div', `${PREFIX}success-circular-line-right`));

        applyIconSize('font');
        return icon;
      }

      if (type === 'error' || type === 'warning' || type === 'info' || type === 'question') {
        // Use the same "success-like" ring parts for every icon
        appendRingParts();

        applyIconSize('font');

        // SVG only draws the inner symbol (no SVG ring)
        const svg = createInnerMarkSvg();
        appendBuiltInInnerMark(svg);
        icon.appendChild(svg);
        return icon;
      }

      // Default to SVG icons for other/custom types
      applyIconSize('box');

      const svg = createInnerMarkSvg();

      const ring = svgEl('circle');
      ring.setAttribute('class', `${PREFIX}svg-ring ${PREFIX}svg-draw`);
      ring.setAttribute('cx', '40');
      ring.setAttribute('cy', '40');
      ring.setAttribute('r', '34');
      ring.setAttribute('stroke', 'currentColor');

      svg.appendChild(ring);
      // For custom types, we draw ring only by default (no inner mark).

      icon.appendChild(svg);
      
      return icon;
    }

    _adjustRingBackgroundColor() {
      try {
        const icon = this.dom && this.dom.icon;
        const popup = this.dom && this.dom.popup;
        if (!icon || !popup) return;
        const bg = getComputedStyle(popup).backgroundColor;
        const parts = icon.querySelectorAll(RING_BG_PARTS_SELECTOR);
        parts.forEach((el) => {
          try { el.style.backgroundColor = bg; } catch {}
        });
      } catch {}
    }

    _didOpen() {
      // Keyboard close (ESC)
      if (this.params.closeOnEsc) {
        this._onKeydown = (e) => {
          if (!e) return;
          if (e.key === 'Escape') this._close(null);
        };
        document.addEventListener('keydown', this._onKeydown);
      }

      // Keep the "success-like" ring perfectly blended with popup bg
      this._adjustRingBackgroundColor();

      // Popup animation (optional)
      if (this.params.popupAnimation) {
        const X = Layer._getXjs();
        if (X && this.dom.popup) {
          // Override the CSS scale transition with a spring-ish entrance.
          try {
            this.dom.popup.style.transition = 'none';
            this.dom.popup.style.transform = 'scale(0.92)';
            X(this.dom.popup).animate({
              scale: [0.92, 1],
              y: [-6, 0],
              duration: 520,
              easing: { stiffness: 260, damping: 16 }
            });
          } catch {}
        }
      }

      // Icon SVG draw animation
      if (this.params.iconAnimation) {
        this._animateIcon();
      }

      // User hook (SweetAlert-ish naming)
      try {
        if (typeof this.params.didOpen === 'function') this.params.didOpen(this.dom.popup);
      } catch {}
    }

    _animateIcon() {
      const icon = this.dom.icon;
      if (!icon) return;
      const type = (this.params && this.params.icon) || '';

      // Ring animation (same as success) for all built-in icons
      if (RING_TYPES.has(type)) this._adjustRingBackgroundColor();
      try { icon.classList.remove(`${PREFIX}icon-show`); } catch {}
      requestAnimationFrame(() => {
        try { icon.classList.add(`${PREFIX}icon-show`); } catch {}
      });

      // Success tick is CSS-driven; others still draw their SVG mark after the ring starts.
      if (type === 'success') return;

      const X = Layer._getXjs();
      if (!X) return;

      const svg = icon.querySelector('svg');
      if (!svg) return;

      const marks = Array.from(svg.querySelectorAll(`.${PREFIX}svg-mark`));
      const dot = svg.querySelector(`.${PREFIX}svg-dot`);

      // If this is a built-in icon, keep the SweetAlert-like order:
      // ring sweep first (~0.51s), then draw the inner mark.
      const baseDelay = RING_TYPES.has(type) ? 520 : 0;

      if (type === 'error') {
        // Draw order: left-top -> right-bottom, then right-top -> left-bottom
        // NOTE: A tiny delay (like 70ms) looks simultaneous; make it strictly sequential.
        const a = svg.querySelector(`.${PREFIX}svg-error-left`) || marks[0];  // M28 28 L52 52
        const b = svg.querySelector(`.${PREFIX}svg-error-right`) || marks[1]; // M52 28 L28 52
        const dur = 320;
        const gap = 60;
        try { if (a) X(a).draw({ duration: dur, easing: 'ease-out', delay: baseDelay }); } catch {}
        try { if (b) X(b).draw({ duration: dur, easing: 'ease-out', delay: baseDelay + dur + gap }); } catch {}
      } else {
        // warning / info / question (single stroke) or custom SVG symbols
        marks.forEach((m, i) => {
          try { X(m).draw({ duration: 420, easing: 'ease-out', delay: baseDelay + i * 60 }); } catch {}
        });
      }

      if (dot) {
        try {
          dot.style.opacity = '0';
          // Keep dot pop after the ring begins
          const d = baseDelay + 140;
          if (type === 'info') {
            X(dot).animate({ opacity: [0, 1], y: [-8, 0], scale: [0.2, 1], duration: 420, delay: d, easing: { stiffness: 300, damping: 14 } });
          } else {
            X(dot).animate({ opacity: [0, 1], scale: [0.2, 1], duration: 320, delay: d, easing: { stiffness: 320, damping: 18 } });
          }
        } catch {}
      }
    }

    _close(isConfirmed) {
      this.dom.overlay.classList.remove('show');
      setTimeout(() => {
        if (this.dom.overlay && this.dom.overlay.parentNode) {
          this.dom.overlay.parentNode.removeChild(this.dom.overlay);
        }
      }, 300);

      if (this._onKeydown) {
        try { document.removeEventListener('keydown', this._onKeydown); } catch {}
        this._onKeydown = null;
      }

      try {
        if (typeof this.params.willClose === 'function') this.params.willClose(this.dom.popup);
      } catch {}
      try {
        if (typeof this.params.didClose === 'function') this.params.didClose();
      } catch {}

      if (isConfirmed === true) {
        this.resolve({ isConfirmed: true, isDenied: false, isDismissed: false });
      } else if (isConfirmed === false) {
        this.resolve({ isConfirmed: false, isDenied: false, isDismissed: true, dismiss: 'cancel' });
      } else {
        this.resolve({ isConfirmed: false, isDenied: false, isDismissed: true, dismiss: 'backdrop' });
      }
    }
  }

  return Layer;

})));