@voidhash/mimic 0.0.1-alpha.2 → 0.0.1-alpha.3

package/dist/index.mjs

@@ -1632,6 +1632,188 @@ function Union(options) {
 	});
 }
 
+//#endregion
+//#region src/primitives/Either.ts
+var EitherPrimitive = class EitherPrimitive {
+	constructor(schema) {
+		_defineProperty(this, "_tag", "EitherPrimitive");
+		_defineProperty(this, "_State", void 0);
+		_defineProperty(this, "_Proxy", void 0);
+		_defineProperty(this, "_schema", void 0);
+		_defineProperty(this, "_opDefinitions", { set: make$5({
+			kind: "either.set",
+			payload: Schema.Unknown,
+			target: Schema.Unknown,
+			apply: (payload) => payload
+		}) });
+		_defineProperty(this, "_internal", {
+			createProxy: (env, operationPath) => {
+				const defaultValue = this._schema.defaultValue;
+				return {
+					get: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					},
+					set: (value) => {
+						env.addOperation(fromDefinition(operationPath, this._opDefinitions.set, value));
+					},
+					match: (handlers) => {
+						const currentState = env.getState(operationPath);
+						const effectiveState = currentState !== null && currentState !== void 0 ? currentState : defaultValue;
+						if (effectiveState === void 0) return void 0;
+						const valueType = this._getValueType(effectiveState);
+						if (!valueType) return void 0;
+						switch (valueType) {
+							case "string":
+								var _handlers$string;
+								return (_handlers$string = handlers.string) === null || _handlers$string === void 0 ? void 0 : _handlers$string.call(handlers, effectiveState);
+							case "number":
+								var _handlers$number;
+								return (_handlers$number = handlers.number) === null || _handlers$number === void 0 ? void 0 : _handlers$number.call(handlers, effectiveState);
+							case "boolean":
+								var _handlers$boolean;
+								return (_handlers$boolean = handlers.boolean) === null || _handlers$boolean === void 0 ? void 0 : _handlers$boolean.call(handlers, effectiveState);
+							case "literal":
+								var _handlers$literal;
+								return (_handlers$literal = handlers.literal) === null || _handlers$literal === void 0 ? void 0 : _handlers$literal.call(handlers, effectiveState);
+							default: return;
+						}
+					},
+					toSnapshot: () => {
+						const state = env.getState(operationPath);
+						return state !== null && state !== void 0 ? state : defaultValue;
+					}
+				};
+			},
+			applyOperation: (_state, operation) => {
+				if (operation.kind !== "either.set") throw new ValidationError(`EitherPrimitive cannot apply operation of kind: ${operation.kind}`);
+				const payload = operation.payload;
+				this._validateAndApplyToVariant(payload, operation.path);
+				return payload;
+			},
+			getInitialState: () => {
+				return this._schema.defaultValue;
+			},
+			transformOperation: (clientOp, serverOp) => {
+				if (!pathsOverlap(clientOp.path, serverOp.path)) return {
+					type: "transformed",
+					operation: clientOp
+				};
+				return {
+					type: "transformed",
+					operation: clientOp
+				};
+			}
+		});
+		this._schema = schema;
+	}
+	/** Mark this either as required */
+	required() {
+		return new EitherPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { required: true }));
+	}
+	/** Set a default value for this either */
+	default(defaultValue) {
+		return new EitherPrimitive(_objectSpread2(_objectSpread2({}, this._schema), {}, { defaultValue }));
+	}
+	/** Get the variants */
+	get variants() {
+		return this._schema.variants;
+	}
+	/**
+	* Determine the type category of a value based on the variants
+	*/
+	_getValueType(value) {
+		const valueType = typeof value;
+		for (const variant of this._schema.variants) if (variant._tag === "LiteralPrimitive") {
+			if (value === variant.literal) return "literal";
+		}
+		if (valueType === "string") {
+			for (const variant of this._schema.variants) if (variant._tag === "StringPrimitive") return "string";
+		}
+		if (valueType === "number") {
+			for (const variant of this._schema.variants) if (variant._tag === "NumberPrimitive") return "number";
+		}
+		if (valueType === "boolean") {
+			for (const variant of this._schema.variants) if (variant._tag === "BooleanPrimitive") return "boolean";
+		}
+	}
+	/**
+	* Find the matching variant for a value.
+	* For literals, matches exact value. For other types, matches by typeof.
+	*/
+	_findMatchingVariant(value) {
+		const valueType = typeof value;
+		for (const variant of this._schema.variants) if (variant._tag === "LiteralPrimitive") {
+			if (value === variant.literal) return variant;
+		}
+		if (valueType === "string") {
+			for (const variant of this._schema.variants) if (variant._tag === "StringPrimitive") return variant;
+		}
+		if (valueType === "number") {
+			for (const variant of this._schema.variants) if (variant._tag === "NumberPrimitive") return variant;
+		}
+		if (valueType === "boolean") {
+			for (const variant of this._schema.variants) if (variant._tag === "BooleanPrimitive") return variant;
+		}
+	}
+	/**
+	* Get the operation kind for a variant
+	*/
+	_getVariantOperationKind(variant) {
+		switch (variant._tag) {
+			case "StringPrimitive": return "string.set";
+			case "NumberPrimitive": return "number.set";
+			case "BooleanPrimitive": return "boolean.set";
+			case "LiteralPrimitive": return "literal.set";
+			default: return "unknown.set";
+		}
+	}
+	/**
+	* Validate a value against the matching variant, including running its validators.
+	* Throws ValidationError if the value doesn't match any variant or fails validation.
+	*/
+	_validateAndApplyToVariant(value, path) {
+		const matchingVariant = this._findMatchingVariant(value);
+		if (!matchingVariant) throw new ValidationError(`EitherPrimitive.set requires a value matching one of: ${this._schema.variants.map((v) => v._tag).join(", ")}, got: ${typeof value}`);
+		const syntheticOp = {
+			kind: this._getVariantOperationKind(matchingVariant),
+			path,
+			payload: value
+		};
+		matchingVariant._internal.applyOperation(void 0, syntheticOp);
+	}
+};
+/**
+* Creates a new EitherPrimitive with the given scalar variant types.
+* Validators defined on the variants are applied when validating values.
+*
+* @example
+* ```typescript
+* // String or number
+* const value = Either(String(), Number());
+*
+* // String, number, or boolean
+* const status = Either(String(), Number(), Boolean()).default("pending");
+*
+* // With literal types
+* const mode = Either(Literal("auto"), Literal("manual"), Number());
+*
+* // With validators - validates string length and number range
+* const constrained = Either(
+*   String().min(2).max(50),
+*   Number().max(255)
+* );
+* ```
+*/
+function Either(...variants) {
+	if (variants.length === 0) throw new ValidationError("Either requires at least one variant");
+	return new EitherPrimitive({
+		required: false,
+		defaultValue: void 0,
+		variants
+	});
+}
+
 //#endregion
 //#region src/primitives/TreeNode.ts
 /**
@@ -2223,6 +2405,8 @@ var Primitive_exports = /* @__PURE__ */ __export({
 	ArrayPrimitive: () => ArrayPrimitive,
 	Boolean: () => Boolean,
 	BooleanPrimitive: () => BooleanPrimitive,
+	Either: () => Either,
+	EitherPrimitive: () => EitherPrimitive,
 	Lazy: () => Lazy,
 	LazyPrimitive: () => LazyPrimitive,
 	Literal: () => Literal,