@nlabs/gothamui 1.8.0

package/lib/views/Gotham/GothamProvider.d.ts

@@ -0,0 +1,43 @@
+import i18n from 'i18next';
+import type { FluxFramework, FluxMiddlewareType, FluxOptions } from '@nlabs/arkhamjs';
+import type { FC, ReactNode } from 'react';
+import type { GothamRouteData } from '../../types/gotham.js';
+import type { AwsRum } from '../../utils/awsRum.js';
+export interface GothamProviderProps {
+    readonly children?: ReactNode;
+    readonly config: GothamConfiguration;
+    readonly session?: Record<string, unknown>;
+}
+export type GothamPosition = 't' | 'tc' | 'tl' | 'tr' | 'b' | 'bc' | 'br' | 'bl';
+export type GothamStatus = 'default' | 'error' | 'info' | 'success' | 'warning' | number;
+export type ThemeDisplayMode = 'auto' | 'dark' | 'light';
+export interface GothamConfiguration {
+    readonly analytics?: {
+        readonly interactions?: boolean;
+    };
+    readonly app?: {
+        readonly logo?: string;
+        readonly name?: string;
+        readonly title?: string;
+        readonly titleBarSeparator?: string;
+    };
+    readonly authRoute?: string;
+    readonly awsRum?: AwsRum;
+    readonly baseUrl?: string;
+    readonly config?: FluxOptions;
+    readonly displayMode?: ThemeDisplayMode;
+    readonly flux?: FluxFramework;
+    readonly isAuth?: () => boolean;
+    readonly middleware?: FluxMiddlewareType[];
+    readonly onInit?: () => void;
+    readonly routes?: GothamRouteData[];
+    readonly storageType?: 'local' | 'session' | false;
+    readonly stores?: unknown[];
+    readonly theme?: Record<string, unknown>;
+    readonly translations?: Record<string, unknown>;
+    readonly i18n?: typeof i18n;
+}
+export declare const defaultGothamConfig: GothamConfiguration;
+export declare const init: (config: GothamConfiguration) => () => void;
+export declare const signOut: (flux: FluxFramework) => () => Promise<void>;
+export declare const GothamProvider: FC<GothamProviderProps>;

package/lib/views/Gotham/GothamProvider.js

