@gialicus/smart-object 1.0.0 → 2.0.1

package/dist/smart-object/define-prototype.js

@@ -0,0 +1,76 @@
+import { getDiscriminatedVariants, getDiscriminator, getFieldSchema, getRecordFieldsFromSchema, isObjectLikeRoot, isZodDiscriminatedUnion, isZodUnionRoot, toRecordEntryMethodPrefix, toSetterMethodName, } from "../zod-introspect.js";
+import { readFieldValue } from "./read-field.js";
+import { createObjectFieldSetter } from "./setters/object-field.js";
+import { createRecordEntryDeleter, createRecordEntryGetter, createRecordEntrySetter, } from "./setters/record-field.js";
+import { createUnionFieldSetter } from "./setters/union-field.js";
+import { createSwitchToVariant, createSwitchVariant } from "./setters/variant-switch.js";
+function defineRecordFieldMethods(prototype, state, zodSchema) {
+    for (const field of getRecordFieldsFromSchema(zodSchema)) {
+        const prefix = toRecordEntryMethodPrefix(field.fieldName);
+        Object.defineProperty(prototype, `get${prefix}Entry`, {
+            value: createRecordEntryGetter(state, field),
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+        Object.defineProperty(prototype, `set${prefix}Entry`, {
+            value: createRecordEntrySetter(state, zodSchema, field),
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+        Object.defineProperty(prototype, `delete${prefix}Entry`, {
+            value: createRecordEntryDeleter(state, zodSchema, field),
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+    }
+}
+function defineUnionRootMethods(prototype, state, zodSchema) {
+    Object.defineProperty(prototype, "switchVariant", {
+        value: createSwitchVariant(state, zodSchema),
+        enumerable: false,
+        configurable: true,
+        writable: true,
+    });
+    if (isZodDiscriminatedUnion(zodSchema)) {
+        const discriminator = getDiscriminator(zodSchema);
+        for (const variant of getDiscriminatedVariants(zodSchema)) {
+            Object.defineProperty(prototype, variant.methodName, {
+                value: createSwitchToVariant(state, zodSchema, variant.schema, variant.tag, discriminator),
+                enumerable: false,
+                configurable: true,
+                writable: true,
+            });
+        }
+    }
+}
+export function definePrototype(prototype, state, zodSchema, keys) {
+    const objectSchema = isObjectLikeRoot(zodSchema) ? zodSchema : undefined;
+    for (const key of keys) {
+        const setMethodName = toSetterMethodName(key);
+        const fieldSchema = getFieldSchema(zodSchema, key);
+        Object.defineProperty(prototype, key, {
+            get() {
+                return readFieldValue(state.getData(this)[key]);
+            },
+            enumerable: true,
+            configurable: true,
+        });
+        Object.defineProperty(prototype, setMethodName, {
+            value: fieldSchema && isObjectLikeRoot(zodSchema)
+                ? createObjectFieldSetter(state, key, fieldSchema, zodSchema)
+                : createUnionFieldSetter(state, zodSchema, key),
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+    }
+    if (objectSchema) {
+        defineRecordFieldMethods(prototype, state, zodSchema);
+    }
+    if (isZodUnionRoot(zodSchema)) {
+        defineUnionRootMethods(prototype, state, zodSchema);
+    }
+}

package/dist/{smart-object.d.ts → smart-object/factory.d.ts}

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import type { SmartObjectConstructor } from "./types.js";
+import type { SmartObjectConstructor } from "../types.js";
 /**
  * Builds a typed SmartObject class from a Zod schema.
  *
@@ -33,4 +33,6 @@ import type { SmartObjectConstructor } from "./types.js";
 export declare function SmartObject<T extends z.ZodObject>(zodSchema: T): SmartObjectConstructor<T>;
 export declare function SmartObject<T extends z.ZodDiscriminatedUnion>(zodSchema: T): SmartObjectConstructor<T>;
 export declare function SmartObject<T extends z.ZodUnion>(zodSchema: T): SmartObjectConstructor<T>;
-//# sourceMappingURL=smart-object.d.ts.map
+export declare function SmartObject<T extends z.ZodIntersection>(zodSchema: T): SmartObjectConstructor<T>;
+export declare function SmartObject<T extends z.ZodLazy>(zodSchema: T): SmartObjectConstructor<T>;
+//# sourceMappingURL=factory.d.ts.map

package/dist/smart-object/factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factory.d.ts","sourceRoot":"","sources":["../../src/smart-object/factory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,sBAAsB,EAAqB,MAAM,aAAa,CAAC;AAwC7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EAAE,SAAS,EAAE,CAAC,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;AAC5F,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,qBAAqB,EAC3D,SAAS,EAAE,CAAC,GACX,sBAAsB,CAAC,CAAC,CAAC,CAAC;AAC7B,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,QAAQ,EAAE,SAAS,EAAE,CAAC,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;AAC3F,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,eAAe,EAAE,SAAS,EAAE,CAAC,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC;AAClG,wBAAgB,WAAW,CAAC,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,SAAS,EAAE,CAAC,GAAG,sBAAsB,CAAC,CAAC,CAAC,CAAC"}

package/dist/smart-object/factory.js

@@ -0,0 +1,27 @@
+import { SmartObjectError } from "../errors.js";
+import { isZodIntersection, isZodObject, isZodUnionOfObjects, isZodUnionRoot, resolveLazySchema, } from "../zod-introspect.js";
+import { buildSmartObjectClass } from "./build-class.js";
+function assertBuildableSchema(schema) {
+    const resolved = resolveLazySchema(schema);
+    if (isZodObject(resolved)) {
+        return;
+    }
+    if (isZodUnionRoot(resolved)) {
+        if (!isZodUnionOfObjects(resolved)) {
+            throw SmartObjectError.unsupportedSchema("SmartObject union root requires all options to be z.object(...)");
+        }
+        return;
+    }
+    if (isZodIntersection(resolved)) {
+        const left = resolved._zod.def.left;
+        const right = resolved._zod.def.right;
+        assertBuildableSchema(left);
+        assertBuildableSchema(right);
+        return;
+    }
+    throw SmartObjectError.unsupportedSchema("SmartObject requires a buildable z.object(...), z.union([...]), z.discriminatedUnion(...), z.intersection(...), or z.lazy(...) schema");
+}
+export function SmartObject(zodSchema) {
+    assertBuildableSchema(zodSchema);
+    return buildSmartObjectClass(zodSchema);
+}

package/dist/smart-object/index.d.ts

@@ -0,0 +1,2 @@
+export { SmartObject } from "./factory.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/smart-object/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/smart-object/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC"}

package/dist/smart-object/index.js

@@ -0,0 +1 @@
+export { SmartObject } from "./factory.js";

package/dist/smart-object/instance-state.d.ts

@@ -0,0 +1,9 @@
+import type { Operation } from "fast-json-patch";
+export type InstanceState<T> = {
+    getData(instance: object): T;
+    setData(instance: object, data: T): void;
+    getOperations(instance: object): Operation[];
+    initOperations(instance: object): void;
+};
+export declare function createInstanceState<T>(): InstanceState<T>;
+//# sourceMappingURL=instance-state.d.ts.map

package/dist/smart-object/instance-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-state.d.ts","sourceRoot":"","sources":["../../src/smart-object/instance-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;IAC7B,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,CAAC,CAAC;IAC7B,OAAO,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,GAAG,IAAI,CAAC;IACzC,aAAa,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,EAAE,CAAC;IAC7C,cAAc,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;CACxC,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,CAAC,KAAK,aAAa,CAAC,CAAC,CAAC,CA0BzD"}

package/dist/smart-object/instance-state.js

@@ -0,0 +1,23 @@
+export function createInstanceState() {
+    const instanceData = new WeakMap();
+    const instanceOperations = new WeakMap();
+    return {
+        getData(instance) {
+            return instanceData.get(instance);
+        },
+        setData(instance, data) {
+            instanceData.set(instance, data);
+        },
+        getOperations(instance) {
+            let operations = instanceOperations.get(instance);
+            if (!operations) {
+                operations = [];
+                instanceOperations.set(instance, operations);
+            }
+            return operations;
+        },
+        initOperations(instance) {
+            instanceOperations.set(instance, []);
+        },
+    };
+}

package/dist/smart-object/json-patch.d.ts

@@ -0,0 +1,4 @@
+import jsonPatch from "fast-json-patch";
+export declare const applyPatch: typeof jsonPatch.applyPatch, compare: typeof jsonPatch.compare;
+export declare function deepClone<T>(value: T): T;
+//# sourceMappingURL=json-patch.d.ts.map

package/dist/smart-object/json-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-patch.d.ts","sourceRoot":"","sources":["../../src/smart-object/json-patch.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,iBAAiB,CAAC;AAExC,eAAO,MAAQ,UAAU,+BAAE,OAAO,0BAAc,CAAC;AAEjD,wBAAgB,SAAS,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAkCxC"}

package/dist/smart-object/json-patch.js

@@ -0,0 +1,27 @@
+import jsonPatch from "fast-json-patch";
+export const { applyPatch, compare } = jsonPatch;
+export function deepClone(value) {
+    if (value instanceof Date) {
+        return new Date(value.getTime());
+    }
+    if (typeof value === "bigint") {
+        return value;
+    }
+    if (value instanceof Map) {
+        return new Map([...value.entries()].map(([key, nestedValue]) => [key, deepClone(nestedValue)]));
+    }
+    if (value instanceof Set) {
+        return new Set([...value].map((item) => deepClone(item)));
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => deepClone(item));
+    }
+    if (typeof value === "object" && value !== null) {
+        const result = {};
+        for (const [key, nestedValue] of Object.entries(value)) {
+            result[key] = deepClone(nestedValue);
+        }
+        return result;
+    }
+    return value;
+}

package/dist/smart-object/read-field.d.ts

@@ -0,0 +1,2 @@
+export declare function readFieldValue(value: unknown): unknown;
+//# sourceMappingURL=read-field.d.ts.map

package/dist/smart-object/read-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-field.d.ts","sourceRoot":"","sources":["../../src/smart-object/read-field.ts"],"names":[],"mappings":"AAEA,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAetD"}

package/dist/smart-object/read-field.js

@@ -0,0 +1,13 @@
+import { deepClone } from "./json-patch.js";
+export function readFieldValue(value) {
+    if (value instanceof Date ||
+        value instanceof Map ||
+        value instanceof Set ||
+        typeof value === "bigint") {
+        return deepClone(value);
+    }
+    if (typeof value === "object" && value !== null) {
+        return deepClone(value);
+    }
+    return value;
+}

package/dist/smart-object/setters/object-field.d.ts

@@ -0,0 +1,5 @@
+import type { z } from "zod";
+import type { SmartObjectSchema } from "../../types.js";
+import type { InstanceState } from "../instance-state.js";
+export declare function createObjectFieldSetter<T>(state: InstanceState<T>, key: string, fieldSchema: z.ZodType, rootSchema: SmartObjectSchema): (this: object, value: unknown) => void;
+//# sourceMappingURL=object-field.d.ts.map

package/dist/smart-object/setters/object-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object-field.d.ts","sourceRoot":"","sources":["../../../src/smart-object/setters/object-field.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAGxD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA8C1D,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,CAAC,CAAC,OAAO,EACtB,UAAU,EAAE,iBAAiB,IAEZ,MAAM,MAAM,EAAE,OAAO,OAAO,UAoC9C"}

package/dist/smart-object/setters/object-field.js

@@ -0,0 +1,56 @@
+import { SmartObjectError } from "../../errors.js";
+import { unwrapFieldSchema } from "../../zod-introspect.js";
+import { serializeDataForPatch, serializeValue } from "../codecs.js";
+import { compare, deepClone } from "../json-patch.js";
+function normalizeFieldPatch(patch, key, fieldSchema, parsed, beforeSerialized) {
+    const inner = unwrapFieldSchema(fieldSchema);
+    const defType = inner._zod.def.type;
+    if (defType !== "set" && defType !== "map") {
+        return patch.map((operation) => {
+            if ("value" in operation && operation.path === `/${key}`) {
+                return {
+                    ...operation,
+                    value: serializeValue(fieldSchema, parsed),
+                };
+            }
+            return operation;
+        });
+    }
+    const prefix = `/${key}`;
+    const touchesField = patch.some((operation) => operation.path === prefix || operation.path.startsWith(`${prefix}/`));
+    if (!touchesField) {
+        return patch;
+    }
+    const hadField = Object.hasOwn(beforeSerialized, key) && beforeSerialized[key] !== undefined;
+    return [
+        {
+            op: hadField ? "replace" : "add",
+            path: prefix,
+            value: serializeValue(fieldSchema, parsed),
+        },
+    ];
+}
+export function createObjectFieldSetter(state, key, fieldSchema, rootSchema) {
+    return function (value) {
+        let parsed;
+        try {
+            parsed = fieldSchema.parse(value);
+        }
+        catch (cause) {
+            throw SmartObjectError.invalidValue(key, cause);
+        }
+        const data = state.getData(this);
+        const beforeData = deepClone(data);
+        const afterData = deepClone(data);
+        afterData[key] = parsed;
+        const beforeSerialized = serializeDataForPatch(beforeData, rootSchema);
+        const afterSerialized = serializeDataForPatch(afterData, rootSchema);
+        const patch = normalizeFieldPatch(compare(beforeSerialized, afterSerialized), key, fieldSchema, parsed, beforeSerialized);
+        if (patch.length === 0) {
+            return;
+        }
+        afterData[key] = parsed;
+        state.setData(this, afterData);
+        state.getOperations(this).push(...patch);
+    };
+}

package/dist/smart-object/setters/record-field.d.ts

@@ -0,0 +1,7 @@
+import type { SmartObjectSchema } from "../../types.js";
+import type { RecordFieldInfo } from "../../zod-introspect.js";
+import type { InstanceState } from "../instance-state.js";
+export declare function createRecordEntryGetter<T>(state: InstanceState<T>, field: RecordFieldInfo): (this: object, key: string) => unknown;
+export declare function createRecordEntrySetter<T>(state: InstanceState<T>, rootSchema: SmartObjectSchema, field: RecordFieldInfo): (this: object, key: string, value: unknown) => void;
+export declare function createRecordEntryDeleter<T>(state: InstanceState<T>, rootSchema: SmartObjectSchema, field: RecordFieldInfo): (this: object, key: string) => void;
+//# sourceMappingURL=record-field.d.ts.map

package/dist/smart-object/setters/record-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-field.d.ts","sourceRoot":"","sources":["../../../src/smart-object/setters/record-field.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAE/D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAuH1D,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,eAAe,IACvE,MAAM,MAAM,EAAE,KAAK,MAAM,aAU3C;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EACvC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,UAAU,EAAE,iBAAiB,EAC7B,KAAK,EAAE,eAAe,IAIL,MAAM,MAAM,EAAE,KAAK,MAAM,EAAE,OAAO,OAAO,UA0C3D;AAED,wBAAgB,wBAAwB,CAAC,CAAC,EACxC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,UAAU,EAAE,iBAAiB,EAC7B,KAAK,EAAE,eAAe,IAIL,MAAM,MAAM,EAAE,KAAK,MAAM,UA0B3C"}

package/dist/smart-object/setters/record-field.js

@@ -0,0 +1,133 @@
+import { SmartObjectError } from "../../errors.js";
+import { serializeDataForPatch, serializeEntryPatchValue } from "../codecs.js";
+import { compare, deepClone } from "../json-patch.js";
+import { readFieldValue } from "../read-field.js";
+function getEntryContainer(data, fieldName, storage) {
+    const container = data[fieldName];
+    if (storage === "map") {
+        return container instanceof Map
+            ? container
+            : new Map();
+    }
+    if (typeof container === "object" && container !== null && !Array.isArray(container)) {
+        return container;
+    }
+    return {};
+}
+function hasEntry(container, key, storage) {
+    if (storage === "map") {
+        return container instanceof Map && container.has(key);
+    }
+    return typeof container === "object" && container !== null && Object.hasOwn(container, key);
+}
+function getEntry(container, key, storage) {
+    if (storage === "map" && container instanceof Map) {
+        return container.get(key);
+    }
+    if (typeof container === "object" && container !== null) {
+        return container[key];
+    }
+    return undefined;
+}
+function cloneContainer(container, storage) {
+    if (storage === "map") {
+        return deepClone(container instanceof Map ? container : new Map());
+    }
+    return deepClone(typeof container === "object" && container !== null
+        ? container
+        : {});
+}
+function setEntry(container, key, value, storage) {
+    if (storage === "map" && container instanceof Map) {
+        container.set(key, value);
+        return;
+    }
+    container[key] = value;
+}
+function deleteEntry(container, key, storage) {
+    if (storage === "map" && container instanceof Map) {
+        container.delete(key);
+        return;
+    }
+    delete container[key];
+}
+function normalizeEntryPatches(patch, fieldName, fieldSchema, valueSchema, nextContainer, storage) {
+    const prefix = `/${fieldName}/`;
+    return patch.map((operation) => {
+        if (!("value" in operation) || !operation.path.startsWith(prefix)) {
+            return operation;
+        }
+        const remainder = operation.path.slice(prefix.length);
+        if (remainder.includes("/")) {
+            return operation;
+        }
+        const entryKey = remainder.replace(/~1/g, "/").replace(/~0/g, "~");
+        const entryValue = storage === "map" && nextContainer instanceof Map
+            ? nextContainer.get(entryKey)
+            : nextContainer[entryKey];
+        return {
+            ...operation,
+            value: serializeEntryPatchValue(fieldSchema, valueSchema, entryValue),
+        };
+    });
+}
+export function createRecordEntryGetter(state, field) {
+    return function (key) {
+        const data = state.getData(this);
+        const value = getEntry(data[field.fieldName], key, field.storage);
+        if (value === undefined) {
+            return undefined;
+        }
+        return readFieldValue(value);
+    };
+}
+export function createRecordEntrySetter(state, rootSchema, field) {
+    const { fieldName, fieldSchema, valueSchema, storage } = field;
+    return function (key, value) {
+        let parsed;
+        try {
+            parsed = valueSchema.parse(value);
+        }
+        catch (cause) {
+            throw SmartObjectError.invalidValue(`${fieldName}.${key}`, cause);
+        }
+        const data = state.getData(this);
+        const container = getEntryContainer(data, fieldName, storage);
+        const previousValue = getEntry(container, key, storage);
+        if (hasEntry(container, key, storage) && Object.is(previousValue, parsed)) {
+            return;
+        }
+        const beforeData = deepClone(data);
+        const afterData = deepClone(data);
+        const nextContainer = cloneContainer(container, storage);
+        setEntry(nextContainer, key, parsed, storage);
+        afterData[fieldName] = nextContainer;
+        const patch = normalizeEntryPatches(compare(serializeDataForPatch(beforeData, rootSchema), serializeDataForPatch(afterData, rootSchema)), fieldName, fieldSchema, valueSchema, nextContainer, storage);
+        if (patch.length === 0) {
+            return;
+        }
+        data[fieldName] = nextContainer;
+        state.getOperations(this).push(...patch);
+    };
+}
+export function createRecordEntryDeleter(state, rootSchema, field) {
+    const { fieldName, storage } = field;
+    return function (key) {
+        const data = state.getData(this);
+        const container = data[fieldName];
+        if (!hasEntry(container, key, storage)) {
+            return;
+        }
+        const beforeData = deepClone(data);
+        const afterData = deepClone(data);
+        const nextContainer = cloneContainer(getEntryContainer(afterData, fieldName, storage), storage);
+        deleteEntry(nextContainer, key, storage);
+        afterData[fieldName] = nextContainer;
+        const patch = compare(serializeDataForPatch(beforeData, rootSchema), serializeDataForPatch(afterData, rootSchema));
+        if (patch.length === 0) {
+            return;
+        }
+        data[fieldName] = nextContainer;
+        state.getOperations(this).push(...patch);
+    };
+}

package/dist/smart-object/setters/union-field.d.ts

@@ -0,0 +1,4 @@
+import type { ZodUnionRootLike } from "../../zod-introspect.js";
+import type { InstanceState } from "../instance-state.js";
+export declare function createUnionFieldSetter<T>(state: InstanceState<T>, schema: ZodUnionRootLike, key: string): (this: object, value: unknown) => void;
+//# sourceMappingURL=union-field.d.ts.map

package/dist/smart-object/setters/union-field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-field.d.ts","sourceRoot":"","sources":["../../../src/smart-object/setters/union-field.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAI1D,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,MAAM,IAEM,MAAM,MAAM,EAAE,OAAO,OAAO,UAyB9C"}

package/dist/smart-object/setters/union-field.js

@@ -0,0 +1,25 @@
+import { SmartObjectError } from "../../errors.js";
+import { compare, deepClone } from "../json-patch.js";
+import { assertKeyAllowedOnMatchingVariants, getMatchingVariantObjects } from "../union-variant.js";
+export function createUnionFieldSetter(state, schema, key) {
+    return function (value) {
+        const matchingVariants = getMatchingVariantObjects(state, this, schema);
+        assertKeyAllowedOnMatchingVariants(matchingVariants, key);
+        const data = state.getData(this);
+        const beforeData = deepClone(data);
+        const candidate = { ...deepClone(data), [key]: value };
+        let parsed;
+        try {
+            parsed = schema.parse(candidate);
+        }
+        catch (cause) {
+            throw SmartObjectError.invalidValue(key, cause);
+        }
+        const patch = compare(beforeData, parsed);
+        if (patch.length === 0) {
+            return;
+        }
+        state.setData(this, parsed);
+        state.getOperations(this).push(...patch);
+    };
+}

package/dist/smart-object/setters/variant-switch.d.ts

@@ -0,0 +1,5 @@
+import type { ZodDiscriminatedUnionLike, ZodObjectLike, ZodUnionRootLike } from "../../zod-introspect.js";
+import type { InstanceState } from "../instance-state.js";
+export declare function createSwitchVariant<T>(state: InstanceState<T>, schema: ZodUnionRootLike): (this: object, value: unknown) => void;
+export declare function createSwitchToVariant<T>(state: InstanceState<T>, schema: ZodDiscriminatedUnionLike, variantSchema: ZodObjectLike, tagValue: string | number | boolean, discriminator: string): (this: object, partial: Record<string, unknown>) => void;
+//# sourceMappingURL=variant-switch.d.ts.map

package/dist/smart-object/setters/variant-switch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variant-switch.d.ts","sourceRoot":"","sources":["../../../src/smart-object/setters/variant-switch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,yBAAyB,EACzB,aAAa,EACb,gBAAgB,EACjB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AA8B1D,wBAAgB,mBAAmB,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,gBAAgB,IACrE,MAAM,MAAM,EAAE,OAAO,OAAO,UAG9C;AAED,wBAAgB,qBAAqB,CAAC,CAAC,EACrC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,MAAM,EAAE,yBAAyB,EACjC,aAAa,EAAE,aAAa,EAC5B,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,EACnC,aAAa,EAAE,MAAM,IAEJ,MAAM,MAAM,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,UAahE"}

package/dist/smart-object/setters/variant-switch.js

@@ -0,0 +1,37 @@
+import { SmartObjectError } from "../../errors.js";
+import { compare, deepClone } from "../json-patch.js";
+function applyVariantSwitch(state, instance, schema, value) {
+    const data = state.getData(instance);
+    const beforeData = deepClone(data);
+    let parsed;
+    try {
+        parsed = schema.parse(value);
+    }
+    catch (cause) {
+        throw SmartObjectError.invalidValue("variant", cause);
+    }
+    const patch = compare(beforeData, parsed);
+    if (patch.length === 0) {
+        return;
+    }
+    state.setData(instance, parsed);
+    state.getOperations(instance).push(...patch);
+}
+export function createSwitchVariant(state, schema) {
+    return function (value) {
+        applyVariantSwitch(state, this, schema, value);
+    };
+}
+export function createSwitchToVariant(state, schema, variantSchema, tagValue, discriminator) {
+    return function (partial) {
+        const candidate = { ...partial, [discriminator]: tagValue };
+        let parsed;
+        try {
+            parsed = variantSchema.parse(candidate);
+        }
+        catch (cause) {
+            throw SmartObjectError.invalidValue("variant", cause);
+        }
+        applyVariantSwitch(state, this, schema, parsed);
+    };
+}

package/dist/smart-object/union-variant.d.ts

@@ -0,0 +1,5 @@
+import { type ZodObjectLike, type ZodUnionRootLike } from "../zod-introspect.js";
+import type { InstanceState } from "./instance-state.js";
+export declare function getMatchingVariantObjects<T>(state: InstanceState<T>, instance: object, schema: ZodUnionRootLike): ZodObjectLike[];
+export declare function assertKeyAllowedOnMatchingVariants(matchingVariants: ZodObjectLike[], key: string): void;
+//# sourceMappingURL=union-variant.d.ts.map

package/dist/smart-object/union-variant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"union-variant.d.ts","sourceRoot":"","sources":["../../src/smart-object/union-variant.ts"],"names":[],"mappings":"AACA,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACtB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAuBzD,wBAAgB,yBAAyB,CAAC,CAAC,EACzC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,gBAAgB,GACvB,aAAa,EAAE,CASjB;AAED,wBAAgB,kCAAkC,CAChD,gBAAgB,EAAE,aAAa,EAAE,EACjC,GAAG,EAAE,MAAM,GACV,IAAI,CAeN"}

package/dist/smart-object/union-variant.js

@@ -0,0 +1,38 @@
+import { SmartObjectError } from "../errors.js";
+import { getDiscriminator, isZodDiscriminatedUnion, isZodObject, } from "../zod-introspect.js";
+function getActiveVariantViaDiscriminator(schema, data) {
+    const discriminator = getDiscriminator(schema);
+    const tag = data[discriminator];
+    for (const option of schema.options) {
+        if (!isZodObject(option)) {
+            continue;
+        }
+        const tagSchema = option.shape[discriminator];
+        if (tagSchema?.safeParse(tag).success) {
+            return option;
+        }
+    }
+    return undefined;
+}
+export function getMatchingVariantObjects(state, instance, schema) {
+    const data = state.getData(instance);
+    if (isZodDiscriminatedUnion(schema)) {
+        const activeVariant = getActiveVariantViaDiscriminator(schema, data);
+        return activeVariant ? [activeVariant] : [];
+    }
+    return schema.options.filter(isZodObject).filter((option) => option.safeParse(data).success);
+}
+export function assertKeyAllowedOnMatchingVariants(matchingVariants, key) {
+    if (matchingVariants.length === 0) {
+        throw SmartObjectError.invalidUnionState();
+    }
+    if (matchingVariants.length === 1) {
+        if (!(key in matchingVariants[0].shape)) {
+            throw SmartObjectError.invalidUnionField(key);
+        }
+        return;
+    }
+    if (!matchingVariants.some((variant) => key in variant.shape)) {
+        throw SmartObjectError.invalidUnionField(key);
+    }
+}