lib0 0.2.112 → 0.2.115-0

package/delta/transformer.test.d.ts

@@ -0,0 +1,13 @@
+export function testBasics(_tc: t.TestCase): void;
+export function testMapBasics(_tc: t.TestCase): void;
+export function testMapQuery(_tc: t.TestCase): void;
+export function testMappingTransformer(): void;
+export function testQuery(): void;
+export function testTransformerCreateUtility(): void;
+export function testStaticContent(): void;
+export function testFixedArray(): void;
+export function testNode(): void;
+export function testNodeTransformer(): void;
+export function testNodeTransformerFromNode(): void;
+import * as t from '../testing.js';
+//# sourceMappingURL=transformer.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transformer.test.d.ts","sourceRoot":"","sources":["transformer.test.js"],"names":[],"mappings":"AAwDO,gCAFI,CAAC,CAAC,QAAQ,QAgBpB;AAKM,mCAFI,CAAC,CAAC,QAAQ,QAcpB;AAKM,kCAFI,CAAC,CAAC,QAAQ,QAcpB;AAEM,+CAGN;AAEM,kCAMN;AAEM,qDAYN;AAEM,0CAgCN;AAEM,uCAKN;AAEM,iCAMN;AAEM,4CAYN;AAEM,oDAQN;mBA5MkB,eAAe"}

package/delta/value.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @template {any} Vals
+ * @typedef {Vals extends AbstractDelta ? ops.MapInsertOp<Vals,''>|ops.MapDeleteOp<Vals,''>|ops.MapModifyOp<Extract<Vals,AbstractDelta>,''> : ops.MapInsertOp<Vals,''>|ops.MapDeleteOp<Vals,''>} ValueOpsFromValues
+ */
+/**
+ * @template Vals
+ * @extends {AbstractDelta}
+ */
+export class DeltaValue<Vals> extends AbstractDelta {
+    /**
+     * @param {s.Schema<Vals>} $vals
+     */
+    constructor($vals: s.Schema<Vals>);
+    $vals: s.Schema<Vals>;
+    /**
+     * @type {ValueOpsFromValues<Vals>?}
+     */
+    change: ValueOpsFromValues<Vals> | null;
+    get(): Vals | undefined;
+    /**
+     * @param {DeltaValue<Vals>} other
+     * @return {boolean}
+     */
+    equals(other: DeltaValue<Vals>): boolean;
+    /**
+     * @param {DeltaValue<Vals>} other
+     */
+    [traits.EqualityTraitSymbol](other: DeltaValue<Vals>): boolean;
+}
+/**
+ * @template Vals
+ * @extends DeltaValue<Vals>
+ */
+export class DeltaValueBuilder<Vals> extends DeltaValue<Vals> {
+    /**
+     * @param {Extract<Vals, AbstractDelta>} delta
+     */
+    modify(delta: Extract<Vals, AbstractDelta>): this;
+    /**
+     * @param {Vals} newVal
+     * @param {Vals|undefined} prevValue
+     * @param {import('./abstract.js').Attribution?} attribution
+     */
+    set(newVal: Vals, prevValue?: Vals | undefined, attribution?: import("./abstract.js").Attribution | null): this;
+    /**
+     * @param {Vals|undefined} prevValue
+     * @param {import('./abstract.js').Attribution?} attribution
+     */
+    delete(prevValue?: Vals | undefined, attribution?: import("./abstract.js").Attribution | null): this;
+    /**
+     *
+     * - insert vs delete ⇒ insert takes precedence
+     * - insert vs modify ⇒ insert takes precedence
+     * - insert vs insert ⇒ priority decides
+     * - delete vs modify ⇒ delete takes precedence
+     * - delete vs delete ⇒ current delete op is removed because item has already been deleted
+     * - modify vs modify ⇒ rebase using priority
+     *
+     * @param {DeltaValueBuilder<Vals>} other
+     * @param {boolean} priority
+     */
+    rebase(other: DeltaValueBuilder<Vals>, priority: boolean): void;
+    /**
+     * @param {DeltaValue<Vals>} other
+     */
+    apply(other: DeltaValue<Vals>): void;
+    /**
+     * @return {this}
+     */
+    clone(): this;
+    done(): DeltaValue<Vals>;
+}
+export function value<Vals = any>($vals?: s.Schema<Vals>): DeltaValueBuilder<Vals>;
+export function $value<Vals extends unknown>($vals: s.Schema<Vals>): s.Schema<DeltaValue<Vals>>;
+/**
+ * @type {s.Schema<DeltaValue<any>>}
+ */
+export const $valueAny: s.Schema<DeltaValue<any>>;
+export type ValueOpsFromValues<Vals extends unknown> = Vals extends AbstractDelta ? ops.MapInsertOp<Vals, ""> | ops.MapDeleteOp<Vals, ""> | ops.MapModifyOp<Extract<Vals, AbstractDelta>, ""> : ops.MapInsertOp<Vals, ""> | ops.MapDeleteOp<Vals, "">;
+import { AbstractDelta } from './abstract.js';
+import * as s from '../schema.js';
+import * as traits from '../traits.js';
+import * as ops from './ops.js';
+//# sourceMappingURL=value.d.ts.map

