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

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

@@ -0,0 +1,49 @@
+import { __toESM as e } from "../../../../_virtual/_rolldown/runtime.js";
+import { commonT as t } from "../../../../plugins/i18n.js";
+import { useCommonAdminCoreDamOptions as n } from "../../composables/commonAdminCoreDamOptions.js";
+import { withTimeout as r } from "../../../listEditor/utils/listEditorLoader.js";
+import { damUploadChunk as i, damUploadFinish as a, damUploadStart as o } from "../../api/uploadApi.js";
+//#region src/domains/dam/uploadQueue/presets/uploadPresets.ts
+var s = 15e3, c = Symbol("uploadSide"), l = Symbol("uploadPresetMembers");
+function u(u) {
+	let { damClient: d, endPointImage: f, apiTimeout: p } = n(u);
+	return {
+		[c]: "library",
+		[l]: {
+			requests: {
+				start: (e) => o(d, f, e),
+				chunk: (e, t, n, r, a, o) => i(d, f, e, t, n, r, a, o),
+				finish: (e, t) => a(d, f, e, t)
+			},
+			messages: {
+				unknownError: () => t("common.damImage.uploadErrors.unknownError"),
+				size: () => t("common.damImage.uploadErrors.size"),
+				offset: () => t("common.damImage.uploadErrors.offset"),
+				mimeType: () => t("common.damImage.uploadErrors.mimeType"),
+				systemError: () => t("common.damImage.uploadErrors.systemError"),
+				chunkValidationFailed: () => t("common.damImage.uploadErrors.chunkValidationFailed")
+			},
+			apiTimeout: p,
+			loadHash: () => r(import("../../../../vendor/rusha/dist/rusha.js").then((t) => /* @__PURE__ */ e(t.default)), s, `rusha did not load within ${s} ms.`).then((e) => e.default.createHash()),
+			emptyFile: "reject",
+			configName: u
+		}
+	};
+}
+function d(e) {
+	return {
+		[c]: "adminDam",
+		[l]: {
+			requests: e.requests,
+			messages: e.messages,
+			apiTimeout: e.apiTimeout,
+			loadHash: () => e.loadHash(),
+			emptyFile: "send",
+			configName: "default"
+		}
+	};
+}
+//#endregion
+export { d as adminDamUploadPreset, u as libraryUploadPreset, l as uploadPresetMembers, c as uploadSide };
+
+//# sourceMappingURL=uploadPresets.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uploadPresets.js","names":["HASH_LOAD_TIMEOUT","uploadSide","uploadPresetMembers","libraryUploadPreset","useCommonAdminCoreDamOptions","configName","damUploadStart","damClient","endPointImage","item","damUploadChunk","fileId","chunk","size","offset","onUploadProgress","damUploadFinish","sha","commonT","withTimeout","m","rusha","adminDamUploadPreset","app"],"sources":["../../../../../src/domains/dam/uploadQueue/presets/uploadPresets.ts"],"sourcesContent":["import type { AxiosProgressEvent } from 'axios'\nimport { commonT } from '@/plugins/i18n'\nimport type { DamUploadStartResponse, UploadQueueItem } from '@/domains/dam/types/UploadQueue'\nimport type { DocId } from '@/shared/types/common'\nimport { damUploadChunk, damUploadFinish, damUploadStart } from '@/domains/dam/api/uploadApi'\nimport { useCommonAdminCoreDamOptions } from '@/domains/dam/composables/commonAdminCoreDamOptions'\nimport { withTimeout } from '@/domains/listEditor/utils/listEditorLoader'\n\nconst HASH_LOAD_TIMEOUT = 15_000\n\nexport type UploadSide = 'library' | 'adminDam'\n// Not exported from the library: only its own functions put them on a set or a run. Nothing reads the side at\n// runtime; a set holds its members under the other one.\nexport const uploadSide = Symbol('uploadSide')\nexport const uploadPresetMembers = Symbol('uploadPresetMembers')\n\n/** What a run asks the server. */\nexport interface UploadRunRequests {\n  start(item: UploadQueueItem): Promise<DamUploadStartResponse>\n  chunk(\n    item: UploadQueueItem,\n    fileId: DocId,\n    chunk: File,\n    size: number,\n    offset: number,\n    onUploadProgress: (event: AxiosProgressEvent) => void\n  ): Promise<unknown>\n  finish(item: UploadQueueItem, sha: string): Promise<unknown>\n}\n\n/** The texts a run writes into its row. Each side keeps its own. */\nexport interface UploadMessages {\n  unknownError(): string\n  /** A field the server refused, by its name. */\n  size(): string\n  offset(): string\n  mimeType(): string\n  /** Put before the name of a refused field there is no text for. */\n  systemError(): string\n  /** HTTP 400 on the last try of a chunk. */\n  chunkValidationFailed(): string\n}\n\nexport interface UploadHash {\n  update(data: ArrayBuffer): unknown\n  digest(encoding: 'hex'): string\n}\n\ninterface UploadPresetMembers {\n  requests: UploadRunRequests\n  messages: UploadMessages\n  apiTimeout: number | null | undefined\n  loadHash(): Promise<UploadHash>\n  /** Whether a file of no bytes is started and finished, or refused before anything is asked. */\n  emptyFile: 'send' | 'reject'\n  /** The DAM configuration whose prv configuration bounds the chunks, and whose last chunk size the upload starts from. */\n  configName: string\n}\n\n/** How one side uploads. Made only by `libraryUploadPreset()` and `adminDamUploadPreset()`; what it holds is not public. */\nexport interface UploadPreset<S extends UploadSide = UploadSide> {\n  readonly [uploadSide]: S\n  readonly [uploadPresetMembers]: UploadPresetMembers\n}\n\nexport type UploadProgressCallback = (progress: number, speed: number, estimate: number) => void\n\nexport interface UploadRun<S extends UploadSide = UploadSide> {\n  readonly [uploadSide]: S\n  uploadInit(): Promise<unknown>\n  upload(): Promise<unknown>\n  /** Stops the run wherever it is, and cancels the chunk on the wire. */\n  stop(): void\n  /** Whether the finish request went out: the server may complete the file whatever became of the answer. */\n  finishAttempted(): boolean\n}\n\n/**\n * Not exported from `src/lib.ts`; the default of `useUpload` (under `default`). The library's API, texts and choices,\n * under the DAM configuration `configName`.\n */\nexport function libraryUploadPreset(configName: string): UploadPreset<'library'> {\n  // A chunk is sized against the timeout the application gives the DAM requests of the configuration, else its root\n  // one. One that gives none (`null` in a config file too) gets the default of the composable.\n  const { damClient, endPointImage, apiTimeout } = useCommonAdminCoreDamOptions(configName)\n\n  return {\n    [uploadSide]: 'library',\n    [uploadPresetMembers]: {\n      requests: {\n        start: (item) => damUploadStart(damClient, endPointImage, item),\n        chunk: (item, fileId, chunk, size, offset, onUploadProgress) =>\n          damUploadChunk(damClient, endPointImage, item, fileId, chunk, size, offset, onUploadProgress),\n        finish: (item, sha) => damUploadFinish(damClient, endPointImage, item, sha),\n      },\n      messages: {\n        unknownError: () => commonT('common.damImage.uploadErrors.unknownError'),\n        size: () => commonT('common.damImage.uploadErrors.size'),\n        offset: () => commonT('common.damImage.uploadErrors.offset'),\n        mimeType: () => commonT('common.damImage.uploadErrors.mimeType'),\n        systemError: () => commonT('common.damImage.uploadErrors.systemError'),\n        chunkValidationFailed: () => commonT('common.damImage.uploadErrors.chunkValidationFailed'),\n      },\n      apiTimeout,\n      // rusha is loaded when a file starts uploading, not with every page that shows the upload queue, and\n      // before the asset is created: a chunk that does not arrive fails the item without an empty asset.\n      loadHash: () =>\n        withTimeout(import('rusha'), HASH_LOAD_TIMEOUT, `rusha did not load within ${HASH_LOAD_TIMEOUT} ms.`).then(\n          (rusha) => rusha.default.createHash()\n        ),\n      emptyFile: 'reject',\n      configName,\n    },\n  }\n}\n\n/** admin-dam's API, texts and choices. What is the application's own, the application hands in. */\nexport function adminDamUploadPreset(app: {\n  /** `uploadStart`, `uploadChunk`, `uploadFinish` of `fileApi.ts`: four asset types, admin-dam's addresses. */\n  requests: UploadRunRequests\n  /** `system.uploadErrors.*`; as `chunkValidationFailed` its `unknownError`, which its store writes today. */\n  messages: UploadMessages\n  /** `envConfig.dam.apiTimeout`. */\n  apiTimeout: number | null | undefined\n  /** `() => Promise.resolve(rusha.createHash())`: rusha stays a static import of admin-dam. */\n  loadHash(): Promise<UploadHash>\n}): UploadPreset<'adminDam'> {\n  return {\n    [uploadSide]: 'adminDam',\n    [uploadPresetMembers]: {\n      requests: app.requests,\n      messages: app.messages,\n      apiTimeout: app.apiTimeout,\n      loadHash: () => app.loadHash(),\n      emptyFile: 'send',\n      configName: 'default',\n    },\n  }\n}\n"],"mappings":";;;;;;AAQA,IAAMA,IAAoB,MAKbC,IAAa,OAAO,YAAY,GAChCC,IAAsB,OAAO,qBAAqB;AAmE/D,SAAgBC,EAAoB,GAA6C;CAG/E,IAAM,EAAE,cAAW,kBAAe,kBAAeC,EAA6BC,CAAU;CAExF,OAAO;GACJJ,IAAa;GACbC,IAAsB;GACrB,UAAU;IACR,QAAQ,MAASI,EAAeC,GAAWC,GAAeC,CAAI;IAC9D,QAAQ,GAAM,GAAQ,GAAO,GAAM,GAAQ,MACzCC,EAAeH,GAAWC,GAAeC,GAAME,GAAQC,GAAOC,GAAMC,GAAQC,CAAgB;IAC9F,SAAS,GAAM,MAAQC,EAAgBT,GAAWC,GAAeC,GAAMQ,CAAG;GAC5E;GACA,UAAU;IACR,oBAAoBC,EAAQ,2CAA2C;IACvE,YAAYA,EAAQ,mCAAmC;IACvD,cAAcA,EAAQ,qCAAqC;IAC3D,gBAAgBA,EAAQ,uCAAuC;IAC/D,mBAAmBA,EAAQ,0CAA0C;IACrE,6BAA6BA,EAAQ,oDAAoD;GAC3F;GACA;GAGA,gBACEC,EAAY,OAAO,yCAAA,CAAA,MAAA,MAAA,kBAAAC,EAAA,OAAA,CAAA,GAAUpB,GAAmB,6BAA6BA,EAAkB,KAAK,CAAC,CAAC,MACnG,MAAUqB,EAAM,QAAQ,WAAW,CACtC;GACF,WAAW;GACX;EACF;CACF;AACF;AAGA,SAAgBC,EAAqB,GASR;CAC3B,OAAO;GACJrB,IAAa;GACbC,IAAsB;GACrB,UAAUqB,EAAI;GACd,UAAUA,EAAI;GACd,YAAYA,EAAI;GAChB,gBAAgBA,EAAI,SAAS;GAC7B,WAAW;GACX,YAAY;EACd;CACF;AACF"}

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

