@squide/firefly 9.3.1 → 9.3.3

package/src/AppRouterReducer.ts

@@ -0,0 +1,363 @@
+import { addLocalModuleRegistrationStatusChangedListener, getLocalModuleRegistrationStatus, removeLocalModuleRegistrationStatusChangedListener, useEventBus, useLogger } from "@squide/core";
+import { addRemoteModuleRegistrationStatusChangedListener, areModulesReady, areModulesRegistered, getRemoteModuleRegistrationStatus, removeRemoteModuleRegistrationStatusChangedListener } from "@squide/module-federation";
+import { addMswStateChangedListener, isMswReady, removeMswStateChangedListener } from "@squide/msw";
+import { useCallback, useEffect, useMemo, useReducer, type Dispatch } from "react";
+import { useExecuteOnce } from "./useExecuteOnce.ts";
+import { isApplicationBootstrapping } from "./useIsBootstrapping.ts";
+
+export type ActiveRouteVisiblity = "unknown" | "public" | "protected";
+
+export interface AppRouterState {
+    waitForMsw: boolean;
+    waitForPublicData: boolean;
+    waitForProtectedData: boolean;
+    areModulesRegistered: boolean;
+    areModulesReady: boolean;
+    isMswReady: boolean;
+    isPublicDataReady: boolean;
+    isProtectedDataReady: boolean;
+    publicDataUpdatedAt?: number;
+    protectedDataUpdatedAt?: number;
+    deferredRegistrationsUpdatedAt?: number;
+    activeRouteVisibility: ActiveRouteVisiblity;
+    isUnauthorized: boolean;
+}
+
+export type AppRouterActionType =
+| "modules-registered"
+| "modules-ready"
+| "msw-ready"
+| "public-data-ready"
+| "protected-data-ready"
+| "public-data-updated"
+| "protected-data-updated"
+| "deferred-registrations-updated"
+| "active-route-is-public"
+| "active-route-is-protected"
+| "is-unauthorized";
+
+// The followings event const are a concatenation of "squide-" with AppRouterActionType.
+// They are dispatched by the useEnhancedReducerDispatch hook.
+export const ModulesRegisteredEvent = "squide-modules-registered";
+export const ModulesReadyEvent = "squide-modules-ready";
+export const MswReadyEvent = "squide-msw-ready";
+export const PublicDataReadyEvent = "squide-public-data-ready";
+export const ProtectedDataReadyEvent = "squide-protected-data-ready";
+export const PublicDataUpdatedEvent = "squide-public-data-updated";
+export const ProtectedDataUpdatedEvent = "squide-protected-data-updated";
+export const DeferredRegistrationsUpdatedEvent = "squide-deferred-registrations-updated";
+export const ApplicationBoostrappedEvent = "squide-app-boostrapped";
+
+export interface AppRouterAction {
+    type: AppRouterActionType;
+}
+
+export type AppRouterDispatch = Dispatch<AppRouterAction>;
+
+function reducer(state: AppRouterState, action: AppRouterAction) {
+    let newState = state;
+
+    switch (action.type) {
+        case "modules-registered": {
+            newState = {
+                ...newState,
+                areModulesRegistered: true
+            };
+
+            break;
+        }
+        case "modules-ready": {
+            newState = {
+                ...newState,
+                areModulesReady: true,
+                // Will be set even if the app is not using deferred registrations.
+                deferredRegistrationsUpdatedAt: Date.now()
+            };
+
+            break;
+        }
+        case "msw-ready": {
+            newState = {
+                ...newState,
+                isMswReady: true
+            };
+
+            break;
+        }
+        case "public-data-ready": {
+            newState = {
+                ...newState,
+                isPublicDataReady: true,
+                publicDataUpdatedAt: Date.now()
+            };
+
+            break;
+        }
+        case "protected-data-ready": {
+            newState = {
+                ...newState,
+                isProtectedDataReady: true,
+                protectedDataUpdatedAt: Date.now()
+            };
+
+            break;
+        }
+        case "public-data-updated": {
+            newState = {
+                ...newState,
+                publicDataUpdatedAt: Date.now()
+            };
+
+            break;
+        }
+        case "protected-data-updated": {
+            newState = {
+                ...newState,
+                protectedDataUpdatedAt: Date.now()
+            };
+
+            break;
+        }
+        case "deferred-registrations-updated": {
+            newState = {
+                ...newState,
+                deferredRegistrationsUpdatedAt: Date.now()
+            };
+
+            break;
+        }
+        case "active-route-is-public": {
+            newState = {
+                ...newState,
+                activeRouteVisibility: "public"
+            };
+
+            break;
+        }
+        case "active-route-is-protected": {
+            newState = {
+                ...newState,
+                activeRouteVisibility: "protected"
+            };
+
+            break;
+        }
+        case "is-unauthorized": {
+            newState = {
+                ...newState,
+                isUnauthorized: true
+            };
+
+            break;
+        }
+        default: {
+            throw new Error(`[squide] The AppRouter component state reducer doesn't support action type "${action.type}".`);
+        }
+    }
+
+    return newState;
+}
+
+export function getAreModulesRegistered() {
+    const localModuleStatus = getLocalModuleRegistrationStatus();
+    const remoteModuleStatus = getRemoteModuleRegistrationStatus();
+
+    return areModulesRegistered(localModuleStatus, remoteModuleStatus);
+}
+
+export function getAreModulesReady() {
+    const localModuleStatus = getLocalModuleRegistrationStatus();
+    const remoteModuleStatus = getRemoteModuleRegistrationStatus();
+
+    return areModulesReady(localModuleStatus, remoteModuleStatus);
+}
+
+export function useModuleRegistrationStatusDispatcher(areModulesRegisteredValue: boolean, areModulesReadyValue: boolean, dispatch: AppRouterDispatch) {
+    const logger = useLogger();
+
+    const dispatchModulesRegistered = useExecuteOnce(useCallback(() => {
+        if (getAreModulesRegistered()) {
+            dispatch({ type: "modules-registered" });
+
+            logger.debug("[squide] %cModules are registered%c.", "color: white; background-color: green;", "");
+
+            return true;
+        }
+
+        return false;
+    }, [dispatch, logger]));
+
+    const dispatchModulesReady = useExecuteOnce(useCallback(() => {
+        if (getAreModulesReady()) {
+            dispatch({ type: "modules-ready" });
+
+            logger.debug("[squide] %cModules are ready%c.", "color: white; background-color: green;", "");
+
+            return true;
+        }
+
+        return false;
+    }, [dispatch, logger]));
+
+    return useEffect(() => {
+        if (!areModulesRegisteredValue) {
+            addLocalModuleRegistrationStatusChangedListener(dispatchModulesRegistered);
+            addRemoteModuleRegistrationStatusChangedListener(dispatchModulesRegistered);
+        }
+
+        if (!areModulesReadyValue) {
+            addLocalModuleRegistrationStatusChangedListener(dispatchModulesReady);
+            addRemoteModuleRegistrationStatusChangedListener(dispatchModulesReady);
+        }
+
+        return () => {
+            removeLocalModuleRegistrationStatusChangedListener(dispatchModulesRegistered);
+            removeRemoteModuleRegistrationStatusChangedListener(dispatchModulesRegistered);
+
+            removeLocalModuleRegistrationStatusChangedListener(dispatchModulesReady);
+            removeRemoteModuleRegistrationStatusChangedListener(dispatchModulesReady);
+        };
+    }, [areModulesRegisteredValue, areModulesReadyValue, dispatchModulesRegistered, dispatchModulesReady]);
+}
+
+export function useMswStatusDispatcher(isMswReadyValue: boolean, dispatch: AppRouterDispatch) {
+    const logger = useLogger();
+
+    const dispatchMswReady = useExecuteOnce(useCallback(() => {
+        if (isMswReady()) {
+            dispatch({ type: "msw-ready" });
+
+            logger.debug("[squide] %cMSW is ready%c.", "color: white; background-color: green;", "");
+
+            return true;
+        }
+
+        return false;
+    }, [dispatch, logger]));
+
+    useEffect(() => {
+        if (!isMswReadyValue) {
+            addMswStateChangedListener(dispatchMswReady);
+        }
+
+        return () => {
+            removeMswStateChangedListener(dispatchMswReady);
+        };
+    }, [isMswReadyValue, dispatchMswReady]);
+}
+
+export function useBootstrappingCompletedDispatcher(state: AppRouterState) {
+    const eventBus = useEventBus();
+
+    const areModulesRegisteredValue = state.areModulesRegistered;
+    const isBoostrapping = isApplicationBootstrapping(state);
+
+    useExecuteOnce(useCallback(() => {
+        if (areModulesRegisteredValue && !isBoostrapping) {
+            eventBus.dispatch(ApplicationBoostrappedEvent);
+
+            return true;
+        }
+
+        return false;
+    }, [areModulesRegisteredValue, isBoostrapping, eventBus]), true);
+}
+
+let dispatchProxyFactory: ((reactDispatch: AppRouterDispatch) => AppRouterDispatch) | undefined;
+
+// This function should only be used by tests.
+export function __setAppReducerDispatchProxyFactory(factory: (reactDispatch: AppRouterDispatch) => AppRouterDispatch) {
+    dispatchProxyFactory = factory;
+}
+
+// This function should only be used by tests.
+export function __clearAppReducerDispatchProxy() {
+    dispatchProxyFactory = undefined;
+}
+
+function useReducerDispatchProxy(reactDispatch: AppRouterDispatch) {
+    return useMemo(() => {
+        return dispatchProxyFactory ? dispatchProxyFactory(reactDispatch) : reactDispatch;
+    }, [reactDispatch]);
+}
+
+function useEnhancedReducerDispatch(reducerDispatch: AppRouterDispatch) {
+    const logger = useLogger();
+    const eventBus = useEventBus();
+
+    return useCallback((action: AppRouterAction) => {
+        logger.debug("[squide] The following action has been dispatched to the AppRouter reducer:", action);
+        eventBus.dispatch(`squide-${action.type}`);
+
+        reducerDispatch(action);
+    }, [reducerDispatch, logger, eventBus]);
+}
+
+export function useAppRouterReducer(waitForMsw: boolean, waitForPublicData: boolean, waitForProtectedData: boolean): [AppRouterState, AppRouterDispatch] {
+    const areModulesInitiallyRegistered = getAreModulesRegistered();
+    const areModulesInitiallyReady = getAreModulesReady();
+    const isMswInitiallyReady = isMswReady();
+
+    const eventBus = useEventBus();
+
+    // When modules are initially registered, the reducer action will never be dispatched, therefore the event would not be dispatched as well.
+    // To ensure the bootstrapping events sequencing, the event is manually dispatched when the modules are initially registered.
+    useExecuteOnce(useCallback(() => {
+        if (areModulesInitiallyRegistered) {
+            eventBus.dispatch(ModulesRegisteredEvent);
+        }
+
+        return true;
+    }, [areModulesInitiallyRegistered, eventBus]), true);
+
+    // When modules are initially registered, the reducer action will never be dispatched, therefore the event would not be dispatched as well.
+    // To ensure the bootstrapping events sequencing, the event is manually dispatched when the modules are initially registered.
+    useExecuteOnce(useCallback(() => {
+        if (areModulesInitiallyReady) {
+            eventBus.dispatch(ModulesReadyEvent);
+        }
+
+        return true;
+    }, [areModulesInitiallyReady, eventBus]), true);
+
+    // When modules are initially registered, the reducer action will never be dispatched, therefore the event would not be dispatched as well.
+    // To ensure the bootstrapping events sequencing, the event is manually dispatched when the modules are initially registered.
+    useExecuteOnce(useCallback(() => {
+        if (isMswInitiallyReady) {
+            eventBus.dispatch(MswReadyEvent);
+        }
+
+        return true;
+    }, [isMswInitiallyReady, eventBus]), true);
+
+    const [state, reactDispatch] = useReducer(reducer, {
+        waitForMsw,
+        waitForPublicData,
+        waitForProtectedData,
+        // When the modules registration functions are awaited, the event listeners are registered after the modules are registered.
+        areModulesRegistered: areModulesInitiallyRegistered,
+        areModulesReady: areModulesInitiallyReady,
+        isMswReady: isMswInitiallyReady,
+        isPublicDataReady: false,
+        isProtectedDataReady: false,
+        activeRouteVisibility: "unknown",
+        isUnauthorized: false
+    });
+
+    const {
+        areModulesRegistered: areModulesRegisteredValue,
+        areModulesReady: areModulesReadyValue,
+        isMswReady: isMswReadyValue
+    } = state;
+
+    // The dispatch proxy is strictly an utility allowing tests to mock the useReducer dispatch function. It's easier
+    // than mocking the import from React.
+    const dispatchProxy = useReducerDispatchProxy(reactDispatch);
+    const dispatch = useEnhancedReducerDispatch(dispatchProxy);
+
+    useModuleRegistrationStatusDispatcher(areModulesRegisteredValue, areModulesReadyValue, dispatch);
+    useMswStatusDispatcher(isMswReadyValue, dispatch);
+    useBootstrappingCompletedDispatcher(state);
+
+    return [state, dispatch];
+}

