lib0 0.2.112 → 0.2.115-0

package/delta/abstract-array.js

@@ -0,0 +1,421 @@
+import * as s from '../schema.js'
+import * as d from './abstract.js'
+import * as traits from '../traits.js'
+import * as object from '../object.js'
+import * as fun from '../function.js'
+import * as array from '../array.js'
+import * as dops from './ops.js'
+import * as error from '../error.js'
+import * as math from '../math.js'
+import { InsertOp, DeleteOp, RetainOp, ModifyOp, TextOp } from './ops.js'
+
+/**
+ * @typedef {Array<dops.DeltaJsonOp>} DeltaJson
+ */
+
+/**
+ * @template {'array' | 'text' | 'custom'} Type
+ * @template {dops.AbstractDeltaArrayOps<any>} OPS
+ * @extends {d.AbstractDelta}
+ */
+export class AbstractDeltaArray extends d.AbstractDelta {
+  /**
+   * @param {Type} type
+   */
+  constructor (type) {
+    super()
+    this.type = type
+    /**
+     * @type {Array<OPS>}
+     */
+    this.ops = []
+  }
+
+  isEmpty () {
+    return this.ops.length === 0
+  }
+
+  /**
+   * @template M
+   * @param {(d:OPS) => dops.AbstractDeltaArrayOps<M>} f
+   * @return {AbstractDeltaArrayBuilder<Type,M>}
+   */
+  map (f) {
+    const d = /** @type {AbstractDeltaArrayBuilder<Type,any>} */ (new /** @type {any} */ (this.constructor)(this.type))
+    d.ops = this.ops.map(f)
+    d.lastOp = d.ops[d.ops.length - 1] ?? null
+    return d
+  }
+
+  /**
+   *
+   * Iterate through the changes. There are two approches to iterate through the changes. The
+   * following examples achieve the same thing:
+   *
+   * @example
+   *   d.forEach((op, index) => {
+   *     if (op instanceof delta.InsertArrayOp) {
+   *       op.insert
+   *     } else if (op instanceof delta.RetainOp ) {
+   *       op.retain
+   *     } else if (op instanceof delta.DeleteOp) {
+   *       op.delete
+   *     }
+   *   })
+   *
+   * The second approach doesn't require instanceof checks.
+   *
+   * @example
+   *   d.forEach(null,
+   *     (insertOp, index) => insertOp.insert,
+   *     (retainOp, index) => insertOp.retain
+   *     (deleteOp, index) => insertOp.delete
+   *   )
+   *
+   * @param {null|((d:OPS,index:number)=>void)} f
+   * @param {null|((insertOp:Extract<OPS,InsertOp<any>|TextOp>,index:number)=>void)} insertHandler
+   * @param {null|((retainOp:RetainOp,index:number)=>void)} retainHandler
+   * @param {null|((deleteOp:DeleteOp,index:number)=>void)} deleteHandler
+   * @param {null|((modifyOp:OPS extends ModifyOp<infer M> ? ModifyOp<M> : never,index:number)=>void)} modifyHandler
+   */
+  forEach (f = null, insertHandler = null, retainHandler = null, deleteHandler = null, modifyHandler = null) {
+    for (
+      let i = 0, index = 0, op = this.ops[i];
+      i < this.ops.length;
+      i++, index += op.length, op = this.ops[i]
+    ) {
+      f?.(op, index)
+      switch (op.constructor) {
+        case RetainOp:
+          retainHandler?.(/** @type {RetainOp} */ (op), index)
+          break
+        case DeleteOp:
+          deleteHandler?.(/** @type {DeleteOp} */ (op), index)
+          break
+        case ModifyOp:
+          modifyHandler?.(/** @type {any}) */ (op), index)
+          break
+        default:
+          insertHandler?.(/** @type {any} */ (op), index)
+      }
+    }
+  }
+
+  /**
+   * @param {AbstractDeltaArray<Type, OPS>} other
+   * @return {boolean}
+   */
+  equals (other) {
+    return this[traits.EqualityTraitSymbol](other)
+  }
+
+  /**
+   * @returns {DeltaJson}
+   */
+  toJSON () {
+    return this.ops.map(o => o.toJSON())
+  }
+
+  get size () {
+    return this.ops.length
+  }
+
+  /**
+   * @param {AbstractDeltaArray<Type,OPS>} other
+   */
+  [traits.EqualityTraitSymbol] (other) {
+    return fun.equalityDeep(this.ops, other.ops)
+  }
+}
+
+/**
+ * @template {'text' | 'array' | 'custom'} Type
+ * @template {dops.AbstractDeltaArrayOps<any>} OPS
+ * @extends {AbstractDeltaArray<Type,OPS>}
+ */
+export class AbstractDeltaArrayBuilder extends AbstractDeltaArray {
+  /**
+   * @param {Type} type
+   * @param {s.Schema<OPS extends dops.AbstractDeltaArrayOps<infer V> ? V : never>} $insert
+   */
+  constructor (type, $insert) {
+    super(type)
+    this.$insert = $insert
+    /**
+     * @type {dops.FormattingAttributes?}
+     */
+    this.usedAttributes = null
+    /**
+     * @type {d.Attribution?}
+     */
+    this.usedAttribution = null
+    /**
+     * @type {dops.AbstractDeltaArrayOps<any>?}
+     */
+    this.lastOp = null
+  }
+
+  /**
+   * @return {this}
+   */
+  clone () {
+    const d = /** @type {this} */ (new AbstractDeltaArrayBuilder(this.type, this.$insert))
+    d.ops = /** @type {OPS[]} */ (this.ops.map(op => op.clone()))
+    d.origin = this.origin
+    d.isDiff = this.isDiff
+    return d
+  }
+
+  /**
+   * @param {dops.FormattingAttributes?} attributes
+   * @return {this}
+   */
+  useAttributes (attributes) {
+    this.usedAttributes = attributes
+    return this
+  }
+
+  /**
+   * @param {string} name
+   * @param {any} value
+   */
+  updateUsedAttributes (name, value) {
+    if (value == null) {
+      this.usedAttributes = object.assign({}, this.usedAttributes)
+      delete this.usedAttributes?.[name]
+      if (object.isEmpty(this.usedAttributes)) {
+        this.usedAttributes = null
+      }
+    } else if (!fun.equalityDeep(this.usedAttributes?.[name], value)) {
+      this.usedAttributes = object.assign({}, this.usedAttributes)
+      this.usedAttributes[name] = value
+    }
+    return this
+  }
+
+  /**
+   * @template {keyof d.Attribution} NAME
+   * @param {NAME} name
+   * @param {d.Attribution[NAME]?} value
+   */
+  updateUsedAttribution (name, value) {
+    if (value == null) {
+      this.usedAttribution = object.assign({}, this.usedAttribution)
+      delete this.usedAttribution?.[name]
+      if (object.isEmpty(this.usedAttribution)) {
+        this.usedAttribution = null
+      }
+    } else if (!fun.equalityDeep(this.usedAttribution?.[name], value)) {
+      this.usedAttribution = object.assign({}, this.usedAttribution)
+      this.usedAttribution[name] = value
+    }
+    return this
+  }
+
+  /**
+   * @param {d.Attribution?} attribution
+   */
+  useAttribution (attribution) {
+    this.usedAttribution = attribution
+    return this
+  }
+
+  /**
+   * @param {(OPS extends TextOp ? string : never) | (OPS extends InsertOp<infer Content> ? Array<Content> : never) } insert
+   * @param {dops.FormattingAttributes?} attributes
+   * @param {d.Attribution?} attribution
+   * @return {this}
+   */
+  insert (insert, attributes = null, attribution = null) {
+    const mergedAttributes = d.mergeAttrs(this.usedAttributes, attributes)
+    const mergedAttribution = d.mergeAttrs(this.usedAttribution, attribution)
+    /**
+     * @param {TextOp | InsertOp<any>} lastOp
+     */
+    const checkMergedEquals = lastOp => (mergedAttributes === lastOp.attributes || fun.equalityDeep(mergedAttributes, lastOp.attributes)) && (mergedAttribution === lastOp.attribution || fun.equalityDeep(mergedAttribution, lastOp.attribution))
+    if (s.$string.check(insert)) {
+      if (dops.$textOp.check(this.lastOp) && checkMergedEquals(this.lastOp)) {
+        this.lastOp.insert += insert
+      } else if (insert.length > 0) {
+        this.ops.push(this.lastOp = /** @type {OPS} */ (new TextOp(insert, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution)))
+      }
+    } else if (array.isArray(insert)) {
+      insert.forEach(/** @param {any} ins */ ins => this.$insert.expect(ins))
+      if (dops.$insertOp.check(this.lastOp) && checkMergedEquals(this.lastOp)) {
+        this.lastOp.insert.push(...insert)
+      } else if (insert.length > 0) {
+        this.ops.push(this.lastOp = /** @type {OPS} */ (new InsertOp(insert, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution)))
+      }
+    }
+    return this
+  }
+
+  /**
+   * @param {OPS extends ModifyOp<infer Mod> ? Mod : never } modify
+   * @param {dops.FormattingAttributes?} attributes
+   * @param {d.Attribution?} attribution
+   * @return {this}
+   */
+  modify (modify, attributes = null, attribution = null) {
+    const mergedAttributes = d.mergeAttrs(this.usedAttributes, attributes)
+    const mergedAttribution = d.mergeAttrs(this.usedAttribution, attribution)
+    this.ops.push(this.lastOp = /** @type {OPS} */ (new ModifyOp(modify, object.isEmpty(mergedAttributes) ? null : mergedAttributes, object.isEmpty(mergedAttribution) ? null : mergedAttribution)))
+    return this
+  }
+
+  /**
+   * @param {number} retain
+   * @param {dops.FormattingAttributes?} attributes
+   * @param {d.Attribution?} attribution
+   * @return {this}
+   */
+  retain (retain, attributes = null, attribution = null) {
+    const mergedAttributes = d.mergeAttrs(this.usedAttributes, attributes)
+    const mergedAttribution = d.mergeAttrs(this.usedAttribution, attribution)
+    if (this.lastOp instanceof RetainOp && fun.equalityDeep(mergedAttributes, this.lastOp.attributes) && fun.equalityDeep(mergedAttribution, this.lastOp.attribution)) {
+      this.lastOp.retain += retain
+    } else if (retain > 0) {
+      // @ts-ignore
+      this.ops.push(this.lastOp = new RetainOp(retain, mergedAttributes, mergedAttribution))
+    }
+    return this
+  }
+
+  /**
+   * @param {number} len
+   * @return {this}
+   */
+  delete (len) {
+    if (this.lastOp instanceof DeleteOp) {
+      this.lastOp.delete += len
+    } else if (len > 0) {
+      // @ts-ignore
+      this.ops.push(this.lastOp = new DeleteOp(len))
+    }
+    return this
+  }
+
+  /**
+   * @todo this is basically untested and is in dire need of randomized testing.
+   * @param {AbstractDeltaArray<Type, OPS>} other
+   */
+  apply (other) {
+    let opsI = 0
+    let offset = 0
+    other.forEach(
+      null,
+      insertOp => {
+        const o = this.ops[opsI]
+        if (offset === 0) {
+          this.ops.splice(opsI, 0, /** @type {OPS} */ (insertOp.clone()))
+          opsI++
+        } else {
+          const cpy = o.clone()
+          cpy._splice(0, offset)
+          o._splice(offset, o.length - offset)
+          this.ops.splice(opsI + 1, 0, /** @type {OPS} */ (insertOp.clone()), /** @type {OPS} */ (cpy))
+          opsI += 2
+          offset = 0
+        }
+      },
+      retainOp => {
+        let skipLen = retainOp.length
+        let o = this.ops[opsI]
+        while (o.length - offset <= skipLen) {
+          skipLen -= o.length - offset
+          o = this.ops[++opsI]
+          offset = 0
+        }
+        offset = skipLen
+      },
+      deleteOp => {
+        let remainingLen = deleteOp.length
+        while (remainingLen > 0) {
+          const o = this.ops[opsI]
+          if (o instanceof DeleteOp) {
+            const delLen = o.length - offset
+            // the same content can't be deleted twice, remove duplicated deletes
+            if (delLen >= remainingLen) {
+              offset = 0
+              opsI++
+            } else {
+              offset += remainingLen
+            }
+            remainingLen -= delLen
+          } else { // insert / embed / retain / modify ⇒ replace
+            // case1: delete o fully
+            // case2: delete some part of beginning
+            // case3: delete some part of end
+            // case4: delete some part of center
+            const delLen = math.min(o.length - offset, remainingLen)
+            if (o.length === delLen) {
+              // case 1
+              offset = 0
+              this.ops.splice(opsI, 1)
+            } else if (offset === 0) {
+              // case 2
+              offset = 0
+              o._splice(0, delLen)
+            } else if (offset + delLen === o.length) {
+              // case 3
+              o._splice(offset, delLen)
+              offset = 0
+              opsI++
+            } else {
+              // case 4
+              o._splice(offset, delLen)
+            }
+            remainingLen -= delLen
+          }
+        }
+      },
+      modifyOp => {
+        if (opsI >= this.ops.length) {
+          this.ops.push(/** @type {OPS} */ (modifyOp.clone()))
+          return
+        }
+        let o = this.ops[opsI]
+        if (dops.$modifyOp.check(o)) {
+          o.modify.apply(modifyOp.modify)
+        } else if (dops.$insertOp.check(o)) {
+          const d = o.insert[offset]
+          d.apply(modifyOp.modify)
+        } else if (dops.$retainOp.check(o)) {
+          if (offset > 0) {
+            const cpy = o.clone()
+            cpy._splice(0, offset)
+            o._splice(offset, o.length - offset)
+            this.ops.splice(opsI + 1, 0, /** @type {OPS} */ (cpy))
+            opsI++
+            o = /** @type {OPS} */ (cpy)
+            offset = 0
+          }
+          if (o.length === 1) {
+            this.ops[opsI] = /** @type {OPS} */ (modifyOp.clone())
+            opsI++
+          } else {
+            this.ops.splice(opsI, 0, /** @type {OPS} */ (modifyOp.clone()))
+            o._splice(0, 1)
+            opsI++
+          }
+        } else if (dops.$deleteOp.check(o)) {
+          // nop
+        } else {
+          error.unexpectedCase()
+        }
+      }
+    )
+    this.lastOp = this.ops[this.ops.length - 1]
+  }
+
+  /**
+   * @return {Type extends 'array' ? (OPS extends dops.InsertOp<infer C> ? import('./array.js').DeltaArray<C> : never) : (Type extends 'text' ? (OPS extends dops.DeltaTextOps<infer Embeds> ? import('./text.js').DeltaText<Embeds> : never) : AbstractDeltaArray<Type,OPS>)}
+   */
+  done () {
+    while (this.lastOp != null && this.lastOp instanceof RetainOp && this.lastOp.attributes === null && this.lastOp.attribution === null) {
+      this.ops.pop()
+      this.lastOp = this.ops[this.ops.length - 1] ?? null
+    }
+    return /** @type {any} */ (this)
+  }
+}

