document-model 2.20.0 → 2.21.1

package/dist/src/document/utils/document-helpers.js

@@ -0,0 +1,410 @@
+import stringify from "safe-stable-stringify";
+export var IntegrityIssueType;
+(function (IntegrityIssueType) {
+    IntegrityIssueType["UNEXPECTED_INDEX"] = "UNEXPECTED_INDEX";
+})(IntegrityIssueType || (IntegrityIssueType = {}));
+export var IntegrityIssueSubType;
+(function (IntegrityIssueSubType) {
+    IntegrityIssueSubType["DUPLICATED_INDEX"] = "DUPLICATED_INDEX";
+    IntegrityIssueSubType["MISSING_INDEX"] = "MISSING_INDEX";
+})(IntegrityIssueSubType || (IntegrityIssueSubType = {}));
+export function checkCleanedOperationsIntegrity(sortedOperations) {
+    const result = [];
+    // 1:1 1
+    // 0:0 0 -> 1:0 1 -> 2:0 -> 3:0 -> 4:0 -> 5:0
+    // 0:0 0 -> 2:1 1 -> 3:0 -> 4:0 -> 5:0
+    // 0:0 0 -> 3:2 1 -> 4:0 -> 5:0
+    // 0:0 0 -> 3:2 1 -> 5:1
+    // 0:3 (expected 0, got -3)
+    // 1:2 (expected 0, got -1)
+    // 0:0 -> 1:1
+    // 0:0 -> 2:2
+    // 0:0 -> 3:2 -> 5:2
+    let currentIndex = -1;
+    for (const nextOperation of sortedOperations) {
+        const nextIndex = nextOperation.index - nextOperation.skip;
+        if (nextIndex !== currentIndex + 1) {
+            result.push({
+                operation: {
+                    index: nextOperation.index,
+                    skip: nextOperation.skip,
+                },
+                issue: IntegrityIssueType.UNEXPECTED_INDEX,
+                category: nextIndex > currentIndex + 1
+                    ? IntegrityIssueSubType.MISSING_INDEX
+                    : IntegrityIssueSubType.DUPLICATED_INDEX,
+                message: `Expected index ${currentIndex + 1} with skip 0 or equivalent, got index ${nextOperation.index} with skip ${nextOperation.skip}`,
+            });
+        }
+        currentIndex = nextOperation.index;
+    }
+    return result;
+}
+// [] -> []
+// [0:0] -> [0:0]
+// 0:0 1:0 2:0 => 0:0 1:0 2:0, removals 0, no issues
+// 0:0 1:1 2:0 => 1:1 2:0, removals 1, no issues
+// 0:0 1:1 2:0 3:1 => 1:1 3:1, removals 2, no issues
+// 0:0 1:1 2:0 3:3 => 3:3
+// 1:1 2:0 3:0 => 1:1 2:0 3:0, removals 0, no issues
+// 1:0 0:0 2:0 => 2:0, removals 2, issues [UNEXPECTED_INDEX, INDEX_OUT_OF_ORDER]
+// 0:0 1:0 2:0 => 0:0 1:0 2:0, removals 0, no issues
+// 0:0 1:0 2:0 => 0:0 1:0 2:0, removals 0, no issues
+// 0:0 1:0 2:0 => 0:0 1:0 2:0, removals 0, no issues
+export function garbageCollect(sortedOperations) {
+    const result = [];
+    let i = sortedOperations.length - 1;
+    while (i > -1) {
+        result.unshift(sortedOperations[i]);
+        const skipUntil = (sortedOperations[i]?.index || 0) - (sortedOperations[i]?.skip || 0) - 1;
+        let j = i - 1;
+        while (j > -1 && (sortedOperations[j]?.index || 0) > skipUntil) {
+            j--;
+        }
+        i = j;
+    }
+    return result;
+}
+export function addUndo(sortedOperations) {
+    const operationsCopy = [...sortedOperations];
+    const latestOperation = operationsCopy[operationsCopy.length - 1];
+    if (!latestOperation)
+        return operationsCopy;
+    if (latestOperation.type === "NOOP") {
+        operationsCopy.push({
+            ...latestOperation,
+            index: latestOperation.index,
+            type: "NOOP",
+            skip: nextSkipNumber(sortedOperations),
+        });
+    }
+    else {
+        operationsCopy.push({
+            type: "NOOP",
+            index: latestOperation.index + 1,
+            timestamp: new Date().toISOString(),
+            input: {},
+            skip: 1,
+            scope: latestOperation.scope,
+            hash: latestOperation.hash,
+        });
+    }
+    return operationsCopy;
+}
+// [0:0 2:0 1:0 3:3 3:1] => [0:0 1:0 2:0 3:1 3:3]
+// Sort by index _and_ skip number
+export function sortOperations(operations) {
+    return operations
+        .slice()
+        .sort((a, b) => a.skip - b.skip)
+        .sort((a, b) => a.index - b.index);
+}
+// [0:0, 1:0, 2:0, A3:0, A4:0, A5:0] + [0:0, 1:0, 2:0, B3:0, B4:2, B5:0]
+// GC               => [0:0, 1:0, 2:0, A3:0, A4:0, A5:0] + [0:0, 1:0, B4:2, B5:0]
+// Split            => [0:0, 1:0] + [2:0, A3:0, A4:0, A5:0] + [B4:2, B5:0]
+// Reshuffle(6:4)   => [6:4, 7:0, 8:0, 9:0, 10:0, 11:0]
+// merge            => [0:0, 1:0, 6:4, 7:0, 8:0, 9:0, 10:0, 11:0]
+export function reshuffleByTimestamp(startIndex, opsA, opsB) {
+    return [...opsA, ...opsB]
+        .sort((a, b) => new Date(a.timestamp || "").getTime() -
+        new Date(b.timestamp || "").getTime())
+        .map((op, i) => ({
+        ...op,
+        index: startIndex.index + i,
+        skip: i === 0 ? startIndex.skip : 0,
+    }));
+}
+export function reshuffleByTimestampAndIndex(startIndex, opsA, opsB) {
+    return [...opsA, ...opsB]
+        .sort((a, b) => new Date(a.timestamp || "").getTime() -
+        new Date(b.timestamp || "").getTime())
+        .sort((a, b) => a.index - b.index)
+        .map((op, i) => ({
+        ...op,
+        index: startIndex.index + i,
+        skip: i === 0 ? startIndex.skip : 0,
+    }));
+}
+// TODO: implement better operation equality function
+export function operationsAreEqual(op1, op2) {
+    return stringify(op1) === stringify(op2);
+}
+// [T0:0 T1:0 T2:0 T3:0] + [B4:0 B5:0] = [T0:0 T1:0 T2:0 T3:0 B4:0 B5:0]
+// [T0:0 T1:0 T2:0 T3:0] + [B3:0 B4:0] = [T0:0 T1:0 T2:0 B3:0 B4:0]
+// [T0:0 T1:0 T2:0 T3:0] + [B2:0 B3:0] = [T0:0 T1:0 B2:0 B3:0]
+// [T0:0 T1:0 T2:0 T3:0] + [B4:0 B4:2] = [T0:0 T1:0 T2:0 T3:0 B4:0 B4:2]
+// [T0:0 T1:0 T2:0 T3:0] + [B3:0 B3:2] = [T0:0 T1:0 T2:0 B3:0 B3:2]
+// [T0:0 T1:0 T2:0 T3:0] + [B2:3 B3:0] = [T0:0 T1:0 B2:3 B3:0]
+export function attachBranch(trunk, newBranch) {
+    const trunkCopy = garbageCollect(sortOperations(trunk.slice()));
+    const newOperations = garbageCollect(sortOperations(newBranch.slice()));
+    if (trunkCopy.length < 1) {
+        return [newOperations, []];
+    }
+    const result = [];
+    let enteredBranch = false;
+    while (newOperations.length > 0) {
+        const newOperationCandidate = newOperations[0];
+        let nextTrunkOperation = trunkCopy.shift();
+        while (nextTrunkOperation &&
+            precedes(nextTrunkOperation, newOperationCandidate)) {
+            result.push(nextTrunkOperation);
+            nextTrunkOperation = trunkCopy.shift();
+        }
+        if (!nextTrunkOperation) {
+            enteredBranch = true;
+        }
+        else if (!enteredBranch) {
+            if (operationsAreEqual(nextTrunkOperation, newOperationCandidate)) {
+                newOperations.shift();
+                result.push(nextTrunkOperation);
+            }
+            else {
+                trunkCopy.unshift(nextTrunkOperation);
+                enteredBranch = true;
+            }
+        }
+        if (enteredBranch) {
+            let nextAppend = newOperations.shift();
+            while (nextAppend) {
+                result.push(nextAppend);
+                nextAppend = newOperations.shift();
+            }
+        }
+    }
+    if (!enteredBranch) {
+        let nextAppend = trunkCopy.shift();
+        while (nextAppend) {
+            result.push(nextAppend);
+            nextAppend = trunkCopy.shift();
+        }
+    }
+    return [garbageCollect(result), trunkCopy];
+}
+export function precedes(op1, op2) {
+    return (op1.index < op2.index ||
+        (op1.index === op2.index && op1.id === op2.id && op1.skip < op2.skip));
+}
+export function split(sortedTargetOperations, sortedMergeOperations) {
+    const commonOperations = [];
+    const targetDiffOperations = [];
+    const mergeDiffOperations = [];
+    // get bigger array length
+    const maxLength = Math.max(sortedTargetOperations.length, sortedMergeOperations.length);
+    let splitHappened = false;
+    for (let i = 0; i < maxLength; i++) {
+        const targetOperation = sortedTargetOperations[i];
+        const mergeOperation = sortedMergeOperations[i];
+        if (targetOperation && mergeOperation) {
+            if (!splitHappened &&
+                operationsAreEqual(targetOperation, mergeOperation)) {
+                commonOperations.push(targetOperation);
+            }
+            else {
+                splitHappened = true;
+                targetDiffOperations.push(targetOperation);
+                mergeDiffOperations.push(mergeOperation);
+            }
+        }
+        else if (targetOperation) {
+            targetDiffOperations.push(targetOperation);
+        }
+        else if (mergeOperation) {
+            mergeDiffOperations.push(mergeOperation);
+        }
+    }
+    return [commonOperations, targetDiffOperations, mergeDiffOperations];
+}
+// [0:0, 1:0, 2:0, A3:0, A4:0, A5:0] + [0:0, 1:0, 2:0, B3:0, B4:2, B5:0]
+// GC               => [0:0, 1:0, 2:0, A3:0, A4:0, A5:0] + [0:0, 1:0, B4:2, B5:0]
+// Split            => [0:0, 1:0] + [2:0, A3:0, A4:0, A5:0] + [B4:2, B5:0]
+// Reshuffle(6:4)   => [6:4, 7:0, 8:0, 9:0, 10:0, 11:0]
+// merge            => [0:0, 1:0, 6:4, 7:0, 8:0, 9:0, 10:0, 11:0]
+export function merge(sortedTargetOperations, sortedMergeOperations, reshuffle) {
+    const [_commonOperations, _targetOperations, _mergeOperations] = split(garbageCollect(sortedTargetOperations), garbageCollect(sortedMergeOperations));
+    const maxCommonIndex = getMaxIndex(_commonOperations);
+    const nextIndex = 1 +
+        Math.max(maxCommonIndex, getMaxIndex(_targetOperations), getMaxIndex(_mergeOperations));
+    const filteredMergeOperations = filterDuplicatedOperations(_mergeOperations, _targetOperations);
+    const newOperationHistory = reshuffle({
+        index: nextIndex,
+        skip: nextIndex - (maxCommonIndex + 1),
+    }, _targetOperations, filteredMergeOperations);
+    return _commonOperations.concat(newOperationHistory);
+}
+function getMaxIndex(sortedOperations) {
+    const lastElement = sortedOperations[sortedOperations.length - 1];
+    if (!lastElement) {
+        return -1;
+    }
+    return lastElement.index;
+}
+// [] => -1
+// [0:0] => -1
+// [0:0 1:0] => 1
+// [0:0 1:1] => -1
+// [1:1] => -1
+// [0:0 1:0 2:0] => 1
+// [0:0 1:0 2:0 2:1] => 2
+// [0:0 1:0 2:0 2:1 2:2] => -1
+// [0:0 1:1 2:0] => 2
+// [0:0 1:1 2:2] => -1
+// [0:0 1:1 2:0 3:0] => 1
+// [0:0 1:1 2:0 3:1] => 3
+// [0:0 1:1 2:0 3:3] => -1
+// [50:50 100:50 150:50 151:0 152:0 153:0 154:3] => 53
+export function nextSkipNumber(sortedOperations) {
+    if (sortedOperations.length < 1) {
+        return -1;
+    }
+    const cleanedOperations = garbageCollect(sortedOperations);
+    let nextSkip = (cleanedOperations[cleanedOperations.length - 1]?.skip || 0) + 1;
+    if (cleanedOperations.length > 1) {
+        nextSkip += cleanedOperations[cleanedOperations.length - 2]?.skip || 0;
+    }
+    return (cleanedOperations[cleanedOperations.length - 1]?.index || -1) <
+        nextSkip
+        ? -1
+        : nextSkip;
+}
+export function checkOperationsIntegrity(operations) {
+    return checkCleanedOperationsIntegrity(garbageCollect(sortOperations(operations)));
+}
+export function groupOperationsByScope(operations) {
+    const result = operations.reduce((acc, operation) => {
+        if (!acc[operation.scope]) {
+            acc[operation.scope] = [];
+        }
+        acc[operation.scope]?.push(operation);
+        return acc;
+    }, {});
+    return result;
+}
+export function prepareOperations(operationsHistory, newOperations) {
+    const result = {
+        integrityIssues: [],
+        validOperations: [],
+        invalidOperations: [],
+        duplicatedOperations: [],
+    };
+    const sortedOperationsHistory = sortOperations(operationsHistory);
+    const sortedOperations = sortOperations(newOperations);
+    const integrityErrors = checkCleanedOperationsIntegrity([
+        ...sortedOperationsHistory,
+        ...sortedOperations,
+    ]);
+    const missingIndexErrors = integrityErrors.filter((integrityIssue) => integrityIssue.category === IntegrityIssueSubType.MISSING_INDEX);
+    // get the integrity error with the lowest index operation
+    const firstMissingIndexOperation = [...missingIndexErrors]
+        .sort((a, b) => b.operation.index - a.operation.index)
+        .pop()?.operation;
+    for (const newOperation of sortedOperations) {
+        // Operation is missing index or it follows an operation that is missing index
+        if (firstMissingIndexOperation &&
+            newOperation.index >= firstMissingIndexOperation.index) {
+            result.invalidOperations.push(newOperation);
+            continue;
+        }
+        // check if operation is duplicated
+        const isDuplicatedOperation = integrityErrors.some((integrityError) => {
+            return (integrityError.operation.index === newOperation.index &&
+                integrityError.operation.skip === newOperation.skip &&
+                integrityError.category === IntegrityIssueSubType.DUPLICATED_INDEX);
+        });
+        // add to duplicated operations if it is duplicated
+        if (isDuplicatedOperation) {
+            result.duplicatedOperations.push(newOperation);
+            continue;
+        }
+        // otherwise, add to valid operations
+        result.validOperations.push(newOperation);
+    }
+    result.integrityIssues.push(...integrityErrors);
+    return result;
+}
+export function removeExistingOperations(newOperations, operationsHistory) {
+    return newOperations.filter((newOperation) => {
+        return !operationsHistory.some((historyOperation) => {
+            return ((newOperation.type === "NOOP" &&
+                newOperation.skip === 0 &&
+                newOperation.index === historyOperation.index) ||
+                (newOperation.index === historyOperation.index &&
+                    newOperation.skip === historyOperation.skip &&
+                    newOperation.scope === historyOperation.scope &&
+                    newOperation.hash === historyOperation.hash &&
+                    newOperation.type === historyOperation.type));
+        });
+    });
+}
+/**
+ * Skips header operations and returns the remaining operations.
+ *
+ * @param operations - The array of operations.
+ * @param skipHeaderOperation - The skip header operation index.
+ * @returns The remaining operations after skipping header operations.
+ */
+export function skipHeaderOperations(operations, skipHeaderOperation) {
+    const lastOperation = sortOperations(operations).at(-1);
+    const lastIndex = lastOperation?.index ?? -1;
+    const nextIndex = lastIndex + 1;
+    const skipOperationIndex = {
+        ...skipHeaderOperation,
+        index: skipHeaderOperation.index ?? nextIndex,
+    };
+    if (skipOperationIndex.index < lastIndex) {
+        throw new Error(`The skip header operation index must be greater than or equal to ${lastIndex}`);
+    }
+    const clearedOperations = garbageCollect(sortOperations([...operations, skipOperationIndex]));
+    return clearedOperations.slice(0, -1); //clearedOperation ? [clearedOperation as TOpIndex] : [];
+}
+export function garbageCollectDocumentOperations(documentOperations) {
+    const clearedOperations = Object.entries(documentOperations).reduce((acc, entry) => {
+        const [scope, ops] = entry;
+        return {
+            ...acc,
+            [scope]: garbageCollect(sortOperations(ops)),
+        };
+    }, {});
+    return clearedOperations;
+}
+/**
+ * Filters out duplicated operations from the target operations array based on their IDs.
+ * If an operation has an ID, it is considered duplicated if there is another operation in the source operations array with the same ID.
+ * If an operation does not have an ID, it is considered unique and will not be filtered out.
+ * @param targetOperations - The array of target operations to filter.
+ * @param sourceOperations - The array of source operations to compare against.
+ * @returns An array of operations with duplicates filtered out.
+ */
+export function filterDuplicatedOperations(targetOperations, sourceOperations) {
+    return targetOperations.filter((op) => {
+        if (op.id) {
+            return !sourceOperations.some((targetOp) => targetOp.id === op.id);
+        }
+        return true;
+    });
+}
+export function filterDocumentOperationsResultingState(documentOperations) {
+    if (!documentOperations) {
+        return {};
+    }
+    const entries = Object.entries(documentOperations);
+    return entries.reduce((acc, [scope, operations]) => ({
+        ...acc,
+        [scope]: operations.map((op) => {
+            const { resultingState, ...restProps } = op;
+            return restProps;
+        }),
+    }), {});
+}
+/**
+ * Calculates the difference between two arrays of operations.
+ * Returns an array of operations that are present in `clearedOperationsA` but not in `clearedOperationsB`.
+ *
+ * @template TOp - The type of the operations.
+ * @param {TOp[]} clearedOperationsA - The first array of operations.
+ * @param {TOp[]} clearedOperationsB - The second array of operations.
+ * @returns {TOp[]} - The difference between the two arrays of operations.
+ */
+export function diffOperations(clearedOperationsA, clearedOperationsB) {
+    return clearedOperationsA.filter((operationA) => !clearedOperationsB.some((operationB) => operationA.index === operationB.index));
+}

