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

package/dist/domains/dam/uploadQueue/composables/assetSuggestions.js

@@ -0,0 +1,20 @@
+import { isArray as e, isEmptyObject as t } from "../../../../shared/utils/common.js";
+//#region src/domains/dam/uploadQueue/composables/assetSuggestions.ts
+function n() {
+	return {
+		updateNewNames: (e, n) => {
+			for (let [r, i] of Object.entries(e)) t(i) && n.add(r);
+		},
+		getAuthorConflicts: (t) => {
+			let n = [];
+			for (let r of Object.values(t)) e(r) && r.length > 1 && r.forEach((e) => {
+				n.push(e);
+			});
+			return n;
+		}
+	};
+}
+//#endregion
+export { n as useAssetSuggestions };
+
+//# sourceMappingURL=assetSuggestions.js.map

package/dist/domains/dam/uploadQueue/composables/assetSuggestions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assetSuggestions.js","names":["useAssetSuggestions","key","value","suggestions","isEmptyObject","newNames","conflicts","isArray","id"],"sources":["../../../../../src/domains/dam/uploadQueue/composables/assetSuggestions.ts"],"sourcesContent":["import type { AssetMetadataSuggestions } from '@/domains/dam/types/Asset'\nimport { isArray, isEmptyObject } from '@/shared/utils/common'\nimport type { DocId } from '@/shared/types/common'\n\nexport function useAssetSuggestions() {\n  const updateNewNames = (suggestions: AssetMetadataSuggestions, newNames: Set<string>) => {\n    for (const [key, value] of Object.entries(suggestions)) {\n      if (isEmptyObject(value)) {\n        newNames.add(key)\n      }\n    }\n  }\n\n  const getAuthorConflicts = (suggestions: AssetMetadataSuggestions) => {\n    const conflicts: Array<DocId> = []\n    for (const value of Object.values(suggestions)) {\n      if (isArray(value) && value.length > 1) {\n        value.forEach((id) => {\n          conflicts.push(id)\n        })\n      }\n    }\n    return conflicts\n  }\n\n  return {\n    updateNewNames,\n    getAuthorConflicts,\n  }\n}\n"],"mappings":";;AAIA,SAAgBA,IAAsB;CAqBpC,OAAO;EACL,iBArBsB,GAAuC,MAA0B;GACvF,KAAK,IAAM,CAACC,GAAKC,MAAU,OAAO,QAAQC,CAAW,GACnD,AAAIC,EAAcF,CAAK,KACrBG,EAAS,IAAIJ,CAAG;EAGtB;EAgBE,qBAd0B,MAA0C;GACpE,IAAMK,IAA0B,CAAC;GACjC,KAAK,IAAMJ,KAAS,OAAO,OAAOC,CAAW,GAC3C,AAAII,EAAQL,CAAK,KAAKA,EAAM,SAAS,KACnCA,EAAM,SAAS,MAAO;IACpB,EAAU,KAAKM,CAAE;GACnB,CAAC;GAGL,OAAOF;EACT;CAKA;AACF"}

package/dist/domains/dam/uploadQueue/composables/damUploadChunkSize.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The size of the next chunk of an upload under the DAM configuration `configName`, bounded by its prv configuration.
+ * A name left out is the inherited one in a component's setup, else `default`.
+ */
+export declare function useDamUploadChunkSize(apiTimeout?: number, configName?: string): {
+    lastChunkSize: import('vue').Ref<number, number>;
+    updateChunkSize: (speed: number | null) => boolean;
+};

package/dist/domains/dam/uploadQueue/composables/damUploadChunkSize.js

@@ -0,0 +1,24 @@
+import { isNull as e } from "../../../../shared/utils/common.js";
+import { useDamConfigStoreOf as t } from "../../config/store/damConfigStore.js";
+import { inheritedDamConfigName as n } from "../../composables/damConfigName.js";
+import { ref as r } from "vue";
+//#region src/domains/dam/uploadQueue/composables/damUploadChunkSize.ts
+var i = /* @__PURE__ */ new Map();
+function a(a = 30, o) {
+	let s = n(o), c = t(s), l = r(i.get(s) || c.damPrvConfig.settings.imageChunkConfig.minSize), u = a / 5, d = a / 4, f = a / 2, p = (t) => {
+		if (e(t)) return !1;
+		let n = l.value / t;
+		return n > f ? m(f * t) : n < u && m(d * t);
+	}, m = (e) => {
+		let t = h(e), n = t !== l.value;
+		return l.value = t, i.set(s, t), n;
+	}, h = (e) => e > c.damPrvConfig.settings.imageChunkConfig.maxSize ? c.damPrvConfig.settings.imageChunkConfig.maxSize : e < c.damPrvConfig.settings.imageChunkConfig.minSize ? c.damPrvConfig.settings.imageChunkConfig.minSize : e;
+	return {
+		lastChunkSize: l,
+		updateChunkSize: p
+	};
+}
+//#endregion
+export { a as useDamUploadChunkSize };
+
+//# sourceMappingURL=damUploadChunkSize.js.map

package/dist/domains/dam/uploadQueue/composables/damUploadChunkSize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"damUploadChunkSize.js","names":["chunkSizes","useDamUploadChunkSize","name","inheritedDamConfigName","configName","damConfigStore","useDamConfigStoreOf","lastChunkSize","ref","minUploadTimeThreshold","apiTimeout","idealUploadTimeThreshold","maxUploadTimeThreshold","updateChunkSize","isNull","speed","expectedChunkUploadSpeed","resize","next","returnFromRange","size","changed","value"],"sources":["../../../../../src/domains/dam/uploadQueue/composables/damUploadChunkSize.ts"],"sourcesContent":["import { ref } from 'vue'\nimport { isNull } from '@/shared/utils/common'\nimport { useDamConfigStoreOf } from '@/domains/dam/config/store/damConfigStore'\nimport { inheritedDamConfigName } from '@/domains/dam/composables/damConfigName'\n\n// The last size of each DAM configuration: one upload hands it to the next one of its name.\nconst chunkSizes = new Map<string, number>()\n\n/**\n * The size of the next chunk of an upload under the DAM configuration `configName`, bounded by its prv configuration.\n * A name left out is the inherited one in a component's setup, else `default`.\n */\nexport function useDamUploadChunkSize(apiTimeout: number = 30, configName?: string) {\n  const name = inheritedDamConfigName(configName)\n  const damConfigStore = useDamConfigStoreOf(name)\n  const lastChunkSize = ref(chunkSizes.get(name) || damConfigStore.damPrvConfig.settings.imageChunkConfig.minSize)\n\n  const minUploadTimeThreshold = apiTimeout / 5\n  const idealUploadTimeThreshold = apiTimeout / 4\n  const maxUploadTimeThreshold = apiTimeout / 2\n\n  const updateChunkSize = (speed: number | null) => {\n    if (isNull(speed)) {\n      return false\n    }\n\n    const expectedChunkUploadSpeed = lastChunkSize.value / speed\n    if (expectedChunkUploadSpeed > maxUploadTimeThreshold) {\n      return resize(maxUploadTimeThreshold * speed)\n    }\n    if (expectedChunkUploadSpeed < minUploadTimeThreshold) {\n      return resize(idealUploadTimeThreshold * speed)\n    }\n\n    return false\n  }\n\n  // Answers whether the size changed: at a bound of the configuration it stays, and the chunk of a retry is not read\n  // from the file again.\n  const resize = (size: number) => {\n    const next = returnFromRange(size)\n    const changed = next !== lastChunkSize.value\n    lastChunkSize.value = next\n    chunkSizes.set(name, next)\n\n    return changed\n  }\n\n  const returnFromRange = (value: number) => {\n    if (value > damConfigStore.damPrvConfig.settings.imageChunkConfig.maxSize) {\n      return damConfigStore.damPrvConfig.settings.imageChunkConfig.maxSize\n    }\n    if (value < damConfigStore.damPrvConfig.settings.imageChunkConfig.minSize) {\n      return damConfigStore.damPrvConfig.settings.imageChunkConfig.minSize\n    }\n\n    return value\n  }\n\n  return {\n    lastChunkSize,\n    updateChunkSize,\n  }\n}\n"],"mappings":";;;;;AAMA,IAAMA,oBAAa,IAAI,IAAoB;AAM3C,SAAgBC,EAAsB,IAAqB,IAAI,GAAqB;CAClF,IAAMC,IAAOC,EAAuBC,CAAU,GACxCC,IAAiBC,EAAoBJ,CAAI,GACzCK,IAAgBC,EAAIR,EAAW,IAAIE,CAAI,KAAKG,EAAe,aAAa,SAAS,iBAAiB,OAAO,GAEzGI,IAAyBC,IAAa,GACtCC,IAA2BD,IAAa,GACxCE,IAAyBF,IAAa,GAEtCG,KAAmB,MAAyB;EAChD,IAAIC,EAAOC,CAAK,GACd,OAAO;EAGT,IAAMC,IAA2BT,EAAc,QAAQQ;EAQvD,OAPIC,IAA2BJ,IACtBK,EAAOL,IAAyBG,CAAK,IAE1CC,IAA2BP,KACtBQ,EAAON,IAA2BI,CAAK;CAIlD,GAIME,KAAU,MAAiB;EAC/B,IAAMC,IAAOC,EAAgBC,CAAI,GAC3BC,IAAUH,MAASX,EAAc;EAIvC,OAHA,EAAc,QAAQW,GACtBlB,EAAW,IAAIE,GAAMgB,CAAI,GAElBG;CACT,GAEMF,KAAmB,MACnBG,IAAQjB,EAAe,aAAa,SAAS,iBAAiB,UACzDA,EAAe,aAAa,SAAS,iBAAiB,UAE3DiB,IAAQjB,EAAe,aAAa,SAAS,iBAAiB,UACzDA,EAAe,aAAa,SAAS,iBAAiB,UAGxDiB;CAGT,OAAO;EACL;EACA;CACF;AACF"}

