@anzusystems/common-admin 1.49.0 → 2.0.0-rc.10

package/dist/domains/dam/uploadQueue/settlement/uploadSettlementTypes.d.ts

@@ -0,0 +1,197 @@
+import { DocId, DocIdNullable, IntegerId } from '../../../../shared/types/common';
+import { AssetDetailItemDto, DamAssetTypeType } from '../../types/Asset';
+import { AssetFileFailReasonType, AssetFileNullable } from '../../types/AssetFile';
+import { UploadQueue, UploadQueueItem, UploadQueueKey } from '../../types/UploadQueue';
+export declare const UploadRowRole: {
+    readonly Upload: "upload";
+    readonly Slot: "slot";
+    readonly MassEdit: "massEdit";
+    readonly Copy: "copy";
+    readonly ExternalImport: "externalImport";
+};
+export type UploadRowRoleType = (typeof UploadRowRole)[keyof typeof UploadRowRole];
+export interface UploadSettlePolicy {
+    /** How a tick reads the state of the row's file. `none`: the row is never tracked. */
+    reader: 'asset' | 'slots' | 'none';
+    /**
+     * Applies to the `processed` state only.
+     * `read`: uploaded only after a read; the event just starts the read.
+     * `event`: the event state is written at once; the read completes the row.
+     * `never`: `processed` does not change the row state (mass edit), it only completes
+     * it. `failed` and `duplicate` apply to every row matching `matches(…, 'settle')`.
+     */
+    settleOn: 'read' | 'event' | 'never';
+    duplicate: 'becomeOriginal' | 'markDuplicate';
+    /** `load`: the row gets a form, and its metadata is loaded into it. */
+    metadata: 'load' | 'none';
+}
+export interface UploadSettlementTarget {
+    assetId: DocId;
+    /** `null` when the caller does not know the file. */
+    fileId: DocIdNullable;
+    /**
+     * DAM configurations of the target. With `configOf`, rows in queues of other configurations are not concerned.
+     * Omitted or empty: rows of every queue. Two DAMs may share an asset id.
+     */
+    configNames?: string[];
+}
+/** Per-request options a reader may honour. A reader that ignores them keeps its old behaviour. */
+export interface UploadReadOptions {
+    /**
+     * Whether a failure of this request should be reported to the app error collector.
+     * Polls and notifications retry while a row waits, so only the first failure of a streak is
+     * `true`. An answered read ends the streak; with `configOf`, streaks are per configuration.
+     * A streak starts only with a failure that was written down (`readers.failureReported`).
+     * A 404 counts as such, so it is `true` at most once per row.
+     * A user-requested refresh is always `true`.
+     */
+    report: boolean;
+    /**
+     * The queue the read is for: the polled queue, or for notification
+     * and refresh reads the queue of the first concerned row.
+     * Lets a reader use the queue's configuration. Omitted when the read concerns no row.
+     */
+    queueKey?: UploadQueueKey;
+}
+export interface UploadSettlementProfile {
+    /** Live view of the store's queues. The settlement keeps no rows and always asks. */
+    queues(): Iterable<[UploadQueueKey, UploadQueue]>;
+    /**
+     * DAM configuration of the queue. With it, named targets and
+     * events concern only rows of their configurations' queues.
+     * Each such read runs once per named configuration, through the queue of its first concerned
+     * row, and writes only into those rows. A configuration with no row of the asset is not read.
+     * Reads run sequentially per configuration, in parallel across configurations (unnamed reads get
+     * their own lane), each with its own failure streak. Caches get the queue of the named rows.
+     * Without it, every row of the asset is concerned, all reads share one lane and streak, and caches get no queue.
+     */
+    configOf?(queueKey: UploadQueueKey): string;
+    roleOf(row: UploadQueueItem): UploadRowRoleType;
+    policyFor(role: UploadRowRoleType): UploadSettlePolicy;
+    /**
+     * `settle`: the row may get a new state. `decorate`: it may be completed without a state change.
+     * `metadata`: it may get metadata from the metadata notification.
+     */
+    matches(row: UploadQueueItem, target: UploadSettlementTarget, purpose: 'settle' | 'decorate' | 'metadata'): boolean;
+    readers: {
+        /** One asset; `null` when it does not exist (404). Throws only when the request fails. */
+        asset(assetId: DocId, options?: UploadReadOptions): Promise<AssetDetailItemDto | null>;
+        /** Assets of one licence. The missing ones are not in the answer. An answer that is no list throws. */
+        assets(licenceId: IntegerId, assetIds: DocId[], options?: UploadReadOptions): Promise<AssetDetailItemDto[]>;
+        /** DAM: the files of all the slots of an asset. An answer that is no list throws. */
+        slotFiles?(assetId: DocId, options?: UploadReadOptions): Promise<AssetFileNullable[]>;
+        /**
+         * LIB: the asset the original file of a duplicate belongs to. `queueKey`: of the first row that is to become it.
+         */
+        duplicateOriginAsset?(originFileId: DocId, options?: Pick<UploadReadOptions, 'queueKey'>): Promise<AssetDetailItemDto>;
+        /** DAM: the original file of a duplicate, by its type. */
+        duplicateOriginFile?(originFileId: DocId, assetType: DamAssetTypeType): Promise<AssetFileNullable>;
+        /**
+         * Whether a failure of a read with `report: true` was written
+         * down, judged by the thrown error, e.g. `apiErrorIsReported`.
+         * If not (timeout, 401, 403), nobody was told and the next read may
+         * report again. Without this, every failure counts as written down.
+         */
+        failureReported?(error: unknown): boolean;
+    };
+    /**
+     * `queueKey` is passed as the second argument only to a profile with `configOf`.
+     * Wrap a `defineCached` `add`, which treats every argument as an id.
+     * Such a profile is asked to fetch once per queue whose rows got
+     * names since its last fetch. Without `configOf`, calls get no queue.
+     */
+    caches: {
+        addAuthors(ids: DocId[], queueKey?: UploadQueueKey): void;
+        addKeywords(ids: DocId[], queueKey?: UploadQueueKey): void;
+        fetchAuthors(queueKey?: UploadQueueKey): void;
+        fetchKeywords(queueKey?: UploadQueueKey): void;
+    };
+    messages: {
+        processingTooLong(row: UploadQueueItem): string;
+        readFailed(row: UploadQueueItem): string;
+        assetMissing(row: UploadQueueItem): string;
+        /**
+         * Fail text for an uploaded row without metadata whose asset
+         * was missing from too many reads. Defaults to `assetMissing`.
+         */
+        assetGone?(row: UploadQueueItem): string;
+    };
+    /**
+     * `'load'`: the row may get metadata from the notification although it failed. `undefined`: default rules.
+     * DAM: a mass-edit row its batch load left out.
+     */
+    metadataGate?(queueKey: UploadQueueKey, row: UploadQueueItem): 'load' | undefined;
+    hooks: {
+        /** The row has reached a final state: count the queue again and start the next waiting upload. */
+        onRowFinal(queueKey: UploadQueueKey, row: UploadQueueItem): void;
+        /** After every asset that was read (DAM: the main file for the open detail). */
+        onAssetRead?(asset: AssetDetailItemDto): void;
+        /** A row with `settleOn: 'never'` has learnt its file is processed (an event, a tick or a manual read). */
+        onProcessedSeen?(queueKey: UploadQueueKey, row: UploadQueueItem): void;
+        afterMetadataLoaded?(queueKey: UploadQueueKey, row: UploadQueueItem): void;
+        /**
+         * Whether a refresh may still change a failed row; called when
+         * that changes, for stores that offer refresh only where it helps.
+         * `true`: tracked despite `clientFailed: true`, or a duplicate whose original could not be read.
+         * `false`: the server settled the file, the asset was missing too
+         * often, or the store removed the row (`untrack`, `dropQueue`).
+         * Never `false` without a prior `true`. Not called by `dispose()`.
+         */
+        onRefreshMayHelp?(queueKey: UploadQueueKey, row: UploadQueueItem, mayHelp: boolean): void;
+    };
+    connection: {
+        /**
+         * Whether notifications arrive for the queue's rows; the poll is then
+         * only a backup. A profile with one shared state may ignore `queueKey`.
+         */
+        isPushAlive(queueKey?: UploadQueueKey): boolean;
+        /** Called whenever that may have changed, for any queue. */
+        onChange(callback: () => void): () => void;
+    };
+}
+export interface UploadSettlementEvent {
+    kind: 'processed' | 'failed' | 'duplicate' | 'metadata' | 'copied';
+    assetId: DocId;
+    /** `event.data.id` */
+    fileId: DocIdNullable;
+    failReason?: AssetFileFailReasonType;
+    originAssetFile?: DocIdNullable;
+    assetType?: DamAssetTypeType | null;
+    /** DAM configurations of the event, as on `UploadSettlementTarget`. Omitted: every queue. */
+    configNames?: string[];
+}
+/**
+ * `settled`: the main file is final, or the asset was missing too often and its rows were given up. `pending`: not yet.
+ * Retryable: `error` (read failed), `missing` (asset not found),
+ * `originalUnread` (duplicate's original could not be read).
+ */
+export type UploadRefreshOutcome = 'settled' | 'pending' | 'error' | 'missing' | 'originalUnread';
+export interface UploadSettlement {
+    /** The row starts waiting for the server. Ignored if the row is not in `queueKey`. */
+    track(queueKey: UploadQueueKey, row: UploadQueueItem, options?: {
+        clientFailed?: boolean;
+    }): void;
+    untrack(row: UploadQueueItem): void;
+    /** The queue was cleared: its poller is dropped. */
+    dropQueue(queueKey: UploadQueueKey): void;
+    /** A notification. Resolves after the write (a delayed read included) or after a failed read; never rejects. */
+    notify(event: UploadSettlementEvent): Promise<void>;
+    /**
+     * Manual refresh: an immediate read with metadata and no hint.
+     * With `configOf`, a named configuration with no row of the asset is not read (`settled`). With several,
+     * returns the first of `error`, `originalUnread`, `missing`, `pending`, `settled` any read had.
+     */
+    refreshAsset(target: UploadSettlementTarget): Promise<UploadRefreshOutcome>;
+    /** The caller knows the file is processed: a read at once, with the hint `processed`. */
+    settleKnownProcessed(target: UploadSettlementTarget, options: {
+        withMetadata: boolean;
+    }): Promise<void>;
+    /** Settles a known duplicate without reading the asset: the `duplicate` event, or a copy the licence already has. */
+    settleKnownDuplicate(target: UploadSettlementTarget, originFileId: DocIdNullable, assetType: DamAssetTypeType | null): Promise<void>;
+    /** A known failure, without a read. Synchronous. */
+    settleKnownFailed(target: UploadSettlementTarget, failReason: AssetFileFailReasonType): void;
+    /** The row failed because too many reads found no asset, and the server has not settled it otherwise since. */
+    isGivenUpMissing(row: UploadQueueItem): boolean;
+    hasTracked(): boolean;
+    dispose(): void;
+}

