@mintplayer/ng-spark 22.3.0 → 22.5.0

package/fesm2022/mintplayer-ng-spark-grid.mjs

@@ -1,9 +1,20 @@
-import { DatatableSettings } from '@mintplayer/ng-bootstrap/datatable';
-import { hasShowedOnFlag, ShowedOn } from '@mintplayer/ng-spark/models';
+import { DatatableSettings, BsDatatableComponent, BsDatatableColumnDirective, BsRowTemplateDirective } from '@mintplayer/ng-bootstrap/datatable';
+import { hasShowedOnFlag, ShowedOn, selectionModeFor, parseSelectionRule, filterQueryActions } from '@mintplayer/ng-spark/models';
 import * as i0 from '@angular/core';
-import { inject, Injectable } from '@angular/core';
-import { SPARK_ATTRIBUTE_RENDERERS, withDeclaredInputs, rendererValue } from '@mintplayer/ng-spark/renderers';
-import { SparkService } from '@mintplayer/ng-spark/services';
+import { inject, Injectable, TemplateRef, input, Directive, computed, ChangeDetectionStrategy, Component, model, output, signal, effect, untracked, contentChildren, viewChild } from '@angular/core';
+import { SPARK_ATTRIBUTE_RENDERERS, rendererValue, withDeclaredInputs } from '@mintplayer/ng-spark/renderers';
+import { SparkService, SparkLanguageService } from '@mintplayer/ng-spark/services';
+import * as i1 from '@angular/common';
+import { CommonModule, NgComponentOutlet } from '@angular/common';
+import * as i2 from '@angular/router';
+import { RouterModule } from '@angular/router';
+import { Color } from '@mintplayer/ng-bootstrap';
+import { BsAlertComponent } from '@mintplayer/ng-bootstrap/alert';
+import { BsSpinnerComponent } from '@mintplayer/ng-bootstrap/spinner';
+import { SparkQueryRefreshService } from '@mintplayer/ng-spark/client-operations';
+import { ResolveTranslationPipe, AttributeValuePipe, ReferenceChipsPipe, TranslateKeyPipe } from '@mintplayer/ng-spark/pipes';
+import { BsCardComponent, BsCardHeaderComponent } from '@mintplayer/ng-bootstrap/card';
+import { BsPriorityNavComponent, BsPriorityNavItemDirective } from '@mintplayer/ng-bootstrap/priority-nav';
 
 /** Page sizes offered by every Spark grid. */
 const SPARK_GRID_PAGE_SIZES = [10, 25, 50];
