@zipbul/baker 3.4.0 → 4.0.0

package/dist/src/rules/typechecker.js

@@ -1,171 +1,5 @@
-import { makeRule } from '../rule-plan.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// isString — typeof check (§4.8 A: operator inline)
-// ─────────────────────────────────────────────────────────────────────────────
-export const isString = makeRule({
-    name: 'isString',
-    constraints: {},
-    validate: value => typeof value === 'string',
-    emit: (varName, ctx) => `if (typeof ${varName} !== 'string') ${ctx.fail('isString')};`,
-});
-export function isNumber(options) {
-    const allowNaN = options?.allowNaN ?? false;
-    const allowInfinity = options?.allowInfinity ?? false;
-    const maxDecimalPlaces = options?.maxDecimalPlaces;
-    const validate = (value) => {
-        if (typeof value !== 'number') {
-            return false;
-        }
-        // Check NaN first — since isFinite(NaN) is also false, order matters
-        if (isNaN(value)) {
-            return allowNaN;
-        }
-        // Non-NaN non-finite values (Infinity / -Infinity)
-        if (!isFinite(value)) {
-            return allowInfinity;
-        }
-        if (maxDecimalPlaces !== undefined) {
-            const parts = value.toExponential().split('e');
-            const mantissaDecimals = (parts[0].split('.')[1] || '').length;
-            const exponent = parseInt(parts[1], 10);
-            if (Math.max(0, mantissaDecimals - exponent) > maxDecimalPlaces) {
-                return false;
-            }
-        }
-        return true;
-    };
-    return makeRule({
-        name: 'isNumber',
-        constraints: {
-            allowNaN: options?.allowNaN,
-            allowInfinity: options?.allowInfinity,
-            maxDecimalPlaces: options?.maxDecimalPlaces,
-        },
-        validate,
-        emit: (varName, ctx) => {
-            if (ctx.insideTypeGate) {
-                // typeof + isNaN already verified by gate — emit only Infinity/maxDecimalPlaces checks
-                let code = '';
-                if (!allowInfinity) {
-                    code += `if (${varName} === Infinity || ${varName} === -Infinity) ${ctx.fail('isNumber')};`;
-                }
-                if (maxDecimalPlaces !== undefined) {
-                    code += `${code ? '\nelse ' : ''}{ var exp=${varName}.toExponential().split('e'); var mant=(exp[0].split('.')[1]||'').length; var exp2=parseInt(exp[1],10); if(Math.max(0,mant-exp2)>${maxDecimalPlaces}) ${ctx.fail('isNumber')}; }`;
-                }
-                return code;
-            }
-            let code = `if (typeof ${varName} !== 'number') ${ctx.fail('isNumber')};`;
-            if (!allowNaN) {
-                code += `\nelse if (isNaN(${varName})) ${ctx.fail('isNumber')};`;
-            }
-            if (!allowInfinity) {
-                code += `\nelse if (${varName} === Infinity || ${varName} === -Infinity) ${ctx.fail('isNumber')};`;
-            }
-            if (maxDecimalPlaces !== undefined) {
-                code += `\nelse { var exp=${varName}.toExponential().split('e'); var mant=(exp[0].split('.')[1]||'').length; var exp2=parseInt(exp[1],10); if(Math.max(0,mant-exp2)>${maxDecimalPlaces}) ${ctx.fail('isNumber')}; }`;
-            }
-            return code;
-        },
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// isBoolean — typeof check (§4.8 A)
-// ─────────────────────────────────────────────────────────────────────────────
-export const isBoolean = makeRule({
-    name: 'isBoolean',
-    constraints: {},
-    validate: value => typeof value === 'boolean',
-    emit: (varName, ctx) => `if (typeof ${varName} !== 'boolean') ${ctx.fail('isBoolean')};`,
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// isDate — instanceof Date + getTime() NaN check (§4.8 A)
-// ─────────────────────────────────────────────────────────────────────────────
-export const isDate = makeRule({
-    name: 'isDate',
-    constraints: {},
-    validate: value => value instanceof Date && !isNaN(value.getTime()),
-    emit: (varName, ctx) => `if (!(${varName} instanceof Date) || isNaN(${varName}.getTime())) ${ctx.fail('isDate')};`,
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// isEnum — factory: indexOf check using Object.values array (§4.8 C)
-// ─────────────────────────────────────────────────────────────────────────────
-export function isEnum(entity) {
-    const values = Object.values(entity);
-    // Set lookup is O(1); array indexOf is O(n). Measured (Bun/JSC):
-    // - 4 items: indexOf 1.2 ns vs Set.has 2.2 ns (indexOf marginally faster)
-    // - 50 items: indexOf 64 ns vs Set.has 8.4 ns (Set 7.5x faster)
-    // Use Set when there are enough values to overcome its constant-factor overhead.
-    const useSet = values.length >= 8;
-    const valuesSet = useSet ? new Set(values) : null;
-    return makeRule({
-        name: 'isEnum',
-        constraints: { values },
-        validate: useSet ? value => valuesSet.has(value) : value => values.includes(value),
-        emit: (varName, ctx) => {
-            if (useSet) {
-                const i = ctx.addRef(valuesSet);
-                return `if (!refs[${i}].has(${varName})) ${ctx.fail('isEnum')};`;
-            }
-            const i = ctx.addRef(values);
-            return `if (!refs[${i}].includes(${varName})) ${ctx.fail('isEnum')};`;
-        },
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// isInt — typeof + Number.isInteger check (§4.8 A)
-// ─────────────────────────────────────────────────────────────────────────────
-export const isInt = makeRule({
-    name: 'isInt',
-    requiresType: 'number',
-    constraints: {},
-    validate: value => typeof value === 'number' && Number.isInteger(value),
-    emit: (varName, ctx) => ctx.insideTypeGate
-        ? `if (!Number.isInteger(${varName})) ${ctx.fail('isInt')};`
-        : `if (typeof ${varName} !== 'number' || !Number.isInteger(${varName})) ${ctx.fail('isInt')};`,
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// isArray — Array.isArray check (§4.8 A: operator inline)
-// ─────────────────────────────────────────────────────────────────────────────
-export const isArray = makeRule({
-    name: 'isArray',
-    constraints: {},
-    validate: value => Array.isArray(value),
-    emit: (varName, ctx) => `if (!Array.isArray(${varName})) ${ctx.fail('isArray')};`,
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// isObject — typeof object + non-null + non-array (§4.8 A)
-// ─────────────────────────────────────────────────────────────────────────────
-export const isObject = makeRule({
-    name: 'isObject',
-    constraints: {},
-    validate: value => typeof value === 'object' && value !== null && !Array.isArray(value),
-    emit: (varName, ctx) => `if (typeof ${varName} !== 'object' || ${varName} === null || Array.isArray(${varName})) ${ctx.fail('isObject')};`,
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// isRegExp — instanceof RegExp (self-narrowing, no typeof gate needed)
-// ─────────────────────────────────────────────────────────────────────────────
-export const isRegExp = makeRule({
-    name: 'isRegExp',
-    constraints: {},
-    validate: value => value instanceof RegExp,
-    emit: (varName, ctx) => `if (!(${varName} instanceof RegExp)) ${ctx.fail('isRegExp')};`,
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// isFunction — typeof check (accepts arrow fns, unlike isInstance(Function))
-// ─────────────────────────────────────────────────────────────────────────────
-export const isFunction = makeRule({
-    name: 'isFunction',
-    constraints: {},
-    validate: value => typeof value === 'function',
-    emit: (varName, ctx) => `if (typeof ${varName} !== 'function') ${ctx.fail('isFunction')};`,
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// isStatelessRegExp — RegExp without g/y (the only flags that mutate lastIndex
-// across repeated test()/exec()). Safe for reuse as a single-shot matcher.
-// ─────────────────────────────────────────────────────────────────────────────
-export const isStatelessRegExp = makeRule({
-    name: 'isStatelessRegExp',
-    constraints: {},
-    validate: value => value instanceof RegExp && !value.global && !value.sticky,
-    emit: (varName, ctx) => `if (!(${varName} instanceof RegExp) || ${varName}.global || ${varName}.sticky) ${ctx.fail('isStatelessRegExp')};`,
-});
+import{RequiredType as G}from"../enums.js";import{makeRule as z}from"../rule-plan.js";export const isString=z({name:"isString",constraints:{},validate:(b)=>typeof b==="string",emit:(b,g)=>`if (typeof ${b} !== 'string') ${g.fail("isString")};`});export function isNumber(b){const g=b?.allowNaN??!1,C=b?.allowInfinity??!1,A=b?.maxDecimalPlaces,B=(h)=>{if(typeof h!=="number")return!1;if(isNaN(h))return g;if(!isFinite(h))return C;if(A!==void 0){const j=h.toExponential().split("e"),E=(j[0].split(".")[1]||"").length,F=parseInt(j[1],10);if(Math.max(0,E-F)>A)return!1}return!0};return z({name:"isNumber",constraints:{allowNaN:b?.allowNaN,allowInfinity:b?.allowInfinity,maxDecimalPlaces:b?.maxDecimalPlaces},validate:B,emit:(h,j)=>{if(j.insideTypeGate){let F="";if(!C)F+=`if (${h} === Infinity || ${h} === -Infinity) ${j.fail("isNumber")};`;if(A!==void 0)F+=`${F?`
+else `:""}{ var exp=${h}.toExponential().split('e'); var mant=(exp[0].split('.')[1]||'').length; var exp2=parseInt(exp[1],10); if(Math.max(0,mant-exp2)>${A}) ${j.fail("isNumber")}; }`;return F}let E=`if (typeof ${h} !== 'number') ${j.fail("isNumber")};`;if(!g)E+=`
+else if (isNaN(${h})) ${j.fail("isNumber")};`;if(!C)E+=`
+else if (${h} === Infinity || ${h} === -Infinity) ${j.fail("isNumber")};`;if(A!==void 0)E+=`
+else { var exp=${h}.toExponential().split('e'); var mant=(exp[0].split('.')[1]||'').length; var exp2=parseInt(exp[1],10); if(Math.max(0,mant-exp2)>${A}) ${j.fail("isNumber")}; }`;return E}})}export const isBoolean=z({name:"isBoolean",constraints:{},validate:(b)=>typeof b==="boolean",emit:(b,g)=>`if (typeof ${b} !== 'boolean') ${g.fail("isBoolean")};`});export const isDate=z({name:"isDate",constraints:{},validate:(b)=>b instanceof Date&&!isNaN(b.getTime()),emit:(b,g)=>`if (!(${b} instanceof Date) || isNaN(${b}.getTime())) ${g.fail("isDate")};`});export function isEnum(b){const g=Object.values(b),C=g.length>=8,A=C?new Set(g):null;return z({name:"isEnum",constraints:{values:g},validate:C?(B)=>A.has(B):(B)=>g.includes(B),emit:(B,h)=>{if(C)return`if (!refs[${h.addRef(A)}].has(${B})) ${h.fail("isEnum")};`;return`if (!refs[${h.addRef(g)}].includes(${B})) ${h.fail("isEnum")};`}})}export const isInt=z({name:"isInt",requiresType:G.Number,constraints:{},validate:(b)=>typeof b==="number"&&Number.isInteger(b),emit:(b,g)=>g.insideTypeGate?`if (!Number.isInteger(${b})) ${g.fail("isInt")};`:`if (typeof ${b} !== 'number' || !Number.isInteger(${b})) ${g.fail("isInt")};`});export const isArray=z({name:"isArray",constraints:{},validate:(b)=>Array.isArray(b),emit:(b,g)=>`if (!Array.isArray(${b})) ${g.fail("isArray")};`});export const isObject=z({name:"isObject",constraints:{},validate:(b)=>typeof b==="object"&&b!==null&&!Array.isArray(b),emit:(b,g)=>`if (typeof ${b} !== 'object' || ${b} === null || Array.isArray(${b})) ${g.fail("isObject")};`});export const isRegExp=z({name:"isRegExp",constraints:{},validate:(b)=>b instanceof RegExp,emit:(b,g)=>`if (!(${b} instanceof RegExp)) ${g.fail("isRegExp")};`});export const isFunction=z({name:"isFunction",constraints:{},validate:(b)=>typeof b==="function",emit:(b,g)=>`if (typeof ${b} !== 'function') ${g.fail("isFunction")};`});export const isStatelessRegExp=z({name:"isStatelessRegExp",constraints:{},validate:(b)=>b instanceof RegExp&&!b.global&&!b.sticky,emit:(b,g)=>`if (!(${b} instanceof RegExp) || ${b}.global || ${b}.sticky) ${g.fail("isStatelessRegExp")};`});

package/dist/src/seal/circular-analyzer.js

@@ -1,63 +1 @@
-import { BakerError } from '../errors.js';
-import { getRaw } from '../meta-access.js';
-/**
- * Static analysis for circular references (§4.6)
- *
- * Traverses the @Type reference graph via DFS to detect cycles.
- *
- * Flat DTO without cycles → false (zero WeakSet overhead)
- * DTO with cycles → true (WeakSet automatically inserted)
- */
-export function analyzeCircular(Class) {
-    // @Type reference graph DFS — detect back-edges via visited set
-    const visited = new Set();
-    function walk(cls) {
-        if (visited.has(cls)) {
-            return true;
-        } // back-edge → cycle detected
-        visited.add(cls);
-        const raw = getRaw(cls);
-        if (raw) {
-            for (const meta of Object.values(raw)) {
-                // Simple @Type
-                if (meta.type?.fn) {
-                    let typeResult;
-                    try {
-                        typeResult = meta.type.fn();
-                    }
-                    catch (e) {
-                        throw new BakerError(`${cls.name}: type function threw: ${e.message}`, { cause: e });
-                    }
-                    const nested = Array.isArray(typeResult) ? typeResult[0] : typeResult;
-                    if (walk(nested)) {
-                        return true;
-                    }
-                }
-                // discriminator subTypes
-                if (meta.type?.discriminator) {
-                    for (const sub of meta.type.discriminator.subTypes) {
-                        if (walk(sub.value)) {
-                            return true;
-                        }
-                    }
-                }
-                // W1 (F-1): collectionValue thunk (Set/Map nested DTO) — invoke and walk
-                if (meta.type?.collectionValue) {
-                    let resolved;
-                    try {
-                        resolved = meta.type.collectionValue();
-                    }
-                    catch (e) {
-                        throw new BakerError(`${cls.name}: collectionValue function threw: ${e.message}`, { cause: e });
-                    }
-                    if (typeof resolved === 'function' && walk(resolved)) {
-                        return true;
-                    }
-                }
-            }
-        }
-        visited.delete(cls); // Release tree edge — prevent false positives for diamond patterns
-        return false;
-    }
-    return walk(Class);
-}
+import{BakerError as G}from"../errors.js";import{getRaw as I}from"../meta-access.js";export function analyzeCircular(H){const A=new Set;function x(j){if(A.has(j))return!0;A.add(j);const D=I(j);if(D)for(const q of Object.values(D)){if(q.type?.fn){let h;try{h=q.type.fn()}catch(F){throw new G(`${j.name}: type function threw: ${F.message}`,{cause:F})}const z=Array.isArray(h)?h[0]:h;if(x(z))return!0}if(q.type?.discriminator){for(const h of q.type.discriminator.subTypes)if(x(h.value))return!0}if(q.type?.collectionValue){let h;try{h=q.type.collectionValue()}catch(z){throw new G(`${j.name}: collectionValue function threw: ${z.message}`,{cause:z})}if(typeof h==="function"&&x(h))return!0}}A.delete(j);return!1}return x(H)}

package/dist/src/seal/codegen-utils.js

@@ -1,18 +1 @@
-// ─────────────────────────────────────────────────────────────────────────────
-// Shared code-generation utilities for deserialize/serialize builders
-// ─────────────────────────────────────────────────────────────────────────────
-/** Convert key to a valid JS identifier suffix (encode non-alphanumeric chars via charCode to prevent collisions) */
-export function sanitizeKey(key) {
-    return key.replace(/[^a-zA-Z0-9_]/g, ch => `$${ch.charCodeAt(0)}$`);
-}
-/**
- * Generate a groups-has expression for the fast-path single-group / Set pattern.
- * Checks if any of the given groups match the runtime groups.
- */
-export function buildGroupsHasExpr(singleGroupVar, groupsVar, groups) {
-    const checks = groups.map(group => {
-        const q = JSON.stringify(group);
-        return `(${singleGroupVar}===${q} || (${groupsVar} && ${groupsVar}.has(${q})))`;
-    });
-    return checks.join(' || ');
-}
+export function sanitizeKey(d){return d.replace(/[^a-zA-Z0-9_]/g,(b)=>`$${b.charCodeAt(0)}$`)}export function buildGroupsHasExpr(d,b,w){return w.map((z)=>{const j=JSON.stringify(z);return`(${d}===${j} || (${b} && ${b}.has(${j})))`}).join(" || ")}