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

package/dist/domains/system/composables/loginStatus.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"loginStatus.js","names":["LoginState","status","ref","serverTimestamp","localTimeShiftInSeconds","useLoginStatus","to","stringToInt","localTime","localTimeDiff","current","readonly","isNull"],"sources":["../../../../src/domains/system/composables/loginStatus.ts"],"sourcesContent":["import { readonly, ref } from 'vue'\nimport type { RouteLocationNormalized } from 'vue-router'\nimport { isNull } from '@/shared/utils/common'\nimport { stringToInt } from '@/shared/utils/string'\n\nexport const LoginState = {\n  Success: 'success',\n  FailureSsoCommunicationFailed: 'failure-sso-communication',\n  FailureInternalError: 'failure-internal-error',\n  FailureUnauthorized: 'failure-unauthorized',\n} as const\nexport type JobStatusType = (typeof LoginState)[keyof typeof LoginState]\n\nconst status = ref<string | null>(null)\nconst serverTimestamp = ref<number | null>(null)\nexport const localTimeShiftInSeconds = ref<number>(0)\n\nexport function useLoginStatus(to: RouteLocationNormalized) {\n  if (to.query.loginState) {\n    status.value = to.query.loginState.toString()\n    serverTimestamp.value = stringToInt(to.query.timestamp)\n    const localTime = Math.floor(Date.now() / 1000)\n    if (serverTimestamp.value) {\n      const localTimeDiff = serverTimestamp.value - localTime\n      /**\n       * If the server time is ahead of the user’s local time by more than the one-minute grace period,\n       * we need to store that time shift so we can refresh the token sooner. Each login measures it\n       * anew: a shift kept from an earlier one makes a valid JWT look expired.\n       */\n      localTimeShiftInSeconds.value = Math.max(0, localTimeDiff - 60)\n    }\n  } else {\n    status.value = null\n    serverTimestamp.value = null\n  }\n\n  // This navigation's verdict: the start-up reads it after its awaits, when another navigation may have\n  // passed the guard and reset `status`.\n  const current = status.value\n  const isStatusNotDefined = () => isNull(current)\n  const isStatusLoginSuccess = () => current === LoginState.Success\n  const isStatusSsoCommunicationFailure = () => current === LoginState.FailureSsoCommunicationFailed\n  const isStatusInternalErrorFailure = () => current === LoginState.FailureInternalError\n  const isStatusUnauthorized = () => current === LoginState.FailureUnauthorized\n\n  return {\n    status: readonly(status),\n    serverTimestamp: readonly(serverTimestamp),\n    isStatusNotDefined,\n    isStatusLoginSuccess,\n    isStatusSsoCommunicationFailure,\n    isStatusInternalErrorFailure,\n    isStatusUnauthorized,\n  }\n}\n"],"mappings":";;;;AAKA,IAAaA,IAAa;CACxB,SAAS;CACT,+BAA+B;CAC/B,sBAAsB;CACtB,qBAAqB;AACvB,GAGMC,IAASC,EAAmB,IAAI,GAChCC,IAAkBD,EAAmB,IAAI,GAClCE,IAA0BF,EAAY,CAAC;AAEpD,SAAgBG,EAAe,GAA6B;CAC1D,IAAIC,EAAG,MAAM,YAAY;EAEvB,AADA,EAAO,QAAQA,EAAG,MAAM,WAAW,SAAS,GAC5C,EAAgB,QAAQC,EAAYD,EAAG,MAAM,SAAS;EACtD,IAAME,IAAY,KAAK,MAAM,KAAK,IAAI,IAAI,GAAI;EAC9C,IAAIL,EAAgB,OAAO;GACzB,IAAMM,IAAgBN,EAAgB,QAAQK;GAM9C,EAAwB,QAAQ,KAAK,IAAI,GAAGC,IAAgB,EAAE;EAChE;CACF,OAEE,AADA,EAAO,QAAQ,MACf,EAAgB,QAAQ;CAK1B,IAAMC,IAAUT,EAAO;CAOvB,OAAO;EACL,QAAQU,EAASV,CAAM;EACvB,iBAAiBU,EAASR,CAAe;EACzC,0BAT+BS,EAAOF,CAAO;EAU7C,4BATiCA,MAAYV,EAAW;EAUxD,uCAT4CU,MAAYV,EAAW;EAUnE,oCATyCU,MAAYV,EAAW;EAUhE,4BATiCU,MAAYV,EAAW;CAU1D;AACF"}

package/dist/domains/system/composables/navigationError.d.ts

@@ -0,0 +1,24 @@
+import { Router } from 'vue-router';
+export interface NavigationErrorHandlerOptions {
+    /** Runs first on every failure, e.g. to drop an admin's navigation-pending overlay. */
+    onError?: (error: unknown) => void;
+    /**
+     * The very first navigation failed, so nothing but the start-up loader is on screen. Called once per
+     * handler. Without it -- and after it -- the page is reloaded, and the message stays up when that is
+     * not possible.
+     */
+    onFirstNavigationError?: (error: unknown) => void;
+    /**
+     * `false` for an admin whose page holds work a reload would lose (DAM's running uploads): a chunk that
+     * does not load then shows the message instead of reloading. Defaults to `true`.
+     */
+    reloadOnChunkError?: boolean;
+}
+/**
+ * For `router.onError`: a navigation that throws -- a guard raising, a route's chunk that does not
+ * load -- otherwise only reaches the console, and the click does nothing the user can see.
+ *
+ * A chunk that does not load is usually an old tab after a deploy: the page is reloaded, at most
+ * once per 30 s, and gets the new one. Anything else shows "the page could not be opened".
+ */
+export declare const createNavigationErrorHandler: (router: Router, options?: NavigationErrorHandlerOptions) => (error: unknown) => void;

package/dist/domains/system/composables/navigationError.js

@@ -0,0 +1,26 @@
+import { useAlerts as e } from "./alerts.js";
+import { useSentry as t } from "./sentry.js";
+import { requestAppReload as n } from "../systemBar/utils/appReload.js";
+import { START_LOCATION as r } from "vue-router";
+//#region src/domains/system/composables/navigationError.ts
+var i = /Failed to fetch dynamically imported module|Importing a module script failed|error loading dynamically imported module|Unable to preload CSS/i, a = (e) => e instanceof Error && (e.name === "ChunkLoadError" || i.test(e.message)), o = (e, t) => {
+	try {
+		return e?.(t), !0;
+	} catch (e) {
+		return console.error(e), !1;
+	}
+}, s = (i, s = {}) => {
+	let c = !1;
+	return (l) => {
+		if (o(s.onError, l), t("router").logError(l instanceof Error ? l : Error(String(l))), !(s.reloadOnChunkError !== !1 && a(l) && n())) {
+			if (i.currentRoute.value === r) {
+				if (s.onFirstNavigationError && !c && (c = !0, o(s.onFirstNavigationError, l)) || n()) return;
+				e().showErrorT("common.alert.navigationFailed", -1);
+			} else e().showErrorT("common.alert.navigationFailed");
+		}
+	};
+};
+//#endregion
+export { s as createNavigationErrorHandler };
+
+//# sourceMappingURL=navigationError.js.map

