@elaraai/e3-ui-components 1.0.83 → 1.0.85

package/dist/query/steps/check.d.ts

@@ -0,0 +1,162 @@
+import { EastType } from '@elaraai/east';
+import { StepLayout, StepSlot } from './print.js';
+import { Shape } from './shape.js';
+import { Condition, StepQuery, StepValue } from './values.js';
+/** A jq step's note, in the checker's manner: a part of the program the visual view keeps as jq. */
+export declare const JQ_STEP_NOTE = "custom: not a visual step; it stays as jq in the visual editor.";
+/**
+ * Where a diagnostic is placed in a step besides a condition: a step's
+ * {@link StepSlot}; `cmp` and `inner`, a condition's comparison and inner
+ * condition; `as` and `over`, the names a step gives; `source`, the data
+ * source; `text`, a jq step's text.
+ */
+export type DiagnosticSlot = StepSlot | "cmp" | "inner" | "as" | "over" | "source" | "text";
+/** A fix, as an edit of the steps, which `applyFix` applies. */
+export type StepFix = 
+/** Keep only the rows of a case first: `field is case` at the front of this filter, or a filter of it before this step. */
+{
+    readonly kind: "addCaseCondition";
+    readonly label: string;
+    readonly stepId: string;
+    readonly field: string;
+    readonly case: string;
+}
+/** Use another field in a slot or a condition. */
+ | {
+    readonly kind: "setField";
+    readonly label: string;
+    readonly stepId: string;
+    readonly slot: DiagnosticSlot;
+    readonly condId?: string;
+    readonly id?: string;
+    readonly field: string;
+}
+/** Use another value in a condition. */
+ | {
+    readonly kind: "setValue";
+    readonly label: string;
+    readonly stepId: string;
+    readonly condId: string;
+    readonly value: StepValue;
+}
+/** Compare a variant's case, not the whole value. */
+ | {
+    readonly kind: "unwhole";
+    readonly label: string;
+    readonly stepId: string;
+    readonly condId: string;
+}
+/** Take the step out. */
+ | {
+    readonly kind: "removeStep";
+    readonly label: string;
+    readonly stepId: string;
+}
+/** Edit a jq step's text: the checker's own fix, at offsets in the step's text. */
+ | {
+    readonly kind: "editJq";
+    readonly label: string;
+    readonly stepId: string;
+    readonly edits: readonly {
+        readonly from: number;
+        readonly to: number;
+        readonly insert: string;
+    }[];
+};
+/** A problem in a query's steps, where it is, and how to fix it. */
+export interface StepDiagnostic {
+    /** The step it is in; `""` for the data source. */
+    readonly stepId: string;
+    /** The condition it is in. */
+    readonly condId?: string;
+    /** The slot it is on. */
+    readonly slot?: DiagnosticSlot;
+    /** What the slot is for: a total's id, a field shown's, a field brought in, an input's name. */
+    readonly id?: string;
+    /** An error stops the query running; a warning does not; a note says what a jq step is. */
+    readonly severity: "error" | "warning" | "note";
+    /** The checker's code; `incomplete` for a slot not filled in; `custom` for a jq step; `too_many_rows` for a range a run cuts off. */
+    readonly code: string;
+    /** The checker's sentence, or the steps' own, in jq's words. */
+    readonly message: string;
+    /**
+     * What the builder's plain words need: `field` (the field's ref), `kind`,
+     * `name` and, for a payload's field, `parent`, `case` and `leaf`; `value`
+     * the condition's value; `suggestion` the checker's first; `what` what an
+     * unfinished slot needs; `cmp` and `fn` the comparison and the total;
+     * `dataset` a Look up's data source, with its `kind`; `rows` and `max` a
+     * range's rows and the most a run returns.
+     */
+    readonly context: Readonly<Record<string, string>>;
+    /** Its fixes, best first. */
+    readonly fixes: readonly StepFix[];
+}
+/** One step's shapes, as the check found them. */
+export interface CheckedStepStage {
+    /** The step's id. */
+    readonly stepId: string;
+    /** The shape of the rows it takes. */
+    readonly before: Shape;
+    /** The shape it gives: its input's when it is unfinished or does not check. */
+    readonly after: Shape;
+}
+/** What checking a query's steps found. */
+export interface CheckedSteps {
+    /** The printed program. */
+    readonly program: string;
+    /** The shape the data source gives. */
+    readonly source: Shape;
+    /** Each step's shapes, in order. */
+    readonly stages: readonly CheckedStepStage[];
+    /** The shape the query gives. */
+    readonly final: Shape;
+    /** The problems, by step. */
+    readonly diagnostics: readonly StepDiagnostic[];
+    /** How many are errors. */
+    readonly errors: number;
+    /** How many are warnings, unfinished slots included. */
+    readonly warnings: number;
+    /** The layout the check was made on: the program's ranges, and east's check. */
+    readonly layout: StepLayout;
+}
+/**
+ * The type of a data source of the root.
+ *
+ * @param root - the root's type: a struct of the data sources
+ * @param name - the data source's name
+ * @returns its type, or `undefined` when the root has none of that name
+ */
+export declare function datasetType(root: EastType, name: string): EastType | undefined;
+/**
+ * A condition of a filter by its id, with the rows it tests: the step's, or
+ * a list's items for a condition inside has any where.
+ *
+ * @param conds - the filter's conditions
+ * @param id - the condition's id
+ * @param shape - the rows the filter takes
+ * @returns the condition and the rows it tests, or `undefined` when no condition has that id
+ */
+export declare function conditionIn(conds: readonly Condition[], id: string, shape: Shape): {
+    condition: Condition;
+    shape: Shape;
+} | undefined;
+/**
+ * Checks a query's steps: once, through east's checker, with what the steps
+ * check themselves.
+ *
+ * @param query - the query
+ * @param root - the root's type: a struct of the data sources
+ * @returns the program, each step's shapes, and the diagnostics by step
+ *
+ * @remarks
+ * An unfinished slot is an `incomplete` warning, since an unfinished step is
+ * not in the program. The checker's diagnostics keep their code and message,
+ * placed by span on the step, condition and slot they came from; each jq
+ * step gets a `custom` note. Where the steps find a problem themselves — a
+ * field of the wrong kind in a slot, a comparison the field's kind does not
+ * take, a Look up in a data source that is not a Dict — what the checker
+ * finds in that slot, that condition or that step follows from it and is
+ * left out, so one problem is reported once.
+ */
+export declare function checkSteps(query: StepQuery, root: EastType): CheckedSteps;
+//# sourceMappingURL=check.d.ts.map

