@shwfed/nuxt 0.11.9 → 0.11.10

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@shwfed/nuxt",
   "configKey": "shwfed",
-  "version": "0.11.9",
+  "version": "0.11.10",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/runtime/components/ui/app/OverlayHost.vue

@@ -23,10 +23,7 @@ function handleOpenUpdate(sessionId, open) {
   if (open) {
     return;
   }
-  overlay.closeSync(sessionId, {
-    _tag: "OverlayAborted",
-    reason: "dismiss"
-  });
+  overlay.closeSync(sessionId);
 }
 const renderedSessions = computed(() => {
   const nextSessions = [];
@@ -95,7 +92,7 @@ const renderedSessions = computed(() => {
   props: session.props,
   shell: session.shell,
   sessionId: session.sessionId,
-  close: (value) => overlay.closeSync(session.sessionId, value),
+  close: (...args) => overlay.closeSync(session.sessionId, ...args),
   patch: (nextProps) => overlay.patchSync(session.sessionId, { props: nextProps }),
   isDesktop: modalSlotProps.isDesktop
 }"

package/dist/runtime/composables/useOverlay.d.ts

@@ -1,11 +1,6 @@
-import { Context, Deferred, Effect, type Scope } from 'effect';
+import { Context, Deferred, Effect, Option, type Scope } from 'effect';
 import { type VNode } from 'vue';
-export type OverlayAbortReason = 'close-all' | 'definition' | 'dismiss' | 'owner' | 'scope';
-export type OverlayAborted = Readonly<{
-    _tag: 'OverlayAborted';
-    reason: OverlayAbortReason;
-}>;
-export type OverlayResult = OverlayAborted | unknown;
+export type OverlayResult = Option.Option<unknown>;
 export type OverlayShellProps = Readonly<{
     title?: string;
     description?: string;
@@ -26,7 +21,7 @@ export type OverlaySlotProps = Readonly<{
     props: OverlayBodyProps;
     shell: OverlayShellProps;
     sessionId: string;
-    close: (value?: unknown) => void;
+    close: (...args: [value?: unknown]) => void;
     patch: (nextProps: Record<string, unknown>) => void;
     isDesktop: boolean;
 }>;
@@ -50,7 +45,7 @@ type OverlaySession = {
 export type OverlayHandle = Readonly<{
     sessionId: string;
     patch: (patch: OverlaySessionPatch) => Effect.Effect<void>;
-    close: (value?: unknown) => Effect.Effect<void>;
+    close: (...args: [value?: unknown]) => Effect.Effect<void>;
     result: Effect.Effect<OverlayResult>;
 }>;
 export type OverlayDefinitionNotFoundError = Readonly<{
@@ -66,24 +61,23 @@ export interface OverlayRuntime {
     syncDefinitions: (ownerId: string, definitions: Array<OverlayDefinition>) => void;
     isOpen: (sessionId: string) => boolean;
     patchSync: (sessionId: string, patch: OverlaySessionPatch) => void;
-    closeSync: (sessionId: string, value?: unknown) => void;
+    closeSync: (sessionId: string, ...args: [value?: unknown]) => void;
     closeTopSync: () => void;
     closeAllSync: () => void;
     open: (definitionId: string, options?: OverlaySessionInput) => Effect.Effect<OverlayHandle, OverlayDefinitionNotFoundError, Scope.Scope>;
     patch: (sessionId: string, patch: OverlaySessionPatch) => Effect.Effect<void>;
-    close: (sessionId: string, value?: unknown) => Effect.Effect<void>;
+    close: (sessionId: string, ...args: [value?: unknown]) => Effect.Effect<void>;
     closeTop: () => Effect.Effect<void>;
     closeAll: () => Effect.Effect<void>;
 }
 declare const OverlayService_base: Context.TagClass<OverlayService, "shwfed/OverlayService", OverlayRuntime>;
 export declare class OverlayService extends OverlayService_base {
 }
-export declare function isOverlayAborted(value: unknown): value is OverlayAborted;
 export declare function useOverlay(): OverlayRuntime;
 export declare function provideOverlay<A, E, R>(effect: Effect.Effect<A, E, R>, runtime?: OverlayRuntime): Effect.Effect<A, E, Exclude<R, OverlayService>>;
 export declare function openOverlay(definitionId: string, options?: OverlaySessionInput): Effect.Effect<OverlayHandle, OverlayDefinitionNotFoundError, OverlayService | Scope.Scope>;
 export declare function patchOverlay(sessionId: string, patch: OverlaySessionPatch): Effect.Effect<void, never, OverlayService>;
-export declare function closeOverlay(sessionId: string, value?: unknown): Effect.Effect<void, never, OverlayService>;
+export declare function closeOverlay(sessionId: string, ...args: [value?: unknown]): Effect.Effect<void, never, OverlayService>;
 export declare function closeTopOverlay(): Effect.Effect<void, never, OverlayService>;
 export declare function closeAllOverlays(): Effect.Effect<void, never, OverlayService>;
 export {};

package/dist/runtime/composables/useOverlay.js

@@ -3,12 +3,6 @@ import { reactive, ref } from "vue";
 import { ButtonActionService } from "./useButtonAction.js";
 export class OverlayService extends Context.Tag("shwfed/OverlayService")() {
 }
-function createAborted(reason) {
-  return {
-    _tag: "OverlayAborted",
-    reason
-  };
-}
 function createDefinitionNotFoundError(definitionId) {
   return {
     _tag: "OverlayDefinitionNotFoundError",
@@ -30,8 +24,11 @@ function getDefaultOverlayDescription(locale) {
       return "\u6253\u5F00\u7684\u5F39\u7A97";
   }
 }
-export function isOverlayAborted(value) {
-  return typeof value === "object" && value !== null && Reflect.get(value, "_tag") === "OverlayAborted" && typeof Reflect.get(value, "reason") === "string";
+function createResult(...args) {
+  if (args.length === 0) {
+    return Option.none();
+  }
+  return Option.some(args[0]);
 }
 function createOverlayRuntime() {
   const definitions = reactive({});
@@ -53,19 +50,19 @@ function createOverlayRuntime() {
     const [session] = sessions.value.splice(index, 1);
     return session;
   }
-  function closeInternal(sessionId, value) {
+  function closeInternal(sessionId, result) {
     return Effect.gen(function* () {
       const session = removeSession(sessionId);
       if (!session) {
         return;
       }
-      yield* Deferred.succeed(session.deferred, value);
+      yield* Deferred.succeed(session.deferred, result);
     });
   }
-  function closeDefinitionSessions(definitionId, reason) {
+  function closeDefinitionSessions(definitionId) {
     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)));
+      void Effect.runPromise(closeInternal(sessionId, Option.none()));
     }
   }
   function registerDefinition(definition) {
@@ -80,7 +77,7 @@ function createOverlayRuntime() {
       return;
     }
     Reflect.deleteProperty(definitions, definitionId);
-    closeDefinitionSessions(definitionId, ownerId === void 0 ? "definition" : "owner");
+    closeDefinitionSessions(definitionId);
   }
   function syncDefinitions(ownerId, nextDefinitions) {
     const nextIds = nextDefinitions.map((definition) => definition.definitionId);
@@ -113,20 +110,20 @@ function createOverlayRuntime() {
       };
     }
   }
-  function closeSync(sessionId, value) {
-    void Effect.runPromise(closeInternal(sessionId, value));
+  function closeSync(sessionId, ...args) {
+    void Effect.runPromise(closeInternal(sessionId, createResult(...args)));
   }
   function closeTopSync() {
     const topSession = sessions.value.at(-1);
     if (!topSession) {
       return;
     }
-    closeSync(topSession.sessionId, createAborted("dismiss"));
+    void Effect.runPromise(closeInternal(topSession.sessionId, Option.none()));
   }
   function closeAllSync() {
     const sessionIds = sessions.value.map((session) => session.sessionId);
     for (const sessionId of sessionIds) {
-      closeSync(sessionId, createAborted("close-all"));
+      void Effect.runPromise(closeInternal(sessionId, Option.none()));
     }
   }
   function createHandle(session) {
@@ -135,7 +132,7 @@ function createOverlayRuntime() {
       patch: (patch) => Effect.sync(() => {
         patchSync(session.sessionId, patch);
       }),
-      close: (value) => closeInternal(session.sessionId, value),
+      close: (...args) => closeInternal(session.sessionId, createResult(...args)),
       result: Deferred.await(session.deferred)
     };
   }
@@ -196,12 +193,12 @@ function createOverlayRuntime() {
         sessions.value.push(session);
         return createHandle(session);
       }),
-      (handle) => closeInternal(handle.sessionId, createAborted("scope"))
+      (handle) => closeInternal(handle.sessionId, Option.none())
     ),
     patch: (sessionId, patch) => Effect.sync(() => {
       patchSync(sessionId, patch);
     }),
-    close: (sessionId, value) => closeInternal(sessionId, value),
+    close: (sessionId, ...args) => closeInternal(sessionId, createResult(...args)),
     closeTop: () => Effect.sync(() => {
       closeTopSync();
     }),
@@ -224,8 +221,8 @@ export function openOverlay(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 closeOverlay(sessionId, ...args) {
+  return Effect.flatMap(OverlayService, (overlay) => overlay.close(sessionId, ...args));
 }
 export function closeTopOverlay() {
   return Effect.flatMap(OverlayService, (overlay) => overlay.closeTop());

package/package.json

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