lib0 1.0.0-rc.7 → 1.0.0-rc.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "1.0.0-rc.7",
+  "version": "1.0.0-rc.9",
   "description": "",
   "sideEffects": false,
   "type": "module",
@@ -272,6 +272,7 @@
   "devDependencies": {
     "@types/node": "^24.11.0",
     "c8": "^10.1.3",
+    "dpdm": "^4.0.1",
     "standard": "^17.1.0",
     "typescript": "^5.9.3"
   },
@@ -280,15 +281,15 @@
     "types": "rm -rf types && tsc -p tsconfig.build.json",
     "dist": "npm run clean && npm run types",
     "debug": "npm run gentesthtml && node ./src/bin/0serve.js -o test.html",
-    "test": "c8 --check-coverage --lines 100 --branches 100 --functions 100 --statements 100 node --unhandled-rejections=strict ./src/test.js --repetition-time 50",
+    "test": "c8 --check-coverage --lines 97 --branches 96 --functions 94 --statements 97 node --unhandled-rejections=strict ./src/test.js",
+    "test:deno": "deno run -A src/test.js",
     "test-inspect": "node --inspect-brk --unhandled-rejections=strict ./src/test.js --repetition-time 50",
-    "test-extensive": "c8 --check-coverage --lines 100 --branches 100 --functions 100 --statements 100 node ./src/test.js --repetition-time 30000 --extensive",
+    "test-extensive": "node ./src/test.js --repetition-time 1000 --extensive",
     "test:bundle": "esbuild bundle.test.js --bundle --outfile=dist/bundle.test.js --analyze --minify && wc -c dist/bundle.test.js",
     "trace-deopt": "clear && node --trace-deopt src/test.js",
     "trace-opt": "clear && node --trace-opt src/test.js",
-    "lint": "tsc && standard",
+    "lint": "tsc && standard && npx dpdm --exit-code circular:1 --warning false --tree false src/test.js",
     "gendocs": "node ./bin/gendocs.js",
-    "release": "npm run dist && np --test-script dist",
     "version": "npm run clean && npm run dist && git add README.md",
     "postpublish": "npm run clean",
     "gentesthtml": "node ./src/bin/gentesthtml.js --script src/test.js > test.html"

package/src/broadcastchannel.js

@@ -44,6 +44,10 @@ class LocalStoragePolyfill {
      * @type {null|function({data:Uint8Array}):void}
      */
     this.onmessage = null
+    /**
+     * @type {null|((this: BroadcastChannel, ev: MessageEvent) => any)}
+     */
+    this.onmessageerror = null
     /**
      * @param {any} e
      */
@@ -79,8 +83,9 @@ const getChannel = room =>
     /**
      * @param {{data:ArrayBuffer}} e
      */
-    /* c8 ignore next */
+    /* c8 ignore next 3 */
     bc.onmessage = e => subs.forEach(sub => sub(e.data, 'broadcastchannel'))
+    bc.onmessageerror = e => console.error('broadcastchannel error', e)
     return {
       bc, subs
     }

package/src/delta/delta.js

@@ -972,6 +972,9 @@ class DeltaData {
      * >}
      */
     this.children = /** @type {any} */ (list.create())
+    /**
+     * All child-ops sizes combined. Note that delete-ops also have a length
+     */
     this.childCnt = 0
     /**
      * @type {any}
@@ -982,6 +985,10 @@ class DeltaData {
      */
     this._fingerprint = null
     this.isDone = false
+    /**
+     * Is the final document and does not contain delete, modify, or retain ops.
+     */
+    this.isFinal = false
   }
 }
 
@@ -1461,9 +1468,21 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
+   * Apply other delta on this op. The result is the merged op of both of them.
+   *
+   * a.apply(b.apply(c))
+   *
+   * is equivalent to
+   *
+   * a.apply(b).apply(c)
+   *
+   * @todo fuzz test the above property
+   *
    * @param {Delta<Conf>?} other
+   * @param {{ final?: boolean }} opts -- experimental
+   * @return {Delta<Conf>}
    */
