@elaraai/e3-ui-components 1.0.83 → 1.0.85

package/dist/query/foot.d.ts

@@ -0,0 +1,22 @@
+import { StepOption } from './model/slots.js';
+import { StepKind } from './steps/values.js';
+import { PartActions, PartStyles } from './parts.js';
+/** Props of {@link QueryFoot}. */
+export interface QueryFootProps {
+    /** The Quick add buttons, each saying whether its step fits. */
+    readonly options: readonly StepOption[];
+    /** The parts' styles, and the words. */
+    readonly ps: PartStyles;
+    /** What "Add a step at the end" asks: the add-step list, hanging from it. */
+    readonly onSlot: PartActions["onSlot"];
+    /** A Quick add button pressed: its step, added at the end. */
+    readonly onQuick: (kind: StepKind) => void;
+}
+/**
+ * Renders the foot — see the module docs.
+ *
+ * @param props - The Quick add buttons, and what the foot asks ({@link QueryFootProps})
+ * @returns The foot
+ */
+export declare const QueryFoot: import('react').NamedExoticComponent<QueryFootProps>;
+//# sourceMappingURL=foot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"foot.d.ts","sourceRoot":"","sources":["../../src/query/foot.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAmBH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAgB,KAAK,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7E,kCAAkC;AAClC,MAAM,WAAW,cAAc;IAC3B,gEAAgE;IAChE,QAAQ,CAAC,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;IACxC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,QAAQ,CAAC,CAAC;IACvC,8DAA8D;IAC9D,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAC;CAC9C;AAKD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,sDA2BpB,CAAC"}

package/dist/query/hooks.d.ts

