@dabble/patches 0.1.1

package/dist/json-patch/ops/index.js

@@ -0,0 +1,25 @@
+import { add } from './add.js';
+import { bit } from './bitmask.js';
+import { copy } from './copy.js';
+import { increment } from './increment.js';
+import { move } from './move.js';
+import { remove } from './remove.js';
+import { replace } from './replace.js';
+import { test } from './test.js';
+import { text } from './text.js';
+export * from './bitmask.js';
+export { add, bit, copy, increment, move, remove, replace, test };
+export function getTypes(custom) {
+    return {
+        test,
+        add,
+        remove,
+        replace,
+        copy,
+        move,
+        '@inc': increment,
+        '@bit': bit,
+        '@txt': text,
+        ...custom,
+    };
+}

package/dist/json-patch/ops/move.d.ts

@@ -0,0 +1,2 @@
+import type { JSONPatchOpHandler } from '../types.js';
+export declare const move: JSONPatchOpHandler;

package/dist/json-patch/ops/move.js

@@ -0,0 +1,211 @@
+import { getOpData } from '../utils/getOpData.js';
+import { getTypeLike } from '../utils/getType.js';
+import { log } from '../utils/log.js';
+import { isAdd, mapAndFilterOps, updateRemovedOps } from '../utils/ops.js';
+import { getArrayPrefixAndIndex, getIndexAndEnd, isArrayPath } from '../utils/paths.js';
+import { getValue, pluckWithShallowCopy } from '../utils/pluck.js';
+import { toArrayIndex } from '../utils/toArrayIndex.js';
+import { updateArrayIndexes } from '../utils/updateArrayIndexes.js';
+import { add } from './add.js';
+export const move = {
+    like: 'move',
+    apply(state, path, from) {
+        if (path === from)
+            return;
+        let value;
+        const [keys, lastKey, target] = getOpData(state, from);
+        if (target === null) {
+            return `[op:move] path not found: ${from}`;
+        }
+        if (Array.isArray(target)) {
+            const index = toArrayIndex(target, lastKey);
+            if (target.length <= index) {
+                return `[op:move] invalid array index: ${path}`;
+            }
+            value = target[index];
+            pluckWithShallowCopy(state, keys, true).splice(index, 1);
+        }
+        else {
+            value = target[lastKey];
+            delete pluckWithShallowCopy(state, keys, true)[lastKey];
+        }
+        return add.apply(state, path, value);
+    },
+    invert(_state, { path, from }) {
+        return { op: 'move', from: path, path: '' + from };
+    },
+    transform(state, thisOp, otherOps) {
+        log('Transforming', otherOps, 'against "move"', thisOp);
+        let removed = false;
+        const { from, path } = thisOp;
+        if (from === path)
+            return otherOps;
+        const [fromPrefix, fromIndex] = getArrayPrefixAndIndex(state, from);
+        const [pathPrefix, pathIndex] = getArrayPrefixAndIndex(state, path);
+        const isPathArray = pathPrefix !== undefined;
+        const isSameArray = isPathArray && pathPrefix === fromPrefix;
+        /*
+        A move needs to do a "remove" and an "add" at once with `from` and `path`. If it is being moved from one location in
+        an array to another in the same array, this needs to be handled special.
+    
+        1. Ops that were added to where the move lands when not an array should be removed just like with an add/copy
+        2. Ops that were added to where the move came from should be translated to the new path
+        3. Ops that are in an array with the moved item after need to be adjusted up or down
+          3a. But, ops that were translated to the new path shouldn't get adjusted up or down by these adjustments
+        */
+        // A move removes the value from one place then adds it to another, update the paths and add a marker to them so
+        // they won't be altered by `updateArrayIndexes`, then remove the markers afterwards
+        otherOps = mapAndFilterOps(otherOps, otherOp => {
+            if (removed) {
+                return otherOp;
+            }
+            const opLike = getTypeLike(state, otherOp);
+            if (opLike === 'remove' && from === otherOp.path) {
+                // Once an operation removes the moved value, the following ops should be working on the old location and not
+                // not the new one. Allow the following operations (which may include add/remove) to affect the old location
+                removed = true;
+            }
+            const original = otherOp;
+            otherOp = updateMovePath(state, otherOp, 'path', from, path, original);
+            otherOp = updateMovePath(state, otherOp, 'from', from, path, original);
+            return otherOp;
+        });
+        // Remove/adjust items that were affected by this item moving (those that actually moved because of it will not
+        // be affected because they have a temporary $ marker prefix that will keep them from doing so)
+        if (isSameArray) {
+            // need special logic when a move is within one array
+            otherOps = updateArrayIndexesForMove(state, fromPrefix, fromIndex, pathIndex, otherOps);
+        }
+        else {
+            // if a move is not within one array, treat it as a remove then add
+            if (isArrayPath(from, state)) {
+                otherOps = updateArrayIndexes(state, from, otherOps, -1);
+            }
+            else {
+                otherOps = updateRemovedOps(state, from, otherOps);
+            }
+            if (isArrayPath(path, state)) {
+                otherOps = updateArrayIndexes(state, path, otherOps, 1);
+            }
+            else {
+                otherOps = updateRemovedOps(state, path, otherOps);
+            }
+        }
+        // Remove the move markers added with `updateMovePath`
+        return mapAndFilterOps(otherOps, removeMoveMarkers);
+    },
+};
+/**
+ * Update paths for a move operation, adding a marker so the path will not be altered by array updates.
+ */
+function updateMovePath(state, op, pathName, from, to, original) {
+    const path = op[pathName];
+    if (!path)
+        return op; // No adjustment needed on a property that doesn't exist
+    // If a value is being added or copied to the old location it should not be adjusted
+    if (isAdd(state, op, pathName) && op.path === from) {
+        return op;
+    }
+    // If this path needs to be changed due to a move operation, change it, but prefix it with a $ temporarily so when we
+    // adjust the array indexes to account for this change, we aren't changing this path we JUST set. We will remove the
+    // $ prefix right after we adjust arrays affected by this move.
+    if (path === from || path.indexOf(from + '/') === 0) {
+        if (op === original)
+            op = Object.assign({}, op);
+        log('Moving', op, 'from', from, 'to', to);
+        // Add a marker "$" so this path will not be double-updated by array index updates
+        op[pathName] = '$' + path.replace(from, to);
+    }
+    return op;
+}
+/**
+ * Update array indexes to account for values being added or removed from an array. If the path is not an array index
+ * or if nothing is changed then the original array is returned.
+ */
+function updateArrayIndexesForMove(state, prefix, fromIndex, pathIndex, otherOps) {
+    // Check ops for any that need to be replaced
+    log(`Shifting array indexes for a move between ${prefix}/${fromIndex} and ${prefix}/${pathIndex}`);
+    return mapAndFilterOps(otherOps, otherOp => {
+        // check for items from the same array that will be affected
+        const fromUpdate = updateArrayPathForMove(state, otherOp, 'from', prefix, fromIndex, pathIndex);
+        const pathUpdate = updateArrayPathForMove(state, otherOp, 'path', prefix, fromIndex, pathIndex);
+        if (!fromUpdate || !pathUpdate)
+            return null;
+        if (fromUpdate !== otherOp || pathUpdate !== otherOp) {
+            otherOp = { ...otherOp, path: pathUpdate.path };
+            if (fromUpdate.from)
+                otherOp.from = fromUpdate.from;
+        }
+        return otherOp;
+    });
+}
+/**
+ * Get the adjusted path if it is higher, or undefined if not.
+ */
+function updateArrayPathForMove(state, otherOp, pathName, prefix, from, to) {
+    const path = otherOp[pathName];
+    if (!path || !path.startsWith(prefix))
+        return otherOp;
+    const min = Math.min(from, to);
+    const max = Math.max(from, to);
+    const [otherIndex, end] = getIndexAndEnd(state, path, prefix.length);
+    if (otherIndex === undefined)
+        return otherOp; // if a prop on an array is being set, for e.g.
+    const isFinalProp = end === path.length;
+    const opLike = getTypeLike(state, otherOp);
+    // If this index is not within the movement boundary, don't touch it
+    if (otherIndex < min || otherIndex > max) {
+        return otherOp;
+    }
+    // If the index touches the boundary on an unaffected side, don't touch it
+    if (isFinalProp && isAdd(state, otherOp, pathName)) {
+        /*
+          if the move is from low to high (min is a remove, max is an add) then
+          use the remove logic with an add
+    
+          if the move is from high to low (min is an add, max is a remove) then
+          use the add logic at the bottom
+        */
+        if (otherIndex === min) {
+            if (min === from) {
+                // treat like a remove
+                return otherOp;
+            }
+            else {
+                // treat like an add
+                return otherOp;
+            }
+        }
+        else if (otherIndex === max) {
+            if (max === from) {
+                // treat like a remove
+                const fromIndex = getIndexAndEnd(state, otherOp.from, prefix.length)[0];
+                if (opLike === 'move' && pathName === 'path' && to <= fromIndex && fromIndex < from)
+                    return otherOp;
+                // continue
+            }
+            else {
+                // treat like an add
+                return otherOp;
+            }
+        }
+    }
+    const modifier = from === min ? -1 : 1;
+    const newPath = prefix + (otherIndex + modifier) + path.slice(end);
+    return getValue(state, otherOp, pathName, newPath);
+}
+/**
+ * Remove any move markers placed during updateMovePath. This occurs in-place since these objects have already been
+ * cloned.
+ */
+function removeMoveMarkers(op) {
+    if (op.path[0] === '$') {
+        op.path = op.path.slice(1);
+    }
+    if (op.from && op.from[0] === '$') {
+        op.from = op.from.slice(1);
+    }
+    if (op.from === op.path)
+        return null;
+    return op;
+}

