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

package/dist/Document-ChuFrTk1.cjs

@@ -0,0 +1,571 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+//#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
+Object.defineProperty(exports, 'Document_exports', {
+  enumerable: true,
+  get: function () {
+    return Document_exports;
+  }
+});
+Object.defineProperty(exports, 'OperationPath_exports', {
+  enumerable: true,
+  get: function () {
+    return OperationPath_exports;
+  }
+});
+Object.defineProperty(exports, 'Operation_exports', {
+  enumerable: true,
+  get: function () {
+    return Operation_exports;
+  }
+});
+Object.defineProperty(exports, 'ProxyEnvironment_exports', {
+  enumerable: true,
+  get: function () {
+    return ProxyEnvironment_exports;
+  }
+});
+Object.defineProperty(exports, 'Transaction_exports', {
+  enumerable: true,
+  get: function () {
+    return Transaction_exports;
+  }
+});
+Object.defineProperty(exports, '__export', {
+  enumerable: true,
+  get: function () {
+    return __export;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, '_defineProperty', {
+  enumerable: true,
+  get: function () {
+    return _defineProperty;
+  }
+});
+Object.defineProperty(exports, 'decode', {
+  enumerable: true,
+  get: function () {
+    return decode;
+  }
+});
+Object.defineProperty(exports, 'encode', {
+  enumerable: true,
+  get: function () {
+    return encode;
+  }
+});
+Object.defineProperty(exports, 'fromDefinition', {
+  enumerable: true,
+  get: function () {
+    return fromDefinition;
+  }
+});
+Object.defineProperty(exports, 'isEmpty', {
+  enumerable: true,
+  get: function () {
+    return isEmpty;
+  }
+});
+Object.defineProperty(exports, 'isPrefix', {
+  enumerable: true,
+  get: function () {
+    return isPrefix;
+  }
+});
+Object.defineProperty(exports, 'make', {
+  enumerable: true,
+  get: function () {
+    return make;
+  }
+});
+Object.defineProperty(exports, 'pathsEqual', {
+  enumerable: true,
+  get: function () {
+    return pathsEqual;
+  }
+});
+Object.defineProperty(exports, 'pathsOverlap', {
+  enumerable: true,
+  get: function () {
+    return pathsOverlap;
+  }
+});