@@ -0,0 +1,265 @@
+import { ReactNode } from 'react';
+import { ValueTypeOf } from '@elaraai/east';
+import { DataSourceType, SavedQueryType } from '@elaraai/e3-ui/internal';
+import { SplitCallAnswer } from '@elaraai/e3-api-client';
+import { DatasetStatusDetail, ExecuteResult, OneShotRequest, SplitCallPlan, SplitCallProgress, SplitCallRequest, TreePath } from '@elaraai/e3-types';
+import { E3Config } from '../platform/e3-config.js';
+import { SummaryCache } from './model/summaries.js';
+import { QueryWords } from './model/words.js';
+import { QueryRoot } from './one-shot.js';
+import { PlanOptions } from './plan.js';
+/** A data source the builder is handed. */
+export type DataSource = ValueTypeOf<typeof DataSourceType>;
+/** A saved query, or a recent run of one. */
+type SavedQuery = ValueTypeOf<typeof SavedQueryType>;
+/**
+ * The root a builder's queries read: each bound data source as a root field,
+ * in the order given — or why it cannot be queried, in the builder's words.
+ *
+ * @remarks
+ * A `Data.bind` source is its dataset's path, a record `[records, name]`, and a
+ * `Data.bindPaged` source the path its handle was bound with, which the paged
+ * runtime that built it holds. A paged source read through one of a record's
+ * indexes is refused: its rows are the index's, not the record's a query reads.
+ *
+ * @param datasets - The data sources, as the payload holds them
+ * @param words - The words, for a refusal
+ * @returns The root, or the refusal
+ */
+export declare function useQueryRoot(datasets: DataSource[], words: QueryWords): QueryRoot | string;
+/**
+ * Makes a one-shot call: the request, answered by the call's result.
+ *
+ * @param request - The request — a query's or a summary's, platform-free
+ * @returns The result
+ */
+export type QueryCall = (request: OneShotRequest) => Promise<ExecuteResult>;
+/** Props of {@link QueryCallProvider}. */
+export interface QueryCallProviderProps {
+    /** How a one-shot call is made for the subtree. */
+    call: QueryCall;
+    /** The subtree. */
+    children?: ReactNode;
+}
+/**
+ * Makes the query builder's one-shot calls with a host's own function — a
+ * test's, or a host that reaches e3 another way.
+ *
+ * @param props - The call and the subtree
+ * @returns The provider
+ */
+export declare function QueryCallProvider({ call, children }: QueryCallProviderProps): import('react').FunctionComponentElement<import('react').ProviderProps<QueryCall | null>>;
+/**
+ * How the builder makes a one-shot call: a {@link QueryCallProvider}'s, else
+ * e3-api-client's `oneShotExecute` against the `E3Provider`'s server and
+ * workspace, with its token and through its `fetch`.
+ *
+ * @returns The call, or `undefined` when there is no server to call
+ */
+export declare function useQueryCall(): QueryCall | undefined;
+/** What a split call is given: the signal that abandons it, and where its progress goes. */
+export interface QuerySplitCallOptions {
+    /** Abandons the call: it stops polling, and rejects with the signal's reason. Its job runs on. */
+    readonly signal: AbortSignal;
+    /** Told the call's progress each time e3 reports it: its stage, and the units of it done of all. */
+    readonly onProgress: (progress: SplitCallProgress) => void;
+}
+/**
+ * Makes a split call: the request, answered once its job ends by the call's
+ * result — read as a one-shot call's is — and the hash of its assembled
+ * output, which a re-keyed join's second call reads (#942).
+ *
+ * @param request - The request — a plan's, platform-free (`splitCallRequest`,
+ *   `rekeyCallRequests`)
+ * @param options - The signal that abandons it, and where its progress goes
+ * @returns The call's result, and its assembled output's hash once its pieces
+ *   ran (`null` before)
+ *
+ * @remarks
+ * It rejects with e3-api-client's `ApiError` or `AuthError` when the server
+ * refuses the call, with a `TypeError` when the server cannot be reached, as
+ * `fetch` does, and with any other error when e3 could not run it (a job that
+ * ended `failed`); and with the signal's reason once it is abandoned.
+ */
+export type QuerySplitCall = (request: SplitCallRequest, options: QuerySplitCallOptions) => Promise<SplitCallAnswer>;
+/**
+ * Plans a split call's pieces without running it: e3's explain, a job that
+ * plans them as the call's run plans them and runs no unit, so the count is
+ * the run's (#1132).
+ *
+ * @param request - The call, as its run sent it
+ * @param options - The signal that abandons it
+ * @returns How many pieces, the argument they are cut over, by its position,
+ *   and what that argument weighs in the store
+ *
+ * @remarks
+ * It rejects as a split call does ({@link QuerySplitCall}), and with an
+ * `Error` naming what is wrong when e3 finds the call wrong.
+ */
+export type QuerySplitExplain = (request: SplitCallRequest, options: {
+    readonly signal: AbortSignal;
+}) => Promise<SplitCallPlan>;
+/** Props of {@link QuerySplitCallProvider}. */
+export interface QuerySplitCallProviderProps {
+    /** How a split call is made for the subtree. */
+    call: QuerySplitCall;
+    /**
+     * How the subtree's split calls' pieces are counted when a run answered
+     * before its call reported them (#1132): the in-memory call's `explain`,
+     * say. Without it, such a run's pieces go uncounted.
+     */
+    explain?: QuerySplitExplain;
+    /** The subtree. */
+    children?: ReactNode;
+}
+/**
+ * Makes the query builder's split calls with a host's own function — a
+ * test's (`createInMemorySplitCall`), or a host that reaches e3 another way —
+ * and counts their pieces with the host's explain, when it gives one.
+ *
+ * @param props - The call, its explain and the subtree
+ * @returns The provider
+ */
+export declare function QuerySplitCallProvider({ call, explain, children }: QuerySplitCallProviderProps): import('react').FunctionComponentElement<import('react').ProviderProps<QuerySplitCall | null>>;
+/**
+ * How the builder makes a split call: a {@link QuerySplitCallProvider}'s, else
+ * e3-api-client's `splitCall` against the `E3Provider`'s server and workspace,
+ * with its token and through its `fetch`, which launches the call, polls it —
+ * 100 ms apart at first, backing off to a second — and reports each progress
+ * it finds.
+ *
+ * @returns The call, or `undefined` when there is no server to call
+ */
+export declare function useQuerySplitCall(): QuerySplitCall | undefined;
+/**
+ * How the builder counts a split call's pieces when its run answered before
+ * e3 reported them (#1132): a {@link QuerySplitCallProvider}'s explain — a
+ * host's split calls are explained by the host, or not at all — else
+ * e3-api-client's `splitCallExplain` against the `E3Provider`'s server and
+ * workspace, with its token and through its `fetch`, which launches the
+ * explain and polls it until it has planned.
+ *
+ * @returns The explain, or `undefined` when there is none to make
+ */
+export declare function useQuerySplitExplain(): QuerySplitExplain | undefined;
+/** What e3's status says of a data source: how many rows it holds, its hash, and what it weighs. */
+export interface SourceStatus {
+    /** How many elements a stored list or lookup table holds; `undefined` for a value that is not a collection, or not known. */
+    readonly rows: number | undefined;
+    /** The hash of its value; `undefined` when it has none, or it is not known. */
+    readonly hash: string | undefined;
+    /** What its value weighs in the store, in bytes — a collection's segments and its manifest; `undefined` when not known. */
+    readonly bytes: number | undefined;
+}
+/**
+ * Reads a data source's status: what a run weighs before it plans.
+ *
+ * @param path - The dataset's path, as the root holds it
+ * @returns Its status
+ */
+export type QuerySourceStatus = (path: TreePath) => Promise<SourceStatus>;
+/** Props of {@link QuerySourceStatusProvider}. */
+export interface QuerySourceStatusProviderProps {
+    /** How a data source's status is read for the subtree. */
+    status: QuerySourceStatus;
+    /** The subtree. */
+    children?: ReactNode;
+}
+/**
+ * Reads the data sources' statuses with a host's own function — a test's, or
+ * a host's over datasets in memory (`createInMemorySourceStatus`).
+ *
+ * @param props - The status and the subtree
+ * @returns The provider
+ */
+export declare function QuerySourceStatusProvider({ status, children }: QuerySourceStatusProviderProps): import('react').FunctionComponentElement<import('react').ProviderProps<QuerySourceStatus | null>>;
+/** A data source's status query, as TanStack Query takes it: its key, and its function. */
+export interface SourceStatusQuery {
+    /** Its key: the server, the repository, the workspace and the dataset's path. */
+    readonly queryKey: readonly unknown[];
+    /** Its function: e3-api-client's `datasetGetStatus`. */
+    readonly queryFn: () => Promise<DatasetStatusDetail>;
+}
+/**
+ * A data source's status query on e3, as TanStack Query takes it: the Datasets
+ * tab polls it, and a run reads it through the same cache before it plans.
+ *
+ * @param config - The server: its token, and the `fetch` its requests go through
+ * @param workspace - The workspace
+ * @param path - The dataset's path
+ * @returns The query's key, and its function: e3-api-client's `datasetGetStatus`
+ */
+export declare function sourceStatusQuery(config: E3Config, workspace: string, path: TreePath): SourceStatusQuery;
+/**
+ * A data source's status, as e3's dataset status gives it.
+ *
+ * @param detail - The dataset's status detail
+ * @returns Its rows, hash and stored bytes
+ */
+export declare function sourceStatusOf(detail: DatasetStatusDetail): SourceStatus;
+/**
+ * How the builder reads a data source's status: a
+ * {@link QuerySourceStatusProvider}'s, else e3's dataset status against the
+ * `E3Provider`'s server and workspace, through the TanStack Query cache the
+ * Datasets tab polls, a status read in the last 5 seconds serving again.
+ *
+ * @returns The status, or `undefined` when there is no server to ask
+ */
+export declare function useQuerySourceStatus(): QuerySourceStatus | undefined;
+/** Props of {@link QueryPlanOptionsProvider}. */
+export interface QueryPlanOptionsProviderProps {
+    /**
+     * The most a dataset may weigh, in stored bytes, and still be read by one
+     * call: e3's smallest piece (`PIECE_SIZES.min`, 16 MiB) when omitted. A
+     * host over a server that cuts small pieces (`E3_TEST_PIECE_BYTES`) sets
+     * it small, so its runs split.
+     */
+    pieceBytes?: number;
+    /** The subtree. */
+    children?: ReactNode;
+}
+/**
+ * Sets how the query builder plans its runs for a subtree: the most a dataset
+ * may weigh and still be read by one call.
+ *
+ * @param props - The options and the subtree
+ * @returns The provider
+ */
+export declare function QueryPlanOptionsProvider({ pieceBytes, children }: QueryPlanOptionsProviderProps): import('react').FunctionComponentElement<import('react').ProviderProps<PlanOptions>>;
+/**
+ * How the builder plans its runs: a {@link QueryPlanOptionsProvider}'s options,
+ * else the defaults.
+ *
+ * @returns The options
+ */
+export declare function useQueryPlanOptions(): PlanOptions;
+/**
+ * The builder's summaries: #934's summary programs, each run as a one-shot
+ * call with small limits when a slot that needs it opens, and kept by prefix
+ * and the hashes of the datasets it read. A summary that fails leaves the
+ * slot's offers without values.
+ *
+ * @param root - The root, or why it cannot be queried
+ * @param call - How a one-shot call is made
+ * @returns The cache, and the latest hash of each data source a run has read
+ */
+export declare function useQuerySummaries(root: QueryRoot | string, call: QueryCall | undefined): {
+    cache: SummaryCache;
+    hashes: ReadonlyMap<string, string>;
+};
+/** How many recent runs a viewer keeps. */
+export declare const RECENT_RUNS = 10;
+/**
+ * This viewer's recent runs, newest first, kept in the browser under the
+ * builder's key — each a saved query's form, printed as East text. A query run
+ * again moves to the front.
+ *
+ * @param key - The builder's recent-runs key (`queryKeys(id).recent`)
+ * @returns The runs, and `remember(run)`
+ */
+export declare function useRecentQueries(key: string): {
+    recent: readonly SavedQuery[];
+    remember: (run: SavedQuery) => void;
+};
+export {};
+//# sourceMappingURL=hooks.d.ts.map

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

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