@@ -0,0 +1,30 @@
+export type UploadPollMode = 'dense' | 'sparse';
+export interface UploadPollModeSchedule {
+    /** The ages of the youngest row at which it is read. */
+    marksMs: number[];
+    /** After the last mark: up to the age `untilMs`, every `everyMs`. */
+    tiers: Array<{
+        untilMs: number;
+        everyMs: number;
+    }>;
+    tailEveryMs: number;
+}
+export declare const UPLOAD_POLL_SCHEDULE: Record<UploadPollMode, UploadPollModeSchedule>;
+/** Between two automatic reads of one queue. */
+export declare const UPLOAD_POLL_MIN_GAP_MS: number;
+/** The wait after the first, the second… failed read in a row; the last one for every further. */
+export declare const UPLOAD_POLL_ERROR_LADDER_MS: number[];
+/** The age of a row at which it says its processing takes too long. */
+export declare const UPLOAD_POLL_SLOW_TEXT_AFTER_MS: number;
+/** Reads in a row without the asset of a row, after which the row fails. */
+export declare const UPLOAD_POLL_MISSING_LIMIT = 3;
+/** Failed reads in a row, after which the row warns. */
+export declare const UPLOAD_POLL_READ_FAILURE_LIMIT = 3;
+/** Notifications about the file of one asset within this window are one read. */
+export declare const UPLOAD_NOTIFY_FILE_DELAY_MS = 250;
+/** The backend can send the metadata notification before its transaction is committed. */
+export declare const UPLOAD_NOTIFY_METADATA_DELAY_MS: number;
+export declare const UPLOAD_READ_BATCH_LIMIT = 50;
+export declare const firstDelay: (mode: UploadPollMode) => number;
+/** The wait for the next read when the youngest row is `ageMs` old. */
+export declare function delayAfterRead(ageMs: number, mode: UploadPollMode): number;

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

