@anzusystems/common-admin 1.47.0-beta.dev-1790143991 → 2.0.0-rc.1

package/dist/domains/dam/uploadQueue/core/uploadQueueCore.js

@@ -0,0 +1,176 @@
+import { isUndefined as e } from "../../../../shared/utils/common.js";
+import { apiErrorStatus as t } from "../../../api/utils/apiErrors.js";
+import { UploadQueueItemStatus as n } from "../../types/UploadQueue.js";
+import { createUploadSettlement as r } from "../settlement/uploadSettlement.js";
+import { uploadQueuePresetMembers as i } from "./uploadQueueCoreTypes.js";
+import { getCurrentScope as a, onScopeDispose as o, reactive as s, toRaw as c } from "vue";
+import l from "axios";
+//#region src/domains/dam/uploadQueue/core/uploadQueueCore.ts
+var u = 2, d = 10485760, f = 0, p = (n) => {
+	let r = l.isAxiosError(n) ? n.response?.status : t(n);
+	return !e(r) && r >= 400 && r < 500;
+}, m = (e) => e === n.Waiting || e === n.Uploading || e === n.Processing;
+function h(e) {
+	let { queues: t, settlement: l, runnerFor: d, onClientFailure: h, rowTracked: g, rowRemoved: _, refreshable: v } = e[i], y = /* @__PURE__ */ new WeakMap(), b = s(/* @__PURE__ */ new WeakSet()), { hooks: x, ...S } = l, C = r({
+		...S,
+		queues: () => t.entries(),
+		hooks: {
+			...x,
+			onRowFinal: (e, t) => {
+				t.status === n.Failed && y.has(t) && U(t), x?.onRowFinal?.(e, t), I(e), z(e);
+			},
+			...v && { onRefreshMayHelp: (e, t, n) => {
+				n ? b.add(c(t)) : b.delete(c(t)), x?.onRefreshMayHelp?.(e, t, n);
+			} }
+		}
+	});
+	a() && o(() => C.dispose());
+	function w(e) {
+		return t.get(e) ?? null;
+	}
+	function T(e) {
+		return t.get(e)?.items ?? [];
+	}
+	function E(e, t) {
+		return T(e).filter((e) => e.status === t);
+	}
+	function D(e) {
+		return t.get(e)?.totalCount ?? 0;
+	}
+	function O(e) {
+		return t.get(e)?.processedCount ?? 0;
+	}
+	function k(e) {
+		return t.get(e)?.fileInputKey ?? -1;
+	}
+	function A(e) {
+		let t = [];
+		for (let n of T(e)) t.includes(n.assetType) || t.push(n.assetType);
+		return t;
+	}
+	function j(e) {
+		return `${e}_${++f}`;
+	}
+	function M(e) {
+		return {
+			items: [],
+			totalCount: 0,
+			processedCount: 0,
+			fileInputKey: e,
+			suggestions: {
+				newKeywordNames: /* @__PURE__ */ new Set(),
+				newAuthorNames: /* @__PURE__ */ new Set()
+			}
+		};
+	}
+	function N(e) {
+		t.get(e) || t.set(e, M(0));
+	}
+	function P(e, n) {
+		t.get(e)?.items.push(n);
+	}
+	function F(e, t) {
+		N(e), P(e, t), I(e), z(e);
+	}
+	function I(e) {
+		let r = t.get(e);
+		r && (r.totalCount = r.items.length, r.processedCount = E(e, n.Uploaded).length + E(e, n.Failed).length);
+	}
+	function L(e, t, n, r) {
+		e.progress.progressPercent = t, e.progress.remainingTime = r, e.progress.speed = n;
+	}
+	function R(e) {
+		N(e);
+		let n = t.get(e);
+		n && n.fileInputKey++;
+	}
+	function z(e) {
+		let t = E(e, n.Waiting);
+		if (t.length === 0) return;
+		let r = u - E(e, n.Uploading).length;
+		t.slice(0, Math.max(r, 0)).forEach((t) => V(t, e));
+	}
+	function B(e, t, n) {
+		g?.(e, t), C.track(e, t, n);
+	}
+	async function V(e, t) {
+		if (y.has(e)) return;
+		let r;
+		try {
+			r = d(e, t)(e, (t, n, r) => {
+				L(e, t, n, r);
+			}), y.set(e, r.stop), await r.uploadInit(), await r.upload(), y.delete(e), e.status === n.Processing && B(t, e), I(t), z(t);
+		} catch (i) {
+			if (y.delete(e), e.status === n.Stop || e.status === n.Uploaded || e.status === n.Failed) return;
+			let a = h?.(t, e, i);
+			e.error.hasError = !0, a && (e.error.message = a.message), e.status = n.Failed, e.canEditMetadata = !1, a?.alert(), r?.finishAttempted() && !p(i) && B(t, e, { clientFailed: !0 }), I(t), z(t);
+		}
+	}
+	function H(e) {
+		(m(e.status) || y.has(e)) && (e.status = n.Stop, U(e));
+	}
+	function U(e) {
+		y.get(e)?.(), y.delete(e), e.latestChunkAbortController?.abort();
+	}
+	function W(e, n) {
+		let r = t.get(e), i = r?.items[n];
+		r && i && (H(i), C.untrack(i), _?.(e, i), r.items.splice(n, 1), I(e), z(e));
+	}
+	function G(e, r) {
+		let i = t.get(e);
+		if (!i || i.items.length === 0) return;
+		r.status = n.Stop, C.untrack(r), U(r);
+		let a = i.items.indexOf(r);
+		a > -1 && W(e, a), z(e);
+	}
+	function K(e) {
+		let r = t.get(e);
+		if (!r) return;
+		if (r.items.length === 0) {
+			C.dropQueue(e);
+			return;
+		}
+		let i = E(e, n.Uploading);
+		r.items.forEach((e) => {
+			e.status = n.Stop, y.get(e)?.(), y.delete(e);
+		}), i.forEach((e) => e.latestChunkAbortController?.abort()), q(e), R(e);
+	}
+	function q(e) {
+		t.get(e)?.items.forEach((t) => {
+			_?.(e, t), H(t);
+		}), C.dropQueue(e), t.set(e, M(k(e) + 1));
+	}
+	function J(e) {
+		return e.status === n.Failed && b.has(c(e));
+	}
+	return {
+		settlement: C,
+		roleOf: (e) => l.roleOf(e),
+		getQueue: w,
+		getQueueItems: T,
+		getQueueItemsByStatus: E,
+		getQueueTotalCount: D,
+		getQueueProcessedCount: O,
+		getQueueFileInputKey: k,
+		getQueueItemsTypes: A,
+		uniqueKey: j,
+		createQueue: N,
+		addQueueItem: P,
+		addRow: F,
+		recalculateQueueCounts: I,
+		setUploadSpeed: L,
+		forceReloadFileInput: R,
+		processUpload: z,
+		queueItemUploadStart: V,
+		track: B,
+		removeByIndex: W,
+		stopItemUpload: G,
+		stopUpload: K,
+		clearQueue: q,
+		refreshMayHelp: J
+	};
+}
+//#endregion
+export { d as UPLOAD_QUEUE_ITEM_CHUNK_SIZE, h as createUploadQueueCore };
+
+//# sourceMappingURL=uploadQueueCore.js.map

