@elaraai/east-ui 1.0.80 → 1.0.82

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

@@ -5,7 +5,7 @@
 /**
  * `<Plan>` tag — see the export's JSDoc.
  */
-import { Plan as PlanFactory, type PlanConfig, type PlanAxisKindLiteral } from "../../collections/plan/index.js";
+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
@@ -16,45 +16,160 @@ import type { UIElement } from "../runtime.js";
  * numerals), cards rows (Roster chips), event marks and group strips —
  * sliced and reviewed as one surface.
  *
- * Rows are built with the kind factories (`Plan.span` / `buckets` / `chart` /
- * `heat` / `table` / `cards` / `events` / `group`, the data-driven
- * `Plan.rows`, and the accessor `.of` forms); content with the value builders
- * (`Plan.run` / `event` / `chip` / `mark` / `marker` / `decision` / `port` /
- * `segment` / cell builders, instants via `Plan.at.*`); the axis with
- * `Plan.axis` (`time`) / `Plan.axis.number` / `Plan.axis.ordinal`. Maps to
- * `Plan.Root`.
+ * 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 { East } from "@elaraai/east";
- * import { Plan, UIComponentType } from "@elaraai/east-ui";
+ * 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, _$ => (
- *     <Plan
- *         axis={Plan.axis({
- *             window: { min: new Date("2026-06-29"), max: new Date("2026-09-21") },
- *             resolution: "week", now: new Date("2026-07-27"),
- *         })}
- *         rows={[
- *             Plan.span({
- *                 key: "m03", label: "L1-M03", id: true, sub: "120 t",
- *                 runs: [
- *                     Plan.run({ key: "set", start: new Date("2026-06-29"), end: new Date("2026-07-06"), label: "SET", state: "actual" }),
- *                     Plan.run({ key: "run", start: new Date("2026-07-06"), end: new Date("2026-07-27"), label: "RUN · B-214", quantity: "96 t", state: "in-progress" }),
- *                     Plan.run({ key: "next", start: new Date("2026-08-03"), end: new Date("2026-08-24"), label: "RUN · B-221", quantity: "88 t", state: "recommended" }),
- *                 ],
- *             }),
- *         ]}
- *     />
- * ));
+ * 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 whole authoring namespace — `Plan.axis` (+ `.time` / `.number` /
- * `.ordinal`), `Plan.at`, the kind factories, the value builders,
- * `Plan.layer` / `Plan.fixed` (chart channels), `Plan.markKind`, and
- * `Plan.Types.*`. Replaces `Gantt`, `Planner` and `AlignedStack`.
+ * 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
@@ -62,37 +177,5 @@ import type { UIElement } from "../runtime.js";
  */
 export declare const Plan: {
     <K extends PlanAxisKindLiteral = PlanAxisKindLiteral>(props: PlanConfig<K>): UIElement;
-    axis: typeof PlanFactory.axis;
-    at: typeof PlanFactory.at;
-    span: typeof PlanFactory.span;
-    buckets: typeof PlanFactory.buckets;
-    chart: typeof PlanFactory.chart;
-    heat: typeof PlanFactory.heat;
-    table: typeof PlanFactory.table;
-    cards: typeof PlanFactory.cards;
-    events: typeof PlanFactory.events;
-    group: typeof PlanFactory.group;
-    series: typeof PlanFactory.series;
-    run: typeof PlanFactory.run;
-    decision: typeof PlanFactory.decision;
-    port: typeof PlanFactory.port;
-    event: typeof PlanFactory.event;
-    lane: typeof PlanFactory.lane;
-    marker: typeof PlanFactory.marker;
-    chip: typeof PlanFactory.chip;
-    mark: typeof PlanFactory.mark;
-    link: typeof PlanFactory.link;
-    markKind: typeof PlanFactory.markKind;
-    heatCells: typeof PlanFactory.heatCells;
-    weightCells: typeof PlanFactory.weightCells;
-    segmentCells: typeof PlanFactory.segmentCells;
-    segment: typeof PlanFactory.segment;
-    tableCells: typeof PlanFactory.tableCells;
-    tableSeries: typeof PlanFactory.tableSeries;
-    layer: typeof PlanFactory.layer;
-    fixed: typeof PlanFactory.fixed;
-    pick: typeof PlanFactory.pick;
-    pickItems: typeof PlanFactory.pickItems;
-    Types: typeof PlanFactory.Types;
-};
+} & Omit<PlanNamespace, "Root">;
 //# sourceMappingURL=plan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../../src/runtime/collections/plan.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH,OAAO,EACH,IAAI,IAAI,WAAW,EACnB,KAAK,UAAU,EACf,KAAK,mBAAmB,EAC3B,MAAM,iCAAiC,CAAC;AACzC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,eAAO,MAAM,IAAI,EAAE;IACf,CAAC,CAAC,SAAS,mBAAmB,GAAG,mBAAmB,EAAE,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;IACvF,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAC;IAC9B,EAAE,EAAE,OAAO,WAAW,CAAC,EAAE,CAAC;IAC1B,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAC;IAC9B,OAAO,EAAE,OAAO,WAAW,CAAC,OAAO,CAAC;IACpC,KAAK,EAAE,OAAO,WAAW,CAAC,KAAK,CAAC;IAChC,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAC;IAC9B,KAAK,EAAE,OAAO,WAAW,CAAC,KAAK,CAAC;IAChC,KAAK,EAAE,OAAO,WAAW,CAAC,KAAK,CAAC;IAChC,MAAM,EAAE,OAAO,WAAW,CAAC,MAAM,CAAC;IAClC,KAAK,EAAE,OAAO,WAAW,CAAC,KAAK,CAAC;IAChC,MAAM,EAAE,OAAO,WAAW,CAAC,MAAM,CAAC;IAClC,GAAG,EAAE,OAAO,WAAW,CAAC,GAAG,CAAC;IAC5B,QAAQ,EAAE,OAAO,WAAW,CAAC,QAAQ,CAAC;IACtC,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAC;IAC9B,KAAK,EAAE,OAAO,WAAW,CAAC,KAAK,CAAC;IAChC,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAC;IAC9B,MAAM,EAAE,OAAO,WAAW,CAAC,MAAM,CAAC;IAClC,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAC;IAC9B,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAC;IAC9B,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAC;IAC9B,QAAQ,EAAE,OAAO,WAAW,CAAC,QAAQ,CAAC;IACtC,SAAS,EAAE,OAAO,WAAW,CAAC,SAAS,CAAC;IACxC,WAAW,EAAE,OAAO,WAAW,CAAC,WAAW,CAAC;IAC5C,YAAY,EAAE,OAAO,WAAW,CAAC,YAAY,CAAC;IAC9C,OAAO,EAAE,OAAO,WAAW,CAAC,OAAO,CAAC;IACpC,UAAU,EAAE,OAAO,WAAW,CAAC,UAAU,CAAC;IAC1C,WAAW,EAAE,OAAO,WAAW,CAAC,WAAW,CAAC;IAC5C,KAAK,EAAE,OAAO,WAAW,CAAC,KAAK,CAAC;IAChC,KAAK,EAAE,OAAO,WAAW,CAAC,KAAK,CAAC;IAChC,IAAI,EAAE,OAAO,WAAW,CAAC,IAAI,CAAC;IAC9B,SAAS,EAAE,OAAO,WAAW,CAAC,SAAS,CAAC;IACxC,KAAK,EAAE,OAAO,WAAW,CAAC,KAAK,CAAC;CAuCnC,CAAC"}