@@ -44,20 +55,21 @@ function isVirtualScrollingQuery(query) {
 }
 
 /**
- * The parts of a Spark grid that both grid components need and that were, until this existed,
- * written out twice.
- *
- * `spark-query-list` and `spark-sub-query` had byte-identical copies of the renderer lookup, the
- * renderer input construction and the lookup-reference loading — around 120 lines between them.
- * That duplication is not a tidiness complaint: it is what produced the drift. The two copies
- * disagreed about `[indeterminate]`, about resetting permission state, about whether a fetch
- * failure surfaces or is swallowed, and about virtual-scroll sizing — four user-visible bugs, each
- * fixed on one side and not the other, because nothing made the two files move together.
- *
- * Kept deliberately small and stateless. The two components differ in real ways — one is
- * route-coupled and carries streaming, search and a websocket dependency graph — so merging them
- * into a single component would drag all of that into every detail page's bundle. Shared logic
- * belongs here; shared *state* does not.
+ * Renderer lookup and lookup-reference loading for a Spark grid.
+ *
+ * This was extracted when `spark-query-list` and `spark-sub-query` were two components holding
+ * byte-identical copies of it — around 120 lines between them. That duplication was not a
+ * tidiness complaint: it produced drift. The two copies disagreed about `[indeterminate]`, about
+ * resetting permission state, about whether a fetch failure surfaces or is swallowed, and about
+ * virtual-scroll sizing — four user-visible bugs, each fixed on one side and not the other.
+ *
+ * There is now one grid, {@link SparkQueryGridComponent}, so the drift cannot recur. This stays
+ * separate because it is stateless service-shaped logic rather than view state, and because it is
+ * what a custom grid would need in order to render Spark cells at all.
+ *
+ * The constraint that shaped the split still holds and is why the grid takes rows as an input
+ * rather than owning a socket: streaming's dependency graph must not reach the bundle of every
+ * detail page.
  */
 class SparkGridRenderers {
     registry = inject(SPARK_ATTRIBUTE_RENDERERS);
@@ -75,10 +87,21 @@ class SparkGridRenderers {
      */
     columnInputsFor(component, item, attr) {
         const itemAttr = item.attributes.find(a => a.name === attr.name);
+        return this.cellInputsFor(component, rendererValue(itemAttr), attr, item);
+    }
+    /**
+     * The same contract for a row that is not a <see cref="PersistentObject"/>.
+     *
+     * An AsDetail row is a plain dictionary — embedded values with no id and no attribute list — so
+     * its value cannot be read the way {@link columnInputsFor} reads one. Only the extraction
+     * differs; the renderer contract is identical, and stating it once is what stops the two from
+     * drifting the way the cell markup already had.
+     */
+    cellInputsFor(component, value, column, item) {
         return withDeclaredInputs(component, {
-            value: rendererValue(itemAttr),
-            attribute: attr,
-            options: attr.rendererOptions,
+            value,
+            attribute: column,
+            options: column.rendererOptions,
             item,
         });
     }
@@ -103,9 +126,735 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
+/**
+ * Header slots for `<spark-query-card>`.
+ *
+ * Each directive marks a template that REPLACES one region of the card header. Supplying one
+ * leaves the other two alone — that is the whole point of having three rather than the single
+ * whole-header template they replace, where changing the icon meant re-implementing the caption
+ * and the action bar as well.
+ *
+ * An omitted slot is not an empty slot: the card renders its default. This is what keeps the
+ * auto-rendered sub-query working. A sub-query is rendered from `EntityTypeDefinition.Queries`
+ * with no host to project into, so a mechanism that only ever REPLACED chrome would leave that
+ * call site with nothing — which is why an earlier design had the query declare its own chrome
+ * server-side. Overriding a default needs no host; replacing one does.
+ *
+ * The two ends of that are visible in the defaults themselves. Neither `SparkQuery` nor
+ * `EntityType` carries an icon, so the server has nothing to say and the slot is the only
+ * source. Actions are the mirror image: the server declares them per type, so the default is
+ * the real answer and the slot is a rare override.
+ *
+ * Naming follows ng-bootstrap's `*bsDatatableColumn` convention — prefix, component, slot —
+ * with `spark`, since these are ng-spark directives and `bs` is another package's prefix. These
+ * are the first attribute directives in ng-spark; every existing selector is an element.
+ *
+ * ## Targeting one query
+ *
+ * Each slot takes an optional query alias or id as its value. A detail page renders one card per
+ * entry in `EntityTypeDefinition.Queries`, so a host that supplies a bare slot would decorate
+ * every one of them identically — rarely what is wanted. A targeted slot applies to that query;
+ * an untargeted one is the fallback for the rest.
+ *
+ * ```html
+ * <span *sparkQueryIcon="'cars'"><spark-icon name="car-front" /></span>
+ * <span *sparkQueryIcon><spark-icon name="table" /></span>
+ * ```
+ *
+ * Matching is case-insensitive, against the query's alias and then its id. This is the
+ * `bsPriorityNavItem` shape: a value input aliased to the selector, collected with
+ * `contentChildren`.
+ */
+/** Resolves a slot list to the one that applies to a query: targeted first, then untargeted. */
+function slotFor(slots, query) {
+    if (!slots.length)
+        return null;
+    const matches = (target) => !!target && (target.localeCompare(query?.alias ?? '', undefined, { sensitivity: 'accent' }) === 0 ||
+        target.localeCompare(query?.id ?? '', undefined, { sensitivity: 'accent' }) === 0);
+    // A targeted slot wins over the catch-all even when it is declared later: "this one query"
+    // is the more specific statement, and declaration order in a template is not a priority.
+    return slots.find(s => matches(s.forQuery())) ?? slots.find(s => !s.forQuery()) ?? null;
+}
+/**
+ * The icon at the header's leading edge. No default: nothing in the model describes one.
+ *
+ * ```html
+ * <spark-query-card [queryId]="'cars'">
+ *   <spark-icon *sparkQueryIcon name="car-front" />
+ * </spark-query-card>
+ * ```
+ */
+class SparkQueryIconDirective {
+    templateRef = inject(TemplateRef);
+    /** Query alias or id this slot applies to. Empty targets every query on the page. */
+    forQuery = input('', { ...(ngDevMode ? { debugName: "forQuery" } : /* istanbul ignore next */ {}), alias: 'sparkQueryIcon' });
+    static ngTemplateContextGuard(_dir, ctx) {
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkQueryIconDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.0", type: SparkQueryIconDirective, isStandalone: true, selector: "[sparkQueryIcon]", inputs: { forQuery: { classPropertyName: "forQuery", publicName: "sparkQueryIcon", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkQueryIconDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[sparkQueryIcon]' }]
+        }], propDecorators: { forQuery: [{ type: i0.Input, args: [{ isSignal: true, alias: "sparkQueryIcon", required: false }] }] } });
+/**
+ * The header caption. Defaults to the query's translated description, falling back to its name.
+ *
+ * The context carries that resolved default as `$implicit`, so a host can decorate it — add a
+ * count, a badge — without re-resolving the translation itself.
+ */
+class SparkQueryCaptionDirective {
+    templateRef = inject(TemplateRef);
+    forQuery = input('', { ...(ngDevMode ? { debugName: "forQuery" } : /* istanbul ignore next */ {}), alias: 'sparkQueryCaption' });
+    static ngTemplateContextGuard(_dir, ctx) {
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkQueryCaptionDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.0", type: SparkQueryCaptionDirective, isStandalone: true, selector: "[sparkQueryCaption]", inputs: { forQuery: { classPropertyName: "forQuery", publicName: "sparkQueryCaption", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkQueryCaptionDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[sparkQueryCaption]' }]
+        }], propDecorators: { forQuery: [{ type: i0.Input, args: [{ isSignal: true, alias: "sparkQueryCaption", required: false }] }] } });
+/**
+ * The buttons at the header's trailing edge. Defaults to the server-declared custom actions.
+ *
+ * The context carries those actions and the current selection, so a host that wants its own
+ * buttons ALONGSIDE the server's can render both rather than choosing. Without that, overriding
+ * this slot to add one button would silently drop every action the type declares — and the
+ * server's actions are the ones carrying `selectionRule` and the permission filter.
+ *
+ * ```html
+ * <ng-container *sparkQueryActions="let actions; selection as rows">
+ *   <button (click)="export(rows)">Export</button>
+ * </ng-container>
+ * ```
+ */
+class SparkQueryActionsDirective {
+    templateRef = inject(TemplateRef);
+    forQuery = input('', { ...(ngDevMode ? { debugName: "forQuery" } : /* istanbul ignore next */ {}), alias: 'sparkQueryActions' });
+    static ngTemplateContextGuard(_dir, ctx) {
+        return true;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkQueryActionsDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive });
+    static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "22.0.0", type: SparkQueryActionsDirective, isStandalone: true, selector: "[sparkQueryActions]", inputs: { forQuery: { classPropertyName: "forQuery", publicName: "sparkQueryActions", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0 });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkQueryActionsDirective, decorators: [{
+            type: Directive,
+            args: [{ selector: '[sparkQueryActions]' }]
+        }], propDecorators: { forQuery: [{ type: i0.Input, args: [{ isSignal: true, alias: "sparkQueryActions", required: false }] }] } });
+/** Context for the icon slot: the query whose card is being rendered. */
+class SparkQuerySlotContext {
+    $implicit = null;
+}
+class SparkQueryCaptionContext {
+    /** The caption the card would have rendered: description, or the query name. */
+    $implicit = '';
+    query = null;
+}
+class SparkQueryActionsContext {
+    /** The custom actions the card would have rendered, already filtered for this query. */
+    $implicit = [];
+    /** Rows currently ticked. Empty unless an action is selection-gated. */
+    selection = [];
+    query = null;
+}
+
+/**
+ * One cell of a Spark table, wherever that table is.
+ *
+ * ## Why this exists
+ *
+ * The cell markup was written out three times: twice in the query grids (since merged into
+ * {@link SparkQueryGridComponent}) and once more in the AsDetail table on the PO detail page. The
+ * third copy was never counted, and it had already drifted — a `boolean` column rendered the text
+ * `"true"` there while the grid rendered a checkbox, a `color` rendered its hex string rather than
+ * a swatch, and a custom renderer was dispatched by a second, hand-copied lookup.
+ *
+ * ## What it does and does not own
+ *
+ * It owns **presentation**: which control a `dataType` becomes, and dispatching a declared custom
+ * renderer. It does not own **value resolution**, and deliberately so — the two callers read from
+ * genuinely different row models. A query row is a `PersistentObject` with an attribute list and
+ * an id; an AsDetail row is a plain dictionary of embedded values with neither. Trying to unify
+ * that would put a second row-access path inside this component and buy nothing.
+ *
+ * So the caller resolves the value with whichever pipe fits its row model, and passes the result.
+ *
+ * ## The two links are not the same link, and only one is here
+ *
+ * `link` is for a cell whose own value points at another entity — an AsDetail reference column.
+ * The query grid's first-column link is a different rule (it points at the row's own detail page,
+ * gated on `Read`), and it stays in the grid, wrapping this component. Passing both would nest
+ * anchors, which is invalid HTML; the grid therefore leaves `link` unset.
+ */
+class SparkGridCellComponent {
+    renderers = inject(SparkGridRenderers);
+    /** The column being rendered. Its `dataType` and `renderer` decide everything below. */
+    column = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "column" }] : /* istanbul ignore next */ []));
+    /**
+     * What the caller's value pipe produced: the display text for most columns, and the raw value
+     * for `boolean` and `color`, which need the value rather than a rendering of it.
+     */
+    display = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "display" }] : /* istanbul ignore next */ []));
+    /**
+     * The value handed to a declared custom renderer.
+     *
+     * Separate from {@link display} because they are not the same thing: a renderer receives the
+     * underlying value — for AsDetail, the nested object itself — while `display` has already been
+     * flattened to something printable.
+     */
+    rendererValue = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "rendererValue" }] : /* istanbul ignore next */ []));
+    /** The row, passed through to a custom renderer as `item`. */
+    item = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "item" }] : /* istanbul ignore next */ []));
+    /**
+     * Pre-resolved chips for a reference-array column, or empty when the column is not one.
+     *
+     * Resolved by the caller because the label source differs: a query row carries a per-id
+     * breadcrumb map, while an AsDetail row's `__sparkBreadcrumbs` is keyed by column name only and
+     * so cannot label the members of an array. Rather than render a row of raw ids, an AsDetail
+     * caller passes nothing and the cell falls through to text.
+     */
+    chips = input([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "chips" }] : /* istanbul ignore next */ []));
+    /** Route for a cell whose value references another entity. See the class comment. */
+    link = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "link" }] : /* istanbul ignore next */ []));
+    rendererComponent = computed(() => this.renderers.columnComponentFor(this.column()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "rendererComponent" }] : /* istanbul ignore next */ []));
+    rendererInputs = computed(() => {
+        const component = this.rendererComponent();
+        return component
+            ? this.renderers.cellInputsFor(component, this.rendererValue(), this.column(), this.item())
+            : {};
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "rendererInputs" }] : /* istanbul ignore next */ []));
+    /** Null and undefined are distinct from `false` here — see the template. */
+    isUnsetBoolean = computed(() => this.display() == null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "isUnsetBoolean" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkGridCellComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.0", type: SparkGridCellComponent, isStandalone: true, selector: "spark-grid-cell", inputs: { column: { classPropertyName: "column", publicName: "column", isSignal: true, isRequired: true, transformFunction: null }, display: { classPropertyName: "display", publicName: "display", isSignal: true, isRequired: false, transformFunction: null }, rendererValue: { classPropertyName: "rendererValue", publicName: "rendererValue", isSignal: true, isRequired: false, transformFunction: null }, item: { classPropertyName: "item", publicName: "item", isSignal: true, isRequired: false, transformFunction: null }, chips: { classPropertyName: "chips", publicName: "chips", isSignal: true, isRequired: false, transformFunction: null }, link: { classPropertyName: "link", publicName: "link", isSignal: true, isRequired: false, transformFunction: null } }, ngImport: i0, template: "@if (rendererComponent(); as rendererType) {\n  <ng-container *ngComponentOutlet=\"rendererType; inputs: rendererInputs()\"></ng-container>\n} @else if (column().dataType === 'boolean') {\n  <!-- [indeterminate] matters: without it a null boolean renders as an unchecked box, which reads\n       as an explicit `false`. One of the three copies of this cell bound it and the others had\n       drifted, so the same column said different things on a detail page and in a grid. -->\n  <input type=\"checkbox\"\n    [checked]=\"display() === true\"\n    [indeterminate]=\"isUnsetBoolean()\"\n    disabled\n    onclick=\"return false;\">\n} @else if (column().dataType === 'color') {\n  @if (display(); as colorVal) {\n    <!-- Inline on purpose, and it is not a style-guide slip. In a query grid this cell is\n         rendered INSIDE <mp-datatable>'s shadow root, which does not see document\n         stylesheets: neither this component's scoped rules nor Bootstrap utilities apply\n         there. Inline styles do. Measured 2026-08-23 -- see the comment in the .scss. -->\n    <span class=\"d-inline-block align-middle border rounded\"\n          [style.background-color]=\"colorVal\"\n          style=\"width: 1.5em; height: 1.5em;\"></span>\n  }\n} @else if (chips().length) {\n  <span class=\"d-inline-flex flex-wrap gap-1\">\n    @for (chip of chips(); track chip.id) {\n      <span class=\"spark-chip\">{{ chip.label }}</span>\n    }\n  </span>\n} @else if (link(); as route) {\n  <a [routerLink]=\"route\">{{ display() }}</a>\n} @else {\n  {{ display() }}\n}\n", styles: [".spark-chip{display:inline-block;padding:.35em .9em;font-size:.8125em;font-weight:600;line-height:1.4;white-space:nowrap;text-align:center;vertical-align:baseline;color:var(--bs-body-color);background-color:var(--bs-secondary-bg);border:1px solid var(--bs-border-color);border-radius:50rem;text-decoration:none}a.spark-chip:hover,a.spark-chip:focus-visible{background-color:var(--bs-tertiary-bg)}.spark-color-swatch{width:1.5em;height:1.5em}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgComponentOutlet, selector: "[ngComponentOutlet]", inputs: ["ngComponentOutlet", "ngComponentOutletInputs", "ngComponentOutletInjector", "ngComponentOutletEnvironmentInjector", "ngComponentOutletContent", "ngComponentOutletNgModule"], exportAs: ["ngComponentOutlet"] }, { kind: "ngmodule", type: RouterModule }, { kind: "directive", type: i2.RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "browserUrl", "routerLink"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkGridCellComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'spark-grid-cell', imports: [CommonModule, NgComponentOutlet, RouterModule], changeDetection: ChangeDetectionStrategy.OnPush, template: "@if (rendererComponent(); as rendererType) {\n  <ng-container *ngComponentOutlet=\"rendererType; inputs: rendererInputs()\"></ng-container>\n} @else if (column().dataType === 'boolean') {\n  <!-- [indeterminate] matters: without it a null boolean renders as an unchecked box, which reads\n       as an explicit `false`. One of the three copies of this cell bound it and the others had\n       drifted, so the same column said different things on a detail page and in a grid. -->\n  <input type=\"checkbox\"\n    [checked]=\"display() === true\"\n    [indeterminate]=\"isUnsetBoolean()\"\n    disabled\n    onclick=\"return false;\">\n} @else if (column().dataType === 'color') {\n  @if (display(); as colorVal) {\n    <!-- Inline on purpose, and it is not a style-guide slip. In a query grid this cell is\n         rendered INSIDE <mp-datatable>'s shadow root, which does not see document\n         stylesheets: neither this component's scoped rules nor Bootstrap utilities apply\n         there. Inline styles do. Measured 2026-08-23 -- see the comment in the .scss. -->\n    <span class=\"d-inline-block align-middle border rounded\"\n          [style.background-color]=\"colorVal\"\n          style=\"width: 1.5em; height: 1.5em;\"></span>\n  }\n} @else if (chips().length) {\n  <span class=\"d-inline-flex flex-wrap gap-1\">\n    @for (chip of chips(); track chip.id) {\n      <span class=\"spark-chip\">{{ chip.label }}</span>\n    }\n  </span>\n} @else if (link(); as route) {\n  <a [routerLink]=\"route\">{{ display() }}</a>\n} @else {\n  {{ display() }}\n}\n", styles: [".spark-chip{display:inline-block;padding:.35em .9em;font-size:.8125em;font-weight:600;line-height:1.4;white-space:nowrap;text-align:center;vertical-align:baseline;color:var(--bs-body-color);background-color:var(--bs-secondary-bg);border:1px solid var(--bs-border-color);border-radius:50rem;text-decoration:none}a.spark-chip:hover,a.spark-chip:focus-visible{background-color:var(--bs-tertiary-bg)}.spark-color-swatch{width:1.5em;height:1.5em}\n"] }]
+        }], propDecorators: { column: [{ type: i0.Input, args: [{ isSignal: true, alias: "column", required: true }] }], display: [{ type: i0.Input, args: [{ isSignal: true, alias: "display", required: false }] }], rendererValue: [{ type: i0.Input, args: [{ isSignal: true, alias: "rendererValue", required: false }] }], item: [{ type: i0.Input, args: [{ isSignal: true, alias: "item", required: false }] }], chips: [{ type: i0.Input, args: [{ isSignal: true, alias: "chips", required: false }] }], link: [{ type: i0.Input, args: [{ isSignal: true, alias: "link", required: false }] }] } });
+
+/**
+ * The one Spark grid: a `<bs-datatable>` rendering a query or a sub-query.
+ *
+ * This replaces two components that were the same grid written twice — and, counting
+ * `spark-query-list`'s streaming and paged branches, the `<bs-datatable>` element itself written
+ * three times. The duplication had already produced four user-visible bugs, each fixed on one
+ * side and not the other: `[indeterminate]` on null booleans, permission state surviving a failed
+ * reload, a swallowed fetch failure, and virtual-scroll sizing. `SparkGridRenderers` was
+ * extracted to stop that and could only take the stateless helpers with it; this takes the rest.
+ *
+ * ## What it deliberately does NOT own: streaming
+ *
+ * `spark-grid-renderers.ts` records why — a websocket dependency graph must not reach the bundle
+ * of every PO detail page, none of which stream. So rows can come from **either** side:
+ *
+ *  - unbound `data` — the grid fetches for itself, paging and sorting server-side;
+ *  - bound `data` — the grid renders what it is given and never fetches.
+ *
+ * `spark-query-list` keeps the socket and feeds its snapshot in. This is the line `bs-datatable`
+ * itself draws: `[data]` and `[fetch]` are mutually exclusive, and binding both makes `[fetch]`
+ * win silently.
+ *
+ * ## Reading its state
+ *
+ * `query`, `entityType`, `customActions`, `selection`, `canRead`, `canCreate` and `resultCount`
+ * are readable so a host can render chrome around the grid. Read them through a template
+ * reference variable — `<spark-query-grid #grid>` … `grid.query()` — not `viewChild`: hosts wrap
+ * grids in `@if`, where a `viewChild` is intermittently undefined.
+ */
+class SparkQueryGridComponent {
+    sparkService = inject(SparkService);
+    gridRenderers = inject(SparkGridRenderers);
+    queryRefresh = inject(SparkQueryRefreshService);
+    lang = inject(SparkLanguageService);
+    /** Query alias or id. */
+    queryId = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "queryId" }] : /* istanbul ignore next */ []));
+    /**
+     * The parent persistent object this query is scoped to, when it has one.
+     *
+     * Optional, because not every query is a detail of something: a page can host a grid that
+     * stands on its own — "my accounts", a dashboard list — and the server already treats an absent
+     * parent as "no parent" rather than as an error. Requiring these made that shape impossible to
+     * express: the component simply never loaded, with no request, no error and no log.
+     *
+     * Pass both or neither. One without the other is ignored, matching `SparkService.executeQuery`,
+     * which omits either param when it is falsy, and the execute endpoint, which resolves a parent
+     * only when both are present.
+     */
+    parentId = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "parentId" }] : /* istanbul ignore next */ []));
+    parentType = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "parentType" }] : /* istanbul ignore next */ []));
+    /**
+     * Rows supplied from outside. When bound, the grid renders these and runs no fetch.
+     *
+     * This is how streaming stays out of this component (see the class comment). `null` — the
+     * default — means "fetch for yourself"; an empty array means "you have been given no rows",
+     * which is a different statement and renders an empty grid rather than triggering a load.
+     */
+    data = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "data" }] : /* istanbul ignore next */ []));
+    /**
+     * Server-side search term, passed through to the query.
+     *
+     * An input rather than a box, so the host owns the control and the grid owns the request. A
+     * host with client-side rows filters them itself before binding `data`.
+     */
+    search = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "search" }] : /* istanbul ignore next */ []));
+    /**
+     * Change this to re-run the query. Any value works; only its identity matters.
+     *
+     * A declarative token rather than only a `reload()` method, because calling a method means
+     * holding a component handle, and hosts wrap this grid in `@if`, where a `viewChild` is
+     * intermittently undefined.
+     *
+     * This drives the CHEAP refresh (see {@link reload}). It deliberately does not feed the main
+     * effect: re-running `loadData` would re-resolve the query, the entity types, the permissions
+     * and the lookups, and reset the user's page and sort on every button press.
+     */
+    reloadToken = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "reloadToken" }] : /* istanbul ignore next */ []));
+    /**
+     * Paging and sorting. Two-way, so a host driving `data` can sort those rows by whatever the
+     * user actually clicked — the datatable writes the new sort back through here.
+     */
+    settings = model(new DatatableSettings({
+        perPage: { values: SPARK_GRID_PAGE_SIZES, selected: SPARK_GRID_PAGE_SIZES[0] },
+        page: { values: [1], selected: 1 },
+        sortColumns: [],
+    }), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "settings" }] : /* istanbul ignore next */ []));
+    /** Rows the user has ticked. Two-way so chrome outside the grid can read and clear them. */
+    selection = model([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "selection" }] : /* istanbul ignore next */ []));
+    /** Emitted whenever a load or a page fetch fails, for a host in bespoke chrome. */
+    error = output();
+    rowClicked = output();
+    customActionExecuted = output();
+    colors = Color;
+    query = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "query" }] : /* istanbul ignore next */ []));
+    entityType = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "entityType" }] : /* istanbul ignore next */ []));
+    allEntityTypes = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "allEntityTypes" }] : /* istanbul ignore next */ []));
+    lookupReferenceOptions = signal({}, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "lookupReferenceOptions" }] : /* istanbul ignore next */ []));
+    loading = signal(true, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "loading" }] : /* istanbul ignore next */ []));
+    canRead = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "canRead" }] : /* istanbul ignore next */ []));
+    canCreate = signal(false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "canCreate" }] : /* istanbul ignore next */ []));
+    resultCount = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "resultCount" }] : /* istanbul ignore next */ []));
+    customActions = signal([], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "customActions" }] : /* istanbul ignore next */ []));
+    fetchFn = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "fetchFn" }] : /* istanbul ignore next */ []));
+    /**
+     * Why the component renders its own failure instead of only reporting one.
+     *
+     * `SparkService` is a bare `firstValueFrom` passthrough with no interceptor, so every failure
+     * surfaces here and nowhere else. A host embedding this grid cannot surface what it never sees,
+     * and the default has to be visible with no host cooperation — hence a rendered alert, not just
+     * an output.
+     */
+    errorMessage = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "errorMessage" }] : /* istanbul ignore next */ []));
+    /** 'none' unless an action is selection-gated, so unaffected grids gain no checkbox column. */
+    selectionMode = computed(() => selectionModeFor(this.customActions()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "selectionMode" }] : /* istanbul ignore next */ []));
+    isVirtualScrolling = computed(() => isVirtualScrollingQuery(this.query()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "isVirtualScrolling" }] : /* istanbul ignore next */ []));
+    visibleAttributes = computed(() => visibleGridAttributes(this.entityType()), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "visibleAttributes" }] : /* istanbul ignore next */ []));
+    /**
+     * True when rows do not come from this component's own fetch.
+     *
+     * Either because the host bound `data`, or because the query streams — a streaming query's rows
+     * arrive over a socket and `/execute` is not a way to get them. The grid recognises the second
+     * case itself rather than waiting to be told, because it resolves the query before the host can
+     * see it: left to `data` alone, every streaming grid would fire one pointless fetch on mount,
+     * before the host had anything to bind.
+     */
+    hasExternalData = computed(() => this.data() !== null || this.query()?.isStreamingQuery === true, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "hasExternalData" }] : /* istanbul ignore next */ []));
+    /** Whether an action's selection rule is satisfied right now. The server checks it again. */
+    isActionEnabled(action) {
+        return parseSelectionRule(action.selectionRule)(this.selection().length);
+    }
+    constructor() {
+        effect(() => {
+            const qId = this.queryId();
+            const pId = this.parentId();
+            const pType = this.parentType();
+            // Only the query id is required. Requiring a parent here is what made a standalone grid
+            // silently render nothing.
+            if (qId) {
+                this.loadData(qId, pId, pType);
+            }
+            else {
+                // No query id at all. `loading` starts true, so without this the component would spin
+                // forever instead of saying anything.
+                this.loading.set(false);
+            }
+        });
+        // Separate effect, so the token drives the cheap refresh and never the full metadata reload.
+        // `first` skips the initial run: the effect above has already fetched, and reacting to the
+        // token's starting value would double-fetch on mount.
+        let first = true;
+        effect(() => {
+            // Both the host's token and the server's refreshQuery drive the same cheap refresh.
+            this.reloadToken();
+            this.queryRefresh.tokenFor(this.queryId());
+            if (first) {
+                first = false;
+                return;
+            }
+            untracked(() => this.reload());
+        });
+        // A new search term must refetch even when page, perPage and sort are unchanged — the
+        // datatable dedupes reloads by exactly that triple, and a new fetch identity is what resets
+        // its dedupe key. Skipping the first run keeps mount to a single request.
+        let firstSearch = true;
+        effect(() => {
+            this.search();
+            if (firstSearch) {
+                firstSearch = false;
+                return;
+            }
+            untracked(() => this.onSearchChanged());
+        });
+    }
+    /**
+     * Re-run the query, keeping the current page, sort and scroll position.
+     *
+     * Data-level on purpose: it re-seeds the fetch closure and nothing else. For a definition
+     * change — new columns, a renamed query — the inputs themselves must change; that is the
+     * expensive path. Inert when rows come from the host: there is nothing here to re-run.
+     */
+    reload() {
+        if (this.hasExternalData())
+            return;
+        const q = this.query();
+        if (q)
+            this.fetchFn.set(this.makeFetch(q, this.parentId(), this.parentType()));
+    }
+    onSearchChanged() {
+        if (this.hasExternalData())
+            return;
+        const s = this.settings();
+        // Back to page 1: the old page number means nothing against a different result set.
+        this.settings.set(new DatatableSettings({
+            perPage: { values: s.perPage.values, selected: s.perPage.selected },
+            page: { values: [1], selected: 1 },
+            sortColumns: s.sortColumns,
+        }));
+        this.reload();
+    }
+    async onCustomAction(action) {
+        if (action.confirmationMessageKey) {
+            const message = this.lang.t(action.confirmationMessageKey) || 'Are you sure?';
+            if (!confirm(message))
+                return;
+        }
+        try {
+            await this.sparkService.executeCustomAction(this.entityType().id, action.name, undefined, this.selection());
+            this.customActionExecuted.emit({ action });
+            if (action.refreshOnCompleted)
+                this.reload();
+        }
+        catch (e) {
+            const err = e;
+            this.errorMessage.set(err.error?.error || err.message || this.lang.t('common.actionFailed') || 'Action failed');
+        }
+    }
+    reportError(err) {
+        this.errorMessage.set(this.describe(err));
+        this.error.emit(err);
+    }
+    /**
+     * A 404 is deliberately generic.
+     *
+     * `Endpoints/Queries/Get.cs` answers 404 with byte-identical bodies for "no such query" and
+     * "you may not see it", so existence is not disclosed (security audit M-3). The component
+     * therefore genuinely cannot tell them apart, and both "Not found" and "Access denied" would be
+     * a guess — one of them leaking, the other misleading.
+     */
+    describe(err) {
+        if (err?.status === 404) {
+            return this.lang.t('spark.query.unavailable') || 'This list is not available.';
+        }
+        return err?.error?.error || err?.message
+            || this.lang.t('common.unexpectedError') || 'An unexpected error occurred';
+    }
+    async loadData(queryId, parentId, parentType) {
+        this.loading.set(true);
+        this.errorMessage.set(null);
+        this.fetchFn.set(null);
+        // Reset everything derived from the previous query, not just the fetch. Leaving
+        // `entityType`/`canRead` behind let a failed reload build a row link out of the PREVIOUS type
+        // and the previous permission.
+        this.query.set(null);
+        this.entityType.set(null);
+        this.canRead.set(false);
+        this.canCreate.set(false);
+        this.customActions.set([]);
+        this.resultCount.set(null);
+        // Ids from the previous query are meaningless against the next one, and would be POSTed as
+        // though they belonged to it.
+        this.selection.set([]);
+        try {
+            const [resolvedQuery, entityTypes] = await Promise.all([
+                this.sparkService.getQuery(queryId),
+                this.sparkService.getEntityTypes(),
+            ]);
+            this.query.set(resolvedQuery);
+            this.allEntityTypes.set(entityTypes);
+            const et = this.resolveEntityType(resolvedQuery, entityTypes);
+            this.entityType.set(et);
+            if (et) {
+                const [permissions, actions] = await Promise.all([
+                    this.sparkService.getPermissions(et.id),
+                    this.sparkService.getCustomActions(et.id),
+                ]);
+                this.canRead.set(permissions.canRead);
+                this.canCreate.set(permissions.canCreate);
+                // 'query', not 'list'. The server model has always documented "detail" | "query" |
+                // "both"; a filter testing for a value nothing emits renders the action NOWHERE.
+                this.customActions.set(filterQueryActions(actions));
+            }
+            this.settings.set(initialGridSettings(resolvedQuery));
+            // The datatable drives paging/sorting via [(settings)] and calls fetchFn per page. Virtual
+            // scrolling is just the [virtualScroll] template flag.
+            // `resolvedQuery`, not `hasExternalData()`: the query signal is set above, but reading the
+            // computed here would depend on signal-read ordering inside an async method. Ask the value
+            // directly.
+            if (this.data() === null && !resolvedQuery?.isStreamingQuery) {
+                this.fetchFn.set(this.makeFetch(resolvedQuery, parentId, parentType));
+            }
+            this.loadLookupReferenceOptions();
+        }
+        catch (e) {
+            this.fetchFn.set(null);
+            this.reportError(e);
+        }
+        finally {
+            this.loading.set(false);
+        }
+    }
+    /**
+     * The query's entity type.
+     *
+     * The source-name fallback is not optional garnish: a `Database.*` query need not declare
+     * `entityType`, and the sub-query grid — which matched on the declared name alone — rendered
+     * those as an empty card with no columns, no rows and no error, while the identical query
+     * rendered correctly as a page. Both grids are this one now, so there is one answer.
+     */
+    resolveEntityType(query, entityTypes) {
+        if (!query)
+            return null;
+        if (query.entityType) {
+            return entityTypes.find(t => t.name === query.entityType || t.alias === query.entityType?.toLowerCase()) ?? null;
+        }
+        const sourceName = extractSourceName(query.source);
+        const singular = singularize(sourceName);
+        return entityTypes.find(t => t.name === sourceName || t.name === singular || t.clrType.endsWith(singular)) ?? null;
+    }
+    makeFetch(query, parentId, parentType) {
+        return (req) => this.sparkService.executeQuery(query.id, {
+            sortColumns: req.sortColumns,
+            skip: (req.page - 1) * req.perPage,
+            take: req.perPage,
+            search: this.search() || undefined,
+            parentId, parentType,
+        }).then(r => {
+            this.errorMessage.set(null);
+            this.resultCount.set(r.totalRecords);
+            return {
+                data: r.data,
+                totalRecords: r.totalRecords,
+                totalPages: Math.ceil(r.totalRecords / req.perPage) || 1,
+                perPage: req.perPage,
+                page: req.page,
+            };
+        }).catch((e) => {
+            // Report before returning the empty page, or a failed fetch is indistinguishable from a
+            // query that legitimately has no rows.
+            this.reportError(e);
+            this.resultCount.set(0);
+            return { data: [], totalRecords: 0, totalPages: 1, perPage: req.perPage, page: req.page };
+        });
+    }
+    async loadLookupReferenceOptions() {
+        this.lookupReferenceOptions.set(await this.gridRenderers.loadLookupOptions(this.visibleAttributes()));
+    }
+    /**
+     * The underlying value a custom renderer receives, which is not the printable one.
+     *
+     * `rendererValue` unwraps an AsDetail attribute to the nested object (or objects) rather than
+     * flattening it to text — a renderer for a nested type needs the object, not a summary of it.
+     */
+    rendererValueFor(item, attr) {
+        return rendererValue(item.attributes.find(a => a.name === attr.name));
+    }
+    getColumnRendererComponent(attr) {
+        return this.gridRenderers.columnComponentFor(attr);
+    }
+    getColumnRendererInputs(component, item, attr) {
+        return this.gridRenderers.columnInputsFor(component, item, attr);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkQueryGridComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.0", type: SparkQueryGridComponent, isStandalone: true, selector: "spark-query-grid", inputs: { queryId: { classPropertyName: "queryId", publicName: "queryId", isSignal: true, isRequired: true, transformFunction: null }, parentId: { classPropertyName: "parentId", publicName: "parentId", isSignal: true, isRequired: false, transformFunction: null }, parentType: { classPropertyName: "parentType", publicName: "parentType", isSignal: true, isRequired: false, transformFunction: null }, data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: false, transformFunction: null }, search: { classPropertyName: "search", publicName: "search", isSignal: true, isRequired: false, transformFunction: null }, reloadToken: { classPropertyName: "reloadToken", publicName: "reloadToken", isSignal: true, isRequired: false, transformFunction: null }, settings: { classPropertyName: "settings", publicName: "settings", isSignal: true, isRequired: false, transformFunction: null }, selection: { classPropertyName: "selection", publicName: "selection", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { settings: "settingsChange", selection: "selectionChange", error: "error", rowClicked: "rowClicked", customActionExecuted: "customActionExecuted" }, ngImport: i0, template: "<!--\n  Three explicit states, in this order, and the order is load-bearing.\n\n  This template used to open with `@if (query(); as q)` wrapping EVERYTHING, and `query()` is only\n  set after loadData's awaits resolve. Three separate bugs fell out of that one line: the spinner\n  was unreachable on a first load (it rendered inside the gate, while `loading` starts true and\n  `query` starts null), a first-load failure rendered ZERO DOM \u2014 no card, no message, nothing to\n  see or report \u2014 and a failed RELOAD left the previous query's rows on screen.\n\n  So: `loading` is checked first and outside any dependency on `query`, and the final `@else`\n  always renders something. Do not fold these back into one gate, and do not move the spinner\n  inside the `query()` branch.\n-->\n@if (loading()) {\n  <div class=\"text-center p-3\">\n    <bs-spinner />\n  </div>\n} @else if (query()) {\n  <!-- A page-fetch failure while the grid is already resolved. Without this the catch returns an\n       empty page and a failed query is indistinguishable from one that legitimately has no rows. -->\n  @if (errorMessage(); as err) {\n    <bs-alert [type]=\"colors.danger\" class=\"mb-3\">\n      {{ err }}\n    </bs-alert>\n  }\n\n  <!--\n    One datatable, two row sources. `[data]` and `[fetch]` are mutually exclusive in\n    ng-bootstrap \u2014 binding both makes `[fetch]` win silently \u2014 so exactly one is ever non-null\n    here: `fetchFn` is left null whenever `data` is bound. See the class comment for why rows can\n    arrive from outside at all (streaming must not put a websocket in every detail page's bundle).\n  -->\n  <bs-datatable\n      [selectionMode]=\"selectionMode()\"\n      [(selection)]=\"selection\"\n      [virtualScroll]=\"isVirtualScrolling()\"\n      [itemSize]=\"40\"\n      [isResponsive]=\"isVirtualScrolling()\"\n      [data]=\"data()\"\n      [fetch]=\"fetchFn()\"\n      [(settings)]=\"settings\">\n    @for (attr of visibleAttributes(); track attr.id) {\n      <div *bsDatatableColumn=\"attr.name; sortable: true\">\n        {{ (attr.label | resolveTranslation) || attr.name }}\n      </div>\n    }\n\n    <ng-container *bsRowTemplate=\"let item\">\n      @let row = $any(item);\n      @for (attr of visibleAttributes(); track attr.id; let first = $first) {\n        <td>\n          @if (row) {\n            <!-- The first column links to the row's detail page. Two things about this are\n                 routinely misread:\n\n                 1. `cellContent` is projected INSIDE the anchor, so a custom `renderer` does NOT\n                    suppress this link \u2014 a renderer that emits its own <a> produces nested anchors\n                    (invalid HTML) rather than replacing this one.\n                 2. `canRead()` is the whole gate, and it is the rights model: `Query` without\n                    `Read` lists the rows and withholds the link. Withhold `Read` for a query\n                    whose rows no detail page can load \u2014 a Custom.* query that fabricates rows in\n                    memory, say. -->\n            @if (first && canRead()) {\n              <a [routerLink]=\"['/po', entityType()!.alias || entityType()!.id, row.id]\"\n                 (click)=\"rowClicked.emit(row)\">\n                <ng-container *ngTemplateOutlet=\"cellContent; context: { $implicit: row, attr: attr }\"></ng-container>\n              </a>\n            } @else {\n              <ng-container *ngTemplateOutlet=\"cellContent; context: { $implicit: row, attr: attr }\"></ng-container>\n            }\n          } @else {\n            &nbsp;\n          }\n        </td>\n      }\n    </ng-container>\n  </bs-datatable>\n} @else {\n  <!-- The query could not be resolved. Rendering something keeps the host's layout intact and,\n       crucially, makes the failure visible: this branch used to render nothing at all. -->\n  <bs-alert [type]=\"colors.danger\" class=\"mb-0\">\n    {{ errorMessage() || ('spark.query.unavailable' | t) }}\n  </bs-alert>\n}\n\n<ng-template #cellContent let-item let-attr=\"attr\">\n  <!--\n    Presentation lives in <spark-grid-cell>, shared with the AsDetail table on the PO detail page.\n    Value resolution stays here: a query row is a PersistentObject with an attribute list, and the\n    AsDetail table's rows are plain dictionaries, so only the rendering is common.\n\n    `link` is deliberately not passed. The first-column link is the grid's own rule and wraps this\n    template from outside; setting both would nest anchors.\n  -->\n  <spark-grid-cell\n      [column]=\"attr\"\n      [display]=\"(attr.name | attributeValue:item:entityType():lookupReferenceOptions():allEntityTypes())\"\n      [rendererValue]=\"rendererValueFor(item, attr)\"\n      [item]=\"item\"\n      [chips]=\"(attr.name | referenceChips:item)\" />\n</ng-template>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "ngmodule", type: RouterModule }, { kind: "directive", type: i2.RouterLink, selector: "[routerLink]", inputs: ["target", "queryParams", "fragment", "queryParamsHandling", "state", "info", "relativeTo", "preserveFragment", "skipLocationChange", "replaceUrl", "browserUrl", "routerLink"] }, { kind: "component", type: BsAlertComponent, selector: "bs-alert", inputs: ["type", "announce", "isVisible"], outputs: ["isVisibleChange", "afterOpenedOrClosed"] }, { kind: "component", type: BsDatatableComponent, selector: "bs-datatable", inputs: ["columns", "data", "fetch", "settings", "selectionMode", "selectable", "selection", "rowKey", "resizableColumns", "pagination", "virtualScroll", "itemSize", "virtualBuffer", "isResponsive", "compareWith", "tree", "idKey", "childCountKey", "treeIndent", "expandedIds", "selectionStrategy"], outputs: ["settingsChange", "selectionChange", "rowClick", "rowDblClick", "rowContextMenu", "expandedIdsChange", "rowExpand", "rowCollapse"] }, { kind: "directive", type: BsDatatableColumnDirective, selector: "[bsDatatableColumn]", inputs: ["bsDatatableColumn", "bsDatatableColumnSortable"] }, { kind: "directive", type: BsRowTemplateDirective, selector: "[bsRowTemplate]" }, { kind: "component", type: BsSpinnerComponent, selector: "bs-spinner", inputs: ["type", "color"] }, { kind: "component", type: SparkGridCellComponent, selector: "spark-grid-cell", inputs: ["column", "display", "rendererValue", "item", "chips", "link"] }, { kind: "pipe", type: ResolveTranslationPipe, name: "resolveTranslation" }, { kind: "pipe", type: AttributeValuePipe, name: "attributeValue" }, { kind: "pipe", type: ReferenceChipsPipe, name: "referenceChips" }, { kind: "pipe", type: TranslateKeyPipe, name: "t" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkQueryGridComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'spark-query-grid', imports: [CommonModule, RouterModule, BsAlertComponent, BsDatatableComponent, BsDatatableColumnDirective, BsRowTemplateDirective, BsSpinnerComponent, SparkGridCellComponent, ResolveTranslationPipe, AttributeValuePipe, ReferenceChipsPipe, TranslateKeyPipe], changeDetection: ChangeDetectionStrategy.OnPush, template: "<!--\n  Three explicit states, in this order, and the order is load-bearing.\n\n  This template used to open with `@if (query(); as q)` wrapping EVERYTHING, and `query()` is only\n  set after loadData's awaits resolve. Three separate bugs fell out of that one line: the spinner\n  was unreachable on a first load (it rendered inside the gate, while `loading` starts true and\n  `query` starts null), a first-load failure rendered ZERO DOM \u2014 no card, no message, nothing to\n  see or report \u2014 and a failed RELOAD left the previous query's rows on screen.\n\n  So: `loading` is checked first and outside any dependency on `query`, and the final `@else`\n  always renders something. Do not fold these back into one gate, and do not move the spinner\n  inside the `query()` branch.\n-->\n@if (loading()) {\n  <div class=\"text-center p-3\">\n    <bs-spinner />\n  </div>\n} @else if (query()) {\n  <!-- A page-fetch failure while the grid is already resolved. Without this the catch returns an\n       empty page and a failed query is indistinguishable from one that legitimately has no rows. -->\n  @if (errorMessage(); as err) {\n    <bs-alert [type]=\"colors.danger\" class=\"mb-3\">\n      {{ err }}\n    </bs-alert>\n  }\n\n  <!--\n    One datatable, two row sources. `[data]` and `[fetch]` are mutually exclusive in\n    ng-bootstrap \u2014 binding both makes `[fetch]` win silently \u2014 so exactly one is ever non-null\n    here: `fetchFn` is left null whenever `data` is bound. See the class comment for why rows can\n    arrive from outside at all (streaming must not put a websocket in every detail page's bundle).\n  -->\n  <bs-datatable\n      [selectionMode]=\"selectionMode()\"\n      [(selection)]=\"selection\"\n      [virtualScroll]=\"isVirtualScrolling()\"\n      [itemSize]=\"40\"\n      [isResponsive]=\"isVirtualScrolling()\"\n      [data]=\"data()\"\n      [fetch]=\"fetchFn()\"\n      [(settings)]=\"settings\">\n    @for (attr of visibleAttributes(); track attr.id) {\n      <div *bsDatatableColumn=\"attr.name; sortable: true\">\n        {{ (attr.label | resolveTranslation) || attr.name }}\n      </div>\n    }\n\n    <ng-container *bsRowTemplate=\"let item\">\n      @let row = $any(item);\n      @for (attr of visibleAttributes(); track attr.id; let first = $first) {\n        <td>\n          @if (row) {\n            <!-- The first column links to the row's detail page. Two things about this are\n                 routinely misread:\n\n                 1. `cellContent` is projected INSIDE the anchor, so a custom `renderer` does NOT\n                    suppress this link \u2014 a renderer that emits its own <a> produces nested anchors\n                    (invalid HTML) rather than replacing this one.\n                 2. `canRead()` is the whole gate, and it is the rights model: `Query` without\n                    `Read` lists the rows and withholds the link. Withhold `Read` for a query\n                    whose rows no detail page can load \u2014 a Custom.* query that fabricates rows in\n                    memory, say. -->\n            @if (first && canRead()) {\n              <a [routerLink]=\"['/po', entityType()!.alias || entityType()!.id, row.id]\"\n                 (click)=\"rowClicked.emit(row)\">\n                <ng-container *ngTemplateOutlet=\"cellContent; context: { $implicit: row, attr: attr }\"></ng-container>\n              </a>\n            } @else {\n              <ng-container *ngTemplateOutlet=\"cellContent; context: { $implicit: row, attr: attr }\"></ng-container>\n            }\n          } @else {\n            &nbsp;\n          }\n        </td>\n      }\n    </ng-container>\n  </bs-datatable>\n} @else {\n  <!-- The query could not be resolved. Rendering something keeps the host's layout intact and,\n       crucially, makes the failure visible: this branch used to render nothing at all. -->\n  <bs-alert [type]=\"colors.danger\" class=\"mb-0\">\n    {{ errorMessage() || ('spark.query.unavailable' | t) }}\n  </bs-alert>\n}\n\n<ng-template #cellContent let-item let-attr=\"attr\">\n  <!--\n    Presentation lives in <spark-grid-cell>, shared with the AsDetail table on the PO detail page.\n    Value resolution stays here: a query row is a PersistentObject with an attribute list, and the\n    AsDetail table's rows are plain dictionaries, so only the rendering is common.\n\n    `link` is deliberately not passed. The first-column link is the grid's own rule and wraps this\n    template from outside; setting both would nest anchors.\n  -->\n  <spark-grid-cell\n      [column]=\"attr\"\n      [display]=\"(attr.name | attributeValue:item:entityType():lookupReferenceOptions():allEntityTypes())\"\n      [rendererValue]=\"rendererValueFor(item, attr)\"\n      [item]=\"item\"\n      [chips]=\"(attr.name | referenceChips:item)\" />\n</ng-template>\n" }]
+        }], ctorParameters: () => [], propDecorators: { queryId: [{ type: i0.Input, args: [{ isSignal: true, alias: "queryId", required: true }] }], parentId: [{ type: i0.Input, args: [{ isSignal: true, alias: "parentId", required: false }] }], parentType: [{ type: i0.Input, args: [{ isSignal: true, alias: "parentType", required: false }] }], data: [{ type: i0.Input, args: [{ isSignal: true, alias: "data", required: false }] }], search: [{ type: i0.Input, args: [{ isSignal: true, alias: "search", required: false }] }], reloadToken: [{ type: i0.Input, args: [{ isSignal: true, alias: "reloadToken", required: false }] }], settings: [{ type: i0.Input, args: [{ isSignal: true, alias: "settings", required: false }] }, { type: i0.Output, args: ["settingsChange"] }], selection: [{ type: i0.Input, args: [{ isSignal: true, alias: "selection", required: false }] }, { type: i0.Output, args: ["selectionChange"] }], error: [{ type: i0.Output, args: ["error"] }], rowClicked: [{ type: i0.Output, args: ["rowClicked"] }], customActionExecuted: [{ type: i0.Output, args: ["customActionExecuted"] }] } });
+function extractSourceName(source) {
+    const dotIndex = source.indexOf('.');
+    return dotIndex >= 0 ? source.substring(dotIndex + 1) : source;
+}
+/**
+ * Enough English to map a query source onto a type name — `Cars` to `Car`, `People` to `Person`.
+ *
+ * Deliberately a small table plus three suffix rules rather than a library: it runs against type
+ * names the application itself chose, and a wrong guess costs nothing, since the caller falls
+ * through to matching the plural and the CLR type name.
+ */
+function singularize(plural) {
+    const irregulars = {
+        'People': 'Person',
+        'Children': 'Child',
+        'Men': 'Man',
+        'Women': 'Woman',
+    };
+    if (irregulars[plural])
+        return irregulars[plural];
+    if (plural.endsWith('ies'))
+        return plural.slice(0, -3) + 'y';
+    if (plural.endsWith('es'))
+        return plural.slice(0, -2);
+    if (plural.endsWith('s'))
+        return plural.slice(0, -1);
+    return plural;
+}
+
+/**
+ * A `<bs-card>` around a {@link SparkQueryGridComponent}: icon, caption, actions, grid.
+ *
+ * ## Chrome is overridden, not replaced
+ *
+ * Every header region has a default, and a host replaces only the ones it supplies. That is what
+ * lets this component serve the auto-rendered case: a sub-query is rendered once per entry in
+ * `EntityTypeDefinition.Queries` with nobody projecting into it, and it must look right with no
+ * host cooperation at all. A slot mechanism that only ever *replaced* chrome would leave that
+ * call site blank — which is why an earlier design had the query carry its own chrome from the
+ * server. Overriding a default needs no host; replacing one does.
+ *
+ * ## Two ways in, one set of templates
+ *
+ * Hand-written markup uses the structural directives and is found with `contentChildren`.
+ * The auto-rendered path cannot: `spark-po-detail` is created by the router, so in a default app
+ * there is no tag to project into. It therefore forwards `TemplateRef`s as inputs instead — a
+ * directive cannot cross a component boundary but its template can, and that forwarding is
+ * already the idiom in `spark-po-detail` (`extraActionsTemplate`, `extraContentTemplate`).
+ *
+ * Content wins over a forwarded input: the closer declaration is the more specific one.
+ */
+class SparkQueryCardComponent {
+    lang = inject(SparkLanguageService);
+    queryId = input.required(/* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "queryId" }] : /* istanbul ignore next */ []));
+    parentId = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "parentId" }] : /* istanbul ignore next */ []));
+    parentType = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "parentType" }] : /* istanbul ignore next */ []));
+    reloadToken = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "reloadToken" }] : /* istanbul ignore next */ []));
+    data = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "data" }] : /* istanbul ignore next */ []));
+    search = input('', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "search" }] : /* istanbul ignore next */ []));
+    /**
+     * Slots forwarded from a host that cannot project content — see the class comment. A card
+     * reached through hand-written markup should use the structural directives instead.
+     */
+    iconTemplate = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "iconTemplate" }] : /* istanbul ignore next */ []));
+    captionTemplate = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "captionTemplate" }] : /* istanbul ignore next */ []));
+    actionsTemplate = input(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "actionsTemplate" }] : /* istanbul ignore next */ []));
+    error = output();
+    rowClicked = output();
+    customActionExecuted = output();
+    colors = Color;
+    iconSlots = contentChildren(SparkQueryIconDirective, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "iconSlots" }] : /* istanbul ignore next */ []));
+    captionSlots = contentChildren(SparkQueryCaptionDirective, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "captionSlots" }] : /* istanbul ignore next */ []));
+    actionSlots = contentChildren(SparkQueryActionsDirective, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "actionSlots" }] : /* istanbul ignore next */ []));
+    /**
+     * The grid, read only to surface its state — the query, the actions, the selection — to this
+     * component's own header.
+     *
+     * Optional rather than `required` on purpose. The header renders ABOVE the grid in this
+     * template, so on the first change-detection pass the view query has not resolved yet and
+     * `viewChild.required()` would throw where a plain one returns `undefined`. Everything below
+     * therefore reads it defensively; the signal updates once the view initialises and the header
+     * re-renders with the real query.
+     *
+     * A host reads grid state through a template reference variable instead, because a host may put
+     * the grid behind an `@if`, where a view query genuinely is intermittently undefined.
+     */
+    grid = viewChild(SparkQueryGridComponent, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "grid" }] : /* istanbul ignore next */ []));
+    query = computed(() => this.grid()?.query() ?? null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "query" }] : /* istanbul ignore next */ []));
+    iconTpl = computed(() => slotFor(this.iconSlots(), this.query())?.templateRef ?? this.iconTemplate(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "iconTpl" }] : /* istanbul ignore next */ []));
+    captionTpl = computed(() => slotFor(this.captionSlots(), this.query())?.templateRef ?? this.captionTemplate(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "captionTpl" }] : /* istanbul ignore next */ []));
+    actionsTpl = computed(() => slotFor(this.actionSlots(), this.query())?.templateRef ?? this.actionsTemplate(), /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "actionsTpl" }] : /* istanbul ignore next */ []));
+    /** The caption the card renders unless a slot replaces it. */
+    caption = computed(() => {
+        const q = this.query();
+        return (q?.description ? this.lang.resolve(q.description) : '') || q?.name || '';
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "caption" }] : /* istanbul ignore next */ []));
+    customActions = computed(() => this.grid()?.customActions() ?? [], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "customActions" }] : /* istanbul ignore next */ []));
+    selection = computed(() => this.grid()?.selection() ?? [], /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "selection" }] : /* istanbul ignore next */ []));
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkQueryCardComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "22.0.0", type: SparkQueryCardComponent, isStandalone: true, selector: "spark-query-card", inputs: { queryId: { classPropertyName: "queryId", publicName: "queryId", isSignal: true, isRequired: true, transformFunction: null }, parentId: { classPropertyName: "parentId", publicName: "parentId", isSignal: true, isRequired: false, transformFunction: null }, parentType: { classPropertyName: "parentType", publicName: "parentType", isSignal: true, isRequired: false, transformFunction: null }, reloadToken: { classPropertyName: "reloadToken", publicName: "reloadToken", isSignal: true, isRequired: false, transformFunction: null }, data: { classPropertyName: "data", publicName: "data", isSignal: true, isRequired: false, transformFunction: null }, search: { classPropertyName: "search", publicName: "search", isSignal: true, isRequired: false, transformFunction: null }, iconTemplate: { classPropertyName: "iconTemplate", publicName: "iconTemplate", isSignal: true, isRequired: false, transformFunction: null }, captionTemplate: { classPropertyName: "captionTemplate", publicName: "captionTemplate", isSignal: true, isRequired: false, transformFunction: null }, actionsTemplate: { classPropertyName: "actionsTemplate", publicName: "actionsTemplate", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { error: "error", rowClicked: "rowClicked", customActionExecuted: "customActionExecuted" }, queries: [{ propertyName: "iconSlots", predicate: SparkQueryIconDirective, isSignal: true }, { propertyName: "captionSlots", predicate: SparkQueryCaptionDirective, isSignal: true }, { propertyName: "actionSlots", predicate: SparkQueryActionsDirective, isSignal: true }], viewQueries: [{ propertyName: "grid", first: true, predicate: SparkQueryGridComponent, descendants: true, isSignal: true }], ngImport: i0, template: "<!--\n  The card is always rendered. A host that wants no card uses <spark-query-grid> directly \u2014 which\n  is what the old `showCard=\"false\"` meant, expressed as a component choice rather than a flag.\n-->\n<bs-card class=\"d-block my-3\">\n  <bs-card-header>\n    <div class=\"d-flex align-items-center gap-2\">\n      @if (iconTpl(); as tpl) {\n        <ng-container *ngTemplateOutlet=\"tpl; context: { $implicit: query() }\"></ng-container>\n      }\n\n      <span class=\"me-auto\">\n        @if (captionTpl(); as tpl) {\n          <ng-container *ngTemplateOutlet=\"tpl; context: { $implicit: caption(), query: query() }\"></ng-container>\n        } @else {\n          {{ caption() }}\n        }\n      </span>\n\n      @if (actionsTpl(); as tpl) {\n        <ng-container *ngTemplateOutlet=\"tpl; context: { $implicit: customActions(), selection: selection(), query: query() }\"></ng-container>\n      } @else if (customActions().length) {\n        <!-- The default: the actions the server declares for this type. The nav renders only when\n             there are any, so a query without actions is pixel-identical to a plain caption.\n\n             Disabled, not hidden: hiding makes the affordance undiscoverable and reflows the\n             priority nav on every selection change. The server enforces the same rule. -->\n        <bs-priority-nav [moreLabel]=\"lang.t('common.more')\" [collapseAt]=\"'sm'\">\n          @for (action of customActions(); track action.name) {\n            <button *bsPriorityNavItem=\"10 + action.offset\" class=\"btn btn-sm btn-outline-primary\"\n                    [disabled]=\"!grid()?.isActionEnabled(action)\" (click)=\"grid()?.onCustomAction(action)\">\n              {{ action.displayName | resolveTranslation }}\n            </button>\n          }\n        </bs-priority-nav>\n      }\n    </div>\n  </bs-card-header>\n\n  <div class=\"p-3\">\n    <spark-query-grid\n        [queryId]=\"queryId()\"\n        [parentId]=\"parentId()\"\n        [parentType]=\"parentType()\"\n        [reloadToken]=\"reloadToken()\"\n        [data]=\"data()\"\n        [search]=\"search()\"\n        (error)=\"error.emit($event)\"\n        (rowClicked)=\"rowClicked.emit($event)\"\n        (customActionExecuted)=\"customActionExecuted.emit($event)\" />\n  </div>\n</bs-card>\n", dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: BsCardComponent, selector: "bs-card", inputs: ["color", "outline"] }, { kind: "component", type: BsCardHeaderComponent, selector: "bs-card-header", inputs: ["color", "navStyle"] }, { kind: "component", type: BsPriorityNavComponent, selector: "bs-priority-nav", inputs: ["moreLabel", "moreLabelTemplate", "collapseAt", "overflowFrom", "hideEmptyMore", "ariaLabel"], outputs: ["overflowChange"] }, { kind: "directive", type: BsPriorityNavItemDirective, selector: "[bsPriorityNavItem]", inputs: ["bsPriorityNavItem", "bsPriorityNavItemHideBelow"] }, { kind: "component", type: SparkQueryGridComponent, selector: "spark-query-grid", inputs: ["queryId", "parentId", "parentType", "data", "search", "reloadToken", "settings", "selection"], outputs: ["settingsChange", "selectionChange", "error", "rowClicked", "customActionExecuted"] }, { kind: "pipe", type: ResolveTranslationPipe, name: "resolveTranslation" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.0", ngImport: i0, type: SparkQueryCardComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'spark-query-card', imports: [CommonModule, BsCardComponent, BsCardHeaderComponent, BsPriorityNavComponent, BsPriorityNavItemDirective, SparkQueryGridComponent, ResolveTranslationPipe], changeDetection: ChangeDetectionStrategy.OnPush, template: "<!--\n  The card is always rendered. A host that wants no card uses <spark-query-grid> directly \u2014 which\n  is what the old `showCard=\"false\"` meant, expressed as a component choice rather than a flag.\n-->\n<bs-card class=\"d-block my-3\">\n  <bs-card-header>\n    <div class=\"d-flex align-items-center gap-2\">\n      @if (iconTpl(); as tpl) {\n        <ng-container *ngTemplateOutlet=\"tpl; context: { $implicit: query() }\"></ng-container>\n      }\n\n      <span class=\"me-auto\">\n        @if (captionTpl(); as tpl) {\n          <ng-container *ngTemplateOutlet=\"tpl; context: { $implicit: caption(), query: query() }\"></ng-container>\n        } @else {\n          {{ caption() }}\n        }\n      </span>\n\n      @if (actionsTpl(); as tpl) {\n        <ng-container *ngTemplateOutlet=\"tpl; context: { $implicit: customActions(), selection: selection(), query: query() }\"></ng-container>\n      } @else if (customActions().length) {\n        <!-- The default: the actions the server declares for this type. The nav renders only when\n             there are any, so a query without actions is pixel-identical to a plain caption.\n\n             Disabled, not hidden: hiding makes the affordance undiscoverable and reflows the\n             priority nav on every selection change. The server enforces the same rule. -->\n        <bs-priority-nav [moreLabel]=\"lang.t('common.more')\" [collapseAt]=\"'sm'\">\n          @for (action of customActions(); track action.name) {\n            <button *bsPriorityNavItem=\"10 + action.offset\" class=\"btn btn-sm btn-outline-primary\"\n                    [disabled]=\"!grid()?.isActionEnabled(action)\" (click)=\"grid()?.onCustomAction(action)\">\n              {{ action.displayName | resolveTranslation }}\n            </button>\n          }\n        </bs-priority-nav>\n      }\n    </div>\n  </bs-card-header>\n\n  <div class=\"p-3\">\n    <spark-query-grid\n        [queryId]=\"queryId()\"\n        [parentId]=\"parentId()\"\n        [parentType]=\"parentType()\"\n        [reloadToken]=\"reloadToken()\"\n        [data]=\"data()\"\n        [search]=\"search()\"\n        (error)=\"error.emit($event)\"\n        (rowClicked)=\"rowClicked.emit($event)\"\n        (customActionExecuted)=\"customActionExecuted.emit($event)\" />\n  </div>\n</bs-card>\n" }]
+        }], propDecorators: { queryId: [{ type: i0.Input, args: [{ isSignal: true, alias: "queryId", required: true }] }], parentId: [{ type: i0.Input, args: [{ isSignal: true, alias: "parentId", required: false }] }], parentType: [{ type: i0.Input, args: [{ isSignal: true, alias: "parentType", required: false }] }], reloadToken: [{ type: i0.Input, args: [{ isSignal: true, alias: "reloadToken", required: false }] }], data: [{ type: i0.Input, args: [{ isSignal: true, alias: "data", required: false }] }], search: [{ type: i0.Input, args: [{ isSignal: true, alias: "search", required: false }] }], iconTemplate: [{ type: i0.Input, args: [{ isSignal: true, alias: "iconTemplate", required: false }] }], captionTemplate: [{ type: i0.Input, args: [{ isSignal: true, alias: "captionTemplate", required: false }] }], actionsTemplate: [{ type: i0.Input, args: [{ isSignal: true, alias: "actionsTemplate", required: false }] }], error: [{ type: i0.Output, args: ["error"] }], rowClicked: [{ type: i0.Output, args: ["rowClicked"] }], customActionExecuted: [{ type: i0.Output, args: ["customActionExecuted"] }], iconSlots: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => SparkQueryIconDirective), { isSignal: true }] }], captionSlots: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => SparkQueryCaptionDirective), { isSignal: true }] }], actionSlots: [{ type: i0.ContentChildren, args: [i0.forwardRef(() => SparkQueryActionsDirective), { isSignal: true }] }], grid: [{ type: i0.ViewChild, args: [i0.forwardRef(() => SparkQueryGridComponent), { isSignal: true }] }] } });
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { SPARK_GRID_PAGE_SIZES, SparkGridRenderers, initialGridSettings, isVirtualScrollingQuery, visibleGridAttributes };
+export { SPARK_GRID_PAGE_SIZES, SparkGridCellComponent, SparkGridRenderers, SparkQueryActionsContext, SparkQueryActionsDirective, SparkQueryCaptionContext, SparkQueryCaptionDirective, SparkQueryCardComponent, SparkQueryGridComponent, SparkQueryIconDirective, SparkQuerySlotContext, initialGridSettings, isVirtualScrollingQuery, slotFor, visibleGridAttributes };
 //# sourceMappingURL=mintplayer-ng-spark-grid.mjs.map