package/dist/domains/dam/uploadQueue/core/uploadQueueCore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadQueueCore.js","names":["axios","QUEUE_MAX_PARALLEL_UPLOADS","UPLOAD_QUEUE_ITEM_CHUNK_SIZE","queueItemSequence","isRefusal","status","error","apiErrorStatus","isUndefined","isUnderWay","UploadQueueItemStatus","createUploadQueueCore","profile","preset","uploadQueuePresetMembers","stopHandles","refreshableRows","reactive","settlementProfile","settlement","createUploadSettlement","queues","hooks","row","stopRun","queueKey","recalculateQueueCounts","processUpload","refreshable","mayHelp","toRaw","getCurrentScope","onScopeDispose","getQueue","getQueueItems","getQueueItemsByStatus","item","getQueueTotalCount","getQueueProcessedCount","getQueueFileInputKey","getQueueItemsTypes","types","uniqueKey","prefix","emptyQueue","createQueue","addQueueItem","addRow","queue","setUploadSpeed","progress","estimate","speed","forceReloadFileInput","waitingItems","freeSlots","queueItemUploadStart","track","rowTracked","options","run","runnerFor","failure","onClientFailure","stopRow","removeByIndex","index","rowRemoved","stopItemUpload","currentIndex","stopUpload","uploading","clearQueue","refreshMayHelp"],"sources":["../../../../../src/domains/dam/uploadQueue/core/uploadQueueCore.ts"],"sourcesContent":["import axios from 'axios'\nimport { getCurrentScope, onScopeDispose, reactive, toRaw } from 'vue'\nimport { apiErrorStatus } from '@/domains/api/utils/apiErrors'\nimport type { DamAssetTypeType } from '@/domains/dam/types/Asset'\nimport {\n  type UploadQueue,\n  type UploadQueueItem,\n  UploadQueueItemStatus,\n  type UploadQueueItemStatusType,\n  type UploadQueueKey,\n} from '@/domains/dam/types/UploadQueue'\nimport { createUploadSettlement } from '@/domains/dam/uploadQueue/settlement/uploadSettlement'\nimport type { UploadRun, UploadSide } from '@/domains/dam/uploadQueue/presets/uploadPresets'\nimport {\n  type UploadQueueCore,\n  type UploadQueuePreset,\n  uploadQueuePresetMembers,\n} from '@/domains/dam/uploadQueue/core/uploadQueueCoreTypes'\nimport { isUndefined } from '@/shared/utils/common'\n\nconst QUEUE_MAX_PARALLEL_UPLOADS = 2\n\nexport const UPLOAD_QUEUE_ITEM_CHUNK_SIZE = 10485760\n\n// A file name is not unique, nor is an asset added twice: rows that share a `:key` have Vue patch the wrong one.\n// One count for every core of the page.\nlet queueItemSequence = 0\n\n// An answer of the server that says no (4xx). The requests of an upload reject with the error of axios as it is.\nconst isRefusal = (error: unknown) => {\n  const status = axios.isAxiosError(error) ? error.response?.status : apiErrorStatus(error)\n\n  return !isUndefined(status) && status >= 400 && status < 500\n}\n\n// Waiting for its turn, being sent, or with the server: not settled yet, one way or the other.\nconst isUnderWay = (status: UploadQueueItemStatusType) =>\n  status === UploadQueueItemStatus.Waiting ||\n  status === UploadQueueItemStatus.Uploading ||\n  status === UploadQueueItemStatus.Processing\n\n/**\n * The upload queue of a store: its queues as the store holds them, two uploads at a time per queue, the run of each\n * row, how a row leaves, and the settlement of the rows the server works on. Made in the setup of the store.\n */\nexport function createUploadQueueCore<S extends UploadSide>(preset: UploadQueuePreset<S>): UploadQueueCore {\n  const {\n    queues,\n    settlement: profile,\n    runnerFor,\n    onClientFailure,\n    rowTracked,\n    rowRemoved,\n    refreshable,\n  } = preset[uploadQueuePresetMembers]\n\n  // The runs still going, by their row as the core got it: a stop reaches a run also between its chunks.\n  const stopHandles = new WeakMap<UploadQueueItem, () => void>()\n  // The failed rows a refresh may still change, as the settlement tells them. Reactive, for the rows that show it.\n  const refreshableRows = reactive(new WeakSet<UploadQueueItem>())\n\n  const { hooks, ...settlementProfile } = profile\n  const settlement = createUploadSettlement({\n    ...settlementProfile,\n    queues: () => queues.entries(),\n    hooks: {\n      ...hooks,\n      onRowFinal: (queueKey, row) => {\n        // Z26: the server takes a failed file nowhere, so what is left of it is not sent. Its place is free below,\n        // and with the run stopped no third file goes out beside two.\n        if (row.status === UploadQueueItemStatus.Failed && stopHandles.has(row)) stopRun(row)\n        hooks?.onRowFinal?.(queueKey, row)\n        recalculateQueueCounts(queueKey)\n        processUpload(queueKey)\n      },\n      ...(refreshable && {\n        onRefreshMayHelp: (queueKey: UploadQueueKey, row: UploadQueueItem, mayHelp: boolean) => {\n          if (mayHelp) refreshableRows.add(toRaw(row))\n          else refreshableRows.delete(toRaw(row))\n          hooks?.onRefreshMayHelp?.(queueKey, row, mayHelp)\n        },\n      }),\n    },\n  })\n\n  // A store disposed of leaves nothing behind: no timer of a poll, no listener for the tab or for the socket.\n  if (getCurrentScope()) onScopeDispose(() => settlement.dispose())\n\n  function getQueue(queueKey: UploadQueueKey) {\n    return queues.get(queueKey) ?? null\n  }\n\n  function getQueueItems(queueKey: UploadQueueKey) {\n    return queues.get(queueKey)?.items ?? []\n  }\n\n  function getQueueItemsByStatus(queueKey: UploadQueueKey, status: UploadQueueItemStatusType) {\n    return getQueueItems(queueKey).filter((item) => item.status === status)\n  }\n\n  function getQueueTotalCount(queueKey: UploadQueueKey) {\n    return queues.get(queueKey)?.totalCount ?? 0\n  }\n\n  function getQueueProcessedCount(queueKey: UploadQueueKey) {\n    return queues.get(queueKey)?.processedCount ?? 0\n  }\n\n  function getQueueFileInputKey(queueKey: UploadQueueKey) {\n    return queues.get(queueKey)?.fileInputKey ?? -1\n  }\n\n  function getQueueItemsTypes(queueKey: UploadQueueKey) {\n    const types: Array<DamAssetTypeType> = []\n    for (const item of getQueueItems(queueKey)) {\n      if (!types.includes(item.assetType)) types.push(item.assetType)\n    }\n    return types\n  }\n\n  function uniqueKey(prefix: string) {\n    return `${prefix}_${++queueItemSequence}`\n  }\n\n  function emptyQueue(fileInputKey: number): UploadQueue {\n    return {\n      items: [],\n      totalCount: 0,\n      processedCount: 0,\n      fileInputKey,\n      suggestions: { newKeywordNames: new Set<string>(), newAuthorNames: new Set<string>() },\n    }\n  }\n\n  function createQueue(queueKey: UploadQueueKey) {\n    if (!queues.get(queueKey)) queues.set(queueKey, emptyQueue(0))\n  }\n\n  // Into a queue that is not there: nothing, as for the counts below.\n  function addQueueItem(queueKey: UploadQueueKey, item: UploadQueueItem) {\n    queues.get(queueKey)?.items.push(item)\n  }\n\n  function addRow(queueKey: UploadQueueKey, item: UploadQueueItem) {\n    createQueue(queueKey)\n    addQueueItem(queueKey, item)\n    recalculateQueueCounts(queueKey)\n    processUpload(queueKey)\n  }\n\n  function recalculateQueueCounts(queueKey: UploadQueueKey) {\n    const queue = queues.get(queueKey)\n    if (!queue) return\n    queue.totalCount = queue.items.length\n    queue.processedCount =\n      getQueueItemsByStatus(queueKey, UploadQueueItemStatus.Uploaded).length +\n      getQueueItemsByStatus(queueKey, UploadQueueItemStatus.Failed).length\n  }\n\n  function setUploadSpeed(item: UploadQueueItem, progress: number, speed: number, estimate: number) {\n    item.progress.progressPercent = progress\n    item.progress.remainingTime = estimate\n    item.progress.speed = speed\n  }\n\n  function forceReloadFileInput(queueKey: UploadQueueKey) {\n    createQueue(queueKey)\n    const queue = queues.get(queueKey)\n    if (!queue) return\n    queue.fileInputKey++\n  }\n\n  function processUpload(queueKey: UploadQueueKey) {\n    const waitingItems = getQueueItemsByStatus(queueKey, UploadQueueItemStatus.Waiting)\n    if (waitingItems.length === 0) return\n    const freeSlots =\n      QUEUE_MAX_PARALLEL_UPLOADS - getQueueItemsByStatus(queueKey, UploadQueueItemStatus.Uploading).length\n    waitingItems.slice(0, Math.max(freeSlots, 0)).forEach((item) => queueItemUploadStart(item, queueKey))\n  }\n\n  function track(queueKey: UploadQueueKey, item: UploadQueueItem, options?: { clientFailed?: boolean }) {\n    rowTracked?.(queueKey, item)\n    settlement.track(queueKey, item, options)\n  }\n\n  async function queueItemUploadStart(item: UploadQueueItem, queueKey: UploadQueueKey) {\n    // A row whose run is under way already: one that cannot be sent stays waiting while its hash loads, and the\n    // queue looks again after each file it adds.\n    if (stopHandles.has(item)) return\n    let run: UploadRun<S> | undefined\n    try {\n      // Made here: a set that cannot make the run fails its row as a failed upload does. Thrown past this, it left\n      // the row waiting, to be started and to throw again with every row after it.\n      run = runnerFor(item, queueKey)(item, (progress, speed, estimate) => {\n        setUploadSpeed(item, progress, speed, estimate)\n      })\n      stopHandles.set(item, run.stop)\n      await run.uploadInit()\n      await run.upload()\n      stopHandles.delete(item)\n      // Not a row its notification has settled meanwhile, nor a stopped one.\n      if (item.status === UploadQueueItemStatus.Processing) track(queueKey, item)\n      recalculateQueueCounts(queueKey)\n      processUpload(queueKey)\n    } catch (error) {\n      stopHandles.delete(item)\n      // Stopped: it is gone from the queue, or the queue goes, and whatever stopped it started the next one. Uploaded:\n      // the processed notification beat the answer to the finish request, and its settlement counted the queue.\n      if (item.status === UploadQueueItemStatus.Stop || item.status === UploadQueueItemStatus.Uploaded) return\n      // Failed before its request was, by the settlement, which stopped the run and counted the queue: the row keeps\n      // the reason of the server, nothing is written over it and nothing told (Z26).\n      if (item.status === UploadQueueItemStatus.Failed) return\n      // Read before anything is written into the row: whether its reason was told already is among the failed rows.\n      const failure = onClientFailure?.(queueKey, item, error)\n      item.error.hasError = true\n      if (failure) item.error.message = failure.message\n      item.status = UploadQueueItemStatus.Failed\n      // Its metadata event comes while the file still sends, and had enabled the form.\n      item.canEditMetadata = false\n      failure?.alert()\n      // The finish request went out, so the server may complete the file all the same: the row is asked about for as\n      // long as it stays in the queue. Not when the server answered that request with a refusal: it is sent once,\n      // and a file the server has refused to finish it will not finish.\n      if (run?.finishAttempted() && !isRefusal(error)) {\n        track(queueKey, item, { clientFailed: true })\n      }\n      recalculateQueueCounts(queueKey)\n      processUpload(queueKey)\n    }\n  }\n\n  // A row on its way, or one whose upload still runs although the server has settled it, is stopped: its run, also\n  // between chunks, and the chunk on the wire. A settled row without a run stays as it is.\n  function stopRow(item: UploadQueueItem) {\n    if (!isUnderWay(item.status) && !stopHandles.has(item)) return\n    item.status = UploadQueueItemStatus.Stop\n    stopRun(item)\n  }\n\n  function stopRun(item: UploadQueueItem) {\n    stopHandles.get(item)?.()\n    stopHandles.delete(item)\n    item.latestChunkAbortController?.abort()\n  }\n\n  function removeByIndex(queueKey: UploadQueueKey, index: number) {\n    const queue = queues.get(queueKey)\n    const item = queue?.items[index]\n    if (!queue || !item) return\n    stopRow(item)\n    // The poll of the queue no longer asks about it, nor does a read a notification asked for on its behalf.\n    settlement.untrack(item)\n    rowRemoved?.(queueKey, item)\n    queue.items.splice(index, 1)\n    recalculateQueueCounts(queueKey)\n    // Its run, if any, ends without starting the next row: the place is free now.\n    processUpload(queueKey)\n  }\n\n  function stopItemUpload(queueKey: UploadQueueKey, item: UploadQueueItem) {\n    const queue = queues.get(queueKey)\n    if (!queue || queue.items.length === 0) return\n    item.status = UploadQueueItemStatus.Stop\n    settlement.untrack(item)\n    stopRun(item)\n    // By identity: the position the caller saw the row at is another row's once the list has changed.\n    const currentIndex = queue.items.indexOf(item)\n    if (currentIndex > -1) removeByIndex(queueKey, currentIndex)\n    processUpload(queueKey)\n  }\n\n  function stopUpload(queueKey: UploadQueueKey) {\n    const queue = queues.get(queueKey)\n    if (!queue) return\n    if (queue.items.length === 0) {\n      // Emptied row by row, the queue still has its idle poll: it goes with the queue.\n      settlement.dropQueue(queueKey)\n      return\n    }\n    const uploading = getQueueItemsByStatus(queueKey, UploadQueueItemStatus.Uploading)\n    queue.items.forEach((item) => {\n      item.status = UploadQueueItemStatus.Stop\n      stopHandles.get(item)?.()\n      stopHandles.delete(item)\n    })\n    uploading.forEach((item) => item.latestChunkAbortController?.abort())\n    clearQueue(queueKey)\n    forceReloadFileInput(queueKey)\n  }\n\n  // Also of a queue that is not there: it is made, empty.\n  function clearQueue(queueKey: UploadQueueKey) {\n    queues.get(queueKey)?.items.forEach((item) => {\n      rowRemoved?.(queueKey, item)\n      stopRow(item)\n    })\n    // Before the queue is replaced: its rows are no longer asked about.\n    settlement.dropQueue(queueKey)\n    queues.set(queueKey, emptyQueue(getQueueFileInputKey(queueKey) + 1))\n  }\n\n  function refreshMayHelp(item: UploadQueueItem) {\n    return item.status === UploadQueueItemStatus.Failed && refreshableRows.has(toRaw(item))\n  }\n\n  return {\n    settlement,\n    roleOf: (item) => profile.roleOf(item),\n    getQueue,\n    getQueueItems,\n    getQueueItemsByStatus,\n    getQueueTotalCount,\n    getQueueProcessedCount,\n    getQueueFileInputKey,\n    getQueueItemsTypes,\n    uniqueKey,\n    createQueue,\n    addQueueItem,\n    addRow,\n    recalculateQueueCounts,\n    setUploadSpeed,\n    forceReloadFileInput,\n    processUpload,\n    queueItemUploadStart,\n    track,\n    removeByIndex,\n    stopItemUpload,\n    stopUpload,\n    clearQueue,\n    refreshMayHelp,\n  }\n}\n"],"mappings":"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"}

