@luzmo/analytics-components-kit 1.0.5-beta.2 → 1.0.5

package/angular/utils/formula/base/formula-input-base.d.ts

@@ -0,0 +1,62 @@
+import type { Completion } from '@codemirror/autocomplete';
+import '@luzmo/lucero/progress-circle';
+import { type PropertyValues, type TemplateResult } from 'lit';
+import { FormulaEditorStore } from '../store/formula-editor-store';
+import { LuzmoFormulaBase } from './formula-base';
+/**
+ * Shared base for the editable formula surfaces (`luzmo-formula-field` and
+ * `luzmo-formula-editor`). Extends `LuzmoFormulaBase` with the input-specific
+ * surface: the editable-input sizing/placeholder/readonly properties and the
+ * rendering + change handling of the (lazily-loaded) CodeMirror input.
+ *
+ * The read-only display (`luzmo-formula`) extends `LuzmoFormulaBase` directly,
+ * so it never exposes these editing-only properties.
+ *
+ * Not a registered element - abstract base only.
+ */
+export declare abstract class LuzmoFormulaInputBase extends LuzmoFormulaBase<FormulaEditorStore> {
+    /** Autocompletion options offered while typing in the (lazily-loaded) CodeMirror input. */
+    protected _autoCompletionList: Completion[];
+    constructor();
+    /** The editable surfaces use the full (CodeMirror-backed) editor store. */
+    protected _createStore(): FormulaEditorStore;
+    /** Renders the field display-only (no editing). */
+    readonly: boolean;
+    /** Placeholder text shown in the editable input when the expression is empty. */
+    placeholder: string;
+    /** Number of text lines the input is sized to start with. Defaults to 3. */
+    rows: number;
+    /** Maximum number of text lines before a scrollbar appears (only when `grows`). */
+    maxRows?: number;
+    /** Whether the input grows in height with its content (up to `maxRows` if set). */
+    grows: boolean;
+    protected willUpdate(changedProperties: PropertyValues): void;
+    /** Rebuilds the CodeMirror autocompletion list from the current datasets. */
+    protected _rebuildAutoCompletion(): void;
+    /**
+     * Syncs the external expression into the store, then pushes the resolved root
+     * content into the (root) CodeMirror editor - either the live view or, before
+     * it exists, the input element.
+     */
+    protected _applyExternalExpression(): void;
+    protected _handleInputContentChanged(event: CustomEvent<{
+        content: string;
+    }>): void;
+    /**
+     * Renders the (lazily-loaded) CodeMirror input. While the module loads, a
+     * same-sized placeholder with a centered spinner is shown instead of `nothing`,
+     * so the input reserves its space and the surrounding layout doesn't shift in.
+     */
+    protected _renderFormulaCodeMirror(options?: {
+        part?: string;
+        hasError?: boolean;
+    }): TemplateResult;
+    /**
+     * A placeholder matching the CodeMirror input's box (border, radius and
+     * `rows`-based height) shown while the editor module loads, so swapping in the
+     * real input causes no content shift. The bottom radius follows
+     * `--luzmo-formula-field-bottom-radius`, which the editor squares off so the
+     * placeholder lines up with the lists below exactly like the loaded input.
+     */
+    private _renderInputLoadingPlaceholder;
+}

package/angular/utils/formula/codemirror/actions.d.ts