package/dist/query/in-memory-call.d.ts

@@ -0,0 +1,150 @@
+import { EastType } from '@elaraai/east';
+import { TreePath } from '@elaraai/e3-types';
+import { QueryCall, QuerySourceStatus, QuerySplitCall, QuerySplitExplain } from './hooks.js';
+/**
+ * A dataset an in-memory call may read.
+ *
+ * @property path - Its path in the workspace, as a call's argument names it
+ * @property type - Its East type
+ * @property value - Its value
+ * @property hash - The hash a run pins it at; the SHA-256 of its beast2 bytes when omitted
+ * @property bytes - What it weighs in the store, as its status says; its beast2 bytes' length when omitted
+ */
+export interface InMemoryDataset {
+    /** Its path in the workspace, as a call's argument names it. */
+    readonly path: TreePath;
+    /** Its East type. */
+    readonly type: EastType;
+    /** Its value. */
+    readonly value: unknown;
+    /** The hash a run pins it at; the SHA-256 of its beast2 bytes when omitted. */
+    readonly hash?: string;
+    /** What it weighs in the store, in bytes, as its status says; its beast2 bytes' length when omitted. A test weighs a small dataset as a large one with it. */
+    readonly bytes?: number;
+}
+/**
+ * Builds a one-shot call answered in memory, as e3 answers one: the request's
+ * body decoded from its IR and compiled with no platform function — a query's
+ * call is platform-free — then called with the value of each dataset its
+ * arguments name, each pinned at its hash.
+ *
+ * @param datasets - The datasets a call may read
+ * @returns The call
+ *
+ * @remarks
+ * - **Success**: the answer, beast2 at the body's output type, and each
+ *   dataset read with its hash.
+ * - **Failed**: a body that raises an East error fails as a runner's run does —
+ *   exit code 1, and on stderr `Error: <message>` with each place it was
+ *   raised, so the builder places it in the jq.
+ * - **Invalid**: an argument naming no dataset here is refused as e3 refuses
+ *   an unassigned one ("Dataset argument 0 is not assigned"), and an inline
+ *   value as one this stand-in does not take.
+ * - **Too large**: an answer over the request's `maxResultBytes`.
+ *
+ * The time limit is not kept: a body runs to its end.
+ *
+ * @example
+ * ```tsx
+ * const call = createInMemoryQueryCall([
+ *     { path: [variant("field", "inputs"), variant("field", "orders")], type: ArrayType(Order), value: orders },
+ * ]);
+ * return <QueryCallProvider call={call}>{surface}</QueryCallProvider>;
+ * ```
+ */
+export declare function createInMemoryQueryCall(datasets: readonly InMemoryDataset[]): QueryCall;
+/** Options for {@link createInMemorySplitCall}. */
+export interface InMemorySplitCallOptions {
+    /**
+     * How many pieces the partitioned dataset is cut into, in order: as near
+     * equal runs of its rows as can be, some empty when there are more pieces
+     * than rows.
+     */
+    readonly pieces: number;
+}
+/**
+ * A split call answered in memory ({@link createInMemorySplitCall}), and its
+ * explain (#1132): what e3's explain of the same call answers, with no piece
+ * run.
+ */
+export type InMemorySplitCall = QuerySplitCall & {
+    /** How many pieces a call cuts, the argument they are cut over and what it weighs. */
+    readonly explain: QuerySplitExplain;
+};
+/**
+ * Builds a split call answered in memory, run as e3 runs one: the request's
+ * programs decoded and compiled with no platform function — a plan's are
+ * platform-free — the partitioned dataset cut into a given number of pieces,
+ * each piece's program run with an `emit` that collects what it emits, the
+ * pieces' outputs assembled by the output kind, and the final function run
+ * once over the assembled output and the arguments.
+ *
+ * @param datasets - The datasets a call may read
+ * @param options - How many pieces the partitioned dataset is cut into
+ * @returns The call, and its `explain`
+ *
+ * @remarks
+ * Each output kind assembles as e3 assembles it (`e3-data-architecture.md`
+ * §3.7), a piece at a time and then across the pieces in input order:
+ * - `array`: each piece's rows, concatenated;
+ * - `set`: their union, in East's order;
+ * - `dict`: by key, a key emitted again folded with `merge(key, a, b)` in
+ *   emission order — within a piece, then across the pieces; without `merge`,
+ *   a key emitted twice fails, naming it;
+ * - `fold`: every value a piece emits folded with `combine`, starting from
+ *   `zero`; then the pieces' partials folded the same way.
+ *
+ * Arguments partitioned together — dicts keyed alike (#942) — are cut at the
+ * same keys: the first key of each run of the one whose beast2 bytes weigh
+ * the most. The assembled output is kept by the SHA-256 of its beast2 bytes,
+ * which the answer gives, and a later call of this stand-in reads it by that
+ * hash as an `object` argument, as e3 reads an earlier call's output.
+ *
+ * With no `then`, the call's value is the assembled output. Its answer is as a
+ * one-shot call's: beast2 at the value's type with each dataset argument
+ * pinned at its hash, `failed` for an East error with its places on stderr,
+ * `invalid` for an argument naming nothing here — a dataset, or an object no
+ * call of this stand-in assembled — or for arguments that cannot be cut
+ * together, and `too_large` over the request's `maxResultBytes`. It reports
+ * each piece done, then the merge or the fold, to `onProgress`, yielding
+ * between pieces, and rejects with the signal's reason once abandoned. The
+ * time limit is not kept.
+ *
+ * Its `explain` answers what e3's explain of the same call does, and runs no
+ * piece (#1132): how many pieces the call cuts — `pieces`, whatever the data —
+ * the argument it cuts them over, by its position — the one partitioned, or of
+ * several, the one whose beast2 bytes weigh the most — and what that argument
+ * weighs: a dataset's weight as its status says it, else its beast2 bytes. It
+ * rejects with an `Error` what the call answers `invalid`, as e3-api-client's
+ * `splitCallExplain` does — "Split call explain refused: …" — reads an object
+ * argument an earlier call of this stand-in assembled, and rejects with the
+ * signal's reason once abandoned.
+ *
+ * @example
+ * ```tsx
+ * const split = createInMemorySplitCall([{ path: ORDERS, type: OrdersType, value: orders }], { pieces: 7 });
+ * return <QuerySplitCallProvider call={split} explain={split.explain}>{surface}</QuerySplitCallProvider>;
+ * ```
+ */
+export declare function createInMemorySplitCall(datasets: readonly InMemoryDataset[], options: InMemorySplitCallOptions): InMemorySplitCall;
+/**
+ * Builds a data source's status answered in memory: how many rows each
+ * dataset holds, its hash, and what it weighs — its beast2 bytes' length, or
+ * the weight a test gives it.
+ *
+ * @param datasets - The datasets
+ * @returns The status
+ *
+ * @remarks
+ * A list's, a set's or a lookup table's rows are its elements; any other
+ * value's are not counted. A path with nothing in memory is refused, as e3
+ * refuses a dataset it does not hold.
+ *
+ * @example
+ * ```tsx
+ * const status = createInMemorySourceStatus([{ path: ORDERS, type: OrdersType, value: orders }]);
+ * return <QuerySourceStatusProvider status={status}>{surface}</QuerySourceStatusProvider>;
+ * ```
+ */
+export declare function createInMemorySourceStatus(datasets: readonly InMemoryDataset[]): QuerySourceStatus;
+//# sourceMappingURL=in-memory-call.d.ts.map

