@zipbul/baker 1.0.0 → 1.1.0

package/dist/src/seal/expose-validator.d.ts

@@ -1,11 +1,11 @@
 import type { RawClassMeta } from '../types';
 /**
- * @Expose 스택 정적 검증 (§4.1, §3.3)
+ * Static validation of @Expose stacks (§4.1, §3.3)
  *
- * 검사 ①: 동일 @Expose 항목에 deserializeOnly: true + serializeOnly: true → 양쪽 방향 모두 제외
- * 검사 ②: 같은 방향에 2개 이상 @Expose가 있고 groups가 겹치면 SealError
- *          - 둘 다 groups=[] (ungrouped) → 겹침
- *          - 둘 다 non-empty groups이며 교집합 존재 → 겹침
- *          - 하나는 ungrouped, 다른 하나는 grouped → 겹치지 않음 (다른 적용 범위)
+ * Check 1: same @Expose entry has deserializeOnly: true + serializeOnly: true → excluded from both directions
+ * Check 2: if 2+ @Expose entries in the same direction have overlapping groups → SealError
+ *          - both groups=[] (ungrouped) → overlap
+ *          - both non-empty groups with intersection → overlap
+ *          - one ungrouped + one grouped → no overlap (different scope)
  */
 export declare function validateExposeStacks(merged: RawClassMeta, className?: string): void;

package/dist/src/seal/seal.d.ts

@@ -1,38 +1,38 @@
 import type { RawClassMeta, SealedExecutors } from '../types';
 /** @internal Placeholder executor for circular dependency detection during seal */
 declare function _circularPlaceholder(className: string): SealedExecutors<unknown>;
-/** @internal — configure()에서 사후 호출 경고용 */
+/** @internal — used by configure() to warn about post-seal calls */
 export declare function _isSealed(): boolean;
