@squide/firefly 9.3.1 → 9.3.3

package/dist/useCanUpdateDeferredRegistrations.js

@@ -1,2 +1,16 @@
-export { useCanUpdateDeferredRegistrations } from './chunk-WVRMJZV6.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__ from "./AppRouterContext.js";
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: ./src/useCanUpdateDeferredRegistrations.ts?__rslib_entry__
+
+function useCanUpdateDeferredRegistrations() {
+    const { areModulesReady, publicDataUpdatedAt, protectedDataUpdatedAt, deferredRegistrationsUpdatedAt } = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__.useAppRouterState)();
+    return(// Do not trigger an update if the deferred registrations has not been registered yet (if there are deferred registrations, once they are
+    // registered, the modules will be marked as ready).
+    areModulesReady && deferredRegistrationsUpdatedAt && (publicDataUpdatedAt && publicDataUpdatedAt > deferredRegistrationsUpdatedAt || protectedDataUpdatedAt && protectedDataUpdatedAt > deferredRegistrationsUpdatedAt));
+}
+
+export { useCanUpdateDeferredRegistrations };
+
+//# sourceMappingURL=useCanUpdateDeferredRegistrations.js.map

package/dist/useCanUpdateDeferredRegistrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCanUpdateDeferredRegistrations.js","sources":["webpack://@squide/firefly/./src/useCanUpdateDeferredRegistrations.ts"],"sourcesContent":["import { useAppRouterState } from \"./AppRouterContext.ts\";\n\nexport function useCanUpdateDeferredRegistrations() {\n    const {\n        areModulesReady,\n        publicDataUpdatedAt,\n        protectedDataUpdatedAt,\n        deferredRegistrationsUpdatedAt\n    } = useAppRouterState();\n\n    return (\n        // Do not trigger an update if the deferred registrations has not been registered yet (if there are deferred registrations, once they are\n        // registered, the modules will be marked as ready).\n        areModulesReady\n        // Make sure the apps is actually having deferred registrations.\n        && deferredRegistrationsUpdatedAt\n        // If either the public data or the protected data has been updated, update the deferred registrations.\n        && (\n            (publicDataUpdatedAt && publicDataUpdatedAt > deferredRegistrationsUpdatedAt) ||\n            (protectedDataUpdatedAt && protectedDataUpdatedAt > deferredRegistrationsUpdatedAt)\n        )\n    );\n}\n"],"names":["useAppRouterState","useCanUpdateDeferredRegistrations","areModulesReady","publicDataUpdatedAt","protectedDataUpdatedAt","deferredRegistrationsUpdatedAt"],"mappings":";;;;;AAA0D;AAEnD,SAASC;IACZ,MAAM,EACFC,eAAe,EACfC,mBAAmB,EACnBC,sBAAsB,EACtBC,8BAA8B,EACjC,GAAGL,+EAAiBA;IAErB,OACI,yIAAyI;IACzI,oDAAoD;IACpDE,mBAEGG,kCAGC,CAACF,uBAAuBA,sBAAsBE,kCAC7CD,0BAA0BA,yBAAyBC,8BAA8B;AAG9F"}

package/dist/useDeferredRegistrations.d.ts

@@ -1,13 +1,10 @@
-import { ModuleRegistrationError } from '@squide/core';
-
-interface DeferredRegistrationsErrorsObject {
+import { type ModuleRegistrationError } from "@squide/core";
+export interface DeferredRegistrationsErrorsObject {
     localModuleErrors: ModuleRegistrationError[];
     remoteModuleErrors: ModuleRegistrationError[];
 }
-type DeferredRegistrationsErrorCallback = (errorsObject: DeferredRegistrationsErrorsObject) => void;
-interface UseDeferredRegistrationsOptions {
+export type DeferredRegistrationsErrorCallback = (errorsObject: DeferredRegistrationsErrorsObject) => void;
+export interface UseDeferredRegistrationsOptions {
     onError?: DeferredRegistrationsErrorCallback;
 }
-declare function useDeferredRegistrations(data: unknown, { onError }?: UseDeferredRegistrationsOptions): void;
-
-export { type DeferredRegistrationsErrorCallback, type DeferredRegistrationsErrorsObject, type UseDeferredRegistrationsOptions, useDeferredRegistrations };
+export declare function useDeferredRegistrations(data: unknown, { onError }?: UseDeferredRegistrationsOptions): void;

package/dist/useDeferredRegistrations.js

@@ -1,6 +1,74 @@
-export { useDeferredRegistrations } from './chunk-BFHHJOJT.js';
-import './chunk-YRWFYWK4.js';
-import './chunk-N2GOIQ5E.js';
-import './chunk-4RUCDAUT.js';
-import './chunk-WVRMJZV6.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__core_src_index_js_d19dd8a6__ from "../../core/src/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__useCanRegisterDeferredRegistrations_js_257f17d4__ from "./useCanRegisterDeferredRegistrations.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useCanUpdateDeferredRegistrations_js_12932b2c__ from "./useCanUpdateDeferredRegistrations.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useRegisterDeferredRegistrations_js_eed558b9__ from "./useRegisterDeferredRegistrations.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useUpdateDeferredRegistrations_js_80de5337__ from "./useUpdateDeferredRegistrations.js";
+
+;// CONCATENATED MODULE: external "../../core/src/index.js"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./useCanRegisterDeferredRegistrations.js"
+
+;// CONCATENATED MODULE: external "./useCanUpdateDeferredRegistrations.js"
+
+;// CONCATENATED MODULE: external "./useRegisterDeferredRegistrations.js"
+
+;// CONCATENATED MODULE: external "./useUpdateDeferredRegistrations.js"
+
+;// CONCATENATED MODULE: ./src/useDeferredRegistrations.ts?__rslib_entry__
+
+
+
+
+
+
+function hasError({ localModuleErrors, remoteModuleErrors }) {
+    return localModuleErrors.length > 0 || remoteModuleErrors.length > 0;
+}
+function useDeferredRegistrations(data, { onError } = {}) {
+    const runtime = (0,__WEBPACK_EXTERNAL_MODULE__core_src_index_js_d19dd8a6__.useRuntime)();
+    const canRegisterDeferredRegistrations = (0,__WEBPACK_EXTERNAL_MODULE__useCanRegisterDeferredRegistrations_js_257f17d4__.useCanRegisterDeferredRegistrations)();
+    const canUpdateDeferredRegistrations = (0,__WEBPACK_EXTERNAL_MODULE__useCanUpdateDeferredRegistrations_js_12932b2c__.useCanUpdateDeferredRegistrations)();
+    const registerDeferredRegistrations = (0,__WEBPACK_EXTERNAL_MODULE__useRegisterDeferredRegistrations_js_eed558b9__.useRegisterDeferredRegistrations)();
+    const updateDeferredRegistrations = (0,__WEBPACK_EXTERNAL_MODULE__useUpdateDeferredRegistrations_js_80de5337__.useUpdateDeferredRegistrations)();
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (canRegisterDeferredRegistrations) {
+            const register = async ()=>{
+                const errors = await registerDeferredRegistrations(data, runtime);
+                if (hasError(errors) && onError) {
+                    onError(errors);
+                }
+            };
+            register();
+        }
+    }, [
+        canRegisterDeferredRegistrations,
+        registerDeferredRegistrations,
+        data,
+        onError,
+        runtime
+    ]);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (canUpdateDeferredRegistrations) {
+            const update = async ()=>{
+                const errors = await updateDeferredRegistrations(data, runtime);
+                if (hasError(errors) && onError) {
+                    onError(errors);
+                }
+            };
+            update();
+        }
+    }, [
+        canUpdateDeferredRegistrations,
+        updateDeferredRegistrations,
+        data,
+        onError,
+        runtime
+    ]);
+}
+
+export { useDeferredRegistrations };
+
+//# sourceMappingURL=useDeferredRegistrations.js.map