@@ -0,0 +1,47 @@
+import type { EditorView } from '@codemirror/view';
+/**
+ * Replaces the entire document content. Used to set the initial / external expression.
+ *
+ * The cursor is kept at its current offset (clamped to the new length) instead of
+ * being remapped through the full-document replacement, which would otherwise
+ * collapse it to the document start. This matters when the host re-applies the
+ * `expression` while the user is editing: their caret must stay where it was so a
+ * subsequent insertion still lands at that spot rather than at the start / end.
+ */
+export declare function setEditorContent(view: EditorView, content: string): void;
+/**
+ * Inserts content at the current selection (replacing any selected text), and
+ * places the cursor right after the inserted content.
+ *
+ * The selection is read *before* focusing: refocusing a blurred editor (e.g. after
+ * double-clicking a column / function in one of the side lists, which moves focus
+ * out of the editor) can let the browser move the caret to the end of the content,
+ * so we pin the insertion to the range the user's cursor was actually at.
+ */
+export declare function insertAtSelection(view: EditorView, content: string): void;
+/**
+ * Replaces a range of the document (defaults to the whole document) with new content.
+ */
+export declare function replaceContent(view: EditorView, data: {
+    positionInDocument?: {
+        from: number;
+        to: number;
+    };
+    withContent: string;
+}): void;
+/**
+ * Moves the cursor to the document position nearest to the given screen coordinates.
+ */
+export declare function setCursorAtCoordinates(view: EditorView, coordinates: {
+    x: number;
+    y: number;
+}): void;
+/**
+ * Moves the cursor to the given document position.
+ */
+export declare function setCursorAtPosition(view: EditorView, position: number): void;
+/**
+ * Replaces an empty argument token (`##EMPTYARG-<emptyArgumentId>##`) with the
+ * provided content and places the cursor right after the inserted content.
+ */
+export declare function updateEmptyArgument(view: EditorView, withContent: string, emptyArgumentId: string): void;

package/angular/utils/formula/codemirror/drop-cursor.d.ts

@@ -0,0 +1,15 @@
+import { type Extension } from '@codemirror/state';
+import { EditorView } from '@codemirror/view';
+/**
+ * Editor extension that renders a drop caret at the position set via
+ * {@link showDropCursorAt}. Use instead of CodeMirror's `dropCursor()` when the
+ * drag is handled by pragmatic drag-and-drop rather than native drag events.
+ */
+export declare function formulaDropCursor(): Extension;
+/** Shows the drop caret at the document position nearest the given coordinates. */
+export declare function showDropCursorAt(view: EditorView, coordinates: {
+    x: number;
+    y: number;
+}): void;
+/** Hides the drop caret if it is currently shown. */
+export declare function clearDropCursor(view: EditorView): void;

package/angular/utils/formula/codemirror/icon-element.d.ts

@@ -0,0 +1,7 @@
+import type { IconDefinition } from '@luzmo/icons';
+/**
+ * Builds an inline `<svg>` element (filled with `currentColor`) from a Luzmo icon
+ * definition, for use in plain-DOM contexts such as CodeMirror autocompletion
+ * options and info tooltips (which cannot render Lit templates).
+ */
+export declare function createIconSvg(definition: IconDefinition): SVGElement;

package/angular/utils/formula/codemirror/parser.d.ts

@@ -0,0 +1,16 @@
+import type { Range } from '@codemirror/state';
+import { Decoration } from '@codemirror/view';
+import type { FormulaEditorStore } from '../store/formula-editor-store';
+import type { FormulaEditorDataset } from '../../../types/formula.types';
+export interface ParseOptions {
+    store: FormulaEditorStore;
+    datasets: FormulaEditorDataset[];
+    contentLanguage: string;
+    parentAggregationWidgetId: string | null;
+    multiStageAggregation: boolean;
+}
+/**
+ * Scans the document and builds the set of replace-decorations for every
+ * column reference, empty argument and aggregation widget placeholder it finds.
+ */
+export declare function buildDecorations(doc: string, options: ParseOptions): Range<Decoration>[];

package/angular/utils/formula/codemirror/tests/actions.test.d.ts

@@ -0,0 +1 @@
+export {};

package/angular/utils/formula/codemirror/theme.d.ts

@@ -0,0 +1,20 @@
+interface StyleSpec {
+    [property: string]: string | number | StyleSpec;
+}
+type ThemeSpec = Record<string, StyleSpec>;
+export declare const baseFormulaEditorTheme: ThemeSpec;
+/**
+ * Styling for the autocompletion dropdown and its info (hint) panel. Applied via
+ * `EditorView.theme` (which outranks the library's base theme) so sizing, spacing
+ * and font-size follow the editor size and colors come from the global tokens.
+ */
+export declare const formulaEditorAutocompleteTheme: ThemeSpec;
+export declare function createFormulaEditorDynamicTheme(options: {
+    rows?: number;
+    maxRows?: number;
+    grows?: boolean;
+    editorHeight?: string;
+    hasError?: boolean;
+    singleLine?: boolean;
+}): ThemeSpec;
+export {};

