@squide/firefly 7.0.0 → 9.0.0

package/dist/chunk-G32YX2KR.js

@@ -0,0 +1,22 @@
+import { isNil } from '@squide/core';
+import { createContext, useContext } from 'react';
+
+// src/AppRouterContext.ts
+var AppRouterStateContext = createContext(void 0);
+function useAppRouterState() {
+  const state = useContext(AppRouterStateContext);
+  if (isNil(state)) {
+    throw new Error("[squide] The useAppRouterState hook must be called by a children of the AppRouter component.");
+  }
+  return state;
+}
+var AppRouterDispatcherContext = createContext(void 0);
+function useAppRouterDispatcher() {
+  const dispatch = useContext(AppRouterDispatcherContext);
+  if (isNil(dispatch)) {
+    throw new Error("[squide] The useAppRouterDispatcher hook must be called by a children of the AppRouter component.");
+  }
+  return dispatch;
+}
+
+export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState };

package/dist/chunk-H6F7HDB3.js

@@ -0,0 +1,9 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+import { useRuntimeNavigationItems } from '@squide/react-router';
+
+function useNavigationItems() {
+  useAppRouterState();
+  return useRuntimeNavigationItems();
+}
+
+export { useNavigationItems };

package/dist/chunk-HE5HKFL3.js

@@ -0,0 +1,16 @@
+// src/GlobalDataQueriesError.ts
+var GlobalDataQueriesError = class extends Error {
+  #errors;
+  constructor(message, errors) {
+    super(message);
+    this.#errors = errors;
+  }
+  get errors() {
+    return this.#errors;
+  }
+};
+function isGlobalDataQueriesError(error) {
+  return error !== void 0 && error !== null && error instanceof GlobalDataQueriesError;
+}
+
+export { GlobalDataQueriesError, isGlobalDataQueriesError };

package/dist/chunk-I6L3AYOB.js

@@ -0,0 +1,24 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+
+// src/useIsBootstrapping.ts
+function useIsBootstrapping() {
+  const {
+    waitForMsw,
+    waitForPublicData,
+    waitForProtectedData,
+    areModulesReady,
+    isMswReady,
+    isPublicDataReady,
+    isProtectedDataReady,
+    isActiveRouteProtected,
+    isUnauthorized
+  } = useAppRouterState();
+  const isAppReady = !isUnauthorized && areModulesReady && (!waitForMsw || isMswReady) && (!waitForPublicData || isPublicDataReady) && (!waitForProtectedData || !isActiveRouteProtected || isProtectedDataReady);
+  const flush = (
+    // Only applicable when there's a unauthorized request while fetching the initial data.
+    isUnauthorized && (!waitForMsw || isMswReady) && (!waitForPublicData || isPublicDataReady)
+  );
+  return !isAppReady && !flush;
+}
+
+export { useIsBootstrapping };

package/dist/chunk-IOMSOUAL.js

@@ -0,0 +1,20 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+
+// src/useCanFetchPublicData.ts
+function useCanFetchPublicData() {
+  const {
+    waitForMsw,
+    areModulesRegistered,
+    areModulesReady,
+    isMswReady,
+    isPublicDataReady
+  } = useAppRouterState();
+  return (
+    // Always return true when the public data has already been fetched sucessfully so TanStack Query can update the data in the background.
+    isPublicDataReady || // Wait until the modules has been registered, but do not wait for the deferred registrations to be registered has they will probably
+    // depends on the protected data.
+    (areModulesRegistered || areModulesReady) && (!waitForMsw || isMswReady)
+  );
+}
+
+export { useCanFetchPublicData };

package/dist/chunk-L5BP3WP3.js

@@ -0,0 +1,21 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+
+// src/useCanFetchProtectedData.ts
+function useCanFetchProtectedData() {
+  const {
+    waitForMsw,
+    areModulesRegistered,
+    areModulesReady,
+    isMswReady,
+    isProtectedDataReady,
+    isActiveRouteProtected
+  } = useAppRouterState();
+  return (
+    // Always return true when the protected data has already been fetched sucessfully so TanStack Query can update the data in the background.
+    isProtectedDataReady || // Wait until the modules has been registered, but do not wait for the deferred registrations to be registered as they will probably
+    // depends on the protected data.
+    (areModulesRegistered || areModulesReady) && isActiveRouteProtected && (!waitForMsw || isMswReady)
+  );
+}
+
+export { useCanFetchProtectedData };