package/dist/domains/system/composables/navigationError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigationError.js","names":["CHUNK_LOAD_MESSAGE","isChunkLoadError","error","safely","callback","callbackError","createNavigationErrorHandler","firstNavigationHandled","options","useSentry","requestAppReload","router","START_LOCATION"],"sources":["../../../../src/domains/system/composables/navigationError.ts"],"sourcesContent":["import { START_LOCATION, type Router } from 'vue-router'\nimport { useAlerts } from '@/domains/system/composables/alerts'\nimport { useSentry } from '@/domains/system/composables/sentry'\nimport { requestAppReload } from '@/domains/system/systemBar/utils/appReload'\n\nexport interface NavigationErrorHandlerOptions {\n  /** Runs first on every failure, e.g. to drop an admin's navigation-pending overlay. */\n  onError?: (error: unknown) => void\n  /**\n   * The very first navigation failed, so nothing but the start-up loader is on screen. Called once per\n   * handler. Without it -- and after it -- the page is reloaded, and the message stays up when that is\n   * not possible.\n   */\n  onFirstNavigationError?: (error: unknown) => void\n  /**\n   * `false` for an admin whose page holds work a reload would lose (DAM's running uploads): a chunk that\n   * does not load then shows the message instead of reloading. Defaults to `true`.\n   */\n  reloadOnChunkError?: boolean\n}\n\n// What the browsers say when a route's chunk cannot be fetched (Chromium, Safari, Firefox), and what\n// Vite says when the route's stylesheet, loaded before its code, cannot be.\nconst CHUNK_LOAD_MESSAGE =\n  /Failed to fetch dynamically imported module|Importing a module script failed|error loading dynamically imported module|Unable to preload CSS/i\n\nconst isChunkLoadError = (error: unknown) =>\n  error instanceof Error && (error.name === 'ChunkLoadError' || CHUNK_LOAD_MESSAGE.test(error.message))\n\n// An admin's callback must not throw out of the handler: vue-router would skip the error listeners\n// after this one, `useRecordPage`'s among them.\nconst safely = (callback: ((error: unknown) => void) | undefined, error: unknown): boolean => {\n  try {\n    callback?.(error)\n    return true\n  } catch (callbackError) {\n    console.error(callbackError)\n    return false\n  }\n}\n\n/**\n * For `router.onError`: a navigation that throws -- a guard raising, a route's chunk that does not\n * load -- otherwise only reaches the console, and the click does nothing the user can see.\n *\n * A chunk that does not load is usually an old tab after a deploy: the page is reloaded, at most\n * once per 30 s, and gets the new one. Anything else shows \"the page could not be opened\".\n */\nexport const createNavigationErrorHandler = (router: Router, options: NavigationErrorHandlerOptions = {}) => {\n  // Once: a callback that sends the user to an error page would otherwise be called again when that\n  // page fails as well.\n  let firstNavigationHandled = false\n\n  return (error: unknown) => {\n    safely(options.onError, error)\n    useSentry('router').logError(error instanceof Error ? error : new Error(String(error)))\n\n    if (options.reloadOnChunkError !== false && isChunkLoadError(error) && requestAppReload()) return\n\n    if (router.currentRoute.value === START_LOCATION) {\n      if (options.onFirstNavigationError && !firstNavigationHandled) {\n        firstNavigationHandled = true\n        // One that throws has not left the loader: the reload or the message below still has to.\n        if (safely(options.onFirstNavigationError, error)) return\n      }\n      if (requestAppReload()) return\n      // Nothing but the start-up loader is on screen and the reload was just tried: the message stays.\n      useAlerts().showErrorT('common.alert.navigationFailed', -1)\n      return\n    }\n\n    useAlerts().showErrorT('common.alert.navigationFailed')\n  }\n}\n"],"mappings":";;;;;AAuBA,IAAMA,IACJ,iJAEIC,KAAoB,MACxBC,aAAiB,UAAUA,EAAM,SAAS,oBAAoBF,EAAmB,KAAKE,EAAM,OAAO,IAI/FC,KAAU,GAAkD,MAA4B;CAC5F,IAAI;EAEF,OADAC,IAAWF,CAAK,GACT;CACT,SAASG,GAAe;EAEtB,OADA,QAAQ,MAAMA,CAAa,GACpB;CACT;AACF,GASaC,KAAgC,GAAgB,IAAyC,CAAC,MAAM;CAG3G,IAAIC,IAAyB;CAE7B,QAAQ,MAAmB;EAIzB,IAHAJ,EAAOK,EAAQ,SAASN,CAAK,GAC7BO,EAAU,QAAQ,CAAC,CAAC,SAASP,aAAiB,QAAQA,IAAY,MAAM,OAAOA,CAAK,CAAC,CAAC,GAElF,IAAQ,uBAAuB,MAASD,EAAiBC,CAAK,KAAKQ,EAAiB,IAExF;OAAIC,EAAO,aAAa,UAAUC,GAAgB;IAMhD,IALIJ,EAAQ,0BAA0B,CAACD,MACrC,IAAyB,IAErBJ,EAAOK,EAAQ,wBAAwBN,CAAK,MAE9CQ,EAAiB,GAAG;IAExB,EAAU,CAAC,CAAC,WAAW,iCAAiC,EAAE;GAE5D,OAEA,EAAU,CAAC,CAAC,WAAW,+BAA+B;EAFtD;CAGF;AACF"}

package/dist/domains/system/composables/pageNavigation.d.ts

@@ -0,0 +1,28 @@
+import { RouteLocationRaw, Router } from 'vue-router';
+/**
+ * Follows the user's navigation on `router`: whether one is on its way, and which page is shown.
+ *
+ * Register it as the router's first guard. A page that acts after an asynchronous step -- a load, a save, a socket
+ * event -- asks `onPage()` first (`usePageNavigation`): while the user is navigating, or once the user has left, it
+ * does nothing. Its redirect would cancel the user's navigation (in production a page's chunk is fetched on its first
+ * visit), and its message would stay on the page the user went to.
+ *
+ * Returns the unregistration, for tests that create a router each.
+ */
+export declare function trackNavigation(router: Router): () => void;
+export declare const isNavigationPending: (router: Router) => boolean;
+/** Whether the app's router has a navigation of the user's on its way. */
+export declare const isAppNavigationPending: () => boolean;
+export interface UsePageNavigationReturn {
+    /** The user is still on this page and not navigating away from it. */
+    onPage: () => boolean;
+    /** Navigates only `onPage()`. Resolves whether it got there. */
+    push: (to: RouteLocationRaw) => Promise<boolean>;
+    replace: (to: RouteLocationRaw) => Promise<boolean>;
+}
+/**
+ * For a page, or a composable it calls in its setup, that navigates after an asynchronous step: the redirect after a
+ * save, a create or a delete, a load that forwards. The page is the one shown at setup; a later instance of the same
+ * path (A, B, A again) is another page. A composable that is handed its router passes it on.
+ */
+export declare function usePageNavigation(router?: Router | undefined): UsePageNavigationReturn;

package/dist/domains/system/composables/pageNavigation.js

@@ -0,0 +1,40 @@
+import { NavigationFailureType as e, isNavigationFailure as t, useRouter as n } from "vue-router";
+//#region src/domains/system/composables/pageNavigation.ts
+var r = /* @__PURE__ */ new WeakMap(), i;
+function a(n) {
+	if (i = n, r.has(n)) return () => void 0;
+	let a = {
+		pending: !1,
+		pageId: 0
+	};
+	r.set(n, a);
+	let o = n.beforeEach(() => {
+		a.pending = !0;
+	}), s = n.afterEach((n, r, i) => {
+		t(i, e.cancelled) || (a.pending = !1, !i && n.path !== r.path && (a.pageId += 1));
+	}), c = n.onError(() => {
+		a.pending = !1;
+	});
+	return () => {
+		o(), s(), c(), r.delete(n), i === n && (i = void 0);
+	};
+}
+var o = (e) => r.get(e)?.pending === !0, s = () => i !== void 0 && o(i), c = (e) => r.get(e)?.pageId ?? 0;
+function l(e = n()) {
+	if (!e) return {
+		onPage: () => !0,
+		push: async () => !1,
+		replace: async () => !1
+	};
+	a(e);
+	let t = c(e), r = () => !o(e) && c(e) === t, i = (t, n) => r() ? (n ? e.replace(t) : e.push(t)).then((e) => !e) : Promise.resolve(!1);
+	return {
+		onPage: r,
+		push: (e) => i(e, !1),
+		replace: (e) => i(e, !0)
+	};
+}
+//#endregion
+export { s as isAppNavigationPending, o as isNavigationPending, a as trackNavigation, l as usePageNavigation };
+
+//# sourceMappingURL=pageNavigation.js.map