package/dist/{browser/src → src}/document/utils/errors.d.ts

@@ -1,4 +1,4 @@
-import { ZodIssue } from 'zod';
+import { ZodIssue } from "zod";
 export declare class InvalidActionInputError extends Error {
     data: unknown;
     constructor(data: unknown);

package/dist/src/document/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/document/utils/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAE/B,qBAAa,uBAAwB,SAAQ,KAAK;IACzC,IAAI,EAAE,OAAO,CAAC;gBACT,IAAI,EAAE,OAAO;CAO1B;AAED,qBAAa,0BAA2B,SAAQ,uBAAuB;IAC9D,MAAM,EAAE,QAAQ,EAAE,CAAC;gBAEd,MAAM,EAAE,QAAQ,EAAE;CAK/B"}

package/dist/src/document/utils/errors.js

@@ -0,0 +1,18 @@
+export class InvalidActionInputError extends Error {
+    data;
+    constructor(data) {
+        super();
+        this.name = "InvalidActionInputError";
+        this.data = data;
+        this.message =
+            this.message || `Invalid action input: ${JSON.stringify(data, null, 2)}`;
+    }
+}
+export class InvalidActionInputZodError extends InvalidActionInputError {
+    issues;
+    constructor(issues) {
+        super(issues);
+        this.issues = issues;
+        this.name = "InvalidActionInputZodError";
+    }
+}

package/dist/{browser/src → src}/document/utils/file.d.ts

@@ -1,8 +1,9 @@
-import { default as JSZip } from 'jszip';
-import { Action, AttachmentInput, Document, Reducer } from '../types';
-import { ReplayDocumentOptions } from './base';
+import { Reducer } from "#document/types.js";
+import JSZip from "jszip";
+import { AttachmentInput, PHDocument } from "../types.js";
+import { ReplayDocumentOptions } from "./base.js";
 export type FileInput = string | number[] | Uint8Array | ArrayBuffer | Blob;
-export declare const createZip: (document: Document) => Promise<JSZip>;
+export declare function createZip(document: PHDocument): JSZip;
 /**
  * Saves a document to a ZIP file.
  *
@@ -15,8 +16,8 @@ export declare const createZip: (document: Document) => Promise<JSZip>;
  * @param extension - The extension to use for the file.
  * @returns A promise that resolves to the path of the saved file.
  */
-export declare const saveToFile: (document: Document, path: string, extension: string, name?: string) => Promise<string>;
-export declare const saveToFileHandle: (document: Document, input: FileSystemFileHandle) => Promise<void>;
+export declare function baseSaveToFile(document: PHDocument, path: string, extension: string, name?: string): Promise<string>;
+export declare function baseSaveToFileHandle(document: PHDocument, input: FileSystemFileHandle): Promise<void>;
 /**
  * Loads a document from a ZIP file.
  *
@@ -32,8 +33,8 @@ export declare const saveToFileHandle: (document: Document, input: FileSystemFil
  * @returns A promise that resolves to the document state after applying all the operations.
  * @throws An error if the initial state or the operations history is not found in the ZIP file.
  */
-export declare const loadFromFile: <S, A extends Action, L>(path: string, reducer: Reducer<S, A, L>, options?: ReplayDocumentOptions) => Promise<Document<S, A, L>>;
-export declare const loadFromInput: <S, A extends Action, L>(input: FileInput, reducer: Reducer<S, A, L>, options?: ReplayDocumentOptions) => Promise<Document<S, A, L>>;
+export declare function baseLoadFromFile<TDocument extends PHDocument>(path: string, reducer: Reducer<TDocument>, options?: ReplayDocumentOptions): Promise<TDocument>;
+export declare function baseLoadFromInput<TDocument extends PHDocument>(input: FileInput, reducer: Reducer<TDocument>, options?: ReplayDocumentOptions): Promise<TDocument>;
 /**
  * Fetches an attachment from a URL and returns its base64-encoded data and MIME type.
  * @param url - The URL of the attachment to fetch.

package/dist/src/document/utils/file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.d.ts","sourceRoot":"","sources":["../../../../src/document/utils/file.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAExE,OAAO,KAAK,MAAM,OAAO,CAAC;AAE1B,OAAO,EAEL,eAAe,EAGf,UAAU,EACX,MAAM,aAAa,CAAC;AACrB,OAAO,EAAkB,qBAAqB,EAAE,MAAM,WAAW,CAAC;AAOlE,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,MAAM,EAAE,GAAG,UAAU,GAAG,WAAW,GAAG,IAAI,CAAC;AAE5E,wBAAgB,SAAS,CAAC,QAAQ,EAAE,UAAU,SAuC7C;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAClC,QAAQ,EAAE,UAAU,EACpB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,MAAM,mBAgBd;AAED,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,UAAU,EACpB,KAAK,EAAE,oBAAoB,iBAO5B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,gBAAgB,CAAC,SAAS,SAAS,UAAU,EACjE,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,EAC3B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,SAAS,CAAC,CAGpB;AAED,wBAAsB,iBAAiB,CAAC,SAAS,SAAS,UAAU,EAClE,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,OAAO,CAAC,SAAS,CAAC,EAC3B,OAAO,CAAC,EAAE,qBAAqB,GAC9B,OAAO,CAAC,SAAS,CAAC,CAIpB;AAgED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAWzE;AAED;;;;GAIG;AACH,wBAAsB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC,CAMzE"}

package/dist/src/document/utils/file.js

@@ -0,0 +1,155 @@
+import { fetchFile, getFile, hash, readFile, writeFile } from "#utils/env";
+import JSZip from "jszip";
+import mime from "mime/lite";
+import { replayDocument } from "./base.js";
+import { filterDocumentOperationsResultingState, garbageCollectDocumentOperations, } from "./document-helpers.js";
+import { validateOperations } from "./validation.js";
+export function createZip(document) {
+    // create zip file
+    const zip = new JSZip();
+    const { name, revision, documentType, created, lastModified } = document;
+    const header = {
+        name,
+        revision,
+        documentType,
+        created,
+        lastModified,
+    };
+    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));
+    if (document.attachments) {
+        const attachments = Object.keys(document.attachments);
+        attachments.forEach((key) => {
+            const { data, ...attributes } = document.attachments?.[key] ?? {};
+            if (data) {
+                zip.file(key, data, {
+                    base64: true,
+                    createFolders: true,
+                    comment: JSON.stringify(attributes),
+                });
+            }
+        });
+    }
+    return zip;
+}
+/**
+ * Saves a document to a ZIP file.
+ *
+ * @remarks
+ * This function creates a ZIP file containing the document's state, operations,
+ * and file attachments. The file is saved to the specified path.
+ *
+ * @param document - The document to save to the file.
+ * @param path - The path to save the file to.
+ * @param extension - The extension to use for the file.
+ * @returns A promise that resolves to the path of the saved file.
+ */
+export async function baseSaveToFile(document, path, extension, name) {
+    // create zip file
+    const zip = createZip(document);
+    const file = await zip.generateAsync({
+        type: "uint8array",
+        streamFiles: true,
+    });
+    const fileName = name ?? document.name;
+    const fileExtension = `.${extension}.zip`;
+    return writeFile(path, fileName.endsWith(fileExtension) ? fileName : `${fileName}${fileExtension}`, file);
+}
+export async function baseSaveToFileHandle(document, input) {
+    const zip = createZip(document);
+    const blob = await zip.generateAsync({ type: "blob" });
+    const writable = await input.createWritable();
+    await writable.write(blob);
+    await writable.close();
+}
+/**
+ * Loads a document from a ZIP file.
+ *
+ * @remarks
+ * This function reads a ZIP file and returns the document state after
+ * applying all the operations. The reducer is used to apply the operations.
+ *
+ * @typeParam S - The type of the state object.
+ * @typeParam A - The type of the actions that can be applied to the state object.
+ *
+ * @param path - The path to the ZIP file.
+ * @param reducer - The reducer to apply the operations to the state object.
+ * @returns A promise that resolves to the document state after applying all the operations.
+ * @throws An error if the initial state or the operations history is not found in the ZIP file.
+ */
+export async function baseLoadFromFile(path, reducer, options) {
+    const file = readFile(path);
+    return baseLoadFromInput(file, reducer, options);
+}
+export async function baseLoadFromInput(input, reducer, options) {
+    const zip = new JSZip();
+    await zip.loadAsync(input);
+    return loadFromZip(zip, reducer, options);
+}
+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");
+    let header = undefined;
+    if (headerZip) {
+        header = JSON.parse(await headerZip.async("string"));
+    }
+    const operationsZip = zip.file("operations.json");
+    if (!operationsZip) {
+        throw new Error("Operations history not found");
+    }
+    const operations = JSON.parse(await operationsZip.async("string"));
+    const clearedOperations = garbageCollectDocumentOperations(operations);
+    const operationsError = validateOperations(clearedOperations);
+    if (operationsError.length) {
+        const errorMessages = operationsError.map((err) => err.message);
+        throw new Error(errorMessages.join("\n"));
+    }
+    let result = replayDocument(initialState, clearedOperations, reducer, undefined, header, {}, options);
+    if (header) {
+        result = {
+            ...result,
+            ...header,
+        };
+    }
+    return result;
+}
+function getFileAttributes(file) {
+    const extension = file.replace(/^.*\./, "") || undefined;
+    const fileName = file.replace(/^.*[/\\]/, "") || undefined;
+    return { extension, fileName };
+}
+/**
+ * Fetches an attachment from a URL and returns its base64-encoded data and MIME type.
+ * @param url - The URL of the attachment to fetch.
+ * @returns A Promise that resolves to an object containing the base64-encoded data and MIME type of the attachment.
+ */
+export async function getRemoteFile(url) {
+    const { buffer, mimeType = "application/octet-stream" } = await fetchFile(url);
+    const attributes = getFileAttributes(url);
+    const data = buffer.toString("base64");
+    return {
+        data,
+        hash: hash(data),
+        mimeType,
+        ...attributes,
+    };
+}
+/**
+ * Reads an attachment from a file and returns its base64-encoded data and MIME type.
+ * @param path - The path of the attachment file to read.
+ * @returns A Promise that resolves to an object containing the base64-encoded data and MIME type of the attachment.
+ */
+export async function getLocalFile(path) {
+    const buffer = await getFile(path);
+    const mimeType = mime.getType(path) || "application/octet-stream";
+    const attributes = getFileAttributes(path);
+    const data = buffer.toString("base64");
+    return { data, hash: hash(data), mimeType, ...attributes };
+}

