@elaraai/east-ui 1.0.85 → 1.0.87

package/dist/src/runtime/collections/calendar.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"calendar.js","sourceRoot":"","sources":["../../../../src/runtime/collections/calendar.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,iDAAiD;AAEjD,OAAO,EAA0C,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EACH,QAAQ,IAAI,eAAe,GAG9B,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,SAAS,WAAW,CAChB,KAAkD;IAElD,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC;IAClC,OAAO,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,MAAuC,CAAC,CAAC;AAC/E,CAAC;AAED,MAAM,CAAC,MAAM,QAAQ,GAMjB,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE;IAC3B,KAAK,EAAE,eAAe,CAAC,KAAK;IAC5B,KAAK,EAAE,eAAe,CAAC,KAAK;IAC5B,MAAM,EAAE,eAAe,CAAC,MAAM;IAC9B,YAAY,EAAE,eAAe,CAAC,YAAY;IAC1C,MAAM,EAAE,eAAe,CAAC,MAAM;CACjC,CAAC,CAAC"}

package/dist/src/runtime/collections/flowchart.d.ts

@@ -1,58 +0,0 @@
-/**
- * Copyright (c) 2025 Elara AI Pty Ltd
- * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
- */
-/** `<Flowchart>` tag — see the export's JSDoc. */
-import { type ExprType, type SubtypeExprOrValue, ArrayType, StructType } from "@elaraai/east";
-import { Flowchart as FlowchartFactory, type FlowchartConfig, type FlowchartLaneLiteral, type RowElement } from "../../collections/flowchart/index.js";
-import { UIComponentType } from "../../component.js";
-/**
- * `<Flowchart>` — a self-contained state-transition flowchart: states as
- * nodes in ordered phase lanes, H/V-routed transition arrows, optional
- * per-link decision triggers (lettered diamonds) and evidence-weighted
- * strokes — all from flat data tables. Hover cards, the selection
- * inspector and the pointer-highlight grammar are built-in surfaces
- * derived from core + declared fields; view lenses are saved slice
- * cohorts, never props.
- *
- * @example
- * ```tsx
- * // .tsx file with the `@jsxImportSource @elaraai/east-ui` pragma
- * import { East } from "@elaraai/east";
- * import { Flowchart, UIComponentType } from "@elaraai/east-ui";
- *
- * const flow = East.function([], UIComponentType, _$ => (
- *     <Flowchart
- *         states={[
- *             { code: "RMI", name: "Raw intake", phase: "prep" },
- *             { code: "CUT", name: "Cut blanks", phase: "prep" },
- *             { code: "ASM", name: "Assembled", phase: "build" },
- *         ]}
- *         state={s => ({ key: s.code, label: s.name, lane: s.phase })}
- *         links={[{ src: "RMI", dst: "CUT" }, { src: "CUT", dst: "ASM" }]}
- *         link={l => ({ from: l.src, to: l.dst })}
- *         lanes={[{ key: "prep", label: "Prep" }, { key: "build", label: "Build" }]}
- *     />
- * ));
- * ```
- *
- * @remarks
- * Interaction is opt-in per channel: selection (`onSelectState`,
- * `onSelectLink`, `onSelectTrigger`), path tracing (`onTracePath`),
- * link authoring (`linkMode`, `onCreateLink`, `onDeleteLink`,
- * `canConnect`) and the bound slice (`slice`, `affordances`). With no
- * callbacks bound it is a read-only picture. Desugars to
- * `Flowchart.Root(states, config)`.
- */
-declare function FlowchartTag<S extends SubtypeExprOrValue<ArrayType<StructType>>, L extends SubtypeExprOrValue<ArrayType<StructType>>, N extends SubtypeExprOrValue<ArrayType<StructType>> = [], T extends SubtypeExprOrValue<ArrayType<StructType>> = []>(props: {
-    states: S;
-} & FlowchartConfig<RowElement<S>, RowElement<L>, RowElement<N>, RowElement<T>> & {
-    links: L;
-    lanes: N | readonly FlowchartLaneLiteral[];
-    triggers?: T;
-}): ExprType<UIComponentType>;
-export declare const Flowchart: typeof FlowchartTag & {
-    Types: typeof FlowchartFactory.Types;
-};
-export {};
-//# sourceMappingURL=flowchart.d.ts.map

