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

package/dist/domains/anzuUser/store/userCrossSystemStore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userCrossSystemStore.js","names":["CrossSystemPhase","BulkAction","BulkOutcome","useUserCrossSystemStore","defineStore","searchTerm","ref","resolvedId","phase","results","identityConflict","bulkRunning","bulkAction","bulkSubjectId","bulkLog","termRejected","resetResults","setResult","system","result","ensureResult","emptyUserSystemAxes","patchAxes","current","setUser","startBulk","action","subjectId","queued","systems","kept","entry","setBulkEntry","index","i","old","finishBulk","reset"],"sources":["../../../../src/domains/anzuUser/store/userCrossSystemStore.ts"],"sourcesContent":["import { acceptHMRUpdate, defineStore } from 'pinia'\nimport { ref } from 'vue'\nimport { emptyUserSystemAxes, type UserSystemAxes } from '@/domains/anzuUser/utils/userSystemState'\nimport type { AnzuUser } from '@/shared/types/AnzuUser'\nimport type { IntegerId, IntegerIdNullable } from '@/shared/types/common'\n\nexport interface UserSystemResult {\n  axes: UserSystemAxes\n  user: AnzuUser | null\n}\n\nexport const CrossSystemPhase = {\n  Idle: 'idle',\n  /** First round of an e-mail search: find the person and their id. */\n  MatchingEmail: 'matchingEmail',\n  /** Second round: ask every system by that id, to catch the ones holding a different e-mail. */\n  VerifyingById: 'verifyingById',\n  Done: 'done',\n} as const\nexport type CrossSystemPhaseType = (typeof CrossSystemPhase)[keyof typeof CrossSystemPhase]\n\nexport const BulkAction = {\n  Enable: 'enable',\n  Disable: 'disable',\n  Metadata: 'metadata',\n} as const\nexport type BulkActionType = (typeof BulkAction)[keyof typeof BulkAction]\n\nexport const BulkOutcome = {\n  Pending: 'pending',\n  Running: 'running',\n  Done: 'done',\n  Forbidden: 'forbidden',\n  Unauthenticated: 'unauthenticated',\n  NotFound: 'notFound',\n  Invalid: 'invalid',\n  Unavailable: 'unavailable',\n} as const\nexport type BulkOutcomeType = (typeof BulkOutcome)[keyof typeof BulkOutcome]\n\nexport interface BulkLogEntry {\n  system: string\n  outcome: BulkOutcomeType\n  /**\n   * Which run the line belongs to.\n   *\n   * The log survives a run so that a retry does not erase the systems that succeeded a minute ago,\n   * and the retry button acts on whatever the log calls failed. Without these two fields a failed\n   * metadata write would be retried as a disable, and a previous person's failures would be retried\n   * against the id currently on screen -- neither `setEnabled` nor `writeMetadata` can tell it is\n   * being asked about a different action or a different account.\n   */\n  action: BulkActionType\n  subjectId: IntegerIdNullable\n  detail?: string\n}\n\n/**\n * Search results and the bulk run live here, not inside the dialog's component.\n *\n * The dialog can be closed while the calls are still going -- one dead backend running into its\n * timeout must not lock the screen -- and state owned by the component would be thrown away with\n * it. The results stay on the page either way.\n */\nexport const useUserCrossSystemStore = defineStore('commonAdminUserCrossSystemStore', () => {\n  const searchTerm = ref('')\n  const resolvedId = ref<IntegerIdNullable>(null)\n  const phase = ref<CrossSystemPhaseType>(CrossSystemPhase.Idle)\n  const results = ref(new Map<string, UserSystemResult>())\n\n  /**\n   * The same e-mail answered with two different ids.\n   *\n   * Bulk actions stop when this is set. Picking the first one quietly would have every later\n   * fan-out follow the wrong identity, and since no admin can delete an AnzuUser, anything written\n   * under it stays.\n   */\n  const identityConflict = ref<Map<string, IntegerId> | null>(null)\n\n  const bulkRunning = ref(false)\n  const bulkAction = ref<BulkActionType | null>(null)\n  const bulkSubjectId = ref<IntegerIdNullable>(null)\n  const bulkLog = ref<BulkLogEntry[]>([])\n\n  /** The term was neither an address nor an id, so nothing was asked and there is nothing to show. */\n  const termRejected = ref(false)\n\n  function resetResults() {\n    results.value = new Map()\n    resolvedId.value = null\n    identityConflict.value = null\n    phase.value = CrossSystemPhase.Idle\n    termRejected.value = false\n    // A new search is a new person. Leaving the log behind would put the previous one's failures on\n    // screen under a live retry button, and that retry writes to `resolvedId` -- somebody else by\n    // then.\n    bulkLog.value = []\n    bulkAction.value = null\n    bulkSubjectId.value = null\n  }\n\n  function setResult(system: string, result: UserSystemResult) {\n    results.value.set(system, result)\n  }\n\n  function ensureResult(system: string) {\n    if (!results.value.has(system)) {\n      results.value.set(system, { axes: emptyUserSystemAxes(), user: null })\n    }\n  }\n\n  function patchAxes(system: string, axes: UserSystemAxes) {\n    ensureResult(system)\n    const current = results.value.get(system)!\n    results.value.set(system, { ...current, axes })\n  }\n\n  function setUser(system: string, user: AnzuUser | null) {\n    ensureResult(system)\n    const current = results.value.get(system)!\n    results.value.set(system, { ...current, user })\n  }\n\n  /**\n   * Opens a run over `systems`, keeping what the same run already said about the others.\n   *\n   * The retry is why anything is kept at all: \"try the failed ones again\" runs a subset, and\n   * resetting the whole log would erase the systems that succeeded a minute ago, so a partial\n   * success would read as if it had never happened. What is kept is scoped to this action and this\n   * account, because everything else in the log belongs to a run the operator is no longer looking\n   * at.\n   */\n  function startBulk(action: BulkActionType, systems: string[], subjectId: IntegerIdNullable) {\n    bulkRunning.value = true\n    bulkAction.value = action\n    bulkSubjectId.value = subjectId\n    const queued = new Set(systems)\n    const kept = bulkLog.value.filter(\n      (entry) => entry.action === action && entry.subjectId === subjectId && !queued.has(entry.system)\n    )\n    bulkLog.value = [...kept, ...systems.map((system) => ({ system, outcome: BulkOutcome.Pending, action, subjectId }))]\n  }\n\n  function setBulkEntry(system: string, outcome: BulkOutcomeType, detail?: string) {\n    const index = bulkLog.value.findIndex(\n      (entry) => entry.system === system && entry.action === bulkAction.value && entry.subjectId === bulkSubjectId.value\n    )\n    if (index === -1) return\n    const entry: BulkLogEntry = { ...bulkLog.value[index]!, outcome, detail }\n    bulkLog.value = bulkLog.value.map((old, i) => (i === index ? entry : old))\n  }\n\n  function finishBulk() {\n    bulkRunning.value = false\n  }\n\n  /**\n   * What leaving the page does: nobody on screen for the next visit.\n   *\n   * `resetResults` already drops the log and which run it was for. The lock it deliberately leaves:\n   * a run still writing goes on after the page is gone -- `cancel()` stops the probes, not the\n   * writes -- and releasing it would let a second bulk action start against the same account while\n   * the first is unfinished (B13). The run releases it itself when it ends.\n   */\n  function reset() {\n    searchTerm.value = ''\n    resetResults()\n  }\n\n  return {\n    searchTerm,\n    resolvedId,\n    phase,\n    results,\n    identityConflict,\n    bulkRunning,\n    bulkAction,\n    bulkSubjectId,\n    bulkLog,\n    termRejected,\n    resetResults,\n    setResult,\n    patchAxes,\n    setUser,\n    startBulk,\n    setBulkEntry,\n    finishBulk,\n    reset,\n  }\n})\n\nif (import.meta.hot) {\n  import.meta.hot.accept(acceptHMRUpdate(useUserCrossSystemStore, import.meta.hot))\n}\n"],"mappings":";;;;AAWA,IAAaA,IAAmB;CAC9B,MAAM;CAEN,eAAe;CAEf,eAAe;CACf,MAAM;AACR,GAGaC,IAAa;CACxB,QAAQ;CACR,SAAS;CACT,UAAU;AACZ,GAGaC,IAAc;CACzB,SAAS;CACT,SAAS;CACT,MAAM;CACN,WAAW;CACX,iBAAiB;CACjB,UAAU;CACV,SAAS;CACT,aAAa;AACf,GA2BaC,IAA0BC,EAAY,yCAAyC;CAC1F,IAAMC,IAAaC,EAAI,EAAE,GACnBC,IAAaD,EAAuB,IAAI,GACxCE,IAAQF,EAA0BN,EAAiB,IAAI,GACvDS,IAAUH,kBAAI,IAAI,IAA8B,CAAC,GASjDI,IAAmBJ,EAAmC,IAAI,GAE1DK,IAAcL,EAAI,EAAK,GACvBM,IAAaN,EAA2B,IAAI,GAC5CO,IAAgBP,EAAuB,IAAI,GAC3CQ,IAAUR,EAAoB,CAAC,CAAC,GAGhCS,IAAeT,EAAI,EAAK;CAE9B,SAASU,IAAe;EAWtB,AAVA,EAAQ,wBAAQ,IAAI,IAAI,GACxB,EAAW,QAAQ,MACnB,EAAiB,QAAQ,MACzB,EAAM,QAAQhB,EAAiB,MAC/B,EAAa,QAAQ,IAIrB,EAAQ,QAAQ,CAAC,GACjB,EAAW,QAAQ,MACnB,EAAc,QAAQ;CACxB;CAEA,SAASiB,EAAU,GAAgB,GAA0B;EAC3D,EAAQ,MAAM,IAAIC,GAAQC,CAAM;CAClC;CAEA,SAASC,EAAa,GAAgB;EACpC,AAAKX,EAAQ,MAAM,IAAIS,CAAM,KAC3BT,EAAQ,MAAM,IAAIS,GAAQ;GAAE,MAAMG,EAAoB;GAAG,MAAM;EAAK,CAAC;CAEzE;CAEA,SAASC,EAAU,GAAgB,GAAsB;EACvD,EAAaJ,CAAM;EACnB,IAAMK,IAAUd,EAAQ,MAAM,IAAIS,CAAM;EACxC,EAAQ,MAAM,IAAIA,GAAQ;GAAE,GAAGK;GAAS;EAAK,CAAC;CAChD;CAEA,SAASC,EAAQ,GAAgB,GAAuB;EACtD,EAAaN,CAAM;EACnB,IAAMK,IAAUd,EAAQ,MAAM,IAAIS,CAAM;EACxC,EAAQ,MAAM,IAAIA,GAAQ;GAAE,GAAGK;GAAS;EAAK,CAAC;CAChD;CAWA,SAASE,EAAU,GAAwB,GAAmB,GAA8B;EAG1F,AAFA,EAAY,QAAQ,IACpB,EAAW,QAAQC,GACnB,EAAc,QAAQC;EACtB,IAAMC,IAAS,IAAI,IAAIC,CAAO,GACxBC,IAAOhB,EAAQ,MAAM,QACxB,MAAUiB,EAAM,WAAWL,KAAUK,EAAM,cAAcJ,KAAa,CAACC,EAAO,IAAIG,EAAM,MAAM,CACjG;EACA,EAAQ,QAAQ,CAAC,GAAGD,GAAM,GAAGD,EAAQ,KAAK,OAAY;GAAE;GAAQ,SAAS3B,EAAY;GAAS;GAAQ;EAAU,EAAE,CAAC;CACrH;CAEA,SAAS8B,EAAa,GAAgB,GAA0B,GAAiB;EAC/E,IAAMC,IAAQnB,EAAQ,MAAM,WACzB,MAAUiB,EAAM,WAAWb,KAAUa,EAAM,WAAWnB,EAAW,SAASmB,EAAM,cAAclB,EAAc,KAC/G;EACA,IAAIoB,MAAU,IAAI;EAClB,IAAMF,IAAsB;GAAE,GAAGjB,EAAQ,MAAMmB;GAAS;GAAS;EAAO;EACxE,EAAQ,QAAQnB,EAAQ,MAAM,KAAK,GAAK,MAAOoB,MAAMD,IAAQF,IAAQI,CAAI;CAC3E;CAEA,SAASC,IAAa;EACpB,EAAY,QAAQ;CACtB;CAUA,SAASC,IAAQ;EAEf,AADA,EAAW,QAAQ,IACnBrB,EAAa;CACf;CAEA,OAAO;EACL;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;AACF,CAAC"}

package/dist/domains/anzuUser/utils/userMetadataDiff.d.ts

@@ -0,0 +1,39 @@
+import { BaseUser } from '../../../shared/types/AnzuUser';
+/**
+ * The six fields the cross-system view compares.
+ *
+ * `email` is in the list and is also the reason the e-mail search runs twice: if a person is
+ * `jozko@sme.sk` in weather and `j.mrkvicka@sme.sk` in blog, a search by e-mail finds weather and
+ * blog answers nothing -- which looks exactly like "no account here". The second round, by the id
+ * the first round found, is what turns that silence into the inconsistency it actually is.
+ */
+export declare const USER_METADATA_FIELDS: readonly ["email", "person.firstName", "person.lastName", "person.fullName", "avatar.color", "avatar.text"];
+export type UserMetadataField = (typeof USER_METADATA_FIELDS)[number];
+export declare const readMetadataField: (user: BaseUser, field: UserMetadataField) => string;
+export declare const writeMetadataField: (user: BaseUser, field: UserMetadataField, value: string) => void;
+export interface MetadataDifference {
+    field: UserMetadataField;
+    /** System to the value it holds, for every system that answered with a record. */
+    values: Map<string, string>;
+}
+/**
+ * Which of the six fields the systems disagree about.
+ *
+ * Blog is compared on `person.*` like everything else, and its own root `firstName`/`lastName`
+ * columns are deliberately left out of this: those are the byline under an article, the blog's slug
+ * and the public API, not back-office metadata. That blog's `person` is empty for most bloggers and
+ * will therefore read as different is correct -- the back-office identity really is unset there,
+ * and the first repair fills it in.
+ */
+export declare const findMetadataDifferences: (records: Map<string, BaseUser>) => MetadataDifference[];
+/**
+ * Which record the repair form is pre-filled from: the first system in the configured order that
+ * has one.
+ *
+ * Never "whichever answered first" -- the fan-out is parallel, so that would be a different answer
+ * on every run. The order is a default rather than a hidden rule: the dialog names the source and
+ * lets it be changed.
+ */
+export declare const pickPrefillSource: (order: string[], records: Map<string, BaseUser>) => string | null;
+/** Systems whose stored value differs from the one about to be written. Nothing else is touched. */
+export declare const systemsNeedingWrite: (target: BaseUser, records: Map<string, BaseUser>, fields?: readonly UserMetadataField[]) => string[];

package/dist/domains/anzuUser/utils/userMetadataDiff.js

@@ -0,0 +1,60 @@
+//#region src/domains/anzuUser/utils/userMetadataDiff.ts
+var e = [
+	"email",
+	"person.firstName",
+	"person.lastName",
+	"person.fullName",
+	"avatar.color",
+	"avatar.text"
+], t = (e, t) => {
+	switch (t) {
+		case "email": return e.email;
+		case "person.firstName": return e.person.firstName;
+		case "person.lastName": return e.person.lastName;
+		case "person.fullName": return e.person.fullName;
+		case "avatar.color": return e.avatar.color;
+		case "avatar.text": return e.avatar.text;
+	}
+}, n = (e, t, n) => {
+	switch (t) {
+		case "email":
+			e.email = n;
+			break;
+		case "person.firstName":
+			e.person.firstName = n;
+			break;
+		case "person.lastName":
+			e.person.lastName = n;
+			break;
+		case "person.fullName":
+			e.person.fullName = n;
+			break;
+		case "avatar.color":
+			e.avatar.color = n;
+			break;
+		case "avatar.text": e.avatar.text = n;
+	}
+}, r = (n) => {
+	let r = [];
+	if (n.size < 2) return r;
+	for (let i of e) {
+		let e = /* @__PURE__ */ new Map();
+		for (let [r, a] of n) e.set(r, t(a, i));
+		new Set(e.values()).size > 1 && r.push({
+			field: i,
+			values: e
+		});
+	}
+	return r;
+}, i = (e, t) => {
+	for (let n of e) if (t.has(n)) return n;
+	return null;
+}, a = (n, r, i = e) => {
+	let a = [];
+	for (let [e, o] of r) i.some((e) => t(o, e) !== t(n, e)) && a.push(e);
+	return a;
+};
+//#endregion
+export { e as USER_METADATA_FIELDS, r as findMetadataDifferences, i as pickPrefillSource, t as readMetadataField, a as systemsNeedingWrite, n as writeMetadataField };
+
+//# sourceMappingURL=userMetadataDiff.js.map

package/dist/domains/anzuUser/utils/userMetadataDiff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userMetadataDiff.js","names":["USER_METADATA_FIELDS","readMetadataField","field","user","writeMetadataField","value","findMetadataDifferences","differences","records","values","system","pickPrefillSource","order","systemsNeedingWrite","systems","fields","target"],"sources":["../../../../src/domains/anzuUser/utils/userMetadataDiff.ts"],"sourcesContent":["import type { BaseUser } from '@/shared/types/AnzuUser'\n\n/**\n * The six fields the cross-system view compares.\n *\n * `email` is in the list and is also the reason the e-mail search runs twice: if a person is\n * `jozko@sme.sk` in weather and `j.mrkvicka@sme.sk` in blog, a search by e-mail finds weather and\n * blog answers nothing -- which looks exactly like \"no account here\". The second round, by the id\n * the first round found, is what turns that silence into the inconsistency it actually is.\n */\nexport const USER_METADATA_FIELDS = [\n  'email',\n  'person.firstName',\n  'person.lastName',\n  'person.fullName',\n  'avatar.color',\n  'avatar.text',\n] as const\n\nexport type UserMetadataField = (typeof USER_METADATA_FIELDS)[number]\n\nexport const readMetadataField = (user: BaseUser, field: UserMetadataField): string => {\n  switch (field) {\n    case 'email':\n      return user.email\n    case 'person.firstName':\n      return user.person.firstName\n    case 'person.lastName':\n      return user.person.lastName\n    case 'person.fullName':\n      return user.person.fullName\n    case 'avatar.color':\n      return user.avatar.color\n    case 'avatar.text':\n      return user.avatar.text\n  }\n}\n\nexport const writeMetadataField = (user: BaseUser, field: UserMetadataField, value: string): void => {\n  switch (field) {\n    case 'email':\n      user.email = value\n      break\n    case 'person.firstName':\n      user.person.firstName = value\n      break\n    case 'person.lastName':\n      user.person.lastName = value\n      break\n    case 'person.fullName':\n      user.person.fullName = value\n      break\n    case 'avatar.color':\n      user.avatar.color = value\n      break\n    case 'avatar.text':\n      user.avatar.text = value\n      break\n  }\n}\n\nexport interface MetadataDifference {\n  field: UserMetadataField\n  /** System to the value it holds, for every system that answered with a record. */\n  values: Map<string, string>\n}\n\n/**\n * Which of the six fields the systems disagree about.\n *\n * Blog is compared on `person.*` like everything else, and its own root `firstName`/`lastName`\n * columns are deliberately left out of this: those are the byline under an article, the blog's slug\n * and the public API, not back-office metadata. That blog's `person` is empty for most bloggers and\n * will therefore read as different is correct -- the back-office identity really is unset there,\n * and the first repair fills it in.\n */\nexport const findMetadataDifferences = (records: Map<string, BaseUser>): MetadataDifference[] => {\n  const differences: MetadataDifference[] = []\n  if (records.size < 2) return differences\n\n  for (const field of USER_METADATA_FIELDS) {\n    const values = new Map<string, string>()\n    for (const [system, user] of records) {\n      values.set(system, readMetadataField(user, field))\n    }\n    const distinct = new Set(values.values())\n    if (distinct.size > 1) differences.push({ field, values })\n  }\n\n  return differences\n}\n\n/**\n * Which record the repair form is pre-filled from: the first system in the configured order that\n * has one.\n *\n * Never \"whichever answered first\" -- the fan-out is parallel, so that would be a different answer\n * on every run. The order is a default rather than a hidden rule: the dialog names the source and\n * lets it be changed.\n */\nexport const pickPrefillSource = (order: string[], records: Map<string, BaseUser>): string | null => {\n  for (const system of order) {\n    if (records.has(system)) return system\n  }\n  return null\n}\n\n/** Systems whose stored value differs from the one about to be written. Nothing else is touched. */\nexport const systemsNeedingWrite = (\n  target: BaseUser,\n  records: Map<string, BaseUser>,\n  fields: readonly UserMetadataField[] = USER_METADATA_FIELDS\n): string[] => {\n  const systems: string[] = []\n  for (const [system, user] of records) {\n    const differs = fields.some((field) => readMetadataField(user, field) !== readMetadataField(target, field))\n    if (differs) systems.push(system)\n  }\n  return systems\n}\n"],"mappings":";AAUA,IAAaA,IAAuB;CAClC;CACA;CACA;CACA;CACA;CACA;AACF,GAIaC,KAAqB,GAAgB,MAAqC;CACrF,QAAQC,GAAR;EACE,KAAK,SACH,OAAOC,EAAK;EACd,KAAK,oBACH,OAAOA,EAAK,OAAO;EACrB,KAAK,mBACH,OAAOA,EAAK,OAAO;EACrB,KAAK,mBACH,OAAOA,EAAK,OAAO;EACrB,KAAK,gBACH,OAAOA,EAAK,OAAO;EACrB,KAAK,eACH,OAAOA,EAAK,OAAO;CACvB;AACF,GAEaC,KAAsB,GAAgB,GAA0B,MAAwB;CACnG,QAAQF,GAAR;EACE,KAAK;GACH,EAAK,QAAQG;GACb;EACF,KAAK;GACH,EAAK,OAAO,YAAYA;GACxB;EACF,KAAK;GACH,EAAK,OAAO,WAAWA;GACvB;EACF,KAAK;GACH,EAAK,OAAO,WAAWA;GACvB;EACF,KAAK;GACH,EAAK,OAAO,QAAQA;GACpB;EACF,KAAK,eACH,EAAK,OAAO,OAAOA;CAEvB;AACF,GAiBaC,KAA2B,MAAyD;CAC/F,IAAMC,IAAoC,CAAC;CAC3C,IAAIC,EAAQ,OAAO,GAAG,OAAOD;CAE7B,KAAK,IAAML,KAASF,GAAsB;EACxC,IAAMS,oBAAS,IAAI,IAAoB;EACvC,KAAK,IAAM,CAACC,GAAQP,MAASK,GAC3B,EAAO,IAAIE,GAAQT,EAAkBE,GAAMD,CAAK,CAAC;EAGnD,AAAI,IADiB,IAAIO,EAAO,OAAO,CACnC,CAAA,CAAS,OAAO,KAAGF,EAAY,KAAK;GAAE;GAAO;EAAO,CAAC;CAC3D;CAEA,OAAOA;AACT,GAUaI,KAAqB,GAAiB,MAAkD;CACnG,KAAK,IAAMD,KAAUE,GACnB,IAAIJ,EAAQ,IAAIE,CAAM,GAAG,OAAOA;CAElC,OAAO;AACT,GAGaG,KACX,GACA,GACA,IAAuCb,MAC1B;CACb,IAAMc,IAAoB,CAAC;CAC3B,KAAK,IAAM,CAACJ,GAAQP,MAASK,GAE3B,AADgBO,EAAO,MAAM,MAAUd,EAAkBE,GAAMD,CAAK,MAAMD,EAAkBe,GAAQd,CAAK,CACrG,KAASY,EAAQ,KAAKJ,CAAM;CAElC,OAAOI;AACT"}

package/dist/domains/anzuUser/utils/userSystemState.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Four independent axes inside, one derived state outside.
+ *
+ * The axes are kept apart because they answer different questions and can move independently: a
+ * system can be loaded and forbidden, or absent and still enabled in configuration. Collapsing
+ * them into one enum early is what made the per-admin prototypes conflate "no access" with "no
+ * account here" -- admin-cms's panel leaves `userExists` at null on any non-404 and offers
+ * "Create" in a system the operator cannot even read.
+ */
+export declare const UserSystemLoad: {
+    readonly Idle: "idle";
+    readonly Loading: "loading";
+    readonly Loaded: "loaded";
+    readonly Error: "error";
+};
+export type UserSystemLoadType = (typeof UserSystemLoad)[keyof typeof UserSystemLoad];
+export declare const UserSystemPresence: {
+    readonly Present: "present";
+    readonly Absent: "absent";
+    readonly Unknown: "unknown";
+};
+export type UserSystemPresenceType = (typeof UserSystemPresence)[keyof typeof UserSystemPresence];
+export declare const UserSystemAccess: {
+    readonly Ok: "ok";
+    readonly Forbidden: "forbidden";
+    readonly Unauthenticated: "unauthenticated";
+    readonly Unavailable: "unavailable";
+    readonly ConfigDisabled: "configDisabled";
+};
+export type UserSystemAccessType = (typeof UserSystemAccess)[keyof typeof UserSystemAccess];
+/**
+ * `enabled` is one of the axes and not a detail: without it the two states the cross-system view
+ * shows most often -- "the account is here and on" versus "here and off" -- cannot be told apart.
+ *
+ * Ownership is deliberately *not* an axis. None of the six visual states below distinguishes it;
+ * it decides which button is drawn, and that is the descriptor's `manage` union.
+ */
+export interface UserSystemAxes {
+    load: UserSystemLoadType;
+    presence: UserSystemPresenceType;
+    access: UserSystemAccessType;
+    enabled: boolean | 'unknown';
+}
+export declare const UserSystemState: {
+    /** Nothing has been asked yet, or the answer is still on its way. */
+    readonly Loading: "loading";
+    readonly Enabled: "enabled";
+    readonly Disabled: "disabled";
+    readonly Absent: "absent";
+    readonly Forbidden: "forbidden";
+    readonly Unavailable: "unavailable";
+    readonly ConfigDisabled: "configDisabled";
+};
+export type UserSystemStateType = (typeof UserSystemState)[keyof typeof UserSystemState];
+export declare const emptyUserSystemAxes: () => UserSystemAxes;
+/**
+ * The single closed function from axes to what is drawn. Order matters: a system switched off in
+ * configuration is reported as such whatever else is known about it, and access is decided before
+ * presence because a forbidden record is not an absent one.
+ */
+export declare const resolveUserSystemState: (axes: UserSystemAxes) => UserSystemStateType;
+/**
+ * How a probe response becomes axes.
+ *
+ * 401 is its own case and it is not a detail. A first 401 is ambiguous -- an expired session looks
+ * exactly like "no account here" -- and since the buttons are gated by this answer alone, showing
+ * an expired token as "no account here" is the one confusion decision 16 forbids. The caller is
+ * expected to have retried through its refresh hook before classifying; what arrives here is the
+ * verdict after that retry.
+ *
+ * 422 deliberately has no case. A detail GET loads the record and returns it; it does not validate
+ * a body. A 422 belongs to the log of writes.
+ */
+export declare const classifyProbeStatus: (status: number | null) => Pick<UserSystemAxes, "presence" | "access">;
+/**
+ * Whether the probe answered authoritatively that nobody is there.
+ *
+ * Creating an account is offered only when every relevant system said so. A record that could not
+ * be read is not a record that does not exist, and since no admin can delete an AnzuUser, a
+ * duplicate identity created on a guess cannot be taken back.
+ */
+export declare const isAuthoritativelyAbsent: (axes: UserSystemAxes) => boolean;
+/** A system a bulk action may act on: it answered, the account is there, and access was granted. */
+export declare const isActionable: (axes: UserSystemAxes) => boolean;

package/dist/domains/anzuUser/utils/userSystemState.js

@@ -0,0 +1,55 @@
+//#region src/domains/anzuUser/utils/userSystemState.ts
+var e = {
+	Idle: "idle",
+	Loading: "loading",
+	Loaded: "loaded",
+	Error: "error"
+}, t = {
+	Present: "present",
+	Absent: "absent",
+	Unknown: "unknown"
+}, n = {
+	Ok: "ok",
+	Forbidden: "forbidden",
+	Unauthenticated: "unauthenticated",
+	Unavailable: "unavailable",
+	ConfigDisabled: "configDisabled"
+}, r = {
+	Loading: "loading",
+	Enabled: "enabled",
+	Disabled: "disabled",
+	Absent: "absent",
+	Forbidden: "forbidden",
+	Unavailable: "unavailable",
+	ConfigDisabled: "configDisabled"
+}, i = () => ({
+	load: e.Idle,
+	presence: t.Unknown,
+	access: n.Ok,
+	enabled: "unknown"
+}), a = (i) => i.access === n.ConfigDisabled ? r.ConfigDisabled : i.access === n.Forbidden ? r.Forbidden : i.access === n.Unauthenticated || i.access === n.Unavailable ? r.Unavailable : i.load === e.Idle || i.load === e.Loading ? r.Loading : i.presence === t.Absent ? r.Absent : i.presence === t.Unknown ? r.Unavailable : i.enabled === !0 ? r.Enabled : r.Disabled, o = (e) => e === null ? {
+	presence: t.Unknown,
+	access: n.Unavailable
+} : e === 404 ? {
+	presence: t.Absent,
+	access: n.Ok
+} : e === 403 ? {
+	presence: t.Unknown,
+	access: n.Forbidden
+} : e === 401 ? {
+	presence: t.Unknown,
+	access: n.Unauthenticated
+} : e >= 500 ? {
+	presence: t.Unknown,
+	access: n.Unavailable
+} : e >= 200 && e < 300 ? {
+	presence: t.Present,
+	access: n.Ok
+} : {
+	presence: t.Unknown,
+	access: n.Unavailable
+}, s = (r) => r.load === e.Loaded && r.presence === t.Absent && r.access === n.Ok, c = (r) => r.load === e.Loaded && r.presence === t.Present && r.access === n.Ok;
+//#endregion
+export { n as UserSystemAccess, e as UserSystemLoad, t as UserSystemPresence, r as UserSystemState, o as classifyProbeStatus, i as emptyUserSystemAxes, c as isActionable, s as isAuthoritativelyAbsent, a as resolveUserSystemState };
+
+//# sourceMappingURL=userSystemState.js.map

package/dist/domains/anzuUser/utils/userSystemState.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userSystemState.js","names":["UserSystemLoad","UserSystemPresence","UserSystemAccess","UserSystemState","emptyUserSystemAxes","resolveUserSystemState","axes","classifyProbeStatus","status","isAuthoritativelyAbsent","isActionable"],"sources":["../../../../src/domains/anzuUser/utils/userSystemState.ts"],"sourcesContent":["/**\n * Four independent axes inside, one derived state outside.\n *\n * The axes are kept apart because they answer different questions and can move independently: a\n * system can be loaded and forbidden, or absent and still enabled in configuration. Collapsing\n * them into one enum early is what made the per-admin prototypes conflate \"no access\" with \"no\n * account here\" -- admin-cms's panel leaves `userExists` at null on any non-404 and offers\n * \"Create\" in a system the operator cannot even read.\n */\nexport const UserSystemLoad = {\n  Idle: 'idle',\n  Loading: 'loading',\n  Loaded: 'loaded',\n  Error: 'error',\n} as const\nexport type UserSystemLoadType = (typeof UserSystemLoad)[keyof typeof UserSystemLoad]\n\nexport const UserSystemPresence = {\n  Present: 'present',\n  Absent: 'absent',\n  Unknown: 'unknown',\n} as const\nexport type UserSystemPresenceType = (typeof UserSystemPresence)[keyof typeof UserSystemPresence]\n\nexport const UserSystemAccess = {\n  Ok: 'ok',\n  Forbidden: 'forbidden',\n  Unauthenticated: 'unauthenticated',\n  Unavailable: 'unavailable',\n  ConfigDisabled: 'configDisabled',\n} as const\nexport type UserSystemAccessType = (typeof UserSystemAccess)[keyof typeof UserSystemAccess]\n\n/**\n * `enabled` is one of the axes and not a detail: without it the two states the cross-system view\n * shows most often -- \"the account is here and on\" versus \"here and off\" -- cannot be told apart.\n *\n * Ownership is deliberately *not* an axis. None of the six visual states below distinguishes it;\n * it decides which button is drawn, and that is the descriptor's `manage` union.\n */\nexport interface UserSystemAxes {\n  load: UserSystemLoadType\n  presence: UserSystemPresenceType\n  access: UserSystemAccessType\n  enabled: boolean | 'unknown'\n}\n\nexport const UserSystemState = {\n  /** Nothing has been asked yet, or the answer is still on its way. */\n  Loading: 'loading',\n  Enabled: 'enabled',\n  Disabled: 'disabled',\n  Absent: 'absent',\n  Forbidden: 'forbidden',\n  Unavailable: 'unavailable',\n  ConfigDisabled: 'configDisabled',\n} as const\nexport type UserSystemStateType = (typeof UserSystemState)[keyof typeof UserSystemState]\n\nexport const emptyUserSystemAxes = (): UserSystemAxes => ({\n  load: UserSystemLoad.Idle,\n  presence: UserSystemPresence.Unknown,\n  access: UserSystemAccess.Ok,\n  enabled: 'unknown',\n})\n\n/**\n * The single closed function from axes to what is drawn. Order matters: a system switched off in\n * configuration is reported as such whatever else is known about it, and access is decided before\n * presence because a forbidden record is not an absent one.\n */\nexport const resolveUserSystemState = (axes: UserSystemAxes): UserSystemStateType => {\n  if (axes.access === UserSystemAccess.ConfigDisabled) return UserSystemState.ConfigDisabled\n  if (axes.access === UserSystemAccess.Forbidden) return UserSystemState.Forbidden\n  if (axes.access === UserSystemAccess.Unauthenticated || axes.access === UserSystemAccess.Unavailable) {\n    return UserSystemState.Unavailable\n  }\n  if (axes.load === UserSystemLoad.Idle || axes.load === UserSystemLoad.Loading) return UserSystemState.Loading\n  if (axes.presence === UserSystemPresence.Absent) return UserSystemState.Absent\n  if (axes.presence === UserSystemPresence.Unknown) return UserSystemState.Unavailable\n  return axes.enabled === true ? UserSystemState.Enabled : UserSystemState.Disabled\n}\n\n/**\n * How a probe response becomes axes.\n *\n * 401 is its own case and it is not a detail. A first 401 is ambiguous -- an expired session looks\n * exactly like \"no account here\" -- and since the buttons are gated by this answer alone, showing\n * an expired token as \"no account here\" is the one confusion decision 16 forbids. The caller is\n * expected to have retried through its refresh hook before classifying; what arrives here is the\n * verdict after that retry.\n *\n * 422 deliberately has no case. A detail GET loads the record and returns it; it does not validate\n * a body. A 422 belongs to the log of writes.\n */\nexport const classifyProbeStatus = (status: number | null): Pick<UserSystemAxes, 'presence' | 'access'> => {\n  if (status === null) {\n    // A timeout, a network failure, or anything that never reached a status.\n    return { presence: UserSystemPresence.Unknown, access: UserSystemAccess.Unavailable }\n  }\n  if (status === 404) return { presence: UserSystemPresence.Absent, access: UserSystemAccess.Ok }\n  if (status === 403) return { presence: UserSystemPresence.Unknown, access: UserSystemAccess.Forbidden }\n  if (status === 401) return { presence: UserSystemPresence.Unknown, access: UserSystemAccess.Unauthenticated }\n  if (status >= 500) return { presence: UserSystemPresence.Unknown, access: UserSystemAccess.Unavailable }\n  if (status >= 200 && status < 300) return { presence: UserSystemPresence.Present, access: UserSystemAccess.Ok }\n  return { presence: UserSystemPresence.Unknown, access: UserSystemAccess.Unavailable }\n}\n\n/**\n * Whether the probe answered authoritatively that nobody is there.\n *\n * Creating an account is offered only when every relevant system said so. A record that could not\n * be read is not a record that does not exist, and since no admin can delete an AnzuUser, a\n * duplicate identity created on a guess cannot be taken back.\n */\nexport const isAuthoritativelyAbsent = (axes: UserSystemAxes): boolean =>\n  axes.load === UserSystemLoad.Loaded &&\n  axes.presence === UserSystemPresence.Absent &&\n  axes.access === UserSystemAccess.Ok\n\n/** A system a bulk action may act on: it answered, the account is there, and access was granted. */\nexport const isActionable = (axes: UserSystemAxes): boolean =>\n  axes.load === UserSystemLoad.Loaded &&\n  axes.presence === UserSystemPresence.Present &&\n  axes.access === UserSystemAccess.Ok\n"],"mappings":";AASA,IAAaA,IAAiB;CAC5B,MAAM;CACN,SAAS;CACT,QAAQ;CACR,OAAO;AACT,GAGaC,IAAqB;CAChC,SAAS;CACT,QAAQ;CACR,SAAS;AACX,GAGaC,IAAmB;CAC9B,IAAI;CACJ,WAAW;CACX,iBAAiB;CACjB,aAAa;CACb,gBAAgB;AAClB,GAiBaC,IAAkB;CAE7B,SAAS;CACT,SAAS;CACT,UAAU;CACV,QAAQ;CACR,WAAW;CACX,aAAa;CACb,gBAAgB;AAClB,GAGaC,WAA6C;CACxD,MAAMJ,EAAe;CACrB,UAAUC,EAAmB;CAC7B,QAAQC,EAAiB;CACzB,SAAS;AACX,IAOaG,KAA0B,MACjCC,EAAK,WAAWJ,EAAiB,iBAAuBC,EAAgB,iBACxEG,EAAK,WAAWJ,EAAiB,YAAkBC,EAAgB,YACnEG,EAAK,WAAWJ,EAAiB,mBAAmBI,EAAK,WAAWJ,EAAiB,cAChFC,EAAgB,cAErBG,EAAK,SAASN,EAAe,QAAQM,EAAK,SAASN,EAAe,UAAgBG,EAAgB,UAClGG,EAAK,aAAaL,EAAmB,SAAeE,EAAgB,SACpEG,EAAK,aAAaL,EAAmB,UAAgBE,EAAgB,cAClEG,EAAK,YAAY,KAAOH,EAAgB,UAAUA,EAAgB,UAe9DI,KAAuB,MAC9BC,MAAW,OAEN;CAAE,UAAUP,EAAmB;CAAS,QAAQC,EAAiB;AAAY,IAElFM,MAAW,MAAY;CAAE,UAAUP,EAAmB;CAAQ,QAAQC,EAAiB;AAAG,IAC1FM,MAAW,MAAY;CAAE,UAAUP,EAAmB;CAAS,QAAQC,EAAiB;AAAU,IAClGM,MAAW,MAAY;CAAE,UAAUP,EAAmB;CAAS,QAAQC,EAAiB;AAAgB,IACxGM,KAAU,MAAY;CAAE,UAAUP,EAAmB;CAAS,QAAQC,EAAiB;AAAY,IACnGM,KAAU,OAAOA,IAAS,MAAY;CAAE,UAAUP,EAAmB;CAAS,QAAQC,EAAiB;AAAG,IACvG;CAAE,UAAUD,EAAmB;CAAS,QAAQC,EAAiB;AAAY,GAUzEO,KAA2B,MACtCH,EAAK,SAASN,EAAe,UAC7BM,EAAK,aAAaL,EAAmB,UACrCK,EAAK,WAAWJ,EAAiB,IAGtBQ,KAAgB,MAC3BJ,EAAK,SAASN,EAAe,UAC7BM,EAAK,aAAaL,EAAmB,WACrCK,EAAK,WAAWJ,EAAiB"}

package/dist/domains/anzuUser/utils/userTabs.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The one tab that is not a system.
+ *
+ * A module of its own because `<script setup>` cannot export, and both the shell and the pages that
+ * read `?tab=` need to name it.
+ */
+export declare const OTHER_SYSTEMS_TAB = "__otherSystems";

package/dist/domains/anzuUser/utils/userTabs.js

@@ -0,0 +1,6 @@
+//#region src/domains/anzuUser/utils/userTabs.ts
+var e = "__otherSystems";
+//#endregion
+export { e as OTHER_SYSTEMS_TAB };
+
+//# sourceMappingURL=userTabs.js.map

package/dist/domains/anzuUser/utils/userTabs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"userTabs.js","names":["OTHER_SYSTEMS_TAB"],"sources":["../../../../src/domains/anzuUser/utils/userTabs.ts"],"sourcesContent":["/**\n * The one tab that is not a system.\n *\n * A module of its own because `<script setup>` cannot export, and both the shell and the pages that\n * read `?tab=` need to name it.\n */\nexport const OTHER_SYSTEMS_TAB = '__otherSystems'\n"],"mappings":";AAMA,IAAaA,IAAoB"}

package/dist/domains/api/composables/defineApiClient.d.ts

@@ -0,0 +1,32 @@
+import { AxiosInstance, AxiosInterceptorManager, AxiosRequestConfig, AxiosResponse, CreateAxiosDefaults, InternalAxiosRequestConfig } from 'axios';
+type RequestUse = Parameters<AxiosInterceptorManager<InternalAxiosRequestConfig>['use']>;
+type ResponseUse = Parameters<AxiosInterceptorManager<AxiosResponse>['use']>;
+export interface ApiClientRequestInterceptor {
+    onFulfilled?: RequestUse[0];
+    onRejected?: RequestUse[1];
+    options?: RequestUse[2];
+}
+export interface ApiClientResponseInterceptor {
+    onFulfilled?: ResponseUse[0];
+    onRejected?: ResponseUse[1];
+}
+export interface ApiClientSetup {
+    /** The instance's defaults; nothing is added to them. */
+    config: CreateAxiosDefaults;
+    request?: ApiClientRequestInterceptor[];
+    response?: ApiClientResponseInterceptor[];
+}
+/**
+ * An admin's axios client: created on the first call, the same instance on every later one, with its
+ * interceptors registered once -- the factories the admins wrote by hand each carried the guard, and
+ * one that registered outside it stacked a copy of every interceptor per call.
+ *
+ * `setup` runs on that first call, not when the module loads, as the guards did: an admin's env config
+ * is empty until it has loaded, and a client's interceptors come from modules in an import cycle with
+ * it (the refresh interceptor calls the auth api, which goes through the client), so at load time they
+ * may not be initialized yet.
+ */
+export declare function defineApiClient(setup: () => ApiClientSetup): () => AxiosInstance;
+/** A `runWhen` that leaves out requests to urls starting with one of `prefixes` (the auth endpoints). */
+export declare const skipUrlPrefixes: (...prefixes: string[]) => (config: AxiosRequestConfig) => boolean;
+export {};

package/dist/domains/api/composables/defineApiClient.js

@@ -0,0 +1,20 @@
+import { isNull as e } from "../../../shared/utils/common.js";
+import t from "axios";
+//#region src/domains/api/composables/defineApiClient.ts
+function n(n) {
+	let r = null;
+	return () => {
+		if (e(r)) {
+			let { config: e, request: i = [], response: a = [] } = n(), o = t.create(e);
+			for (let { onFulfilled: e, onRejected: t, options: n } of i) o.interceptors.request.use(e, t, n);
+			for (let { onFulfilled: e, onRejected: t } of a) o.interceptors.response.use(e, t);
+			r = o;
+		}
+		return r;
+	};
+}
+var r = (...e) => (t) => !e.some((e) => t.url?.startsWith(e) ?? !1);
+//#endregion
+export { n as defineApiClient, r as skipUrlPrefixes };
+
+//# sourceMappingURL=defineApiClient.js.map

package/dist/domains/api/composables/defineApiClient.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defineApiClient.js","names":["axios","defineApiClient","instance","isNull","setup","created","config","request","onFulfilled","onRejected","options","response","skipUrlPrefixes","prefixes","prefix"],"sources":["../../../../src/domains/api/composables/defineApiClient.ts"],"sourcesContent":["import axios, {\n  type AxiosInstance,\n  type AxiosInterceptorManager,\n  type AxiosRequestConfig,\n  type AxiosResponse,\n  type CreateAxiosDefaults,\n  type InternalAxiosRequestConfig,\n} from 'axios'\nimport { isNull } from '@/shared/utils/common'\n\n// axios's own handler types, which it does not export.\ntype RequestUse = Parameters<AxiosInterceptorManager<InternalAxiosRequestConfig>['use']>\ntype ResponseUse = Parameters<AxiosInterceptorManager<AxiosResponse>['use']>\n\nexport interface ApiClientRequestInterceptor {\n  onFulfilled?: RequestUse[0]\n  onRejected?: RequestUse[1]\n  options?: RequestUse[2]\n}\n\nexport interface ApiClientResponseInterceptor {\n  onFulfilled?: ResponseUse[0]\n  onRejected?: ResponseUse[1]\n}\n\nexport interface ApiClientSetup {\n  /** The instance's defaults; nothing is added to them. */\n  config: CreateAxiosDefaults\n  request?: ApiClientRequestInterceptor[]\n  response?: ApiClientResponseInterceptor[]\n}\n\n/**\n * An admin's axios client: created on the first call, the same instance on every later one, with its\n * interceptors registered once -- the factories the admins wrote by hand each carried the guard, and\n * one that registered outside it stacked a copy of every interceptor per call.\n *\n * `setup` runs on that first call, not when the module loads, as the guards did: an admin's env config\n * is empty until it has loaded, and a client's interceptors come from modules in an import cycle with\n * it (the refresh interceptor calls the auth api, which goes through the client), so at load time they\n * may not be initialized yet.\n */\nexport function defineApiClient(setup: () => ApiClientSetup): () => AxiosInstance {\n  let instance: AxiosInstance | null = null\n  return () => {\n    if (isNull(instance)) {\n      const { config, request = [], response = [] } = setup()\n      const created = axios.create(config)\n      for (const { onFulfilled, onRejected, options } of request) {\n        created.interceptors.request.use(onFulfilled, onRejected, options)\n      }\n      for (const { onFulfilled, onRejected } of response) {\n        created.interceptors.response.use(onFulfilled, onRejected)\n      }\n      instance = created\n    }\n    return instance\n  }\n}\n\n/** A `runWhen` that leaves out requests to urls starting with one of `prefixes` (the auth endpoints). */\nexport const skipUrlPrefixes =\n  (...prefixes: string[]) =>\n  (config: AxiosRequestConfig): boolean =>\n    !prefixes.some((prefix) => config.url?.startsWith(prefix) ?? false)\n"],"mappings":";;;AA0CA,SAAgBC,EAAgB,GAAkD;CAChF,IAAIC,IAAiC;CACrC,aAAa;EACX,IAAIC,EAAOD,CAAQ,GAAG;GACpB,IAAM,EAAE,WAAQ,aAAU,CAAC,GAAG,cAAW,CAAC,MAAME,EAAM,GAChDC,IAAUL,EAAM,OAAOM,CAAM;GACnC,KAAK,IAAM,EAAE,gBAAa,eAAY,gBAAaC,GACjD,EAAQ,aAAa,QAAQ,IAAIC,GAAaC,GAAYC,CAAO;GAEnE,KAAK,IAAM,EAAE,gBAAa,mBAAgBC,GACxC,EAAQ,aAAa,SAAS,IAAIH,GAAaC,CAAU;GAE3D,IAAWJ;EACb;EACA,OAAOH;CACT;AACF;AAGA,IAAaU,KACV,GAAGC,OACH,MACC,CAACA,EAAS,MAAM,MAAWP,EAAO,KAAK,WAAWQ,CAAM,KAAK,EAAK"}

package/dist/domains/api/composables/pagination.d.ts

@@ -0,0 +1,23 @@
+import { DatatableSortBy } from '../../filters/datatable/utils/datatableColumns';
+import { SortOrderType } from '../types/SortOrder';
+import { Ref } from 'vue';
+export interface Pagination {
+    sortBy: DatatableSortBy;
+    page: number;
+    rowsPerPage: number;
+    rowsNumber: number;
+    hasNextPage: null | boolean;
+    currentViewCount: number;
+    totalCount: number;
+}
+interface PaginationOptions {
+    rowsPerPage: number;
+}
+export declare function usePagination(sortKey: string | null, sortOrder?: SortOrderType, options?: Partial<PaginationOptions>, externalPaginationRef?: Ref<Pagination>): UsePaginationReturnType;
+interface UsePaginationReturnType {
+    pagination: Ref<Pagination>;
+    setSortBy: (sortBy: DatatableSortBy) => void;
+    setPage: (page: number) => void;
+    incrementPage: () => number;
+}
+export {};

package/dist/domains/api/composables/pagination.js

@@ -0,0 +1,63 @@
+import { isNull as e, isString as t, isUndefined as n } from "../../../shared/utils/common.js";
+import { SortOrder as r } from "../types/SortOrder.js";
+import { ref as i } from "vue";
+//#region src/domains/api/composables/pagination.ts
+var a = () => ({ rowsPerPage: 25 });
+function o(o, s = r.Desc, c = {}, l) {
+	let u = {
+		...a(),
+		...c
+	}, d = l ?? i({
+		sortBy: e(o) ? null : {
+			key: o,
+			order: s
+		},
+		page: 1,
+		rowsPerPage: u.rowsPerPage,
+		rowsNumber: 0,
+		hasNextPage: null,
+		currentViewCount: 0,
+		totalCount: 0
+	});
+	function f(r, i) {
+		if (t(r)) {
+			d.value = {
+				...d.value,
+				sortBy: {
+					key: r,
+					order: i
+				}
+			};
+			return;
+		}
+		let a = r;
+		e(a) || n(a) ? d.value = {
+			...d.value,
+			sortBy: a
+		} : d.value = {
+			...d.value,
+			sortBy: {
+				key: a.key,
+				order: a.order
+			}
+		};
+	}
+	return {
+		pagination: d,
+		setSortBy: f,
+		setPage: (e) => {
+			d.value = {
+				...d.value,
+				page: e
+			};
+		},
+		incrementPage: () => (d.value = {
+			...d.value,
+			page: d.value.page + 1
+		}, d.value.page)
+	};
+}
+//#endregion
+export { o as usePagination };
+
+//# sourceMappingURL=pagination.js.map

package/dist/domains/api/composables/pagination.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pagination.js","names":["createDefaultPaginationOptions","usePagination","SortOrder","mergedOptions","options","pagination","externalPaginationRef","ref","isNull","sortKey","sortOrder","setSortBy","isString","arg1","arg2","sortBy","isUndefined"],"sources":["../../../../src/domains/api/composables/pagination.ts"],"sourcesContent":["import { type DatatableSortBy } from '@/domains/filters/datatable/utils/datatableColumns'\nimport { SortOrder, type SortOrderType } from '@/domains/api/types/SortOrder'\nimport { type Ref, ref } from 'vue'\nimport { isNull, isString, isUndefined } from '@/shared/utils/common'\n\nexport interface Pagination {\n  sortBy: DatatableSortBy\n  page: number\n  rowsPerPage: number\n  rowsNumber: number\n  hasNextPage: null | boolean\n  currentViewCount: number\n  totalCount: number\n}\n\ninterface PaginationOptions {\n  rowsPerPage: number\n}\n\nconst createDefaultPaginationOptions = () => {\n  return {\n    rowsPerPage: 25,\n  }\n}\n\nexport function usePagination(\n  sortKey: string | null,\n  sortOrder: SortOrderType = SortOrder.Desc,\n  options: Partial<PaginationOptions> = {},\n  externalPaginationRef?: Ref<Pagination>\n): UsePaginationReturnType {\n  const mergedOptions = { ...createDefaultPaginationOptions(), ...options }\n\n  const pagination =\n    externalPaginationRef ??\n    ref<Pagination>({\n      sortBy: isNull(sortKey) ? null : { key: sortKey, order: sortOrder },\n      page: 1,\n      rowsPerPage: mergedOptions.rowsPerPage,\n      rowsNumber: 0,\n      hasNextPage: null,\n      currentViewCount: 0,\n      totalCount: 0,\n    })\n\n  /**\n   * Update sorting for the datatable.\n   * Supported call variants:\n   * 1) setSortBy(sortBy: DatatableSortBy) — pass a DatatableSortBy object\n   * 2) setSortBy(sortKey: string, sortOrder: SortOrderType) — pass key and order separately\n   */\n  function setSortBy(sortBy: DatatableSortBy): void\n  function setSortBy(sortKey: string, sortOrder: SortOrderType): void\n  function setSortBy(arg1: DatatableSortBy | string, arg2?: SortOrderType): void {\n    if (isString(arg1)) {\n      pagination.value = {\n        ...pagination.value,\n        sortBy: { key: arg1, order: arg2 as SortOrderType },\n      }\n      return\n    }\n\n    const sortBy = arg1\n    if (isNull(sortBy) || isUndefined(sortBy)) {\n      pagination.value = { ...pagination.value, sortBy }\n      return\n    }\n    pagination.value = { ...pagination.value, sortBy: { key: sortBy.key, order: sortBy.order } }\n  }\n\n  const setPage = (page: number) => {\n    pagination.value = { ...pagination.value, page }\n  }\n\n  const incrementPage = () => {\n    pagination.value = { ...pagination.value, page: pagination.value.page + 1 }\n    return pagination.value.page\n  }\n\n  return {\n    pagination,\n    setSortBy,\n    setPage,\n    incrementPage,\n  }\n}\n\ninterface UsePaginationReturnType {\n  pagination: Ref<Pagination>\n  setSortBy: (sortBy: DatatableSortBy) => void\n  setPage: (page: number) => void\n  incrementPage: () => number\n}\n"],"mappings":";;;;AAmBA,IAAMA,WACG,EACL,aAAa,GACf;AAGF,SAAgBC,EACd,GACA,IAA2BC,EAAU,MACrC,IAAsC,CAAC,GACvC,GACyB;CACzB,IAAMC,IAAgB;EAAE,GAAGH,EAA+B;EAAG,GAAGI;CAAQ,GAElEC,IACJC,KACAC,EAAgB;EACd,QAAQC,EAAOC,CAAO,IAAI,OAAO;GAAE,KAAKA;GAAS,OAAOC;EAAU;EAClE,MAAM;EACN,aAAaP,EAAc;EAC3B,YAAY;EACZ,aAAa;EACb,kBAAkB;EAClB,YAAY;CACd,CAAC;CAUH,SAASQ,EAAU,GAAgC,GAA4B;EAC7E,IAAIC,EAASC,CAAI,GAAG;GAClB,EAAW,QAAQ;IACjB,GAAGR,EAAW;IACd,QAAQ;KAAE,KAAKQ;KAAM,OAAOC;IAAsB;GACpD;GACA;EACF;EAEA,IAAMC,IAASF;EACf,AAAIL,EAAOO,CAAM,KAAKC,EAAYD,CAAM,IACtC,EAAW,QAAQ;GAAE,GAAGV,EAAW;GAAO;EAAO,IAGnD,EAAW,QAAQ;GAAE,GAAGA,EAAW;GAAO,QAAQ;IAAE,KAAKU,EAAO;IAAK,OAAOA,EAAO;GAAM;EAAE;CAC7F;CAWA,OAAO;EACL;EACA;EACA,UAZe,MAAiB;GAChC,EAAW,QAAQ;IAAE,GAAGV,EAAW;IAAO;GAAK;EACjD;EAWE,sBARA,EAAW,QAAQ;GAAE,GAAGA,EAAW;GAAO,MAAMA,EAAW,MAAM,OAAO;EAAE,GACnEA,EAAW,MAAM;CAQ1B;AACF"}

package/dist/domains/api/composables/request.d.ts

@@ -0,0 +1,79 @@
+import { AxiosClientFn } from '../utils/client';
+import { AxiosRequestConfig } from 'axios';
+import { Ref } from 'vue';
+/**
+ * Whether the response carries a body at all.
+ *
+ * `''` is not an empty document, it is what axios hands back when no bytes arrived: its adapter
+ * returns `responseText`, and `transformResponse` only attempts `JSON.parse` when the string is
+ * truthy, so a 204 and a body-less 200 both arrive as `''`. `0` and `false` do parse and are real
+ * values -- reading them as absent is the bug this replaces.
+ *
+ * `null` is treated as absent too. It is distinguishable from `''` at runtime, but nothing can carry
+ * it in the type: the response type excludes `null` so that a command site cannot declare itself as
+ * returning one.
+ */
+export declare const hasBody: (res: {
+    data: unknown;
+}) => boolean;
+/**
+ * Strips what the helper decides from whatever the caller passed as `options`.
+ *
+ * The type says these cannot be set, but a type says nothing at runtime: `data` in particular
+ * survived the spread whenever no body was passed, so a caller could put a body on a GET through
+ * the back door and skip the serialisation with it.
+ */
+declare const HELPER_OWNED: readonly ["method", "url", "data", "signal"];
+export declare const ownedByHelper: <T extends object>(options: T) => Omit<T, (typeof HELPER_OWNED)[number]>;
+/**
+ * The url as axios will actually request it: the client's `baseURL` and default `params`, the
+ * request's own `params`, and whatever `paramsSerializer` renders them.
+ *
+ * Built by axios itself rather than approximated: a url recorded before the call is not the one
+ * that went out, and an approximation renders arrays, nested objects and dates differently from the
+ * wire -- which is worse than no url, because it looks findable and is not. It is handed the same
+ * config the request was given, minus what this helper owns, for the same reason: a call carrying
+ * its own `paramsSerializer` or `baseURL` is asking for a url that the defaults do not produce.
+ *
+ * `undefined` in, `undefined` out: a call that failed before it had a url has none to report, and
+ * asking axios for one would answer with the client's root -- a url that was never requested and
+ * that reads like an endpoint. An empty string is different: that is a call whose url really is the
+ * client root, and it gets rendered.
+ *
+ * Rendered from the config axios actually used whenever there is one: the one it keeps on its own
+ * error, or the one it keeps on the response it did return, which covers the failures the helper
+ * raises itself after reading that response. Both are the request as it went out -- merged, and past
+ * any request interceptor that rewrote the url or the params -- while anything rebuilt here is a
+ * reconstruction, and by the time a failure is described the factory may hand back a different
+ * instance or its defaults may have moved on.
+ *
+ * A config that axios kept is rendered through an instance with no defaults of its own, for that
+ * same reason: `getUri` merges the instance's defaults *under* the config it is given, so rendering
+ * it through the caller's client would let a default added since the request appear in a url that
+ * never carried it. The rebuild is the one case that does want those defaults -- there is no record
+ * of the request to read them from -- so it goes through the client.
+ *
+ * Never throws. It runs on every failure path, inside the catch, so an exception here would replace
+ * the error the caller is waiting for with one about building a diagnostic string -- and a client
+ * without `getUri` (a hand-built stub, a mock) must not turn a mapped failure into a `TypeError`.
+ */
+export declare const requestedUrl: (client: AxiosClientFn, url: string | undefined, options?: AxiosRequestConfig, failure?: unknown, dispatched?: AxiosRequestConfig) => string | undefined;
+export type Abortable = {
+    /** Runs one call with a signal of its own, registered so `abort()` can reach it. */
+    run: <T>(fn: (signal: AbortSignal, generation: number) => Promise<T>, external?: AbortSignal) => Promise<T>;
+    /** Stops every call this instance still has in flight. */
+    abort: () => void;
+    /** The generation a call starts in; a stale one must not write to state the caller can see. */
+    generation: () => number;
+    /** Whether this instance has anything in flight. */
+    loading: Ref<boolean>;
+};
+export type AbortableOptions = {
+    /**
+     * Each call supersedes the one before it. The abort happens before the new call registers, so
+     * "the latest wins" holds by construction rather than by how the two calls happen to interleave.
+     */
+    cancelPrevious?: boolean;
+};
+export declare const createAbortable: (options?: AbortableOptions) => Abortable;
+export {};

package/dist/domains/api/composables/request.js

@@ -0,0 +1,55 @@
+import { isNull as e, isString as t, isUndefined as n } from "../../../shared/utils/common.js";
+import { ref as r } from "vue";
+import i from "axios";
+//#region src/domains/api/composables/request.ts
+var a = (t) => !n(t.data) && !e(t.data) && t.data !== "", o = [
+	"method",
+	"url",
+	"data",
+	"signal"
+], s = (e) => {
+	let t = { ...e };
+	for (let e of o) delete t[e];
+	return t;
+}, c, l = () => c ??= i.create(), u = (e, r, a = {}, o, c) => {
+	if (!n(r)) try {
+		let u = (i.isAxiosError(o) ? o.config : void 0) ?? c, d = n(u) ? e().getUri({
+			...s(a),
+			url: r
+		}) : l().getUri(u);
+		return t(d) ? d : r;
+	} catch {
+		return r;
+	}
+}, d = (e = {}) => {
+	let { cancelPrevious: t = !1 } = e, n = /* @__PURE__ */ new Set(), i = 0, a = r(!1), o = () => {
+		a.value = n.size > 0;
+	}, s = () => {
+		n.forEach((e) => e.abort()), n.clear();
+	};
+	return {
+		run: async (e, r) => {
+			t && s(), i += 1;
+			let a = new AbortController();
+			n.add(a), o();
+			let c = () => a.abort();
+			r && (r.aborted ? a.abort() : r.addEventListener("abort", c, { once: !0 }));
+			try {
+				return await e(a.signal, i);
+			} catch (e) {
+				throw a.abort(), e;
+			} finally {
+				r?.removeEventListener("abort", c), n.delete(a), o();
+			}
+		},
+		abort: () => {
+			i += 1, s(), o();
+		},
+		generation: () => i,
+		loading: a
+	};
+};
+//#endregion
+export { d as createAbortable, a as hasBody, s as ownedByHelper, u as requestedUrl };
+
+//# sourceMappingURL=request.js.map