package/dist/domains/dam/uploadQueue/settlement/uploadSettlementTypes.js

@@ -0,0 +1,11 @@
+// src/domains/dam/uploadQueue/settlement/uploadSettlementTypes.ts
+var e = {
+	Upload: "upload",
+	Slot: "slot",
+	MassEdit: "massEdit",
+	Copy: "copy",
+	ExternalImport: "externalImport"
+};
+export { e as UploadRowRole };
+
+//# sourceMappingURL=uploadSettlementTypes.js.map

package/dist/domains/dam/uploadQueue/settlement/uploadSettlementTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadSettlementTypes.js","names":["UploadRowRole"],"sources":["../../../../../src/domains/dam/uploadQueue/settlement/uploadSettlementTypes.ts"],"sourcesContent":["import type { DocId, DocIdNullable, IntegerId } from '@/shared/types/common'\nimport type { AssetDetailItemDto, DamAssetTypeType } from '@/domains/dam/types/Asset'\nimport type { AssetFileFailReasonType, AssetFileNullable } from '@/domains/dam/types/AssetFile'\nimport type { UploadQueue, UploadQueueItem, UploadQueueKey } from '@/domains/dam/types/UploadQueue'\n\nexport const UploadRowRole = {\n  Upload: 'upload',\n  Slot: 'slot',\n  MassEdit: 'massEdit',\n  Copy: 'copy',\n  ExternalImport: 'externalImport',\n} as const\nexport type UploadRowRoleType = (typeof UploadRowRole)[keyof typeof UploadRowRole]\n\nexport interface UploadSettlePolicy {\n  /** How a tick reads the state of the row's file. `none`: the row is never tracked. */\n  reader: 'asset' | 'slots' | 'none'\n  /**\n   * Applies to the `processed` state only.\n   * `read`: uploaded only after a read; the event just starts the read.\n   * `event`: the event state is written at once; the read completes the row.\n   * `never`: `processed` does not change the row state (mass edit), it only completes\n   * it. `failed` and `duplicate` apply to every row matching `matches(…, 'settle')`.\n   */\n  settleOn: 'read' | 'event' | 'never'\n  duplicate: 'becomeOriginal' | 'markDuplicate'\n  /** `load`: the row gets a form, and its metadata is loaded into it. */\n  metadata: 'load' | 'none'\n}\n\nexport interface UploadSettlementTarget {\n  assetId: DocId\n  /** `null` when the caller does not know the file. */\n  fileId: DocIdNullable\n  /**\n   * DAM configurations of the target. With `configOf`, rows in queues of other configurations are not concerned.\n   * Omitted or empty: rows of every queue. Two DAMs may share an asset id.\n   */\n  configNames?: string[]\n}\n\n/** Per-request options a reader may honour. A reader that ignores them keeps its old behaviour. */\nexport interface UploadReadOptions {\n  /**\n   * Whether a failure of this request should be reported to the app error collector.\n   * Polls and notifications retry while a row waits, so only the first failure of a streak is\n   * `true`. An answered read ends the streak; with `configOf`, streaks are per configuration.\n   * A streak starts only with a failure that was written down (`readers.failureReported`).\n   * A 404 counts as such, so it is `true` at most once per row.\n   * A user-requested refresh is always `true`.\n   */\n  report: boolean\n  /**\n   * The queue the read is for: the polled queue, or for notification\n   * and refresh reads the queue of the first concerned row.\n   * Lets a reader use the queue's configuration. Omitted when the read concerns no row.\n   */\n  queueKey?: UploadQueueKey\n}\n\nexport interface UploadSettlementProfile {\n  /** Live view of the store's queues. The settlement keeps no rows and always asks. */\n  queues(): Iterable<[UploadQueueKey, UploadQueue]>\n  /**\n   * DAM configuration of the queue. With it, named targets and\n   * events concern only rows of their configurations' queues.\n   * Each such read runs once per named configuration, through the queue of its first concerned\n   * row, and writes only into those rows. A configuration with no row of the asset is not read.\n   * Reads run sequentially per configuration, in parallel across configurations (unnamed reads get\n   * their own lane), each with its own failure streak. Caches get the queue of the named rows.\n   * Without it, every row of the asset is concerned, all reads share one lane and streak, and caches get no queue.\n   */\n  configOf?(queueKey: UploadQueueKey): string\n  roleOf(row: UploadQueueItem): UploadRowRoleType\n  policyFor(role: UploadRowRoleType): UploadSettlePolicy\n  /**\n   * `settle`: the row may get a new state. `decorate`: it may be completed without a state change.\n   * `metadata`: it may get metadata from the metadata notification.\n   */\n  matches(row: UploadQueueItem, target: UploadSettlementTarget, purpose: 'settle' | 'decorate' | 'metadata'): boolean\n\n  readers: {\n    /** One asset; `null` when it does not exist (404). Throws only when the request fails. */\n    asset(assetId: DocId, options?: UploadReadOptions): Promise<AssetDetailItemDto | null>\n    /** Assets of one licence. The missing ones are not in the answer. An answer that is no list throws. */\n    assets(licenceId: IntegerId, assetIds: DocId[], options?: UploadReadOptions): Promise<AssetDetailItemDto[]>\n    /** DAM: the files of all the slots of an asset. An answer that is no list throws. */\n    slotFiles?(assetId: DocId, options?: UploadReadOptions): Promise<AssetFileNullable[]>\n    /**\n     * LIB: the asset the original file of a duplicate belongs to. `queueKey`: of the first row that is to become it.\n     */\n    duplicateOriginAsset?(\n      originFileId: DocId,\n      options?: Pick<UploadReadOptions, 'queueKey'>\n    ): Promise<AssetDetailItemDto>\n    /** DAM: the original file of a duplicate, by its type. */\n    duplicateOriginFile?(originFileId: DocId, assetType: DamAssetTypeType): Promise<AssetFileNullable>\n    /**\n     * Whether a failure of a read with `report: true` was written\n     * down, judged by the thrown error, e.g. `apiErrorIsReported`.\n     * If not (timeout, 401, 403), nobody was told and the next read may\n     * report again. Without this, every failure counts as written down.\n     */\n    failureReported?(error: unknown): boolean\n  }\n  /**\n   * `queueKey` is passed as the second argument only to a profile with `configOf`.\n   * Wrap a `defineCached` `add`, which treats every argument as an id.\n   * Such a profile is asked to fetch once per queue whose rows got\n   * names since its last fetch. Without `configOf`, calls get no queue.\n   */\n  caches: {\n    addAuthors(ids: DocId[], queueKey?: UploadQueueKey): void\n    addKeywords(ids: DocId[], queueKey?: UploadQueueKey): void\n    fetchAuthors(queueKey?: UploadQueueKey): void\n    fetchKeywords(queueKey?: UploadQueueKey): void\n  }\n  messages: {\n    processingTooLong(row: UploadQueueItem): string\n    readFailed(row: UploadQueueItem): string\n    assetMissing(row: UploadQueueItem): string\n    /**\n     * Fail text for an uploaded row without metadata whose asset\n     * was missing from too many reads. Defaults to `assetMissing`.\n     */\n    assetGone?(row: UploadQueueItem): string\n  }\n  /**\n   * `'load'`: the row may get metadata from the notification although it failed. `undefined`: default rules.\n   * DAM: a mass-edit row its batch load left out.\n   */\n  metadataGate?(queueKey: UploadQueueKey, row: UploadQueueItem): 'load' | undefined\n  hooks: {\n    /** The row has reached a final state: count the queue again and start the next waiting upload. */\n    onRowFinal(queueKey: UploadQueueKey, row: UploadQueueItem): void\n    /** After every asset that was read (DAM: the main file for the open detail). */\n    onAssetRead?(asset: AssetDetailItemDto): void\n    /** A row with `settleOn: 'never'` has learnt its file is processed (an event, a tick or a manual read). */\n    onProcessedSeen?(queueKey: UploadQueueKey, row: UploadQueueItem): void\n    afterMetadataLoaded?(queueKey: UploadQueueKey, row: UploadQueueItem): void\n    /**\n     * Whether a refresh may still change a failed row; called when\n     * that changes, for stores that offer refresh only where it helps.\n     * `true`: tracked despite `clientFailed: true`, or a duplicate whose original could not be read.\n     * `false`: the server settled the file, the asset was missing too\n     * often, or the store removed the row (`untrack`, `dropQueue`).\n     * Never `false` without a prior `true`. Not called by `dispose()`.\n     */\n    onRefreshMayHelp?(queueKey: UploadQueueKey, row: UploadQueueItem, mayHelp: boolean): void\n  }\n  connection: {\n    /**\n     * Whether notifications arrive for the queue's rows; the poll is then\n     * only a backup. A profile with one shared state may ignore `queueKey`.\n     */\n    isPushAlive(queueKey?: UploadQueueKey): boolean\n    /** Called whenever that may have changed, for any queue. */\n    onChange(callback: () => void): () => void\n  }\n}\n\nexport interface UploadSettlementEvent {\n  kind: 'processed' | 'failed' | 'duplicate' | 'metadata' | 'copied'\n  assetId: DocId\n  /** `event.data.id` */\n  fileId: DocIdNullable\n  failReason?: AssetFileFailReasonType\n  originAssetFile?: DocIdNullable\n  assetType?: DamAssetTypeType | null\n  /** DAM configurations of the event, as on `UploadSettlementTarget`. Omitted: every queue. */\n  configNames?: string[]\n}\n\n/**\n * `settled`: the main file is final, or the asset was missing too often and its rows were given up. `pending`: not yet.\n * Retryable: `error` (read failed), `missing` (asset not found),\n * `originalUnread` (duplicate's original could not be read).\n */\nexport type UploadRefreshOutcome = 'settled' | 'pending' | 'error' | 'missing' | 'originalUnread'\n\nexport interface UploadSettlement {\n  /** The row starts waiting for the server. Ignored if the row is not in `queueKey`. */\n  track(queueKey: UploadQueueKey, row: UploadQueueItem, options?: { clientFailed?: boolean }): void\n  untrack(row: UploadQueueItem): void\n  /** The queue was cleared: its poller is dropped. */\n  dropQueue(queueKey: UploadQueueKey): void\n\n  /** A notification. Resolves after the write (a delayed read included) or after a failed read; never rejects. */\n  notify(event: UploadSettlementEvent): Promise<void>\n  /**\n   * Manual refresh: an immediate read with metadata and no hint.\n   * With `configOf`, a named configuration with no row of the asset is not read (`settled`). With several,\n   * returns the first of `error`, `originalUnread`, `missing`, `pending`, `settled` any read had.\n   */\n  refreshAsset(target: UploadSettlementTarget): Promise<UploadRefreshOutcome>\n  /** The caller knows the file is processed: a read at once, with the hint `processed`. */\n  settleKnownProcessed(target: UploadSettlementTarget, options: { withMetadata: boolean }): Promise<void>\n  /** Settles a known duplicate without reading the asset: the `duplicate` event, or a copy the licence already has. */\n  settleKnownDuplicate(\n    target: UploadSettlementTarget,\n    originFileId: DocIdNullable,\n    assetType: DamAssetTypeType | null\n  ): Promise<void>\n  /** A known failure, without a read. Synchronous. */\n  settleKnownFailed(target: UploadSettlementTarget, failReason: AssetFileFailReasonType): void\n\n  /** The row failed because too many reads found no asset, and the server has not settled it otherwise since. */\n  isGivenUpMissing(row: UploadQueueItem): boolean\n  hasTracked(): boolean\n  dispose(): void\n}\n"],"mappings":";AAKA,IAAaA,IAAgB;CAC3B,QAAQ;CACR,MAAM;CACN,UAAU;CACV,MAAM;CACN,gBAAgB;AAClB"}