@@ -0,0 +1,217 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2024-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { Logger, LoggerDebugLevel } from '@nlabs/arkhamjs-middleware-logger';
+import { BrowserStorage } from '@nlabs/arkhamjs-storage-browser';
+import { useFlux } from '@nlabs/arkhamjs-utils-react';
+import { merge } from '@nlabs/utils';
+import i18n from 'i18next';
+import { useEffect, useMemo, useState } from 'react';
+import { I18nextProvider, initReactI18next } from 'react-i18next';
+import { createBrowserRouter, RouterProvider } from 'react-router';
+import { GothamActions } from '../../actions/GothamActions.js';
+import { Config } from '../../config/appConfig.js';
+import { GothamConstants } from '../../constants/GothamConstants.js';
+import { gothamApp } from '../../stores/GothamAppStore.js';
+import { createAwsRumBrowserClient } from '../../utils/awsRum.js';
+import { GothamContext } from '../../utils/GothamContext.js';
+import { registerInteractionAnalytics } from '../../utils/interactionAnalytics.js';
+import { registerFlux } from '../../utils/navEventQueue.js';
+import { parseRoutes } from '../../utils/routeUtils.js';
+import { GothamRoot } from './GothamRoot.js';
+export const defaultGothamConfig = {
+    analytics: {
+        interactions: true
+    },
+    app: {
+        name: 'gotham',
+        title: 'GothamUI'
+    },
+    authRoute: '/',
+    baseUrl: '',
+    isAuth: ()=>false,
+    middleware: [],
+    routes: [],
+    storageType: 'session',
+    stores: [],
+    theme: {},
+    translations: {
+        translation: {}
+    }
+};
+const defaultAwsRum = createAwsRumBrowserClient();
+export const init = (config)=>()=>{
+        const { onInit } = config;
+        GothamActions.init();
+        if (onInit) {
+            onInit();
+        }
+    };
+export const signOut = (flux)=>async ()=>{
+        await flux.clearAppData();
+        await GothamActions.loading(false);
+        const authRoute = Config.get('authRoute', '/');
+        GothamActions.navGoto(authRoute);
+    };
+/* eslint-disable react-hooks/rules-of-hooks -- The compatibility rule does not recognize arrow-function components. */ export const GothamProvider = ({ config: appConfig })=>{
+    const flux = useFlux();
+    const config = useMemo(()=>merge({
+            ...defaultGothamConfig,
+            analytics: {
+                ...defaultGothamConfig.analytics
+            },
+            app: {
+                ...defaultGothamConfig.app
+            },
+            theme: {},
+            translations: {
+                translation: {}
+            }
+        }, appConfig), [
+        appConfig
+    ]);
+    const { isAuth, middleware, routes = [], storageType, stores, i18n: providedI18n, translations } = config;
+    const name = config?.app?.name;
+    const awsRum = config.awsRum || defaultAwsRum;
+    const [session, setSession] = useState({});
+    const [isFluxReady, setIsFluxReady] = useState(Boolean(flux?.isInit));
+    const router = useMemo(()=>createBrowserRouter([
+            {
+                Component: GothamRoot,
+                children: parseRoutes(routes),
+                index: false,
+                path: '/'
+            }
+        ]), [
+        routes
+    ]);
+    // Initialize i18next if translations are provided but no i18n instance is given
+    const i18nInstance = useMemo(()=>{
+        if (providedI18n) {
+            return providedI18n;
+        }
+        if (translations && Object.keys(translations).length > 0) {
+            // Create a new i18next instance and initialize it
+            const newI18n = i18n.createInstance();
+            newI18n.use(initReactI18next).init({
+                fallbackLng: 'en',
+                interpolation: {
+                    escapeValue: false // React already escapes values
+                },
+                lng: 'en',
+                resources: translations
+            });
+            return newI18n;
+        }
+        return null;
+    }, [
+        providedI18n,
+        translations
+    ]);
+    useEffect(()=>{
+        Config.set(config);
+        let isMounted = true;
+        const setupFlux = async ()=>{
+            if (!flux) {
+                if (isMounted) {
+                    setIsFluxReady(true);
+                }
+                return;
+            }
+            const env = Config.get('environment');
+            const logger = new Logger({
+                debugLevel: env === 'development' ? LoggerDebugLevel.DISPATCH : LoggerDebugLevel.DISABLED
+            });
+            const storage = storageType ? new BrowserStorage({
+                type: storageType
+            }) : undefined;
+            const fluxMiddleware = [
+                logger,
+                ...middleware || []
+            ];
+            const fluxStores = [
+                gothamApp,
+                ...stores || []
+            ];
+            if (flux.isInit) {
+                await flux.addStores(fluxStores);
+                flux.addMiddleware(fluxMiddleware);
+            } else {
+                const fluxConfig = {
+                    middleware: fluxMiddleware,
+                    name,
+                    stores: fluxStores,
+                    ...storage ? {
+                        storage
+                    } : {}
+                };
+                await flux.init(fluxConfig);
+            }
+            flux.on(GothamConstants.SIGN_OUT, signOut(flux));
+            flux.on(GothamConstants.UPDATE_SESSION, ({ session })=>{
+                setSession(session);
+            });
+            registerFlux(flux);
+            if (isMounted) {
+                setIsFluxReady(true);
+            }
+        };
+        void setupFlux();
+        init(config);
+        return ()=>{
+            isMounted = false;
+        };
+    }, [
+        flux,
+        config,
+        middleware,
+        name,
+        storageType,
+        stores
+    ]);
+    useEffect(()=>{
+        const unregister = config.analytics?.interactions === false ? undefined : registerInteractionAnalytics(awsRum);
+        return ()=>unregister?.();
+    }, [
+        awsRum,
+        config.analytics?.interactions
+    ]);
+    const contextValue = useMemo(()=>({
+            Flux: flux,
+            awsRum,
+            isAuth,
+            session
+        }), [
+        flux,
+        awsRum,
+        isAuth,
+        session
+    ]);
+    if (!isFluxReady) {
+        return null;
+    }
+    if (i18nInstance) {
+        return /*#__PURE__*/ _jsx(I18nextProvider, {
+            i18n: i18nInstance,
+            children: /*#__PURE__*/ _jsx(GothamContext.Provider, {
+                value: contextValue,
+                children: /*#__PURE__*/ _jsx("div", {
+                    children: /*#__PURE__*/ _jsx(RouterProvider, {
+                        router: router
+                    })
+                })
+            })
+        });
+    }
+    return /*#__PURE__*/ _jsx(GothamContext.Provider, {
+        value: contextValue,
+        children: /*#__PURE__*/ _jsx("div", {
+            children: /*#__PURE__*/ _jsx(RouterProvider, {
+                router: router
+            })
+        })
+    });
+}; /* eslint-enable react-hooks/rules-of-hooks */ 
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/views/Gotham/GothamProvider.tsx"],"sourcesContent":["/**\n * Copyright (c) 2024-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {Logger, LoggerDebugLevel} from '@nlabs/arkhamjs-middleware-logger';\nimport {BrowserStorage} from '@nlabs/arkhamjs-storage-browser';\nimport {useFlux} from '@nlabs/arkhamjs-utils-react';\nimport {merge} from '@nlabs/utils';\nimport i18n from 'i18next';\nimport {useEffect, useMemo, useState} from 'react';\nimport {I18nextProvider, initReactI18next} from 'react-i18next';\nimport {createBrowserRouter, RouterProvider} from 'react-router';\n\nimport {GothamActions} from '../../actions/GothamActions.js';\nimport {Config} from '../../config/appConfig.js';\nimport {GothamConstants} from '../../constants/GothamConstants.js';\nimport {gothamApp} from '../../stores/GothamAppStore.js';\nimport {createAwsRumBrowserClient} from '../../utils/awsRum.js';\nimport {GothamContext} from '../../utils/GothamContext.js';\nimport {registerInteractionAnalytics} from '../../utils/interactionAnalytics.js';\nimport {registerFlux} from '../../utils/navEventQueue.js';\nimport {parseRoutes} from '../../utils/routeUtils.js';\nimport {GothamRoot} from './GothamRoot.js';\n\nimport type {FluxFramework, FluxMiddlewareType, FluxOptions} from '@nlabs/arkhamjs';\nimport type {FC, ReactNode} from 'react';\nimport type {GothamRouteData} from '../../types/gotham.js';\nimport type {AwsRum} from '../../utils/awsRum.js';\nimport type {CustomRouteProps} from '../../utils/routeUtils.js';\n\nexport interface GothamProviderProps {\n  readonly children?: ReactNode;\n  readonly config: GothamConfiguration;\n  readonly session?: Record<string, unknown>;\n}\n\nexport type GothamPosition = 't' | 'tc' | 'tl' | 'tr' | 'b' | 'bc' | 'br' | 'bl';\nexport type GothamStatus = 'default' | 'error' | 'info' | 'success' | 'warning' | number;\nexport type ThemeDisplayMode = 'auto' | 'dark' | 'light';\n\nexport interface GothamConfiguration {\n  readonly analytics?: {\n    readonly interactions?: boolean;\n  };\n  readonly app?: {\n    readonly logo?: string;\n    readonly name?: string;\n    readonly title?: string;\n    readonly titleBarSeparator?: string;\n  };\n  readonly authRoute?: string;\n  readonly awsRum?: AwsRum;\n  readonly baseUrl?: string;\n  readonly config?: FluxOptions;\n  readonly displayMode?: ThemeDisplayMode;\n  readonly flux?: FluxFramework;\n  readonly isAuth?: () => boolean;\n  readonly middleware?: FluxMiddlewareType[];\n  readonly onInit?: () => void;\n  readonly routes?: GothamRouteData[];\n  readonly storageType?: 'local' | 'session' | false;\n  readonly stores?: unknown[];\n  readonly theme?: Record<string, unknown>;\n  readonly translations?: Record<string, unknown>;\n  readonly i18n?: typeof i18n;\n}\n\nexport const defaultGothamConfig: GothamConfiguration = {\n  analytics: {\n    interactions: true\n  },\n  app: {\n    name: 'gotham',\n    title: 'GothamUI'\n  },\n  authRoute: '/',\n  baseUrl: '',\n  isAuth: () => false,\n  middleware: [],\n  routes: [],\n  storageType: 'session',\n  stores: [],\n  theme: {},\n  translations: {translation: {}}\n};\n\nconst defaultAwsRum = createAwsRumBrowserClient();\n\nexport const init = (config: GothamConfiguration) => (): void => {\n  const {onInit} = config;\n  GothamActions.init();\n\n  if(onInit) {\n    onInit();\n  }\n};\n\nexport const signOut = (flux: FluxFramework) => async () => {\n  await flux.clearAppData();\n  await GothamActions.loading(false);\n\n  const authRoute = Config.get('authRoute', '/') as string;\n  GothamActions.navGoto(authRoute);\n};\n\n/* eslint-disable react-hooks/rules-of-hooks -- The compatibility rule does not recognize arrow-function components. */\nexport const GothamProvider: FC<GothamProviderProps> = ({config: appConfig}) => {\n  const flux = useFlux();\n  const config: GothamConfiguration = useMemo(() => merge({\n    ...defaultGothamConfig,\n    analytics: {...defaultGothamConfig.analytics},\n    app: {...defaultGothamConfig.app},\n    theme: {},\n    translations: {translation: {}}\n  }, appConfig), [appConfig]);\n  const {\n    isAuth,\n    middleware,\n    routes = [],\n    storageType,\n    stores,\n    i18n: providedI18n,\n    translations\n  } = config;\n  const name = config?.app?.name;\n  const awsRum = config.awsRum || defaultAwsRum;\n  const [session, setSession] = useState({});\n  const [isFluxReady, setIsFluxReady] = useState(Boolean((flux as any)?.isInit));\n  const router = useMemo(() => createBrowserRouter(\n    [\n      {\n        Component: GothamRoot,\n        children: parseRoutes(routes as unknown as CustomRouteProps[]),\n        index: false,\n        path: '/'\n      }\n    ]\n  ), [routes]);\n\n  // Initialize i18next if translations are provided but no i18n instance is given\n  const i18nInstance = useMemo(() => {\n    if(providedI18n) {\n      return providedI18n;\n    }\n\n    if(translations && Object.keys(translations).length > 0) {\n      // Create a new i18next instance and initialize it\n      const newI18n = i18n.createInstance();\n\n      newI18n\n        .use(initReactI18next)\n        .init({\n          fallbackLng: 'en',\n          interpolation: {\n            escapeValue: false // React already escapes values\n          },\n          lng: 'en', // default language\n          resources: translations as Record<string, Record<string, Record<string, string>>>\n        });\n\n      return newI18n;\n    }\n\n    return null;\n  }, [providedI18n, translations]);\n\n  useEffect(() => {\n    Config.set(config as Record<string, unknown>);\n    let isMounted = true;\n\n    const setupFlux = async () => {\n      if(!flux) {\n        if(isMounted) {\n          setIsFluxReady(true);\n        }\n        return;\n      }\n\n      const env: string = Config.get('environment') as string;\n      const logger: Logger = new Logger({\n        debugLevel: env === 'development' ? LoggerDebugLevel.DISPATCH : LoggerDebugLevel.DISABLED\n      });\n      const storage: BrowserStorage | undefined = storageType ? new BrowserStorage({type: storageType}) : undefined;\n      const fluxMiddleware = [logger, ...(middleware || [])];\n      const fluxStores = [gothamApp, ...(stores || [])];\n\n      if((flux as any).isInit) {\n        await flux.addStores(fluxStores);\n        flux.addMiddleware(fluxMiddleware);\n      } else {\n        const fluxConfig: FluxOptions = {\n          middleware: fluxMiddleware,\n          name,\n          stores: fluxStores,\n          ...(storage ? {storage} : {})\n        };\n\n        await flux.init(fluxConfig);\n      }\n\n      flux.on(GothamConstants.SIGN_OUT, signOut(flux));\n      flux.on(GothamConstants.UPDATE_SESSION, ({session}) => {\n        setSession(session);\n      });\n\n      registerFlux(flux);\n      if(isMounted) {\n        setIsFluxReady(true);\n      }\n    };\n\n    void setupFlux();\n\n    init(config);\n\n    return () => {\n      isMounted = false;\n    };\n  }, [flux, config, middleware, name, storageType, stores]);\n\n  useEffect(() => {\n    const unregister = config.analytics?.interactions === false\n      ? undefined\n      : registerInteractionAnalytics(awsRum);\n\n    return () => unregister?.();\n  }, [awsRum, config.analytics?.interactions]);\n\n  const contextValue = useMemo(() => ({Flux: flux, awsRum, isAuth, session}), [flux, awsRum, isAuth, session]);\n\n  if(!isFluxReady) {\n    return null;\n  }\n\n  if(i18nInstance) {\n    return (\n      <I18nextProvider i18n={i18nInstance}>\n        <GothamContext.Provider value={contextValue}>\n          <div>\n            <RouterProvider router={router}/>\n          </div>\n        </GothamContext.Provider>\n      </I18nextProvider>\n    );\n  }\n\n  return (\n    <GothamContext.Provider value={contextValue}>\n      <div>\n        <RouterProvider router={router}/>\n      </div>\n    </GothamContext.Provider>\n  );\n};\n/* eslint-enable react-hooks/rules-of-hooks */\n"],"names":["Logger","LoggerDebugLevel","BrowserStorage","useFlux","merge","i18n","useEffect","useMemo","useState","I18nextProvider","initReactI18next","createBrowserRouter","RouterProvider","GothamActions","Config","GothamConstants","gothamApp","createAwsRumBrowserClient","GothamContext","registerInteractionAnalytics","registerFlux","parseRoutes","GothamRoot","defaultGothamConfig","analytics","interactions","app","name","title","authRoute","baseUrl","isAuth","middleware","routes","storageType","stores","theme","translations","translation","defaultAwsRum","init","config","onInit","signOut","flux","clearAppData","loading","get","navGoto","GothamProvider","appConfig","providedI18n","awsRum","session","setSession","isFluxReady","setIsFluxReady","Boolean","isInit","router","Component","children","index","path","i18nInstance","Object","keys","length","newI18n","createInstance","use","fallbackLng","interpolation","escapeValue","lng","resources","set","isMounted","setupFlux","env","logger","debugLevel","DISPATCH","DISABLED","storage","type","undefined","fluxMiddleware","fluxStores","addStores","addMiddleware","fluxConfig","on","SIGN_OUT","UPDATE_SESSION","unregister","contextValue","Flux","Provider","value","div"],"mappings":"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"}

package/lib/views/Gotham/GothamRoot.d.ts

@@ -0,0 +1,6 @@
+import type { FC } from 'react';
+export declare const navBack: (history: any) => () => void;
+export declare const navForward: (history: any) => () => void;
+export declare const navGoto: (navigate: any) => (data: any) => void;
+export declare const navReplace: (history: any) => (data: any) => void;
+export declare const GothamRoot: FC;

package/lib/views/Gotham/GothamRoot.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { useFluxListener } from '@nlabs/arkhamjs-utils-react';
+import { useContext, useEffect, useRef } from 'react';
+import { Outlet, useLocation, useMatches, useNavigate } from 'react-router';
+import { Notify } from '../../components/Notify/Notify.js';
+import { GothamConstants } from '../../constants/GothamConstants.js';
+import { GothamContext } from '../../utils/GothamContext.js';
+import { LoaderView } from '../LoaderView/LoaderView.js';
+export const navBack = (history)=>()=>{
+        history.goBack();
+    };
+export const navForward = (history)=>()=>{
+        history.goForward();
+    };
+export const navGoto = (navigate)=>(data)=>{
+        const { params, path = '' } = data;
+        navigate(path, params);
+    };
+export const navReplace = (history)=>(data)=>{
+        const { params, path = '' } = data;
+        history.replace(path, params);
+    };
+export const GothamRoot = ()=>{
+    const { awsRum } = useContext(GothamContext);
+    const navigate = useNavigate();
+    const location = useLocation();
+    const matches = useMatches();
+    const lastTrackedPath = useRef(undefined);
+    useFluxListener(GothamConstants.NAV_BACK, navBack(navigate));
+    useFluxListener(GothamConstants.NAV_FORWARD, navForward(navigate));
+    useFluxListener(GothamConstants.NAV_GOTO, navGoto(navigate));
+    useFluxListener(GothamConstants.NAV_REPLACE, navReplace(navigate));
+    useEffect(()=>{
+        const analytics = [
+            ...matches
+        ].reverse().map((match)=>match.handle?.analytics).find(Boolean);
+        const path = analytics?.route || location.pathname;
+        const viewId = analytics?.viewId || path;
+        if (!awsRum || lastTrackedPath.current === viewId) {
+            return;
+        }
+        lastTrackedPath.current = viewId;
+        awsRum.track({
+            name: 'page_view',
+            path,
+            properties: {
+                title: analytics?.title || document.title,
+                viewId
+            },
+            type: 'page_view'
+        });
+    }, [
+        awsRum,
+        location.pathname,
+        matches
+    ]);
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            /*#__PURE__*/ _jsx(Outlet, {}),
+            /*#__PURE__*/ _jsx(Notify, {}),
+            /*#__PURE__*/ _jsx(LoaderView, {})
+        ]
+    });
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L2dvdGhhbWpzL3NyYy92aWV3cy9Hb3RoYW0vR290aGFtUm9vdC50c3giXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTgtUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cbmltcG9ydCB7dXNlRmx1eExpc3RlbmVyfSBmcm9tICdAbmxhYnMvYXJraGFtanMtdXRpbHMtcmVhY3QnO1xuaW1wb3J0IHt1c2VDb250ZXh0LCB1c2VFZmZlY3QsIHVzZVJlZn0gZnJvbSAncmVhY3QnO1xuaW1wb3J0IHtPdXRsZXQsIHVzZUxvY2F0aW9uLCB1c2VNYXRjaGVzLCB1c2VOYXZpZ2F0ZX0gZnJvbSAncmVhY3Qtcm91dGVyJztcblxuaW1wb3J0IHtOb3RpZnl9IGZyb20gJy4uLy4uL2NvbXBvbmVudHMvTm90aWZ5L05vdGlmeS5qcyc7XG5pbXBvcnQge0dvdGhhbUNvbnN0YW50c30gZnJvbSAnLi4vLi4vY29uc3RhbnRzL0dvdGhhbUNvbnN0YW50cy5qcyc7XG5pbXBvcnQge0dvdGhhbUNvbnRleHR9IGZyb20gJy4uLy4uL3V0aWxzL0dvdGhhbUNvbnRleHQuanMnO1xuaW1wb3J0IHtMb2FkZXJWaWV3fSBmcm9tICcuLi9Mb2FkZXJWaWV3L0xvYWRlclZpZXcuanMnO1xuXG5pbXBvcnQgdHlwZSB7RkN9IGZyb20gJ3JlYWN0JztcblxuaW50ZXJmYWNlIFJvdXRlQW5hbHl0aWNzIHtcbiAgcmVhZG9ubHkgcm91dGU/OiBzdHJpbmc7XG4gIHJlYWRvbmx5IHRpdGxlPzogc3RyaW5nO1xuICByZWFkb25seSB2aWV3SWQ6IHN0cmluZztcbn1cblxuZXhwb3J0IGNvbnN0IG5hdkJhY2sgPSAoaGlzdG9yeSkgPT4gKCk6IHZvaWQgPT4ge1xuICBoaXN0b3J5LmdvQmFjaygpO1xufTtcblxuZXhwb3J0IGNvbnN0IG5hdkZvcndhcmQgPSAoaGlzdG9yeSkgPT4gKCk6IHZvaWQgPT4ge1xuICBoaXN0b3J5LmdvRm9yd2FyZCgpO1xufTtcblxuZXhwb3J0IGNvbnN0IG5hdkdvdG8gPSAobmF2aWdhdGUpID0+IChkYXRhKTogdm9pZCA9PiB7XG4gIGNvbnN0IHtwYXJhbXMsIHBhdGggPSAnJ30gPSBkYXRhO1xuICBuYXZpZ2F0ZShwYXRoLCBwYXJhbXMpO1xufTtcblxuZXhwb3J0IGNvbnN0IG5hdlJlcGxhY2UgPSAoaGlzdG9yeSkgPT4gKGRhdGEpOiB2b2lkID0+IHtcbiAgY29uc3Qge3BhcmFtcywgcGF0aCA9ICcnfSA9IGRhdGE7XG4gIGhpc3RvcnkucmVwbGFjZShwYXRoLCBwYXJhbXMpO1xufTtcblxuZXhwb3J0IGNvbnN0IEdvdGhhbVJvb3Q6IEZDID0gKCkgPT4ge1xuICBjb25zdCB7YXdzUnVtfSA9IHVzZUNvbnRleHQoR290aGFtQ29udGV4dCk7XG4gIGNvbnN0IG5hdmlnYXRlID0gdXNlTmF2aWdhdGUoKTtcbiAgY29uc3QgbG9jYXRpb24gPSB1c2VMb2NhdGlvbigpO1xuICBjb25zdCBtYXRjaGVzID0gdXNlTWF0Y2hlcygpO1xuICBjb25zdCBsYXN0VHJhY2tlZFBhdGggPSB1c2VSZWY8c3RyaW5nIHwgdW5kZWZpbmVkPih1bmRlZmluZWQpO1xuXG4gIHVzZUZsdXhMaXN0ZW5lcihHb3RoYW1Db25zdGFudHMuTkFWX0JBQ0ssIG5hdkJhY2sobmF2aWdhdGUpKTtcbiAgdXNlRmx1eExpc3RlbmVyKEdvdGhhbUNvbnN0YW50cy5OQVZfRk9SV0FSRCwgbmF2Rm9yd2FyZChuYXZpZ2F0ZSkpO1xuICB1c2VGbHV4TGlzdGVuZXIoR290aGFtQ29uc3RhbnRzLk5BVl9HT1RPLCBuYXZHb3RvKG5hdmlnYXRlKSk7XG4gIHVzZUZsdXhMaXN0ZW5lcihHb3RoYW1Db25zdGFudHMuTkFWX1JFUExBQ0UsIG5hdlJlcGxhY2UobmF2aWdhdGUpKTtcblxuICB1c2VFZmZlY3QoKCkgPT4ge1xuICAgIGNvbnN0IGFuYWx5dGljcyA9IFsuLi5tYXRjaGVzXVxuICAgICAgLnJldmVyc2UoKVxuICAgICAgLm1hcCgobWF0Y2gpID0+IChtYXRjaC5oYW5kbGUgYXMge2FuYWx5dGljcz86IFJvdXRlQW5hbHl0aWNzfSB8IHVuZGVmaW5lZCk/LmFuYWx5dGljcylcbiAgICAgIC5maW5kKEJvb2xlYW4pO1xuICAgIGNvbnN0IHBhdGggPSBhbmFseXRpY3M/LnJvdXRlIHx8IGxvY2F0aW9uLnBhdGhuYW1lO1xuICAgIGNvbnN0IHZpZXdJZCA9IGFuYWx5dGljcz8udmlld0lkIHx8IHBhdGg7XG5cbiAgICBpZighYXdzUnVtIHx8IGxhc3RUcmFja2VkUGF0aC5jdXJyZW50ID09PSB2aWV3SWQpIHtcbiAgICAgIHJldHVybjtcbiAgICB9XG5cbiAgICBsYXN0VHJhY2tlZFBhdGguY3VycmVudCA9IHZpZXdJZDtcbiAgICBhd3NSdW0udHJhY2soe1xuICAgICAgbmFtZTogJ3BhZ2VfdmlldycsXG4gICAgICBwYXRoLFxuICAgICAgcHJvcGVydGllczoge1xuICAgICAgICB0aXRsZTogYW5hbHl0aWNzPy50aXRsZSB8fCBkb2N1bWVudC50aXRsZSxcbiAgICAgICAgdmlld0lkXG4gICAgICB9LFxuICAgICAgdHlwZTogJ3BhZ2VfdmlldydcbiAgICB9KTtcbiAgfSwgW2F3c1J1bSwgbG9jYXRpb24ucGF0aG5hbWUsIG1hdGNoZXNdKTtcblxuICByZXR1cm4gKFxuICAgIDw+XG4gICAgICA8T3V0bGV0Lz5cbiAgICAgIDxOb3RpZnkgLz5cbiAgICAgIDxMb2FkZXJWaWV3IC8+XG4gICAgPC8+XG4gICk7XG59O1xuIl0sIm5hbWVzIjpbInVzZUZsdXhMaXN0ZW5lciIsInVzZUNvbnRleHQiLCJ1c2VFZmZlY3QiLCJ1c2VSZWYiLCJPdXRsZXQiLCJ1c2VMb2NhdGlvbiIsInVzZU1hdGNoZXMiLCJ1c2VOYXZpZ2F0ZSIsIk5vdGlmeSIsIkdvdGhhbUNvbnN0YW50cyIsIkdvdGhhbUNvbnRleHQiLCJMb2FkZXJWaWV3IiwibmF2QmFjayIsImhpc3RvcnkiLCJnb0JhY2siLCJuYXZGb3J3YXJkIiwiZ29Gb3J3YXJkIiwibmF2R290byIsIm5hdmlnYXRlIiwiZGF0YSIsInBhcmFtcyIsInBhdGgiLCJuYXZSZXBsYWNlIiwicmVwbGFjZSIsIkdvdGhhbVJvb3QiLCJhd3NSdW0iLCJsb2NhdGlvbiIsIm1hdGNoZXMiLCJsYXN0VHJhY2tlZFBhdGgiLCJ1bmRlZmluZWQiLCJOQVZfQkFDSyIsIk5BVl9GT1JXQVJEIiwiTkFWX0dPVE8iLCJOQVZfUkVQTEFDRSIsImFuYWx5dGljcyIsInJldmVyc2UiLCJtYXAiLCJtYXRjaCIsImhhbmRsZSIsImZpbmQiLCJCb29sZWFuIiwicm91dGUiLCJwYXRobmFtZSIsInZpZXdJZCIsImN1cnJlbnQiLCJ0cmFjayIsIm5hbWUiLCJwcm9wZXJ0aWVzIiwidGl0bGUiLCJkb2N1bWVudCIsInR5cGUiXSwibWFwcGluZ3MiOiI7QUFBQTs7O0NBR0MsR0FDRCxTQUFRQSxlQUFlLFFBQU8sOEJBQThCO0FBQzVELFNBQVFDLFVBQVUsRUFBRUMsU0FBUyxFQUFFQyxNQUFNLFFBQU8sUUFBUTtBQUNwRCxTQUFRQyxNQUFNLEVBQUVDLFdBQVcsRUFBRUMsVUFBVSxFQUFFQyxXQUFXLFFBQU8sZUFBZTtBQUUxRSxTQUFRQyxNQUFNLFFBQU8sb0NBQW9DO0FBQ3pELFNBQVFDLGVBQWUsUUFBTyxxQ0FBcUM7QUFDbkUsU0FBUUMsYUFBYSxRQUFPLCtCQUErQjtBQUMzRCxTQUFRQyxVQUFVLFFBQU8sOEJBQThCO0FBVXZELE9BQU8sTUFBTUMsVUFBVSxDQUFDQyxVQUFZO1FBQ2xDQSxRQUFRQyxNQUFNO0lBQ2hCLEVBQUU7QUFFRixPQUFPLE1BQU1DLGFBQWEsQ0FBQ0YsVUFBWTtRQUNyQ0EsUUFBUUcsU0FBUztJQUNuQixFQUFFO0FBRUYsT0FBTyxNQUFNQyxVQUFVLENBQUNDLFdBQWEsQ0FBQ0M7UUFDcEMsTUFBTSxFQUFDQyxNQUFNLEVBQUVDLE9BQU8sRUFBRSxFQUFDLEdBQUdGO1FBQzVCRCxTQUFTRyxNQUFNRDtJQUNqQixFQUFFO0FBRUYsT0FBTyxNQUFNRSxhQUFhLENBQUNULFVBQVksQ0FBQ007UUFDdEMsTUFBTSxFQUFDQyxNQUFNLEVBQUVDLE9BQU8sRUFBRSxFQUFDLEdBQUdGO1FBQzVCTixRQUFRVSxPQUFPLENBQUNGLE1BQU1EO0lBQ3hCLEVBQUU7QUFFRixPQUFPLE1BQU1JLGFBQWlCO0lBQzVCLE1BQU0sRUFBQ0MsTUFBTSxFQUFDLEdBQUd4QixXQUFXUztJQUM1QixNQUFNUSxXQUFXWDtJQUNqQixNQUFNbUIsV0FBV3JCO0lBQ2pCLE1BQU1zQixVQUFVckI7SUFDaEIsTUFBTXNCLGtCQUFrQnpCLE9BQTJCMEI7SUFFbkQ3QixnQkFBZ0JTLGdCQUFnQnFCLFFBQVEsRUFBRWxCLFFBQVFNO0lBQ2xEbEIsZ0JBQWdCUyxnQkFBZ0JzQixXQUFXLEVBQUVoQixXQUFXRztJQUN4RGxCLGdCQUFnQlMsZ0JBQWdCdUIsUUFBUSxFQUFFZixRQUFRQztJQUNsRGxCLGdCQUFnQlMsZ0JBQWdCd0IsV0FBVyxFQUFFWCxXQUFXSjtJQUV4RGhCLFVBQVU7UUFDUixNQUFNZ0MsWUFBWTtlQUFJUDtTQUFRLENBQzNCUSxPQUFPLEdBQ1BDLEdBQUcsQ0FBQyxDQUFDQyxRQUFXQSxNQUFNQyxNQUFNLEVBQStDSixXQUMzRUssSUFBSSxDQUFDQztRQUNSLE1BQU1uQixPQUFPYSxXQUFXTyxTQUFTZixTQUFTZ0IsUUFBUTtRQUNsRCxNQUFNQyxTQUFTVCxXQUFXUyxVQUFVdEI7UUFFcEMsSUFBRyxDQUFDSSxVQUFVRyxnQkFBZ0JnQixPQUFPLEtBQUtELFFBQVE7WUFDaEQ7UUFDRjtRQUVBZixnQkFBZ0JnQixPQUFPLEdBQUdEO1FBQzFCbEIsT0FBT29CLEtBQUssQ0FBQztZQUNYQyxNQUFNO1lBQ056QjtZQUNBMEIsWUFBWTtnQkFDVkMsT0FBT2QsV0FBV2MsU0FBU0MsU0FBU0QsS0FBSztnQkFDekNMO1lBQ0Y7WUFDQU8sTUFBTTtRQUNSO0lBQ0YsR0FBRztRQUFDekI7UUFBUUMsU0FBU2dCLFFBQVE7UUFBRWY7S0FBUTtJQUV2QyxxQkFDRTs7MEJBQ0UsS0FBQ3ZCOzBCQUNELEtBQUNJOzBCQUNELEtBQUNHOzs7QUFHUCxFQUFFIn0=