package/angular/utils/formula/codemirror/widget.d.ts

@@ -0,0 +1,18 @@
+import { WidgetType } from '@codemirror/view';
+import type { FormulaEditorStore } from '../store/formula-editor-store';
+import type { FormulaEditorWidgetConfig } from '../../../types/formula.types';
+/**
+ * A CodeMirror widget that renders a formula editor pill in place of its
+ * placeholder text: an inline column pill (built directly as DOM, mirroring
+ * `luzmo-formula`'s display markup) or one of the pill custom elements
+ * (`luzmo-formula-empty-argument-pill` / `luzmo-formula-aggregation`).
+ */
+export declare class FormulaPillWidget extends WidgetType {
+    private readonly config;
+    private readonly store;
+    private _element?;
+    constructor(config: FormulaEditorWidgetConfig, store: FormulaEditorStore);
+    toDOM(): HTMLElement;
+    eq(other: FormulaPillWidget): boolean;
+    ignoreEvent(): boolean;
+}

package/angular/utils/formula/config/aggregations.d.ts

@@ -0,0 +1,9 @@
+import type { FormulaAggregationFunction, FormulaAggregationFunctionData } from '../../../types/formula.types';
+/**
+ * The aggregation functions shown in the aggregations list, in display order.
+ */
+export declare const formulaAggregationFunctions: FormulaAggregationFunction[];
+/**
+ * Returns the localized metadata for every aggregation function.
+ */
+export declare function getFormulaAggregationFunctionsDataMap(): Record<FormulaAggregationFunction, FormulaAggregationFunctionData>;

package/angular/utils/formula/config/build-datasets.d.ts

@@ -0,0 +1,10 @@
+import type { DatasetWithDataFields } from '../../transformations/convert-datasets-to-data-fields';
+import type { DatasetDataFields } from '../../../components/data-field-panel/types';
+import type { FormulaEditorDataset } from '../../../types/formula.types';
+/**
+ * Normalizes datasets provided directly (`DatasetDataFields`) or fetched from the
+ * Luzmo API (`DatasetWithDataFields`) into the {@link FormulaEditorDataset} shape
+ * consumed by the formula input and store. When more than one dataset is present,
+ * each gets an accent color from the shared palette.
+ */
+export declare function buildFormulaEditorDatasets(input: (DatasetDataFields | DatasetWithDataFields)[]): FormulaEditorDataset[];

package/angular/utils/formula/config/expression-helpers.d.ts

@@ -0,0 +1,42 @@
+import { type FormulaAggregationFunction, type FormulaAggregationFunctionData, type FormulaAggregationWidgetData } from '../../../types/formula.types';
+/**
+ * Generates a unique id, preferring the native crypto API when available.
+ */
+export declare function generateId(): string;
+/**
+ * Returns the placeholder token for a new empty argument.
+ */
+export declare function getEmptyArgumentDropExpression(): string;
+/**
+ * Returns the placeholder token for an aggregation widget.
+ */
+export declare function getAggregationWidgetExpression(aggregationWidgetId: string): string;
+/**
+ * Renders the persisted aggregation widget state back into a formula expression.
+ */
+export declare function getAggregationFunctionExpression(aggregationWidgetData: FormulaAggregationWidgetData | undefined, aggregationFunctionsDataMap: Record<FormulaAggregationFunction, FormulaAggregationFunctionData>): string;
+/**
+ * Replaces the content of every string literal with spaces, keeping the quote
+ * characters and the overall length (and thus every index) intact. Run a syntax
+ * scan (e.g. an aggregation-function regex) against the masked string so matches
+ * inside literals - like `'SUM(x)'` - are ignored, then slice the original.
+ */
+export declare function maskStringLiterals(expression: string): string;
+/**
+ * Finds the index of the closing parenthesis that matches the (implicit) open
+ * parenthesis preceding `startIndex`. Returns -1 when no match is found.
+ */
+export declare function getClosingParenthesisIndex(expression: string, startIndex?: number): number;
+/**
+ * Parses the include / exclude column lists out of a `GROUPINEX(...)` tail
+ * expression of the form `[<included>], [<excluded>]`.
+ */
+export declare function getIncludeExcludeColumnsFromExpression(expression: string): {
+    includedColumns: string[];
+    excludedColumns: string[];
+};
+/**
+ * Returns the color palette used to color-code datasets when more than one
+ * dataset is present.
+ */
+export declare function getColorPalette(theme?: 'dark' | 'light'): string[];

