@dabble/patches 0.5.3 → 0.5.5

package/dist/algorithms/shared/lz.js

@@ -0,0 +1,456 @@
+import "../../chunk-IZ2YBCUP.js";
+const f = String.fromCharCode;
+const keyStrBase64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+const keyStrUriSafe = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+-$";
+const baseReverseDic = {};
+function compress(uncompressed) {
+  return _compress(uncompressed, 16, (a) => f(a));
+}
+function decompress(compressed) {
+  if (compressed == null) return "";
+  if (compressed === "") return null;
+  return _decompress(compressed.length, 32768, (index) => compressed.charCodeAt(index));
+}
+function compressToBase64(input) {
+  if (input == null) return "";
+  const res = _compress(input, 6, (a) => keyStrBase64.charAt(a));
+  switch (res.length % 4) {
+    case 0:
+      return res;
+    case 1:
+      return res + "===";
+    case 2:
+      return res + "==";
+    case 3:
+      return res + "=";
+    default:
+      return res;
+  }
+}
+function decompressFromBase64(input) {
+  if (input == null) return "";
+  if (input === "") return null;
+  return _decompress(input.length, 32, (index) => getBaseValue(keyStrBase64, input.charAt(index)));
+}
+function compressToUTF16(input) {
+  if (input == null) return "";
+  return _compress(input, 15, (a) => f(a + 32)) + " ";
+}
+function decompressFromUTF16(compressed) {
+  if (compressed == null) return "";
+  if (compressed === "") return null;
+  return _decompress(compressed.length, 16384, (index) => compressed.charCodeAt(index) - 32);
+}
+function compressToUint8Array(uncompressed) {
+  const compressed = compress(uncompressed);
+  const buf = new Uint8Array(compressed.length * 2);
+  for (let i = 0, length = compressed.length; i < length; i++) {
+    const currentValue = compressed.charCodeAt(i);
+    buf[i * 2] = currentValue >>> 8;
+    buf[i * 2 + 1] = currentValue % 256;
+  }
+  return buf;
+}
+function decompressFromUint8Array(compressed) {
+  if (compressed == null) {
+    return decompress(null);
+  } else {
+    const buf = new Array(compressed.length / 2);
+    for (let i = 0, length = buf.length; i < length; i++) {
+      buf[i] = compressed[i * 2] * 256 + compressed[i * 2 + 1];
+    }
+    const result = [];
+    buf.forEach((c) => result.push(f(c)));
+    return decompress(result.join(""));
+  }
+}
+function compressToEncodedURIComponent(input) {
+  if (input == null) return "";
+  return _compress(input, 6, (a) => keyStrUriSafe.charAt(a));
+}
+function decompressFromEncodedURIComponent(input) {
+  if (input == null) return "";
+  if (input === "") return null;
+  const normalizedInput = input.replace(/ /g, "+");
+  return _decompress(
+    normalizedInput.length,
+    32,
+    (index) => getBaseValue(keyStrUriSafe, normalizedInput.charAt(index))
+  );
+}
+function getBaseValue(alphabet, character) {
+  if (!baseReverseDic[alphabet]) {
+    baseReverseDic[alphabet] = {};
+    for (let i = 0; i < alphabet.length; i++) {
+      baseReverseDic[alphabet][alphabet.charAt(i)] = i;
+    }
+  }
+  return baseReverseDic[alphabet][character];
+}
+function _compress(uncompressed, bitsPerChar, getCharFromInt) {
+  if (uncompressed == null) return "";
+  let i;
+  let value;
+  const context_dictionary = {};
+  const context_dictionaryToCreate = {};
+  let context_c = "";
+  let context_wc = "";
+  let context_w = "";
+  let context_enlargeIn = 2;
+  let context_dictSize = 3;
+  let context_numBits = 2;
+  const context_data = [];
+  let context_data_val = 0;
+  let context_data_position = 0;
+  for (let ii = 0; ii < uncompressed.length; ii += 1) {
+    context_c = uncompressed.charAt(ii);
+    if (!Object.prototype.hasOwnProperty.call(context_dictionary, context_c)) {
+      context_dictionary[context_c] = context_dictSize++;
+      context_dictionaryToCreate[context_c] = true;
+    }
+    context_wc = context_w + context_c;
+    if (Object.prototype.hasOwnProperty.call(context_dictionary, context_wc)) {
+      context_w = context_wc;
+    } else {
+      if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+        if (context_w.charCodeAt(0) < 256) {
+          for (i = 0; i < context_numBits; i++) {
+            context_data_val = context_data_val << 1;
+            if (context_data_position === bitsPerChar - 1) {
+              context_data_position = 0;
+              context_data.push(getCharFromInt(context_data_val));
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+          }
+          value = context_w.charCodeAt(0);
+          for (i = 0; i < 8; i++) {
+            context_data_val = context_data_val << 1 | value & 1;
+            if (context_data_position === bitsPerChar - 1) {
+              context_data_position = 0;
+              context_data.push(getCharFromInt(context_data_val));
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = value >> 1;
+          }
+        } else {
+          value = 1;
+          for (i = 0; i < context_numBits; i++) {
+            context_data_val = context_data_val << 1 | value;
+            if (context_data_position === bitsPerChar - 1) {
+              context_data_position = 0;
+              context_data.push(getCharFromInt(context_data_val));
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = 0;
+          }
+          value = context_w.charCodeAt(0);
+          for (i = 0; i < 16; i++) {
+            context_data_val = context_data_val << 1 | value & 1;
+            if (context_data_position === bitsPerChar - 1) {
+              context_data_position = 0;
+              context_data.push(getCharFromInt(context_data_val));
+              context_data_val = 0;
+            } else {
+              context_data_position++;
+            }
+            value = value >> 1;
+          }
+        }
+        context_enlargeIn--;
+        if (context_enlargeIn === 0) {
+          context_enlargeIn = Math.pow(2, context_numBits);
+          context_numBits++;
+        }
+        delete context_dictionaryToCreate[context_w];
+      } else {
+        value = context_dictionary[context_w];
+        for (i = 0; i < context_numBits; i++) {
+          context_data_val = context_data_val << 1 | value & 1;
+          if (context_data_position === bitsPerChar - 1) {
+            context_data_position = 0;
+            context_data.push(getCharFromInt(context_data_val));
+            context_data_val = 0;
+          } else {
+            context_data_position++;
+          }
+          value = value >> 1;
+        }
+      }
+      context_enlargeIn--;
+      if (context_enlargeIn === 0) {
+        context_enlargeIn = Math.pow(2, context_numBits);
+        context_numBits++;
+      }
+      context_dictionary[context_wc] = context_dictSize++;
+      context_w = String(context_c);
+    }
+  }
+  if (context_w !== "") {
+    if (Object.prototype.hasOwnProperty.call(context_dictionaryToCreate, context_w)) {
+      if (context_w.charCodeAt(0) < 256) {
+        for (i = 0; i < context_numBits; i++) {
+          context_data_val = context_data_val << 1;
+          if (context_data_position === bitsPerChar - 1) {
+            context_data_position = 0;
+            context_data.push(getCharFromInt(context_data_val));
+            context_data_val = 0;
+          } else {
+            context_data_position++;
+          }
+        }
+        value = context_w.charCodeAt(0);
+        for (i = 0; i < 8; i++) {
+          context_data_val = context_data_val << 1 | value & 1;
+          if (context_data_position === bitsPerChar - 1) {
+            context_data_position = 0;
+            context_data.push(getCharFromInt(context_data_val));
+            context_data_val = 0;
+          } else {
+            context_data_position++;
+          }
+          value = value >> 1;
+        }
+      } else {
+        value = 1;
+        for (i = 0; i < context_numBits; i++) {
+          context_data_val = context_data_val << 1 | value;
+          if (context_data_position === bitsPerChar - 1) {
+            context_data_position = 0;
+            context_data.push(getCharFromInt(context_data_val));
+            context_data_val = 0;
+          } else {
+            context_data_position++;
+          }
+          value = 0;
+        }
+        value = context_w.charCodeAt(0);
+        for (i = 0; i < 16; i++) {
+          context_data_val = context_data_val << 1 | value & 1;
+          if (context_data_position === bitsPerChar - 1) {
+            context_data_position = 0;
+            context_data.push(getCharFromInt(context_data_val));
+            context_data_val = 0;
+          } else {
+            context_data_position++;
+          }
+          value = value >> 1;
+        }
+      }
+      context_enlargeIn--;
+      if (context_enlargeIn === 0) {
+        context_enlargeIn = Math.pow(2, context_numBits);
+        context_numBits++;
+      }
+      delete context_dictionaryToCreate[context_w];
+    } else {
+      value = context_dictionary[context_w];
+      for (i = 0; i < context_numBits; i++) {
+        context_data_val = context_data_val << 1 | value & 1;
+        if (context_data_position === bitsPerChar - 1) {
+          context_data_position = 0;
+          context_data.push(getCharFromInt(context_data_val));
+          context_data_val = 0;
+        } else {
+          context_data_position++;
+        }
+        value = value >> 1;
+      }
+    }
+    context_enlargeIn--;
+    if (context_enlargeIn === 0) {
+      context_enlargeIn = Math.pow(2, context_numBits);
+      context_numBits++;
+    }
+  }
+  value = 2;
+  for (i = 0; i < context_numBits; i++) {
+    context_data_val = context_data_val << 1 | value & 1;
+    if (context_data_position === bitsPerChar - 1) {
+      context_data_position = 0;
+      context_data.push(getCharFromInt(context_data_val));
+      context_data_val = 0;
+    } else {
+      context_data_position++;
+    }
+    value = value >> 1;
+  }
+  while (true) {
+    context_data_val = context_data_val << 1;
+    if (context_data_position === bitsPerChar - 1) {
+      context_data.push(getCharFromInt(context_data_val));
+      break;
+    } else context_data_position++;
+  }
+  return context_data.join("");
+}
+function _decompress(length, resetValue, getNextValue) {
+  const dictionary = [];
+  let enlargeIn = 4;
+  let dictSize = 4;
+  let numBits = 3;
+  let entry = "";
+  const result = [];
+  let w;
+  let bits;
+  let resb;
+  let maxpower;
+  let power;
+  let c;
+  const data = { val: getNextValue(0), position: resetValue, index: 1 };
+  for (let i = 0; i < 3; i += 1) {
+    dictionary[i] = i;
+  }
+  bits = 0;
+  maxpower = Math.pow(2, 2);
+  power = 1;
+  while (power !== maxpower) {
+    resb = data.val & data.position;
+    data.position >>= 1;
+    if (data.position === 0) {
+      data.position = resetValue;
+      data.val = getNextValue(data.index++);
+    }
+    bits |= (resb > 0 ? 1 : 0) * power;
+    power <<= 1;
+  }
+  const next = bits;
+  switch (next) {
+    case 0:
+      bits = 0;
+      maxpower = Math.pow(2, 8);
+      power = 1;
+      while (power !== maxpower) {
+        resb = data.val & data.position;
+        data.position >>= 1;
+        if (data.position === 0) {
+          data.position = resetValue;
+          data.val = getNextValue(data.index++);
+        }
+        bits |= (resb > 0 ? 1 : 0) * power;
+        power <<= 1;
+      }
+      c = f(bits);
+      break;
+    case 1:
+      bits = 0;
+      maxpower = Math.pow(2, 16);
+      power = 1;
+      while (power !== maxpower) {
+        resb = data.val & data.position;
+        data.position >>= 1;
+        if (data.position === 0) {
+          data.position = resetValue;
+          data.val = getNextValue(data.index++);
+        }
+        bits |= (resb > 0 ? 1 : 0) * power;
+        power <<= 1;
+      }
+      c = f(bits);
+      break;
+    case 2:
+      return "";
+    default:
+      return "";
+  }
+  dictionary[3] = c;
+  w = c;
+  result.push(c);
+  while (true) {
+    if (data.index > length) {
+      return "";
+    }
+    bits = 0;
+    maxpower = Math.pow(2, numBits);
+    power = 1;
+    while (power !== maxpower) {
+      resb = data.val & data.position;
+      data.position >>= 1;
+      if (data.position === 0) {
+        data.position = resetValue;
+        data.val = getNextValue(data.index++);
+      }
+      bits |= (resb > 0 ? 1 : 0) * power;
+      power <<= 1;
+    }
+    c = bits;
+    switch (c) {
+      case 0:
+        bits = 0;
+        maxpower = Math.pow(2, 8);
+        power = 1;
+        while (power !== maxpower) {
+          resb = data.val & data.position;
+          data.position >>= 1;
+          if (data.position === 0) {
+            data.position = resetValue;
+            data.val = getNextValue(data.index++);
+          }
+          bits |= (resb > 0 ? 1 : 0) * power;
+          power <<= 1;
+        }
+        dictionary[dictSize++] = f(bits);
+        c = dictSize - 1;
+        enlargeIn--;
+        break;
+      case 1:
+        bits = 0;
+        maxpower = Math.pow(2, 16);
+        power = 1;
+        while (power !== maxpower) {
+          resb = data.val & data.position;
+          data.position >>= 1;
+          if (data.position === 0) {
+            data.position = resetValue;
+            data.val = getNextValue(data.index++);
+          }
+          bits |= (resb > 0 ? 1 : 0) * power;
+          power <<= 1;
+        }
+        dictionary[dictSize++] = f(bits);
+        c = dictSize - 1;
+        enlargeIn--;
+        break;
+      case 2:
+        return result.join("");
+    }
+    if (enlargeIn === 0) {
+      enlargeIn = Math.pow(2, numBits);
+      numBits++;
+    }
+    if (dictionary[c]) {
+      entry = dictionary[c];
+    } else {
+      if (c === dictSize) {
+        entry = w + w.charAt(0);
+      } else {
+        return null;
+      }
+    }
+    result.push(entry);
+    dictionary[dictSize++] = w + entry.charAt(0);
+    enlargeIn--;
+    w = entry;
+    if (enlargeIn === 0) {
+      enlargeIn = Math.pow(2, numBits);
+      numBits++;
+    }
+  }
+}
+export {
+  compress,
+  compressToBase64,
+  compressToEncodedURIComponent,
+  compressToUTF16,
+  compressToUint8Array,
+  decompress,
+  decompressFromBase64,
+  decompressFromEncodedURIComponent,
+  decompressFromUTF16,
+  decompressFromUint8Array
+};

package/dist/client/Patches.d.ts

@@ -5,6 +5,7 @@ import { PatchesStore } from './PatchesStore.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
+import '../algorithms/shared/changeBatching.js';
 
 interface PatchesOptions {
     /** Persistence layer instance (e.g., new IndexedDBStore('my-db') or new InMemoryStore()). */

package/dist/client/PatchesDoc.d.ts

@@ -1,4 +1,5 @@
 import { Signal, Unsubscriber } from '../event-signal.js';
+import { SizeCalculator } from '../algorithms/shared/changeBatching.js';
 import { PatchesSnapshot, SyncingState, Change, ChangeMutator } from '../types.js';
 import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
@@ -9,10 +10,20 @@ import '../json-patch/types.js';
  */
 interface PatchesDocOptions {
     /**
-     * Maximum size in bytes for a single payload (network message).
-     * Changes exceeding this will be split into multiple smaller changes.
+     * Maximum size in bytes for a single change's storage representation.
+     * Changes exceeding this will be split. Used for backends with row size limits.
      */
-    maxPayloadBytes?: number;
+    maxStorageBytes?: number;
+    /**
+     * Custom size calculator for storage limit checks.
+     * Import from '@dabble/patches/compression' for actual compression measurement,
+     * or provide your own function (e.g., ratio estimate).
+     *
+     * @example
+     * import { compressedSizeBase64 } from '@dabble/patches/compression';
+     * { sizeCalculator: compressedSizeBase64, maxStorageBytes: 1_000_000 }
+     */
+    sizeCalculator?: SizeCalculator;
 }
 /**
  * Represents a document synchronized using JSON patches.
@@ -25,7 +36,8 @@ declare class PatchesDoc<T extends object = object> {
     protected _snapshot: PatchesSnapshot<T>;
     protected _changeMetadata: Record<string, any>;
     protected _syncing: SyncingState;
-    protected readonly _maxPayloadBytes?: number;
+    protected readonly _maxStorageBytes?: number;
+    protected readonly _sizeCalculator?: SizeCalculator;
     /** Subscribe to be notified before local state changes. */
     readonly onBeforeChange: Signal<(change: Change) => void>;
     /** Subscribe to be notified after local state changes are applied. */

package/dist/client/PatchesDoc.js

@@ -9,7 +9,8 @@ class PatchesDoc {
   _snapshot;
   _changeMetadata = {};
   _syncing = null;
-  _maxPayloadBytes;
+  _maxStorageBytes;
+  _sizeCalculator;
   /** Subscribe to be notified before local state changes. */
   onBeforeChange = signal();
   /** Subscribe to be notified after local state changes are applied. */
@@ -28,7 +29,8 @@ class PatchesDoc {
     this._state = structuredClone(initialState);
     this._snapshot = { state: this._state, rev: 0, changes: [] };
     this._changeMetadata = initialMetadata;
-    this._maxPayloadBytes = options.maxPayloadBytes;
+    this._maxStorageBytes = options.maxStorageBytes;
+    this._sizeCalculator = options.sizeCalculator;
   }
   /** The unique identifier for this document, once assigned. */
   get id() {
@@ -86,7 +88,7 @@ class PatchesDoc {
    * @returns The generated Change objects.
    */
   change(mutator) {
-    const changes = makeChange(this._snapshot, mutator, this._changeMetadata, this._maxPayloadBytes);
+    const changes = makeChange(this._snapshot, mutator, this._changeMetadata, this._maxStorageBytes, this._sizeCalculator);
     if (changes.length === 0) {
       return changes;
     }

package/dist/client/index.d.ts

@@ -9,4 +9,5 @@ import '../json-patch/JSONPatch.js';
 import '@dabble/delta';
 import '../json-patch/types.js';
 import '../event-signal.js';
+import '../algorithms/shared/changeBatching.js';
 import '../net/protocol/types.js';

package/dist/compression/index.d.ts

@@ -0,0 +1,67 @@
+export { compressToBase64, compressToUint8Array, decompressFromBase64, decompressFromUint8Array } from '../algorithms/shared/lz.js';
+import { JSONPatchOp } from '../json-patch/types.js';
+
+/**
+ * Tree-shakable compression utilities for Patches.
+ *
+ * This module provides compression functionality that is only bundled
+ * when explicitly imported. If you don't use compression, these ~18KB
+ * won't be included in your bundle.
+ *
+ * @example Client: Size calculator for change splitting
+ * ```typescript
+ * import { compressedSizeBase64 } from '@dabble/patches/compression';
+ *
+ * new PatchesDoc(state, {}, {
+ *   sizeCalculator: compressedSizeBase64,
+ *   maxStorageBytes: 1_000_000
+ * });
+ * ```
+ *
+ * @example Server: Compressor for storage backend
+ * ```typescript
+ * import { base64Compressor } from '@dabble/patches/compression';
+ *
+ * const backend = new CompressedStoreBackend(store, base64Compressor);
+ * ```
+ */
+
+/**
+ * Function that calculates the storage size of data.
+ * Used by change batching to determine if changes need to be split.
+ */
+type SizeCalculator = (data: unknown) => number;
+/**
+ * Calculate size after base64 LZ compression.
+ * Use this when your server uses base64 compression format.
+ */
+declare const compressedSizeBase64: SizeCalculator;
+/**
+ * Calculate size after uint8array LZ compression.
+ * Use this when your server uses binary compression format.
+ */
+declare const compressedSizeUint8: SizeCalculator;
+/**
+ * Interface for compressing/decompressing JSON Patch operations.
+ * Passed to CompressedStoreBackend to enable transparent compression.
+ */
+interface OpsCompressor {
+    /** Compress ops to string or binary format */
+    compress: (ops: JSONPatchOp[]) => string | Uint8Array;
+    /** Decompress string or binary back to ops array */
+    decompress: (compressed: string | Uint8Array) => JSONPatchOp[];
+    /** Type guard to check if ops are in compressed format */
+    isCompressed: (ops: unknown) => ops is string | Uint8Array;
+}
+/**
+ * Compressor that uses base64 encoding.
+ * Works with any storage backend that supports strings.
+ */
+declare const base64Compressor: OpsCompressor;
+/**
+ * Compressor that uses binary Uint8Array format.
+ * More efficient storage but requires backend that supports binary data.
+ */
+declare const uint8Compressor: OpsCompressor;
+
+export { type OpsCompressor, type SizeCalculator, base64Compressor, compressedSizeBase64, compressedSizeUint8, uint8Compressor };

package/dist/compression/index.js

@@ -0,0 +1,47 @@
+import "../chunk-IZ2YBCUP.js";
+import {
+  compressToBase64,
+  compressToUint8Array,
+  decompressFromBase64,
+  decompressFromUint8Array
+} from "../algorithms/shared/lz.js";
+const compressedSizeBase64 = (data) => {
+  if (data === void 0) return 0;
+  try {
+    const json = JSON.stringify(data);
+    if (!json) return 0;
+    return compressToBase64(json).length;
+  } catch {
+    return 0;
+  }
+};
+const compressedSizeUint8 = (data) => {
+  if (data === void 0) return 0;
+  try {
+    const json = JSON.stringify(data);
+    if (!json) return 0;
+    return compressToUint8Array(json).length;
+  } catch {
+    return 0;
+  }
+};
+const base64Compressor = {
+  compress: (ops) => compressToBase64(JSON.stringify(ops)),
+  decompress: (compressed) => JSON.parse(decompressFromBase64(compressed) || "[]"),
+  isCompressed: (ops) => typeof ops === "string"
+};
+const uint8Compressor = {
+  compress: (ops) => compressToUint8Array(JSON.stringify(ops)),
+  decompress: (compressed) => JSON.parse(decompressFromUint8Array(compressed) || "[]"),
+  isCompressed: (ops) => ops instanceof Uint8Array
+};
+export {
+  base64Compressor,
+  compressToBase64,
+  compressToUint8Array,
+  compressedSizeBase64,
+  compressedSizeUint8,
+  decompressFromBase64,
+  decompressFromUint8Array,
+  uint8Compressor
+};

package/dist/index.d.ts

@@ -26,4 +26,5 @@ export { move } from './json-patch/ops/move.js';
 export { remove } from './json-patch/ops/remove.js';
 export { replace } from './json-patch/ops/replace.js';
 export { test } from './json-patch/ops/test.js';
+import './algorithms/shared/changeBatching.js';
 import './net/protocol/types.js';

package/dist/json-patch/utils/log.d.ts

@@ -1,4 +1,4 @@
-declare let log: (...data: any[]) => void;
+declare let log: (...args: any[]) => void;
 declare function verbose(value: boolean): void;
 
 export { log, verbose };

package/dist/json-patch/utils/log.js

@@ -1,5 +1,5 @@
 import "../../chunk-IZ2YBCUP.js";
-let log = console.log;
+let log = () => void 0;
 function verbose(value) {
   log = value ? console.log : () => void 0;
 }