@loro-dev/flock 1.1.1 → 2.0.1

package/src/index.ts

@@ -75,7 +75,7 @@ export type ExportRecord = {
   m?: MetadataMap;
 };
 
-export type ExportBundle = Record<string, ExportRecord>;
+export type ExportBundle = { version: number, entries: Record<string, ExportRecord> };
 
 export type EntryClock = {
   physicalTime: number;
@@ -495,9 +495,9 @@ function decodeImportReport(raw: unknown): ImportReport {
 }
 
 function cloneBundle(bundle: ExportBundle): ExportBundle {
-  const next: ExportBundle = {};
-  for (const [key, record] of Object.entries(bundle)) {
-    next[key] = cloneRecord(record);
+  const next: ExportBundle = { version: bundle.version, entries: {} };
+  for (const [key, record] of Object.entries(bundle.entries)) {
+    next.entries[key] = cloneRecord(record);
   }
   return next;
 }
@@ -592,6 +592,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 +614,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);
   }
@@ -634,8 +645,8 @@ export class Flock {
     if (!transform) {
       return base;
     }
-    const result: ExportBundle = {};
-    for (const [key, record] of Object.entries(base)) {
+    const result: ExportBundle = { version: base.version, entries: {} };
+    for (const [key, record] of Object.entries(base.entries)) {
       const context = buildContext(key, record);
       const basePayload = createExportPayload(record);
       const workingPayload = clonePayload(basePayload);
@@ -644,7 +655,7 @@ export class Flock {
         basePayload,
         transformed ?? workingPayload,
       );
-      result[key] = buildRecord(record.c, finalPayload);
+      result.entries[key] = buildRecord(record.c, finalPayload);
     }
     return result;
   }
@@ -674,8 +685,8 @@ export class Flock {
     const working = preprocess ? cloneBundle(options.bundle) : options.bundle;
     const skippedByHooks: Array<{ key: KeyPart[]; reason: string }> = [];
     if (preprocess) {
-      for (const key of Object.keys(working)) {
-        const record = working[key];
+      for (const key of Object.keys(working.entries)) {
+        const record = working.entries[key];
         if (!record) {
           continue;
         }
@@ -685,10 +696,10 @@ export class Flock {
         const normalized = normalizeImportDecision(decision);
         if (!normalized.accept) {
           skippedByHooks.push({ key: context.key, reason: normalized.reason });
-          delete working[key];
+          delete working.entries[key];
           continue;
         }
-        working[key] = buildRecord(record.c, basePayload);
+        working.entries[key] = buildRecord(record.c, basePayload);
       }
     }
     const coreReport = this.importJsonInternal(working);

package/src/moonbit.d.ts

@@ -0,0 +1,57 @@
+/**
+ * A non-public unique symbol used to mark the brand of a type.
+ * And avoid user to construct values of the type.
+ */
+export const __brand: unique symbol;
+
+export type Unit = undefined;
+export type Bool = boolean;
+
+/**
+ * A signed integer in 32-bit two's complement format.
+ */
+export type Int = number;
+
+/**
+ * An unsigned integer in 32-bit two's complement format.
+ */
+export type UInt = number;
+
+/**
+ * A character in the range 0-0x10FFFF.
+ */
+export type Char = number;
+
+/**
+ * A byte in the range 0-255.
+ */
+export type Byte = number;
+
+/**
+ * Single-precision floating point number.
+ */
+export type Float = number;
+
+export type Double = number;
+
+export type Int64 = { [__brand]: 568910272 };
+
+export type UInt64 = { [__brand]: 689305396 };
+
+export type String = string;
+
+export type Bytes = Uint8Array;
+
+export type FixedArray<T> = T[];
+
+export type UnboxedOption<T> = 
+  | /* Some */ T 
+  | /* None */ undefined;
+
+export type UnboxedOptionAsInt<T> = 
+  | /* Some */ T 
+  | /* None */ -1;
+
+export type Result<T, E> =
+  | /* Ok */ { $tag: 1, _0: T }
+  | /* Err */ { $tag: 0, _0: E };