typesea 0.1.0

package/dist/adapters/index.js

@@ -0,0 +1,396 @@
+import { isAsyncDecoderValue } from "../async/index.js";
+import { isDecoderValue } from "../decoder/index.js";
+import { TypeSeaAssertionError } from "../guard/index.js";
+import { formatIssue } from "../message/index.js";
+import { toJsonSchema } from "../json-schema/index.js";
+import { isSchemaValue } from "../schema/index.js";
+/**
+ * @brief to trpc parser.
+ */
+export function toTrpcParser(source) {
+    readSyncAdapterSource(source, "tRPC parser source");
+    return Object.freeze({
+        parse(value) {
+            const result = decodeSyncSource(source, value);
+            if (result.ok) {
+                return result.value;
+            }
+            throw new TypeSeaAssertionError(result.error);
+        }
+    });
+}
+/**
+ * @brief to async trpc parser.
+ */
+export function toAsyncTrpcParser(source) {
+    readAsyncAdapterSource(source, "async tRPC parser source");
+    return Object.freeze({
+        async parseAsync(value) {
+            const result = await decodeAsyncSource(source, value);
+            if (result.ok) {
+                return result.value;
+            }
+            throw new TypeSeaAssertionError(result.error);
+        }
+    });
+}
+/**
+ * @brief to fastify route schema.
+ */
+export function toFastifyRouteSchema(guard, options) {
+    const part = readFastifyPart(options);
+    const schema = toJsonSchema(guard, readFastifyJsonSchemaOptions(options));
+    if (!schema.ok) {
+        return schema;
+    }
+    return {
+        ok: true,
+        value: Object.freeze({
+            [part]: schema.value
+        })
+    };
+}
+/**
+ * @brief to fastify validator compiler.
+ */
+export function toFastifyValidatorCompiler(source) {
+    const readSource = readFastifyValidatorCompilerSource(source);
+    return Object.freeze((route) => {
+        const selectedSource = readSource(route);
+        return (value) => {
+            const result = decodeSyncSource(selectedSource, value);
+            if (result.ok) {
+                return {
+                    value: result.value
+                };
+            }
+            return {
+                error: new TypeSeaAssertionError(result.error)
+            };
+        };
+    });
+}
+/**
+ * @brief to react hook form resolver.
+ */
+export function toReactHookFormResolver(source, options) {
+    const config = readReactHookFormOptions(options);
+    readAsyncAdapterSource(source, "React Hook Form resolver source");
+    return async (values) => {
+        const result = await decodeAsyncSource(source, values);
+        if (result.ok) {
+            return Object.freeze({
+                values: result.value,
+                errors: emptyErrors
+            });
+        }
+        return Object.freeze({
+            values: emptyValues,
+            errors: issuesToReactHookFormErrors(result.error, config.messages)
+        });
+    };
+}
+/**
+ * @brief decode sync source.
+ */
+function decodeSyncSource(source, value) {
+    if (isDecoderValue(source)) {
+        return source.decode(value);
+    }
+    const guard = readGuard(source, "adapter source");
+    return guard.check(value);
+}
+/**
+ * @brief decode async source.
+ */
+async function decodeAsyncSource(source, value) {
+    if (isAsyncDecoderValue(source)) {
+        return await source.decodeAsync(value);
+    }
+    if (isDecoderValue(source)) {
+        return source.decode(value);
+    }
+    const guard = readGuard(source, "adapter source");
+    return guard.check(value);
+}
+/**
+ * @brief read guard.
+ */
+function readGuard(value, label) {
+    if (!isRecord(value)) {
+        throw new TypeError(`${label} must be a TypeSea guard or decoder`);
+    }
+    const guard = value;
+    const schema = value["schema"];
+    if (!isSchemaValue(schema) || typeof guard.check !== "function") {
+        throw new TypeError(`${label} must be a TypeSea guard or decoder`);
+    }
+    return guard;
+}
+/**
+ * @brief read sync adapter source.
+ */
+function readSyncAdapterSource(source, label) {
+    if (isDecoderValue(source)) {
+        return;
+    }
+    readGuard(source, label);
+}
+/**
+ * @brief read fastify validator compiler source.
+ * @details Normalizes a single validator source or a route-part source table into one selector.
+ * @returns Source selector used by the Fastify compiler callback.
+ */
+function readFastifyValidatorCompilerSource(source) {
+    if (isDecoderValue(source) || isGuardValue(source)) {
+        readSyncAdapterSource(source, "Fastify validator source");
+        return () => source;
+    }
+    if (!isRecord(source)) {
+        throw new TypeError("Fastify validator source must be a TypeSea guard, decoder, or route map");
+    }
+    readFastifyCompilerMap(source);
+    return (route) => {
+        const part = readFastifyRouteHttpPart(route);
+        const selected = source[part];
+        if (selected === undefined) {
+            throw new TypeError(`Fastify validator source is missing ${part}`);
+        }
+        return selected;
+    };
+}
+/**
+ * @brief is guard value.
+ * @details Performs the same structural guard check as `readGuard` without throwing.
+ * @returns True when the value is a TypeSea guard object.
+ */
+function isGuardValue(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    const guard = value;
+    return isSchemaValue(value["schema"]) && typeof guard.check === "function";
+}
+/**
+ * @brief read fastify compiler map.
+ * @details Validates every present route-part source before Fastify starts compiling routes.
+ * @post No result value is produced; malformed sources throw TypeError.
+ */
+function readFastifyCompilerMap(source) {
+    readOptionalFastifyCompilerPart(source, "body");
+    readOptionalFastifyCompilerPart(source, "querystring");
+    readOptionalFastifyCompilerPart(source, "params");
+    readOptionalFastifyCompilerPart(source, "headers");
+}
+/**
+ * @brief read optional fastify compiler part.
+ * @details Checks one optional source-map slot without consulting prototype state.
+ * @post No result value is produced; malformed present sources throw TypeError.
+ */
+function readOptionalFastifyCompilerPart(source, part) {
+    if (!Object.prototype.hasOwnProperty.call(source, part)) {
+        return;
+    }
+    const partSource = source[part];
+    if (partSource === undefined) {
+        throw new TypeError(`Fastify validator source for ${part} must be defined`);
+    }
+    readSyncAdapterSource(partSource, `Fastify validator source for ${part}`);
+}
+/**
+ * @brief read fastify route http part.
+ * @details Converts Fastify's route descriptor slot into TypeSea's closed part union.
+ * @returns Validated Fastify HTTP part.
+ */
+function readFastifyRouteHttpPart(route) {
+    switch (route.httpPart) {
+        case "body":
+        case "querystring":
+        case "params":
+        case "headers":
+            return route.httpPart;
+        default:
+            throw new TypeError("Fastify validator route httpPart is invalid");
+    }
+}
+/**
+ * @brief read async adapter source.
+ */
+function readAsyncAdapterSource(source, label) {
+    if (isAsyncDecoderValue(source) || isDecoderValue(source)) {
+        return;
+    }
+    readGuard(source, label);
+}
+/**
+ * @brief read fastify part.
+ */
+function readFastifyPart(options) {
+    if (options?.part === undefined) {
+        return "body";
+    }
+    switch (options.part) {
+        case "body":
+        case "querystring":
+        case "params":
+        case "headers":
+            return options.part;
+        default:
+            throw new TypeError("Fastify schema part is invalid");
+    }
+}
+/**
+ * @brief read fastify json schema options.
+ * @details Copies only JSON Schema exporter options out of the adapter options object.
+ * @returns Partial JSON Schema options without exact-optional undefined slots.
+ */
+function readFastifyJsonSchemaOptions(options) {
+    const output = {};
+    if (options?.dialect !== undefined) {
+        output.dialect = options.dialect;
+    }
+    if (options?.schemaId !== undefined) {
+        output.schemaId = options.schemaId;
+    }
+    return output;
+}
+/**
+ * @brief read react hook form options.
+ */
+function readReactHookFormOptions(options) {
+    if (options === undefined) {
+        return {
+            messages: undefined
+        };
+    }
+    if (!isRecord(options)) {
+        throw new TypeError("React Hook Form resolver options must be an object");
+    }
+    return {
+        messages: options.messages
+    };
+}
+/**
+ * @brief issues to react hook form errors.
+ */
+function issuesToReactHookFormErrors(issues, options) {
+    const errors = makeReactHookFormErrorBranch();
+    for (let index = 0; index < issues.length; index += 1) {
+        const issue = issues[index];
+        if (issue === undefined) {
+            continue;
+        }
+        insertReactHookFormIssue(errors, issue, options);
+    }
+    return freezeReactHookFormErrors(errors);
+}
+/**
+ * @brief make react hook form error branch.
+ * @details Allocates one null-prototype object so form field names cannot collide with inherited keys.
+ * @returns Mutable branch owned by the caller.
+ */
+function makeReactHookFormErrorBranch() {
+    return Object.create(null);
+}
+/**
+ * @brief insert react hook form issue.
+ * @details Inserts one TypeSea issue into a nested React Hook Form error tree.
+ * @param errors Borrowed output branch that receives the leaf error when absent.
+ * @param issue Borrowed input issue; its path is converted into string map keys.
+ * @param options Borrowed input message options used only for new leaf formatting.
+ * @post Existing first errors are preserved to match React Hook Form resolver behavior.
+ */
+function insertReactHookFormIssue(errors, issue, options) {
+    const path = issue.path.length === 0 ? rootIssuePath : issue.path;
+    let cursor = errors;
+    for (let index = 0; index < path.length - 1; index += 1) {
+        const segment = path[index];
+        if (segment === undefined) {
+            continue;
+        }
+        const key = reactHookFormPathKey(segment);
+        const child = cursor[key];
+        if (child === undefined) {
+            const branch = makeReactHookFormErrorBranch();
+            cursor[key] = branch;
+            cursor = branch;
+            continue;
+        }
+        if (!isReactHookFormErrorBranch(child)) {
+            return;
+        }
+        cursor = child;
+    }
+    const last = path[path.length - 1];
+    if (last === undefined) {
+        return;
+    }
+    const key = reactHookFormPathKey(last);
+    if (Object.prototype.hasOwnProperty.call(cursor, key)) {
+        return;
+    }
+    cursor[key] = Object.freeze({
+        type: issue.code,
+        message: issue.message ?? formatIssue(issue, options)
+    });
+}
+/**
+ * @brief react hook form path key.
+ * @details Converts one TypeSea path segment into the object key React Hook Form traverses.
+ * @param segment Borrowed input path segment.
+ * @returns Stable string key for object or array-index lookup.
+ */
+function reactHookFormPathKey(segment) {
+    return typeof segment === "number" ? String(segment) : segment;
+}
+/**
+ * @brief freeze react hook form errors.
+ * @details Recursively freezes the null-prototype tree after all issues have been inserted.
+ * @param errors Borrowed mutable branch that becomes immutable before publication.
+ * @returns Frozen React Hook Form error tree.
+ */
+function freezeReactHookFormErrors(errors) {
+    const keys = Object.keys(errors);
+    for (let index = 0; index < keys.length; index += 1) {
+        const key = keys[index];
+        if (key === undefined) {
+            continue;
+        }
+        const child = errors[key];
+        if (isReactHookFormErrorBranch(child)) {
+            errors[key] = freezeReactHookFormErrors(child);
+        }
+    }
+    return Object.freeze(errors);
+}
+/**
+ * @brief is react hook form error branch.
+ * @details Distinguishes internal branch objects from frozen leaf error objects.
+ * @param value Candidate branch or leaf error value.
+ * @returns True when value is a null-prototype branch object.
+ */
+function isReactHookFormErrorBranch(value) {
+    return typeof value === "object" &&
+        value !== null &&
+        Object.getPrototypeOf(value) === null;
+}
+/**
+ * @brief root issue path.
+ * @details Module-scope path used when a TypeSea issue points at the submitted root value.
+ * @invariant The singleton is never mutated after module initialization.
+ */
+const rootIssuePath = Object.freeze(["root"]);
+/**
+ * @brief is record.
+ */
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * @brief empty errors.
+ */
+const emptyErrors = Object.freeze({});
+/**
+ * @brief empty values.
+ */
+const emptyValues = Object.freeze({});