package/dist/query/steps/check.d.ts.map

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

package/dist/query/steps/count.d.ts

@@ -0,0 +1,49 @@
+import { ArrayType, IntegerType, EastType, ValueTypeOf } from '@elaraai/east';
+import { StepQuery } from './values.js';
+/** The id a count of the data source's rows is given, beside the steps' ids. */
+export declare const SOURCE_COUNT = "$source";
+/** How many rows a counting run returns, by default. */
+export declare const DEFAULT_MAX_ROWS = 1000;
+/** The counts a counting program gives: one per counted stage. */
+declare const CountsType: ArrayType<IntegerType>;
+/** A counting program, and what its counts count. */
+export interface CountingProgram {
+    /** The program's text. */
+    readonly text: string;
+    /** What each count is of, in order: {@link SOURCE_COUNT}, or a step's id. */
+    readonly counted: readonly string[];
+}
+/**
+ * The program that runs a query and counts each stage's rows.
+ *
+ * @param query - the query
+ * @param root - the root's type: a struct of the data sources
+ * @param options - `maxRows`, how many rows of a rows result to return (1 000 by default)
+ * @returns the program, and what its counts are of
+ *
+ * @remarks
+ * After the data source and each step whose shape is rows, the program binds
+ * `length as $nK`; it ends `{counts: [$n0, …], result: …}`, the result
+ * `.[:maxRows]` when the query gives rows and `.` otherwise. It checks against
+ * the root as the query does.
+ */
+export declare function countingProgram(query: StepQuery, root: EastType, options?: {
+    maxRows?: number;
+}): CountingProgram;
+/**
+ * Reads a counting run's output.
+ *
+ * @param output - what the counting program gave: its counts and its result
+ * @param counted - what each count is of, as {@link countingProgram} gave it
+ * @returns each count, by {@link SOURCE_COUNT} or step id, and the result
+ * @throws {Error} When the counts are not one whole number per counted stage.
+ */
+export declare function readCounts<T>(output: {
+    readonly counts: ValueTypeOf<typeof CountsType>;
+    readonly result: T;
+}, counted: readonly string[]): {
+    counts: ReadonlyMap<string, number>;
+    value: T;
+};
+export {};
+//# sourceMappingURL=count.d.ts.map

