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

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

@@ -0,0 +1,22 @@
+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 only the start-up loader is on screen. Called once per handler.
+     * Without it, and after it, the page is reloaded. The message stays up when a reload 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 error,
+ * a chunk that does not load) otherwise only reaches the console.
+ * A failed chunk is usually an old tab after a deploy: the page reloads, at most once per 30 s.
+ * 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,25 @@
+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";
+// 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");
+		}
+	};
+};
+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 only the start-up loader is on screen. Called once per handler.\n   * Without it, and after it, the page is reloaded. The message stays up when a reload is 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 error,\n * a chunk that does not load) otherwise only reaches the console.\n * A failed chunk is usually an old tab after a deploy: the page reloads, at most once per 30 s.\n * Anything else shows \"the page could not be opened\".\n */\nexport const createNavigationErrorHandler = (router: Router, options: NavigationErrorHandlerOptions = {}) => {\n  // Runs once. Otherwise a callback that redirects to an error page runs again when that page fails too.\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        // A callback that throws has not cleared the loader. The reload or the message below must still run.\n        if (safely(options.onFirstNavigationError, error)) return\n      }\n      if (requestAppReload()) return\n      // Only the start-up loader is on screen and the reload was just tried, so the message stays.\n      useAlerts().showErrorT('common.alert.navigationFailed', -1)\n      return\n    }\n\n    useAlerts().showErrorT('common.alert.navigationFailed')\n  }\n}\n"],"mappings":";;;;;AAsBA,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,GAQaC,KAAgC,GAAgB,IAAyC,CAAC,MAAM;CAE3G,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,27 @@
+import { RouteLocationRaw, Router } from 'vue-router';
+/**
+ * Tracks the user's navigation on `router`: whether one is pending, and which page is shown.
+ * Register it as the router's first guard. A page that acts after an async step
+ * (load, save, socket event) checks `onPage()` first via `usePageNavigation`.
+ * While the user navigates or after leaving, it does nothing. A redirect would
+ * cancel the user's navigation, and a message would stay on the next page.
+ * 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 in its setup, that navigates after
+ * an async step, such as a redirect after save, create or delete.
+ * The page is the one shown at setup. A later visit to the same path (A, B, A again) is another page.
+ * A composable that receives its router passes it on.
+ */
+export declare function usePageNavigation(router?: Router | undefined): UsePageNavigationReturn;

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