package/dist/json-patch/ops/remove.d.ts

@@ -0,0 +1,2 @@
+import type { JSONPatchOpHandler } from '../types.js';
+export declare const remove: JSONPatchOpHandler;

package/dist/json-patch/ops/remove.js

@@ -0,0 +1,31 @@
+import { getOpData } from '../utils/getOpData.js';
+import { log } from '../utils/log.js';
+import { transformRemove } from '../utils/ops.js';
+import { pluckWithShallowCopy } from '../utils/pluck.js';
+import { toArrayIndex } from '../utils/toArrayIndex.js';
+export const remove = {
+    like: 'remove',
+    apply(state, path) {
+        const [keys, lastKey, target] = getOpData(state, path);
+        if (target === null) {
+            return;
+        }
+        if (Array.isArray(target)) {
+            const index = toArrayIndex(target, lastKey);
+            if (target.length <= index) {
+                return '[op:remove] invalid array index: ' + path;
+            }
+            pluckWithShallowCopy(state, keys).splice(index, 1);
+        }
+        else {
+            delete pluckWithShallowCopy(state, keys)[lastKey];
+        }
+    },
+    invert(_state, { path }, value) {
+        return { op: 'add', path, value };
+    },
+    transform(state, thisOp, otherOps) {
+        log('Transforming', otherOps, 'against "remove"', thisOp);
+        return transformRemove(state, thisOp.path, otherOps, true);
+    },
+};

