@shwfed/nuxt 0.10.14 → 0.11.0

package/dist/runtime/composables/useOverlay.js

@@ -0,0 +1,201 @@
+import { Context, Deferred, Effect } from "effect";
+import { reactive, ref } from "vue";
+export class OverlayService extends Context.Tag("shwfed/OverlayService")() {
+}
+function createAborted(reason) {
+  return {
+    _tag: "OverlayAborted",
+    reason
+  };
+}
+function createDefinitionNotFoundError(definitionId) {
+  return {
+    _tag: "OverlayDefinitionNotFoundError",
+    definitionId
+  };
+}
+export function isOverlayAborted(value) {
+  return typeof value === "object" && value !== null && Reflect.get(value, "_tag") === "OverlayAborted" && typeof Reflect.get(value, "reason") === "string";
+}
+function createOverlayRuntime() {
+  const definitions = reactive({});
+  const sessions = ref([]);
+  function findSessionIndex(sessionId) {
+    return sessions.value.findIndex((session) => session.sessionId === sessionId);
+  }
+  function getDefinition(definitionId) {
+    return Reflect.get(definitions, definitionId);
+  }
+  function getSession(sessionId) {
+    return sessions.value.find((session) => session.sessionId === sessionId);
+  }
+  function removeSession(sessionId) {
+    const index = findSessionIndex(sessionId);
+    if (index < 0) {
+      return void 0;
+    }
+    const [session] = sessions.value.splice(index, 1);
+    return session;
+  }
+  function closeInternal(sessionId, value) {
+    return Effect.gen(function* () {
+      const session = removeSession(sessionId);
+      if (!session) {
+        return;
+      }
+      yield* Deferred.succeed(session.deferred, value);
+    });
+  }
+  function closeDefinitionSessions(definitionId, reason) {
+    const targetSessions = sessions.value.filter((session) => session.definitionId === definitionId).map((session) => session.sessionId);
+    for (const sessionId of targetSessions) {
+      void Effect.runPromise(closeInternal(sessionId, createAborted(reason)));
+    }
+  }
+  function registerDefinition(definition) {
+    Reflect.set(definitions, definition.definitionId, definition);
+  }
+  function unregisterDefinition(definitionId, ownerId) {
+    const definition = getDefinition(definitionId);
+    if (!definition) {
+      return;
+    }
+    if (ownerId !== void 0 && definition.ownerId !== ownerId) {
+      return;
+    }
+    Reflect.deleteProperty(definitions, definitionId);
+    closeDefinitionSessions(definitionId, ownerId === void 0 ? "definition" : "owner");
+  }
+  function syncDefinitions(ownerId, nextDefinitions) {
+    const nextIds = nextDefinitions.map((definition) => definition.definitionId);
+    const currentIds = Object.values(definitions).filter((definition) => definition.ownerId === ownerId).map((definition) => definition.definitionId);
+    for (const definitionId of currentIds) {
+      if (!nextIds.includes(definitionId)) {
+        unregisterDefinition(definitionId, ownerId);
+      }
+    }
+    for (const definition of nextDefinitions) {
+      registerDefinition(definition);
+    }
+  }
+  function patchSync(sessionId, patch) {
+    const session = getSession(sessionId);
+    if (!session) {
+      return;
+    }
+    if (patch.shell) {
+      session.shell = {
+        ...session.shell,
+        ...patch.shell
+      };
+    }
+    if (patch.props) {
+      session.props = {
+        ...session.props,
+        ...patch.props
+      };
+    }
+  }
+  function closeSync(sessionId, value) {
+    void Effect.runPromise(closeInternal(sessionId, value));
+  }
+  function closeTopSync() {
+    const topSession = sessions.value.at(-1);
+    if (!topSession) {
+      return;
+    }
+    closeSync(topSession.sessionId, createAborted("dismiss"));
+  }
+  function closeAllSync() {
+    const sessionIds = sessions.value.map((session) => session.sessionId);
+    for (const sessionId of sessionIds) {
+      closeSync(sessionId, createAborted("close-all"));
+    }
+  }
+  function createHandle(session) {
+    return {
+      sessionId: session.sessionId,
+      patch: (patch) => Effect.sync(() => {
+        patchSync(session.sessionId, patch);
+      }),
+      close: (value) => closeInternal(session.sessionId, value),
+      result: Deferred.await(session.deferred)
+    };
+  }
+  const runtime = {
+    get definitions() {
+      return definitions;
+    },
+    get sessions() {
+      return sessions.value;
+    },
+    get topSession() {
+      return sessions.value.at(-1);
+    },
+    registerDefinition,
+    unregisterDefinition,
+    syncDefinitions,
+    isOpen: (sessionId) => findSessionIndex(sessionId) >= 0,
+    patchSync,
+    closeSync,
+    closeTopSync,
+    closeAllSync,
+    open: (definitionId, options) => Effect.acquireRelease(
+      Effect.gen(function* () {
+        const definition = getDefinition(definitionId);
+        if (!definition) {
+          return yield* Effect.fail(createDefinitionNotFoundError(definitionId));
+        }
+        const deferred = yield* Deferred.make();
+        const session = {
+          sessionId: crypto.randomUUID(),
+          definitionId,
+          shell: {
+            ...definition.shell,
+            ...options?.shell
+          },
+          props: {
+            ...options?.props
+          },
+          deferred
+        };
+        sessions.value.push(session);
+        return createHandle(session);
+      }),
+      (handle) => closeInternal(handle.sessionId, createAborted("scope"))
+    ),
+    patch: (sessionId, patch) => Effect.sync(() => {
+      patchSync(sessionId, patch);
+    }),
+    close: (sessionId, value) => closeInternal(sessionId, value),
+    closeTop: () => Effect.sync(() => {
+      closeTopSync();
+    }),
+    closeAll: () => Effect.sync(() => {
+      closeAllSync();
+    })
+  };
+  return runtime;
+}
+const overlayRuntime = createOverlayRuntime();
+export function useOverlay() {
+  return overlayRuntime;
+}
+export function provideOverlay(effect, runtime = overlayRuntime) {
+  return effect.pipe(Effect.provideService(OverlayService, runtime));
+}
+export function openOverlay(definitionId, options) {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.open(definitionId, options));
+}
+export function patchOverlay(sessionId, patch) {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.patch(sessionId, patch));
+}
+export function closeOverlay(sessionId, value) {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.close(sessionId, value));
+}
+export function closeTopOverlay() {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.closeTop());
+}
+export function closeAllOverlays() {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.closeAll());
+}