package/delta/value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"value.d.ts","sourceRoot":"","sources":["value.js"],"names":[],"mappings":"AAMA;;;GAGG;AAEH;;;GAGG;AACH,wBAHa,IAAI;IAIf;;OAEG;IACH,mBAFW,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EASxB;IALC,sBAAkB;IAClB;;OAEG;IACH,QAFU,kBAAkB,CAAC,IAAI,CAAC,OAAC,CAEjB;IAGpB,wBAEC;IAED;;;OAGG;IACH,cAHW,UAAU,CAAC,IAAI,CAAC,GACf,OAAO,CAIlB;IAED;;OAEG;IACH,oCAFW,UAAU,CAAC,IAAI,CAAC,WAI1B;CACF;AAED;;;GAGG;AACH,+BAHa,IAAI;IAIf;;OAEG;IACH,cAFW,OAAO,CAAC,IAAI,EAAE,aAAa,CAAC,QAKtC;IAED;;;;OAIG;IACH,YAJW,IAAI,cACJ,IAAI,GAAC,SAAS,gBACd,OAAO,eAAe,EAAE,WAAW,OAAC,QAK9C;IAED;;;OAGG;IACH,mBAHW,IAAI,GAAC,SAAS,gBACd,OAAO,eAAe,EAAE,WAAW,OAAC,QAK9C;IAED;;;;;;;;;;;OAWG;IACH,cAHW,iBAAiB,CAAC,IAAI,CAAC,YACvB,OAAO,QAuBjB;IAED;;OAEG;IACH,aAFW,UAAU,CAAC,IAAI,CAAC,QAgB1B;IAED;;OAEG;IACH,SAFY,IAAI,CAQf;IAED,QACoB,UAAU,CAAC,IAAI,CAAC,CACnC;CACF;AAOM,sBAJO,IAAI,gBACP,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GACb,iBAAiB,CAAC,IAAI,CAAC,CAEuD;AAOnF,uBAJY,IAAI,yBACZ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,GACb,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAEoE;AAE1G;;GAEG;AACH,wBAFU,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAEe;+BAhK/B,IAAI,oBACV,IAAI,SAAS,aAAa,GAAG,GAAG,CAAC,WAAW,CAAC,IAAI,EAAC,EAAE,CAAC,GAAC,GAAG,CAAC,WAAW,CAAC,IAAI,EAAC,EAAE,CAAC,GAAC,GAAG,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,EAAC,aAAa,CAAC,EAAC,EAAE,CAAC,GAAG,GAAG,CAAC,WAAW,CAAC,IAAI,EAAC,EAAE,CAAC,GAAC,GAAG,CAAC,WAAW,CAAC,IAAI,EAAC,EAAE,CAAC;8BAJjK,eAAe;mBAF1B,cAAc;wBADT,cAAc;qBAEjB,UAAU"}

package/delta/value.js