package/src/FireflyRuntime.tsx

@@ -0,0 +1,71 @@
+import type { RegisterRouteOptions, RuntimeOptions } from "@squide/core";
+import { MswPlugin, MswPluginName } from "@squide/msw";
+import { ReactRouterRuntime, type Route } from "@squide/react-router";
+import type { RequestHandler } from "msw";
+import { getAreModulesRegistered } from "./AppRouterReducer.ts";
+
+export interface FireflyRuntimeOptions extends RuntimeOptions {
+    useMsw?: boolean;
+}
+
+export class FireflyRuntime extends ReactRouterRuntime {
+    readonly #useMsw: boolean;
+
+    constructor({ plugins, useMsw, ...options }: FireflyRuntimeOptions = {}) {
+        if (useMsw) {
+            super({
+                plugins: [
+                    ...(plugins ?? []),
+                    runtime => new MswPlugin(runtime)
+                ],
+                ...options
+            });
+
+            this.#useMsw = true;
+        } else {
+            super({
+                plugins,
+                ...options
+            });
+
+            this.#useMsw = false;
+        }
+    }
+
+    registerRequestHandlers(handlers: RequestHandler[]) {
+        const mswPlugin = this.getPlugin(MswPluginName) as MswPlugin;
+
+        if (!mswPlugin) {
+            throw new Error("[squide] Cannot register the provided MSW request handlers because the runtime hasn't been initialized with MSW. Did you instanciate the FireflyRuntime with the \"useMsw\" option?");
+        }
+
+        if (getAreModulesRegistered()) {
+            throw new Error("[squide] Cannot register an MSW request handlers once the modules are registered. Are you trying to register an MSW request handler in a deferred registration function? Only navigation items can be registered in a deferred registration function.");
+        }
+
+        mswPlugin.registerRequestHandlers(handlers);
+    }
+
+    // Must define a return type otherwise we get an "error TS2742: The inferred type of 'requestHandlers' cannot be named" error.
+    get requestHandlers(): RequestHandler[] {
+        const mswPlugin = this.getPlugin(MswPluginName) as MswPlugin;
+
+        if (!mswPlugin) {
+            throw new Error("[squide] Cannot retrieve MSW request handlers because the runtime hasn't been initialized with MSW. Did you instanciate the FireflyRuntime with the \"useMsw\" option?");
+        }
+
+        return mswPlugin.requestHandlers;
+    }
+
+    registerRoute(route: Route, options: RegisterRouteOptions = {}) {
+        if (getAreModulesRegistered()) {
+            throw new Error("[squide] Cannot register a route once the modules are registered. Are you trying to register a route in a deferred registration function? Only navigation items can be registered in a deferred registration function.");
+        }
+
+        super.registerRoute(route, options);
+    }
+
+    get isMswEnabled() {
+        return this.#useMsw;
+    }
+}