package/dist/domains/dam/uploadQueue/composables/uploadMeter.d.ts

@@ -0,0 +1,26 @@
+import { AxiosProgressEvent } from 'axios';
+import { UploadProgressCallback } from '../presets/uploadPresets';
+/**
+ * How far one upload is, how fast it goes and how long it still takes, from one curve: the bytes of its file sent
+ * over time, from the request of its first chunk to the answer to its last. It reports once a second, the first at
+ * once, and only once it has a speed and either bytes came since its last report or the answer to a chunk that is
+ * whole on its way is awaited; the whole file once it is out, also without a speed; without `report` it reports
+ * nothing and asks for no second.
+ */
+export declare function useUploadMeter(report: UploadProgressCallback | undefined): {
+    /** The reports of a file of the given size begin. */
+    start(size: number): void;
+    /** Before each request of a chunk: the curve goes on from what the server has, and the try reports into it. */
+    attempt(chunkSize: number): (event: Pick<AxiosProgressEvent, "loaded" | "total">) => void;
+    /** The server answered the chunk of the try. */
+    chunkDone(chunkSize: number): void;
+    /**
+     * A try failed: the server took none of its bytes, and neither its time nor the pause after it counts. Until the
+     * next try has a speed nothing is reported, and the row keeps what it was told last.
+     */
+    attemptFailed(): void;
+    /** Z9: the second that runs reports the whole file, and no further one is asked for. */
+    lastChunkSent(): void;
+    /** Z10: no further report. */
+    stop(): void;
+};

package/dist/domains/dam/uploadQueue/composables/uploadMeter.js

@@ -0,0 +1,59 @@
+import { isNull as e } from "../../../../shared/utils/common.js";
+//#region src/domains/dam/uploadQueue/composables/uploadMeter.ts
+var t = 1e3, n = 1e4, r = 500;
+function i(i) {
+	let a = [], o = 0, s = 0, c = 0, l = 0, u = !1, d = !1, f = 0, p, m, h = () => {
+		let e = Date.now();
+		return a.length && e < a.at(-1).at && (a = []), e;
+	}, g = (e, t = !1) => {
+		let r = h();
+		for (e > c && (u = !0), c = e, a.push({
+			at: r,
+			sent: e,
+			answered: t
+		}); a.length > 2 && a[1].at <= r - n;) a.shift();
+	}, _ = (e) => {
+		let t = a.findIndex((t) => t.at >= e);
+		if (t === -1) return a.at(-1).sent;
+		if (t === 0) return a[0].sent;
+		let n = a[t - 1], r = a[t];
+		return n.sent + (r.sent - n.sent) * (e - n.at) / (r.at - n.at);
+	}, v = () => {
+		let e = d ? a.at(-1)?.at : h();
+		if (a.length < 2 || e === void 0) return null;
+		let t = Math.max(a[0].at, e - n), i = e - t, o = a.at(-1).sent - _(t), s = a.some((e) => e.answered && e.at > t);
+		return i > 0 && o > 0 && (i >= r || s) ? o * 1e3 / i : null;
+	}, y = () => !!m && c >= m.end, b = () => {
+		let n = v() ?? (d ? f : null);
+		i && !e(n) && (u || y() || d) && (u = !1, l = d ? 100 : Math.max(l, Math.min(c * 100 / o, 100)), f = Math.ceil(n), i(l, f, d ? 0 : Math.ceil((o - c) / n))), d || (p = setTimeout(b, t));
+	};
+	return {
+		start(e) {
+			o = e, i && b();
+		},
+		attempt(e) {
+			let t = { end: s + e };
+			return m = t, g(s), (n) => {
+				if (m !== t) return;
+				let r = n.loaded;
+				n.total && (r = n.loaded >= n.total ? e : n.loaded * e / n.total), g(s + Math.min(Math.max(r, 0), e));
+			};
+		},
+		chunkDone(e) {
+			m = void 0, s += e, g(s, !0);
+		},
+		attemptFailed() {
+			m = void 0, a = [], c = s;
+		},
+		lastChunkSent() {
+			d = !0;
+		},
+		stop() {
+			clearTimeout(p), p = void 0, d = !0;
+		}
+	};
+}
+//#endregion
+export { i as useUploadMeter };
+
+//# sourceMappingURL=uploadMeter.js.map

