runtypex 0.1.13 → 0.2.1

package/dist/cjs/core/emitMapperFromSpec.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitMapperFromSpec = emitMapperFromSpec;
+exports.readMapRules = readMapRules;
+exports.findMapPolicyViolations = findMapPolicyViolations;
+exports.handleMapPolicyViolations = handleMapPolicyViolations;
+exports.resolveMapSpecObject = resolveMapSpecObject;
+const typescript_1 = __importDefault(require("typescript"));
+const index_js_1 = require("./index.js");
+const path_js_1 = require("./path.js");
+function emitMapperFromSpec(params) {
+    // Resolve the concrete object literal so generated code does not retain DSL calls.
+    const specObject = resolveMapSpecObject(params.checker, params.specNode);
+    if (!specObject)
+        return null;
+    handleMapPolicyViolations(findMapPolicyViolations(params.checker, specObject, params.options?.mappingPolicy), params.options?.policyMode ?? "warn");
+    const rules = readMapRules(params.checker, specObject);
+    const props = params.checker.getPropertiesOfType(params.domainType);
+    const fields = [];
+    for (const prop of props) {
+        const rule = rules.get(prop.name);
+        if (!rule)
+            return null;
+        fields.push(`${JSON.stringify(prop.name)}:R(${JSON.stringify(prop.name)},${(0, path_js_1.emitPathAccess)("input", rule.from)})`);
+    }
+    const specText = _emitRuntimeSpecText(specObject, params.sourceFile);
+    const dtoGuard = params.options?.validateDto === false ? null : (0, index_js_1.emitGuardFromType)(params.checker, params.dtoType);
+    const domainGuard = params.options?.validateDomain === false ? null : (0, index_js_1.emitGuardFromType)(params.checker, params.domainType);
+    return [
+        `(function(){const S=${specText};`,
+        dtoGuard ? `const VD=${dtoGuard};` : "",
+        domainGuard ? `const VO=${domainGuard};` : "",
+        `return(input)=>{`,
+        dtoGuard ? `if(!VD(input))throw new TypeError("[runtypex] DTO validation failed.");` : "",
+        `const R=(key,raw)=>{const rule=S[key];const value=raw===undefined&&Object.prototype.hasOwnProperty.call(rule,"default")?rule.default:raw;return typeof rule.transform==="function"?rule.transform(value,input):value;};`,
+        `const output={${fields.join(",")}};`,
+        domainGuard ? `if(!VO(output))throw new TypeError("[runtypex] Domain validation failed.");` : "",
+        `return output;};})()`,
+    ].join("");
+}
+function readMapRules(checker, specNode) {
+    const object = resolveMapSpecObject(checker, specNode);
+    const rules = new Map();
+    if (!object)
+        return rules;
+    for (const prop of object.properties) {
+        if (!typescript_1.default.isPropertyAssignment(prop))
+            continue;
+        const key = _propertyName(prop.name);
+        const rule = _readRule(prop.initializer);
+        if (key && rule)
+            rules.set(key, { key, ...rule });
+    }
+    return rules;
+}
+function findMapPolicyViolations(checker, specNode, policyNode) {
+    if (!policyNode)
+        return [];
+    const rules = readMapRules(checker, specNode);
+    const policyRules = readMapRules(checker, policyNode);
+    const canonicalByPath = new Map();
+    const violations = [];
+    for (const rule of policyRules.values()) {
+        const existing = canonicalByPath.get(rule.from);
+        if (existing && existing !== rule.key) {
+            violations.push({ from: rule.from, expectedKey: existing, actualKey: rule.key });
+            continue;
+        }
+        canonicalByPath.set(rule.from, rule.key);
+    }
+    violations.push(...Array.from(rules.values()).flatMap((rule) => {
+        const expected = canonicalByPath.get(rule.from);
+        return expected && expected !== rule.key
+            ? [{ from: rule.from, expectedKey: expected, actualKey: rule.key }]
+            : [];
+    }));
+    return violations;
+}
+function handleMapPolicyViolations(violations, mode) {
+    if (!violations.length)
+        return;
+    const details = violations
+        .map((item) => `DTO path "${item.from}" is canonically mapped as "${item.expectedKey}", but this map uses "${item.actualKey}".`)
+        .join("\n");
+    const message = `[runtypex/mapper] Mapping policy violation:\n${details}`;
+    if (mode === "error")
+        throw new Error(message);
+    console.warn(message);
+}
+/** Finds the mapping object behind inline, defineMap-wrapped, or identifier specs. */
+function resolveMapSpecObject(checker, node) {
+    const expr = _skip(node);
+    if (typescript_1.default.isObjectLiteralExpression(expr))
+        return expr;
+    if (typescript_1.default.isCallExpression(expr) && expr.arguments[0]) {
+        const arg = _skip(expr.arguments[0]);
+        if (typescript_1.default.isObjectLiteralExpression(arg))
+            return arg;
+    }
+    if (typescript_1.default.isCallExpression(expr) && typescript_1.default.isCallExpression(expr.expression)) {
+        return resolveMapSpecObject(checker, expr.expression);
+    }
+    if (typescript_1.default.isIdentifier(expr)) {
+        const symbol = checker.getShorthandAssignmentValueSymbol?.(expr) ?? checker.getSymbolAtLocation(expr);
+        const declaration = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+        if (declaration && typescript_1.default.isVariableDeclaration(declaration) && declaration.initializer) {
+            return resolveMapSpecObject(checker, declaration.initializer);
+        }
+        const variable = _findVariableDeclaration(expr.getSourceFile(), expr.text, expr.getStart(expr.getSourceFile()));
+        if (variable?.initializer)
+            return resolveMapSpecObject(checker, variable.initializer);
+    }
+    return null;
+}
+function _readRule(node) {
+    const expr = _skip(node);
+    if (typescript_1.default.isObjectLiteralExpression(expr)) {
+        return _readRuleObject(expr);
+    }
+    if (typescript_1.default.isCallExpression(expr) && expr.arguments[0]) {
+        const from = _stringValue(expr.arguments[0]);
+        const metadata = expr.arguments.length > 2 ? expr.arguments[2] : expr.arguments[1];
+        if (!from)
+            return null;
+        return { from, ..._readMetadata(metadata) };
+    }
+    return null;
+}
+function _readRuleObject(object) {
+    const from = _readStringProperty(object, "from");
+    if (!from)
+        return null;
+    return {
+        from,
+        db: _readStringProperty(object, "db") ?? undefined,
+        description: _readStringProperty(object, "description") ?? undefined,
+        dtoDescription: _readStringProperty(object, "dtoDescription") ?? undefined,
+    };
+}
+function _readMetadata(node) {
+    const expr = node ? _skip(node) : null;
+    if (!expr || !typescript_1.default.isObjectLiteralExpression(expr))
+        return {};
+    return {
+        db: _readStringProperty(expr, "db") ?? undefined,
+        description: _readStringProperty(expr, "description") ?? undefined,
+        dtoDescription: _readStringProperty(expr, "dtoDescription") ?? undefined,
+    };
+}
+function _readStringProperty(object, name) {
+    const prop = object.properties.find((item) => typescript_1.default.isPropertyAssignment(item) && _propertyName(item.name) === name);
+    return prop ? _stringValue(prop.initializer) : null;
+}
+function _skip(node) {
+    let expr = node;
+    while (typescript_1.default.isParenthesizedExpression(expr) || typescript_1.default.isAsExpression(expr) || typescript_1.default.isTypeAssertionExpression(expr)) {
+        expr = expr.expression;
+    }
+    return expr;
+}
+function _propertyName(name) {
+    if (typescript_1.default.isIdentifier(name) || typescript_1.default.isStringLiteral(name) || typescript_1.default.isNumericLiteral(name))
+        return name.text;
+    return null;
+}
+function _stringValue(node) {
+    if (typescript_1.default.isStringLiteral(node) || typescript_1.default.isNoSubstitutionTemplateLiteral(node))
+        return node.text;
+    return null;
+}
+function _findVariableDeclaration(sourceFile, name, before) {
+    let found = null;
+    const visit = (node) => {
+        if (typescript_1.default.isVariableDeclaration(node) &&
+            typescript_1.default.isIdentifier(node.name) &&
+            node.name.text === name &&
+            node.getStart(sourceFile) < before) {
+            found = node;
+        }
+        node.forEachChild(visit);
+    };
+    visit(sourceFile);
+    return found;
+}
+function _emitRuntimeSpecText(specObject, sourceFile) {
+    // Remove TypeScript-only syntax from inline transform callbacks before embedding.
+    const marker = "__runtypexSpec";
+    const output = typescript_1.default.transpileModule(`const ${marker} = ${specObject.getText(sourceFile)};`, {
+        compilerOptions: {
+            module: typescript_1.default.ModuleKind.ESNext,
+            target: typescript_1.default.ScriptTarget.ESNext,
+        },
+    }).outputText.trim();
+    const prefix = `const ${marker} = `;
+    return output.startsWith(prefix) ? output.slice(prefix.length).replace(/;$/, "") : specObject.getText(sourceFile);
+}