package/src/GlobalDataQueriesError.ts

@@ -0,0 +1,17 @@
+export class GlobalDataQueriesError extends Error {
+    readonly #errors: Error[];
+
+    constructor(message: string, errors: Error[]) {
+        super(message);
+
+        this.#errors = errors;
+    }
+
+    get errors() {
+        return this.#errors;
+    }
+}
+
+export function isGlobalDataQueriesError(error?: unknown): error is GlobalDataQueriesError {
+    return error !== undefined && error !== null && error instanceof GlobalDataQueriesError;
+}

package/src/RootRoute.tsx

@@ -0,0 +1,25 @@
+import { useEffect } from "react";
+import { Outlet } from "react-router-dom";
+import { useAppRouterDispatcher, useAppRouterState } from "./AppRouterContext.ts";
+import { useIsActiveRouteProtected } from "./useIsActiveRouteProtected.ts";
+
+export function RootRoute() {
+    const state = useAppRouterState();
+    const isActiveRouteProtected = useIsActiveRouteProtected(state.areModulesReady);
+
+    const dispatch = useAppRouterDispatcher();
+
+    useEffect(() => {
+        // Dispatching the active route visibility must be done in a route because React Router's useLocation
+        // hook throws if it's not called from a child of the router component.
+        if (isActiveRouteProtected) {
+            dispatch({ type: "active-route-is-protected" });
+        } else {
+            dispatch({ type: "active-route-is-public" });
+        }
+    }, [isActiveRouteProtected, dispatch]);
+
+    return (
+        <Outlet />
+    );
+}

