lib0 1.0.0-rc.29 → 1.0.0-rc.30

package/dist/delta/delta.d.ts

@@ -992,70 +992,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 +1032,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 +1306,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 +1344,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.30",
   "description": "isomorphic utility functions",
   "sideEffects": false,
   "type": "module",