package/dist/src/runtime/collections/flowchart.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flowchart.d.ts","sourceRoot":"","sources":["../../../../src/runtime/collections/flowchart.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,kDAAkD;AAElD,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,kBAAkB,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EACH,SAAS,IAAI,gBAAgB,EAC7B,KAAK,eAAe,EACpB,KAAK,oBAAoB,EACzB,KAAK,UAAU,EAClB,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,iBAAS,YAAY,CACjB,CAAC,SAAS,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,EACnD,CAAC,SAAS,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,EACnD,CAAC,SAAS,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,GAAG,EAAE,EACxD,CAAC,SAAS,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,GAAG,EAAE,EAExD,KAAK,EAAE;IAAE,MAAM,EAAE,CAAC,CAAA;CAAE,GAAG,eAAe,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,GAC5F;IAAE,KAAK,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,GAAG,SAAS,oBAAoB,EAAE,CAAC;IAAC,QAAQ,CAAC,EAAE,CAAC,CAAA;CAAE,GAC7E,QAAQ,CAAC,eAAe,CAAC,CAG3B;AAED,eAAO,MAAM,SAAS,EAAE,OAAO,YAAY,GAAG;IAC1C,KAAK,EAAE,OAAO,gBAAgB,CAAC,KAAK,CAAC;CAGvC,CAAC"}

package/dist/src/runtime/collections/flowchart.js

@@ -1,54 +0,0 @@
-/**
- * Copyright (c) 2025 Elara AI Pty Ltd
- * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
- */
-/** `<Flowchart>` tag — see the export's JSDoc. */
-import { ArrayType, StructType } from "@elaraai/east";
-import { Flowchart as FlowchartFactory, } from "../../collections/flowchart/index.js";
-import { UIComponentType } from "../../component.js";
-/**
- * `<Flowchart>` — a self-contained state-transition flowchart: states as
- * nodes in ordered phase lanes, H/V-routed transition arrows, optional
- * per-link decision triggers (lettered diamonds) and evidence-weighted
- * strokes — all from flat data tables. Hover cards, the selection
- * inspector and the pointer-highlight grammar are built-in surfaces
- * derived from core + declared fields; view lenses are saved slice
- * cohorts, never props.
- *
- * @example
- * ```tsx
- * // .tsx file with the `@jsxImportSource @elaraai/east-ui` pragma
- * import { East } from "@elaraai/east";
- * import { Flowchart, UIComponentType } from "@elaraai/east-ui";
- *
- * const flow = East.function([], UIComponentType, _$ => (
- *     <Flowchart
- *         states={[
- *             { code: "RMI", name: "Raw intake", phase: "prep" },
- *             { code: "CUT", name: "Cut blanks", phase: "prep" },
- *             { code: "ASM", name: "Assembled", phase: "build" },
- *         ]}
- *         state={s => ({ key: s.code, label: s.name, lane: s.phase })}
- *         links={[{ src: "RMI", dst: "CUT" }, { src: "CUT", dst: "ASM" }]}
- *         link={l => ({ from: l.src, to: l.dst })}
- *         lanes={[{ key: "prep", label: "Prep" }, { key: "build", label: "Build" }]}
- *     />
- * ));
- * ```
- *
- * @remarks
- * Interaction is opt-in per channel: selection (`onSelectState`,
- * `onSelectLink`, `onSelectTrigger`), path tracing (`onTracePath`),
- * link authoring (`linkMode`, `onCreateLink`, `onDeleteLink`,
- * `canConnect`) and the bound slice (`slice`, `affordances`). With no
- * callbacks bound it is a read-only picture. Desugars to
- * `Flowchart.Root(states, config)`.
- */
-function FlowchartTag(props) {
-    const { states, ...config } = props;
-    return FlowchartFactory.Root(states, config);
-}
-export const Flowchart = Object.assign(FlowchartTag, {
-    Types: FlowchartFactory.Types,
-});
-//# sourceMappingURL=flowchart.js.map

package/dist/src/runtime/collections/flowchart.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"flowchart.js","sourceRoot":"","sources":["../../../../src/runtime/collections/flowchart.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,kDAAkD;AAElD,OAAO,EAA0C,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EACH,SAAS,IAAI,gBAAgB,GAIhC,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,SAAS,YAAY,CAMjB,KAC4E;IAE5E,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC;IACpC,OAAO,gBAAgB,CAAC,IAAI,CAAC,MAAM,EAAE,MAAe,CAAC,CAAC;AAC1D,CAAC;AAED,MAAM,CAAC,MAAM,SAAS,GAElB,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE;IAC5B,KAAK,EAAE,gBAAgB,CAAC,KAAK;CAChC,CAAC,CAAC"}

package/dist/src/runtime/collections/plan.d.ts