@@ -0,0 +1,39 @@
+import { NavigationFailureType as e, isNavigationFailure as t, useRouter as n } from "vue-router";
+// 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)
+	};
+}
+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 * Tracks the user's navigation on `router`: whether one is pending, and which page is shown.\n * Register it as the router's first guard. A page that acts after an async step\n * (load, save, socket event) checks `onPage()` first via `usePageNavigation`.\n * While the user navigates or after leaving, it does nothing. A redirect would\n * cancel the user's navigation, and a message would stay on the next page.\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 replaced this one and is still pending. 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 in its setup, that navigates after\n * an async step, such as a redirect after save, create or delete.\n * The page is the one shown at setup. A later visit to the same path (A, B, A again) is another page.\n * A composable that receives 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 track or navigate.\n  if (!router) return { onPage: () => true, push: async () => false, replace: async () => false }\n  // Registers 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, so a location the router cannot resolve still throws inside the caller's try/catch.\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;AAUJ,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;AAgBnE,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,33 @@
+import { Ref } from 'vue';
+/**
+ * Get-one loader for a detail or edit page, in the shape `useRecordPage`
+ * reads. Raises `loading` and runs `load` with the page's signal.
+ * Returns `true` once loaded, else the result of `handleRecordLoadError`: `false`
+ * leaves the page, `undefined` means aborted or session expired (page stays).
+ * `loading` is lowered unless the load was aborted, because the flag then belongs to the next page.
+ * A bare `return` in `load` means loaded, and anything thrown counts as a load failure.
+ * Use it only for the record's single request; anything more stays hand-written.
+ * @example
+ * 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>;
+/**
+ * Save of a create or edit form. Raises `loading`, touches `v$` and calls `showValidationError`
+ * if invalid, runs `save`, shows errors with `showErrorsDefault`, lowers `loading`.
+ * The success alert and what follows it stay in `save`.
+ * `loading` and `v$` are captured at definition, so both must exist then. Extra validators,
+ * flags, error handling, `finally` work, return values or requests stay hand-written.
+ * @example
+ * 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,32 @@
+import { useAlerts as e } from "./alerts.js";
+import { handleRecordLoadError as t } from "./recordPage.js";
+// 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;
+		}
+	};
+};
+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 * Get-one loader for a detail or edit page, in the shape `useRecordPage`\n * reads. Raises `loading` and runs `load` with the page's signal.\n * Returns `true` once loaded, else the result of `handleRecordLoadError`: `false`\n * leaves the page, `undefined` means aborted or session expired (page stays).\n * `loading` is lowered unless the load was aborted, because the flag then belongs to the next page.\n * A bare `return` in `load` means loaded, and anything thrown counts as a load failure.\n * Use it only for the record's single request; anything more stays hand-written.\n * @example\n * const fetchData = defineRecordLoader(detailLoading, async (id: IntegerId, signal) => {\n *   faq.value = await fetchFaq({ urlParams: { id }, signal })\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 * Save of a create or edit form. Raises `loading`, touches `v$` and calls `showValidationError`\n * if invalid, runs `save`, shows errors with `showErrorsDefault`, lowers `loading`.\n * The success alert and what follows it stay in `save`.\n * `loading` and `v$` are captured at definition, so both must exist then. Extra validators,\n * flags, error handling, `finally` work, return values or requests stay hand-written.\n * @example\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 */\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":";;;AAiBA,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,GAcWE,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,53 @@
+import { Ref } from 'vue';
+import { RouteRecordName } from 'vue-router';
+/**
+ * Shows why a record failed to load and returns whether its page should leave.
+ * Only for the record's own get-one: a 404 or 403 there means the record is unavailable, unlike for secondary requests.
+ * An aborted request or an expired session shows nothing and does not leave. Other errors show the
+ * `showErrorsDefault` message and leave, since the page would show an empty record with live buttons.
+ * While the user navigates elsewhere (`trackNavigation`) it shows nothing
+ * and does not leave, because the message would stay on the next page.
+ */
+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>;
+    /**
+     * Same as the page's Close button: the record's sibling views and the create form.
+     * A route with the record's params is skipped only as that record's address, see `leave`.
+     */
+    skipRouteNames?: RouteRecordName[];
+    /**
+     * The page's loading flag. `leave` keeps it up so the empty record's buttons never show.
+     * The page lowers it on unmount. The flag is often shared by all views of
+     * the entity, and the next one (e.g. a create form) must not inherit it.
+     */
+    loading?: Ref<boolean>;
+    /**
+     * The record's load, run on mount with the page's signal. `false` leaves the page, `true` and `undefined` keep it.
+     * A load also called later is fine: `load: () => getData()`.
+     * Omit it and write `onMounted` by hand when the page acts on
+     * the result, 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.
+ * `false` from the loader means leave. `undefined` is a superseded or aborted load, and the page stays.
+ * While the user navigates elsewhere (`trackNavigation`), the page does not
+ * leave. If that navigation fails, the page stays with its loading flag up.
+ * Not handled: a guard that refuses the step back can leave the address bar out of sync with the router.
+ * @example
+ * useRecordPage({ fallbackRouteName: '/x', skipRouteNames: [...],
+ * loading: detailLoading, load: (signal) => fetchData(id, { signal }) })
+ */
+export declare function useRecordPage(options?: UseRecordPageOptions): UseRecordPageReturn;

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