package/dist/chunk-MZG2PJJG.js

@@ -0,0 +1,19 @@
+import { useIsActiveRouteProtected } from './chunk-PP3MRMJJ.js';
+import { useAppRouterState, useAppRouterDispatcher } from './chunk-G32YX2KR.js';
+import { useEffect } from 'react';
+import { Outlet } from 'react-router-dom';
+import { jsx } from 'react/jsx-runtime';
+
+function RootRoute() {
+  const state = useAppRouterState();
+  const isActiveRouteProtected = useIsActiveRouteProtected(state.areModulesReady);
+  const dispatch = useAppRouterDispatcher();
+  useEffect(() => {
+    if (isActiveRouteProtected) {
+      dispatch({ type: "active-route-is-protected" });
+    }
+  }, [isActiveRouteProtected, dispatch]);
+  return /* @__PURE__ */ jsx(Outlet, {});
+}
+
+export { RootRoute };

package/dist/chunk-N2GOIQ5E.js

@@ -0,0 +1,14 @@
+import { useAppRouterDispatcher } from './chunk-G32YX2KR.js';
+import { updateDeferredRegistrations } from '@squide/module-federation';
+import { useCallback } from 'react';
+
+function useUpdateDeferredRegistrations() {
+  const dispatch = useAppRouterDispatcher();
+  return useCallback(async (data, runtime) => {
+    const errors = await updateDeferredRegistrations(data, runtime);
+    dispatch({ type: "deferred-registrations-updated" });
+    return errors;
+  }, [dispatch]);
+}
+
+export { useUpdateDeferredRegistrations };

package/dist/chunk-PP3MRMJJ.js

@@ -0,0 +1,11 @@
+import { useRouteMatch, useIsRouteProtected } from '@squide/react-router';
+import { useLocation } from 'react-router-dom';
+
+// src/useIsActiveRouteProtected.ts
+function useIsActiveRouteProtected(areModulesReady) {
+  const location = useLocation();
+  const activeRoute = useRouteMatch(location, { throwWhenThereIsNoMatch: areModulesReady });
+  return useIsRouteProtected(activeRoute);
+}
+
+export { useIsActiveRouteProtected };

package/dist/chunk-PU7MASPN.js

@@ -0,0 +1,18 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+
+// src/useCanRegisterDeferredRegistrations.ts
+function useCanRegisterDeferredRegistrations() {
+  const {
+    waitForPublicData,
+    waitForProtectedData,
+    areModulesReady,
+    areModulesRegistered,
+    isPublicDataReady,
+    isProtectedDataReady,
+    isActiveRouteProtected,
+    isUnauthorized
+  } = useAppRouterState();
+  return !isUnauthorized && areModulesRegistered && !areModulesReady && (!waitForPublicData || isPublicDataReady) && (!waitForProtectedData || !isActiveRouteProtected || isProtectedDataReady);
+}
+
+export { useCanRegisterDeferredRegistrations };

package/dist/chunk-RG5N56BQ.js