package/dist/query/in-memory-call.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-memory-call.d.ts","sourceRoot":"","sources":["../../src/query/in-memory-call.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAGH,KAAK,QAAQ,EAChB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAEqF,KAAK,QAAQ,EACxG,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,SAAS,EAAE,iBAAiB,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAElG;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC5B,gEAAgE;IAChE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,qBAAqB;IACrB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,iBAAiB;IACjB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,+EAA+E;IAC/E,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,8JAA8J;IAC9J,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CAC3B;AAuDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,CAwBvF;AAED,mDAAmD;AACnD,MAAM,WAAW,wBAAwB;IACrC;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CAC3B;AA8FD;;;;GAIG;AACH,MAAM,MAAM,iBAAiB,GAAG,cAAc,GAAG;IAC7C,sFAAsF;IACtF,QAAQ,CAAC,OAAO,EAAE,iBAAiB,CAAC;CACvC,CAAC;AAOF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,EAAE,OAAO,EAAE,wBAAwB,GAAG,iBAAiB,CA0IlI;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,SAAS,eAAe,EAAE,GAAG,iBAAiB,CAOlG"}

package/dist/query/jq-editor.d.ts

@@ -0,0 +1,34 @@
+import { CheckJqResult } from '@elaraai/east';
+import { SummaryCache } from './model/summaries.js';
+import { QueryRoot } from './one-shot.js';
+import { PartStyles } from './parts.js';
+/** Props of {@link JqEditor}. */
+export interface JqEditorProps {
+    /** The jq as typed. */
+    readonly text: string;
+    /** Its check: east's checker over the root. */
+    readonly checked: CheckJqResult;
+    /** The root: what completions offer, and what the text is read as steps over. */
+    readonly root: QueryRoot;
+    /** The builder's summaries: the values completions offer, where one is held. */
+    readonly summaries: {
+        readonly cache: SummaryCache;
+        readonly hashes: ReadonlyMap<string, string>;
+    };
+    /** The parts' styles, and the words. */
+    readonly ps: PartStyles;
+    /** Told each change of the text. */
+    readonly onText: (text: string) => void;
+    /** Told the focus left the editor: the jq typed, one gesture. */
+    readonly onLeave: () => void;
+    /** Told a fix taken: the text it makes, and its label — one gesture of its own. */
+    readonly onFix: (text: string, label: string) => void;
+}
+/**
+ * Renders the jq view's editor — see the module docs.
+ *
+ * @param props - The text and its check, the root, the summaries, the words and what it tells ({@link JqEditorProps})
+ * @returns The editor
+ */
+export declare const JqEditor: import('react').NamedExoticComponent<JqEditorProps>;
+//# sourceMappingURL=jq-editor.d.ts.map

