@voidhash/mimic 0.0.1-alpha.1 → 0.0.1-alpha.10

package/dist/Document-CwiAFTIq.mjs

@@ -0,0 +1,438 @@
+import { t as __export } from "./chunk-CLMFDpHK.mjs";
+
+//#region \0@oxc-project+runtime@0.103.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.103.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/OperationPath.ts
+var OperationPath_exports = /* @__PURE__ */ __export({
+	decode: () => decode$2,
+	encode: () => encode$2,
+	fromTokens: () => fromTokens,
+	getRelativePath: () => getRelativePath,
+	isPrefix: () => isPrefix,
+	make: () => make$3,
+	pathsEqual: () => pathsEqual,
+	pathsOverlap: () => pathsOverlap
+});
+const parseStringPath = (stringPath) => {
+	return stringPath.split("/");
+};
+const makeStringPathFromTokens = (tokens) => {
+	return tokens.join("/");
+};
+/**
+* Creates a new operation path.
+* @param stringPath - The string path to create the path from.
+* @returns The new operation path.
+*/
+function make$3(stringPath) {
+	const tokensInternal = stringPath ? parseStringPath(stringPath) : [];
+	/**
+	* Returns the tokens of the path.
+	* @returns The tokens of the path.
+	*/
+	const toTokens = () => {
+		return tokensInternal;
+	};
+	/**
+	* Concatenates two paths.
+	* @param other - The other path to concatenate.
+	* @returns The new path.
+	*/
+	const concat = (other) => {
+		return make$3(makeStringPathFromTokens(toTokens().concat(other.toTokens())));
+	};
+	/**
+	* Appends a token to the path.
+	* @param token - The token to append.
+	* @returns The new path.
+	*/
+	const append = (token) => {
+		return make$3(makeStringPathFromTokens(toTokens().concat([token])));
+	};
+	/**
+	* Removes the last token from the path.
+	* @returns The new path.
+	*/
+	const pop = () => {
+		return make$3(makeStringPathFromTokens(toTokens().slice(0, -1)));
+	};
+	/**
+	* Removes the first token from the path.
+	* @returns The new path.
+	*/
+	const shift = () => {
+		return make$3(makeStringPathFromTokens(toTokens().slice(1)));
+	};
+	return {
+		_tag: "OperationPath",
+		toTokens,
+		concat,
+		append,
+		pop,
+		shift
+	};
+}
+/**
+* Creates a new operation path from tokens.
+* @param tokens - The tokens to create the path from.
+* @returns The new operation path.
+*/
+function fromTokens(tokens) {
+	return make$3(makeStringPathFromTokens(tokens));
+}
+/**
+* Checks if two operation paths overlap (one is prefix of the other or equal).
+*/
+const pathsOverlap = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	const minLength = Math.min(tokensA.length, tokensB.length);
+	for (let i = 0; i < minLength; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Checks if pathA is a prefix of pathB (pathA is ancestor of pathB).
+*/
+const isPrefix = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	if (tokensA.length > tokensB.length) return false;
+	for (let i = 0; i < tokensA.length; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Checks if two paths are exactly equal.
+*/
+const pathsEqual = (pathA, pathB) => {
+	const tokensA = pathA.toTokens().filter((t) => t !== "");
+	const tokensB = pathB.toTokens().filter((t) => t !== "");
+	if (tokensA.length !== tokensB.length) return false;
+	for (let i = 0; i < tokensA.length; i++) if (tokensA[i] !== tokensB[i]) return false;
+	return true;
+};
+/**
+* Gets the relative path of pathB with respect to pathA.
+* Assumes pathA is a prefix of pathB.
+*/
+const getRelativePath = (basePath, fullPath) => {
+	const baseTokens = basePath.toTokens().filter((t) => t !== "");
+	return fullPath.toTokens().filter((t) => t !== "").slice(baseTokens.length);
+};
+/**
+* Encodes an OperationPath to a string for network transport.
+* @param path - The operation path to encode.
+* @returns The encoded string representation.
+*/
+const encode$2 = (path) => {
+	return makeStringPathFromTokens(path.toTokens());
+};
+/**
+* Decodes an encoded string back to an OperationPath.
+* @param encoded - The encoded string representation.
+* @returns The decoded OperationPath.
+*/
+const decode$2 = (encoded) => {
+	return make$3(encoded);
+};
+
+//#endregion
+//#region src/Operation.ts
+var Operation_exports = /* @__PURE__ */ __export({
+	decode: () => decode$1,
+	encode: () => encode$1,
+	fromDefinition: () => fromDefinition
+});
+const fromDefinition = (operationPath, definition, payload) => {
+	return {
+		kind: definition.kind,
+		path: operationPath,
+		payload
+	};
+};
+/**
+* Encodes an Operation to a JSON-serializable format for network transport.
+* @param operation - The operation to encode.
+* @returns The encoded representation.
+*/
+const encode$1 = (operation) => {
+	return {
+		kind: operation.kind,
+		path: encode$2(operation.path),
+		payload: operation.payload
+	};
+};
+/**
+* Decodes an encoded operation back to an Operation.
+* Note: This returns a partial operation without the definition methods.
+* The caller must have the operation definitions to fully reconstruct if needed.
+* @param encoded - The encoded representation.
+* @returns The decoded Operation (without definition-specific methods).
+*/
+const decode$1 = (encoded) => {
+	return {
+		kind: encoded.kind,
+		path: decode$2(encoded.path),
+		payload: encoded.payload
+	};
+};
+
+//#endregion
+//#region src/ProxyEnvironment.ts
+var ProxyEnvironment_exports = /* @__PURE__ */ __export({ make: () => make$2 });
+/** Default UUID generator using crypto.randomUUID */
+const defaultGenerateId = () => {
+	return crypto.randomUUID();
+};
+/** Default state getter that always returns undefined */
+const defaultGetState = (_path) => {};
+/**
+* Creates a ProxyEnvironment.
+* @param optionsOrCallback - Either an options object or a simple callback for operations
+*/
+const make$2 = (optionsOrCallback) => {
+	var _options$getState, _options$generateId;
+	const options = typeof optionsOrCallback === "function" ? { onOperation: optionsOrCallback } : optionsOrCallback;
+	return {
+		addOperation: (operation) => {
+			options.onOperation(operation);
+		},
+		getState: (_options$getState = options.getState) !== null && _options$getState !== void 0 ? _options$getState : defaultGetState,
+		generateId: (_options$generateId = options.generateId) !== null && _options$generateId !== void 0 ? _options$generateId : defaultGenerateId
+	};
+};
+
+//#endregion
+//#region src/Transaction.ts
+var Transaction_exports = /* @__PURE__ */ __export({
+	decode: () => decode,
+	empty: () => empty,
+	encode: () => encode,
+	isEmpty: () => isEmpty,
+	make: () => make$1,
+	merge: () => merge
+});
+/**
+* Creates a new Transaction with the given operations.
+*/
+const make$1 = (ops) => ({
+	id: crypto.randomUUID(),
+	ops,
+	timestamp: Date.now()
+});
+/**
+* Creates an empty Transaction.
+*/
+const empty = () => make$1([]);
+/**
+* Checks if a transaction is empty (has no operations).
+*/
+const isEmpty = (tx) => tx.ops.length === 0;
+/**
+* Merges multiple transactions into one.
+*/
+const merge = (txs) => {
+	return make$1(txs.flatMap((tx) => tx.ops));
+};
+/**
+* Encodes a Transaction to a JSON-serializable format for network transport.
+* @param transaction - The transaction to encode.
+* @returns The encoded representation.
+*/
+const encode = (transaction) => ({
+	id: transaction.id,
+	ops: transaction.ops.map(encode$1),
+	timestamp: transaction.timestamp
+});
+/**
+* Decodes an encoded transaction back to a Transaction.
+* @param encoded - The encoded representation.
+* @returns The decoded Transaction.
+*/
+const decode = (encoded) => ({
+	id: encoded.id,
+	ops: encoded.ops.map(decode$1),
+	timestamp: encoded.timestamp
+});
+
+//#endregion
+//#region src/Document.ts
+var Document_exports = /* @__PURE__ */ __export({
+	NestedTransactionError: () => NestedTransactionError,
+	OperationError: () => OperationError,
+	make: () => make
+});
+/**
+* Error thrown when attempting to start a nested transaction.
+*/
+var NestedTransactionError = class extends Error {
+	constructor() {
+		super("Nested transactions are not supported");
+		_defineProperty(this, "_tag", "NestedTransactionError");
+		this.name = "NestedTransactionError";
+	}
+};
+/**
+* Error thrown when an operation fails to apply.
+*/
+var OperationError = class extends Error {
+	constructor(message) {
+		super(message);
+		_defineProperty(this, "_tag", "OperationError");
+		this.name = "OperationError";
+	}
+};
+/**
+* Creates a new Document for the given schema.
+*/
+const make = (schema, options) => {
+	var _options$initial;
+	let _state = (_options$initial = options === null || options === void 0 ? void 0 : options.initial) !== null && _options$initial !== void 0 ? _options$initial : schema._internal.getInitialState();
+	let _pending = [];
+	let _inTransaction = false;
+	let _txOps = [];
+	let _txBaseState = void 0;
+	/**
+	* Gets state at the given path.
+	*/
+	const getStateAtPath = (path) => {
+		const tokens = path.toTokens().filter((t) => t !== "");
+		if (tokens.length === 0) return _state;
+		let current = _state;
+		for (const token of tokens) {
+			if (current === null || current === void 0) return;
+			if (typeof current === "object") {
+				if (Array.isArray(current)) {
+					const entry = current.find((e) => e.id === token);
+					if (entry) {
+						current = entry.value;
+						continue;
+					}
+				}
+				current = current[token];
+			} else return;
+		}
+		return current;
+	};
+	/**
+	* Applies a single operation to the current state.
+	*/
+	const applyOperation = (op) => {
+		try {
+			_state = schema._internal.applyOperation(_state, op);
+		} catch (error) {
+			if (error instanceof Error) throw new OperationError(error.message);
+			throw new OperationError(String(error));
+		}
+	};
+	/**
+	* Handles an operation from a proxy.
+	* In transaction mode: collects operations, applies to state immediately for subsequent reads.
+	* Outside transaction mode: auto-wraps in a single-operation transaction.
+	*/
+	const handleOperation = (op) => {
+		if (_inTransaction) {
+			_txOps.push(op);
+			applyOperation(op);
+		} else {
+			const baseState = _state;
+			try {
+				applyOperation(op);
+				_pending.push(op);
+			} catch (error) {
+				_state = baseState;
+				throw error;
+			}
+		}
+	};
+	/**
+	* Creates a ProxyEnvironment for the document.
+	*/
+	const createEnv = () => {
+		return make$2({
+			onOperation: handleOperation,
+			getState: getStateAtPath
+		});
+	};
+	const env = createEnv();
+	const rootProxy = schema._internal.createProxy(env, make$3(""));
+	return {
+		schema,
+		root: rootProxy,
+		get: () => {
+			return _state;
+		},
+		toSnapshot: () => {
+			return rootProxy.toSnapshot();
+		},
+		transaction: (fn) => {
+			if (_inTransaction) throw new NestedTransactionError();
+			_inTransaction = true;
+			_txOps = [];
+			_txBaseState = _state;
+			try {
+				const result = fn(rootProxy);
+				_pending.push(..._txOps);
+				return result;
+			} catch (error) {
+				_state = _txBaseState;
+				throw error;
+			} finally {
+				_inTransaction = false;
+				_txOps = [];
+				_txBaseState = void 0;
+			}
+		},
+		apply: (ops) => {
+			for (const op of ops) applyOperation(op);
+		},
+		flush: () => {
+			const tx = make$1(_pending);
+			_pending = [];
+			return tx;
+		}
+	};
+};
+
+//#endregion
+export { encode as a, Operation_exports as c, isPrefix as d, pathsEqual as f, decode as i, fromDefinition as l, _defineProperty as m, make as n, isEmpty as o, pathsOverlap as p, Transaction_exports as r, ProxyEnvironment_exports as s, Document_exports as t, OperationPath_exports as u };
+//# sourceMappingURL=Document-CwiAFTIq.mjs.map

package/dist/Document-CwiAFTIq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Document-CwiAFTIq.mjs","names":["make","tokensInternal: ReadonlyArray<OperationPathToken>","encode","decode","encode","OperationPath.encode","decode","OperationPath.decode","make","options: ProxyEnvironmentOptions","make","Operation.encode","Operation.decode","_state: Primitive.InferState<TSchema> | undefined","_pending: Operation.Operation<any, any, any>[]","_txOps: Operation.Operation<any, any, any>[]","_txBaseState: Primitive.InferState<TSchema> | undefined","current: unknown","ProxyEnvironment.make","OperationPath.make","Transaction.make"],"sources":["../src/OperationPath.ts","../src/Operation.ts","../src/ProxyEnvironment.ts","../src/Transaction.ts","../src/Document.ts"],"sourcesContent":["// export type OperationPath = string\nexport type OperationPathToken = string\n\nexport interface OperationPath {\n    readonly _tag: \"OperationPath\"\n    readonly toTokens: () => ReadonlyArray<OperationPathToken>\n    readonly concat: (other: OperationPath) => OperationPath\n    readonly append: (token: OperationPathToken) => OperationPath\n    readonly pop: () => OperationPath\n    readonly shift: () => OperationPath\n}\n\nconst parseStringPath = (stringPath: string): ReadonlyArray<OperationPathToken> => {\n    return stringPath.split(\"/\")\n}\n\nconst makeStringPathFromTokens = (tokens: ReadonlyArray<OperationPathToken>): string => {\n    return tokens.join(\"/\")\n}\n\n/**\n * Creates a new operation path.\n * @param stringPath - The string path to create the path from.\n * @returns The new operation path.\n */\nexport function make(stringPath?: string): OperationPath {\n\n    const tokensInternal: ReadonlyArray<OperationPathToken> = stringPath ? parseStringPath(stringPath) : []\n\n    /**\n     * Returns the tokens of the path.\n     * @returns The tokens of the path.\n     */\n    const toTokens = () => {\n        return tokensInternal\n    }\n\n    /**\n     * Concatenates two paths.\n     * @param other - The other path to concatenate.\n     * @returns The new path.\n     */\n    const concat = (other: OperationPath): OperationPath => {\n        return make(makeStringPathFromTokens(toTokens().concat(other.toTokens())))\n    }\n\n    /**\n     * Appends a token to the path.\n     * @param token - The token to append.\n     * @returns The new path.\n     */\n    const append = (token: OperationPathToken): OperationPath => {\n        return make(makeStringPathFromTokens(toTokens().concat([token])))\n    }\n\n    /**\n     * Removes the last token from the path.\n     * @returns The new path.\n     */\n    const pop = (): OperationPath => {\n        return make(makeStringPathFromTokens(toTokens().slice(0, -1)))\n    }\n\n    /**\n     * Removes the first token from the path.\n     * @returns The new path.\n     */\n    const shift = (): OperationPath => {\n        return make(makeStringPathFromTokens(toTokens().slice(1)))\n    }\n\n    return {\n        _tag: \"OperationPath\",\n        toTokens,\n        concat,\n        append,\n        pop,\n        shift\n    } as const\n}\n\n/**\n * Creates a new operation path from tokens.\n * @param tokens - The tokens to create the path from.\n * @returns The new operation path.\n */\nexport function fromTokens(tokens: ReadonlyArray<OperationPathToken>): OperationPath {\n    return make(makeStringPathFromTokens(tokens))\n}\n\n// =============================================================================\n// Path Utility Functions\n// =============================================================================\n\n/**\n * Checks if two operation paths overlap (one is prefix of the other or equal).\n */\nexport const pathsOverlap = (\n  pathA: OperationPath,\n  pathB: OperationPath\n): boolean => {\n  const tokensA = pathA.toTokens().filter((t) => t !== \"\");\n  const tokensB = pathB.toTokens().filter((t) => t !== \"\");\n\n  const minLength = Math.min(tokensA.length, tokensB.length);\n\n  for (let i = 0; i < minLength; i++) {\n    if (tokensA[i] !== tokensB[i]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Checks if pathA is a prefix of pathB (pathA is ancestor of pathB).\n */\nexport const isPrefix = (\n  pathA: OperationPath,\n  pathB: OperationPath\n): boolean => {\n  const tokensA = pathA.toTokens().filter((t) => t !== \"\");\n  const tokensB = pathB.toTokens().filter((t) => t !== \"\");\n\n  if (tokensA.length > tokensB.length) {\n    return false;\n  }\n\n  for (let i = 0; i < tokensA.length; i++) {\n    if (tokensA[i] !== tokensB[i]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Checks if two paths are exactly equal.\n */\nexport const pathsEqual = (\n  pathA: OperationPath,\n  pathB: OperationPath\n): boolean => {\n  const tokensA = pathA.toTokens().filter((t) => t !== \"\");\n  const tokensB = pathB.toTokens().filter((t) => t !== \"\");\n\n  if (tokensA.length !== tokensB.length) {\n    return false;\n  }\n\n  for (let i = 0; i < tokensA.length; i++) {\n    if (tokensA[i] !== tokensB[i]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Gets the relative path of pathB with respect to pathA.\n * Assumes pathA is a prefix of pathB.\n */\nexport const getRelativePath = (\n  basePath: OperationPath,\n  fullPath: OperationPath\n): string[] => {\n  const baseTokens = basePath.toTokens().filter((t) => t !== \"\");\n  const fullTokens = fullPath.toTokens().filter((t) => t !== \"\");\n\n  return fullTokens.slice(baseTokens.length);\n};\n\n/**\n * Encoded representation of an OperationPath for network transport.\n */\nexport type EncodedOperationPath = string;\n\n/**\n * Encodes an OperationPath to a string for network transport.\n * @param path - The operation path to encode.\n * @returns The encoded string representation.\n */\nexport const encode = (path: OperationPath): EncodedOperationPath => {\n  return makeStringPathFromTokens(path.toTokens());\n};\n\n/**\n * Decodes an encoded string back to an OperationPath.\n * @param encoded - The encoded string representation.\n * @returns The decoded OperationPath.\n */\nexport const decode = (encoded: EncodedOperationPath): OperationPath => {\n  return make(encoded);\n};","\nimport * as OperationPath from \"./OperationPath\"\nimport * as OperationDefinition from \"./OperationDefinition\"\nimport { Schema } from \"effect\";\n\n\nexport type Operation<TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>> = {\n    readonly kind: TKind\n    readonly path: OperationPath.OperationPath\n    readonly payload: Schema.Schema.Type<TPayload>,\n\n} & TDef\n\nexport const fromDefinition = <TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>>(operationPath: OperationPath.OperationPath, definition: TDef, payload: Schema.Schema.Type<TPayload>): Operation<TKind, TPayload, TDef> => {\n    return {\n        kind: definition.kind,\n        path: operationPath,\n        payload: payload,\n    } as Operation<TKind, TPayload, TDef>\n}\n\n/**\n * Encoded representation of an Operation for network transport.\n */\nexport interface EncodedOperation {\n    readonly kind: unknown\n    readonly path: OperationPath.EncodedOperationPath\n    readonly payload: unknown\n}\n\n/**\n * Encodes an Operation to a JSON-serializable format for network transport.\n * @param operation - The operation to encode.\n * @returns The encoded representation.\n */\nexport const encode = <TKind, TPayload extends Schema.Schema.Any, TDef extends OperationDefinition.OperationDefinition<TKind, TPayload, any>>(\n    operation: Operation<TKind, TPayload, TDef>\n): EncodedOperation => {\n    return {\n        kind: operation.kind,\n        path: OperationPath.encode(operation.path),\n        payload: operation.payload,\n    }\n}\n\n/**\n * Decodes an encoded operation back to an Operation.\n * Note: This returns a partial operation without the definition methods.\n * The caller must have the operation definitions to fully reconstruct if needed.\n * @param encoded - The encoded representation.\n * @returns The decoded Operation (without definition-specific methods).\n */\nexport const decode = (encoded: EncodedOperation): Operation<unknown, Schema.Schema.Any, any> => {\n    return {\n        kind: encoded.kind,\n        path: OperationPath.decode(encoded.path),\n        payload: encoded.payload,\n    } as Operation<unknown, Schema.Schema.Any, any>\n}","import * as Operation from \"./Operation\";\nimport * as OperationPath from \"./OperationPath\";\n\nexport type ProxyEnvironment = {\n  /** Adds an operation to be collected/applied */\n  readonly addOperation: (operation: Operation.Operation<any, any, any>) => void;\n  /** Gets the current state at the given path */\n  readonly getState: (path: OperationPath.OperationPath) => unknown;\n  /** Generates a unique ID (UUID) for array elements */\n  readonly generateId: () => string;\n};\n\nexport interface ProxyEnvironmentOptions {\n  /** Callback when an operation is added */\n  readonly onOperation: (operation: Operation.Operation<any, any, any>) => void;\n  /** Function to retrieve current state at a path (defaults to returning undefined) */\n  readonly getState?: (path: OperationPath.OperationPath) => unknown;\n  /** Optional: Custom ID generator (defaults to crypto.randomUUID) */\n  readonly generateId?: () => string;\n}\n\n/** Default UUID generator using crypto.randomUUID */\nconst defaultGenerateId = (): string => {\n  return crypto.randomUUID();\n};\n\n/** Default state getter that always returns undefined */\nconst defaultGetState = (_path: OperationPath.OperationPath): unknown => {\n  return undefined;\n};\n\n/**\n * Creates a ProxyEnvironment.\n * @param optionsOrCallback - Either an options object or a simple callback for operations\n */\nexport const make = (\n  optionsOrCallback: ProxyEnvironmentOptions | ((operation: Operation.Operation<any, any, any>) => void)\n): ProxyEnvironment => {\n  // Support both old callback style and new options object\n  const options: ProxyEnvironmentOptions =\n    typeof optionsOrCallback === \"function\"\n      ? { onOperation: optionsOrCallback }\n      : optionsOrCallback;\n\n  return {\n    addOperation: (operation: Operation.Operation<any, any, any>) => {\n      options.onOperation(operation);\n    },\n    getState: options.getState ?? defaultGetState,\n    generateId: options.generateId ?? defaultGenerateId,\n  };\n};\n","import * as Operation from \"./Operation\";\n\n/**\n * A Transaction represents a group of operations that were applied atomically.\n */\nexport interface Transaction {\n  /** Unique identifier for this transaction */\n  readonly id: string;\n  /** Operations contained in this transaction */\n  readonly ops: ReadonlyArray<Operation.Operation<any, any, any>>;\n  /** Timestamp when the transaction was created */\n  readonly timestamp: number;\n}\n\n/**\n * Creates a new Transaction with the given operations.\n */\nexport const make = (ops: ReadonlyArray<Operation.Operation<any, any, any>>): Transaction => ({\n  id: crypto.randomUUID(),\n  ops,\n  timestamp: Date.now(),\n});\n\n/**\n * Creates an empty Transaction.\n */\nexport const empty = (): Transaction => make([]);\n\n/**\n * Checks if a transaction is empty (has no operations).\n */\nexport const isEmpty = (tx: Transaction): boolean => tx.ops.length === 0;\n\n/**\n * Merges multiple transactions into one.\n */\nexport const merge = (txs: ReadonlyArray<Transaction>): Transaction => {\n  const allOps = txs.flatMap(tx => tx.ops);\n  return make(allOps);\n};\n\n\n/**\n * Encoded representation of a Transaction for network transport.\n */\nexport interface EncodedTransaction {\n  readonly id: string;\n  readonly ops: ReadonlyArray<Operation.EncodedOperation>;\n  readonly timestamp: number;\n}\n\n/**\n * Encodes a Transaction to a JSON-serializable format for network transport.\n * @param transaction - The transaction to encode.\n * @returns The encoded representation.\n */\nexport const encode = (transaction: Transaction): EncodedTransaction => ({\n  id: transaction.id,\n  ops: transaction.ops.map(Operation.encode),\n  timestamp: transaction.timestamp,\n});\n\n/**\n * Decodes an encoded transaction back to a Transaction.\n * @param encoded - The encoded representation.\n * @returns The decoded Transaction.\n */\nexport const decode = (encoded: EncodedTransaction): Transaction => ({\n  id: encoded.id,\n  ops: encoded.ops.map(Operation.decode),\n  timestamp: encoded.timestamp,\n});\n","import * as Operation from \"./Operation\";\nimport * as OperationPath from \"./OperationPath\";\nimport * as ProxyEnvironment from \"./ProxyEnvironment\";\nimport * as Transaction from \"./Transaction\";\nimport type * as Primitive from \"./Primitive\";\n\n// =============================================================================\n// Document Errors\n// =============================================================================\n\n/**\n * Error thrown when attempting to start a nested transaction.\n */\nexport class NestedTransactionError extends Error {\n  readonly _tag = \"NestedTransactionError\";\n  constructor() {\n    super(\"Nested transactions are not supported\");\n    this.name = \"NestedTransactionError\";\n  }\n}\n\n/**\n * Error thrown when an operation fails to apply.\n */\nexport class OperationError extends Error {\n  readonly _tag = \"OperationError\";\n  constructor(message: string) {\n    super(message);\n    this.name = \"OperationError\";\n  }\n}\n\n// =============================================================================\n// Document Interface\n// =============================================================================\n\n/**\n * A Document manages state for a primitive-based schema with transaction support.\n */\nexport interface Document<TSchema extends Primitive.AnyPrimitive> {\n  /** The schema defining this document's structure */\n  readonly schema: TSchema;\n  \n  /** Root proxy for accessing and modifying document data */\n  readonly root: Primitive.InferProxy<TSchema>;\n  \n  /** Returns the current document state */\n  get(): Primitive.InferState<TSchema> | undefined;\n  \n  /**\n   * Returns a readonly snapshot of the entire document state for rendering.\n   * The snapshot is a type-safe, readonly structure where:\n   * - Required fields and fields with defaults are guaranteed to be defined\n   * - Optional fields may be undefined\n   */\n  toSnapshot(): Primitive.InferSnapshot<TSchema>;\n  \n  /**\n   * Runs a function within a transaction.\n   * All operations are collected and applied atomically.\n   * If the function throws, all changes are rolled back.\n   * @returns The return value of the function\n   */\n  transaction<R>(fn: (root: Primitive.InferProxy<TSchema>) => R): R;\n  \n  /**\n   * Applies external operations (e.g., from server/peers) to the document.\n   * These operations are NOT added to pending operations.\n   */\n  apply(ops: ReadonlyArray<Operation.Operation<any, any, any>>): void;\n  \n  /**\n   * Returns pending local operations as a Transaction and clears the buffer.\n   */\n  flush(): Transaction.Transaction;\n}\n\n// =============================================================================\n// Document Options\n// =============================================================================\n\nexport interface DocumentOptions<TSchema extends Primitive.AnyPrimitive> {\n  /** Initial state for the document */\n  readonly initial?: Primitive.InferState<TSchema>;\n}\n\n// =============================================================================\n// Document Implementation\n// =============================================================================\n\n/**\n * Creates a new Document for the given schema.\n */\nexport const make = <TSchema extends Primitive.AnyPrimitive>(\n  schema: TSchema,\n  options?: DocumentOptions<TSchema>\n): Document<TSchema> => {\n  // Internal state\n  let _state: Primitive.InferState<TSchema> | undefined = \n    options?.initial ?? schema._internal.getInitialState();\n  \n  // Pending operations buffer (local changes not yet flushed)\n  let _pending: Operation.Operation<any, any, any>[] = [];\n  \n  // Transaction state\n  let _inTransaction = false;\n  let _txOps: Operation.Operation<any, any, any>[] = [];\n  let _txBaseState: Primitive.InferState<TSchema> | undefined = undefined;\n\n  /**\n   * Gets state at the given path.\n   */\n  const getStateAtPath = (path: OperationPath.OperationPath): unknown => {\n    const tokens = path.toTokens().filter(t => t !== \"\");\n    \n    if (tokens.length === 0) {\n      return _state;\n    }\n    \n    let current: unknown = _state;\n    for (const token of tokens) {\n      if (current === null || current === undefined) {\n        return undefined;\n      }\n      \n      if (typeof current === \"object\") {\n        // Handle array entries (which have { id, pos, value } structure)\n        if (Array.isArray(current)) {\n          // Try to find by ID in array entries\n          const entry = current.find((e: any) => e.id === token);\n          if (entry) {\n            current = entry.value;\n            continue;\n          }\n        }\n        \n        // Handle regular object property access\n        current = (current as Record<string, unknown>)[token];\n      } else {\n        return undefined;\n      }\n    }\n    \n    return current;\n  };\n\n  /**\n   * Applies a single operation to the current state.\n   */\n  const applyOperation = (op: Operation.Operation<any, any, any>): void => {\n    try {\n      _state = schema._internal.applyOperation(_state, op);\n    } catch (error) {\n      if (error instanceof Error) {\n        throw new OperationError(error.message);\n      }\n      throw new OperationError(String(error));\n    }\n  };\n\n  /**\n   * Handles an operation from a proxy.\n   * In transaction mode: collects operations, applies to state immediately for subsequent reads.\n   * Outside transaction mode: auto-wraps in a single-operation transaction.\n   */\n  const handleOperation = (op: Operation.Operation<any, any, any>): void => {\n    if (_inTransaction) {\n      // In transaction: collect op and apply immediately for subsequent reads\n      _txOps.push(op);\n      applyOperation(op);\n    } else {\n      // Not in transaction: auto-wrap in single-operation transaction\n      const baseState = _state;\n      try {\n        applyOperation(op);\n        _pending.push(op);\n      } catch (error) {\n        // Rollback on error\n        _state = baseState;\n        throw error;\n      }\n    }\n  };\n\n  /**\n   * Creates a ProxyEnvironment for the document.\n   */\n  const createEnv = (): ProxyEnvironment.ProxyEnvironment => {\n    return ProxyEnvironment.make({\n      onOperation: handleOperation,\n      getState: getStateAtPath,\n    });\n  };\n\n  // Create the root proxy\n  const env = createEnv();\n  const rootProxy = schema._internal.createProxy(env, OperationPath.make(\"\")) as Primitive.InferProxy<TSchema>;\n\n  // Document implementation\n  const document: Document<TSchema> = {\n    schema,\n    root: rootProxy,\n    \n    get: (): Primitive.InferState<TSchema> | undefined => {\n      return _state;\n    },\n    \n    toSnapshot: (): Primitive.InferSnapshot<TSchema> => {\n      return (rootProxy as { toSnapshot(): Primitive.InferSnapshot<TSchema> }).toSnapshot();\n    },\n    \n    transaction: <R,>(fn: (root: Primitive.InferProxy<TSchema>) => R): R => {\n      if (_inTransaction) {\n        throw new NestedTransactionError();\n      }\n      \n      // Start transaction\n      _inTransaction = true;\n      _txOps = [];\n      _txBaseState = _state;\n      \n      try {\n        // Execute the transaction function\n        const result = fn(rootProxy);\n        \n        // Commit: add transaction ops to pending\n        _pending.push(..._txOps);\n        \n        return result;\n      } catch (error) {\n        // Rollback: restore base state\n        _state = _txBaseState;\n        throw error;\n      } finally {\n        // Clean up transaction state\n        _inTransaction = false;\n        _txOps = [];\n        _txBaseState = undefined;\n      }\n    },\n    \n    apply: (ops: ReadonlyArray<Operation.Operation<any, any, any>>): void => {\n      for (const op of ops) {\n        applyOperation(op);\n      }\n    },\n    \n    flush: (): Transaction.Transaction => {\n      const tx = Transaction.make(_pending);\n      _pending = [];\n      return tx;\n    },\n  };\n\n  return document;\n};\n"],"mappings":"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"}

package/dist/Presence-DKKP4v5X.d.cts

@@ -0,0 +1,91 @@
+import * as Schema from "effect/Schema";
+
+//#region src/Presence.d.ts
+declare namespace Presence_d_exports {
+  export { AnyPresence, Infer, Presence, PresenceEntry, PresenceOptions, isValid, make, validate, validateSafe };
+}
+/**
+ * A Presence schema wrapper that holds an Effect Schema for validation.
+ * This is used by both client and server to validate presence data.
+ */
+interface Presence<TData> {
+  readonly _tag: "Presence";
+  /** The Effect Schema used for validation */
+  readonly schema: Schema.Schema<TData>;
+  /** Branded type marker for inference */
+  readonly _Data: TData;
+}
+/**
+ * Options for creating a Presence instance.
+ */
+interface PresenceOptions<TData> {
+  /** The Effect Schema defining the presence data structure */
+  readonly schema: Schema.Schema<TData>;
+}
+/**
+ * Infer the data type from a Presence instance.
+ */
+type Infer<P extends Presence<any>> = P["_Data"];
+/**
+ * Any Presence type (for generic constraints).
+ */
+type AnyPresence = Presence<any>;
+/**
+ * A presence entry as stored/transmitted.
+ */
+interface PresenceEntry<TData = unknown> {
+  /** The presence data */
+  readonly data: TData;
+  /** Optional user ID from authentication */
+  readonly userId?: string;
+}
+/**
+ * Creates a new Presence schema wrapper.
+ *
+ * @example
+ * ```typescript
+ * import { Presence } from "@voidhash/mimic";
+ * import { Schema } from "effect";
+ *
+ * const CursorPresence = Presence.make({
+ *   schema: Schema.Struct({
+ *     name: Schema.String,
+ *     cursor: Schema.Struct({
+ *       x: Schema.Number,
+ *       y: Schema.Number,
+ *     }),
+ *   }),
+ * });
+ * ```
+ */
+declare const make: <TData>(options: PresenceOptions<TData>) => Presence<TData>;
+/**
+ * Validates unknown data against a Presence schema.
+ * Throws a ParseError if validation fails.
+ *
+ * @param presence - The Presence instance with the schema
+ * @param data - Unknown data to validate
+ * @returns The validated and typed data
+ * @throws ParseError if validation fails
+ */
+declare const validate: <TData>(presence: Presence<TData>, data: unknown) => TData;
+/**
+ * Safely validates unknown data against a Presence schema.
+ * Returns undefined if validation fails instead of throwing.
+ *
+ * @param presence - The Presence instance with the schema
+ * @param data - Unknown data to validate
+ * @returns The validated data or undefined if invalid
+ */
+declare const validateSafe: <TData>(presence: Presence<TData>, data: unknown) => TData | undefined;
+/**
+ * Checks if unknown data is valid according to a Presence schema.
+ *
+ * @param presence - The Presence instance with the schema
+ * @param data - Unknown data to check
+ * @returns true if valid, false otherwise
+ */
+declare const isValid: <TData>(presence: Presence<TData>, data: unknown) => data is TData;
+//#endregion
+export { Presence_d_exports as i, Infer as n, PresenceEntry as r, AnyPresence as t };
+//# sourceMappingURL=Presence-DKKP4v5X.d.cts.map

package/dist/Presence-DKKP4v5X.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Presence-DKKP4v5X.d.cts","names":[],"sources":["../src/Presence.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;UAeiB;;;mBAGE,MAAA,CAAO,OAAO;;EAHhB,SAAA,KAAQ,EAKP,KALO;;;;;AAWR,UAAA,eAAe,CAAA,KAAA,CAEC,CAAA;EAMrB;EAKA,SAAA,MAAW,EAXJ,MAAA,CAAO,MAWA,CAXO,KAWC,CAAA;AASlC;AA8BA;;;AAAwE,KA5C5D,KA4C4D,CAAA,UA5C5C,QA4C4C,CAAA,GAAA,CAAA,CAAA,GA5C3B,CA4C2B,CAAA,OAAA,CAAA;;;AAmBxE;AACqB,KA3DT,WAAA,GAAc,QA2DL,CAAA,GAAA,CAAA;;;;AAcR,UAhEI,aAyEhB,CAAA,QAAA,OAAA,CAAA,CAAA;EARoB;EAAT,SAAA,IAAA,EA/DK,KA+DL;EAET;EAAK,SAAA,MAAA,CAAA,EAAA,MAAA;AAeR;;;;;;;;;;;;;;;;;;;;cApDa,uBAAyB,gBAAgB,WAAS,SAAS;;;;;;;;;;cAmB3D,4BACD,SAAS,0BAElB;;;;;;;;;cAYU,gCACD,SAAS,0BAElB;;;;;;;;cAeU,2BACD,SAAS,kCAEV"}