lib0 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/delta/transformer/project.d.ts

@@ -0,0 +1,223 @@
+/**
+ * One child slot of a {@link ProjectionTransformer}'s fixed output layout: a run of static text, a
+ * single static node/embed, or a single hole (filled by a sub-transformer's output).
+ *
+ * A hole's `carrier` records how its sub-transformer's output is placed: `'value'` lifts a
+ * `lib0:value` carrier to a bare scalar embed (1 position, replaced on update); `'node'` embeds a
+ * structural node verbatim (a nested `project`'s render, or a non-value carrier) and forwards its
+ * incremental change as a `modify`. The kind is fixed once: known at `init` for auto-wrapped nested
+ * projects, otherwise sniffed from the first render and cached (`lastScalar` keeps the last lifted
+ * scalar so a view deletion of a value slot can be self-healed).
+ *
+ * @typedef {{ kind: 'text', str: string, format?: any, attribution?: any }
+ *  | { kind: 'static', el: any, format?: any, attribution?: any }
+ *  | { kind: 'hole', t: Transformer<any,any>, el: any, carrier?: 'value'|'node', lastScalar?: any, format?: any, attribution?: any }} ChildItem
+ */
+/**
+ * Stateful transformer produced by {@link ProjectionTemplate}. Side A is the data (the
+ * *projectionDelta*); side B is the projected structure - the spec with each hole filled by its
+ * sub-transformer's output. `project` resolves the `lib0:value` carrier itself: at an *attribute*
+ * position (keyed) and at a *child* position (positional, 1->1) it lifts the carrier to its bare
+ * scalar. A child hole that is a nested `project` (or any non-`lib0:value` carrier) is embedded as a
+ * node. A `lib0:inline` fragment is left intact for a downstream `inline(['lib0:inline'])`.
+ *
+ * The output layout is *fixed*: every hole occupies exactly one attribute or one child node, and
+ * static content is constant. So `applyA` routes data changes into holes, and `applyB` routes view
+ * edits at *node*-hole positions back to holes while **self-healing** edits to static content and to
+ * value slots (a bare scalar has no `modify` channel, so a value-slot view edit is not round-tripped
+ * to data in v1 - use an attribute hole for an editable binding).
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class ProjectionTransformer extends Transformer<any, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     * @param {string} name
+     * @param {Array<{ key: string|number, value: any, attribution?: any }>} staticAttrs
+     * @param {Array<{ key: string|number, t: Transformer<any,any> }>} attrHoles
+     * @param {Array<ChildItem>} items child slots in output order
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>, name: string, staticAttrs: Array<{
+        key: string | number;
+        value: any;
+        attribution?: any;
+    }>, attrHoles: Array<{
+        key: string | number;
+        t: Transformer<any, any>;
+    }>, items: Array<ChildItem>);
+    name: string;
+    staticAttrs: {
+        key: string | number;
+        value: any;
+        attribution?: any;
+    }[];
+    attrHoles: {
+        key: string | number;
+        t: Transformer<any, any>;
+    }[];
+    items: ChildItem[];
+    /**
+     * @type {Array<{ start: number, len: number, item: ChildItem }>}
+     */
+    segs: Array<{
+        start: number;
+        len: number;
+        item: ChildItem;
+    }>;
+    initialized: boolean;
+    /**
+     * Lift a child hole's sub-transformer output and place it on `out`. Returns the output count (1).
+     * For a value carrier the bare scalar is inserted (and cached for self-heal); otherwise the node is
+     * embedded verbatim. The hole's `carrier` kind is sniffed once here and cached.
+     *
+     * @param {delta.DeltaBuilderAny} out
+     * @param {ChildItem & { kind: 'hole' }} item
+     * @param {delta.DeltaAny?} rb the sub-transformer's B output
+     */
+    _placeHole(out: delta.DeltaBuilderAny, item: ChildItem & {
+        kind: "hole";
+    }, rb: delta.DeltaAny | null): void;
+    /**
+     * Initial render: emit the full structure with every hole filled.
+     *
+     * @param {delta.DeltaBuilderAny} d
+     */
+    _render(d: delta.DeltaBuilderAny): {
+        a: delta.DeltaBuilder<any, false> | null;
+        b: delta.DeltaBuilder<any, false> | null;
+        isEmpty(): boolean;
+        clear(): void;
+        applyA(a: delta.DeltaBuilder<any, false> | null): /*elided*/ any;
+        applyB(b: delta.DeltaBuilder<any, false> | null): /*elided*/ any;
+        reverse(): /*elided*/ any;
+    };
+    /**
+     * Incremental data change: emit only the hole updates. A value hole is *replaced*
+     * (`delete(1).insert([scalar])`, since a scalar embed has no inner structure to modify); a node
+     * hole forwards its sub-transformer's incremental change as a `modify`.
+     *
+     * @param {delta.DeltaBuilderAny} d
+     */
+    _update(d: delta.DeltaBuilderAny): {
+        a: delta.DeltaBuilder<any, false> | null;
+        b: delta.DeltaBuilder<any, false> | null;
+        isEmpty(): boolean;
+        clear(): void;
+        applyA(a: delta.DeltaBuilder<any, false> | null): /*elided*/ any;
+        applyB(b: delta.DeltaBuilder<any, false> | null): /*elided*/ any;
+        reverse(): /*elided*/ any;
+    };
+    /**
+     * Reconstruct the content occupying output positions `[start, start+len)` as insert ops on `out`
+     * (used to self-heal a view delete). Static text/nodes are restored from the spec, and a value
+     * slot is restored from its last-rendered scalar. Node-hole positions are skipped (their dynamic
+     * structure cannot be restored without the current data).
+     *
+     * @param {delta.DeltaBuilderAny} out
+     * @param {number} start
+     * @param {number} len
+     */
+    _restore(out: delta.DeltaBuilderAny, start: number, len: number): void;
+}
+/**
+ * Template that projects the *projectionDelta* onto a fixed structure described by `spec` - an
+ * ordinary {@link import('../delta.js').create delta} whose attribute values and inserted children
+ * may be transformer {@link Template templates} ("holes"). Each hole receives the whole
+ * projectionDelta; its output is placed at that position. The spec is a *write-only template*: it is
+ * walked once at {@link ProjectionTemplate#init} and never fingerprinted/diffed.
+ *
+ * Holes resolve themselves: a `lib0:value` carrier (produced by {@link import('./attr.js').attr}) is
+ * lifted to a bare scalar; a nested subtree that contains a hole is **auto-wrapped** into a nested
+ * `project` at `init`, so deep structure composes through nested templates with the recursion built
+ * once (bounded by spec depth). Plain static subtrees are embedded verbatim.
+ *
+ * @template {delta.DeltaConf} [IN=any]
+ * @template {delta.DeltaConf} [SpecConf=any]
+ * @extends {Template<IN, ProjectOutput<SpecConf>>}
+ */
+export class ProjectionTemplate<IN extends delta.DeltaConf = any, SpecConf extends delta.DeltaConf = any> extends Template<IN, delta.DeltaConfOverwrite<delta.AsDeltaConf<Omit<SpecConf, "children" | "attrs"> & (SpecConf extends {
+    attrs: infer A;
+} ? {
+    attrs: ResolveAttrs<A>;
+} : {}) & (SpecConf extends {
+    children: infer Ch;
+} ? {
+    children: ResolveChild<Ch>;
+} : {})>, {}>> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+     * @param {delta.Delta<SpecConf>} spec
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>, spec: delta.Delta<SpecConf>);
+    spec: delta.Delta<SpecConf>;
+}
+export function project<IN extends delta.DeltaConf, SpecConf extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>, spec: delta.Delta<SpecConf>): ProjectionTemplate<IN, SpecConf>;
+/**
+ * Resolve a hole template's output conf `OUT` to its projected placement type: a `lib0:value` carrier
+ * lifts to its bare scalar; any other node is embedded as a `Delta<OUT>`.
+ */
+export type ResolveHoleOut<OUT extends delta.DeltaConf> = OUT extends {
+    name: "lib0:value";
+    attrs: {
+        value: infer V;
+    };
+} ? V : delta.Delta<OUT>;
+/**
+ * Resolve one spec child element to its projected output type, distributing over a children union: a
+ * hole ({@link Template}, whose output conf the spec carries) resolves via its `OUT`, a nested spec
+ * delta recurses, and anything else (text, a static scalar/node) is kept verbatim.
+ */
+export type ResolveChild<C> = C extends Template<any, infer OUT extends delta.DeltaConf> ? ResolveHoleOut<OUT> : C extends delta.Delta<infer NC extends delta.DeltaConf> ? delta.Delta<ProjectOutput<NC>> : C;
+/**
+ * Resolve a spec's attrs map: a hole attribute value resolves via its output conf; a static value is kept.
+ */
+export type ResolveAttrs<A> = { [K in keyof A]: A[K] extends Template<any, infer OUT extends delta.DeltaConf> ? ResolveHoleOut<OUT> : A[K]; };
+/**
+ * The concrete output conf of a `project($d, spec)` whose spec has conf `SpecConf`: static structure
+ * is kept, value holes lift to their scalar, nested specs / node holes recurse. Holes are schema-bound
+ * {@link Template}s, so their output conf is already concrete in `SpecConf` (no input param needed).
+ */
+export type ProjectOutput<SpecConf extends delta.DeltaConf> = import("./core.js").ResolveOut<delta.AsDeltaConf<Omit<SpecConf, "attrs" | "children"> & (SpecConf extends {
+    attrs: infer A;
+} ? {
+    attrs: ResolveAttrs<A>;
+} : {}) & (SpecConf extends {
+    children: infer Ch;
+} ? {
+    children: ResolveChild<Ch>;
+} : {})>>;
+/**
+ * One child slot of a {@link ProjectionTransformer}'s fixed output layout: a run of static text, a
+ * single static node/embed, or a single hole (filled by a sub-transformer's output).
+ *
+ * A hole's `carrier` records how its sub-transformer's output is placed: `'value'` lifts a
+ * `lib0:value` carrier to a bare scalar embed (1 position, replaced on update); `'node'` embeds a
+ * structural node verbatim (a nested `project`'s render, or a non-value carrier) and forwards its
+ * incremental change as a `modify`. The kind is fixed once: known at `init` for auto-wrapped nested
+ * projects, otherwise sniffed from the first render and cached (`lastScalar` keeps the last lifted
+ * scalar so a view deletion of a value slot can be self-healed).
+ */
+export type ChildItem = {
+    kind: "text";
+    str: string;
+    format?: any;
+    attribution?: any;
+} | {
+    kind: "static";
+    el: any;
+    format?: any;
+    attribution?: any;
+} | {
+    kind: "hole";
+    t: Transformer<any, any>;
+    el: any;
+    carrier?: "value" | "node";
+    lastScalar?: any;
+    format?: any;
+    attribution?: any;
+};
+import { Transformer } from './core.js';
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+//# sourceMappingURL=project.d.ts.map