package/dist/domains/dam/uploadQueue/core/uploadQueueCoreTypes.d.ts

@@ -0,0 +1,69 @@
+import { DamAssetTypeType } from '../../types/Asset';
+import { UploadQueue, UploadQueueItem, UploadQueueItemStatusType, UploadQueueKey } from '../../types/UploadQueue';
+import { uploadSide, UploadProgressCallback, UploadRun, UploadSide } from '../presets/uploadPresets';
+import { UploadRowRoleType, UploadSettlement, UploadSettlementProfile } from '../settlement/uploadSettlementTypes';
+export declare const uploadQueuePresetMembers: unique symbol;
+/** The settlement profile of a store (step 2). The core adds `queues` and, after `hooks.onRowFinal`, counts the queue and starts the next row. */
+export type UploadQueueSettlementProfile = Omit<UploadSettlementProfile, 'queues' | 'hooks'> & {
+    hooks?: Partial<UploadSettlementProfile['hooks']>;
+};
+/** The queues of a store as the core reads and writes them, from the state of the store at that moment. */
+export interface UploadQueueContainer {
+    get(queueKey: UploadQueueKey): UploadQueue | undefined;
+    set(queueKey: UploadQueueKey, queue: UploadQueue): void;
+    entries(): Iterable<[UploadQueueKey, UploadQueue]>;
+}
+/** What a failed run writes into its row, and the alert sent once the row is marked. */
+export interface UploadQueueClientFailure {
+    message: string;
+    alert(): void;
+}
+interface UploadQueuePresetMembers<S extends UploadSide> {
+    queues: UploadQueueContainer;
+    settlement: UploadQueueSettlementProfile;
+    /** What sends the row: an upload, or in admin-dam the import of a row of an external provider. */
+    runnerFor(item: UploadQueueItem, queueKey: UploadQueueKey): (item: UploadQueueItem, onProgress: UploadProgressCallback) => UploadRun<S>;
+    /** Read before the core writes anything into the failed row. */
+    onClientFailure?(queueKey: UploadQueueKey, item: UploadQueueItem, error: unknown): UploadQueueClientFailure;
+    rowTracked?(queueKey: UploadQueueKey, item: UploadQueueItem): void;
+    rowRemoved?(queueKey: UploadQueueKey, item: UploadQueueItem): void;
+    /** Whether the core keeps the failed rows a refresh may still change. */
+    refreshable: boolean;
+}
+/** What a store hands its core. Made only by `libraryQueuePreset()` and `adminDamQueuePreset()`. */
+export interface UploadQueuePreset<S extends UploadSide = UploadSide> {
+    readonly [uploadSide]: S;
+    readonly [uploadQueuePresetMembers]: UploadQueuePresetMembers<S>;
+}
+export interface UploadQueueCore {
+    settlement: UploadSettlement;
+    roleOf(item: UploadQueueItem): UploadRowRoleType;
+    getQueue(queueKey: UploadQueueKey): UploadQueue | null;
+    getQueueItems(queueKey: UploadQueueKey): UploadQueueItem[];
+    getQueueItemsByStatus(queueKey: UploadQueueKey, status: UploadQueueItemStatusType): UploadQueueItem[];
+    getQueueTotalCount(queueKey: UploadQueueKey): number;
+    getQueueProcessedCount(queueKey: UploadQueueKey): number;
+    getQueueFileInputKey(queueKey: UploadQueueKey): number;
+    getQueueItemsTypes(queueKey: UploadQueueKey): DamAssetTypeType[];
+    /** `prefix` and a number no other row of this page has. */
+    uniqueKey(prefix: string): string;
+    createQueue(queueKey: UploadQueueKey): void;
+    addQueueItem(queueKey: UploadQueueKey, item: UploadQueueItem): void;
+    /** Makes the queue if need be, adds the row, counts, starts what may start. */
+    addRow(queueKey: UploadQueueKey, item: UploadQueueItem): void;
+    recalculateQueueCounts(queueKey: UploadQueueKey): void;
+    setUploadSpeed(item: UploadQueueItem, progress: number, speed: number, estimate: number): void;
+    forceReloadFileInput(queueKey: UploadQueueKey): void;
+    processUpload(queueKey: UploadQueueKey): void;
+    queueItemUploadStart(item: UploadQueueItem, queueKey: UploadQueueKey): Promise<void>;
+    track(queueKey: UploadQueueKey, item: UploadQueueItem, options?: {
+        clientFailed?: boolean;
+    }): void;
+    removeByIndex(queueKey: UploadQueueKey, index: number): void;
+    stopItemUpload(queueKey: UploadQueueKey, item: UploadQueueItem): void;
+    stopUpload(queueKey: UploadQueueKey): void;
+    clearQueue(queueKey: UploadQueueKey): void;
+    /** Whether a refresh may still change a failed row. Filled only with the library's preset. */
+    refreshMayHelp(item: UploadQueueItem): boolean;
+}
+export {};