package/delta/abstract.d.ts

@@ -0,0 +1,69 @@
+export const $attribution: s.Schema<{
+    insert?: string[] | undefined;
+    insertAt?: number | undefined;
+    delete?: string[] | undefined;
+    deleteAt?: number | undefined;
+    attributes?: {
+        [x: string]: string[];
+    } | undefined;
+    attributesAt?: number | undefined;
+} & {}>;
+/**
+ * @typedef {s.TypeOf<$attribution>} Attribution
+ */
+/**
+ * @implements {traits.EqualityTrait}
+ */
+export class AbstractDelta implements traits.EqualityTrait {
+    remote: boolean;
+    /**
+     * @type {any} origin
+     */
+    origin: any;
+    isDiff: boolean;
+    /**
+     * @return {any}
+     */
+    toJSON(): any;
+    /**
+     * @return {boolean}
+     */
+    isEmpty(): boolean;
+    /**
+     * @param {AbstractDelta} other
+     * @param {boolean} priority
+     */
+    rebase(other: AbstractDelta, priority: boolean): void;
+    /**
+     * @param {AbstractDelta} other
+     */
+    apply(other: AbstractDelta): void;
+    /**
+     * @return {this}
+     */
+    clone(): this;
+    /**
+     * @param {any} _other
+     * @return {boolean}
+     */
+    [traits.EqualityTraitSymbol](_other: any): boolean;
+}
+export const $delta: s.Schema<AbstractDelta>;
+export const $$delta: s.Schema<s.$InstanceOf<AbstractDelta>>;
+export function mergeAttrs<T extends {
+    [key: string]: any;
+}>(a: T | null, b: T | null): T | null;
+export function mergeDeltas<D extends AbstractDelta | null>(a: D, b: D): D;
+export type Attribution = s.TypeOf<s.Schema<{
+    insert?: string[] | undefined;
+    insertAt?: number | undefined;
+    delete?: string[] | undefined;
+    deleteAt?: number | undefined;
+    attributes?: {
+        [x: string]: string[];
+    } | undefined;
+    attributesAt?: number | undefined;
+} & {}>>;
+import * as s from '../schema.js';
+import * as traits from '../traits.js';
+//# sourceMappingURL=abstract.d.ts.map