package/dist/json-patch/ops/replace.d.ts

@@ -0,0 +1,2 @@
+import type { JSONPatchOpHandler } from '../types.js';
+export declare const replace: JSONPatchOpHandler;

package/dist/json-patch/ops/replace.js

@@ -0,0 +1,44 @@
+import { deepEqual } from '../utils/deepEqual.js';
+import { getOpData } from '../utils/getOpData.js';
+import { log } from '../utils/log.js';
+import { updateRemovedOps } from '../utils/ops.js';
+import { pluckWithShallowCopy } from '../utils/pluck.js';
+import { toArrayIndex } from '../utils/toArrayIndex.js';
+export const replace = {
+    like: 'replace',
+    apply(state, path, value) {
+        if (typeof value === 'undefined') {
+            return '[op:replace] require value, but got undefined';
+        }
+        const [keys, lastKey, target] = getOpData(state, path, true);
+        if (target === null) {
+            return `[op:replace] path not found: ${path}`;
+        }
+        if (Array.isArray(target)) {
+            const index = toArrayIndex(target, lastKey);
+            if (target.length <= index) {
+                return `[op:replace] invalid array index: ${path}`;
+            }
+            if (!deepEqual(target[index], value)) {
+                pluckWithShallowCopy(state, keys, true).splice(index, 1, value);
+            }
+        }
+        else {
+            if (!deepEqual(target[lastKey], value)) {
+                pluckWithShallowCopy(state, keys, true)[lastKey] = value;
+            }
+        }
+    },
+    invert(_state, { path }, value, changedObj) {
+        if (path.endsWith('/-'))
+            path = path.replace('-', changedObj.length);
+        return value === undefined ? { op: 'remove', path } : { op: 'replace', path, value };
+    },
+    transform(state, thisOp, otherOps) {
+        log('Transforming ', otherOps, ' against "replace"', thisOp);
+        return updateRemovedOps(state, thisOp.path, otherOps);
+    },
+    compose(_state, _value1, value2) {
+        return value2;
+    },
+};

package/dist/json-patch/ops/test.d.ts