@@ -0,0 +1,68 @@
+//#region src/domains/dam/uploadQueue/settlement/uploadPollSchedule.ts
+var e = 1e3, t = 60 * e, n = {
+	dense: {
+		marksMs: [
+			5,
+			10,
+			16,
+			23,
+			31,
+			40,
+			50,
+			60
+		].map((t) => t * e),
+		tiers: [
+			{
+				untilMs: 5 * t,
+				everyMs: 30 * e
+			},
+			{
+				untilMs: 20 * t,
+				everyMs: 1 * t
+			},
+			{
+				untilMs: 60 * t,
+				everyMs: 2 * t
+			}
+		],
+		tailEveryMs: 10 * t
+	},
+	sparse: {
+		marksMs: [
+			10,
+			30,
+			60
+		].map((t) => t * e),
+		tiers: [
+			{
+				untilMs: 5 * t,
+				everyMs: 1 * t
+			},
+			{
+				untilMs: 20 * t,
+				everyMs: 3 * t
+			},
+			{
+				untilMs: 60 * t,
+				everyMs: 5 * t
+			}
+		],
+		tailEveryMs: 10 * t
+	}
+}, r = 2 * e, i = [
+	15,
+	30,
+	60,
+	120,
+	300
+].map((t) => t * e), a = 20 * t, o = 2 * e, s = (e) => n[e].marksMs[0];
+function c(e, t) {
+	let r = n[t], i = r.marksMs.find((t) => t > e);
+	if (i !== void 0) return i - e;
+	let a = r.tiers.find((t) => t.untilMs > e);
+	return a ? a.everyMs : r.tailEveryMs;
+}
+//#endregion
+export { o as UPLOAD_NOTIFY_METADATA_DELAY_MS, i as UPLOAD_POLL_ERROR_LADDER_MS, r as UPLOAD_POLL_MIN_GAP_MS, n as UPLOAD_POLL_SCHEDULE, a as UPLOAD_POLL_SLOW_TEXT_AFTER_MS, c as delayAfterRead, s as firstDelay };
+
+//# sourceMappingURL=uploadPollSchedule.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uploadPollSchedule.js","names":["S","MIN","UPLOAD_POLL_SCHEDULE","s","UPLOAD_POLL_MIN_GAP_MS","UPLOAD_POLL_ERROR_LADDER_MS","UPLOAD_POLL_SLOW_TEXT_AFTER_MS","UPLOAD_NOTIFY_METADATA_DELAY_MS","firstDelay","mode","delayAfterRead","schedule","mark","markMs","ageMs","tier","candidate"],"sources":["../../../../../src/domains/dam/uploadQueue/settlement/uploadPollSchedule.ts"],"sourcesContent":["export type UploadPollMode = 'dense' | 'sparse'\n\nexport interface UploadPollModeSchedule {\n  /** The ages of the youngest row at which it is read. */\n  marksMs: number[]\n  /** After the last mark: up to the age `untilMs`, every `everyMs`. */\n  tiers: Array<{ untilMs: number; everyMs: number }>\n  tailEveryMs: number\n}\n\nconst S = 1000\nconst MIN = 60 * S\n\n// `dense`: the poll is the only channel. `sparse`: the notifications are alive, the poll is their backup.\nexport const UPLOAD_POLL_SCHEDULE: Record<UploadPollMode, UploadPollModeSchedule> = {\n  dense: {\n    marksMs: [5, 10, 16, 23, 31, 40, 50, 60].map((s) => s * S),\n    tiers: [\n      { untilMs: 5 * MIN, everyMs: 30 * S },\n      { untilMs: 20 * MIN, everyMs: 1 * MIN },\n      { untilMs: 60 * MIN, everyMs: 2 * MIN },\n    ],\n    tailEveryMs: 10 * MIN,\n  },\n  sparse: {\n    marksMs: [10, 30, 60].map((s) => s * S),\n    tiers: [\n      { untilMs: 5 * MIN, everyMs: 1 * MIN },\n      { untilMs: 20 * MIN, everyMs: 3 * MIN },\n      { untilMs: 60 * MIN, everyMs: 5 * MIN },\n    ],\n    tailEveryMs: 10 * MIN,\n  },\n}\n\n/** Between two automatic reads of one queue. */\nexport const UPLOAD_POLL_MIN_GAP_MS = 2 * S\n/** The wait after the first, the second… failed read in a row; the last one for every further. */\nexport const UPLOAD_POLL_ERROR_LADDER_MS = [15, 30, 60, 120, 300].map((s) => s * S)\n/** The age of a row at which it says its processing takes too long. */\nexport const UPLOAD_POLL_SLOW_TEXT_AFTER_MS = 20 * MIN\n/** Reads in a row without the asset of a row, after which the row fails. */\nexport const UPLOAD_POLL_MISSING_LIMIT = 3\n/** Failed reads in a row, after which the row warns. */\nexport const UPLOAD_POLL_READ_FAILURE_LIMIT = 3\n/** Notifications about the file of one asset within this window are one read. */\nexport const UPLOAD_NOTIFY_FILE_DELAY_MS = 250\n/** The backend can send the metadata notification before its transaction is committed. */\nexport const UPLOAD_NOTIFY_METADATA_DELAY_MS = 2 * S\nexport const UPLOAD_READ_BATCH_LIMIT = 50\n\nexport const firstDelay = (mode: UploadPollMode): number => UPLOAD_POLL_SCHEDULE[mode].marksMs[0]!\n\n/** The wait for the next read when the youngest row is `ageMs` old. */\nexport function delayAfterRead(ageMs: number, mode: UploadPollMode): number {\n  const schedule = UPLOAD_POLL_SCHEDULE[mode]\n  const mark = schedule.marksMs.find((markMs) => markMs > ageMs)\n  if (mark !== undefined) return mark - ageMs\n  const tier = schedule.tiers.find((candidate) => candidate.untilMs > ageMs)\n  return tier ? tier.everyMs : schedule.tailEveryMs\n}\n"],"mappings":";AAUA,IAAMA,IAAI,KACJC,IAAM,KAAKD,GAGJE,IAAuE;CAClF,OAAO;EACL,SAAS;GAAC;GAAG;GAAI;GAAI;GAAI;GAAI;GAAI;GAAI;EAAE,CAAC,CAAC,KAAK,MAAMC,IAAIH,CAAC;EACzD,OAAO;GACL;IAAE,SAAS,IAAIC;IAAK,SAAS,KAAKD;GAAE;GACpC;IAAE,SAAS,KAAKC;IAAK,SAAS,IAAIA;GAAI;GACtC;IAAE,SAAS,KAAKA;IAAK,SAAS,IAAIA;GAAI;EACxC;EACA,aAAa,KAAKA;CACpB;CACA,QAAQ;EACN,SAAS;GAAC;GAAI;GAAI;EAAE,CAAC,CAAC,KAAK,MAAME,IAAIH,CAAC;EACtC,OAAO;GACL;IAAE,SAAS,IAAIC;IAAK,SAAS,IAAIA;GAAI;GACrC;IAAE,SAAS,KAAKA;IAAK,SAAS,IAAIA;GAAI;GACtC;IAAE,SAAS,KAAKA;IAAK,SAAS,IAAIA;GAAI;EACxC;EACA,aAAa,KAAKA;CACpB;AACF,GAGaG,IAAyB,IAAIJ,GAE7BK,IAA8B;CAAC;CAAI;CAAI;CAAI;CAAK;AAAG,CAAC,CAAC,KAAK,MAAMF,IAAIH,CAAC,GAErEM,IAAiC,KAAKL,GAQtCM,IAAkC,IAAIP,GAGtCQ,KAAc,MAAiCN,EAAqBO,EAAK,CAAC,QAAQ;AAG/F,SAAgBC,EAAe,GAAe,GAA8B;CAC1E,IAAMC,IAAWT,EAAqBO,IAChCG,IAAOD,EAAS,QAAQ,MAAM,MAAWE,IAASC,CAAK;CAC7D,IAAIF,MAAS,KAAA,GAAW,OAAOA,IAAOE;CACtC,IAAMC,IAAOJ,EAAS,MAAM,MAAM,MAAcK,EAAU,UAAUF,CAAK;CACzE,OAAOC,IAAOA,EAAK,UAAUJ,EAAS;AACxC"}

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