@@ -1,181 +0,0 @@
-/**
- * Copyright (c) 2025 Elara AI Pty Ltd
- * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
- */
-/**
- * `<Plan>` tag — see the export's JSDoc.
- */
-import { type PlanConfig, type PlanAxisKindLiteral, type PlanNamespace } from "../../collections/plan/index.js";
-import type { UIElement } from "../runtime.js";
-/**
- * `<Plan>` — the axis-aligned composite canvas: one shared axis
- * (`{ time | number | ordinal }` — a window ÷ resolution or step, or an
- * ordinal list, = `n` buckets) over heterogeneous rows — span rows
- * (Gantt state-runs), bucket rows (Planner allocation lanes), chart rows
- * (Chart layers consumed as data), heat/table rows (Matrix cells / bucketed
- * numerals), cards rows (Roster chips), event marks and group strips —
- * sliced and reviewed as one surface.
- *
- * A canvas is its `data` — a keyed collection of raw entries, or a paged
- * source of one — and its `series`: one `Plan.series.*` value per row series,
- * whose accessors derive each canvas row from the raw fields (`Plan.pick`
- * makes the list one the user picks from). The list IS the layout — one block
- * per series, top to bottom — and hierarchy comes only from the data's own
- * nesting (#822): a series' `children` walk what an entry holds, to any depth
- * (`Plan.children` steps down to another entry type), and a flat source is
- * grouped in a data step first (`groupToDicts`). `Plan.series.section` titles
- * a block and `Plan.series.views` shows one entry several ways. Every row has
- * a typed id — its series and the path of entry keys to it (`Plan.ref`).
- *
- * Content comes from the value builders (`Plan.run` / `event` / `chip` /
- * `mark` / `marker` / `decision` / `port` / `segment` / the cell builders,
- * instants via `Plan.at.*`), the axis from `Plan.axis` (`time`) /
- * `Plan.axis.number` / `Plan.axis.ordinal` — its window stated, or supplied by
- * a bound slice — and rows no dataset holds from the kind factories
- * (`Plan.span` / `buckets` / `chart` / `heat` / `table` / `cards` / `events` /
- * `group`), placed by a `Plan.series.rows` entry. Props are
- * {@link PlanConfig}; maps to `Plan.Root`.
- *
- * @example
- * ```tsx
- * // .tsx file with the `@jsxImportSource @elaraai/east-ui` pragma
- * import { ArrayType, DateTimeType, DictType, East, FloatType, IntegerType, StringType, StructType, VariantType, variant } from "@elaraai/east";
- * import { EventStateType, Format, Plan, UIComponentType } from "@elaraai/east-ui";
- *
- * const canvas = East.function([], UIComponentType, ($) => {
- *     // Monday of ISO week n, 2026 — window W27–W38 (half-open), now W31.
- *     const week = $.const(East.function([IntegerType], DateTimeType, ($, n) => {
- *         const w1 = $.const(new Date("2025-12-29T00:00:00Z"), DateTimeType);
- *         return w1.addWeeks(n.subtract(1n));
- *     }));
- *     // The RAW domain shape — series discriminated by a variant field
- *     // (the natural ops-dataset form; the same rows page from a dataset).
- *     const JobRow = StructType({
- *         batch: StringType, start: DateTimeType, end: DateTimeType,
- *         tonnes: FloatType, state: EventStateType,
- *     });
- *     const ShiftRow = StructType({
- *         key: StringType, from: DateTimeType, to: DateTimeType,
- *         hours: FloatType, state: EventStateType,
- *     });
- *     const OpsRow = StructType({
- *         line: StringType,
- *         kind: VariantType({
- *             machine: StructType({ jobs: ArrayType(JobRow) }),
- *             crew:    StructType({ shifts: ArrayType(ShiftRow) }),
- *         }),
- *     });
- *     const ops = $.const(new Map([
- *         ["L1-M03", { line: "Line 1", kind: variant("machine", { jobs: [
- *             { batch: "B-214", start: week(28n), end: week(31n), tonnes: 96.0, state: variant("in-progress", null) },
- *             { batch: "B-221", start: week(32n), end: week(35n), tonnes: 88.0, state: variant("proposed", variant("recommended", null)) },
- *         ] }) }],
- *         ["L1-M04", { line: "Line 1", kind: variant("machine", { jobs: [
- *             { batch: "B-208", start: week(27n), end: week(30n), tonnes: 112.0, state: variant("actual", null) },
- *         ] }) }],
- *         ["L2-M11", { line: "Line 2", kind: variant("machine", { jobs: [
- *             { batch: "B-241", start: week(29n), end: week(33n), tonnes: 92.0, state: variant("confirmed", null) },
- *         ] }) }],
- *         ["crewA", { line: "Line 1", kind: variant("crew", { shifts: [
- *             { key: "s1", from: week(27n), to: week(29n), hours: 80.0, state: variant("confirmed", null) },
- *             { key: "s2", from: week(31n), to: week(33n), hours: 64.0, state: variant("proposed", variant("recommended", null)) },
- *         ] }) }],
- *     ]), DictType(StringType, OpsRow));
- *     // Hierarchy is the DATA's (#822): one `groupToDicts` groups the rows
- *     // into the canvas's blocks — each machine under its line, the crews
- *     // under one "Crews" block. An entry of the result holds its rows.
- *     const blocks = $.let(ops.groupToDicts(
- *         ($, r) => r.kind.hasTag("crew").ifElse(() => "Crews", () => r.line),
- *         ($, _r, k) => k));
- *     const Block = DictType(StringType, OpsRow);
- *     // The series — real East values bound in the body, typed by the
- *     // constructor. The list IS the layout: one block per series, top to
- *     // bottom. The accessors are where raw fields become canvas vocabulary:
- *     // labels, quantity displays and chip text all derive CLIENT-SIDE,
- *     // inside each series' `derive`.
- *     const series = $.const([
- *         // One row per line, its machines stepped down into
- *         // (`Plan.children`) and their runs rolled up into its bands —
- *         // which sum the runs' quantities, unit by unit.
- *         Plan.series.span(Block, {
- *             key: "lines", title: "Lines",
- *             match: (_b, name) => name.equal("Crews").not(),
- *             label: (_b, name) => name,
- *             runs: _b => [],
- *             rollup: "union",
- *             children: Plan.children((b) => b, [
- *                 Plan.series.span(OpsRow, {
- *                     key: "machines", title: "Machines",
- *                     match: r => r.kind.hasTag("machine"),
- *                     label: (_r, k) => k, id: true,
- *                     runs: r => r.kind.unwrap("machine").jobs.map((_$, j) => Plan.run({
- *                         key: j.batch, start: j.start, end: j.end,
- *                         label: East.str`RUN · ${j.batch}`,
- *                         // A quantity is one value: the bar prints `96 t`,
- *                         // and the line's band sums the tonnes.
- *                         quantity: Plan.quantity(j.tonnes, { unit: "t", format: Format.Number({ maximumFractionDigits: 0n }) }),
- *                         state: j.state,
- *                     })),
- *                 }),
- *             ]),
- *         }),
- *         // One strip per matching block — here the one "Crews" block,
- *         // wearing its member count.
- *         Plan.series.group(Block, {
- *             key: "crews", title: "Crews",
- *             match: (_b, name) => name.equal("Crews"),
- *             label: (_b, name) => name,
- *             children: Plan.children((b) => b, [
- *                 Plan.series.cards(OpsRow, {
- *                     key: "crew-shifts", title: "Crew shifts",
- *                     match: r => r.kind.hasTag("crew"),
- *                     label: (_r, k) => k,
- *                     chips: r => r.kind.unwrap("crew").shifts.map(($, s) => {
- *                         const hrs = $.let(East.Float.printFixed(s.hours, 0n), StringType);
- *                         // `+` marks ADDED hours — a removed proposal keeps the
- *                         // plain figure (see planCardRows for the full ladder).
- *                         const label = $.let(s.state.match({
- *                             proposed: (_$, p) => p.hasTag("removed").ifElse(
- *                                 () => East.str`${hrs}h`,
- *                                 () => East.str`+${hrs}h`),
- *                         }, _$ => East.str`${hrs}h`), StringType);
- *                         return Plan.chip({ key: s.key, from: s.from, to: s.to, label, state: s.state });
- *                     }),
- *                 }),
- *             ]),
- *         }),
- *         Plan.series.rows(Block, { key: "chrome", title: "Milestones", subtitle: "one-off chrome" },
- *             [Plan.events({ key: "ms", label: "MILESTONES", id: true, marks: [
- *                 Plan.mark({ key: "kick", at: week(28n), kind: "milestone", label: "KICKOFF" }),
- *                 Plan.mark({ key: "rel", at: week(33n), kind: "milestone", label: "REL 2.4" }),
- *             ] })]),
- *     ], ArrayType(Plan.Types.Series(Block)));
- *     const axis = $.const(Plan.axis({ window: { min: week(27n), max: week(39n) }, resolution: "week", now: week(31n) }));
- *     return (
- *         <Plan
- *             axis={axis}
- *             data={blocks}
- *             series={series}
- *         />
- *     );
- * });
- * ```
- *
- * @remarks
- * Carries the factory namespace except `Root` (the tag is the root):
- * `Plan.axis` (+ `.time` / `.number` / `.ordinal`), `Plan.at`,
- * `Plan.series.*`, `Plan.children`, `Plan.ref` / `Plan.sectionRef`,
- * `Plan.pick` / `Plan.pickItems`, the kind factories, the value and cell
- * builders, `Plan.quantity`, `Plan.link`, `Plan.layer` / `Plan.fixed` (chart
- * channels), `Plan.markKind`, `Plan.uiState` (a bound `ui` state's seed), and
- * `Plan.Types.*`. Replaces `Gantt`, `Planner` and
- * `AlignedStack`.
- *
- * The tag is generic in the canvas's axis kind `K`, inferred from `axis`:
- * a series whose instants ride another arm is a compile error at the tag
- * (see `PlanConfig`).
- */
-export declare const Plan: {
-    <K extends PlanAxisKindLiteral = PlanAxisKindLiteral>(props: PlanConfig<K>): UIElement;
-} & Omit<PlanNamespace, "Root">;
-//# sourceMappingURL=plan.d.ts.map

