@powerhousedao/shared 6.0.0-dev.247 → 6.0.0-dev.249

package/dist/document-model/index.js

@@ -2,6 +2,7 @@ import { a as buildOperationSignatureParams, c as hex2ab, i as buildOperationSig
 import { generateMock } from "./mock.js";
 import { ZodError, z } from "zod";
 import { stringify } from "safe-stable-stringify";
+import { strFromU8, strToU8, unzip, zip } from "fflate";
 import { castDraft, create, unsafe } from "mutative";
 import { pascalCase } from "change-case";
 //#region document-model/errors.ts
@@ -303,29 +304,29 @@ function DocumentModelInputSchema() {
 function DocumentModelGlobalStateSchema() {
 	return z.object({
 		__typename: z.literal("DocumentModelGlobalState").optional(),
-		author: AuthorSchema(),
-		description: z.string(),
-		extension: z.string(),
 		id: z.string(),
 		name: z.string(),
+		author: AuthorSchema(),
+		extension: z.string(),
+		description: z.string(),
 		specifications: z.array(DocumentSpecificationSchema())
 	});
 }
 function DocumentSpecificationSchema() {
 	return z.object({
 		__typename: z.literal("DocumentSpecification").optional(),
-		changeLog: z.array(z.string()),
-		modules: z.array(ModuleSchema()),
 		state: ScopeStateSchema(),
-		version: z.number().int()
+		modules: z.array(ModuleSchema()),
+		version: z.number().int(),
+		changeLog: z.array(z.string())
 	});
 }
 function ModuleSchema() {
 	return z.object({
 		__typename: z.literal("ModuleSpecification").optional(),
-		description: z.string().nullable(),
 		id: z.string(),
 		name: z.string(),
+		description: z.string().nullable(),
 		operations: z.array(OperationSpecificationSchema())
 	});
 }
@@ -338,24 +339,24 @@ function MoveOperationInputSchema() {
 function OperationSpecificationSchema() {
 	return z.object({
 		__typename: z.literal("OperationSpecification").optional(),
-		description: z.string().nullable(),
-		errors: z.array(OperationErrorSchema()),
-		examples: z.array(CodeExampleSchema()),
 		id: z.string(),
 		name: z.string().nullable(),
-		reducer: z.string().nullable(),
+		description: z.string().nullable(),
 		schema: z.string().nullable(),
 		template: z.string().nullable(),
+		reducer: z.string().nullable(),
+		errors: z.array(OperationErrorSchema()),
+		examples: z.array(CodeExampleSchema()),
 		scope: OperationScopeSchema()
 	});
 }
 function OperationErrorSchema() {
 	return z.object({
 		__typename: z.literal("OperationErrorSpecification").optional(),
-		code: z.string().nullable(),
-		description: z.string().nullable(),
 		id: z.string(),
 		name: z.string().nullable(),
+		code: z.string().nullable(),
+		description: z.string().nullable(),
 		template: z.string().nullable()
 	});
 }
@@ -497,15 +498,15 @@ function SetStateSchemaInputSchema() {
 function StateSchema() {
 	return z.object({
 		__typename: z.literal("State").optional(),
+		schema: z.string(),
 		examples: z.array(CodeExampleSchema()),
-		initialValue: z.string(),
-		schema: z.string()
+		initialValue: z.string()
 	});
 }
 function ScopeStateSchema() {
 	return z.object({
-		global: StateSchema(),
-		local: StateSchema()
+		local: StateSchema(),
+		global: StateSchema()
 	});
 }
 function UpdateChangeLogItemInputSchema() {
@@ -2563,16 +2564,16 @@ function baseReducer(document, action, customReducer, dispatch, options = {}) {
 			});
 		} catch (error) {
 			const actionScopeOps = newDocument.operations[_action.scope];
-			if (!actionScopeOps) throw new Error(`No operations found for scope: ${_action.scope}`);
+			if (!actionScopeOps) throw new Error(`No operations found for scope: ${_action.scope}`, { cause: error });
 			const lastOperationIndex = actionScopeOps.length - 1;
 			const draftScopeOps = draft.operations[_action.scope];
-			if (!draftScopeOps) throw new Error(`No operations found in draft for scope: ${_action.scope}`);
+			if (!draftScopeOps) throw new Error(`No operations found in draft for scope: ${_action.scope}`, { cause: error });
 			draftScopeOps[lastOperationIndex].error = error.message;
 			draftScopeOps[lastOperationIndex].skip = 0;
 			if (shouldProcessSkipOperation) {
 				draft.state = castDraft({ ...document.state });
 				const documentScopeOps = document.operations[_action.scope];
-				if (!documentScopeOps) throw new Error(`No operations found for scope: ${_action.scope}`);
+				if (!documentScopeOps) throw new Error(`No operations found for scope: ${_action.scope}`, { cause: error });
 				draft.operations = castDraft({
 					...document.operations,
 					[_action.scope]: [...documentScopeOps, { ...draftScopeOps[lastOperationIndex] }]
@@ -3237,18 +3238,50 @@ const documentModelReducer = createReducer(documentModelStateReducer);
 //#endregion
 //#region document-model/files.ts
 const NON_DOMAIN_SCOPES = new Set(["auth", "document"]);
-async function loadJSZip() {
-	const { default: JSZip } = await import("jszip");
-	return JSZip;
+function zipAsync(data) {
+	return new Promise((resolve, reject) => {
+		zip(data, (err, out) => err ? reject(err) : resolve(out));
+	});
+}
+function unzipAsync(data) {
+	return new Promise((resolve, reject) => {
+		unzip(data, (err, out) => err ? reject(err) : resolve(out));
+	});
+}
+const BASE64_RE = /^[A-Za-z0-9+/]+={0,2}$/;
+function isLikelyBase64(s) {
+	if (s.length === 0 || s.length % 4 !== 0) return false;
+	return BASE64_RE.test(s);
+}
+function binaryStringToUint8Array(s) {
+	const arr = new Uint8Array(s.length);
+	for (let i = 0; i < s.length; i++) arr[i] = s.charCodeAt(i) & 255;
+	return arr;
+}
+function base64ToUint8Array(s) {
+	if (typeof atob === "function") return binaryStringToUint8Array(atob(s));
+	const BufferCtor = globalThis.Buffer;
+	if (!BufferCtor) throw new Error("Cannot decode base64 string: neither `atob` nor `Buffer` is available in this environment");
+	return BufferCtor.from(s, "base64");
+}
+async function toUint8Array(input) {
+	if (input instanceof Uint8Array) return input;
+	if (input instanceof ArrayBuffer) return new Uint8Array(input);
+	if (typeof Blob !== "undefined" && input instanceof Blob) return new Uint8Array(await input.arrayBuffer());
+	if (Array.isArray(input)) return new Uint8Array(input);
+	if (typeof input === "string") return isLikelyBase64(input) ? base64ToUint8Array(input) : binaryStringToUint8Array(input);
+	throw new Error("Unsupported FileInput type");
+}
+function jsonEntry(value) {
+	return strToU8(JSON.stringify(value, null, 2));
 }
 async function createZip(document) {
-	const zip = new (await (loadJSZip()))();
-	const header = document.header;
-	zip.file("header.json", JSON.stringify(header, null, 2));
-	zip.file("state.json", JSON.stringify(document.initialState || {}, null, 2));
-	zip.file("current-state.json", JSON.stringify(document.state || {}, null, 2));
-	zip.file("operations.json", JSON.stringify(filterDocumentOperationsResultingState(document.operations), null, 2));
-	return zip;
+	return zipAsync({
+		"header.json": jsonEntry(document.header),
+		"state.json": jsonEntry(document.initialState || {}),
+		"current-state.json": jsonEntry(document.state || {}),
+		"operations.json": jsonEntry(filterDocumentOperationsResultingState(document.operations))
+	});
 }
 /**
 * Creates a minimal ZIP backup from strand data.
@@ -3256,7 +3289,6 @@ async function createZip(document) {
 * Creates a ZIP with minimal header and empty operations.
 */
 async function createMinimalZip(data) {
-	const JSZip = await loadJSZip();
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	const header = {
 		id: data.documentId,
@@ -3272,30 +3304,32 @@ async function createMinimalZip(data) {
 		revision: {},
 		lastModifiedAtUtcIso: now
 	};
-	const zip = new JSZip();
-	zip.file("header.json", JSON.stringify(header, null, 2));
-	zip.file("state.json", JSON.stringify(data.state, null, 2));
-	zip.file("current-state.json", JSON.stringify(data.state, null, 2));
-	zip.file("operations.json", JSON.stringify({}, null, 2));
-	return zip;
+	return zipAsync({
+		"header.json": jsonEntry(header),
+		"state.json": jsonEntry(data.state),
+		"current-state.json": jsonEntry(data.state),
+		"operations.json": jsonEntry({})
+	});
 }
 async function baseSaveToFileHandle(document, input) {
-	const blob = await (await createZip(document)).generateAsync({ type: "blob" });
+	const data = await createZip(document);
 	const writable = await input.createWritable();
-	await writable.write(blob);
+	await writable.write(new Uint8Array(data));
 	await writable.close();
 }
-async function loadFromZip(zip, reducer, options) {
-	const initialStateZip = zip.file("state.json");
-	if (!initialStateZip) throw new Error("Initial state not found");
-	const initialStateStr = await initialStateZip.async("string");
-	const initialState = JSON.parse(initialStateStr);
-	const headerZip = zip.file("header.json");
-	if (!headerZip) throw new Error("Document header not found - file format may be outdated");
-	const header = JSON.parse(await headerZip.async("string"));
-	const operationsZip = zip.file("operations.json");
-	if (!operationsZip) throw new Error("Operations history not found");
-	const clearedOperations = garbageCollectDocumentOperations(JSON.parse(await operationsZip.async("string")));
+function readEntry(files, name) {
+	const entry = files[name];
+	if (!entry) throw new Error(`${name} not found in document zip`);
+	return strFromU8(entry);
+}
+async function loadFromZipData(data, reducer, options) {
+	const files = await unzipAsync(data);
+	if (!files["state.json"]) throw new Error("Initial state not found");
+	const initialState = JSON.parse(readEntry(files, "state.json"));
+	if (!files["header.json"]) throw new Error("Document header not found - file format may be outdated");
+	const header = JSON.parse(readEntry(files, "header.json"));
+	if (!files["operations.json"]) throw new Error("Operations history not found");
+	const clearedOperations = garbageCollectDocumentOperations(JSON.parse(readEntry(files, "operations.json")));
 	const operationsError = validateOperations(clearedOperations);
 	if (operationsError.length) {
 		const errorMessages = operationsError.map((err) => err.message);
@@ -3307,9 +3341,7 @@ async function loadFromZip(zip, reducer, options) {
 	};
 }
 async function baseLoadFromInput(input, reducer, options) {
-	const zip = new (await (loadJSZip()))();
-	await zip.loadAsync(input);
-	return loadFromZip(zip, reducer, options);
+	return loadFromZipData(await toUint8Array(input), reducer, options);
 }
 const documentModelLoadFromInput = (input) => {
 	return baseLoadFromInput(input, documentModelReducer);