package/dist/{browser/src → src}/document/utils/node.d.ts

@@ -1,4 +1,4 @@
-import { default as crypto, RandomUUIDOptions } from 'node:crypto';
+import { BinaryLike, RandomUUIDOptions } from "node:crypto";
 export declare function generateUUID(options?: RandomUUIDOptions): `${string}-${string}-${string}-${string}-${string}`;
 export declare function writeFile(path: string, name: string, data: Uint8Array): Promise<string>;
 export declare function readFile(path: string): Buffer<ArrayBufferLike>;
@@ -7,5 +7,5 @@ export declare function fetchFile(url: string): Promise<{
     mimeType?: string;
 }>;
 export declare const getFile: (file: string) => Promise<Buffer<ArrayBufferLike>>;
-export declare const hash: (data: crypto.BinaryLike, algorithm?: string) => string;
+export declare const hash: (data: BinaryLike, algorithm?: string) => string;
 //# sourceMappingURL=node.d.ts.map

package/dist/src/document/utils/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../../../src/document/utils/node.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,UAAU,EACV,iBAAiB,EAGlB,MAAM,aAAa,CAAC;AAKrB,wBAAgB,YAAY,CAAC,OAAO,CAAC,EAAE,iBAAiB,uDAEvD;AAED,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,MAAM,CAAC,CAkBjB;AAED,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,2BAEpC;AAED,wBAAgB,SAAS,CACvB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAkBhD;AAED,eAAO,MAAM,OAAO,SAAgB,MAAM,qCAEzC,CAAC;AAEF,eAAO,MAAM,IAAI,SAAU,UAAU,+BAEpC,CAAC"}