package/dist/useDeferredRegistrations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDeferredRegistrations.js","sources":["webpack://@squide/firefly/./src/useDeferredRegistrations.ts"],"sourcesContent":["import { useRuntime, type ModuleRegistrationError } from \"@squide/core\";\nimport { useEffect } from \"react\";\nimport { useCanRegisterDeferredRegistrations } from \"./useCanRegisterDeferredRegistrations.ts\";\nimport { useCanUpdateDeferredRegistrations } from \"./useCanUpdateDeferredRegistrations.ts\";\nimport { useRegisterDeferredRegistrations } from \"./useRegisterDeferredRegistrations.ts\";\nimport { useUpdateDeferredRegistrations } from \"./useUpdateDeferredRegistrations.ts\";\n\nexport interface DeferredRegistrationsErrorsObject {\n    localModuleErrors: ModuleRegistrationError[];\n    remoteModuleErrors: ModuleRegistrationError[];\n}\n\nexport type DeferredRegistrationsErrorCallback = (errorsObject: DeferredRegistrationsErrorsObject) => void;\n\nexport interface UseDeferredRegistrationsOptions {\n    onError?: DeferredRegistrationsErrorCallback;\n}\n\nfunction hasError({ localModuleErrors, remoteModuleErrors }: DeferredRegistrationsErrorsObject) {\n    return localModuleErrors.length > 0 || remoteModuleErrors.length > 0;\n}\n\nexport function useDeferredRegistrations(data: unknown, { onError }: UseDeferredRegistrationsOptions = {}) {\n    const runtime = useRuntime();\n\n    const canRegisterDeferredRegistrations = useCanRegisterDeferredRegistrations();\n    const canUpdateDeferredRegistrations = useCanUpdateDeferredRegistrations();\n\n    const registerDeferredRegistrations = useRegisterDeferredRegistrations();\n    const updateDeferredRegistrations = useUpdateDeferredRegistrations();\n\n    useEffect(() => {\n        if (canRegisterDeferredRegistrations) {\n            const register = async () => {\n                const errors = await registerDeferredRegistrations(data, runtime);\n\n                if (hasError(errors) && onError) {\n                    onError(errors);\n                }\n            };\n\n            register();\n        }\n    }, [canRegisterDeferredRegistrations, registerDeferredRegistrations, data, onError, runtime]);\n\n    useEffect(() => {\n        if (canUpdateDeferredRegistrations) {\n            const update = async () => {\n                const errors = await updateDeferredRegistrations(data, runtime);\n\n                if (hasError(errors) && onError) {\n                    onError(errors);\n                }\n            };\n\n            update();\n        }\n    }, [canUpdateDeferredRegistrations, updateDeferredRegistrations, data, onError, runtime]);\n}\n"],"names":["useRuntime","useEffect","useCanRegisterDeferredRegistrations","useCanUpdateDeferredRegistrations","useRegisterDeferredRegistrations","useUpdateDeferredRegistrations","hasError","localModuleErrors","remoteModuleErrors","useDeferredRegistrations","data","onError","runtime","canRegisterDeferredRegistrations","canUpdateDeferredRegistrations","registerDeferredRegistrations","updateDeferredRegistrations","register","errors","update"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAwE;AACtC;AAC6D;AACJ;AACF;AACJ;AAarF,SAASM,SAAS,EAAEC,iBAAiB,EAAEC,kBAAkB,EAAqC;IAC1F,OAAOD,kBAAkB,MAAM,GAAG,KAAKC,mBAAmB,MAAM,GAAG;AACvE;AAEO,SAASC,yBAAyBC,IAAa,EAAE,EAAEC,OAAO,EAAmC,GAAG,CAAC,CAAC;IACrG,MAAMC,UAAUZ,sEAAUA;IAE1B,MAAMa,mCAAmCX,oHAAmCA;IAC5E,MAAMY,iCAAiCX,gHAAiCA;IAExE,MAAMY,gCAAgCX,8GAAgCA;IACtE,MAAMY,8BAA8BX,0GAA8BA;IAElEJ,+CAASA,CAAC;QACN,IAAIY,kCAAkC;YAClC,MAAMI,WAAW;gBACb,MAAMC,SAAS,MAAMH,8BAA8BL,MAAME;gBAEzD,IAAIN,SAASY,WAAWP,SAAS;oBAC7BA,QAAQO;gBACZ;YACJ;YAEAD;QACJ;IACJ,GAAG;QAACJ;QAAkCE;QAA+BL;QAAMC;QAASC;KAAQ;IAE5FX,+CAASA,CAAC;QACN,IAAIa,gCAAgC;YAChC,MAAMK,SAAS;gBACX,MAAMD,SAAS,MAAMF,4BAA4BN,MAAME;gBAEvD,IAAIN,SAASY,WAAWP,SAAS;oBAC7BA,QAAQO;gBACZ;YACJ;YAEAC;QACJ;IACJ,GAAG;QAACL;QAAgCE;QAA6BN;QAAMC;QAASC;KAAQ;AAC5F"}

