@webamoki/web-svelte 0.8.0 → 1.0.1

package/dist/utils/email/README.md

@@ -44,10 +44,10 @@ import { sendEmail } from '@webamoki/web-svelte/utils/email';
 
 // Send a simple text email
 const messageId = await sendEmail({
-	to: 'recipient@example.com',
-	subject: 'Hello from SES',
-	text: 'This is a plain text email.',
-	from: 'sender@example.com'
+  to: 'recipient@example.com',
+  subject: 'Hello from SES',
+  text: 'This is a plain text email.',
+  from: 'sender@example.com'
 });
 
 console.log('Email sent with message ID:', messageId);
@@ -57,12 +57,12 @@ console.log('Email sent with message ID:', messageId);
 
 ```typescript
 await sendEmail({
-	to: 'recipient@example.com',
-	subject: 'Welcome!',
-	html: '<h1>Welcome to our service!</h1><p>Thanks for signing up.</p>',
-	text: 'Welcome to our service! Thanks for signing up.', // Fallback for email clients that don't support HTML
-	from: 'noreply@example.com',
-	fromName: 'My Application'
+  to: 'recipient@example.com',
+  subject: 'Welcome!',
+  html: '<h1>Welcome to our service!</h1><p>Thanks for signing up.</p>',
+  text: 'Welcome to our service! Thanks for signing up.', // Fallback for email clients that don't support HTML
+  from: 'noreply@example.com',
+  fromName: 'My Application'
 });
 ```
 