-  apply (other) {
+  apply (other, { final = this.isFinal } = {}) {
     if (other == null) return this
     modDeltaCheck(this)
     this.$schema?.expect(other)
@@ -1486,8 +1505,13 @@ export class DeltaBuilder extends Delta {
         this.attrs[op.key] = op.clone()
       } else if ($deleteAttrOp.check(op)) {
         op.prevValue = c?.value
-        // @ts-ignore
-        delete this.attrs[op.key]
+        if (final) {
+          // @ts-ignore
+          delete this.attrs[op.key]
+        } else {
+          // @ts-ignore
+          this.attrs[op.key] = op.clone()
+        }
       }
     }
     // apply children
@@ -1495,6 +1519,9 @@ export class DeltaBuilder extends Delta {
      * @type {ChildrenOpAny?}
      */
     let opsI = this.children.start
+    if ($deleteOp.check(opsI)) {
+      opsI = opNextUndeleted(opsI)
+    }
     let offset = 0
     /**
      * At the end, we will try to merge this op, and op.next op with their respective previous op.
@@ -1506,57 +1533,63 @@ export class DeltaBuilder extends Delta {
      */
     const maybeMergeable = []
     /**
-     * @template {InsertOp<any>|RetainOp|DeleteOp|TextOp|ModifyOp<any>|null} OP
-     * @param {OP} op
-     * @return {OP}
+     * Schedule an op to be merged later
+     * @param {ChildrenOpAny?} op
+     * @return {ChildrenOpAny}
      */
     const scheduleForMerge = op => {
       op && maybeMergeable.push(op)
-      return op
+      return /** @type {any} */ (op)
+    }
+
+    /**
+     * Split opsI at the current offset - ensuring that we can insert safely at the current position
+     */
+    const splitHere = () => {
+      if (offset > 0 && opsI != null) {
+        const rightPart = scheduleForMerge(opsI.clone(offset))
+        opsI._splice(offset, opsI.length - offset)
+        list.insertBetween(this.children, opsI, opsI.next || null, rightPart)
+        offset = 0
+        opsI = rightPart
+      }
+    }
+    /**
+     * @param {ChildrenOpAny} op
+     */
+    const insertClonedOp = op => {
+      splitHere()
+      list.insertBetween(this.children, opsI == null ? this.children.end : opsI.prev, opsI, scheduleForMerge(op.clone()))
+      this.childCnt += op.length
     }
-    other.children.forEach(op => {
+    for (const op of other.children) {
+      if (opsI?.length === offset) {
+        opsI = opNextUndeleted(opsI)
+        offset = 0
+      }
       if ($textOp.check(op) || $insertOp.check(op)) {
-        if (offset === 0) {
-          list.insertBetween(this.children, opsI == null ? this.children.end : opsI.prev, opsI, scheduleForMerge(op.clone()))
-        } else {
-          // @todo inmplement "splitHelper" and "insertHelper" - I'm splitting all the time and
-          // forget to update opsI
-          if (opsI == null) error.unexpectedCase()
-          const cpy = scheduleForMerge(opsI.clone(offset))
-          opsI._splice(offset, opsI.length - offset)
-          list.insertBetween(this.children, opsI, opsI.next || null, cpy)
-          list.insertBetween(this.children, opsI, cpy || null, scheduleForMerge(op.clone()))
-          opsI = cpy
-          offset = 0
-        }
-        this.childCnt += op.insert.length
+        insertClonedOp(op)
       } else if ($retainOp.check(op)) {
         let retainLen = op.length
-
-        if (offset > 0 && opsI != null && op.format != null && !$deleteOp.check(opsI) && !object.every(op.format, (v, k) => fun.equalityDeep(v, /** @type {InsertOp<any>|RetainOp|ModifyOp} */ (opsI).format?.[k] || null))) {
+        if (offset > 0 && opsI != null && op.format != null && !$deleteOp.check(opsI) && (/** @type {InsertOp<any>|RetainOp|ModifyOp} */ (opsI).format == null || !fun.equalityDeep(opsI.format, op.format))) {
           // need to split current op
-          const cpy = scheduleForMerge(opsI.clone(offset))
-          opsI._splice(offset, opsI.length - offset)
-          list.insertBetween(this.children, opsI, opsI.next || null, cpy)
-          opsI = cpy
-          offset = 0
+          splitHere()
         }
-
         while (opsI != null && opsI.length - offset <= retainLen) {
-          op.format != null && updateOpFormat(opsI, op.format)
+          if (op.format != null) {
+            updateOpFormat(opsI, op.format)
+            scheduleForMerge(opsI)
+          }
           retainLen -= opsI.length - offset
-          opsI = opsI?.next || null
+          opsI = opNextUndeleted(opsI)
           offset = 0
         }
-
         if (opsI != null) {
           if (op.format != null && retainLen > 0) {
-            // split current op and apply format
-            const cpy = scheduleForMerge(opsI.clone(retainLen))
-            opsI._splice(retainLen, opsI.length - retainLen)
-            list.insertBetween(this.children, opsI, opsI.next || null, cpy)
-            updateOpFormat(opsI, op.format)
-            opsI = cpy
+            offset = retainLen
+            splitHere()
+            updateOpFormat(/** @type {ChildrenOpAny} */ (opsI.prev), op.format)
+            scheduleForMerge(opsI.prev)
           } else {
             offset += retainLen
           }
@@ -1571,17 +1604,22 @@ export class DeltaBuilder extends Delta {
             list.pushEnd(this.children, scheduleForMerge(new DeleteOp(remainingLen, null)))
             this.childCnt += remainingLen
             break
-          } else if ($deleteOp.check(opsI)) {
-            const delLen = opsI.length - offset
-            // the same content can't be deleted twice, remove duplicated deletes
-            if (delLen >= remainingLen) {
+          } else if ($retainOp.check(opsI)) { // retain ⇒ splice retain, insert delete
+            const delLen = math.min(opsI.length - offset, remainingLen)
+            opsI._splice(offset, delLen)
+            this.childCnt -= delLen
+            if (opsI.length === 0) {
+              list.remove(this.children, opsI)
+              opsI = opNextUndeleted(opsI)
+              offset = 0
+            }
+            if (opsI?.length === offset) {
+              opsI = opNextUndeleted(opsI)
               offset = 0
-              opsI = opsI.next
-            } else {
-              offset += remainingLen
             }
+            insertClonedOp(new DeleteOp(delLen, null))
             remainingLen -= delLen
-          } else { // insert / embed / retain / modify ⇒ replace
+          } else if (!$deleteOp.check(opsI)) { // insert / embed / modify ⇒ replace
             // case1: delete o fully
             // case2: delete some part of beginning
             // case3: delete some part of end
@@ -1590,38 +1628,38 @@ export class DeltaBuilder extends Delta {
             this.childCnt -= delLen
             if (opsI.length === delLen) {
               // case 1
-              offset = 0
               list.remove(this.children, opsI)
-              scheduleForMerge(opsI = opsI.next)
+              scheduleForMerge(opsI = opNextUndeleted(opsI))
+              offset = 0
             } else if (offset === 0) {
               // case 2
               offset = 0
-              opsI._splice(0, delLen)
+              opsI._splice(offset, delLen)
             } else if (offset + delLen === opsI.length) {
               // case 3
               opsI._splice(offset, delLen)
+              opsI = opNextUndeleted(opsI)
               offset = 0
-              opsI = opsI.next
             } else {
               // case 4
               opsI._splice(offset, delLen)
             }
             remainingLen -= delLen
+          } else {
+            error.unexpectedCase()
           }
         }
       } else if ($modifyOp.check(op)) {
         if (opsI == null) {
           list.pushEnd(this.children, op.clone())
           this.childCnt += 1
-          return
-        }
-        if ($modifyAttrOp.check(opsI)) {
-          opsI._modValue.apply(/** @type {any} */ (op.value))
-          opsI = opsI.next
+        } else if ($modifyOp.check(opsI)) {
+          opsI._modValue.apply(/** @type {any} */ (op.value), { final })
+          opsI = opNextUndeleted(opsI)
         } else if ($insertOp.check(opsI)) {
-          opsI._modValue(offset).apply(op.value)
+          opsI._modValue(offset).apply(op.value, { final })
           if (opsI.length === ++offset) {
-            opsI = opsI.next
+            opsI = opNextUndeleted(opsI)
             offset = 0
           }
         } else if ($retainOp.check(opsI)) {
@@ -1631,7 +1669,9 @@ export class DeltaBuilder extends Delta {
             list.insertBetween(this.children, opsI.prev, opsI, cpy) // insert skipped len
             offset = 0
           }
-          list.insertBetween(this.children, opsI.prev, opsI, scheduleForMerge(op.clone())) // insert skipped len
+          const insertModOp = scheduleForMerge(op.clone())
+          opsI.format && updateOpFormat(insertModOp, opsI.format)
+          list.insertBetween(this.children, opsI.prev, opsI, insertModOp) // insert skipped len
           if (opsI.length === 1) {
             list.remove(this.children, opsI)
           } else {
@@ -1646,7 +1686,7 @@ export class DeltaBuilder extends Delta {
       } else {
         error.unexpectedCase()
       }
-    })
+    }
     // iterate backwards, to ensure that we merge all content
     for (let i = maybeMergeable.length - 1; i >= 0; i--) {
       const op = maybeMergeable[i]
@@ -1660,6 +1700,9 @@ export class DeltaBuilder extends Delta {
   }
 
   /**
+   * Rebase this op against a concurrent op. We can apply this op on a doc that already applied
+   * `other` op.
+   *
    * @param {DeltaAny} other
    * @param {boolean} priority
    */
@@ -1863,12 +1906,23 @@ const updateOpFormat = (op, formatUpdate) => {
         /** @type {any} */ (op).format = object.assign({}, op.format, { [k]: v })
       } else if (op.format != null) {
         const { [k]: _, ...rest } = op.format
-        ;/** @type {any} */ (op).format = rest
+        ;/** @type {any} */ (op).format = object.isEmpty(rest) ? null : rest
       }
     }
   }
 }
 
+/**
+ * @param {ChildrenOpAny?} op
+ */
+const opNextUndeleted = op => {
+  op = op?.next || null
+  while (op != null && $deleteOp.check(op)) {
+    op = op.next
+  }
+  return op
+}
+
 /**
  * @template {DeltaConf} Conf
  * @extends {s.Schema<Delta<Conf>>}
@@ -2361,6 +2415,8 @@ export const diff = (d1, d2) => {
           error.unexpectedCase()
         }
       }
+      // @todo instead of applying, we want to first exec d, then formattingDiff - we need a merge
+      // function!
       d.apply(formattingDiff)
     }
     for (const attr2 of d2.attrs) {

package/src/environment.js

@@ -13,6 +13,14 @@ import * as f from './function.js'
 /* c8 ignore next */
 export const isNode = /* @__PURE__ */(() => typeof process !== 'undefined' && process.release && /node|io\.js/.test(process.release.name) && Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]')()
 
+/**
+ * True iff this script is running in deno
+ * @type {boolean}
+ */
+/* c8 ignore next 2 */
+// @ts-ignore
+export const isDeno = /* @__PURE__ */(() => typeof Deno !== 'undefined')()
+
 /* c8 ignore next */
 export const isBrowser = /* @__PURE__ */(() => typeof window !== 'undefined' && typeof document !== 'undefined' && !isNode)()
 /* c8 ignore next */

package/src/schema.js

@@ -487,7 +487,7 @@ export class $StringTemplate extends Schema {
   check (o, err) {
     const c = this._r.exec(o) != null
     /* c8 ignore next */
-    !c && err?.extend(null, this._r.toString(), o+'', 'String doesn\'t match string template.')
+    !c && err?.extend(null, this._r.toString(), o + '', 'String doesn\'t match string template.')
     return c
   }
 }

package/src/trait/equality.js

@@ -1,4 +1,4 @@
-export const EqualityTraitSymbol = Symbol('Equality')
+export const EqualityTraitSymbol = Symbol.for('0:equality')
 
 /**
  * @typedef {{ [EqualityTraitSymbol]:(other:EqualityTrait)=>boolean }} EqualityTrait

package/src/trait/fingerprint.js

@@ -2,7 +2,7 @@ import * as encoding from '../encoding.js'
 import * as rabin from '../hash/rabin.js'
 import * as buffer from '../buffer.js'
 
-export const FingerprintTraitSymbol = Symbol('Fingerprint')
+export const FingerprintTraitSymbol = Symbol.for('0:fingerprint')
 
 /**
  * When implementing this trait, it is recommended to write some sort of "magic number" first to

package/types/delta/delta.d.ts

@@ -658,10 +658,27 @@ export class DeltaBuilder<Conf extends DeltaConf = {}, FixedConf extends boolean
         attrs: AddToAttrs<DeltaConfGetAttrs<Conf>, Key, D>;
     }>, FixedConf>;
     /**
+     * Apply other delta on this op. The result is the merged op of both of them.
+     *
+     * a.apply(b.apply(c))
+     *
+     * is equivalent to
+     *
+     * a.apply(b).apply(c)
+     *
+     * @todo fuzz test the above property
+     *
      * @param {Delta<Conf>?} other
+     * @param {{ final?: boolean }} opts -- experimental
+     * @return {Delta<Conf>}
      */
-    apply(other: Delta<Conf> | null): this;
+    apply(other: Delta<Conf> | null, { final }?: {
+        final?: boolean;
+    }): Delta<Conf>;
     /**
+     * Rebase this op against a concurrent op. We can apply this op on a doc that already applied
+     * `other` op.
+     *
      * @param {DeltaAny} other
      * @param {boolean} priority
      */
@@ -1119,6 +1136,9 @@ declare class DeltaData<Name extends string, Attrs extends { [K in string | numb
      * >}
      */
     children: list.List<(Text extends true ? (RetainOp | TextOp | DeleteOp<any>) : never) | (RetainOp | InsertOp<Children> | DeleteOp<any> | (Delta extends Children ? ModifyOp<Extract<Children, Delta>> : never))>;
+    /**
+     * All child-ops sizes combined. Note that delete-ops also have a length
+     */
     childCnt: number;
     /**
      * @type {any}
@@ -1129,6 +1149,10 @@ declare class DeltaData<Name extends string, Attrs extends { [K in string | numb
      */
     _fingerprint: string | null;
     isDone: boolean;
+    /**
+     * Is the final document and does not contain delete, modify, or retain ops.
+     */
+    isFinal: boolean;
 }
 import * as prng from '../prng.js';
 export {};

package/types/environment.d.ts

@@ -1,4 +1,9 @@
 export const isNode: boolean;
+/**
+ * True iff this script is running in deno
+ * @type {boolean}
+ */
+export const isDeno: boolean;
 export const isBrowser: boolean;
 export const isMac: boolean;
 export function hasParam(name: string): boolean;