@webamoki/web-svelte 1.2.3 → 2.0.0

package/dist/{utils → shared/utils}/datetime/index.js

@@ -1,6 +1,5 @@
-import { CalendarDate, DateFormatter, fromDate, getDayOfWeek, getLocalTimeZone, startOfMonth, Time, toCalendarDate, today, toTime, ZonedDateTime } from '@internationalized/date';
+import { CalendarDate, DateFormatter, fromDate, getDayOfWeek, getLocalTimeZone, startOfMonth, Time, toCalendarDate, today as todayFn, toTime, ZonedDateTime } from '@internationalized/date';
 import { map, range } from 'ramda';
-const DEFAULT_TIME_ZONE = 'Europe/London';
 const DEFAULT_LOCALE = 'en-GB';
 // Day of the week
 export const Days = [
@@ -13,25 +12,46 @@ export const Days = [
     'Sunday'
 ];
 export const DayIndex = Object.fromEntries(Days.map((day, index) => [day, index]));
-/**
- * Calculates the age from a date of birth.
- * @param dob - The date of birth.
- * @returns The age in years.
- * @throws Error if the date of birth is in the future.
- */
-export function ageFromDob(dob, timezone) {
-    const todayDate = today(timezone);
-    if (todayDate.compare(dob) < 0) {
-        throw new Error('Date of birth is in the future');
+// Date functions local to a timezone
+export class LocalDateF {
+    timezone;
+    constructor(timezone) {
+        this.timezone = timezone;
+    }
+    /**
+     * Calculates the age from a date of birth.
+     * @param dob - The date of birth.
+     * @returns The age in years.
+     * @throws Error if the date of birth is in the future.
+     */
+    ageFromDob(dob) {
+        const todayDate = this.today();
+        if (todayDate.compare(dob) < 0) {
+            throw new Error('Date of birth is in the future');
+        }
+        let years = todayDate.year - dob.year;
+        const monthDiff = todayDate.month - dob.month;
+        const dayDiff = todayDate.day - dob.day;
+        // Adjust years down if birthday hasn't occurred this year
+        if (monthDiff < 0 || (monthDiff === 0 && dayDiff < 0)) {
+            years--;
+        }
+        return years;
     }
-    let years = todayDate.year - dob.year;
-    const monthDiff = todayDate.month - dob.month;
-    const dayDiff = todayDate.day - dob.day;
-    // Adjust years down if birthday hasn't occurred this year
-    if (monthDiff < 0 || (monthDiff === 0 && dayDiff < 0)) {
-        years--;
+    /**
+     * Checks if a given date is today.
+     * @param date - The date to check.
+     * @returns True if the date is today, false otherwise.
+     */
+    isDateToday(date) {
+        return this.today().compare(date) === 0;
+    }
+    /**
+     * @returns The current date.
+     */
+    today() {
+        return todayFn(this.timezone);
     }
-    return years;
 }
 /**
  * Checks if two time ranges overlap, boundaries are not considered overlapping.
@@ -145,14 +165,6 @@ export function isDateDay(date, dayOfWeek) {
     const dateDay = getDayOfDate(date);
     return dateDay === dayOfWeek;
 }
-/**
- * Checks if a given date is today.
- * @param date - The date to check.
- * @returns True if the date is today, false otherwise.
- */
-export function isDateToday(date, timezone) {
-    return today(timezone).compare(date) === 0;
-}
 const msPerWeek = 7 * 24 * 60 * 60 * 1000;
 /**
  * Calculates the difference in weeks between two dates.
@@ -160,9 +172,10 @@ const msPerWeek = 7 * 24 * 60 * 60 * 1000;
  * @param date2 - The second date in order.
  */
 export function dateDiffWeeks(date1, date2) {
-    const date1Abs = date1.toDate(DEFAULT_TIME_ZONE).getTime();
-    const date2Abs = date2.toDate(DEFAULT_TIME_ZONE).getTime();
-    return Math.floor((date2Abs - date1Abs) / msPerWeek);
+    const date1Ms = date1.toDate('UTC').getTime();
+    const date2Ms = date2.toDate('UTC').getTime();
+    const absDiff = Math.abs(date2Ms - date1Ms);
+    return Math.floor(absDiff / msPerWeek);
 }
 /* Formatting */
 /* Day of the week*/
@@ -313,9 +326,8 @@ function formatDate(date, formatter) {
 }
 // Pad number with zeroes to the left
 function padNum(num, len) {
-    if (isNaN(num)) {
+    if (isNaN(num))
         return '0'.repeat(len);
-    }
     return num.toString().padStart(len, '0');
 }
 // SerDe

package/dist/{utils → shared/utils}/email/README.md

@@ -4,17 +4,17 @@ This package provides utilities for sending emails using AWS Simple Email Servic
 
 ## Key Features
 
-- **Cloudflare Workers Compatible**: Uses direct AWS SES API calls with fetch instead of AWS SDK
-- **AWS Signature V4**: Implements proper AWS authentication for secure API requests
+- **Cloudflare Workers Compatible**: Uses `aws4fetch` for direct AWS SES API calls
+- **AWS Signature V4**: Handled by `aws4fetch` for secure API requests
 - **Zero Heavy Dependencies**: No AWS SDK required, works in any JavaScript runtime with fetch support
 
 ## Installation
 
-No additional dependencies required beyond the standard JavaScript runtime. The implementation uses:
+The implementation uses:
 
+- `aws4fetch` for AWS Signature V4 signing and requests
 - Native `fetch` API for HTTP requests
-- Web Crypto API for AWS Signature V4 signing
-- Native `DOMParser` for XML response parsing
+- Native `DOMParser` for XML response parsing (optional, used for error/response parsing)
 
 ## Configuration
 

package/dist/{utils → shared/utils}/email/ses.js

@@ -1,4 +1,4 @@
-import { signRequest } from './aws-signer.js';
+import { AwsClient } from 'aws4fetch';
 /**
  * Send an email using AWS SES API.
  * Uses AWS Signature V4 signing and fetch API for Cloudflare Workers compatibility.
@@ -71,21 +71,29 @@ export async function sendEmail(options) {
     const host = `email.${awsRegion}.amazonaws.com`;
     const path = '/';
     try {
-        // Sign the request
-        const { headers } = await signRequest('POST', host, path, body, {
+        const aws = new AwsClient({
             accessKeyId: awsAccessKeyId,
             region: awsRegion,
-            secretAccessKey: awsSecretAccessKey
+            secretAccessKey: awsSecretAccessKey,
+            service: 'ses'
         });
-        // Make the request
-        const response = await fetch(`https://${host}${path}`, {
+        const url = `https://${host}${path}`;
+        const init = {
             body,
             headers: {
-                ...headers,
-                'Content-Length': body.length.toString(),
-                Host: host
+                'Content-Type': 'application/x-form-urlencoded'
             },
             method: 'POST'
+        };
+        // Sign the request and then use the global fetch.
+        // We avoid using aws.fetch() directly as it can cause issues in some test environments
+        // or when fetch is mocked/replaced after AwsClient instantiation.
+        const signedRequest = await aws.sign(url, init);
+        // Use two-argument fetch to satisfy tests that expect the second argument to be an options object
+        const response = await fetch(signedRequest.url, {
+            body: init.body,
+            headers: signedRequest.headers,
+            method: signedRequest.method
         });
         const responseText = await response.text();
         if (!response.ok) {

package/dist/shared/utils/functional/index.d.ts

@@ -0,0 +1,2 @@
+import { Result } from './result.js';
+export { Result };

package/dist/shared/utils/functional/index.js

@@ -0,0 +1,2 @@
+import { Result } from './result.js';
+export { Result };

package/dist/shared/utils/functional/result.d.ts

@@ -0,0 +1,72 @@
+export type Result<T, E> = {
+    error: E;
+    ok: false;
+} | {
+    ok: true;
+    value: T;
+};
+export declare const Result: {
+    /**
+     * Creates a failed result with the given error.
+     */
+    err<E>(error: E): {
+        error: E;
+        ok: false;
+    };
+    /**
+     * Creates a successful result with the given value.
+     */
+    ok<T>(value: T): {
+        ok: true;
+        value: T;
+    };
+    /**
+     * Returns true if the result is Ok.
+     */
+    isOk<T, E>(result: Result<T, E>): result is {
+        ok: true;
+        value: T;
+    };
+    /**
+     * Returns true if the result is Err.
+     */
+    isErr<T, E>(result: Result<T, E>): result is {
+        error: E;
+        ok: false;
+    };
+    /**
+     * Returns the contained Ok value or a provided default.
+     */
+    unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
+    /**
+     * Returns the contained Ok value or computes it from the provided op.
+     * @param op - Computes value in error case or throws an error.
+     */
+    unwrapOrElse<T, E>(result: Result<T, E>, op: (error: E) => T): T;
+    /**
+     * Maps a Result<T, E> to Result<U, E> by applying a function to a contained Ok value,
+     * leaving an Err value untouched.
+     */
+    map<T, U, E>(result: Result<T, E>, fn: (val: T) => U): Result<U, E>;
+    /**
+     * Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value,
+     * leaving an Ok value untouched.
+     */
+    mapErr<T, E, F>(result: Result<T, E>, fn: (err: E) => F): Result<T, F>;
+    /**
+     * Calls op if the result is Ok, otherwise returns the Err value of self.
+     * This function can be used for control flow based on Result values.
+     */
+    andThen<T, U, E>(result: Result<T, E>, op: (val: T) => Result<U, E>): Result<U, E>;
+    /**
+     * Calls op if the result is Err, otherwise returns the Ok value of self.
+     */
+    orElse<T, E, F>(result: Result<T, E>, op: (err: E) => Result<T, F>): Result<T, F>;
+    /**
+     * Pattern matches the Result and returns the result of the corresponding arm.
+     */
+    match<T, E, R>(result: Result<T, E>, arms: {
+        err: (err: E) => R;
+        ok: (val: T) => R;
+    }): R;
+};

package/dist/shared/utils/functional/result.js

@@ -0,0 +1,86 @@
+export const Result = {
+    /**
+     * Creates a failed result with the given error.
+     */
+    err(error) {
+        return { error, ok: false };
+    },
+    /**
+     * Creates a successful result with the given value.
+     */
+    ok(value) {
+        return { ok: true, value };
+    },
+    /**
+     * Returns true if the result is Ok.
+     */
+    isOk(result) {
+        return result.ok;
+    },
+    /**
+     * Returns true if the result is Err.
+     */
+    isErr(result) {
+        return !result.ok;
+    },
+    /**
+     * Returns the contained Ok value or a provided default.
+     */
+    unwrapOr(result, defaultValue) {
+        if (result.ok)
+            return result.value;
+        return defaultValue;
+    },
+    /**
+     * Returns the contained Ok value or computes it from the provided op.
+     * @param op - Computes value in error case or throws an error.
+     */
+    unwrapOrElse(result, op) {
+        if (result.ok)
+            return result.value;
+        return op(result.error);
+    },
+    /**
+     * Maps a Result<T, E> to Result<U, E> by applying a function to a contained Ok value,
+     * leaving an Err value untouched.
+     */
+    map(result, fn) {
+        if (result.ok)
+            return Result.ok(fn(result.value));
+        return result;
+    },
+    /**
+     * Maps a Result<T, E> to Result<T, F> by applying a function to a contained Err value,
+     * leaving an Ok value untouched.
+     */
+    mapErr(result, fn) {
+        if (!result.ok)
+            return Result.err(fn(result.error));
+        return result;
+    },
+    /**
+     * Calls op if the result is Ok, otherwise returns the Err value of self.
+     * This function can be used for control flow based on Result values.
+     */
+    andThen(result, op) {
+        if (result.ok)
+            return op(result.value);
+        return result;
+    },
+    /**
+     * Calls op if the result is Err, otherwise returns the Ok value of self.
+     */
+    orElse(result, op) {
+        if (!result.ok)
+            return op(result.error);
+        return result;
+    },
+    /**
+     * Pattern matches the Result and returns the result of the corresponding arm.
+     */
+    match(result, arms) {
+        if (result.ok)
+            return arms.ok(result.value);
+        return arms.err(result.error);
+    }
+};

package/dist/shared/utils/functional/result.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shared/utils/functional/result.spec.js

@@ -0,0 +1,96 @@
+import { describe, expect, it } from 'vitest';
+import { Result } from './result.js';
+describe('Result', () => {
+    it('ok should create a successful result', () => {
+        const res = Result.ok(42);
+        expect(res).toEqual({ ok: true, value: 42 });
+        expect(Result.isOk(res)).toBe(true);
+        expect(Result.isErr(res)).toBe(false);
+    });
+    it('err should create a failed result', () => {
+        const res = Result.err('error');
+        expect(res).toEqual({ error: 'error', ok: false });
+        expect(Result.isOk(res)).toBe(false);
+        expect(Result.isErr(res)).toBe(true);
+    });
+    describe('unwrapOr', () => {
+        it('should return value for ok', () => {
+            expect(Result.unwrapOr(Result.ok(42), 0)).toBe(42);
+        });
+        it('should return default value for err', () => {
+            expect(Result.unwrapOr(Result.err('error'), 0)).toBe(0);
+        });
+    });
+    describe('unwrapOrElse', () => {
+        it('should return value for ok', () => {
+            expect(Result.unwrapOrElse(Result.ok(42), () => 0)).toBe(42);
+        });
+        it('should return computed value for err', () => {
+            expect(Result.unwrapOrElse(Result.err('error'), (e) => e.length)).toBe(5);
+        });
+    });
+    describe('map', () => {
+        it('should transform ok value', () => {
+            const res = Result.map(Result.ok(42), (v) => v * 2);
+            expect(res).toEqual(Result.ok(84));
+        });
+        it('should not transform err value', () => {
+            const res = Result.map(Result.err('error'), (v) => v * 2);
+            expect(res).toEqual(Result.err('error'));
+        });
+    });
+    describe('mapErr', () => {
+        it('should transform err value', () => {
+            const res = Result.mapErr(Result.err('error'), (e) => e.toUpperCase());
+            expect(res).toEqual(Result.err('ERROR'));
+        });
+        it('should not transform ok value', () => {
+            const res = Result.mapErr(Result.ok(42), (e) => e.toUpperCase());
+            expect(res).toEqual(Result.ok(42));
+        });
+    });
+    describe('andThen', () => {
+        it('should chain ok values', () => {
+            const res = Result.andThen(Result.ok(42), (v) => Result.ok(v * 2));
+            expect(res).toEqual(Result.ok(84));
+        });
+        it('should return first err', () => {
+            const res = Result.andThen(Result.err('error'), (v) => Result.ok(v * 2));
+            expect(res).toEqual(Result.err('error'));
+        });
+        it('should return nested err', () => {
+            const res = Result.andThen(Result.ok(42), () => Result.err('nested error'));
+            expect(res).toEqual(Result.err('nested error'));
+        });
+    });
+    describe('orElse', () => {
+        it('should chain err values', () => {
+            const res = Result.orElse(Result.err('error'), (e) => Result.err(e.toUpperCase()));
+            expect(res).toEqual(Result.err('ERROR'));
+        });
+        it('should return first ok', () => {
+            const res = Result.orElse(Result.ok(42), (e) => Result.err(e.toUpperCase()));
+            expect(res).toEqual(Result.ok(42));
+        });
+        it('should return nested ok', () => {
+            const res = Result.orElse(Result.err('error'), () => Result.ok(42));
+            expect(res).toEqual(Result.ok(42));
+        });
+    });
+    describe('match', () => {
+        it('should call ok branch', () => {
+            const res = Result.match(Result.ok(42), {
+                err: () => 0,
+                ok: (v) => v * 2
+            });
+            expect(res).toBe(84);
+        });
+        it('should call err branch', () => {
+            const res = Result.match(Result.err('error'), {
+                err: (e) => e.length,
+                ok: (v) => v * 2
+            });
+            expect(res).toBe(5);
+        });
+    });
+});

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

@@ -0,0 +1,28 @@
+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';
+export type CheckFunction = () => Promise<CheckResult>;
+export type CheckResult = Result<void, ResponseError>;
+export declare const CheckResult: {
+    ok(): {
+        ok: true;
+        value: void;
+    };
+};
+export type ResponseError = {
+    code: number;
+    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 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<ResponseResult<Output>>): RemoteQueryFunction<StandardSchemaV1.InferInput<Schema>, ResponseResult<Output>>;
+export declare function guardedQueryVoid<Output>(check: CheckFunction, fn: () => Promise<ResponseResult<Output>>): RemoteQueryFunction<void, ResponseResult<Output>>;

package/dist/shared/utils/remote.js

@@ -0,0 +1,74 @@
+import { command, form, query } from '$app/server';
+import { error } from '@sveltejs/kit';
+import { Result } from './functional/index.js';
+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));
+    }
+};
+/* Guards command remote function with a check function. */
+export function guardedCommand(check, schema, fn) {
+    return command(schema, async (output) => {
+        const outcome = await check();
+        // Command remote functions cannot redirect for error,
+        //   so return result object.
+        if (!outcome.ok)
+            return Result.err(outcome.error);
+        return await fn(output);
+    });
+}
+/* Guards input-less command remote function with a check function. */
+export function guardedCommandVoid(check, fn) {
+    return command(async () => {
+        const outcome = await check();
+        if (!outcome.ok)
+            return Result.err(outcome.error);
+        return await fn();
+    });
+}
+/* Guards form remote function with a check function. */
+export function guardedForm(schema, check, fn) {
+    return form(schema, async (output, issue) => {
+        const outcome = await check();
+        // Use sveltekit error to play nicer form errors
+        if (!outcome.ok)
+            error(outcome.error.code, outcome.error.message);
+        return await fn(output, issue);
+    });
+}
+/* Guards input-less form remote function with a check function. */
+export function guardedFormVoid(check, fn) {
+    return form(async () => {
+        const outcome = await check();
+        if (!outcome.ok)
+            error(outcome.error.code, outcome.error.message);
+        return await fn();
+    });
+}
+/* Guards query remote function with a check function. */
+export function guardedQuery(check, schema, fn) {
+    return query(schema, async (output) => {
+        const outcome = await check();
+        if (!outcome.ok)
+            return Result.err(outcome.error);
+        return await fn(output);
+    });
+}
+/* Guards input-less query remote function with a check function. */
+export function guardedQueryVoid(check, fn) {
+    return query(async () => {
+        const outcome = await check();
+        if (!outcome.ok)
+            return Result.err(outcome.error);
+        return await fn();
+    });
+}