@@ -70,12 +70,12 @@ await sendEmail({
 
 ```typescript
 await sendEmail({
-	to: ['user1@example.com', 'user2@example.com'],
-	cc: 'manager@example.com',
-	bcc: ['archive@example.com', 'backup@example.com'],
-	subject: 'Team Update',
-	text: 'This is a team-wide announcement.',
-	from: 'team@example.com'
+  to: ['user1@example.com', 'user2@example.com'],
+  cc: 'manager@example.com',
+  bcc: ['archive@example.com', 'backup@example.com'],
+  subject: 'Team Update',
+  text: 'This is a team-wide announcement.',
+  from: 'team@example.com'
 });
 ```
 
@@ -83,12 +83,12 @@ await sendEmail({
 
 ```typescript
 await sendEmail({
-	to: 'customer@example.com',
-	subject: 'Your order confirmation',
-	html: '<p>Your order has been confirmed!</p>',
-	from: 'noreply@example.com',
-	fromName: 'Order System',
-	replyTo: 'support@example.com'
+  to: 'customer@example.com',
+  subject: 'Your order confirmation',
+  html: '<p>Your order has been confirmed!</p>',
+  from: 'noreply@example.com',
+  fromName: 'Order System',
+  replyTo: 'support@example.com'
 });
 ```
 
@@ -110,15 +110,15 @@ Sends an email via AWS SES.
 
 ```typescript
 interface SendEmailOptions {
-	to: string | string[]; // Required: recipient email address(es)
-	cc?: string | string[]; // Optional: CC recipients
-	bcc?: string | string[]; // Optional: BCC recipients
-	subject: string; // Required: email subject
-	text?: string; // Optional: plain text body
-	html?: string; // Optional: HTML body
-	from: string; // Required: sender email
-	fromName?: string; // Optional: sender display name
-	replyTo?: string | string[]; // Optional: reply-to address(es)
+  to: string | string[]; // Required: recipient email address(es)
+  cc?: string | string[]; // Optional: CC recipients
+  bcc?: string | string[]; // Optional: BCC recipients
+  subject: string; // Required: email subject
+  text?: string; // Optional: plain text body
+  html?: string; // Optional: HTML body
+  from: string; // Required: sender email
+  fromName?: string; // Optional: sender display name
+  replyTo?: string | string[]; // Optional: reply-to address(es)
 }
 ```
 
@@ -136,16 +136,16 @@ Always wrap calls in try-catch:
 
 ```typescript
 try {
-	const messageId = await sendEmail({
-		to: 'user@example.com',
-		subject: 'Test',
-		text: 'Hello!',
-		from: 'sender@example.com'
-	});
-	console.log('Success:', messageId);
+  const messageId = await sendEmail({
+    to: 'user@example.com',
+    subject: 'Test',
+    text: 'Hello!',
+    from: 'sender@example.com'
+  });
+  console.log('Success:', messageId);
 } catch (error) {
-	console.error('Failed to send email:', error.message);
-	// Handle error appropriately
+  console.error('Failed to send email:', error.message);
+  // Handle error appropriately
 }
 ```
 
@@ -163,26 +163,26 @@ import { sendEmail } from '@webamoki/web-svelte/utils/email';
 import type { Actions } from './$types';
 
 export const actions: Actions = {
-	default: async ({ request }) => {
-		const formData = await request.formData();
-		const email = formData.get('email') as string;
-		const message = formData.get('message') as string;
-
-		try {
-			await sendEmail({
-				to: 'admin@example.com',
-				subject: `Contact form submission from ${email}`,
-				text: message,
-				from: 'noreply@example.com',
-				replyTo: email
-			});
-
-			return { success: true };
-		} catch (error) {
-			console.error('Email error:', error);
-			return { success: false, error: 'Failed to send message' };
-		}
-	}
+  default: async ({ request }) => {
+    const formData = await request.formData();
+    const email = formData.get('email') as string;
+    const message = formData.get('message') as string;
+
+    try {
+      await sendEmail({
+        to: 'admin@example.com',
+        subject: `Contact form submission from ${email}`,
+        text: message,
+        from: 'noreply@example.com',
+        replyTo: email
+      });
+
+      return { success: true };
+    } catch (error) {
+      console.error('Email error:', error);
+      return { success: false, error: 'Failed to send message' };
+    }
+  }
 };
 ```
 

package/dist/utils/email/aws-signer.d.ts

@@ -4,8 +4,8 @@
  */
 interface AwsCredentials {
     accessKeyId: string;
-    secretAccessKey: string;
     region: string;
+    secretAccessKey: string;
 }
 /**
  * Create AWS Signature V4 authorization header

package/dist/utils/email/aws-signer.js

@@ -2,47 +2,11 @@
  * AWS Signature Version 4 signing utilities for SES API
  * Compatible with Cloudflare Workers and other edge runtimes
  */
-/**
- * Create a SHA-256 hash
- */
-async function sha256(message) {
-    const encoder = new TextEncoder();
-    const data = encoder.encode(message);
-    return await crypto.subtle.digest('SHA-256', data);
-}
-/**
- * Create a SHA-256 HMAC
- */
-async function hmacSha256(key, message) {
-    const encoder = new TextEncoder();
-    const keyData = key instanceof ArrayBuffer ? new Uint8Array(key) : key;
-    const cryptoKey = await crypto.subtle.importKey('raw', keyData, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
-    return await crypto.subtle.sign('HMAC', cryptoKey, encoder.encode(message));
-}
-/**
- * Convert ArrayBuffer to hex string
- */
-function bufferToHex(buffer) {
-    return Array.from(new Uint8Array(buffer))
-        .map((b) => b.toString(16).padStart(2, '0'))
-        .join('');
-}
-/**
- * Get signing key for AWS Signature V4
- */
-async function getSignatureKey(key, dateStamp, regionName, serviceName) {
-    const encoder = new TextEncoder();
-    const kDate = await hmacSha256(encoder.encode('AWS4' + key), dateStamp);
-    const kRegion = await hmacSha256(kDate, regionName);
-    const kService = await hmacSha256(kRegion, serviceName);
-    const kSigning = await hmacSha256(kService, 'aws4_request');
-    return kSigning;
-}
 /**
  * Create AWS Signature V4 authorization header
  */
 export async function signRequest(method, host, path, body, credentials, service = 'ses') {
-    const { accessKeyId, secretAccessKey, region } = credentials;
+    const { accessKeyId, region, secretAccessKey } = credentials;
     // Create timestamp
     const now = new Date();
     const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, ''); // Format: YYYYMMDDTHHMMSSZ
@@ -75,9 +39,45 @@ export async function signRequest(method, host, path, body, credentials, service
     return {
         headers: {
             Authorization: authorizationHeader,
-            'X-Amz-Date': amzDate,
-            'Content-Type': 'application/x-www-form-urlencoded'
+            'Content-Type': 'application/x-www-form-urlencoded',
+            'X-Amz-Date': amzDate
         },
         signedHeaders
     };
 }
+/**
+ * Convert ArrayBuffer to hex string
+ */
+function bufferToHex(buffer) {
+    return Array.from(new Uint8Array(buffer))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+/**
+ * Get signing key for AWS Signature V4
+ */
+async function getSignatureKey(key, dateStamp, regionName, serviceName) {
+    const encoder = new TextEncoder();
+    const kDate = await hmacSha256(encoder.encode('AWS4' + key), dateStamp);
+    const kRegion = await hmacSha256(kDate, regionName);
+    const kService = await hmacSha256(kRegion, serviceName);
+    const kSigning = await hmacSha256(kService, 'aws4_request');
+    return kSigning;
+}
+/**
+ * Create a SHA-256 HMAC
+ */
+async function hmacSha256(key, message) {
+    const encoder = new TextEncoder();
+    const keyData = key instanceof ArrayBuffer ? new Uint8Array(key) : key;
+    const cryptoKey = await crypto.subtle.importKey('raw', keyData, { hash: 'SHA-256', name: 'HMAC' }, false, ['sign']);
+    return await crypto.subtle.sign('HMAC', cryptoKey, encoder.encode(message));
+}
+/**
+ * Create a SHA-256 hash
+ */
+async function sha256(message) {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(message);
+    return await crypto.subtle.digest('SHA-256', data);
+}

package/dist/utils/email/ses.d.ts

@@ -1,16 +1,16 @@
 export interface SendEmailOptions {
-    to: string | string[];
-    cc?: string | string[];
+    awsAccessKeyId: string;
+    awsRegion: string;
+    awsSecretAccessKey: string;
     bcc?: string | string[];
-    subject: string;
-    text?: string;
-    html?: string;
+    cc?: string | string[];
     from: string;
     fromName?: string;
+    html?: string;
     replyTo?: string | string[];
-    awsRegion: string;
-    awsAccessKeyId: string;
-    awsSecretAccessKey: string;
+    subject: string;
+    text?: string;
+    to: string | string[];
 }
 /**
  * Send an email using AWS SES API.

package/dist/utils/email/ses.js

@@ -8,7 +8,7 @@ import { signRequest } from './aws-signer.js';
 export async function sendEmail(options) {
     if (!options)
         throw new Error('sendEmail: options is required');
-    const { to, cc, bcc, subject, text, html, from, fromName, replyTo, awsRegion, awsAccessKeyId, awsSecretAccessKey } = options;
+    const { awsAccessKeyId, awsRegion, awsSecretAccessKey, bcc, cc, from, fromName, html, replyTo, subject, text, to } = options;
     if (!subject) {
         throw new Error('sendEmail: subject is required');
     }
@@ -74,18 +74,18 @@ export async function sendEmail(options) {
         // Sign the request
         const { headers } = await signRequest('POST', host, path, body, {
             accessKeyId: awsAccessKeyId,
-            secretAccessKey: awsSecretAccessKey,
-            region: awsRegion
+            region: awsRegion,
+            secretAccessKey: awsSecretAccessKey
         });
         // Make the request
         const response = await fetch(`https://${host}${path}`, {
-            method: 'POST',
+            body,
             headers: {
                 ...headers,
-                Host: host,
-                'Content-Length': body.length.toString()
+                'Content-Length': body.length.toString(),
+                Host: host
             },
-            body
+            method: 'POST'
         });
         const responseText = await response.text();
         if (!response.ok) {
@@ -103,7 +103,7 @@ export async function sendEmail(options) {
             catch {
                 errorMessage = responseText || `HTTP ${response.status} ${response.statusText}`;
             }
-            throw new Error(`sendEmail: failed to send email: ${JSON.stringify({ message: errorMessage, code: errorCode })}`);
+            throw new Error(`sendEmail: failed to send email: ${JSON.stringify({ code: errorCode, message: errorMessage })}`);
         }
         // Parse success response for MessageId using regex (works in Node.js and browsers)
         try {
@@ -133,7 +133,7 @@ export async function sendEmail(options) {
             if (typeof e['name'] === 'string')
                 code = e['name'];
         }
-        const details = { message, code };
+        const details = { code, message };
         throw new Error(`sendEmail: failed to send email: ${JSON.stringify(details)}`);
     }
 }

package/dist/utils/form/index.d.ts

@@ -1,25 +1,25 @@
-import { type } from 'arktype';
+import type { type } from 'arktype';
 import { type SuperValidated } from 'sveltekit-superforms';
 export * from './virtual-form.js';
-export declare function prepareForm<S extends type.Any<Record<string, unknown>>>(schema: S, validated: SuperValidated<S['infer']> | S['infer'], options?: Partial<{
+export declare function prepareEmptyForm<S extends type.Any<Record<string, unknown>>>(schema: S, options?: Partial<{
     invalidateAll: boolean;
-    resetForm: boolean;
-    onSuccess: (form: Readonly<SuperValidated<S['infer'], App.Superforms.Message, S['infer']>>) => void;
     onError: (form: Readonly<SuperValidated<S['infer'], App.Superforms.Message, S['infer']>>) => void;
+    onSuccess: (form: Readonly<SuperValidated<S['infer'], App.Superforms.Message, S['infer']>>) => void;
+    resetForm: boolean;
 }>): {
-    form: import("sveltekit-superforms").SuperForm<S["infer"], any>;
     data: import("sveltekit-superforms/client").SuperFormData<S["infer"]>;
-    isProcessing: import("svelte/store").Readable<boolean>;
     errors: import("sveltekit-superforms/client").SuperFormErrors<S["infer"]>;
+    form: import("sveltekit-superforms").SuperForm<S["infer"], any>;
+    isProcessing: import("svelte/store").Readable<boolean>;
 };
-export declare function prepareEmptyForm<S extends type.Any<Record<string, unknown>>>(schema: S, options?: Partial<{
+export declare function prepareForm<S extends type.Any<Record<string, unknown>>>(schema: S, validated: S['infer'] | SuperValidated<S['infer']>, options?: Partial<{
     invalidateAll: boolean;
-    resetForm: boolean;
-    onSuccess: (form: Readonly<SuperValidated<S['infer'], App.Superforms.Message, S['infer']>>) => void;
     onError: (form: Readonly<SuperValidated<S['infer'], App.Superforms.Message, S['infer']>>) => void;
+    onSuccess: (form: Readonly<SuperValidated<S['infer'], App.Superforms.Message, S['infer']>>) => void;
+    resetForm: boolean;
 }>): {
-    form: import("sveltekit-superforms").SuperForm<S["infer"], any>;
     data: import("sveltekit-superforms/client").SuperFormData<S["infer"]>;
-    isProcessing: import("svelte/store").Readable<boolean>;
     errors: import("sveltekit-superforms/client").SuperFormErrors<S["infer"]>;
+    form: import("sveltekit-superforms").SuperForm<S["infer"], any>;
+    isProcessing: import("svelte/store").Readable<boolean>;
 };

package/dist/utils/form/index.js

@@ -1,16 +1,17 @@
-import { type } from 'arktype';
 import { toast } from 'svelte-sonner';
 import { defaults, superForm } from 'sveltekit-superforms';
 import { arktype, arktypeClient } from 'sveltekit-superforms/adapters';
 import { dateTransport } from '../datetime/index.js';
 export * from './virtual-form.js';
-export function prepareForm(schema, validated, options) {
-    const form = superForm(validated, {
-        validators: arktypeClient(schema),
+export function prepareEmptyForm(schema, options) {
+    const form = superForm(defaults(arktype(schema)), {
         dataType: 'json',
         invalidateAll: options?.invalidateAll ?? false,
-        transport: dateTransport,
-        resetForm: options?.resetForm ?? true,
+        onError({ result }) {
+            const message = result.error.message ?? 'There was an error submitting the form';
+            const status = result.status ?? 500;
+            toast.error(`${status} - ${message}`);
+        },
         onUpdated({ form }) {
             if (form.valid && form.message.success) {
                 options?.onSuccess?.(form);
@@ -25,23 +26,23 @@ export function prepareForm(schema, validated, options) {
                 }
             }
         },
-        onError({ result }) {
-            const message = result.error.message ?? 'There was an error submitting the form';
-            const status = result.status ?? 500;
-            toast.error(`${status} - ${message}`);
-        }
+        resetForm: options?.resetForm ?? true,
+        transport: dateTransport,
+        validators: arktypeClient(schema)
     });
     const isProcessing = form.delayed;
     const errors = form.errors;
-    return { form, data: form.form, isProcessing, errors };
+    return { data: form.form, errors, form, isProcessing };
 }
-export function prepareEmptyForm(schema, options) {
-    const form = superForm(defaults(arktype(schema)), {
-        validators: arktypeClient(schema),
+export function prepareForm(schema, validated, options) {
+    const form = superForm(validated, {
         dataType: 'json',
-        invalidateAll: options?.invalidateAll === undefined ? false : true,
-        transport: dateTransport,
-        resetForm: options?.resetForm === undefined ? true : false,
+        invalidateAll: options?.invalidateAll ?? false,
+        onError({ result }) {
+            const message = result.error.message ?? 'There was an error submitting the form';
+            const status = result.status ?? 500;
+            toast.error(`${status} - ${message}`);
+        },
         onUpdated({ form }) {
             if (form.valid && form.message.success) {
                 options?.onSuccess?.(form);
@@ -56,13 +57,11 @@ export function prepareEmptyForm(schema, options) {
                 }
             }
         },
-        onError({ result }) {
-            const message = result.error.message ?? 'There was an error submitting the form';
-            const status = result.status ?? 500;
-            toast.error(`${status} - ${message}`);
-        }
+        resetForm: options?.resetForm ?? true,
+        transport: dateTransport,
+        validators: arktypeClient(schema)
     });
     const isProcessing = form.delayed;
     const errors = form.errors;
-    return { form, data: form.form, isProcessing, errors };
+    return { data: form.form, errors, form, isProcessing };
 }

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

@@ -1,14 +1,14 @@
-import { type } from 'arktype';
-import type { SuperValidated } from 'sveltekit-superforms/client';
 import type { Transport } from '@sveltejs/kit';
+import type { SuperValidated } from 'sveltekit-superforms/client';
+import { type } from 'arktype';
 export declare class VirtualForm<S extends type.Any<Record<string, unknown>>> {
     #private;
+    get isProcessing(): boolean;
     constructor(schema: S, action: string, options?: {
         actionName?: string;
-        transport?: Transport;
-        onSuccess?: (form: Readonly<SuperValidated<S['infer'], App.Superforms.Message, S['infer']>>) => void;
         onError?: (message: App.Superforms.Message) => void;
+        onSuccess?: (form: Readonly<SuperValidated<S['infer'], App.Superforms.Message, S['infer']>>) => void;
+        transport?: Transport;
     });
     submit(data: S['infer']): Promise<void>;
-    get isProcessing(): boolean;
 }

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

@@ -1,19 +1,22 @@
 import { type } from 'arktype';
+import { parse, stringify } from 'devalue';
 import { toast } from 'svelte-sonner';
 import { createSubscriber } from 'svelte/reactivity';
-import { parse, stringify } from 'devalue';
 import { dateTransport } from '../datetime/index.js';
 export class VirtualForm {
+    get isProcessing() {
+        this.#subscribe();
+        return this.#isProcessing;
+    }
     // state storage
     #isProcessing = false;
-    #url = '';
-    #schema;
-    #transport;
-    #onSuccess;
     #onError;
+    #onSuccess;
+    #schema;
     // svelte reactive tracking
     #subscribe;
-    #update = () => { };
+    #transport;
+    #url = '';
     constructor(schema, action, options = {}) {
         this.#url = `${action}${options.actionName ? '?/' + options.actionName : ''}`;
         this.#schema = schema;
@@ -25,50 +28,6 @@ export class VirtualForm {
             return () => { };
         });
     }
-    // Apply transport encoding to data before sending
-    #encodeTransport(data) {
-        if (!this.#transport || typeof data !== 'object' || data === null) {
-            return data;
-        }
-        // Handle arrays
-        if (Array.isArray(data)) {
-            return data.map((item) => this.#encodeTransport(item));
-        }
-        // Try each transport encoder
-        for (const [key, encoder] of Object.entries(this.#transport)) {
-            const encoded = encoder.encode(data);
-            if (encoded !== false) {
-                return { __type: key, __value: encoded };
-            }
-        }
-        // Recursively encode nested objects
-        const result = {};
-        for (const [key, value] of Object.entries(data)) {
-            result[key] = this.#encodeTransport(value);
-        }
-        return result;
-    }
-    // Apply transport decoding to received data
-    #decodeTransport(data) {
-        if (!this.#transport || typeof data !== 'object' || data === null) {
-            return data;
-        }
-        // Handle arrays
-        if (Array.isArray(data)) {
-            return data.map((item) => this.#decodeTransport(item));
-        }
-        // Check if this is a transport-encoded value
-        const obj = data;
-        if (obj.__type && obj.__value && this.#transport[obj.__type]) {
-            return this.#transport[obj.__type].decode(obj.__value);
-        }
-        // Recursively decode nested objects
-        const result = {};
-        for (const [key, value] of Object.entries(obj)) {
-            result[key] = this.#decodeTransport(value);
-        }
-        return result;
-    }
     async submit(data) {
         this.#isProcessing = true;
         this.#update();
@@ -77,10 +36,10 @@ export class VirtualForm {
         if (validated instanceof type.errors) {
             console.error('Validation failed:', validated.summary);
             this.#onError?.({
-                text: 'Validation failed',
                 data: validated.summary,
+                showToast: false,
                 success: false,
-                showToast: false
+                text: 'Validation failed'
             });
             return;
         }
@@ -92,8 +51,8 @@ export class VirtualForm {
             formData.append('__superform_id', '1');
             formData.append('__superform_json', stringify(encodedData));
             const res = await fetch(this.#url, {
-                method: 'POST',
-                body: formData
+                body: formData,
+                method: 'POST'
             });
             const result = await res.json();
             if (!res.ok || result.status === 400) {
@@ -122,13 +81,54 @@ export class VirtualForm {
         }
         catch (err) {
             console.error(err);
-            this.#onError?.({ text: 'Network error', data: err, success: false, showToast: false });
+            this.#onError?.({ data: err, showToast: false, success: false, text: 'Network error' });
         }
         this.#isProcessing = false;
         this.#update();
     }
-    get isProcessing() {
-        this.#subscribe();
-        return this.#isProcessing;
+    // Apply transport decoding to received data
+    #decodeTransport(data) {
+        if (!this.#transport || typeof data !== 'object' || data === null) {
+            return data;
+        }
+        // Handle arrays
+        if (Array.isArray(data)) {
+            return data.map((item) => this.#decodeTransport(item));
+        }
+        // Check if this is a transport-encoded value
+        const obj = data;
+        if (obj.__type && obj.__value && this.#transport[obj.__type]) {
+            return this.#transport[obj.__type].decode(obj.__value);
+        }
+        // Recursively decode nested objects
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = this.#decodeTransport(value);
+        }
+        return result;
+    }
+    // Apply transport encoding to data before sending
+    #encodeTransport(data) {
+        if (!this.#transport || typeof data !== 'object' || data === null) {
+            return data;
+        }
+        // Handle arrays
+        if (Array.isArray(data)) {
+            return data.map((item) => this.#encodeTransport(item));
+        }
+        // Try each transport encoder
+        for (const [key, encoder] of Object.entries(this.#transport)) {
+            const encoded = encoder.encode(data);
+            if (encoded !== false) {
+                return { __type: key, __value: encoded };
+            }
+        }
+        // Recursively encode nested objects
+        const result = {};
+        for (const [key, value] of Object.entries(data)) {
+            result[key] = this.#encodeTransport(value);
+        }
+        return result;
     }
+    #update = () => { };
 }

package/dist/utils/search.d.ts

@@ -1,2 +1,2 @@
-export declare function fuzzySearchHighlight(needle: string, haystack: string): string | null;
 export declare function fuzzySearch(needle: string, haystack: string): boolean;
+export declare function fuzzySearchHighlight(needle: string, haystack: string): null | string;