package/dist/domains/dam/uploadQueue/core/uploadQueueCoreTypes.js

@@ -0,0 +1,6 @@
+//#region src/domains/dam/uploadQueue/core/uploadQueueCoreTypes.ts
+var e = Symbol("uploadQueuePresetMembers");
+//#endregion
+export { e as uploadQueuePresetMembers };
+
+//# sourceMappingURL=uploadQueueCoreTypes.js.map

package/dist/domains/dam/uploadQueue/core/uploadQueueCoreTypes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadQueueCoreTypes.js","names":["uploadQueuePresetMembers"],"sources":["../../../../../src/domains/dam/uploadQueue/core/uploadQueueCoreTypes.ts"],"sourcesContent":["import type { DamAssetTypeType } from '@/domains/dam/types/Asset'\nimport type {\n  UploadQueue,\n  UploadQueueItem,\n  UploadQueueItemStatusType,\n  UploadQueueKey,\n} from '@/domains/dam/types/UploadQueue'\nimport type {\n  uploadSide,\n  UploadProgressCallback,\n  UploadRun,\n  UploadSide,\n} from '@/domains/dam/uploadQueue/presets/uploadPresets'\nimport type {\n  UploadRowRoleType,\n  UploadSettlement,\n  UploadSettlementProfile,\n} from '@/domains/dam/uploadQueue/settlement/uploadSettlementTypes'\n\n// Not exported from the library: only its own functions put the members on a set of the core.\nexport const uploadQueuePresetMembers = Symbol('uploadQueuePresetMembers')\n\n/** The settlement profile of a store (step 2). The core adds `queues` and, after `hooks.onRowFinal`, counts the queue and starts the next row. */\nexport type UploadQueueSettlementProfile = Omit<UploadSettlementProfile, 'queues' | 'hooks'> & {\n  hooks?: Partial<UploadSettlementProfile['hooks']>\n}\n\n/** The queues of a store as the core reads and writes them, from the state of the store at that moment. */\nexport interface UploadQueueContainer {\n  get(queueKey: UploadQueueKey): UploadQueue | undefined\n  set(queueKey: UploadQueueKey, queue: UploadQueue): void\n  entries(): Iterable<[UploadQueueKey, UploadQueue]>\n}\n\n/** What a failed run writes into its row, and the alert sent once the row is marked. */\nexport interface UploadQueueClientFailure {\n  message: string\n  alert(): void\n}\n\ninterface UploadQueuePresetMembers<S extends UploadSide> {\n  queues: UploadQueueContainer\n  settlement: UploadQueueSettlementProfile\n  /** What sends the row: an upload, or in admin-dam the import of a row of an external provider. */\n  runnerFor(\n    item: UploadQueueItem,\n    queueKey: UploadQueueKey\n  ): (item: UploadQueueItem, onProgress: UploadProgressCallback) => UploadRun<S>\n  /** Read before the core writes anything into the failed row. */\n  onClientFailure?(queueKey: UploadQueueKey, item: UploadQueueItem, error: unknown): UploadQueueClientFailure\n  rowTracked?(queueKey: UploadQueueKey, item: UploadQueueItem): void\n  rowRemoved?(queueKey: UploadQueueKey, item: UploadQueueItem): void\n  /** Whether the core keeps the failed rows a refresh may still change. */\n  refreshable: boolean\n}\n\n/** What a store hands its core. Made only by `libraryQueuePreset()` and `adminDamQueuePreset()`. */\nexport interface UploadQueuePreset<S extends UploadSide = UploadSide> {\n  readonly [uploadSide]: S\n  readonly [uploadQueuePresetMembers]: UploadQueuePresetMembers<S>\n}\n\nexport interface UploadQueueCore {\n  settlement: UploadSettlement\n  roleOf(item: UploadQueueItem): UploadRowRoleType\n\n  getQueue(queueKey: UploadQueueKey): UploadQueue | null\n  getQueueItems(queueKey: UploadQueueKey): UploadQueueItem[]\n  getQueueItemsByStatus(queueKey: UploadQueueKey, status: UploadQueueItemStatusType): UploadQueueItem[]\n  getQueueTotalCount(queueKey: UploadQueueKey): number\n  getQueueProcessedCount(queueKey: UploadQueueKey): number\n  getQueueFileInputKey(queueKey: UploadQueueKey): number\n  getQueueItemsTypes(queueKey: UploadQueueKey): DamAssetTypeType[]\n\n  /** `prefix` and a number no other row of this page has. */\n  uniqueKey(prefix: string): string\n  createQueue(queueKey: UploadQueueKey): void\n  addQueueItem(queueKey: UploadQueueKey, item: UploadQueueItem): void\n  /** Makes the queue if need be, adds the row, counts, starts what may start. */\n  addRow(queueKey: UploadQueueKey, item: UploadQueueItem): void\n  recalculateQueueCounts(queueKey: UploadQueueKey): void\n  setUploadSpeed(item: UploadQueueItem, progress: number, speed: number, estimate: number): void\n  forceReloadFileInput(queueKey: UploadQueueKey): void\n\n  processUpload(queueKey: UploadQueueKey): void\n  queueItemUploadStart(item: UploadQueueItem, queueKey: UploadQueueKey): Promise<void>\n  track(queueKey: UploadQueueKey, item: UploadQueueItem, options?: { clientFailed?: boolean }): void\n\n  removeByIndex(queueKey: UploadQueueKey, index: number): void\n  stopItemUpload(queueKey: UploadQueueKey, item: UploadQueueItem): void\n  stopUpload(queueKey: UploadQueueKey): void\n  clearQueue(queueKey: UploadQueueKey): void\n\n  /** Whether a refresh may still change a failed row. Filled only with the library's preset. */\n  refreshMayHelp(item: UploadQueueItem): boolean\n}\n"],"mappings":";AAoBA,IAAaA,IAA2B,OAAO,0BAA0B"}