@@ -0,0 +1,19 @@
+import { UploadPollMode } from './uploadPollSchedule';
+export interface QueuePollerDeps {
+    /** The age of the youngest tracked row of the queue in ms, or `null` when the queue tracks nothing. */
+    youngestAgeMs(): number | null;
+    mode(): UploadPollMode;
+    /** One read of all the tracked rows of the queue. A rejection is a failed read. */
+    read(trigger: 'tick' | 'visible'): Promise<void>;
+}
+export interface QueuePoller {
+    /** A row began to be tracked: the next read comes no later than its first mark. */
+    rowAdded(): void;
+    /** The tab is visible again: a read at once. */
+    readNow(trigger: 'visible'): void;
+    /** The tab was hidden, the mode changed or the queue tracks nothing any more: the timer is set anew. */
+    reschedule(): void;
+    stop(): void;
+}
+/** The timer of the ticks of one queue. What a tick reads is up to `deps.read`. */
+export declare function createQueuePoller(deps: QueuePollerDeps): QueuePoller;

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

@@ -0,0 +1,76 @@
+import { UPLOAD_POLL_ERROR_LADDER_MS as e, UPLOAD_POLL_MIN_GAP_MS as t, delayAfterRead as n, firstDelay as r } from "./uploadPollSchedule.js";
+import { uploadSettlementRuntime as i } from "./uploadSettlementRuntime.js";
+//#region src/domains/dam/uploadQueue/settlement/uploadPoller.ts
+function a(a) {
+	let o = null, s = null, c = !1, l = null, u = !1, d = null, f = 0, p = !1, m = () => i.scheduler, h = (e, t) => e === null ? t : Math.min(e, t), g = () => {
+		s &&= (m().clearTimeout(s.handle), null);
+	}, _ = () => {
+		g(), o = null, l = null, u = !1, f = 0;
+	}, v = () => {
+		g(), !(p || c || o === null) && i.visibility.isVisible() && (s = { handle: m().setTimeout(y, Math.max(0, o - m().now())) });
+	}, y = () => {
+		s = null, !p && (a.youngestAgeMs() === null ? _() : i.visibility.isVisible() && b("tick"));
+	}, b = async (r) => {
+		if (c) {
+			u = !0;
+			return;
+		}
+		g(), o = null, c = !0;
+		let i = !1;
+		try {
+			await a.read(r);
+		} catch {
+			i = !0;
+		}
+		if (c = !1, p) return;
+		let s = m().now();
+		d = s, f = i ? f + 1 : 0;
+		let y = a.youngestAgeMs();
+		if (y === null) {
+			_();
+			return;
+		}
+		let b = i ? s + e[Math.min(f, e.length) - 1] : s + n(y, a.mode()), x = s + t;
+		o = u ? x : Math.max(x, h(l, b)), l = null, u = !1, v();
+	};
+	return {
+		rowAdded: () => {
+			if (p) return;
+			let e = m().now() + r(a.mode());
+			c ? l = h(l, e) : (o = h(o, e), v());
+		},
+		readNow: (e) => {
+			if (p) return;
+			if (c) {
+				u = !0;
+				return;
+			}
+			if (a.youngestAgeMs() === null) {
+				_();
+				return;
+			}
+			let n = m().now();
+			d !== null && n - d < 2e3 ? (o = h(o, d + t), v()) : b(e);
+		},
+		reschedule: () => {
+			if (p || c) return;
+			let e = a.youngestAgeMs();
+			if (e === null) _();
+			else if (!i.visibility.isVisible()) g();
+			else {
+				if (f === 0) {
+					let i = m().now(), s = a.mode(), c = d === null ? null : i - d, l = c === null || e < c ? i - e + r(s) : i - c + Math.max(t, n(e - c, s));
+					o = h(o, Math.max(i, l));
+				}
+				v();
+			}
+		},
+		stop: () => {
+			p = !0, _();
+		}
+	};
+}
+//#endregion
+export { a as createQueuePoller };
+
+//# sourceMappingURL=uploadPoller.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"uploadPoller.js","names":["createQueuePoller","nextAt","timer","inFlight","earlierAt","followUp","lastReadEndedAt","consecutiveFailures","stopped","scheduler","uploadSettlementRuntime","sooner","planned","candidate","disarm","goIdle","arm","onTimer","deps","runRead","failed","trigger","now","age","computed","UPLOAD_POLL_ERROR_LADDER_MS","delayAfterRead","soonest","UPLOAD_POLL_MIN_GAP_MS","firstDelay","mode","sinceRead"],"sources":["../../../../../src/domains/dam/uploadQueue/settlement/uploadPoller.ts"],"sourcesContent":["import {\n  delayAfterRead,\n  firstDelay,\n  UPLOAD_POLL_ERROR_LADDER_MS,\n  UPLOAD_POLL_MIN_GAP_MS,\n  type UploadPollMode,\n} from '@/domains/dam/uploadQueue/settlement/uploadPollSchedule'\nimport { uploadSettlementRuntime } from '@/domains/dam/uploadQueue/settlement/uploadSettlementRuntime'\n\nexport interface QueuePollerDeps {\n  /** The age of the youngest tracked row of the queue in ms, or `null` when the queue tracks nothing. */\n  youngestAgeMs(): number | null\n  mode(): UploadPollMode\n  /** One read of all the tracked rows of the queue. A rejection is a failed read. */\n  read(trigger: 'tick' | 'visible'): Promise<void>\n}\n\nexport interface QueuePoller {\n  /** A row began to be tracked: the next read comes no later than its first mark. */\n  rowAdded(): void\n  /** The tab is visible again: a read at once. */\n  readNow(trigger: 'visible'): void\n  /** The tab was hidden, the mode changed or the queue tracks nothing any more: the timer is set anew. */\n  reschedule(): void\n  stop(): void\n}\n\n/** The timer of the ticks of one queue. What a tick reads is up to `deps.read`. */\nexport function createQueuePoller(deps: QueuePollerDeps): QueuePoller {\n  let nextAt: number | null = null\n  let timer: { handle: unknown } | null = null\n  let inFlight = false\n  // A sooner read asked for while one was on its way.\n  let earlierAt: number | null = null\n  let followUp = false\n  let lastReadEndedAt: number | null = null\n  let consecutiveFailures = 0\n  let stopped = false\n\n  const scheduler = () => uploadSettlementRuntime.scheduler\n  const sooner = (planned: number | null, candidate: number) =>\n    planned === null ? candidate : Math.min(planned, candidate)\n\n  const disarm = () => {\n    if (!timer) return\n    scheduler().clearTimeout(timer.handle)\n    timer = null\n  }\n\n  // The queue tracks nothing: no plan is kept for rows that are gone, and a later failure starts the ladder anew.\n  const goIdle = () => {\n    disarm()\n    nextAt = null\n    earlierAt = null\n    followUp = false\n    consecutiveFailures = 0\n  }\n\n  const arm = () => {\n    disarm()\n    if (stopped || inFlight || nextAt === null) return\n    // A hidden tab reads nothing; the planned time stays for its return.\n    if (!uploadSettlementRuntime.visibility.isVisible()) return\n    timer = { handle: scheduler().setTimeout(onTimer, Math.max(0, nextAt - scheduler().now())) }\n  }\n\n  const onTimer = () => {\n    timer = null\n    if (stopped) return\n    if (deps.youngestAgeMs() === null) {\n      goIdle()\n      return\n    }\n    if (!uploadSettlementRuntime.visibility.isVisible()) return\n    void runRead('tick')\n  }\n\n  const runRead = async (trigger: 'tick' | 'visible') => {\n    if (inFlight) {\n      followUp = true\n      return\n    }\n    disarm()\n    nextAt = null\n    inFlight = true\n    let failed = false\n    try {\n      await deps.read(trigger)\n    } catch {\n      failed = true\n    }\n    inFlight = false\n    if (stopped) return\n    const now = scheduler().now()\n    lastReadEndedAt = now\n    consecutiveFailures = failed ? consecutiveFailures + 1 : 0\n    const age = deps.youngestAgeMs()\n    if (age === null) {\n      goIdle()\n      return\n    }\n    const computed = failed\n      ? now + UPLOAD_POLL_ERROR_LADDER_MS[Math.min(consecutiveFailures, UPLOAD_POLL_ERROR_LADDER_MS.length) - 1]!\n      : now + delayAfterRead(age, deps.mode())\n    const soonest = now + UPLOAD_POLL_MIN_GAP_MS\n    nextAt = followUp ? soonest : Math.max(soonest, sooner(earlierAt, computed))\n    earlierAt = null\n    followUp = false\n    arm()\n  }\n\n  const rowAdded = () => {\n    if (stopped) return\n    const candidate = scheduler().now() + firstDelay(deps.mode())\n    // A new row only ever brings the read closer.\n    if (inFlight) {\n      earlierAt = sooner(earlierAt, candidate)\n      return\n    }\n    nextAt = sooner(nextAt, candidate)\n    arm()\n  }\n\n  const readNow = (trigger: 'visible') => {\n    if (stopped) return\n    if (inFlight) {\n      followUp = true\n      return\n    }\n    if (deps.youngestAgeMs() === null) {\n      goIdle()\n      return\n    }\n    const now = scheduler().now()\n    if (lastReadEndedAt !== null && now - lastReadEndedAt < UPLOAD_POLL_MIN_GAP_MS) {\n      nextAt = sooner(nextAt, lastReadEndedAt + UPLOAD_POLL_MIN_GAP_MS)\n      arm()\n      return\n    }\n    void runRead(trigger)\n  }\n\n  const reschedule = () => {\n    // A read on its way plans the next one itself, with the mode of that moment.\n    if (stopped || inFlight) return\n    // Before the hidden tab: a queue that empties while nobody looks keeps no plan for the return.\n    const age = deps.youngestAgeMs()\n    if (age === null) {\n      goIdle()\n      return\n    }\n    if (!uploadSettlementRuntime.visibility.isVisible()) {\n      disarm()\n      return\n    }\n    // A wait of the error ladder stands: the rhythm of a mode would plan by a read that failed.\n    if (consecutiveFailures === 0) {\n      const now = scheduler().now()\n      const mode = deps.mode()\n      const sinceRead = lastReadEndedAt === null ? null : now - lastReadEndedAt\n      // What would have been planned under the mode of now: by the last read, or by the first mark of a row that\n      // came after it. Never later than what is planned already.\n      const candidate =\n        sinceRead === null || age < sinceRead\n          ? now - age + firstDelay(mode)\n          : now - sinceRead + Math.max(UPLOAD_POLL_MIN_GAP_MS, delayAfterRead(age - sinceRead, mode))\n      nextAt = sooner(nextAt, Math.max(now, candidate))\n    }\n    arm()\n  }\n\n  const stop = () => {\n    stopped = true\n    goIdle()\n  }\n\n  return { rowAdded, readNow, reschedule, stop }\n}\n"],"mappings":"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"}

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

