@overlastic/svelte 0.4.3

package/dist/index.global.js

@@ -0,0 +1,766 @@
+"use strict";
+var OverlaysSvelte = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    Overlay: () => Overlay,
+    defineOverlay: () => defineOverlay,
+    renderOverlay: () => renderOverlay,
+    usePrograms: () => usePrograms
+  });
+
+  // ../@core/src/define/global.ts
+  var UnifiedOverlayProviderID = "unified-overlay";
+  function defineGlobalElement(id = "", root = document.body) {
+    const el = document.createElement("div");
+    if (id)
+      el.id = id;
+    if (root !== false)
+      root.appendChild(el);
+    return el;
+  }
+
+  // ../@core/src/internal/index.ts
+  var context = {
+    position: null,
+    spaces: {}
+  };
+
+  // ../@core/src/define/name-index.ts
+  function defineName(id = UnifiedOverlayProviderID, auto = true) {
+    if (!context.spaces[id])
+      context.spaces[id] = 0;
+    if (auto)
+      return `${id}--${++context.spaces[id]}`;
+    return id;
+  }
+  function getIndex(id = UnifiedOverlayProviderID) {
+    return context.spaces[id] || 0;
+  }
+
+  // ../@core/src/deferred.ts
+  function createDeferred() {
+    let resolve, reject;
+    const promise = new Promise((_resolve, _reject) => {
+      resolve = _resolve;
+      reject = _reject;
+    });
+    promise.resolve = (v) => {
+      resolve(v);
+      return promise;
+    };
+    promise.reject = reject;
+    return promise;
+  }
+
+  // ../@core/src/events/index.ts
+  function watchClickPosition() {
+    if (typeof window === "undefined" && typeof document === "undefined")
+      return;
+    document.addEventListener("click", (event) => {
+      if (event.target instanceof Element) {
+        const { left, top, width, height } = event.target.getBoundingClientRect();
+        if (left > 0 || top > 0) {
+          context.position = { x: left + width / 2, y: top + height / 2 };
+        } else {
+          context.position = null;
+        }
+      } else {
+        context.position = null;
+      }
+      setTimeout(() => context.position = null, 64);
+    });
+  }
+
+  // ../@core/src/constructor.ts
+  function createConstructor(mount) {
+    function define(instance2, options) {
+      function executor(props, options2) {
+        const deferred = createDeferred();
+        const name = defineName(options2.id, options2.autoIncrement);
+        const index = getIndex(options2.id);
+        const container = defineGlobalElement(name, options2.root);
+        mount(instance2, props, Object.assign(options2, {
+          position: context.position,
+          id: name,
+          deferred,
+          index,
+          container
+        }));
+        return deferred;
+      }
+      let inst;
+      function only(props, options2) {
+        if (!inst) {
+          inst = executor(props, options2);
+          inst.finally(() => inst = void 0);
+        }
+        return inst;
+      }
+      function caller(props, overrides) {
+        const opts = { ...options, ...overrides };
+        return opts.only ? only(props, opts) : executor(props, opts);
+      }
+      return caller;
+    }
+    function render(instance2, props, options) {
+      return define(instance2, options)(props);
+    }
+    return { define, render };
+  }
+  watchClickPosition();
+
+  // ../@core/src/utils/util.ts
+  function delay(milliseconds) {
+    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+  }
+
+  // src/internal/index.ts
+  var injectOverlayKey = Symbol("overlays:svelte");
+  var injectOptionsKey = Symbol("overlays:options");
+
+  // src/define/constructor.ts
+  var constructor = createConstructor((Inst, props, options) => {
+    const { container, deferred, context: _context = /* @__PURE__ */ new Map() } = options;
+    function vanish() {
+      childApp.$destroy();
+      container.remove();
+    }
+    const context2 = new Map([..._context.entries()]);
+    context2.set(injectOverlayKey, {
+      resolve: deferred.resolve,
+      reject: deferred.reject,
+      deferred,
+      visible: false,
+      vanish
+    });
+    const childApp = new Inst({
+      target: container,
+      props,
+      context: context2
+    });
+  });
+
+  // src/define/index.ts
+  var defineOverlay = constructor.define;
+  var renderOverlay = constructor.render;
+
+  // ../../node_modules/.pnpm/svelte@3.57.0/node_modules/svelte/internal/index.mjs
+  function noop() {
+  }
+  function assign(tar, src) {
+    for (const k in src)
+      tar[k] = src[k];
+    return tar;
+  }
+  function run(fn) {
+    return fn();
+  }
+  function blank_object() {
+    return /* @__PURE__ */ Object.create(null);
+  }
+  function run_all(fns) {
+    fns.forEach(run);
+  }
+  function is_function(thing) {
+    return typeof thing === "function";
+  }
+  function safe_not_equal(a, b) {
+    return a != a ? b == b : a !== b || (a && typeof a === "object" || typeof a === "function");
+  }
+  function is_empty(obj) {
+    return Object.keys(obj).length === 0;
+  }
+  function create_slot(definition, ctx, $$scope, fn) {
+    if (definition) {
+      const slot_ctx = get_slot_context(definition, ctx, $$scope, fn);
+      return definition[0](slot_ctx);
+    }
+  }
+  function get_slot_context(definition, ctx, $$scope, fn) {
+    return definition[1] && fn ? assign($$scope.ctx.slice(), definition[1](fn(ctx))) : $$scope.ctx;
+  }
+  function get_slot_changes(definition, $$scope, dirty, fn) {
+    if (definition[2] && fn) {
+      const lets = definition[2](fn(dirty));
+      if ($$scope.dirty === void 0) {
+        return lets;
+      }
+      if (typeof lets === "object") {
+        const merged = [];
+        const len = Math.max($$scope.dirty.length, lets.length);
+        for (let i = 0; i < len; i += 1) {
+          merged[i] = $$scope.dirty[i] | lets[i];
+        }
+        return merged;
+      }
+      return $$scope.dirty | lets;
+    }
+    return $$scope.dirty;
+  }
+  function update_slot_base(slot, slot_definition, ctx, $$scope, slot_changes, get_slot_context_fn) {
+    if (slot_changes) {
+      const slot_context = get_slot_context(slot_definition, ctx, $$scope, get_slot_context_fn);
+      slot.p(slot_context, slot_changes);
+    }
+  }
+  function get_all_dirty_from_scope($$scope) {
+    if ($$scope.ctx.length > 32) {
+      const dirty = [];
+      const length = $$scope.ctx.length / 32;
+      for (let i = 0; i < length; i++) {
+        dirty[i] = -1;
+      }
+      return dirty;
+    }
+    return -1;
+  }
+  var is_hydrating = false;
+  function start_hydrating() {
+    is_hydrating = true;
+  }
+  function end_hydrating() {
+    is_hydrating = false;
+  }
+  function insert(target, node, anchor) {
+    target.insertBefore(node, anchor || null);
+  }
+  function detach(node) {
+    if (node.parentNode) {
+      node.parentNode.removeChild(node);
+    }
+  }
+  function text(data) {
+    return document.createTextNode(data);
+  }
+  function empty() {
+    return text("");
+  }
+  function children(element) {
+    return Array.from(element.childNodes);
+  }
+  var current_component;
+  function set_current_component(component) {
+    current_component = component;
+  }
+  function get_current_component() {
+    if (!current_component)
+      throw new Error("Function called outside component initialization");
+    return current_component;
+  }
+  function setContext(key, context2) {
+    get_current_component().$$.context.set(key, context2);
+    return context2;
+  }
+  function getContext(key) {
+    return get_current_component().$$.context.get(key);
+  }
+  var dirty_components = [];
+  var binding_callbacks = [];
+  var render_callbacks = [];
+  var flush_callbacks = [];
+  var resolved_promise = /* @__PURE__ */ Promise.resolve();
+  var update_scheduled = false;
+  function schedule_update() {
+    if (!update_scheduled) {
+      update_scheduled = true;
+      resolved_promise.then(flush);
+    }
+  }
+  function add_render_callback(fn) {
+    render_callbacks.push(fn);
+  }
+  var seen_callbacks = /* @__PURE__ */ new Set();
+  var flushidx = 0;
+  function flush() {
+    if (flushidx !== 0) {
+      return;
+    }
+    const saved_component = current_component;
+    do {
+      try {
+        while (flushidx < dirty_components.length) {
+          const component = dirty_components[flushidx];
+          flushidx++;
+          set_current_component(component);
+          update(component.$$);
+        }
+      } catch (e) {
+        dirty_components.length = 0;
+        flushidx = 0;
+        throw e;
+      }
+      set_current_component(null);
+      dirty_components.length = 0;
+      flushidx = 0;
+      while (binding_callbacks.length)
+        binding_callbacks.pop()();
+      for (let i = 0; i < render_callbacks.length; i += 1) {
+        const callback = render_callbacks[i];
+        if (!seen_callbacks.has(callback)) {
+          seen_callbacks.add(callback);
+          callback();
+        }
+      }
+      render_callbacks.length = 0;
+    } while (dirty_components.length);
+    while (flush_callbacks.length) {
+      flush_callbacks.pop()();
+    }
+    update_scheduled = false;
+    seen_callbacks.clear();
+    set_current_component(saved_component);
+  }
+  function update($$) {
+    if ($$.fragment !== null) {
+      $$.update();
+      run_all($$.before_update);
+      const dirty = $$.dirty;
+      $$.dirty = [-1];
+      $$.fragment && $$.fragment.p($$.ctx, dirty);
+      $$.after_update.forEach(add_render_callback);
+    }
+  }
+  function flush_render_callbacks(fns) {
+    const filtered = [];
+    const targets = [];
+    render_callbacks.forEach((c) => fns.indexOf(c) === -1 ? filtered.push(c) : targets.push(c));
+    targets.forEach((c) => c());
+    render_callbacks = filtered;
+  }
+  var outroing = /* @__PURE__ */ new Set();
+  var outros;
+  function group_outros() {
+    outros = {
+      r: 0,
+      c: [],
+      p: outros
+      // parent group
+    };
+  }
+  function check_outros() {
+    if (!outros.r) {
+      run_all(outros.c);
+    }
+    outros = outros.p;
+  }
+  function transition_in(block, local) {
+    if (block && block.i) {
+      outroing.delete(block);
+      block.i(local);
+    }
+  }
+  function transition_out(block, local, detach2, callback) {
+    if (block && block.o) {
+      if (outroing.has(block))
+        return;
+      outroing.add(block);
+      outros.c.push(() => {
+        outroing.delete(block);
+        if (callback) {
+          if (detach2)
+            block.d(1);
+          callback();
+        }
+      });
+      block.o(local);
+    } else if (callback) {
+      callback();
+    }
+  }
+  var globals = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : global;
+  var _boolean_attributes = [
+    "allowfullscreen",
+    "allowpaymentrequest",
+    "async",
+    "autofocus",
+    "autoplay",
+    "checked",
+    "controls",
+    "default",
+    "defer",
+    "disabled",
+    "formnovalidate",
+    "hidden",
+    "inert",
+    "ismap",
+    "itemscope",
+    "loop",
+    "multiple",
+    "muted",
+    "nomodule",
+    "novalidate",
+    "open",
+    "playsinline",
+    "readonly",
+    "required",
+    "reversed",
+    "selected"
+  ];
+  var boolean_attributes = /* @__PURE__ */ new Set([..._boolean_attributes]);
+  function mount_component(component, target, anchor, customElement) {
+    const { fragment, after_update } = component.$$;
+    fragment && fragment.m(target, anchor);
+    if (!customElement) {
+      add_render_callback(() => {
+        const new_on_destroy = component.$$.on_mount.map(run).filter(is_function);
+        if (component.$$.on_destroy) {
+          component.$$.on_destroy.push(...new_on_destroy);
+        } else {
+          run_all(new_on_destroy);
+        }
+        component.$$.on_mount = [];
+      });
+    }
+    after_update.forEach(add_render_callback);
+  }
+  function destroy_component(component, detaching) {
+    const $$ = component.$$;
+    if ($$.fragment !== null) {
+      flush_render_callbacks($$.after_update);
+      run_all($$.on_destroy);
+      $$.fragment && $$.fragment.d(detaching);
+      $$.on_destroy = $$.fragment = null;
+      $$.ctx = [];
+    }
+  }
+  function make_dirty(component, i) {
+    if (component.$$.dirty[0] === -1) {
+      dirty_components.push(component);
+      schedule_update();
+      component.$$.dirty.fill(0);
+    }
+    component.$$.dirty[i / 31 | 0] |= 1 << i % 31;
+  }
+  function init(component, options, instance2, create_fragment2, not_equal, props, append_styles, dirty = [-1]) {
+    const parent_component = current_component;
+    set_current_component(component);
+    const $$ = component.$$ = {
+      fragment: null,
+      ctx: [],
+      // state
+      props,
+      update: noop,
+      not_equal,
+      bound: blank_object(),
+      // lifecycle
+      on_mount: [],
+      on_destroy: [],
+      on_disconnect: [],
+      before_update: [],
+      after_update: [],
+      context: new Map(options.context || (parent_component ? parent_component.$$.context : [])),
+      // everything else
+      callbacks: blank_object(),
+      dirty,
+      skip_bound: false,
+      root: options.target || parent_component.$$.root
+    };
+    append_styles && append_styles($$.root);
+    let ready = false;
+    $$.ctx = instance2 ? instance2(component, options.props || {}, (i, ret, ...rest) => {
+      const value = rest.length ? rest[0] : ret;
+      if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
+        if (!$$.skip_bound && $$.bound[i])
+          $$.bound[i](value);
+        if (ready)
+          make_dirty(component, i);
+      }
+      return ret;
+    }) : [];
+    $$.update();
+    ready = true;
+    run_all($$.before_update);
+    $$.fragment = create_fragment2 ? create_fragment2($$.ctx) : false;
+    if (options.target) {
+      if (options.hydrate) {
+        start_hydrating();
+        const nodes = children(options.target);
+        $$.fragment && $$.fragment.l(nodes);
+        nodes.forEach(detach);
+      } else {
+        $$.fragment && $$.fragment.c();
+      }
+      if (options.intro)
+        transition_in(component.$$.fragment);
+      mount_component(component, options.target, options.anchor, options.customElement);
+      end_hydrating();
+      flush();
+    }
+    set_current_component(parent_component);
+  }
+  var SvelteElement;
+  if (typeof HTMLElement === "function") {
+    SvelteElement = class extends HTMLElement {
+      constructor() {
+        super();
+        this.attachShadow({ mode: "open" });
+      }
+      connectedCallback() {
+        const { on_mount } = this.$$;
+        this.$$.on_disconnect = on_mount.map(run).filter(is_function);
+        for (const key in this.$$.slotted) {
+          this.appendChild(this.$$.slotted[key]);
+        }
+      }
+      attributeChangedCallback(attr, _oldValue, newValue) {
+        this[attr] = newValue;
+      }
+      disconnectedCallback() {
+        run_all(this.$$.on_disconnect);
+      }
+      $destroy() {
+        destroy_component(this, 1);
+        this.$destroy = noop;
+      }
+      $on(type, callback) {
+        if (!is_function(callback)) {
+          return noop;
+        }
+        const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
+        callbacks.push(callback);
+        return () => {
+          const index = callbacks.indexOf(callback);
+          if (index !== -1)
+            callbacks.splice(index, 1);
+        };
+      }
+      $set($$props) {
+        if (this.$$set && !is_empty($$props)) {
+          this.$$.skip_bound = true;
+          this.$$set($$props);
+          this.$$.skip_bound = false;
+        }
+      }
+    };
+  }
+  var SvelteComponent = class {
+    $destroy() {
+      destroy_component(this, 1);
+      this.$destroy = noop;
+    }
+    $on(type, callback) {
+      if (!is_function(callback)) {
+        return noop;
+      }
+      const callbacks = this.$$.callbacks[type] || (this.$$.callbacks[type] = []);
+      callbacks.push(callback);
+      return () => {
+        const index = callbacks.indexOf(callback);
+        if (index !== -1)
+          callbacks.splice(index, 1);
+      };
+    }
+    $set($$props) {
+      if (this.$$set && !is_empty($$props)) {
+        this.$$.skip_bound = true;
+        this.$$set($$props);
+        this.$$.skip_bound = false;
+      }
+    }
+  };
+  var SvelteComponentDev = class extends SvelteComponent {
+    constructor(options) {
+      if (!options || !options.target && !options.$$inline) {
+        throw new Error("'target' is a required option");
+      }
+      super();
+    }
+    $destroy() {
+      super.$destroy();
+      this.$destroy = () => {
+        console.warn("Component was already destroyed");
+      };
+    }
+    $capture_state() {
+    }
+    $inject_state() {
+    }
+  };
+  var SvelteComponentTyped = class extends SvelteComponentDev {
+    constructor(options) {
+      super(options);
+    }
+  };
+
+  // ../../node_modules/.pnpm/svelte@3.57.0/node_modules/svelte/ssr.mjs
+  function onMount() {
+  }
+
+  // src/composable/usePrograms.ts
+  function usePrograms(options = {}) {
+    setContext(injectOptionsKey, options);
+    return getContext(injectOverlayKey);
+  }
+
+  // src/components/index.ts
+  function create_if_block(ctx) {
+    let current;
+    const default_slot_template = (
+      /* #slots */
+      ctx[2].default
+    );
+    const default_slot = create_slot(
+      default_slot_template,
+      ctx,
+      /* $$scope */
+      ctx[1],
+      null
+    );
+    return {
+      c() {
+        if (default_slot)
+          default_slot.c();
+      },
+      m(target, anchor) {
+        if (default_slot)
+          default_slot.m(target, anchor);
+        current = true;
+      },
+      p(ctx2, dirty) {
+        if (default_slot) {
+          if (default_slot.p && (!current || dirty & 2)) {
+            update_slot_base(
+              default_slot,
+              default_slot_template,
+              ctx2,
+              /* $$scope */
+              ctx2[1],
+              !current ? get_all_dirty_from_scope(
+                /* $$scope */
+                ctx2[1]
+              ) : get_slot_changes(
+                default_slot_template,
+                /* $$scope */
+                ctx2[1],
+                dirty,
+                null
+              ),
+              null
+            );
+          }
+        }
+      },
+      i(local) {
+        if (current)
+          return;
+        transition_in(default_slot, local);
+        current = true;
+      },
+      o(local) {
+        transition_out(default_slot, local);
+        current = false;
+      },
+      d(detaching) {
+        if (default_slot)
+          default_slot.d(detaching);
+      }
+    };
+  }
+  function create_fragment(ctx) {
+    let if_block_anchor;
+    let current;
+    let if_block = (
+      /* visible */
+      ctx[0] && create_if_block(ctx)
+    );
+    return {
+      c() {
+        if (if_block)
+          if_block.c();
+        if_block_anchor = empty();
+      },
+      m(target, anchor) {
+        if (if_block)
+          if_block.m(target, anchor);
+        insert(target, if_block_anchor, anchor);
+        current = true;
+      },
+      p(ctx2, [dirty]) {
+        if (
+          /* visible */
+          ctx2[0]
+        ) {
+          if (if_block) {
+            if_block.p(ctx2, dirty);
+            if (dirty & 1)
+              transition_in(if_block, 1);
+          } else {
+            if_block = create_if_block(ctx2);
+            if_block.c();
+            transition_in(if_block, 1);
+            if_block.m(if_block_anchor.parentNode, if_block_anchor);
+          }
+        } else if (if_block) {
+          group_outros();
+          transition_out(if_block, 1, 1, () => {
+            if_block = null;
+          });
+          check_outros();
+        }
+      },
+      i() {
+        if (current)
+          return;
+        transition_in(if_block);
+        current = true;
+      },
+      o() {
+        transition_out(if_block);
+        current = false;
+      },
+      d(detaching) {
+        if (if_block)
+          if_block.d(detaching);
+        if (detaching)
+          detach(if_block_anchor);
+      }
+    };
+  }
+  function instance($$self, $$props, $$invalidate) {
+    let { $$slots: slots = {}, $$scope } = $$props;
+    let { visible = false } = $$props;
+    const { duration = 0, immediate = true } = getContext(injectOptionsKey) || {};
+    const { deferred, vanish } = getContext(injectOverlayKey);
+    async function destroy() {
+      $$invalidate(0, visible = false);
+      await delay(duration);
+      vanish == null ? void 0 : vanish();
+      return Promise.resolve();
+    }
+    onMount(() => immediate && $$invalidate(0, visible = true));
+    deferred == null ? void 0 : deferred.then(destroy).catch(destroy);
+    $$self.$$set = ($$props2) => {
+      if ("visible" in $$props2)
+        $$invalidate(0, visible = $$props2.visible);
+      if ("$$scope" in $$props2)
+        $$invalidate(1, $$scope = $$props2.$$scope);
+    };
+    return [visible, $$scope, slots];
+  }
+  var Overlay = class extends SvelteComponentTyped {
+    constructor(options) {
+      super(options);
+      init(this, options, instance, create_fragment, safe_not_equal, { visible: 0 }, noop);
+    }
+  };
+  return __toCommonJS(src_exports);
+})();