package/dist/domains/dam/uploadQueue/core/uploadQueueFill.d.ts

@@ -0,0 +1,14 @@
+import { CustomDataValue } from '../../../customDataForm/types/CustomDataForm';
+import { DamAssetTypeType } from '../../types/Asset';
+import { UploadQueueItem } from '../../types/UploadQueue';
+import { DocId } from '../../../../shared/types/common';
+/** Only into the rows of the asset type of the field. */
+export declare function fillCustomDataValue(items: UploadQueueItem[], data: {
+    assetType: DamAssetTypeType;
+    elementProperty: string;
+    value: CustomDataValue;
+}, forceReplace?: boolean): void;
+/** `accepts`: the rows that may take them; without it, every row. */
+export declare function fillKeywords(items: UploadQueueItem[], value: DocId[], forceReplace?: boolean, accepts?: (item: UploadQueueItem) => boolean): void;
+/** `accepts`: the rows that may take them; without it, every row. */
+export declare function fillAuthors(items: UploadQueueItem[], value: DocId[], forceReplace?: boolean, accepts?: (item: UploadQueueItem) => boolean): void;

package/dist/domains/dam/uploadQueue/core/uploadQueueFill.js

@@ -0,0 +1,19 @@
+import { isArray as e, isNull as t, isUndefined as n } from "../../../../shared/utils/common.js";
+//#region src/domains/dam/uploadQueue/core/uploadQueueFill.ts
+function r(r, i, a = !1) {
+	for (let o of r) {
+		if (o.assetType !== i.assetType) continue;
+		let r = o.customData[i.elementProperty], s = n(r) || t(r) || r === "" || e(r) && !r.length;
+		(a || s) && (o.customData[i.elementProperty] = e(i.value) ? i.value.slice() : i.value);
+	}
+}
+function i(e, t, r = !1, i) {
+	for (let a of e) (!i || i(a)) && (r || n(a.keywords) || a.keywords.length === 0) && (a.keywords = [...t]);
+}
+function a(e, t, r = !1, i) {
+	for (let a of e) (!i || i(a)) && (r || n(a.authors) || a.authors.length === 0) && (a.authors = [...t]);
+}
+//#endregion
+export { a as fillAuthors, r as fillCustomDataValue, i as fillKeywords };
+
+//# sourceMappingURL=uploadQueueFill.js.map

package/dist/domains/dam/uploadQueue/core/uploadQueueFill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadQueueFill.js","names":["fillCustomDataValue","item","items","data","current","empty","isUndefined","isNull","isArray","forceReplace","fillKeywords","accepts","value","fillAuthors"],"sources":["../../../../../src/domains/dam/uploadQueue/core/uploadQueueFill.ts"],"sourcesContent":["import type { CustomDataValue } from '@/domains/customDataForm/types/CustomDataForm'\nimport type { DamAssetTypeType } from '@/domains/dam/types/Asset'\nimport type { UploadQueueItem } from '@/domains/dam/types/UploadQueue'\nimport type { DocId } from '@/shared/types/common'\nimport { isArray, isNull, isUndefined } from '@/shared/utils/common'\n\n// The mass operations of an upload queue, over the rows they are given. They read only `assetType`, `customData`,\n// `keywords` and `authors` of a row. Public as `uploadQueueFillCustomDataValue`, `…Keywords`, `…Authors`.\n// Each filled row gets a list of its own (Z24): one list shared by the rows, and by the form it came from, would\n// change in all of them with an edit of any.\n\n/** Only into the rows of the asset type of the field. */\nexport function fillCustomDataValue(\n  items: UploadQueueItem[],\n  data: { assetType: DamAssetTypeType; elementProperty: string; value: CustomDataValue },\n  forceReplace = false\n) {\n  for (const item of items) {\n    if (item.assetType !== data.assetType) continue\n    const current = item.customData[data.elementProperty]\n    // `null` is how a value saved empty comes back; a field of several values is empty as an empty list.\n    const empty = isUndefined(current) || isNull(current) || current === '' || (isArray(current) && !current.length)\n    if (forceReplace || empty) {\n      item.customData[data.elementProperty] = isArray(data.value) ? data.value.slice() : data.value\n    }\n  }\n}\n\n/** `accepts`: the rows that may take them; without it, every row. */\nexport function fillKeywords(\n  items: UploadQueueItem[],\n  value: DocId[],\n  forceReplace = false,\n  accepts?: (item: UploadQueueItem) => boolean\n) {\n  for (const item of items) {\n    if (accepts && !accepts(item)) continue\n    if (forceReplace || isUndefined(item.keywords) || item.keywords.length === 0) {\n      item.keywords = [...value]\n    }\n  }\n}\n\n/** `accepts`: the rows that may take them; without it, every row. */\nexport function fillAuthors(\n  items: UploadQueueItem[],\n  value: DocId[],\n  forceReplace = false,\n  accepts?: (item: UploadQueueItem) => boolean\n) {\n  for (const item of items) {\n    if (accepts && !accepts(item)) continue\n    if (forceReplace || isUndefined(item.authors) || item.authors.length === 0) {\n      item.authors = [...value]\n    }\n  }\n}\n"],"mappings":";;AAYA,SAAgBA,EACd,GACA,GACA,IAAe,IACf;CACA,KAAK,IAAMC,KAAQC,GAAO;EACxB,IAAID,EAAK,cAAcE,EAAK,WAAW;EACvC,IAAMC,IAAUH,EAAK,WAAWE,EAAK,kBAE/BE,IAAQC,EAAYF,CAAO,KAAKG,EAAOH,CAAO,KAAKA,MAAY,MAAOI,EAAQJ,CAAO,KAAK,CAACA,EAAQ;EACzG,CAAIK,KAAgBJ,OAClB,EAAK,WAAWF,EAAK,mBAAmBK,EAAQL,EAAK,KAAK,IAAIA,EAAK,MAAM,MAAM,IAAIA,EAAK;CAE5F;AACF;AAGA,SAAgBO,EACd,GACA,GACA,IAAe,IACf,GACA;CACA,KAAK,IAAMT,KAAQC,GACjB,CAAI,MAAYS,EAAQV,CAAI,OACxBQ,KAAgBH,EAAYL,EAAK,QAAQ,KAAKA,EAAK,SAAS,WAAW,OACzE,EAAK,WAAW,CAAC,GAAGW,CAAK;AAG/B;AAGA,SAAgBC,EACd,GACA,GACA,IAAe,IACf,GACA;CACA,KAAK,IAAMZ,KAAQC,GACjB,CAAI,MAAYS,EAAQV,CAAI,OACxBQ,KAAgBH,EAAYL,EAAK,OAAO,KAAKA,EAAK,QAAQ,WAAW,OACvE,EAAK,UAAU,CAAC,GAAGW,CAAK;AAG9B"}