package/dist/delta/transformer/rename-attrs.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Renames node attributes (`a` -> `b`) in both directions. Holds no per-application state, so
+ * {@link RenameAttrs} builds a single instance and shares it across every `init`.
+ *
+ * @extends Transformer<any,any>
+ */
+export class RenameAttrsTransformer extends Transformer<any, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     * @param {{[K:string|number]:string|number}} renames
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>, renames: {
+        [K: string | number]: string | number;
+    });
+    arenames: {
+        [K: string]: string | number;
+        [K: number]: string | number;
+    };
+    /**
+     * @type {{[K:string|number]:string|number}}
+     */
+    brenames: {
+        [K: string | number]: string | number;
+    };
+    /**
+     * @param {delta.DeltaAny} deltaA
+     * @return {import('./core.js').TransformResultAny}
+     */
+    applyA(deltaA: delta.DeltaAny): import("./core.js").TransformResultAny;
+    /**
+     * @param {delta.DeltaAny} deltaB
+     * @return {import('./core.js').TransformResultAny}
+     */
+    applyB(deltaB: delta.DeltaAny): import("./core.js").TransformResultAny;
+}
+/**
+ * Template that renames node attributes (`a` -> `b`) in both directions.
+ *
+ * @template {{[K:string|number]:string|number}} Renames
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, ApplyRenameAttrs<Renames, IN>>}
+ */
+export class RenameAttrs<Renames extends {
+    [K: string | number]: string | number;
+}, IN extends delta.DeltaConf = any> extends Template<IN, delta.DeltaConfOverwrite<IN, {
+    attrs: import("../../ts.js").PropsRename<import("../../ts.js").TypeIsAny<IN, {
+        [K: string]: any;
+        [K: number]: any;
+    }, IN extends {
+        attrs: infer Attrs;
+    } ? Attrs extends undefined ? {} : Attrs : {}>, Renames>;
+}>> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+     * @param {Renames} renames
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>, renames: Renames);
+    /**
+     * @type {Renames}
+     */
+    renames: Renames;
+}
+export function renameAttrs<IN extends delta.DeltaConf, const Renames extends {
+    [K: string | number]: string | number;
+}>($d: import("../../schema.js").Schema<delta.Delta<IN>>, renames: Renames): RenameAttrs<Renames, IN>;
+export type ApplyRenameAttrs<Renames extends {
+    [K: string | number]: string | number;
+}, IN extends delta.DeltaConf> = delta.DeltaConfOverwrite<IN, {
+    attrs: import("../../ts.js").PropsRename<delta.DeltaConfGetAttrs<IN>, Renames>;
+}>;
+import { Transformer } from './core.js';
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+//# sourceMappingURL=rename-attrs.d.ts.map