@@ -0,0 +1,55 @@
+import { GlobalDataQueriesError } from './chunk-HE5HKFL3.js';
+import { useCanFetchProtectedData } from './chunk-L5BP3WP3.js';
+import { useAppRouterDispatcher, useAppRouterState } from './chunk-G32YX2KR.js';
+import { useQueries } from '@tanstack/react-query';
+import { useCallback, useEffect, useRef } from 'react';
+
+function useProtectedDataQueries(queries, isUnauthorizedError) {
+  const canFetchProtectedData = useCanFetchProtectedData();
+  const dispatch = useAppRouterDispatcher();
+  const combineResults = useCallback((results) => {
+    const errors = results.filter((x) => x.error).map((x) => x.error);
+    return {
+      data: results.map((x) => x.data),
+      errors,
+      hasErrors: errors.length > 0,
+      isReady: results.length === queries.length && results.every((x) => x.data)
+    };
+  }, [queries.length]);
+  const { data, errors: queriesErrors, hasErrors, isReady } = useQueries({
+    queries: queries.map((x) => ({
+      enabled: canFetchProtectedData,
+      ...x
+    })),
+    combine: combineResults
+  });
+  const {
+    isProtectedDataReady,
+    isUnauthorized
+  } = useAppRouterState();
+  useEffect(() => {
+    if (hasErrors) {
+      if (!isProtectedDataReady && !isUnauthorized && queriesErrors.some((x) => isUnauthorizedError(x))) {
+        dispatch({ type: "is-unauthorized" });
+      }
+      if (!queriesErrors.every((x) => isUnauthorizedError(x))) {
+        throw new GlobalDataQueriesError("[squide] Global protected data queries failed.", queriesErrors);
+      }
+    }
+  }, [hasErrors, queriesErrors, isProtectedDataReady, isUnauthorized, isUnauthorizedError, dispatch]);
+  const isReadyRef = useRef(false);
+  useEffect(() => {
+    if (isReadyRef.current && data) {
+      dispatch({ type: "protected-data-updated" });
+    }
+  }, [data, dispatch]);
+  useEffect(() => {
+    if (isReady) {
+      isReadyRef.current = true;
+      dispatch({ type: "protected-data-ready" });
+    }
+  }, [isReady, dispatch]);
+  return data;
+}
+
+export { useProtectedDataQueries };

package/dist/chunk-VUMBZ5BP.js

@@ -0,0 +1,46 @@
+import { useCanFetchPublicData } from './chunk-IOMSOUAL.js';
+import { GlobalDataQueriesError } from './chunk-HE5HKFL3.js';
+import { useAppRouterDispatcher } from './chunk-G32YX2KR.js';
+import { useQueries } from '@tanstack/react-query';
+import { useCallback, useEffect, useRef } from 'react';
+
+function usePublicDataQueries(queries) {
+  const canFetchPublicData = useCanFetchPublicData();
+  const dispatch = useAppRouterDispatcher();
+  const combineResults = useCallback((results) => {
+    const errors = results.filter((x) => x.error).map((x) => x.error);
+    return {
+      data: results.map((x) => x.data),
+      errors,
+      hasErrors: errors.length > 0,
+      isReady: results.length === queries.length && results.every((x) => x.data)
+    };
+  }, [queries.length]);
+  const { data, errors: queriesErrors, hasErrors, isReady } = useQueries({
+    queries: queries.map((x) => ({
+      enabled: canFetchPublicData,
+      ...x
+    })),
+    combine: combineResults
+  });
+  useEffect(() => {
+    if (hasErrors) {
+      throw new GlobalDataQueriesError("[squide] Global public data queries failed.", queriesErrors);
+    }
+  }, [hasErrors, queriesErrors]);
+  const isReadyRef = useRef(false);
+  useEffect(() => {
+    if (isReadyRef.current && data) {
+      dispatch({ type: "public-data-updated" });
+    }
+  }, [data, dispatch]);
+  useEffect(() => {
+    if (isReady) {
+      isReadyRef.current = true;
+      dispatch({ type: "public-data-ready" });
+    }
+  }, [isReady, dispatch]);
+  return data;
+}
+
+export { usePublicDataQueries };

package/dist/chunk-WOPD33CM.js