package/delta/abstract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract.d.ts","sourceRoot":"","sources":["abstract.js"],"names":[],"mappings":"AAKA;;;;;;;;;QAOE;AAEF;;GAEG;AAEH;;GAEG;AACH,sCAFgB,MAAM,CAAC,aAAa;IAIhC,gBAAmB;IACnB;;OAEG;IACH,QAFU,GAAG,CAEK;IAClB,gBAAkB;IAGpB;;OAEG;IACH,UAFY,GAAG,CAId;IAED;;OAEG;IACH,WAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,cAHW,aAAa,YACb,OAAO,QAIjB;IAED;;OAEG;IACH,aAFW,aAAa,QAIvB;IAED;;OAEG;IACH,SAFY,IAAI,CAIf;IAED;;;OAGG;IACH,qCAHW,GAAG,GACF,OAAO,CAIlB;CACF;AAED,6CAAkD;AAClD,sBAAkC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAuF;AASxJ,2BAJ+B,CAAC,SAA1B;IAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAG,KAC1B,CAAC,GAAG,IAAI,KACR,CAAC,GAAG,IAAI,YAE0F;AAQtG,4BALuB,CAAC,SAAjB,aAAa,OAAE,KAClB,CAAC,KACD,CAAC,GACA,CAAC,CASZ;0BAtFY,CAAC,CAAC,MAAM;;;;;;;;;QAAc;mBAZhB,cAAc;wBAFT,cAAc"}