package/dist/cjs/core/emitObject.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import type { GenContext } from "./index.js";
+/**
+ * Handles interfaces, classes, and object-like structures.
+ */
+export declare function emitObject(ctx: GenContext, expr: string, t: ts.Type): string | null;

package/dist/cjs/core/emitObject.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitObject = emitObject;
+const typescript_1 = __importDefault(require("typescript"));
+const path_js_1 = require("./path.js");
+/**
+ * Handles interfaces, classes, and object-like structures.
+ */
+function emitObject(ctx, expr, t) {
+    const isObject = (t.getFlags() & typescript_1.default.TypeFlags.Object) !== 0;
+    if (!isObject)
+        return null;
+    const props = ctx.checker.getPropertiesOfType(t);
+    const parts = [`typeof ${expr}==="object"`, `${expr}!==null`];
+    for (const prop of props) {
+        const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
+        if (!declaration)
+            continue;
+        const propType = ctx.checker.getTypeOfSymbolAtLocation(prop, declaration);
+        const isOptional = (prop.getFlags() & typescript_1.default.SymbolFlags.Optional) !== 0;
+        const propExpr = (0, path_js_1.emitPropertyAccess)(expr, prop.name);
+        const condition = ctx.emit(propExpr, propType);
+        const checkExpr = isOptional ? `(${propExpr}===undefined||${condition})` : condition;
+        parts.push(checkExpr);
+    }
+    return `(${parts.join("&&")})`;
+}