package/dist/domains/dam/uploadQueue/store/uploadQueuesStore.d.ts

@@ -0,0 +1,54 @@
+import { UploadRefreshOutcome } from '../settlement/uploadSettlementTypes';
+import { DocId, DocIdNullable, IntegerId } from '../../../../shared/types/common';
+import { AssetDetailItemDto, DamAssetTypeType } from '../../types/Asset';
+import { AssetFileFailReasonType } from '../../types/AssetFile';
+import { UploadQueue, UploadQueueItem, UploadQueueKey } from '../../types/UploadQueue';
+/** Fields the user edits and a detail save writes. */
+export interface EditableFields {
+    keywords: DocId[];
+    authors: DocId[];
+    customData: UploadQueueItem['customData'];
+    mainFileSingleUse: boolean | null | undefined;
+}
+/** Field-by-field snapshot of an asset's rows (`noteRowsOfAsset`). */
+export interface RowsNote {
+    assetId: DocId;
+    /** DAM configuration of the queues the rows are in. */
+    configName: string;
+    rows: Map<UploadQueueItem, EditableFields>;
+}
+/**
+ * Which rows a settle function targets: queues of the named DAM configuration, or of the configuration of `queueKey`.
+ * Required because two DAMs may share an asset id.
+ */
+export type UploadQueueRowsOf = string | {
+    queueKey: UploadQueueKey;
+};
+export declare const useUploadQueuesStore: import('pinia').SetupStoreDefinition<"commonAdminUploadQueuesStore", {
+    getQueue: (queueKey: UploadQueueKey) => UploadQueue | null;
+    getQueueItems: (queueKey: UploadQueueKey) => UploadQueueItem[];
+    addByFiles: (queueKey: UploadQueueKey, extSystem: IntegerId, assetLicence: IntegerId, files: File[], configName: string) => Promise<void>;
+    addByCopyToLicence: (queueKey: UploadQueueKey, extSystem: IntegerId, assetLicence: IntegerId, assets: DocId[], configName: string) => Promise<void>;
+    queueItemProcessed: (assetId: DocId, of: UploadQueueRowsOf) => Promise<void>;
+    queueItemFullyProcessed: (assetId: DocId, of: UploadQueueRowsOf) => Promise<void>;
+    queueItemDuplicate: (assetId: DocId, originAssetFile: DocIdNullable, assetType: DamAssetTypeType | null, of: UploadQueueRowsOf) => Promise<void>;
+    queueItemFailed: (assetId: DocId, failReason: AssetFileFailReasonType, of: UploadQueueRowsOf) => Promise<void>;
+    refreshAsset: (assetId: DocId, of: UploadQueueRowsOf) => Promise<UploadRefreshOutcome>;
+    /**
+     * Whether a refresh may still change a failed row. True when its finish request went out before the client gave
+     * up and the server has said nothing final since, or when it is a duplicate whose original could not be read.
+     */
+    refreshMayHelp: (item: UploadQueueItem) => boolean;
+    /** The row failed because its asset was missing from enough reads ("Asset už neexistuje."). */
+    isGivenUpMissing: (item: UploadQueueItem) => boolean;
+    removeByIndex: (queueKey: UploadQueueKey, index: number) => void;
+    stopItemUpload: (queueKey: UploadQueueKey, queueItem: UploadQueueItem, _index?: number) => Promise<void>;
+    getQueueTotalCount: (queueKey: UploadQueueKey) => number;
+    getQueueProcessedCount: (queueKey: UploadQueueKey) => number;
+    stopUpload: (queueKey: UploadQueueKey) => void;
+    getQueueItemsTypes: (queueKey: UploadQueueKey) => DamAssetTypeType[];
+    updateFromDetail: (asset: AssetDetailItemDto, configName: string, mainFileSingleUse?: boolean | null, rowsAtSave?: RowsNote) => Promise<void>;
+    noteRowsOfAsset: (assetId: DocId, configName: string) => RowsNote;
+    forgetRowsNote: (note: RowsNote) => void;
+    forceReloadFileInput: (queueKey: UploadQueueKey) => void;
+}>;

