@elaraai/e3-ui 1.0.86 → 1.0.87

package/dist/src/plan/root.d.ts

@@ -0,0 +1,290 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The Plan's canvas — `Plan.Root`, which assembles the canvas's root
+ * ({@link PlanRootType}): its rows over `data`, its axis, links, editing
+ * session and the rest. `<Plan>` carries it in its payload (#1191),
+ * beside the event kinds and their resources.
+ *
+ * @packageDocumentation
+ */
+import { type EastType, type ExprType, type SubtypeExprOrValue, Expr, ArrayType, BooleanType, DictType, FunctionType, NullType, OptionType, StringType } from "@elaraai/east";
+import { DensityType, DragEventType, StatusValueType, UIComponentType, type DensityLiteral, type PagedSourceLike, type PickHandle, type StatusValueLiteral } from "@elaraai/east-ui";
+import { SliceBindType, type RecordSliceChromeOptions, type SliceAffordanceLiteral } from "@elaraai/east-ui/internal";
+import { PlanGrainType, type PlanGrainLiteral, PlanLinkType, PlanRowIdType, PlanGroupToggleEventType, PlanElementRefType, PlanBlocksType, PlanUiBindType, type PlanAxisKindLiteral, type PlanAxisInput } from "./types.js";
+import { PlanRootType } from "./ir.js";
+import { PlanSeriesType, type PlanSeriesInput } from "./series.js";
+/**
+ * The Plan's editing session (#880) — the Sheet's, over the canvas's entries:
+ * every dropped card and every moved or resized element (#825) is a DRAFT of
+ * the entry it was made on, each gesture one undoable transaction, and Save
+ * one checked, idempotent batch against the base the drafts began from.
+ *
+ * @remarks
+ * The entries are `data`'s top-level entries: a gesture on a row at any depth
+ * drafts the entry its row came from (the whole subtree rides in it), and the
+ * canvas draws a draft by deriving the entry's rows again — exactly what
+ * Save leaves. The callbacks are East functions over the canvas's own entry
+ * type `R` and key type `K`:
+ *
+ * - `onApply(Editing.Types.ChangeSet(R, K)) → Editing.Types.ApplyResult`
+ *   commits a batch — sync or async. Its base is the inline `Dict`'s snapshot,
+ *   or a paged source's revision; a batch against a source that moved is
+ *   refused, never rebased.
+ * - `onUpdate(Dict<K, R>)` is the inline adapter instead: with
+ *   `data={liveHandle}` it applies each batch with `Editing.apply` over the
+ *   handle's latest `Dict` and writes the whole result — idempotent across
+ *   retries. Exclusive with `onApply`.
+ * - `onPatch(Plan.Types.PatchEvent(R))` observes every gesture.
+ * - `ready(R, K) → Editing.Types.Readiness` is the author's check over one
+ *   drafted entry; a refusal holds Save and names the entry.
+ *
+ * @property onApply - Commit one checked batch (sync or async)
+ * @property onUpdate - The inline adapter's writer — the whole collection with the batch applied (requires `data={liveHandle}`)
+ * @property onPatch - Observe every gesture
+ * @property mode - `"batch"` (Save sends) or `"auto"` (each ready gesture goes at once)
+ * @property ready - The author's readiness check over a drafted entry
+ */
+export interface PlanEditingConfig {
+    /** Commit one checked batch — `Fn(Editing.Types.ChangeSet(R, K)) → Editing.Types.ApplyResult`, sync or async. */
+    onApply?: ExprType<EastType>;
+    /** The inline adapter's writer — `Fn(Dict<K, R>) → Null`; requires `data={liveHandle}`, exclusive with `onApply`. */
+    onUpdate?: ExprType<EastType>;
+    /** Observe every gesture — `Fn(Plan.Types.PatchEvent(R)) → Null`. */
+    onPatch?: ExprType<EastType>;
+    /** When a ready batch goes: on Save (`"batch"`, the default), or at once (`"auto"`). */
+    mode?: "batch" | "auto";
+    /** The author's check over one drafted entry — `Fn(R, K) → Editing.Types.Readiness`. */
+    ready?: ExprType<EastType>;
+}
+/**
+ * A whole-value bind handle (`State.bind` / `Data.bind`) over a keyed
+ * collection — accepted as `data`. The canvas reads it as the inline arm, and
+ * `editing.onUpdate` writes each applied batch back through it (#880).
+ */
+export interface PlanBindHandle {
+    /** The handle's read. */
+    read: (...args: never[]) => Expr<DictType<EastType, EastType>>;
+}
+/**
+ * The canvas's configuration — {@link createPlanRoot}'s (`Plan.Root`), and
+ * what `<Plan>` takes for its rows over `data` (#1191).
+ *
+ * @remarks
+ * `K` is the canvas's axis kind, inferred from `axis` ALONE (`series` is a
+ * `NoInfer` site): a `Plan.axis.number(...)` fixes `K = "number"`, and every
+ * series in the array must then carry a kind within it — a `"time"` series
+ * is a compile error at the tag. An erased axis (a `$.let`-bound expression,
+ * a variant value) leaves `K` at every kind, so the render-time diagnostic
+ * decides; an erased series (`$.const`-bound list, East expression) is
+ * accepted on any axis for the same reason.
+ *
+ * @typeParam K - The canvas's axis kind — inferred from `axis`
+ * @property axis - The shared axis declaration (`Plan.axis` / `.time` / `.number` / `.ordinal`)
+ * @property data - The source — a `Dict<K, R>` value/expression, a bind handle over one, or a paged source of one; pairs with `series` or `pick`
+ * @property series - The row series over `data` — `Plan.series.*` values; the list IS the layout; exclusive with `pick`
+ * @property pick - A bound series library (`Plan.pick`) — the canvas shows the picked series and mounts the library panel; exclusive with `series`
+ * @property links - The link graph (R1) — run-edge quantity links (`Plan.link` values)
+ * @property grain - Initial grain (`"group"` / `"resource"`; default resource)
+ * @property popover - Generalized click-popover resolver over the element ref (`none` result ⇒ no surface)
+ * @property hover - Generalized hovercard resolver over the element ref (`none` result ⇒ no surface)
+ * @property expandRender - The R2 developer render for rows declaring `expand` (called with the row's id)
+ * @property expandGutter - The R2 gutter render — fills the expanded row's grown gutter cell (called with the row's id)
+ * @property editing - The editing session (#880) — every dropped card, move and resize a draft, saved as one checked batch
+ * @property slice - Bound slice chrome (toolbar affordances)
+ * @property footer - Status-footer items
+ * @property id - DnD target identity — what a Library beside the Plan reaches it by
+ * @property sources - The ids of the Libraries beside the Plan whose cards it takes; its own library panel's need none
+ * @property canDrop - IR-level drop veto (the ⊘ stage) — consulted before a drop becomes a draft
+ * @property onSelect - Row click (selection)
+ * @property onElementClick - A click on any element — run, tile, mark, chip, cell or link ribbon — by its ref (#824)
+ * @property onGroupToggle - A row with children expanded or collapsed
+ * @property onGrainChange - Grain segment change
+ * @property ui - A bound interaction state (`State.bind` at `Plan.Types.UiState`, #824)
+ * @property style - Sizing, density and gutter width
+ */
+export interface PlanConfig<K extends PlanAxisKindLiteral = PlanAxisKindLiteral> {
+    /** The shared axis declaration (`Plan.axis` / `.time` / `.number` / `.ordinal`) — fixes the canvas kind `K`.
+     *  A time or number axis states its `window`, or the canvas binds a `slice` whose range supplies it —
+     *  there is no fit to the data (#822), inline or paged. */
+    axis: PlanAxisInput<K>;
+    /** The source — a KEYED collection: a `Dict<K, R>` value or expression (a
+     *  `$.let`-bound map, `Data.bind(...).read()`) or a whole-value bind handle
+     *  over one (`data={handle}` — what `editing.onUpdate` writes back
+     *  through) for the INLINE arm, or a `$.let`-bound paged handle over one
+     *  (`Data.bindPaged(ops)`) for the PAGED arm; the East type is the
+     *  discriminant. Any key type: a row's path
+     *  starts with its entry's key (the String itself, any other key as its
+     *  `.east` text), so the canvas is addressed by the keys the source is
+     *  searched and windowed by. Entries may be any East type — a struct, a
+     *  recursive node, or a collection (`groupToDicts`' groups).
+     *
+     *  A positional collection is refused — key it at the call site with
+     *  `rows.toDict((_$, r) => r.id)`, which makes the choice explicit. */
+    data: SubtypeExprOrValue<DictType<EastType, EastType>> | PlanBindHandle | PagedSourceLike;
+    /** The row series over `data` — `Plan.series.*` values, a TS array or an
+     *  East expression of `ArrayType(Plan.Types.Series(R))`.
+     *
+     *  The list IS the layout (#822): each series contributes one contiguous
+     *  block, top to bottom in declared order, its rows in source order, each
+     *  parent followed by its subtree. Series keys must be unique across the
+     *  whole series tree — a TS array is checked here.
+     *
+     *  Every series' axis kind must lie within the axis's (`K`): a `"time"`
+     *  series on a `"number"` axis fails to compile here. */
+    series?: PlanSeriesInput<NoInfer<K>>;
+    /**
+     * A bound series library from `Plan.pick` — the pickable form of `series`.
+     *
+     * @remarks
+     * Exclusive with `series`, because the handle already CARRIES the series
+     * list; passing both would say it twice and leave the two free to disagree.
+     * Give one or the other: `series` for a fixed canvas, `pick` for a canvas
+     * whose rows the user chooses.
+     *
+     * The Plan does the rest — it feeds itself the picked series (in the pick's
+     * order, which is the layout) and mounts the library panel as chrome, the
+     * way `slice` mounts the rail.
+     *
+     * A pick is STATE, so a Plan carrying one must sit inside a `Reactive` —
+     * `Plan.pick` binds through `State.bind`, and a bind outside a reactive
+     * evaluation promotes the enclosing function to async.
+     */
+    pick?: PickHandle<ReturnType<typeof PlanSeriesType>>;
+    /** The link graph (R1) — run-edge quantity links (`Plan.link` values, map-derivable
+     *  from data, their ends `Plan.ref(series, …path)`); the links-focus control gathers a
+     *  row's transitive family over it. */
+    links?: SubtypeExprOrValue<ArrayType<PlanLinkType>>;
+    /** Initial grain (default `"resource"`). */
+    grain?: PlanGrainLiteral | SubtypeExprOrValue<PlanGrainType>;
+    /** Generalized click-popover resolver — called with the clicked element's
+     *  ref (`run` / `event` / `chip` / `mark` / `cell` arm, each carrying the
+     *  row's id, or a ribbon's `link` arm); returning `none` opens no surface. */
+    popover?: SubtypeExprOrValue<FunctionType<[PlanElementRefType], OptionType<UIComponentType>>>;
+    /** Generalized hovercard resolver — the hover twin of `popover`. */
+    hover?: SubtypeExprOrValue<FunctionType<[PlanElementRefType], OptionType<UIComponentType>>>;
+    /** The R2 developer render — called with the row's id when a row declaring
+     *  `expand` focuses; builds the mounted body from captured data /
+     *  bind-handles. */
+    expandRender?: SubtypeExprOrValue<FunctionType<[PlanRowIdType], UIComponentType>>;
+    /** The R2 GUTTER render — an expanded row's gutter cell grows with the row
+     *  (one tall cell, top-aligned under the row's name), and this fills the
+     *  space that opens up: the identity, measures or controls that only earn
+     *  their place once the row has the canvas. Called with the same row id
+     *  as `expandRender`. */
+    expandGutter?: SubtypeExprOrValue<FunctionType<[PlanRowIdType], UIComponentType>>;
+    /** The editing session (#880) — see {@link PlanEditingConfig}. Without it the canvas takes no gesture: no card
+     *  lands and nothing moves. */
+    editing?: PlanEditingConfig;
+    /** Bound slice chrome — the handle + toolbar affordances (default `["cohort","filter","search","range","resolution","brush","summary"]`). */
+    slice?: {
+        /** The bound handle from `Slice.bind`. */
+        slice: SubtypeExprOrValue<SliceBindType>;
+        /** The toolbar affordances, in order. */
+        affordances?: SliceAffordanceLiteral[];
+    } | RecordSliceChromeOptions;
+    /** Status-footer items (`end: true` right-aligns). */
+    footer?: {
+        /** The footer text. */
+        text: SubtypeExprOrValue<StringType>;
+        /** Optional status tint. */
+        tone?: StatusValueLiteral | SubtypeExprOrValue<StatusValueType>;
+        /** Right-align the item. */
+        end?: boolean;
+    }[];
+    /** DnD target identity — names the Plan in drag-grammar cell refs, which is how a Library beside the Plan
+     *  reaches it: its cards land only on a Plan with an `id` whose `sources` lists it. The Plan's own library
+     *  panel needs neither — an author's tab's cards land without them (#1259). A card lands only on a row whose
+     *  series declares `edit.create` (where it lands and how it becomes an item). The canvas's own elements
+     *  move whether or not it has an `id` — where their series declares a move's fields (`edit.key` and
+     *  `start` / `end`, or `at`, #825). Each is a draft of the root's `editing` session. */
+    id?: string;
+    /** The ids of the Libraries beside the Plan whose cards it takes (`add`), reached by its `id` — its own
+     *  library panel's need none (omit = no Library beside it). */
+    sources?: string[];
+    /** IR-level drop veto — consulted with the candidate event (`add` for a card; `move` or `resize` for an
+     *  element moved, #825; a `CellRef.row` is the row id's canonical text) where the drag rests and again
+     *  before it becomes a draft; `false` ⇒ the ⊘ invalid stage; a throwing predicate fails open. */
+    canDrop?: SubtypeExprOrValue<FunctionType<[DragEventType], BooleanType>>;
+    /** Row click (selection) — the row's id. */
+    onSelect?: SubtypeExprOrValue<FunctionType<[PlanRowIdType], NullType>>;
+    /** A click on any element, by its ref (#824) — `run` (`{ row, run }`), `event` (`{ row, event }`),
+     *  `mark` (an event mark or a decision diamond, `{ row, mark }`), `chip` (`{ row, chip }`), `cell`
+     *  (`{ row, at }` — the bucket's instant, not an index) or a link ribbon's `link` (`{ key, from, to }`).
+     *  One function over one variant, as the `popover` / `hover` resolvers are: `ref.match({ … })`. */
+    onElementClick?: SubtypeExprOrValue<FunctionType<[PlanElementRefType], NullType>>;
+    /** A row with children expanded or collapsed (fires after the in-place swap). */
+    onGroupToggle?: SubtypeExprOrValue<FunctionType<[PlanGroupToggleEventType], NullType>>;
+    /** Grain segment change (grain is Plan-local state; initial via `grain`). */
+    onGrainChange?: SubtypeExprOrValue<FunctionType<[PlanGrainType], NullType>>;
+    /**
+     * The canvas's interaction state, held by the host (#824) — a
+     * `State.bind([Plan.Types.UiState], key, Plan.uiState())` handle.
+     *
+     * @remarks
+     * Bound, the canvas reads it and writes the user's actions back: the
+     * selection, the rows folded or opened against what they declare, the
+     * charts expanded. Write it from outside to select a row, fold or open one,
+     * expand a chart, or — through `focus` — bring a row into view (a deep
+     * link, a list beside the canvas); the canvas spends a `focus` request
+     * once it has. Unbound, the canvas keeps the state itself and persists the
+     * user's folds and charts under its storage key (#813).
+     *
+     * A write re-renders whatever reads the state, like any `State.bind`: read
+     * it in the `Reactive` that renders the canvas only for what depends on it.
+     */
+    ui?: SubtypeExprOrValue<PlanUiBindType>;
+    /** Sizing (#320), density, gutter width. */
+    style?: {
+        /** Definite height (`"fill"` fills the parent). */
+        height?: SubtypeExprOrValue<StringType>;
+        /** Max-height cap. */
+        maxHeight?: SubtypeExprOrValue<StringType>;
+        /** Row rhythm. */
+        density?: DensityLiteral | SubtypeExprOrValue<DensityType>;
+        /** Gutter width — a CSS px size (`"168px"`; default 168). */
+        gutterWidth?: SubtypeExprOrValue<StringType>;
+    };
+}
+/**
+ * Creates the canvas's root — the {@link PlanRootType} value `<Plan>`
+ * carries as its payload's `plan` — for the tests and the renderer's own
+ * fixtures, which read it whole.
+ *
+ * @typeParam K - The canvas's axis kind, inferred from `config.axis`; every series must lie within it
+ * @param config - The canvas's configuration ({@link PlanConfig})
+ * @returns An East expression of {@link PlanRootType}
+ * @throws {Error} When `data` is not a keyed source, `series` / `pick` are both or neither given, two series share a
+ *   key, a bound series list reads another key type than `data`, or the axis states no window and no slice is bound
+ *
+ * @remarks
+ * Window and resolution have no callbacks by design: they are slice writes
+ * (`setRange` / `setResolution`) — hosts observe the slice. A change to the
+ * data — a dropped card, a moved or resized element — is a draft of the
+ * `editing` session, saved as one checked batch (#880, #825).
+ */
+export declare function createPlanRoot<K extends PlanAxisKindLiteral = PlanAxisKindLiteral>(config: PlanConfig<K>): ExprType<PlanRootType>;
+/**
+ * The canvas's configuration with `data` optional (#1191): a Plan of event
+ * kinds, or of `rows` alone, has none.
+ *
+ * @internal
+ */
+export type PlanCanvasOptions = Omit<PlanConfig, "data"> & {
+    data?: PlanConfig["data"];
+};
+/**
+ * Builds the canvas's root (#1191): its rows over `data`, and then `extra`,
+ * fixed blocks every window serves alike — or, with no `data`, `extra`
+ * alone.
+ *
+ * @param config - The canvas's configuration, `data` optional
+ * @param extra - The fixed blocks after `data`'s: a Plan's `rows`
+ * @returns An East expression of {@link PlanRootType}
+ * @throws {Error} As {@link createPlanRoot} does; and with no `data`, a `series`, `pick` or `editing`, each of which reads it
+ * @internal
+ */
+export declare function buildPlanRoot(config: PlanCanvasOptions, extra: ExprType<PlanBlocksType> | undefined): ExprType<PlanRootType>;
+//# sourceMappingURL=root.d.ts.map

package/dist/src/plan/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../../src/plan/root.ts"],"names":[],"mappings":"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"}