+{"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

@@ -6,6 +6,14 @@
  * `<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
@@ -15,84 +23,164 @@ import { Plan as PlanFactory, } from "../../collections/plan/index.js";
  * numerals), cards rows (Roster chips), event marks and group strips —
  * sliced and reviewed as one surface.
  *
- * Rows are built with the kind factories (`Plan.span` / `buckets` / `chart` /
- * `heat` / `table` / `cards` / `events` / `group`, the data-driven
- * `Plan.rows`, and the accessor `.of` forms); content with the value builders
- * (`Plan.run` / `event` / `chip` / `mark` / `marker` / `decision` / `port` /
- * `segment` / cell builders, instants via `Plan.at.*`); the axis with
- * `Plan.axis` (`time`) / `Plan.axis.number` / `Plan.axis.ordinal`. Maps to
- * `Plan.Root`.
+ * 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 { East } from "@elaraai/east";
- * import { Plan, UIComponentType } from "@elaraai/east-ui";
+ * 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, _$ => (
- *     <Plan
- *         axis={Plan.axis({
- *             window: { min: new Date("2026-06-29"), max: new Date("2026-09-21") },
- *             resolution: "week", now: new Date("2026-07-27"),
- *         })}
- *         rows={[
- *             Plan.span({
- *                 key: "m03", label: "L1-M03", id: true, sub: "120 t",
- *                 runs: [
- *                     Plan.run({ key: "set", start: new Date("2026-06-29"), end: new Date("2026-07-06"), label: "SET", state: "actual" }),
- *                     Plan.run({ key: "run", start: new Date("2026-07-06"), end: new Date("2026-07-27"), label: "RUN · B-214", quantity: "96 t", state: "in-progress" }),
- *                     Plan.run({ key: "next", start: new Date("2026-08-03"), end: new Date("2026-08-24"), label: "RUN · B-221", quantity: "88 t", state: "recommended" }),
- *                 ],
- *             }),
- *         ]}
- *     />
- * ));
+ * 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 whole authoring namespace — `Plan.axis` (+ `.time` / `.number` /
- * `.ordinal`), `Plan.at`, the kind factories, the value builders,
- * `Plan.layer` / `Plan.fixed` (chart channels), `Plan.markKind`, and
- * `Plan.Types.*`. Replaces `Gantt`, `Planner` and `AlignedStack`.
+ * 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(function Plan(props) {
-    return PlanFactory.Root(props);
-}, {
-    axis: PlanFactory.axis,
-    at: PlanFactory.at,
-    span: PlanFactory.span,
-    buckets: PlanFactory.buckets,
-    chart: PlanFactory.chart,
-    heat: PlanFactory.heat,
-    table: PlanFactory.table,
-    cards: PlanFactory.cards,
-    events: PlanFactory.events,
-    group: PlanFactory.group,
-    series: PlanFactory.series,
-    run: PlanFactory.run,
-    decision: PlanFactory.decision,
-    port: PlanFactory.port,
-    event: PlanFactory.event,
-    lane: PlanFactory.lane,
-    marker: PlanFactory.marker,
-    chip: PlanFactory.chip,
-    mark: PlanFactory.mark,
-    link: PlanFactory.link,
-    markKind: PlanFactory.markKind,
-    heatCells: PlanFactory.heatCells,
-    weightCells: PlanFactory.weightCells,
-    segmentCells: PlanFactory.segmentCells,
-    segment: PlanFactory.segment,
-    tableCells: PlanFactory.tableCells,
-    tableSeries: PlanFactory.tableSeries,
-    layer: PlanFactory.layer,
-    fixed: PlanFactory.fixed,
-    pick: PlanFactory.pick,
-    pickItems: PlanFactory.pickItems,
-    Types: PlanFactory.Types,
-});
+export const Plan = Object.assign(PlanTag, authoring);
 //# sourceMappingURL=plan.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"plan.js","sourceRoot":"","sources":["../../../../src/runtime/collections/plan.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AAEH,OAAO,EACH,IAAI,IAAI,WAAW,GAGtB,MAAM,iCAAiC,CAAC;AAGzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoDG;AACH,MAAM,CAAC,MAAM,IAAI,GAkCb,MAAM,CAAC,MAAM,CACb,SAAS,IAAI,CAAsD,KAAoB;IACnF,OAAO,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACnC,CAAC,EACD;IACI,IAAI,EAAE,WAAW,CAAC,IAAI;IACtB,EAAE,EAAE,WAAW,CAAC,EAAE;IAClB,IAAI,EAAE,WAAW,CAAC,IAAI;IACtB,OAAO,EAAE,WAAW,CAAC,OAAO;IAC5B,KAAK,EAAE,WAAW,CAAC,KAAK;IACxB,IAAI,EAAE,WAAW,CAAC,IAAI;IACtB,KAAK,EAAE,WAAW,CAAC,KAAK;IACxB,KAAK,EAAE,WAAW,CAAC,KAAK;IACxB,MAAM,EAAE,WAAW,CAAC,MAAM;IAC1B,KAAK,EAAE,WAAW,CAAC,KAAK;IACxB,MAAM,EAAE,WAAW,CAAC,MAAM;IAC1B,GAAG,EAAE,WAAW,CAAC,GAAG;IACpB,QAAQ,EAAE,WAAW,CAAC,QAAQ;IAC9B,IAAI,EAAE,WAAW,CAAC,IAAI;IACtB,KAAK,EAAE,WAAW,CAAC,KAAK;IACxB,IAAI,EAAE,WAAW,CAAC,IAAI;IACtB,MAAM,EAAE,WAAW,CAAC,MAAM;IAC1B,IAAI,EAAE,WAAW,CAAC,IAAI;IACtB,IAAI,EAAE,WAAW,CAAC,IAAI;IACtB,IAAI,EAAE,WAAW,CAAC,IAAI;IACtB,QAAQ,EAAE,WAAW,CAAC,QAAQ;IAC9B,SAAS,EAAE,WAAW,CAAC,SAAS;IAChC,WAAW,EAAE,WAAW,CAAC,WAAW;IACpC,YAAY,EAAE,WAAW,CAAC,YAAY;IACtC,OAAO,EAAE,WAAW,CAAC,OAAO;IAC5B,UAAU,EAAE,WAAW,CAAC,UAAU;IAClC,WAAW,EAAE,WAAW,CAAC,WAAW;IACpC,KAAK,EAAE,WAAW,CAAC,KAAK;IACxB,KAAK,EAAE,WAAW,CAAC,KAAK;IACxB,IAAI,EAAE,WAAW,CAAC,IAAI;IACtB,SAAS,EAAE,WAAW,CAAC,SAAS;IAChC,KAAK,EAAE,WAAW,CAAC,KAAK;CAC3B,CACJ,CAAC"}
+{"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/sheet.d.ts

@@ -7,9 +7,38 @@
  */
 import type { SubtypeExprOrValue, ArrayType, DictType, StringType, StructType } from "@elaraai/east";
 import type { PagedSource } from "../../contracts/source.js";
-import { Sheet as SheetFactory, type SheetColumnSpec, type SheetOptions, type SheetBindHandle } from "../../collections/sheet/index.js";
+import { type SheetColumnSpec, type SheetOptions, type SheetGroupedOptions, type SheetEntriesOptions, type SheetEntryOf, type SheetBindHandle, type SheetLinesField, type SheetLineOf, type SheetNamespace } from "../../collections/sheet/index.js";
 import type { DataRowType } from "../../collections/table/index.js";
 import type { UIElement } from "../runtime.js";
+/**
+ * `<Sheet data={entries} id="id" group={Sheet.group(P, "lines", …)} columns={{ … }} />`
+ * — GROUPED rows with LOOSE rows between the groups (#846): `data` holds
+ * `Sheet.Types.Entry(P, "lines")` entries, each a group or a row of the
+ * line type; `columns` are declared over the line type.
+ */
+declare function SheetTag<P extends StructType, F extends SheetLinesField<P>>(props: {
+    data: NoInfer<SubtypeExprOrValue<ArrayType<SheetEntryOf<P, F>>> | SheetBindHandle<SheetEntryOf<P, F>> | PagedSource<ArrayType<SheetEntryOf<P, F>>> | PagedSource<DictType<StringType, SheetEntryOf<P, F>>>>;
+    columns: SheetColumnSpec<SheetLineOf<P, F>>;
+} & SheetEntriesOptions<P, F>): UIElement;
+/**
+ * `<Sheet data={plans} id="id" group={Sheet.group(P, "lines", …)} columns={{ … }} />`
+ * — GROUPED rows (#740): the rows are groups, `columns` are declared over
+ * the line type the group's lines field holds.
+ */
+declare function SheetTag<T extends SubtypeExprOrValue<ArrayType<StructType>>, F extends SheetLinesField<DataRowType<T>>>(props: {
+    data: T;
+    columns: SheetColumnSpec<SheetLineOf<DataRowType<T>, F>>;
+} & SheetGroupedOptions<DataRowType<T>, F>): UIElement;
+/** GROUPED rows over a whole-value bind handle of groups. */
+declare function SheetTag<P extends StructType, F extends SheetLinesField<P>>(props: {
+    data: SheetBindHandle<P>;
+    columns: SheetColumnSpec<SheetLineOf<P, F>>;
+} & SheetGroupedOptions<P, F>): UIElement;
+/** GROUPED rows over a paged source of groups. */
+declare function SheetTag<P extends StructType, F extends SheetLinesField<P>>(props: {
+    data: PagedSource<ArrayType<P>> | PagedSource<DictType<StringType, P>>;
+    columns: SheetColumnSpec<SheetLineOf<P, F>>;
+} & SheetGroupedOptions<P, F>): UIElement;
 /**
  * `<Sheet data={rows} id="id" columns={{ … }} />` — the planning spreadsheet.
  * Maps to `Sheet.Root`. `columns` is typed as `SheetColumnSpec<R>` (a mapped
@@ -45,24 +74,30 @@ declare function SheetTag<R extends StructType>(props: {
  * @example
  * ```tsx
  * // .tsx file with the `@jsxImportSource @elaraai/east-ui` pragma
- * import { East, ArrayType, DateTimeType, FloatType, OptionType, StringType, StructType, none } from "@elaraai/east";
+ * import { ArrayType, DateTimeType, East, FloatType, OptionType, StringType, StructType, none } from "@elaraai/east";
  * import { Reactive, Sheet, State, UIComponentType } from "@elaraai/east-ui";
  *
- * const JobType = StructType({ id: StringType, start: OptionType(DateTimeType), task: StringType, qty: OptionType(FloatType) });
- *
- * const jobs = East.function([], UIComponentType, (_$) => (
+ * const sheet = East.function([], UIComponentType, (_$) => (
  *     <Reactive>{$ => {
- *         const rows = $.let(State.bind([ArrayType(JobType)], "jobs", [{ id: "j1", start: none, task: "Machining", qty: none }]));
+ *         const JobType = StructType({
+ *             id:    StringType,
+ *             start: OptionType(DateTimeType),   // none = blank cell
+ *             task:  StringType,                 // "" = blank cell
+ *             qty:   OptionType(FloatType),
+ *         });
+ *         const jobs = $.let(State.bind([ArrayType(JobType)], "sheet_basic_jobs", [
+ *             { id: "j1", start: none, task: "Machining", qty: none },
+ *         ]));
  *         return (
  *             <Sheet
- *                 data={rows.read()}
+ *                 data={jobs}
  *                 id="id"
  *                 columns={{
- *                     start: Sheet.column.date(JobType, { header: "Start", sub: "d/m · fri · +3d" }),
+ *                     start: Sheet.column.date(JobType, { header: "Start", sub: "dd / mm / yyyy" }),
  *                     task:  Sheet.column.text(JobType, { header: "Task" }),
- *                     qty:   Sheet.column.quantity(JobType, { header: "Qty" }),
+ *                     qty:   Sheet.column.quantity(JobType, { header: "Qty" }),   // no driver on this sheet — the two-argument form
  *                 }}
- *                 onUpdate={rows.write}
+ *                 onUpdate={jobs.write}
  *             />
  *         );
  *     }}</Reactive>
@@ -70,20 +105,18 @@ declare function SheetTag<R extends StructType>(props: {
  * ```
  *
  * @remarks
- * Carries the whole authoring namespace — `Sheet.column.*` (the builders),
- * `Sheet.register.members` / `.concat`, `Sheet.driver`, `Sheet.link.arity` /
- * `.check` / `.parse` / `.print`, `Sheet.patch`, and `Sheet.Types.*` (the
- * closed wire types plus the typed constructors `Context(R, D)` / `Fill(T)` /
- * `Patch(R)` / `Proposal(R)` / `Edit(R)` / `CheckContext(R)`). Desugars to
+ * Carries the factory namespace except `Root` (the tag is the root):
+ * `Sheet.column.*` (the builders), `Sheet.register.members` / `.concat`,
+ * `Sheet.driver`, `Sheet.link.arity` / `.check` / `.parse` / `.print`,
+ * `Sheet.patch`, `Sheet.apply` (a checked batch applied to a collection),
+ * `Sheet.group` / `Sheet.group.cell.*` (grouped rows, #740 — with loose rows
+ * between the groups over `Sheet.Types.Entry` entries, #846), `Sheet.subRows`
+ * / `Sheet.subRow` (sub rows, #844), and `Sheet.Types.*` (the closed wire
+ * types plus the typed constructors, among them `DraftContext(R, D)` /
+ * `Fill(T)` / `Patch(R)` / `Proposal(R)` / `CheckContext(R)` / `Draft(R)` /
+ * `PatchEvent(E)` / `ChangeSet(E)` / `Entry(G, "rows")`). Desugars to
  * `Sheet.Root(data, columns, options)`.
  */
-export declare const Sheet: typeof SheetTag & {
-    column: typeof SheetFactory.column;
-    register: typeof SheetFactory.register;
-    driver: typeof SheetFactory.driver;
-    link: typeof SheetFactory.link;
-    patch: typeof SheetFactory.patch;
-    Types: typeof SheetFactory.Types;
-};
+export declare const Sheet: typeof SheetTag & Omit<SheetNamespace, "Root">;
 export {};
 //# sourceMappingURL=sheet.d.ts.map