@overlastic/svelte 0.4.3

package/dist/index.js

@@ -0,0 +1,216 @@
+// src/define/constructor.ts
+import { createConstructor } from "@overlastic/core";
+
+// 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 context = new Map([..._context.entries()]);
+  context.set(injectOverlayKey, {
+    resolve: deferred.resolve,
+    reject: deferred.reject,
+    deferred,
+    visible: false,
+    vanish
+  });
+  const childApp = new Inst({
+    target: container,
+    props,
+    context
+  });
+});
+
+// src/define/index.ts
+var defineOverlay = constructor.define;
+var renderOverlay = constructor.render;
+
+// src/composable/usePrograms.ts
+import { getContext, setContext } from "svelte";
+function usePrograms(options = {}) {
+  setContext(injectOptionsKey, options);
+  return getContext(injectOverlayKey);
+}
+
+// src/components/index.ts
+import { getContext as getContext2, onMount } from "svelte";
+import { delay } from "@overlastic/core";
+import {
+  SvelteComponentTyped,
+  check_outros,
+  create_slot,
+  detach,
+  empty,
+  get_all_dirty_from_scope,
+  get_slot_changes,
+  group_outros,
+  init,
+  insert,
+  noop,
+  safe_not_equal,
+  transition_in,
+  transition_out,
+  update_slot_base
+} from "svelte/internal";
+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 } = getContext2(injectOptionsKey) || {};
+  const { deferred, vanish } = getContext2(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);
+  }
+};
+export {
+  Overlay,
+  defineOverlay,
+  renderOverlay,
+  usePrograms
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@overlastic/svelte",
+  "type": "module",
+  "version": "0.4.3",
+  "license": "MIT",
+  "homepage": "https://github.com/hairyf/overlastic#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hairyf/overlastic.git"
+  },
+  "bugs": {
+    "url": "https://github.com/hairyf/overlastic/issues"
+  },
+  "keywords": [
+    "unified",
+    "overlay",
+    "svelte"
+  ],
+  "main": "./dist/index.cjs",
+  "publishConfig": {
+    "jsdelivr": "./dist/index.global.js",
+    "linkDirectory": false
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "svelte": "^3.57.0",
+    "@overlastic/core": "^0.4.3"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts",
+    "lint": "eslint ."
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "types": "./dist/index.d.ts"
+}