package/dist/query/steps/count.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"count.d.ts","sourceRoot":"","sources":["../../../src/query/steps/count.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;GAOG;AAEH,OAAO,EAAE,SAAS,EAAE,WAAW,EAAsB,KAAK,QAAQ,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAG5G,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,gFAAgF;AAChF,eAAO,MAAM,YAAY,YAAY,CAAC;AAEtC,wDAAwD;AACxD,eAAO,MAAM,gBAAgB,OAAO,CAAC;AAErC,kEAAkE;AAClE,QAAA,MAAM,UAAU,wBAAyB,CAAC;AAE1C,qDAAqD;AACrD,MAAM,WAAW,eAAe;IAC5B,0BAA0B;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CACvC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,GAAG,eAAe,CAiBrH;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,CAAC,EACxB,MAAM,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,OAAO,UAAU,CAAC,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAA;CAAE,EAC/E,OAAO,EAAE,SAAS,MAAM,EAAE,GAC3B;IAAE,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAQnD"}

package/dist/query/steps/edit.d.ts

@@ -0,0 +1,108 @@
+import { EastType, option } from '@elaraai/east';
+import { StepFix } from './check.js';
+import { Shape } from './shape.js';
+import { Condition, Match, Step, StepKind, StepQuery, StepValue } from './values.js';
+/**
+ * An empty test, its slots not chosen.
+ *
+ * @param id - its id; a fresh one when omitted
+ * @returns the condition
+ */
+export declare function emptyCondition(id?: string): Condition;
+/**
+ * A query with a step inserted.
+ *
+ * @param query - the query
+ * @param step - the step
+ * @param at - where: before the step at this index; at the end when omitted
+ * @returns the new query
+ */
+export declare function insertStep(query: StepQuery, step: Step, at?: number): StepQuery;
+/** A query without a step. */
+export declare function removeStep(query: StepQuery, stepId: string): StepQuery;
+/**
+ * A query with a step moved.
+ *
+ * @param query - the query
+ * @param stepId - the step
+ * @param by - how many places, up (negative) or down; a move past an end is no move
+ * @returns the new query
+ */
+export declare function moveStep(query: StepQuery, stepId: string, by: number): StepQuery;
+/** A query with a step replaced whole: the step given keeps its place. */
+export declare function updateStep(query: StepQuery, stepId: string, step: Step): StepQuery;
+/**
+ * A query with an empty condition added to a filter, or to a group in it.
+ *
+ * @param query - the query
+ * @param stepId - the filter
+ * @param groupId - the group; the filter itself when omitted
+ * @param id - the new condition's id; a fresh one when omitted
+ * @returns the new query
+ */
+export declare function addCondition(query: StepQuery, stepId: string, groupId?: string, id?: string): StepQuery;
+/**
+ * A query with a group added to a filter, or to a group in it: the opposite
+ * match to where it is, with two empty conditions.
+ *
+ * @param query - the query
+ * @param stepId - the filter
+ * @param groupId - the group it goes in; the filter itself when omitted
+ * @returns the new query
+ */
+export declare function addGroup(query: StepQuery, stepId: string, groupId?: string): StepQuery;
+/** A query without a condition, wherever it is in a filter. */
+export declare function removeCondition(query: StepQuery, stepId: string, condId: string): StepQuery;
+/**
+ * A query with a filter's or a group's match changed. A group inside it of
+ * the same match is no group any more, and its conditions join it.
+ *
+ * @param query - the query
+ * @param stepId - the filter
+ * @param groupId - the group; the filter itself when omitted
+ * @param match - the new match
+ * @returns the new query
+ */
+export declare function setMatch(query: StepQuery, stepId: string, groupId: string | undefined, match: Match): StepQuery;
+/** A query with a condition's value set. */
+export declare function setConditionValue(query: StepQuery, stepId: string, condId: string, value: option<StepValue>): StepQuery;
+/**
+ * A query with a condition's field set. A new field of the kind the old one
+ * was (a whole number and a number are one kind here) keeps the comparison
+ * and the value; another starts from its own comparison (is in year for a
+ * date, has at least 1 for a list, …).
+ *
+ * @param query - the query
+ * @param stepId - the filter
+ * @param condId - the condition
+ * @param field - the new field's ref
+ * @param root - the root's type
+ * @returns the new query
+ */
+export declare function setConditionField(query: StepQuery, stepId: string, condId: string, field: string, root: EastType): StepQuery;
+/**
+ * A query with a fix the check offers applied.
+ *
+ * @param query - the query
+ * @param fix - the fix
+ * @param root - the root's type
+ * @returns the new query
+ *
+ * @remarks
+ * Keep only a case's rows first puts `field is case` at the front of the
+ * filter the problem is in (in place of a case test of that field), and an
+ * any filter becomes all of it and the old conditions as a group; for a step
+ * of another kind, a filter of it goes before the step.
+ */
+export declare function applyFix(query: StepQuery, fix: StepFix, root: EastType): StepQuery;
+/**
+ * A new step of a kind, with the defaults it starts with
+ * (`Query Editor Spec.md` §4.4).
+ *
+ * @param kind - the kind of step
+ * @param before - the shape of the rows it will take
+ * @param root - the root's type, whose lookup tables a Look up starts from
+ * @returns the step, with fresh ids
+ */
+export declare function newStep(kind: StepKind, before: Shape, root: EastType): Step;
+//# sourceMappingURL=edit.d.ts.map