package/dist/domains/system/composables/pageNavigation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pageNavigation.js","names":["states","appRouter","trackNavigation","router","state","removeBeforeEach","removeAfterEach","isNavigationFailure","failure","NavigationFailureType","to","from","removeOnError","isNavigationPending","isAppNavigationPending","pageIdOf","usePageNavigation","useRouter","pageId","onPage","navigate","replace"],"sources":["../../../../src/domains/system/composables/pageNavigation.ts"],"sourcesContent":["import { isNavigationFailure, NavigationFailureType, type RouteLocationRaw, type Router, useRouter } from 'vue-router'\n\ninterface NavigationState {\n  pending: boolean\n  pageId: number\n}\n\nconst states = new WeakMap<Router, NavigationState>()\nlet appRouter: Router | undefined\n\n/**\n * Follows the user's navigation on `router`: whether one is on its way, and which page is shown.\n *\n * Register it as the router's first guard. A page that acts after an asynchronous step -- a load, a save, a socket\n * event -- asks `onPage()` first (`usePageNavigation`): while the user is navigating, or once the user has left, it\n * does nothing. Its redirect would cancel the user's navigation (in production a page's chunk is fetched on its first\n * visit), and its message would stay on the page the user went to.\n *\n * Returns the unregistration, for tests that create a router each.\n */\nexport function trackNavigation(router: Router): () => void {\n  appRouter = router\n  if (states.has(router)) return () => undefined\n  const state: NavigationState = { pending: false, pageId: 0 }\n  states.set(router, state)\n  const removeBeforeEach = router.beforeEach(() => {\n    state.pending = true\n  })\n  const removeAfterEach = router.afterEach((to, from, failure) => {\n    // A newer navigation took its place and is still on its way; it clears the flag itself.\n    if (isNavigationFailure(failure, NavigationFailureType.cancelled)) return\n    state.pending = false\n    // The admins key their RouterView by the path: another path is another page.\n    if (!failure && to.path !== from.path) state.pageId += 1\n  })\n  const removeOnError = router.onError(() => {\n    state.pending = false\n  })\n  return () => {\n    removeBeforeEach()\n    removeAfterEach()\n    removeOnError()\n    states.delete(router)\n    if (appRouter === router) appRouter = undefined\n  }\n}\n\nexport const isNavigationPending = (router: Router): boolean => states.get(router)?.pending === true\n\n/** Whether the app's router has a navigation of the user's on its way. */\nexport const isAppNavigationPending = (): boolean => appRouter !== undefined && isNavigationPending(appRouter)\n\nconst pageIdOf = (router: Router) => states.get(router)?.pageId ?? 0\n\nexport interface UsePageNavigationReturn {\n  /** The user is still on this page and not navigating away from it. */\n  onPage: () => boolean\n  /** Navigates only `onPage()`. Resolves whether it got there. */\n  push: (to: RouteLocationRaw) => Promise<boolean>\n  replace: (to: RouteLocationRaw) => Promise<boolean>\n}\n\n/**\n * For a page, or a composable it calls in its setup, that navigates after an asynchronous step: the redirect after a\n * save, a create or a delete, a load that forwards. The page is the one shown at setup; a later instance of the same\n * path (A, B, A again) is another page. A composable that is handed its router passes it on.\n */\nexport function usePageNavigation(router: Router | undefined = useRouter()): UsePageNavigationReturn {\n  // Without a router (a composable mounted alone in a test) there is nothing to follow, and nothing to navigate.\n  if (!router) return { onPage: () => true, push: async () => false, replace: async () => false }\n  // Registered late if the admin did not register it: it then misses only the guards that run before it.\n  trackNavigation(router)\n  const pageId = pageIdOf(router)\n\n  const onPage = () => !isNavigationPending(router) && pageIdOf(router) === pageId\n\n  // Not async: a location the router refuses to resolve still throws where the caller's try/catch sees it.\n  const navigate = (to: RouteLocationRaw, replace: boolean): Promise<boolean> => {\n    if (!onPage()) return Promise.resolve(false)\n    return (replace ? router.replace(to) : router.push(to)).then((failure) => !failure)\n  }\n\n  return {\n    onPage,\n    push: (to) => navigate(to, false),\n    replace: (to) => navigate(to, true),\n  }\n}\n"],"mappings":";;AAOA,IAAMA,oBAAS,IAAI,QAAiC,GAChDC;AAYJ,SAAgBC,EAAgB,GAA4B;CAE1D,IADA,IAAYC,GACRH,EAAO,IAAIG,CAAM,GAAG,aAAa,KAAA;CACrC,IAAMC,IAAyB;EAAE,SAAS;EAAO,QAAQ;CAAE;CAC3D,EAAO,IAAID,GAAQC,CAAK;CACxB,IAAMC,IAAmBF,EAAO,iBAAiB;EAC/C,EAAM,UAAU;CAClB,CAAC,GACKG,IAAkBH,EAAO,WAAW,GAAI,GAAM,MAAY;EAE9D,AAAII,EAAoBC,GAASC,EAAsB,SAAS,MAChE,EAAM,UAAU,IAEZ,CAACD,KAAWE,EAAG,SAASC,EAAK,SAAM,EAAM,UAAU;CACzD,CAAC,GACKC,IAAgBT,EAAO,cAAc;EACzC,EAAM,UAAU;CAClB,CAAC;CACD,aAAa;EAKX,AAJAE,EAAiB,GACjBC,EAAgB,GAChBM,EAAc,GACdZ,EAAO,OAAOG,CAAM,GAChBF,MAAcE,MAAQ,IAAY,KAAA;CACxC;AACF;AAEA,IAAaU,KAAuB,MAA4Bb,EAAO,IAAIG,CAAM,CAAC,EAAE,YAAY,IAGnFW,UAAwCb,MAAc,KAAA,KAAaY,EAAoBZ,CAAS,GAEvGc,KAAY,MAAmBf,EAAO,IAAIG,CAAM,CAAC,EAAE,UAAU;AAenE,SAAgBa,EAAkB,IAA6BC,EAAU,GAA4B;CAEnG,IAAI,CAACd,GAAQ,OAAO;EAAE,cAAc;EAAM,MAAM,YAAY;EAAO,SAAS,YAAY;CAAM;CAE9F,EAAgBA,CAAM;CACtB,IAAMe,IAASH,EAASZ,CAAM,GAExBgB,UAAe,CAACN,EAAoBV,CAAM,KAAKY,EAASZ,CAAM,MAAMe,GAGpEE,KAAY,GAAsB,MACjCD,EAAO,KACJE,IAAUlB,EAAO,QAAQO,CAAE,IAAIP,EAAO,KAAKO,CAAE,EAAA,CAAG,MAAM,MAAY,CAACF,CAAO,IAD5D,QAAQ,QAAQ,EAAK;CAI7C,OAAO;EACL;EACA,OAAO,MAAOY,EAASV,GAAI,EAAK;EAChC,UAAU,MAAOU,EAASV,GAAI,EAAI;CACpC;AACF"}

package/dist/domains/system/composables/recordActions.d.ts

@@ -0,0 +1,41 @@
+import { Ref } from 'vue';
+/**
+ * The record's get-one for a detail or edit page, in the shape `useRecordPage` reads: raises `loading`, runs `load`
+ * with the page's signal and answers `true` once it resolved, or what `handleRecordLoadError` says after it showed
+ * why it threw: `false` leave the page, `undefined` the request was stopped or the session expired (the page stays).
+ * `loading` goes down unless the load was aborted: the flag belongs to the next page by then.
+ *
+ * Inside `load` a bare `return` means loaded (`true`), not "stay" as in a hand-written loader, and everything thrown
+ * counts as the record failing to load. So only for the record's own single request: a second awaited request, a
+ * secondary request with its own error handling, an early exit meaning "stay", an own alert, an own abort check, an
+ * extra loaded/ready flag or a flag kept in a store stays hand-written.
+ *
+ * ```ts
+ * const fetchData = defineRecordLoader(detailLoading, async (id: IntegerId, signal) => {
+ *   faq.value = await fetchFaq({ urlParams: { id }, signal })
+ * })
+ * ```
+ */
+export declare const defineRecordLoader: <Id>(loading: Ref<boolean>, load: (id: Id, signal: AbortSignal | undefined) => Promise<void>) => (id: Id, options?: {
+    signal?: AbortSignal;
+}) => Promise<boolean | undefined>;
+/**
+ * The save of a create or edit form: raises `loading`, touches `v$` and stops with `showValidationError` when it is
+ * invalid, runs `save`, shows a thrown error with `showErrorsDefault`, lowers `loading`. The success alert and what
+ * follows it (a callback, a route push, closing a dialog) stay in `save`.
+ *
+ * `loading` and `v$` are taken when the save is defined, so both must exist by then. A second validator, a check
+ * before the flag goes up, a second flag, own error handling, work in `finally`, a returned value or a second
+ * request stays hand-written.
+ *
+ * ```ts
+ * const onUpdate = defineRecordSave(saveButtonLoading, v$, async () => {
+ *   faq.value = await updateFaq({ urlParams: { id: faq.value.id }, body: faq.value })
+ *   showRecordWas('updated')
+ * })
+ * ```
+ */
+export declare const defineRecordSave: <Args extends unknown[]>(loading: Ref<boolean>, v$: Ref<{
+    $touch: () => void;
+    $invalid: boolean;
+}>, save: (...args: Args) => Promise<void>) => (...args: Args) => Promise<void>;

package/dist/domains/system/composables/recordActions.js

@@ -0,0 +1,33 @@
+import { useAlerts as e } from "./alerts.js";
+import { handleRecordLoadError as t } from "./recordPage.js";
+//#region src/domains/system/composables/recordActions.ts
+var n = (e, n) => async (r, i = {}) => {
+	e.value = !0;
+	try {
+		return await n(r, i.signal), !0;
+	} catch (e) {
+		return !t(e) && void 0;
+	} finally {
+		i.signal?.aborted || (e.value = !1);
+	}
+}, r = (t, n, r) => {
+	let { showValidationError: i, showErrorsDefault: a } = e();
+	return async (...e) => {
+		t.value = !0;
+		try {
+			if (n.value.$touch(), n.value.$invalid) {
+				i();
+				return;
+			}
+			await r(...e);
+		} catch (e) {
+			a(e);
+		} finally {
+			t.value = !1;
+		}
+	};
+};
+//#endregion
+export { n as defineRecordLoader, r as defineRecordSave };
+
+//# sourceMappingURL=recordActions.js.map

package/dist/domains/system/composables/recordActions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordActions.js","names":["defineRecordLoader","load","id","options","error","defineRecordSave","useAlerts","args","v$","save"],"sources":["../../../../src/domains/system/composables/recordActions.ts"],"sourcesContent":["import type { Ref } from 'vue'\nimport { useAlerts } from '@/domains/system/composables/alerts'\nimport { handleRecordLoadError } from '@/domains/system/composables/recordPage'\n\n/**\n * The record's get-one for a detail or edit page, in the shape `useRecordPage` reads: raises `loading`, runs `load`\n * with the page's signal and answers `true` once it resolved, or what `handleRecordLoadError` says after it showed\n * why it threw: `false` leave the page, `undefined` the request was stopped or the session expired (the page stays).\n * `loading` goes down unless the load was aborted: the flag belongs to the next page by then.\n *\n * Inside `load` a bare `return` means loaded (`true`), not \"stay\" as in a hand-written loader, and everything thrown\n * counts as the record failing to load. So only for the record's own single request: a second awaited request, a\n * secondary request with its own error handling, an early exit meaning \"stay\", an own alert, an own abort check, an\n * extra loaded/ready flag or a flag kept in a store stays hand-written.\n *\n * ```ts\n * const fetchData = defineRecordLoader(detailLoading, async (id: IntegerId, signal) => {\n *   faq.value = await fetchFaq({ urlParams: { id }, signal })\n * })\n * ```\n */\nexport const defineRecordLoader =\n  <Id>(loading: Ref<boolean>, load: (id: Id, signal: AbortSignal | undefined) => Promise<void>) =>\n  async (id: Id, options: { signal?: AbortSignal } = {}): Promise<boolean | undefined> => {\n    loading.value = true\n    try {\n      await load(id, options.signal)\n      return true\n    } catch (error) {\n      return handleRecordLoadError(error) ? false : undefined\n    } finally {\n      if (!options.signal?.aborted) loading.value = false\n    }\n  }\n\n/**\n * The save of a create or edit form: raises `loading`, touches `v$` and stops with `showValidationError` when it is\n * invalid, runs `save`, shows a thrown error with `showErrorsDefault`, lowers `loading`. The success alert and what\n * follows it (a callback, a route push, closing a dialog) stay in `save`.\n *\n * `loading` and `v$` are taken when the save is defined, so both must exist by then. A second validator, a check\n * before the flag goes up, a second flag, own error handling, work in `finally`, a returned value or a second\n * request stays hand-written.\n *\n * ```ts\n * const onUpdate = defineRecordSave(saveButtonLoading, v$, async () => {\n *   faq.value = await updateFaq({ urlParams: { id: faq.value.id }, body: faq.value })\n *   showRecordWas('updated')\n * })\n * ```\n */\nexport const defineRecordSave = <Args extends unknown[]>(\n  loading: Ref<boolean>,\n  v$: Ref<{ $touch: () => void; $invalid: boolean }>,\n  save: (...args: Args) => Promise<void>\n) => {\n  const { showValidationError, showErrorsDefault } = useAlerts()\n  return async (...args: Args): Promise<void> => {\n    loading.value = true\n    try {\n      v$.value.$touch()\n      if (v$.value.$invalid) {\n        showValidationError()\n        return\n      }\n      await save(...args)\n    } catch (error) {\n      showErrorsDefault(error)\n    } finally {\n      loading.value = false\n    }\n  }\n}\n"],"mappings":";;;AAqBA,IAAaA,KACN,GAAuB,MAC5B,OAAO,GAAQ,IAAoC,CAAC,MAAoC;CACtF,EAAQ,QAAQ;CAChB,IAAI;EAEF,OADA,MAAMC,EAAKC,GAAIC,EAAQ,MAAM,GACtB;CACT,SAASC,GAAO;EACd,OAAO,GAAsBA,CAAK,KAAY,KAAA;CAChD,UAAU;EACR,AAAKD,EAAQ,QAAQ,YAAS,EAAQ,QAAQ;CAChD;AACF,GAkBWE,KACX,GACA,GACA,MACG;CACH,IAAM,EAAE,wBAAqB,yBAAsBC,EAAU;CAC7D,OAAO,OAAO,GAAGC,MAA8B;EAC7C,EAAQ,QAAQ;EAChB,IAAI;GAEF,IADAC,EAAG,MAAM,OAAO,GACZA,EAAG,MAAM,UAAU;IACrB,EAAoB;IACpB;GACF;GACA,MAAMC,EAAK,GAAGF,CAAI;EACpB,SAASH,GAAO;GACd,EAAkBA,CAAK;EACzB,UAAU;GACR,EAAQ,QAAQ;EAClB;CACF;AACF"}

package/dist/domains/system/composables/recordPage.d.ts

@@ -0,0 +1,68 @@
+import { Ref } from 'vue';
+import { RouteRecordName } from 'vue-router';
+/**
+ * Shows why a record could not be loaded and says whether its page should leave.
+ *
+ * For the record's own get-one, not for what a page loads around it: a 404 or 403 there means the
+ * record is not there for this user, a 404 of a secondary request does not. A request that was
+ * stopped (the page is gone) and a session found expired (the logout is already loading) show
+ * nothing and do not leave. Everything else -- a 5xx, the network, a timeout, the sign-in server --
+ * shows the message `showErrorsDefault` has for it and leaves too: the page would only show an
+ * empty record with live buttons. While the user is navigating to another page (`trackNavigation`)
+ * it shows nothing, the message would stay there; the page's `leave` then stays put as well.
+ */
+export declare const handleRecordLoadError: (error: unknown, duration?: number) => boolean;
+export interface UseRecordPageOptions {
+    /** Where to go when nothing in the history is a destination: the entity's list. */
+    fallbackRouteName?: RouteRecordName;
+    fallbackRouteParams?: Record<string, any>;
+    /**
+     * What the page gives its Close button: the record's sibling views and the create form. A route
+     * with the record's params is skipped as that record's address only, see `leave`.
+     */
+    skipRouteNames?: RouteRecordName[];
+    /**
+     * The page's loading flag. `leave` holds it up, so the empty record's buttons never show, and the
+     * page lowers it as it unmounts: the flag is often shared by every view of the entity, and the
+     * next one -- a create form that loads nothing -- must not inherit it.
+     */
+    loading?: Ref<boolean>;
+    /**
+     * The record's load, run on mount with the page's signal; `false` from it leaves the page (`leave`), `true` and
+     * `undefined` keep it. A load the page also calls later (a refresh after a save) is fine:
+     * `load: () => getData()`. Leave it out, and write the `onMounted` by hand, when the page acts on the result
+     * otherwise, loads in setup or makes more requests on mount.
+     */
+    load?: (signal: AbortSignal) => Promise<boolean | undefined>;
+}
+export interface UseRecordPageReturn {
+    /** For the record's get-one: stopped when the page unmounts. */
+    signal: AbortSignal;
+    /** Back to where the user came from, else to the fallback. Resolves whether it got there. */
+    leave: () => Promise<boolean>;
+    /** The user is still on this page and not navigating away: for a redirect after the load. */
+    onPage: () => boolean;
+}
+/**
+ * For a detail or edit page: aborts the record's load when the page goes, and leaves the page when
+ * the load fails.
+ *
+ * ```ts
+ * useRecordPage({
+ *   fallbackRouteName: '/x',
+ *   skipRouteNames: [...],
+ *   loading: detailLoading,
+ *   load: (signal) => fetchData(id, { signal }),
+ * })
+ * ```
+ *
+ * `false` from the loader means "leave"; `undefined` is a load that was superseded or stopped on
+ * purpose, after which the page stays. A page that does more with the load writes its own `onMounted`
+ * with the returned `signal` and `leave`, see `load`.
+ *
+ * While the user is navigating to another page (an async guard, a lazy chunk; `trackNavigation`),
+ * the page does not leave: the user's navigation decides, and should it fail, the page stays with
+ * its loading flag up. Not handled: a guard that refuses the step back can leave the address bar out
+ * of step with the router.
+ */
+export declare function useRecordPage(options?: UseRecordPageOptions): UseRecordPageReturn;

package/dist/domains/system/composables/recordPage.js

@@ -0,0 +1,103 @@
+import "../../../shared/statusCodes.js";
+import { isAnzuApiForbiddenError as e } from "../../../shared/error/AnzuApiForbiddenError.js";
+import { isAnzuApiCancelledError as t } from "../../../shared/error/AnzuApiCancelledError.js";
+import { SessionExpiredError as n } from "../../../shared/error/SessionExpiredError.js";
+import { isInCauseChain as r } from "../../../shared/error/isInCauseChain.js";
+import { useAlerts as i } from "./alerts.js";
+import { isAppNavigationPending as a, usePageNavigation as o } from "./pageNavigation.js";
+import { apiErrorStatus as s } from "../../api/utils/apiErrors.js";
+import { forgetLeftAfterFailure as c, isLeftAfterFailureRecently as l, markLeftAfterFailure as u, useRouteHistory as d } from "./routeHistory.js";
+import { useDatatablePageStore as f } from "../store/datatablePageStore.js";
+import { onBeforeUnmount as p, onMounted as m } from "vue";
+import { useRouter as h } from "vue-router";
+//#region src/domains/system/composables/recordPage.ts
+var g = (o, c = -1) => {
+	if (t(o) || r(o, (e) => e instanceof n)) return !1;
+	if (a()) return !0;
+	let { showErrorT: l, showErrorsDefault: u, showUnknownError: d } = i(), f = s(o);
+	return e(o) || f === 403 ? (l("common.alert.recordForbidden", c), !0) : f === 404 ? (l("common.alert.recordNotFound", c), !0) : (u(o, c) || d(c), !0);
+}, _ = (e) => e.split(/[?#]/, 1)[0] ?? e, v = (e) => e.split("#", 1)[0] ?? e, y = /:(\w+)(?:\((?:\\.|[^\\)])*\))?([?*+])?/g, b = (e, t) => {
+	let n = e.getRoutes().find((e) => e.name === t);
+	if (n) return [...n.path.matchAll(y)].map((e) => ({
+		key: e[1],
+		optional: e[2] === "?" || e[2] === "*"
+	}));
+}, x = (e) => new Promise((t) => {
+	let n = (e) => {
+		r(), i(), t(e);
+	}, r = e.afterEach((e, t, r) => n(!r)), i = e.onError(() => n(!1));
+}), S = (e) => e.then((e) => !e, () => !1);
+function C(e = {}) {
+	let t = h(), { history: n } = d(), { preservePageForLanding: r } = f(), { onPage: i } = o(), a = t.currentRoute.value.path;
+	c(a);
+	let s = new AbortController(), g = !1;
+	p(() => {
+		g = !0, s.abort(), e.loading && (e.loading.value = !1);
+	});
+	let y = () => !g && t.currentRoute.value.path === a, C = () => {
+		let n = t.currentRoute.value, r = /* @__PURE__ */ new Set([_(n.fullPath)]), i = /* @__PURE__ */ new Set();
+		for (let a of e.skipRouteNames ?? []) {
+			let e = b(t, a);
+			if (!e) continue;
+			if (e.length === 0 || e.some(({ key: e, optional: t }) => !t && !(e in n.params))) {
+				i.add(a);
+				continue;
+			}
+			let o = Object.fromEntries(e.filter(({ key: e }) => e in n.params).map(({ key: e }) => [e, n.params[e]]));
+			try {
+				r.add(_(t.resolve({
+					name: a,
+					params: o
+				}).fullPath));
+			} catch {
+				i.add(a);
+			}
+		}
+		return {
+			paths: r,
+			names: i
+		};
+	}, w = () => {
+		let { paths: e, names: t } = C();
+		for (let r = n.value.length - 1; r >= 0; r--) {
+			let i = n.value[r];
+			if (!(e.has(_(i.fullPath)) || l(_(i.fullPath))) && !(i.name !== void 0 && i.name !== null && t.has(i.name))) return i.fullPath;
+		}
+	}, T = async (e) => {
+		let n;
+		try {
+			n = t.resolve(e).fullPath;
+		} catch {
+			return !1;
+		}
+		let i = t.options.history.state.back;
+		if (typeof i == "string" && v(i) === v(n)) {
+			let e = x(t);
+			return r(t), t.back(), e;
+		}
+		let a = t.replace(e);
+		return r(t, {
+			to: e,
+			navigation: a
+		}), S(a);
+	}, E = async () => {
+		if (!y() || (e.loading && (e.loading.value = !0), !i())) return !1;
+		u(a);
+		let t = w();
+		return t !== void 0 && await T(t) ? !0 : !y() || !i() || e.fallbackRouteName === void 0 ? !1 : T({
+			name: e.fallbackRouteName,
+			params: e.fallbackRouteParams
+		});
+	}, { load: D } = e;
+	return D && m(async () => {
+		await D(s.signal) === !1 && await E();
+	}), {
+		signal: s.signal,
+		leave: E,
+		onPage: i
+	};
+}
+//#endregion
+export { g as handleRecordLoadError, C as useRecordPage };
+
+//# sourceMappingURL=recordPage.js.map

package/dist/domains/system/composables/recordPage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordPage.js","names":["handleRecordLoadError","isAnzuApiCancelledError","error","isInCauseChain","cause","SessionExpiredError","isAppNavigationPending","useAlerts","status","apiErrorStatus","isAnzuApiForbiddenError","showErrorT","duration","showErrorsDefault","showUnknownError","pathOf","fullPath","withoutHash","PATH_PARAM","paramsOf","record","router","route","name","match","waitForLanding","done","stopAfterEach","stopError","resolve","landed","failure","settled","navigation","useRecordPage","useRouter","useRouteHistory","useDatatablePageStore","usePageNavigation","path","controller","unmounted","options","stillHere","skipped","current","paths","names","declared","optional","key","params","findTarget","i","history","entry","isLeftAfterFailureRecently","go","target","to","back","landing","preservePageForLanding","leave","onPage","load","onMounted"],"sources":["../../../../src/domains/system/composables/recordPage.ts"],"sourcesContent":["import { onBeforeUnmount, onMounted, type Ref } from 'vue'\nimport { type NavigationFailure, type RouteLocationRaw, type RouteRecordName, type Router, useRouter } from 'vue-router'\nimport { useAlerts } from '@/domains/system/composables/alerts'\nimport {\n  forgetLeftAfterFailure,\n  isLeftAfterFailureRecently,\n  markLeftAfterFailure,\n  useRouteHistory,\n} from '@/domains/system/composables/routeHistory'\nimport { useDatatablePageStore } from '@/domains/system/store/datatablePageStore'\nimport { isAppNavigationPending, usePageNavigation } from '@/domains/system/composables/pageNavigation'\nimport { apiErrorStatus } from '@/domains/api/utils/apiErrors'\nimport { isAnzuApiCancelledError } from '@/shared/error/AnzuApiCancelledError'\nimport { isAnzuApiForbiddenError } from '@/shared/error/AnzuApiForbiddenError'\nimport { SessionExpiredError } from '@/shared/error/SessionExpiredError'\nimport { isInCauseChain } from '@/shared/error/isInCauseChain'\nimport { HTTP_STATUS_FORBIDDEN, HTTP_STATUS_NOT_FOUND } from '@/shared/statusCodes'\n\n/**\n * Shows why a record could not be loaded and says whether its page should leave.\n *\n * For the record's own get-one, not for what a page loads around it: a 404 or 403 there means the\n * record is not there for this user, a 404 of a secondary request does not. A request that was\n * stopped (the page is gone) and a session found expired (the logout is already loading) show\n * nothing and do not leave. Everything else -- a 5xx, the network, a timeout, the sign-in server --\n * shows the message `showErrorsDefault` has for it and leaves too: the page would only show an\n * empty record with live buttons. While the user is navigating to another page (`trackNavigation`)\n * it shows nothing, the message would stay there; the page's `leave` then stays put as well.\n */\nexport const handleRecordLoadError = (error: unknown, duration = -1): boolean => {\n  if (isAnzuApiCancelledError(error)) return false\n  if (isInCauseChain(error, (cause) => cause instanceof SessionExpiredError)) return false\n  if (isAppNavigationPending()) return true\n\n  const { showErrorT, showErrorsDefault, showUnknownError } = useAlerts()\n  const status = apiErrorStatus(error)\n  // A rejected 403 is `AnzuApiForbiddenError`, which carries no status; one let through by\n  // `validateStatus` is a response code error that does.\n  if (isAnzuApiForbiddenError(error) || status === HTTP_STATUS_FORBIDDEN) {\n    showErrorT('common.alert.recordForbidden', duration)\n    return true\n  }\n  if (status === HTTP_STATUS_NOT_FOUND) {\n    showErrorT('common.alert.recordNotFound', duration)\n    return true\n  }\n  if (!showErrorsDefault(error, duration)) showUnknownError(duration)\n  return true\n}\n\nexport interface UseRecordPageOptions {\n  /** Where to go when nothing in the history is a destination: the entity's list. */\n  fallbackRouteName?: RouteRecordName\n  fallbackRouteParams?: Record<string, any>\n  /**\n   * What the page gives its Close button: the record's sibling views and the create form. A route\n   * with the record's params is skipped as that record's address only, see `leave`.\n   */\n  skipRouteNames?: RouteRecordName[]\n  /**\n   * The page's loading flag. `leave` holds it up, so the empty record's buttons never show, and the\n   * page lowers it as it unmounts: the flag is often shared by every view of the entity, and the\n   * next one -- a create form that loads nothing -- must not inherit it.\n   */\n  loading?: Ref<boolean>\n  /**\n   * The record's load, run on mount with the page's signal; `false` from it leaves the page (`leave`), `true` and\n   * `undefined` keep it. A load the page also calls later (a refresh after a save) is fine:\n   * `load: () => getData()`. Leave it out, and write the `onMounted` by hand, when the page acts on the result\n   * otherwise, loads in setup or makes more requests on mount.\n   */\n  load?: (signal: AbortSignal) => Promise<boolean | undefined>\n}\n\nexport interface UseRecordPageReturn {\n  /** For the record's get-one: stopped when the page unmounts. */\n  signal: AbortSignal\n  /** Back to where the user came from, else to the fallback. Resolves whether it got there. */\n  leave: () => Promise<boolean>\n  /** The user is still on this page and not navigating away: for a redirect after the load. */\n  onPage: () => boolean\n}\n\nconst pathOf = (fullPath: string) => fullPath.split(/[?#]/, 1)[0] ?? fullPath\nconst withoutHash = (fullPath: string) => fullPath.split('#', 1)[0] ?? fullPath\n\n// A param's name, its custom regex (whose `)` may be escaped) and its modifier: `?` and `*` make it optional.\nconst PATH_PARAM = /:(\\w+)(?:\\((?:\\\\.|[^\\\\)])*\\))?([?*+])?/g\n\nconst paramsOf = (router: Router, name: RouteRecordName) => {\n  const record = router.getRoutes().find((route) => route.name === name)\n  if (!record) return undefined\n  return [...record.path.matchAll(PATH_PARAM)].map((match) => ({\n    key: match[1]!,\n    optional: match[2] === '?' || match[2] === '*',\n  }))\n}\n\n// `router.back()` answers nothing; its landing, or its error, is the answer.\nconst waitForLanding = (router: Router) =>\n  new Promise<boolean>((resolve) => {\n    const done = (landed: boolean) => {\n      stopAfterEach()\n      stopError()\n      resolve(landed)\n    }\n    const stopAfterEach = router.afterEach((_to, _from, failure) => done(!failure))\n    const stopError = router.onError(() => done(false))\n  })\n\nconst settled = (navigation: Promise<NavigationFailure | void | undefined>) =>\n  navigation.then(\n    (failure) => !failure,\n    () => false\n  )\n\n/**\n * For a detail or edit page: aborts the record's load when the page goes, and leaves the page when\n * the load fails.\n *\n * ```ts\n * useRecordPage({\n *   fallbackRouteName: '/x',\n *   skipRouteNames: [...],\n *   loading: detailLoading,\n *   load: (signal) => fetchData(id, { signal }),\n * })\n * ```\n *\n * `false` from the loader means \"leave\"; `undefined` is a load that was superseded or stopped on\n * purpose, after which the page stays. A page that does more with the load writes its own `onMounted`\n * with the returned `signal` and `leave`, see `load`.\n *\n * While the user is navigating to another page (an async guard, a lazy chunk; `trackNavigation`),\n * the page does not leave: the user's navigation decides, and should it fail, the page stays with\n * its loading flag up. Not handled: a guard that refuses the step back can leave the address bar out\n * of step with the router.\n */\nexport function useRecordPage(options: UseRecordPageOptions = {}): UseRecordPageReturn {\n  const router = useRouter()\n  const { history } = useRouteHistory()\n  const { preservePageForLanding } = useDatatablePageStore()\n  const { onPage } = usePageNavigation()\n\n  // The path, not the name: /x/1 and /x/2 share a name, and a late failure of the one must not move\n  // the user off the other.\n  const path = router.currentRoute.value.path\n  // On it again: a failure there before no longer counts.\n  forgetLeftAfterFailure(path)\n  const controller = new AbortController()\n  let unmounted = false\n  onBeforeUnmount(() => {\n    unmounted = true\n    controller.abort()\n    // Raised by `leave`, or left up by the load just aborted, whose `finally` no longer owns it. The\n    // next page mounts after this one is gone and raises it again for its own load.\n    if (options.loading) options.loading.value = false\n  })\n\n  const stillHere = () => !unmounted && router.currentRoute.value.path === path\n\n  // Unlike the Close button, which skips every entry with the record's route name so that closing\n  // one row never opens another, this goes back to the view the user actually came from -- another\n  // record of the same entity included. Only the addresses of THIS record are skipped, compared\n  // without query and hash (a tab in the query is the same view), plus the create form the record\n  // may have been saved from: back there, Save would create a second record.\n  const skipped = () => {\n    const current = router.currentRoute.value\n    const paths = new Set<string>([pathOf(current.fullPath)])\n    const names = new Set<RouteRecordName>()\n    for (const name of options.skipRouteNames ?? []) {\n      const declared = paramsOf(router, name)\n      if (!declared) continue\n      // A route without params is one address; one the record cannot fill is skipped by name.\n      if (declared.length === 0 || declared.some(({ key, optional }) => !optional && !(key in current.params))) {\n        names.add(name)\n        continue\n      }\n      const params = Object.fromEntries(\n        declared.filter(({ key }) => key in current.params).map(({ key }) => [key, current.params[key]])\n      )\n      try {\n        paths.add(pathOf(router.resolve({ name, params }).fullPath))\n      } catch {\n        names.add(name)\n      }\n    }\n    return { paths, names }\n  }\n\n  const findTarget = (): string | undefined => {\n    const { paths, names } = skipped()\n    for (let i = history.value.length - 1; i >= 0; i--) {\n      const entry = history.value[i]!\n      // An address a page just left after a failure is no destination either: two failing records\n      // next to each other in the history -- A, then B, while the backend is down -- would send the\n      // user back and forth for as long as the outage lasts, B leaving to A, which finds B as its\n      // newest entry. Skipped, the chain ends at the list.\n      if (paths.has(pathOf(entry.fullPath)) || isLeftAfterFailureRecently(pathOf(entry.fullPath))) continue\n      if (entry.name !== undefined && entry.name !== null && names.has(entry.name as RouteRecordName)) continue\n      return entry.fullPath\n    }\n    return undefined\n  }\n\n  // Leaves no trace of the failed address: a step back when the target is the entry right before\n  // it, a replace otherwise -- a push would let the browser's Back return to the page that just\n  // failed, which would fail and leave again.\n  const go = async (to: RouteLocationRaw): Promise<boolean> => {\n    let target: string\n    try {\n      target = router.resolve(to).fullPath\n    } catch {\n      return false\n    }\n    // Without the hash: a list's filter writes it under the router, so the record's `state.back`\n    // names the list without it, while the route history has it. The filter also keeps the list\n    // entry's `current` in step, so the step back lands on the filter, and adds no entry.\n    const back = router.options.history.state.back\n    if (typeof back === 'string' && withoutHash(back) === withoutHash(target)) {\n      const landing = waitForLanding(router)\n      preservePageForLanding(router)\n      router.back()\n      return landing\n    }\n    const navigation = router.replace(to)\n    preservePageForLanding(router, { to, navigation })\n    return settled(navigation)\n  }\n\n  const leave = async (): Promise<boolean> => {\n    if (!stillHere()) return false\n    // Held up for good on a leave that fails: the record is not loaded, and its buttons -- Save\n    // creating a new record, Delete with the address's id -- must not come back. The Close button,\n    // which no page ties to loading, is the way out then.\n    if (options.loading) options.loading.value = true\n    // The user is on the way to another page: that navigation decides, ours would cancel it.\n    if (!onPage()) return false\n    markLeftAfterFailure(path)\n    const target = findTarget()\n    if (target !== undefined && (await go(target))) return true\n    if (!stillHere() || !onPage() || options.fallbackRouteName === undefined) return false\n    return go({ name: options.fallbackRouteName, params: options.fallbackRouteParams })\n  }\n\n  const { load } = options\n  if (load) {\n    onMounted(async () => {\n      if ((await load(controller.signal)) === false) await leave()\n    })\n  }\n\n  return { signal: controller.signal, leave, onPage }\n}\n"],"mappings":"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"}

package/dist/domains/system/composables/routeHistory.d.ts

@@ -0,0 +1,38 @@
+import { NavigationFailure, RouteLocationNormalized, RouteLocationRaw, RouteRecordName, RouteRecordNameGeneric, Router } from 'vue-router';
+import { Ref } from 'vue';
+/** A visited route, as far as going back to it needs. */
+export interface RouteHistoryEntry {
+    name: RouteRecordNameGeneric;
+    fullPath: string;
+}
+/** For `useRecordPage` only. */
+export declare const markLeftAfterFailure: (path: string) => void;
+/** For `useRecordPage` only: the page is there again, so a failure before no longer counts. */
+export declare const forgetLeftAfterFailure: (path: string) => void;
+/** For `useRecordPage` only. */
+export declare const isLeftAfterFailureRecently: (path: string) => boolean;
+/** Where `navigateBack` goes and its navigation, as `router.push` answers it. */
+export interface NavigateBackTarget {
+    to: RouteLocationRaw;
+    navigation: Promise<NavigationFailure | void | undefined>;
+}
+export interface NavigateBackOptions {
+    /**
+     * Route names that are not a destination -- typically the sibling views of the record being
+     * closed and the create form it may have been reached from. The CURRENT route is always skipped
+     * on top of these, so there is no need to name it here.
+     */
+    skipRouteNames?: RouteRecordName[];
+    /** Where to go when the walk finds nothing -- a tab opened straight on the record. */
+    fallbackRouteName?: RouteRecordName;
+    fallbackRouteParams?: Record<string, any>;
+}
+export declare function useRouteHistory(): {
+    history: Readonly<Ref<readonly RouteHistoryEntry[]>>;
+    addRoute: (route: RouteLocationNormalized) => void;
+    clearHistory: () => void;
+    setBlacklistedRoutes: (routeNames: RouteRecordName[]) => void;
+    addBlacklistedRoute: (routeName: RouteRecordName) => void;
+    /** Returns where it goes and its navigation, `undefined` for a step back in the browser's history. */
+    navigateBack: (router: Router, options?: NavigateBackOptions) => NavigateBackTarget | undefined;
+};

package/dist/domains/system/composables/routeHistory.js

@@ -0,0 +1,65 @@
+import { readonly as e, ref as t } from "vue";
+//#region src/domains/system/composables/routeHistory.ts
+var n = t([]), r = /* @__PURE__ */ new Map(), i = 6e4, a = (e) => {
+	let t = Date.now();
+	for (let [e, n] of r) t - n >= i && r.delete(e);
+	r.set(e, t);
+}, o = (e) => {
+	r.delete(e);
+}, s = (e) => {
+	let t = r.get(e);
+	return t === void 0 ? !1 : Date.now() - t < i || (r.delete(e), !1);
+}, c = t([]), l = 10;
+function u() {
+	let t = (e) => {
+		if (c.value.includes(e.name)) return;
+		let [t] = e.fullPath.split("#");
+		t === window.location.pathname + window.location.search && e.hash !== window.location.hash && (e = {
+			...e,
+			hash: window.location.hash,
+			fullPath: t + window.location.hash
+		});
+		let r = n.value[n.value.length - 1];
+		r && r.fullPath === e.fullPath || (n.value.push({
+			name: e.name,
+			fullPath: e.fullPath
+		}), n.value.length > l && n.value.shift());
+	}, i = (e) => {
+		c.value = e;
+	}, a = (e) => {
+		c.value.includes(e) || c.value.push(e);
+	}, o = (e) => {
+		for (let t = n.value.length - 1; t >= 0; t--) if (e(n.value[t])) return n.value[t];
+	};
+	return {
+		history: e(n),
+		addRoute: t,
+		clearHistory: () => {
+			n.value = [], r.clear();
+		},
+		setBlacklistedRoutes: i,
+		addBlacklistedRoute: a,
+		navigateBack: (e, t = {}) => {
+			let { skipRouteNames: n, fallbackRouteName: r, fallbackRouteParams: i } = t, a = e.currentRoute.value, s = n ?? [], c = (e) => e.fullPath === a.fullPath || a.name !== void 0 && e.name === a.name, l = o((e) => !c(e) && !s.includes(e.name));
+			if (l) return {
+				to: l.fullPath,
+				navigation: e.push(l.fullPath)
+			};
+			if (r) {
+				let t = {
+					name: r,
+					params: i
+				};
+				return {
+					to: t,
+					navigation: e.push(t)
+				};
+			}
+			e.back();
+		}
+	};
+}
+//#endregion
+export { o as forgetLeftAfterFailure, s as isLeftAfterFailureRecently, a as markLeftAfterFailure, u as useRouteHistory };
+
+//# sourceMappingURL=routeHistory.js.map

package/dist/domains/system/composables/routeHistory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routeHistory.js","names":["history","ref","leftAfterFailure","LEFT_AFTER_FAILURE_MS","markLeftAfterFailure","now","left","at","path","forgetLeftAfterFailure","isLeftAfterFailureRecently","blacklistedRouteNames","MAX_HISTORY","useRouteHistory","addRoute","route","pathAndQuery","lastRoute","setBlacklistedRoutes","routeNames","addBlacklistedRoute","routeName","findRouteBack","i","isDestination","readonly","options","current","router","skip","skipRouteNames","isCurrent","entry","fallbackRouteName","fallback","fallbackRouteParams"],"sources":["../../../../src/domains/system/composables/routeHistory.ts"],"sourcesContent":["import type {\n  NavigationFailure,\n  RouteLocationNormalized,\n  RouteLocationRaw,\n  RouteRecordName,\n  RouteRecordNameGeneric,\n  Router,\n} from 'vue-router'\nimport { readonly, type Ref, ref } from 'vue'\n\n/** A visited route, as far as going back to it needs. */\nexport interface RouteHistoryEntry {\n  name: RouteRecordNameGeneric\n  fullPath: string\n}\n\n// Module state, so the history is one list per document. A test that fills it has to clear it\n// again (`clearHistory`), or the next test in the file reads what the previous one left behind.\nconst history = ref<RouteHistoryEntry[]>([])\n// Paths a record page left because its record failed, with when; read by `useRecordPage`, which\n// skips them as a destination for a while. Here so that `clearHistory` clears it with the history.\nconst leftAfterFailure = new Map<string, number>()\nconst LEFT_AFTER_FAILURE_MS = 60_000\n\n/** For `useRecordPage` only. */\nexport const markLeftAfterFailure = (path: string) => {\n  const now = Date.now()\n  // Expired ones go here too: a path is otherwise only dropped when it is looked up again.\n  for (const [left, at] of leftAfterFailure) if (now - at >= LEFT_AFTER_FAILURE_MS) leftAfterFailure.delete(left)\n  leftAfterFailure.set(path, now)\n}\n\n/** For `useRecordPage` only: the page is there again, so a failure before no longer counts. */\nexport const forgetLeftAfterFailure = (path: string) => {\n  leftAfterFailure.delete(path)\n}\n\n/** For `useRecordPage` only. */\nexport const isLeftAfterFailureRecently = (path: string) => {\n  const at = leftAfterFailure.get(path)\n  if (at === undefined) return false\n  if (Date.now() - at < LEFT_AFTER_FAILURE_MS) return true\n  leftAfterFailure.delete(path)\n  return false\n}\nconst blacklistedRouteNames = ref<RouteRecordName[]>([])\n/**\n * How many routes back the history reaches. Note that `addRoute` drops only CONSECUTIVE duplicates,\n * so a user bouncing A -> B -> A -> B fills four of these slots and can push the listing they want\n * to return to out of the window. `fallbackRouteName` is what catches that.\n */\nconst MAX_HISTORY = 10\n\n/** Where `navigateBack` goes and its navigation, as `router.push` answers it. */\nexport interface NavigateBackTarget {\n  to: RouteLocationRaw\n  navigation: Promise<NavigationFailure | void | undefined>\n}\n\nexport interface NavigateBackOptions {\n  /**\n   * Route names that are not a destination -- typically the sibling views of the record being\n   * closed and the create form it may have been reached from. The CURRENT route is always skipped\n   * on top of these, so there is no need to name it here.\n   */\n  skipRouteNames?: RouteRecordName[]\n  /** Where to go when the walk finds nothing -- a tab opened straight on the record. */\n  fallbackRouteName?: RouteRecordName\n  fallbackRouteParams?: Record<string, any>\n}\n\nexport function useRouteHistory(): {\n  history: Readonly<Ref<readonly RouteHistoryEntry[]>>\n  addRoute: (route: RouteLocationNormalized) => void\n  clearHistory: () => void\n  // The admin's typed router narrows `RouteRecordName` to its route names: a misspelled one does not compile.\n  setBlacklistedRoutes: (routeNames: RouteRecordName[]) => void\n  addBlacklistedRoute: (routeName: RouteRecordName) => void\n  /** Returns where it goes and its navigation, `undefined` for a step back in the browser's history. */\n  navigateBack: (router: Router, options?: NavigateBackOptions) => NavigateBackTarget | undefined\n} {\n  const addRoute = (route: RouteLocationNormalized) => {\n    if (blacklistedRouteNames.value.includes(route.name as RouteRecordName)) {\n      return\n    }\n\n    // A list filter rewrites its hash with `history.replaceState`, which the router never sees. On a\n    // push the address bar still shows the route being left, so its hash is the one to come back to.\n    const [pathAndQuery] = route.fullPath.split('#')\n    if (pathAndQuery === window.location.pathname + window.location.search && route.hash !== window.location.hash) {\n      route = { ...route, hash: window.location.hash, fullPath: pathAndQuery + window.location.hash }\n    }\n\n    const lastRoute = history.value[history.value.length - 1]\n    if (lastRoute && lastRoute.fullPath === route.fullPath) {\n      return\n    }\n\n    history.value.push({ name: route.name, fullPath: route.fullPath })\n    if (history.value.length > MAX_HISTORY) {\n      history.value.shift()\n    }\n  }\n\n  /** REPLACES the list. Two callers would overwrite each other -- to add one, use `addBlacklistedRoute`. */\n  const setBlacklistedRoutes = (routeNames: RouteRecordName[]) => {\n    blacklistedRouteNames.value = routeNames\n  }\n\n  const addBlacklistedRoute = (routeName: RouteRecordName) => {\n    if (!blacklistedRouteNames.value.includes(routeName)) {\n      blacklistedRouteNames.value.push(routeName)\n    }\n  }\n\n  // Internal on purpose. A caller reaching for it directly would get the walk WITHOUT the\n  // current-route exclusion `navigateBack` adds -- which is the whole trap `navigateBack` exists\n  // to close.\n  const findRouteBack = (isDestination: (route: RouteHistoryEntry) => boolean): RouteHistoryEntry | undefined => {\n    for (let i = history.value.length - 1; i >= 0; i--) {\n      if (isDestination(history.value[i]!)) {\n        return history.value[i]\n      }\n    }\n    return undefined\n  }\n\n  const clearHistory = () => {\n    history.value = []\n    leftAfterFailure.clear()\n  }\n\n  const navigateBack = (router: Router, options: NavigateBackOptions = {}): NavigateBackTarget | undefined => {\n    const { skipRouteNames, fallbackRouteName, fallbackRouteParams } = options\n    const current = router.currentRoute.value\n    const skip: readonly RouteRecordNameGeneric[] = skipRouteNames ?? []\n\n    // The route we are on is never a place to go back to. `addRoute` runs in `beforeEach`, so a\n    // navigation that a later guard cancels still records the route we never left -- and pushing\n    // that again is a silent no-op, which reads as the button doing nothing at all. Callers\n    // therefore do not name their own route in `skipRouteNames`.\n    //\n    // Both tests sit INSIDE the walk rather than filtering its result: a route name is optional in\n    // vue-router, and a nameless current route can only be recognised by its path -- rejecting the\n    // candidate afterwards would stop the walk at it instead of carrying on to the entry before.\n    // Names are compared with `===` so a symbol name counts too, but only when the current route\n    // has one: two different nameless routes are both `undefined` and are not the same place.\n    const isCurrent = (route: RouteHistoryEntry) =>\n      route.fullPath === current.fullPath || (current.name !== undefined && route.name === current.name)\n\n    const route = findRouteBack((entry) => !isCurrent(entry) && !skip.includes(entry.name))\n\n    if (route) {\n      return { to: route.fullPath, navigation: router.push(route.fullPath) }\n    }\n    if (fallbackRouteName) {\n      const fallback = { name: fallbackRouteName, params: fallbackRouteParams }\n      return { to: fallback, navigation: router.push(fallback) }\n    }\n    router.back()\n    return undefined\n  }\n\n  return {\n    history: readonly(history),\n    addRoute,\n    clearHistory,\n    setBlacklistedRoutes,\n    addBlacklistedRoute,\n    navigateBack,\n  }\n}\n"],"mappings":";;AAkBA,IAAMA,IAAUC,EAAyB,CAAC,CAAC,GAGrCC,oBAAmB,IAAI,IAAoB,GAC3CC,IAAwB,KAGjBC,KAAwB,MAAiB;CACpD,IAAMC,IAAM,KAAK,IAAI;CAErB,KAAK,IAAM,CAACC,GAAMC,MAAOL,GAAkB,AAAIG,IAAME,KAAMJ,KAAuBD,EAAiB,OAAOI,CAAI;CAC9G,EAAiB,IAAIE,GAAMH,CAAG;AAChC,GAGaI,KAA0B,MAAiB;CACtD,EAAiB,OAAOD,CAAI;AAC9B,GAGaE,KAA8B,MAAiB;CAC1D,IAAMH,IAAKL,EAAiB,IAAIM,CAAI;CAIpC,OAHID,MAAO,KAAA,IAAkB,KACzB,KAAK,IAAI,IAAIA,IAAKJ,MACtBD,EAAiB,OAAOM,CAAI,GACrB;AACT,GACMG,IAAwBV,EAAuB,CAAC,CAAC,GAMjDW,IAAc;AAoBpB,SAAgBC,IASd;CACA,IAAMC,KAAY,MAAmC;EACnD,IAAIH,EAAsB,MAAM,SAASI,EAAM,IAAuB,GACpE;EAKF,IAAM,CAACC,KAAgBD,EAAM,SAAS,MAAM,GAAG;EAC/C,AAAIC,MAAiB,OAAO,SAAS,WAAW,OAAO,SAAS,UAAUD,EAAM,SAAS,OAAO,SAAS,SACvG,IAAQ;GAAE,GAAGA;GAAO,MAAM,OAAO,SAAS;GAAM,UAAUC,IAAe,OAAO,SAAS;EAAK;EAGhG,IAAMC,IAAYjB,EAAQ,MAAMA,EAAQ,MAAM,SAAS;EACvD,AAAIiB,KAAaA,EAAU,aAAaF,EAAM,aAI9Cf,EAAQ,MAAM,KAAK;GAAE,MAAMe,EAAM;GAAM,UAAUA,EAAM;EAAS,CAAC,GAC7Df,EAAQ,MAAM,SAASY,KACzBZ,EAAQ,MAAM,MAAM;CAExB,GAGMkB,KAAwB,MAAkC;EAC9D,EAAsB,QAAQC;CAChC,GAEMC,KAAuB,MAA+B;EAC1D,AAAKT,EAAsB,MAAM,SAASU,CAAS,KACjDV,EAAsB,MAAM,KAAKU,CAAS;CAE9C,GAKMC,KAAiB,MAAwF;EAC7G,KAAK,IAAIC,IAAIvB,EAAQ,MAAM,SAAS,GAAGuB,KAAK,GAAG,KAC7C,IAAIC,EAAcxB,EAAQ,MAAMuB,EAAG,GACjC,OAAOvB,EAAQ,MAAMuB;CAI3B;CAsCA,OAAO;EACL,SAASE,EAASzB,CAAO;EACzB;EACA,oBAvCyB;GAEzB,AADA,EAAQ,QAAQ,CAAC,GACjBE,EAAiB,MAAM;EACzB;EAqCE;EACA;EACA,eArCoB,GAAgB,IAA+B,CAAC,MAAsC;GAC1G,IAAM,EAAE,mBAAgB,sBAAmB,2BAAwBwB,GAC7DC,IAAUC,EAAO,aAAa,OAC9BC,IAA0CC,KAAkB,CAAC,GAY7DC,KAAa,MACjBhB,EAAM,aAAaY,EAAQ,YAAaA,EAAQ,SAAS,KAAA,KAAaZ,EAAM,SAASY,EAAQ,MAEzFZ,IAAQO,GAAe,MAAU,CAACS,EAAUC,CAAK,KAAK,CAACH,EAAK,SAASG,EAAM,IAAI,CAAC;GAEtF,IAAIjB,GACF,OAAO;IAAE,IAAIA,EAAM;IAAU,YAAYa,EAAO,KAAKb,EAAM,QAAQ;GAAE;GAEvE,IAAIkB,GAAmB;IACrB,IAAMC,IAAW;KAAE,MAAMD;KAAmB,QAAQE;IAAoB;IACxE,OAAO;KAAE,IAAID;KAAU,YAAYN,EAAO,KAAKM,CAAQ;IAAE;GAC3D;GACA,EAAO,KAAK;EAEd;CASA;AACF"}

package/dist/domains/system/composables/sentry.d.ts

@@ -0,0 +1,17 @@
+interface SentryContext {
+    extra?: Record<string, any>;
+    tags?: Record<string, string>;
+    level?: 'fatal' | 'error' | 'warning' | 'log' | 'info' | 'debug';
+    [key: string]: any;
+}
+export declare function useSentry(component?: string): {
+    logError: (error: Error, context?: SentryContext) => void;
+    logMessage: (message: string, level?: "fatal" | "error" | "warning" | "info" | "debug", context?: SentryContext) => void;
+    setTag: (key: string, value: string) => void;
+    setUser: (user: {
+        id: string;
+        email?: string;
+        username?: string;
+    }) => void;
+};
+export {};