package/dist/useExecuteOnce.d.ts

@@ -1,3 +1 @@
-declare function useExecuteOnce(fct: () => boolean, inline?: boolean): () => void;
-
-export { useExecuteOnce };
+export declare function useExecuteOnce(fct: () => boolean, inline?: boolean): () => void;

package/dist/useExecuteOnce.js

@@ -1 +1,29 @@
-export { useExecuteOnce } from './chunk-TURKCH7J.js';
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: ./src/useExecuteOnce.ts?__rslib_entry__
+
+// Not using useEffect or useLayoutEffect because this utility hook is often used to dispatch events
+// and it messed with the events dispatch order.
+function useExecuteOnce(fct, inline = false) {
+    const triggered = (0,__WEBPACK_EXTERNAL_MODULE_react__.useRef)(false);
+    const onceFct = (0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (!triggered.current) {
+            const result = fct();
+            if (result) {
+                triggered.current = true;
+            }
+        }
+    }, [
+        fct
+    ]);
+    if (inline) {
+        onceFct();
+    }
+    return onceFct;
+}
+
+export { useExecuteOnce };
+
+//# sourceMappingURL=useExecuteOnce.js.map

package/dist/useExecuteOnce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useExecuteOnce.js","sources":["webpack://@squide/firefly/./src/useExecuteOnce.ts"],"sourcesContent":["import { useCallback, useRef } from \"react\";\n\n// Not using useEffect or useLayoutEffect because this utility hook is often used to dispatch events\n// and it messed with the events dispatch order.\nexport function useExecuteOnce(fct: () => boolean, inline: boolean = false) {\n    const triggered = useRef(false);\n\n    const onceFct = useCallback(() => {\n        if (!triggered.current) {\n            const result = fct();\n\n            if (result) {\n                triggered.current = true;\n            }\n        }\n    }, [fct]);\n\n    if (inline) {\n        onceFct();\n    }\n\n    return onceFct;\n}\n"],"names":["useCallback","useRef","useExecuteOnce","fct","inline","triggered","onceFct","result"],"mappings":";;;;;AAA4C;AAE5C,oGAAoG;AACpG,gDAAgD;AACzC,SAASE,eAAeC,GAAkB,EAAEC,SAAkB,KAAK;IACtE,MAAMC,YAAYJ,4CAAMA,CAAC;IAEzB,MAAMK,UAAUN,iDAAWA,CAAC;QACxB,IAAI,CAACK,UAAU,OAAO,EAAE;YACpB,MAAME,SAASJ;YAEf,IAAII,QAAQ;gBACRF,UAAU,OAAO,GAAG;YACxB;QACJ;IACJ,GAAG;QAACF;KAAI;IAER,IAAIC,QAAQ;QACRE;IACJ;IAEA,OAAOA;AACX"}

package/dist/useIsActiveRouteProtected.d.ts

@@ -1,3 +1 @@
-declare function useIsActiveRouteProtected(areModulesReady: boolean): boolean;
-
-export { useIsActiveRouteProtected };
+export declare function useIsActiveRouteProtected(areModulesReady: boolean): boolean;

package/dist/useIsActiveRouteProtected.js

@@ -1 +1,23 @@
-export { useIsActiveRouteProtected } from './chunk-PP3MRMJJ.js';
+import * as __WEBPACK_EXTERNAL_MODULE__react_router_src_index_js_ff6a88b1__ from "../../react-router/src/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE_react_router_dom_5358f3fe__ from "react-router-dom";
+
+;// CONCATENATED MODULE: external "../../react-router/src/index.js"
+
+;// CONCATENATED MODULE: external "react-router-dom"
+
+;// CONCATENATED MODULE: ./src/useIsActiveRouteProtected.ts?__rslib_entry__
+
+
+function useIsActiveRouteProtected(areModulesReady) {
+    // Using this hook instead of window.location to retrieve the current location because it triggers a re-render everytime the browser location change.
+    const location = (0,__WEBPACK_EXTERNAL_MODULE_react_router_dom_5358f3fe__.useLocation)();
+    // Only throw when there's no match if the modules are ready, otherwise it's expected that no route will be found since they are not all registered yet.
+    const activeRoute = (0,__WEBPACK_EXTERNAL_MODULE__react_router_src_index_js_ff6a88b1__.useRouteMatch)(location, {
+        throwWhenThereIsNoMatch: areModulesReady
+    });
+    return (0,__WEBPACK_EXTERNAL_MODULE__react_router_src_index_js_ff6a88b1__.useIsRouteProtected)(activeRoute);
+}
+
+export { useIsActiveRouteProtected };
+
+//# sourceMappingURL=useIsActiveRouteProtected.js.map

package/dist/useIsActiveRouteProtected.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsActiveRouteProtected.js","sources":["webpack://@squide/firefly/./src/useIsActiveRouteProtected.ts"],"sourcesContent":["import { useIsRouteProtected, useRouteMatch } from \"@squide/react-router\";\nimport { useLocation } from \"react-router-dom\";\n\nexport function useIsActiveRouteProtected(areModulesReady: boolean) {\n    // Using this hook instead of window.location to retrieve the current location because it triggers a re-render everytime the browser location change.\n    const location = useLocation();\n\n    // Only throw when there's no match if the modules are ready, otherwise it's expected that no route will be found since they are not all registered yet.\n    const activeRoute = useRouteMatch(location, { throwWhenThereIsNoMatch: areModulesReady });\n\n    return useIsRouteProtected(activeRoute);\n}\n"],"names":["useIsRouteProtected","useRouteMatch","useLocation","useIsActiveRouteProtected","areModulesReady","location","activeRoute"],"mappings":";;;;;;;;AAA0E;AAC3B;AAExC,SAASG,0BAA0BC,eAAwB;IAC9D,qJAAqJ;IACrJ,MAAMC,WAAWH,qEAAWA;IAE5B,wJAAwJ;IACxJ,MAAMI,cAAcL,iFAAaA,CAACI,UAAU;QAAE,yBAAyBD;IAAgB;IAEvF,OAAOJ,uFAAmBA,CAACM;AAC/B"}