package/delta/abstract.js

@@ -0,0 +1,102 @@
+import * as object from '../object.js'
+import * as traits from '../traits.js'
+import * as error from '../error.js'
+import * as s from '../schema.js'
+
+export const $attribution = s.$object({
+  insert: s.$array(s.$string).optional,
+  insertAt: s.$number.optional,
+  delete: s.$array(s.$string).optional,
+  deleteAt: s.$number.optional,
+  attributes: s.$record(s.$string, s.$array(s.$string)).optional,
+  attributesAt: s.$number.optional
+})
+
+/**
+ * @typedef {s.TypeOf<$attribution>} Attribution
+ */
+
+/**
+ * @implements {traits.EqualityTrait}
+ */
+export class AbstractDelta {
+  constructor () {
+    this.remote = false
+    /**
+     * @type {any} origin
+     */
+    this.origin = null
+    this.isDiff = true
+  }
+
+  /**
+   * @return {any}
+   */
+  toJSON () {
+    error.methodUnimplemented()
+  }
+
+  /**
+   * @return {boolean}
+   */
+  isEmpty () {
+    error.methodUnimplemented()
+  }
+
+  /**
+   * @param {AbstractDelta} other
+   * @param {boolean} priority
+   */
+  rebase (other, priority) {
+    error.methodUnimplemented()
+  }
+
+  /**
+   * @param {AbstractDelta} other
+   */
+  apply (other) {
+    error.methodUnimplemented()
+  }
+
+  /**
+   * @return {this}
+   */
+  clone () {
+    error.methodUnimplemented()
+  }
+
+  /**
+   * @param {any} _other
+   * @return {boolean}
+   */
+  [traits.EqualityTraitSymbol] (_other) {
+    error.methodUnimplemented()
+  }
+}
+
+export const $delta = s.$instanceOf(AbstractDelta)
+export const $$delta = /** @type {s.Schema<s.$InstanceOf<AbstractDelta>>} */ (s.$constructedBy(s.$InstanceOf, s => s.shape.prototype instanceof AbstractDelta))
+
+/**
+ * Helper function to merge attribution and attributes. The latter input "wins".
+ *
+ * @template {{ [key: string]: any }} T
+ * @param {T | null} a
+ * @param {T | null} b
+ */
+export const mergeAttrs = (a, b) => object.isEmpty(a) ? b : (object.isEmpty(b) ? a : object.assign({}, a, b))
+
+/**
+ * @template {AbstractDelta?} D
+ * @param {D} a
+ * @param {D} b
+ * @return {D}
+ */
+export const mergeDeltas = (a, b) => {
+  if (a != null && b != null) {
+    const c = /** @type {D & AbstractDelta} */ (a.clone())
+    c.apply(b)
+    return c
+  }
+  return a == null ? b : (a || null)
+}