package/dist/delta/transformer/rename.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Relabels a node: side B carries the configured `name`, side A keeps the source node's original
+ * name. Otherwise identity. Useful to mark a `children`-mapped collection as `lib0:inline` (so a
+ * downstream {@link import('./inline.js').inline}`(['lib0:inline'])` splices it into its parent) or
+ * simply to rename the container (e.g. a data collection projected as a `<ul>`).
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class RenameTransformer extends Transformer<any, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     * @param {string} name
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>, name: string);
+    target: string;
+    /** @type {string|undefined} */
+    srcName: string | undefined;
+}
+/**
+ * Template for {@link RenameTransformer}.
+ *
+ * @template {string} Name
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, delta.DeltaConfOverwrite<IN, { name: Name }>>}
+ */
+export class Rename<Name extends string, IN extends delta.DeltaConf = any> extends Template<IN, delta.DeltaConfOverwrite<IN, {
+    name: Name;
+}>> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+     * @param {Name} name
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>, name: Name);
+    target: Name;
+}
+export function rename<IN extends delta.DeltaConf, Name extends string>($d: import("../../schema.js").Schema<delta.Delta<IN>>, name: Name): Rename<Name, IN>;
+import { Transformer } from './core.js';
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+//# sourceMappingURL=rename.d.ts.map

