@mintplayer/ng-spark 22.23.0 → 22.24.0

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

@@ -1,117 +1,177 @@
-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 { 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;
+  private readonly rendererRegistry;
+  /**
+   * 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;
+  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>;
+}

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

@@ -1,65 +1,64 @@
-import * as _mintplayer_ng_spark_models from '@mintplayer/ng-spark/models';
-import { PersistentObject, EntityType, RefreshOverlay, ValidationError } from '@mintplayer/ng-spark/models';
-import * as _angular_core from '@angular/core';
-import { Color } from '@mintplayer/ng-bootstrap';
-
-declare class SparkPoEditComponent {
-    private readonly route;
-    private readonly router;
-    private readonly sparkService;
-    private readonly language;
-    saved: _angular_core.OutputEmitterRef<PersistentObject>;
-    cancelled: _angular_core.OutputEmitterRef<void>;
-    colors: typeof Color;
-    entityType: _angular_core.WritableSignal<EntityType | null>;
-    item: _angular_core.WritableSignal<PersistentObject | null>;
-    type: string;
-    id: string;
-    formData: _angular_core.WritableSignal<Record<string, any>>;
-    /**
-     * Bound two-way to the form, which is where refreshes land. Read by
-     * {@link getEditableAttributes} so the save sees the object the user was actually shown.
-     */
-    refreshOverlay: _angular_core.WritableSignal<RefreshOverlay>;
-    validationErrors: _angular_core.WritableSignal<ValidationError[]>;
-    isSaving: _angular_core.WritableSignal<boolean>;
-    private allEntityTypes;
-    generalErrors: _angular_core.Signal<ValidationError[]>;
-    constructor();
-    private onParamsChange;
-    initFormData(): void;
-    /**
-     * Resolves a nested AsDetail type by CLR name, for rebuilding the nested PO wire shape on save.
-     *
-     * ⚠️ <b>`detailTypes` first, catalogue second.</b> The catalogue from `/spark/types` is
-     * <b>Query-gated</b>, and an AsDetail row type usually has no rights of its own — nobody grants
-     * `Query/GateSettings`, because a gate is edited through the Repository that owns it. So the
-     * catalogue does not contain it, the resolver returned undefined, and the save quietly took the
-     * scalar branch: the attribute went out as a raw dict under `value` instead of a nested PO under
-     * `object`, the server could not map it, and `EntityMapper`'s conversion `catch` swallowed the
-     * failure. The save reported success and wrote nothing.
-     * <para>
-     * `detailTypes` is the parent's own copy of its row types, carried on the type definition for
-     * exactly this reason (#385 fixed the rendering half; this is the save half). It is gated on the
-     * parent's right, which is the right that governs editing the row anyway.
-     * </para>
-     */
-    private resolveEntityType;
-    /**
-     * The attributes this page will read values from when it builds the save.
-     *
-     * ⚠️ <b>Overlaid before filtering, not after loading.</b> A refresh hook can reveal an attribute
-     * that was hidden when the object was loaded, and the ordinary reason it does so is that the
-     * attribute has just become required. Filtering on the loaded state left such an attribute out of
-     * both {@link initFormData} and the save payload, so the user filled in a field whose value was
-     * then dropped on the floor and refused by the server as missing — with no way out of the form.
-     * The overlay is the form's, bound two-way, so the two halves cannot drift again.
-     */
-    getEditableAttributes(): _mintplayer_ng_spark_models.EntityAttributeDefinition[];
-    onSave(): Promise<void>;
-    onCancel(): void;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkPoEditComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkPoEditComponent, "spark-po-edit", never, {}, { "saved": "saved"; "cancelled": "cancelled"; }, never, never, true, never>;
-}
-
-export { SparkPoEditComponent };
+import { Color } from "@mintplayer/ng-bootstrap";
+import { EntityType, PersistentObject, RefreshOverlay, ValidationError } from "@mintplayer/ng-spark/models";
+import * as i0 from "@angular/core";
+export declare class SparkPoEditComponent {
+  private readonly route;
+  private readonly router;
+  private readonly sparkService;
+  private readonly language;
+  saved: import("@angular/core").OutputEmitterRef<PersistentObject>;
+  cancelled: import("@angular/core").OutputEmitterRef<void>;
+  colors: typeof Color;
+  entityType: import("@angular/core").WritableSignal<EntityType | null>;
+  item: import("@angular/core").WritableSignal<PersistentObject | null>;
+  type: string;
+  id: string;
+  formData: import("@angular/core").WritableSignal<Record<string, any>>;
+  /**
+   * Bound two-way to the form, which is where refreshes land. Read by
+   * {@link getEditableAttributes} so the save sees the object the user was actually shown.
+   */
+  refreshOverlay: import("@angular/core").WritableSignal<RefreshOverlay>;
+  validationErrors: import("@angular/core").WritableSignal<ValidationError[]>;
+  isSaving: import("@angular/core").WritableSignal<boolean>;
+  private allEntityTypes;
+  generalErrors: import("@angular/core").Signal<ValidationError[]>;
+  constructor();
+  private onParamsChange;
+  initFormData(): void;
+  /**
+   * Resolves a nested AsDetail type by CLR name, for rebuilding the nested PO wire shape on save.
+   *
+   * ⚠️ <b>`detailTypes` first, catalogue second.</b> The catalogue from `/spark/types` is
+   * <b>Query-gated</b>, and an AsDetail row type usually has no rights of its own — nobody grants
+   * `Query/GateSettings`, because a gate is edited through the Repository that owns it. So the
+   * catalogue does not contain it, the resolver returned undefined, and the save quietly took the
+   * scalar branch: the attribute went out as a raw dict under `value` instead of a nested PO under
+   * `object`, the server could not map it, and `EntityMapper`'s conversion `catch` swallowed the
+   * failure. The save reported success and wrote nothing.
+   * <para>
+   * `detailTypes` is the parent's own copy of its row types, carried on the type definition for
+   * exactly this reason (#385 fixed the rendering half; this is the save half). It is gated on the
+   * parent's right, which is the right that governs editing the row anyway.
+   * </para>
+   */
+  private resolveEntityType;
+  /**
+   * The attributes this page will read values from when it builds the save.
+   *
+   * ⚠️ <b>Overlaid before filtering, not after loading.</b> A refresh hook can reveal an attribute
+   * that was hidden when the object was loaded, and the ordinary reason it does so is that the
+   * attribute has just become required. Filtering on the loaded state left such an attribute out of
+   * both {@link initFormData} and the save payload, so the user filled in a field whose value was
+   * then dropped on the floor and refused by the server as missing — with no way out of the form.
+   * The overlay is the form's, bound two-way, so the two halves cannot drift again.
+   */
+  getEditableAttributes(): import("@mintplayer/ng-spark/models").EntityAttributeDefinition[];
+  onSave(): Promise<void>;
+  onCancel(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkPoEditComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkPoEditComponent, "spark-po-edit", never, {}, {
+    "saved": "saved";
+    "cancelled": "cancelled";
+  }, never, never, true, never>;
+}