@dabble/patches 0.1.1

package/dist/utils.d.ts

@@ -0,0 +1,36 @@
+import type { Change, DeletedChange } from './types.js';
+/**
+ * Splits an array of changes into two arrays based on the presence of a baseRev.
+ * The first array contains changes before the first change with a baseRev,
+ * and the second array contains the change with baseRev and all subsequent changes.
+ *
+ * @param changes - Array of changes to split
+ * @returns A tuple containing [changes before baseRev, changes with and after baseRev]
+ */
+export declare function splitChanges<T>(changes: Change[]): [Change[], Change[]];
+/**
+ * Applies a sequence of changes to a state object.
+ * Each change is applied in sequence using the applyPatch function.
+ *
+ * @param state - The initial state to apply changes to
+ * @param changes - Array of changes to apply
+ * @returns The state after all changes have been applied
+ */
+export declare function applyChanges<T>(state: T, changes: Change[]): T;
+/**
+ * Rebases local changes against server changes using operational transformation.
+ * This function handles the transformation of local changes to be compatible with server changes
+ * that have been applied in the meantime.
+ *
+ * The process:
+ * 1. Filters out local changes that are already in server changes
+ * 2. Creates a patch from server changes that need to be transformed against
+ * 3. Transforms each remaining local change against the server patch
+ * 4. Updates revision numbers for the transformed changes
+ *
+ * @param serverChanges - Array of changes received from the server
+ * @param localChanges - Array of local changes that need to be rebased
+ * @returns Array of rebased local changes with updated revision numbers
+ */
+export declare function rebaseChanges(serverChanges: Change[], localChanges: Change[]): Change[];
+export declare function isChange(change: Change | DeletedChange): change is Change;

package/dist/utils.js

@@ -0,0 +1,83 @@
+import { applyPatch } from './json-patch/applyPatch.js';
+import { JSONPatch } from './json-patch/JSONPatch.js';
+/**
+ * Splits an array of changes into two arrays based on the presence of a baseRev.
+ * The first array contains changes before the first change with a baseRev,
+ * and the second array contains the change with baseRev and all subsequent changes.
+ *
+ * @param changes - Array of changes to split
+ * @returns A tuple containing [changes before baseRev, changes with and after baseRev]
+ */
+export function splitChanges(changes) {
+    const index = changes.findIndex(c => c.baseRev);
+    return [changes.slice(0, index), changes.slice(index)];
+}
+/**
+ * Applies a sequence of changes to a state object.
+ * Each change is applied in sequence using the applyPatch function.
+ *
+ * @param state - The initial state to apply changes to
+ * @param changes - Array of changes to apply
+ * @returns The state after all changes have been applied
+ */
+export function applyChanges(state, changes) {
+    if (!changes.length)
+        return state;
+    for (const change of changes) {
+        state = applyPatch(state, change.ops, { strict: true });
+    }
+    return state;
+}
+/**
+ * Rebases local changes against server changes using operational transformation.
+ * This function handles the transformation of local changes to be compatible with server changes
+ * that have been applied in the meantime.
+ *
+ * The process:
+ * 1. Filters out local changes that are already in server changes
+ * 2. Creates a patch from server changes that need to be transformed against
+ * 3. Transforms each remaining local change against the server patch
+ * 4. Updates revision numbers for the transformed changes
+ *
+ * @param serverChanges - Array of changes received from the server
+ * @param localChanges - Array of local changes that need to be rebased
+ * @returns Array of rebased local changes with updated revision numbers
+ */
+export function rebaseChanges(serverChanges, localChanges) {
+    if (!serverChanges.length || !localChanges.length) {
+        return localChanges;
+    }
+    const lastChange = serverChanges[serverChanges.length - 1];
+    const receivedIds = new Set(serverChanges.map(change => change.id));
+    const transformAgainstIds = new Set(receivedIds);
+    // Filter out local changes that are already in server changes
+    const filteredLocalChanges = [];
+    for (const change of localChanges) {
+        if (receivedIds.has(change.id)) {
+            transformAgainstIds.delete(change.id);
+        }
+        else {
+            filteredLocalChanges.push(change);
+        }
+    }
+    // Create a patch from server changes that need to be transformed against
+    const transformPatch = new JSONPatch(serverChanges
+        .filter(change => transformAgainstIds.has(change.id))
+        .map(change => change.ops)
+        .flat());
+    // Rebase local changes against server changes
+    const base = lastChange.rev;
+    let rev = lastChange.rev;
+    return filteredLocalChanges
+        .map(change => {
+        rev++;
+        const ops = transformPatch.transform(change.ops).ops;
+        if (!ops.length)
+            return null;
+        return { ...change, base, rev, ops };
+    })
+        .filter(Boolean);
+}
+export function isChange(change) {
+    return 'rev' in change;
+}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "@dabble/patches",
+  "version": "0.1.1",
+  "description": "Immutable JSON Patch implementation based on RFC 6902 supporting operational transformation and last-writer-wins",
+  "author": "Jacob Wright <jacwright@gmail.com>",
+  "bugs": {
+    "url": "https://github.com/dabblewriter/patches/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./client": {
+      "import": "./dist/client/index.js",
+      "types": "./dist/client/index.d.ts"
+    },
+    "./server": {
+      "import": "./dist/server/index.js",
+      "types": "./dist/server/index.d.ts"
+    },
+    "./net": {
+      "import": "./dist/net/index.js",
+      "types": "./dist/net/index.d.ts"
+    },
+    "./persist": {
+      "import": "./dist/persist/index.js",
+      "types": "./dist/persist/index.d.ts"
+    }
+  },
+  "files": [
+    "package.json",
+    "README.md",
+    "dist"
+  ],
+  "homepage": "https://github.com/dabblewriter/patches/",
+  "keywords": [
+    "immutable",
+    "json",
+    "patch",
+    "rfc6902",
+    "operational-transformation",
+    "collaborative-editing"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dabblewriter/patches.git"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "svelte-package -i src",
+    "prepare": "npm run build",
+    "test": "vitest run",
+    "tdd": "vitest"
+  },
+  "dependencies": {
+    "alphacounter": "^2.x",
+    "crypto-id": "^0.2.3",
+    "simple-peer": "^9.11.1"
+  },
+  "peerDependencies": {
+    "@dabble/delta": "^1.2.4"
+  },
+  "devDependencies": {
+    "@sveltejs/package": "^2.3.10",
+    "@types/simple-peer": "^9.11.8",
+    "fake-indexeddb": "^6.0.0",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3",
+    "vite": "^6.2.6",
+    "vite-plugin-dts": "^4.5.3",
+    "vitest": "^3.1.1"
+  }
+}