@webamoki/web-svelte 2.4.0 → 2.5.1

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

@@ -0,0 +1,14 @@
+import type { RemoteCommand } from '@sveltejs/kit';
+import type { CommandResult, CommandSuccess, ResponseError } from './remote.js';
+export declare class CommandAction<S, O extends CommandSuccess> {
+    #private;
+    input: Parameters<RemoteCommand<S, Promise<CommandResult<O>>>>[0];
+    get submitting(): boolean;
+    constructor(remote: RemoteCommand<S, Promise<CommandResult<O>>>, defaultInput: Parameters<RemoteCommand<S, Promise<CommandResult<O>>>>[0], config?: {
+        onError?: (error: ResponseError) => void;
+        onSuccess?: (result: O) => void;
+        toastError?: boolean;
+        toastSuccess?: boolean;
+    });
+    execute(): Promise<O>;
+}

package/dist/shared/utils/command.js

@@ -0,0 +1,43 @@
+// Client side handling
+import { toast } from 'svelte-sonner';
+export class CommandAction {
+    input = $state();
+    get submitting() {
+        return this.#submitCount > 0;
+    }
+    #onError;
+    #onSuccess;
+    #remote;
+    #submitCount = $state(0);
+    #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() {
+        this.#submitCount++;
+        try {
+            const result = await this.#remote(this.input);
+            if (result.ok) {
+                if (this.#toastSuccess)
+                    toast.success(result.value.message);
+                this.#onSuccess?.(result.value);
+                return result.value;
+            }
+            else {
+                if (this.#toastError)
+                    toast.error(`${result.error.code} - ${result.error.message}`);
+                this.#onError?.(result.error);
+                throw result.error;
+            }
+        }
+        finally {
+            this.#submitCount--;
+        }
+    }
+}

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

@@ -1,6 +1,10 @@
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { type InvalidField, type RemoteCommand, type RemoteForm, type RemoteFormInput, type RemoteQueryFunction } from '@sveltejs/kit';
 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

@@ -1,18 +1,15 @@
 import { command, form, query } from '$app/server';
-import { error } from '@sveltejs/kit';
 import { Result } from './functional/index.js';
+import { error } from '@sveltejs/kit';
 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.4.0",
+  "version": "2.5.1",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -57,6 +57,10 @@
     "./utils/remote": {
       "types": "./dist/shared/utils/remote.d.ts",
       "import": "./dist/shared/utils/remote.js"
+    },
+    "./utils/command": {
+      "types": "./dist/shared/utils/command.d.ts",
+      "import": "./dist/shared/utils/command.js"
     }
   },
   "peerDependencies": {