package/dist/cjs/core/emitPrimitive.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import type { GenContext } from "./index.js";
+/**
+ * Handles primitive types like number, string, boolean...
+ */
+export declare function emitPrimitive(ctx: GenContext, expr: string, t: ts.Type): string | null;

package/dist/cjs/core/emitPrimitive.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitPrimitive = emitPrimitive;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Handles primitive types like number, string, boolean...
+ */
+function emitPrimitive(ctx, expr, t) {
+    if ((t.flags & (typescript_1.default.TypeFlags.Any | typescript_1.default.TypeFlags.Unknown)) !== 0)
+        return "true";
+    if (t.flags & typescript_1.default.TypeFlags.Null)
+        return `${expr}===null`;
+    if (t.flags & typescript_1.default.TypeFlags.Undefined)
+        return `${expr}===undefined`;
+    if (t.flags & typescript_1.default.TypeFlags.BooleanLike)
+        return `typeof ${expr}==="boolean"`;
+    if (t.flags & typescript_1.default.TypeFlags.NumberLike)
+        return `typeof ${expr}==="number"`;
+    if (t.flags & typescript_1.default.TypeFlags.StringLike)
+        return `typeof ${expr}==="string"`;
+    if (t.flags & typescript_1.default.TypeFlags.BigIntLike)
+        return `typeof ${expr}==="bigint"`;
+    if (t.flags & typescript_1.default.TypeFlags.ESSymbolLike)
+        return `typeof ${expr}==="symbol"`;
+    return null;
+}

package/dist/cjs/core/emitUnionOrIntersection.d.ts

@@ -0,0 +1,6 @@
+import ts from "typescript";
+import type { GenContext } from "./index.js";
+/**
+ * Handles union (A | B) and intersection (A & B) types.
+ */
+export declare function emitUnionOrIntersection(ctx: GenContext, expr: string, t: ts.Type): string | null;

package/dist/cjs/core/emitUnionOrIntersection.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emitUnionOrIntersection = emitUnionOrIntersection;
+/**
+ * Handles union (A | B) and intersection (A & B) types.
+ */
+function emitUnionOrIntersection(ctx, expr, t) {
+    if (t.isUnion()) {
+        return `(${t.types.map(tt => ctx.emit(expr, tt)).join("||")})`;
+    }
+    if (t.isIntersection()) {
+        return `(${t.types.map(tt => ctx.emit(expr, tt)).join("&&")})`;
+    }
+    return null;
+}

package/dist/cjs/core/index.d.ts

