document-model 1.0.55 → 1.1.0-debug.1

package/dist/browser/es/src/document/utils/base.js

@@ -0,0 +1,220 @@
+import "../../../node_modules/.pnpm/safe-stable-stringify@2.4.3/node_modules/safe-stable-stringify/esm/wrapper.js";
+import { baseReducer } from "../reducer.js";
+import { hash } from "../../../_virtual/browser.js";
+import { NOOP, UNDO, REDO, SET_NAME, PRUNE, LOAD_STATE } from "../actions/types.js";
+import { castImmutable, freeze } from "immer";
+import cjsModule from "../../../node_modules/.pnpm/safe-stable-stringify@2.4.3/node_modules/safe-stable-stringify/index.js";
+function isNoopOperation(op) {
+  return op.type === NOOP && op.skip !== void 0 && op.skip > 0 && op.hash !== void 0;
+}
+function isUndoRedo(action) {
+  return [UNDO, REDO].includes(action.type);
+}
+function isBaseAction(action) {
+  return [SET_NAME, UNDO, REDO, PRUNE, LOAD_STATE].includes(action.type);
+}
+function createAction(type, input, attachments, validator, scope = "global") {
+  if (!type) {
+    throw new Error("Empty action type");
+  }
+  if (typeof type !== "string") {
+    throw new Error(`Invalid action type: ${JSON.stringify(type)}`);
+  }
+  const action = { type, input, scope };
+  if (attachments) {
+    action.attachments = attachments;
+  }
+  try {
+    validator == null ? void 0 : validator().parse(action.input);
+  } catch (error) {
+    throw new Error(`Invalid action input: ${error}`);
+  }
+  return action;
+}
+function createReducer(reducer, documentReducer = baseReducer) {
+  return (document, action, dispatch, options) => {
+    return documentReducer(document, action, reducer, dispatch, options);
+  };
+}
+const createExtendedState = (initialState, createState) => {
+  return {
+    name: "",
+    documentType: "",
+    revision: {
+      global: 0,
+      local: 0
+    },
+    created: (/* @__PURE__ */ new Date()).toISOString(),
+    lastModified: (/* @__PURE__ */ new Date()).toISOString(),
+    attachments: {},
+    ...initialState,
+    state: (createState == null ? void 0 : createState(initialState == null ? void 0 : initialState.state)) ?? ((initialState == null ? void 0 : initialState.state) ?? { global: {}, local: {} })
+  };
+};
+const createDocument = (initialState, createState) => {
+  const state = createExtendedState(
+    initialState,
+    createState
+  );
+  return {
+    ...state,
+    initialState: state,
+    operations: { global: [], local: [] },
+    clipboard: []
+  };
+};
+const hashDocument = (document, scope = "global") => {
+  return hash(cjsModule(document.state[scope] || ""));
+};
+const hashKey = (date, randomLimit = 1e3) => {
+  const random = Math.random() * randomLimit;
+  return hash(`${(date ?? /* @__PURE__ */ new Date()).toISOString()}${random}`);
+};
+function readOnly(value) {
+  return castImmutable(freeze(value, true));
+}
+function mapSkippedOperations(operations, skippedHeadOperations) {
+  const ops = [...operations];
+  let skipped = skippedHeadOperations || 0;
+  let latestOpIndex = ops.length > 0 ? ops[ops.length - 1].index : 0;
+  const scopeOpsWithIgnore = [];
+  for (const operation of ops.reverse()) {
+    if (skipped > 0) {
+      const operationsDiff = latestOpIndex - operation.index;
+      skipped -= operationsDiff;
+    }
+    if (skipped < 0) {
+      throw new Error("Invalid operation index, missing operations");
+    }
+    const mappedOp = {
+      ignore: skipped > 0,
+      operation
+    };
+    const operationSkip = operation.skip > 0 ? operation.skip + 1 : 0;
+    if (operationSkip > 0 && operationSkip > skipped) {
+      const skipDiff = operationSkip - skipped;
+      skipped = skipped + skipDiff;
+    }
+    latestOpIndex = operation.index;
+    scopeOpsWithIgnore.push(mappedOp);
+  }
+  return scopeOpsWithIgnore.reverse();
+}
+function calculateSkipsLeft(operations, currentIndex, skip) {
+  const sortedOperations = operations.slice().sort((a, b) => a.skip - b.skip).sort((a, b) => a.index - b.index);
+  let skipsLeft = skip;
+  let skipsToPerform = 0;
+  let lastIndex = currentIndex;
+  for (const operation of sortedOperations.reverse()) {
+    const distance = lastIndex - operation.index;
+    skipsLeft = skipsLeft - distance;
+    if (skipsLeft > -1) {
+      skipsToPerform++;
+      lastIndex = operation.index;
+    } else {
+      break;
+    }
+  }
+  return skipsToPerform;
+}
+function sortOperations(operations) {
+  return Object.values(operations).flatMap((array) => array).sort(
+    (a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime()
+  );
+}
+function sortMappedOperations(operations) {
+  return Object.values(operations).flatMap((array) => array).sort(
+    (a, b) => new Date(a.operation.timestamp).getTime() - new Date(b.operation.timestamp).getTime()
+  );
+}
+function replayOperations(initialState, clearedOperations, reducer, dispatch, header, documentReducer = baseReducer, skipHeaderOperations = {}, options) {
+  const wrappedReducer = createReducer(reducer, documentReducer);
+  return replayDocument(
+    initialState,
+    clearedOperations,
+    wrappedReducer,
+    dispatch,
+    header,
+    skipHeaderOperations,
+    options
+  );
+}
+function replayDocument(initialState, operations, reducer, dispatch, header, skipHeaderOperations = {}, options) {
+  const checkHashes = (options == null ? void 0 : options.checkHashes) ?? true;
+  const document = createDocument(initialState);
+  const flatOperations = Object.values(operations).flat();
+  const result = flatOperations.reduce((document2, operation) => {
+    const doc = reducer(document2, operation, dispatch, {
+      skip: operation.skip,
+      ignoreSkipOperations: true,
+      reuseHash: !checkHashes
+    });
+    return doc;
+  }, document);
+  if (!checkHashes) {
+    for (const scope of Object.keys(result.state)) {
+      for (let i = flatOperations.length - 1; i >= 0; i--) {
+        const operation = flatOperations[i];
+        if (operation.scope !== scope) {
+          continue;
+        }
+        if (operation.hash !== hashDocument(result, scope)) {
+          throw new Error(`Hash mismatch for scope ${scope}`);
+        } else {
+          break;
+        }
+      }
+    }
+  }
+  const resultOperations = Object.keys(
+    result.operations
+  ).reduce(
+    (acc, key) => {
+      const scope = key;
+      return {
+        ...acc,
+        [scope]: [
+          ...result.operations[scope].map((operation, index) => {
+            var _a;
+            return {
+              ...operation,
+              timestamp: ((_a = operations[scope][index]) == null ? void 0 : _a.timestamp) ?? operation.timestamp
+            };
+          })
+        ]
+      };
+    },
+    { global: [], local: [] }
+  );
+  const lastModified = Object.values(resultOperations).reduce((acc, curr) => {
+    const operation = curr[curr.length - 1];
+    if ((operation == null ? void 0 : operation.timestamp) > acc) {
+      acc = operation.timestamp;
+    }
+    return acc;
+  }, initialState.lastModified);
+  return { ...result, operations: resultOperations, lastModified };
+}
+function isSameDocument(documentA, documentB) {
+  return cjsModule(documentA) === cjsModule(documentB);
+}
+export {
+  calculateSkipsLeft,
+  createAction,
+  createDocument,
+  createExtendedState,
+  createReducer,
+  hashDocument,
+  hashKey,
+  isBaseAction,
+  isNoopOperation,
+  isSameDocument,
+  isUndoRedo,
+  mapSkippedOperations,
+  readOnly,
+  replayDocument,
+  replayOperations,
+  sortMappedOperations,
+  sortOperations
+};
+//# sourceMappingURL=base.js.map

package/dist/browser/es/src/document/utils/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sources":["../../../../../../src/document/utils/base.ts"],"sourcesContent":["import stringifyJson from 'safe-stable-stringify';\nimport { baseReducer } from '../reducer';\nimport {\n    Action,\n    BaseAction,\n    UndoRedoAction,\n    Document,\n    ExtendedState,\n    ImmutableStateReducer,\n    Reducer,\n    Immutable,\n    OperationScope,\n    State,\n    CreateState,\n    PartialState,\n    DocumentOperations,\n    DocumentHeader,\n    DocumentOperationsIgnoreMap,\n    Operation,\n    MappedOperation,\n} from '../types';\nimport { hash } from './node';\nimport {\n    LOAD_STATE,\n    PRUNE,\n    REDO,\n    SET_NAME,\n    UNDO,\n    NOOP,\n} from '../actions/types';\nimport { castImmutable, freeze } from 'immer';\nimport { SignalDispatch } from '../signal';\n\nexport function isNoopOperation(op: Partial<Operation>): boolean {\n    return (\n        op.type === NOOP &&\n        op.skip !== undefined &&\n        op.skip > 0 &&\n        op.hash !== undefined\n    );\n}\n\nexport function isUndoRedo(action: Action): action is UndoRedoAction {\n    return [UNDO, REDO].includes(action.type);\n}\n\nexport function isBaseAction(action: Action): action is BaseAction {\n    return [SET_NAME, UNDO, REDO, PRUNE, LOAD_STATE].includes(action.type);\n}\n\n/**\n * Helper function to be used by action creators.\n *\n * @remarks\n * Creates an action with the given type and input properties. The input\n * properties default to an empty object.\n *\n * @typeParam A - Type of the action to be returned.\n *\n * @param type - The type of the action.\n * @param input - The input properties of the action.\n * @param attachments - The attachments included in the action.\n * @param validator - The validator to use for the input properties.\n * @param scope - The scope of the action, can either be 'global' or 'local'.\n * @param skip - The number of operations to skip before this new action is applied.\n *\n * @throws Error if the type is empty or not a string.\n *\n * @returns The new action.\n */\nexport function createAction<A extends Action>(\n    type: A['type'],\n    input?: A['input'],\n    attachments?: Action['attachments'],\n    validator?: () => { parse(v: unknown): A['input'] },\n    scope: OperationScope = 'global',\n): A {\n    if (!type) {\n        throw new Error('Empty action type');\n    }\n\n    if (typeof type !== 'string') {\n        throw new Error(`Invalid action type: ${JSON.stringify(type)}`);\n    }\n\n    const action: Action = { type, input, scope };\n\n    if (attachments) {\n        action.attachments = attachments;\n    }\n\n    try {\n        validator?.().parse(action.input);\n    } catch (error) {\n        throw new Error(`Invalid action input: ${error}`);\n    }\n\n    return action as A;\n}\n\n/**\n * Helper function to create a document model reducer.\n *\n * @remarks\n * This function creates a new reducer that wraps the provided `reducer` with\n * `documentReducer`, adding support for document actions:\n *   - `SET_NAME`\n *   - `UNDO`\n *   - `REDO`\n *   - `PRUNE`\n *\n * It also updates the document-related attributes on every operation.\n *\n * @param reducer - The custom reducer to wrap.\n * @param documentReducer - The document reducer to use.\n *\n * @returns The new reducer.\n */\nexport function createReducer<\n    S = unknown,\n    A extends Action = Action,\n    L = unknown,\n>(\n    reducer: ImmutableStateReducer<S, A, L>,\n    documentReducer = baseReducer,\n): Reducer<S, A, L> {\n    return (document, action, dispatch, options) => {\n        return documentReducer(document, action, reducer, dispatch, options);\n    };\n}\n\nexport const createExtendedState = <S, L>(\n    initialState?: Partial<ExtendedState<PartialState<S>, PartialState<L>>>,\n    createState?: CreateState<S, L>,\n): ExtendedState<S, L> => {\n    return {\n        name: '',\n        documentType: '',\n        revision: {\n            global: 0,\n            local: 0,\n        },\n        created: new Date().toISOString(),\n        lastModified: new Date().toISOString(),\n        attachments: {},\n        ...initialState,\n        state:\n            createState?.(initialState?.state) ??\n            ((initialState?.state ?? { global: {}, local: {} }) as State<S, L>),\n    };\n};\n\n/**\n * Builds the initial document state from the provided data.\n *\n * @typeParam T - The type of the data.\n * @typeParam A - The type of the actions.\n *\n * @param initialState - The initial state of the document. The `data` property\n *   is required, but all other properties are optional.\n *\n * @returns The new document state.\n */\nexport const createDocument = <S, A extends Action, L = unknown>(\n    initialState?: Partial<ExtendedState<PartialState<S>, PartialState<L>>>,\n    createState?: (\n        state?: Partial<State<PartialState<S>, PartialState<L>>>,\n    ) => State<S, L>,\n): Document<S, A, L> => {\n    const state: ExtendedState<S, L> = createExtendedState(\n        initialState,\n        createState,\n    );\n    return {\n        ...state,\n        initialState: state,\n        operations: { global: [], local: [] },\n        clipboard: [],\n    };\n};\n\nexport const hashDocument = (\n    document: Pick<Document, 'state'>,\n    scope: OperationScope = 'global',\n) => {\n    return hash(stringifyJson(document.state[scope] || ''));\n};\n\nexport const hashKey = (date?: Date, randomLimit = 1000) => {\n    const random = Math.random() * randomLimit;\n    return hash(`${(date ?? new Date()).toISOString()}${random}`);\n};\n\nexport function readOnly<T>(value: T): Immutable<T> {\n    return castImmutable(freeze(value, true));\n}\n\n/**\n * Maps skipped operations in an array of operations.\n * Skipped operations are operations that are ignored during processing.\n * @param operations - The array of operations to map.\n * @param skippedHeadOperations - The number of operations to skip at the head of the array of operations.\n * @returns An array of mapped operations with ignore flag indicating if the operation is skipped.\n * @throws Error if the operation index is invalid and there are missing operations.\n */\nexport function mapSkippedOperations<A extends Action>(\n    operations: Operation<BaseAction | A>[],\n    skippedHeadOperations?: number,\n): MappedOperation<A>[] {\n    const ops = [...operations];\n\n    let skipped = skippedHeadOperations || 0;\n    let latestOpIndex = ops.length > 0 ? ops[ops.length - 1].index : 0;\n\n    const scopeOpsWithIgnore = [] as MappedOperation<A>[];\n\n    for (const operation of ops.reverse()) {\n        if (skipped > 0) {\n            const operationsDiff = latestOpIndex - operation.index;\n            skipped -= operationsDiff;\n        }\n\n        if (skipped < 0) {\n            throw new Error('Invalid operation index, missing operations');\n        }\n\n        const mappedOp = {\n            ignore: skipped > 0,\n            operation,\n        };\n\n        // here we add 1 to the skip number because we want to get the number of\n        // operations that we want to move the pointer back to get the latest valid operation\n        // operation.skip = 1 means that we want to move the pointer back 2 operations to get to the latest valid operation\n        const operationSkip = operation.skip > 0 ? operation.skip + 1 : 0;\n\n        if (operationSkip > 0 && operationSkip > skipped) {\n            const skipDiff = operationSkip - skipped;\n            skipped = skipped + skipDiff;\n        }\n\n        latestOpIndex = operation.index;\n        scopeOpsWithIgnore.push(mappedOp);\n    }\n\n    return scopeOpsWithIgnore.reverse();\n}\n\nexport function calculateSkipsLeft<A extends Action>(\n    operations: Operation<BaseAction | A>[],\n    currentIndex: number,\n    skip: number,\n): number {\n    const sortedOperations = operations\n        .slice()\n        .sort((a, b) => a.skip - b.skip)\n        .sort((a, b) => a.index - b.index);\n\n    let skipsLeft = skip;\n    let skipsToPerform = 0;\n    let lastIndex = currentIndex;\n\n    for (const operation of sortedOperations.reverse()) {\n        const distance = lastIndex - operation.index;\n\n        skipsLeft = skipsLeft - distance;\n\n        if (skipsLeft > -1) {\n            skipsToPerform++;\n            lastIndex = operation.index;\n        } else {\n            break;\n        }\n    }\n\n    return skipsToPerform;\n}\n\n// Flattens the operations from all scopes into\n// a single array and sorts them by timestamp\nexport function sortOperations<A extends Action>(\n    operations: DocumentOperations<A>,\n) {\n    return Object.values(operations)\n        .flatMap(array => array)\n        .sort(\n            (a, b) =>\n                new Date(a.timestamp).getTime() -\n                new Date(b.timestamp).getTime(),\n        );\n}\n\n// Flattens the mapped operations (with ignore flag) from all scopes into\n// a single array and sorts them by timestamp\nexport function sortMappedOperations<A extends Action>(\n    operations: DocumentOperationsIgnoreMap<A>,\n) {\n    return Object.values(operations)\n        .flatMap(array => array)\n        .sort(\n            (a, b) =>\n                new Date(a.operation.timestamp).getTime() -\n                new Date(b.operation.timestamp).getTime(),\n        );\n}\n\n// Runs the operations on the initial data using the\n// provided reducer, wrapped with the document reducer.\n// This rebuilds the document according to the provided actions.\nexport function replayOperations<T, A extends Action, L>(\n    initialState: ExtendedState<T, L>,\n    clearedOperations: DocumentOperations<A>,\n    reducer: ImmutableStateReducer<T, A, L>,\n    dispatch?: SignalDispatch,\n    header?: DocumentHeader,\n    documentReducer = baseReducer,\n    skipHeaderOperations: SkipHeaderOperations = {},\n    options?: {\n        checkHashes?: boolean;\n    },\n): Document<T, A, L> {\n    // wraps the provided custom reducer with the\n    // base document reducer\n    const wrappedReducer = createReducer(reducer, documentReducer);\n\n    return replayDocument(\n        initialState,\n        clearedOperations,\n        wrappedReducer,\n        dispatch,\n        header,\n        skipHeaderOperations,\n        options,\n    );\n}\n\nexport type SkipHeaderOperations = Partial<Record<OperationScope, number>>;\n\nexport type ReplayDocumentOptions = {\n    // if false then reuses the hash from the operations\n    // and only checks the final hash of each scope\n    checkHashes?: boolean;\n};\n\n// Runs the operations on the initial data using the\n// provided document reducer.\n// This rebuilds the document according to the provided actions.\nexport function replayDocument<T, A extends Action, L>(\n    initialState: ExtendedState<T, L>,\n    operations: DocumentOperations<A>,\n    reducer: Reducer<T, A, L>,\n    dispatch?: SignalDispatch,\n    header?: DocumentHeader,\n    skipHeaderOperations: SkipHeaderOperations = {},\n    options?: ReplayDocumentOptions,\n): Document<T, A, L> {\n    const checkHashes = options?.checkHashes ?? true;\n\n    // builds a new document from the initial data\n    const document = createDocument<T, A, L>(initialState);\n\n    const flatOperations = Object.values(operations).flat();\n\n    const result = flatOperations.reduce((document, operation) => {\n        const doc = reducer(document, operation, dispatch, {\n            skip: operation.skip,\n            ignoreSkipOperations: true,\n            reuseHash: !checkHashes,\n        });\n\n        return doc;\n    }, document);\n\n    // if hash generation was skipped then checks if the hash\n    // of each scope matches the hash of last operation\n    if (!checkHashes) {\n        for (const scope of Object.keys(result.state)) {\n            for (let i = flatOperations.length - 1; i >= 0; i--) {\n                const operation = flatOperations[i];\n\n                if (operation.scope !== scope) {\n                    continue;\n                }\n                if (operation.hash !== hashDocument(result, scope)) {\n                    throw new Error(`Hash mismatch for scope ${scope}`);\n                } else {\n                    break;\n                }\n            }\n        }\n    }\n\n    // reuses operation timestamp if provided\n    const resultOperations: DocumentOperations<A> = Object.keys(\n        result.operations,\n    ).reduce(\n        (acc, key) => {\n            const scope = key as keyof DocumentOperations<A>;\n            return {\n                ...acc,\n                [scope]: [\n                    ...result.operations[scope].map((operation, index) => {\n                        return {\n                            ...operation,\n                            timestamp:\n                                operations[scope][index]?.timestamp ??\n                                operation.timestamp,\n                        };\n                    }),\n                ],\n            };\n        },\n        { global: [], local: [] },\n    );\n    // gets the last modified timestamp from the latest operation\n    const lastModified = Object.values(resultOperations).reduce((acc, curr) => {\n        const operation = curr[curr.length - 1];\n        if (operation?.timestamp > acc) {\n            acc = operation.timestamp;\n        }\n        return acc;\n    }, initialState.lastModified);\n\n    return { ...result, operations: resultOperations, lastModified };\n}\n\nexport function isSameDocument(documentA: Document, documentB: Document) {\n    return stringifyJson(documentA) === stringifyJson(documentB);\n}\n"],"names":["stringifyJson","document"],"mappings":"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"}

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

@@ -0,0 +1,324 @@
+import "../../../node_modules/.pnpm/safe-stable-stringify@2.4.3/node_modules/safe-stable-stringify/esm/wrapper.js";
+import cjsModule from "../../../node_modules/.pnpm/safe-stable-stringify@2.4.3/node_modules/safe-stable-stringify/index.js";
+var IntegrityIssueType = /* @__PURE__ */ ((IntegrityIssueType2) => {
+  IntegrityIssueType2["UNEXPECTED_INDEX"] = "UNEXPECTED_INDEX";
+  return IntegrityIssueType2;
+})(IntegrityIssueType || {});
+var IntegrityIssueSubType = /* @__PURE__ */ ((IntegrityIssueSubType2) => {
+  IntegrityIssueSubType2["DUPLICATED_INDEX"] = "DUPLICATED_INDEX";
+  IntegrityIssueSubType2["MISSING_INDEX"] = "MISSING_INDEX";
+  return IntegrityIssueSubType2;
+})(IntegrityIssueSubType || {});
+function checkCleanedOperationsIntegrity(sortedOperations) {
+  const result = [];
+  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: "UNEXPECTED_INDEX",
+        category: nextIndex > currentIndex + 1 ? "MISSING_INDEX" : "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;
+}
+function garbageCollect(sortedOperations) {
+  var _a, _b, _c;
+  const result = [];
+  let i = sortedOperations.length - 1;
+  while (i > -1) {
+    result.unshift(sortedOperations[i]);
+    const skipUntil = (((_a = sortedOperations[i]) == null ? void 0 : _a.index) || 0) - (((_b = sortedOperations[i]) == null ? void 0 : _b.skip) || 0) - 1;
+    let j = i - 1;
+    while (j > -1 && (((_c = sortedOperations[j]) == null ? void 0 : _c.index) || 0) > skipUntil) {
+      j--;
+    }
+    i = j;
+  }
+  return result;
+}
+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: (/* @__PURE__ */ new Date()).toISOString(),
+      input: {},
+      skip: 1,
+      scope: latestOperation.scope,
+      hash: latestOperation.hash
+    });
+  }
+  return operationsCopy;
+}
+function sortOperations(operations) {
+  return operations.slice().sort((a, b) => a.skip - b.skip).sort((a, b) => a.index - b.index);
+}
+const 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
+  }));
+};
+const 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
+  }));
+};
+function operationsAreEqual(op1, op2) {
+  return cjsModule(op1) === cjsModule(op2);
+}
+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];
+}
+function precedes(op1, op2) {
+  return op1.index < op2.index || op1.index === op2.index && op1.skip < op2.skip;
+}
+function split(sortedTargetOperations, sortedMergeOperations) {
+  const commonOperations = [];
+  const targetDiffOperations = [];
+  const mergeDiffOperations = [];
+  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];
+}
+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 newOperationHistory = reshuffle(
+    {
+      index: nextIndex,
+      skip: nextIndex - (maxCommonIndex + 1)
+    },
+    _targetOperations,
+    _mergeOperations
+  );
+  return _commonOperations.concat(newOperationHistory);
+}
+function getMaxIndex(sortedOperations) {
+  const lastElement = sortedOperations[sortedOperations.length - 1];
+  if (!lastElement) {
+    return -1;
+  }
+  return lastElement.index;
+}
+function nextSkipNumber(sortedOperations) {
+  var _a, _b, _c;
+  if (sortedOperations.length < 1) {
+    return -1;
+  }
+  const cleanedOperations = garbageCollect(sortedOperations);
+  let nextSkip = (((_a = cleanedOperations[cleanedOperations.length - 1]) == null ? void 0 : _a.skip) || 0) + 1;
+  if (cleanedOperations.length > 1) {
+    nextSkip += ((_b = cleanedOperations[cleanedOperations.length - 2]) == null ? void 0 : _b.skip) || 0;
+  }
+  return (((_c = cleanedOperations[cleanedOperations.length - 1]) == null ? void 0 : _c.index) || -1) < nextSkip ? -1 : nextSkip;
+}
+const checkOperationsIntegrity = (operations) => {
+  return checkCleanedOperationsIntegrity(
+    garbageCollect(sortOperations(operations))
+  );
+};
+const groupOperationsByScope = (operations) => {
+  const result = operations.reduce((acc, operation) => {
+    var _a;
+    if (!acc[operation.scope]) {
+      acc[operation.scope] = [];
+    }
+    (_a = acc[operation.scope]) == null ? void 0 : _a.push(operation);
+    return acc;
+  }, {});
+  return result;
+};
+const prepareOperations = (operationsHistory, newOperations) => {
+  var _a;
+  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 === "MISSING_INDEX"
+    /* MISSING_INDEX */
+  );
+  const firstMissingIndexOperation = (_a = [...missingIndexErrors].sort((a, b) => b.operation.index - a.operation.index).pop()) == null ? void 0 : _a.operation;
+  for (const newOperation of sortedOperations) {
+    if (firstMissingIndexOperation && newOperation.index >= firstMissingIndexOperation.index) {
+      result.invalidOperations.push(newOperation);
+      continue;
+    }
+    const isDuplicatedOperation = integrityErrors.some((integrityError) => {
+      return integrityError.operation.index === newOperation.index && integrityError.operation.skip === newOperation.skip && integrityError.category === "DUPLICATED_INDEX";
+    });
+    if (isDuplicatedOperation) {
+      result.duplicatedOperations.push(newOperation);
+      continue;
+    }
+    result.validOperations.push(newOperation);
+  }
+  result.integrityIssues.push(...integrityErrors);
+  return result;
+};
+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;
+    });
+  });
+}
+function skipHeaderOperations(operations, skipHeaderOperation) {
+  const [lastOperation] = sortOperations(operations).slice(-1);
+  const lastIndex = (lastOperation == null ? void 0 : 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);
+}
+function grabageCollectDocumentOperations(documentOperations) {
+  const clearedOperations = Object.entries(documentOperations).reduce(
+    (acc, entry) => {
+      const [scope, ops] = entry;
+      return {
+        ...acc,
+        [scope]: garbageCollect(sortOperations(ops))
+      };
+    },
+    {}
+  );
+  return {
+    ...clearedOperations
+  };
+}
+export {
+  IntegrityIssueSubType,
+  IntegrityIssueType,
+  addUndo,
+  attachBranch,
+  checkCleanedOperationsIntegrity,
+  checkOperationsIntegrity,
+  garbageCollect,
+  grabageCollectDocumentOperations,
+  groupOperationsByScope,
+  merge,
+  nextSkipNumber,
+  operationsAreEqual,
+  precedes,
+  prepareOperations,
+  removeExistingOperations,
+  reshuffleByTimestamp,
+  reshuffleByTimestampAndIndex,
+  skipHeaderOperations,
+  sortOperations,
+  split
+};
+//# sourceMappingURL=document-helpers.js.map

