@elaraai/east-ui 1.0.80 → 1.0.82

package/dist/test/collections/plan.examples.d.ts

@@ -12,7 +12,8 @@ export declare const planTargetState: import("@elaraai/east").ExampleDef<[], any
  * resolution, and the 14-day sprint at day resolution with `ddd DD` labels
  * (the #309 pinned-day-columns contract the Planner's `day` preset and the
  * AlignedStack date-axis panel guarded). The style sweeps ride `style` —
- * density rhythm and gutter width — and every callback (select / run click /
+ * density rhythm and gutter width — over a canvas holding every row kind, so
+ * one click re-rhythms them all; every callback (select / element click /
  * group toggle / grain change) logs to the aside, the retired configurators'
  * pattern. Fill sizing stays `planFill`'s; the per-kind visual grammars stay
  * the static per-kind panels.
@@ -23,10 +24,24 @@ export declare const planBucketRows: import("@elaraai/east").ExampleDef<[], any>
 export declare const planChartRows: import("@elaraai/east").ExampleDef<[], any>;
 export declare const planHeatRows: import("@elaraai/east").ExampleDef<[], any>;
 export declare const planTableRows: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * Temporal fold (#824). The data is weekly; the canvas shows it at whatever
+ * resolution the axis states, and at MONTH every row shows ONE value per
+ * month — the fold of its weeks there — where it used to stack four or five
+ * on top of each other. Each cell builder and chart layer declares its fold,
+ * defaulting to what its values mean: a heat level and a line fold by `mean`,
+ * a table numeral and a column by `sum`, a weight fraction by `mean`. A row
+ * overrides it where the meaning differs — peak load by `max`, closing stock
+ * by `last`. The switch is the resolution; nothing in the data changes, and a
+ * row whose weeks were never folded (WEEK) shows them as they are.
+ */
+export declare const planFold: import("@elaraai/east").ExampleDef<[], any>;
 export declare const planCardRows: import("@elaraai/east").ExampleDef<[], any>;
 export declare const planEventRows: import("@elaraai/east").ExampleDef<[], any>;
 export declare const planGroupedRows: import("@elaraai/east").ExampleDef<[], any>;
 export declare const planSeriesData: import("@elaraai/east").ExampleDef<[], any>;
+export declare const planLiteralRows: import("@elaraai/east").ExampleDef<[], any>;
+export declare const planPick: import("@elaraai/east").ExampleDef<[], any>;
 export declare const planLibraryDnd: import("@elaraai/east").ExampleDef<[], any>;
 /**
  * A Plan is a drag target, and a heterogeneous one — which is what makes it
@@ -34,50 +49,110 @@ export declare const planLibraryDnd: import("@elaraai/east").ExampleDef<[], any>
  *
  * Roster, Board and Blend have ONE kind of cell, so "can you drop here" is a
  * question about the cell's contents. A Plan's rows are nine different things,
- * so the question is answered TWICE, at two different levels:
+ * so the question is answered at three levels:
  *
- *  1. **Structurally, by kind.** Only rows holding discrete scheduled objects
- *     register a drop cell at all — `span` (runs), `buckets` (tiles), `events`
+ *  1. **Structurally, by series.** A card lands only on a row whose series
+ *     declares `edit` — WHERE it lands (`items`, the entry's list the row's
+ *     elements come from) and HOW it becomes one (`create`, from the drop: the
+ *     card, the row and the bucket's instant). Only the kinds holding discrete
+ *     scheduled objects can — `span` (runs), `buckets` (tiles), `events`
  *     (marks), `cards` (chips). A `chart` / `heat` / `table` row renders
- *     DERIVED values, so there is nothing for a card to become; it registers
- *     no cell, never lights up during a drag, and is not reachable by any
- *     predicate. Group strips are wayfinding, so they are inert too — their
- *     MEMBERS receive.
+ *     DERIVED values, and section headers and group strips are wayfinding:
+ *     they register no cell and never light up during a drag.
  *  2. **By policy, with `canDrop`.** Of the rows that can receive, this canvas
  *     admits only the matching FAMILY: a job goes on a machine, a delivery on
  *     a dock, a shift on a crew, a milestone on a stream. The `PALLET` card
  *     belongs to no family and is therefore refused everywhere — the ⊘ stage
  *     on every row, which is what a card with nowhere to go should look like.
+ *  3. **As a draft (#880).** A drop is a gesture of the editing session: the
+ *     entry is drafted with the new item in its list and its rows derived
+ *     again — drawn at once with the pending mark, undone with ⌘Z — and Apply
+ *     writes every draft as ONE checked batch, here through the live handle's
+ *     inline adapter (`editing.onUpdate`).
  *
- * The drop is not cosmetic. `onDrag` writes to bound state, the series
- * accessors read that state back, and the row re-derives — the documented flow
- * for every target ("no drop writes state directly"). Nothing is painted
- * optimistically, so what appears on the canvas is only ever what the data
- * says.
+ * The canvas is bounded shorter than its rows, so the Line 3 machine starts
+ * below the fold: a card held at the canvas's bottom edge scrolls it there
+ * (#608). A card is also a keyboard control — Space picks it up, the arrows
+ * carry it from row to row and along a row's buckets, Space drops it and
+ * Escape cancels — and every step is said to a screen reader.
  */
 export declare const planRowDrop: import("@elaraai/east").ExampleDef<[], any>;
 /** Fill (#320) — `height="fill"` resolves against the bounded Box and
- *  virtualizes 200 span rows under 8 rollup parents. The bound must land on the
- *  canvas WRAPPER: a percentage passed inward resolves against an auto-height
- *  parent, computes to `auto`, and silently unbinds — the frame reports bounded,
- *  renders its spacer, and never scrolls (#567 D1).
+ *  virtualizes 200 rows of mixed kinds under 8 line strips. The bound must land
+ *  on the canvas WRAPPER: a percentage passed inward resolves against an
+ *  auto-height parent, computes to `auto`, and silently unbinds — the frame
+ *  reports bounded, renders its spacer, and never scrolls (#567 D1).
  *
  *  The grouping is here for what it does to VIRTUALIZATION, not for the
  *  chrome. Collapsing a strip removes its 25 children from the virtualizer's
  *  item list, so `count` and the total size change while the scroll offset does
  *  not — the case where an estimate that disagrees with the rendered height
- *  shows up as drift or a jumping scrollbar. The parents also give the list two
- *  different row heights (a rollup band is taller than a leaf), so the
- *  `estimateSize` path is exercised rather than a single constant. */
+ *  shows up as drift or a jumping scrollbar. The strips also give the list
+ *  another row height again, so the `estimateSize` path is exercised rather
+ *  than a single constant. */
 export declare const planFill: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * Review as drafts (#880): a verdict is a FIELD of the record the reviewer
+ * decides about — `approval`, an `ApprovalStateType` — and the series whose
+ * rows are reviewed names it (`review: { verdict: "approval" }`). Approve or
+ * Reject on a row, and Approve all / Reject all at the foot, draft the entries
+ * with the field changed: the canvas derives the drafted rows again at once —
+ * buttons, bar, dot and run — marked pending, the history bar undoes, redoes
+ * and discards them, and Apply writes them back through the live handle as one
+ * checked batch. The foot's summary is the HOST's, over what it holds: the
+ * saved state, which moves only when Apply lands.
+ */
 export declare const planReview: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * The Plan's editing session (#880) — the Sheet's, over the canvas's entries.
+ *
+ * The source holds LINES, each holding its machines. A machine is reviewed
+ * (its `approval` field), receives dropped jobs (its `jobs` list) and has its
+ * jobs moved and resized, and every gesture lands on the MACHINE rows, one
+ * level down — yet each drafts the LINE, the source's top-level entry, which
+ * the whole subtree rides in:
+ *
+ *  - Approve / Reject on a machine, and Approve all / Reject all at the foot,
+ *    draft its `approval` (`review: { verdict: "approval" }` on the machines).
+ *  - A job card dropped on a machine drafts a new job in its `jobs` at the
+ *    bucket's instant (`edit: { items: "jobs", create }`).
+ *  - A job's run moves along its machine or onto another machine, and resizes
+ *    by either end (#825): the series names the job's key and the instant
+ *    fields a move writes (`key`, `start`, `end`). It moves in whole weeks, or
+ *    in days with Shift held. A move onto a machine of the other line takes
+ *    the job out of one line and puts it into the other, as one gesture over
+ *    both. From the keyboard, Space on a focused run picks it up: ←/→ move it
+ *    a week, Shift+←/→ its end, Alt+←/→ its start, ↑/↓ carry it to another
+ *    machine, and Space drops it.
+ *
+ * Every gesture is one transaction, drawn at once with the pending mark; the
+ * toolbar's history bar undoes, redoes and discards it (so do ⌘Z and ⌘⇧Z).
+ * `ready` is the author's check over a drafted line: a machine holding more
+ * than four jobs is refused, by name, and Apply waits until it is fixed — M11
+ * already holds four, so a job moved onto it holds Apply until one leaves.
+ * Apply writes the batch back through the live handle (`onUpdate`), and
+ * `onPatch` hears each gesture as it is made.
+ */
+export declare const planEditing: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * A bound `ui` state (#824): the canvas's selection, the rows folded or opened
+ * against what they declare, the expanded charts, and a row to bring into
+ * view — held by the HOST, in `State.bind` at `Plan.Types.UiState`, seeded by
+ * `Plan.uiState(…)`. The canvas reads it and writes the user's actions back;
+ * anything else may write it too. Here a picker beside the canvas brings a
+ * machine into view (`focus` — the canvas opens the line it sits in, scrolls
+ * to it and spends the request) and selects it, three buttons fold, open and
+ * expand from outside, and a readout says what the state holds — including
+ * whatever the user clicked on the canvas itself.
+ */
+export declare const planUiState: import("@elaraai/east").ExampleDef<[], any>;
 /**
  * R2 expand-in-place — the one example that shows the whole gesture.
  *
  * Expand is two halves and needs BOTH: a per-row `expand` declaration (data,
  * so it flows through an accessor like every other envelope field) and the
- * ROOT's `expandRender` resolver, which builds the mounted body from the row
- * ref. Neither alone shows the control.
+ * ROOT's `expandRender` resolver, which builds the mounted body from the row's
+ * id. Neither alone shows the control.
  *
  * The rows here are deliberately heterogeneous — span, chart, heat, table,
  * events — because focusing one is what makes the other five collapse, and
@@ -104,10 +179,10 @@ export declare const planNarrow: import("@elaraai/east").ExampleDef<[], any>;
  * through the element builders (`Plan.run({ start: j.start })`), a chart
  * layer's numeric x accessor lands its columns on the same arm, `Plan.tableCells`
  * reads a numeric `at`, and the heat cells stored as RECORDS spell it out with
- * `Plan.at.number`. The slice's range field is a float, so the horizon brush
- * and the range chip ride the slice's `float` arm exactly as they ride
- * `datetime` on a time axis; there is no resolution segment — `step` is the
- * declaration.
+ * `Plan.at.number`. The slice's range field is an integer day, so the horizon
+ * brush and the range chip ride the slice's `integer` arm exactly as they ride
+ * `datetime` on a time axis — a closed range, so the eight days `[1, 9)` read
+ * `1–8`; there is no resolution segment — `step` is the declaration.
  */
 export declare const planNumberAxis: import("@elaraai/east").ExampleDef<[], any>;
 /**

package/dist/test/collections/plan.examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan.examples.d.ts","sourceRoot":"","sources":["../../../test/collections/plan.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wCAAwC;AA4CxC,eAAO,MAAM,eAAe,6CA2V1B,CAAC;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,6CA4LvB,CAAC;AAMH,eAAO,MAAM,YAAY,6CAuKvB,CAAC;AAEH,eAAO,MAAM,cAAc,6CAiHzB,CAAC;AAEH,eAAO,MAAM,aAAa,6CAkHxB,CAAC;AAEH,eAAO,MAAM,YAAY,6CAwFvB,CAAC;AAEH,eAAO,MAAM,aAAa,6CAwLxB,CAAC;AAEH,eAAO,MAAM,YAAY,6CAqFvB,CAAC;AAEH,eAAO,MAAM,aAAa,6CAkExB,CAAC;AAEH,eAAO,MAAM,eAAe,6CA4F1B,CAAC;AAMH,eAAO,MAAM,cAAc,6CA6FzB,CAAC;AAMH,eAAO,MAAM,cAAc,6CA0TzB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,WAAW,6CAwStB,CAAC;AAMH;;;;;;;;;;;;sEAYsE;AACtE,eAAO,MAAM,QAAQ,6CAoInB,CAAC;AAMH,eAAO,MAAM,UAAU,6CA+GrB,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,6CAsMrB,CAAC;AAOH;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,6CA8JrB,CAAC;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,6CAkLzB,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,6CAgJ1B,CAAC"}
+{"version":3,"file":"plan.examples.d.ts","sourceRoot":"","sources":["../../../test/collections/plan.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wCAAwC;AAiDxC,eAAO,MAAM,eAAe,6CA0W1B,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,YAAY,6CAqRvB,CAAC;AAMH,eAAO,MAAM,YAAY,6CAgMvB,CAAC;AAEH,eAAO,MAAM,cAAc,6CAiHzB,CAAC;AAEH,eAAO,MAAM,aAAa,6CAkHxB,CAAC;AAEH,eAAO,MAAM,YAAY,6CAqGvB,CAAC;AAEH,eAAO,MAAM,aAAa,6CAoNxB,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,QAAQ,6CA8HnB,CAAC;AAEH,eAAO,MAAM,YAAY,6CAqFvB,CAAC;AAEH,eAAO,MAAM,aAAa,6CAkExB,CAAC;AAEH,eAAO,MAAM,eAAe,6CAmF1B,CAAC;AAMH,eAAO,MAAM,cAAc,6CAyHzB,CAAC;AAMH,eAAO,MAAM,eAAe,6CAuD1B,CAAC;AAMH,eAAO,MAAM,QAAQ,6CAmEnB,CAAC;AAMH,eAAO,MAAM,cAAc,6CAoTzB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,WAAW,6CAsStB,CAAC;AAMH;;;;;;;;;;;;8BAY8B;AAC9B,eAAO,MAAM,QAAQ,6CA4InB,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,UAAU,6CA6FrB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,WAAW,6CAoJtB,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,6CAmHtB,CAAC;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,6CAwMrB,CAAC;AAOH;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,6CAkKrB,CAAC;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,cAAc,6CAiLzB,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,6CA6I1B,CAAC"}