package/dist/domains/dam/uploadQueue/factory/UploadQueueItemFactory.d.ts

@@ -0,0 +1,6 @@
+import { UploadQueueItem, UploadQueueItemStatusType, UploadQueueItemTypeType } from '../../types/UploadQueue';
+import { IntegerId } from '../../../../shared/types/common';
+import { DamAssetTypeType } from '../../types/Asset';
+export declare function useUploadQueueItemFactory(): {
+    createDefault: (key: string, type: UploadQueueItemTypeType, status: UploadQueueItemStatusType, assetType: DamAssetTypeType, chunkSize: number, licenceId: IntegerId) => UploadQueueItem;
+};

package/dist/domains/dam/uploadQueue/factory/UploadQueueItemFactory.js

@@ -0,0 +1,53 @@
+import { DamAssetStatusDefault as e } from "../../types/Asset.js";
+import { AssetFileFailReasonDefault as t } from "../../types/AssetFile.js";
+//#region src/domains/dam/uploadQueue/factory/UploadQueueItemFactory.ts
+function n() {
+	return { createDefault: (n, r, i, a, o, s) => ({
+		key: n,
+		type: r,
+		file: null,
+		status: i,
+		isDuplicate: !1,
+		duplicateAssetId: null,
+		uploadedAssetId: null,
+		assetType: a,
+		assetStatus: e,
+		displayTitle: "",
+		assetId: null,
+		fileId: null,
+		externalProviderAssetId: null,
+		externalProviderName: null,
+		externalProviderMetadata: {},
+		keywords: [],
+		authors: [],
+		authorConflicts: [],
+		customData: {},
+		latestChunkAbortController: null,
+		chunkSize: o,
+		currentChunkIndex: 0,
+		chunkTotalCount: 0,
+		licenceId: s,
+		imagePreview: void 0,
+		progress: {
+			remainingTime: null,
+			progressPercent: null,
+			speed: null
+		},
+		canEditMetadata: !1,
+		error: {
+			hasError: !1,
+			message: "",
+			assetFileFailReason: t
+		},
+		notificationFallbackTimer: void 0,
+		notificationFallbackTry: 1,
+		slotName: null,
+		image: void 0,
+		mainFileSingleUse: null,
+		mainFileInternal: null
+	}) };
+}
+//#endregion
+export { n as useUploadQueueItemFactory };
+
+//# sourceMappingURL=UploadQueueItemFactory.js.map

package/dist/domains/dam/uploadQueue/factory/UploadQueueItemFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UploadQueueItemFactory.js","names":["useUploadQueueItemFactory","DamAssetStatusDefault","AssetFileFailReasonDefault"],"sources":["../../../../../src/domains/dam/uploadQueue/factory/UploadQueueItemFactory.ts"],"sourcesContent":["import type {\n  UploadQueueItem,\n  UploadQueueItemStatusType,\n  UploadQueueItemTypeType,\n} from '@/domains/dam/types/UploadQueue'\nimport type { IntegerId } from '@/shared/types/common'\nimport { DamAssetStatusDefault, type DamAssetTypeType } from '@/domains/dam/types/Asset'\nimport { AssetFileFailReasonDefault } from '@/domains/dam/types/AssetFile'\n\nexport function useUploadQueueItemFactory() {\n  const createDefault = (\n    key: string,\n    type: UploadQueueItemTypeType,\n    status: UploadQueueItemStatusType,\n    assetType: DamAssetTypeType,\n    chunkSize: number,\n    licenceId: IntegerId\n  ): UploadQueueItem => {\n    return {\n      key: key,\n      type: type,\n      file: null,\n      status: status,\n      isDuplicate: false,\n      duplicateAssetId: null,\n      uploadedAssetId: null,\n      assetType: assetType,\n      assetStatus: DamAssetStatusDefault,\n      displayTitle: '',\n      assetId: null,\n      fileId: null,\n      externalProviderAssetId: null,\n      externalProviderName: null,\n      externalProviderMetadata: {},\n      keywords: [],\n      authors: [],\n      authorConflicts: [],\n      customData: {},\n      latestChunkAbortController: null,\n      chunkSize: chunkSize,\n      currentChunkIndex: 0,\n      chunkTotalCount: 0,\n      licenceId: licenceId,\n      imagePreview: undefined,\n      progress: {\n        remainingTime: null,\n        progressPercent: null,\n        speed: null,\n      },\n      canEditMetadata: false,\n      error: {\n        hasError: false,\n        message: '',\n        assetFileFailReason: AssetFileFailReasonDefault,\n      },\n      notificationFallbackTimer: undefined,\n      notificationFallbackTry: 1,\n      slotName: null,\n      image: undefined,\n      mainFileSingleUse: null,\n      mainFileInternal: null,\n    }\n  }\n\n  return {\n    createDefault,\n  }\n}\n"],"mappings":";;;AASA,SAAgBA,IAA4B;CAuD1C,OAAO,EACL,gBAtDA,GACA,GACA,GACA,GACA,GACA,OAEO;EACA;EACC;EACN,MAAM;EACE;EACR,aAAa;EACb,kBAAkB;EAClB,iBAAiB;EACN;EACX,aAAaC;EACb,cAAc;EACd,SAAS;EACT,QAAQ;EACR,yBAAyB;EACzB,sBAAsB;EACtB,0BAA0B,CAAC;EAC3B,UAAU,CAAC;EACX,SAAS,CAAC;EACV,iBAAiB,CAAC;EAClB,YAAY,CAAC;EACb,4BAA4B;EACjB;EACX,mBAAmB;EACnB,iBAAiB;EACN;EACX,cAAc,KAAA;EACd,UAAU;GACR,eAAe;GACf,iBAAiB;GACjB,OAAO;EACT;EACA,iBAAiB;EACjB,OAAO;GACL,UAAU;GACV,SAAS;GACT,qBAAqBC;EACvB;EACA,2BAA2B,KAAA;EAC3B,yBAAyB;EACzB,UAAU;EACV,OAAO,KAAA;EACP,mBAAmB;EACnB,kBAAkB;CACpB,GAKF;AACF"}

package/dist/domains/dam/uploadQueue/presets/queuePresets.d.ts

@@ -0,0 +1,30 @@
+import { Ref } from 'vue';
+import { UploadQueue, UploadQueueItem, UploadQueueKey } from '../../types/UploadQueue';
+import { UploadProgressCallback, UploadRun } from './uploadPresets';
+import { UploadQueuePreset, UploadQueueSettlementProfile } from '../core/uploadQueueCoreTypes';
+/** Not exported from `src/lib.ts`: only the library store uses it. Every row is uploaded, under the configuration of its queue. */
+export declare function libraryQueuePreset(store: {
+    queues: Ref<Map<UploadQueueKey, UploadQueue>>;
+    settlement: UploadQueueSettlementProfile;
+    /** The DAM configuration the queue was made under, `default` for one the store does not know. */
+    configOf(queueKey: UploadQueueKey): string;
+}): UploadQueuePreset<'library'>;
+/** admin-dam's queue: what it shows and does that the library does not. The store hands in what is its own. */
+export declare function adminDamQueuePreset(store: {
+    queues: Ref<Record<UploadQueueKey, UploadQueue>>;
+    settlement: UploadQueueSettlementProfile;
+    /** `useUpload` of admin-dam's `uploadService.ts`. */
+    upload(item: UploadQueueItem, onProgress: UploadProgressCallback): UploadRun<'adminDam'>;
+    /** The run of an `ExternalProviderAsset` row: `adminDamImportRun(externalProviderImport(item).importInit)`. */
+    importRun(item: UploadQueueItem): UploadRun<'adminDam'>;
+    /** `resolveUploadErrorMessage`: the text of a failed upload. */
+    failureMessage(error: unknown): string;
+    /** `showError` of the store's `useAlerts()`: one alert per reason. */
+    alert(message: string): void;
+    /** `handedOver.add(toRaw(item))`. */
+    rowTracked(queueKey: UploadQueueKey, item: UploadQueueItem): void;
+    /** `metadataFailures.delete(metadataFailureKey(queueKey, item))`. */
+    rowRemoved(queueKey: UploadQueueKey, item: UploadQueueItem): void;
+}): UploadQueuePreset<'adminDam'>;
+/** The run of an import: its request is all there is; `upload` and `stop` do nothing, never `finishAttempted`. */
+export declare function adminDamImportRun(uploadInit: () => Promise<unknown>): UploadRun<'adminDam'>;

