lib0 1.0.0-rc.29 → 1.0.0-rc.31

package/dist/delta/delta.d.ts

@@ -85,6 +85,10 @@ export const $deltaMapChangeJson: s.Schema<DeltaAttrOpJSON>;
  *   fingerprint read (and any `diff` / equality check that relies on it) is
  *   wrong. Fields covered: insert, delete, retain, format, attribution,
  *   value, key.
+ * - **A `clone` copies `_fingerprint` when the copy is content-identical:** a full range and the
+ *   same key. Freezing a nested value with `done()` is fingerprint-neutral (trailing plain retains
+ *   are not fingerprinted), so nothing else can differ. The root delta returned by
+ *   `clone`/`slice`/`cloneDeep` never inherits a fingerprint.
  *
  * @internal not part of the consumer API — a content op; build deltas via {@link create}/{@link DeltaBuilder}.
  */
@@ -433,9 +437,12 @@ export class SetAttrOp<V extends unknown = any, K extends string | number = any>
      * Full (frozen) clone. A `move` apply reuses the source op instead of cloning, so there is no
      * shared-mutable variant — see {@link DeltaBuilder#apply}.
      *
-     * @return {SetAttrOp<V,K>}
+     * @template {string|number} [K2=K]
+     * @param {K2} [key] retarget the clone to another attribute key (a transformer projecting or
+     * renaming an attribute); defaults to this op's key.
+     * @return {SetAttrOp<V,K2>}
      */
-    clone(): SetAttrOp<V, K>;
+    clone<K2 extends string | number = K>(key?: K2): SetAttrOp<V, K2>;
     $type: s.Schema<SetAttrOp<any, any>>;
     /**
      * @param {SetAttrOp<V>} other
@@ -475,9 +482,11 @@ export class DeleteAttrOp<V = any, K extends string | number = string | number>
     /**
      * Full (frozen) clone; a `move` apply reuses the source op instead — see {@link DeltaBuilder#apply}.
      *
-     * @return {DeleteAttrOp<V,K>}
+     * @template {string|number} [K2=K]
+     * @param {K2} [key] retarget the clone to another attribute key; defaults to this op's key.
+     * @return {DeleteAttrOp<V,K2>}
      */
-    clone(): DeleteAttrOp<V, K>;
+    clone<K2 extends string | number = K>(key?: K2): DeleteAttrOp<V, K2>;
     $type: s.Schema<DeleteAttrOp<any, string | number>>;
     /**
      * @param {DeleteAttrOp<V>} other
@@ -531,9 +540,11 @@ export class ModifyAttrOp<Modifier extends DeltaAny = DeltaAny, K extends string
     /**
      * Full (frozen) clone; a `move` apply reuses the source op instead — see {@link DeltaBuilder#apply}.
      *
-     * @return {ModifyAttrOp<Modifier,K>}
+     * @template {string|number} [K2=K]
+     * @param {K2} [key] retarget the clone to another attribute key; defaults to this op's key.
+     * @return {ModifyAttrOp<Modifier,K2>}
      */
-    clone(): ModifyAttrOp<Modifier, K>;
+    clone<K2 extends string | number = K>(key?: K2): ModifyAttrOp<Modifier, K2>;
     $type: s.Schema<ModifyAttrOp<any, string>>;
     /**
      * @param {ModifyAttrOp<Modifier>} other
@@ -545,7 +556,7 @@ export const $modifyOp: s.Schema<ModifyOp<Delta<any>>>;
 export const $textOp: s.Schema<TextOp>;
 export const $deleteOp: s.Schema<DeleteOp<any>>;
 export const $retainOp: s.Schema<RetainOp>;
-export const $anyOp: s.Schema<DeleteOp<any> | TextOp | InsertOp<any> | ModifyOp<Delta<any>>>;
+export const $anyOp: s.Schema<TextOp | InsertOp<any> | DeleteOp<any> | ModifyOp<Delta<any>>>;
 export const $setAttrOp: s.Schema<SetAttrOp<any>>;
 export const $modifyAttrOp: s.Schema<ModifyAttrOp<any>>;
 export const $deleteAttrOp: s.Schema<DeleteAttrOp<any>>;
@@ -992,70 +1003,38 @@ export function create<Schema extends s.Schema<DeltaAny>>(schema: Schema): Schem
  * @param {NodeName} nodeName
  * @param {Attrs} attrs
  * @param {Children} [children]
- * @return {DeltaBuilder<(NodeName extends string ? { name: NodeName } : {}) & {
- *   attrs: Attrs extends null ? {} : Attrs,
- *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
- *   text: Extract<Children,string> extends never ? false : true
- * }>}
+ * @return {DeltaBuilder<CondensedDeltaConf<NodeName,Attrs,Children>>}
  */
 export function create<NodeName extends string | null, Attrs extends {
     [k: string | number]: any;
-} | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, children?: Children | undefined): DeltaBuilder<(NodeName extends string ? {
-    name: NodeName;
-} : {}) & {
-    attrs: Attrs extends null ? {} : Attrs;
-    children: Extract<Children, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never;
-    text: Extract<Children, string> extends never ? false : true;
-}>;
+} | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, children?: Children | undefined): DeltaBuilder<CondensedDeltaConf<NodeName, Attrs, Children>>;
 /**
  * @template {string|null} NodeName
  * @template {Array<any>|string} [Children=never]
  * @overload
  * @param {NodeName} nodeName
  * @param {...Array<Children>} children
- * @return {DeltaBuilder<(NodeName extends string ? { name: NodeName } : {}) & {
- *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
- *   text: Extract<Children,string> extends never ? false : true
- * }>}
+ * @return {DeltaBuilder<CondensedDeltaConf<NodeName,null,Children>>}
  */