package/dist/useIsBootstrapping.d.ts

@@ -1,7 +1,3 @@
-import { AppRouterState } from './AppRouterReducer.js';
-import 'react';
-
-declare function useIsBootstrapping(): boolean;
-declare function isApplicationBootstrapping(state: AppRouterState): boolean;
-
-export { isApplicationBootstrapping, useIsBootstrapping };
+import type { AppRouterState } from "./AppRouterReducer.ts";
+export declare function useIsBootstrapping(): boolean;
+export declare function isApplicationBootstrapping(state: AppRouterState): boolean;

package/dist/useIsBootstrapping.js

@@ -1,2 +1,22 @@
-export { isApplicationBootstrapping, useIsBootstrapping } from './chunk-H2ILEMPE.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__ from "./AppRouterContext.js";
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: ./src/useIsBootstrapping.ts?__rslib_entry__
+
+function useIsBootstrapping() {
+    const state = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__.useAppRouterState)();
+    return isApplicationBootstrapping(state);
+}
+function isApplicationBootstrapping(state) {
+    const { waitForMsw, waitForPublicData, waitForProtectedData, areModulesReady, isMswReady, isPublicDataReady, isProtectedDataReady, activeRouteVisibility, isUnauthorized } = state;
+    const isAppReady = !isUnauthorized && areModulesReady && (!waitForMsw || isMswReady) && (!waitForPublicData || isPublicDataReady) && (!waitForProtectedData || activeRouteVisibility === "public" || isProtectedDataReady);
+    // When an API request returns a 401, the bootstrapping should be bypassed to render the login page.
+    const flush = // Only applicable when there's a unauthorized request while fetching the initial data.
+    isUnauthorized && (!waitForMsw || isMswReady) && (!waitForPublicData || isPublicDataReady);
+    return !isAppReady && !flush;
+}
+
+export { isApplicationBootstrapping, useIsBootstrapping };
+
+//# sourceMappingURL=useIsBootstrapping.js.map

package/dist/useIsBootstrapping.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useIsBootstrapping.js","sources":["webpack://@squide/firefly/./src/useIsBootstrapping.ts"],"sourcesContent":["import { useAppRouterState } from \"./AppRouterContext.ts\";\nimport type { AppRouterState } from \"./AppRouterReducer.ts\";\n\nexport function useIsBootstrapping() {\n    const state = useAppRouterState();\n\n    return isApplicationBootstrapping(state);\n}\n\nexport function isApplicationBootstrapping(state: AppRouterState) {\n    const {\n        waitForMsw,\n        waitForPublicData,\n        waitForProtectedData,\n        areModulesReady,\n        isMswReady,\n        isPublicDataReady,\n        isProtectedDataReady,\n        activeRouteVisibility,\n        isUnauthorized\n    } = state;\n\n    const isAppReady = (\n        !isUnauthorized\n        // Wait until the modules has been registered and the deferred registrations has been registered if any.\n        && areModulesReady\n        // Not required but can sometimes prevent a re-render when the state value is somehow updated after the initial data is ready.\n        && (!waitForMsw || isMswReady)\n        // Wait for the initial data to be ready.\n        && (!waitForPublicData || isPublicDataReady)\n        && (!waitForProtectedData || activeRouteVisibility === \"public\" || isProtectedDataReady)\n    );\n\n    // When an API request returns a 401, the bootstrapping should be bypassed to render the login page.\n    const flush = (\n        // Only applicable when there's a unauthorized request while fetching the initial data.\n        isUnauthorized\n        // Not required but can sometimes prevent a re-render when the state value is somehow updated after the public data is ready.\n        && (!waitForMsw || isMswReady)\n        // If the application is loading public data, we want to wait for this data to be ready to prevent a re-render.\n        && (!waitForPublicData || isPublicDataReady)\n    );\n\n    return !isAppReady && !flush;\n}\n"],"names":["useAppRouterState","useIsBootstrapping","state","isApplicationBootstrapping","waitForMsw","waitForPublicData","waitForProtectedData","areModulesReady","isMswReady","isPublicDataReady","isProtectedDataReady","activeRouteVisibility","isUnauthorized","isAppReady","flush"],"mappings":";;;;;AAA0D;AAGnD,SAASC;IACZ,MAAMC,QAAQF,+EAAiBA;IAE/B,OAAOG,2BAA2BD;AACtC;AAEO,SAASC,2BAA2BD,KAAqB;IAC5D,MAAM,EACFE,UAAU,EACVC,iBAAiB,EACjBC,oBAAoB,EACpBC,eAAe,EACfC,UAAU,EACVC,iBAAiB,EACjBC,oBAAoB,EACpBC,qBAAqB,EACrBC,cAAc,EACjB,GAAGV;IAEJ,MAAMW,aACF,CAACD,kBAEEL,mBAEC,EAACH,cAAcI,UAAS,KAExB,EAACH,qBAAqBI,iBAAgB,KACtC,EAACH,wBAAwBK,0BAA0B,YAAYD,oBAAmB;IAG1F,oGAAoG;IACpG,MAAMI,QACF,uFAAuF;IACvFF,kBAEI,EAACR,cAAcI,UAAS,KAExB,EAACH,qBAAqBI,iBAAgB;IAG9C,OAAO,CAACI,cAAc,CAACC;AAC3B"}

package/dist/useNavigationItems.d.ts

@@ -1,7 +1,3 @@
-import * as _squide_react_router from '@squide/react-router';
-import { UseRuntimeNavigationItemsOptions } from '@squide/react-router';
-
-type UseNavigationItemsOptions = UseRuntimeNavigationItemsOptions;
-declare function useNavigationItems(options?: UseNavigationItemsOptions): _squide_react_router.RootNavigationItem[];
-
-export { type UseNavigationItemsOptions, useNavigationItems };
+import { type UseRuntimeNavigationItemsOptions } from "@squide/react-router";
+export type UseNavigationItemsOptions = UseRuntimeNavigationItemsOptions;
+export declare function useNavigationItems(options?: UseNavigationItemsOptions): import("@squide/react-router").RootNavigationItem[];