package/delta/array.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @template ArrayContent
+ * @template {boolean} [WithText=false]
+ * @extends AbstractDeltaArrayBuilder<'array', import('./ops.js').DeltaArrayOps<ArrayContent,WithText>>
+ */
+export class DeltaArray<ArrayContent, WithText extends boolean = false> extends AbstractDeltaArrayBuilder<"array", ops.DeltaArrayOps<ArrayContent, WithText>> {
+    /**
+     * @param {s.Schema<ArrayContent>} $insert
+     * @param {WithText} withText
+     */
+    constructor($insert: s.Schema<ArrayContent>, withText: WithText);
+    withText: WithText;
+}
+export function $array<ArrayContent, WithText extends boolean = false>($insert: s.Schema<ArrayContent>, withText?: WithText): s.Schema<DeltaArray<ArrayContent, WithText>>;
+/**
+ * @type {s.Schema<DeltaArray<any,any>>}
+ */
+export const $arrayAny: s.Schema<DeltaArray<any, any>>;
+export function array<V = any, WithText extends boolean = any>($insert?: s.Schema<V>, withText?: WithText): DeltaArray<V, WithText>;
+import * as ops from './ops.js';
+import { AbstractDeltaArrayBuilder } from './abstract-array.js';
+import * as s from '../schema.js';
+//# sourceMappingURL=array.d.ts.map