@@ -0,0 +1,25 @@
+import { useRuntime, getLocalModuleRegistrationStatus, addLocalModuleRegistrationStatusChangedListener, removeLocalModuleRegistrationStatusChangedListener } from '@squide/core';
+import { getRemoteModuleRegistrationStatus, areModulesReady, addRemoteModuleRegistrationStatusChangedListener, removeRemoteModuleRegistrationStatusChangedListener } from '@squide/module-federation';
+import { useSyncExternalStore, useEffect } from 'react';
+
+// src/useStrictRegistrationMode.ts
+function subscribeToLocalModuleRegistrationStatusChanged(callback) {
+  addLocalModuleRegistrationStatusChangedListener(callback);
+  return () => removeLocalModuleRegistrationStatusChangedListener(callback);
+}
+function subscribeToRemoteModuleRegistrationStatusChanged(callback) {
+  addRemoteModuleRegistrationStatusChangedListener(callback);
+  return () => removeRemoteModuleRegistrationStatusChangedListener(callback);
+}
+function useStrictRegistrationMode() {
+  const runtime = useRuntime();
+  const localModuleStatus = useSyncExternalStore(subscribeToLocalModuleRegistrationStatusChanged, getLocalModuleRegistrationStatus);
+  const remoteModuleStatus = useSyncExternalStore(subscribeToRemoteModuleRegistrationStatusChanged, getRemoteModuleRegistrationStatus);
+  useEffect(() => {
+    if (areModulesReady(localModuleStatus, remoteModuleStatus)) {
+      runtime._validateRegistrations();
+    }
+  }, [runtime, localModuleStatus, remoteModuleStatus]);
+}
+
+export { useStrictRegistrationMode };

package/dist/chunk-WVRMJZV6.js

@@ -0,0 +1,18 @@
+import { useAppRouterState } from './chunk-G32YX2KR.js';
+
+// src/useCanUpdateDeferredRegistrations.ts
+function useCanUpdateDeferredRegistrations() {
+  const {
+    areModulesReady,
+    publicDataUpdatedAt,
+    protectedDataUpdatedAt,
+    deferredRegistrationsUpdatedAt
+  } = 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 };

package/dist/chunk-YRWFYWK4.js

@@ -0,0 +1,11 @@
+import { registerDeferredRegistrations } from '@squide/module-federation';
+import { useCallback } from 'react';
+
+// src/useRegisterDeferredRegistrations.ts
+function useRegisterDeferredRegistrations() {
+  return useCallback((data, runtime) => {
+    return registerDeferredRegistrations(data, runtime);
+  }, []);
+}
+
+export { useRegisterDeferredRegistrations };

package/dist/index.d.ts

@@ -1,10 +1,27 @@
 export * from '@squide/core';
+export * from '@squide/module-federation';
 export * from '@squide/msw';
 export * from '@squide/react-router';
-export * from '@squide/webpack-module-federation';
-export { AppRouter, AppRouterProps, BootstrappingRoute, OnCompleteRegistrationsFunction, OnLoadProtectedDataFunction, OnLoadPublicDataFunction, RenderRouterProviderFunction } from './AppRouter.js';
-export { FireflyRuntime, FireflyRuntimeOptions } from './fireflyRuntime.js';
-import 'react';
+export { FireflyRuntime, FireflyRuntimeOptions } from './FireflyRuntime.js';
+export { AppRouter, AppRouterProps, AppRouterRenderFunctionArgs, RenderRouterProviderFunction, RenderRouterProviderFunctionArgs } from './AppRouter.js';
+export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState } from './AppRouterContext.js';
+export { AppRouterAction, AppRouterActionType, AppRouterDispatch, AppRouterState, __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher } from './AppRouterReducer.js';
+export { GlobalDataQueriesError, isGlobalDataQueriesError } from './GlobalDataQueriesError.js';
+export { useCanFetchProtectedData } from './useCanFetchProtectedData.js';
+export { useCanFetchPublicData } from './useCanFetchPublicData.js';
+export { useCanRegisterDeferredRegistrations } from './useCanRegisterDeferredRegistrations.js';
+export { useCanUpdateDeferredRegistrations } from './useCanUpdateDeferredRegistrations.js';
+export { DeferredRegistrationsErrorCallback, DeferredRegistrationsErrorsObject, UseDeferredRegistrationsOptions, useDeferredRegistrations } from './useDeferredRegistrations.js';
+export { useIsActiveRouteProtected } from './useIsActiveRouteProtected.js';
+export { useIsBootstrapping } from './useIsBootstrapping.js';
+export { useNavigationItems } from './useNavigationItems.js';
+export { IsUnauthorizedErrorCallback, useProtectedDataQueries } from './useProtectedDataQueries.js';
+export { usePublicDataQueries } from './usePublicDataQueries.js';
+export { useRegisterDeferredRegistrations } from './useRegisterDeferredRegistrations.js';
+export { useStrictRegistrationMode } from './useStrictRegistrationMode.js';
+export { useUpdateDeferredRegistrations } from './useUpdateDeferredRegistrations.js';
+import 'msw';
 import 'react/jsx-runtime';
