@elaraai/e3-ui-components 1.0.83 → 1.0.85

package/dist/query/open-query.d.ts

@@ -0,0 +1,214 @@
+import { OptionType, StringType, StructType, VariantType, ValueTypeOf } from '@elaraai/east';
+import { SavedQueryType } from '@elaraai/e3-ui/internal';
+/**
+ * The query open in a builder.
+ *
+ * @property new - A query not yet saved: `id` tells it from every other new
+ *   query, so each keeps its own drafts; `source` is the data source it starts
+ *   from; `from`, when it begins as a run of this viewer's that was never
+ *   saved, is that run — its name, its description and its checked query
+ * @property saved - A saved query, by its name
+ */
+export declare const QueryOpenType: VariantType<{
+    readonly new: StructType<{
+        readonly id: StringType;
+        readonly source: StringType;
+        readonly from: OptionType<StructType<{
+            readonly name: StringType;
+            readonly description: OptionType<StringType>;
+            readonly program: import('@elaraai/east').RecursiveType<VariantType<{
+                readonly alternative: StructType<{
+                    readonly left: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly right: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly array: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                readonly binary: StructType<{
+                    readonly left: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly op: StringType;
+                    readonly right: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly bind: StructType<{
+                    readonly body: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly patterns: import('@elaraai/east').ArrayType<import('@elaraai/east').RecursiveType<VariantType<{
+                        readonly array: import('@elaraai/east').ArrayType<import('@elaraai/east').RecursiveTypeMarker>;
+                        readonly object: import('@elaraai/east').ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly value: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                        }>>;
+                        readonly variable: StringType;
+                    }>>>;
+                    readonly source: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly break: StringType;
+                readonly call: StructType<{
+                    readonly args: import('@elaraai/east').ArrayType<import('@elaraai/east').RecursiveTypeMarker>;
+                    readonly name: StringType;
+                }>;
+                readonly comma: StructType<{
+                    readonly left: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly right: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly def: StructType<{
+                    readonly body: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly name: StringType;
+                    readonly params: import('@elaraai/east').ArrayType<StringType>;
+                    readonly rest: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly descend: import('@elaraai/east').NullType;
+                readonly field: StructType<{
+                    readonly name: StringType;
+                    readonly optional: import('@elaraai/east').BooleanType;
+                    readonly target: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly foreach: StructType<{
+                    readonly extract: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                    readonly init: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly pattern: import('@elaraai/east').RecursiveType<VariantType<{
+                        readonly array: import('@elaraai/east').ArrayType<import('@elaraai/east').RecursiveTypeMarker>;
+                        readonly object: import('@elaraai/east').ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly value: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                        }>>;
+                        readonly variable: StringType;
+                    }>>;
+                    readonly source: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly update: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly format: StructType<{
+                    readonly name: StringType;
+                    readonly string: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                }>;
+                readonly identity: import('@elaraai/east').NullType;
+                readonly if: StructType<{
+                    readonly branches: import('@elaraai/east').ArrayType<StructType<{
+                        readonly condition: import('@elaraai/east').RecursiveTypeMarker;
+                        readonly then: import('@elaraai/east').RecursiveTypeMarker;
+                    }>>;
+                    readonly otherwise: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                }>;
+                readonly index: StructType<{
+                    readonly index: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly optional: import('@elaraai/east').BooleanType;
+                    readonly target: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly iterate: StructType<{
+                    readonly optional: import('@elaraai/east').BooleanType;
+                    readonly target: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly label: StructType<{
+                    readonly body: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly name: StringType;
+                }>;
+                readonly literal: VariantType<{
+                    readonly boolean: import('@elaraai/east').BooleanType;
+                    readonly float: import('@elaraai/east').FloatType;
+                    readonly integer: import('@elaraai/east').IntegerType;
+                    readonly null: import('@elaraai/east').NullType;
+                    readonly string: StringType;
+                }>;
+                readonly negate: import('@elaraai/east').RecursiveTypeMarker;
+                readonly object: import('@elaraai/east').ArrayType<StructType<{
+                    readonly key: VariantType<{
+                        readonly computed: import('@elaraai/east').RecursiveTypeMarker;
+                        readonly name: StringType;
+                        readonly variable: StringType;
+                    }>;
+                    readonly value: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                }>>;
+                readonly pipe: StructType<{
+                    readonly left: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly right: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly reduce: StructType<{
+                    readonly init: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly pattern: import('@elaraai/east').RecursiveType<VariantType<{
+                        readonly array: import('@elaraai/east').ArrayType<import('@elaraai/east').RecursiveTypeMarker>;
+                        readonly object: import('@elaraai/east').ArrayType<StructType<{
+                            readonly key: StringType;
+                            readonly value: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                        }>>;
+                        readonly variable: StringType;
+                    }>>;
+                    readonly source: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly update: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly slice: StructType<{
+                    readonly from: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                    readonly optional: import('@elaraai/east').BooleanType;
+                    readonly target: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly to: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                }>;
+                readonly string: import('@elaraai/east').ArrayType<VariantType<{
+                    readonly interpolate: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly text: StringType;
+                }>>;
+                readonly try: StructType<{
+                    readonly body: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly catch: OptionType<import('@elaraai/east').RecursiveTypeMarker>;
+                }>;
+                readonly update: StructType<{
+                    readonly op: StringType;
+                    readonly path: import('@elaraai/east').RecursiveTypeMarker;
+                    readonly value: import('@elaraai/east').RecursiveTypeMarker;
+                }>;
+                readonly variable: StringType;
+            }>>;
+            readonly root: import('@elaraai/east').ArrayType<StructType<{
+                readonly name: StringType;
+                readonly path: import('@elaraai/east').ArrayType<VariantType<{
+                    readonly field: StringType;
+                }>>;
+            }>>;
+            readonly saved_at: import('@elaraai/east').DateTimeType;
+        }>>;
+    }>;
+    readonly saved: StringType;
+}>;
+/** The query open in a builder. */
+export type QueryOpen = ValueTypeOf<typeof QueryOpenType>;
+/**
+ * The notice a query arrived with.
+ *
+ * @property sourceId - The session of the query it arrived with ({@link querySourceId})
+ * @property text - What the Query tab says when that query opens
+ */
+export declare const QueryArrivalType: StructType<{
+    readonly sourceId: StringType;
+    readonly text: StringType;
+}>;
+/** The notice a query arrived with. */
+export type QueryArrival = ValueTypeOf<typeof QueryArrivalType>;
+/**
+ * The open query's editing session's source id — `query.saved:"Big orders"`,
+ * or `query.new:"1"` — one session, and its drafts, per query.
+ *
+ * @param open - The open query
+ * @returns Its source id
+ */
+export declare function querySourceId(open: QueryOpen): string;
+/**
+ * A new query: on a data source, or begun as a run of this viewer's that was
+ * never saved — its own id, so its drafts are its own.
+ *
+ * @param source - The data source it starts from
+ * @param from - The run it begins as, when it does
+ * @returns The query to open
+ */
+export declare function newQuery(source: string, from?: ValueTypeOf<typeof SavedQueryType>): QueryOpen;
+/**
+ * Opens a query: writes it as the open query, with the notice it arrives with.
+ *
+ * @param next - The query to open
+ * @param notice - What the Query tab says when it opens — none for a query opened without one
+ */
+export type OpenQueryWrite = (next: QueryOpen, notice?: string) => void;
+/**
+ * The query open in the builder the key names, a way to open another, and the
+ * notice the open query arrived with.
+ *
+ * @param key - The builder's open-query key
+ * @param first - The query it opens before any is written — a new query on its first data source
+ * @returns The open query; the write that opens another, with the notice it arrives with; and the last notice written
+ */
+export declare function useOpenQuery(key: string, first: QueryOpen): [QueryOpen, OpenQueryWrite, QueryArrival | undefined];
+//# sourceMappingURL=open-query.d.ts.map

package/dist/query/open-query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-query.d.ts","sourceRoot":"","sources":["../../src/query/open-query.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAeH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAmE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AACnK,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAGzD;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGxB,CAAC;AAEH,mCAAmC;AACnC,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;EAAyD,CAAC;AAEvF,uCAAuC;AACvC,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAQhE;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,CAErD;AAKD;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,CAAC,OAAO,cAAc,CAAC,GAAG,SAAS,CAG7F;AAED;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;AAExE;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,CAAC,SAAS,EAAE,cAAc,EAAE,YAAY,GAAG,SAAS,CAAC,CAiBjH"}

package/dist/query/parts.d.ts

@@ -0,0 +1,115 @@
+import { ReactElement, ReactNode } from 'react';
+import { SystemStyleObject } from '@chakra-ui/react';
+import { IconDefinition } from '@fortawesome/free-solid-svg-icons';
+import { CardLine, CardPart, ProblemLine } from './model/cards.js';
+import { ActionRef, InputRef, RemoveRef, SlotRef } from './model/refs.js';
+import { QueryWords } from './model/words.js';
+import { StepFix } from './steps/check.js';
+/** A recipe's styles, by slot. */
+export type Styles = Record<string, SystemStyleObject>;
+/** What the parts ask of the Query tab. */
+export interface PartActions {
+    /** The key of the slot whose autocomplete is open. */
+    readonly openSlot: string | undefined;
+    /** Opens a slot's autocomplete, hanging from its element. */
+    readonly onSlot: (slot: SlotRef, anchor: HTMLElement) => void;
+    /** An input typed in and left. */
+    readonly onInput: (input: InputRef, raw: string) => void;
+    /** A × pressed. */
+    readonly onRemove: (ref: RemoveRef) => void;
+    /** An add pressed: one that adds, or one that opens a slot, hanging from its element. */
+    readonly onAction: (ref: ActionRef, anchor: HTMLElement) => void;
+    /** A problem's fix taken. */
+    readonly onFix: (fix: StepFix, label: string) => void;
+}
+/** What drawing the parts needs: the styles of the recipes they are made of, and the words. */
+export interface PartStyles {
+    /** The `queryBuilder` recipe's. */
+    readonly styles: Styles;
+    /** The `select` recipe's, small: a slot is its trigger. */
+    readonly select: Styles;
+    /** The `input` recipe's, small. */
+    readonly input: SystemStyleObject;
+    /** The `iconButton` recipe's, quiet and extra small. */
+    readonly icon: SystemStyleObject;
+    /** The `codeBlock` recipe's. */
+    readonly code: Styles;
+    /** The words. */
+    readonly words: QueryWords;
+}
+/**
+ * The parts' styles: the `queryBuilder` recipe's, and the core recipes' a
+ * part is made of.
+ *
+ * @param words - The words
+ * @returns The styles, and the words
+ */
+export declare function usePartStyles(words: QueryWords): PartStyles;
+/**
+ * A slot's key: what its element carries as `data-slot-key`, so the slot a
+ * pick opens next is found after the query renders again.
+ *
+ * @param slot - The slot
+ * @returns Its key
+ */
+export declare function slotKey(slot: SlotRef): string;
+/**
+ * A tooltip over a control: the design system's, after a moment's hover.
+ *
+ * @param props - The words it shows, and the control
+ * @returns The control, with its tooltip
+ */
+export declare function Tip({ label, children }: {
+    label: string;
+    children: ReactElement;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * An icon button, named for a screen reader and by its tooltip.
+ *
+ * @param props - Its name, its icon, whether it is off, what it does, and its styles
+ * @returns The button
+ */
+export declare function IconPart({ label, icon, disabled, css, onClick }: {
+    label: string;
+    icon: IconDefinition;
+    disabled?: boolean;
+    css: SystemStyleObject | SystemStyleObject[];
+    onClick: () => void;
+}): import("react/jsx-runtime").JSX.Element;
+/**
+ * A row's parts, in order.
+ *
+ * @param props - The parts, their styles and what they ask
+ * @returns The parts
+ */
+export declare function Parts({ parts, ps, actions, ghost }: {
+    parts: readonly CardPart[];
+    ps: PartStyles;
+    actions: PartActions;
+    ghost?: boolean;
+}): ReactNode;
+/**
+ * The problems under a row: each in its severity's ink, the checker's own
+ * sentence on hover, and its fixes as buttons.
+ *
+ * @param props - The problems, their styles and what a fix asks
+ * @returns The problem lines
+ */
+export declare function Problems({ problems, ps, actions }: {
+    problems: readonly ProblemLine[];
+    ps: PartStyles;
+    actions: PartActions;
+}): ReactNode;
+/**
+ * A card's lines: rows, groups with their head and lines, feet, notes and a
+ * jq step's code, each with the problems under it.
+ *
+ * @param props - The lines, their styles and what they ask
+ * @returns The lines
+ */
+export declare function Lines({ lines, ps, actions }: {
+    lines: readonly CardLine[];
+    ps: PartStyles;
+    actions: PartActions;
+}): ReactNode;
+//# sourceMappingURL=parts.d.ts.map

package/dist/query/parts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parts.d.ts","sourceRoot":"","sources":["../../src/query/parts.tsx"],"names":[],"mappings":"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"}

package/dist/query/plan-popover.d.ts

@@ -0,0 +1,22 @@
+import { SplitCallProgress } from '@elaraai/e3-types';
+import { QueryWords } from './model/words.js';
+import { QueryPlan } from './plan.js';
+/** Props of {@link QueryPlanReadout}. */
+export interface QueryPlanReadoutProps {
+    /** The run's plan. */
+    readonly planned: QueryPlan;
+    /** A split call's progress, while it goes. */
+    readonly progress: SplitCallProgress | undefined;
+    /** How many pieces a split call cut, once e3 says. */
+    readonly pieces: number | undefined;
+    /** The words. */
+    readonly words: QueryWords;
+}
+/**
+ * Renders the plan's read-out — see the module docs.
+ *
+ * @param props - The plan, a split call's progress and pieces, and the words ({@link QueryPlanReadoutProps})
+ * @returns The read-out, and its popover while open
+ */
+export declare const QueryPlanReadout: import('react').NamedExoticComponent<QueryPlanReadoutProps>;
+//# sourceMappingURL=plan-popover.d.ts.map

package/dist/query/plan-popover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-popover.d.ts","sourceRoot":"","sources":["../../src/query/plan-popover.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAsBH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AAE3D,OAAO,EAAwB,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEzE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAE3C,yCAAyC;AACzC,MAAM,WAAW,qBAAqB;IAClC,sBAAsB;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5B,8CAA8C;IAC9C,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACjD,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,iBAAiB;IACjB,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;CAC9B;AAED;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,6DAsB3B,CAAC"}