package/angular/utils/formula/config/functions.d.ts

@@ -0,0 +1,3 @@
+import type { FormulaFunctionCategory, FormulaFunction, FormulaFunctionData } from '../../../types/formula.types';
+export declare function getFormulaFunctionCategories(): FormulaFunctionCategory[];
+export declare function getFormulaFunctionDataMap(): Record<FormulaFunction, FormulaFunctionData>;

package/angular/utils/formula/config/groupings.d.ts

@@ -0,0 +1,9 @@
+import { FormulaAggregationGrouping, type FormulaAggregationGroupingData } from '../../../types/formula.types';
+/**
+ * The grouping scopes shown in the aggregation widget grouping selector, in display order.
+ */
+export declare const formulaAggregationGroupings: FormulaAggregationGrouping[];
+/**
+ * Returns the localized metadata for every aggregation grouping scope.
+ */
+export declare function getFormulaAggregationGroupingsDataMap(): Record<FormulaAggregationGrouping, FormulaAggregationGroupingData>;

package/angular/utils/formula/config/regex.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Regular expressions used to tokenize and transform formula expressions.
+ *
+ * Tokens used internally by the editor:
+ * - `##EMPTYARG-<uuid>##`  -> an empty argument awaiting input
+ * - `{<datasetId>:<columnId>}` -> a column reference
+ * - `##AGGR-<uuid>##`  -> an aggregation widget placeholder
+ */
+/**
+ * Matches an empty argument, a column reference, or an aggregation widget placeholder.
+ * Capture groups: 1 = emptyArgumentId, 2 = `datasetId:columnId`, 3 = aggregationWidgetId.
+ */
+export declare const regexpToMatchEmptyArgumentOrColumnOrAggregationWidget: RegExp;
+/**
+ * Matches an empty argument or a column reference (no aggregation widgets).
+ * Capture groups: 1 = emptyArgumentId, 2 = `datasetId:columnId`.
+ */
+export declare const regexpToMatchEmptyArgumentOrColumn: RegExp;
+/**
+ * Matches the start of an aggregation function, optionally wrapped in a grouping function.
+ * Capture groups: 1 = grouping wrapper incl. `(`, 2 = grouping name, 3 = aggregation function.
+ */
+export declare const regexpToMatchAggregationFunctionStart: RegExp;
+/**
+ * Matches an aggregation function that has no arguments (an empty aggregation).
+ */
+export declare const regexpToMatchEmptyAggregationFunction: RegExp;
+/**
+ * Matches a single aggregation widget placeholder. Capture group 1 = aggregationWidgetId.
+ */
+export declare const regexpToMatchAggregationWidget: RegExp;
+/**
+ * Matches array content (used to parse the include / exclude column lists).
+ */
+export declare const regexpToMatchArrayContent: RegExp;
+/**
+ * Matches a column reference `{datasetId:columnId}`.
+ */
+export declare const regexpToMatchColumn: RegExp;

package/angular/utils/formula/config/resolve-column-presentation.d.ts

@@ -0,0 +1,19 @@
+import type { IconDefinition } from '@luzmo/icons';
+import type { DatasetDataField } from '../../../types/dataset-data-field.types';
+/** The shared presentation (data-type icon + localized label) of a column reference. */
+export interface ColumnPresentation {
+    icon: IconDefinition;
+    label: string;
+}
+/**
+ * Resolves how a column reference is presented in the formula surfaces: its
+ * data-type icon and its localized label. Shared by the read-only display
+ * (`luzmo-formula`) and the CodeMirror column-pill widget so both render columns
+ * identically. Stays CodeMirror-free so the display path can use it too.
+ *
+ * @param column The resolved column (from the datasets), or `undefined` when it
+ *   could not be resolved yet (datasets still loading / unknown id).
+ * @param contentLanguage The locale used to pick the column name.
+ * @param fallbackLabel The label to show when the column is unresolved (the column id).
+ */
+export declare function resolveColumnPresentation(column: Pick<DatasetDataField, 'type' | 'subtype' | 'lowestLevel' | 'name'> | undefined, contentLanguage: string, fallbackLabel: string): ColumnPresentation;