package/dist/domains/dam/uploadQueue/composables/uploadMeter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadMeter.js","names":["TICK_MS","WINDOW_MS","MIN_SPAN_MS","useUploadMeter","points","fileSize","received","sent","shown","moved","sendingOver","reportedSpeed","timer","current","now","at","mark","bytes","sentAt","next","point","before","after","speed","end","from","span","answered","answerAwaited","tick","bytesPerSecond","report","isNull","size","thisTry","chunkSize","onItsWay","event"],"sources":["../../../../../src/domains/dam/uploadQueue/composables/uploadMeter.ts"],"sourcesContent":["import type { AxiosProgressEvent } from 'axios'\nimport type { UploadProgressCallback } from '@/domains/dam/uploadQueue/presets/uploadPresets'\nimport { isNull } from '@/shared/utils/common'\n\nconst TICK_MS = 1_000\n// Holds the answer to at least one chunk of the size the upload aims at (a quarter of the timeout, 7.5 s at 30 s),\n// and follows a change of speed within it.\nconst WINDOW_MS = 10_000\n// A shorter stretch without an answer of the server shows mostly what the browser took into its buffers: Chromium\n// tells how far the body is at most every 100 ms, axios passes it on at most every 333 ms.\nconst MIN_SPAN_MS = 500\n\ninterface MeterPoint {\n  at: number\n  /** Bytes of the file sent by then: the chunks the server answered, and the share of the one on its way. */\n  sent: number\n  /** The server answered a chunk here. */\n  answered: boolean\n}\n\n/**\n * How far one upload is, how fast it goes and how long it still takes, from one curve: the bytes of its file sent\n * over time, from the request of its first chunk to the answer to its last. It reports once a second, the first at\n * once, and only once it has a speed and either bytes came since its last report or the answer to a chunk that is\n * whole on its way is awaited; the whole file once it is out, also without a speed; without `report` it reports\n * nothing and asks for no second.\n */\nexport function useUploadMeter(report: UploadProgressCallback | undefined) {\n  let points: MeterPoint[] = []\n  let fileSize = 0\n  // Bytes of the chunks the server answered.\n  let received = 0\n  // Bytes sent by the last point; after a failed try, what the server has.\n  let sent = 0\n  // The share last reported: it never goes back.\n  let shown = 0\n  // Bytes came since the last report. A chunk that stands on its way reports nothing: a speed falling with every\n  // second of silence would make the time left hours and the next chunk, sized by the speed, small.\n  let moved = false\n  let sendingOver = false\n  // The speed last reported: the whole file is reported at it when no speed can be read by then, as when the clock\n  // went back before the answer to the last chunk.\n  let reportedSpeed = 0\n  let timer: ReturnType<typeof setTimeout> | undefined\n  // The try whose progress counts, and where the curve is once its chunk is whole on its way. A report of a try that\n  // has ended comes too late to be on the curve.\n  let current: { end: number } | undefined\n\n  const now = () => {\n    const at = Date.now()\n    // The clock went back: nothing measured before can be set against it.\n    if (points.length && at < points.at(-1)!.at) points = []\n    return at\n  }\n  const mark = (bytes: number, answered = false) => {\n    const at = now()\n    if (bytes > sent) moved = true\n    sent = bytes\n    points.push({ at, sent: bytes, answered })\n    // One point stays before the window: its edge is read between two.\n    while (points.length > 2 && points[1]!.at <= at - WINDOW_MS) points.shift()\n  }\n  // Where the curve was as the millisecond `at` began: of the points that share it, the first.\n  const sentAt = (at: number) => {\n    const next = points.findIndex((point) => point.at >= at)\n    if (next === -1) return points.at(-1)!.sent\n    if (next === 0) return points[0]!.sent\n    const before = points[next - 1]!\n    const after = points[next]!\n    return before.sent + ((after.sent - before.sent) * (at - before.at)) / (after.at - before.at)\n  }\n  /** Bytes a second over the window up to now, or up to the last answer once the file is out. */\n  const speed = () => {\n    const end = sendingOver ? points.at(-1)?.at : now()\n    if (points.length < 2 || end === undefined) return null\n    const from = Math.max(points[0]!.at, end - WINDOW_MS)\n    const span = end - from\n    // No point is later than the end: the last one says where the curve is, also among several of one millisecond.\n    const bytes = points.at(-1)!.sent - sentAt(from)\n    const answered = points.some((point) => point.answered && point.at > from)\n    return span > 0 && bytes > 0 && (span >= MIN_SPAN_MS || answered) ? (bytes * 1000) / span : null\n  }\n\n  // The wait for the answer to a chunk that is whole on its way is the server's time. The speed goes on counting it:\n  // the next chunk is sized right after the answer, and not by what the browser took alone.\n  const answerAwaited = () => !!current && sent >= current.end\n\n  const tick = () => {\n    const bytesPerSecond = speed() ?? (sendingOver ? reportedSpeed : null)\n    if (report && !isNull(bytesPerSecond) && (moved || answerAwaited() || sendingOver)) {\n      moved = false\n      shown = sendingOver ? 100 : Math.max(shown, Math.min((sent * 100) / fileSize, 100))\n      reportedSpeed = Math.ceil(bytesPerSecond)\n      report(shown, reportedSpeed, sendingOver ? 0 : Math.ceil((fileSize - sent) / bytesPerSecond))\n    }\n    if (!sendingOver) timer = setTimeout(tick, TICK_MS)\n  }\n\n  return {\n    /** The reports of a file of the given size begin. */\n    start(size: number) {\n      fileSize = size\n      if (report) tick()\n    },\n    /** Before each request of a chunk: the curve goes on from what the server has, and the try reports into it. */\n    attempt(chunkSize: number) {\n      const thisTry = { end: received + chunkSize }\n      current = thisTry\n      mark(received)\n      return (event: Pick<AxiosProgressEvent, 'loaded' | 'total'>) => {\n        if (current !== thisTry) return\n        let onItsWay = event.loaded\n        // `total` is the whole multipart body; what goes on the curve is its share of the chunk, and all of the chunk\n        // once the body is out: of numbers past 2^53 the division makes a little less.\n        if (event.total) onItsWay = event.loaded >= event.total ? chunkSize : (event.loaded * chunkSize) / event.total\n        mark(received + Math.min(Math.max(onItsWay, 0), chunkSize))\n      }\n    },\n    /** The server answered the chunk of the try. */\n    chunkDone(chunkSize: number) {\n      current = undefined\n      received += chunkSize\n      mark(received, true)\n    },\n    /**\n     * A try failed: the server took none of its bytes, and neither its time nor the pause after it counts. Until the\n     * next try has a speed nothing is reported, and the row keeps what it was told last.\n     */\n    attemptFailed() {\n      current = undefined\n      points = []\n      sent = received\n    },\n    /** Z9: the second that runs reports the whole file, and no further one is asked for. */\n    lastChunkSent() {\n      sendingOver = true\n    },\n    /** Z10: no further report. */\n    stop() {\n      clearTimeout(timer)\n      timer = undefined\n      sendingOver = true\n    },\n  }\n}\n"],"mappings":"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"}

package/dist/domains/dam/uploadQueue/composables/uploadQueueItemRefresh.d.ts

@@ -0,0 +1,27 @@
+import { Ref } from 'vue';
+import { UploadQueueItem, UploadQueueKey } from '../../types/UploadQueue';
+import { UploadQueueListBinding } from '../components/uploadQueueBindings';
+import { DocId } from '../../../../shared/types/common';
+export declare const SHOW_REFRESH_AFTER_SECONDS = 20;
+/** The warnings of a refresh, the message keys a host's `warn` is handed. */
+export declare const REFRESH_WARNING_KEYS: {
+    readonly pendingT: "common.damImage.queueItem.stillUploadingOrProcessing";
+    readonly failedT: "common.damImage.queueItem.refreshFailed";
+    readonly assetGoneT: "common.damImage.queueItem.assetGone";
+    readonly originalUnreadT: "common.damImage.queueItem.duplicateOriginalUnread";
+};
+export type UploadRefreshWarningKey = (typeof REFRESH_WARNING_KEYS)[keyof typeof REFRESH_WARNING_KEYS];
+/** The refresh of the rows of a list, over what its host binds: the host asks, and says what came of it. */
+export declare function createUploadQueueItemRefresh(queue: Pick<UploadQueueListBinding, 'items' | 'refresh' | 'refreshMayHelp' | 'warn'>): {
+    refreshing: Ref<boolean, boolean>;
+    refreshItem: (item: UploadQueueItem) => Promise<void>;
+};
+/**
+ * The refresh of an item of the upload queue: asks what became of its file, and settles the item accordingly.
+ * The store asks with the client of the configuration of the queue, and settles the rows of its queues: those of the
+ * queue `queueKey` of the refresh, or of the configuration `configName` where none is given.
+ */
+export declare function useUploadQueueItemRefresh(configName: string): {
+    refreshing: Ref<boolean, boolean>;
+    refreshItem: (assetId: DocId, item?: UploadQueueItem, queueKey?: UploadQueueKey) => Promise<void>;
+};

package/dist/domains/dam/uploadQueue/composables/uploadQueueItemRefresh.js

@@ -0,0 +1,59 @@
+import { isUndefined as e } from "../../../../shared/utils/common.js";
+import { useAlerts as t } from "../../../system/composables/alerts.js";
+import { UploadQueueItemStatus as n } from "../../types/UploadQueue.js";
+import { useUploadQueuesStore as r } from "../store/uploadQueuesStore.js";
+import { ref as i } from "vue";
+//#region src/domains/dam/uploadQueue/composables/uploadQueueItemRefresh.ts
+var a = {
+	pendingT: "common.damImage.queueItem.stillUploadingOrProcessing",
+	failedT: "common.damImage.queueItem.refreshFailed",
+	assetGoneT: "common.damImage.queueItem.assetGone",
+	originalUnreadT: "common.damImage.queueItem.duplicateOriginalUnread"
+}, o = {
+	pending: a.pendingT,
+	error: a.failedT,
+	missing: a.assetGoneT,
+	originalUnread: a.originalUnreadT
+}, s = (e, t) => {
+	switch (e.status) {
+		case n.Failed: return t(e);
+		case n.Uploaded: return !e.canEditMetadata && !e.isDuplicate;
+		case n.Stop: return !1;
+		default: return !0;
+	}
+}, c = async (e, t, r, i, c, l) => {
+	e.value = !0;
+	let u = i?.status;
+	try {
+		let e = o[await t()];
+		if (!e) return;
+		if (i) {
+			if (c()) return;
+			let t = i.status === u ? null : i.status;
+			if (t === n.Uploaded || t === n.Stop || t === n.Failed && e !== a.originalUnreadT || !s(i, l)) return;
+		}
+		r(e);
+	} finally {
+		e.value = !1;
+	}
+};
+function l(e) {
+	let t = i(!1), n = (t) => !e.items().includes(t);
+	return {
+		refreshing: t,
+		refreshItem: async (r) => {
+			n(r) || await c(t, () => e.refresh(r), (t) => e.warn(t), r, () => n(r), (t) => e.refreshMayHelp(t));
+		}
+	};
+}
+function u(n) {
+	let a = r(), { showWarningT: o } = t(), s = i(!1);
+	return {
+		refreshing: s,
+		refreshItem: (t, r, i) => c(s, () => a.refreshAsset(t, e(i) ? n : { queueKey: i }), (e) => o(e), r, () => !!r && !e(i) && !a.getQueueItems(i).includes(r), (e) => a.refreshMayHelp(e))
+	};
+}
+//#endregion
+export { a as REFRESH_WARNING_KEYS, l as createUploadQueueItemRefresh, u as useUploadQueueItemRefresh };
+
+//# sourceMappingURL=uploadQueueItemRefresh.js.map