package/dist/delta/transformer/value.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Stateful transformer that resolves `lib0:value` carrier *children* of a node: a `lib0:value` node
+ * (1 position) becomes an embed of its scalar value (1 position), and back. Count-preserving, so a
+ * single sparse positional map (`insert([1])` at carrier positions, coalesced `retain(n)` over
+ * gaps) indexes both directions - the same `childTs` technique as {@link import('./children.js')}.
+ *
+ * A standalone, *composable* one-level resolver (the `lib0:value` counterpart of
+ * {@link import('./inline.js').inline}`(['lib0:inline'])`): place it after any transformer that emits
+ * `lib0:value` carriers, or compose it with {@link import('./children.js').children} to descend into
+ * deeper levels. `project` lifts the carriers in its *own* structure, so `unwrapValue` is only needed
+ * for carriers emitted by a non-`project` transformer.
+ *
+ * Editing a resolved scalar from side B (the view) is not round-tripped in v1: a value *update*
+ * driven from side A (a `modify` on the carrier) maps to `delete(1).insert([newValue])`, but a side
+ * B `delete`+`insert` of the embed is treated structurally.
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class UnwrapValueTransformer extends Transformer<any, any> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
+     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
+     */
+    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>);
+    /**
+     * Sparse positional map of carriers: `insert([1])` at each `lib0:value` child, `retain(n)` over
+     * gaps (text and pass-through nodes).
+     *
+     * @type {delta.DeltaBuilderAny}
+     */
+    map: delta.DeltaBuilderAny;
+    /**
+     * @param {delta.DeltaBuilderAny} d the change to map
+     * @param {boolean} fwd `true` maps side A (carriers present) -> B (resolved), `false` maps back
+     * @return {import('./core.js').TransformResultAny}
+     */
+    transform(d: delta.DeltaBuilderAny, fwd: boolean): import("./core.js").TransformResultAny;
+}
+/**
+ * A `lib0:value` carrier child lifts to its scalar `value` type; any other child passes through.
+ * Naked-param conditional, so it distributes over a children union.
+ *
+ * @template C
+ * @typedef {C extends delta.Delta<{ name: 'lib0:value', attrs: { value: infer V extends import('../../trait/fingerprint.js').Fingerprintable } }> ? V : C} UnwrapValueChild
+ */
+/**
+ * `unwrapValue`'s output conf: `IN` with every `lib0:value` carrier child replaced by its lifted
+ * scalar (see {@link UnwrapValueChild}); name/attrs/text unchanged.
+ *
+ * @template {delta.DeltaConf} IN
+ * @typedef {import('./core.js').ResolveOut<delta.DeltaConfOverwrite<IN, { children: UnwrapValueChild<delta.DeltaConfGetChildren<IN>> }>>} UnwrapValueOut
+ */
+/**
+ * Template for {@link UnwrapValueTransformer}.
+ *
+ * @template {delta.DeltaConf} [IN=any]
+ * @extends {Template<IN, UnwrapValueOut<IN>>}
+ */
+export class UnwrapValue<IN extends delta.DeltaConf = any> extends Template<IN, delta.DeltaConfOverwrite<delta.DeltaConfOverwrite<IN, {
+    children: UnwrapValueChild<IN extends {
+        children: infer Children;
+    } ? unknown extends Children ? any : Children : never> | UnwrapValueChild<IN extends {
+        recursiveChildren: true;
+    } ? delta.Delta<IN> : never>;
+}>, {}>> {
+    /**
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d
+     */
+    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>);
+}
+export function unwrapValue<IN extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>): UnwrapValue<IN>;
+/**
+ * A `lib0:value` carrier child lifts to its scalar `value` type; any other child passes through.
+ * Naked-param conditional, so it distributes over a children union.
+ */
+export type UnwrapValueChild<C> = C extends delta.Delta<{
+    name: "lib0:value";
+    attrs: {
+        value: infer V extends import("../../trait/fingerprint.js").Fingerprintable;
+    };
+}> ? V : C;
+/**
+ * `unwrapValue`'s output conf: `IN` with every `lib0:value` carrier child replaced by its lifted
+ * scalar (see {@link UnwrapValueChild}); name/attrs/text unchanged.
+ */
+export type UnwrapValueOut<IN extends delta.DeltaConf> = import("./core.js").ResolveOut<delta.DeltaConfOverwrite<IN, {
+    children: UnwrapValueChild<delta.DeltaConfGetChildren<IN>>;
+}>>;
+import { Transformer } from './core.js';
+import * as delta from '../delta.js';
+import { Template } from './core.js';
+//# sourceMappingURL=value.d.ts.map

