@webamoki/web-svelte 0.7.4 → 1.0.0

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,23 +1,21 @@
 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[];
+    subject: string;
+    text?: string;
+    to: string | string[];
 }
 /**
  * Send an email using AWS SES API.
  * Uses AWS Signature V4 signing and fetch API for Cloudflare Workers compatibility.
  *
- * Environment variables required:
- * - AWS_REGION
- * - AWS_ACCESS_KEY_ID
- * - AWS_SECRET_ACCESS_KEY
- *
  * @returns messageId returned by SES
  */
 export declare function sendEmail(options: SendEmailOptions): Promise<string>;

package/dist/utils/email/ses.js

@@ -3,17 +3,12 @@ import { signRequest } from './aws-signer.js';
  * Send an email using AWS SES API.
  * Uses AWS Signature V4 signing and fetch API for Cloudflare Workers compatibility.
  *
- * Environment variables required:
- * - AWS_REGION
- * - AWS_ACCESS_KEY_ID
- * - AWS_SECRET_ACCESS_KEY
- *
  * @returns messageId returned by SES
  */
 export async function sendEmail(options) {
     if (!options)
         throw new Error('sendEmail: options is required');
-    const { to, cc, bcc, subject, text, html, from, fromName, replyTo } = options;
+    const { awsAccessKeyId, awsRegion, awsSecretAccessKey, bcc, cc, from, fromName, html, replyTo, subject, text, to } = options;
     if (!subject) {
         throw new Error('sendEmail: subject is required');
     }
@@ -38,12 +33,9 @@ export async function sendEmail(options) {
     if (!toAddresses || toAddresses.length === 0) {
         throw new Error('sendEmail: at least one valid recipient is required (to)');
     }
-    // Get AWS credentials from environment
-    const region = process.env.AWS_REGION;
-    const accessKeyId = process.env.AWS_ACCESS_KEY_ID;
-    const secretAccessKey = process.env.AWS_SECRET_ACCESS_KEY;
-    if (!region || !accessKeyId || !secretAccessKey) {
-        throw new Error('sendEmail: missing required environment variables (AWS_REGION, AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY)');
+    // Validate AWS credentials
+    if (!awsRegion || !awsAccessKeyId || !awsSecretAccessKey) {
+        throw new Error('sendEmail: missing required AWS credentials (awsRegion, awsAccessKeyId, awsSecretAccessKey)');
     }
     // Format source with optional fromName
     const source = fromName ? `${fromName} <${from}>` : from;
@@ -76,24 +68,24 @@ export async function sendEmail(options) {
         params.append('Message.Body.Text.Charset', 'UTF-8');
     }
     const body = params.toString();
-    const host = `email.${region}.amazonaws.com`;
+    const host = `email.${awsRegion}.amazonaws.com`;
     const path = '/';
     try {
         // Sign the request
         const { headers } = await signRequest('POST', host, path, body, {
-            accessKeyId,
-            secretAccessKey,
-            region
+            accessKeyId: awsAccessKeyId,
+            region: awsRegion,
+            secretAccessKey: awsSecretAccessKey
         });
-        // Make the API request
+        // 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) {
@@ -111,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 {
@@ -141,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;
 }