package/angular/utils/formula/config/tests/build-datasets.test.d.ts

@@ -0,0 +1 @@
+export {};

package/angular/utils/formula/config/validate-expression.d.ts

@@ -0,0 +1,19 @@
+import type { FormulaAggregationFunction, FormulaAggregationFunctionData, FormulaFunction, FormulaFunctionData } from '../../../types/formula.types';
+/**
+ * Builds the set of word identifiers (upper-cased) that may legitimately appear
+ * as bare text in a resolved formula expression: the function and aggregation
+ * names, the grouping wrappers, the `CAST` target types and the literal
+ * keywords. Columns are never bare (they are `{datasetId:columnId}` placeholders),
+ * so any other word is unresolved free text.
+ */
+export declare function getValidFormulaWordIdentifiers(functionDataMap: Record<FormulaFunction, FormulaFunctionData>, aggregationFunctionDataMap: Record<FormulaAggregationFunction, FormulaAggregationFunctionData>): Set<string>;
+/**
+ * Scans a resolved (function-syntax) expression for the first bare word that is
+ * not a known function, aggregation, grouping wrapper, cast type or literal -
+ * i.e. unresolved free text such as a half-typed column name. Returns that word,
+ * or `null` when every word resolves to a valid identifier.
+ *
+ * String literals and column placeholders are stripped first so their contents
+ * are never mistaken for unresolved identifiers.
+ */
+export declare function findUnresolvedToken(expression: string, validWordIdentifiers: Set<string>): string | null;

package/angular/utils/formula/load-formula-codemirror.d.ts

@@ -0,0 +1,4 @@
+/** Loads (and registers) `luzmo-formula-codemirror` once, returning the same promise on repeat calls. */
+export declare function ensureFormulaCodeMirrorLoaded(): Promise<void>;
+/** Whether the formula CodeMirror module has finished loading. */
+export declare function isFormulaCodeMirrorLoaded(): boolean;

package/angular/utils/formula/render-explanation-tooltip.d.ts

@@ -0,0 +1,7 @@
+import { nothing, type TemplateResult } from 'lit';
+/**
+ * Builds the rich tooltip body (description + optional formula example with
+ * inline column-type icons) slotted into a `luzmo-formula-draggable-field`'s `tooltip`
+ * slot. Returns `nothing` when there is no content to show.
+ */
+export declare function renderExplanationTooltip(description: string, example: string, exampleHasIcons: boolean): TemplateResult | typeof nothing;

package/angular/utils/formula/store/formula-display-store.d.ts

