@zipbul/baker 3.4.0 → 3.4.1

package/dist/src/functions/serialize.js

@@ -1,52 +1 @@
-import { BakerError } from '../errors.js';
-import { ensureSealed } from '../seal/seal.js';
-import { checkCallOptions } from './check-call-options.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// serialize — Public API (§5.2)
-// ─────────────────────────────────────────────────────────────────────────────
-/** Boundary check shared by serialize / serializeSync / serializeAsync. */
-function resolveSerializer(instance, fnName) {
-    if (instance == null || typeof instance !== 'object') {
-        throw new BakerError(`${fnName}: expected a class instance, got ${instance === null ? 'null' : typeof instance}`);
-    }
-    const Class = instance.constructor;
-    if (typeof Class !== 'function') {
-        throw new BakerError(`${fnName}: instance has no constructor`);
-    }
-    // Reject plain objects and forged ones (e.g. `{ constructor: SomeDto }`): a real instance is
-    // `instanceof` its own constructor via the prototype chain; the `constructor` property alone
-    // (which anyone can set) is not trusted.
-    if (Class === Object || !(instance instanceof Class)) {
-        throw new BakerError(`${fnName}: received a plain object. Pass an instance of a DTO class decorated with @Field.`);
-    }
-    return ensureSealed(Class);
-}
-export function serialize(instance, options) {
-    const checkedOpts = checkCallOptions(options);
-    const sealed = resolveSerializer(instance, 'serialize');
-    return sealed.isSerializeAsync
-        ? sealed.serialize(instance, checkedOpts)
-        : sealed.serialize(instance, checkedOpts);
-}
-/**
- * Sync-asserted serialize. Throws `BakerError` if Class has any async transform on the serialize side.
- */
-export function serializeSync(instance, options) {
-    const checkedOpts = checkCallOptions(options);
-    const sealed = resolveSerializer(instance, 'serializeSync');
-    if (sealed.isSerializeAsync) {
-        const className = instance.constructor.name;
-        throw new BakerError(`serializeSync(${className}): DTO has async serialize transforms. Use serializeAsync() instead.`);
-    }
-    return sealed.serialize(instance, checkedOpts);
-}
-/**
- * Async-asserted serialize. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
- */
-export function serializeAsync(instance, options) {
-    const checkedOpts = checkCallOptions(options);
-    const sealed = resolveSerializer(instance, 'serializeAsync');
-    return sealed.isSerializeAsync
-        ? sealed.serialize(instance, checkedOpts)
-        : Promise.resolve(sealed.serialize(instance, checkedOpts));
-}
+import{BakerError as x}from"../errors.js";import{ensureSealed as I}from"../seal/seal.js";import{checkCallOptions as F}from"./check-call-options.js";function G(b,q){if(b==null||typeof b!=="object")throw new x(`${q}: expected a class instance, got ${b===null?"null":typeof b}`);const g=b.constructor;if(typeof g!=="function")throw new x(`${q}: instance has no constructor`);if(g===Object||!(b instanceof g))throw new x(`${q}: received a plain object. Pass an instance of a DTO class decorated with @Field.`);return I(g)}export function serialize(b,q){const g=F(q),j=G(b,"serialize");return j.isSerializeAsync?j.serialize(b,g):j.serialize(b,g)}export function serializeSync(b,q){const g=F(q),j=G(b,"serializeSync");if(j.isSerializeAsync){const H=b.constructor.name;throw new x(`serializeSync(${H}): DTO has async serialize transforms. Use serializeAsync() instead.`)}return j.serialize(b,g)}export function serializeAsync(b,q){const g=F(q),j=G(b,"serializeAsync");return j.isSerializeAsync?j.serialize(b,g):Promise.resolve(j.serialize(b,g))}

package/dist/src/functions/validate.js