package/dist/useNavigationItems.js

@@ -1,2 +1,26 @@
-export { useNavigationItems } from './chunk-GXSW4CZS.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__react_router_src_index_js_ff6a88b1__ from "../../react-router/src/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__ from "./AppRouterContext.js";
+
+;// CONCATENATED MODULE: external "../../react-router/src/index.js"
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: ./src/useNavigationItems.ts?__rslib_entry__
+
+
+function useNavigationItems(options) {
+    // This is not the most sophisticated strategy but it seems to be good enough for now.
+    // The idea is that when deferred registrations are used by the consumer applications, the deferred registrations could
+    // be updated when the global data is updated. If the deferred registrations are updated, it means that the registered
+    // navigation items might have been updated and a re-render must happens to display the new navigation items.
+    // Since the "deferredRegistrationsUpdatedAt" state value of the AppRouterReducer is updated everytime the deferred registrations
+    // are updated, subscribing to the state with useAppRouterState ensure that the navigation items will be re-rendered.
+    // A more sophisticated strategy could be implemented later on if needed, something involving a subscription to the "runtime" changes, or
+    // even introducing new module states.
+    (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__.useAppRouterState)();
+    return (0,__WEBPACK_EXTERNAL_MODULE__react_router_src_index_js_ff6a88b1__.useRuntimeNavigationItems)(options);
+}
+
+export { useNavigationItems };
+
+//# sourceMappingURL=useNavigationItems.js.map

package/dist/useNavigationItems.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useNavigationItems.js","sources":["webpack://@squide/firefly/./src/useNavigationItems.ts"],"sourcesContent":["import { useRuntimeNavigationItems, type UseRuntimeNavigationItemsOptions } from \"@squide/react-router\";\nimport { useAppRouterState } from \"./AppRouterContext.ts\";\n\nexport type UseNavigationItemsOptions = UseRuntimeNavigationItemsOptions;\n\nexport function useNavigationItems(options?: UseNavigationItemsOptions) {\n    // This is not the most sophisticated strategy but it seems to be good enough for now.\n    // The idea is that when deferred registrations are used by the consumer applications, the deferred registrations could\n    // be updated when the global data is updated. If the deferred registrations are updated, it means that the registered\n    // navigation items might have been updated and a re-render must happens to display the new navigation items.\n    // Since the \"deferredRegistrationsUpdatedAt\" state value of the AppRouterReducer is updated everytime the deferred registrations\n    // are updated, subscribing to the state with useAppRouterState ensure that the navigation items will be re-rendered.\n    // A more sophisticated strategy could be implemented later on if needed, something involving a subscription to the \"runtime\" changes, or\n    // even introducing new module states.\n    useAppRouterState();\n\n    return useRuntimeNavigationItems(options);\n}\n"],"names":["useRuntimeNavigationItems","useAppRouterState","useNavigationItems","options"],"mappings":";;;;;;;;AAAwG;AAC9C;AAInD,SAASE,mBAAmBC,OAAmC;IAClE,sFAAsF;IACtF,uHAAuH;IACvH,sHAAsH;IACtH,6GAA6G;IAC7G,iIAAiI;IACjI,qHAAqH;IACrH,yIAAyI;IACzI,sCAAsC;IACtCF,+EAAiBA;IAEjB,OAAOD,6FAAyBA,CAACG;AACrC"}

package/dist/useProtectedDataQueries.d.ts

@@ -1,11 +1,9 @@
-import { QueriesOptions, QueriesResults, UseQueryResult } from '@tanstack/react-query';
-
-declare const ProtectedDataFetchStartedEvent = "squide-protected-data-fetch-started";
-declare const ProtectedDataFetchFailedEvent = "squide-protected-data-fetch-failed";
-type IsUnauthorizedErrorCallback = (error: unknown) => boolean;
+import { type QueriesOptions, type QueriesResults, type UseQueryResult } from "@tanstack/react-query";
+export declare const ProtectedDataFetchStartedEvent = "squide-protected-data-fetch-started";
+export declare const ProtectedDataFetchFailedEvent = "squide-protected-data-fetch-failed";
+export type IsUnauthorizedErrorCallback = (error: unknown) => boolean;
 type MapUseQueryResultToData<T> = {
     [K in keyof T]: T[K] extends UseQueryResult<infer U> ? U : never;
 };
-declare function useProtectedDataQueries<T extends Array<any>>(queries: QueriesOptions<T>, isUnauthorizedError: IsUnauthorizedErrorCallback): MapUseQueryResultToData<QueriesResults<T>>;
-
-export { type IsUnauthorizedErrorCallback, ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries };
+export declare function useProtectedDataQueries<T extends Array<any>>(queries: QueriesOptions<T>, isUnauthorizedError: IsUnauthorizedErrorCallback): MapUseQueryResultToData<QueriesResults<T>>;
+export {};

package/dist/useProtectedDataQueries.js

