@mintplayer/ng-spark 22.25.0 → 22.27.0

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

@@ -128,51 +128,71 @@ export interface PersistentObjectAttribute {
    */
   asDetailType?: string;
 }
+/**
+ * One action of the composed catalogue (#467, D7), as `/spark/actions/list` reports it for a type:
+ * a built-in (New, Edit, Delete) or a custom action, already narrowed to what the caller may run.
+ * Text arrives resolved by the server (D26).
+ */
 export interface CustomActionDefinition {
   name: string;
-  displayName: TranslatedString;
+  /** `actions.{name}.label`, or the humanized name when untranslated. */
+  label: TranslatedString;
   icon?: string;
-  description?: string;
+  /** `actions.{name}.description`; absent when untranslated. */
+  description?: TranslatedString;
   showedOn: string;
   selectionRule?: string;
   refreshOnCompleted: boolean;
-  confirmationMessageKey?: string;
+  /**
+   * The confirmation to ask before running, `actions.{name}.confirmation` or the explicit key the
+   * catalogue names. May contain `{count}`, the number of rows about to be acted on. Absent: no prompt.
+   */
+  confirmation?: TranslatedString;
   /**
    * How prominently, and how warily, to present the action: 'primary', 'secondary', 'danger',
    * 'warning'. Undefined renders the neutral default.
    *
    * Presentation only — the server decides who may see and run an action. A 'danger' variant just
-   * asks the button to look like what it does; pair it with `confirmationMessageKey` for anything
+   * asks the button to look like what it does; pair it with a `confirmation` for anything
    * irreversible, because the colour warns and the prompt is what actually prevents the accident.
    */
   variant?: string;
   offset: number;
   /**
-   * True for the framework's built-in `New` and `Delete` (#460, D18): catalogue entries with a
-   * `showedOn` and a `selectionRule` like any custom action (defaults: New has no rule, Delete is
-   * `>0`; an app overrides them in `customActions.json`), but run through `/po/new` and
-   * `/po/delete-many`, never `/actions/execute`. Absent for a custom action.
+   * True for the framework's built-in `New`, `Edit` and `Delete` (#460 D18, #467 D7): catalogue
+   * entries with a `showedOn` and a `selectionRule` like any custom action (the core's
+   * `actions.json` ships them; an app overrides or removes them in its own), but run through
+   * `/po/new`, the edit page and `/po/delete-many`, never `/actions/execute`. Absent for a custom action.
    */
   isDefault?: boolean;
 }
-/** How many rows a grid lets the user select — what `<bs-datatable>` renders. */
-export type SparkSelectionMode = 'none' | 'single' | 'multiple';
 /**
- * What a query definition (or a sub-query entry) declares (#460, D17): a fixed mode, or `'auto'` —
+ * Whether a grid lets the user tick rows — what `<bs-datatable>` renders. There is no single
+ * selection (#467, D10): a selectable list is a checkbox list, and actions whose rule does not
+ * match the count are disabled rather than the selection trimmed.
+ */
+export type SparkSelectionMode = 'none' | 'multiple';
+/**
+ * What a query definition (or a sub-query entry) declares (#460 D17): a fixed mode, or `'auto'` —
  * the default, and what an absent field means — to derive it from the actions offered.
  */
 export type SparkSelectionModeSetting = 'auto' | SparkSelectionMode;