@@ -0,0 +1,17 @@
+import ts from "typescript";
+/**
+ * ✅ emitGuardFromType
+ * Converts a TypeScript type to a JavaScript runtime validation function string.
+ */
+export declare function emitGuardFromType(checker: ts.TypeChecker, type: ts.Type): string;
+/**
+ * ✅ GenContext
+ * Internal helper for converting TypeScript types to JS validation expressions.
+ */
+export declare class GenContext {
+    checker: ts.TypeChecker;
+    private seen;
+    constructor(checker: ts.TypeChecker);
+    /** Top-level router — delegates each type to the correct handler. */
+    emit(expr: string, t: ts.Type): string;
+}

package/dist/cjs/core/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenContext = void 0;
+exports.emitGuardFromType = emitGuardFromType;
+const emitPrimitive_js_1 = require("./emitPrimitive.js");
+const emitLiteralOrEnum_js_1 = require("./emitLiteralOrEnum.js");
+const emitUnionOrIntersection_js_1 = require("./emitUnionOrIntersection.js");
+const emitArrayOrTuple_js_1 = require("./emitArrayOrTuple.js");
+const emitObject_js_1 = require("./emitObject.js");
+/**
+ * ✅ emitGuardFromType
+ * Converts a TypeScript type to a JavaScript runtime validation function string.
+ */
+function emitGuardFromType(checker, type) {
+    const ctx = new GenContext(checker);
+    const condition = ctx.emit("input", type);
+    return `(input)=>${condition}`;
+}
+/**
+ * ✅ GenContext
+ * Internal helper for converting TypeScript types to JS validation expressions.
+ */
+class GenContext {
+    checker;
+    seen = new Map();
+    constructor(checker) {
+        this.checker = checker;
+    }
+    /** Top-level router — delegates each type to the correct handler. */
+    emit(expr, t) {
+        if (this.seen.has(t))
+            return this.seen.get(t);
+        return ((0, emitPrimitive_js_1.emitPrimitive)(this, expr, t) ??
+            (0, emitLiteralOrEnum_js_1.emitLiteralOrEnum)(this, expr, t) ??
+            (0, emitUnionOrIntersection_js_1.emitUnionOrIntersection)(this, expr, t) ??
+            (0, emitArrayOrTuple_js_1.emitArrayOrTuple)(this, expr, t) ??
+            (0, emitObject_js_1.emitObject)(this, expr, t) ??
+            "true");
+    }
+}
+exports.GenContext = GenContext;

package/dist/cjs/core/path.d.ts

@@ -0,0 +1,9 @@
+export type PathSegment = string | number;
+/** Splits a mapper path into object keys and numeric array indexes. */
+export declare function parsePath(path: string): PathSegment[];
+/** Runtime fallback reader used when mapper calls are not transformed. */
+export declare function getByPath(value: unknown, path: string): unknown;
+/** Emits bracket-only access for user-authored DTO paths. */
+export declare function emitPathAccess(root: string, path: string): string;
+/** Emits compact dot access when safe, with bracket fallback for quoted keys. */
+export declare function emitPropertyAccess(root: string, property: string | number): string;

package/dist/cjs/core/path.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePath = parsePath;
+exports.getByPath = getByPath;
+exports.emitPathAccess = emitPathAccess;
+exports.emitPropertyAccess = emitPropertyAccess;
+/** Splits a mapper path into object keys and numeric array indexes. */
+function parsePath(path) {
+    if (!path)
+        return [];
+    return path.split(".").map((segment) => {
+        if (/^(0|[1-9]\d*)$/.test(segment))
+            return Number(segment);
+        return segment;
+    });
+}
+/** Runtime fallback reader used when mapper calls are not transformed. */
+function getByPath(value, path) {
+    let current = value;
+    for (const segment of parsePath(path)) {
+        if (current == null)
+            return undefined;
+        current = current[segment];
+    }
+    return current;
+}
+/** Emits bracket-only access for user-authored DTO paths. */
+function emitPathAccess(root, path) {
+    return parsePath(path).reduce((expr, segment) => {
+        if (typeof segment === "number")
+            return `${expr}[${segment}]`;
+        return `${expr}[${JSON.stringify(segment)}]`;
+    }, root);
+}
+/** Emits compact dot access when safe, with bracket fallback for quoted keys. */
+function emitPropertyAccess(root, property) {
+    if (typeof property === "number")
+        return `${root}[${property}]`;
+    if (/^[A-Za-z_$][\w$]*$/.test(property))
+        return `${root}.${property}`;
+    return `${root}[${JSON.stringify(property)}]`;
+}