@@ -1,5 +1,126 @@
-export { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries } from './chunk-MKTGJHQR.js';
-import './chunk-XDWYPVAJ.js';
-import './chunk-TURKCH7J.js';
-import './chunk-HE5HKFL3.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__core_src_index_js_d19dd8a6__ from "../../core/src/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__tanstack_react_query_db705f77__ from "@tanstack/react-query";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__ from "./AppRouterContext.js";
+import * as __WEBPACK_EXTERNAL_MODULE__GlobalDataQueriesError_js_0c24ca62__ from "./GlobalDataQueriesError.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useCanFetchProtectedData_js_52158d16__ from "./useCanFetchProtectedData.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js_e1f8f91b__ from "./useExecuteOnce.js";
+
+;// CONCATENATED MODULE: external "../../core/src/index.js"
+
+;// CONCATENATED MODULE: external "@tanstack/react-query"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: external "./GlobalDataQueriesError.js"
+
+;// CONCATENATED MODULE: external "./useCanFetchProtectedData.js"
+
+;// CONCATENATED MODULE: external "./useExecuteOnce.js"
+
+;// CONCATENATED MODULE: ./src/useProtectedDataQueries.ts?__rslib_entry__
+
+
+
+
+
+
+
+const ProtectedDataFetchStartedEvent = "squide-protected-data-fetch-started";
+const ProtectedDataFetchFailedEvent = "squide-protected-data-fetch-failed";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function useProtectedDataQueries(queries, isUnauthorizedError) {
+    const canFetchProtectedData = (0,__WEBPACK_EXTERNAL_MODULE__useCanFetchProtectedData_js_52158d16__.useCanFetchProtectedData)();
+    const eventBus = (0,__WEBPACK_EXTERNAL_MODULE__core_src_index_js_d19dd8a6__.useEventBus)();
+    const dispatch = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__.useAppRouterDispatcher)();
+    const combineResults = (0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)((results)=>{
+        const errors = results.filter((x)=>x.error).map((x)=>x.error);
+        const hasErrors = errors.length > 0;
+        return {
+            data: results.map((x)=>x.data),
+            errors,
+            hasErrors,
+            isReady: !hasErrors && !results.some((x)=>x.isPending)
+        };
+    }, []);
+    const { data, errors: queriesErrors, hasErrors, isReady } = (0,__WEBPACK_EXTERNAL_MODULE__tanstack_react_query_db705f77__.useQueries)({
+        queries: queries.map((x)=>({
+                enabled: canFetchProtectedData,
+                ...x
+            })),
+        combine: combineResults
+    });
+    const { isProtectedDataReady, isUnauthorized } = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__.useAppRouterState)();
+    (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js_e1f8f91b__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (canFetchProtectedData) {
+            eventBus.dispatch(ProtectedDataFetchStartedEvent);
+            return true;
+        }
+        return false;
+    }, [
+        canFetchProtectedData,
+        eventBus
+    ]), true);
+    // Using a ref seems to be the only way to prevent starting two deferred registrations scope.
+    const isReadyRef = (0,__WEBPACK_EXTERNAL_MODULE_react__.useRef)(false);
+    const dispatchReady = (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js_e1f8f91b__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (isReady) {
+            isReadyRef.current = true;
+            dispatch({
+                type: "protected-data-ready"
+            });
+            return true;
+        }
+        return false;
+    }, [
+        isReady,
+        dispatch
+    ]));
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        // State update must be executed in useEffect.
+        dispatchReady();
+    }, [
+        dispatchReady
+    ]);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (isReadyRef.current && data) {
+            dispatch({
+                type: "protected-data-updated"
+            });
+        }
+    }, [
+        data,
+        dispatch
+    ]);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (hasErrors) {
+            if (!isProtectedDataReady && !isUnauthorized && queriesErrors.some((x)=>isUnauthorizedError(x))) {
+                // Will transition the state to allow the routes to render even if the bootstrapping is not complete, because otherwise
+                // a login page for example could not be rendered.
+                dispatch({
+                    type: "is-unauthorized"
+                });
+            }
+            // Otherwise, when a user is logged off, a refetch might throws a 401.
+            if (!queriesErrors.every((x)=>isUnauthorizedError(x))) {
+                eventBus.dispatch(ProtectedDataFetchFailedEvent, queriesErrors);
+                throw new __WEBPACK_EXTERNAL_MODULE__GlobalDataQueriesError_js_0c24ca62__.GlobalDataQueriesError("[squide] Global protected data queries failed.", queriesErrors);
+            }
+        }
+    }, [
+        hasErrors,
+        queriesErrors,
+        isProtectedDataReady,
+        isUnauthorized,
+        isUnauthorizedError,
+        dispatch,
+        eventBus
+    ]);
+    return data;
+}
+
+export { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent, useProtectedDataQueries };
+
+//# sourceMappingURL=useProtectedDataQueries.js.map