package/dist/runtime/layouts/default.d.vue.ts

@@ -1,6 +1,7 @@
 import type { Scope } from 'effect';
+import type { OverlayService as OverlayRuntimeService } from '../composables/useOverlay.js';
 import type { Sidebar as SidebarType } from '../composables/useNavigationTabs.js';
-type CommandEffect = import('effect').Effect.Effect<void>;
+type CommandEffect = import('effect').Effect.Effect<void, never, Scope.Scope | OverlayRuntimeService>;
 type ProfileCommandInputItem = Readonly<{
     id: string | number;
     title: string;

package/dist/runtime/layouts/default.vue.d.ts

@@ -1,6 +1,7 @@
 import type { Scope } from 'effect';
+import type { OverlayService as OverlayRuntimeService } from '../composables/useOverlay.js';
 import type { Sidebar as SidebarType } from '../composables/useNavigationTabs.js';
-type CommandEffect = import('effect').Effect.Effect<void>;
+type CommandEffect = import('effect').Effect.Effect<void, never, Scope.Scope | OverlayRuntimeService>;
 type ProfileCommandInputItem = Readonly<{
     id: string | number;
     title: string;

package/dist/runtime/plugins/overlay/index.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("#app").Plugin<{
+    overlay: import("../../composables/useOverlay.js").OverlayRuntime;
+}> & import("#app").ObjectPlugin<{
+    overlay: import("../../composables/useOverlay.js").OverlayRuntime;
+}>;
+export default _default;

package/dist/runtime/plugins/overlay/index.js

@@ -0,0 +1,12 @@
+import { defineNuxtPlugin } from "#app";
+import { useOverlay } from "../../composables/useOverlay.js";
+export default defineNuxtPlugin({
+  name: "shwfed-nuxt:overlay",
+  setup: () => {
+    return {
+      provide: {
+        overlay: useOverlay()
+      }
+    };
+  }
+});

package/dist/runtime/plugins/toast/index.d.ts

@@ -9,6 +9,8 @@ declare const _default: import("#app").Plugin<{
         promise: <ToastData>(promise: Promise<ToastData> | (() => Promise<ToastData>), data?: ({
             id?: number | string | undefined;
             icon?: import("vue").Component | undefined;
+            dismissible?: boolean | undefined;
+            duration?: number | undefined;
             class?: string | undefined;
             style?: import("vue").CSSProperties | undefined;
             cancel?: (import("vue-sonner").Action | import("vue").Component) | undefined;
@@ -18,8 +20,6 @@ declare const _default: import("#app").Plugin<{
             richColors?: boolean | undefined;
             invert?: boolean | undefined;
             closeButton?: boolean | undefined;
-            dismissible?: boolean | undefined;
-            duration?: number | undefined;
             important?: boolean | undefined;
             action?: (import("vue-sonner").Action | import("vue").Component) | undefined;
             onDismiss?: ((toast: import("vue-sonner").ToastT) => void) | undefined;
@@ -62,6 +62,8 @@ declare const _default: import("#app").Plugin<{
         promise: <ToastData>(promise: Promise<ToastData> | (() => Promise<ToastData>), data?: ({
             id?: number | string | undefined;
             icon?: import("vue").Component | undefined;
+            dismissible?: boolean | undefined;
+            duration?: number | undefined;
             class?: string | undefined;
             style?: import("vue").CSSProperties | undefined;
             cancel?: (import("vue-sonner").Action | import("vue").Component) | undefined;
@@ -71,8 +73,6 @@ declare const _default: import("#app").Plugin<{
             richColors?: boolean | undefined;
             invert?: boolean | undefined;
             closeButton?: boolean | undefined;
-            dismissible?: boolean | undefined;
-            duration?: number | undefined;
             important?: boolean | undefined;
             action?: (import("vue-sonner").Action | import("vue").Component) | undefined;
             onDismiss?: ((toast: import("vue-sonner").ToastT) => void) | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shwfed/nuxt",
-  "version": "0.10.14",
+  "version": "0.11.0",
   "description": "",
   "license": "MIT",
   "type": "module",