+import 'react';
 import 'react-router-dom';
-import 'msw';
+import '@tanstack/react-query';

package/dist/index.js

@@ -1,6 +1,23 @@
-export { AppRouter, BootstrappingRoute } from './chunk-YPB7BNRJ.js';
-export { FireflyRuntime } from './chunk-JRNDLQBI.js';
+export { usePublicDataQueries } from './chunk-VUMBZ5BP.js';
+export { useCanFetchPublicData } from './chunk-IOMSOUAL.js';
+export { useDeferredRegistrations } from './chunk-2E76JVV7.js';
+export { useRegisterDeferredRegistrations } from './chunk-YRWFYWK4.js';
+export { useUpdateDeferredRegistrations } from './chunk-N2GOIQ5E.js';
+export { useCanRegisterDeferredRegistrations } from './chunk-PU7MASPN.js';
+export { useCanUpdateDeferredRegistrations } from './chunk-WVRMJZV6.js';
+export { useIsBootstrapping } from './chunk-I6L3AYOB.js';
+export { useNavigationItems } from './chunk-H6F7HDB3.js';
+export { useProtectedDataQueries } from './chunk-RG5N56BQ.js';
+export { AppRouter } from './chunk-36U4TTNR.js';
+export { useStrictRegistrationMode } from './chunk-WOPD33CM.js';
+export { FireflyRuntime } from './chunk-FKQ7XQEU.js';
+export { __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, getAreModulesReady, getAreModulesRegistered, useAppRouterReducer, useModuleRegistrationStatusDispatcher, useMswStatusDispatcher } from './chunk-ENUCXEMN.js';
+export { GlobalDataQueriesError, isGlobalDataQueriesError } from './chunk-HE5HKFL3.js';
+import './chunk-MZG2PJJG.js';
+export { useIsActiveRouteProtected } from './chunk-PP3MRMJJ.js';
+export { useCanFetchProtectedData } from './chunk-L5BP3WP3.js';
+export { AppRouterDispatcherContext, AppRouterStateContext, useAppRouterDispatcher, useAppRouterState } from './chunk-G32YX2KR.js';
 export * from '@squide/core';
+export * from '@squide/module-federation';
 export * from '@squide/msw';
 export * from '@squide/react-router';
-export * from '@squide/webpack-module-federation';

package/dist/useCanFetchProtectedData.d.ts

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

package/dist/useCanFetchProtectedData.js

@@ -0,0 +1,2 @@
+export { useCanFetchProtectedData } from './chunk-L5BP3WP3.js';
+import './chunk-G32YX2KR.js';

package/dist/useCanFetchPublicData.d.ts

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

package/dist/useCanFetchPublicData.js

@@ -0,0 +1,2 @@
+export { useCanFetchPublicData } from './chunk-IOMSOUAL.js';
+import './chunk-G32YX2KR.js';

package/dist/useCanRegisterDeferredRegistrations.d.ts

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

package/dist/useCanRegisterDeferredRegistrations.js

@@ -0,0 +1,2 @@
+export { useCanRegisterDeferredRegistrations } from './chunk-PU7MASPN.js';
+import './chunk-G32YX2KR.js';

package/dist/useCanUpdateDeferredRegistrations.d.ts

@@ -0,0 +1,3 @@
+declare function useCanUpdateDeferredRegistrations(): boolean | 0 | undefined;
+
+export { useCanUpdateDeferredRegistrations };

package/dist/useCanUpdateDeferredRegistrations.js

@@ -0,0 +1,2 @@
+export { useCanUpdateDeferredRegistrations } from './chunk-WVRMJZV6.js';
+import './chunk-G32YX2KR.js';

package/dist/useDeferredRegistrations.d.ts

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

package/dist/useDeferredRegistrations.js

@@ -0,0 +1,6 @@
+export { useDeferredRegistrations } from './chunk-2E76JVV7.js';
+import './chunk-YRWFYWK4.js';
+import './chunk-N2GOIQ5E.js';
+import './chunk-PU7MASPN.js';
+import './chunk-WVRMJZV6.js';
+import './chunk-G32YX2KR.js';