package/dist/domains/dam/uploadQueue/composables/uploadQueueItemRefresh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadQueueItemRefresh.js","names":["REFRESH_WARNING_KEYS","WARNING_OF","refreshMayStillHelp","item","UploadQueueItemStatus","refreshMayHelp","refreshAndSay","statusBefore","key","ask","gone","changedInto","createUploadQueueItemRefresh","refreshing","ref","queue","failed","useUploadQueueItemRefresh","uploadQueuesStore","useUploadQueuesStore","useAlerts","assetId","isUndefined","queueKey","configName","showWarningT"],"sources":["../../../../../src/domains/dam/uploadQueue/composables/uploadQueueItemRefresh.ts"],"sourcesContent":["import { type Ref, ref } from 'vue'\nimport { type UploadQueueItem, UploadQueueItemStatus, type UploadQueueKey } from '@/domains/dam/types/UploadQueue'\nimport type { UploadQueueListBinding } from '@/domains/dam/uploadQueue/components/uploadQueueBindings'\nimport type { UploadRefreshOutcome } from '@/domains/dam/uploadQueue/settlement/uploadSettlementTypes'\nimport { useUploadQueuesStore } from '@/domains/dam/uploadQueue/store/uploadQueuesStore'\nimport { useAlerts } from '@/domains/system/composables/alerts'\nimport type { DocId } from '@/shared/types/common'\nimport { isUndefined } from '@/shared/utils/common'\n\n// How long an item of the queue waits before it offers refresh.\nexport const SHOW_REFRESH_AFTER_SECONDS = 20\n\n/** The warnings of a refresh, the message keys a host's `warn` is handed. */\nexport const REFRESH_WARNING_KEYS = {\n  pendingT: 'common.damImage.queueItem.stillUploadingOrProcessing',\n  failedT: 'common.damImage.queueItem.refreshFailed',\n  assetGoneT: 'common.damImage.queueItem.assetGone',\n  originalUnreadT: 'common.damImage.queueItem.duplicateOriginalUnread',\n} as const\nexport type UploadRefreshWarningKey = (typeof REFRESH_WARNING_KEYS)[keyof typeof REFRESH_WARNING_KEYS]\n\n// Why the item is as it was: the file is not done yet, or what asking again may mend, by its cause.\nconst WARNING_OF: Partial<Record<UploadRefreshOutcome, UploadRefreshWarningKey>> = {\n  pending: REFRESH_WARNING_KEYS.pendingT,\n  error: REFRESH_WARNING_KEYS.failedT,\n  missing: REFRESH_WARNING_KEYS.assetGoneT,\n  originalUnread: REFRESH_WARNING_KEYS.originalUnreadT,\n}\n\n/**\n * Whether a refresh may still change the item, as the row offers it: a failed one as its host says, an uploaded\n * one while it waits for its metadata, one still on its way or processed always, a stopped one never.\n */\nconst refreshMayStillHelp = (item: UploadQueueItem, refreshMayHelp: (item: UploadQueueItem) => boolean) => {\n  switch (item.status) {\n    case UploadQueueItemStatus.Failed:\n      return refreshMayHelp(item)\n    case UploadQueueItemStatus.Uploaded:\n      return !item.canEditMetadata && !item.isDuplicate\n    case UploadQueueItemStatus.Stop:\n      return false\n    default:\n      return true\n  }\n}\n\n/**\n * One refresh, and what the user is told of it. `item` is the one whose refresh was pressed, where the caller has\n * it, `gone` whether it was taken out of its queue meanwhile, and `refreshMayHelp` whether a refresh may still\n * change it once it has failed.\n */\nconst refreshAndSay = async (\n  refreshing: Ref<boolean>,\n  ask: () => Promise<UploadRefreshOutcome>,\n  warn: UploadQueueListBinding['warn'],\n  item: UploadQueueItem | undefined,\n  gone: () => boolean,\n  refreshMayHelp: (item: UploadQueueItem) => boolean\n) => {\n  refreshing.value = true\n  const statusBefore = item?.status\n  try {\n    const key = WARNING_OF[await ask()]\n    if (!key) return\n    if (item) {\n      // Taken out of its queue meanwhile: the word would be about a row nobody sees any more.\n      if (gone()) return\n      // Uploaded, stopped or failed while the read was on its way, by what overtook it or by this very read: what\n      // the read found is about the row as it was before, and the row shows what became of it. Only the press that\n      // left it without the original of its duplicate says why, as the row keeps its refresh for that.\n      const changedInto = item.status === statusBefore ? null : item.status\n      if (changedInto === UploadQueueItemStatus.Uploaded || changedInto === UploadQueueItemStatus.Stop) return\n      if (changedInto === UploadQueueItemStatus.Failed && key !== REFRESH_WARNING_KEYS.originalUnreadT) return\n      // And only while pressing again may still help it: not a failed row with no refresh left, nor an uploaded\n      // one that has its form.\n      if (!refreshMayStillHelp(item, refreshMayHelp)) return\n    }\n    warn(key)\n  } finally {\n    refreshing.value = false\n  }\n}\n\n/** The refresh of the rows of a list, over what its host binds: the host asks, and says what came of it. */\nexport function createUploadQueueItemRefresh(\n  queue: Pick<UploadQueueListBinding, 'items' | 'refresh' | 'refreshMayHelp' | 'warn'>\n) {\n  const refreshing = ref(false)\n  const gone = (item: UploadQueueItem) => !queue.items().includes(item)\n\n  const refreshItem = async (item: UploadQueueItem) => {\n    // A row that is no longer in the list is not asked about.\n    if (gone(item)) return\n    await refreshAndSay(\n      refreshing,\n      () => queue.refresh(item),\n      (key) => queue.warn(key),\n      item,\n      () => gone(item),\n      (failed) => queue.refreshMayHelp(failed)\n    )\n  }\n\n  return { refreshing, refreshItem }\n}\n\n/**\n * The refresh of an item of the upload queue: asks what became of its file, and settles the item accordingly.\n * The store asks with the client of the configuration of the queue, and settles the rows of its queues: those of the\n * queue `queueKey` of the refresh, or of the configuration `configName` where none is given.\n */\nexport function useUploadQueueItemRefresh(configName: string) {\n  const uploadQueuesStore = useUploadQueuesStore()\n  const { showWarningT } = useAlerts()\n  const refreshing = ref(false)\n\n  /**\n   * `item` is the one whose refresh was pressed and `queueKey` the queue it was pressed in, where the caller has\n   * them: the warnings of a failure and of a file not done yet go by them.\n   */\n  const refreshItem = (assetId: DocId, item?: UploadQueueItem, queueKey?: UploadQueueKey) =>\n    refreshAndSay(\n      refreshing,\n      () => uploadQueuesStore.refreshAsset(assetId, isUndefined(queueKey) ? configName : { queueKey }),\n      (key) => showWarningT(key),\n      item,\n      // A removed item keeps its status unless it was still waiting or being sent: that it is gone is read from\n      // its queue.\n      () => !!item && !isUndefined(queueKey) && !uploadQueuesStore.getQueueItems(queueKey).includes(item),\n      (failed) => uploadQueuesStore.refreshMayHelp(failed)\n    )\n\n  return { refreshing, refreshItem }\n}\n"],"mappings":";;;;;;AAaA,IAAaA,IAAuB;CAClC,UAAU;CACV,SAAS;CACT,YAAY;CACZ,iBAAiB;AACnB,GAIMC,IAA6E;CACjF,SAASD,EAAqB;CAC9B,OAAOA,EAAqB;CAC5B,SAASA,EAAqB;CAC9B,gBAAgBA,EAAqB;AACvC,GAMME,KAAuB,GAAuB,MAAuD;CACzG,QAAQC,EAAK,QAAb;EACE,KAAKC,EAAsB,QACzB,OAAOC,EAAeF,CAAI;EAC5B,KAAKC,EAAsB,UACzB,OAAO,CAACD,EAAK,mBAAmB,CAACA,EAAK;EACxC,KAAKC,EAAsB,MACzB,OAAO;EACT,SACE,OAAO;CACX;AACF,GAOME,IAAgB,OACpB,GACA,GACA,GACA,GACA,GACA,MACG;CACH,EAAW,QAAQ;CACnB,IAAMC,IAAeJ,GAAM;CAC3B,IAAI;EACF,IAAMK,IAAMP,EAAW,MAAMQ,EAAI;EACjC,IAAI,CAACD,GAAK;EACV,IAAIL,GAAM;GAER,IAAIO,EAAK,GAAG;GAIZ,IAAMC,IAAcR,EAAK,WAAWI,IAAe,OAAOJ,EAAK;GAK/D,IAJIQ,MAAgBP,EAAsB,YAAYO,MAAgBP,EAAsB,QACxFO,MAAgBP,EAAsB,UAAUI,MAAQR,EAAqB,mBAG7E,CAACE,EAAoBC,GAAME,CAAc,GAAG;EAClD;EACA,EAAKG,CAAG;CACV,UAAU;EACR,EAAW,QAAQ;CACrB;AACF;AAGA,SAAgBI,EACd,GACA;CACA,IAAMC,IAAaC,EAAI,EAAK,GACtBJ,KAAQ,MAA0B,CAACK,EAAM,MAAM,CAAC,CAAC,SAASZ,CAAI;CAepE,OAAO;EAAE;EAAY,oBAbM,MAA0B;GAEnD,AAAIO,EAAKP,CAAI,KACb,MAAMG,EACJO,SACME,EAAM,QAAQZ,CAAI,IACvB,MAAQY,EAAM,KAAKP,CAAG,GACvBL,SACMO,EAAKP,CAAI,IACd,MAAWY,EAAM,eAAeC,CAAM,CACzC;EACF;CAEiC;AACnC;AAOA,SAAgBC,EAA0B,GAAoB;CAC5D,IAAMC,IAAoBC,EAAqB,GACzC,EAAE,oBAAiBC,EAAU,GAC7BP,IAAaC,EAAI,EAAK;CAkB5B,OAAO;EAAE;EAAY,cAZA,GAAgB,GAAwB,MAC3DR,EACEO,SACMK,EAAkB,aAAaG,GAASC,EAAYC,CAAQ,IAAIC,IAAa,EAAE,YAAS,CAAC,IAC9F,MAAQC,EAAajB,CAAG,GACzBL,SAGM,CAAC,CAACA,KAAQ,CAACmB,EAAYC,CAAQ,KAAK,CAACL,EAAkB,cAAcK,CAAQ,CAAC,CAAC,SAASpB,CAAI,IACjG,MAAWe,EAAkB,eAAeF,CAAM,CACrD;CAE+B;AACnC"}