package/dist/query/steps/edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edit.d.ts","sourceRoot":"","sources":["../../../src/query/steps/edit.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;GAMG;AAEH,OAAO,EAEH,KAAK,QAAQ,EAAE,KAAK,MAAM,EAC7B,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAG1C,OAAO,EAAsD,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAC5F,OAAO,EACkC,KAAK,SAAS,EAAE,KAAK,KAAK,EAAE,KAAK,IAAI,EAAE,KAAK,QAAQ,EAAe,KAAK,SAAS,EAAE,KAAK,SAAS,EACzI,MAAM,aAAa,CAAC;AAoCrB;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,EAAE,GAAE,MAA6B,GAAG,SAAS,CAE3E;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,SAAS,CAI/E;AAED,8BAA8B;AAC9B,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAEtE;AAED;;;;;;;GAOG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,CAQhF;AAED,0EAA0E;AAC1E,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,SAAS,CAElF;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,EAAE,GAAE,MAA6B,GAAG,SAAS,CAQ7H;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAStF;AAED,+DAA+D;AAC/D,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,SAAS,CAE3F;AAOD;;;;;;;;;GASG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,KAAK,GAAG,SAAS,CAQ/G;AAUD,4CAA4C;AAC5C,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,GAAG,SAAS,CAEvH;AAmCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,SAAS,CAkB5H;AAuCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,GAAG,SAAS,CA6BlF;AAsCD;;;;;;;;GAQG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,CAkE3E"}