package/dist/domains/dam/uploadQueue/store/uploadQueuesStore.js

@@ -0,0 +1,319 @@
+import { requestedUrl as e } from "../../../api/composables/request.js";
+import { apiErrorIsReported as t, apiErrorStatus as n, mapApiError as r, report as i } from "../../../api/utils/apiErrors.js";
+import { useCommonAdminCoreDamOptions as a } from "../../composables/commonAdminCoreDamOptions.js";
+import { ENTITY as o, fetchAsset as s, fetchAssetByFileId as c, fetchAssetListByIds as l } from "../../api/damAssetApi.js";
+import { SYSTEM_CORE_DAM as u } from "../../api/damConstants.js";
+import { useDamCachedAuthors as d } from "../../author/composables/cachedAuthors.js";
+import { useUploadQueueItemFactory as f } from "../factory/UploadQueueItemFactory.js";
+import { useAssetSuggestions as p } from "../composables/assetSuggestions.js";
+import { useDamConfigState as m } from "../../config/composables/damConfigState.js";
+import { useDamNotifications as h } from "../../composables/damNotifications.js";
+import { useDamNotificationsConnection as g } from "../../composables/damNotificationsConnection.js";
+import { DamNotificationName as _ } from "../../composables/damNotificationsEventBus.js";
+import { getAssetTypeByMimeType as v } from "../utils/mimeTypeHelper.js";
+import { UPLOAD_QUEUE_ITEM_CHUNK_SIZE as y, createUploadQueueCore as b } from "../core/uploadQueueCore.js";
+import { libraryQueuePreset as x } from "../presets/queuePresets.js";
+import { UploadRowRole as S } from "../settlement/uploadSettlementTypes.js";
+import { useDamCachedKeywords as C } from "../../keyword/composables/cachedKeywords.js";
+import { damFileTypeFix as w } from "../../../ui/file/utils/fileType.js";
+import { DamAssetType as T } from "../../types/Asset.js";
+import { UploadQueueItemStatus as E, UploadQueueItemType as D } from "../../types/UploadQueue.js";
+import { AnzuApiResponseCodeError as ee } from "../../../../shared/error/AnzuApiResponseCodeError.js";
+import { cloneDeep as O, isArray as k, isString as A, isUndefined as j } from "../../../../shared/utils/common.js";
+import { commonT as M } from "../../../../plugins/i18n.js";
+import { getCurrentScope as te, ref as ne } from "vue";
+import { defineStore as N } from "pinia";
+// src/domains/dam/uploadQueue/store/uploadQueuesStore.ts
+var re = (e) => O({
+	keywords: e.keywords,
+	authors: e.authors,
+	customData: e.customData,
+	mainFileSingleUse: e.mainFileSingleUse
+}), P = (e, t) => JSON.stringify(e) === JSON.stringify(t), F = (e, t, n) => {
+	let r = {
+		fields: /* @__PURE__ */ new Set(),
+		customKeys: /* @__PURE__ */ new Set()
+	}, i = (n) => !t || P(e[n], t[n]) ? !0 : (r.fields.add(n), !1);
+	i("keywords") && (e.keywords = [...n.keywords]), i("authors") && (e.authors = [...n.authors]);
+	let a = O(n.customData);
+	if (t && a) {
+		let n = e.customData ?? {}, i = t.customData ?? {};
+		(/* @__PURE__ */ new Set([...Object.keys(n), ...Object.keys(i)])).forEach((e) => {
+			P(n[e], i[e]) || (r.customKeys.add(e), e in n ? a[e] = O(n[e]) : delete a[e]);
+		});
+	}
+	return e.customData = a, j(n.mainFileSingleUse) ? r.fields.add("mainFileSingleUse") : i("mainFileSingleUse") && (e.mainFileSingleUse = n.mainFileSingleUse), r;
+}, ie = (e, t, n) => {
+	let r = e.rows.get(t);
+	if (!r) return;
+	n.fields.has("keywords") || (r.keywords = [...t.keywords]), n.fields.has("authors") || (r.authors = [...t.authors]), n.fields.has("mainFileSingleUse") || (r.mainFileSingleUse = t.mainFileSingleUse);
+	let i = t.customData ?? {}, a = r.customData = { ...r.customData };
+	(/* @__PURE__ */ new Set([...Object.keys(i), ...Object.keys(a)])).forEach((e) => {
+		n.customKeys.has(e) || (e in i ? a[e] = O(i[e]) : delete a[e]);
+	});
+}, I = N("commonAdminUploadQueuesStore", () => {
+	let O = ne(/* @__PURE__ */ new Map()), { createDefault: N } = f(), P = /* @__PURE__ */ new Map(), I = (e) => (j(e) ? void 0 : P.get(e)) ?? "default", L = (e) => a(I(e)), ae = {
+		roleOf: (e) => e.type === D.Asset ? S.Copy : S.Upload,
+		policyFor: () => ({
+			reader: "asset",
+			settleOn: "read",
+			duplicate: "becomeOriginal",
+			metadata: "load"
+		}),
+		matches: (e, t) => e.assetId === t.assetId,
+		readers: {
+			asset: async (e, t) => {
+				let { damClient: r, endPointAsset: i } = L(t?.queueKey);
+				try {
+					return t?.report === !1 ? await s(r, i, e, { report: !1 }) : await s(r, i, e);
+				} catch (e) {
+					if (n(e) === 404) return null;
+					throw e;
+				}
+			},
+			assets: async (t, n, a) => {
+				let { damClient: s, endPointAsset: c } = L(a?.queueKey);
+				try {
+					return await l(s, c, n, t);
+				} catch (l) {
+					if (a?.report) {
+						let a = k(l) ? l.at(-1) : void 0, d = `${c}/licence/${t}/ids/${n.join(",")}`, f = {
+							system: u,
+							entity: o,
+							url: e(s, d, {}, l, a?.config)
+						}, p = k(l) ? new ee(a?.status ?? 0) : l;
+						throw i(r(p, f), f);
+					}
+					throw l;
+				}
+			},
+			duplicateOriginAsset: async (e, t) => {
+				let { damClient: n, endPointAsset: r } = L(t?.queueKey);
+				return c(n, r, e);
+			},
+			failureReported: t
+		},
+		configOf: I,
+		caches: {
+			addAuthors: (e, t) => d(I(t)).addToCachedAuthors(e),
+			addKeywords: (e, t) => C(I(t)).addToCachedKeywords(e),
+			fetchAuthors: (e) => d(I(e)).fetchCachedAuthors(),
+			fetchKeywords: (e) => C(I(e)).fetchCachedKeywords()
+		},
+		messages: {
+			processingTooLong: () => M("common.damImage.uploadErrors.processingTooLong"),
+			readFailed: () => M("common.damImage.uploadErrors.readFailed"),
+			assetMissing: () => M("common.damImage.uploadErrors.unknownError"),
+			assetGone: () => M("common.damImage.queueItem.assetGone")
+		},
+		connection: {
+			isPushAlive: (e) => g(I(e)).isPushAlive(),
+			onChange: g().onChange
+		}
+	}, R = b(x({
+		queues: O,
+		settlement: ae,
+		configOf: I
+	})), { settlement: z } = R;
+	function B(e, t, n) {
+		let r = P.get(e);
+		if (!j(r) && r !== t && R.getQueueItems(e).length > 0) throw Error(`useUploadQueuesStore: the queue "${e}" has rows under the DAM configuration "${r}", none is added under "${t}".`);
+		P.set(e, t), R.addRow(e, n);
+	}
+	let V = te(), H = (e, t) => {
+		switch (e.name) {
+			case _.AssetFileProcessed: return {
+				kind: "processed",
+				assetId: e.data.asset,
+				fileId: null,
+				configNames: t
+			};
+			case _.AssetFileFailed: return {
+				kind: "failed",
+				assetId: e.data.asset,
+				fileId: null,
+				failReason: e.data.failReason,
+				configNames: t
+			};
+			case _.AssetFileDuplicate: return {
+				kind: "duplicate",
+				assetId: e.data.asset,
+				fileId: null,
+				originAssetFile: e.data.originAssetFile,
+				assetType: e.data.assetType,
+				configNames: t
+			};
+			case _.AssetMetadataProcessed: return {
+				kind: "metadata",
+				assetId: e.data.asset,
+				fileId: null,
+				configNames: t
+			};
+			case _.AssetFileCopied: return {
+				kind: "copied",
+				assetId: e.data.asset,
+				fileId: null,
+				configNames: t
+			};
+		}
+		return null;
+	}, { addDamNotificationListener: U } = h(), W = !1;
+	function G() {
+		if (W) return;
+		W = !0;
+		let e = () => U((e, t) => {
+			let n = H(e, t);
+			n && z.notify(n);
+		}, { all: !0 });
+		V ? V.run(e) : e();
+	}
+	async function K(e, t, n, r, i) {
+		a(i);
+		let { getDamConfigExtSystem: o } = m(void 0, i), s = o(t);
+		if (j(s)) throw Error("useUploadQueuesStore.addByCopyToLicence: Ext system must be initialised.");
+		G();
+		for (let t of r) {
+			let r = N(R.uniqueKey("asset_" + t), D.Asset, E.Processing, T.Image, y, n);
+			r.assetId = t, B(e, i, r);
+			let a = R.getQueueItems(e).at(-1);
+			a && R.track(e, a);
+		}
+	}
+	async function q(e, t, n, r, i) {
+		a(i);
+		let { getDamConfigExtSystem: o } = m(void 0, i), s = o(t);
+		if (j(s)) throw Error("useUploadQueuesStore.addByFiles: Ext system must be initialised.");
+		G();
+		for await (let t of r) {
+			let r = v(w(t), s);
+			if (!r || r !== T.Image) continue;
+			let a = N(R.uniqueKey("file_" + t.name), D.File, E.Waiting, r, y, n);
+			a.file = t, a.displayTitle = t.name, B(e, i, a);
+		}
+	}
+	let J = (e, t) => ({
+		assetId: e,
+		fileId: null,
+		configNames: [A(t) ? t : I(t.queueKey)]
+	});
+	function oe(e, t) {
+		return z.notify({
+			kind: "processed",
+			...J(e, t)
+		});
+	}
+	function se(e, t) {
+		return z.settleKnownProcessed(J(e, t), { withMetadata: !0 });
+	}
+	function ce(e, t, n, r) {
+		return z.settleKnownDuplicate(J(e, r), t, n);
+	}
+	async function le(e, t, n) {
+		z.settleKnownFailed(J(e, n), t);
+	}
+	function ue(e, t) {
+		return z.refreshAsset(J(e, t));
+	}
+	async function de(e, t, n) {
+		R.stopItemUpload(e, t);
+	}
+	let Y = /* @__PURE__ */ new Map(), fe = (e, t) => `${e}\u0000${t}`, pe = 0, X = /* @__PURE__ */ new Set();
+	function Z(e, t) {
+		let n = /* @__PURE__ */ new Map();
+		O.value.forEach((r, i) => {
+			I(i) === t && r.items.forEach((t) => {
+				t.assetId === e && t.type && n.set(t, re(t));
+			});
+		});
+		let r = {
+			assetId: e,
+			configName: t,
+			rows: n
+		};
+		return X.add(r), r;
+	}
+	function Q(e) {
+		X.delete(e);
+	}
+	let $ = (e, t, n) => {
+		X.forEach((r) => {
+			r !== e && r.assetId === e.assetId && r.configName === e.configName && ie(r, t, n);
+		});
+	};
+	async function me(e, t, n, r) {
+		let { updateNewNames: i, getAuthorConflicts: o } = p(), c;
+		try {
+			c = a(t);
+		} catch {
+			return;
+		}
+		let { addToCachedKeywords: l, fetchCachedKeywords: u } = C(t), { addToCachedAuthors: f, fetchCachedAuthors: m } = d(t), h = () => Array.from(O.value.entries()).filter(([e]) => I(e) === t), g = h().flatMap(([, e]) => e.items);
+		if (!g.some((t) => t.assetId === e.id && !!t.type) && !g.some((t) => !!t.type && t.status === E.Processing && t.licenceId === e.licence)) {
+			r && Q(r);
+			return;
+		}
+		let _ = r ?? Z(e.id, t), v = _.rows, y = ++pe, b = fe(t, e.id);
+		Y.set(b, y);
+		let x = () => Y.get(b) === y;
+		try {
+			let t = await s(c.damClient, c.endPointAsset, e.id);
+			if (!x()) return;
+			h().forEach(([e, n]) => {
+				n.items.forEach((e) => {
+					if (e.assetId === t.id && e.type) {
+						let r = F(e, v.get(e), {
+							keywords: t.keywords,
+							authors: t.authors,
+							customData: t.metadata.customData,
+							mainFileSingleUse: t.mainFileSingleUse
+						});
+						$(_, e, r), i(t.metadata.authorSuggestions, n.suggestions.newAuthorNames), i(t.metadata.keywordSuggestions, n.suggestions.newKeywordNames), e.authorConflicts = o(t.metadata.authorSuggestions), l(e.keywords), f(e.authors), f(e.authorConflicts);
+					}
+				}), R.recalculateQueueCounts(e), m(), u();
+			});
+		} catch {
+			if (!x()) return;
+			h().forEach(([, t]) => {
+				t.items.forEach((t) => {
+					if (t.assetId === e.id && t.type) {
+						let r = F(t, v.get(t), {
+							keywords: e.keywords,
+							authors: e.authors,
+							customData: e.metadata.customData,
+							mainFileSingleUse: j(n) ? void 0 : n
+						});
+						$(_, t, r), l(t.keywords), f(t.authors);
+					}
+				});
+			}), m(), u();
+		} finally {
+			Q(_), x() && Y.delete(b);
+		}
+	}
+	return {
+		getQueue: R.getQueue,
+		getQueueItems: R.getQueueItems,
+		addByFiles: q,
+		addByCopyToLicence: K,
+		queueItemProcessed: oe,
+		queueItemFullyProcessed: se,
+		queueItemDuplicate: ce,
+		queueItemFailed: le,
+		refreshAsset: ue,
+		refreshMayHelp: R.refreshMayHelp,
+		isGivenUpMissing: (e) => z.isGivenUpMissing(e),
+		removeByIndex: R.removeByIndex,
+		stopItemUpload: de,
+		getQueueTotalCount: R.getQueueTotalCount,
+		getQueueProcessedCount: R.getQueueProcessedCount,
+		stopUpload: R.stopUpload,
+		getQueueItemsTypes: R.getQueueItemsTypes,
+		updateFromDetail: me,
+		noteRowsOfAsset: Z,
+		forgetRowsNote: Q,
+		forceReloadFileInput: R.forceReloadFileInput
+	};
+});
+export { I as useUploadQueuesStore };
+
+//# sourceMappingURL=uploadQueuesStore.js.map