-/** seal 완료된 클래스 목록 — unseal에서 SEALED 제거 시 사용 */
+/** List of sealed classes — used by unseal to remove SEALED */
 export declare const _sealedClasses: Set<Function>;
 /**
- * @internal — deserialize/serialize에서 호출.
- * 이미 sealed면 no-op.
+ * @internal — called from deserialize/serialize.
+ * No-op if already sealed.
  */
 export declare function _autoSeal(): void;
 /**
- * @internal — 동적 import로 auto-seal 이후에 등록된 클래스를 즉석 seal.
- * Class[RAW]가 있고 Class[SEALED]가 없는 경우에만 동작.
+ * @internal — on-demand seal for classes registered after auto-seal via dynamic import.
+ * Only operates when Class[RAW] exists and Class[SEALED] does not.
  */
 export declare function _sealOnDemand(Class: Function): void;
 /**
- * @internal 테스트 전용 — testing.ts의 unseal()에서 호출
+ * @internal testing only — called by unseal() in testing.ts
  */
 export declare function _resetForTesting(): void;
 /**
- * @internal — serialize/deserialize에서 사용. sealed executor를 보장하여 반환.
+ * @internal — used by serialize/deserialize. Ensures and returns a sealed executor.
  */
 export declare function _ensureSealed(Class: Function): SealedExecutors<unknown>;
 /**
- * Class의 prototype chain을 따라 RAW 메타데이터를 child-first로 병합한다.
+ * Merges RAW metadata child-first along the prototype chain of Class.
  *
- * 병합 규칙:
- * - validation: union merge (부모+자식 모두 적용, 중복 rule 제거)
- * - transform: 자식 우선, 자식에 없으면 부모 계승
- * - expose: 자식 우선, 자식에 없으면 부모 계승
- * - exclude: 자식 우선, 자식에 없으면 부모 계승
- * - type: 자식 우선, 자식에 없으면 부모 계승
- * - flags: 자식 우선, 자식에 없는 각 플래그만 부모에서 보충
+ * Merge rules:
+ * - validation: union merge (both parent and child apply, duplicate rules removed)
+ * - transform: child takes priority, inherits from parent if absent in child
+ * - expose: child takes priority, inherits from parent if absent in child
+ * - exclude: child takes priority, inherits from parent if absent in child
+ * - type: child takes priority, inherits from parent if absent in child
+ * - flags: child takes priority, only missing flags are supplemented from parent
  */
 export declare function mergeInheritance(Class: Function): RawClassMeta;
 export declare const __testing__: {

package/dist/src/seal/serialize-builder.d.ts

@@ -1,7 +1,7 @@
 import type { RawClassMeta } from '../types';
 import type { SealOptions, RuntimeOptions } from '../interfaces';
 /**
- * serialize executor 코드 생성.
- * 무검증 전제 — 항상 Record<string, unknown> 반환 (§4.3).
+ * Generate serialize executor code.
+ * Assumes no validation — always returns Record<string, unknown> (§4.3).
  */
 export declare function buildSerializeCode<T>(Class: Function, merged: RawClassMeta, options: SealOptions | undefined, isAsync: boolean): (instance: T, opts?: RuntimeOptions) => Record<string, unknown> | Promise<Record<string, unknown>>;

package/dist/src/symbols.d.ts

@@ -1,10 +1,10 @@
 /**
- * 2개의 Symbol — 외부 저장소 0, 글로벌 오염 0
- * Symbol.for 사용: AOT 코드와 런타임 코드가 동일 Symbol을 공유할 수 있도록 global registry 사용
+ * 2 Symbols — zero external storage, zero global pollution
+ * Uses Symbol.for: allows AOT code and runtime code to share the same Symbol via the global registry
  */
-/** Tier 1 수집 메타데이터 (데코레이터가 Class에 저장) */
+/** Tier 1 collection metadata (stored on Class by decorators) */
 export declare const RAW: unique symbol;
-/** Tier 2 봉인 결과 (seal()이 Class에 저장하는 dual executor) */
+/** Tier 2 seal result (dual executor stored on Class by seal()) */
 export declare const SEALED: unique symbol;
-/** 클래스 레벨 @Schema() 메타데이터 */
+/** Class-level @Schema() metadata */
 export declare const RAW_CLASS_SCHEMA: unique symbol;

package/dist/src/symbols.js

@@ -1,5 +1,5 @@
 // @bun
-import{e as a,f as b,g as c}from"../index-aegrb1kn.js";export{b as SEALED,c as RAW_CLASS_SCHEMA,a as RAW};
+import{e as a,f as b,g as c}from"../index-70ggmxsa.js";export{b as SEALED,c as RAW_CLASS_SCHEMA,a as RAW};
 
 //# debugId=51B5F46B85FFE3B364756E2164756E21
 //# sourceMappingURL=symbols.js.map

package/dist/src/types.d.ts

@@ -1,13 +1,13 @@
 export interface EmitContext {
-    /** RegExp 참조 배열에 등록, 인덱스 반환 */
+    /** Register a RegExp in the reference array, return its index */
     addRegex(re: RegExp): number;
-    /** 참조 배열에 등록, 인덱스 반환 — 함수, 배열, Set, 원시값 등 */
+    /** Register in the reference array, return its index — functions, arrays, Sets, primitives, etc. */
     addRef(value: unknown): number;
-    /** SealedExecutors 객체 참조 배열에 등록 — 중첩 @Type DTO용 */
+    /** Register a SealedExecutors object in the reference array — for nested @Type DTOs */
     addExecutor(executor: SealedExecutors<unknown>): number;
-    /** 에러 코드로 실패 처리 코드 문자열 생성 — path는 builder가 바인딩 */
+    /** Generate a failure code string from an error code — path is bound by the builder */
     fail(code: string): string;
-    /** 에러 수집 모드 여부 (= !stopAtFirstError) */
+    /** Whether error collection mode is enabled (= !stopAtFirstError) */
     collectErrors: boolean;
 }
 export interface EmittableRule {
@@ -15,17 +15,17 @@ export interface EmittableRule {
     emit(varName: string, ctx: EmitContext): string;
     readonly ruleName: string;
     /**
-     * builder가 typeof 가드 삽입 여부를 판단하는 메타.
-     * 해당 타입을 전제하는 rule만 설정 (예: isEmail → 'string').
-     * @IsString 자체는 undefined (자체 typeof 포함).
+     * Meta for the builder to determine whether to insert a typeof guard.
+     * Only set for rules that assume a specific type (e.g., isEmail → 'string').
+     * @IsString itself is undefined (it includes its own typeof check).
      */
     readonly requiresType?: 'string' | 'number' | 'boolean' | 'date';
-    /** 룰 파라미터를 외부에서 읽을 수 있도록 노출 — toJsonSchema 매핑에 사용 */
+    /** Expose rule parameters for external reading — used for toJsonSchema mapping */
     readonly constraints?: Record<string, unknown>;
-    /** async validate 함수 사용 시 true — deserialize-builder가 await 코드를 생성 */
+    /** true when using an async validate function — deserialize-builder generates await code */
     readonly isAsync?: boolean;
 }
-/** 사용자 정의 메시지 콜백 인자 */
+/** Arguments for user-defined message callback */
 export interface MessageArgs {
     property: string;
     value: unknown;
@@ -35,17 +35,17 @@ export interface RuleDef {
     rule: EmittableRule;
     each?: boolean;
     groups?: string[];
-    /** 검증 실패 시 BakerError.message에 포함할 값 */
+    /** Value to include in BakerError.message on validation failure */
     message?: string | ((args: MessageArgs) => string);
-    /** 검증 실패 시 BakerError.context에 포함할 임의 값 */
+    /** Arbitrary value to include in BakerError.context on validation failure */
     context?: unknown;
 }
-/** @Transform 콜백 시그니처 */
+/** @Transform callback signature */
 export type TransformFunction = (params: TransformParams) => unknown;
 export interface TransformParams {
     value: unknown;
     key: string;
-    /** deserialize: input 원본 객체, serialize: class 인스턴스 */
+    /** deserialize: original input object, serialize: class instance */
     obj: Record<string, unknown>;
     type: 'deserialize' | 'serialize';
 }
@@ -77,23 +77,29 @@ export interface TypeDef {
         }[];
     };
     keepDiscriminatorProperty?: boolean;
-    /** seal() 정규화 결과 — fn()이 배열을 반환하면 true */
+    /** seal() normalization result — true if fn() returns an array */
     isArray?: boolean;
-    /** seal() 정규화 결과 — fn() 해석 후 캐시된 클래스 (프리미티브 제외, DTO만) */
+    /** seal() normalization result — cached class after resolving fn() (DTOs only, excluding primitives) */
     resolvedClass?: new (...args: any[]) => any;
+    /** seal() normalization result — Map or Set collection type */
+    collection?: 'Map' | 'Set';
+    /** Nested DTO class thunk for Map value / Set element */
+    collectionValue?: () => new (...args: any[]) => any;
+    /** seal() normalization result — cached class after resolving collectionValue */
+    resolvedCollectionValue?: new (...args: any[]) => any;
 }
 export interface PropertyFlags {
-    /** @IsOptional() — undefined/null 시 validation 전체 skip */
+    /** @IsOptional() — skip all validation when undefined/null */
     isOptional?: boolean;
-    /** @IsDefined() — undefined 불허 (@IsOptional 오버라이드). 현재 코드는 undefined만 거부, null은 후속 검증에 위임 */
+    /** @IsDefined() — disallow undefined (overrides @IsOptional). Current code rejects only undefined; null is delegated to subsequent validation */
     isDefined?: boolean;
-    /** @IsNullable() — null 허용+할당, undefined는 거부 */
+    /** @IsNullable() — allow and assign null, reject undefined */
     isNullable?: boolean;
-    /** @ValidateIf(cond) — false 시 필드 전체 검증 skip */
+    /** @ValidateIf(cond) — skip all field validation when false */
     validateIf?: (obj: any) => boolean;
-    /** @ValidateNested() — 중첩 DTO 재귀 검증 트리거. @Type과 함께 사용 */
+    /** @ValidateNested() — trigger recursive validation for nested DTOs. Used with @Type */
     validateNested?: boolean;
-    /** @ValidateNested({ each: true }) — 배열 원소별 중첩 DTO 검증 */
+    /** @ValidateNested({ each: true }) — validate nested DTOs per array element */
     validateNestedEach?: boolean;
 }
 export interface RawPropertyMeta {
@@ -112,15 +118,15 @@ import type { RuntimeOptions } from './interfaces';
 import type { BakerError } from './errors';
 import type { Result, ResultAsync } from '@zipbul/result';
 export interface SealedExecutors<T> {
-    /** 내부 executor — Result 패턴. deserialize()가 감싸서 throw로 변환 */
+    /** Internal executor — Result pattern. deserialize() wraps and converts to throw */
     _deserialize(input: unknown, options?: RuntimeOptions): Result<T, BakerError[]> | ResultAsync<T, BakerError[]>;
-    /** 내부 executor — 항상 성공. serialize는 무검증 전제 */
+    /** Internal executor — always succeeds. serialize assumes no validation */
     _serialize(instance: T, options?: RuntimeOptions): Record<string, unknown> | Promise<Record<string, unknown>>;
-    /** deserialize 방향에 async 규칙/transform/nested가 있으면 true */
+    /** true if the deserialize direction has async rules/transforms/nested */
     _isAsync: boolean;
-    /** serialize 방향에 async transform/nested가 있으면 true */
+    /** true if the serialize direction has async transforms/nested */
     _isSerializeAsync: boolean;
-    /** seal 시 병합된 메타데이터 캐시 — toJsonSchema에서 사용 (RAW 삭제 후에도 유효) */
+    /** Merged metadata cache at seal time — used by toJsonSchema (valid even after RAW is deleted) */
     _merged?: RawClassMeta;
 }
 export interface JsonSchema202012 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zipbul/baker",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Decorator-based validate + transform with inline code generation. class-validator DX, AOT-level performance, zero reflect-metadata.",
   "license": "MIT",
   "author": "Junhyung Park (https://github.com/parkrevil)",

package/dist/index-57gr0v18.js

@@ -1,6 +0,0 @@
-// @bun
-import{e as J}from"./index-aegrb1kn.js";var Q=new Set;function T(b,w){if(!Object.prototype.hasOwnProperty.call(b,J))b[J]=Object.create(null),Q.add(b);let j=b[J];return j[w]??={validation:[],transform:[],expose:[],exclude:null,type:null,flags:{},schema:null}}function U(b){return b[Symbol.toStringTag]==="AsyncFunction"}var Z=Symbol.for("baker:arrayOf");function d(...b){let w={rules:b};return w[Z]=!0,w}function $(b){return typeof b==="object"&&b!==null&&b[Z]===!0}var K=new Set(["type","discriminator","keepDiscriminatorProperty","rules","optional","nullable","name","deserializeName","serializeName","exclude","groups","when","schema","transform","transformDirection"]);function X(b){if(typeof b==="function")return!1;if(typeof b!=="object"||b===null)return!1;if($(b))return!1;let w=Object.keys(b);if(w.length===0)return!0;return w.some((j)=>K.has(j))}function N(b){if(b.length===0)return{rules:[],options:{}};if(b.length===1&&X(b[0])){let j=b[0];return{rules:j.rules??[],options:j}}let w=b[b.length-1];if(X(w)){let j=w,B=b.slice(0,-1);if(j.rules)B=[...B,...j.rules];return{rules:B,options:j}}return{rules:b,options:{}}}function P(b,w,j){for(let B of w)if($(B))for(let G of B.rules)b.validation.push({rule:G,each:!0,groups:j.groups});else b.validation.push({rule:B,groups:j.groups})}function S(b,w){if(w.name)b.expose.push({name:w.name,groups:w.groups});else if(w.deserializeName||w.serializeName){if(w.deserializeName)b.expose.push({name:w.deserializeName,deserializeOnly:!0,groups:w.groups});if(w.serializeName)b.expose.push({name:w.serializeName,serializeOnly:!0,groups:w.groups})}else if(w.groups)b.expose.push({groups:w.groups});else b.expose.push({})}function V(b,w){if(!w.transform)return;let j=w.transform,G=U(j)?async(z)=>j({value:z.value,key:z.key,obj:z.obj,direction:z.type}):(z)=>j({value:z.value,key:z.key,obj:z.obj,direction:z.type});if(w.transformDirection&&w.transformDirection!=="deserializeOnly"&&w.transformDirection!=="serializeOnly")throw Error(`Invalid transformDirection: "${w.transformDirection}". Expected 'deserializeOnly' or 'serializeOnly'.`);let q={};if(w.transformDirection==="deserializeOnly")q.deserializeOnly=!0;if(w.transformDirection==="serializeOnly")q.serializeOnly=!0;b.transform.push({fn:G,options:Object.keys(q).length>0?q:void 0})}function F(...b){return(w,j)=>{let B=w.constructor,q=T(B,j),{rules:z,options:v}=N(b);if(P(q,z,v),v.optional)q.flags.isOptional=!0;if(v.nullable)q.flags.isNullable=!0;if(v.when)q.flags.validateIf=v.when;if(v.type)q.type={fn:v.type,discriminator:v.discriminator,keepDiscriminatorProperty:v.keepDiscriminatorProperty};if(S(q,v),v.exclude){if(v.exclude===!0)q.exclude={};else if(v.exclude==="deserializeOnly")q.exclude={deserializeOnly:!0};else if(v.exclude==="serializeOnly")q.exclude={serializeOnly:!0}}if(V(q,v),v.schema)if(typeof q.schema==="function");else q.schema={...q.schema??{},...v.schema}}}
-export{Q as a,U as b,d as c,F as d};
-
-//# debugId=3AECA7367D7355B264756E2164756E21
-//# sourceMappingURL=index-57gr0v18.js.map

package/dist/index-aegrb1kn.js

@@ -1,6 +0,0 @@
-// @bun
-var b=Symbol.for("baker:raw"),d=Symbol.for("baker:sealed"),f=Symbol.for("baker:rawClassSchema");
-export{b as e,d as f,f as g};
-
-//# debugId=BEECA922A80577C664756E2164756E21
-//# sourceMappingURL=index-aegrb1kn.js.map