package/dist/query/steps/fields.d.ts

@@ -0,0 +1,101 @@
+import { EastType } from '@elaraai/east';
+import { Shape } from './shape.js';
+import { ComparisonKind } from './values.js';
+/**
+ * What kind of value a field holds, as the builder offers it: text, a whole
+ * number, a number, a date, yes or no, one of some cases, a list, a record,
+ * a lookup table, a calculation, or anything else.
+ */
+export type FieldKind = "text" | "int" | "num" | "date" | "bool" | "case" | "list" | "record" | "dict" | "fn" | "other";
+/** A field a step can name, in a shape. */
+export interface StepField {
+    /** How a step names it: `"total"`, `"status"`, `"status.shipped.date"`. */
+    readonly ref: string;
+    /** The name a step gives a field made from it: `"total"`, `"status"`, `"shipped_date"`. */
+    readonly name: string;
+    /** What kind of value it holds. */
+    readonly kind: FieldKind;
+    /** The type a read of it gives here: a payload field not narrowed to its case is an option. */
+    readonly type: EastType;
+    /** Whether it can be missing: an option, or a payload field not narrowed to its case. */
+    readonly optional: boolean;
+    /** The fields jq reads it through from a row: `["total"]`, `["status", "type"]`, `["status", "value", "date"]`. */
+    readonly path: readonly string[];
+    /** A case field's cases. */
+    readonly cases?: readonly string[];
+    /** A payload field's variant field, the case whose payload has it, its name in the payload, and whether the rows are narrowed to that case. */
+    readonly payload?: {
+        readonly parent: string;
+        readonly case: string;
+        readonly leaf: string;
+        readonly narrowed: boolean;
+    };
+    /** A list's item type. */
+    readonly element?: EastType;
+}
+/**
+ * The kind of value a type holds.
+ *
+ * @param type - a field's type
+ * @returns its kind, read through an option and a recursive wrapper
+ */
+export declare function kindOf(type: EastType): FieldKind;
+/**
+ * The fields of a record, as steps name them: each field; for a variant
+ * field, its case and each field of each struct case's payload.
+ *
+ * @param record - the record's type
+ * @param narrowed - the variant fields narrowed to one case, with the case
+ * @returns the fields, in the record's order, each variant's case before its payloads' fields
+ */
+export declare function fieldsOfRecord(record: EastType, narrowed: ReadonlyMap<string, string>): StepField[];
+/**
+ * The field catalog of a shape: the fields of its rows.
+ *
+ * @param shape - the shape
+ * @returns its rows' fields; none when it is not rows
+ */
+export declare function fieldsOf(shape: Shape): StepField[];
+/**
+ * The field a step names, in a shape.
+ *
+ * @param shape - the shape
+ * @param ref - how the step names it
+ * @returns the field, or `undefined` when the shape has none of that name
+ */
+export declare function fieldByRef(shape: Shape, ref: string): StepField | undefined;
+/**
+ * The fields jq reads a field through, for one the shape does not have: a
+ * name is read as itself, and `parent.case.leaf` as a payload's field, so the
+ * check names what is wrong.
+ *
+ * @param ref - how a step names it
+ * @returns the fields jq reads
+ */
+export declare function pathOfUnknown(ref: string): string[];
+/**
+ * The record each item of a list is, when the items are records.
+ *
+ * @param field - a list field
+ * @returns its item record, or `undefined`
+ */
+export declare function itemRecordOf(field: StepField): EastType | undefined;
+/**
+ * The comparisons a field takes (`Query Editor Spec.md` §4.4): its kind's,
+ * and is missing and has a value for an optional field that is not a
+ * payload's; a list takes has any where only when its items are records.
+ *
+ * @param field - the field
+ * @returns the comparisons, in the order the builder offers them
+ */
+export declare function comparisonsFor(field: StepField): ComparisonKind[];
+/**
+ * The comparison a field starts with when it is picked: is in year for a
+ * date, has at least for a list, is yes for yes or no, is at least for a
+ * number, and is otherwise.
+ *
+ * @param field - the field
+ * @returns the comparison
+ */
+export declare function defaultComparison(field: StepField): ComparisonKind;
+//# sourceMappingURL=fields.d.ts.map