@@ -0,0 +1,2 @@
+import type { JSONPatchOpHandler } from '../types.js';
+export declare const test: JSONPatchOpHandler;

package/dist/json-patch/ops/test.js

@@ -0,0 +1,22 @@
+import { deepEqual } from '../utils/deepEqual.js';
+import { getOpData } from '../utils/getOpData.js';
+export const test = {
+    like: 'test',
+    apply(state, path, expected) {
+        const [, lastKey, target] = getOpData(state, path);
+        if (target === null) {
+            return `[op:test] path not found: ${path}`;
+        }
+        if (!deepEqual(target[lastKey], expected)) {
+            const a = JSON.stringify(target[lastKey]);
+            const b = JSON.stringify(expected);
+            return `[op:test] not matched: ${a} ${b}`;
+        }
+    },
+    invert() {
+        return undefined;
+    },
+    transform(_state, _other, ops) {
+        return ops;
+    },
+};

package/dist/json-patch/ops/text.d.ts

@@ -0,0 +1,2 @@
+import type { JSONPatchOpHandler } from '../types.js';
+export declare const text: JSONPatchOpHandler;

package/dist/json-patch/ops/text.js

@@ -0,0 +1,57 @@
+import { Delta } from '@dabble/delta';
+import { replace } from '../ops/replace.js';
+import { get } from '../utils/get.js';
+import { log } from '../utils/log.js';
+import { updateRemovedOps } from '../utils/ops.js';
+export const text = {
+    like: 'replace',
+    apply(state, path, value) {
+        const delta = Array.isArray(value) ? new Delta(value) : value;
+        if (!delta || !Array.isArray(delta.ops)) {
+            return 'Invalid delta';
+        }
+        let existingData = get(state, path);
+        let doc;
+        if (Array.isArray(existingData)) {
+            if (existingData.length && existingData[0].insert) {
+                doc = new Delta(existingData);
+            }
+        }
+        else if (existingData && existingData.ops) {
+            doc = new Delta(existingData.ops);
+        }
+        if (!doc) {
+            doc = new Delta().insert('\n');
+        }
+        doc = doc.compose(delta);
+        if (hasInvalidOps(doc)) {
+            return 'Invalid text delta provided for this text document';
+        }
+        return replace.apply(state, path, doc);
+    },
+    transform(state, thisOp, otherOps) {
+        log('Transforming ', otherOps, ' against "@txt"', thisOp);
+        return updateRemovedOps(state, thisOp.path, otherOps, false, true, thisOp.op, op => {
+            if (op.path !== thisOp.path)
+                return null; // If a subpath, it is overwritten
+            if (!op.value || !Array.isArray(op.value))
+                return null; // If not a delta, it is overwritten
+            const thisDelta = new Delta(thisOp.value);
+            let otherDelta = new Delta(op.value);
+            otherDelta = thisDelta.transform(otherDelta, true);
+            return { ...op, value: otherDelta.ops };
+        });
+    },
+    invert(state, { path, value }, oldValue, changedObj) {
+        if (path.endsWith('/-'))
+            path = path.replace('-', changedObj.length);
+        const delta = new Delta(value);
+        return oldValue === undefined ? { op: 'remove', path } : { op: '@txt', path, value: delta.invert(oldValue) };
+    },
+    compose(state, delta1, delta2) {
+        return new Delta(delta1).compose(new Delta(delta2));
+    },
+};
+function hasInvalidOps(doc) {
+    return doc.ops.some(op => typeof op.insert !== 'string' && (typeof op.insert !== 'object' || op.insert === null));
+}

package/dist/json-patch/patchProxy.d.ts