@@ -0,0 +1,102 @@
+import { useAlerts as e } from "./alerts.js";
+import { forgetLeftAfterFailure as t, isLeftAfterFailureRecently as n, markLeftAfterFailure as r, useRouteHistory as i } from "./routeHistory.js";
+import { useDatatablePageStore as a } from "../store/datatablePageStore.js";
+import { isAppNavigationPending as o, usePageNavigation as s } from "./pageNavigation.js";
+import { apiErrorStatus as c } from "../../api/utils/apiErrors.js";
+import { isAnzuApiCancelledError as l } from "../../../shared/error/AnzuApiCancelledError.js";
+import { isAnzuApiForbiddenError as u } from "../../../shared/error/AnzuApiForbiddenError.js";
+import { SessionExpiredError as d } from "../../../shared/error/SessionExpiredError.js";
+import { isInCauseChain as f } from "../../../shared/error/isInCauseChain.js";
+import "../../../shared/statusCodes.js";
+import { onBeforeUnmount as p, onMounted as m } from "vue";
+import { useRouter as h } from "vue-router";
+// src/domains/system/composables/recordPage.ts
+var g = (t, n = -1) => {
+	if (l(t) || f(t, (e) => e instanceof d)) return !1;
+	if (o()) return !0;
+	let { showErrorT: r, showErrorsDefault: i, showUnknownError: a } = e(), s = c(t);
+	return u(t) || s === 403 ? (r("common.alert.recordForbidden", n), !0) : s === 404 ? (r("common.alert.recordNotFound", n), !0) : (i(t, n) || a(n), !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 o = h(), { history: c } = i(), { preservePageForLanding: l } = a(), { onPage: u } = s(), d = o.currentRoute.value.path;
+	t(d);
+	let f = new AbortController(), g = !1;
+	p(() => {
+		g = !0, f.abort(), e.loading && (e.loading.value = !1);
+	});
+	let y = () => !g && o.currentRoute.value.path === d, C = () => {
+		let t = o.currentRoute.value, n = /* @__PURE__ */ new Set([_(t.fullPath)]), r = /* @__PURE__ */ new Set();
+		for (let i of e.skipRouteNames ?? []) {
+			let e = b(o, i);
+			if (!e) continue;
+			if (e.length === 0 || e.some(({ key: e, optional: n }) => !n && !(e in t.params))) {
+				r.add(i);
+				continue;
+			}
+			let a = Object.fromEntries(e.filter(({ key: e }) => e in t.params).map(({ key: e }) => [e, t.params[e]]));
+			try {
+				n.add(_(o.resolve({
+					name: i,
+					params: a
+				}).fullPath));
+			} catch {
+				r.add(i);
+			}
+		}
+		return {
+			paths: n,
+			names: r
+		};
+	}, w = () => {
+		let { paths: e, names: t } = C();
+		for (let r = c.value.length - 1; r >= 0; r--) {
+			let i = c.value[r];
+			if (!(e.has(_(i.fullPath)) || n(_(i.fullPath))) && !(i.name !== void 0 && i.name !== null && t.has(i.name))) return i.fullPath;
+		}
+	}, T = async (e) => {
+		let t;
+		try {
+			t = o.resolve(e).fullPath;
+		} catch {
+			return !1;
+		}
+		let n = o.options.history.state.back;
+		if (typeof n == "string" && v(n) === v(t)) {
+			let e = x(o);
+			return l(o), o.back(), e;
+		}
+		let r = o.replace(e);
+		return l(o, {
+			to: e,
+			navigation: r
+		}), S(r);
+	}, E = async () => {
+		if (!y() || (e.loading && (e.loading.value = !0), !u())) return !1;
+		r(d);
+		let t = w();
+		return t !== void 0 && await T(t) ? !0 : !y() || !u() || e.fallbackRouteName === void 0 ? !1 : T({
+			name: e.fallbackRouteName,
+			params: e.fallbackRouteParams
+		});
+	}, { load: D } = e;
+	return D && m(async () => {
+		await D(f.signal) === !1 && await E();
+	}), {
+		signal: f.signal,
+		leave: E,
+		onPage: u
+	};
+}
+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 failed to load and returns whether its page should leave.\n * Only for the record's own get-one: a 404 or 403 there means the record is unavailable, unlike for secondary requests.\n * An aborted request or an expired session shows nothing and does not leave. Other errors show the\n * `showErrorsDefault` message and leave, since the page would show an empty record with live buttons.\n * While the user navigates elsewhere (`trackNavigation`) it shows nothing\n * and does not leave, because the message would stay on the next page.\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   * Same as the page's Close button: the record's sibling views and the create form.\n   * A route with the record's params is skipped only as that record's address, see `leave`.\n   */\n  skipRouteNames?: RouteRecordName[]\n  /**\n   * The page's loading flag. `leave` keeps it up so the empty record's buttons never show.\n   * The page lowers it on unmount. The flag is often shared by all views of\n   * the entity, and the next one (e.g. a create form) must not inherit it.\n   */\n  loading?: Ref<boolean>\n  /**\n   * The record's load, run on mount with the page's signal. `false` leaves the page, `true` and `undefined` keep it.\n   * A load also called later is fine: `load: () => getData()`.\n   * Omit it and write `onMounted` by hand when the page acts on\n   * the result, 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()` returns nothing, so its landing or its error is the result.\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 the load fails.\n * `false` from the loader means leave. `undefined` is a superseded or aborted load, and the page stays.\n * While the user navigates elsewhere (`trackNavigation`), the page does not\n * leave. If that navigation fails, the page stays with its loading flag up.\n * Not handled: a guard that refuses the step back can leave the address bar out of sync with the router.\n * @example\n * useRecordPage({ fallbackRouteName: '/x', skipRouteNames: [...],\n * loading: detailLoading, load: (signal) => fetchData(id, { signal }) })\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 one must not move the user off the other.\n  const path = router.currentRoute.value.path\n  // The page is visited again, so an earlier failure 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 aborted load whose `finally` no longer owns it.\n    // The 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, this\n  // returns to the view the user came from, including another record of the same entity.\n  // Only this record's addresses are skipped, compared without query and hash (a tab in the query is the same view).\n  // The create form is skipped too: going 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      // Addresses left recently after a failure are skipped too.\n      // Otherwise two failing records in the history (A, then B, backend down) send the\n      // user back and forth for the whole outage. 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 previous entry, a replace otherwise.\n  // A push would let browser Back return to the failed page, 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    // Compared without the hash. A list filter writes the hash outside the\n    // router, so `state.back` lacks it while the route history has it.\n    // The filter keeps the list entry's `current` in sync, 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    // Stays up for good if the leave fails. The record is not loaded, and its Save and Delete buttons must not return.\n    // The Close button, which no page ties to loading, is the way out then.\n    if (options.loading) options.loading.value = true\n    // The user is navigating to another page. That navigation decides, and 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,37 @@
+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 record's sibling views and its create form.
+     * The current route is always skipped, so do not list it here.
+     */
+    skipRouteNames?: RouteRecordName[];
+    /** Where to go when the walk finds nothing, e.g. a tab opened directly 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 the target and its navigation, or `undefined` for a browser history step back. */
+    navigateBack: (router: Router, options?: NavigateBackOptions) => NavigateBackTarget | undefined;
+};

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