package/dist/domains/dam/uploadQueue/composables/uploadQueueMassOperations.d.ts

@@ -0,0 +1,12 @@
+import { MaybeRefOrGetter } from 'vue';
+import { UploadQueueKey } from '../../types/UploadQueue';
+import { DamAssetTypeType } from '../../types/Asset';
+export declare function useUploadQueueMassOperations(queueKey: MaybeRefOrGetter<UploadQueueKey>): {
+    replaceEmptyCustomDataValue: (data: {
+        assetType: DamAssetTypeType;
+        elementProperty: string;
+        value: any;
+    }, forceReplace?: boolean) => void;
+    replaceEmptyKeywords: (value: any, forceReplace?: boolean) => void;
+    replaceEmptyAuthors: (value: any, forceReplace?: boolean) => void;
+};

package/dist/domains/dam/uploadQueue/composables/uploadQueueMassOperations.js

@@ -0,0 +1,22 @@
+import { useUploadQueuesStore as e } from "../store/uploadQueuesStore.js";
+import { fillAuthors as t, fillCustomDataValue as n, fillKeywords as r } from "../core/uploadQueueFill.js";
+import { toValue as i } from "vue";
+//#region src/domains/dam/uploadQueue/composables/uploadQueueMassOperations.ts
+function a(a) {
+	let o = e();
+	return {
+		replaceEmptyCustomDataValue: (e, t = !1) => {
+			n(o.getQueueItems(i(a)), e, t);
+		},
+		replaceEmptyKeywords: (e, t = !1) => {
+			r(o.getQueueItems(i(a)), e, t);
+		},
+		replaceEmptyAuthors: (e, n = !1) => {
+			t(o.getQueueItems(i(a)), e, n);
+		}
+	};
+}
+//#endregion
+export { a as useUploadQueueMassOperations };
+
+//# sourceMappingURL=uploadQueueMassOperations.js.map

package/dist/domains/dam/uploadQueue/composables/uploadQueueMassOperations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadQueueMassOperations.js","names":["useUploadQueueMassOperations","uploadQueuesStore","useUploadQueuesStore","toValue","queueKey","data","forceReplace","value"],"sources":["../../../../../src/domains/dam/uploadQueue/composables/uploadQueueMassOperations.ts"],"sourcesContent":["import { type MaybeRefOrGetter, toValue } from 'vue'\nimport type { UploadQueueKey } from '@/domains/dam/types/UploadQueue'\nimport { useUploadQueuesStore } from '@/domains/dam/uploadQueue/store/uploadQueuesStore'\nimport type { DamAssetTypeType } from '@/domains/dam/types/Asset'\nimport { fillAuthors, fillCustomDataValue, fillKeywords } from '@/domains/dam/uploadQueue/core/uploadQueueFill'\n\nexport function useUploadQueueMassOperations(queueKey: MaybeRefOrGetter<UploadQueueKey>) {\n  const uploadQueuesStore = useUploadQueuesStore()\n\n  const replaceEmptyCustomDataValue = (\n    data: { assetType: DamAssetTypeType; elementProperty: string; value: any },\n    forceReplace = false\n  ) => {\n    fillCustomDataValue(uploadQueuesStore.getQueueItems(toValue(queueKey)), data, forceReplace)\n  }\n\n  const replaceEmptyKeywords = (value: any, forceReplace = false) => {\n    fillKeywords(uploadQueuesStore.getQueueItems(toValue(queueKey)), value, forceReplace)\n  }\n\n  const replaceEmptyAuthors = (value: any, forceReplace = false) => {\n    fillAuthors(uploadQueuesStore.getQueueItems(toValue(queueKey)), value, forceReplace)\n  }\n\n  return {\n    replaceEmptyCustomDataValue,\n    replaceEmptyKeywords,\n    replaceEmptyAuthors,\n  }\n}\n"],"mappings":";;;;AAMA,SAAgBA,EAA6B,GAA4C;CACvF,IAAMC,IAAoBC,EAAqB;CAiB/C,OAAO;EACL,8BAfA,GACA,IAAe,OACZ;GACH,EAAoBD,EAAkB,cAAcE,EAAQC,CAAQ,CAAC,GAAGC,GAAMC,CAAY;EAC5F;EAYE,uBAV4B,GAAY,IAAe,OAAU;GACjE,EAAaL,EAAkB,cAAcE,EAAQC,CAAQ,CAAC,GAAGG,GAAOD,CAAY;EACtF;EASE,sBAP2B,GAAY,IAAe,OAAU;GAChE,EAAYL,EAAkB,cAAcE,EAAQC,CAAQ,CAAC,GAAGG,GAAOD,CAAY;EACrF;CAMA;AACF"}

package/dist/domains/dam/uploadQueue/composables/uploadService.d.ts

@@ -0,0 +1,13 @@
+import { UploadQueueItem } from '../../types/UploadQueue';
+import { UploadMessages, UploadPreset, UploadProgressCallback, UploadRun, UploadSide } from '../presets/uploadPresets';
+/** The text of a validation answer (422 with `fields`): one line per field, in the texts of the side. */
+export declare function uploadValidationMessage(error: unknown, messages: UploadMessages): string;
+/** One run for both sides; without a set it is the library's. Public as `useDamUpload`. */
+export declare function useUpload(queueItem: UploadQueueItem, uploadCallback?: UploadProgressCallback, preset?: undefined): UploadRun<'library'> & {
+    stopSpeedCheck(): void;
+};
+/** The run of the side of the set. */
+export declare function useUpload<S extends UploadSide>(queueItem: UploadQueueItem, uploadCallback: UploadProgressCallback | undefined, preset: UploadPreset<S>): UploadRun<S> & {
+    stopSpeedCheck(): void;
+};
+export declare const uploadStop: (abortController: AbortController) => void;

package/dist/domains/dam/uploadQueue/composables/uploadService.js