+/** The largest selection the server accepts in one request (`SparkDefaultActions.MaxSelectedItems`). */
+export declare const SPARK_MAX_SELECTED_ITEMS = 200;
 /**
- * The selection mode a grid renders.
- *
- * A declared `'none'`, `'single'` or `'multiple'` wins outright. `'auto'` (or nothing) derives it,
- * so a grid gains a checkbox column exactly when an action needs one and is otherwise
- * pixel-identical to a grid with no selection at all — as Vidyano's query grid does. The offered
- * actions include the default Delete (`>0`) when the caller may delete, so such a grid is
- * multi-select.
+ * Whether an action needs ticked rows (#467, R1(4)): it has a rule, and the rule accepts at least
+ * one row. `=0` accepts none, so an action that runs only without a selection never makes a list
+ * selectable; an action without a rule acts on the query, not on rows.
+ */
+export declare function needsSelection(action: CustomActionDefinition): boolean;
+/**
+ * The selection mode a grid renders (#467, R1).
  *
- * Derived: `'single'` when every gated action is satisfied by one row and refused by two; anything
- * else that cares about the count gets `'multiple'`.
+ * A declared `'none'` or `'multiple'` wins outright. `'auto'` (or nothing) derives it from
+ * `actions`, which must already be the **effective** list for this result — listed for the caller
+ * (the right), shown on queries, not withheld by `disabledActions` and not hidden by the recycle
+ * bin. Built-in Edit and Delete count like any other action. `'multiple'` when at least one of them
+ * {@link needsSelection}, else `'none'`, so a read-only user sees a list with no checkbox column.
  */
 export declare function selectionModeFor(actions: CustomActionDefinition[], declared?: SparkSelectionModeSetting | null): SparkSelectionMode;
 /**
@@ -293,7 +313,8 @@ export interface AttributeGroup {
 export interface EntityType {
   id: string;
   name: string;
-  description?: TranslatedString;
+  /** The type's display name, resolved by the server (#467, D6; formerly `description`). */
+  label?: TranslatedString;
   /**
    * The backing CLR type, or absent for a JSON-only virtual type (#325).
    *
@@ -369,7 +390,8 @@ export interface SparkQuerySortColumn {
 export interface SparkQuery {
   id: string;
   name: string;
-  description?: TranslatedString;
+  /** The query's display name, resolved by the server (#467; formerly `description`). */
+  label?: TranslatedString;
   source: string;
   alias?: string;
   sortColumns: SparkQuerySortColumn[];