package/dist/{utils/search.d.ts → shared/utils/string.d.ts}

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

package/dist/{utils/search.js → shared/utils/string.js}

@@ -23,8 +23,14 @@ export function fuzzySearch(needle, haystack) {
 export function fuzzySearchHighlight(needle, haystack) {
     const hlen = haystack.length;
     const nlen = needle.length;
+    const escape = (text) => text
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
     if (nlen === 0)
-        return `<span>${haystack}</span>`;
+        return `<span>${escape(haystack)}</span>`;
     if (nlen > hlen)
         return null;
     let result = '';
@@ -37,7 +43,7 @@ export function fuzzySearchHighlight(needle, haystack) {
             const hch = haystack[j];
             if (hch.toLowerCase() === nch) {
                 // match found → wrap in <b>
-                result += `<b>${hch}</b>`;
+                result += `<b>${escape(hch)}</b>`;
                 j++;
                 found = true;
                 matchedCount++;
@@ -45,7 +51,7 @@ export function fuzzySearchHighlight(needle, haystack) {
             }
             else {
                 // non-match → normal text
-                result += hch;
+                result += escape(hch);
                 j++;
             }
         }
@@ -55,9 +61,12 @@ export function fuzzySearchHighlight(needle, haystack) {
         }
     }
     // add remaining unmatched characters
-    result += haystack.slice(j);
+    result += escape(haystack.slice(j));
     // sanity check — must have matched all needle chars
     if (matchedCount < nlen)
         return null;
     return `<span>${result}</span>`;
 }
+export function toTitleCase(str) {
+    return str.toLowerCase().replace(/\b\w/g, (char) => char.toUpperCase());
+}