@@ -1,49 +1 @@
-import { toBakerIssueSet, BakerError } from '../errors.js';
-import { ensureSealed } from '../seal/seal.js';
-import { checkCallOptions } from './check-call-options.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// validate — Public API (§5.3)
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * DTO-level validation — validates `input` against a decorated class's schema.
- * Sync DTOs return directly; async DTOs return Promise. To validate a single primitive without a
- * DTO, call the rule directly (e.g. `isEmail()(value)`).
- */
-function validate(Class, input, options) {
-    const checkedOpts = checkCallOptions(options);
-    const sealed = ensureSealed(Class);
-    if (sealed.isAsync) {
-        return sealed.validate(input, checkedOpts).then((result) => result === null ? true : toBakerIssueSet(result));
-    }
-    const result = sealed.validate(input, checkedOpts);
-    return result === null ? true : toBakerIssueSet(result);
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// W14: strict sync/async variants — explicit intent at call site
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Sync-asserted validate. Throws `BakerError` if Class has any async rule/transform
- * on the deserialize/validate side. Use when caller code assumes sync return.
- */
-function validateSync(Class, input, options) {
-    const checkedOpts = checkCallOptions(options);
-    const sealed = ensureSealed(Class);
-    if (sealed.isAsync) {
-        throw new BakerError(`validateSync(${Class.name}): DTO has async rules/transforms. Use validateAsync() instead.`);
-    }
-    const result = sealed.validate(input, checkedOpts);
-    return result === null ? true : toBakerIssueSet(result);
-}
-/**
- * Async-asserted validate. Always returns Promise (sync DTOs are wrapped via Promise.resolve).
- */
-function validateAsync(Class, input, options) {
-    const checkedOpts = checkCallOptions(options);
-    const sealed = ensureSealed(Class);
-    if (sealed.isAsync) {
-        return sealed.validate(input, checkedOpts).then((r) => r === null ? true : toBakerIssueSet(r));
-    }
-    const result = sealed.validate(input, checkedOpts);
-    return Promise.resolve(result === null ? true : toBakerIssueSet(result));
-}
-export { validate, validateSync, validateAsync };
+import{toBakerIssueSet as F,BakerError as J}from"../errors.js";import{ensureSealed as G}from"../seal/seal.js";import{checkCallOptions as H}from"./check-call-options.js";function validate(q,g,x){const j=H(x),b=G(q);if(b.isAsync)return b.validate(g,j).then((z)=>z===null?!0:F(z));const f=b.validate(g,j);return f===null?!0:F(f)}function validateSync(q,g,x){const j=H(x),b=G(q);if(b.isAsync)throw new J(`validateSync(${q.name}): DTO has async rules/transforms. Use validateAsync() instead.`);const f=b.validate(g,j);return f===null?!0:F(f)}function validateAsync(q,g,x){const j=H(x),b=G(q);if(b.isAsync)return b.validate(g,j).then((z)=>z===null?!0:F(z));const f=b.validate(g,j);return Promise.resolve(f===null?!0:F(f))}export{validate,validateSync,validateAsync};

package/dist/src/interfaces.js

@@ -1,4 +0,0 @@
-// ─────────────────────────────────────────────────────────────────────────────
-// SealOptions — seal() global options (§1.4)
-// ─────────────────────────────────────────────────────────────────────────────
-export {};

package/dist/src/meta-access.js

@@ -1,75 +1 @@
-import { RAW, SEALED } from './symbols.js';
-/** Returns the metadata object visible on cls (own or inherited via the class prototype chain). */
-function metaOf(cls) {
-    return cls[Symbol.metadata] ?? undefined;
-}
-/** Returns the class's own metadata object, creating one if absent. */
-function ensureOwnMeta(cls) {
-    if (!Object.hasOwn(cls, Symbol.metadata)) {
-        Object.defineProperty(cls, Symbol.metadata, {
-            value: {},
-            writable: true,
-            configurable: true,
-            enumerable: false,
-        });
-    }
-    return cls[Symbol.metadata];
-}
-export function getSealed(cls) {
-    return cls[SEALED];
-}
-/** Same as getSealed but throws if the class is not sealed — for callers that establish the invariant elsewhere. */
-export function requireSealed(cls) {
-    const v = cls[SEALED];
-    if (v === undefined) {
-        throw new Error(`${cls.name || '<anonymous>'}: class is not sealed`);
-    }
-    return v;
-}
-export function setSealed(cls, exec) {
-    cls[SEALED] = exec;
-}
-export function hasSealedOwn(cls) {
-    return Object.hasOwn(cls, SEALED);
-}
-export function deleteSealed(cls) {
-    delete cls[SEALED];
-}
-export function deleteRaw(cls) {
-    if (Object.hasOwn(cls, Symbol.metadata)) {
-        delete cls[Symbol.metadata][RAW];
-    }
-}
-export function getRaw(cls) {
-    return metaOf(cls)?.[RAW];
-}
-/** Same as getRaw but throws if the class has no @Field decorators — for callers that establish the invariant elsewhere. */
-export function requireRaw(cls) {
-    const v = getRaw(cls);
-    if (v === undefined) {
-        throw new Error(`${cls.name || '<anonymous>'}: class has no @Field decorators`);
-    }
-    return v;
-}
-export function setRaw(cls, raw) {
-    ensureOwnMeta(cls)[RAW] = raw;
-}
-/**
- * True only when cls has its OWN RAW slot. A subclass without its own @Field decorators
- * resolves Class[Symbol.metadata] to the parent's metadata via the class prototype chain;
- * the dual own-check keeps mergeInheritance from double-counting inherited fields.
- */
-export function hasRawOwn(cls) {
-    if (!Object.hasOwn(cls, Symbol.metadata)) {
-        return false;
-    }
-    const meta = cls[Symbol.metadata];
-    return meta != null && Object.hasOwn(meta, RAW);
-}
-export function freezeRaw(cls) {
-    // Guard on own RAW: an inherited-only subclass must not freeze the parent's RAW.
-    if (!hasRawOwn(cls)) {
-        return;
-    }
-    Object.freeze(getRaw(cls));
-}
+import{RAW as B,SEALED as q}from"./symbols.js";function C(j){return j[Symbol.metadata]??void 0}function F(j){if(!Object.hasOwn(j,Symbol.metadata))Object.defineProperty(j,Symbol.metadata,{value:{},writable:!0,configurable:!0,enumerable:!1});return j[Symbol.metadata]}export function getSealed(j){return j[q]}export function requireSealed(j){const k=j[q];if(k===void 0)throw Error(`${j.name||"<anonymous>"}: class is not sealed`);return k}export function setSealed(j,k){j[q]=k}export function hasSealedOwn(j){return Object.hasOwn(j,q)}export function deleteSealed(j){delete j[q]}export function deleteRaw(j){if(Object.hasOwn(j,Symbol.metadata))delete j[Symbol.metadata][B]}export function getRaw(j){return C(j)?.[B]}export function requireRaw(j){const k=getRaw(j);if(k===void 0)throw Error(`${j.name||"<anonymous>"}: class has no @Field decorators`);return k}export function setRaw(j,k){F(j)[B]=k}export function hasRawOwn(j){if(!Object.hasOwn(j,Symbol.metadata))return!1;const k=j[Symbol.metadata];return k!=null&&Object.hasOwn(k,B)}export function freezeRaw(j){if(!hasRawOwn(j))return;Object.freeze(getRaw(j))}

package/dist/src/registry.js

@@ -1,8 +1 @@
-/**
- * Global registry — automatically registers classes with at least one decorator attached
- *
- * - Automatically called from ensureMeta()
- * - seal() iterates this Set to seal all DTOs
- * - Metadata is not stored here — used only as an index (which classes are registered)
- */
-export const globalRegistry = new Set();
+export const globalRegistry=new Set;

package/dist/src/rule-metadata.js

@@ -1,17 +1 @@
-export function defineRuleMetadata(fn, meta) {
-    const target = fn;
-    target.emit = meta.emit;
-    target.ruleName = meta.ruleName;
-    if (meta.requiresType !== undefined) {
-        target.requiresType = meta.requiresType;
-    }
-    if (meta.constraints !== undefined) {
-        target.constraints = meta.constraints;
-    }
-    if (meta.isAsync !== undefined) {
-        target.isAsync = meta.isAsync;
-    }
-    if (meta.plan) {
-        target.plan = meta.plan;
-    }
-}
+export function defineRuleMetadata(q,b){const j=q;j.emit=b.emit;j.ruleName=b.ruleName;if(b.requiresType!==void 0)j.requiresType=b.requiresType;if(b.constraints!==void 0)j.constraints=b.constraints;if(b.isAsync!==void 0)j.isAsync=b.isAsync;if(b.plan)j.plan=b.plan}

package/dist/src/rule-plan.js

@@ -1,117 +1 @@
-import { defineRuleMetadata } from './rule-metadata.js';
-const planValue = () => ({ kind: 'value' });
-const planLength = (object = planValue()) => ({
-    kind: 'member',
-    object,
-    property: 'length',
-});
-const planTime = (object = planValue()) => ({
-    kind: 'call0',
-    object,
-    method: 'getTime',
-});
-const planLiteral = (value) => ({ kind: 'literal', value });
-const planCompare = (left, op, right) => ({
-    kind: 'compare',
-    left,
-    op,
-    right: typeof right === 'number' ? planLiteral(right) : right,
-});
-const planOr = (...checks) => ({ kind: 'or', checks });
-function makePlannedRule(options) {
-    const inner = {
-        name: options.name,
-        requiresType: options.requiresType,
-        plan: options.plan,
-        validate: options.validate,
-        emit: (varName, ctx) => emitRulePlan(varName, ctx, options.name, options.plan, undefined, ctx.insideTypeGate),
-    };
-    if (options.constraints !== undefined) {
-        inner.constraints = options.constraints;
-    }
-    return makeRule(inner);
-}
-function makeRule(options) {
-    const fn = ((value) => options.validate(value));
-    const meta = {
-        emit: options.emit,
-        ruleName: options.name,
-        constraints: options.constraints ?? {},
-    };
-    if (options.requiresType !== undefined) {
-        meta.requiresType = options.requiresType;
-    }
-    if (options.isAsync !== undefined) {
-        meta.isAsync = options.isAsync;
-    }
-    if (options.plan !== undefined) {
-        meta.plan = options.plan;
-    }
-    defineRuleMetadata(fn, meta);
-    return fn;
-}
-function emitRulePlan(varName, ctx, ruleName, plan, cache, insideTypeGate) {
-    const failure = insideTypeGate ? stripSelfComparison(plan.failure) : plan.failure;
-    return `if (${emitPlanCheck(failure, varName, cache)}) ${ctx.fail(ruleName)};`;
-}
-/** Strip `x !== x` / `getTime() !== getTime()` self-comparison guards — redundant inside type gate */
-function stripSelfComparison(check) {
-    if (check.kind === 'compare') {
-        return check;
-    }
-    const filtered = check.checks.filter(c => !isSelfComparison(c));
-    if (filtered.length === 0) {
-        return check;
-    } // safety: don't strip everything
-    if (filtered.length === 1) {
-        return filtered[0];
-    }
-    return { kind: check.kind, checks: filtered };
-}
-function isSelfComparison(check) {
-    if (check.kind !== 'compare' || check.op !== '!==') {
-        return false;
-    }
-    return exprEqual(check.left, check.right);
-}
-function exprEqual(a, b) {
-    if (a.kind !== b.kind) {
-        return false;
-    }
-    switch (a.kind) {
-        case 'value':
-            return true;
-        case 'literal':
-            return a.value === b.value;
-        case 'member':
-            return exprEqual(a.object, b.object);
-        case 'call0':
-            return a.method === b.method && exprEqual(a.object, b.object);
-        default:
-            // Compile-time exhaustiveness: adding a RulePlanExpr.kind without a case fails to compile here.
-            return a;
-    }
-}
-function emitPlanCheck(check, varName, cache) {
-    if (check.kind === 'compare') {
-        return `${emitPlanExpr(check.left, varName, cache)} ${check.op} ${emitPlanExpr(check.right, varName, cache)}`;
-    }
-    const joiner = check.kind === 'and' ? ' && ' : ' || ';
-    return `(${check.checks.map(part => emitPlanCheck(part, varName, cache)).join(joiner)})`;
-}
-function emitPlanExpr(expr, varName, cache) {
-    switch (expr.kind) {
-        case 'value':
-            return varName;
-        case 'literal':
-            return String(expr.value);
-        case 'member':
-            return cache?.length ?? `${emitPlanExpr(expr.object, varName, cache)}.length`;
-        case 'call0':
-            return cache?.time ?? `${emitPlanExpr(expr.object, varName, cache)}.getTime()`;
-        default:
-            // Compile-time exhaustiveness: adding a RulePlanExpr.kind without a case fails to compile here.
-            return expr;
-    }
-}
-export { planValue, planLength, planTime, planLiteral, planCompare, planOr, makePlannedRule, makeRule, emitRulePlan };
+import{defineRuleMetadata as U}from"./rule-metadata.js";const planValue=()=>({kind:"value"});const planLength=(z=planValue())=>({kind:"member",object:z,property:"length"});const planTime=(z=planValue())=>({kind:"call0",object:z,method:"getTime"});const planLiteral=(z)=>({kind:"literal",value:z});const planCompare=(z,A,B)=>({kind:"compare",left:z,op:A,right:typeof B==="number"?planLiteral(B):B});const planOr=(...z)=>({kind:"or",checks:z});function makePlannedRule(z){const A={name:z.name,requiresType:z.requiresType,plan:z.plan,validate:z.validate,emit:(B,D)=>emitRulePlan(B,D,z.name,z.plan,void 0,D.insideTypeGate)};if(z.constraints!==void 0)A.constraints=z.constraints;return makeRule(A)}function makeRule(z){const A=(D)=>z.validate(D),B={emit:z.emit,ruleName:z.name,constraints:z.constraints??{}};if(z.requiresType!==void 0)B.requiresType=z.requiresType;if(z.isAsync!==void 0)B.isAsync=z.isAsync;if(z.plan!==void 0)B.plan=z.plan;U(A,B);return A}function emitRulePlan(z,A,B,D,H,K){const Q=K?W(D.failure):D.failure;return`if (${J(Q,z,H)}) ${A.fail(B)};`}function W(z){if(z.kind==="compare")return z;const A=z.checks.filter((B)=>!X(B));if(A.length===0)return z;if(A.length===1)return A[0];return{kind:z.kind,checks:A}}function X(z){if(z.kind!=="compare"||z.op!=="!==")return!1;return I(z.left,z.right)}function I(z,A){if(z.kind!==A.kind)return!1;switch(z.kind){case"value":return!0;case"literal":return z.value===A.value;case"member":return I(z.object,A.object);case"call0":return z.method===A.method&&I(z.object,A.object);default:return z}}function J(z,A,B){if(z.kind==="compare")return`${F(z.left,A,B)} ${z.op} ${F(z.right,A,B)}`;const D=z.kind==="and"?" && ":" || ";return`(${z.checks.map((H)=>J(H,A,B)).join(D)})`}function F(z,A,B){switch(z.kind){case"value":return A;case"literal":return String(z.value);case"member":return B?.length??`${F(z.object,A,B)}.length`;case"call0":return B?.time??`${F(z.object,A,B)}.getTime()`;default:return z}}export{planValue,planLength,planTime,planLiteral,planCompare,planOr,makePlannedRule,makeRule,emitRulePlan};

package/dist/src/rules/array.js

@@ -1,96 +1 @@
-import { makePlannedRule, makeRule, planCompare, planLength } from '../rule-plan.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// arrayContains(values) — array contains all specified values
-// ─────────────────────────────────────────────────────────────────────────────
-function arrayContains(values) {
-    return makeRule({
-        name: 'arrayContains',
-        requiresType: 'array',
-        constraints: { values },
-        validate: value => Array.isArray(value) && values.every(v => value.includes(v)),
-        emit: (varName, ctx) => {
-            const i = ctx.addRef(values);
-            return `if (!refs[${i}].every(function(v){return ${varName}.includes(v);})) ${ctx.fail('arrayContains')};`;
-        },
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// arrayNotContains(values) — array does not contain any of the specified values
-// ─────────────────────────────────────────────────────────────────────────────
-function arrayNotContains(values) {
-    return makeRule({
-        name: 'arrayNotContains',
-        requiresType: 'array',
-        constraints: { values },
-        validate: value => Array.isArray(value) && values.every(v => !value.includes(v)),
-        emit: (varName, ctx) => {
-            const i = ctx.addRef(values);
-            return `if (refs[${i}].some(function(v){return ${varName}.includes(v);})) ${ctx.fail('arrayNotContains')};`;
-        },
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// arrayMinSize(min) — minimum array length
-// ─────────────────────────────────────────────────────────────────────────────
-function arrayMinSize(min) {
-    const plan = { cacheKey: 'length', failure: planCompare(planLength(), '<', min) };
-    return makePlannedRule({
-        name: 'arrayMinSize',
-        requiresType: 'array',
-        constraints: { min },
-        plan,
-        validate: value => Array.isArray(value) && value.length >= min,
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// arrayMaxSize(max) — maximum array length
-// ─────────────────────────────────────────────────────────────────────────────
-function arrayMaxSize(max) {
-    const plan = { cacheKey: 'length', failure: planCompare(planLength(), '>', max) };
-    return makePlannedRule({
-        name: 'arrayMaxSize',
-        requiresType: 'array',
-        constraints: { max },
-        plan,
-        validate: value => Array.isArray(value) && value.length <= max,
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// arrayUnique(identifier?) — no duplicates in array
-// ─────────────────────────────────────────────────────────────────────────────
-function arrayUnique(identifier) {
-    return makeRule({
-        name: 'arrayUnique',
-        requiresType: 'array',
-        constraints: {},
-        validate: value => {
-            if (!Array.isArray(value)) {
-                return false;
-            }
-            if (identifier) {
-                const keys = value.map(identifier);
-                return new Set(keys).size === keys.length;
-            }
-            return new Set(value).size === value.length;
-        },
-        emit: (varName, ctx) => {
-            if (identifier) {
-                const i = ctx.addRef(identifier);
-                return `{var keys=${varName}.map(refs[${i}]);if(new Set(keys).size!==keys.length)${ctx.fail('arrayUnique')};}`;
-            }
-            return `if(new Set(${varName}).size!==${varName}.length)${ctx.fail('arrayUnique')};`;
-        },
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// arrayNotEmpty — array is not empty (singleton)
-// ─────────────────────────────────────────────────────────────────────────────
-const arrayNotEmptyPlan = { cacheKey: 'length', failure: planCompare(planLength(), '===', 0) };
-const arrayNotEmpty = makePlannedRule({
-    name: 'arrayNotEmpty',
-    requiresType: 'array',
-    constraints: {},
-    plan: arrayNotEmptyPlan,
-    validate: value => Array.isArray(value) && value.length > 0,
-});
-export { arrayContains, arrayNotContains, arrayMinSize, arrayMaxSize, arrayUnique, arrayNotEmpty };
+import{makePlannedRule as B,makeRule as D,planCompare as F,planLength as G}from"../rule-plan.js";function arrayContains(b){return D({name:"arrayContains",requiresType:"array",constraints:{values:b},validate:(j)=>Array.isArray(j)&&b.every((w)=>j.includes(w)),emit:(j,w)=>{return`if (!refs[${w.addRef(b)}].every(function(v){return ${j}.includes(v);})) ${w.fail("arrayContains")};`}})}function arrayNotContains(b){return D({name:"arrayNotContains",requiresType:"array",constraints:{values:b},validate:(j)=>Array.isArray(j)&&b.every((w)=>!j.includes(w)),emit:(j,w)=>{return`if (refs[${w.addRef(b)}].some(function(v){return ${j}.includes(v);})) ${w.fail("arrayNotContains")};`}})}function arrayMinSize(b){const j={cacheKey:"length",failure:F(G(),"<",b)};return B({name:"arrayMinSize",requiresType:"array",constraints:{min:b},plan:j,validate:(w)=>Array.isArray(w)&&w.length>=b})}function arrayMaxSize(b){const j={cacheKey:"length",failure:F(G(),">",b)};return B({name:"arrayMaxSize",requiresType:"array",constraints:{max:b},plan:j,validate:(w)=>Array.isArray(w)&&w.length<=b})}function arrayUnique(b){return D({name:"arrayUnique",requiresType:"array",constraints:{},validate:(j)=>{if(!Array.isArray(j))return!1;if(b){const w=j.map(b);return new Set(w).size===w.length}return new Set(j).size===j.length},emit:(j,w)=>{if(b){const A=w.addRef(b);return`{var keys=${j}.map(refs[${A}]);if(new Set(keys).size!==keys.length)${w.fail("arrayUnique")};}`}return`if(new Set(${j}).size!==${j}.length)${w.fail("arrayUnique")};`}})}const H={cacheKey:"length",failure:F(G(),"===",0)};const arrayNotEmpty=B({name:"arrayNotEmpty",requiresType:"array",constraints:{},plan:H,validate:(b)=>Array.isArray(b)&&b.length>0});export{arrayContains,arrayNotContains,arrayMinSize,arrayMaxSize,arrayUnique,arrayNotEmpty};

package/dist/src/rules/binary.js

@@ -1,51 +1,3 @@
-import { makeRule } from '../rule-plan.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// isUint8Array — instanceof guard (self-narrowing, no typeof gate; mirrors isRegExp)
-// ─────────────────────────────────────────────────────────────────────────────
-export const isUint8Array = makeRule({
-    name: 'isUint8Array',
-    constraints: {},
-    validate: value => value instanceof Uint8Array,
-    emit: (varName, ctx) => `if (!(${varName} instanceof Uint8Array)) ${ctx.fail('isUint8Array')};`,
-});
-// ─────────────────────────────────────────────────────────────────────────────
-// isByteSize(min, max?) — byte length of any ArrayBufferView (binary analogue of isByteLength)
-//
-// The ArrayBuffer.isView guard MUST short-circuit before any .byteLength read: reading .byteLength
-// on a non-view yields undefined (and undefined < min is false → would wrongly pass), and on
-// null/undefined it throws. The guard-first else-if chain prevents both. .byteLength is inlined
-// (not aliased to a local like isByteLength) — it is a trivial getter, not an expensive call.
-//
-// min/max are dev-supplied constants; per "trust TS for dev inputs" they are not runtime-guarded,
-// consistent with isByteLength.
-// ─────────────────────────────────────────────────────────────────────────────
-export function isByteSize(min, max) {
-    return makeRule({
-        name: 'isByteSize',
-        constraints: { min, max },
-        // Fail-form mirrors emit exactly (same as isByteLength), so validate() and the generated code
-        // agree for ALL inputs — including degenerate NaN bounds, where pass-form (>= NaN) would reject
-        // but the emitted (< NaN) accepts, breaking validate/emit parity.
-        validate: value => {
-            if (!ArrayBuffer.isView(value)) {
-                return false;
-            }
-            const byteLen = value.byteLength;
-            if (byteLen < min) {
-                return false;
-            }
-            if (max !== undefined && byteLen > max) {
-                return false;
-            }
-            return true;
-        },
-        emit: (varName, ctx) => {
-            let code = `if (!ArrayBuffer.isView(${varName})) ${ctx.fail('isByteSize')};`;
-            code += `\nelse if (${varName}.byteLength < ${min}) ${ctx.fail('isByteSize')};`;
-            if (max !== undefined) {
-                code += `\nelse if (${varName}.byteLength > ${max}) ${ctx.fail('isByteSize')};`;
-            }
-            return code;
-        },
-    });
-}
+import{makeRule as A}from"../rule-plan.js";export const isUint8Array=A({name:"isUint8Array",constraints:{},validate:(f)=>f instanceof Uint8Array,emit:(f,j)=>`if (!(${f} instanceof Uint8Array)) ${j.fail("isUint8Array")};`});export function isByteSize(f,j){return A({name:"isByteSize",constraints:{min:f,max:j},validate:(q)=>{if(!ArrayBuffer.isView(q))return!1;const w=q.byteLength;if(w<f)return!1;if(j!==void 0&&w>j)return!1;return!0},emit:(q,w)=>{let z=`if (!ArrayBuffer.isView(${q})) ${w.fail("isByteSize")};`;z+=`
+else if (${q}.byteLength < ${f}) ${w.fail("isByteSize")};`;if(j!==void 0)z+=`
+else if (${q}.byteLength > ${j}) ${w.fail("isByteSize")};`;return z}})}

package/dist/src/rules/combinators.js

@@ -1,111 +1 @@
-import { BakerError } from '../errors.js';
-import { makeRule } from '../rule-plan.js';
-// ─────────────────────────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────────────────────────
-/** Assert that a value is a baker rule (callable with `.emit` fn + `.ruleName` string). */
-function assertRuleArg(value, combinator) {
-    if (typeof value === 'function' &&
-        typeof value.emit === 'function' &&
-        typeof value.ruleName === 'string') {
-        return;
-    }
-    throw new BakerError(`${combinator}: every argument must be a baker rule (function with .emit and .ruleName). Use createRule() or import a rule from @zipbul/baker/rules.`);
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// oneOf — OR combinator: value matches at least one of the given rules.
-// (Not JSON-Schema `oneOf`/exactly-one — semantics is "matches at least one",
-//  first matching branch wins, short-circuit.)
-// ─────────────────────────────────────────────────────────────────────────────
-function oneOf(...branches) {
-    if (branches.length === 0) {
-        throw new BakerError('oneOf requires at least one rule.');
-    }
-    for (const b of branches) {
-        assertRuleArg(b, 'oneOf');
-    }
-    const constraints = { oneOf: branches.map(b => b.ruleName) };
-    const isAsync = branches.some(b => b.isAsync === true);
-    if (isAsync) {
-        const validate = async (value) => {
-            for (const b of branches) {
-                if (await b(value)) {
-                    return true;
-                }
-            }
-            return false;
-        };
-        return makeRule({
-            name: 'oneOf',
-            constraints,
-            isAsync: true,
-            validate,
-            emit: (varName, ctx) => {
-                const i = ctx.addRef(validate);
-                return `if (!(await refs[${i}](${varName}))) ${ctx.fail('oneOf')};`;
-            },
-        });
-    }
-    const validate = (value) => branches.some(b => b(value));
-    return makeRule({
-        name: 'oneOf',
-        constraints,
-        validate,
-        emit: (varName, ctx) => {
-            const calls = branches.map(b => `refs[${ctx.addRef(b)}](${varName})`).join(' || ');
-            return `if (!(${calls})) ${ctx.fail('oneOf')};`;
-        },
-    });
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// arrayEvery — value is an array and every element satisfies all given rules
-// (AND over the rules, applied per element). Arrays only — Set/Map element
-// validation stays at the @Field level via arrayOf.
-// ─────────────────────────────────────────────────────────────────────────────
-function arrayEvery(...rules) {
-    if (rules.length === 0) {
-        throw new BakerError('arrayEvery requires at least one rule.');
-    }
-    for (const r of rules) {
-        assertRuleArg(r, 'arrayEvery');
-    }
-    const constraints = { arrayEvery: rules.map(r => r.ruleName) };
-    const isAsync = rules.some(r => r.isAsync === true);
-    if (isAsync) {
-        const validate = async (value) => {
-            if (!Array.isArray(value)) {
-                return false;
-            }
-            for (const el of value) {
-                for (const r of rules) {
-                    if (!(await r(el))) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        };
-        return makeRule({
-            name: 'arrayEvery',
-            constraints,
-            isAsync: true,
-            validate,
-            emit: (varName, ctx) => {
-                const i = ctx.addRef(validate);
-                return `if (!(await refs[${i}](${varName}))) ${ctx.fail('arrayEvery')};`;
-            },
-        });
-    }
-    const elementPredicate = (el) => rules.every(r => r(el));
-    const validate = (value) => Array.isArray(value) && value.every(elementPredicate);
-    return makeRule({
-        name: 'arrayEvery',
-        constraints,
-        validate,
-        emit: (varName, ctx) => {
-            const i = ctx.addRef(elementPredicate);
-            return `if (!(Array.isArray(${varName}) && ${varName}.every(refs[${i}]))) ${ctx.fail('arrayEvery')};`;
-        },
-    });
-}
-export { oneOf, arrayEvery };
+import{BakerError as H}from"../errors.js";import{makeRule as F}from"../rule-plan.js";function J(q,D){if(typeof q==="function"&&typeof q.emit==="function"&&typeof q.ruleName==="string")return;throw new H(`${D}: every argument must be a baker rule (function with .emit and .ruleName). Use createRule() or import a rule from @zipbul/baker/rules.`)}function oneOf(...q){if(q.length===0)throw new H("oneOf requires at least one rule.");for(const z of q)J(z,"oneOf");const D={oneOf:q.map((z)=>z.ruleName)};if(q.some((z)=>z.isAsync===!0)){const z=async(j)=>{for(const w of q)if(await w(j))return!0;return!1};return F({name:"oneOf",constraints:D,isAsync:!0,validate:z,emit:(j,w)=>{return`if (!(await refs[${w.addRef(z)}](${j}))) ${w.fail("oneOf")};`}})}return F({name:"oneOf",constraints:D,validate:(z)=>q.some((j)=>j(z)),emit:(z,j)=>{return`if (!(${q.map((C)=>`refs[${j.addRef(C)}](${z})`).join(" || ")})) ${j.fail("oneOf")};`}})}function arrayEvery(...q){if(q.length===0)throw new H("arrayEvery requires at least one rule.");for(const j of q)J(j,"arrayEvery");const D={arrayEvery:q.map((j)=>j.ruleName)};if(q.some((j)=>j.isAsync===!0)){const j=async(w)=>{if(!Array.isArray(w))return!1;for(const C of w)for(const I of q)if(!await I(C))return!1;return!0};return F({name:"arrayEvery",constraints:D,isAsync:!0,validate:j,emit:(w,C)=>{return`if (!(await refs[${C.addRef(j)}](${w}))) ${C.fail("arrayEvery")};`}})}const G=(j)=>q.every((w)=>w(j));return F({name:"arrayEvery",constraints:D,validate:(j)=>Array.isArray(j)&&j.every(G),emit:(j,w)=>{const C=w.addRef(G);return`if (!(Array.isArray(${j}) && ${j}.every(refs[${C}]))) ${w.fail("arrayEvery")};`}})}export{oneOf,arrayEvery};