@webamoki/web-svelte 1.2.2 → 2.0.0

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());
+}

package/package.json

@@ -4,16 +4,14 @@
     "access": "public",
     "provenance": true
   },
-  "version": "1.2.2",
+  "version": "2.0.0",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Webamoki/Web-svelte.git"
   },
   "files": [
-    "dist",
-    "!dist/**/*.test.*",
-    "!dist/**/*.spec.*"
+    "dist"
   ],
   "sideEffects": [
     "**/*.css"
@@ -21,48 +19,44 @@
   "type": "module",
   "exports": {
     "./components/form": {
-      "types": "./dist/components/form/index.d.ts",
-      "svelte": "./dist/components/form/index.js"
+      "types": "./dist/shared/components/form/index.d.ts",
+      "svelte": "./dist/shared/components/form/index.js"
     },
     "./components/ui": {
-      "types": "./dist/components/ui/index.d.ts",
-      "svelte": "./dist/components/ui/index.js"
+      "types": "./dist/shared/components/ui/index.d.ts",
+      "svelte": "./dist/shared/components/ui/index.js"
     },
     "./utils/datetime": {
-      "types": "./dist/utils/datetime/index.d.ts",
-      "import": "./dist/utils/datetime/index.js"
+      "types": "./dist/shared/utils/datetime/index.d.ts",
+      "import": "./dist/shared/utils/datetime/index.js"
     },
-    "./utils/types/arktype": {
-      "types": "./dist/utils/types/arktype.d.ts",
-      "import": "./dist/utils/types/arktype.js"
-    },
-    "./utils/types/consts": {
-      "types": "./dist/utils/types/consts.d.ts",
-      "import": "./dist/utils/types/consts.js"
-    },
-    "./utils/types/db": {
-      "types": "./dist/utils/types/db.d.ts",
-      "import": "./dist/utils/types/db.js"
+    "./utils/arktype": {
+      "types": "./dist/shared/utils/arktype.d.ts",
+      "import": "./dist/shared/utils/arktype.js"
     },
     "./utils/form": {
-      "types": "./dist/utils/form/index.d.ts",
-      "import": "./dist/utils/form/index.js"
+      "types": "./dist/shared/utils/form/index.d.ts",
+      "import": "./dist/shared/utils/form/index.js"
     },
     "./utils/email": {
-      "types": "./dist/utils/email/index.d.ts",
-      "import": "./dist/utils/email/index.js"
+      "types": "./dist/shared/utils/email/index.d.ts",
+      "import": "./dist/shared/utils/email/index.js"
+    },
+    "./utils/functional": {
+      "types": "./dist/shared/utils/functional/index.d.ts",
+      "import": "./dist/shared/utils/functional/index.js"
     },
     "./server/form-handler": {
-      "types": "./dist/server/form-handler.d.ts",
-      "import": "./dist/server/form-handler.js"
+      "types": "./dist/shared/server/form-handler.d.ts",
+      "import": "./dist/shared/server/form-handler.js"
     },
     "./server/form-processor": {
-      "types": "./dist/server/form-processor.d.ts",
-      "import": "./dist/server/form-processor.js"
+      "types": "./dist/shared/server/form-processor.d.ts",
+      "import": "./dist/shared/server/form-processor.js"
     },
-    "./utils/search": {
-      "types": "./dist/utils/search.d.ts",
-      "import": "./dist/utils/search.js"
+    "./utils/remote": {
+      "types": "./dist/shared/utils/remote.d.ts",
+      "import": "./dist/shared/utils/remote.js"
     }
   },
   "peerDependencies": {
@@ -80,6 +74,7 @@
     "@eslint/compat": "^2.0.3",
     "@eslint/js": "^9.39.4",
     "@internationalized/date": "^3.12.0",
+    "@standard-schema/spec": "^1.1.0",
     "@sveltejs/adapter-static": "^3.0.10",
     "@sveltejs/kit": "^2.55.0",
     "@sveltejs/package": "^2.5.7",
@@ -122,9 +117,9 @@
   ],
   "dependencies": {
     "@lucide/svelte": "^1.6.0",
+    "aws4fetch": "^1.0.20",
     "bits-ui": "^2.16.3",
     "devalue": "^5.6.4",
-    "drizzle-orm": "^0.45.1",
     "formsnap": "^2.0.1",
     "ramda": "^0.32.0",
     "sorted-array-functions": "^1.3.0",

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

@@ -1,17 +0,0 @@
-/**
- * AWS Signature Version 4 signing utilities for SES API
- * Compatible with Cloudflare Workers and other edge runtimes
- */
-interface AwsCredentials {
-    accessKeyId: string;
-    region: string;
-    secretAccessKey: string;
-}
-/**
- * Create AWS Signature V4 authorization header
- */
-export declare function signRequest(method: string, host: string, path: string, body: string, credentials: AwsCredentials, service?: string): Promise<{
-    headers: Record<string, string>;
-    signedHeaders: string;
-}>;
-export {};

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

@@ -1,83 +0,0 @@
-/**
- * AWS Signature Version 4 signing utilities for SES API
- * Compatible with Cloudflare Workers and other edge runtimes
- */
-/**
- * Create AWS Signature V4 authorization header
- */
-export async function signRequest(method, host, path, body, credentials, service = 'ses') {
-    const { accessKeyId, region, secretAccessKey } = credentials;
-    // Create timestamp
-    const now = new Date();
-    const amzDate = now.toISOString().replace(/[:-]|\.\d{3}/g, ''); // Format: YYYYMMDDTHHMMSSZ
-    const dateStamp = amzDate.slice(0, 8); // Format: YYYYMMDD
-    // Hash the request body
-    const payloadHash = bufferToHex(await sha256(body));
-    // Create canonical headers
-    const canonicalHeaders = `host:${host}\n` + `x-amz-date:${amzDate}\n`;
-    const signedHeaders = 'host;x-amz-date';
-    // Create canonical request
-    const canonicalRequest = `${method}\n` +
-        `${path}\n` +
-        `\n` + // Empty query string
-        `${canonicalHeaders}\n` +
-        `${signedHeaders}\n` +
-        `${payloadHash}`;
-    // Create string to sign
-    const algorithm = 'AWS4-HMAC-SHA256';
-    const credentialScope = `${dateStamp}/${region}/${service}/aws4_request`;
-    const canonicalRequestHash = bufferToHex(await sha256(canonicalRequest));
-    const stringToSign = `${algorithm}\n` + `${amzDate}\n` + `${credentialScope}\n` + `${canonicalRequestHash}`;
-    // Calculate signature
-    const signingKey = await getSignatureKey(secretAccessKey, dateStamp, region, service);
-    const signature = bufferToHex(await hmacSha256(signingKey, stringToSign));
-    // Create authorization header
-    const authorizationHeader = `${algorithm} ` +
-        `Credential=${accessKeyId}/${credentialScope}, ` +
-        `SignedHeaders=${signedHeaders}, ` +
-        `Signature=${signature}`;
-    return {
-        headers: {
-            Authorization: authorizationHeader,
-            '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/string.d.ts

@@ -1 +0,0 @@
-export declare function toTitleCase(str: string): string;

package/dist/utils/string.js

@@ -1,4 +0,0 @@
-/* --- String functions --- */
-export function toTitleCase(str) {
-    return str.toLowerCase().replace(/\b\w/g, (char) => char.toUpperCase());
-}

package/dist/utils/types/arktype.js

@@ -1,92 +0,0 @@
-import { CalendarDate as calendarImport, Time as timeImport } from '@internationalized/date';
-import { type } from 'arktype';
-import { Days } from '../datetime/index.js';
-import { toTitleCase } from '../string.js';
-import { EMAIL_MAX, FIRST_NAME_MAX, LAST_NAME_MAX, NAME_MAX } from './consts.js';
-// Phone arktype: allows "+", digits, and spaces only
-export const Phone = type('string').narrow((value, ctx) => {
-    if (!/^[+0-9 ]+$/.test(value)) {
-        return ctx.reject({
-            problem: 'invalid phone number. Only +, digits, and spaces are allowed.'
-        });
-    }
-    return true;
-});
-/** Type string which is trimmed before narrowing the type checking */
-export function trimTo(typeTo) {
-    return type('string.trim').to(typeTo);
-}
-export const Day = type.enumerated(...Days);
-export const Time = type.instanceOf(timeImport).configure({
-    problem: () => 'invalid time'
-});
-export const CalendarDate = type.instanceOf(calendarImport).configure({
-    problem: () => 'invalid date'
-});
-export const HexColor = type('string').narrow((value, ctx) => {
-    // Regex explanation:
-    // ^           : start of string
-    // [0-9A-Fa-f]{3} : three hex digits (short form)
-    // ([0-9A-Fa-f]{3})? : optional three more digits (long form #RRGGBB)
-    // $           : end of string
-    if (!/^[0-9A-Fa-f]{3}([0-9A-Fa-f]{3})?$/.test(value)) {
-        return ctx.reject({
-            problem: 'invalid hex color value'
-        });
-    }
-    return true;
-});
-export const Email = trimTo(type('string.email')
-    .configure({
-    problem: () => 'invalid email address'
-})
-    .atMostLength(EMAIL_MAX)).pipe((email) => email.toLowerCase());
-export const Name = trimTo(type.string.moreThanLength(0).atMostLength(NAME_MAX)).pipe(toTitleCase);
-export const FirstName = trimTo(type.string.moreThanLength(0).atMostLength(FIRST_NAME_MAX)).pipe(toTitleCase);
-export const LastName = trimTo(type.string.moreThanLength(0).atMostLength(LAST_NAME_MAX)).pipe(toTitleCase);
-export const Id = type('number >= 0');
-const passwordMaxLength = 20;
-const passwordMinLength = 8;
-const allowedChars = /^[A-Za-z0-9!@$#()]+$/;
-export const Password = type('string')
-    .atLeastLength(passwordMinLength)
-    .atMostLength(passwordMaxLength)
-    .configure({
-    problem: (ctx) => `Must be ${ctx.expected}`
-})
-    .narrow((data, ctx) => {
-    if (!allowedChars.test(data)) {
-        return ctx.reject({
-            problem: 'invalid characters. Only A–Z, a–z, 0–9, !@$#() are allowed.'
-        });
-    }
-    if (!/[A-Z]/.test(data)) {
-        return ctx.reject({
-            problem: 'must contain at least one uppercase letter.'
-        });
-    }
-    if (!/[a-z]/.test(data)) {
-        return ctx.reject({
-            problem: 'must contain at least one lowercase letter.'
-        });
-    }
-    if (!/[0-9]/.test(data)) {
-        return ctx.reject({
-            problem: 'must contain at least one number.'
-        });
-    }
-    if (!/[!@$#()]/.test(data)) {
-        return ctx.reject({
-            problem: 'must contain at least one special character (!@$#()).'
-        });
-    }
-    return true;
-});
-export const Duration = type('number').narrow((value, ctx) => {
-    if (!Number.isInteger(value) || value <= 0) {
-        return ctx.reject({
-            problem: 'invalid minutes'
-        });
-    }
-    return true;
-});

package/dist/utils/types/consts.d.ts

@@ -1,5 +0,0 @@
-export declare const FIRST_NAME_MAX = 25;
-export declare const LAST_NAME_MAX = 25;
-export declare const NAME_MAX = 50;
-export declare const EMAIL_MAX = 100;
-export declare const HEX_COLOR_MAX = 6;

package/dist/utils/types/consts.js

@@ -1,5 +0,0 @@
-export const FIRST_NAME_MAX = 25;
-export const LAST_NAME_MAX = 25;
-export const NAME_MAX = 50;
-export const EMAIL_MAX = 100;
-export const HEX_COLOR_MAX = 6;