package/dist/domains/dam/uploadQueue/presets/queuePresets.js

@@ -0,0 +1,65 @@
+import { UploadQueueItemStatus as e, UploadQueueItemType as t } from "../../types/UploadQueue.js";
+import { uploadQueuePresetMembers as n } from "../core/uploadQueueCoreTypes.js";
+import { libraryUploadPreset as r, uploadSide as i } from "./uploadPresets.js";
+import { useUpload as a } from "../composables/uploadService.js";
+//#region src/domains/dam/uploadQueue/presets/queuePresets.ts
+var o = (e) => ({
+	get: (t) => e.value.get(t),
+	set: (t, n) => {
+		e.value.set(t, n);
+	},
+	entries: () => e.value.entries()
+}), s = (e) => ({
+	get: (t) => t in e.value ? e.value[t] : void 0,
+	set: (t, n) => {
+		e.value[t] = n;
+	},
+	entries: () => Object.entries(e.value)
+});
+function c(e) {
+	return {
+		[i]: "library",
+		[n]: {
+			queues: o(e.queues),
+			settlement: e.settlement,
+			runnerFor: (t, n) => (t, i) => a(t, i, r(e.configOf(n))),
+			refreshable: !0
+		}
+	};
+}
+function l(r) {
+	let a = s(r.queues);
+	return {
+		[i]: "adminDam",
+		[n]: {
+			queues: a,
+			settlement: r.settlement,
+			runnerFor: (e) => e.type === t.ExternalProviderAsset ? (e) => r.importRun(e) : (e, t) => r.upload(e, t),
+			onClientFailure: (t, n, i) => {
+				let o = r.failureMessage(i), s = (a.get(t)?.items ?? []).some((t) => t.status === e.Failed && t.error.message === o);
+				return {
+					message: o,
+					alert: () => {
+						s || r.alert(o);
+					}
+				};
+			},
+			rowTracked: (e, t) => r.rowTracked(e, t),
+			rowRemoved: (e, t) => r.rowRemoved(e, t),
+			refreshable: !1
+		}
+	};
+}
+function u(e) {
+	return {
+		[i]: "adminDam",
+		uploadInit: e,
+		upload: () => Promise.resolve(),
+		stop: () => {},
+		finishAttempted: () => !1
+	};
+}
+//#endregion
+export { u as adminDamImportRun, l as adminDamQueuePreset, c as libraryQueuePreset };
+
+//# sourceMappingURL=queuePresets.js.map

package/dist/domains/dam/uploadQueue/presets/queuePresets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"queuePresets.js","names":["mapQueues","queues","queueKey","queue","objectQueues","libraryQueuePreset","uploadSide","uploadQueuePresetMembers","store","useUpload","item","onProgress","libraryUploadPreset","adminDamQueuePreset","UploadQueueItemType","row","message","error","alreadyReported","failedItem","UploadQueueItemStatus","adminDamImportRun"],"sources":["../../../../../src/domains/dam/uploadQueue/presets/queuePresets.ts"],"sourcesContent":["import type { Ref } from 'vue'\nimport {\n  type UploadQueue,\n  type UploadQueueItem,\n  UploadQueueItemStatus,\n  UploadQueueItemType,\n  type UploadQueueKey,\n} from '@/domains/dam/types/UploadQueue'\nimport { useUpload } from '@/domains/dam/uploadQueue/composables/uploadService'\nimport {\n  libraryUploadPreset,\n  type UploadProgressCallback,\n  type UploadRun,\n  uploadSide,\n} from '@/domains/dam/uploadQueue/presets/uploadPresets'\nimport {\n  type UploadQueueContainer,\n  type UploadQueuePreset,\n  uploadQueuePresetMembers,\n  type UploadQueueSettlementProfile,\n} from '@/domains/dam/uploadQueue/core/uploadQueueCoreTypes'\n\nconst mapQueues = (queues: Ref<Map<UploadQueueKey, UploadQueue>>): UploadQueueContainer => ({\n  get: (queueKey) => queues.value.get(queueKey),\n  set: (queueKey, queue) => {\n    queues.value.set(queueKey, queue)\n  },\n  entries: () => queues.value.entries(),\n})\n\n// By `in`, as the store has always looked: a key named after a member of `Object.prototype` finds that member.\nconst objectQueues = (queues: Ref<Record<UploadQueueKey, UploadQueue>>): UploadQueueContainer => ({\n  get: (queueKey) => (queueKey in queues.value ? queues.value[queueKey] : undefined),\n  set: (queueKey, queue) => {\n    queues.value[queueKey] = queue\n  },\n  entries: () => Object.entries(queues.value),\n})\n\n/** Not exported from `src/lib.ts`: only the library store uses it. Every row is uploaded, under the configuration of its queue. */\nexport function libraryQueuePreset(store: {\n  queues: Ref<Map<UploadQueueKey, UploadQueue>>\n  settlement: UploadQueueSettlementProfile\n  /** The DAM configuration the queue was made under, `default` for one the store does not know. */\n  configOf(queueKey: UploadQueueKey): string\n}): UploadQueuePreset<'library'> {\n  return {\n    [uploadSide]: 'library',\n    [uploadQueuePresetMembers]: {\n      queues: mapQueues(store.queues),\n      settlement: store.settlement,\n      runnerFor: (_item, queueKey) => (item, onProgress) =>\n        useUpload(item, onProgress, libraryUploadPreset(store.configOf(queueKey))),\n      refreshable: true,\n    },\n  }\n}\n\n/** admin-dam's queue: what it shows and does that the library does not. The store hands in what is its own. */\nexport function adminDamQueuePreset(store: {\n  queues: Ref<Record<UploadQueueKey, UploadQueue>>\n  settlement: UploadQueueSettlementProfile\n  /** `useUpload` of admin-dam's `uploadService.ts`. */\n  upload(item: UploadQueueItem, onProgress: UploadProgressCallback): UploadRun<'adminDam'>\n  /** The run of an `ExternalProviderAsset` row: `adminDamImportRun(externalProviderImport(item).importInit)`. */\n  importRun(item: UploadQueueItem): UploadRun<'adminDam'>\n  /** `resolveUploadErrorMessage`: the text of a failed upload. */\n  failureMessage(error: unknown): string\n  /** `showError` of the store's `useAlerts()`: one alert per reason. */\n  alert(message: string): void\n  /** `handedOver.add(toRaw(item))`. */\n  rowTracked(queueKey: UploadQueueKey, item: UploadQueueItem): void\n  /** `metadataFailures.delete(metadataFailureKey(queueKey, item))`. */\n  rowRemoved(queueKey: UploadQueueKey, item: UploadQueueItem): void\n}): UploadQueuePreset<'adminDam'> {\n  const queues = objectQueues(store.queues)\n  return {\n    [uploadSide]: 'adminDam',\n    [uploadQueuePresetMembers]: {\n      queues,\n      settlement: store.settlement,\n      runnerFor: (item) =>\n        item.type === UploadQueueItemType.ExternalProviderAsset\n          ? (row) => store.importRun(row)\n          : (row, onProgress) => store.upload(row, onProgress),\n      onClientFailure: (queueKey, _item, error) => {\n        const message = store.failureMessage(error)\n        // One alert per reason: a licence that refuses uploads fails every file in the batch.\n        const alreadyReported = (queues.get(queueKey)?.items ?? []).some(\n          (failedItem) => failedItem.status === UploadQueueItemStatus.Failed && failedItem.error.message === message\n        )\n        return {\n          message,\n          alert: () => {\n            if (!alreadyReported) store.alert(message)\n          },\n        }\n      },\n      rowTracked: (queueKey, item) => store.rowTracked(queueKey, item),\n      rowRemoved: (queueKey, item) => store.rowRemoved(queueKey, item),\n      refreshable: false,\n    },\n  }\n}\n\n/** The run of an import: its request is all there is; `upload` and `stop` do nothing, never `finishAttempted`. */\nexport function adminDamImportRun(uploadInit: () => Promise<unknown>): UploadRun<'adminDam'> {\n  return {\n    [uploadSide]: 'adminDam',\n    uploadInit,\n    upload: () => Promise.resolve(),\n    stop: () => {},\n    finishAttempted: () => false,\n  }\n}\n"],"mappings":";;;;;AAsBA,IAAMA,KAAa,OAAyE;CAC1F,MAAM,MAAaC,EAAO,MAAM,IAAIC,CAAQ;CAC5C,MAAM,GAAU,MAAU;EACxB,EAAO,MAAM,IAAIA,GAAUC,CAAK;CAClC;CACA,eAAeF,EAAO,MAAM,QAAQ;AACtC,IAGMG,KAAgB,OAA4E;CAChG,MAAM,MAAcF,KAAYD,EAAO,QAAQA,EAAO,MAAMC,KAAY,KAAA;CACxE,MAAM,GAAU,MAAU;EACxB,EAAO,MAAMA,KAAYC;CAC3B;CACA,eAAe,OAAO,QAAQF,EAAO,KAAK;AAC5C;AAGA,SAAgBI,EAAmB,GAKF;CAC/B,OAAO;GACJC,IAAa;GACbC,IAA2B;GAC1B,QAAQP,EAAUQ,EAAM,MAAM;GAC9B,YAAYA,EAAM;GAClB,YAAY,GAAO,OAAc,GAAM,MACrCC,EAAUC,GAAMC,GAAYC,EAAoBJ,EAAM,SAASN,CAAQ,CAAC,CAAC;GAC3E,aAAa;EACf;CACF;AACF;AAGA,SAAgBW,EAAoB,GAeF;CAChC,IAAMZ,IAASG,EAAaI,EAAM,MAAM;CACxC,OAAO;GACJF,IAAa;GACbC,IAA2B;GAC1B;GACA,YAAYC,EAAM;GAClB,YAAY,MACVE,EAAK,SAASI,EAAoB,yBAC7B,MAAQN,EAAM,UAAUO,CAAG,KAC3B,GAAK,MAAeP,EAAM,OAAOO,GAAKJ,CAAU;GACvD,kBAAkB,GAAU,GAAO,MAAU;IAC3C,IAAMK,IAAUR,EAAM,eAAeS,CAAK,GAEpCC,KAAmBjB,EAAO,IAAIC,CAAQ,CAAC,EAAE,SAAS,CAAC,EAAA,CAAG,MACzD,MAAeiB,EAAW,WAAWC,EAAsB,UAAUD,EAAW,MAAM,YAAYH,CACrG;IACA,OAAO;KACL;KACA,aAAa;MACX,AAAKE,KAAiBV,EAAM,MAAMQ,CAAO;KAC3C;IACF;GACF;GACA,aAAa,GAAU,MAASR,EAAM,WAAWN,GAAUQ,CAAI;GAC/D,aAAa,GAAU,MAASF,EAAM,WAAWN,GAAUQ,CAAI;GAC/D,aAAa;EACf;CACF;AACF;AAGA,SAAgBW,EAAkB,GAA2D;CAC3F,OAAO;GACJf,IAAa;EACd;EACA,cAAc,QAAQ,QAAQ;EAC9B,YAAY,CAAC;EACb,uBAAuB;CACzB;AACF"}