package/dist/src/runtime/collections/plan.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../../src/runtime/collections/plan.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH,OAAO,EAEH,KAAK,UAAU,EACf,KAAK,mBAAmB,EACxB,KAAK,aAAa,EACrB,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAY/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuKG;AACH,eAAO,MAAM,IAAI,EAAE;IACf,CAAC,CAAC,SAAS,mBAAmB,GAAG,mBAAmB,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;CAC1F,GAAG,IAAI,CAAC,aAAa,EAAE,MAAM,CAAqC,CAAC"}

package/dist/src/runtime/collections/plan.js

@@ -1,186 +0,0 @@
-/**
- * Copyright (c) 2025 Elara AI Pty Ltd
- * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
- */
-/**
- * `<Plan>` tag — see the export's JSDoc.
- */
-import { Plan as PlanFactory, } from "../../collections/plan/index.js";
-/** The tag's call — `Plan.Root`, generic in the axis kind `K` that `axis` fixes. */
-function PlanTag(props) {
-    return PlanFactory.Root(props);
-}
-// The tag IS the root, so `Root` is the one factory member it does not carry.
-// Derived, never hand-listed: a member added to `PlanNamespace` rides the tag
-// with no edit here (#814).
-const { Root: _root, ...authoring } = PlanFactory;
-/**
- * `<Plan>` — the axis-aligned composite canvas: one shared axis
- * (`{ time | number | ordinal }` — a window ÷ resolution or step, or an
- * ordinal list, = `n` buckets) over heterogeneous rows — span rows
- * (Gantt state-runs), bucket rows (Planner allocation lanes), chart rows
- * (Chart layers consumed as data), heat/table rows (Matrix cells / bucketed
- * numerals), cards rows (Roster chips), event marks and group strips —
- * sliced and reviewed as one surface.
- *
- * A canvas is its `data` — a keyed collection of raw entries, or a paged
- * source of one — and its `series`: one `Plan.series.*` value per row series,
- * whose accessors derive each canvas row from the raw fields (`Plan.pick`
- * makes the list one the user picks from). The list IS the layout — one block
- * per series, top to bottom — and hierarchy comes only from the data's own
- * nesting (#822): a series' `children` walk what an entry holds, to any depth
- * (`Plan.children` steps down to another entry type), and a flat source is
- * grouped in a data step first (`groupToDicts`). `Plan.series.section` titles
- * a block and `Plan.series.views` shows one entry several ways. Every row has
- * a typed id — its series and the path of entry keys to it (`Plan.ref`).
- *
- * Content comes from the value builders (`Plan.run` / `event` / `chip` /
- * `mark` / `marker` / `decision` / `port` / `segment` / the cell builders,
- * instants via `Plan.at.*`), the axis from `Plan.axis` (`time`) /
- * `Plan.axis.number` / `Plan.axis.ordinal` — its window stated, or supplied by
- * a bound slice — and rows no dataset holds from the kind factories
- * (`Plan.span` / `buckets` / `chart` / `heat` / `table` / `cards` / `events` /
- * `group`), placed by a `Plan.series.rows` entry. Props are
- * {@link PlanConfig}; maps to `Plan.Root`.
- *
- * @example
- * ```tsx
- * // .tsx file with the `@jsxImportSource @elaraai/east-ui` pragma
- * import { ArrayType, DateTimeType, DictType, East, FloatType, IntegerType, StringType, StructType, VariantType, variant } from "@elaraai/east";
- * import { EventStateType, Format, Plan, UIComponentType } from "@elaraai/east-ui";
- *
- * const canvas = East.function([], UIComponentType, ($) => {
- *     // Monday of ISO week n, 2026 — window W27–W38 (half-open), now W31.
- *     const week = $.const(East.function([IntegerType], DateTimeType, ($, n) => {
- *         const w1 = $.const(new Date("2025-12-29T00:00:00Z"), DateTimeType);
- *         return w1.addWeeks(n.subtract(1n));
- *     }));
- *     // The RAW domain shape — series discriminated by a variant field
- *     // (the natural ops-dataset form; the same rows page from a dataset).
- *     const JobRow = StructType({
- *         batch: StringType, start: DateTimeType, end: DateTimeType,
- *         tonnes: FloatType, state: EventStateType,
- *     });
- *     const ShiftRow = StructType({
- *         key: StringType, from: DateTimeType, to: DateTimeType,
- *         hours: FloatType, state: EventStateType,
- *     });
- *     const OpsRow = StructType({
- *         line: StringType,
- *         kind: VariantType({
- *             machine: StructType({ jobs: ArrayType(JobRow) }),
- *             crew:    StructType({ shifts: ArrayType(ShiftRow) }),
- *         }),
- *     });
- *     const ops = $.const(new Map([
- *         ["L1-M03", { line: "Line 1", kind: variant("machine", { jobs: [
- *             { batch: "B-214", start: week(28n), end: week(31n), tonnes: 96.0, state: variant("in-progress", null) },
- *             { batch: "B-221", start: week(32n), end: week(35n), tonnes: 88.0, state: variant("proposed", variant("recommended", null)) },
- *         ] }) }],
- *         ["L1-M04", { line: "Line 1", kind: variant("machine", { jobs: [
- *             { batch: "B-208", start: week(27n), end: week(30n), tonnes: 112.0, state: variant("actual", null) },
- *         ] }) }],
- *         ["L2-M11", { line: "Line 2", kind: variant("machine", { jobs: [
- *             { batch: "B-241", start: week(29n), end: week(33n), tonnes: 92.0, state: variant("confirmed", null) },
- *         ] }) }],
- *         ["crewA", { line: "Line 1", kind: variant("crew", { shifts: [
- *             { key: "s1", from: week(27n), to: week(29n), hours: 80.0, state: variant("confirmed", null) },
- *             { key: "s2", from: week(31n), to: week(33n), hours: 64.0, state: variant("proposed", variant("recommended", null)) },
- *         ] }) }],
- *     ]), DictType(StringType, OpsRow));
- *     // Hierarchy is the DATA's (#822): one `groupToDicts` groups the rows
- *     // into the canvas's blocks — each machine under its line, the crews
- *     // under one "Crews" block. An entry of the result holds its rows.
- *     const blocks = $.let(ops.groupToDicts(
- *         ($, r) => r.kind.hasTag("crew").ifElse(() => "Crews", () => r.line),
- *         ($, _r, k) => k));
- *     const Block = DictType(StringType, OpsRow);
- *     // The series — real East values bound in the body, typed by the
- *     // constructor. The list IS the layout: one block per series, top to
- *     // bottom. The accessors are where raw fields become canvas vocabulary:
- *     // labels, quantity displays and chip text all derive CLIENT-SIDE,
- *     // inside each series' `derive`.
- *     const series = $.const([
- *         // One row per line, its machines stepped down into
- *         // (`Plan.children`) and their runs rolled up into its bands —
- *         // which sum the runs' quantities, unit by unit.
- *         Plan.series.span(Block, {
- *             key: "lines", title: "Lines",
- *             match: (_b, name) => name.equal("Crews").not(),
- *             label: (_b, name) => name,
- *             runs: _b => [],
- *             rollup: "union",
- *             children: Plan.children((b) => b, [
- *                 Plan.series.span(OpsRow, {
- *                     key: "machines", title: "Machines",
- *                     match: r => r.kind.hasTag("machine"),
- *                     label: (_r, k) => k, id: true,
- *                     runs: r => r.kind.unwrap("machine").jobs.map((_$, j) => Plan.run({
- *                         key: j.batch, start: j.start, end: j.end,
- *                         label: East.str`RUN · ${j.batch}`,
- *                         // A quantity is one value: the bar prints `96 t`,
- *                         // and the line's band sums the tonnes.
- *                         quantity: Plan.quantity(j.tonnes, { unit: "t", format: Format.Number({ maximumFractionDigits: 0n }) }),
- *                         state: j.state,
- *                     })),
- *                 }),
- *             ]),
- *         }),
- *         // One strip per matching block — here the one "Crews" block,
- *         // wearing its member count.
- *         Plan.series.group(Block, {
- *             key: "crews", title: "Crews",
- *             match: (_b, name) => name.equal("Crews"),
- *             label: (_b, name) => name,
- *             children: Plan.children((b) => b, [
- *                 Plan.series.cards(OpsRow, {
- *                     key: "crew-shifts", title: "Crew shifts",
- *                     match: r => r.kind.hasTag("crew"),
- *                     label: (_r, k) => k,
- *                     chips: r => r.kind.unwrap("crew").shifts.map(($, s) => {
- *                         const hrs = $.let(East.Float.printFixed(s.hours, 0n), StringType);
- *                         // `+` marks ADDED hours — a removed proposal keeps the
- *                         // plain figure (see planCardRows for the full ladder).
- *                         const label = $.let(s.state.match({
- *                             proposed: (_$, p) => p.hasTag("removed").ifElse(
- *                                 () => East.str`${hrs}h`,
- *                                 () => East.str`+${hrs}h`),
- *                         }, _$ => East.str`${hrs}h`), StringType);
- *                         return Plan.chip({ key: s.key, from: s.from, to: s.to, label, state: s.state });
- *                     }),
- *                 }),
- *             ]),
- *         }),
- *         Plan.series.rows(Block, { key: "chrome", title: "Milestones", subtitle: "one-off chrome" },
- *             [Plan.events({ key: "ms", label: "MILESTONES", id: true, marks: [
- *                 Plan.mark({ key: "kick", at: week(28n), kind: "milestone", label: "KICKOFF" }),
- *                 Plan.mark({ key: "rel", at: week(33n), kind: "milestone", label: "REL 2.4" }),
- *             ] })]),
- *     ], ArrayType(Plan.Types.Series(Block)));
- *     const axis = $.const(Plan.axis({ window: { min: week(27n), max: week(39n) }, resolution: "week", now: week(31n) }));
- *     return (
- *         <Plan
- *             axis={axis}
- *             data={blocks}
- *             series={series}
- *         />
- *     );
- * });
- * ```
- *
- * @remarks
- * Carries the factory namespace except `Root` (the tag is the root):
- * `Plan.axis` (+ `.time` / `.number` / `.ordinal`), `Plan.at`,
- * `Plan.series.*`, `Plan.children`, `Plan.ref` / `Plan.sectionRef`,
- * `Plan.pick` / `Plan.pickItems`, the kind factories, the value and cell
- * builders, `Plan.quantity`, `Plan.link`, `Plan.layer` / `Plan.fixed` (chart
- * channels), `Plan.markKind`, `Plan.uiState` (a bound `ui` state's seed), and
- * `Plan.Types.*`. Replaces `Gantt`, `Planner` and
- * `AlignedStack`.
- *
- * The tag is generic in the canvas's axis kind `K`, inferred from `axis`:
- * a series whose instants ride another arm is a compile error at the tag
- * (see `PlanConfig`).
- */
-export const Plan = Object.assign(PlanTag, authoring);
-//# sourceMappingURL=plan.js.map