package/dist/cjs/generator/generate-jsdoc.d.ts

@@ -0,0 +1,13 @@
+import ts from "typescript";
+export type GenerateJSDocOptions = {
+    name?: string;
+    mappingPolicy?: ts.Expression;
+    policyMode?: "warn" | "error";
+};
+export declare function generateJSDocFromSpec(params: {
+    checker: ts.TypeChecker;
+    dtoType: ts.Type;
+    domainType: ts.Type;
+    specNode: ts.Expression;
+    options?: GenerateJSDocOptions;
+}): string;

package/dist/cjs/generator/generate-jsdoc.js

@@ -0,0 +1,103 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateJSDocFromSpec = generateJSDocFromSpec;
+const typescript_1 = __importDefault(require("typescript"));
+const path_js_1 = require("../core/path.js");
+const emitMapperFromSpec_js_1 = require("../core/emitMapperFromSpec.js");
+const JSDOC_CONTENT_WIDTH = 76;
+function generateJSDocFromSpec(params) {
+    const checker = params.checker;
+    const dtoName = params.dtoType.symbol?.name ?? "Dto";
+    const name = params.options?.name ?? params.domainType.symbol?.name ?? "GeneratedDomain";
+    const rules = (0, emitMapperFromSpec_js_1.readMapRules)(checker, params.specNode);
+    const lines = [`export interface ${name} {`];
+    (0, emitMapperFromSpec_js_1.handleMapPolicyViolations)((0, emitMapperFromSpec_js_1.findMapPolicyViolations)(checker, params.specNode, params.options?.mappingPolicy), params.options?.policyMode ?? "warn");
+    // Each domain property gets source metadata that editors can show on hover.
+    for (const prop of checker.getPropertiesOfType(params.domainType)) {
+        const rule = rules.get(prop.name);
+        if (!rule)
+            throw new Error(`[runtypex/generator] ${name}.${prop.name} is not mapped.`);
+        const declaration = prop.valueDeclaration ?? prop.declarations?.[0];
+        const domainType = declaration ? checker.getTypeOfSymbolAtLocation(prop, declaration) : checker.getAnyType();
+        const dtoPathType = _getTypeAtPath(checker, params.dtoType, rule.from);
+        const description = _getDomainDescription(checker, prop) ?? rule.description;
+        const optional = (prop.getFlags() & typescript_1.default.SymbolFlags.Optional) !== 0 ? "?" : "";
+        lines.push("  /**");
+        if (description) {
+            _pushJSDocText(lines, _escapeComment(description));
+            lines.push("   *");
+        }
+        _pushJSDocField(lines, "DTO", `${dtoName}.${rule.from}`);
+        if (rule.dtoDescription) {
+            _pushJSDocText(lines, _escapeComment(rule.dtoDescription), "     ");
+        }
+        _pushJSDocField(lines, "DTO type", dtoPathType ? checker.typeToString(dtoPathType) : "unknown");
+        if (rule.db)
+            _pushJSDocField(lines, "DB", _escapeComment(rule.db));
+        _pushJSDocField(lines, "Domain type", checker.typeToString(domainType));
+        lines.push("   */");
+        lines.push(`  ${_propertyName(prop.name)}${optional}: ${checker.typeToString(domainType)};`);
+        lines.push("");
+    }
+    lines.push("}");
+    return lines.join("\n");
+}
+/** Resolves the DTO type reached by a mapping path such as profile.name or items.0.id. */
+function _getTypeAtPath(checker, root, path) {
+    let current = root;
+    for (const segment of (0, path_js_1.parsePath)(path)) {
+        if (!current)
+            return null;
+        if (typeof segment === "number") {
+            current =
+                checker.getElementTypeOfArrayType?.(current) ??
+                    current.typeArguments?.[segment] ??
+                    current.getNumberIndexType?.() ??
+                    null;
+            continue;
+        }
+        const prop = checker.getPropertyOfType(current, segment);
+        const declaration = prop?.valueDeclaration ?? prop?.declarations?.[0];
+        current = prop && declaration ? checker.getTypeOfSymbolAtLocation(prop, declaration) : null;
+    }
+    return current;
+}
+function _propertyName(name) {
+    return /^[A-Za-z_$][\w$]*$/.test(name) ? name : JSON.stringify(name);
+}
+function _escapeComment(value) {
+    return value.replace(/\*\//g, "* /");
+}
+function _getDomainDescription(checker, prop) {
+    const description = typescript_1.default.displayPartsToString(prop.getDocumentationComment(checker)).trim();
+    return description || null;
+}
+function _pushJSDocField(lines, label, value) {
+    _pushJSDocText(lines, `${label}: ${value}`, "", " ".repeat(label.length + 2));
+}
+function _pushJSDocText(lines, text, firstIndent = "", continuationIndent = firstIndent) {
+    for (const line of _wrapJSDocText(text, firstIndent, continuationIndent)) {
+        lines.push(`   * ${line}`);
+    }
+}
+function _wrapJSDocText(text, firstIndent, continuationIndent) {
+    const words = text.replace(/\s+/g, " ").trim().split(" ").filter(Boolean);
+    if (!words.length)
+        return [firstIndent.trimEnd()];
+    const lines = [];
+    let current = firstIndent;
+    for (const word of words) {
+        const candidate = current.trim().length ? `${current} ${word}` : `${current}${word}`;
+        if (candidate.length <= JSDOC_CONTENT_WIDTH || !current.trim().length) {
+            current = candidate;
+            continue;
+        }
+        lines.push(current.trimEnd());
+        current = `${continuationIndent}${word}`;
+    }
+    lines.push(current.trimEnd());
+    return lines;
+}

package/dist/cjs/generator/index.d.ts

@@ -0,0 +1 @@
+export * from "./generate-jsdoc.js";

package/dist/cjs/generator/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generate-jsdoc.js"), exports);

package/dist/cjs/index.d.ts

@@ -0,0 +1,4 @@
+export { makeValidate, makeAssert, type ValidateFn, type AssertFn } from "./runtime/validate.js";
+export { defineMap, defineMappingPolicy, mapperHelpers, makeMapper, source, transform, type DefinedMap, type Mapper, type MapperOptions, type MapperMetadata, type MapRule, type MapSpec, type MappingPolicy, type MappingPolicyMode, type PathOf, } from "./runtime/mapper.js";
+export { default as vitePlugin } from "./transformer/vite-plugin.js";
+export { default as tsTransformer } from "./transformer/ts-transformer.js";

package/dist/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tsTransformer = exports.vitePlugin = exports.transform = exports.source = exports.makeMapper = exports.mapperHelpers = exports.defineMappingPolicy = exports.defineMap = exports.makeAssert = exports.makeValidate = void 0;
+var validate_js_1 = require("./runtime/validate.js");
+Object.defineProperty(exports, "makeValidate", { enumerable: true, get: function () { return validate_js_1.makeValidate; } });
+Object.defineProperty(exports, "makeAssert", { enumerable: true, get: function () { return validate_js_1.makeAssert; } });
+var mapper_js_1 = require("./runtime/mapper.js");
+Object.defineProperty(exports, "defineMap", { enumerable: true, get: function () { return mapper_js_1.defineMap; } });
+Object.defineProperty(exports, "defineMappingPolicy", { enumerable: true, get: function () { return mapper_js_1.defineMappingPolicy; } });
+Object.defineProperty(exports, "mapperHelpers", { enumerable: true, get: function () { return mapper_js_1.mapperHelpers; } });
+Object.defineProperty(exports, "makeMapper", { enumerable: true, get: function () { return mapper_js_1.makeMapper; } });
+Object.defineProperty(exports, "source", { enumerable: true, get: function () { return mapper_js_1.source; } });
+Object.defineProperty(exports, "transform", { enumerable: true, get: function () { return mapper_js_1.transform; } });
+var vite_plugin_js_1 = require("./transformer/vite-plugin.js");
+Object.defineProperty(exports, "vitePlugin", { enumerable: true, get: function () { return __importDefault(vite_plugin_js_1).default; } });
+var ts_transformer_js_1 = require("./transformer/ts-transformer.js");
+Object.defineProperty(exports, "tsTransformer", { enumerable: true, get: function () { return __importDefault(ts_transformer_js_1).default; } });

package/dist/cjs/mapper/index.d.ts

@@ -0,0 +1 @@
+export * from "../runtime/mapper.js";

package/dist/cjs/mapper/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("../runtime/mapper.js"), exports);

package/dist/cjs/runtime/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./validate.js";
+export * from "./mapper.js";

package/dist/cjs/runtime/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./validate.js"), exports);
+__exportStar(require("./mapper.js"), exports);