package/dist/aot/index.d.ts

@@ -0,0 +1,33 @@
+import type { Guard, Presence } from "../guard/index.js";
+import type { PathSegment } from "../issue/index.js";
+import { type Result } from "../result/index.js";
+/**
+ * @brief aot issue code.
+ */
+export type AotIssueCode = "unsupported_aot_lazy" | "unsupported_aot_refine" | "unsupported_aot_symbol_literal";
+/**
+ * @brief aot issue.
+ */
+export interface AotIssue {
+    readonly path: readonly PathSegment[];
+    readonly code: AotIssueCode;
+    readonly message: string;
+}
+/**
+ * @brief aot compile options.
+ */
+export interface AotCompileOptions {
+    readonly name: string | undefined;
+}
+/**
+ * @brief aot module.
+ */
+export interface AotModule {
+    readonly source: string;
+    readonly declarationSource: string;
+}
+/**
+ * @brief emit aot module.
+ */
+export declare function emitAotModule(guard: Guard<unknown, Presence>, options?: Partial<AotCompileOptions>): Result<AotModule, readonly AotIssue[]>;
+//# sourceMappingURL=index.d.ts.map

package/dist/aot/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/aot/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAQ1D;;GAEG;AACH,MAAM,MAAM,YAAY,GACpB,sBAAsB,GACtB,wBAAwB,GACxB,gCAAgC,CAAC;AAErC;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,WAAW,EAAE,CAAC;IACtC,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC;IAC5B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CACnC;AASD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,KAAK,CAAC,OAAO,EAAE,QAAQ,CAAC,EAC/B,OAAO,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,GACnC,MAAM,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,CAAC,CAsBxC"}