-export function from<NodeName extends string | null, Children extends Array<any> | string = never>(nodeName: NodeName, ...children: Array<Children>[]): DeltaBuilder<(NodeName extends string ? {
-    name: NodeName;
-} : {}) & {
-    children: Extract<Children, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never;
-    text: Extract<Children, string> extends never ? false : true;
-}>;
+export function from<NodeName extends string | null, Children extends Array<any> | string = never>(nodeName: NodeName, ...children: Array<Children>[]): DeltaBuilder<CondensedDeltaConf<NodeName, null, Children>>;
 /**
  * @template {Array<any>|string} [Children=never]
  * @overload
  * @param {...Array<Children>} children
- * @return {DeltaBuilder<{
- *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
- *   text: Extract<Children,string> extends never ? false : true
- * }>}
+ * @return {DeltaBuilder<CondensedDeltaConf<null,null,Children>>}
  */
-export function from<Children extends Array<any> | string = never>(...children: Array<Children>[]): DeltaBuilder<{
-    children: Extract<Children, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never;
-    text: Extract<Children, string> extends never ? false : true;
-}>;
+export function from<Children extends Array<any> | string = never>(...children: Array<Children>[]): DeltaBuilder<CondensedDeltaConf<null, null, Children>>;
 /**
  * @template {{[k:string|number]:any}|null} Attrs
  * @template {Array<any>|string} [Children=never]
  * @overload
  * @param {Attrs} attrs
  * @param {...Array<Children>} children
- * @return {DeltaBuilder<{
- *   attrs: Attrs extends null ? {} : Attrs,
- *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
- *   text: Extract<Children,string> extends never ? false : true
- * }>}
+ * @return {DeltaBuilder<CondensedDeltaConf<null,Attrs,Children>>}
  */
 export function from<Attrs extends {
     [k: string | number]: any;
-} | null, Children extends Array<any> | string = never>(attrs: Attrs, ...children: Array<Children>[]): DeltaBuilder<{
-    attrs: Attrs extends null ? {} : Attrs;
-    children: Extract<Children, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never;
-    text: Extract<Children, string> extends never ? false : true;
-}>;
+} | null, Children extends Array<any> | string = never>(attrs: Attrs, ...children: Array<Children>[]): DeltaBuilder<CondensedDeltaConf<null, Attrs, Children>>;
 /**
  * @template {string|null} NodeName
  * @template {{[k:string|number]:any}|null} Attrs
@@ -1064,28 +1043,98 @@ export function from<Attrs extends {
  * @param {NodeName} nodeName
  * @param {Attrs} attrs
  * @param {...Array<Children>} children
- * @return {DeltaBuilder<(NodeName extends string ? { name: NodeName } : {}) & {
- *   attrs: Attrs extends null ? {} : Attrs,
- *   children: Extract<Children,Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
- *   text: Extract<Children,string> extends never ? false : true
- * }>}
+ * @return {DeltaBuilder<CondensedDeltaConf<NodeName,Attrs,Children>>}
  */
 export function from<NodeName extends string | null, Attrs extends {
     [k: string | number]: any;
-} | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, ...children: Array<Children>[]): DeltaBuilder<(NodeName extends string ? {
-    name: NodeName;
-} : {}) & {
-    attrs: Attrs extends null ? {} : Attrs;
-    children: Extract<Children, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never;
-    text: Extract<Children, string> extends never ? false : true;
-}>;
+} | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, ...children: Array<Children>[]): DeltaBuilder<CondensedDeltaConf<NodeName, Attrs, Children>>;
+/**
+ * Shorthand for `delta.create().insert(..)` — see {@link DeltaBuilder#insert}.
+ *
+ * ## Builder shorthands
+ *
+ * A changeset is written as a chain (see the readme's "condensed vs. builder chain"), and the
+ * `create()` head of that chain carries no information. Every content/attr builder method is
+ * therefore also exported standalone — {@link insert}, {@link modify}, {@link retain},
+ * {@link delete_} (trailing underscore: `delete` is a reserved word),
+ * {@link setAttr}, {@link setAttrs}, {@link deleteAttr}, {@link modifyAttr} — each returning the very
+ * same {@link DeltaBuilder}, so the rest of the chain is unchanged:
+ *
+ *     delta.retain(5).delete(6).insert('!') // ⇔ delta.create().retain(5).delete(6).insert('!')
+ *     delta.delete_(6)                      // ⇔ delta.create().delete(6)
+ *
+ * There is deliberately no `format` shorthand: formatting is the second argument of
+ * `insert`/`retain`/`modify` (`delta.retain(5, { bold: true })`). The ambient-context setters
+ * (`useFormats` & co), the mark methods, `apply`/`append`/`rebase` and the terminal methods (`done`,
+ * `toJSON`, ..) are not mirrored — they either say nothing on an empty delta or don't build one.
+ *
+ * Each shorthand is typed by indexing the method off {@link DeltaBuilder}, pinned to `create()`'s
+ * zero-arg overload — so a shorthand and its `create()`-headed equivalent infer the identical conf,
+ * with no re-declared generics to drift. The type arguments must be written out
+ * (`DeltaBuilder<{}, false>['insert']`, not `DeltaBuilder['insert']`): a bare reference to a generic
+ * type in JSDoc resolves its parameters to `any` rather than to the declared defaults, and
+ * `FixedConf = any` satisfies both arms of `insert`'s `FixedConf extends true ? ..` branch, which
+ * collapses the accreted conf.
+ *
+ * @type {DeltaBuilder<{}, false>['insert']}
+ */
+export const insert: DeltaBuilder<{}, false>["insert"];
+/**
+ * Shorthand for `delta.create().modify(..)` — see {@link DeltaBuilder#modify} and {@link insert}.
+ *
+ * @type {DeltaBuilder<{}, false>['modify']}
+ */
+export const modify: DeltaBuilder<{}, false>["modify"];
+/**
+ * Shorthand for `delta.create().retain(..)` — see {@link DeltaBuilder#retain} and {@link insert}.
+ *
+ * @type {DeltaBuilder<{}, false>['retain']}
+ */
+export const retain: DeltaBuilder<{}, false>["retain"];
+/**
+ * Shorthand for `delta.create().delete(..)` — see {@link DeltaBuilder}'s `delete` and {@link insert}.
+ *
+ * Trailing underscore because `delete` is a reserved word: `export const delete` is a syntax error,
+ * and the rename clause that would work at runtime (`export { _delete as delete }`) makes `tsc` 6
+ * emit a duplicated specifier into the `.d.ts` (`export { _delete as delete, _delete as delete }`),
+ * which then fails `npm run check-dist-types` with "Duplicate identifier". The bug is specific to
+ * declaration emit from a `.js` file — the same clause emits correctly from a `.ts` — so it cannot
+ * be worked around in source; re-test it when the TypeScript floor moves.
+ *
+ * @type {DeltaBuilder<{}, false>['delete']}
+ */
+export const delete_: DeltaBuilder<{}, false>["delete"];
+/**
+ * Shorthand for `delta.create().setAttr(..)` — see {@link DeltaBuilder#setAttr} and {@link insert}.
+ *
+ * @type {DeltaBuilder<{}, false>['setAttr']}
+ */
+export const setAttr: DeltaBuilder<{}, false>["setAttr"];
+/**
+ * Shorthand for `delta.create().setAttrs(..)` — see {@link DeltaBuilder#setAttrs} and {@link insert}.
+ *
+ * @type {DeltaBuilder<{}, false>['setAttrs']}
+ */
+export const setAttrs: DeltaBuilder<{}, false>["setAttrs"];
+/**
+ * Shorthand for `delta.create().deleteAttr(..)` — see {@link DeltaBuilder#deleteAttr} and {@link insert}.
+ *
+ * @type {DeltaBuilder<{}, false>['deleteAttr']}
+ */
+export const deleteAttr: DeltaBuilder<{}, false>["deleteAttr"];
+/**
+ * Shorthand for `delta.create().modifyAttr(..)` — see {@link DeltaBuilder#modifyAttr} and {@link insert}.
+ *
+ * @type {DeltaBuilder<{}, false>['modifyAttr']}
+ */
+export const modifyAttr: DeltaBuilder<{}, false>["modifyAttr"];
 export function diff<Conf_1 extends DeltaConf>(d1: Delta<Conf_1>, d2: NoInfer<Delta<Conf_1>>, options?: DiffOptions): Delta<Conf_1>;
 export function inverse<Conf_1 extends DeltaConf>(d: DeltaAny, base: Delta<Conf_1>): Delta<Conf_1>;
 export function diffChangesetWithSeparator(changeset: Array<{
     index: number;
     remove: Array<any>;
     insert: Array<any>;
-}>, separator: RegExp): any[];
+}>, separator: RegExp, leftmostIndex?: number): any[];
 /**
  * Provenance metadata on a content/attr op: *who/what* inserted, deleted, or formatted it. The canonical
  * shape below is a convention — apply/diff/equality treat attribution as an **opaque** object (never branching
@@ -1268,6 +1317,28 @@ export type ReadDeltaConf<DConfSpec extends ReadableDeltaConf> = [DConfSpec exte
 } ? {
     recursiveChildren: true;
 } : {}))>> : never;
+/**
+ * The conf produced by the condensed factories ({@link create}'s 3-arg form and {@link from}) -
+ * the whole node declared in one call instead of built up with chained `setAttr`/`insert`. Routed
+ * through {@link DeltaConfOverwrite} - and hence `PrettifyDeltaConf`/`_SanifyDelta` - so a condensed
+ * call yields exactly the conf its `create(name).setAttrs(attrs).insert(children)`
+ * equivalent would: delta-valued attrs/children normalize to `Delta<..>` (not `DeltaBuilder<..>`),
+ * and an unsupplied slot is omitted rather than declared as `children: never` / `text: false`.
+ *
+ * The `[X] extends [never]` bracketing is load-bearing: `Extract<never,Array<any>>` is `never`, and
+ * a bare `never extends Array<infer Ac>` matches with `Ac = never`.
+ */
+export type CondensedDeltaConf<NodeName_1 extends string | null, Attrs_1 extends {
+    [k: string | number]: any;
+} | null, Children_1 extends Array<any> | string> = DeltaConfOverwrite<NodeName_1 extends string ? {
+    name: NodeName_1;
+} : {}, (Attrs_1 extends null ? {} : {
+    attrs: Attrs_1;
+}) & ([Extract<Children_1, Array<any>>] extends [never] ? {} : (Extract<Children_1, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? {} : {
+    children: Ac;
+}) : {})) & ([Extract<Children_1, string>] extends [never] ? {} : {
+    text: true;
+})>;
 export type DiffOptions = {
     /**
      * Predicate deciding when two nodes
@@ -1284,6 +1355,24 @@ export type DiffOptions = {
      * manipulates deltas in place, e.g. a transformer).
      */
     clone?: boolean | undefined;
+    /**
+     * Where the change starts, as a position into `d1`: the
+     * `path`'s numbers are content offsets (the trailing number is the gap the change starts at, in pre-edit
+     * coordinates — the `from` of the editor transaction), string steps descend into attributes; `assoc` and
+     * `attrs` are ignored. Places the first edit there when the content allows it (a wrong hint only shifts
+     * placement, never correctness) — see "The hint" above.
+     */
+    hint?: import("./position.js").Pos | undefined;
+};
+/**
+ * Where a lockstep walk of two states stands: the current op of each side and the units of it already
+ * consumed from the walked end.
+ */
+export type Cursors = {
+    a: ChildrenOpAny | null;
+    ai: number;
+    b: ChildrenOpAny | null;
+    bi: number;
 };
 import * as s from '../schema.js';
 import * as list from '../list.js';

package/dist/diff/patience.d.ts

@@ -1,4 +1,4 @@
-export function diff(as: Array<string>, bs: Array<string>): Array<{
+export function diff(as: Array<string>, bs: Array<string>, leftmost?: boolean): Array<{
     index: number;
     remove: Array<string>;
     insert: Array<string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "1.0.0-rc.29",
+  "version": "1.0.0-rc.31",
   "description": "isomorphic utility functions",
   "sideEffects": false,
   "type": "module",