package/dist/src/runtime/collections/plan.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../../../src/runtime/collections/plan.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH,OAAO,EACH,IAAI,IAAI,WAAW,GAItB,MAAM,iCAAiC,CAAC;AAGzC,oFAAoF;AACpF,SAAS,OAAO,CAAsD,KAAoB;IACtF,OAAO,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACnC,CAAC;AAED,8EAA8E;AAC9E,8EAA8E;AAC9E,4BAA4B;AAC5B,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,SAAS,EAAE,GAAG,WAAW,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuKG;AACH,MAAM,CAAC,MAAM,IAAI,GAEiB,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC"}

package/dist/src/runtime/collections/roster.d.ts

@@ -1,60 +0,0 @@
-/**
- * Copyright (c) 2025 Elara AI Pty Ltd
- * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
- */
-/** `<Roster>` tag — see the export's JSDoc. */
-import { type ExprType, type SubtypeExprOrValue, ArrayType, StructType } from "@elaraai/east";
-import { Roster as RosterFactory, type RosterConfig, type RowElement } from "../../collections/roster/index.js";
-import { UIComponentType } from "../../component.js";
-/**
- * `<Roster>` — people × days-of-week shift scheduling. Takes the two flat
- * tables a dataset naturally provides — `people` and `shifts` — each with a
- * chart-style field encoding (`person`, `shift`); the factory joins them by
- * person key. The component owns the week (`days` defaults to Mon–Sun).
- *
- * Declares the drag & drop **target** role: `sources` lists the Library ids
- * it accepts `add` drags from, and every completed drag (add / move /
- * remove) funnels through `onDrag` as one typed event. Published mode
- * renders committed shifts only, pointer-immutable; edit mode enables
- * grips, empty-cell add (`onAddAt`), and ghost acceptance (`onAccept`).
- *
- * @example
- * ```tsx
- * // .tsx file with the `@jsxImportSource @elaraai/east-ui` pragma
- * import { East, variant } from "@elaraai/east";
- * import { Roster, UIComponentType } from "@elaraai/east-ui";
- *
- * const roster = East.function([], UIComponentType, _$ => (
- *     <Roster
- *         id="roster-se"
- *         sources={["people"]}
- *         mode="edit"
- *         people={[
- *             { id: "patel", name: "Patel", target: "38h → 30h" },
- *         ]}
- *         person={p => ({ key: p.id, label: p.name, sublabel: p.target })}
- *         shifts={[
- *             { id: "p1", person: "patel", day: "Mon", hours: 8n, state: variant("committed", null) },
- *             { id: "p2", person: "patel", day: "Wed", hours: 4n, state: variant("proposed", variant("model", null)) },
- *         ]}
- *         shift={s => ({ key: s.id, person: s.person, day: s.day,
- *                        hours: s.hours, state: s.state })}
- *     />
- * ));
- * ```
- *
- * @remarks
- * Shift states are typed `PlannerStateType` values in the data
- * (`variant("committed", null)`, `variant("proposed", variant("model",
- * null))`, …) — `Roster.Types.State` names the grammar. Desugars to
- * `Roster.Root(people, shifts, config)`.
- */
-declare function RosterTag<P extends SubtypeExprOrValue<ArrayType<StructType>>, S extends SubtypeExprOrValue<ArrayType<StructType>>>(props: {
-    people: P;
-    shifts: S;
-} & RosterConfig<RowElement<P>, RowElement<S>>): ExprType<UIComponentType>;
-export declare const Roster: typeof RosterTag & {
-    Types: typeof RosterFactory.Types;
-};
-export {};
-//# sourceMappingURL=roster.d.ts.map