package/src/boostrap.ts

@@ -0,0 +1,62 @@
+import { isFunction, registerLocalModules, type ModuleRegisterFunction, type ModuleRegistrationError, type RegisterModulesOptions } from "@squide/core";
+import { registerRemoteModules, type RemoteDefinition, type RemoteModuleRegistrationError } from "@squide/module-federation";
+import { setMswAsReady } from "@squide/msw";
+import type { FireflyRuntime } from "./FireflyRuntime.tsx";
+
+export const ApplicationBootstrappingStartedEvent = "squide-app-bootstrapping-started";
+
+let isBootstrapped = false;
+
+export type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) => Promise<void>;
+
+export interface BootstrapAppOptions<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext> {
+    localModules?: ModuleRegisterFunction<TRuntime, TContext, TData>[];
+    remotes?: RemoteDefinition[];
+    startMsw?: StartMswFunction<TRuntime>;
+}
+
+export async function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options: BootstrapAppOptions<TRuntime, TContext, TData> = {}) {
+    const {
+        localModules = [],
+        remotes = [],
+        context,
+        startMsw
+    } = options;
+
+    if (isBootstrapped) {
+        throw new Error("[squide] A squide application can only be bootstrapped once. Did you call the \"bootstrap\" function twice?");
+    }
+
+    runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);
+
+    let localModuleErrors: ModuleRegistrationError[] = [];
+    let remoteModuleErrors: RemoteModuleRegistrationError[] = [];
+
+    localModuleErrors = await registerLocalModules<TRuntime, TContext, TData>(localModules, runtime, { context });
+    remoteModuleErrors = await registerRemoteModules(remotes, runtime, { context });
+
+    if (runtime.isMswEnabled) {
+        if (!isFunction(startMsw)) {
+            throw new Error("[squide] When MSW is enabled, the \"startMsw\" function must be provided.");
+        }
+
+        try {
+            await startMsw(runtime);
+
+            setMswAsReady();
+        } catch (error: unknown) {
+            runtime.logger.debug("[squide] An error occured while starting MSW.", error);
+        }
+    }
+
+    isBootstrapped = true;
+
+    return {
+        localModuleErrors,
+        remoteModuleErrors
+    };
+}
+
+export function __resetBootstrapGuard() {
+    isBootstrapped = false;
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+export * from "@squide/core";
+export * from "@squide/module-federation";
+export * from "@squide/msw";
+export * from "@squide/react-router";
+
+export * from "./FireflyRuntime.tsx";
+
+export * from "./AppRouter.tsx";
+export * from "./AppRouterContext.ts";
+export * from "./AppRouterReducer.ts";
+
+export * from "./GlobalDataQueriesError.ts";
+export * from "./useCanFetchProtectedData.ts";
+export * from "./useCanFetchPublicData.ts";
+export * from "./useCanRegisterDeferredRegistrations.ts";
+export * from "./useCanUpdateDeferredRegistrations.ts";
+export * from "./useDeferredRegistrations.ts";
+export * from "./useIsActiveRouteProtected.ts";
+export * from "./useIsBootstrapping.ts";
+export * from "./useNavigationItems.ts";
+export * from "./useProtectedDataQueries.ts";
+export * from "./usePublicDataQueries.ts";
+export * from "./useRegisterDeferredRegistrations.ts";
+export * from "./useStrictRegistrationMode.ts";
+export * from "./useUpdateDeferredRegistrations.ts";
+
+export * from "./boostrap.ts";
+

package/src/useCanFetchProtectedData.ts

@@ -0,0 +1,26 @@
+import { useAppRouterState } from "./AppRouterContext.ts";
+
+export function useCanFetchProtectedData() {
+    const {
+        waitForMsw,
+        areModulesRegistered,
+        areModulesReady,
+        isMswReady,
+        isProtectedDataReady,
+        activeRouteVisibility
+    } = 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)
+            // Only fetch the protected data for protected routes, aka do not fetch the protected data for public routes.
+            && activeRouteVisibility === "protected"
+            // Wait for MSW since the endpoints for the protected data might be an MSW endpoint when in development.
+            && (!waitForMsw || isMswReady)
+        )
+    );
+}

