@infotrust/ui 0.0.0-stage → 0.30.0

package/dist/components/content/ItDocsLayout.vue.d.ts

@@ -0,0 +1,29 @@
+type __VLS_Props = {
+    /** The page title (an h1). Omit it to render your own header in the default slot. */
+    title?: string;
+    headingLevel?: 1 | 2;
+};
+type __VLS_Slots = {
+    /** ItSectionNav with the docs pages. Folds behind its toggle when the layout is one column. */
+    nav?: () => unknown;
+    /** ItSectionNav mode="toc" for the open page. Below 1100px it folds behind its toggle above the article. */
+    outline?: () => unknown;
+    breadcrumb?: () => unknown;
+    /** One line under the title: type, freshness, reading time. */
+    meta?: () => unknown;
+    /** Page actions, such as "Copy for LLM". */
+    actions?: () => unknown;
+    /** The article (ItDocsArticle), then ItDocsPager. */
+    default?: () => unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    title: string;
+    headingLevel: 1 | 2;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/content/ItDocsPager.vue.d.ts

@@ -0,0 +1,12 @@
+import type { ItDocsPagerLink } from './docs';
+type __VLS_Props = {
+    previous?: ItDocsPagerLink | null;
+    next?: ItDocsPagerLink | null;
+    label?: string;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    label: string;
+    next: ItDocsPagerLink | null;
+    previous: ItDocsPagerLink | null;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/content/ItProse.vue.d.ts

@@ -0,0 +1,18 @@
+type __VLS_Props = {
+    /** Keep the document's semantics. This frame never changes heading levels. */
+    as?: 'div' | 'article' | 'section';
+};
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    as: "div" | "article" | "section";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/content/docs.d.ts

@@ -0,0 +1,23 @@
+import type { ItRouteLocation } from '../../utils/router';
+/** One heading and the content under it, up to the next heading. The app renders and sanitizes the HTML. */
+export interface ItDocsSection {
+    /** Null for the introduction above the first heading. */
+    heading: {
+        id: string;
+        level: 2 | 3 | 4;
+        /** Plain text: the outline, the action labels, and the copy all use it. */
+        text: string;
+        /** Sanitized inline HTML for the heading; `text` is shown when absent. */
+        html?: string;
+        /** A numbered step ("3"): drawn as a badge, and the section's content lines up with the heading text. */
+        step?: string | null;
+    } | null;
+    /** Sanitized HTML for the section body. Fenced code (`<pre><code class="language-…">`) renders as ItCodeBlock. */
+    html: string;
+}
+/** A neighbouring page for ItDocsPager. */
+export interface ItDocsPagerLink {
+    label: string;
+    to?: ItRouteLocation;
+    href?: string;
+}

package/dist/components/dag/ItDagCanvas.vue.d.ts

@@ -0,0 +1,143 @@
+import { type ItDagConnectionRule, type ItDagDirection, type ItDagEdgeItem, type ItDagEdgeShape, type ItDagLibraryItem, type ItDagNodeItem, type ItDagNoun, type ItDagPoint, type ItDagPort, type ItDagRemoveGuard } from './dag';
+import { type ItDagHistoryController } from './history';
+type __VLS_Props = {
+    nodes: ItDagNodeItem[];
+    edges: ItDagEdgeItem[];
+    /** Names the canvas region: "Remediation plan". */
+    label: string;
+    editable?: boolean;
+    /** `right`: inputs on the left, columns by depth. `down`: inputs on top, rows by depth. */
+    direction?: ItDagDirection;
+    edgeShape?: ItDagEdgeShape;
+    /** Allow connections that close a loop. Off: it is a DAG. */
+    allowCycles?: boolean;
+    /** An app rule on top of the built-in ones: return a reason to refuse, or null. */
+    connectionRule?: ItDagConnectionRule;
+    /** The selected step's id (v-model:selected). */
+    selected?: string | null;
+    /** Editable: the steps "Add step" offers. Omit it and the canvas has no Add step. */
+    library?: ItDagLibraryItem[];
+    /** Height on the page: px, or any CSS length ("calc(100vh - 240px)"). Full view fills the window. */
+    height?: number | string;
+    /** The step editor's width: `md` for a few fields, `lg` when the #editor slot shows more (a step's signature, its requests). */
+    editorSize?: 'md' | 'lg';
+    /** Default: "No steps yet" (with `noun`, "No labels yet"). */
+    emptyTitle?: string;
+    emptyDescription?: string;
+    /** What the nodes are called in the canvas's own words, lowercase: `{ one: 'label', other: 'labels' }`. */
+    noun?: ItDagNoun;
+    /** Asked before anything is removed, with what would go; false (or a promise of false) keeps it. */
+    beforeRemove?: ItDagRemoveGuard;
+    /** `modal`: a click on a step opens the built-in editor. `none`: it selects the step and emits `open`; the app opens its own editor. */
+    editor?: 'modal' | 'none';
+    /** Editable: undo and redo, in the controls and on ⌘/Ctrl+Z. */
+    history?: boolean | ItDagHistoryController;
+    /** The lowest zoom "Fit to view" goes to (0.75: a readable 75%). Zoom out can still go to 25%, or to this when it is lower. */
+    fitMinZoom?: number;
+    /** @deprecated Use fitMinZoom. Retained for one minor release. */
+    minZoom?: number;
+    /**
+     * What a scroll over the canvas does. `page` (default): it scrolls the
+     * page, for a canvas on a page that scrolls. `pan`: a trackpad swipe or
+     * the mouse wheel pans the canvas (Shift + wheel pans sideways), for a
+     * canvas that owns its page (a studio); full view always pans. A pinch and
+     * Ctrl/⌘ + wheel zoom either way.
+     */
+    wheel?: 'page' | 'pan';
+};
+type __VLS_Slots = {
+    /** Replaces a step's card. Render an ItDagNode with your own body, or your own card. */
+    node?: (scope: {
+        node: ItDagNodeItem;
+        selected: boolean;
+    }) => unknown;
+    /** The step editor's fields, under the name. Edit `draft` (its `data` is a copy); Save writes it back. */
+    editor?: (scope: {
+        node: ItDagNodeItem;
+        draft: ItDagNodeItem;
+    }) => unknown;
+    /** The connection modal's body, under From and To: what flows along the connection (its data shape, a sample). */
+    connection?: (scope: {
+        edge: ItDagEdgeItem;
+        source: ItDagNodeItem;
+        target: ItDagNodeItem;
+        sourcePort?: ItDagPort;
+        targetPort?: ItDagPort;
+    }) => unknown;
+    /** Top right of the canvas: controls for the whole graph (Settings, Run). They stay in reach in full view. */
+    actions?: () => unknown;
+    /** Replaces the empty state. */
+    empty?: () => unknown;
+};
+/**
+ * Fits the graph in view, but never below a readable zoom: a graph too big at
+ * that zoom shows its start (the first column, the top row) and the rest pans.
+ * Never above 100%, so a small graph keeps its true size.
+ */
+declare function fit(): Promise<void>;
+/** A click on a step, or Enter on it: the built-in editor, or with `editor="none"` the app's (`open`). */
+declare function openNode(id: string): void;
+declare function clearHistory(): void;
+declare function undo(): Promise<void>;
+declare function redo(): Promise<void>;
+/**
+ * Pans to a step when it is out of sight (a run follows its current step with
+ * it). Called before the graph is laid out (on mount), it waits for the
+ * layout and its fit, so the app needs no timer.
+ */
+declare function revealNode(id: string): void;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {
+    fit: typeof fit;
+    arrange: () => Promise<void>;
+    revealNode: typeof revealNode;
+    openNode: typeof openNode;
+    undo: typeof undo;
+    redo: typeof redo;
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    clearHistory: typeof clearHistory;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    open: (node: ItDagNodeItem<unknown>) => any;
+    "update:nodes": (nodes: ItDagNodeItem<unknown>[]) => any;
+    "update:edges": (edges: ItDagEdgeItem[]) => any;
+    "update:selected": (id: string | null) => any;
+    create: (event: {
+        item: ItDagLibraryItem;
+        position: ItDagPoint;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onOpen?: ((node: ItDagNodeItem<unknown>) => any) | undefined;
+    "onUpdate:nodes"?: ((nodes: ItDagNodeItem<unknown>[]) => any) | undefined;
+    "onUpdate:edges"?: ((edges: ItDagEdgeItem[]) => any) | undefined;
+    "onUpdate:selected"?: ((id: string | null) => any) | undefined;
+    onCreate?: ((event: {
+        item: ItDagLibraryItem;
+        position: ItDagPoint;
+    }) => any) | undefined;
+}>, {
+    wheel: "page" | "pan";
+    height: number | string;
+    direction: ItDagDirection;
+    selected: string | null;
+    minZoom: number;
+    noun: ItDagNoun;
+    editable: boolean;
+    edgeShape: ItDagEdgeShape;
+    allowCycles: boolean;
+    connectionRule: ItDagConnectionRule;
+    library: ItDagLibraryItem[];
+    editorSize: "md" | "lg";
+    emptyTitle: string;
+    emptyDescription: string;
+    beforeRemove: ItDagRemoveGuard;
+    editor: "modal" | "none";
+    history: boolean | ItDagHistoryController;
+    fitMinZoom: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dag/ItDagControls.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/dag/ItDagEdge.vue.d.ts

@@ -0,0 +1,21 @@
+import { Position } from '@vue-flow/core';
+import { type ItDagEdgeShape, type ItDagEdgeTone } from './dag';
+import { type ItDagEdgeRoute } from './route';
+type __VLS_Props = {
+    id: string;
+    sourceX: number;
+    sourceY: number;
+    targetX: number;
+    targetY: number;
+    sourcePosition: Position;
+    targetPosition: Position;
+    data?: {
+        label?: string;
+        tone?: ItDagEdgeTone;
+        shape?: ItDagEdgeShape;
+        name?: string;
+        route?: ItDagEdgeRoute;
+    };
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/dag/ItDagLibrary.vue.d.ts

@@ -0,0 +1,19 @@
+import { type ItDagLibraryItem, type ItDagNoun } from './dag';
+type __VLS_Props = {
+    visible: boolean;
+    items: ItDagLibraryItem[];
+    /** One line under the title ("Between Read live version and Find tag."). */
+    description?: string;
+    /** Steps that do not fit where the step goes, by key, with the reason. */
+    misfits?: Record<string, string>;
+    /** What the canvas calls its nodes (ItDagCanvas `noun`). */
+    noun?: ItDagNoun;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:visible": (value: boolean) => any;
+    pick: (item: ItDagLibraryItem) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:visible"?: ((value: boolean) => any) | undefined;
+    onPick?: ((item: ItDagLibraryItem) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/dag/ItDagNode.vue.d.ts

@@ -0,0 +1,20 @@
+import { type ItDagNodeItem } from './dag';
+type __VLS_Props = {
+    node: ItDagNodeItem;
+    /** The canvas passes its selection; set it by hand outside a canvas. */
+    selected?: boolean;
+};
+type __VLS_Slots = {
+    /** Body under the meta line. */
+    default?: () => unknown;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    selected: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dag/dag.d.ts

@@ -0,0 +1,182 @@
+import type { Component, InjectionKey } from 'vue';
+export type ItDagDirection = 'right' | 'down';
+export type ItDagEdgeShape = 'step' | 'bezier';
+/** `active` is data moving now (a running step's input); `muted` is a path that did not run. */
+export type ItDagEdgeTone = 'default' | 'active' | 'success' | 'danger' | 'muted';
+export interface ItDagPoint {
+    x: number;
+    y: number;
+}
+export interface ItDagPort {
+    id: string;
+    /** Shown beside the port when a side has more than one ("True", "False"). Also its accessible name. */
+    label?: string;
+    /** Output: the kind of data it gives ("findings"). */
+    type?: string;
+    /** Input: the kinds of data it takes. Omit to take any. */
+    accepts?: string[];
+    /** Input: the most connections it takes. */
+    max?: number;
+}
+export interface ItDagNodeItem<Data = unknown> {
+    id: string;
+    label: string;
+    /** Overline above the label: the step's kind ("Trigger", "Action", "Condition"). */
+    kind?: string;
+    /** A muted line under the label ("GTM-NX42K · 26 tags"). */
+    meta?: string;
+    /** A Lucide icon for the kind. */
+    icon?: Component;
+    /** The platform the step works on ("gtm", "ga4"): its ItPlatformChip takes the icon's place. */
+    platform?: string;
+    /** Operational status, from the ItStatus registry: queued, running, succeeded, failed… */
+    status?: string | null;
+    /** The call the step makes, in mono on its own line under the meta ("gtm.tag.find"): the `uses` of the DAG patterns. */
+    call?: string;
+    /** A short word at the right of the call line: "Held" on a write that waits for its batch, "Planned" on a step not built yet. */
+    badge?: {
+        label: string;
+        tone?: 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+    };
+    /** Where the node sits on the canvas. Omit it and auto-layout places the node. */
+    position?: ItDagPoint;
+    /** Default: one input. `[]` for none (a trigger). */
+    inputs?: ItDagPort[];
+    /** Default: one output. `[]` for none (an end step). */
+    outputs?: ItDagPort[];
+    /** Dims the node: a step that did not run or is turned off. */
+    muted?: boolean;
+    /**
+     * False: a step the graph cannot do without (a workflow's start). Its editor
+     * has no "Delete step", and Delete or Backspace leave it in place. Default true.
+     */
+    removable?: boolean;
+    /** The step editor's title when "Edit step" does not say it ("Workflow settings" on a workflow's start). */
+    editorTitle?: string;
+    /** The app's own data for the step. */
+    data?: Data;
+}
+export interface ItDagEdgeItem {
+    id: string;
+    source: string;
+    target: string;
+    /** Output port id on the source. Default: its first output. */
+    sourcePort?: string;
+    /** Input port id on the target. Default: its first input. */
+    targetPort?: string;
+    /** A short word on the edge ("3 findings", "True"). */
+    label?: string;
+    tone?: ItDagEdgeTone;
+}
+export interface ItDagConnection {
+    source: string;
+    sourcePort: string;
+    target: string;
+    targetPort: string;
+}
+/** A step a user can add from the canvas's step library ("Add step"). */
+export interface ItDagLibraryItem {
+    key: string;
+    label: string;
+    description?: string;
+    icon?: Component;
+    /** The platform the step works on: its ItPlatformChip takes the icon's place. */
+    platform?: string;
+    /** Heading the item is listed under ("Data", "Messaging", "AI"). */
+    group?: string;
+    /** A status word on the card when the step is not ready ("not_connected", "expired"). */
+    status?: string | null;
+    /**
+     * The ports the new step will have. With them, "Add a step here" on a line
+     * lists the steps that fit between its two steps first, and the rest apart
+     * with the reason. Without them, a step is not judged before it is added.
+     */
+    inputs?: ItDagPort[];
+    outputs?: ItDagPort[];
+}
+/** An app rule on top of the built-in ones: a reason to refuse, or null. */
+export type ItDagConnectionRule = (connection: ItDagConnection) => string | null;
+/**
+ * What the canvas calls its nodes, in every string it writes ("Add step",
+ * "Delete label", "Search labels"). Lowercase; the canvas capitalizes it at
+ * the start of a sentence. `article` is for "a/an" before `one`: by default
+ * "an" before a vowel, so set it for words the rule gets wrong ("a user",
+ * "an hour").
+ */
+export interface ItDagNoun {
+    one: string;
+    other: string;
+    article?: 'a' | 'an';
+}
+export declare const IT_DAG_NOUN: ItDagNoun;
+/** "a step", "an asset". */
+export declare function itDagA(noun: ItDagNoun): string;
+export declare function itDagCapitalize(text: string): string;
+/** Steps and lines together: what a removal takes away, or the model as a whole. */
+export interface ItDagGraph {
+    nodes: ItDagNodeItem[];
+    edges: ItDagEdgeItem[];
+}
+/**
+ * Asked before the canvas removes anything (Delete or Backspace, "Delete
+ * step", a line's Delete): the steps and lines that would go, the lines of a
+ * removed step included. Return false (or resolve to false) to keep them; the
+ * app can ask first with `useItConfirm().destructive`.
+ */
+export type ItDagRemoveGuard = (change: ItDagGraph) => boolean | Promise<boolean>;
+export declare function itDagInputs(node: ItDagNodeItem): ItDagPort[];
+export declare function itDagOutputs(node: ItDagNodeItem): ItDagPort[];
+/** The edge's ports, with the defaults filled in. Pass the nodes by id when looking up many edges. */
+export declare function itDagEdgePorts(edge: ItDagEdgeItem, nodes: readonly ItDagNodeItem[] | ReadonlyMap<string, ItDagNodeItem>): {
+    sourcePort: string | undefined;
+    targetPort: string | undefined;
+};
+export declare function itDagEdgeId(connection: ItDagConnection): string;
+/** True when a path of edges leads from `from` to `to`. */
+export declare function itDagReaches(edges: readonly ItDagEdgeItem[], from: string, to: string): boolean;
+/**
+ * Why a connection is refused, or null when it is allowed. The built-in rules:
+ * output to input only, no step to itself, no second edge between the same
+ * ports, the input's `accepts` and `max`, and no loop (unless `allowCycles`).
+ */
+export declare function itDagConnectionError(nodes: readonly ItDagNodeItem[], edges: readonly ItDagEdgeItem[], connection: ItDagConnection, options?: {
+    allowCycles?: boolean;
+    noun?: ItDagNoun;
+}): string | null;
+/** What ItDagCanvas shares with its parts (steps, controls). */
+export interface ItDagCanvasContext {
+    editable: () => boolean;
+    direction: () => ItDagDirection;
+    expanded: () => boolean;
+    toggleExpanded: () => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    fit: () => void;
+    arrange: () => void;
+    /** The edge the pointer is on: its toolbar shows. */
+    hoveredEdge: () => string | null;
+    /** Pointer on or off an edge's line or its toolbar; off both waits a moment, so the pointer can reach the toolbar. */
+    hoverEdge: (id: string, part: 'line' | 'tools', on: boolean) => void;
+    /** Opens the connection modal for an edge. */
+    openConnection: (id: string) => void;
+    /** Opens the library to put a step on an edge, between its two steps. */
+    insertOnEdge: (id: string) => void;
+    removeEdge: (id: string) => void;
+    /** The part of the canvas in view, in canvas coordinates, as of the last pan or zoom (null before the first fit). */
+    view: () => ItDagViewRect | null;
+    /** What the canvas calls its nodes. */
+    noun: () => ItDagNoun;
+    /** Undo and redo are on (an editable canvas with `history`). */
+    history: () => boolean;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    undo: () => void;
+    redo: () => void;
+}
+export interface ItDagViewRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare const IT_DAG_CANVAS: InjectionKey<ItDagCanvasContext>;

package/dist/components/dag/history.d.ts

@@ -0,0 +1,51 @@
+import type { ItDagEdgeItem, ItDagGraph, ItDagNodeItem, ItDagPoint } from './dag';
+/** App-owned history for persisted graphs. The app records changes and remaps server ids. */
+export interface ItDagHistoryController {
+    canUndo: boolean;
+    canRedo: boolean;
+    /** Disable history controls while an app save or restore is pending. */
+    busy?: boolean;
+    undo(): void | Promise<void>;
+    redo(): void | Promise<void>;
+    clear?(): void;
+}
+export interface ItDagHistoryEntry {
+    /** Steps that came onto the canvas, with their index in the model, so undo then redo puts them back in place. */
+    addedNodes: {
+        node: ItDagNodeItem;
+        index: number;
+    }[];
+    removedNodes: {
+        node: ItDagNodeItem;
+        index: number;
+    }[];
+    addedEdges: {
+        edge: ItDagEdgeItem;
+        index: number;
+    }[];
+    removedEdges: {
+        edge: ItDagEdgeItem;
+        index: number;
+    }[];
+    /** Steps that stayed and changed place. `from` is undefined for a step auto-layout had placed. */
+    moved: {
+        id: string;
+        from?: ItDagPoint;
+        to?: ItDagPoint;
+    }[];
+}
+/** What one action changed, as an entry; null when it changed none of what history tracks (a step's name or data). */
+export declare function itDagHistoryDiff(before: ItDagGraph, after: ItDagGraph): ItDagHistoryEntry | null;
+/**
+ * The steps after undoing (`undo`) or redoing (`redo`) an entry on the model
+ * as it is now. Lines are a second step (`itDagHistoryEdges`): a line to a
+ * step Vue Flow has not stored yet is dropped, so the canvas sends the steps
+ * first and the lines once the steps are in.
+ */
+export declare function itDagHistoryNodes(entry: ItDagHistoryEntry, nodes: readonly ItDagNodeItem[], way: 'undo' | 'redo'): ItDagNodeItem[];
+/**
+ * The lines after undoing or redoing an entry, given the steps it left
+ * (`nodes`): the lines of a step it took away go with it, and a line comes
+ * back only when both its steps are on the canvas.
+ */
+export declare function itDagHistoryEdges(entry: ItDagHistoryEntry, edges: readonly ItDagEdgeItem[], nodes: readonly ItDagNodeItem[], way: 'undo' | 'redo'): ItDagEdgeItem[];

package/dist/components/dag/layout.d.ts

@@ -0,0 +1,54 @@
+import type { ItDagDirection, ItDagPoint } from './dag';
+export interface ItDagLayoutNode {
+    id: string;
+    width: number;
+    height: number;
+    inputs: string[];
+    outputs: string[];
+    /**
+     * Where each port's center is along its side, in the order of `inputs` and
+     * `outputs`: from the top when the flow runs right, from the left when it
+     * runs down. Omit to spread the ports evenly.
+     */
+    portOffsets?: {
+        inputs: number[];
+        outputs: number[];
+    };
+}
+export interface ItDagLayoutEdge {
+    id: string;
+    source: string;
+    target: string;
+    sourcePort: string;
+    targetPort: string;
+}
+/** An edge's route: where it leaves the source's border, the bends, and where it meets the target's border. */
+export interface ItDagRoute {
+    start: ItDagPoint;
+    bends: ItDagPoint[];
+    end: ItDagPoint;
+}
+export interface ItDagArrangement {
+    /** Each node's top-left corner, on whole pixels. */
+    positions: Map<string, ItDagPoint>;
+    /** Each edge's route, for the positions as ELK placed them (before the round to whole pixels). */
+    routes: Map<string, ItDagRoute>;
+}
+/** Space between steps in one column, between columns, and the straight run out of a port. */
+export declare const IT_DAG_SPACING: {
+    node: number;
+    layer: number;
+    lead: number;
+};
+/** Starts loading ELK (and its worker) before the first layout needs it. A failure here is left to that layout. */
+export declare function itDagPreloadLayout(): void;
+/** Places every node and routes every edge. */
+export declare function itDagArrange(nodes: ItDagLayoutNode[], edges: ItDagLayoutEdge[], direction?: ItDagDirection): Promise<ItDagArrangement>;
+/**
+ * A plain layout for when ELK cannot load: columns by depth (rows when the
+ * direction is down), each in the model's order, with the same spacing. No
+ * crossing reduction and no routes; it only keeps the steps apart and readable.
+ */
+export declare function itDagFallbackLayout(nodes: ItDagLayoutNode[], edges: ItDagLayoutEdge[], direction?: ItDagDirection): Map<string, ItDagPoint>;
+/** Places every node; returns each node's top-left corner. */
+export declare function itDagLayout(nodes: ItDagLayoutNode[], edges: ItDagLayoutEdge[], direction?: ItDagDirection): Promise<Map<string, ItDagPoint>>;

package/dist/components/dag/route.d.ts

@@ -0,0 +1,24 @@
+import type { ItDagPoint } from './dag';
+/** A route as the canvas keeps it: the port points it was made for, and the bends between. */
+export interface ItDagEdgeRoute {
+    from: ItDagPoint;
+    to: ItDagPoint;
+    bends: ItDagPoint[];
+}
+/**
+ * The route's points from `source` to `target`, or null when a step has moved
+ * since the layout (the route no longer meets its ports). The straight run out
+ * of the source and the straight run into the target take the ports' exact
+ * line: every bend on that run moves, not only the one next to the port. A run
+ * left a pixel off its port draws a second, offset line beside the other lines
+ * into the same input, which reads as a doubled line. A port that slid across
+ * the flow (its step changed height) keeps the route: its run follows it. A
+ * rejected route falls back to a plain line, which can cut through a step.
+ */
+export declare function routePoints(route: ItDagEdgeRoute | undefined, source: ItDagPoint, target: ItDagPoint, across: boolean): ItDagPoint[] | null;
+/** The path through the points, each bend rounded by up to `radius`, and the point halfway along it (for a label). */
+export declare function routePath(points: ItDagPoint[], radius: number): {
+    path: string;
+    labelX: number;
+    labelY: number;
+};

package/dist/components/data/DataError.vue.d.ts

@@ -0,0 +1,12 @@
+type __VLS_Props = {
+    error: string | boolean;
+    /** What failed to load, in a few words: the chart's or card's label. */
+    subject?: string;
+    retryable?: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    retry: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRetry?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;