@@ -0,0 +1,122 @@
+import { DocIdNullable } from '../../../../shared/types/common';
+import { AssetDetailItemDto, DamAssetTypeType } from '../../types/Asset';
+import { AssetFile, AssetFileFailReasonType, AssetFileProcessStatusType } from '../../types/AssetFile';
+import { UploadQueue, UploadQueueItem, UploadQueueKey } from '../../types/UploadQueue';
+import { UploadRowRoleType, UploadSettlementProfile, UploadSettlementTarget } from './uploadSettlementTypes';
+export interface UploadTrackState {
+    queueKey: UploadQueueKey;
+    /** When the row began to wait for the server, in the time of the scheduler. */
+    eligibleSince: number;
+    /** The client gave the row up on its finish request; the server may have finished the file all the same. */
+    clientFailed: boolean;
+    /** Successful reads in a row that did not carry the asset of the row, or its file among the slots. */
+    misses: number;
+    /** Failed reads in a row. */
+    readFailures: number;
+    /**
+     * A failed read of the row was written down, or one that found no asset was let be reported, and no read has
+     * brought its asset since: the next ones are not.
+     */
+    reported: boolean;
+}
+export interface UploadRowNotice {
+    /** The row has waited longer than a processing should take. */
+    slow: boolean;
+    /** The reads of the row keep failing. */
+    readWarning: boolean;
+    /** Which of the two the settlement has written into `row.error`. */
+    shown: 'slow' | 'readWarning' | null;
+    /** The text it wrote then. A row whose message is another one by now carries somebody else's error. */
+    text: string | null;
+}
+/** What a read is to do for one target. */
+export interface UploadReadIntent {
+    /** The state an event carried: it stands when the read itself shows no final state. */
+    hint: 'processed' | null;
+    /** When the row settles as processed, load its metadata as well. */
+    metadata: boolean;
+    /** The metadata notification: the metadata may come before the final state. */
+    early: boolean;
+    /** A read that tells a row with `settleOn: 'never'` its file is processed. */
+    seen: boolean;
+}
+/** What the settlement remembers about rows. Every key is `toRaw(row)`. */
+export interface UploadSettleMemory {
+    tracked: WeakMap<UploadQueueItem, UploadTrackState>;
+    /** The last write an event made into the row; a read that started before it is stale. Never cleared. */
+    revision: WeakMap<UploadQueueItem, number>;
+    metadataLoaded: WeakSet<UploadQueueItem>;
+    /** Failed rows an event has brought back: their next read loads the metadata. */
+    reviveWithMetadata: WeakSet<UploadQueueItem>;
+    /** Failed rows a refresh may still change: given up by the client and asked about, or left without their original. */
+    refreshMayHelp: WeakSet<UploadQueueItem>;
+    /** Rows failed by the read that was one too many to find no asset, as long as the server settles them by nothing else. */
+    givenUpMissing: WeakSet<UploadQueueItem>;
+    notices: WeakMap<UploadQueueItem, UploadRowNotice>;
+    /** One counter for the revisions and the starts of the reads. */
+    clock: number;
+}
+export declare const createUploadSettleMemory: () => UploadSettleMemory;
+export interface UploadSettleRow {
+    queueKey: UploadQueueKey;
+    queue: UploadQueue;
+    row: UploadQueueItem;
+}
+export interface UploadSettleOptions {
+    /** A row stopped being tracked, by a write or by the store. */
+    onUntrack?(queueKey: UploadQueueKey): void;
+    /** The settlement was disposed of: what a read of an original brings after that is written nowhere. */
+    isDisposed?(): boolean;
+}
+export declare const isFinalFileStatus: (status: AssetFileProcessStatusType | null | undefined) => status is "processed" | "duplicate" | "failed";
+/**
+ * The state a read gives the file of the target. An asset carries the state of its main file alone: a final state
+ * it shows stands, otherwise the state the event carried, when it carried one. Of another file (a slot beside the
+ * main one) the asset says nothing, and only what the event carried stands.
+ */
+export declare const resolveReadStatus: (asset: AssetDetailItemDto, target: Pick<UploadSettlementTarget, "fileId">, intent: Pick<UploadReadIntent, "hint">) => AssetFileProcessStatusType | undefined;
+export declare const clearRowError: (row: UploadQueueItem) => void;
+export declare const isEmptyMetadataValue: (value: unknown) => boolean;
+/**
+ * The first load of the metadata of a row. What the user has put into the row before it (a mass operation of the
+ * queue) stays: only the empty lists and the empty custom fields are filled.
+ */
+export declare function mergeLoadedMetadata(queue: UploadQueue, row: UploadQueueItem, asset: AssetDetailItemDto, caches: Pick<UploadSettlementProfile['caches'], 'addAuthors' | 'addKeywords'>): void;
+/**
+ * What a read asset gives a row without a change of its state. `hadMetadata`: the metadata of the row was loaded
+ * once, whether or not it has its form now.
+ */
+export declare function decorateRow(row: UploadQueueItem, asset: AssetDetailItemDto, mainFile: AssetFile, role: UploadRowRoleType, hadMetadata: boolean): void;
+/**
+ * The writes of the settlement: a read asset or a known state into the rows of the queues. No timers and no reads
+ * of its own, but for the original of a duplicate.
+ */
+export declare function createUploadSettle(profile: UploadSettlementProfile, memory?: UploadSettleMemory, options?: UploadSettleOptions): {
+    memory: UploadSettleMemory;
+    policyOf: (row: UploadQueueItem) => import('./uploadSettlementTypes').UploadSettlePolicy;
+    concerns: (queueKey: UploadQueueKey, row: UploadQueueItem, target: UploadSettlementTarget, purpose: "settle" | "decorate" | "metadata") => boolean;
+    byConfiguration: (target: UploadSettlementTarget) => UploadSettlementTarget[];
+    fetchNames: () => void;
+    rows: () => UploadSettleRow[];
+    isLive: (row: UploadQueueItem) => boolean;
+    bump: (row: UploadQueueItem) => number;
+    isStale: (row: UploadQueueItem, startedAt: number) => boolean;
+    startRead: () => number;
+    trackStateOf: (row: UploadQueueItem) => UploadTrackState | undefined;
+    untrack: (row: UploadQueueItem) => void;
+    setRefreshMayHelp: (queueKey: UploadQueueKey, row: UploadQueueItem, mayHelp: boolean) => void;
+    noticeOf: (row: UploadQueueItem) => UploadRowNotice;
+    syncNotice: (row: UploadQueueItem, { clear }?: {
+        clear?: boolean;
+    }) => void;
+    applyAssetRead: (asset: AssetDetailItemDto, target: UploadSettlementTarget, intent: UploadReadIntent, startedAt: number) => Promise<boolean>;
+    settleProcessedByEvent: (target: UploadSettlementTarget) => void;
+    announceProcessed: (target: UploadSettlementTarget) => void;
+    settleFailed: ({ queueKey, row }: Pick<UploadSettleRow, "queueKey" | "row">, failReason: AssetFileFailReasonType) => void;
+    settleKnownFailed: (target: UploadSettlementTarget, failReason: AssetFileFailReasonType) => void;
+    settleDuplicate: (target: UploadSettlementTarget, originFileId: DocIdNullable, assetType: DamAssetTypeType | null, eligible?: (row: UploadQueueItem) => boolean) => Promise<boolean>;
+    settleKnownDuplicate: (target: UploadSettlementTarget, originFileId: DocIdNullable, assetType: DamAssetTypeType | null) => Promise<void>;
+    awaitsMetadata: (row: UploadQueueItem) => boolean;
+    giveUpOnMissing: ({ queueKey, row }: Pick<UploadSettleRow, "queueKey" | "row">) => void;
+};
+export type UploadSettle = ReturnType<typeof createUploadSettle>;