@loro-dev/flock 2.0.0 → 2.1.0

package/src/index.ts

@@ -38,6 +38,7 @@ type MaybePromise<T> = T | Promise<T>;
 type ExportOptions = {
   from?: VersionVector;
   hooks?: ExportHooks;
+  pruneTombstonesBefore?: number;
 };
 
 type ImportOptions = {
@@ -246,6 +247,16 @@ function encodeVersionVector(vv?: VersionVector): RawVersionVector | undefined {
   return raw;
 }
 
+function normalizePruneBefore(pruneTombstonesBefore?: number): number | undefined {
+  if (pruneTombstonesBefore === undefined) {
+    return undefined;
+  }
+  if (typeof pruneTombstonesBefore !== "number" || !Number.isFinite(pruneTombstonesBefore)) {
+    return undefined;
+  }
+  return pruneTombstonesBefore;
+}
+
 function decodeVersionVector(raw: unknown): VersionVector {
   if (raw === null || typeof raw !== "object") {
     return {};
@@ -507,7 +518,11 @@ function isExportOptions(value: unknown): value is ExportOptions {
     typeof value === "object" &&
     value !== null &&
     (Object.prototype.hasOwnProperty.call(value, "hooks") ||
-      Object.prototype.hasOwnProperty.call(value, "from"))
+      Object.prototype.hasOwnProperty.call(value, "from") ||
+      Object.prototype.hasOwnProperty.call(
+        value,
+        "pruneTombstonesBefore",
+      ))
   );
 }
 
@@ -592,6 +607,12 @@ export class Flock {
     );
   }
 
+  /**
+   * Put a value into the flock. If the given entry already exists, this insert will be skipped.
+   * @param key 
+   * @param value 
+   * @param now 
+   */
   put(key: KeyPart[], value: Value, now?: number): void {
     put_json_ffi(this.inner, key, value, now);
   }
@@ -608,6 +629,11 @@ export class Flock {
     this.put(key, value, now);
   }
 
+  /**
+   * Delete a value from the flock. If the given entry does not exist, this delete will be skipped.
+   * @param key 
+   * @param now 
+   */
   delete(key: KeyPart[], now?: number): void {
     delete_ffi(this.inner, key, now);
   }
@@ -624,12 +650,23 @@ export class Flock {
     return decodeVersionVector(version_ffi(this.inner));
   }
 
-  private exportJsonInternal(from?: VersionVector): ExportBundle {
-    return export_json_ffi(this.inner, encodeVersionVector(from)) as ExportBundle;
+  private exportJsonInternal(
+    from?: VersionVector,
+    pruneTombstonesBefore?: number,
+  ): ExportBundle {
+    const pruneBefore = normalizePruneBefore(pruneTombstonesBefore);
+    return export_json_ffi(
+      this.inner,
+      encodeVersionVector(from),
+      pruneBefore,
+    ) as ExportBundle;
   }
 
   private async exportJsonWithHooks(options: ExportOptions): Promise<ExportBundle> {
-    const base = this.exportJsonInternal(options.from);
+    const base = this.exportJsonInternal(
+      options.from,
+      options.pruneTombstonesBefore,
+    );
     const transform = options.hooks?.transform;
     if (!transform) {
       return base;
@@ -651,17 +688,22 @@ export class Flock {
 
   exportJson(): ExportBundle;
   exportJson(from: VersionVector): ExportBundle;
+  exportJson(
+    from: VersionVector,
+    pruneTombstonesBefore: number,
+  ): ExportBundle;
   exportJson(options: ExportOptions): Promise<ExportBundle>;
   exportJson(
     arg?: VersionVector | ExportOptions,
+    pruneTombstonesBefore?: number,
   ): ExportBundle | Promise<ExportBundle> {
     if (arg === undefined) {
-      return this.exportJsonInternal();
+      return this.exportJsonInternal(undefined, pruneTombstonesBefore);
     }
     if (isExportOptions(arg)) {
       return this.exportJsonWithHooks(arg);
     }
-    return this.exportJsonInternal(arg);
+    return this.exportJsonInternal(arg, pruneTombstonesBefore);
   }
 
   private importJsonInternal(bundle: ExportBundle): ImportReport {