@mintplayer/ng-spark 22.23.0 → 22.25.0

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

@@ -0,0 +1,216 @@
+import { EntityAttributeDefinition, EntityPermissions, EntityType, PersistentObject, PersistentObjectAttribute, QueryColumn, SparkDeletedFilter, comparableValue } from "@mintplayer/ng-spark/models";
+import * as i0 from "@angular/core";
+import { Provider } from "@angular/core";
+import { Color } from "@mintplayer/ng-bootstrap";
+import { ReferenceChip } from "@mintplayer/ng-spark/pipes";
+import { SparkLanguageService } from "@mintplayer/ng-spark/services";
+import { SparkDetailContext } from "@mintplayer/ng-spark/panels";
+/** One revision of a row, newest first (`MintPlayer.Spark.History.SparkRevision`). */
+export interface SparkRevision {
+  changeVector: string;
+  /** When the revision was written (ISO 8601 with offset); null when the server does not know. */
+  lastModified?: string | null;
+  /** Who wrote it — an id (D8: audit fields hold ids only). */
+  userId?: string | null;
+  /** The id resolved to a name at read time, when the app registered an `IHistoryUserNameResolver`. */
+  userName?: string | null;
+  /** The revision RavenDB writes when the document is deleted (a purge-free hard delete). */
+  isDeleteRevision?: boolean;
+  /** The revision the document currently is. Reverting to it changes nothing. */
+  isCurrent?: boolean;
+}
+export interface SparkRevisionListOptions {
+  skip?: number;
+  /** Server default 50, at most 200. */
+  take?: number;
+  /** `include` / `only` to read the history of a soft-deleted row (`ViewDeleted` holders only). */
+  deleted?: SparkDeletedFilter | null;
+}
+/**
+ * Client for the History package's endpoints (`MintPlayer.Spark.History`, #460 T1). Every read is
+ * gated on the CURRENT row (a row the caller can no longer see has no readable history) and on
+ * `History/T`; old revisions come back redacted like the live object.
+ */
+export declare class SparkHistoryService {
+  private readonly spark;
+  /** `POST /spark/po/revisions` → the row's revisions, newest first. */
+  list(type: string, id: string, options?: SparkRevisionListOptions): Promise<SparkRevision[]>;
+  /** `POST /spark/po/revision` → the revision as a read-only, redacted persistent object. */
+  get(type: string, id: string, changeVector: string, options?: {
+    deleted?: SparkDeletedFilter | null;
+  }): Promise<PersistentObject>;
+  /**
+   * `POST /spark/po/revert` → the reverted row. Requires `History/T`, `Revert/T` and `Edit/T`; saved
+   * through the normal pipeline. 403 = the revert is disabled for this row, 409 = the row changed
+   * since it was loaded, 400 = an interceptor refused (e.g. the row is locked).
+   */
+  revert(type: string, id: string, changeVector: string): Promise<PersistentObject>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkHistoryService, never>;
+  static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+/** One attribute that differs between a revision and the current object. */
+export interface SparkRevisionChange {
+  attribute: EntityAttributeDefinition;
+  /** Absent when the attribute did not exist on that side (added or removed since). */
+  revision: PersistentObjectAttribute | undefined;
+  current: PersistentObjectAttribute | undefined;
+}
+/**
+ * The attributes a revision is compared on: the ones the detail page shows, in its order. Redacted
+ * attributes are simply absent from what the server sends, so they never appear as a difference.
+ */
+export declare function revisionAttributes(entityType: EntityType | null | undefined): EntityAttributeDefinition[];
+/** The shown attributes whose content differs between `revision` and `current`, in display order. */
+export declare function diffRevision(entityType: EntityType | null | undefined, revision: PersistentObject | null | undefined, current: PersistentObject | null | undefined): SparkRevisionChange[];
+type HistoryView = 'view' | 'diff';
+/** One attribute of one object, ready for `<spark-grid-cell>`. */
+interface HistoryCell {
+  column: QueryColumn;
+  display: unknown;
+  rendererValue: unknown;
+  chips: ReferenceChip[];
+}
+/**
+ * A row's revision history (#460, History package): the revision list, a read-only view of one
+ * revision, its field diff against the current object, and Revert.
+ *
+ * Standalone — bind it anywhere — and also what the History detail panel
+ * (`provideSparkHistory()`) renders on every routed detail page.
+ *
+ * Rights come from `permissions`: nothing is listed without `canViewHistory`, and Revert is offered
+ * only with `canRevert` (the server's `Revert/T` together with `Edit/T`), never for the current
+ * revision, a delete revision, or a row opened from the recycle bin (Revert saves through the live
+ * pipeline, which does not see a deleted row). The server enforces all of it again.
+ */
+export declare class SparkPoHistoryComponent {
+  private readonly history;
+  protected readonly lang: SparkLanguageService;
+  /** Entity type id or alias, as the endpoints take it. */
+  type: import("@angular/core").InputSignal<string>;
+  id: import("@angular/core").InputSignal<string>;
+  entityType: import("@angular/core").InputSignal<EntityType>;
+  /** The object as it is now — the right-hand side of every diff. */
+  current: import("@angular/core").InputSignal<PersistentObject | null>;
+  permissions: import("@angular/core").InputSignal<EntityPermissions | null>;
+  /** The mode the row was opened with (`only` = from the recycle bin). */
+  deleted: import("@angular/core").InputSignal<SparkDeletedFilter | null>;
+  /** Rows per request (server default 50, at most 200). */
+  pageSize: import("@angular/core").InputSignal<number>;
+  /** Emitted with the saved object after a successful Revert. */
+  reverted: import("@angular/core").OutputEmitterRef<PersistentObject>;
+  protected readonly colors: typeof Color;
+  protected readonly revisions: import("@angular/core").WritableSignal<SparkRevision[]>;
+  protected readonly loading: import("@angular/core").WritableSignal<boolean>;
+  protected readonly hasMore: import("@angular/core").WritableSignal<boolean>;
+  protected readonly error: import("@angular/core").WritableSignal<string | null>;
+  protected readonly selected: import("@angular/core").WritableSignal<SparkRevision | null>;
+  protected readonly selectedObject: import("@angular/core").WritableSignal<PersistentObject | null>;
+  protected readonly selectedLoading: import("@angular/core").WritableSignal<boolean>;
+  protected readonly view: import("@angular/core").WritableSignal<HistoryView>;
+  protected readonly reverting: import("@angular/core").WritableSignal<boolean>;
+  protected readonly canView: import("@angular/core").Signal<boolean>;
+  protected readonly attributes: import("@angular/core").Signal<EntityAttributeDefinition[]>;
+  protected readonly changes: import("@angular/core").Signal<import("@mintplayer/ng-spark/history").SparkRevisionChange[]>;
+  private readonly gridRenderers;
+  /** Lookup-reference labels for the shown attributes, so a lookup value reads as its label. */
+  private readonly lookupOptions;
+  /**
+   * The read-only view: every shown attribute of the selected revision, rendered by the same
+   * `<spark-grid-cell>` (and custom renderers) as a query grid — a reference as its label, a date in
+   * the viewer's culture and zone, a boolean as a checkbox — instead of the raw wire value.
+   */
+  protected readonly viewCells: import("@angular/core").Signal<{
+    attribute: EntityAttributeDefinition;
+    cell: HistoryCell;
+  }[]>;
+  /** The diff rows, both sides rendered like {@link viewCells}. */
+  protected readonly changeCells: import("@angular/core").Signal<{
+    change: import("@mintplayer/ng-spark/history").SparkRevisionChange;
+    old: HistoryCell;
+    now: HistoryCell;
+  }[]>;
+  protected readonly canRevertSelected: import("@angular/core").Signal<boolean>;
+  constructor();
+  /** Reloads the list from the top, dropping the selection. */
+  refresh(): Promise<void>;
+  loadMore(): Promise<void>;
+  private loadPage;
+  select(revision: SparkRevision): Promise<void>;
+  clearSelection(): void;
+  revert(): Promise<void>;
+  /**
+   * One attribute of `po` for `<spark-grid-cell>`. A persistent object is a row the grid pipes read
+   * (`valueFor` understands both shapes), so the value resolution is the grid's, not a copy of it.
+   */
+  private cell;
+  protected who(revision: SparkRevision): string;
+  private describe;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkPoHistoryComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkPoHistoryComponent, "spark-po-history", never, {
+    "type": {
+      "alias": "type";
+      "required": true;
+      "isSignal": true;
+    };
+    "id": {
+      "alias": "id";
+      "required": true;
+      "isSignal": true;
+    };
+    "entityType": {
+      "alias": "entityType";
+      "required": true;
+      "isSignal": true;
+    };
+    "current": {
+      "alias": "current";
+      "required": false;
+      "isSignal": true;
+    };
+    "permissions": {
+      "alias": "permissions";
+      "required": false;
+      "isSignal": true;
+    };
+    "deleted": {
+      "alias": "deleted";
+      "required": false;
+      "isSignal": true;
+    };
+    "pageSize": {
+      "alias": "pageSize";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "reverted": "reverted";
+  }, never, never, true, never>;
+}
+/**
+ * The History card on the routed detail page (#460). Registered by {@link provideSparkHistory} as a
+ * `SPARK_DETAIL_PANELS` entry; renders nothing for a caller without `History/T`.
+ * After a Revert it asks the page to reload, so the attributes above show the reverted values.
+ */
+export declare class SparkHistoryPanelComponent {
+  context: import("@angular/core").InputSignal<SparkDetailContext>;
+  protected readonly visible: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkHistoryPanelComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkHistoryPanelComponent, "spark-history-panel", never, {
+    "context": {
+      "alias": "context";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Adds a History card (`<spark-po-history>`: revision list, read-only view, diff, Revert) to every
+ * detail page `sparkRoutes()` routes to, for holders of `History/T` (#460). Needs the server package
+ * `MintPlayer.Spark.History` and revisions enabled for the type in its model.
+ *
+ * `providers: [provideSpark(...), provideSparkHistory()]`
+ */
+export declare function provideSparkHistory(options?: {
+  order?: number;
+}): Provider[];
+export { comparableValue };

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

@@ -1,13 +1,15 @@
-import * as _angular_platform_browser from '@angular/platform-browser';
-import * as _angular_core from '@angular/core';
-
-declare class SparkIconComponent {
-    private registry;
-    name: _angular_core.InputSignal<string>;
-    iconHtml: _angular_core.Signal<_angular_platform_browser.SafeHtml | undefined>;
-    cssFallbackClass: _angular_core.Signal<string>;
-    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparkIconComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparkIconComponent, "spark-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
-}
-
-export { SparkIconComponent };
+import * as i0 from "@angular/core";
+export declare class SparkIconComponent {
+  private registry;
+  name: import("@angular/core").InputSignal<string>;
+  iconHtml: import("@angular/core").Signal<import("@angular/platform-browser").SafeHtml | undefined>;
+  cssFallbackClass: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<SparkIconComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<SparkIconComponent, "spark-icon", never, {
+    "name": {
+      "alias": "name";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}