package/dist/query/jq-editor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jq-editor.d.ts","sourceRoot":"","sources":["../../src/query/jq-editor.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAuCH,OAAO,EAEH,KAAK,aAAa,EACrB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAA2B,KAAK,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAElF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAU,MAAM,YAAY,CAAC;AAoMrD,iCAAiC;AACjC,MAAM,WAAW,aAAa;IAC1B,uBAAuB;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC;IAChC,iFAAiF;IACjF,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,gFAAgF;IAChF,QAAQ,CAAC,SAAS,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;QAAC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,CAAC;IACnG,wCAAwC;IACxC,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,oCAAoC;IACpC,QAAQ,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACxC,iEAAiE;IACjE,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAC;IAC7B,mFAAmF;IACnF,QAAQ,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;CACzD;AAED;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,qDAwWnB,CAAC"}

package/dist/query/library-tab.d.ts

@@ -0,0 +1,33 @@
+import { QueryRoot } from './one-shot.js';
+import { QueryOpen } from './open-query.js';
+import { PartStyles } from './parts.js';
+import { SavedQueries, SavedQuery } from './session.js';
+/** Props of {@link LibraryTab}. */
+export interface LibraryTabProps {
+    /** The saved queries. */
+    readonly record: SavedQueries;
+    /** This viewer's recent runs, the most recent first. */
+    readonly recent: readonly SavedQuery[];
+    /** The root the builder's data sources make. */
+    readonly root: QueryRoot;
+    /** The open query. */
+    readonly open: QueryOpen;
+    /** Opens a saved query. */
+    readonly onOpenSaved: (name: string) => void;
+    /** Opens a recent run never saved, as a new query begun as it. */
+    readonly onOpenRun: (run: SavedQuery) => void;
+    /** The tab's library's id. */
+    readonly id: string;
+    /** The parts' styles, and the words. */
+    readonly ps: PartStyles;
+    /** Where the library keeps its state. */
+    readonly storageKey: string;
+}
+/**
+ * Renders the Library tab — see the module docs.
+ *
+ * @param props - The saved queries, the recent runs, the root, the open query and what a click does ({@link LibraryTabProps})
+ * @returns The tab's notice, and its library
+ */
+export declare const LibraryTab: import('react').NamedExoticComponent<LibraryTabProps>;
+//# sourceMappingURL=library-tab.d.ts.map

