@contraagent/ui 0.0.0-stage → 0.2.0

package/dist/elements/overview/ca-pipeline-graph.d.ts

@@ -0,0 +1,211 @@
+import type { JournalRow, Plan } from '@contraagent/api';
+import '@contraagent/elements/graph/define';
+import { LitElement, type PropertyValueMap, type PropertyValues } from 'lit';
+import type { MatrixSort } from '../../adapters/graph/matrix.js';
+/** The changes `willUpdate` reads: the properties, and the private `down`, `sort`, `rev` and `budget`. */
+type Changed = PropertyValues<CaPipelineGraph> & PropertyValueMap<{
+    down: boolean;
+    sort: MatrixSort;
+    rev: number;
+    budget: number;
+}>;
+/** The most nodes the drawing holds before it stops opening functions on its own, for a frame `w` px wide. */
+export declare const budgetFor: (w: number) => number;
+/** The most layers the drawing spans before it closes again what it opened on its own, for a frame `w` px wide: about one screen. */
+export declare const spanFor: (w: number) => number;
+export declare const tooWide: (span: number, w: number) => boolean;
+/**
+ * The run as a graph of its flow, one layer at a time (`<cae-layered-graph>` draws
+ * it). A layer shows the kinds of the tasks its function created (a kind node each,
+ * joined to the ones it waits for) and the functions it called (a function node each,
+ * holding their tasks); nodes created in one loop are drawn in a loop box, with its
+ * last pass ("up to 3 passes") and, when its units ran different numbers of passes,
+ * how many ran each ("1 pass: 4 | 2 passes: 1"); a nested loop's box is inside it, and
+ * a dotted edge inside each box, from its last layer back to its first, is the return
+ * to its next pass. A kind node names who runs its tasks (✦ and an accent: an agent
+ * task; ⚙: a Python task); a function node and a loop box carry the mark of an inner
+ * view (their layer, their passes). Inside a node, one mark per unit, at the same place
+ * in every node, so a unit can be followed across the layer: a task in a kind node, a
+ * flow call in a function node; in a loop box, the unit's latest pass, with the number
+ * of passes it ran when more than 1. A mark of several tasks shows the most severe
+ * state among them (failed, running, not started, waiting, skipped, done); a flow
+ * call's mark counts every task of it and of the flow calls it started, and its own
+ * error (raised or closed) as failed. A node's count is its tasks done of its tasks,
+ * with the others by state, and a function node names its flow calls that stopped
+ * with an error. A problem has a square mark (failed: red; not started: hatched),
+ * every other state a round one. Above 200 marks, a node shows a bar of its counts and
+ * names its failed marks. A solid edge waits for an output; a dashed edge was created
+ * after a result; an edge from outside the layer starts at a named stub.
+ *
+ * A click selects a mark, a node or a loop box (`sel`); the card beside it shows its
+ * facts and links to where it leads: a mark to its task detail, a kind node to its
+ * tasks, a function node to its layer, a loop box to its passes. A double click, or
+ * Enter, follows the first of them. Hovering or focusing a mark highlights its unit
+ * and the tasks joined to it, as the selected mark does. The graph opens on the first
+ * layer with more than one node (a static flow's kinds), or on a single function node
+ * whose flow call raised; a layer the run does not have opens that one, with a line
+ * naming it, and the view route is set right in place (a function named by its qualified
+ * name alone opens its layer when the run reaches it by one flow path). A loop's
+ * passes are a row per unit and a column per node and pass, a nested loop's passes as
+ * a group of columns inside each pass of the outer one, the units sortable by number
+ * of passes or by status (`<cae-mark-matrix>`). The breadcrumb, shown on every layer
+ * below the top (a loop named by its file and line), and Escape go back up. On a
+ * narrow screen the graph runs top to bottom. "Graph | Table" changes the view; in a
+ * loop's passes, "Graph" opens the layer the loop is in, with its box selected.
+ * A height set on the element (or given it by a flex or grid container) is the
+ * graph's, less the outline's line above it: the drawing fits in it.
+ *
+ * @fires ca-open-task - `{key, view?}`: a mark's task detail was opened (a task that did not start opens on its input, a Python task on its output)
+ * @fires ca-navigate - `{sel}`: a mark, a node, a table row or a loop box was selected, or the selection cleared; `{tab: 'tasks', kind}`: a kind node's tasks (`kind` '' for a node of several kinds); `{layer, unit?}`: a function's layer, a loop's passes, a flow call's function or the breadcrumb, or Escape; `{layer, unit, sel}`: "Graph" in a loop's passes, its box selected; `{layer, unit, sel, replace: true}`: the view route's layer set right
+ */
+export declare class CaPipelineGraph extends LitElement {
+    static styles: (import("lit").CSSResult | import("lit").CSSResult[])[];
+    static properties: {
+        plan: {
+            attribute: boolean;
+        };
+        journal: {
+            attribute: boolean;
+        };
+        run: {};
+        live: {
+            type: BooleanConstructor;
+        };
+        layer: {};
+        unit: {};
+        sel: {};
+        down: {
+            state: boolean;
+        };
+        sort: {
+            state: boolean;
+        };
+        missing: {
+            state: boolean;
+        };
+        rev: {
+            state: boolean;
+        };
+        budget: {
+            state: boolean;
+        };
+        wide: {
+            state: boolean;
+        };
+    };
+    plan: Plan;
+    /** The finished attempts: they tell why a task did not start. */
+    journal: JournalRow[];
+    /** The run id: paths in a cause are shown relative to it. */
+    run: string;
+    /** The run is running: tasks still pending are waiting; once it is over, they did not run. */
+    live: boolean;
+    /** The layer shown: its segments (function names, then `loop:<line>` for a loop's passes) joined by `/`; '' for the layer the graph opens on. */
+    layer: string;
+    /** The unit highlighted while nothing is hovered or focused. */
+    unit: string;
+    /** What is selected in the layer: a node or a loop box by its id, a mark by `markSel`; '' for nothing. */
+    sel: string;
+    /** Top to bottom: the frame is narrow. */
+    private down;
+    /** Top to bottom: the drawing is too long to read left to right in the frame. */
+    private tall;
+    /** A loop's passes: how its units are sorted. */
+    private sort;
+    /** The layer the view route named that this run does not have (shown once the graph fell back to its opening layer). */
+    private missing;
+    /** The view route's layer to set right after this update, and that change, which is not the reader's. */
+    private fixLayer;
+    private replacing;
+    /** The layer the graph opens on, the one shown, and what it shows. */
+    private auto;
+    private segments;
+    /** The layer alone, for a loop's passes; null when the layer is drawn with its functions. */
+    private proj;
+    /** The layer as it is drawn: alone, or with its functions drawn open. */
+    private model;
+    private graph;
+    private input;
+    /** The order the layer was last drawn in, before this update: the graph keeps it. */
+    private prevOrder;
+    private matrix;
+    private matrixIn;
+    /** Each layer's order, so nodes stay where they are while the plan grows. */
+    private orders;
+    private links;
+    private states;
+    /** The locale the words were last made in. */
+    private locale;
+    /** The functions the reader opened and closed (and the mode: all or none opened), kept per run in the page's memory. */
+    private opened;
+    private closed;
+    private memRun;
+    /** A change to them: the layer is drawn again. */
+    private rev;
+    /** The most nodes the drawing holds before it stops opening functions on its own (`budgetFor` the frame). */
+    private budget;
+    /** The places drawn open, and what each place holds. */
+    private shownOpen;
+    private stats;
+    /** After this update, the focus goes on this item's open or close control. */
+    private focusToggle;
+    /** The outline: the flow's places from its top, as a tree; the items the reader folded or unfolded. */
+    private flowStats;
+    private tree;
+    private folds;
+    /** The frame is wide enough for the outline as a column. */
+    private wide;
+    private readonly oh;
+    /** What a hovered or selected mark lights, for this layer. */
+    private lights;
+    /** After this update, the focus goes into the new layer: on the item it came from (`cameFrom`), else the first. */
+    private refocus;
+    private cameFrom;
+    private resize?;
+    private readonly h;
+    protected willUpdate(changed: Changed): void;
+    /** The generic graph's model of the layer (`words`: its words changed), its arrangement, and a loop's passes. */
+    private build;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    /** The reader's opens and closes of this run's functions. */
+    private memory;
+    /** Which functions are drawn open: those chosen (`auto`), every one, or only those the reader opened. */
+    private openMode;
+    private setMode;
+    /** A function node's place, by its id in the drawing. */
+    private placeOfNode;
+    /** Open or close a function: `id` is its node (to open) or its cluster (to close). */
+    private toggle;
+    /** The id a place's node will have once drawn closed. */
+    private nodeIdOf;
+    private readonly onToggle;
+    protected updated(): void;
+    private readonly onEscape;
+    private readonly onSelect;
+    private readonly onActivate;
+    private readonly onDrill;
+    private readonly onView;
+    render(): import("lit").TemplateResult<1>;
+    private renderGraph;
+    /** The graph's own width: the element's, less the outline's column beside it. */
+    private graphWidth;
+    /** The place keys on the way to the layer shown (the functions of its path). */
+    private currentKeys;
+    /** The place (or loop item) the selection is, or is in: '' for none. */
+    private selectedItem;
+    /** The id an outline item is drawn with, once its places are open; and those places. */
+    private drawnId;
+    /** The place whose layer a loop item is in ('' when it is the layer shown, null when none is known). */
+    private containerKey;
+    private outlineHost;
+    /** This element as its parts see it (`pipeline-graph/host.ts`), its private members included. */
+    private partsHost;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'ca-pipeline-graph': CaPipelineGraph;
+    }
+}
+export {};
+//# sourceMappingURL=ca-pipeline-graph.d.ts.map

package/dist/elements/overview/ca-pipeline-graph.d.ts.map

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