@@ -479,14 +501,20 @@ export interface QueryColumn extends SparkCellColumn {
 /**
  * One row: an id, a display string, and a value per column.
  *
- * Deliberately too weak to act on — no attribute metadata, no `can` block, no etag, because none
- * of those can be trusted from a projection.
+ * Deliberately too weak to act on — no attribute metadata, no `can` block, because neither can be
+ * trusted from a projection. It does carry its document's `etag` (#467, D14), a version rather than
+ * a judgement, so a delete from the list says which version it removes.
  */
 export interface QueryResultItem {
   /** Never null and unique within a result; the server refuses anything else. */
   id: string;
   /** What to show when the row is named rather than tabulated (a reference picker's value). */
   breadcrumb?: string;
+  /**
+   * The document's change vector when the list loaded (#467, D14). A delete sends it back; a row
+   * changed since is a 409. Absent for a row with no document behind it.
+   */
+  etag?: string;
   values: QueryResultItemValue[];
   /** Presentation hints for the whole row. Keys arrive lower-cased. */
   typeHints?: Record<string, string>;
@@ -926,6 +954,13 @@ export declare function comparableValue(attribute: PersistentObjectAttribute | u
 export declare function comparableFormValue(value: unknown): string;
 /** Whether two form-dict values hold the same content (see {@link comparableFormValue}). */
 export declare function formValuesEqual(a: unknown, b: unknown): boolean;
+/**
+ * The prompt to show before running `action` on `count` rows, with `{count}` substituted, or null
+ * when the action asks for no confirmation (#467, D7).
+ */
+export declare function confirmationText(action: CustomActionDefinition | undefined | null, count: number, lang?: string): string | null;
+/** The built-in action named `name` (`New`, `Edit`, `Delete`) in `actions`, when the server listed it. */
+export declare function builtInAction(actions: CustomActionDefinition[], name: 'New' | 'Edit' | 'Delete'): CustomActionDefinition | undefined;
 /** Whether `showedOn` offers the action on a query: `"query"` or `"both"`, in any casing. */
 export declare function isShowedOnQuery(showedOn: string | undefined | null): boolean;
 /** Whether `showedOn` offers the action on a detail page: `"detail"` or `"both"`, in any casing. */
@@ -937,7 +972,7 @@ export declare function isShowedOnDetail(showedOn: string | undefined | null): b
  * and `"both"` — as the server model and the custom-actions guide have always
  * documented — compared case-insensitively (#460 M15: `"Both"` used to render nowhere).
  *
- * The built-in New and Delete (`isDefault`, #460 D18) are left out: they are not executed as
+ * The built-in New, Edit and Delete (`isDefault`, #460 D18, #467 D7) are left out: they are not executed as
  * custom actions, and the grid offers them itself (see {@link defaultQueryActions}).
  *
  * ⚠️ This narrows what is DISPLAYED. It is NOT an authorization boundary: the grant
@@ -948,8 +983,8 @@ export declare function filterQueryActions(actions: CustomActionDefinition[]): C
 /** The custom actions a detail page should offer — the detail-side counterpart of {@link filterQueryActions}. */
 export declare function filterDetailActions(actions: CustomActionDefinition[]): CustomActionDefinition[];
 /**
- * The built-in New and Delete the server listed for this caller (#460, D18), when their `showedOn`
- * includes the query side. Present only when the caller holds `New/T` or `Delete/T`.
+ * The built-in New, Edit and Delete the server listed for this caller (#460 D18, #467 D7), when their `showedOn`
+ * includes the query side. Present only when the caller holds `New/T`, `Edit/T` or `Delete/T`.
  */
 export declare function defaultQueryActions(actions: CustomActionDefinition[]): CustomActionDefinition[];
 /**

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

@@ -17,6 +17,16 @@ export declare class SparkPoCreateComponent {
   isSaving: import("@angular/core").WritableSignal<boolean>;
   private allEntityTypes;
   generalErrors: import("@angular/core").Signal<ValidationError[]>;
+  /**
+   * The parent a sub-query card's New passed in the URL (`parentId`, `parentType`, `queryId`), or
+   * null. Forwarded to the form so a Reference attribute's option query runs under the object the
+   * New was started from — the same parent `/po/new` receives.
+   */
+  subQueryParent: import("@angular/core").WritableSignal<{
+    parentId: string;
+    parentType: string;
+    queryId: string;
+  } | null>;
   constructor();
   private onParamsChange;
   /**

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

@@ -60,8 +60,12 @@ export declare class SparkPoDetailComponent {
   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>;
+  /** The catalogue's Edit (#467, D8) when this page offers it: listed for the caller, on the detail side, and allowed on this row. */
+  editAction: import("@angular/core").WritableSignal<CustomActionDefinition | null>;
+  /** The catalogue's Delete, on the same terms as {@link editAction}. */
+  deleteAction: import("@angular/core").WritableSignal<CustomActionDefinition | null>;
+  canEdit: import("@angular/core").Signal<boolean>;
+  canDelete: import("@angular/core").Signal<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>;
@@ -125,6 +129,8 @@ export declare class SparkPoDetailComponent {
    * 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.
    */
+  /** Edit's and Delete's button classes: the catalogue's variant, else the look they always had. */
+  protected builtInActionClass(action: CustomActionDefinition, fallback: 'primary' | 'danger'): string;
   protected customActionClass(action: CustomActionDefinition): string;
   /**
    * The action currently running, or null. Drives the disabled state on every custom-action

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

@@ -139,6 +139,16 @@ export declare class SparkPoFormComponent {
   isSaving: import("@angular/core").InputSignal<boolean>;
   parentId: import("@angular/core").InputSignal<string | undefined>;
   parentType: import("@angular/core").InputSignal<string | undefined>;
+  /**
+   * The parent a Reference attribute's option query runs under, when it differs from
+   * `parentId`/`parentType`. Those two also name the object that owns an AsDetail row for the row
+   * round-trips (`parentTypeForWire`), so they cannot carry a create page's sub-query parent: a New
+   * opened from an Account's card must offer that account's repositories, while its detail rows still
+   * belong to the type being created. Unset, the option queries use `parentId`/`parentType` as before.
+   */
+  referenceParentId: import("@angular/core").InputSignal<string | undefined>;
+  referenceParentType: import("@angular/core").InputSignal<string | undefined>;
+  private readonly optionQueryParent;
   save: import("@angular/core").OutputEmitterRef<void>;
   cancel: import("@angular/core").OutputEmitterRef<void>;
   /**
@@ -433,6 +443,16 @@ export declare class SparkPoFormComponent {
       "required": false;
       "isSignal": true;
     };
+    "referenceParentId": {
+      "alias": "referenceParentId";
+      "required": false;
+      "isSignal": true;
+    };
+    "referenceParentType": {
+      "alias": "referenceParentType";
+      "required": false;
+      "isSignal": true;
+    };
     "objectTypeId": {
       "alias": "objectTypeId";
       "required": false;

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

@@ -3,7 +3,7 @@ import { TemplateRef } from "@angular/core";
 import { Color } from "@mintplayer/ng-bootstrap";
 import { SparkLanguageService } from "@mintplayer/ng-spark/services";
 import { SparkQueryToolbarAction } from "@mintplayer/ng-spark/grid";
-import { CustomActionDefinition, QueryColumn, QueryColumnFilter, QueryResultItem, SparkDeletedFilter } from "@mintplayer/ng-spark/models";
+import { CustomActionDefinition, QueryColumn, QueryColumnFilter, QueryResultItem, SparkDeletedFilter, SparkSelectionModeSetting } from "@mintplayer/ng-spark/models";
 import { SparkQueryListContext } from "@mintplayer/ng-spark/panels";
 /**
  * The routed query page: chrome around one {@link SparkQueryGridComponent}.
@@ -31,6 +31,11 @@ export declare class SparkQueryListComponent {
   protected readonly lang: SparkLanguageService;
   extraActionsTemplate: import("@angular/core").InputSignal<TemplateRef<void> | null>;
   showCustomActions: import("@angular/core").InputSignal<boolean>;
+  /**
+   * Overrides the query's own `selectionMode` (#467, R3), as the sub-query card's input does: for a
+   * host that embeds this page and wants, say, `'none'` on a list the actions would make selectable.
+   */
+  selectionMode: import("@angular/core").InputSignal<SparkSelectionModeSetting | null>;
   /**
    * Forwarded to the grid, so a query PAGE can replace its row links — the same reason the card
    * forwards it. Without this the escape hatch existed only for a directly-embedded grid.
@@ -147,6 +152,11 @@ export declare class SparkQueryListComponent {
       "required": false;
       "isSignal": true;
     };
+    "selectionMode": {
+      "alias": "selectionMode";
+      "required": false;
+      "isSignal": true;
+    };
     "rowRoute": {
       "alias": "rowRoute";
       "required": false;

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

@@ -62,11 +62,22 @@ export interface NewObjectOptions {
 }
 /** Where a bulk delete was started from; see {@link SparkService.deleteMany}. */
 export interface DeleteManyOptions {
-  /** The query the rows were selected in, for the server's `OnDisableActionsAsync`. */
-  queryId?: string;
+  /**
+   * The query the rows were selected in. Required (#467, D12): the server fetches the rows through it
+   * and applies its `OnDisableActionsAsync` decision; without it the call is a 400.
+   */
+  queryId: string;
   /** The sub-query's container, when deleting from a sub-query. */
   parentId?: string;
   parentType?: string;
+  /** One reason for the whole batch, recorded on every soft-deleted row (#467, D20). */
+  reason?: string;
+}
+/** A row and the version of it the caller saw (#467, D14): what a bulk delete names. */
+export interface SparkRowVersion {
+  id: string;
+  /** The row's `etag` from the query result. */
+  etag: string;
 }
 /** Context for {@link SparkService.deleteRow}. Every field is required — see `DeleteRow.cs`. */
 export interface DeleteRowOptions {
@@ -151,7 +162,24 @@ export declare class SparkService {
   get(type: string, id: string, options?: {
     deleted?: SparkDeletedFilter;
   }): Promise<PersistentObject>;
-  create(type: string, data: Partial<PersistentObject>): Promise<PersistentObject>;
+  /**
+   * `parent` is the sub-query the New was started from — the same `parentId`/`parentType`/`queryId`
+   * `newObject` was given. The server resolves and authorizes it again and hands it to the save hooks
+   * as `PersistentObject.Parent`.
+   *
+   * Resolves to `null` when a server interceptor cancelled the create (#482: the user answered a prompt with
+   * Cancel) — the server answers 204 and nothing was created.
+   */
+  create(type: string, data: Partial<PersistentObject>, parent?: {
+    parentId: string;
+    parentType: string;
+    queryId: string;
+  }): Promise<PersistentObject | null>;
+  /**
+   * Saves an edit. `data.etag` — the etag the object was loaded with — is required (#467, D16): it is
+   * the version being edited. A 409 means the object changed since (`reason: 'changed'`) or was
+   * deleted since (`reason: 'deleted'`).
+   */
   update(type: string, id: string, data: Partial<PersistentObject>): Promise<PersistentObject>;
   /**
    * Asks the server to reshape an in-progress object after `triggeredBy`'s value changed.
@@ -190,14 +218,20 @@ export declare class SparkService {
    * of the route variables.
    */
   deleteRow(type: string, options: DeleteRowOptions): Promise<void>;
-  delete(type: string, id: string): Promise<void>;
+  /**
+   * Deletes one object. `etag` is the version being deleted — the loaded object's `etag` — and is
+   * required (#467, D14): an object changed since is a 409.
+   */
+  delete(type: string, id: string, etag: string): Promise<void>;
   /**
    * Deletes several rows of one type in one request — the default Delete action on a selection
-   * (`POST /spark/po/delete-many`, #460 D18). All or nothing: a 404 means some row is missing or not
-   * yours to delete, a 403 that the server's `OnDisableActionsAsync` withholds Delete on the query or
-   * on one of the rows, a 400 that the selection breaks the rule or the 200-row cap.
+   * (`POST /spark/po/delete-many`, #460 D18). Each row carries the `etag` its query result row had
+   * (#467, D14). All or nothing: a 404 means some row is missing or not yours to delete, a 403 that
+   * the server's `OnDisableActionsAsync` withholds Delete on the query or on one of the rows, a 409
+   * that rows changed since the list loaded (the body's `message` names them), a 400 that the
+   * selection breaks the rule or the 200-row cap.
    */
-  deleteMany(type: string, ids: string[], options?: DeleteManyOptions): Promise<void>;
+  deleteMany(type: string, items: SparkRowVersion[], options: DeleteManyOptions): Promise<void>;
   getCustomActions(objectTypeId: string): Promise<CustomActionDefinition[]>;
   /**
    * @param parent The object of THIS type the action is operating on — the detail-page invocation.

package/types/mintplayer-ng-spark-soft-delete.d.ts

@@ -17,7 +17,7 @@ export declare class SparkSoftDeleteService {
    * `POST /spark/po/purge` → 204. Requires `Purge/T` and a deleted row. Removes the document and
    * every revision of it; it cannot be undone.
    */
-  purge(type: string, id: string): Promise<void>;
+  purge(type: string, id: string, etag: string): Promise<void>;
   static ɵfac: i0.ɵɵFactoryDeclaration<SparkSoftDeleteService, never>;
   static ɵprov: i0.ɵɵInjectableDeclaration<any>;
 }