@mintplayer/ng-spark 22.3.0 → 22.4.0

package/types/mintplayer-ng-spark-po-detail.d.ts

@@ -2,10 +2,7 @@ import * as _angular_core from '@angular/core';
 import { TemplateRef, Type } from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
 import { SparkLanguageService } from '@mintplayer/ng-spark/services';
-import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { PersistentObject, EntityType, CustomActionDefinition, LookupReference, EntityAttributeDefinition, AttributeTab, AttributeGroup, SparkQuery } from '@mintplayer/ng-spark/models';
-import { HttpErrorResponse } from '@angular/common/http';
-import { DatatableSettings, BsDatatableFetch } from '@mintplayer/ng-bootstrap/datatable';
+import { PersistentObject, EntityType, CustomActionDefinition, LookupReference, EntityAttributeDefinition, AttributeTab, AttributeGroup } from '@mintplayer/ng-spark/models';
 
 declare class SparkPoDetailComponent {
     private readonly route;
@@ -20,6 +17,21 @@ declare class SparkPoDetailComponent {
         $implicit: PersistentObject;
         entityType: EntityType;
     }> | null>;
+    /**
+     * Header slots forwarded to every sub-query card on this page.
+     *
+     * A structural directive cannot cross a component boundary, and this component is created by
+     * the router — in a default app there is no `<spark-po-detail>` tag to project content into.
+     * So an app that wants slotted chrome on its sub-queries substitutes its own route component
+     * via `SparkRouteConfig.poDetail` and forwards the templates through here. Forwarding a
+     * `TemplateRef` as an input is already this component's idiom; see the two above.
+     *
+     * Each slot may target one query by alias, so a single forwarded set serves a page rendering
+     * several sub-queries.
+     */
+    queryIconTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    queryCaptionTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
+    queryActionsTemplate: _angular_core.InputSignal<TemplateRef<any> | null>;
     edited: _angular_core.OutputEmitterRef<void>;
     deleted: _angular_core.OutputEmitterRef<void>;
     customActionExecuted: _angular_core.OutputEmitterRef<{
@@ -59,140 +71,7 @@ declare class SparkPoDetailComponent {
     onDelete(): Promise<void>;
     onBack(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoDetailComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoDetailComponent, "spark-po-detail", never, { "showCustomActions": { "alias": "showCustomActions"; "required": false; "isSignal": true; }; "extraActionsTemplate": { "alias": "extraActionsTemplate"; "required": false; "isSignal": true; }; "extraContentTemplate": { "alias": "extraContentTemplate"; "required": false; "isSignal": true; }; }, { "edited": "edited"; "deleted": "deleted"; "customActionExecuted": "customActionExecuted"; }, never, never, true, never>;
-}
-
-declare class SparkSubQueryComponent {
-    private readonly sparkService;
-    private readonly gridRenderers;
-    readonly lang: SparkLanguageService;
-    queryId: _angular_core.InputSignal<string>;
-    /**
-     * 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. Leaving these required 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: _angular_core.InputSignal<string>;
-    parentType: _angular_core.InputSignal<string>;
-    /**
-     * 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. Nothing else in ng-spark
-     * uses `viewChild` either — the house idiom is to re-seed a signal.
-     *
-     * 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: _angular_core.InputSignal<unknown>;
-    /**
-     * Render without the surrounding card, for a host that owns its own chrome — a tab
-     * body, a modal, a dashboard tile.
-     *
-     * This is the escape hatch for a genuinely chromeless embed. It only serves a host
-     * that instantiated this component by hand — where the component is auto-rendered
-     * from `EntityTypeDefinition.Queries` there is no host to pass it.
-     */
-    showCard: _angular_core.InputSignal<boolean>;
-    /**
-     * Replace the header for one hand-instantiated usage.
-     *
-     * A `TemplateRef` rather than `<ng-content>` deliberately: it matches
-     * `spark-po-detail`'s `extraActionsTemplate`/`extraContentTemplate`, and unlike
-     * projection it can be forwarded by a host that is itself several layers up.
-     *
-     * Precedence is headerTemplate -> caption + query actions.
-     */
-    headerTemplate: _angular_core.InputSignal<TemplateRef<{
-        $implicit: SparkQuery;
-    }> | null>;
-    colors: typeof Color;
-    query: _angular_core.WritableSignal<SparkQuery | null>;
-    entityType: _angular_core.WritableSignal<EntityType | null>;
-    allEntityTypes: _angular_core.WritableSignal<EntityType[]>;
-    /**
-     * 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.
-     *
-     * A 404 is deliberately vague. `Endpoints/Queries/Get.cs` answers 404 for BOTH
-     * "no such query" and "you may not see it", with byte-identical bodies, so that
-     * existence is not disclosed (security audit M-3). This component therefore
-     * genuinely cannot tell the two apart, and any message claiming otherwise would
-     * either leak or mislead.
-     */
-    errorMessage: _angular_core.WritableSignal<string | null>;
-    /**
-     * Actions the query declares, rendered in this component's own header.
-     *
-     * This is what makes a query's chrome work with no host: a sub-query is rendered
-     * automatically from `EntityTypeDefinition.Queries`, so there is nobody to project
-     * a toolbar in. The query says what belongs in its header, and it follows the query
-     * wherever it is rendered.
-     */
-    customActions: _angular_core.WritableSignal<CustomActionDefinition[]>;
-    /** Emitted whenever a load or a page fetch fails, for a host in bespoke chrome. */
-    error: _angular_core.OutputEmitterRef<HttpErrorResponse>;
-    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
-    loading: _angular_core.WritableSignal<boolean>;
-    canRead: _angular_core.WritableSignal<boolean>;
-    settings: _angular_core.WritableSignal<DatatableSettings>;
-    fetchFn: _angular_core.WritableSignal<BsDatatableFetch<PersistentObject> | null>;
-    /**
-     * Rows the user has ticked. Lives here rather than in the datatable so the action bar can
-     * read it, and MUST be cleared whenever the source changes — otherwise route A's selection
-     * is POSTed as ids of route B's type.
-     */
-    selection: _angular_core.WritableSignal<PersistentObject[]>;
-    private readonly queryRefresh;
-    /** 'none' unless an action is selection-gated, so unaffected grids gain no checkbox column. */
-    selectionMode: _angular_core.Signal<_mintplayer_ng_spark_models.SparkSelectionMode>;
-    /** Whether an action's selection rule is satisfied right now. The server checks it again. */
-    isActionEnabled(action: CustomActionDefinition): boolean;
-    isVirtualScrolling: _angular_core.Signal<boolean>;
-    visibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
-    constructor();
-    /**
-     * 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, mirroring
-     * `SparkQueryListComponent.reload()`. Use it after something mutates server-side
-     * state the query reads from. For a definition change — new columns, a renamed
-     * query — the inputs themselves must change; that is the expensive path.
-     */
-    onCustomAction(action: CustomActionDefinition): Promise<void>;
-    private reportError;
-    /**
-     * 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 (audit M-3). The
-     * component therefore cannot tell them apart, and both "Not found" and "Access
-     * denied" would be a guess — one of them leaking, the other misleading.
-     */
-    private describe;
-    reload(): void;
-    private loadData;
-    private makeFetch;
-    private loadLookupReferenceOptions;
-    getColumnRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
-    getColumnRendererInputs(component: Type<any>, item: PersistentObject, attr: EntityAttributeDefinition): Record<string, any>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkSubQueryComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkSubQueryComponent, "spark-sub-query", never, { "queryId": { "alias": "queryId"; "required": true; "isSignal": true; }; "parentId": { "alias": "parentId"; "required": false; "isSignal": true; }; "parentType": { "alias": "parentType"; "required": false; "isSignal": true; }; "reloadToken": { "alias": "reloadToken"; "required": false; "isSignal": true; }; "showCard": { "alias": "showCard"; "required": false; "isSignal": true; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; "isSignal": true; }; }, { "error": "error"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoDetailComponent, "spark-po-detail", never, { "showCustomActions": { "alias": "showCustomActions"; "required": false; "isSignal": true; }; "extraActionsTemplate": { "alias": "extraActionsTemplate"; "required": false; "isSignal": true; }; "extraContentTemplate": { "alias": "extraContentTemplate"; "required": false; "isSignal": true; }; "queryIconTemplate": { "alias": "queryIconTemplate"; "required": false; "isSignal": true; }; "queryCaptionTemplate": { "alias": "queryCaptionTemplate"; "required": false; "isSignal": true; }; "queryActionsTemplate": { "alias": "queryActionsTemplate"; "required": false; "isSignal": true; }; }, { "edited": "edited"; "deleted": "deleted"; "customActionExecuted": "customActionExecuted"; }, never, never, true, never>;
 }
 
-export { SparkPoDetailComponent, SparkSubQueryComponent };
+export { SparkPoDetailComponent };

package/types/mintplayer-ng-spark-query-list.d.ts

@@ -1,19 +1,34 @@
 import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { PersistentObject, CustomActionDefinition, SparkQuery, EntityType, LookupReference, EntityAttributeDefinition } from '@mintplayer/ng-spark/models';
+import { PersistentObject, CustomActionDefinition } from '@mintplayer/ng-spark/models';
 import * as _angular_core from '@angular/core';
-import { TemplateRef, Type } from '@angular/core';
+import { TemplateRef } from '@angular/core';
 import { Color } from '@mintplayer/ng-bootstrap';
-import { BsDatatableFetch, DatatableSettings } from '@mintplayer/ng-bootstrap/datatable';
 import { SparkLanguageService } from '@mintplayer/ng-spark/services';
 
+/**
+ * The routed query page: chrome around one {@link SparkQueryGridComponent}.
+ *
+ * It owns what is genuinely page-shaped and route-shaped, and nothing else:
+ *
+ *  - **Route resolution.** It has no `queryId` input; it reads `paramMap`, and it serves two
+ *    routes — `query/:queryId`, and `po/:type`, which resolves an entity type to a query. That
+ *    second one is type-to-query resolution, not query rendering, and is why this component still
+ *    exists rather than the router pointing at the grid.
+ *  - **Streaming.** The websocket lives here so it stays out of every PO detail page's bundle;
+ *    the snapshot is filtered and sorted client-side and handed to the grid as `[data]`.
+ *  - The action bar, the caption, the LIVE badge, the search box and the New button.
+ *
+ * The grid itself — columns, cells, paging, the row link, selection, custom-action execution —
+ * is the shared component. This page previously wrote out `<bs-datatable>` twice, once per
+ * transport, with a shared row template between them; both are gone.
+ */
 declare class SparkQueryListComponent {
     private readonly route;
     private readonly router;
     private readonly sparkService;
     private readonly streamingService;
-    protected readonly lang: SparkLanguageService;
-    private readonly gridRenderers;
     private readonly destroyRef;
+    protected readonly lang: SparkLanguageService;
     extraActionsTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
     showCustomActions: _angular_core.InputSignal<boolean>;
     rowClicked: _angular_core.OutputEmitterRef<PersistentObject>;
@@ -22,76 +37,48 @@ declare class SparkQueryListComponent {
         action: CustomActionDefinition;
     }>;
     colors: typeof Color;
+    /** The query the grid should render, resolved from the route. Null until it is known. */
+    queryId: _angular_core.WritableSignal<string | null>;
     errorMessage: _angular_core.WritableSignal<string | null>;
-    query: _angular_core.WritableSignal<SparkQuery | null>;
-    entityType: _angular_core.WritableSignal<EntityType | null>;
-    allEntityTypes: _angular_core.WritableSignal<EntityType[]>;
-    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
-    resultCount: _angular_core.WritableSignal<number | null>;
-    searchTerm: string;
-    canRead: _angular_core.WritableSignal<boolean>;
-    canCreate: _angular_core.WritableSignal<boolean>;
-    customActions: _angular_core.WritableSignal<CustomActionDefinition[]>;
-    isStreaming: _angular_core.WritableSignal<boolean>;
-    private streamingSub;
-    private allItems;
-    streamItems: _angular_core.WritableSignal<PersistentObject[]>;
-    fetchFn: _angular_core.WritableSignal<BsDatatableFetch<PersistentObject> | null>;
-    settings: _angular_core.WritableSignal<DatatableSettings>;
-    constructor();
-    private onParamsChange;
-    /**
-     * A load failure has to render, not just be swallowed: a denied query answers 404
-     * (audit M-3, so existence is not leaked), which is indistinguishable from a missing
-     * one -- hence a deliberately generic message rather than a guess at which it was.
-     */
-    private reportLoadFailure;
-    onCustomAction(action: CustomActionDefinition): Promise<void>;
-    private resolveEntityTypeForQuery;
-    private extractSourceName;
-    private singularize;
-    /**
-     * Builds the server-side fetch callback the datatable invokes per page/sort.
-     * Reads `searchTerm` live, so a settings change (or a new fetchFn identity)
-     * refetches with the current search term.
-     */
-    private makeFetch;
+    searchTerm: _angular_core.WritableSignal<string>;
+    private readonly grid;
     /**
-     * Force a refetch (e.g. after a custom action) without changing page/sort.
+     * Grid state, surfaced for this page's chrome.
      *
-     * Public so a host can drive it, and named to match
-     * `SparkSubQueryComponent.reload()` — the two grids had drifted into having the
-     * same mechanism under different names, one of them unreachable.
+     * Optional `viewChild`, read defensively: the action bar and caption render above the grid, so
+     * on the first change-detection pass the query has not resolved yet.
      */
-    reload(): void;
-    onSearchChange(): void;
-    clearSearch(): void;
+    protected readonly query: _angular_core.Signal<_mintplayer_ng_spark_models.SparkQuery | null>;
+    protected readonly entityType: _angular_core.Signal<_mintplayer_ng_spark_models.EntityType | null>;
+    protected readonly customActions: _angular_core.Signal<CustomActionDefinition[]>;
+    protected readonly canCreate: _angular_core.Signal<boolean>;
+    protected readonly resultCount: _angular_core.Signal<number | null>;
+    protected readonly isVirtualScrolling: _angular_core.Signal<boolean>;
+    protected readonly gridError: _angular_core.Signal<string | null>;
+    /** Whether an action's selection rule is satisfied. Delegated: the grid holds the selection. */
+    protected isActionEnabled(action: CustomActionDefinition): boolean;
+    isStreaming: _angular_core.WritableSignal<boolean>;
+    private streamingSub;
+    private readonly allItems;
+    private readonly streamItems;
     /**
-     * Whether the first column links to a detail page.
+     * Rows handed to the grid, or `null` to let it fetch for itself.
      *
-     * Declared by the query, because the framework cannot derive it: `Database.*` rows
-     * are always real documents, but a `Custom.*` query may return loadable documents
-     * (Fleet's Stolen_Cars) or rows fabricated in memory (StreamItems). Absent means
-     * navigable -- defaulting Custom.* to false would strip the working links off every
-     * custom query that does return documents.
+     * Null for a normal query — an empty array would read as "here are no rows" and suppress the
+     * fetch entirely.
      */
+    protected readonly gridData: _angular_core.Signal<PersistentObject[] | null>;
+    constructor();
+    private onParamsChange;
     /**
-     * Rows the user has ticked. Lives here rather than in the datatable so the action bar can
-     * read it, and MUST be cleared whenever the source changes — otherwise route A's selection
-     * is POSTed as ids of route B's type.
+     * A load failure has to render, not just be swallowed: a denied query answers 404 (audit M-3, so
+     * existence is not leaked), which is indistinguishable from a missing one — hence a deliberately
+     * generic message rather than a guess at which it was.
      */
-    selection: _angular_core.WritableSignal<PersistentObject[]>;
-    private readonly queryRefresh;
-    /** 'none' unless an action is selection-gated, so unaffected grids gain no checkbox column. */
-    selectionMode: _angular_core.Signal<_mintplayer_ng_spark_models.SparkSelectionMode>;
-    /** Whether an action's selection rule is satisfied right now. The server checks it again. */
-    isActionEnabled(action: CustomActionDefinition): boolean;
-    isVirtualScrolling: _angular_core.Signal<boolean>;
-    visibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
-    getColumnRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
-    getColumnRendererInputs(component: Type<any>, item: PersistentObject, attr: EntityAttributeDefinition): Record<string, any>;
-    private loadLookupReferenceOptions;
-    onCreate(): void;
+    private reportLoadFailure;
+    protected onCustomAction(action: CustomActionDefinition): Promise<void>;
+    protected onCreate(): void;
+    protected clearSearch(): void;
     private connectStreaming;
     private disconnectStreaming;
     private handleStreamingMessage;