package/dist/src/runtime/collections/roster.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"roster.d.ts","sourceRoot":"","sources":["../../../../src/runtime/collections/roster.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,+CAA+C;AAE/C,OAAO,EAAE,KAAK,QAAQ,EAAE,KAAK,kBAAkB,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EACH,MAAM,IAAI,aAAa,EACvB,KAAK,YAAY,EACjB,KAAK,UAAU,EAClB,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,iBAAS,SAAS,CACd,CAAC,SAAS,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,EACnD,CAAC,SAAS,kBAAkB,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,EAEnD,KAAK,EAAE;IAAE,MAAM,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,GAAG,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC,GAC7E,QAAQ,CAAC,eAAe,CAAC,CAG3B;AAED,eAAO,MAAM,MAAM,EAAE,OAAO,SAAS,GAAG;IACpC,KAAK,EAAE,OAAO,aAAa,CAAC,KAAK,CAAC;CAGpC,CAAC"}

package/dist/src/runtime/collections/roster.js

@@ -1,59 +0,0 @@
-/**
- * Copyright (c) 2025 Elara AI Pty Ltd
- * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
- */
-/** `<Roster>` tag — see the export's JSDoc. */
-import { ArrayType, StructType } from "@elaraai/east";
-import { Roster as RosterFactory, } from "../../collections/roster/index.js";
-import { UIComponentType } from "../../component.js";
-/**
- * `<Roster>` — people × days-of-week shift scheduling. Takes the two flat
- * tables a dataset naturally provides — `people` and `shifts` — each with a
- * chart-style field encoding (`person`, `shift`); the factory joins them by
- * person key. The component owns the week (`days` defaults to Mon–Sun).
- *
- * Declares the drag & drop **target** role: `sources` lists the Library ids
- * it accepts `add` drags from, and every completed drag (add / move /
- * remove) funnels through `onDrag` as one typed event. Published mode
- * renders committed shifts only, pointer-immutable; edit mode enables
- * grips, empty-cell add (`onAddAt`), and ghost acceptance (`onAccept`).
- *
- * @example
- * ```tsx
- * // .tsx file with the `@jsxImportSource @elaraai/east-ui` pragma
- * import { East, variant } from "@elaraai/east";
- * import { Roster, UIComponentType } from "@elaraai/east-ui";
- *
- * const roster = East.function([], UIComponentType, _$ => (
- *     <Roster
- *         id="roster-se"
- *         sources={["people"]}
- *         mode="edit"
- *         people={[
- *             { id: "patel", name: "Patel", target: "38h → 30h" },
- *         ]}
- *         person={p => ({ key: p.id, label: p.name, sublabel: p.target })}
- *         shifts={[
- *             { id: "p1", person: "patel", day: "Mon", hours: 8n, state: variant("committed", null) },
- *             { id: "p2", person: "patel", day: "Wed", hours: 4n, state: variant("proposed", variant("model", null)) },
- *         ]}
- *         shift={s => ({ key: s.id, person: s.person, day: s.day,
- *                        hours: s.hours, state: s.state })}
- *     />
- * ));
- * ```
- *
- * @remarks
- * Shift states are typed `PlannerStateType` values in the data
- * (`variant("committed", null)`, `variant("proposed", variant("model",
- * null))`, …) — `Roster.Types.State` names the grammar. Desugars to
- * `Roster.Root(people, shifts, config)`.
- */
-function RosterTag(props) {
-    const { people, shifts, ...config } = props;
-    return RosterFactory.Root(people, shifts, config);
-}
-export const Roster = Object.assign(RosterTag, {
-    Types: RosterFactory.Types,
-});
-//# sourceMappingURL=roster.js.map

package/dist/src/runtime/collections/roster.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"roster.js","sourceRoot":"","sources":["../../../../src/runtime/collections/roster.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,+CAA+C;AAE/C,OAAO,EAA0C,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC9F,OAAO,EACH,MAAM,IAAI,aAAa,GAG1B,MAAM,mCAAmC,CAAC;AAC3C,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,SAAS,SAAS,CAId,KAA4E;IAE5E,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,KAAK,CAAC;IAC5C,OAAO,aAAa,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAoD,CAAC,CAAC;AACpG,CAAC;AAED,MAAM,CAAC,MAAM,MAAM,GAEf,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE;IACzB,KAAK,EAAE,aAAa,CAAC,KAAK;CAC7B,CAAC,CAAC"}