@webamoki/web-svelte 0.5.35 → 0.6.0

package/dist/server/form-handler.d.ts

@@ -1,29 +1,32 @@
 import { type SuperValidated } from 'sveltekit-superforms';
+import { type VirtualFormValidated } from './form-processor.js';
 /**
  * automatically handle database errors from catch.
  * used in form/action handling in page.server.ts
  */
-export declare function handleDbErrorForm<T extends Record<string, unknown>>(form: SuperValidated<T>, message: string, err: unknown): import("@sveltejs/kit").ActionFailure<{
-    form: SuperValidated<T>;
+export declare function handleDbErrorForm<T extends Record<string, unknown>>(form: SuperValidated<T> | VirtualFormValidated<T>, message: string, err: unknown): import("@sveltejs/kit").ActionFailure<{
+    form: SuperValidated<T> | VirtualFormValidated<T>;
 }>;
 /**
  * check if an error returned by a try catch is a duplicate value error in postgre
  */
 export declare function isDuplicateDbError(err: unknown): boolean;
-export declare function successMessage<T extends Record<string, unknown>>(form: SuperValidated<T>): {
-    form: SuperValidated<T, any, T>;
-} | import("@sveltejs/kit").ActionFailure<{
-    form: SuperValidated<T, any, T>;
-}>;
-export declare function errorMessage<T extends Record<string, unknown>>(form: SuperValidated<T>, options?: {
+export declare function successMessage<T extends Record<string, unknown>>(form: SuperValidated<T> | VirtualFormValidated<T>, options?: {
     showToast?: boolean;
     text?: string;
     data?: unknown;
-}): {
-    form: SuperValidated<T, any, T>;
-} | import("@sveltejs/kit").ActionFailure<{
-    form: SuperValidated<T, any, T>;
-}>;
-export declare function failFormValidation<T extends Record<string, unknown>>(form: SuperValidated<T>): import("@sveltejs/kit").ActionFailure<{
-    form: SuperValidated<T>;
+}): any;
+export declare function errorMessage<T extends Record<string, unknown>>(form: SuperValidated<T> | VirtualFormValidated<T>, options?: {
+    showToast?: boolean;
+    text?: string;
+    data?: unknown;
+}): any;
+export declare function failFormValidation<T extends Record<string, unknown>>(form: SuperValidated<T> | {
+    valid: boolean;
+}): import("@sveltejs/kit").ActionFailure<{
+    message: string;
+}> | import("@sveltejs/kit").ActionFailure<{
+    form: SuperValidated<T> | {
+        valid: boolean;
+    };
 }>;

package/dist/server/form-handler.js

@@ -1,5 +1,7 @@
 import { DatabaseError } from 'pg';
 import { fail, message as superFormMessage } from 'sveltekit-superforms';
+import { FormError } from './form-processor.js';
+import { fail as failKit } from '@sveltejs/kit';
 /**
  * automatically handle database errors from catch.
  * used in form/action handling in page.server.ts
@@ -12,23 +14,44 @@ export function handleDbErrorForm(form, message, err) {
     console.error(`Unexpected Error ${message}:`, err);
     return fail(500, { form });
 }
+function isVirtualFormValidated(form) {
+    return 'virtual' in form && form.virtual;
+}
 /**
  * check if an error returned by a try catch is a duplicate value error in postgre
  */
 export function isDuplicateDbError(err) {
     return err instanceof DatabaseError && err.code === '23505';
 }
-export function successMessage(form) {
-    return superFormMessage(form, { success: true, showToast: true, text: 'Success' });
+export function successMessage(form, options) {
+    const message = {
+        success: true,
+        showToast: options?.showToast ?? true,
+        text: options?.text ?? 'Success',
+        data: options?.data
+    };
+    if ('virtual' in form && form.virtual) {
+        return message;
+    }
+    return superFormMessage(form, message);
 }
 export function errorMessage(form, options) {
-    return superFormMessage(form, {
+    const message = {
         success: false,
         showToast: options?.showToast ?? false,
         text: options?.text,
         data: options?.data
-    });
+    };
+    if (isVirtualFormValidated(form)) {
+        return message;
+    }
+    return superFormMessage(form, message);
 }
 export function failFormValidation(form) {
+    if (form.valid)
+        throw new Error('Invalid form passed');
+    if (form instanceof FormError) {
+        return failKit(400, { message: form.message });
+    }
     return fail(400, { form });
 }

package/dist/server/form-processor.d.ts

@@ -0,0 +1,12 @@
+import { type } from 'arktype';
+export declare class FormError {
+    message: string;
+    valid: false;
+    constructor(message: string);
+}
+export type VirtualFormValidated<T extends Record<string, unknown>> = {
+    data: T;
+    virtual: boolean;
+    valid: boolean;
+};
+export declare function processForm<S extends type.Any<Record<string, unknown>>>(request: Request, schema: S): Promise<FormError | import("sveltekit-superforms").SuperValidated<S["infer"], any, S["inferIn"]> | VirtualFormValidated<S["infer"]>>;

package/dist/server/form-processor.js

@@ -0,0 +1,48 @@
+import { dateTransport } from '../utils/datetime/index.js';
+import { type } from 'arktype';
+import { superValidate } from 'sveltekit-superforms';
+import { arktype } from 'sveltekit-superforms/adapters';
+export class FormError {
+    message;
+    valid;
+    constructor(message) {
+        this.message = message;
+        this.valid = false;
+    }
+}
+export async function processForm(request, schema) {
+    let formData;
+    try {
+        formData = await request.formData();
+    }
+    catch (error) {
+        return new FormError(error instanceof Error ? error.message : 'Invalid form data');
+    }
+    if ('__superform_id' in formData) {
+        return await superValidate(request, arktype(schema), { transport: dateTransport });
+    }
+    try {
+        // Parse form data and extract the JSON string
+        const dataString = formData.get('data');
+        if (typeof dataString !== 'string') {
+            return new FormError('Missing or invalid data field');
+        }
+        // Parse the JSON string
+        const body = JSON.parse(dataString);
+        // Validate against the schema
+        const validated = schema(body);
+        // Check if validation failed
+        if (validated instanceof type.errors) {
+            return new FormError(validated.summary);
+        }
+        // Return validated data
+        return {
+            data: validated,
+            virtual: true,
+            valid: true
+        };
+    }
+    catch (error) {
+        return new FormError(error instanceof Error ? error.message : 'Invalid form data');
+    }
+}

package/dist/utils/{form.d.ts → form/index.d.ts}

@@ -20,4 +20,3 @@ export declare function prepareEmptyForm<S extends type.Any<Record<string, unkno
     delayed: import("svelte/store").Readable<boolean>;
     errors: import("sveltekit-superforms/client").SuperFormErrors<S["infer"]>;
 };
-export declare function getServerForm<S extends type.Any<Record<string, unknown>>>(request: Request, schema: S): Promise<SuperValidated<S["infer"], any, S["inferIn"]>>;

package/dist/utils/{form.js → form/index.js}

@@ -1,8 +1,8 @@
 import { type } from 'arktype';
 import { toast } from 'svelte-sonner';
-import { defaults, superForm, superValidate } from 'sveltekit-superforms';
+import { defaults, superForm } from 'sveltekit-superforms';
 import { arktype, arktypeClient } from 'sveltekit-superforms/adapters';
-import { dateTransport } from './datetime/index.js';
+import { dateTransport } from '../datetime/index.js';
 export function prepareForm(validated, schema, options) {
     const form = superForm(validated, {
         validators: arktypeClient(schema),
@@ -65,6 +65,3 @@ export function prepareEmptyForm(schema, options) {
     const errors = form.errors;
     return { form, data: form.form, delayed, errors };
 }
-export async function getServerForm(request, schema) {
-    return await superValidate(request, arktype(schema), { transport: dateTransport });
-}

package/dist/utils/form/virtual-form.d.ts

@@ -0,0 +1,11 @@
+import { type } from 'arktype';
+export declare class VirtualForm<S extends type.Any<Record<string, unknown>>> {
+    #private;
+    constructor(schema: S, action: string, options?: {
+        actionName?: string;
+        onSuccess?: (message: App.Superforms.Message) => void;
+        onError?: (message: App.Superforms.Message) => void;
+    });
+    submit(data: S['infer']): Promise<void>;
+    get isLoading(): boolean;
+}

package/dist/utils/form/virtual-form.js

@@ -0,0 +1,96 @@
+import { type } from 'arktype';
+import { toast } from 'svelte-sonner';
+import { createSubscriber } from 'svelte/reactivity';
+function decodeMessage(json) {
+    const parsed = JSON.parse(json);
+    // Basic validation
+    if (!Array.isArray(parsed) || typeof parsed[0] !== 'object' || parsed[0] === null) {
+        throw new Error('Invalid encoded message format');
+    }
+    const schema = parsed[0];
+    // resolve an index into the parsed array
+    const resolve = (idx) => (idx >= 0 ? parsed[idx] : undefined);
+    const output = {};
+    // dynamically resolve each schema key
+    for (const key of Object.keys(schema)) {
+        const index = schema[key];
+        output[key] = resolve(index);
+    }
+    return output;
+}
+export class VirtualForm {
+    // state storage
+    #isLoading = false;
+    #url = '';
+    #schema;
+    #onSuccess;
+    #onError;
+    // svelte reactive tracking
+    #subscribe;
+    #update = () => { };
+    constructor(schema, action, options = {}) {
+        this.#url = `${action}${options.actionName ? '?/' + options.actionName : ''}`;
+        this.#schema = schema;
+        this.#onSuccess = options.onSuccess;
+        this.#onError = options.onError;
+        this.#subscribe = createSubscriber((update) => {
+            this.#update = update;
+            return () => { };
+        });
+    }
+    async submit(data) {
+        this.#isLoading = true;
+        this.#update();
+        // Validate data against schema
+        const validated = this.#schema(data);
+        if (validated instanceof type.errors) {
+            console.error('Validation failed:', validated.summary);
+            this.#onError?.({
+                text: 'Validation failed',
+                data: validated.summary,
+                success: false,
+                showToast: false
+            });
+            return;
+        }
+        try {
+            // Encode JSON as form data (like superforms does)
+            const formData = new FormData();
+            formData.append('data', JSON.stringify(validated));
+            const res = await fetch(this.#url, {
+                method: 'POST',
+                body: formData
+            });
+            const result = await res.json();
+            if (!res.ok || result.status === 400) {
+                console.error('Request failed:', result);
+                this.#onError?.(result);
+                this.#isLoading = false;
+                this.#update();
+                return;
+            }
+            const message = decodeMessage(result['data']);
+            const text = message?.text;
+            if (message.success) {
+                this.#onSuccess?.(message);
+                if (text && message?.showToast)
+                    toast.success(text);
+            }
+            else {
+                this.#onError?.(message);
+                if (text && message?.showToast)
+                    toast.error(text);
+            }
+        }
+        catch (err) {
+            console.error(err);
+            this.#onError?.({ text: 'Network error', data: err, success: false, showToast: false });
+        }
+        this.#isLoading = false;
+        this.#update();
+    }
+    get isLoading() {
+        this.#subscribe();
+        return this.#isLoading;
+    }
+}

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.5.35",
+  "version": "0.6.0",
   "license": "MIT",
   "files": [
     "dist",
@@ -40,13 +40,17 @@
       "import": "./dist/utils/types/db.js"
     },
     "./utils/form": {
-      "types": "./dist/utils/form.d.ts",
-      "import": "./dist/utils/form.js"
+      "types": "./dist/utils/form/index.d.ts",
+      "import": "./dist/utils/form/index.js"
     },
     "./server/form-handler": {
       "types": "./dist/server/form-handler.d.ts",
       "import": "./dist/server/form-handler.js"
     },
+    "./server/form-processor": {
+      "types": "./dist/server/form-processor.d.ts",
+      "import": "./dist/server/form-processor.js"
+    },
     "./utils/search": {
       "types": "./dist/utils/search.d.ts",
       "import": "./dist/utils/search.js"
@@ -63,7 +67,6 @@
     "@changesets/cli": "^2.29.7",
     "@eslint/compat": "^1.4.1",
     "@eslint/js": "^9.39.1",
-    "@sveltejs/adapter-static": "^3.0.10",
     "@sveltejs/kit": "^2.48.4",
     "@sveltejs/package": "^2.5.4",
     "@sveltejs/vite-plugin-svelte": "^6.2.1",
@@ -101,6 +104,7 @@
   "dependencies": {
     "@internationalized/date": "^3.10.0",
     "@lucide/svelte": "^0.553.0",
+    "@sveltejs/adapter-auto": "^7.0.0",
     "arktype": "^2.1.26",
     "bits-ui": "^2.14.3",
     "drizzle-orm": "^0.44.7",