@@ -0,0 +1,124 @@
+import { isUndefined as e } from "../../../../shared/utils/common.js";
+import { axiosErrorResponseHasValidationData as t } from "../../../../shared/error/AnzuApiValidationError.js";
+import "../../../system/composables/alerts.js";
+import { useDamConfigStoreOf as n } from "../../config/store/damConfigStore.js";
+import { UploadQueueItemStatus as r } from "../../types/UploadQueue.js";
+import { useDamUploadChunkSize as i } from "./damUploadChunkSize.js";
+import { useUploadMeter as a } from "./uploadMeter.js";
+import { libraryUploadPreset as o, uploadPresetMembers as s, uploadSide as c } from "../presets/uploadPresets.js";
+import { ref as l } from "vue";
+import u from "axios";
+//#region src/domains/dam/uploadQueue/composables/uploadService.ts
+var d = 4, f = 1e3, p = 3;
+function m(e, t) {
+	if (!u.isAxiosError(e) || !e.response || !e.response.data) return t.unknownError();
+	let n = e.response.data, r = [];
+	for (let [e, i] of Object.entries(n.fields ?? {})) switch (e) {
+		case "size":
+			r.push(t.size());
+			break;
+		case "offset":
+			r.push(t.offset());
+			break;
+		case "mimeType":
+			r.push(t.mimeType());
+			break;
+		default: r.push(t.systemError() + ": " + e + " - " + i.join(","));
+	}
+	return r.length > 0 ? r.join("\n") : t.unknownError();
+}
+var h = async (e, t, n) => new Promise((r, i) => {
+	let a = n.slice(e, e + t), o = new FileReader();
+	o.onload = function(t) {
+		if (t.target?.readyState === FileReader.DONE) {
+			let n = t.target.result;
+			n instanceof ArrayBuffer ? r({
+				data: n,
+				offset: e
+			}) : i(/* @__PURE__ */ Error("FileReader result is not an ArrayBuffer"));
+		}
+	}, o.onerror = function(e) {
+		i(e);
+	}, o.readAsArrayBuffer(a);
+}), g = (e) => new Promise((t) => setTimeout(t, e)), _ = () => /* @__PURE__ */ Error("Upload stopped"), v = (e) => {
+	let { minSize: t, maxSize: r } = n(e).damPrvConfig.settings.imageChunkConfig;
+	return t > 0 && r > 0;
+};
+function y(n, y, b) {
+	let x = b ?? o("default"), { requests: S, messages: C, apiTimeout: w, loadHash: T, emptyFile: E, configName: D } = x[s], O = l(0), k = a(y), A, j = !1, M = !1, { updateChunkSize: N, lastChunkSize: P } = i(w ?? void 0, D), F = () => M || n.status === r.Stop, I = async (e, t) => new Promise((r, i) => {
+		let a = k.attempt(e.size);
+		n.fileId ? S.chunk(n, n.fileId, e, e.size, t, a).then((e) => {
+			r(e);
+		}).catch((e) => {
+			i(e);
+		}) : i();
+	}), L = async (e, r) => {
+		if (F()) return Promise.reject(_());
+		N(n.progress.speed);
+		let i = await h(e, P.value, n.file), a = new File([i.data], n.file.name, { type: n.file.type });
+		if (F()) return Promise.reject(_());
+		n.currentChunkIndex = e, n.latestChunkAbortController = new AbortController();
+		let o = f, s = 0;
+		do {
+			if (s++, a.size === 0) return Promise.reject(/* @__PURE__ */ Error("uploadService: a chunk of no bytes"));
+			try {
+				return await I(a, e), k.chunkDone(a.size), r.update(i.data), a;
+			} catch (r) {
+				if (k.attemptFailed(), u.isCancel(r) || F()) return Promise.reject(r);
+				let c = s >= d;
+				if (c && u.isAxiosError(r) && r.response?.status === 400) return n.error.message = C.chunkValidationFailed(), Promise.reject(r);
+				if (t(r)) return n.error.message = m(r, C), Promise.reject(r);
+				if (c) break;
+				if (N(n.progress.speed) && (i = await h(e, P.value, n.file), a = new File([i.data], n.file.name, { type: n.file.type })), await g(o), F()) return Promise.reject(_());
+				o *= p;
+			}
+		} while (s < d);
+		return Promise.reject("Unable to upload chunk, max tries exceeded");
+	}, R = () => k.stop(), z = async () => {
+		if (!v(D)) throw Error(`uploadService: the chunk bounds of the DAM configuration "${D}" are not loaded`);
+		let e = !!n.file && (E === "send" || n.file.size > 0);
+		e && (n.status = r.Uploading);
+		let t = await T();
+		if (F()) throw _();
+		return A = t, new Promise((t, i) => {
+			n.file ? e ? (O.value = n.file.size, n.status = r.Uploading, S.start(n).then((e) => {
+				!e?.id || !e?.asset ? i(/* @__PURE__ */ Error("uploadService: the start answer names no file or no asset")) : (n.assetId = e.asset, n.fileId = e.id, F() ? i(_()) : t(n));
+			}).catch((e) => {
+				i(e);
+			})) : i(/* @__PURE__ */ Error("Empty file")) : i(/* @__PURE__ */ Error("uploadService: the queue item has no file"));
+		});
+	}, B = async () => {
+		k.start(O.value);
+		try {
+			let t = n.file?.size, r = A;
+			if (e(t) || e(r)) throw void 0;
+			if (F()) throw _();
+			let i = 0;
+			for (; i < t;) {
+				let e = await L(i, r);
+				i += e.size;
+			}
+			if (k.lastChunkSent(), F()) throw _();
+			return j = !0, await S.finish(n, r.digest("hex"));
+		} catch (e) {
+			throw R(), e;
+		}
+	}, V = () => {
+		M = !0, R(), n.latestChunkAbortController?.abort();
+	};
+	return {
+		[c]: x[c],
+		uploadInit: z,
+		upload: B,
+		stop: V,
+		stopSpeedCheck: R,
+		finishAttempted: () => j
+	};
+}
+var b = (e) => {
+	e.abort();
+};
+//#endregion
+export { b as uploadStop, m as uploadValidationMessage, y as useUpload };
+
+//# sourceMappingURL=uploadService.js.map