@@ -0,0 +1,87 @@
+import type { ElementSize } from '../../base';
+import { type FormulaAggregationFunction, type FormulaAggregationFunctionData, type FormulaAggregationWidgetData, type FormulaEditorDataset, type FormulaFunction, type FormulaFunctionData } from '../../../types/formula.types';
+/**
+ * Display-safe core of the formula store, shared by the read-only `luzmo-formula`
+ * display and (through {@link FormulaEditorStore}) the editable surfaces.
+ *
+ * It owns everything a static rendering needs - the persisted aggregation-widget
+ * data, the operation data maps and the pure expression transforms - without any
+ * dependency on CodeMirror. The editable surfaces add the CodeMirror editor
+ * registry, expression insertion and autocompletion in the {@link FormulaEditorStore}
+ * subclass, which is the only part of the formula family that pulls CodeMirror in.
+ *
+ * It extends `EventTarget` so pill widgets and the container can subscribe to
+ * `widgets-changed` (aggregation widget state changed) updates.
+ */
+export declare class FormulaDisplayStore extends EventTarget {
+    readonly functionDataMap: Record<FormulaFunction, FormulaFunctionData>;
+    readonly aggregationFunctionDataMap: Record<FormulaAggregationFunction, FormulaAggregationFunctionData>;
+    /** When true, aggregations are rendered as nested aggregation widgets. */
+    multiStageAggregation: boolean;
+    /** When true, aggregations can be dropped inside another aggregation. */
+    nestedAggregation: boolean;
+    /** When true, the editor is read-only: inline pills cannot be edited or opened. */
+    readonly: boolean;
+    /** Language used to localize column names (for autocomplete and pills). */
+    contentLanguage: string;
+    /** Editor size, threaded into pills so their detail dropdowns (e.g. the include/exclude panel) scale with the editor. */
+    size: ElementSize;
+    /** Datasets available to the editor (used by transforms and autocomplete). */
+    datasets: FormulaEditorDataset[];
+    /** True while the editor is fetching datasets from `datasetIds`; column pills show a loading state. */
+    loading: boolean;
+    /** Id of the aggregation widget whose editor was focused last (null = root). */
+    lastFocusedAggregationWidgetId: string | null;
+    /**
+     * Id of the empty-argument pill that was focused last. Inserting from the side
+     * lists (double-click / activate) blurs the pill before the insert runs, so the
+     * editor's caret is no longer inside it; remembering the pill lets the insert
+     * fill that argument instead of dropping at the (stale) caret. Set when a pill
+     * gains focus and cleared once the editor content itself is focused (i.e. a real
+     * caret is placed).
+     */
+    lastFocusedEmptyArgumentId: string | null;
+    /**
+     * Id of an aggregation widget that was just created (via a list insert or
+     * autocomplete) and whose nested input should grab focus once rendered, so the
+     * user can keep typing into it. Only set for aggregations that accept content
+     * (arity > 0) and cleared by the pill after it focuses.
+     */
+    pendingFocusAggregationWidgetId: string | null;
+    private _aggregationWidgets;
+    get aggregationWidgets(): FormulaAggregationWidgetData[];
+    addWidgets(widgets: FormulaAggregationWidgetData[]): void;
+    removeWidgets(widgetIds: string[]): void;
+    updateWidget(widget: FormulaAggregationWidgetData): void;
+    getWidget(widgetId: string): FormulaAggregationWidgetData | undefined;
+    clearWidgets(): void;
+    protected _notifyWidgetsChanged(): void;
+    /**
+     * Toggles read-only and notifies mounted pills so their (already-rendered)
+     * controls re-render disabled / enabled. Setting the field directly (e.g. at
+     * construction) is fine; use this when toggling after pills exist.
+     */
+    setReadonly(value: boolean): void;
+    /**
+     * Toggles the dataset-loading flag and asks any listeners to rebuild their pill
+     * decorations, so column pills can reflect the loading state (a spinner while
+     * the column label is being resolved).
+     */
+    setLoading(value: boolean): void;
+    /**
+     * Flags a just-created aggregation widget so its nested input grabs focus once
+     * rendered, but only when the aggregation accepts content (arity > 0); e.g.
+     * COUNTR (arity 0) has no input to type into.
+     */
+    protected _markAggregationForFocus(widgets: FormulaAggregationWidgetData[]): void;
+    /**
+     * Replaces every aggregation function in the expression with an aggregation
+     * widget placeholder (`##AGGR-<id>##`), registering the parsed widget data.
+     */
+    transformToAggregationWidgetSyntax(expression: string): string;
+    /**
+     * Replaces every aggregation widget placeholder with the rendered aggregation
+     * function expression, recursively resolving nested widgets.
+     */
+    transformToAggregationFunctionSyntax(expression: string): string;
+}

package/angular/utils/formula/store/formula-editor-context.d.ts

@@ -0,0 +1,8 @@
+import type { FormulaEditorStore } from './formula-editor-store';
+/**
+ * Context used to share a single {@link FormulaEditorStore} instance from the
+ * root `luzmo-formula-editor` down to nested inputs and pill widgets.
+ */
+export declare const formulaEditorContext: {
+    __context__: FormulaEditorStore;
+};

package/angular/utils/formula/store/formula-editor-store.d.ts