package/src/useCanFetchPublicData.ts

@@ -0,0 +1,23 @@
+import { useAppRouterState } from "./AppRouterContext.ts";
+
+export 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)
+            // Wait for MSW since the endpoints for the protected data might be an MSW endpoint when in development.
+            && (!waitForMsw || isMswReady)
+        )
+    );
+}

package/src/useCanRegisterDeferredRegistrations.ts

@@ -0,0 +1,24 @@
+import { useAppRouterState } from "./AppRouterContext.ts";
+
+export function useCanRegisterDeferredRegistrations() {
+    const {
+        waitForPublicData,
+        waitForProtectedData,
+        areModulesReady,
+        areModulesRegistered,
+        isPublicDataReady,
+        isProtectedDataReady,
+        activeRouteVisibility,
+        isUnauthorized
+    } = useAppRouterState();
+
+    return (
+        !isUnauthorized
+        // Wait for the modules to be registered but make sure the deferred registrations has not been registered yet (updates are handled by another hook).
+        && areModulesRegistered && !areModulesReady
+        // && (!waitForMsw || isMswReady)
+        // Wait for the initial data to be ready since the deferred registrations will probably need that data.
+        && (!waitForPublicData || isPublicDataReady)
+        && (!waitForProtectedData || activeRouteVisibility === "public" || isProtectedDataReady)
+    );
+}

package/src/useCanUpdateDeferredRegistrations.ts

@@ -0,0 +1,23 @@
+import { useAppRouterState } from "./AppRouterContext.ts";
+
+export 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
+        // Make sure the apps is actually having deferred registrations.
+        && deferredRegistrationsUpdatedAt
+        // If either the public data or the protected data has been updated, update the deferred registrations.
+        && (
+            (publicDataUpdatedAt && publicDataUpdatedAt > deferredRegistrationsUpdatedAt) ||
+            (protectedDataUpdatedAt && protectedDataUpdatedAt > deferredRegistrationsUpdatedAt)
+        )
+    );
+}