@@ -0,0 +1,71 @@
+import { readonly as e, ref as t } from "vue";
+// src/domains/system/composables/routeHistory.ts
+var n = t([]), r = 0, i = /* @__PURE__ */ new Map(), a = 6e4, o = (e) => {
+	let t = Date.now();
+	for (let [e, n] of i) t - n >= a && i.delete(e);
+	i.set(e, t);
+}, s = (e) => {
+	i.delete(e);
+}, c = (e) => {
+	let t = i.get(e);
+	return t === void 0 ? !1 : Date.now() - t < a || (i.delete(e), !1);
+}, l = t([]), u = 10;
+function d() {
+	let t = (e) => {
+		if (l.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 > u && n.value.shift());
+	}, a = (e) => {
+		l.value = e;
+	}, o = (e) => {
+		l.value.includes(e) || l.value.push(e);
+	}, s = (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++, i.clear();
+		},
+		setBlacklistedRoutes: a,
+		addBlacklistedRoute: o,
+		navigateBack: (e, t = {}) => {
+			let { skipRouteNames: i, fallbackRouteName: a, fallbackRouteParams: o } = t, c = e.currentRoute.value, l = i ?? [], u = (e) => e.fullPath === c.fullPath || c.name !== void 0 && e.name === c.name, d = s((e) => !u(e) && !l.includes(e.name));
+			if (d) {
+				let t = r, i = e.push(d.fullPath);
+				return Promise.resolve(i).then((e) => {
+					if (e || t !== r) return;
+					let i = n.value.indexOf(d);
+					n.value.splice(i === -1 ? 0 : i);
+				}, () => void 0), {
+					to: d.fullPath,
+					navigation: i
+				};
+			}
+			if (a) {
+				let t = {
+					name: a,
+					params: o
+				};
+				return {
+					to: t,
+					navigation: e.push(t)
+				};
+			}
+			e.back();
+		}
+	};
+}
+export { s as forgetLeftAfterFailure, c as isLeftAfterFailureRecently, o as markLeftAfterFailure, d 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","historyGeneration","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","generation","navigation","failure","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 there is one history per document. A test that fills\n// it must call `clearHistory`, or the next test sees the leftovers.\nconst history = ref<RouteHistoryEntry[]>([])\n// Bumped by `clearHistory`, so a Close landing afterwards leaves the new list alone.\nlet historyGeneration = 0\n// Paths a record page left after its record failed, with the\n// time. `useRecordPage` skips them as destinations for a while.\n// Kept here so `clearHistory` clears it too.\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  // Prunes expired entries here too. Otherwise a path is dropped only 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. `addRoute` drops only consecutive\n * duplicates, so A, B, A, B uses four slots and can push the wanted list out.\n * `fallbackRouteName` covers that case.\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 record's sibling views and its create form.\n   * The current route is always skipped, so do not list it here.\n   */\n  skipRouteNames?: RouteRecordName[]\n  /** Where to go when the walk finds nothing, e.g. a tab opened directly 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 the target and its navigation, or `undefined` for a browser history step back. */\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.\n    // On a push the address bar still shows the route being left, so its hash is the one to return 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 whole list, so two callers overwrite each other. Use `addBlacklistedRoute` to add one. */\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. Called directly, it lacks the current-route exclusion that `navigateBack` adds.\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    historyGeneration++\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 current route is never a destination. `addRoute` runs in `beforeEach`, so a navigation\n    // cancelled by a later guard still records it, and pushing it again is a silent no-op.\n    // The check runs inside the walk, not on its result. A nameless current route is recognised only\n    // by its path, and rejecting the result afterwards would stop the walk instead of continuing.\n    // Names use `===` so symbol names work, but only when the current route has\n    // a name: two nameless routes are both `undefined` and 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      const generation = historyGeneration\n      const navigation = router.push(route.fullPath)\n      // Back on `route`, the entries after it are behind the user. Kept, they become\n      // the next Close's destination, and Close ping-pongs between two details.\n      // They are dropped only after landing, so a navigation stopped by a\n      // guard or cancelled by a second click leaves the history unchanged.\n      // `Promise.resolve` because a test double's `push` may return nothing.\n      Promise.resolve(navigation).then(\n        (failure) => {\n          if (failure || generation !== historyGeneration) return\n          // Missing without `clearHistory` means `route` was pushed out\n          // at the front by `MAX_HISTORY`. Everything left came after it.\n          const at = history.value.indexOf(route)\n          history.value.splice(at === -1 ? 0 : at)\n        },\n        () => undefined\n      )\n      return { to: route.fullPath, navigation }\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":"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"}

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 {};

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

@@ -0,0 +1,55 @@
+// src/domains/system/composables/sentry.ts
+var e = null, t = () => (e ||= import("@sentry/vue").then((e) => e).catch(() => null), e);
+function n(e = "common-admin") {
+	let n = `[${e}]`, r = (e) => {
+		t().then((t) => {
+			if (t) try {
+				e(t);
+			} catch (e) {
+				console.debug("Sentry logging failed", e);
+			}
+		});
+	}, i = (t) => ({
+		...t,
+		tags: {
+			...t?.tags,
+			component: e
+		}
+	});
+	return {
+		logError: (e, t) => {
+			console.error(n, e), r((n) => n.captureException(e, i(t)));
+		},
+		logMessage: (e, t = "info", a) => {
+			switch (t) {
+				case "fatal":
+				case "error":
+					console.error(n, e);
+					break;
+				case "warning":
+					console.warn(n, e);
+					break;
+				case "info":
+					console.info(n, e);
+					break;
+				case "debug":
+					console.debug(n, e);
+					break;
+				default: console.log(n, e);
+			}
+			r((n) => n.captureMessage(e, {
+				level: t,
+				...i(a)
+			}));
+		},
+		setTag: (e, t) => {
+			r((n) => n.setTag(e, t));
+		},
+		setUser: (e) => {
+			r((t) => t.setUser(e));
+		}
+	};
+}
+export { n as useSentry };
+
+//# sourceMappingURL=sentry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sentry.js","names":["sentryPromise","getSentry","module","useSentry","consoleLabel","component","report","sentry","taggedContext","context","error","level","message","key","value","user"],"sources":["../../../../src/domains/system/composables/sentry.ts"],"sourcesContent":["import type * as SentryType from '@sentry/vue'\n\ninterface SentryContext {\n  extra?: Record<string, any>\n  tags?: Record<string, string>\n  level?: 'fatal' | 'error' | 'warning' | 'log' | 'info' | 'debug'\n  [key: string]: any\n}\n\nlet sentryPromise: Promise<typeof SentryType | null> | null = null\n\nconst getSentry = (): Promise<typeof SentryType | null> => {\n  if (!sentryPromise) {\n    sentryPromise = import('@sentry/vue').then((module) => module).catch(() => null)\n  }\n  return sentryPromise\n}\n\nexport function useSentry(component = 'common-admin') {\n  const consoleLabel = `[${component}]`\n\n  /**\n   * Sentry is imported lazily, so this is async and must never\n   * throw. A failed report must not break the code that reports.\n   */\n  const report = (send: (sentry: typeof SentryType) => void): void => {\n    getSentry().then((sentry) => {\n      if (!sentry) {\n        return\n      }\n      try {\n        send(sentry)\n      } catch (e) {\n        console.debug('Sentry logging failed', e)\n      }\n    })\n  }\n\n  const taggedContext = (context?: SentryContext): SentryContext => ({\n    ...context,\n    tags: {\n      ...context?.tags,\n      component,\n    },\n  })\n\n  const logError = (error: Error, context?: SentryContext): void => {\n    console.error(consoleLabel, error)\n\n    report((sentry) => sentry.captureException(error, taggedContext(context)))\n  }\n\n  const logMessage = (\n    message: string,\n    level: 'fatal' | 'error' | 'warning' | 'info' | 'debug' = 'info',\n    context?: SentryContext\n  ): void => {\n    switch (level) {\n      case 'fatal':\n      case 'error':\n        console.error(consoleLabel, message)\n        break\n      case 'warning':\n        console.warn(consoleLabel, message)\n        break\n      case 'info':\n        console.info(consoleLabel, message)\n        break\n      case 'debug':\n        console.debug(consoleLabel, message)\n        break\n      default:\n        console.log(consoleLabel, message)\n    }\n\n    report((sentry) => sentry.captureMessage(message, { level, ...taggedContext(context) }))\n  }\n\n  const setTag = (key: string, value: string): void => {\n    report((sentry) => sentry.setTag(key, value))\n  }\n\n  const setUser = (user: { id: string; email?: string; username?: string }): void => {\n    report((sentry) => sentry.setUser(user))\n  }\n\n  return {\n    logError,\n    logMessage,\n    setTag,\n    setUser,\n  }\n}\n"],"mappings":";AASA,IAAIA,IAA0D,MAExDC,WACJ,AACED,MAAgB,OAAO,cAAc,CAAC,MAAM,MAAWE,CAAM,CAAC,CAAC,YAAY,IAAI,GAE1EF;AAGT,SAAgBG,EAAU,IAAY,gBAAgB;CACpD,IAAMC,IAAe,IAAIC,EAAU,IAM7BC,KAAU,MAAoD;EAClE,EAAU,CAAC,CAAC,MAAM,MAAW;GAC3B,IAAKC,GAGL,IAAI;IACF,EAAKA,CAAM;GACb,SAAS,GAAG;IACV,QAAQ,MAAM,yBAAyB,CAAC;GAC1C;EACF,CAAC;CACH,GAEMC,KAAiB,OAA4C;EACjE,GAAGC;EACH,MAAM;GACJ,GAAGA,GAAS;GACZ;EACF;CACF;CA0CA,OAAO;EACL,WAzCgB,GAAc,MAAkC;GAGhE,AAFA,QAAQ,MAAML,GAAcM,CAAK,GAEjCJ,GAAQ,MAAWC,EAAO,iBAAiBG,GAAOF,EAAcC,CAAO,CAAC,CAAC;EAC3E;EAsCE,aAnCA,GACA,IAA0D,QAC1D,MACS;GACT,QAAQE,GAAR;IACE,KAAK;IACL,KAAK;KACH,QAAQ,MAAMP,GAAcQ,CAAO;KACnC;IACF,KAAK;KACH,QAAQ,KAAKR,GAAcQ,CAAO;KAClC;IACF,KAAK;KACH,QAAQ,KAAKR,GAAcQ,CAAO;KAClC;IACF,KAAK;KACH,QAAQ,MAAMR,GAAcQ,CAAO;KACnC;IACF,SACE,QAAQ,IAAIR,GAAcQ,CAAO;GACrC;GAEA,GAAQ,MAAWL,EAAO,eAAeK,GAAS;IAAE;IAAO,GAAGJ,EAAcC,CAAO;GAAE,CAAC,CAAC;EACzF;EAaE,SAXc,GAAa,MAAwB;GACnD,GAAQ,MAAWF,EAAO,OAAOM,GAAKC,CAAK,CAAC;EAC9C;EAUE,UARe,MAAkE;GACjF,GAAQ,MAAWP,EAAO,QAAQQ,CAAI,CAAC;EACzC;CAOA;AACF"}