@@ -0,0 +1,168 @@
+import * as fun from '../function.js'
+import * as traits from '../traits.js'
+import * as s from '../schema.js'
+import * as ops from './ops.js'
+import { AbstractDelta } from './abstract.js'
+
+/**
+ * @template {any} Vals
+ * @typedef {Vals extends AbstractDelta ? ops.MapInsertOp<Vals,''>|ops.MapDeleteOp<Vals,''>|ops.MapModifyOp<Extract<Vals,AbstractDelta>,''> : ops.MapInsertOp<Vals,''>|ops.MapDeleteOp<Vals,''>} ValueOpsFromValues
+ */
+
+/**
+ * @template Vals
+ * @extends {AbstractDelta}
+ */
+export class DeltaValue extends AbstractDelta {
+  /**
+   * @param {s.Schema<Vals>} $vals
+   */
+  constructor ($vals) {
+    super()
+    this.$vals = $vals
+    /**
+     * @type {ValueOpsFromValues<Vals>?}
+     */
+    this.change = null
+  }
+
+  get () {
+    return ops.$insertOp.check(this.change) ? this.change.value : undefined
+  }
+
+  /**
+   * @param {DeltaValue<Vals>} other
+   * @return {boolean}
+   */
+  equals (other) {
+    return this[traits.EqualityTraitSymbol](other)
+  }
+
+  /**
+   * @param {DeltaValue<Vals>} other
+   */
+  [traits.EqualityTraitSymbol] (other) {
+    return fun.equalityDeep(this.change, other.change)
+  }
+}
+
+/**
+ * @template Vals
+ * @extends DeltaValue<Vals>
+ */
+export class DeltaValueBuilder extends DeltaValue {
+  /**
+   * @param {Extract<Vals, AbstractDelta>} delta
+   */
+  modify (delta) {
+    this.change = /** @type {ValueOpsFromValues<Vals>} */ (new ops.MapModifyOp('', delta))
+    return this
+  }
+
+  /**
+   * @param {Vals} newVal
+   * @param {Vals|undefined} prevValue
+   * @param {import('./abstract.js').Attribution?} attribution
+   */
+  set (newVal, prevValue = undefined, attribution = null) {
+    this.change = /** @type {ValueOpsFromValues<Vals>} */ (new ops.MapInsertOp('', this.$vals.cast(newVal), prevValue && this.$vals.cast(prevValue), attribution))
+    return this
+  }
+
+  /**
+   * @param {Vals|undefined} prevValue
+   * @param {import('./abstract.js').Attribution?} attribution
+   */
+  delete (prevValue = undefined, attribution = null) {
+    this.change = /** @type {ValueOpsFromValues<Vals>} */ (new ops.MapDeleteOp('', prevValue && this.$vals.cast(prevValue), attribution))
+    return this
+  }
+
+  /**
+   *
+   * - insert vs delete ⇒ insert takes precedence
+   * - insert vs modify ⇒ insert takes precedence
+   * - insert vs insert ⇒ priority decides
+   * - delete vs modify ⇒ delete takes precedence
+   * - delete vs delete ⇒ current delete op is removed because item has already been deleted
+   * - modify vs modify ⇒ rebase using priority
+   *
+   * @param {DeltaValueBuilder<Vals>} other
+   * @param {boolean} priority
+   */
+  rebase (other, priority) {
+    const c = this.change
+    if (ops.$insertOp.check(c)) {
+      if (other.change?.constructor === ops.MapInsertOp && !priority) {
+        this.change = null
+      }
+    } else if (ops.$deleteOp.check(c)) {
+      const otherOp = other.change
+      if (otherOp?.constructor === ops.MapInsertOp) {
+        this.change = null
+      }
+    } else if (ops.$modifyOp.check(c)) {
+      const otherOp = other.change
+      if (otherOp == null) {
+        // nop
+      } else if (otherOp.constructor === ops.MapModifyOp) {
+        c.value.rebase(otherOp.value, priority)
+      } else {
+        this.change = null
+      }
+    }
+  }
+
+  /**
+   * @param {DeltaValue<Vals>} other
+   */
+  apply (other) {
+    const oop = other.change
+    const c = this.change
+    if (ops.$modifyOp.check(oop)) {
+      if (c != null && (ops.$modifyOp.check(c) || ops.$insertOp.check(c)) && $valueAny.check(c.value)) {
+        /** @type {DeltaValue<any>} */ (c.value).apply(oop.value)
+      } else {
+        // then this is a simple modify
+        this.change = oop
+      }
+    } else if (oop != null) {
+      oop.prevValue = c?.value
+      this.change = oop
+    }
+  }
+
+  /**
+   * @return {this}
+   */
+  clone () {
+    const d = /** @type {this} */ (new DeltaValueBuilder(this.$vals))
+    d.change = /** @type {ValueOpsFromValues<Vals>} */ (this.change?.clone())
+    d.origin = this.origin
+    d.isDiff = this.isDiff
+    return d
+  }
+
+  done () {
+    return /** @type {DeltaValue<Vals>} */ (this)
+  }
+}
+
+/**
+ * @template [Vals=any]
+ * @param {s.Schema<Vals>} $vals
+ * @return {DeltaValueBuilder<Vals>}
+ */
+export const value = ($vals = s.$any) => /** @type {any} */ (new DeltaValueBuilder($vals))
+
+/**
+ * @template {any} Vals
+ * @param {s.Schema<Vals>} $vals
+ * @return {s.Schema<DeltaValue<Vals>>}
+ */
+export const $value = $vals => /** @type {any} */ (s.$instanceOf(DeltaValue, o => $vals.extends(o.$vals)))
+
+/**
+ * @type {s.Schema<DeltaValue<any>>}
+ */
+export const $valueAny = s.$instanceOf(DeltaValue)