package/dist/delta/transformer.d.ts

@@ -0,0 +1,14 @@
+export * from "./transformer/core.js";
+export * from "./transformer/id.js";
+export * from "./transformer/rename.js";
+export * from "./transformer/conform.js";
+export * from "./transformer/pipe.js";
+export * from "./transformer/attr.js";
+export * from "./transformer/inline.js";
+export * from "./transformer/children.js";
+export * from "./transformer/project.js";
+export * from "./transformer/value.js";
+export * from "./transformer/rename-attrs.js";
+export * from "./transformer/attribution-to-format.js";
+export * from "./transformer/full-attributions.js";
+//# sourceMappingURL=transformer.d.ts.map

package/dist/diff/patience.d.ts

@@ -0,0 +1,25 @@
+export function diff(as: Array<string>, bs: Array<string>): Array<{
+    index: number;
+    remove: Array<string>;
+    insert: Array<string>;
+}>;
+export function diffSplitBy(a: string, b: string, regexp: RegExp | string): {
+    index: number;
+    remove: string;
+    insert: string;
+}[];
+/**
+ * Idea: match all "non-word" characters and keep them separate (spaces, comma, exclamation marks, ..).
+ * Anything that can be classivied as a word (emoji, char, number) will be bundled together. All other tokens are kept
+ * individually. "hello, world!!!!" => ['hello', ',', ' ', 'world', '!', '!']
+ *
+ * @experimental
+ */
+export const smartSplitRegex: RegExp;
+export function diffAuto(a: string, b: string): {
+    insert: string;
+    remove: string;
+    index: number;
+}[];
+export function splitByRegexp(str: string, regexp: RegExp, includeSeparator: boolean): string[];
+//# sourceMappingURL=patience.d.ts.map

package/{types → dist}/environment.d.ts

@@ -1,6 +1,16 @@
 export const isNode: boolean;
+/**
+ * True iff this script is running in deno
+ * @type {boolean}
+ */
+export const isDeno: boolean;
 export const isBrowser: boolean;
 export const isMac: boolean;
+/**
+ * True iff a DOM is available — either a real browser, or Node with a jsdom shim installed (see
+ * `src/test-setup.js`). Gate DOM-dependent tests on this so they run in the browser AND under jsdom.
+ */
+export const hasDom: boolean;
 export function hasParam(name: string): boolean;
 export function getParam(name: string, defaultVal: string): string;
 export function getVariable(name: string): string | null;

package/dist/hash/fnv1a.d.ts

@@ -0,0 +1,11 @@
+/**
+ * FNV-1a offset basis (32bit).
+ */
+export const offsetBasis: 2166136261;
+/**
+ * FNV-1a prime (32bit).
+ */
+export const prime: 16777619;
+export function digest(data: Uint8Array, hash?: number): number;
+export function digestString(str: string, hash?: number): number;
+//# sourceMappingURL=fnv1a.d.ts.map