@mintplayer/ng-spark 22.23.0 → 22.25.0

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

@@ -1,117 +1,180 @@
-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 { PersistentObject, EntityType, CustomActionDefinition, LookupReference, QueryResultItem, EntityAttributeDefinition, AttributeTab, AttributeGroup } from '@mintplayer/ng-spark/models';
-
-declare class SparkPoDetailComponent {
-    private readonly route;
-    private readonly router;
-    private readonly sparkService;
-    private readonly queryRefresh;
-    private readonly attributeRefresh;
-    protected readonly lang: SparkLanguageService;
-    private readonly rendererRegistry;
-    showCustomActions: _angular_core.InputSignal<boolean>;
-    extraActionsTemplate: _angular_core.InputSignal<TemplateRef<void> | null>;
-    extraContentTemplate: _angular_core.InputSignal<TemplateRef<{
-        $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<{
-        action: CustomActionDefinition;
-        item: PersistentObject;
-    }>;
-    colors: typeof Color;
-    errorMessage: _angular_core.WritableSignal<string | null>;
-    entityType: _angular_core.WritableSignal<EntityType | null>;
-    allEntityTypes: _angular_core.WritableSignal<EntityType[]>;
-    item: _angular_core.WritableSignal<PersistentObject | null>;
-    lookupReferenceOptions: _angular_core.WritableSignal<Record<string, LookupReference>>;
-    asDetailTypes: _angular_core.WritableSignal<Record<string, EntityType>>;
-    asDetailReferenceOptions: _angular_core.WritableSignal<Record<string, Record<string, QueryResultItem[]>>>;
-    type: string;
-    id: string;
-    canEdit: _angular_core.WritableSignal<boolean>;
-    canDelete: _angular_core.WritableSignal<boolean>;
-    customActions: _angular_core.WritableSignal<CustomActionDefinition[]>;
-    /**
-     * The actions actually offered for the object on screen.
-     *
-     * The catalogue at `/spark/actions/{objectTypeId}` is per TYPE -- the server is never told which
-     * row is open -- so an action that applies to only some rows cannot be filtered there. The
-     * entity's actions hook decides while it has the entity in hand and withholds what does not
-     * apply, and the object arrives carrying that answer.
-     *
-     * An affordance, not a permission: the endpoint stays reachable and the action handler still
-     * refuses on its own terms. What this prevents is offering a destructive action where it cannot
-     * possibly apply -- Coverage showed an irreversible red "Delete data" button on every repository
-     * page, healthy ones included, and only admitted it would refuse after the confirmation prompt.
-     */
-    visibleCustomActions: _angular_core.Signal<CustomActionDefinition[]>;
-    constructor();
-    /**
-     * Applies patched attribute values in place, without a re-fetch.
-     *
-     * The operation carries the value the server computed after its own write, so this is both
-     * cheaper and more correct than re-reading: a re-read goes through a RavenDB index that may
-     * still be stale from the very write that produced the patch, and would show the old value.
-     */
-    private applyAttributePatches;
-    private onParamsChange;
-    visibleAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
-    private static readonly DEFAULT_TAB;
-    ungroupedAttributes: _angular_core.Signal<EntityAttributeDefinition[]>;
-    resolvedTabs: _angular_core.Signal<AttributeTab[]>;
-    groupsForTab(tab: AttributeTab): AttributeGroup[];
-    attrsForGroup(group: AttributeGroup): EntityAttributeDefinition[];
-    getDetailRendererComponent(attr: EntityAttributeDefinition): Type<any> | null;
-    getDetailRendererInputs(component: Type<any>, attr: EntityAttributeDefinition, item: PersistentObject): Record<string, any>;
-    /** Column renderer for a cell of an AsDetail sub-table (so embedded rows honor `col.renderer` too). */
-    getAsDetailCellRendererComponent(col: EntityAttributeDefinition): Type<any> | null;
-    getAsDetailCellRendererInputs(component: Type<any>, row: Record<string, any>, col: EntityAttributeDefinition): Record<string, any>;
-    private loadLookupReferenceOptions;
-    private loadAsDetailTypes;
-    /**
-     * The bootstrap classes for a custom action's button. Outline-primary stays the default, so
-     * every existing action looks exactly as it did; a server-declared variant opts one action into
-     * a louder style. Restricted to a known set rather than interpolated, because the value arrives
-     * from a JSON file and must not be able to put arbitrary classes on the button.
-     */
-    protected customActionClass(action: CustomActionDefinition): string;
-    /**
-     * The action currently running, or null. Drives the disabled state on every custom-action
-     * button.
-     *
-     * A custom action is not necessarily quick: Coverage's Resync makes paged GitHub App calls for
-     * every account the caller manages, inside the request. Without this the button stayed live and
-     * looked inert for several seconds, and a second click queued a second full run -- which is how
-     * a slow action and a broken one became indistinguishable.
-     */
-    runningAction: _angular_core.WritableSignal<string | null>;
-    onCustomAction(action: CustomActionDefinition): Promise<void>;
-    onEdit(): void;
-    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; }; "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 };
+import * as i0 from "@angular/core";
+import { TemplateRef, Type } from "@angular/core";
+import { Color } from "@mintplayer/ng-bootstrap";
+import { SparkLanguageService } from "@mintplayer/ng-spark/services";
+import { SparkResolvedRowRenderer } from "@mintplayer/ng-spark/renderers";
+import { AttributeGroup, AttributeTab, CustomActionDefinition, EntityAttributeDefinition, EntityPermissions, EntityType, LookupReference, PersistentObject, QueryResultItem, SparkDeletedFilter } from "@mintplayer/ng-spark/models";
+import { SparkDetailContext } from "@mintplayer/ng-spark/panels";
+export declare class SparkPoDetailComponent {
+  private readonly route;
+  private readonly router;
+  private readonly sparkService;
+  private readonly returnNavigation;
+  private readonly queryRefresh;
+  private readonly attributeRefresh;
+  protected readonly lang: SparkLanguageService;
+  protected readonly rendererRegistry: import("@mintplayer/ng-spark/renderers").SparkAttributeRendererRegistration[];
+  /**
+   * Add-on panels and action-bar buttons (#460, `SPARK_DETAIL_PANELS` / `SPARK_DETAIL_ACTIONS`).
+   * Multi-provided, so History, SoftDelete and Moderation can each add theirs to the page
+   * `sparkRoutes()` routes to, which is created by the router and takes no templates.
+   */
+  protected readonly detailPanels: import("@mintplayer/ng-spark/panels").SparkDetailPanel[];
+  protected readonly detailActions: import("@mintplayer/ng-spark/panels").SparkDetailAction[];
+  showCustomActions: import("@angular/core").InputSignal<boolean>;
+  extraActionsTemplate: import("@angular/core").InputSignal<TemplateRef<void> | null>;
+  extraContentTemplate: import("@angular/core").InputSignal<TemplateRef<{
+    $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: import("@angular/core").InputSignal<TemplateRef<any> | null>;
+  queryCaptionTemplate: import("@angular/core").InputSignal<TemplateRef<any> | null>;
+  queryActionsTemplate: import("@angular/core").InputSignal<TemplateRef<any> | null>;
+  edited: import("@angular/core").OutputEmitterRef<void>;
+  deleted: import("@angular/core").OutputEmitterRef<void>;
+  customActionExecuted: import("@angular/core").OutputEmitterRef<{
+    action: CustomActionDefinition;
+    item: PersistentObject;
+  }>;
+  colors: typeof Color;
+  errorMessage: import("@angular/core").WritableSignal<string | null>;
+  entityType: import("@angular/core").WritableSignal<EntityType | null>;
+  /** The sub-queries rendered as cards below the form, in object form (#460, D17). */
+  protected readonly subQueries: import("@angular/core").Signal<import("@mintplayer/ng-spark/models").SparkSubQuery[]>;
+  allEntityTypes: import("@angular/core").WritableSignal<EntityType[]>;
+  item: import("@angular/core").WritableSignal<PersistentObject | null>;
+  lookupReferenceOptions: import("@angular/core").WritableSignal<Record<string, LookupReference>>;
+  asDetailTypes: import("@angular/core").WritableSignal<Record<string, EntityType>>;
+  asDetailReferenceOptions: import("@angular/core").WritableSignal<Record<string, Record<string, QueryResultItem[]>>>;
+  type: string;
+  id: string;
+  canEdit: import("@angular/core").WritableSignal<boolean>;
+  canDelete: import("@angular/core").WritableSignal<boolean>;
+  customActions: import("@angular/core").WritableSignal<CustomActionDefinition[]>;
+  /** Type-level rights, kept for the add-on context; null until loaded. */
+  permissions: import("@angular/core").WritableSignal<EntityPermissions | null>;
+  /**
+   * The route's `?deleted=` mode (#460, T2): `only` when the row was opened from the recycle bin.
+   * Sent with every load of this object; the server honours it only for `ViewDeleted` holders, so
+   * for anyone else a deleted row stays a 404.
+   */
+  deletedMode: import("@angular/core").WritableSignal<SparkDeletedFilter | null>;
+  /** True when the page shows a soft-deleted row: nothing but Restore/Purge applies to it. */
+  protected readonly isDeletedView: import("@angular/core").Signal<boolean>;
+  /** What every add-on panel and action receives; rebuilt whenever the object or rights change. */
+  protected readonly detailContext: import("@angular/core").Signal<SparkDetailContext | null>;
+  /**
+   * The actions actually offered for the object on screen.
+   *
+   * The catalogue at `/spark/actions/{objectTypeId}` is per TYPE -- the server is never told which
+   * row is open -- so an action that applies to only some rows cannot be filtered there. The
+   * entity's actions hook decides while it has the entity in hand and withholds what does not
+   * apply, and the object arrives carrying that answer.
+   *
+   * Since #460 (D13) the server asks the same hook again when the action is submitted and refuses a
+   * disabled one with 403, so hiding it here matches what the server will do. What this prevents is
+   * offering a destructive action where it cannot possibly apply -- Coverage showed an irreversible
+   * red "Delete data" button on every repository page, healthy ones included, and only admitted it
+   * would refuse after the confirmation prompt.
+   */
+  visibleCustomActions: import("@angular/core").Signal<CustomActionDefinition[]>;
+  constructor();
+  /**
+   * Applies patched attribute values in place, without a re-fetch.
+   *
+   * The operation carries the value the server computed after its own write, so this is both
+   * cheaper and more correct than re-reading: a re-read goes through a RavenDB index that may
+   * still be stale from the very write that produced the patch, and would show the old value.
+   */
+  private applyAttributePatches;
+  private onParamsChange;
+  /** The object as the page's current mode sees it. Only a set mode is sent. */
+  private loadItem;
+  /** (Re)loads the object, its type, rights and actions. Also what add-ons call via `context.reload()`. */
+  load(): Promise<void>;
+  visibleAttributes: import("@angular/core").Signal<EntityAttributeDefinition[]>;
+  private static readonly DEFAULT_TAB;
+  ungroupedAttributes: import("@angular/core").Signal<EntityAttributeDefinition[]>;
+  resolvedTabs: import("@angular/core").Signal<AttributeTab[]>;
+  groupsForTab(tab: AttributeTab): AttributeGroup[];
+  attrsForGroup(group: AttributeGroup): EntityAttributeDefinition[];
+  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>;
+  getDetailRendererInputs(component: Type<any>, attr: EntityAttributeDefinition, item: PersistentObject): Record<string, any>;
+  /** Column renderer for a cell of an AsDetail sub-table (so embedded rows honor `col.renderer` too). */
+  getAsDetailCellRendererComponent(col: EntityAttributeDefinition): Type<any> | null;
+  getAsDetailCellRendererInputs(component: Type<any>, row: Record<string, any>, col: EntityAttributeDefinition): Record<string, any>;
+  private loadLookupReferenceOptions;
+  private loadAsDetailTypes;
+  /**
+   * The bootstrap classes for a custom action's button. Outline-primary stays the default, so
+   * every existing action looks exactly as it did; a server-declared variant opts one action into
+   * a louder style. Restricted to a known set rather than interpolated, because the value arrives
+   * from a JSON file and must not be able to put arbitrary classes on the button.
+   */
+  protected customActionClass(action: CustomActionDefinition): string;
+  /**
+   * The action currently running, or null. Drives the disabled state on every custom-action
+   * button.
+   *
+   * A custom action is not necessarily quick: Coverage's Resync makes paged GitHub App calls for
+   * every account the caller manages, inside the request. Without this the button stayed live and
+   * looked inert for several seconds, and a second click queued a second full run -- which is how
+   * a slow action and a broken one became indistinguishable.
+   */
+  runningAction: import("@angular/core").WritableSignal<string | null>;
+  onCustomAction(action: CustomActionDefinition): Promise<void>;
+  onEdit(): void;
+  onDelete(): Promise<void>;
+  onBack(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkPoDetailComponent, never>;
+  static ɵcmp: i0.ɵɵ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>;
+}