package/dist/domains/dam/uploadQueue/composables/uploadService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploadService.js","names":["axios","CHUNK_MAX_RETRY","CHUNK_RETRY_INTERVAL","CHUNK_RETRY_MULTIPLY","uploadValidationMessage","error","messages","data","errorMessages","key","values","readFile","partial","file","offset","size","reader","e","result","resolve","reject","sleep","ms","stoppedError","chunkBoundsLoaded","useDamConfigStoreOf","configName","minSize","maxSize","useUpload","set","preset","libraryUploadPreset","uploadPresetMembers","fileSize","ref","meter","useUploadMeter","uploadCallback","sha","finishAttempted","stopRequested","useDamUploadChunkSize","apiTimeout","stopped","queueItem","UploadQueueItemStatus","uploadChunk","onUploadProgress","chunkFile","requests","exception","processAndUploadChunk","arrayBuffer","lastChunkSize","sleepTime","attempt","hash","lastAttempt","axiosErrorResponseHasValidationData","updateChunkSize","stopSpeedCheck","uploadInit","sendable","emptyFile","loadHash","res","err","upload","filesize","isUndefined","uploadedChunk","stop","uploadSide","uploadStop"],"sources":["../../../../../src/domains/dam/uploadQueue/composables/uploadService.ts"],"sourcesContent":["import { ref } from 'vue'\nimport axios from 'axios'\nimport {\n  type AnzuApiValidationResponseData,\n  axiosErrorResponseHasValidationData,\n} from '@/shared/error/AnzuApiValidationError'\nimport { type UploadQueueItem, UploadQueueItemStatus } from '@/domains/dam/types/UploadQueue'\nimport { NEW_LINE_MARK } from '@/domains/system/composables/alerts'\nimport { isUndefined } from '@/shared/utils/common'\nimport { useDamUploadChunkSize } from '@/domains/dam/uploadQueue/composables/damUploadChunkSize'\nimport { useDamConfigStoreOf } from '@/domains/dam/config/store/damConfigStore'\nimport { useUploadMeter } from '@/domains/dam/uploadQueue/composables/uploadMeter'\nimport {\n  libraryUploadPreset,\n  type UploadHash,\n  type UploadMessages,\n  type UploadPreset,\n  uploadPresetMembers,\n  type UploadProgressCallback,\n  type UploadRun,\n  uploadSide,\n  type UploadSide,\n} from '@/domains/dam/uploadQueue/presets/uploadPresets'\n\n// const CHUNK_MAX_RETRY = 6\nconst CHUNK_MAX_RETRY = 4\nconst CHUNK_RETRY_INTERVAL = 1000\nconst CHUNK_RETRY_MULTIPLY = 3\n\n/** The text of a validation answer (422 with `fields`): one line per field, in the texts of the side. */\nexport function uploadValidationMessage(error: unknown, messages: UploadMessages): string {\n  if (!axios.isAxiosError(error) || !error.response || !error.response.data) return messages.unknownError()\n  const data = error.response.data as Partial<AnzuApiValidationResponseData>\n  const errorMessages: string[] = []\n  for (const [key, values] of Object.entries(data.fields ?? {})) {\n    switch (key) {\n      case 'size':\n        errorMessages.push(messages.size())\n        break\n      case 'offset':\n        errorMessages.push(messages.offset())\n        break\n      case 'mimeType':\n        errorMessages.push(messages.mimeType())\n        break\n      default:\n        errorMessages.push(messages.systemError() + ': ' + key + ' - ' + values.join(','))\n    }\n  }\n  return errorMessages.length > 0 ? errorMessages.join(NEW_LINE_MARK) : messages.unknownError()\n}\n\nconst readFile = async (offset: number, size: number, file: File): Promise<{ data: ArrayBuffer; offset: number }> => {\n  return new Promise((resolve, reject) => {\n    const partial = file.slice(offset, offset + size)\n    const reader = new FileReader()\n    reader.onload = function (e) {\n      if (e.target?.readyState === FileReader.DONE) {\n        const result = e.target.result\n        if (result instanceof ArrayBuffer) {\n          resolve({ data: result, offset: offset })\n        } else {\n          reject(new Error('FileReader result is not an ArrayBuffer'))\n        }\n      }\n    }\n    reader.onerror = function (e) {\n      reject(e)\n    }\n    reader.readAsArrayBuffer(partial)\n  })\n}\n\nconst sleep = (ms: number) => {\n  return new Promise((resolve) => setTimeout(resolve, ms))\n}\n\nconst stoppedError = () => new Error('Upload stopped')\n\n// The bounds of the chunks come with the prv configuration of the DAM configuration, 0 and 0 till it is loaded: a chunk\n// sized by them is of no bytes.\nconst chunkBoundsLoaded = (configName: string) => {\n  const { minSize, maxSize } = useDamConfigStoreOf(configName).damPrvConfig.settings.imageChunkConfig\n  return minSize > 0 && maxSize > 0\n}\n\n/** One run for both sides; without a set it is the library's. Public as `useDamUpload`. */\nexport function useUpload(\n  queueItem: UploadQueueItem,\n  uploadCallback?: UploadProgressCallback,\n  preset?: undefined\n): UploadRun<'library'> & { stopSpeedCheck(): void }\n/** The run of the side of the set. */\nexport function useUpload<S extends UploadSide>(\n  queueItem: UploadQueueItem,\n  uploadCallback: UploadProgressCallback | undefined,\n  preset: UploadPreset<S>\n): UploadRun<S> & { stopSpeedCheck(): void }\nexport function useUpload(\n  queueItem: UploadQueueItem,\n  uploadCallback?: UploadProgressCallback,\n  preset?: UploadPreset\n): UploadRun & { stopSpeedCheck(): void } {\n  // Made only when none is given: it reads the options of the plugin, which a side with a set of its own need not\n  // have.\n  // Without a preset, as `useUpload` is public: the library's, under `default`.\n  const set = preset ?? libraryUploadPreset('default')\n  const { requests, messages, apiTimeout, loadHash, emptyFile, configName } = set[uploadPresetMembers]\n  const fileSize = ref(0)\n\n  const meter = useUploadMeter(uploadCallback)\n  let sha: UploadHash | undefined\n  // Once the finish request went out the server may complete the file, whatever becomes of the answer.\n  let finishAttempted = false\n  // Set by `stop()`; the queue may stop a run by the status of its row instead, and every check reads both.\n  let stopRequested = false\n  const { updateChunkSize, lastChunkSize } = useDamUploadChunkSize(apiTimeout ?? undefined, configName)\n\n  // A call, not an inline comparison: TypeScript keeps a status narrowed across the awaits in between.\n  const stopped = () => stopRequested || queueItem.status === UploadQueueItemStatus.Stop\n\n  const uploadChunk = async (chunkFile: File, offset: number) => {\n    return new Promise((resolve, reject) => {\n      const onUploadProgress = meter.attempt(chunkFile.size)\n      if (!queueItem.fileId) {\n        reject()\n        return\n      }\n      requests\n        .chunk(queueItem, queueItem.fileId, chunkFile, chunkFile.size, offset, onUploadProgress)\n        .then((result) => {\n          resolve(result)\n        })\n        .catch((exception) => {\n          reject(exception)\n        })\n    })\n  }\n\n  const processAndUploadChunk = async (offset: number, hash: UploadHash): Promise<File> => {\n    if (stopped()) return Promise.reject(stoppedError())\n    updateChunkSize(queueItem.progress.speed)\n    let arrayBuffer: { data: ArrayBuffer; offset: number } = await readFile(\n      offset,\n      lastChunkSize.value,\n      queueItem.file!\n    )\n    let chunkFile = new File([arrayBuffer.data], queueItem.file!.name, {\n      type: queueItem.file!.type,\n    })\n\n    // Stop between chunks has no request to cancel: the controller below would be a fresh one.\n    if (stopped()) return Promise.reject(stoppedError())\n    queueItem.currentChunkIndex = offset\n    queueItem.latestChunkAbortController = new AbortController()\n\n    let sleepTime = CHUNK_RETRY_INTERVAL\n    let attempt = 0\n    do {\n      attempt++\n      // A chunk of no bytes takes the upload no further: the upload fails at once, without the tries of a chunk.\n      if (chunkFile.size === 0) return Promise.reject(new Error('uploadService: a chunk of no bytes'))\n      try {\n        await uploadChunk(chunkFile, offset)\n        meter.chunkDone(chunkFile.size)\n        hash.update(arrayBuffer.data)\n\n        return chunkFile\n      } catch (error) {\n        meter.attemptFailed()\n        if (axios.isCancel(error) || stopped()) return Promise.reject(error)\n        const lastAttempt = attempt >= CHUNK_MAX_RETRY\n        // Check for 400 Bad Request error on last attempt\n        if (lastAttempt && axios.isAxiosError(error) && error.response?.status === 400) {\n          queueItem.error.message = messages.chunkValidationFailed()\n          return Promise.reject(error)\n        }\n\n        if (axiosErrorResponseHasValidationData(error as Error)) {\n          queueItem.error.message = uploadValidationMessage(error, messages)\n          return Promise.reject(error)\n        }\n\n        // Before the work for an attempt that never happens: the loop ends here.\n        if (lastAttempt) break\n\n        if (updateChunkSize(queueItem.progress.speed)) {\n          arrayBuffer = await readFile(offset, lastChunkSize.value, queueItem.file!)\n          chunkFile = new File([arrayBuffer.data], queueItem.file!.name, {\n            type: queueItem.file!.type,\n          })\n        }\n\n        await sleep(sleepTime)\n        // A stop in the pause had no request to cancel.\n        if (stopped()) return Promise.reject(stoppedError())\n        sleepTime *= CHUNK_RETRY_MULTIPLY\n      }\n    } while (attempt < CHUNK_MAX_RETRY)\n    return Promise.reject('Unable to upload chunk, max tries exceeded')\n  }\n\n  const stopSpeedCheck = () => meter.stop()\n\n  const uploadInit = async () => {\n    // Refused before anything is asked: the DAM is not asked to create an asset no chunk can fill.\n    if (!chunkBoundsLoaded(configName)) {\n      throw new Error(`uploadService: the chunk bounds of the DAM configuration \"${configName}\" are not loaded`)\n    }\n    const sendable = !!queueItem.file && (emptyFile === 'send' || queueItem.file.size > 0)\n    // Taken before the first await: the queue starts every item it still sees waiting, and it looks again after\n    // each file it adds.\n    if (sendable) queueItem.status = UploadQueueItemStatus.Uploading\n    const hash = await loadHash()\n    // Stop has no request to cancel while the hash is prepared, so it is checked once the hash is here.\n    if (stopped()) throw stoppedError()\n    sha = hash\n    return new Promise((resolve, reject) => {\n      if (!queueItem.file) {\n        reject(new Error('uploadService: the queue item has no file'))\n        return\n      }\n      if (!sendable) {\n        reject(new Error('Empty file'))\n        return\n      }\n      fileSize.value = queueItem.file.size\n      queueItem.status = UploadQueueItemStatus.Uploading\n      requests\n        .start(queueItem)\n        .then((res) => {\n          // Without both identifiers there is nothing to send the chunks to, nor an asset to ask about: the\n          // upload fails here, as when the start is refused, not after a round of tries that send nothing.\n          if (!res?.id || !res?.asset) {\n            reject(new Error('uploadService: the start answer names no file or no asset'))\n            return\n          }\n          queueItem.assetId = res.asset\n          queueItem.fileId = res.id\n          // A stop asked for while this was on the wire; the asset it created stays on the server.\n          if (stopped()) {\n            reject(stoppedError())\n            return\n          }\n          resolve(queueItem)\n        })\n        .catch((err) => {\n          reject(err)\n        })\n    })\n  }\n\n  const upload = async () => {\n    meter.start(fileSize.value)\n\n    // Every way out but the finish answered stops the meter: no later second reports on a run that failed.\n    try {\n      const filesize = queueItem.file?.size\n      const hash = sha\n      if (isUndefined(filesize) || isUndefined(hash)) throw undefined\n      // A stop while the asset was being created had no chunk request to cancel either.\n      if (stopped()) throw stoppedError()\n\n      let i = 0\n      while (i < filesize) {\n        const uploadedChunk = await processAndUploadChunk(i, hash)\n        i += uploadedChunk.size\n      }\n\n      meter.lastChunkSent()\n      if (stopped()) throw stoppedError()\n      finishAttempted = true\n      return await requests.finish(queueItem, hash.digest('hex'))\n    } catch (error) {\n      stopSpeedCheck()\n      throw error\n    }\n  }\n\n  const stop = () => {\n    stopRequested = true\n    stopSpeedCheck()\n    queueItem.latestChunkAbortController?.abort()\n  }\n\n  return {\n    [uploadSide]: set[uploadSide],\n    uploadInit,\n    upload,\n    stop,\n    stopSpeedCheck,\n    finishAttempted: () => finishAttempted,\n  }\n}\n\nexport const uploadStop = (abortController: AbortController) => {\n  abortController.abort()\n}\n"],"mappings":"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"}