@@ -0,0 +1,41 @@
+import { JSONPatch } from './JSONPatch';
+/**
+ * Creates a proxy object that can be used in two ways:
+ *
+ * 1.  **Path Generation:** When used without a `JSONPatch` instance, accessing properties
+ *     on the proxy generates a JSON Pointer path string via `toString()`. This allows
+ *     for type-safe path creation when using `JSONPatch` methods directly.
+ *     ```ts
+ *     const patch = new JSONPatch();
+ *     const proxy = createPatchProxy<MyType>();
+ *     patch.text(proxy.content, new Delta().insert('text')); // Path is '/content'
+ *     patch.increment(proxy.counter, 5);                     // Path is '/counter'
+ *     ```
+ *
+ * 2.  **Automatic Patch Generation:** When created with a target object and a `JSONPatch`
+ *     instance, modifying the proxy (setting properties, calling array methods like
+ *     `push`, `splice`, etc.) automatically generates the corresponding JSON Patch
+ *     operations and adds them to the provided `patch` instance.
+ *     ```ts
+ *     const patch = new JSONPatch();
+ *     const myObj = { name: { first: 'Alice' }, tags: ['a'] };
+ *     const proxy = createPatchProxy(myObj, patch);
+ *     proxy.name.first = 'Bob';  // Generates replace op
+ *     proxy.tags.push('b');      // Generates add op
+ *     ```
+ *
+ * The proxy behaves like the original value in most contexts due to the `valueOf` trap.
+ * For optional properties, use the non-null assertion operator (!) when setting values:
+ * ```ts
+ * interface User { middleName?: string }
+ * const proxy = createPatchProxy<User>(user, patch);
+ * proxy.middleName! = 'John';  // Assert middleName exists before setting
+ * ```
+ *
+ * @template T The type of the object to proxy.
+ * @param target The target object (required for automatic patch generation mode).
+ * @param patch The `JSONPatch` instance to add generated operations to (required for automatic patch generation mode).
+ * @returns A proxy object of type T.
+ */
+export declare function createPatchProxy<T>(): T;
+export declare function createPatchProxy<T>(target: T, patch: JSONPatch): T;

package/dist/json-patch/patchProxy.js

@@ -0,0 +1,125 @@
+// We use a function as the target so that `push` and other array methods can be called without error.
+const proxyFodder = {};
+export function createPatchProxy(target, patch) {
+    // Call the internal implementation
+    return createPatchProxyInternal(target, patch);
+}
+// Internal implementation with the path parameter
+function createPatchProxyInternal(target, patch, path = '') {
+    // Always use an empty function as the proxy target
+    // This allows us to proxy any type of value, including primitives and undefined,
+    // and enables calling array methods like push/splice directly on array proxies.
+    return new Proxy(proxyFodder, {
+        get(_, prop) {
+            // Return the value directly for symbol properties (not relevant for JSON paths)
+            if (typeof prop === 'symbol') {
+                return target?.[prop];
+            }
+            // Handle toString specially to make properties work as PathLike
+            if (prop === 'toString') {
+                return function () {
+                    return path;
+                };
+            }
+            // Handle valueOf to make the proxy behave like the original value in most contexts
+            if (prop === 'valueOf') {
+                return function () {
+                    return target;
+                };
+            }
+            // --- Array Method Interception ---
+            if (Array.isArray(target)) {
+                switch (prop) {
+                    case 'push':
+                        return (...items) => {
+                            const index = target.length;
+                            for (let i = 0; i < items.length; i++) {
+                                patch?.add(`${path}/${index + i}`, items[i]);
+                            }
+                        };
+                    case 'pop':
+                        return () => {
+                            const index = target.length - 1;
+                            if (index >= 0) {
+                                patch?.remove(`${path}/${index}`);
+                            }
+                        };
+                    case 'shift':
+                        return () => {
+                            if (target.length > 0) {
+                                patch?.remove(`${path}/0`);
+                            }
+                        };
+                    case 'unshift':
+                        return (...items) => {
+                            for (let i = 0; i < items.length; i++) {
+                                patch?.add(`${path}/${i}`, items[i]);
+                            }
+                        };
+                    case 'splice':
+                        return (start, deleteCount, ...items) => {
+                            const actualStart = start < 0 ? Math.max(target.length + start, 0) : Math.min(start, target.length);
+                            const actualDeleteCount = Math.min(Math.max(deleteCount === undefined ? target.length - actualStart : deleteCount, 0), target.length - actualStart);
+                            // Remove deleted elements
+                            for (let i = 0; i < actualDeleteCount; i++) {
+                                patch?.remove(`${path}/${actualStart}`); // Path automatically adjusts for subsequent removes
+                            }
+                            // Add new elements
+                            for (let i = 0; i < items.length; i++) {
+                                patch?.add(`${path}/${actualStart + i}`, items[i]);
+                            }
+                        };
+                }
+            }
+            // --- End Array Method Interception ---
+            // Create a proxy for the property value if it's not an intercepted array method
+            // This handles objects, primitives, and undefined values uniformly
+            // Call the internal implementation recursively
+            return createPatchProxyInternal(target?.[prop], patch, `${path}/${String(prop)}`);
+        },
+        set(_, prop, value) {
+            // Ignore setting the 'length' property on arrays directly
+            if (Array.isArray(target) && prop === 'length') {
+                return true;
+            }
+            if (target?.[prop] === value)
+                return true;
+            const patchPath = `${path}/${String(prop)}`;
+            if (value === undefined) {
+                patch?.remove(patchPath);
+            }
+            else {
+                patch?.replace(patchPath, value);
+            }
+            return true;
+        },
+        deleteProperty(_, prop) {
+            if (target == null || prop in target) {
+                patch?.remove(`${path}/${String(prop)}`);
+            }
+            return true;
+        },
+        // Make the proxy appear to be the same type as the target
+        getPrototypeOf() {
+            return Object.getPrototypeOf(target);
+        },
+        // Support instanceof checks
+        isExtensible() {
+            return target != null && Object.isExtensible(target);
+        },
+        // Support Object.keys and other enumeration methods
+        ownKeys() {
+            return target != null && typeof target === 'object' ? Reflect.ownKeys(target) : [];
+        },
+        // Support property descriptor access
+        getOwnPropertyDescriptor(_, prop) {
+            if (target == null || typeof target !== 'object')
+                return undefined;
+            return Object.getOwnPropertyDescriptor(target, prop);
+        },
+        // Support Object.hasOwnProperty
+        has(_, prop) {
+            return target != null && typeof target === 'object' && prop in target;
+        },
+    });
+}

