@webamoki/web-svelte 2.5.0 → 2.5.2

package/dist/shared/utils/command.d.ts

@@ -1,8 +1,44 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { RemoteCommand } from '@sveltejs/kit';
-import { ResponseResult } from './remote.js';
-export declare class CommandAction<S, O> {
+import type { CommandResult, CommandSuccess, ResponseError } from './remote.js';
+type RC<Schema extends StandardSchemaV1, O extends CommandSuccess> = RemoteCommand<StandardSchemaV1.InferInput<Schema>, Promise<CommandResult<O>>>;
+type RCInput<Schema extends StandardSchemaV1> = StandardSchemaV1.InferInput<Schema>;
+/**
+ * Command Remote function handler for Client
+ * - state for dynamic input
+ * - execute function, which handles toast and callbacks
+ * - submitting state for tracking pending executions
+ */
+export declare class CommandAction<Schema extends StandardSchemaV1, O extends CommandSuccess> {
     #private;
+    input: RCInput<Schema>;
     get submitting(): boolean;
-    constructor(remote: RemoteCommand<S, Promise<ResponseResult<O>>>);
-    execute(input: Parameters<RemoteCommand<S, Promise<ResponseResult<O>>>>[0]): Promise<O>;
+    constructor(remote: RC<Schema, O>, defaultInput: RCInput<Schema>, config?: {
+        onError?: (error: ResponseError) => void;
+        onSuccess?: (state: {
+            input: RCInput<Schema>;
+            result: O;
+        }) => void;
+        toastError?: boolean;
+        toastSuccess?: boolean;
+    });
+    execute(): Promise<void>;
 }
+type RCV<O extends CommandSuccess> = RemoteCommand<void, Promise<CommandResult<O>>>;
+/**
+ * Command Remote function handler for Client without input
+ * - execute function, which handles toast and callbacks
+ * - submitting state for tracking pending executions
+ */
+export declare class CommandActionVoid<O extends CommandSuccess> {
+    #private;
+    get submitting(): boolean;
+    constructor(remote: RCV<O>, config?: {
+        onError?: (error: ResponseError) => void;
+        onSuccess?: (result: O) => void;
+        toastError?: boolean;
+        toastSuccess?: boolean;
+    });
+    execute(): Promise<void>;
+}
+export {};

package/dist/shared/utils/command.js

@@ -1,19 +1,93 @@
 // Client side handling
-import { ResponseResult } from './remote.js';
+import { toast } from 'svelte-sonner';
+import { Result } from './functional/result.js';
+/**
+ * Command Remote function handler for Client
+ * - state for dynamic input
+ * - execute function, which handles toast and callbacks
+ * - submitting state for tracking pending executions
+ */
 export class CommandAction {
+    input = $state();
     get submitting() {
         return this.#submitCount > 0;
     }
+    #onError;
+    #onSuccess;
     #remote;
     #submitCount = $state(0);
-    constructor(remote) {
+    #toastError;
+    #toastSuccess;
+    constructor(remote, defaultInput, config) {
+        this.input = defaultInput;
         this.#remote = remote;
+        this.#toastError = config?.toastError ?? true;
+        this.#toastSuccess = config?.toastSuccess ?? true;
+        this.#onError = config?.onError;
+        this.#onSuccess = config?.onSuccess;
     }
-    async execute(input) {
+    async execute() {
         this.#submitCount++;
         try {
-            const result = await this.#remote(input);
-            return ResponseResult.unwrap(result);
+            const input = this.input;
+            const result = await this.#remote(input).catch(() => Result.err({ code: 500, message: 'Internal Server Error' }));
+            if (result.ok) {
+                if (this.#toastSuccess)
+                    toast.success(result.value.message);
+                this.#onSuccess?.({
+                    input: input,
+                    result: result.value
+                });
+                return;
+            }
+            else {
+                if (this.#toastError)
+                    toast.error(`${result.error.code} - ${result.error.message}`);
+                this.#onError?.(result.error);
+            }
+        }
+        finally {
+            this.#submitCount--;
+        }
+    }
+}
+/**
+ * Command Remote function handler for Client without input
+ * - execute function, which handles toast and callbacks
+ * - submitting state for tracking pending executions
+ */
+export class CommandActionVoid {
+    get submitting() {
+        return this.#submitCount > 0;
+    }
+    #onError;
+    #onSuccess;
+    #remote;
+    #submitCount = $state(0);
+    #toastError;
+    #toastSuccess;
+    constructor(remote, config) {
+        this.#remote = remote;
+        this.#toastError = config?.toastError ?? true;
+        this.#toastSuccess = config?.toastSuccess ?? true;
+        this.#onError = config?.onError;
+        this.#onSuccess = config?.onSuccess;
+    }
+    async execute() {
+        this.#submitCount++;
+        try {
+            const result = await this.#remote().catch(() => Result.err({ code: 500, message: 'Internal Server Error' }));
+            if (result.ok) {
+                if (this.#toastSuccess)
+                    toast.success(result.value.message);
+                this.#onSuccess?.(result.value);
+                return;
+            }
+            else {
+                if (this.#toastError)
+                    toast.error(`${result.error.code} - ${result.error.message}`);
+                this.#onError?.(result.error);
+            }
         }
         finally {
             this.#submitCount--;

package/dist/shared/utils/remote.d.ts

@@ -1,6 +1,10 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import { Result } from './functional/index.js';
 import { type InvalidField, type RemoteCommand, type RemoteForm, type RemoteFormInput, type RemoteQueryFunction } from '@sveltejs/kit';
+export type ResponseError = {
+    code: number;
+    message: string;
+};
 export type CheckFunction = () => Promise<CheckResult>;
 export type CheckResult = Result<void, ResponseError>;
 export declare const CheckResult: {
@@ -8,20 +12,15 @@ export declare const CheckResult: {
         ok: true;
         value: void;
     };
+    /** Throws a sveltekit error if the result is an error result. */
+    enforceOk(r: CheckResult): void;
 };
-export type ResponseError = {
-    code: number;
+export type CommandResult<T extends CommandSuccess> = Result<T, ResponseError>;
+export type CommandSuccess = {
     message: string;
 };
-export type ResponseResult<T> = Result<T, ResponseError>;
-export declare const ResponseResult: {
-    /**
-     * Unwraps a ResponseResult, throwing a sveltekit error if it is an error result.
-     */
-    unwrap<T>(result: ResponseResult<T>): T;
-};
-export declare function guardedCommand<Schema extends StandardSchemaV1, Output>(check: CheckFunction, schema: Schema, fn: (output: StandardSchemaV1.InferOutput<Schema>) => Promise<ResponseResult<Output>>): RemoteCommand<StandardSchemaV1.InferInput<Schema>, Promise<ResponseResult<Output>>>;
-export declare function guardedCommandVoid<Output>(check: CheckFunction, fn: () => Promise<ResponseResult<Output>>): RemoteCommand<void, Promise<ResponseResult<Output>>>;
+export declare function guardedCommand<Schema extends StandardSchemaV1, Output extends CommandSuccess>(check: CheckFunction, schema: Schema, fn: (output: StandardSchemaV1.InferOutput<Schema>) => Promise<CommandResult<Output>>): RemoteCommand<StandardSchemaV1.InferInput<Schema>, Promise<CommandResult<Output>>>;
+export declare function guardedCommandVoid<Output extends CommandSuccess>(check: CheckFunction, fn: () => Promise<CommandResult<Output>>): RemoteCommand<void, Promise<CommandResult<Output>>>;
 export declare function guardedForm<Schema extends StandardSchemaV1<RemoteFormInput, Record<string, unknown>>, Output>(schema: Schema, check: CheckFunction, fn: (output: StandardSchemaV1.InferOutput<Schema>, issue: InvalidField<StandardSchemaV1.InferInput<Schema>>) => Promise<Output>): RemoteForm<StandardSchemaV1.InferInput<Schema>, Output>;
 export declare function guardedFormVoid<Output>(check: CheckFunction, fn: () => Promise<Output>): RemoteForm<void, Output>;
 export declare function guardedQuery<Schema extends StandardSchemaV1, Output>(check: CheckFunction, schema: Schema, fn: (output: StandardSchemaV1.InferOutput<Schema>) => Promise<Output>): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, Output>;

package/dist/shared/utils/remote.js

@@ -5,14 +5,11 @@ export const CheckResult = {
     /* Helper function for ok check result. */
     ok() {
         return Result.ok(undefined);
-    }
-};
-export const ResponseResult = {
-    /**
-     * Unwraps a ResponseResult, throwing a sveltekit error if it is an error result.
-     */
-    unwrap(result) {
-        return Result.unwrapOrElse(result, (err) => error(err.code, err.message));
+    },
+    /** Throws a sveltekit error if the result is an error result. */
+    enforceOk(r) {
+        if (Result.isErr(r))
+            throw error(r.error.code, r.error.message);
     }
 };
 /* Guards command remote function with a check function. */
@@ -39,7 +36,7 @@ export function guardedCommandVoid(check, fn) {
 export function guardedForm(schema, check, fn) {
     return form(schema, async (output, issue) => {
         // Enforce auth check or throw sveltekit error
-        ResponseResult.unwrap(await check());
+        CheckResult.enforceOk(await check());
         return await fn(output, issue);
     });
 }
@@ -47,7 +44,7 @@ export function guardedForm(schema, check, fn) {
 export function guardedFormVoid(check, fn) {
     return form(async () => {
         // Enforce auth check or throw sveltekit error
-        ResponseResult.unwrap(await check());
+        CheckResult.enforceOk(await check());
         return await fn();
     });
 }
@@ -55,7 +52,7 @@ export function guardedFormVoid(check, fn) {
 export function guardedQuery(check, schema, fn) {
     return query(schema, async (output) => {
         // Enforce auth check or throw sveltekit error
-        ResponseResult.unwrap(await check());
+        CheckResult.enforceOk(await check());
         return await fn(output);
     });
 }
@@ -63,7 +60,7 @@ export function guardedQuery(check, schema, fn) {
 export function guardedQueryVoid(check, fn) {
     return query(async () => {
         // Enforce auth check or throw sveltekit error
-        ResponseResult.unwrap(await check());
+        CheckResult.enforceOk(await check());
         return await fn();
     });
 }

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "2.5.0",
+  "version": "2.5.2",
   "license": "MIT",
   "repository": {
     "type": "git",