package/dist/domains/dam/uploadQueue/composables/useUploadQueueDialog.d.ts

@@ -0,0 +1,15 @@
+import { UploadQueueKey } from '../../types/UploadQueue';
+/**
+ * For an upload dialog, from its setup: drawn till it is unmounted. Gone with its widget (the editor sent out of the
+ * article during an upload), the last dialog of its queue forgets that dialog named: the app kept the name, and the next
+ * widget of that queue opened the dialog at once. Not while another dialog of the queue is still drawn: the name closed
+ * that one as well. The queue itself is left as it is.
+ */
+export declare function useUploadQueueDialogDrawn(queueKey: UploadQueueKey): void;
+export declare function useUploadQueueDialog(): {
+    toggleUploadQueueSidebar: () => void;
+    stopQueueLeftBehind: (queueKey: UploadQueueKey) => void;
+    uploadQueueDialog: import('vue').Ref<string | null, string | null>;
+    uploadQueueDialogSaving: import('vue').Ref<string | null, string | null>;
+    uploadQueueSidebar: import('vue').Ref<boolean, boolean>;
+};

package/dist/domains/dam/uploadQueue/composables/useUploadQueueDialog.js

@@ -0,0 +1,28 @@
+import { useUploadQueuesStore as e } from "../store/uploadQueuesStore.js";
+import { onBeforeUnmount as t, ref as n } from "vue";
+//#region src/domains/dam/uploadQueue/composables/useUploadQueueDialog.ts
+var r = n(null), i = n(null), a = n(!1), o = /* @__PURE__ */ new Map();
+function s(e) {
+	o.set(e, (o.get(e) ?? 0) + 1), t(() => {
+		let t = (o.get(e) ?? 1) - 1;
+		if (t > 0) return void o.set(e, t);
+		o.delete(e), r.value === e && (r.value = null);
+	});
+}
+function c() {
+	return {
+		toggleUploadQueueSidebar: () => {
+			a.value = !a.value;
+		},
+		stopQueueLeftBehind: (t) => {
+			r.value !== t && e().stopUpload(t);
+		},
+		uploadQueueDialog: r,
+		uploadQueueDialogSaving: i,
+		uploadQueueSidebar: a
+	};
+}
+//#endregion
+export { c as useUploadQueueDialog, s as useUploadQueueDialogDrawn };
+
+//# sourceMappingURL=useUploadQueueDialog.js.map

package/dist/domains/dam/uploadQueue/composables/useUploadQueueDialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUploadQueueDialog.js","names":["uploadQueueDialog","ref","uploadQueueDialogSaving","uploadQueueSidebar","dialogsDrawn","useUploadQueueDialogDrawn","queueKey","onBeforeUnmount","left","useUploadQueueDialog","useUploadQueuesStore"],"sources":["../../../../../src/domains/dam/uploadQueue/composables/useUploadQueueDialog.ts"],"sourcesContent":["import { onBeforeUnmount, ref } from 'vue'\nimport type { UploadQueueKey } from '@/domains/dam/types/UploadQueue'\nimport { useUploadQueuesStore } from '@/domains/dam/uploadQueue/store/uploadQueuesStore'\n\nconst uploadQueueDialog = ref<UploadQueueKey | null>(null)\n// The queue whose dialog is saving right now. \"Save and apply\" ends with the queue emptied: its host takes no file\n// for that queue meanwhile, through an entry of its own, as the dialog takes none through its \"+\" and its dropzone.\nconst uploadQueueDialogSaving = ref<UploadQueueKey | null>(null)\nconst uploadQueueSidebar = ref(false)\n// The upload dialogs drawn now, by their queue: two widgets of one queue key each draw theirs.\nconst dialogsDrawn = new Map<UploadQueueKey, number>()\n\n/**\n * For an upload dialog, from its setup: drawn till it is unmounted. Gone with its widget (the editor sent out of the\n * article during an upload), the last dialog of its queue forgets that dialog named: the app kept the name, and the next\n * widget of that queue opened the dialog at once. Not while another dialog of the queue is still drawn: the name closed\n * that one as well. The queue itself is left as it is.\n */\nexport function useUploadQueueDialogDrawn(queueKey: UploadQueueKey) {\n  dialogsDrawn.set(queueKey, (dialogsDrawn.get(queueKey) ?? 0) + 1)\n  onBeforeUnmount(() => {\n    const left = (dialogsDrawn.get(queueKey) ?? 1) - 1\n    if (left > 0) return void dialogsDrawn.set(queueKey, left)\n    dialogsDrawn.delete(queueKey)\n    if (uploadQueueDialog.value === queueKey) uploadQueueDialog.value = null\n  })\n}\n\nexport function useUploadQueueDialog() {\n  const toggleUploadQueueSidebar = () => {\n    uploadQueueSidebar.value = !uploadQueueSidebar.value\n  }\n\n  /**\n   * Before files or the copy of an asset are added to the queue `queueKey` from outside its dialog. A queue no dialog\n   * names holds only the rows a dialog that went away with its widget left there (the editor sent out of the article\n   * during an upload), and the dialog opened for the new file showed the first of them, the old file, and its \"save and\n   * apply\" handed the widget that one. Such a queue is stopped first: the uploads of its rows stop, and an asset an\n   * upload has made stays in the DAM.\n   */\n  const stopQueueLeftBehind = (queueKey: UploadQueueKey) => {\n    if (uploadQueueDialog.value !== queueKey) useUploadQueuesStore().stopUpload(queueKey)\n  }\n\n  return {\n    toggleUploadQueueSidebar,\n    stopQueueLeftBehind,\n    uploadQueueDialog,\n    uploadQueueDialogSaving,\n    uploadQueueSidebar,\n  }\n}\n"],"mappings":";;;AAIA,IAAMA,IAAoBC,EAA2B,IAAI,GAGnDC,IAA0BD,EAA2B,IAAI,GACzDE,IAAqBF,EAAI,EAAK,GAE9BG,oBAAe,IAAI,IAA4B;AAQrD,SAAgBC,EAA0B,GAA0B;CAElE,AADAD,EAAa,IAAIE,IAAWF,EAAa,IAAIE,CAAQ,KAAK,KAAK,CAAC,GAChEC,QAAsB;EACpB,IAAMC,KAAQJ,EAAa,IAAIE,CAAQ,KAAK,KAAK;EACjD,IAAIE,IAAO,GAAG,OAAO,KAAKJ,EAAa,IAAIE,GAAUE,CAAI;EAEzD,AADAJ,EAAa,OAAOE,CAAQ,GACxBN,EAAkB,UAAUM,MAAU,EAAkB,QAAQ;CACtE,CAAC;AACH;AAEA,SAAgBG,IAAuB;CAgBrC,OAAO;EACL,gCAhBqC;GACrC,EAAmB,QAAQ,CAACN,EAAmB;EACjD;EAeE,sBAN2B,MAA6B;GACxD,AAAIH,EAAkB,UAAUM,KAAUI,EAAqB,CAAC,CAAC,WAAWJ,CAAQ;EACtF;EAKE;EACA;EACA;CACF;AACF"}

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

@@ -0,0 +1,8 @@
+import { UploadSide } from '../presets/uploadPresets';
+import { UploadQueueCore, UploadQueuePreset } from './uploadQueueCoreTypes';
+export declare const UPLOAD_QUEUE_ITEM_CHUNK_SIZE = 10485760;
+/**
+ * The upload queue of a store: its queues as the store holds them, two uploads at a time per queue, the run of each
+ * row, how a row leaves, and the settlement of the rows the server works on. Made in the setup of the store.
+ */
+export declare function createUploadQueueCore<S extends UploadSide>(preset: UploadQueuePreset<S>): UploadQueueCore;