package/dist/json-patch/state.d.ts

@@ -0,0 +1,2 @@
+import type { JSONPatchOpHandlerMap, Runner } from './types.js';
+export declare function runWithObject(object: any, allTypes: JSONPatchOpHandlerMap, shouldCache: boolean, callback: Runner): any;

package/dist/json-patch/state.js

@@ -0,0 +1,8 @@
+export function runWithObject(object, allTypes, shouldCache, callback) {
+    const state = {
+        root: { '': object },
+        types: allTypes,
+        cache: shouldCache ? new Set() : null,
+    };
+    return callback(state) || state.root[''];
+}

package/dist/json-patch/transformPatch.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Based on work from
+ * https://github.com/Palindrom/JSONPatchOT
+ * (c) 2017 Tomek Wytrebowicz
+ *
+ * MIT license
+ * (c) 2022 Jacob Wright
+ *
+ *
+ * WARNING: using /array/- syntax to indicate the end of the array makes it impossible to transform arrays correctly in
+ * all situaions. Please avoid using this syntax when using Operational Transformations.
+ */
+import type { JSONPatchOp, JSONPatchOpHandlerMap } from './types.js';
+/**
+ * Transform an array of JSON Patch operations against another array of JSON Patch operations. Returns a new array with
+ * transformed operations. Operations that change are cloned, making the results of this function immutable.
+ * `otherOps` are transformed over `thisOps` with thisOps considered to have happened first.
+ */
+export declare function transformPatch(obj: any, thisOps: JSONPatchOp[], otherOps: JSONPatchOp[], custom?: JSONPatchOpHandlerMap): JSONPatchOp[];

package/dist/json-patch/transformPatch.js

@@ -0,0 +1,37 @@
+/*!
+ * Based on work from
+ * https://github.com/Palindrom/JSONPatchOT
+ * (c) 2017 Tomek Wytrebowicz
+ *
+ * MIT license
+ * (c) 2022 Jacob Wright
+ *
+ *
+ * WARNING: using /array/- syntax to indicate the end of the array makes it impossible to transform arrays correctly in
+ * all situaions. Please avoid using this syntax when using Operational Transformations.
+ */
+import { getTypes } from './ops/index.js';
+import { runWithObject } from './state.js';
+import { getType } from './utils/getType.js';
+import { log } from './utils/log.js';
+/**
+ * Transform an array of JSON Patch operations against another array of JSON Patch operations. Returns a new array with
+ * transformed operations. Operations that change are cloned, making the results of this function immutable.
+ * `otherOps` are transformed over `thisOps` with thisOps considered to have happened first.
+ */
+export function transformPatch(obj, thisOps, otherOps, custom) {
+    const types = getTypes(custom);
+    return runWithObject(obj, types, false, state => {
+        return thisOps.reduce((otherOps, thisOp) => {
+            // transform ops with patch operation
+            const handler = getType(state, thisOp)?.transform;
+            if (typeof handler === 'function') {
+                otherOps = handler(state, thisOp, otherOps);
+            }
+            else {
+                log('No function to transform against for', thisOp.op);
+            }
+            return otherOps;
+        }, otherOps);
+    });
+}