package/dist/query/steps/fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.d.ts","sourceRoot":"","sources":["../../../src/query/steps/fields.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAuD,KAAK,KAAK,EAAE,MAAM,YAAY,CAAC;AAC7F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAElD;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC;AAExH,2CAA2C;AAC3C,MAAM,WAAW,SAAS;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,2FAA2F;IAC3F,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mCAAmC;IACnC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,+FAA+F;IAC/F,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IACxB,yFAAyF;IACzF,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,mHAAmH;IACnH,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,4BAA4B;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC,+IAA+I;IAC/I,QAAQ,CAAC,OAAO,CAAC,EAAE;QAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;KAAE,CAAC;IACzH,0BAA0B;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC;CAC/B;AAED;;;;;GAKG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAehD;AAkBD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EAAE,CAkCnG;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,SAAS,EAAE,CAElD;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAE3E;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CAGnD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS,CAInE;AAgBD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,EAAE,CAIjE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,CAQlE"}

package/dist/query/steps/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The query builder's canonical steps (#933): the step algebra behind the
+ * builder, with no rendering in it — steps printed as canonical jq and parsed
+ * back, checked with every diagnostic on its step, condition and slot, edited,
+ * and counted. The builder and the query library import it; the package's
+ * index does not export it.
+ *
+ * @packageDocumentation
+ */
+export { comparison, freshId, isComplete, isConditionComplete, isGiven, needsValue, type Aggregate, type Comparison, type ComparisonKind, type Condition, type GroupCondition, type IdKind, type Match, type PickField, type Step, type StepInput, type StepKind, type StepOf, type StepQuery, type StepValue, type TestCondition, } from './values.js';
+export { UNKNOWN, baseType, optionPayload, orMissing, rowOf, shapeOf, singular, unwrapRecursive, type Shape, type ShapeKind } from './shape.js';
+export { comparisonsFor, defaultComparison, fieldByRef, fieldsOf, fieldsOfRecord, itemRecordOf, kindOf, pathOfUnknown, type FieldKind, type StepField, } from './fields.js';
+export { itemShape, layOutSteps, printSteps, type ConditionRange, type LaidOutSegment, type LaidOutStep, type PrintedSteps, type SlotRange, type StepLayout, type StepRange, type StepSlot, } from './print.js';
+export { defaultTotalName, parseSteps, type StepParseError } from './parse.js';
+export { checkSteps, conditionIn, datasetType, type CheckedStepStage, type CheckedSteps, type DiagnosticSlot, type StepDiagnostic, type StepFix, } from './check.js';
+export { addCondition, addGroup, applyFix, emptyCondition, insertStep, moveStep, newStep, removeCondition, removeStep, setConditionField, setConditionValue, setMatch, updateStep, } from './edit.js';
+export { DEFAULT_MAX_ROWS, SOURCE_COUNT, countingProgram, readCounts, type CountingProgram } from './count.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/query/steps/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/query/steps/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AAEH,OAAO,EACH,UAAU,EAAE,OAAO,EAAE,UAAU,EAAE,mBAAmB,EAAE,OAAO,EAAE,UAAU,EACzE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,KAAK,cAAc,EAAE,KAAK,SAAS,EAAE,KAAK,cAAc,EAAE,KAAK,MAAM,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAClI,KAAK,IAAI,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,KAAK,MAAM,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAE,KAAK,aAAa,GAC5G,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAAE,MAAM,YAAY,CAAC;AAChJ,OAAO,EACH,cAAc,EAAE,iBAAiB,EAAE,UAAU,EAAE,QAAQ,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,EAAE,aAAa,EAC5G,KAAK,SAAS,EAAE,KAAK,SAAS,GACjC,MAAM,aAAa,CAAC;AACrB,OAAO,EACH,SAAS,EAAE,WAAW,EAAE,UAAU,EAClC,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,WAAW,EAAE,KAAK,YAAY,EAAE,KAAK,SAAS,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,KAAK,QAAQ,GAChJ,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,KAAK,cAAc,EAAE,MAAM,YAAY,CAAC;AAC/E,OAAO,EACH,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,KAAK,YAAY,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,OAAO,GACzI,MAAM,YAAY,CAAC;AACpB,OAAO,EACH,YAAY,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,UAAU,EAAE,QAAQ,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,iBAAiB,EAC/H,iBAAiB,EAAE,QAAQ,EAAE,UAAU,GAC1C,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,eAAe,EAAE,UAAU,EAAE,KAAK,eAAe,EAAE,MAAM,YAAY,CAAC"}