package/dist/domains/dam/uploadQueue/presets/uploadPresets.d.ts

@@ -0,0 +1,70 @@
+import { AxiosProgressEvent } from 'axios';
+import { DamUploadStartResponse, UploadQueueItem } from '../../types/UploadQueue';
+import { DocId } from '../../../../shared/types/common';
+export type UploadSide = 'library' | 'adminDam';
+export declare const uploadSide: unique symbol;
+export declare const uploadPresetMembers: unique symbol;
+/** What a run asks the server. */
+export interface UploadRunRequests {
+    start(item: UploadQueueItem): Promise<DamUploadStartResponse>;
+    chunk(item: UploadQueueItem, fileId: DocId, chunk: File, size: number, offset: number, onUploadProgress: (event: AxiosProgressEvent) => void): Promise<unknown>;
+    finish(item: UploadQueueItem, sha: string): Promise<unknown>;
+}
+/** The texts a run writes into its row. Each side keeps its own. */
+export interface UploadMessages {
+    unknownError(): string;
+    /** A field the server refused, by its name. */
+    size(): string;
+    offset(): string;
+    mimeType(): string;
+    /** Put before the name of a refused field there is no text for. */
+    systemError(): string;
+    /** HTTP 400 on the last try of a chunk. */
+    chunkValidationFailed(): string;
+}
+export interface UploadHash {
+    update(data: ArrayBuffer): unknown;
+    digest(encoding: 'hex'): string;
+}
+interface UploadPresetMembers {
+    requests: UploadRunRequests;
+    messages: UploadMessages;
+    apiTimeout: number | null | undefined;
+    loadHash(): Promise<UploadHash>;
+    /** Whether a file of no bytes is started and finished, or refused before anything is asked. */
+    emptyFile: 'send' | 'reject';
+    /** The DAM configuration whose prv configuration bounds the chunks, and whose last chunk size the upload starts from. */
+    configName: string;
+}
+/** How one side uploads. Made only by `libraryUploadPreset()` and `adminDamUploadPreset()`; what it holds is not public. */
+export interface UploadPreset<S extends UploadSide = UploadSide> {
+    readonly [uploadSide]: S;
+    readonly [uploadPresetMembers]: UploadPresetMembers;
+}
+export type UploadProgressCallback = (progress: number, speed: number, estimate: number) => void;
+export interface UploadRun<S extends UploadSide = UploadSide> {
+    readonly [uploadSide]: S;
+    uploadInit(): Promise<unknown>;
+    upload(): Promise<unknown>;
+    /** Stops the run wherever it is, and cancels the chunk on the wire. */
+    stop(): void;
+    /** Whether the finish request went out: the server may complete the file whatever became of the answer. */
+    finishAttempted(): boolean;
+}
+/**
+ * Not exported from `src/lib.ts`; the default of `useUpload` (under `default`). The library's API, texts and choices,
+ * under the DAM configuration `configName`.
+ */
+export declare function libraryUploadPreset(configName: string): UploadPreset<'library'>;
+/** admin-dam's API, texts and choices. What is the application's own, the application hands in. */
+export declare function adminDamUploadPreset(app: {
+    /** `uploadStart`, `uploadChunk`, `uploadFinish` of `fileApi.ts`: four asset types, admin-dam's addresses. */
+    requests: UploadRunRequests;
+    /** `system.uploadErrors.*`; as `chunkValidationFailed` its `unknownError`, which its store writes today. */
+    messages: UploadMessages;
+    /** `envConfig.dam.apiTimeout`. */
+    apiTimeout: number | null | undefined;
+    /** `() => Promise.resolve(rusha.createHash())`: rusha stays a static import of admin-dam. */
+    loadHash(): Promise<UploadHash>;
+}): UploadPreset<'adminDam'>;
+export {};