package/dist/browser/es/src/document/utils/document-helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-helpers.js","sources":["../../../../../../src/document/utils/document-helpers.ts"],"sourcesContent":["import {\n    Operation,\n    OperationScope,\n    Action,\n    DocumentOperations,\n} from '../types';\nimport stringify from 'safe-stable-stringify';\n\nexport type OperationIndex = {\n    index: number;\n    skip: number;\n};\n\nexport enum IntegrityIssueType {\n    UNEXPECTED_INDEX = 'UNEXPECTED_INDEX',\n}\n\nexport enum IntegrityIssueSubType {\n    DUPLICATED_INDEX = 'DUPLICATED_INDEX',\n    MISSING_INDEX = 'MISSING_INDEX',\n}\n\ntype IntegrityIssue = {\n    operation: OperationIndex;\n    issue: IntegrityIssueType;\n    category: IntegrityIssueSubType;\n    message: string;\n};\n\ntype Reshuffle = (\n    startIndex: OperationIndex,\n    opsA: Operation[],\n    opsB: Operation[],\n) => Operation[];\n\nexport function checkCleanedOperationsIntegrity(\n    sortedOperations: Operation[],\n): IntegrityIssue[] {\n    const result: IntegrityIssue[] = [];\n\n    // 1:1 1\n    // 0:0 0 -> 1:0 1 -> 2:0 -> 3:0 -> 4:0 -> 5:0\n    // 0:0 0 -> 2:1 1 -> 3:0 -> 4:0 -> 5:0\n    // 0:0 0 -> 3:2 1 -> 4:0 -> 5:0\n    // 0:0 0 -> 3:2 1 -> 5:1\n\n    // 0:3 (expected 0, got -3)\n    // 1:2 (expected 0, got -1)\n    // 0:0 -> 1:1\n    // 0:0 -> 2:2\n    // 0:0 -> 3:2 -> 5:2\n\n    let currentIndex = -1;\n    for (const nextOperation of sortedOperations) {\n        const nextIndex = nextOperation.index - nextOperation.skip;\n\n        if (nextIndex !== currentIndex + 1) {\n            result.push({\n                operation: {\n                    index: nextOperation.index,\n                    skip: nextOperation.skip,\n                },\n                issue: IntegrityIssueType.UNEXPECTED_INDEX,\n                category:\n                    nextIndex > currentIndex + 1\n                        ? IntegrityIssueSubType.MISSING_INDEX\n                        : IntegrityIssueSubType.DUPLICATED_INDEX,\n                message: `Expected index ${currentIndex + 1} with skip 0 or equivalent, got index ${nextOperation.index} with skip ${nextOperation.skip}`,\n            });\n        }\n\n        currentIndex = nextOperation.index;\n    }\n\n    return result;\n}\n\n// [] -> []\n// [0:0] -> [0:0]\n\n// 0:0 1:0 2:0 => 0:0 1:0 2:0, removals 0, no issues\n// 0:0 1:1 2:0 => 1:1 2:0, removals 1, no issues\n\n// 0:0 1:1 2:0 3:1 => 1:1 3:1, removals 2, no issues\n// 0:0 1:1 2:0 3:3 => 3:3\n\n// 1:1 2:0 3:0 => 1:1 2:0 3:0, removals 0, no issues\n// 1:0 0:0 2:0 => 2:0, removals 2, issues [UNEXPECTED_INDEX, INDEX_OUT_OF_ORDER]\n// 0:0 1:0 2:0 => 0:0 1:0 2:0, removals 0, no issues\n// 0:0 1:0 2:0 => 0:0 1:0 2:0, removals 0, no issues\n// 0:0 1:0 2:0 => 0:0 1:0 2:0, removals 0, no issues\n\nexport function garbageCollect<A extends OperationIndex>(\n    sortedOperations: A[],\n): A[] {\n    const result: A[] = [];\n\n    let i = sortedOperations.length - 1;\n\n    while (i > -1) {\n        result.unshift(sortedOperations[i]);\n        const skipUntil =\n            (sortedOperations[i]?.index || 0) -\n            (sortedOperations[i]?.skip || 0) -\n            1;\n\n        let j = i - 1;\n        while (j > -1 && (sortedOperations[j]?.index || 0) > skipUntil) {\n            j--;\n        }\n\n        i = j;\n    }\n\n    return result;\n}\n\nexport function addUndo(sortedOperations: Operation[]): Operation[] {\n    const operationsCopy = [...sortedOperations];\n    const latestOperation = operationsCopy[operationsCopy.length - 1];\n\n    if (!latestOperation) return operationsCopy;\n\n    if (latestOperation.type === 'NOOP') {\n        operationsCopy.push({\n            ...latestOperation,\n            index: latestOperation.index,\n            type: 'NOOP',\n            skip: nextSkipNumber(sortedOperations),\n        });\n    } else {\n        operationsCopy.push({\n            type: 'NOOP',\n            index: latestOperation.index + 1,\n            timestamp: new Date().toISOString(),\n            input: {},\n            skip: 1,\n            scope: latestOperation.scope,\n            hash: latestOperation.hash,\n        });\n    }\n\n    return operationsCopy;\n}\n\n// [0:0 2:0 1:0 3:3 3:1] => [0:0 1:0 2:0 3:1 3:3]\n// Sort by index _and_ skip number\nexport function sortOperations<A extends OperationIndex>(operations: A[]): A[] {\n    return operations\n        .slice()\n        .sort((a, b) => a.skip - b.skip)\n        .sort((a, b) => a.index - b.index);\n}\n\n// [0:0, 1:0, 2:0, A3:0, A4:0, A5:0] + [0:0, 1:0, 2:0, B3:0, B4:2, B5:0]\n// GC               => [0:0, 1:0, 2:0, A3:0, A4:0, A5:0] + [0:0, 1:0, B4:2, B5:0]\n// Split            => [0:0, 1:0] + [2:0, A3:0, A4:0, A5:0] + [B4:2, B5:0]\n// Reshuffle(6:4)   => [6:4, 7:0, 8:0, 9:0, 10:0, 11:0]\n// merge            => [0:0, 1:0, 6:4, 7:0, 8:0, 9:0, 10:0, 11:0]\nexport const reshuffleByTimestamp: Reshuffle = (startIndex, opsA, opsB) => {\n    return [...opsA, ...opsB]\n        .sort(\n            (a, b) =>\n                new Date(a.timestamp).getTime() -\n                new Date(b.timestamp).getTime(),\n        )\n        .map((op, i) => ({\n            ...op,\n            index: startIndex.index + i,\n            skip: i === 0 ? startIndex.skip : 0,\n        }));\n};\n\nexport const reshuffleByTimestampAndIndex: Reshuffle = (\n    startIndex,\n    opsA,\n    opsB,\n) => {\n    return [...opsA, ...opsB]\n        .sort(\n            (a, b) =>\n                new Date(a.timestamp).getTime() -\n                new Date(b.timestamp).getTime(),\n        )\n        .sort((a, b) => a.index - b.index)\n        .map((op, i) => ({\n            ...op,\n            index: startIndex.index + i,\n            skip: i === 0 ? startIndex.skip : 0,\n        }));\n};\n\n// TODO: implement better operation equality function\nexport function operationsAreEqual(op1: Operation, op2: Operation) {\n    return stringify(op1) === stringify(op2);\n}\n\n// [T0:0 T1:0 T2:0 T3:0] + [B4:0 B5:0] = [T0:0 T1:0 T2:0 T3:0 B4:0 B5:0]\n// [T0:0 T1:0 T2:0 T3:0] + [B3:0 B4:0] = [T0:0 T1:0 T2:0 B3:0 B4:0]\n// [T0:0 T1:0 T2:0 T3:0] + [B2:0 B3:0] = [T0:0 T1:0 B2:0 B3:0]\n\n// [T0:0 T1:0 T2:0 T3:0] + [B4:0 B4:2] = [T0:0 T1:0 T2:0 T3:0 B4:0 B4:2]\n// [T0:0 T1:0 T2:0 T3:0] + [B3:0 B3:2] = [T0:0 T1:0 T2:0 B3:0 B3:2]\n// [T0:0 T1:0 T2:0 T3:0] + [B2:3 B3:0] = [T0:0 T1:0 B2:3 B3:0]\n\nexport function attachBranch(\n    trunk: Operation[],\n    newBranch: Operation[],\n): [Operation[], Operation[]] {\n    const trunkCopy = garbageCollect(sortOperations(trunk.slice()));\n    const newOperations = garbageCollect(sortOperations(newBranch.slice()));\n    if (trunkCopy.length < 1) {\n        return [newOperations, []];\n    }\n\n    const result: Operation[] = [];\n    let enteredBranch = false;\n\n    while (newOperations.length > 0) {\n        const newOperationCandidate = newOperations[0];\n\n        let nextTrunkOperation = trunkCopy.shift();\n        while (\n            nextTrunkOperation &&\n            precedes(nextTrunkOperation, newOperationCandidate)\n        ) {\n            result.push(nextTrunkOperation);\n            nextTrunkOperation = trunkCopy.shift();\n        }\n\n        if (!nextTrunkOperation) {\n            enteredBranch = true;\n        } else if (!enteredBranch) {\n            if (operationsAreEqual(nextTrunkOperation, newOperationCandidate)) {\n                newOperations.shift();\n                result.push(nextTrunkOperation);\n            } else {\n                trunkCopy.unshift(nextTrunkOperation);\n                enteredBranch = true;\n            }\n        }\n\n        if (enteredBranch) {\n            let nextAppend = newOperations.shift();\n            while (nextAppend) {\n                result.push(nextAppend);\n                nextAppend = newOperations.shift();\n            }\n        }\n    }\n\n    if (!enteredBranch) {\n        let nextAppend = trunkCopy.shift();\n        while (nextAppend) {\n            result.push(nextAppend);\n            nextAppend = trunkCopy.shift();\n        }\n    }\n\n    return [garbageCollect(result), trunkCopy];\n}\n\nexport function precedes(op1: Operation, op2: Operation) {\n    return (\n        op1.index < op2.index ||\n        (op1.index === op2.index && op1.skip < op2.skip)\n    );\n}\n\nexport function split(\n    sortedTargetOperations: Operation[],\n    sortedMergeOperations: Operation[],\n): [Operation[], Operation[], Operation[]] {\n    const commonOperations: Operation[] = [];\n    const targetDiffOperations: Operation[] = [];\n    const mergeDiffOperations: Operation[] = [];\n\n    // get bigger array length\n    const maxLength = Math.max(\n        sortedTargetOperations.length,\n        sortedMergeOperations.length,\n    );\n\n    let splitHappened = false;\n    for (let i = 0; i < maxLength; i++) {\n        const targetOperation = sortedTargetOperations[i];\n        const mergeOperation = sortedMergeOperations[i];\n\n        if (targetOperation && mergeOperation) {\n            if (\n                !splitHappened &&\n                operationsAreEqual(targetOperation, mergeOperation)\n            ) {\n                commonOperations.push(targetOperation);\n            } else {\n                splitHappened = true;\n                targetDiffOperations.push(targetOperation);\n                mergeDiffOperations.push(mergeOperation);\n            }\n        } else if (targetOperation) {\n            targetDiffOperations.push(targetOperation);\n        } else if (mergeOperation) {\n            mergeDiffOperations.push(mergeOperation);\n        }\n    }\n\n    return [commonOperations, targetDiffOperations, mergeDiffOperations];\n}\n\n// [0:0, 1:0, 2:0, A3:0, A4:0, A5:0] + [0:0, 1:0, 2:0, B3:0, B4:2, B5:0]\n// GC               => [0:0, 1:0, 2:0, A3:0, A4:0, A5:0] + [0:0, 1:0, B4:2, B5:0]\n// Split            => [0:0, 1:0] + [2:0, A3:0, A4:0, A5:0] + [B4:2, B5:0]\n// Reshuffle(6:4)   => [6:4, 7:0, 8:0, 9:0, 10:0, 11:0]\n// merge            => [0:0, 1:0, 6:4, 7:0, 8:0, 9:0, 10:0, 11:0]\nexport function merge(\n    sortedTargetOperations: Operation[],\n    sortedMergeOperations: Operation[],\n    reshuffle: Reshuffle,\n): Operation[] {\n    const [_commonOperations, _targetOperations, _mergeOperations] = split(\n        garbageCollect(sortedTargetOperations),\n        garbageCollect(sortedMergeOperations),\n    );\n\n    const maxCommonIndex = getMaxIndex(_commonOperations);\n    const nextIndex =\n        1 +\n        Math.max(\n            maxCommonIndex,\n            getMaxIndex(_targetOperations),\n            getMaxIndex(_mergeOperations),\n        );\n\n    const newOperationHistory = reshuffle(\n        {\n            index: nextIndex,\n            skip: nextIndex - (maxCommonIndex + 1),\n        },\n        _targetOperations,\n        _mergeOperations,\n    );\n\n    return _commonOperations.concat(newOperationHistory);\n}\n\nfunction getMaxIndex(sortedOperations: Operation[]) {\n    const lastElement = sortedOperations[sortedOperations.length - 1];\n    if (!lastElement) {\n        return -1;\n    }\n\n    return lastElement.index;\n}\n\n// [] => -1\n// [0:0] => -1\n// [0:0 1:0] => 1\n// [0:0 1:1] => -1\n// [1:1] => -1\n// [0:0 1:0 2:0] => 1\n// [0:0 1:0 2:0 2:1] => 2\n// [0:0 1:0 2:0 2:1 2:2] => -1\n// [0:0 1:1 2:0] => 2\n// [0:0 1:1 2:2] => -1\n// [0:0 1:1 2:0 3:0] => 1\n// [0:0 1:1 2:0 3:1] => 3\n// [0:0 1:1 2:0 3:3] => -1\n// [50:50 100:50 150:50 151:0 152:0 153:0 154:3] => 53\n\nexport function nextSkipNumber<A extends OperationIndex>(\n    sortedOperations: A[],\n): number {\n    if (sortedOperations.length < 1) {\n        return -1;\n    }\n\n    const cleanedOperations = garbageCollect(sortedOperations);\n\n    let nextSkip =\n        (cleanedOperations[cleanedOperations.length - 1]?.skip || 0) + 1;\n\n    if (cleanedOperations.length > 1) {\n        nextSkip += cleanedOperations[cleanedOperations.length - 2]?.skip || 0;\n    }\n\n    return (cleanedOperations[cleanedOperations.length - 1]?.index || -1) <\n        nextSkip\n        ? -1\n        : nextSkip;\n}\n\nexport const checkOperationsIntegrity = (\n    operations: Operation[],\n): IntegrityIssue[] => {\n    return checkCleanedOperationsIntegrity(\n        garbageCollect(sortOperations(operations)),\n    );\n};\n\nexport type OperationsByScope = Partial<Record<OperationScope, Operation[]>>;\n\nexport const groupOperationsByScope = (\n    operations: Operation[],\n): OperationsByScope => {\n    const result = operations.reduce<OperationsByScope>((acc, operation) => {\n        if (!acc[operation.scope]) {\n            acc[operation.scope] = [];\n        }\n\n        acc[operation.scope]?.push(operation);\n\n        return acc;\n    }, {});\n\n    return result;\n};\n\ntype PrepareOperationsResult = {\n    validOperations: Operation[];\n    invalidOperations: Operation[];\n    duplicatedOperations: Operation[];\n    integrityIssues: IntegrityIssue[];\n};\n\nexport const prepareOperations = (\n    operationsHistory: Operation[],\n    newOperations: Operation[],\n): PrepareOperationsResult => {\n    const result: PrepareOperationsResult = {\n        integrityIssues: [],\n        validOperations: [],\n        invalidOperations: [],\n        duplicatedOperations: [],\n    };\n\n    const sortedOperationsHistory = sortOperations(operationsHistory);\n    const sortedOperations = sortOperations(newOperations);\n\n    const integrityErrors = checkCleanedOperationsIntegrity([\n        ...sortedOperationsHistory,\n        ...sortedOperations,\n    ]);\n\n    const missingIndexErrors = integrityErrors.filter(\n        integrityIssue =>\n            integrityIssue.category === IntegrityIssueSubType.MISSING_INDEX,\n    );\n\n    // get the integrity error with the lowest index operation\n    const firstMissingIndexOperation = [...missingIndexErrors]\n        .sort((a, b) => b.operation.index - a.operation.index)\n        .pop()?.operation;\n\n    for (const newOperation of sortedOperations) {\n        // Operation is missing index or it follows an operation that is missing index\n        if (\n            firstMissingIndexOperation &&\n            newOperation.index >= firstMissingIndexOperation.index\n        ) {\n            result.invalidOperations.push(newOperation);\n            continue;\n        }\n\n        // check if operation is duplicated\n        const isDuplicatedOperation = integrityErrors.some(integrityError => {\n            return (\n                integrityError.operation.index === newOperation.index &&\n                integrityError.operation.skip === newOperation.skip &&\n                integrityError.category ===\n                    IntegrityIssueSubType.DUPLICATED_INDEX\n            );\n        });\n\n        // add to duplicated operations if it is duplicated\n        if (isDuplicatedOperation) {\n            result.duplicatedOperations.push(newOperation);\n            continue;\n        }\n\n        // otherwise, add to valid operations\n        result.validOperations.push(newOperation);\n    }\n\n    result.integrityIssues.push(...integrityErrors);\n    return result;\n};\n\nexport function removeExistingOperations(\n    newOperations: Operation[],\n    operationsHistory: Operation[],\n): Operation[] {\n    return newOperations.filter(newOperation => {\n        return !operationsHistory.some(historyOperation => {\n            return (\n                (newOperation.type === 'NOOP' &&\n                    newOperation.skip === 0 &&\n                    newOperation.index === historyOperation.index) ||\n                (newOperation.index === historyOperation.index &&\n                    newOperation.skip === historyOperation.skip &&\n                    newOperation.scope === historyOperation.scope &&\n                    newOperation.hash === historyOperation.hash &&\n                    newOperation.type === historyOperation.type)\n            );\n        });\n    });\n}\n\nexport type SkipHeaderOperationIndex = Partial<Pick<OperationIndex, 'index'>> &\n    Pick<OperationIndex, 'skip'>;\n\n/**\n * Skips header operations and returns the remaining operations.\n *\n * @param operations - The array of operations.\n * @param skipHeaderOperation - The skip header operation index.\n * @returns The remaining operations after skipping header operations.\n */\nexport function skipHeaderOperations<A extends OperationIndex>(\n    operations: A[],\n    skipHeaderOperation: SkipHeaderOperationIndex,\n): A[] {\n    const [lastOperation] = sortOperations(operations).slice(-1);\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    const lastIndex = lastOperation?.index ?? -1;\n    const nextIndex = lastIndex + 1;\n\n    const skipOperationIndex = {\n        ...skipHeaderOperation,\n        index: skipHeaderOperation.index ?? nextIndex,\n    };\n\n    if (skipOperationIndex.index < lastIndex) {\n        throw new Error(\n            `The skip header operation index must be greater than or equal to ${lastIndex}`,\n        );\n    }\n\n    const clearedOperations = garbageCollect(\n        sortOperations([...operations, skipOperationIndex]),\n    );\n\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n    return (clearedOperations || []).slice(0, -1) as A[];\n}\n\nexport function grabageCollectDocumentOperations<A extends Action>(\n    documentOperations: DocumentOperations<A>,\n): DocumentOperations<A> {\n    const clearedOperations = Object.entries(documentOperations).reduce(\n        (acc, entry) => {\n            const [scope, ops] = entry;\n\n            return {\n                ...acc,\n                [scope as OperationScope]: garbageCollect(sortOperations(ops)),\n            };\n        },\n        {} as DocumentOperations<A>,\n    );\n\n    return {\n        ...clearedOperations,\n    };\n}\n"],"names":["IntegrityIssueType","IntegrityIssueSubType","stringify"],"mappings":"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"}