runtypex 0.1.12 → 0.2.0

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,69 @@
+"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");
+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 optional = (prop.getFlags() & typescript_1.default.SymbolFlags.Optional) !== 0 ? "?" : "";
+        lines.push("  /**");
+        if (rule.description) {
+            lines.push(`   * ${_escapeComment(rule.description)}`);
+            lines.push("   *");
+        }
+        const dtoDescription = rule.dtoDescription ? ` ${_escapeComment(rule.dtoDescription)}` : "";
+        lines.push(`   * DTO: ${dtoName}.${rule.from}${dtoDescription}`);
+        lines.push(`   * DTO type: ${dtoPathType ? checker.typeToString(dtoPathType) : "unknown"}`);
+        if (rule.db)
+            lines.push(`   * DB: ${_escapeComment(rule.db)}`);
+        lines.push(`   * 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, "* /");
+}

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);

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

@@ -0,0 +1,71 @@
+type Primitive = string | number | boolean | bigint | symbol | null | undefined | Date;
+export type PathOf<T> = T extends Primitive ? never : T extends readonly (infer U)[] ? `${number}` | `${number}.${PathOf<U>}` : {
+    [K in Extract<keyof T, string>]: T[K] extends Primitive ? K : T[K] extends readonly (infer U)[] ? K | `${K}.${number}` | `${K}.${number}.${PathOf<U>}` : K | `${K}.${PathOf<T[K]>}`;
+}[Extract<keyof T, string>];
+export type Mapper<TDto, TDomain> = (dto: TDto) => TDomain;
+export type MapperMetadata<TValue = never> = {
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue;
+};
+export type MapRule<TDto, TValue> = MapperMetadata<TValue> & {
+    from: PathOf<TDto>;
+    transform?: (value: unknown, dto: TDto) => TValue;
+};
+export type MapSpec<TDto, TDomain> = {
+    [K in keyof TDomain]-?: MapRule<TDto, TDomain[K]>;
+};
+export type MappingPolicy<TDto> = Record<string, MapRule<TDto, unknown>>;
+export type MappingPolicyMode = "warn" | "error";
+export type MapperOptions<TDto> = {
+    policy?: MappingPolicy<TDto>;
+    policyMode?: MappingPolicyMode;
+};
+declare const DTO_TYPE: unique symbol;
+declare const DOMAIN_TYPE: unique symbol;
+export type DefinedMap<TDto, TDomain> = MapSpec<TDto, TDomain> & {
+    readonly [DTO_TYPE]?: TDto;
+    readonly [DOMAIN_TYPE]?: TDomain;
+};
+export declare function defineMap<TDto, TDomain>(): <const TSpec extends MapSpec<TDto, TDomain>>(spec: TSpec) => TSpec & DefinedMap<TDto, TDomain>;
+/** Declares canonical DTO path -> Domain field names for consistency checks. */
+export declare function defineMappingPolicy<TDto>(): <const TSpec extends MappingPolicy<TDto>>(spec: TSpec) => TSpec;
+/** Shorthand rule for direct DTO path reads. */
+export declare function source<const TPath extends string, TValue = never>(from: TPath, metadata?: MapperMetadata<TValue>): {
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue | undefined;
+    from: TPath;
+};
+/** Shorthand rule for DTO path reads that require a value conversion. */
+export declare function transform<const TPath extends string, TValue>(from: TPath, transform: (value: unknown, dto: unknown) => TValue, metadata?: MapperMetadata<TValue>): {
+    db?: string;
+    description?: string;
+    dtoDescription?: string;
+    default?: TValue | undefined;
+    from: TPath;
+    transform: (value: unknown, dto: unknown) => TValue;
+};
+/** Typed helpers for callbacks that need access to the source DTO shape. */
+export declare function mapperHelpers<TDto>(): {
+    source: <const TPath extends PathOf<TDto>, TValue = never>(from: TPath, metadata?: MapperMetadata<TValue>) => {
+        db?: string;
+        description?: string;
+        dtoDescription?: string;
+        default?: TValue | undefined;
+        from: TPath;
+    };
+    transform: <const TPath extends PathOf<TDto>, TValue>(from: TPath, transform: (value: unknown, dto: TDto) => TValue, metadata?: MapperMetadata<TValue>) => {
+        db?: string;
+        description?: string;
+        dtoDescription?: string;
+        default?: TValue | undefined;
+        from: TPath;
+        transform: (value: unknown, dto: TDto) => TValue;
+    };
+};
+/** Runtime interpreter used as fallback when the transformer is not configured. */
+export declare function makeMapper<TDto, TDomain>(spec: DefinedMap<TDto, TDomain> | MapSpec<TDto, TDomain>, options?: MapperOptions<TDto>): Mapper<TDto, TDomain>;
+export {};

package/dist/cjs/runtime/mapper.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineMap = defineMap;
+exports.defineMappingPolicy = defineMappingPolicy;
+exports.source = source;
+exports.transform = transform;
+exports.mapperHelpers = mapperHelpers;
+exports.makeMapper = makeMapper;
+const path_js_1 = require("../core/path.js");
+function defineMap() {
+    return (spec) => spec;
+}
+/** Declares canonical DTO path -> Domain field names for consistency checks. */
+function defineMappingPolicy() {
+    return (spec) => spec;
+}
+/** Shorthand rule for direct DTO path reads. */
+function source(from, metadata) {
+    return { from, ...metadata };
+}
+/** Shorthand rule for DTO path reads that require a value conversion. */
+function transform(from, transform, metadata) {
+    return { from, transform, ...metadata };
+}
+/** Typed helpers for callbacks that need access to the source DTO shape. */
+function mapperHelpers() {
+    return {
+        source: (from, metadata) => source(from, metadata),
+        transform: (from, transform, metadata) => ({ from, transform, ...metadata }),
+    };
+}
+/** Runtime interpreter used as fallback when the transformer is not configured. */
+function makeMapper(spec, options) {
+    _handlePolicyViolations(_findPolicyViolations(spec, options?.policy), options?.policyMode ?? "warn");
+    return ((dto) => {
+        const output = {};
+        for (const key of Object.keys(spec)) {
+            const rule = spec[key];
+            const raw = (0, path_js_1.getByPath)(dto, String(rule.from));
+            const value = raw === undefined && _hasOwn(rule, "default") ? rule.default : raw;
+            output[key] = rule.transform ? rule.transform(value, dto) : value;
+        }
+        return output;
+    });
+}
+function _hasOwn(value, key) {
+    return Object.prototype.hasOwnProperty.call(value, key);
+}
+function _findPolicyViolations(spec, policy) {
+    if (!policy)
+        return [];
+    const canonicalByPath = new Map();
+    const violations = [];
+    for (const key of Object.keys(policy)) {
+        const from = String(policy[key].from);
+        const existing = canonicalByPath.get(from);
+        if (existing && existing !== key) {
+            violations.push(`DTO path "${from}" is canonically mapped as "${existing}", but this map uses "${key}".`);
+            continue;
+        }
+        canonicalByPath.set(from, key);
+    }
+    violations.push(...Object.keys(spec).flatMap((key) => {
+        const from = String(spec[key].from);
+        const expected = canonicalByPath.get(from);
+        return expected && expected !== key
+            ? [`DTO path "${from}" is canonically mapped as "${expected}", but this map uses "${key}".`]
+            : [];
+    }));
+    return violations;
+}
+function _handlePolicyViolations(violations, mode) {
+    if (!violations.length)
+        return;
+    const message = `[runtypex/mapper] Mapping policy violation:\n${violations.join("\n")}`;
+    if (mode === "error")
+        throw new Error(message);
+    console.warn(message);
+}

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

@@ -0,0 +1,11 @@
+/**
+ * runtypex — runtime APIs
+ * 1) makeValidate<T>()  : (v) => v is T
+ * 2) makeAssert<T>()    : throws on invalid
+ *
+ * NOTE: These factories are replaced at build-time by the transformer.
+ */
+export type ValidateFn<T> = (value: unknown) => value is T;
+export type AssertFn<T> = (value: unknown) => asserts value is T;
+export declare function makeValidate<T>(): ValidateFn<T>;
+export declare function makeAssert<T>(): AssertFn<T>;

package/dist/cjs/runtime/validate.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeValidate = makeValidate;
+exports.makeAssert = makeAssert;
+// Replaced by transformer to generated guard
+function __validate(_value) {
+    return true;
+}
+function makeValidate() {
+    return (value) => __validate(value);
+}
+function makeAssert() {
+    const validate = makeValidate();
+    return (value) => {
+        if (!validate(value))
+            throw new TypeError("[runtypex] Validation failed.");
+    };
+}

package/dist/cjs/transformer/helper.d.ts

@@ -0,0 +1,2 @@
+import ts from "typescript";
+export declare function resolveTypeByName(program: ts.Program, sf: ts.SourceFile, checker: ts.TypeChecker, name: string): ts.Type | null;

package/dist/cjs/transformer/helper.js

@@ -0,0 +1,63 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveTypeByName = resolveTypeByName;
+const typescript_1 = __importDefault(require("typescript"));
+function resolveTypeByName(program, sf, checker, name) {
+    // -1️⃣ Primitive type fallback
+    const primitiveNames = ["string", "number", "boolean", "bigint", "symbol", "null", "undefined"];
+    if (primitiveNames.includes(name)) {
+        const map = {
+            string: checker.getStringType(),
+            number: checker.getNumberType(),
+            boolean: checker.getBooleanType(),
+            bigint: checker.getBigIntType(),
+            symbol: checker.getESSymbolType(),
+            null: checker.getNullType(),
+            undefined: checker.getUndefinedType(),
+        };
+        return map[name];
+    }
+    // 2️⃣ Scan source files
+    for (const file of program.getSourceFiles()) {
+        const decl = _findLocalDeclaration(file, name);
+        if (!decl)
+            continue;
+        // ✅ type, interface, enum, class
+        if (typescript_1.default.isInterfaceDeclaration(decl) ||
+            typescript_1.default.isClassDeclaration(decl) ||
+            typescript_1.default.isEnumDeclaration(decl)) {
+            if (decl.name) {
+                const symbol = checker.getSymbolAtLocation(decl.name);
+                if (symbol)
+                    return checker.getDeclaredTypeOfSymbol(symbol);
+            }
+        }
+        if (typescript_1.default.isTypeAliasDeclaration(decl)) {
+            return checker.getTypeFromTypeNode(decl.type);
+        }
+    }
+    // 3️⃣ Scope-based fallback
+    const symbol = checker
+        .getSymbolsInScope(sf, typescript_1.default.SymbolFlags.Type | typescript_1.default.SymbolFlags.Alias | typescript_1.default.SymbolFlags.Interface)
+        .find((s) => s.name === name);
+    return symbol ? checker.getDeclaredTypeOfSymbol(symbol) : null;
+}
+function _findLocalDeclaration(sf, name) {
+    let found;
+    (function walk(node) {
+        if ((typescript_1.default.isInterfaceDeclaration(node) ||
+            typescript_1.default.isTypeAliasDeclaration(node) ||
+            typescript_1.default.isEnumDeclaration(node) ||
+            typescript_1.default.isClassDeclaration(node)) &&
+            node.name?.text === name) {
+            found = node;
+            return;
+        }
+        if (!found)
+            node.forEachChild(walk);
+    })(sf);
+    return found;
+}

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

@@ -0,0 +1,3 @@
+export { default } from "./ts-transformer.js";
+export { default as tsTransformer } from "./ts-transformer.js";
+export { default as vitePlugin } from "./vite-plugin.js";

package/dist/cjs/transformer/index.js

@@ -0,0 +1,12 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.vitePlugin = exports.tsTransformer = exports.default = void 0;
+var ts_transformer_js_1 = require("./ts-transformer.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(ts_transformer_js_1).default; } });
+var ts_transformer_js_2 = require("./ts-transformer.js");
+Object.defineProperty(exports, "tsTransformer", { enumerable: true, get: function () { return __importDefault(ts_transformer_js_2).default; } });
+var vite_plugin_js_1 = require("./vite-plugin.js");
+Object.defineProperty(exports, "vitePlugin", { enumerable: true, get: function () { return __importDefault(vite_plugin_js_1).default; } });

package/dist/cjs/transformer/ts-transformer.d.ts

@@ -0,0 +1,29 @@
+import ts from "typescript";
+type TransformerOptions = {
+    program: ts.Program;
+    removeInProd?: boolean;
+    validateDto?: boolean;
+    validateDomain?: boolean;
+};
+/**
+ * 🧩 tsTransformer
+ * TypeScript custom transformer (BEFORE) factory.
+ *
+ * 📘 Usage (ts-loader / ttypescript):
+ * ```ts
+ * getCustomTransformers: (program) => ({
+ *   before: [ tsTransformer({ program, removeInProd: true }) ]
+ * })
+ * ```
+ *
+ * 🧠 Purpose:
+ *  - Replace makeValidate<T>(), makeAssert<T>() calls
+ *    with *pre-generated runtime validation code* derived from T.
+ *
+ * 💡 Effect:
+ *   ✅ No reflection or runtime type parsing
+ *   ✅ Validation logic embedded at build-time
+ *   ✅ Optionally removed in production builds
+ */
+export default function tsTransformer(options: TransformerOptions): ts.TransformerFactory<ts.SourceFile>;
+export {};