[delta] delta.append & test coverage

Author: dmonad

delta/delta.js

@@ -896,8 +896,8 @@ export const $anyOp = s.$union($insertOp, $deleteOp, $textOp, $modifyOp)
 /**
  * @template {string} [NodeName=any]
  * @template {{[k:string|number]:any}} [Attrs={}]
- * @template {fingerprintTrait.Fingerprintable|never} [Children=never]
- * @template {string|never} [Text=never]
+ * @template {fingerprintTrait.Fingerprintable} [Children=never]
+ * @template {string} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  */
 export class Delta {
@@ -1155,8 +1155,8 @@ const modDeltaCheck = d => {
 /**
  * @template {string} [NodeName=any]
  * @template {{[key:string|number]:any}} [Attrs={}]
- * @template {fingerprintTrait.Fingerprintable|never} [Children=never]
- * @template {string|never} [Text=never]
+ * @template {fingerprintTrait.Fingerprintable} [Children=never]
+ * @template {string} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  * @extends {Delta<NodeName,Attrs,Children,Text,Schema>}
  */
@@ -1734,8 +1734,32 @@ export class DeltaBuilder extends Delta {
     console.info('method rebaseOnInverse unimplemented')
     return this
   }
+
+  /**
+   * Append child ops from one op to the other.
+   *
+   *     delta.create().insert('a').append(delta.create().insert('b')) // => insert "ab"
+   *
+   * @template {DeltaAny} OtherDelta
+   * @param {OtherDelta} other
+   * @return {CastToDelta<OtherDelta> extends Delta<any,any,infer OtherChildren,infer OtherText,any> ? DeltaBuilder<NodeName,Attrs,Children|OtherChildren,Text|OtherText,Schema> : never}
+   */
+  append (other) {
+    // @todo Investigate. Above is a typescript issue. It is necessary to cast OtherDelta to a Delta first before
+    // inferring type, otherwise Children will contain Text.
+    for (const child of other.children) {
+      list.pushEnd(this.children, child.clone())
+    }
+    // @ts-ignore
+    return this
+  }
 }
 
+/**
+ * @template {DeltaAny} D
+ * @typedef {D extends DeltaBuilder<infer N,infer Attrs,infer Children,infer Text,infer Schema> ? Delta<N,Attrs,Children,Text,Schema> : D} CastToDelta
+ */
+
 /**
  * @template {string} NodeName
  * @template {{ [key: string|number]: any }} [Attrs={}]
@@ -1813,9 +1837,9 @@ export class $Delta extends s.Schema {
  * @template {{ [k:string]:any }} [Formats={[k:string]:any}]
  * @param {object} opts
  * @param {NodeNameSchema?} [opts.name]
- * @param {AttrsSchema?} [opts.attrs]
- * @param {ChildrenSchema?} [opts.children]
- * @param {HasText} [opts.text]
+ * @param {AttrsSchema?} [opts.attrs] What key-value pairs are included.
+ * @param {ChildrenSchema?} [opts.children] The type of content in `insertOp`
+ * @param {HasText} [opts.text] Whether this delta contains text using `textOp`
  * @param {Formats} [opts.formats]
  * @param {Recursive} [opts.recursive]
  * @return {[s.Unwrap<s.ReadSchema<NodeNameSchema>>,s.Unwrap<s.ReadSchema<AttrsSchema>>,s.Unwrap<s.ReadSchema<ChildrenSchema>>] extends [infer NodeName, infer Attrs, infer Children] ? s.Schema<Delta<
@@ -2132,7 +2156,6 @@ export const diff = (d1, d2) => {
        * @param {DeltaBuilderAny} d
        * @param {ChildrenOpAny[]} opsIs
        * @param {ChildrenOpAny[]} opsShould
-       *
        */
       const diffAndApply = (d, opsIs, opsShould) => {
         // @todo unoptimized implementation. Convert content to array and diff that based on
@@ -2160,7 +2183,7 @@ export const diff = (d1, d2) => {
           cd.insert = shouldContent.slice(cd.index + adj, cd.index + adj + cd.insert.length)
           adj += cd.remove.length - cd.insert.length
         }
-        for (let i = 0, lastIndex = 0, currIndexOffset2 = 0; i < cdiff.length; i++) {
+        for (let i = 0, lastIndex = 0; i < cdiff.length; i++) {
           const cd = cdiff[i]
           d.retain(cd.index - lastIndex)
           let cdii = 0

delta/delta.test.js

@@ -685,3 +685,15 @@ export const testRepeatRandomMapDiff = tc => {
   d1.apply(d)
   t.compare(d1, d2)
 }
+
+/**
+ * @param {t.TestCase} tc
+ */
+export const testDeltaAppend = tc => {
+  const $d = delta.$delta({ children: s.$number, text: true })
+  const other = delta.create().insert('b').insert([1, 2])
+  const _d = delta.create().insert('a')
+  const d = _d.append(other)
+  $d.expect(d)
+}
+

list.js

@@ -1,6 +1,7 @@
 import { id } from './function.js'
 import * as error from './error.js'
 import * as equalityTrait from './trait/equality.js'
+import * as f from './function.js'
 
 export class ListNode {
   constructor () {
@@ -39,13 +40,26 @@ export class List {
     }
   }
 
+  toArray () {
+    return map(this, f.id)
+  }
+
   /**
    * @param {function(N):any} f
    */
   forEach (f) {
     forEach(this, f)
   }
 
+  /**
+   * @template M
+   * @param {function(N):M} f
+   * @return {Array<M>}
+   */
+  map (f) {
+    return map(this, f)
+  }
+
   /**
    * @param {List<any>} other
    */

list.test.js

@@ -87,7 +87,9 @@ export const testSelectivePop = _tc => {
   list.insertBetween(l, l.start, l.end, middleNode)
   list.replace(l, q3, new QueueItem(4))
   t.compare(list.map(l, n => n.v), [1, 2, 4])
+  t.compare(l.map(n => n.v), [1, 2, 4])
   t.compare(list.toArray(l).map(n => n.v), [1, 2, 4])
+  t.compare(l.toArray().map(n => n.v), [1, 2, 4])
   {
     let cnt = 0
     list.forEach(l, () => cnt++)

schema.test.js

@@ -90,6 +90,7 @@ export const testSchemas = _tc => {
     const z = s.$instanceOf(Base)
     t.assert(z.validate(new Base()))
     t.assert(z.validate(new BetterBase()))
+    t.assert(s.$instanceOf(Base, o => /** @type {any} */ (o).y != null).validate(new BetterBase()))
     // @ts-expect-error
     t.assert(!z.validate(4))
     t.assert(!s.$instanceOf(BetterBetterBase).validate(new BetterBase()))