package/dist/useIsActiveRouteProtected.d.ts

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

package/dist/useIsActiveRouteProtected.js

@@ -0,0 +1 @@
+export { useIsActiveRouteProtected } from './chunk-PP3MRMJJ.js';

package/dist/useIsBootstrapping.d.ts

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

package/dist/useIsBootstrapping.js

@@ -0,0 +1,2 @@
+export { useIsBootstrapping } from './chunk-I6L3AYOB.js';
+import './chunk-G32YX2KR.js';

package/dist/useNavigationItems.d.ts

@@ -0,0 +1,5 @@
+import * as _squide_react_router from '@squide/react-router';
+
+declare function useNavigationItems(): _squide_react_router.RootNavigationItem[];
+
+export { useNavigationItems };

package/dist/useNavigationItems.js

@@ -0,0 +1,2 @@
+export { useNavigationItems } from './chunk-H6F7HDB3.js';
+import './chunk-G32YX2KR.js';

package/dist/useProtectedDataQueries.d.ts

@@ -0,0 +1,9 @@
+import { QueriesOptions, QueriesResults, UseQueryResult } from '@tanstack/react-query';
+
+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, useProtectedDataQueries };

package/dist/useProtectedDataQueries.js

@@ -0,0 +1,4 @@
+export { useProtectedDataQueries } from './chunk-RG5N56BQ.js';
+import './chunk-HE5HKFL3.js';
+import './chunk-L5BP3WP3.js';
+import './chunk-G32YX2KR.js';

package/dist/usePublicDataQueries.d.ts

@@ -0,0 +1,8 @@
+import { QueriesOptions, QueriesResults, UseQueryResult } from '@tanstack/react-query';
+
+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 { usePublicDataQueries };

package/dist/usePublicDataQueries.js

@@ -0,0 +1,4 @@
+export { usePublicDataQueries } from './chunk-VUMBZ5BP.js';
+import './chunk-IOMSOUAL.js';
+import './chunk-HE5HKFL3.js';
+import './chunk-G32YX2KR.js';

package/dist/useRegisterDeferredRegistrations.d.ts

@@ -0,0 +1,9 @@
+import * as _squide_core from '@squide/core';
+import { Runtime } from '@squide/core';
+
+declare function useRegisterDeferredRegistrations(): <TData = unknown, TRuntime extends Runtime = Runtime<unknown, unknown>>(data: TData, runtime: TRuntime) => Promise<{
+    localModuleErrors: _squide_core.ModuleRegistrationError[];
+    remoteModuleErrors: _squide_core.ModuleRegistrationError[];
+}>;
+
+export { useRegisterDeferredRegistrations };

package/dist/useRegisterDeferredRegistrations.js

@@ -0,0 +1 @@
+export { useRegisterDeferredRegistrations } from './chunk-YRWFYWK4.js';

package/dist/useStrictRegistrationMode.d.ts

@@ -0,0 +1,3 @@
+declare function useStrictRegistrationMode(): void;
+
+export { useStrictRegistrationMode };

package/dist/useStrictRegistrationMode.js

@@ -0,0 +1 @@
+export { useStrictRegistrationMode } from './chunk-WOPD33CM.js';

package/dist/useUpdateDeferredRegistrations.d.ts

@@ -0,0 +1,9 @@
+import * as _squide_core from '@squide/core';
+import { Runtime } from '@squide/core';
+
+declare function useUpdateDeferredRegistrations(): <TData = unknown, TRuntime extends Runtime = Runtime<unknown, unknown>>(data: TData, runtime: TRuntime) => Promise<{
+    localModuleErrors: _squide_core.ModuleRegistrationError[];
+    remoteModuleErrors: _squide_core.ModuleRegistrationError[];
+}>;
+
+export { useUpdateDeferredRegistrations };

package/dist/useUpdateDeferredRegistrations.js

@@ -0,0 +1,2 @@
+export { useUpdateDeferredRegistrations } from './chunk-N2GOIQ5E.js';
+import './chunk-G32YX2KR.js';