@mintplayer/ng-spark 22.29.0 → 22.30.0

package/types/mintplayer-ng-spark-grid.d.ts

@@ -252,6 +252,7 @@ export declare class SparkQueryGridComponent {
   /** Add-on row-menu entries (`SPARK_QUERY_ROW_ACTIONS`), e.g. Contributions' revert. */
   private readonly addonRowActions;
   readonly lang: SparkLanguageService;
+  private readonly clientMethods;
   /** Query alias or id. */
   queryId: import("@angular/core").InputSignal<string>;
   /**
@@ -549,6 +550,13 @@ export declare class SparkQueryGridComponent {
    * Every column that ships is drawn (#264): there is no shipped-but-hidden column.
    */
   allColumns: import("@angular/core").Signal<QueryColumn[]>;
+  /** The internal name of the per-row ⋮ menu's column; never shown or announced (its `label` is "Actions"). */
+  readonly rowActionsColumn = "__sparkRowActions";
+  /**
+   * The datatable's `[labels]`: the resize handle and its options dialog, translated. The column
+   * each string names comes from `bsDatatableColumnLabel` in the template. See `sparkDatatableLabels`.
+   */
+  datatableLabels: import("@angular/core").Signal<import("@mintplayer/ng-spark/services").SparkDatatableLabels>;
   /**
    * True when rows do not come from this component's own fetch.
    *
@@ -559,8 +567,16 @@ export declare class SparkQueryGridComponent {
    * before the host had anything to bind.
    */
   hasExternalData: import("@angular/core").Signal<boolean>;
-  /** Whether an action's selection rule is satisfied right now. The server checks it again. */
+  /**
+   * Whether an action can run right now: its selection rule is satisfied, and the client method it
+   * requires (`requiresClient`) is registered and supported here. The server checks the rule again.
+   */
   isActionEnabled(action: CustomActionDefinition): boolean;
+  /**
+   * Why an action is disabled regardless of the selection, translated, for its tooltip: its required
+   * client method is missing or unsupported in this browser (Q9). Null when nothing stands in the way.
+   */
+  actionUnavailableReason(action: CustomActionDefinition): string | null;
   constructor();
   /**
    * Re-run the query, keeping the current page, sort and scroll position.
@@ -872,6 +888,8 @@ export declare class SparkQueryCardComponent {
   protected readonly toolbarActions: import("@angular/core").Signal<SparkQueryToolbarAction[]>;
   protected actionClass(action: SparkQueryToolbarAction): string;
   protected isEnabled(action: SparkQueryToolbarAction): boolean;
+  /** The tooltip of an action disabled for want of its client method (`requiresClient`); null otherwise. */
+  protected unavailableReason(action: SparkQueryToolbarAction): string | null;
   protected run(action: SparkQueryToolbarAction): void;
   protected readonly selection: import("@angular/core").Signal<QueryResultItem[]>;
   static ɵfac: i0.ɵɵFactoryDeclaration<SparkQueryCardComponent, never>;

package/types/mintplayer-ng-spark-models.d.ts

@@ -169,6 +169,12 @@ export interface CustomActionDefinition {
    * `/po/new`, the edit page and `/po/delete-many`, never `/actions/execute`. Absent for a custom action.
    */
   isDefault?: boolean;
+  /**
+   * The client method the action needs in the browser (`provideSparkClientMethods`), e.g.
+   * `'webauthn.create'`. When it is not registered, or its `supported()` says no, the action is shown
+   * disabled with the reason as its tooltip. Advisory: the server still handles a cancelled step.
+   */
+  requiresClient?: string;
 }
 /**
  * Whether a grid lets the user tick rows — what `<bs-datatable>` renders. There is no single
@@ -665,19 +671,41 @@ export interface LookupReferenceValue {
   isActive: boolean;
   extra?: Record<string, unknown>;
 }
+/**
+ * The option a cancelled retry step answers with (`RetryResult.CancelOption` on the server): the
+ * modal's own Cancel button or its dismissal on a `cancellable` prompt, and a client method that did
+ * not answer. An identifier, never a label: the button shows `common.cancel` in the user's language.
+ */
+export declare const SPARK_RETRY_CANCEL = "Cancel";
 export interface RetryActionPayload {
   type: 'retry-action';
   step: number;
   title: string;
   message?: string;
+  /** The action's own options, shown as given. Never `'Cancel'`: see {@link cancellable}. */
   options: string[];
   defaultOption?: string;
   persistentObject?: PersistentObject;
+  /**
+   * Whether the modal adds its own Cancel button, labelled `common.cancel`, which, like closing the
+   * modal, answers {@link SPARK_RETRY_CANCEL}. Without it a closed modal abandons the request.
+   */
+  cancellable?: boolean;
+  /**
+   * Set when the server asks for a client method (`IRetryAccessor.Invoke`) instead of a choice: the
+   * name a method was registered under with `provideSparkClientMethods`. No modal is shown then.
+   */
+  clientMethod?: string;
+  /** The client method's argument, as the server serialized it. */
+  arguments?: unknown;
 }
 export interface RetryActionResult {
   step: number;
+  /** The option chosen. For a client-method step `'OK'` when it answered, `'Cancel'` otherwise. */
   option: string;
   persistentObject?: PersistentObject;
+  /** What the client method resolved with; absent for an ordinary prompt and for a cancelled step. */
+  value?: unknown;
 }
 export interface EntityPermissions {
   /**

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

@@ -13,6 +13,7 @@ export declare class SparkPoDetailComponent {
   private readonly queryRefresh;
   private readonly attributeRefresh;
   protected readonly lang: SparkLanguageService;
+  private readonly clientMethods;
   protected readonly rendererRegistry: import("@mintplayer/ng-spark/renderers").SparkAttributeRendererRegistration[];
   /**
    * Add-on panels and action-bar buttons (#460, `SPARK_DETAIL_PANELS` / `SPARK_DETAIL_ACTIONS`).
@@ -118,6 +119,8 @@ export declare class SparkPoDetailComponent {
   resolvedTabs: import("@angular/core").Signal<AttributeTab[]>;
   groupsForTab(tab: AttributeTab): AttributeGroup[];
   attrsForGroup(group: AttributeGroup): EntityAttributeDefinition[];
+  /** Whether the attribute's renderer asks for the whole row, without a label (`fullWidth`). */
+  isFullWidthRenderer(attr: EntityAttributeDefinition): boolean;
   getDetailRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
   /** Inputs of an AsDetail row renderer (`rowComponent`): the row and the object that owns it. */
   getRowRendererInputs(renderer: SparkResolvedRowRenderer, row: Record<string, any>, item: PersistentObject): Record<string, any>;
@@ -146,6 +149,11 @@ export declare class SparkPoDetailComponent {
    * a slow action and a broken one became indistinguishable.
    */
   runningAction: import("@angular/core").WritableSignal<string | null>;
+  /**
+   * Why an action cannot run in this browser, translated, for its tooltip: the client method it
+   * requires (`requiresClient`) is not registered or not supported here (Q9). Null otherwise.
+   */
+  protected customActionUnavailableReason(action: CustomActionDefinition): string | null;
   onCustomAction(action: CustomActionDefinition): Promise<void>;
   onEdit(): void;
   onDelete(): Promise<void>;

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

@@ -516,6 +516,8 @@ export declare class SparkReferencePickerComponent {
   searchTerm: string;
   /** The picker lists query rows, so its columns are the query's: `showedOn` includes Query (#264; not None). */
   visibleAttributes: import("@angular/core").Signal<import("@mintplayer/ng-spark/models").EntityAttributeDefinition[]>;
+  /** The resize handle and its options dialog, translated; columns are named by `bsDatatableColumnLabel`. */
+  datatableLabels: import("@angular/core").Signal<import("@mintplayer/ng-spark/services").SparkDatatableLabels>;
   rows: import("@angular/core").Signal<QueryResultItem[]>;
   displayValue: import("@angular/core").Signal<string>;
   open(): Promise<void>;

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

@@ -85,6 +85,8 @@ export declare class SparkQueryListComponent {
   protected readonly toolbarActions: import("@angular/core").Signal<SparkQueryToolbarAction[]>;
   protected toolbarActionClass(action: SparkQueryToolbarAction): string;
   protected isToolbarActionEnabled(action: SparkQueryToolbarAction): boolean;
+  /** The tooltip of an action disabled for want of its client method (`requiresClient`); null otherwise. */
+  protected toolbarActionUnavailableReason(action: SparkQueryToolbarAction): string | null;
   protected runToolbarAction(action: SparkQueryToolbarAction): void;
   protected isActionEnabled(action: CustomActionDefinition): boolean;
   isStreaming: import("@angular/core").WritableSignal<boolean>;

package/types/mintplayer-ng-spark-renderers.d.ts

@@ -1,3 +1,4 @@
+import * as i0 from "@angular/core";
 import { InjectionToken, InputSignal, Provider, Type } from "@angular/core";
 import { EntityAttributeDefinition, EntityType, PersistentObject, PersistentObjectAttribute, QueryResultItem, QueryResultItemValue, SparkCellColumn } from "@mintplayer/ng-spark/models";
 /**
@@ -136,7 +137,17 @@ export interface SparkAttributeRendererRegistration {
    * give it, which is the whole reason the renderer itself cannot be used here.
    */
   filterLabel?: (value: unknown) => string;
+  /**
+   * The detail page draws the renderer across the whole row, with no label: for text blocks such
+   * as the core `paragraph` renderer, which are body text rather than a labelled value.
+   */
+  fullWidth?: boolean;
 }
+/**
+ * The renderers ng-spark ships itself, available in every app without registration. An app's own
+ * registration of the same name wins (it comes first in the list).
+ */
+export declare const sparkCoreRenderers: readonly SparkAttributeRendererRegistration[];
 export declare const SPARK_ATTRIBUTE_RENDERERS: InjectionToken<SparkAttributeRendererRegistration[]>;
 /**
  * Register custom attribute renderers globally.
@@ -148,6 +159,42 @@ export declare const SPARK_ATTRIBUTE_RENDERERS: InjectionToken<SparkAttributeRen
  * ])
  */
 export declare function provideSparkAttributeRenderers(renderers: SparkAttributeRendererRegistration[]): Provider;
+/**
+ * The core `paragraph` renderer (generic passkeys page, D5): a read-only string shown as body text,
+ * full width and without a label — an explanatory text block on a persistent object, filled from
+ * translations by the actions class. Pair it with `showedOn: PersistentObject` so it never becomes a
+ * grid column.
+ *
+ * **Escaped by default.** The value is interpolated, so markup in it is shown as text. A blank line
+ * starts a new paragraph and a single newline is a line break.
+ *
+ * `"rendererOptions": { "sanitize": false }` renders the value as HTML instead, through Angular's
+ * `[innerHTML]`, whose sanitizer still strips scripts, event handlers and `javascript:` URLs. There is
+ * deliberately no `bypassSecurityTrustHtml` anywhere on this path: the opt-out is "allow markup",
+ * never "allow script".
+ */
+export declare class SparkParagraphRendererComponent implements SparkAttributeDetailRenderer {
+  readonly value: import("@angular/core").InputSignal<any>;
+  readonly options: import("@angular/core").InputSignal<Record<string, any> | undefined>;
+  protected readonly text: import("@angular/core").Signal<string>;
+  /** Only an explicit `false` opts out of escaping; anything else, absent included, escapes. */
+  protected readonly asHtml: import("@angular/core").Signal<boolean>;
+  /** Paragraphs split on blank lines, each a list of its lines. */
+  protected readonly paragraphs: import("@angular/core").Signal<string[][]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkParagraphRendererComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkParagraphRendererComponent, "spark-paragraph-renderer", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
 /** The row renderer of an AsDetail row type, resolved once per type (see `rowComponent`). */
 export interface SparkResolvedRowRenderer {
   component: Type<any>;

package/types/mintplayer-ng-spark-retry-action-modal.d.ts

@@ -15,6 +15,7 @@ export declare class SparkRetryActionModalComponent {
   protected readonly retryActionService: RetryActionService;
   private readonly sparkService;
   colors: typeof Color;
+  protected readonly cancel = "Cancel";
   isOpen: import("@angular/core").Signal<boolean>;
   /**
    * EntityType definition for the incoming PO — fetched lazily via SparkService so the

package/types/mintplayer-ng-spark-services.d.ts

@@ -102,6 +102,7 @@ export declare class SparkService {
    */
   private static readonly MAX_RETRY_DEPTH;
   private readonly dispatcher;
+  private readonly clientMethods;
   getEntityTypes(): Promise<EntityType[]>;
   /**
    * One entity type, shaped by the caller's attribute rights. `purpose` narrows it for one form (#264, G1/G2):
@@ -492,4 +493,29 @@ export declare class SparkReturnNavigationService {
   listRouteFor(entityTypeName: string): Promise<unknown[] | null>;
   static ɵfac: i0.ɵɵFactoryDeclaration<SparkReturnNavigationService, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
-}
+}
+/** The `<bs-datatable>` strings Spark translates: the column-resize handle and its options dialog. */
+export interface SparkDatatableLabels {
+  resizeColumn: (column: string) => string;
+  resizeColumnHint: string;
+  resizeColumnOptions: (column: string) => string;
+  narrowerColumn: (column: string) => string;
+  widerColumn: (column: string) => string;
+  columnWidth: (px: number) => string;
+  fitColumn: string;
+  resetColumn: string;
+}
+/**
+ * The `[labels]` a Spark `<bs-datatable>` passes so the column-resize handle, its keymap
+ * announcement and its resize options dialog (ng-bootstrap 22.22.0 / web-components 2.19.0) speak
+ * the viewer's language.
+ *
+ * The `column` these formatters receive is the column's label: every Spark grid binds
+ * `bsDatatableColumnLabel` to the header's translated text (and the row-actions column to
+ * "Actions"), so the datatable no longer falls back to the internal name. The keys omitted here
+ * keep the web component's English defaults.
+ *
+ * Every translation is read EAGERLY, so a `computed` that calls this tracks the language and the
+ * translation map, and hands the datatable a new object — which re-renders it — when either changes.
+ */
+export declare function sparkDatatableLabels(lang: SparkLanguageService): SparkDatatableLabels;