@@ -0,0 +1,46 @@
+import type { Completion } from '@codemirror/autocomplete';
+import type { EditorView } from '@codemirror/view';
+import { FormulaDisplayStore } from './formula-display-store';
+import { type ExtendExpressionPayload, type ExtendExpressionType, type FormulaAggregationWidgetData, type FormulaEditorDataset } from '../../../types/formula.types';
+/** Key used to register the root (top-level) editor. */
+export declare const ROOT_EDITOR_ID = "__root__";
+/**
+ * The editable formula store: extends the display-safe {@link FormulaDisplayStore}
+ * with everything the CodeMirror-backed surfaces need - the registry of editor
+ * views (root + nested aggregation widgets), expression insertion and the
+ * autocompletion list.
+ *
+ * This is the only part of the formula family that depends on CodeMirror, so the
+ * read-only `luzmo-formula` display (which uses {@link FormulaDisplayStore}) never
+ * pulls it in.
+ */
+export declare class FormulaEditorStore extends FormulaDisplayStore {
+    private readonly _editors;
+    registerEditor(id: string | null, view: EditorView): void;
+    unregisterEditor(id: string | null): void;
+    getEditor(id?: string | null): EditorView | undefined;
+    /**
+     * Builds the expression fragment for a dropped / inserted item and any new
+     * aggregation widgets that need to be registered.
+     */
+    getDropExpression(type: ExtendExpressionType, id: string | null, datasetId?: string | null, textContent?: string): {
+        expression: string;
+        aggregationWidgets: FormulaAggregationWidgetData[];
+    };
+    /**
+     * Inserts the requested item into the targeted editor (root or aggregation
+     * widget), either at the cursor or by filling a specific empty argument.
+     */
+    onExtendExpression(payload: ExtendExpressionPayload): void;
+    /**
+     * Builds the CodeMirror autocompletion list from the functions, aggregations
+     * (when enabled) and the columns of the provided datasets.
+     */
+    getAutoCompletionList(datasets: FormulaEditorDataset[], showAggregations: boolean): Completion[];
+    /**
+     * Builds the autocompletion info (hint) tooltip for a function / aggregation:
+     * the example expression (with `⟨type⟩` markers rendered as column-type icons)
+     * followed by the description, mirroring the description region.
+     */
+    private _buildOperationInfo;
+}

package/angular/utils/formula/store/tests/formula-editor-store.test.d.ts

@@ -0,0 +1 @@
+export {};

package/angular/utils/formula/tests/validate-expression.test.d.ts

@@ -0,0 +1 @@
+export {};

package/angular/utils/get-css-variable.d.ts

@@ -0,0 +1 @@
+export declare const getCssVariableValue: (element: HTMLElement, variable: string) => string;

package/angular/utils/index.d.ts

@@ -0,0 +1,10 @@
+export { loadDataFieldsForDatasets } from './data/load-data-fields-for-datasets';
+export { decomposeNumericFormat } from './formatter/decompose-numeric-format';
+export { formatter } from './formatter/formatter';
+export { localize } from './formatter/localize';
+export { getLocale, setLocale, targetLocales } from './localize/set-locale';
+export { switchItem } from './switch-item';
+export * from './themes';
+export { convertDatasetsToDataFields } from './transformations/convert-datasets-to-data-fields';
+export { PeriodOverPeriodCondition } from './time/period-over-period-condition.const';
+export { DATE_LEVEL_AND_ABOVE, getValueForFormatter, transformDateToTimezone } from './timezone/datetime-timezone';

package/angular/utils/localize/set-locale.d.ts

@@ -0,0 +1,7 @@
+declare const getLocale: (() => string) & {
+    _LIT_LOCALIZE_GET_LOCALE_?: never;
+}, setLocale: ((newLocale: string) => Promise<void>) & {
+    _LIT_LOCALIZE_SET_LOCALE_?: never;
+};
+export { targetLocales } from './../../generated/locale-codes.js';
+export { getLocale, setLocale };

package/angular/utils/map-tile-providers/index.d.ts

@@ -0,0 +1,93 @@
+export declare const mapVectorTileProviders: {
+    'No Tiles': {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Basic: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Bright: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Dark: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Fiord: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Liberty: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Pastel: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Positron: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Streets: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Toner: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Topographique: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    Voyager: {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+    '3D buildings': {
+        name: string;
+        id: string;
+        url: string;
+        attribution: string;
+        rasterName: string;
+    };
+};