package/dist/query/library-tab.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"library-tab.d.ts","sourceRoot":"","sources":["../../src/query/library-tab.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AA2BH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAK7D,mCAAmC;AACnC,MAAM,WAAW,eAAe;IAC5B,yBAAyB;IACzB,QAAQ,CAAC,MAAM,EAAE,YAAY,CAAC;IAC9B,wDAAwD;IACxD,QAAQ,CAAC,MAAM,EAAE,SAAS,UAAU,EAAE,CAAC;IACvC,gDAAgD;IAChD,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,sBAAsB;IACtB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,2BAA2B;IAC3B,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC7C,kEAAkE;IAClE,QAAQ,CAAC,SAAS,EAAE,CAAC,GAAG,EAAE,UAAU,KAAK,IAAI,CAAC;IAC9C,8BAA8B;IAC9B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,wCAAwC;IACxC,QAAQ,CAAC,EAAE,EAAE,UAAU,CAAC;IACxB,yCAAyC;IACzC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC/B;AAED;;;;;GAKG;AACH,eAAO,MAAM,UAAU,uDA+FrB,CAAC"}

package/dist/query/library.d.ts

@@ -0,0 +1,20 @@
+import { ValueTypeOf } from '@elaraai/east';
+import { QueryLibraryComponent } from '@elaraai/e3-ui/internal';
+/** The renderer's payload, decoded. */
+type QueryLibraryValue = ValueTypeOf<typeof QueryLibraryComponent.schema>;
+/** Props of {@link EastChakraQueryLibrary}. */
+export interface EastChakraQueryLibraryProps {
+    /** The payload, decoded. */
+    value: QueryLibraryValue;
+    /** The structural storage key. */
+    storageKey: string;
+}
+/**
+ * Renders the query library — see the module docs.
+ *
+ * @param props - The payload and its storage key
+ * @returns The query library
+ */
+export declare const EastChakraQueryLibrary: import('react').NamedExoticComponent<EastChakraQueryLibraryProps>;
+export {};
+//# sourceMappingURL=library.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"library.d.ts","sourceRoot":"","sources":["../../src/query/library.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAiDH,OAAO,EACoG,KAAK,WAAW,EAC1H,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAsD,MAAM,yBAAyB,CAAC;AAmBpH,uCAAuC;AACvC,KAAK,iBAAiB,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;AA6C1E,+CAA+C;AAC/C,MAAM,WAAW,2BAA2B;IACxC,4BAA4B;IAC5B,KAAK,EAAE,iBAAiB,CAAC;IACzB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;CACtB;AAsHD;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,mEAgBiE,CAAC"}