package/dist/useProtectedDataQueries.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useProtectedDataQueries.js","sources":["webpack://@squide/firefly/./src/useProtectedDataQueries.ts"],"sourcesContent":["import { useEventBus } from \"@squide/core\";\nimport { useQueries, type QueriesOptions, type QueriesResults, type UseQueryResult } from \"@tanstack/react-query\";\nimport { useCallback, useEffect, useRef } from \"react\";\nimport { useAppRouterDispatcher, useAppRouterState } from \"./AppRouterContext.ts\";\nimport { GlobalDataQueriesError } from \"./GlobalDataQueriesError.ts\";\nimport { useCanFetchProtectedData } from \"./useCanFetchProtectedData.ts\";\nimport { useExecuteOnce } from \"./useExecuteOnce.ts\";\n\nexport const ProtectedDataFetchStartedEvent = \"squide-protected-data-fetch-started\";\nexport const ProtectedDataFetchFailedEvent = \"squide-protected-data-fetch-failed\";\n\nexport type IsUnauthorizedErrorCallback = (error: unknown) => boolean;\n\n// This converts an array of UseQueryResult to an array of the data type of each query result.\n// For more information, view: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-1.html#mapped-types-on-tuples-and-arrays.\ntype MapUseQueryResultToData<T> = { [K in keyof T]: T[K] extends UseQueryResult<infer U> ? U : never };\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function useProtectedDataQueries<T extends Array<any>>(queries: QueriesOptions<T>, isUnauthorizedError: IsUnauthorizedErrorCallback): MapUseQueryResultToData<QueriesResults<T>> {\n    const canFetchProtectedData = useCanFetchProtectedData();\n    const eventBus = useEventBus();\n\n    const dispatch = useAppRouterDispatcher();\n\n    const combineResults = useCallback((results: UseQueryResult<unknown, Error>[]) => {\n        const errors = results.filter(x => x.error).map(x => x.error) as Error[];\n        const hasErrors = errors.length > 0;\n\n        return {\n            data: results.map(x => x.data) as MapUseQueryResultToData<QueriesResults<T>>,\n            errors,\n            hasErrors,\n            isReady: !hasErrors && !results.some(x => x.isPending)\n        };\n    }, []);\n\n    const { data, errors: queriesErrors, hasErrors, isReady } = useQueries({\n        queries: queries.map(x => ({\n            enabled: canFetchProtectedData,\n            ...x\n        })),\n        combine: combineResults\n    });\n\n    const { isProtectedDataReady, isUnauthorized } = useAppRouterState();\n\n    useExecuteOnce(useCallback(() => {\n        if (canFetchProtectedData) {\n            eventBus.dispatch(ProtectedDataFetchStartedEvent);\n\n            return true;\n        }\n\n        return false;\n    }, [canFetchProtectedData, eventBus]), true);\n\n    // Using a ref seems to be the only way to prevent starting two deferred registrations scope.\n    const isReadyRef = useRef(false);\n\n    const dispatchReady = useExecuteOnce(useCallback(() => {\n        if (isReady) {\n            isReadyRef.current = true;\n\n            dispatch({ type: \"protected-data-ready\" });\n\n            return true;\n        }\n\n        return false;\n    }, [isReady, dispatch]));\n\n    useEffect(() => {\n        // State update must be executed in useEffect.\n        dispatchReady();\n    }, [dispatchReady]);\n\n    useEffect(() => {\n        if (isReadyRef.current && data) {\n            dispatch({ type: \"protected-data-updated\" });\n        }\n    }, [data, dispatch]);\n\n    useEffect(() => {\n        if (hasErrors) {\n            if (!isProtectedDataReady && !isUnauthorized && queriesErrors.some(x => isUnauthorizedError(x))) {\n                // Will transition the state to allow the routes to render even if the bootstrapping is not complete, because otherwise\n                // a login page for example could not be rendered.\n                dispatch({ type: \"is-unauthorized\" });\n            }\n\n            // Otherwise, when a user is logged off, a refetch might throws a 401.\n            if (!queriesErrors.every(x => isUnauthorizedError(x))) {\n                eventBus.dispatch(ProtectedDataFetchFailedEvent, queriesErrors);\n\n                throw new GlobalDataQueriesError(\"[squide] Global protected data queries failed.\", queriesErrors);\n            }\n        }\n    }, [hasErrors, queriesErrors, isProtectedDataReady, isUnauthorized, isUnauthorizedError, dispatch, eventBus]);\n\n    return data;\n}\n"],"names":["useEventBus","useQueries","useCallback","useEffect","useRef","useAppRouterDispatcher","useAppRouterState","GlobalDataQueriesError","useCanFetchProtectedData","useExecuteOnce","ProtectedDataFetchStartedEvent","ProtectedDataFetchFailedEvent","useProtectedDataQueries","queries","isUnauthorizedError","canFetchProtectedData","eventBus","dispatch","combineResults","results","errors","x","hasErrors","data","queriesErrors","isReady","isProtectedDataReady","isUnauthorized","isReadyRef","dispatchReady"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAA2C;AACuE;AAC3D;AAC2B;AACb;AACI;AACpB;AAE9C,MAAMU,iCAAiC,sCAAsC;AAC7E,MAAMC,gCAAgC,qCAAqC;AAQlF,8DAA8D;AACvD,SAASC,wBAA8CC,OAA0B,EAAEC,mBAAgD;IACtI,MAAMC,wBAAwBP,8FAAwBA;IACtD,MAAMQ,WAAWhB,uEAAWA;IAE5B,MAAMiB,WAAWZ,oFAAsBA;IAEvC,MAAMa,iBAAiBhB,iDAAWA,CAAC,CAACiB;QAChC,MAAMC,SAASD,QAAQ,MAAM,CAACE,CAAAA,IAAKA,EAAE,KAAK,EAAE,GAAG,CAACA,CAAAA,IAAKA,EAAE,KAAK;QAC5D,MAAMC,YAAYF,OAAO,MAAM,GAAG;QAElC,OAAO;YACH,MAAMD,QAAQ,GAAG,CAACE,CAAAA,IAAKA,EAAE,IAAI;YAC7BD;YACAE;YACA,SAAS,CAACA,aAAa,CAACH,QAAQ,IAAI,CAACE,CAAAA,IAAKA,EAAE,SAAS;QACzD;IACJ,GAAG,EAAE;IAEL,MAAM,EAAEE,IAAI,EAAE,QAAQC,aAAa,EAAEF,SAAS,EAAEG,OAAO,EAAE,GAAGxB,yEAAUA,CAAC;QACnE,SAASY,QAAQ,GAAG,CAACQ,CAAAA,IAAM;gBACvB,SAASN;gBACT,GAAGM,CAAC;YACR;QACA,SAASH;IACb;IAEA,MAAM,EAAEQ,oBAAoB,EAAEC,cAAc,EAAE,GAAGrB,+EAAiBA;IAElEG,0EAAcA,CAACP,iDAAWA,CAAC;QACvB,IAAIa,uBAAuB;YACvBC,SAAS,QAAQ,CAACN;YAElB,OAAO;QACX;QAEA,OAAO;IACX,GAAG;QAACK;QAAuBC;KAAS,GAAG;IAEvC,6FAA6F;IAC7F,MAAMY,aAAaxB,4CAAMA,CAAC;IAE1B,MAAMyB,gBAAgBpB,0EAAcA,CAACP,iDAAWA,CAAC;QAC7C,IAAIuB,SAAS;YACTG,WAAW,OAAO,GAAG;YAErBX,SAAS;gBAAE,MAAM;YAAuB;YAExC,OAAO;QACX;QAEA,OAAO;IACX,GAAG;QAACQ;QAASR;KAAS;IAEtBd,+CAASA,CAAC;QACN,8CAA8C;QAC9C0B;IACJ,GAAG;QAACA;KAAc;IAElB1B,+CAASA,CAAC;QACN,IAAIyB,WAAW,OAAO,IAAIL,MAAM;YAC5BN,SAAS;gBAAE,MAAM;YAAyB;QAC9C;IACJ,GAAG;QAACM;QAAMN;KAAS;IAEnBd,+CAASA,CAAC;QACN,IAAImB,WAAW;YACX,IAAI,CAACI,wBAAwB,CAACC,kBAAkBH,cAAc,IAAI,CAACH,CAAAA,IAAKP,oBAAoBO,KAAK;gBAC7F,uHAAuH;gBACvH,kDAAkD;gBAClDJ,SAAS;oBAAE,MAAM;gBAAkB;YACvC;YAEA,sEAAsE;YACtE,IAAI,CAACO,cAAc,KAAK,CAACH,CAAAA,IAAKP,oBAAoBO,KAAK;gBACnDL,SAAS,QAAQ,CAACL,+BAA+Ba;gBAEjD,MAAM,IAAIjB,sFAAsBA,CAAC,kDAAkDiB;YACvF;QACJ;IACJ,GAAG;QAACF;QAAWE;QAAeE;QAAsBC;QAAgBb;QAAqBG;QAAUD;KAAS;IAE5G,OAAOO;AACX"}