package/dist/query/steps/jq.d.ts

@@ -0,0 +1,188 @@
+import { EastType, JqNode } from '@elaraai/east';
+import { StepValue } from './values.js';
+/**
+ * A child's path, as the parser and the printer key a node's span: the
+ * parent's path, then the step to the child.
+ *
+ * @param path - the parent's path, `""` for the root
+ * @param step - the steps to the child: `"pipe.left"`, `"call.args[0]"`, …; `""` for the node itself
+ * @returns the child's path
+ */
+export declare function at(path: string, step: string): string;
+/**
+ * Whether a name can name a jq variable.
+ *
+ * @param name - the name
+ * @returns whether `$name` reads as a variable
+ */
+export declare function isVariableName(name: string): boolean;
+/** `.` */
+export declare const IDENTITY: JqNode;
+/** `target.name` */
+export declare function fieldNode(target: JqNode, name: string): JqNode;
+/**
+ * The read of a field path: `.a.b` from `.`, or from another node.
+ *
+ * @param names - the fields read, outermost first
+ * @param from - what they are read from; `.` by default
+ * @returns the node
+ */
+export declare function pathNode(names: readonly string[], from?: JqNode): JqNode;
+/** `left | right` */
+export declare function pipe(left: JqNode, right: JqNode): JqNode;
+/**
+ * Segments piped in order, as the parser nests them: `a | (b | c)`.
+ *
+ * @param nodes - the segments, one or more
+ * @returns the pipe
+ */
+export declare function pipeAll(nodes: readonly JqNode[]): JqNode;
+/**
+ * The path of the `i`th of `n` segments piped by {@link pipeAll}, relative
+ * to the pipe.
+ *
+ * @param i - the segment's index
+ * @param n - how many segments
+ * @returns its path
+ */
+export declare function pipedPath(i: number, n: number): string;
+/** `name(args…)` */
+export declare function call(name: string, args?: readonly JqNode[]): JqNode;
+/** `left op right` */
+export declare function binary(left: JqNode, op: string, right: JqNode): JqNode;
+/**
+ * Operands joined by one operator, as the parser nests them: `(a and b) and c`.
+ *
+ * @param operands - the operands, one or more
+ * @param op - `and` or `or`
+ * @returns the chain
+ */
+export declare function chain(operands: readonly JqNode[], op: string): JqNode;
+/**
+ * The path of the `i`th of `n` operands joined by {@link chain}, relative to
+ * the chain.
+ *
+ * @param i - the operand's index
+ * @param n - how many operands
+ * @returns its path
+ */
+export declare function chainedPath(i: number, n: number): string;
+/** `-operand` */
+export declare function negate(operand: JqNode): JqNode;
+/** `$name` */
+export declare function variable(name: string): JqNode;
+/**
+ * `{key: value, key, …}`: each entry a name, with a value or none.
+ *
+ * @param entries - the entries
+ * @returns the object
+ */
+export declare function objectNode(entries: readonly {
+    key: string;
+    value?: JqNode;
+}[]): JqNode;
+/** `[body]`, or `[]` with no body. */
+export declare function arrayNode(body?: JqNode): JqNode;
+/**
+ * Outputs one after another, as the parser nests them: `(a, b), c`.
+ *
+ * @param nodes - the outputs, one or more
+ * @returns the comma
+ */
+export declare function commaAll(nodes: readonly JqNode[]): JqNode;
+/** `target[]` */
+export declare function iterate(target: JqNode): JqNode;
+/** `target[key]` */
+export declare function index(target: JqNode, key: JqNode): JqNode;
+/** `target[:to]` */
+export declare function sliceTo(target: JqNode, to: JqNode): JqNode;
+/** `source as $name | body` */
+export declare function bind(source: JqNode, name: string, body: JqNode): JqNode;
+/** `path op value`, for an update operator */
+export declare function updateNode(path: JqNode, op: string, value: JqNode): JqNode;
+/** A String literal. */
+export declare function stringLiteral(text: string): JqNode;
+/** An Integer literal. */
+export declare function integerLiteral(n: bigint): JqNode;
+/** A Float literal. */
+export declare function floatLiteral(x: number): JqNode;
+/** A Boolean literal. */
+export declare function booleanLiteral(b: boolean): JqNode;
+/** `null` */
+export declare function nullLiteral(): JqNode;
+/**
+ * A number as jq writes it: an Integer when it is whole, which a Float
+ * compares with as its own, and a Float otherwise.
+ *
+ * @param x - the number
+ * @returns the literal
+ */
+export declare function numberLiteral(x: number): JqNode;
+/**
+ * The literal of a step's value.
+ *
+ * @param value - the value
+ * @returns its literal
+ */
+export declare function valueLiteral(value: StepValue): JqNode;
+/**
+ * The fields a node reads in a row, from `.`: `.a.b` gives `["a", "b"]`.
+ *
+ * @param node - the node
+ * @param from - what the reads start from; `.` when omitted, else a test of the base node
+ * @returns the names, or `undefined` when the node is not a plain path
+ */
+export declare function readPath(node: JqNode, from?: (base: JqNode) => boolean): string[] | undefined;
+/**
+ * A call's arguments.
+ *
+ * @param node - the node
+ * @param name - the function's name
+ * @param arity - how many arguments
+ * @returns the arguments, or `undefined` when the node is not that call
+ */
+export declare function readCall(node: JqNode, name: string, arity: number): JqNode[] | undefined;
+/**
+ * A literal's value, with its type.
+ *
+ * @param node - the node
+ * @returns the type and value, or `undefined` when it is not a literal
+ */
+export declare function readLiteral(node: JqNode): {
+    type: EastType;
+    value: unknown;
+} | undefined;
+/**
+ * A literal as a step's value: text, a number, yes or no, or nothing.
+ *
+ * @param node - the node
+ * @returns the value, or `undefined` when it is not a literal
+ */
+export declare function readStepValue(node: JqNode): StepValue | undefined;
+/**
+ * A pipe's segments, in order.
+ *
+ * @param node - the node
+ * @returns the segments; the node alone when it is no pipe
+ */
+export declare function readPipe(node: JqNode): JqNode[];
+/**
+ * An object's entries, when every key is a name.
+ *
+ * @param node - the node
+ * @returns each entry's key and value, or `undefined` when it is no such object
+ */
+export declare function readObject(node: JqNode): {
+    key: string;
+    value: JqNode | undefined;
+}[] | undefined;
+/**
+ * The operands of a chain of one operator, as {@link chain} builds it: the
+ * left side read down while it is the same operator.
+ *
+ * @param node - the node
+ * @param op - `and` or `or`
+ * @returns the operands; the node alone when it is no such chain
+ */
+export declare function readChain(node: JqNode, op: string): JqNode[];
+//# sourceMappingURL=jq.d.ts.map