package/lib/views/HomeView/HomeView.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import React from 'react';
+export interface HomeViewProps {
+    children?: React.ReactNode;
+    title?: string;
+}
+export declare const HomeView: React.NamedExoticComponent<HomeViewProps>;

package/lib/views/HomeView/HomeView.js

@@ -0,0 +1,134 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2018-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import React, { memo, useState } from 'react';
+import { useNavigate } from 'react-router';
+const navItems = [
+    {
+        label: 'Home',
+        path: '/'
+    },
+    {
+        label: 'About',
+        path: '/about'
+    },
+    {
+        label: 'Contact',
+        path: '/contact'
+    }
+];
+const HomeViewComponent = ({ children, title = 'GothamUI' })=>{
+    const [mobileOpen, setMobileOpen] = useState(false);
+    const navigate = useNavigate();
+    const handleDrawerToggle = ()=>{
+        setMobileOpen(!mobileOpen);
+    };
+    const handleNavigation = (path)=>{
+        navigate(path);
+        setMobileOpen(false);
+    };
+    return /*#__PURE__*/ _jsxs("div", {
+        className: "flex flex-col min-h-screen",
+        children: [
+            /*#__PURE__*/ _jsxs("header", {
+                className: "bg-indigo-600 text-white shadow-md",
+                children: [
+                    /*#__PURE__*/ _jsx("div", {
+                        className: "container mx-auto px-4",
+                        children: /*#__PURE__*/ _jsxs("div", {
+                            className: "flex items-center justify-between h-16",
+                            children: [
+                                /*#__PURE__*/ _jsx("div", {
+                                    className: "flex items-center sm:hidden",
+                                    children: /*#__PURE__*/ _jsxs("button", {
+                                        "aria-controls": "mobile-menu",
+                                        "aria-expanded": mobileOpen,
+                                        className: "inline-flex items-center justify-center p-2 rounded-md text-white hover:bg-indigo-500 focus:outline-none focus:ring-2 focus:ring-inset focus:ring-white",
+                                        onClick: handleDrawerToggle,
+                                        type: "button",
+                                        children: [
+                                            /*#__PURE__*/ _jsx("span", {
+                                                className: "sr-only",
+                                                children: "Open main menu"
+                                            }),
+                                            /*#__PURE__*/ _jsx("svg", {
+                                                "aria-hidden": "true",
+                                                className: `${mobileOpen ? 'hidden' : 'block'} h-6 w-6`,
+                                                fill: "none",
+                                                stroke: "currentColor",
+                                                viewBox: "0 0 24 24",
+                                                xmlns: "http://www.w3.org/2000/svg",
+                                                children: /*#__PURE__*/ _jsx("path", {
+                                                    d: "M4 6h16M4 12h16M4 18h16",
+                                                    strokeLinecap: "round",
+                                                    strokeLinejoin: "round",
+                                                    strokeWidth: 2
+                                                })
+                                            }),
+                                            /*#__PURE__*/ _jsx("svg", {
+                                                "aria-hidden": "true",
+                                                className: `${mobileOpen ? 'block' : 'hidden'} h-6 w-6`,
+                                                fill: "none",
+                                                stroke: "currentColor",
+                                                viewBox: "0 0 24 24",
+                                                xmlns: "http://www.w3.org/2000/svg",
+                                                children: /*#__PURE__*/ _jsx("path", {
+                                                    d: "M6 18L18 6M6 6l12 12",
+                                                    strokeLinecap: "round",
+                                                    strokeLinejoin: "round",
+                                                    strokeWidth: 2
+                                                })
+                                            })
+                                        ]
+                                    })
+                                }),
+                                /*#__PURE__*/ _jsx("div", {
+                                    className: "flex-1 flex items-center justify-center sm:items-stretch sm:justify-start",
+                                    children: /*#__PURE__*/ _jsx("div", {
+                                        className: "flex-shrink-0 flex items-center",
+                                        children: /*#__PURE__*/ _jsx("h1", {
+                                            className: "text-xl font-bold",
+                                            children: title
+                                        })
+                                    })
+                                }),
+                                /*#__PURE__*/ _jsx("div", {
+                                    className: "hidden sm:block sm:ml-6",
+                                    children: /*#__PURE__*/ _jsx("div", {
+                                        className: "flex space-x-4",
+                                        children: navItems.map(({ label, path })=>/*#__PURE__*/ _jsx("button", {
+                                                className: "text-white hover:bg-indigo-500 px-3 py-2 rounded-md text-sm font-medium",
+                                                onClick: ()=>handleNavigation(path),
+                                                children: label
+                                            }, path))
+                                    })
+                                })
+                            ]
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx("div", {
+                        className: `${mobileOpen ? 'block' : 'hidden'} sm:hidden`,
+                        id: "mobile-menu",
+                        children: /*#__PURE__*/ _jsx("div", {
+                            className: "px-2 pt-2 pb-3 space-y-1",
+                            children: navItems.map(({ label, path })=>/*#__PURE__*/ _jsx("button", {
+                                    className: "text-white hover:bg-indigo-500 block px-3 py-2 rounded-md text-base font-medium w-full text-left",
+                                    onClick: ()=>handleNavigation(path),
+                                    children: label
+                                }, path))
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx("main", {
+                className: "flex-grow p-4",
+                children: children
+            })
+        ]
+    });
+};
+export const HomeView = /*#__PURE__*/ memo(HomeViewComponent);
+HomeView.displayName = 'HomeView';
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/gothamjs/src/views/HomeView/HomeView.tsx"],"sourcesContent":["/**\n * Copyright (c) 2018-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport React, {memo, useState} from 'react';\nimport {useNavigate} from 'react-router';\n\nconst navItems = [\n  {label: 'Home', path: '/'},\n  {label: 'About', path: '/about'},\n  {label: 'Contact', path: '/contact'}\n];\n\nexport interface HomeViewProps {\n  children?: React.ReactNode;\n  title?: string;\n}\n\nconst HomeViewComponent: React.FC<HomeViewProps> = ({\n  children,\n  title = 'GothamUI'\n}) => {\n  const [mobileOpen, setMobileOpen] = useState(false);\n  const navigate = useNavigate();\n\n  const handleDrawerToggle = () => {\n    setMobileOpen(!mobileOpen);\n  };\n\n  const handleNavigation = (path: string) => {\n    navigate(path);\n    setMobileOpen(false);\n  };\n\n  return (\n    <div className=\"flex flex-col min-h-screen\">\n      {/* Navigation Bar */}\n      <header className=\"bg-indigo-600 text-white shadow-md\">\n        <div className=\"container mx-auto px-4\">\n          <div className=\"flex items-center justify-between h-16\">\n            {/* Mobile menu button */}\n            <div className=\"flex items-center sm:hidden\">\n              <button\n                aria-controls=\"mobile-menu\"\n                aria-expanded={mobileOpen}\n                className=\"inline-flex items-center justify-center p-2 rounded-md text-white hover:bg-indigo-500 focus:outline-none focus:ring-2 focus:ring-inset focus:ring-white\"\n                onClick={handleDrawerToggle}\n                type=\"button\"\n              >\n                <span className=\"sr-only\">Open main menu</span>\n                {/* Icon when menu is closed */}\n                <svg\n                  aria-hidden=\"true\"\n                  className={`${mobileOpen ? 'hidden' : 'block'} h-6 w-6`}\n                  fill=\"none\"\n                  stroke=\"currentColor\"\n                  viewBox=\"0 0 24 24\"\n                  xmlns=\"http://www.w3.org/2000/svg\"\n                >\n                  <path\n                    d=\"M4 6h16M4 12h16M4 18h16\"\n                    strokeLinecap=\"round\"\n                    strokeLinejoin=\"round\"\n                    strokeWidth={2}\n                  />\n                </svg>\n                {/* Icon when menu is open */}\n                <svg\n                  aria-hidden=\"true\"\n                  className={`${mobileOpen ? 'block' : 'hidden'} h-6 w-6`}\n                  fill=\"none\"\n                  stroke=\"currentColor\"\n                  viewBox=\"0 0 24 24\"\n                  xmlns=\"http://www.w3.org/2000/svg\"\n                >\n                  <path\n                    d=\"M6 18L18 6M6 6l12 12\"\n                    strokeLinecap=\"round\"\n                    strokeLinejoin=\"round\"\n                    strokeWidth={2}\n                  />\n                </svg>\n              </button>\n            </div>\n\n            {/* Logo */}\n            <div className=\"flex-1 flex items-center justify-center sm:items-stretch sm:justify-start\">\n              <div className=\"flex-shrink-0 flex items-center\">\n                <h1 className=\"text-xl font-bold\">{title}</h1>\n              </div>\n            </div>\n\n            {/* Desktop Navigation */}\n            <div className=\"hidden sm:block sm:ml-6\">\n              <div className=\"flex space-x-4\">\n                {navItems.map(({label, path}) => (\n                  <button\n                    className=\"text-white hover:bg-indigo-500 px-3 py-2 rounded-md text-sm font-medium\"\n                    key={path}\n                    onClick={() => handleNavigation(path)}\n                  >\n                    {label}\n                  </button>\n                ))}\n              </div>\n            </div>\n          </div>\n        </div>\n\n        {/* Mobile Navigation */}\n        <div\n          className={`${mobileOpen ? 'block' : 'hidden'} sm:hidden`}\n          id=\"mobile-menu\"\n        >\n          <div className=\"px-2 pt-2 pb-3 space-y-1\">\n            {navItems.map(({label, path}) => (\n              <button\n                className=\"text-white hover:bg-indigo-500 block px-3 py-2 rounded-md text-base font-medium w-full text-left\"\n                key={path}\n                onClick={() => handleNavigation(path)}\n              >\n                {label}\n              </button>\n            ))}\n          </div>\n        </div>\n      </header>\n\n      {/* Main Content */}\n      <main className=\"flex-grow p-4\">\n        {children}\n      </main>\n    </div>\n  );\n};\n\nexport const HomeView = memo(HomeViewComponent);\nHomeView.displayName = 'HomeView';\n"],"names":["React","memo","useState","useNavigate","navItems","label","path","HomeViewComponent","children","title","mobileOpen","setMobileOpen","navigate","handleDrawerToggle","handleNavigation","div","className","header","button","aria-controls","aria-expanded","onClick","type","span","svg","aria-hidden","fill","stroke","viewBox","xmlns","d","strokeLinecap","strokeLinejoin","strokeWidth","h1","map","id","main","HomeView","displayName"],"mappings":";AAAA;;;CAGC,GACD,OAAOA,SAAQC,IAAI,EAAEC,QAAQ,QAAO,QAAQ;AAC5C,SAAQC,WAAW,QAAO,eAAe;AAEzC,MAAMC,WAAW;IACf;QAACC,OAAO;QAAQC,MAAM;IAAG;IACzB;QAACD,OAAO;QAASC,MAAM;IAAQ;IAC/B;QAACD,OAAO;QAAWC,MAAM;IAAU;CACpC;AAOD,MAAMC,oBAA6C,CAAC,EAClDC,QAAQ,EACRC,QAAQ,UAAU,EACnB;IACC,MAAM,CAACC,YAAYC,cAAc,GAAGT,SAAS;IAC7C,MAAMU,WAAWT;IAEjB,MAAMU,qBAAqB;QACzBF,cAAc,CAACD;IACjB;IAEA,MAAMI,mBAAmB,CAACR;QACxBM,SAASN;QACTK,cAAc;IAChB;IAEA,qBACE,MAACI;QAAIC,WAAU;;0BAEb,MAACC;gBAAOD,WAAU;;kCAChB,KAACD;wBAAIC,WAAU;kCACb,cAAA,MAACD;4BAAIC,WAAU;;8CAEb,KAACD;oCAAIC,WAAU;8CACb,cAAA,MAACE;wCACCC,iBAAc;wCACdC,iBAAeV;wCACfM,WAAU;wCACVK,SAASR;wCACTS,MAAK;;0DAEL,KAACC;gDAAKP,WAAU;0DAAU;;0DAE1B,KAACQ;gDACCC,eAAY;gDACZT,WAAW,GAAGN,aAAa,WAAW,QAAQ,QAAQ,CAAC;gDACvDgB,MAAK;gDACLC,QAAO;gDACPC,SAAQ;gDACRC,OAAM;0DAEN,cAAA,KAACvB;oDACCwB,GAAE;oDACFC,eAAc;oDACdC,gBAAe;oDACfC,aAAa;;;0DAIjB,KAACT;gDACCC,eAAY;gDACZT,WAAW,GAAGN,aAAa,UAAU,SAAS,QAAQ,CAAC;gDACvDgB,MAAK;gDACLC,QAAO;gDACPC,SAAQ;gDACRC,OAAM;0DAEN,cAAA,KAACvB;oDACCwB,GAAE;oDACFC,eAAc;oDACdC,gBAAe;oDACfC,aAAa;;;;;;8CAOrB,KAAClB;oCAAIC,WAAU;8CACb,cAAA,KAACD;wCAAIC,WAAU;kDACb,cAAA,KAACkB;4CAAGlB,WAAU;sDAAqBP;;;;8CAKvC,KAACM;oCAAIC,WAAU;8CACb,cAAA,KAACD;wCAAIC,WAAU;kDACZZ,SAAS+B,GAAG,CAAC,CAAC,EAAC9B,KAAK,EAAEC,IAAI,EAAC,iBAC1B,KAACY;gDACCF,WAAU;gDAEVK,SAAS,IAAMP,iBAAiBR;0DAE/BD;+CAHIC;;;;;;kCAYjB,KAACS;wBACCC,WAAW,GAAGN,aAAa,UAAU,SAAS,UAAU,CAAC;wBACzD0B,IAAG;kCAEH,cAAA,KAACrB;4BAAIC,WAAU;sCACZZ,SAAS+B,GAAG,CAAC,CAAC,EAAC9B,KAAK,EAAEC,IAAI,EAAC,iBAC1B,KAACY;oCACCF,WAAU;oCAEVK,SAAS,IAAMP,iBAAiBR;8CAE/BD;mCAHIC;;;;;0BAWf,KAAC+B;gBAAKrB,WAAU;0BACbR;;;;AAIT;AAEA,OAAO,MAAM8B,yBAAWrC,KAAKM,mBAAmB;AAChD+B,SAASC,WAAW,GAAG"}

package/lib/views/LoaderView/LoaderView.d.ts

@@ -0,0 +1,8 @@
+export interface LoaderContent {
+    content?: string;
+    isLoading: boolean;
+}
+export declare const toggleLoader: (setLoading: any, setLoaderContent: any) => ({ content, isLoading }: LoaderContent) => void;
+declare const LoaderViewComponent: () => import("react").JSX.Element | null;
+export declare const LoaderView: import("react").MemoExoticComponent<typeof LoaderViewComponent>;
+export {};

package/lib/views/LoaderView/LoaderView.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useFluxListener } from '@nlabs/arkhamjs-utils-react';
+import { memo, useState } from 'react';
+import { Loader } from '../../components/Loader/Loader.js';
+import { GothamConstants } from '../../constants/GothamConstants.js';
+export const toggleLoader = (setLoading, setLoaderContent)=>({ content, isLoading })=>{
+        setLoading(isLoading);
+        setLoaderContent(content);
+    };
+const LoaderViewComponent = ()=>{
+    const [isLoading, setLoading] = useState(false);
+    const [content, setLoaderContent] = useState();
+    useFluxListener(GothamConstants.LOADING, ({ content, isLoading })=>{
+        setLoading(isLoading);
+        setLoaderContent(content);
+    });
+    if (!isLoading) {
+        return null;
+    }
+    return /*#__PURE__*/ _jsx("div", {
+        className: "fixed inset-0 bg-black bg-opacity-50 z-50 flex items-center justify-center",
+        children: /*#__PURE__*/ _jsx(Loader, {
+            content: content
+        })
+    });
+};
+export const LoaderView = /*#__PURE__*/ memo(LoaderViewComponent);
+LoaderView.displayName = 'LoaderView';
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/views/MenuView/MenuView.d.ts

@@ -0,0 +1,13 @@
+import type { ElementType } from 'react';
+export type MenuItems = {
+    readonly current?: boolean;
+    readonly href: string;
+    readonly icon?: ElementType;
+    readonly name: string;
+};
+export interface MenuViewProps {
+    sideMenuItems: MenuItems[];
+    userMenuItems: MenuItems[];
+}
+export declare const MenuView: import("react").NamedExoticComponent<MenuViewProps>;
+export default MenuView;