package/dist/usePublicDataQueries.d.ts

@@ -1,10 +1,8 @@
-import { QueriesOptions, QueriesResults, UseQueryResult } from '@tanstack/react-query';
-
-declare const PublicDataFetchStartedEvent = "squide-public-data-fetch-started";
-declare const PublicDataFetchFailedEvent = "squide-public-data-fetch-failed";
+import { type QueriesOptions, type QueriesResults, type UseQueryResult } from "@tanstack/react-query";
+export declare const PublicDataFetchStartedEvent = "squide-public-data-fetch-started";
+export declare const PublicDataFetchFailedEvent = "squide-public-data-fetch-failed";
 type MapUseQueryResultToData<T> = {
     [K in keyof T]: T[K] extends UseQueryResult<infer U> ? U : never;
 };
-declare function usePublicDataQueries<T extends Array<any>>(queries: QueriesOptions<T>): MapUseQueryResultToData<QueriesResults<T>>;
-
-export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries };
+export declare function usePublicDataQueries<T extends Array<any>>(queries: QueriesOptions<T>): MapUseQueryResultToData<QueriesResults<T>>;
+export {};

package/dist/usePublicDataQueries.js

@@ -1,5 +1,111 @@
-export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries } from './chunk-CTLPFYLM.js';
-import './chunk-IOMSOUAL.js';
-import './chunk-TURKCH7J.js';
-import './chunk-HE5HKFL3.js';
-import './chunk-G32YX2KR.js';
+import * as __WEBPACK_EXTERNAL_MODULE__core_src_index_js_d19dd8a6__ from "../../core/src/index.js";
+import * as __WEBPACK_EXTERNAL_MODULE__tanstack_react_query_db705f77__ from "@tanstack/react-query";
+import * as __WEBPACK_EXTERNAL_MODULE_react__ from "react";
+import * as __WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__ from "./AppRouterContext.js";
+import * as __WEBPACK_EXTERNAL_MODULE__GlobalDataQueriesError_js_0c24ca62__ from "./GlobalDataQueriesError.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useCanFetchPublicData_js_b8d90132__ from "./useCanFetchPublicData.js";
+import * as __WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js_e1f8f91b__ from "./useExecuteOnce.js";
+
+;// CONCATENATED MODULE: external "../../core/src/index.js"
+
+;// CONCATENATED MODULE: external "@tanstack/react-query"
+
+;// CONCATENATED MODULE: external "react"
+
+;// CONCATENATED MODULE: external "./AppRouterContext.js"
+
+;// CONCATENATED MODULE: external "./GlobalDataQueriesError.js"
+
+;// CONCATENATED MODULE: external "./useCanFetchPublicData.js"
+
+;// CONCATENATED MODULE: external "./useExecuteOnce.js"
+
+;// CONCATENATED MODULE: ./src/usePublicDataQueries.ts?__rslib_entry__
+
+
+
+
+
+
+
+const PublicDataFetchStartedEvent = "squide-public-data-fetch-started";
+const PublicDataFetchFailedEvent = "squide-public-data-fetch-failed";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function usePublicDataQueries(queries) {
+    const canFetchPublicData = (0,__WEBPACK_EXTERNAL_MODULE__useCanFetchPublicData_js_b8d90132__.useCanFetchPublicData)();
+    const eventBus = (0,__WEBPACK_EXTERNAL_MODULE__core_src_index_js_d19dd8a6__.useEventBus)();
+    const dispatch = (0,__WEBPACK_EXTERNAL_MODULE__AppRouterContext_js_3c4a3c33__.useAppRouterDispatcher)();
+    const combineResults = (0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)((results)=>{
+        const errors = results.filter((x)=>x.error).map((x)=>x.error);
+        const hasErrors = errors.length > 0;
+        return {
+            data: results.map((x)=>x.data),
+            errors,
+            hasErrors,
+            isReady: !hasErrors && !results.some((x)=>x.isPending)
+        };
+    }, []);
+    const { data, errors: queriesErrors, hasErrors, isReady } = (0,__WEBPACK_EXTERNAL_MODULE__tanstack_react_query_db705f77__.useQueries)({
+        queries: queries.map((x)=>({
+                enabled: canFetchPublicData,
+                ...x
+            })),
+        combine: combineResults
+    });
+    (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js_e1f8f91b__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (canFetchPublicData) {
+            eventBus.dispatch(PublicDataFetchStartedEvent);
+            return true;
+        }
+        return false;
+    }, [
+        canFetchPublicData,
+        eventBus
+    ]), true);
+    // Using a ref seems to be the only way to prevent starting two deferred registrations scope.
+    const isReadyRef = (0,__WEBPACK_EXTERNAL_MODULE_react__.useRef)(false);
+    const dispatchReady = (0,__WEBPACK_EXTERNAL_MODULE__useExecuteOnce_js_e1f8f91b__.useExecuteOnce)((0,__WEBPACK_EXTERNAL_MODULE_react__.useCallback)(()=>{
+        if (isReady) {
+            isReadyRef.current = true;
+            dispatch({
+                type: "public-data-ready"
+            });
+            return true;
+        }
+        return false;
+    }, [
+        isReady,
+        dispatch
+    ]));
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        // State update must be executed in useEffect.
+        dispatchReady();
+    }, [
+        dispatchReady
+    ]);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (isReadyRef.current && data) {
+            dispatch({
+                type: "public-data-updated"
+            });
+        }
+    }, [
+        data,
+        dispatch
+    ]);
+    (0,__WEBPACK_EXTERNAL_MODULE_react__.useEffect)(()=>{
+        if (hasErrors) {
+            eventBus.dispatch(PublicDataFetchFailedEvent, queriesErrors);
+            throw new __WEBPACK_EXTERNAL_MODULE__GlobalDataQueriesError_js_0c24ca62__.GlobalDataQueriesError("[squide] Global public data queries failed.", queriesErrors);
+        }
+    }, [
+        hasErrors,
+        queriesErrors,
+        eventBus
+    ]);
+    return data;
+}
+
+export { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent, usePublicDataQueries };
+
+//# sourceMappingURL=usePublicDataQueries.js.map