package/delta/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["array.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,wBAJa,YAAY,EACD,QAAQ,SAAnB,OAAS;IAIpB;;;OAGG;IACH,qBAHW,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,YACtB,QAAQ,EAKlB;IADC,mBAAwB;CAE3B;AASM,uBANM,YAAY,EACD,QAAQ,SAAnB,OAAS,mBACX,CAAC,CAAC,MAAM,CAAC,YAAY,CAAC,aACtB,QAAQ,GACP,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,YAAY,EAAE,QAAQ,CAAC,CAAC,CAMpD;AACJ;;GAEG;AACH,wBAFU,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,EAAC,GAAG,CAAC,CAAC,CAEwE;AASxG,sBANO,CAAC,QACS,QAAQ,SAAnB,OAAS,kBACX,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,aACX,QAAQ,GACP,UAAU,CAAC,CAAC,EAAC,QAAQ,CAAC,CAEoG;qBA1CjH,UAAU;0CADW,qBAAqB;mBAD5C,cAAc"}

package/delta/array.js

@@ -0,0 +1,45 @@
+import * as s from '../schema.js'
+import { AbstractDeltaArrayBuilder } from './abstract-array.js'
+import * as ops from './ops.js'
+
+/**
+ * @template ArrayContent
+ * @template {boolean} [WithText=false]
+ * @extends AbstractDeltaArrayBuilder<'array', import('./ops.js').DeltaArrayOps<ArrayContent,WithText>>
+ */
+export class DeltaArray extends AbstractDeltaArrayBuilder {
+  /**
+   * @param {s.Schema<ArrayContent>} $insert
+   * @param {WithText} withText
+   */
+  constructor ($insert, withText) {
+    super('array', $insert)
+    this.withText = withText
+  }
+}
+
+/**
+ * @template ArrayContent
+ * @template {boolean} [WithText=false]
+ * @param {s.Schema<ArrayContent>} $insert
+ * @param {WithText} [withText]
+ * @return {s.Schema<DeltaArray<ArrayContent, WithText>>}
+ */
+export const $array = ($insert, withText) => /** @type {any} */ (s.$instanceOf(AbstractDeltaArrayBuilder, o => o.type === 'array' && o.ops.every(op => {
+  if (ops.$textOp.check(op)) return !!withText
+  if (ops.$insertOp.check(op)) return op.insert.every(opi => $insert.check(opi))
+  return true
+})))
+/**
+ * @type {s.Schema<DeltaArray<any,any>>}
+ */
+export const $arrayAny = /** @type {any} */ (s.$instanceOf(AbstractDeltaArrayBuilder, o => o.type === 'array'))
+
+/**
+ * @template [V=any]
+ * @template {boolean} [WithText=any]
+ * @param {s.Schema<V>} $insert
+ * @param {WithText} [withText]
+ * @return {DeltaArray<V,WithText>}
+ */
+export const array = ($insert = s.$any, withText) => /** @type {DeltaArray<V,WithText>} */ (new DeltaArray($insert, withText ?? true))

package/delta/array.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=array.test.d.ts.map

package/delta/array.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.test.d.ts","sourceRoot":"","sources":["array.test.js"],"names":[],"mappings":""}