@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/index.d.ts

@@ -1,29 +1,52 @@
-import React from 'react';
-import { type MetropolisConfiguration } from './config';
-import { type MetropolisAdapters } from './utils/MetropolisProvider';
 import type { FluxFramework } from '@nlabs/arkhamjs';
-export type { MetropolisConfiguration } from './config';
-export type { MetropolisAdapters } from './utils/MetropolisProvider';
-export declare const onInit: (flux: FluxFramework) => void;
-export * from './stores';
-export { appMutation, appQuery, publicMutation, publicQuery, refreshSession, uploadImage, type ApiResultsType, type ReaktorDbCollection } from './utils/api';
+import type { MetropolisConfiguration } from './config/index.js';
+import type { MetropolisAdapters } from './utils/MetropolisProvider.js';
+export { MetropolisContext, MetropolisProvider } from './utils/MetropolisProvider.js';
+export type { MetropolisConfiguration } from './config/index.js';
+export type { MetropolisAdapters } from './utils/MetropolisProvider.js';
+export declare const onInit: (flux: FluxFramework) => Promise<void>;
+export * from './stores/index.js';
+export { appMutation, appQuery, publicMutation, publicQuery, refreshSession, uploadImage, type ApiResultsType, type ReaktorDbCollection } from './utils/api.js';
+export { resolveEnvironmentConfig } from './config/index.js';
+export { getConfigFromFlux } from './utils/configUtils.js';
 export interface MetropolisProps {
     readonly adapters?: MetropolisAdapters;
     readonly children?: React.ReactElement | React.ReactElement[];
     readonly config?: MetropolisConfiguration;
+    readonly translations?: SimpleTranslations | ComplexTranslations;
 }
-export declare const Metropolis: ({ adapters, children, config }: MetropolisProps) => import("react/jsx-runtime").JSX.Element;
+export type SimpleTranslations = Record<string, string>;
+export interface ComplexTranslation {
+    readonly value: string;
+    readonly locale: string;
+    readonly namespace?: string;
+}
+export type ComplexTranslations = Record<string, ComplexTranslation>;
+export declare const Metropolis: ({ adapters, children, config, translations }: MetropolisProps) => import("react/jsx-runtime").JSX.Element;
 export default Metropolis;
-export { useMetropolis } from './utils/useMetropolis';
-export { createAction, createActions, createAllActions, type ActionOptions, type ActionReturnType, type ActionType, type ActionTypes } from './utils/actionFactory';
-export { createValidatorFactory, createValidatorManager, type BaseAdapterOptions } from './utils/validatorFactory';
-export { createBaseActions, type BaseActionOptions } from './utils/baseActionFactory';
-export * from './adapters';
-export * from './stores';
-export * from './utils/app';
-export * from './utils/dateUtils';
-export * from './utils/file';
-export * from './utils/location';
-export * from './constants/MetropolisConstants';
-export * from './graphql/message';
-export * from './graphql/notification';
+export { useTranslation } from 'react-i18next';
+export * from './adapters/index.js';
+export * from './constants/MetropolisConstants.js';
+export * from './graphql/message.js';
+export * from './graphql/notification.js';
+export * from './stores/index.js';
+export { createAction, createActions, createAllActions } from './utils/actionFactory.js';
+export * from './utils/app.js';
+export { createBaseActions } from './utils/baseActionFactory.js';
+export * from './utils/dateUtils.js';
+export * from './utils/file.js';
+export * from './utils/location.js';
+export { useContentActions, useEventActions, useGroupActions, useImageActions, useLocationActions, useMessageActions, useMetropolis, useMetropolisConfig, useMetropolisFlux, usePostActions, usePersonaActions, useReactionActions, useTagActions, useTranslationActions, useUserActions, useWebsocketActions } from './utils/useMetropolis.js';
+export { useConversationTyping } from './utils/useConversationTyping.js';
+export type { ConversationTypingOptions, UseConversationTypingOptions } from './utils/useConversationTyping.js';
+export { createValidatorFactory, createValidatorManager } from './utils/validatorFactory.js';
+export type { ActionOptions, ActionReturnType, ActionType, ActionTypes } from './utils/actionFactory.js';
+export type { BaseActionOptions } from './utils/baseActionFactory.js';
+export type { BaseAdapterOptions } from './utils/validatorFactory.js';
+export * from './actions/appActions/appActions.js';
+export * from './actions/connectionActions/connectionActions.js';
+export * from './actions/conversationActions/conversationActions.js';
+export * from './actions/videoActions/videoActions.js';
+export * from './constants/Collections.js';
+export * from './types/index.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.tsx"],"names":[],"mappings":"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"}

package/lib/index.js

@@ -1,2 +1,248 @@
-import{useFlux as a}from"@nlabs/arkhamjs-utils-react";import{useEffect as c}from"react";import{createWebsocketActions as f}from"./actions/websocketActions/websocketActions";import{Config as l}from"./config";import{app as m,events as u,images as x,locations as y,messages as d,posts as g,tags as M,users as A,websocket as k}from"./stores";import{refreshSession as C}from"./utils/api";import{MetropolisContext as R}from"./utils/MetropolisProvider";export*from"./stores";import{appMutation as N,appQuery as W,publicMutation as j,publicQuery as q,refreshSession as z,uploadImage as G}from"./utils/api";import{useMetropolis as J}from"./utils/useMetropolis";import{createAction as L,createActions as U,createAllActions as X}from"./utils/actionFactory";import{createValidatorFactory as Z,createValidatorManager as _}from"./utils/validatorFactory";import{createBaseActions as oo}from"./utils/baseActionFactory";export*from"./adapters";export*from"./stores";export*from"./utils/app";export*from"./utils/dateUtils";export*from"./utils/file";export*from"./utils/location";export*from"./constants/MetropolisConstants";export*from"./graphql/message";export*from"./graphql/notification";import{jsx as w}from"react/jsx-runtime";const b=e=>{try{e.addStores([m,u,x,y,d,g,M,A,k]);const o=e.getState("user.session.token");o&&C(e,o)}catch(o){throw o}},h=({adapters:e,children:o,config:r={}})=>{l.setConfig(r);const t=a(),s=f(t),p=[],i=[],n={};return c(()=>{b(t),s.wsInit()},[]),w(R.Provider,{value:{adapters:e,isAuth:()=>!0,messages:p,notifications:i,session:n,updateMessage:()=>{},updateNotification:()=>{}},children:o})};var O=h;export{h as Metropolis,N as appMutation,W as appQuery,L as createAction,U as createActions,X as createAllActions,oo as createBaseActions,Z as createValidatorFactory,_ as createValidatorManager,O as default,b as onInit,j as publicMutation,q as publicQuery,z as refreshSession,G as uploadImage,J as useMetropolis};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/index.tsx"],
  "sourcesContent": ["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {useFlux} from '@nlabs/arkhamjs-utils-react';\nimport React, {useEffect} from 'react';\n\nimport {createWebsocketActions} from './actions/websocketActions/websocketActions';\nimport {Config, type MetropolisConfiguration} from './config';\nimport {\n  app,\n  events,\n  images,\n  locations,\n  messages,\n  posts,\n  tags,\n  users,\n  websocket\n} from './stores';\nimport {refreshSession} from './utils/api';\nimport {MetropolisContext, type MetropolisAdapters} from './utils/MetropolisProvider';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\n\nexport type {MetropolisConfiguration} from './config';\nexport type {MetropolisAdapters} from './utils/MetropolisProvider';\n\nexport const onInit = (flux: FluxFramework) => {\n  try {\n    flux.addStores([\n      app,\n      events,\n      images,\n      locations,\n      messages,\n      posts,\n      tags,\n      users,\n      websocket\n    ]);\n    const token = flux.getState('user.session.token');\n    console.log({token});\n\n    if(token) {\n      refreshSession(flux, token as string);\n    }\n    // wsInit();\n  } catch(error) {\n    throw error;\n  }\n};\n\nexport * from './stores';\n\nexport {\n  appMutation,\n  appQuery,\n  publicMutation,\n  publicQuery,\n  refreshSession,\n  uploadImage,\n  type ApiResultsType,\n  type ReaktorDbCollection\n} from './utils/api';\n\nexport interface MetropolisProps {\n  readonly adapters?: MetropolisAdapters;\n  readonly children?: React.ReactElement | React.ReactElement[];\n  readonly config?: MetropolisConfiguration;\n}\n\nexport const Metropolis = ({adapters, children, config = {}}: MetropolisProps) => {\n  Config.setConfig(config);\n  console.log('Metropolis::init', {config});\n  const flux = useFlux();\n  const websockets = createWebsocketActions(flux);\n  // const [messages, setMessages] = useState<MessageType[]>([]);\n  // const [notifications, setNotifications] = useState<any[]>([]);\n  // const [session, setSession] = useState<SessionType>({});\n\n  const messages = [];\n  const notifications = [];\n  const session = {};\n\n  // Save config to app\n  // const {isAuth: configAuth} = config;\n\n  // const onUpdateMessages = useCallback(() => {\n  //   const cachedSession = Flux.getState('user.session', {});\n  //   setMessages(cachedSession);\n  // }, []);\n  // const onUpdateNotifications = useCallback(() => {\n  //   const cachedSession = Flux.getState('user.session', {});\n  //   setNotifications(cachedSession);\n  // }, []);\n  // const onUpdateSession = useCallback(() => {\n  //   const cachedSession = Flux.getState('user.session', {});\n  //   setSession(cachedSession);\n  // }, []);\n  // const onSignOut = useCallback(() => {\n  //   Flux.setState('user.session', {});\n  //   setSession({});\n  // }, []);\n  // const isAuth = useCallback(() => {\n  //   if(configAuth) {\n  //     return configAuth();\n  //   }\n\n  //   const {userActive} = Flux.getState('user.session', {});\n  //   return userActive;\n  // }, []);\n  // const updateMessage = useCallback((message) => {\n  //   API.graphql(graphqlOperation(UPDATE_MESSAGES, {message}));\n  // }, []);\n  // const updateNotification = useCallback((notification) => {\n  //   API.graphql(graphqlOperation(UPDATE_NOTIFICATIONS, {notification}));\n  // }, []);\n\n  // useFluxListener(ArkhamConstants.INIT, onUpdateSession);\n  // useFluxListener(SIGNOUT, onSignOut);\n  // useFluxListener(UPDATE_MESSAGES, onUpdateMessages);\n  // useFluxListener(UPDATE_NOTIFICATIONS, onUpdateNotifications);\n  // useFluxListener(UPDATE_SESSION, onUpdateSession);\n\n  useEffect(() => {\n    // Initialize\n    onInit(flux);\n    websockets.wsInit();\n\n    // const messageSubscription = API.graphql(graphqlOperation(MessageSubscription))\n    //   // @ts-ignore\n    //   .subscribe({\n    //     next: ({provider, value: messages}) => {\n    //       console.log({provider, messages});\n    //       Flux.dispatch({type: UPDATE_MESSAGES, messages});\n    //     },\n    //     error: (error) => console.warn(error)\n    //   });\n    // const notificationSubscription = API.graphql(graphqlOperation(NotificationSubscription))\n    //   // @ts-ignore\n    //   .subscribe({\n    //     next: ({provider, value: notifications}) => {\n    //       console.log({provider, notifications});\n    //       Flux.dispatch({type: UPDATE_NOTIFICATIONS, notifications});\n    //     },\n    //     error: (error) => console.warn(error)\n    //   });\n    // const sessionSubscription = API.graphql(graphqlOperation(SessionSubscription))\n    //   // @ts-ignore\n    //   .subscribe({\n    //     next: ({provider, value: session}) => {\n    //       console.log({provider, session});\n    //       Flux.dispatch({type: UPDATE_SESSION, session});\n    //     },\n    //     error: (error) => console.warn(error)\n    //   });\n\n    // return () => {\n    //   sessionSubscription.unsubscribe();\n    //   messageSubscription.unsubscribe();\n    //   notificationSubscription.unsubscribe();\n    // };\n  }, []);\n\n  return (\n    <MetropolisContext.Provider\n      value={{\n        adapters,\n        isAuth: () => true,\n        messages,\n        notifications,\n        session,\n        updateMessage: () => { },\n        updateNotification: () => { }\n      }}>\n      {children}\n    </MetropolisContext.Provider>\n  );\n};\n\nexport default Metropolis;\n\nexport {useMetropolis} from './utils/useMetropolis';\n\n// Export new consolidated action factory (replaces all individual createXxxActions)\nexport {\n  createAction,\n  createActions,\n  createAllActions, type ActionOptions, type ActionReturnType, type ActionType, type ActionTypes\n} from './utils/actionFactory';\n\n// Export new consolidated utilities\nexport {\n  createValidatorFactory,\n  createValidatorManager,\n  type BaseAdapterOptions\n} from './utils/validatorFactory';\n\nexport {\n  createBaseActions,\n  type BaseActionOptions\n} from './utils/baseActionFactory';\n\n// Export adapters\nexport * from './adapters';\n\n// Export stores\nexport * from './stores';\n\n// Export utilities (excluding api to avoid conflicts)\nexport * from './utils/app';\nexport * from './utils/dateUtils';\nexport * from './utils/file';\nexport * from './utils/location';\n\n// Export constants\nexport * from './constants/MetropolisConstants';\n\n// Export GraphQL (excluding session to avoid SessionType conflict)\nexport * from './graphql/message';\nexport * from './graphql/notification';\n\n"],
  "mappings": "AAIA,OAAQ,WAAAA,MAAc,8BACtB,OAAe,aAAAC,MAAgB,QAE/B,OAAQ,0BAAAC,MAA6B,8CACrC,OAAQ,UAAAC,MAA2C,WACnD,OACE,OAAAC,EACA,UAAAC,EACA,UAAAC,EACA,aAAAC,EACA,YAAAC,EACA,SAAAC,EACA,QAAAC,EACA,SAAAC,EACA,aAAAC,MACK,WACP,OAAQ,kBAAAC,MAAqB,cAC7B,OAAQ,qBAAAC,MAAiD,6BAgCzD,WAAc,WAEd,OACE,eAAAC,EACA,YAAAC,EACA,kBAAAC,EACA,eAAAC,EACA,kBAAAL,EACA,eAAAM,MAGK,cAuHP,OAAQ,iBAAAC,MAAoB,wBAG5B,OACE,gBAAAC,EACA,iBAAAC,EACA,oBAAAC,MACK,wBAGP,OACE,0BAAAC,EACA,0BAAAC,MAEK,2BAEP,OACE,qBAAAC,OAEK,4BAGP,WAAc,aAGd,WAAc,WAGd,WAAc,cACd,WAAc,oBACd,WAAc,eACd,WAAc,mBAGd,WAAc,kCAGd,WAAc,oBACd,WAAc,yBAvDV,cAAAC,MAAA,oBA1IG,MAAMC,EAAUC,GAAwB,CAC7C,GAAI,CACFA,EAAK,UAAU,CACbzB,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,CACF,CAAC,EACD,MAAMkB,EAAQD,EAAK,SAAS,oBAAoB,EAG7CC,GACDjB,EAAegB,EAAMC,CAAe,CAGxC,OAAQC,EAAO,CACb,MAAMA,CACR,CACF,EAqBaC,EAAa,CAAC,CAAC,SAAAC,EAAU,SAAAC,EAAU,OAAAC,EAAS,CAAC,CAAC,IAAuB,CAChFhC,EAAO,UAAUgC,CAAM,EAEvB,MAAMN,EAAO7B,EAAQ,EACfoC,EAAalC,EAAuB2B,CAAI,EAKxCrB,EAAW,CAAC,EACZ6B,EAAgB,CAAC,EACjBC,EAAU,CAAC,EA0CjB,OAAArC,EAAU,IAAM,CAEd2B,EAAOC,CAAI,EACXO,EAAW,OAAO,CAmCpB,EAAG,CAAC,CAAC,EAGHT,EAACb,EAAkB,SAAlB,CACC,MAAO,CACL,SAAAmB,EACA,OAAQ,IAAM,GACd,SAAAzB,EACA,cAAA6B,EACA,QAAAC,EACA,cAAe,IAAM,CAAE,EACvB,mBAAoB,IAAM,CAAE,CAC9B,EACC,SAAAJ,EACH,CAEJ,EAEA,IAAOK,EAAQP",
  "names": ["useFlux", "useEffect", "createWebsocketActions", "Config", "app", "events", "images", "locations", "messages", "posts", "tags", "users", "websocket", "refreshSession", "MetropolisContext", "appMutation", "appQuery", "publicMutation", "publicQuery", "uploadImage", "useMetropolis", "createAction", "createActions", "createAllActions", "createValidatorFactory", "createValidatorManager", "createBaseActions", "jsx", "onInit", "flux", "token", "error", "Metropolis", "adapters", "children", "config", "websockets", "notifications", "session", "index_default"]
}

+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { useFlux, useFluxState } from '@nlabs/arkhamjs-utils-react';
+import i18n from 'i18next';
+import { DateTime } from 'luxon';
+import { useEffect, useMemo, useRef } from 'react';
+import { I18nextProvider } from 'react-i18next';
+import { syncPersonaTagsToSession, syncPersonaToSession } from './actions/personaActions/personaActions.js';
+import { resolveEnvironmentConfig } from './config/index.js';
+import { app, events, images, locations, messages, notifications, NOTIFICATION_CONSTANTS, permissions, PERSONA_CONSTANTS, posts, subscriptions, TAG_CONSTANTS, tags, USER_CONSTANTS, users, video, websocket } from './stores/index.js';
+import { refreshSession } from './utils/api.js';
+import { getConfigFromFlux } from './utils/configUtils.js';
+import { initI18n } from './utils/i18n.js';
+import { MetropolisContext } from './utils/MetropolisProvider.js';
+import { getRefreshWindowMinutes, hydrateSessionFromStorage, parseJwtExpiryMs } from './utils/session.js';
+import { createAction } from './utils/actionFactory.js';
+export { MetropolisContext, MetropolisProvider } from './utils/MetropolisProvider.js';
+export const onInit = async (flux)=>{
+    if (!flux.getState('app.metropolisInitialized')) {
+        flux.addStores([
+            app,
+            events,
+            images,
+            locations,
+            messages,
+            notifications,
+            permissions,
+            posts,
+            subscriptions,
+            tags,
+            users,
+            video,
+            websocket
+        ]);
+        flux.on(USER_CONSTANTS.SIGN_OUT_SUCCESS, ()=>{
+            flux.dispatch({
+                type: NOTIFICATION_CONSTANTS.CLEAR_ITEMS
+            });
+        });
+        flux.on(PERSONA_CONSTANTS.ADD_ITEM_SUCCESS, async ({ persona = {} })=>{
+            syncPersonaToSession(flux, persona);
+            if (persona?.personaId && !Array.isArray(persona?.tags)) {
+                await syncPersonaTagsToSession(flux, String(persona.personaId));
+            }
+        });
+        flux.on(PERSONA_CONSTANTS.UPDATE_ITEM_SUCCESS, async ({ persona = {} })=>{
+            syncPersonaToSession(flux, persona);
+            if (persona?.personaId && !Array.isArray(persona?.tags)) {
+                await syncPersonaTagsToSession(flux, String(persona.personaId));
+            }
+        });
+        flux.on(TAG_CONSTANTS.ADD_PERSONA_SUCCESS, ({ tag })=>{
+            const currentSession = flux.getState('user.session', {}) || {};
+            const currentTags = Array.isArray(currentSession.tags) ? currentSession.tags : [];
+            const nextTagId = String(tag?.tagId || '').trim();
+            if (!nextTagId) {
+                return;
+            }
+            const mergedTags = [
+                ...currentTags.filter((item)=>String(item?.tagId || '').trim() !== nextTagId),
+                tag
+            ].sort((left, right)=>String(left?.name || '').localeCompare(String(right?.name || '')));
+            const nextSession = {
+                ...currentSession,
+                tags: mergedTags
+            };
+            void flux.setState('user.session', nextSession);
+            flux.dispatch({
+                type: USER_CONSTANTS.UPDATE_SESSION_SUCCESS,
+                user: {
+                    tags: mergedTags
+                }
+            });
+        });
+        flux.on(TAG_CONSTANTS.REMOVE_PERSONA_SUCCESS, ({ tag })=>{
+            const currentSession = flux.getState('user.session', {}) || {};
+            const currentTags = Array.isArray(currentSession.tags) ? currentSession.tags : [];
+            const nextTagId = String(tag?.tagId || '').trim();
+            if (!nextTagId) {
+                return;
+            }
+            const nextTags = currentTags.filter((item)=>String(item?.tagId || '').trim() !== nextTagId);
+            const nextSession = {
+                ...currentSession,
+                tags: nextTags
+            };
+            void flux.setState('user.session', nextSession);
+            flux.dispatch({
+                type: USER_CONSTANTS.UPDATE_SESSION_SUCCESS,
+                user: {
+                    tags: nextTags
+                }
+            });
+        });
+        await Promise.resolve(flux.setState('app.metropolisInitialized', true));
+    }
+    const token = String(flux.getState('user.session.token') || '');
+    if (token) {
+        const session = flux.getState('user.session', {}) || {};
+        const config = getConfigFromFlux(flux);
+        const tokenExpiresAt = parseJwtExpiryMs(token);
+        const sessionLifetimeMinutes = Math.round((Number(session.expires || 0) - Number(session.issued || 0)) / (1000 * 60));
+        const refreshWindowMinutes = getRefreshWindowMinutes(sessionLifetimeMinutes || 15, config.app?.session || {});
+        const refreshExpiresMinutes = Math.max(1, Number(config.app?.session?.maxMinutes || sessionLifetimeMinutes || 15));
+        const expiresAt = Number(session.expires || 0);
+        if (tokenExpiresAt > 0 && Date.now() >= tokenExpiresAt) {
+            await refreshSession(flux, token, refreshExpiresMinutes);
+        } else if (!expiresAt) {
+            await refreshSession(flux, token, refreshExpiresMinutes);
+        } else {
+            const minutesUntilExpiry = Math.round(DateTime.fromMillis(expiresAt).diff(DateTime.local(), 'minutes').toObject().minutes || 0);
+            if (minutesUntilExpiry <= 0 || minutesUntilExpiry <= refreshWindowMinutes) {
+                await refreshSession(flux, token, refreshExpiresMinutes);
+            }
+        }
+    }
+};
+export * from './stores/index.js';
+export { appMutation, appQuery, publicMutation, publicQuery, refreshSession, uploadImage } from './utils/api.js';
+export { resolveEnvironmentConfig } from './config/index.js';
+export { getConfigFromFlux } from './utils/configUtils.js';
+export const Metropolis = ({ adapters, children, config = {}, translations = {} })=>{
+    const flux = useFlux();
+    const resolvedConfig = useMemo(()=>resolveEnvironmentConfig(config), [
+        config
+    ]);
+    const mergedAdapters = useMemo(()=>({
+            ...resolvedConfig.adapters,
+            ...adapters
+        }), [
+        resolvedConfig.adapters,
+        adapters
+    ]);
+    const sessionPersonaId = String(useFluxState('user.session.personaId', '') || '');
+    const sessionToken = String(useFluxState('user.session.token', '') || '');
+    const sessionHydrated = Boolean(useFluxState('app.sessionHydrated', false));
+    const session = useFluxState('user.session', {});
+    const notificationList = useFluxState('notification.list', []);
+    const conversationMap = useFluxState('message.conversations', {});
+    const messages = useMemo(()=>Object.values(conversationMap).flat(), [
+        conversationMap
+    ]);
+    const websocketsRef = useRef(null);
+    if (!websocketsRef.current) {
+        websocketsRef.current = createAction('websocket', flux);
+    }
+    const websockets = websocketsRef.current;
+    useEffect(()=>{
+        initI18n(translations);
+    }, [
+        translations
+    ]);
+    useEffect(()=>{
+        let isActive = true;
+        void (async ()=>{
+            await Promise.resolve(flux.setState('app.config', resolvedConfig));
+            await Promise.resolve(flux.setState('app.sessionHydrated', false));
+            await hydrateSessionFromStorage(flux);
+            if (!isActive) {
+                return;
+            }
+            await onInit(flux);
+            if (!isActive) {
+                return;
+            }
+            await Promise.resolve(flux.setState('app.sessionHydrated', true));
+        })();
+        return ()=>{
+            isActive = false;
+        };
+    }, [
+        flux,
+        resolvedConfig
+    ]);
+    useEffect(()=>{
+        if (!sessionHydrated) {
+            websockets.wsClose();
+            return;
+        }
+        if (sessionToken) {
+            websockets.wsInit(sessionToken, sessionPersonaId);
+        } else {
+            websockets.wsClose();
+        }
+    }, [
+        sessionHydrated,
+        sessionPersonaId,
+        sessionToken,
+        websockets
+    ]);
+    useEffect(()=>{
+        return ()=>{
+            websockets.wsClose();
+        };
+    }, [
+        websockets
+    ]);
+    const isAuth = useMemo(()=>resolvedConfig.isAuth || (()=>{
+            const sessionState = flux.getState('user.session', {});
+            return !!sessionState.userActive;
+        }), [
+        resolvedConfig.isAuth,
+        flux
+    ]);
+    return /*#__PURE__*/ _jsx(MetropolisContext.Provider, {
+        value: {
+            adapters: mergedAdapters,
+            config: resolvedConfig,
+            flux,
+            isAuth,
+            messages,
+            notifications: notificationList,
+            session,
+            updateMessage: ()=>{},
+            updateNotification: websockets.sendNotification
+        },
+        children: /*#__PURE__*/ _jsx(I18nextProvider, {
+            i18n: i18n,
+            children: children
+        })
+    });
+};
+export default Metropolis;
+export { useTranslation } from 'react-i18next';
+export * from './adapters/index.js';
+export * from './constants/MetropolisConstants.js';
+export * from './graphql/message.js';
+export * from './graphql/notification.js';
+export * from './stores/index.js';
+export { createAction, createActions, createAllActions } from './utils/actionFactory.js';
+export * from './utils/app.js';
+export { createBaseActions } from './utils/baseActionFactory.js';
+export * from './utils/dateUtils.js';
+export * from './utils/file.js';
+export * from './utils/location.js';
+export { useContentActions, useEventActions, useGroupActions, useImageActions, useLocationActions, useMessageActions, useMetropolis, useMetropolisConfig, useMetropolisFlux, usePostActions, usePersonaActions, useReactionActions, useTagActions, useTranslationActions, useUserActions, useWebsocketActions } from './utils/useMetropolis.js';
+export { useConversationTyping } from './utils/useConversationTyping.js';
+export { createValidatorFactory, createValidatorManager } from './utils/validatorFactory.js';
+export * from './actions/appActions/appActions.js';
+export * from './actions/connectionActions/connectionActions.js';
+export * from './actions/conversationActions/conversationActions.js';
+export * from './actions/videoActions/videoActions.js';
+export * from './constants/Collections.js';
+export * from './types/index.js';
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/index.tsx"],"sourcesContent":["/**\n * Copyright (c) 2019-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {useFlux, useFluxState} from '@nlabs/arkhamjs-utils-react';\nimport i18n from 'i18next';\nimport {DateTime} from 'luxon';\nimport {useEffect, useMemo, useRef} from 'react';\nimport {I18nextProvider} from 'react-i18next';\n\nimport {createWebsocketActions} from './actions/websocketActions/websocketActions.js';\nimport {syncPersonaTagsToSession, syncPersonaToSession} from './actions/personaActions/personaActions.js';\nimport {resolveEnvironmentConfig} from './config/index.js';\nimport {\n  app,\n  events,\n  images,\n  locations,\n  messages,\n  notifications,\n  NOTIFICATION_CONSTANTS,\n  permissions,\n  PERSONA_CONSTANTS,\n  posts,\n  subscriptions,\n  TAG_CONSTANTS,\n  tags,\n  USER_CONSTANTS,\n  users,\n  video,\n  websocket\n} from './stores/index.js';\nimport {refreshSession} from './utils/api.js';\nimport {getConfigFromFlux} from './utils/configUtils.js';\nimport {initI18n} from './utils/i18n.js';\nimport {MetropolisContext} from './utils/MetropolisProvider.js';\nimport {getRefreshWindowMinutes, hydrateSessionFromStorage, parseJwtExpiryMs} from './utils/session.js';\nimport {createAction} from './utils/actionFactory.js';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {MetropolisConfiguration, MetropolisEnvironmentConfiguration} from './config/index.js';\nimport type {MetropolisAdapters} from './utils/MetropolisProvider.js';\n\nexport {MetropolisContext, MetropolisProvider} from './utils/MetropolisProvider.js';\n\nexport type {MetropolisConfiguration} from './config/index.js';\nexport type {MetropolisAdapters} from './utils/MetropolisProvider.js';\n\nexport const onInit = async (flux: FluxFramework) => {\n  if(!flux.getState('app.metropolisInitialized')) {\n    flux.addStores([\n      app,\n      events,\n      images,\n      locations,\n      messages,\n      notifications,\n      permissions,\n      posts,\n      subscriptions,\n      tags,\n      users,\n      video,\n      websocket\n    ]);\n    flux.on(USER_CONSTANTS.SIGN_OUT_SUCCESS, () => {\n      flux.dispatch({type: NOTIFICATION_CONSTANTS.CLEAR_ITEMS});\n    });\n    flux.on(PERSONA_CONSTANTS.ADD_ITEM_SUCCESS, async ({persona = {}}: {persona?: Record<string, unknown>}) => {\n      syncPersonaToSession(flux, persona);\n\n      if(persona?.personaId && !Array.isArray(persona?.tags)) {\n        await syncPersonaTagsToSession(flux, String(persona.personaId));\n      }\n    });\n\n    flux.on(PERSONA_CONSTANTS.UPDATE_ITEM_SUCCESS, async ({persona = {}}: {persona?: Record<string, unknown>}) => {\n      syncPersonaToSession(flux, persona);\n\n      if(persona?.personaId && !Array.isArray(persona?.tags)) {\n        await syncPersonaTagsToSession(flux, String(persona.personaId));\n      }\n    });\n\n    flux.on(TAG_CONSTANTS.ADD_PERSONA_SUCCESS, ({tag}: {tag?: {name?: string; tagId?: string}}) => {\n      const currentSession = (flux.getState('user.session', {}) || {}) as Record<string, unknown> & {\n        tags?: Array<{name?: string; tagId?: string}>;\n      };\n      const currentTags = Array.isArray(currentSession.tags) ? currentSession.tags : [];\n      const nextTagId = String(tag?.tagId || '').trim();\n\n      if(!nextTagId) {\n        return;\n      }\n\n      const mergedTags = [...currentTags.filter((item) => String(item?.tagId || '').trim() !== nextTagId), tag as {name?: string; tagId?: string}]\n        .sort((left, right) => String(left?.name || '').localeCompare(String(right?.name || '')));\n      const nextSession = {...currentSession, tags: mergedTags};\n\n      void flux.setState('user.session', nextSession);\n      flux.dispatch({type: USER_CONSTANTS.UPDATE_SESSION_SUCCESS, user: {tags: mergedTags}});\n    });\n\n    flux.on(TAG_CONSTANTS.REMOVE_PERSONA_SUCCESS, ({tag}: {tag?: {tagId?: string}}) => {\n      const currentSession = (flux.getState('user.session', {}) || {}) as Record<string, unknown> & {\n        tags?: Array<{name?: string; tagId?: string}>;\n      };\n      const currentTags = Array.isArray(currentSession.tags) ? currentSession.tags : [];\n      const nextTagId = String(tag?.tagId || '').trim();\n\n      if(!nextTagId) {\n        return;\n      }\n\n      const nextTags = currentTags.filter((item) => String(item?.tagId || '').trim() !== nextTagId);\n      const nextSession = {...currentSession, tags: nextTags};\n\n      void flux.setState('user.session', nextSession);\n      flux.dispatch({type: USER_CONSTANTS.UPDATE_SESSION_SUCCESS, user: {tags: nextTags}});\n    });\n    await Promise.resolve(flux.setState('app.metropolisInitialized', true));\n  }\n\n  const token = String(flux.getState('user.session.token') || '');\n\n  if(token) {\n    const session = (flux.getState('user.session', {}) || {}) as {expires?: number; issued?: number; token?: string};\n    const config = getConfigFromFlux(flux);\n    const tokenExpiresAt = parseJwtExpiryMs(token);\n    const sessionLifetimeMinutes = Math.round((Number(session.expires || 0) - Number(session.issued || 0)) / (1000 * 60));\n    const refreshWindowMinutes = getRefreshWindowMinutes(\n      sessionLifetimeMinutes || 15,\n      config.app?.session || {}\n    );\n    const refreshExpiresMinutes = Math.max(1, Number(config.app?.session?.maxMinutes || sessionLifetimeMinutes || 15));\n    const expiresAt = Number(session.expires || 0);\n\n    if(tokenExpiresAt > 0 && Date.now() >= tokenExpiresAt) {\n      await refreshSession(flux, token, refreshExpiresMinutes);\n    } else if(!expiresAt) {\n      await refreshSession(flux, token, refreshExpiresMinutes);\n    } else {\n      const minutesUntilExpiry = Math.round(DateTime.fromMillis(expiresAt).diff(DateTime.local(), 'minutes').toObject().minutes || 0);\n\n      if(minutesUntilExpiry <= 0 || minutesUntilExpiry <= refreshWindowMinutes) {\n        await refreshSession(flux, token as string, refreshExpiresMinutes);\n      }\n    }\n  }\n};\n\nexport * from './stores/index.js';\n\nexport {\n  appMutation,\n  appQuery,\n  publicMutation,\n  publicQuery,\n  refreshSession,\n  uploadImage,\n  type ApiResultsType,\n  type ReaktorDbCollection\n} from './utils/api.js';\n\nexport {resolveEnvironmentConfig} from './config/index.js';\nexport {getConfigFromFlux} from './utils/configUtils.js';\n\nexport interface MetropolisProps {\n  readonly adapters?: MetropolisAdapters;\n  readonly children?: React.ReactElement | React.ReactElement[];\n  readonly config?: MetropolisConfiguration;\n  readonly translations?: SimpleTranslations | ComplexTranslations;\n}\n\nexport type SimpleTranslations = Record<string, string>;\n\nexport interface ComplexTranslation {\n  readonly value: string;\n  readonly locale: string;\n  readonly namespace?: string;\n}\n\nexport type ComplexTranslations = Record<string, ComplexTranslation>;\n\nexport const Metropolis = ({adapters, children, config = {}, translations = {}}: MetropolisProps) => {\n  const flux = useFlux();\n  const resolvedConfig = useMemo<MetropolisEnvironmentConfiguration>(() => resolveEnvironmentConfig(config), [config]);\n  const mergedAdapters = useMemo(() => ({...resolvedConfig.adapters, ...adapters}), [resolvedConfig.adapters, adapters]);\n  const sessionPersonaId = String(useFluxState('user.session.personaId', '') || '');\n  const sessionToken = String(useFluxState('user.session.token', '') || '');\n  const sessionHydrated = Boolean(useFluxState('app.sessionHydrated', false));\n  const session = useFluxState('user.session', {}) as Record<string, unknown>;\n  const notificationList = useFluxState('notification.list', []) as Array<Record<string, unknown>>;\n  const conversationMap = useFluxState('message.conversations', {}) as Record<string, Array<Record<string, unknown>>>;\n  const messages = useMemo(() => Object.values(conversationMap).flat(), [conversationMap]);\n\n  const websocketsRef = useRef<ReturnType<typeof createWebsocketActions> | null>(null);\n  if(!websocketsRef.current) {\n    websocketsRef.current = createAction('websocket', flux) as ReturnType<typeof createWebsocketActions>;\n  }\n  const websockets = websocketsRef.current;\n\n  useEffect(() => {\n    initI18n(translations);\n  }, [translations]);\n\n  useEffect(() => {\n    let isActive = true;\n\n    void (async () => {\n      await Promise.resolve(flux.setState('app.config', resolvedConfig));\n      await Promise.resolve(flux.setState('app.sessionHydrated', false));\n      await hydrateSessionFromStorage(flux);\n\n      if(!isActive) {\n        return;\n      }\n\n      await onInit(flux);\n\n      if(!isActive) {\n        return;\n      }\n\n      await Promise.resolve(flux.setState('app.sessionHydrated', true));\n    })();\n\n    return () => {\n      isActive = false;\n    };\n  }, [flux, resolvedConfig]);\n\n  useEffect(() => {\n    if(!sessionHydrated) {\n      websockets.wsClose();\n      return;\n    }\n\n    if(sessionToken) {\n      websockets.wsInit(sessionToken, sessionPersonaId);\n    } else {\n      websockets.wsClose();\n    }\n  }, [sessionHydrated, sessionPersonaId, sessionToken, websockets]);\n\n  useEffect(() => {\n    return () => {\n      websockets.wsClose();\n    };\n  }, [websockets]);\n\n  const isAuth = useMemo(() => resolvedConfig.isAuth || (() => {\n    const sessionState = flux.getState('user.session', {});\n    return !!sessionState.userActive;\n  }), [resolvedConfig.isAuth, flux]);\n\n  return (\n    <MetropolisContext.Provider\n      value={{\n        adapters: mergedAdapters,\n        config: resolvedConfig,\n        flux,\n        isAuth,\n        messages,\n        notifications: notificationList,\n        session,\n        updateMessage: () => { },\n        updateNotification: websockets.sendNotification\n      }}>\n      <I18nextProvider i18n={i18n}>\n        {children}\n      </I18nextProvider>\n    </MetropolisContext.Provider>\n  );\n};\n\nexport default Metropolis;\n\nexport {useTranslation} from 'react-i18next';\nexport * from './adapters/index.js';\nexport * from './constants/MetropolisConstants.js';\nexport * from './graphql/message.js';\nexport * from './graphql/notification.js';\nexport * from './stores/index.js';\nexport {\n  createAction,\n  createActions,\n  createAllActions\n} from './utils/actionFactory.js';\nexport * from './utils/app.js';\nexport {createBaseActions} from './utils/baseActionFactory.js';\nexport * from './utils/dateUtils.js';\nexport * from './utils/file.js';\nexport * from './utils/location.js';\nexport {\n  useContentActions,\n  useEventActions,\n  useGroupActions,\n  useImageActions,\n  useLocationActions,\n  useMessageActions, useMetropolis,\n  useMetropolisConfig,\n  useMetropolisFlux, usePostActions,\n  usePersonaActions,\n  useReactionActions,\n  useTagActions,\n  useTranslationActions,\n  useUserActions,\n  useWebsocketActions\n} from './utils/useMetropolis.js';\nexport {useConversationTyping} from './utils/useConversationTyping.js';\nexport type {\n  ConversationTypingOptions,\n  UseConversationTypingOptions\n} from './utils/useConversationTyping.js';\nexport {\n  createValidatorFactory,\n  createValidatorManager\n} from './utils/validatorFactory.js';\n\nexport type {\n  ActionOptions,\n  ActionReturnType,\n  ActionType,\n  ActionTypes\n} from './utils/actionFactory.js';\nexport type {BaseActionOptions} from './utils/baseActionFactory.js';\nexport type {BaseAdapterOptions} from './utils/validatorFactory.js';\n\nexport * from './actions/appActions/appActions.js';\nexport * from './actions/connectionActions/connectionActions.js';\nexport * from './actions/conversationActions/conversationActions.js';\nexport * from './actions/videoActions/videoActions.js';\nexport * from './constants/Collections.js';\nexport * from './types/index.js';\n"],"names":["useFlux","useFluxState","i18n","DateTime","useEffect","useMemo","useRef","I18nextProvider","syncPersonaTagsToSession","syncPersonaToSession","resolveEnvironmentConfig","app","events","images","locations","messages","notifications","NOTIFICATION_CONSTANTS","permissions","PERSONA_CONSTANTS","posts","subscriptions","TAG_CONSTANTS","tags","USER_CONSTANTS","users","video","websocket","refreshSession","getConfigFromFlux","initI18n","MetropolisContext","getRefreshWindowMinutes","hydrateSessionFromStorage","parseJwtExpiryMs","createAction","MetropolisProvider","onInit","flux","getState","addStores","on","SIGN_OUT_SUCCESS","dispatch","type","CLEAR_ITEMS","ADD_ITEM_SUCCESS","persona","personaId","Array","isArray","String","UPDATE_ITEM_SUCCESS","ADD_PERSONA_SUCCESS","tag","currentSession","currentTags","nextTagId","tagId","trim","mergedTags","filter","item","sort","left","right","name","localeCompare","nextSession","setState","UPDATE_SESSION_SUCCESS","user","REMOVE_PERSONA_SUCCESS","nextTags","Promise","resolve","token","session","config","tokenExpiresAt","sessionLifetimeMinutes","Math","round","Number","expires","issued","refreshWindowMinutes","refreshExpiresMinutes","max","maxMinutes","expiresAt","Date","now","minutesUntilExpiry","fromMillis","diff","local","toObject","minutes","appMutation","appQuery","publicMutation","publicQuery","uploadImage","Metropolis","adapters","children","translations","resolvedConfig","mergedAdapters","sessionPersonaId","sessionToken","sessionHydrated","Boolean","notificationList","conversationMap","Object","values","flat","websocketsRef","current","websockets","isActive","wsClose","wsInit","isAuth","sessionState","userActive","Provider","value","updateMessage","updateNotification","sendNotification","useTranslation","createActions","createAllActions","createBaseActions","useContentActions","useEventActions","useGroupActions","useImageActions","useLocationActions","useMessageActions","useMetropolis","useMetropolisConfig","useMetropolisFlux","usePostActions","usePersonaActions","useReactionActions","useTagActions","useTranslationActions","useUserActions","useWebsocketActions","useConversationTyping","createValidatorFactory","createValidatorManager"],"mappings":";AAAA;;;CAGC,GACD,SAAQA,OAAO,EAAEC,YAAY,QAAO,8BAA8B;AAClE,OAAOC,UAAU,UAAU;AAC3B,SAAQC,QAAQ,QAAO,QAAQ;AAC/B,SAAQC,SAAS,EAAEC,OAAO,EAAEC,MAAM,QAAO,QAAQ;AACjD,SAAQC,eAAe,QAAO,gBAAgB;AAG9C,SAAQC,wBAAwB,EAAEC,oBAAoB,QAAO,6CAA6C;AAC1G,SAAQC,wBAAwB,QAAO,oBAAoB;AAC3D,SACEC,GAAG,EACHC,MAAM,EACNC,MAAM,EACNC,SAAS,EACTC,QAAQ,EACRC,aAAa,EACbC,sBAAsB,EACtBC,WAAW,EACXC,iBAAiB,EACjBC,KAAK,EACLC,aAAa,EACbC,aAAa,EACbC,IAAI,EACJC,cAAc,EACdC,KAAK,EACLC,KAAK,EACLC,SAAS,QACJ,oBAAoB;AAC3B,SAAQC,cAAc,QAAO,iBAAiB;AAC9C,SAAQC,iBAAiB,QAAO,yBAAyB;AACzD,SAAQC,QAAQ,QAAO,kBAAkB;AACzC,SAAQC,iBAAiB,QAAO,gCAAgC;AAChE,SAAQC,uBAAuB,EAAEC,yBAAyB,EAAEC,gBAAgB,QAAO,qBAAqB;AACxG,SAAQC,YAAY,QAAO,2BAA2B;AAMtD,SAAQJ,iBAAiB,EAAEK,kBAAkB,QAAO,gCAAgC;AAKpF,OAAO,MAAMC,SAAS,OAAOC;IAC3B,IAAG,CAACA,KAAKC,QAAQ,CAAC,8BAA8B;QAC9CD,KAAKE,SAAS,CAAC;YACb7B;YACAC;YACAC;YACAC;YACAC;YACAC;YACAE;YACAE;YACAC;YACAE;YACAE;YACAC;YACAC;SACD;QACDW,KAAKG,EAAE,CAACjB,eAAekB,gBAAgB,EAAE;YACvCJ,KAAKK,QAAQ,CAAC;gBAACC,MAAM3B,uBAAuB4B,WAAW;YAAA;QACzD;QACAP,KAAKG,EAAE,CAACtB,kBAAkB2B,gBAAgB,EAAE,OAAO,EAACC,UAAU,CAAC,CAAC,EAAsC;YACpGtC,qBAAqB6B,MAAMS;YAE3B,IAAGA,SAASC,aAAa,CAACC,MAAMC,OAAO,CAACH,SAASxB,OAAO;gBACtD,MAAMf,yBAAyB8B,MAAMa,OAAOJ,QAAQC,SAAS;YAC/D;QACF;QAEAV,KAAKG,EAAE,CAACtB,kBAAkBiC,mBAAmB,EAAE,OAAO,EAACL,UAAU,CAAC,CAAC,EAAsC;YACvGtC,qBAAqB6B,MAAMS;YAE3B,IAAGA,SAASC,aAAa,CAACC,MAAMC,OAAO,CAACH,SAASxB,OAAO;gBACtD,MAAMf,yBAAyB8B,MAAMa,OAAOJ,QAAQC,SAAS;YAC/D;QACF;QAEAV,KAAKG,EAAE,CAACnB,cAAc+B,mBAAmB,EAAE,CAAC,EAACC,GAAG,EAA0C;YACxF,MAAMC,iBAAkBjB,KAAKC,QAAQ,CAAC,gBAAgB,CAAC,MAAM,CAAC;YAG9D,MAAMiB,cAAcP,MAAMC,OAAO,CAACK,eAAehC,IAAI,IAAIgC,eAAehC,IAAI,GAAG,EAAE;YACjF,MAAMkC,YAAYN,OAAOG,KAAKI,SAAS,IAAIC,IAAI;YAE/C,IAAG,CAACF,WAAW;gBACb;YACF;YAEA,MAAMG,aAAa;mBAAIJ,YAAYK,MAAM,CAAC,CAACC,OAASX,OAAOW,MAAMJ,SAAS,IAAIC,IAAI,OAAOF;gBAAYH;aAAuC,CACzIS,IAAI,CAAC,CAACC,MAAMC,QAAUd,OAAOa,MAAME,QAAQ,IAAIC,aAAa,CAAChB,OAAOc,OAAOC,QAAQ;YACtF,MAAME,cAAc;gBAAC,GAAGb,cAAc;gBAAEhC,MAAMqC;YAAU;YAExD,KAAKtB,KAAK+B,QAAQ,CAAC,gBAAgBD;YACnC9B,KAAKK,QAAQ,CAAC;gBAACC,MAAMpB,eAAe8C,sBAAsB;gBAAEC,MAAM;oBAAChD,MAAMqC;gBAAU;YAAC;QACtF;QAEAtB,KAAKG,EAAE,CAACnB,cAAckD,sBAAsB,EAAE,CAAC,EAAClB,GAAG,EAA2B;YAC5E,MAAMC,iBAAkBjB,KAAKC,QAAQ,CAAC,gBAAgB,CAAC,MAAM,CAAC;YAG9D,MAAMiB,cAAcP,MAAMC,OAAO,CAACK,eAAehC,IAAI,IAAIgC,eAAehC,IAAI,GAAG,EAAE;YACjF,MAAMkC,YAAYN,OAAOG,KAAKI,SAAS,IAAIC,IAAI;YAE/C,IAAG,CAACF,WAAW;gBACb;YACF;YAEA,MAAMgB,WAAWjB,YAAYK,MAAM,CAAC,CAACC,OAASX,OAAOW,MAAMJ,SAAS,IAAIC,IAAI,OAAOF;YACnF,MAAMW,cAAc;gBAAC,GAAGb,cAAc;gBAAEhC,MAAMkD;YAAQ;YAEtD,KAAKnC,KAAK+B,QAAQ,CAAC,gBAAgBD;YACnC9B,KAAKK,QAAQ,CAAC;gBAACC,MAAMpB,eAAe8C,sBAAsB;gBAAEC,MAAM;oBAAChD,MAAMkD;gBAAQ;YAAC;QACpF;QACA,MAAMC,QAAQC,OAAO,CAACrC,KAAK+B,QAAQ,CAAC,6BAA6B;IACnE;IAEA,MAAMO,QAAQzB,OAAOb,KAAKC,QAAQ,CAAC,yBAAyB;IAE5D,IAAGqC,OAAO;QACR,MAAMC,UAAWvC,KAAKC,QAAQ,CAAC,gBAAgB,CAAC,MAAM,CAAC;QACvD,MAAMuC,SAASjD,kBAAkBS;QACjC,MAAMyC,iBAAiB7C,iBAAiB0C;QACxC,MAAMI,yBAAyBC,KAAKC,KAAK,CAAC,AAACC,CAAAA,OAAON,QAAQO,OAAO,IAAI,KAAKD,OAAON,QAAQQ,MAAM,IAAI,EAAC,IAAM,CAAA,OAAO,EAAC;QAClH,MAAMC,uBAAuBtD,wBAC3BgD,0BAA0B,IAC1BF,OAAOnE,GAAG,EAAEkE,WAAW,CAAC;QAE1B,MAAMU,wBAAwBN,KAAKO,GAAG,CAAC,GAAGL,OAAOL,OAAOnE,GAAG,EAAEkE,SAASY,cAAcT,0BAA0B;QAC9G,MAAMU,YAAYP,OAAON,QAAQO,OAAO,IAAI;QAE5C,IAAGL,iBAAiB,KAAKY,KAAKC,GAAG,MAAMb,gBAAgB;YACrD,MAAMnD,eAAeU,MAAMsC,OAAOW;QACpC,OAAO,IAAG,CAACG,WAAW;YACpB,MAAM9D,eAAeU,MAAMsC,OAAOW;QACpC,OAAO;YACL,MAAMM,qBAAqBZ,KAAKC,KAAK,CAAC/E,SAAS2F,UAAU,CAACJ,WAAWK,IAAI,CAAC5F,SAAS6F,KAAK,IAAI,WAAWC,QAAQ,GAAGC,OAAO,IAAI;YAE7H,IAAGL,sBAAsB,KAAKA,sBAAsBP,sBAAsB;gBACxE,MAAM1D,eAAeU,MAAMsC,OAAiBW;YAC9C;QACF;IACF;AACF,EAAE;AAEF,cAAc,oBAAoB;AAElC,SACEY,WAAW,EACXC,QAAQ,EACRC,cAAc,EACdC,WAAW,EACX1E,cAAc,EACd2E,WAAW,QAGN,iBAAiB;AAExB,SAAQ7F,wBAAwB,QAAO,oBAAoB;AAC3D,SAAQmB,iBAAiB,QAAO,yBAAyB;AAmBzD,OAAO,MAAM2E,aAAa,CAAC,EAACC,QAAQ,EAAEC,QAAQ,EAAE5B,SAAS,CAAC,CAAC,EAAE6B,eAAe,CAAC,CAAC,EAAkB;IAC9F,MAAMrE,OAAOtC;IACb,MAAM4G,iBAAiBvG,QAA4C,IAAMK,yBAAyBoE,SAAS;QAACA;KAAO;IACnH,MAAM+B,iBAAiBxG,QAAQ,IAAO,CAAA;YAAC,GAAGuG,eAAeH,QAAQ;YAAE,GAAGA,QAAQ;QAAA,CAAA,GAAI;QAACG,eAAeH,QAAQ;QAAEA;KAAS;IACrH,MAAMK,mBAAmB3D,OAAOlD,aAAa,0BAA0B,OAAO;IAC9E,MAAM8G,eAAe5D,OAAOlD,aAAa,sBAAsB,OAAO;IACtE,MAAM+G,kBAAkBC,QAAQhH,aAAa,uBAAuB;IACpE,MAAM4E,UAAU5E,aAAa,gBAAgB,CAAC;IAC9C,MAAMiH,mBAAmBjH,aAAa,qBAAqB,EAAE;IAC7D,MAAMkH,kBAAkBlH,aAAa,yBAAyB,CAAC;IAC/D,MAAMc,WAAWV,QAAQ,IAAM+G,OAAOC,MAAM,CAACF,iBAAiBG,IAAI,IAAI;QAACH;KAAgB;IAEvF,MAAMI,gBAAgBjH,OAAyD;IAC/E,IAAG,CAACiH,cAAcC,OAAO,EAAE;QACzBD,cAAcC,OAAO,GAAGrF,aAAa,aAAaG;IACpD;IACA,MAAMmF,aAAaF,cAAcC,OAAO;IAExCpH,UAAU;QACR0B,SAAS6E;IACX,GAAG;QAACA;KAAa;IAEjBvG,UAAU;QACR,IAAIsH,WAAW;QAEf,KAAK,AAAC,CAAA;YACJ,MAAMhD,QAAQC,OAAO,CAACrC,KAAK+B,QAAQ,CAAC,cAAcuC;YAClD,MAAMlC,QAAQC,OAAO,CAACrC,KAAK+B,QAAQ,CAAC,uBAAuB;YAC3D,MAAMpC,0BAA0BK;YAEhC,IAAG,CAACoF,UAAU;gBACZ;YACF;YAEA,MAAMrF,OAAOC;YAEb,IAAG,CAACoF,UAAU;gBACZ;YACF;YAEA,MAAMhD,QAAQC,OAAO,CAACrC,KAAK+B,QAAQ,CAAC,uBAAuB;QAC7D,CAAA;QAEA,OAAO;YACLqD,WAAW;QACb;IACF,GAAG;QAACpF;QAAMsE;KAAe;IAEzBxG,UAAU;QACR,IAAG,CAAC4G,iBAAiB;YACnBS,WAAWE,OAAO;YAClB;QACF;QAEA,IAAGZ,cAAc;YACfU,WAAWG,MAAM,CAACb,cAAcD;QAClC,OAAO;YACLW,WAAWE,OAAO;QACpB;IACF,GAAG;QAACX;QAAiBF;QAAkBC;QAAcU;KAAW;IAEhErH,UAAU;QACR,OAAO;YACLqH,WAAWE,OAAO;QACpB;IACF,GAAG;QAACF;KAAW;IAEf,MAAMI,SAASxH,QAAQ,IAAMuG,eAAeiB,MAAM,IAAK,CAAA;YACrD,MAAMC,eAAexF,KAAKC,QAAQ,CAAC,gBAAgB,CAAC;YACpD,OAAO,CAAC,CAACuF,aAAaC,UAAU;QAClC,CAAA,GAAI;QAACnB,eAAeiB,MAAM;QAAEvF;KAAK;IAEjC,qBACE,KAACP,kBAAkBiG,QAAQ;QACzBC,OAAO;YACLxB,UAAUI;YACV/B,QAAQ8B;YACRtE;YACAuF;YACA9G;YACAC,eAAekG;YACfrC;YACAqD,eAAe,KAAQ;YACvBC,oBAAoBV,WAAWW,gBAAgB;QACjD;kBACA,cAAA,KAAC7H;YAAgBL,MAAMA;sBACpBwG;;;AAIT,EAAE;AAEF,eAAeF,WAAW;AAE1B,SAAQ6B,cAAc,QAAO,gBAAgB;AAC7C,cAAc,sBAAsB;AACpC,cAAc,qCAAqC;AACnD,cAAc,uBAAuB;AACrC,cAAc,4BAA4B;AAC1C,cAAc,oBAAoB;AAClC,SACElG,YAAY,EACZmG,aAAa,EACbC,gBAAgB,QACX,2BAA2B;AAClC,cAAc,iBAAiB;AAC/B,SAAQC,iBAAiB,QAAO,+BAA+B;AAC/D,cAAc,uBAAuB;AACrC,cAAc,kBAAkB;AAChC,cAAc,sBAAsB;AACpC,SACEC,iBAAiB,EACjBC,eAAe,EACfC,eAAe,EACfC,eAAe,EACfC,kBAAkB,EAClBC,iBAAiB,EAAEC,aAAa,EAChCC,mBAAmB,EACnBC,iBAAiB,EAAEC,cAAc,EACjCC,iBAAiB,EACjBC,kBAAkB,EAClBC,aAAa,EACbC,qBAAqB,EACrBC,cAAc,EACdC,mBAAmB,QACd,2BAA2B;AAClC,SAAQC,qBAAqB,QAAO,mCAAmC;AAKvE,SACEC,sBAAsB,EACtBC,sBAAsB,QACjB,8BAA8B;AAWrC,cAAc,qCAAqC;AACnD,cAAc,mDAAmD;AACjE,cAAc,uDAAuD;AACrE,cAAc,yCAAyC;AACvD,cAAc,6BAA6B;AAC3C,cAAc,mBAAmB"}

package/lib/stores/appStore.d.ts

@@ -20,3 +20,4 @@ export declare const app: {
     name: string;
 };
 export {};
+//# sourceMappingURL=appStore.d.ts.map

package/lib/stores/appStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"appStore.d.ts","sourceRoot":"","sources":["../../src/stores/appStore.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,aAAa;;;CAGhB,CAAC;AAEX,UAAU,QAAQ;IAChB,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,KAAK,CAAC;QACd,MAAM,CAAC,EAAE,OAAO,CAAC;KAClB,CAAC;CACH;AAED,eAAO,MAAM,aAAa,EAAE,QAAa,CAAC;AAE1C,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,EAAE,gBAAqB,KAAG,QAMvF,CAAC;AAEF,eAAO,MAAM,GAAG;mBARe,MAAM,QAAQ,OAAO,CAAC,QAAQ,CAAC,uBAA0B,QAAQ;;;CAY/F,CAAC"}

package/lib/stores/appStore.js

@@ -1,2 +1,23 @@
-const o={API_NETWORK_ERROR:"APP_API_NETWORK_ERROR",API_NETWORK_SUCCESS:"APP_API_NETWORK_SUCCESS"},t={},p=(a,r,e=t)=>e,S={action:p,initialState:t,name:"app"};export{o as APP_CONSTANTS,S as app,p as appStore,t as defaultValues};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL3N0b3Jlcy9hcHBTdG9yZS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTktUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cblxuZXhwb3J0IGNvbnN0IEFQUF9DT05TVEFOVFMgPSB7XG4gIEFQSV9ORVRXT1JLX0VSUk9SOiAnQVBQX0FQSV9ORVRXT1JLX0VSUk9SJyxcbiAgQVBJX05FVFdPUktfU1VDQ0VTUzogJ0FQUF9BUElfTkVUV09SS19TVUNDRVNTJ1xufSBhcyBjb25zdDtcblxuaW50ZXJmYWNlIEFwcFN0YXRlIHtcbiAgbmV0d29yaz86IHtcbiAgICBlcnJvcj86IEVycm9yO1xuICAgIHN0YXR1cz86IGJvb2xlYW47XG4gIH07XG59XG5cbmV4cG9ydCBjb25zdCBkZWZhdWx0VmFsdWVzOiBBcHBTdGF0ZSA9IHt9O1xuXG5leHBvcnQgY29uc3QgYXBwU3RvcmUgPSAodHlwZTogc3RyaW5nLCBkYXRhOiBQYXJ0aWFsPEFwcFN0YXRlPiwgc3RhdGUgPSBkZWZhdWx0VmFsdWVzKTogQXBwU3RhdGUgPT4ge1xuICBzd2l0Y2godHlwZSkge1xuICAgIGRlZmF1bHQ6IHtcbiAgICAgIHJldHVybiBzdGF0ZTtcbiAgICB9XG4gIH1cbn07XG5cbmV4cG9ydCBjb25zdCBhcHAgPSB7XG4gIGFjdGlvbjogYXBwU3RvcmUsXG4gIGluaXRpYWxTdGF0ZTogZGVmYXVsdFZhbHVlcyxcbiAgbmFtZTogJ2FwcCdcbn07XG4iXSwKICAibWFwcGluZ3MiOiAiQUFLTyxNQUFNQSxFQUFnQixDQUMzQixrQkFBbUIsd0JBQ25CLG9CQUFxQix5QkFDdkIsRUFTYUMsRUFBMEIsQ0FBQyxFQUUzQkMsRUFBVyxDQUFDQyxFQUFjQyxFQUF5QkMsRUFBUUosSUFHM0RJLEVBS0FDLEVBQU0sQ0FDakIsT0FBUUosRUFDUixhQUFjRCxFQUNkLEtBQU0sS0FDUiIsCiAgIm5hbWVzIjogWyJBUFBfQ09OU1RBTlRTIiwgImRlZmF1bHRWYWx1ZXMiLCAiYXBwU3RvcmUiLCAidHlwZSIsICJkYXRhIiwgInN0YXRlIiwgImFwcCJdCn0K
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export const APP_CONSTANTS = {
+    API_NETWORK_ERROR: 'APP_API_NETWORK_ERROR',
+    API_NETWORK_SUCCESS: 'APP_API_NETWORK_SUCCESS'
+};
+export const defaultValues = {};
+export const appStore = (type, data, state = defaultValues)=>{
+    switch(type){
+        default:
+            {
+                return state;
+            }
+    }
+};
+export const app = {
+    action: appStore,
+    initialState: defaultValues,
+    name: 'app'
+};
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L21ldHJvcG9saXNqcy9zcmMvc3RvcmVzL2FwcFN0b3JlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQ29weXJpZ2h0IChjKSAyMDE5LVByZXNlbnQsIE5pdHJvZ2VuIExhYnMsIEluYy5cbiAqIENvcHlyaWdodHMgbGljZW5zZWQgdW5kZXIgdGhlIE1JVCBMaWNlbnNlLiBTZWUgdGhlIGFjY29tcGFueWluZyBMSUNFTlNFIGZpbGUgZm9yIHRlcm1zLlxuICovXG5cbmV4cG9ydCBjb25zdCBBUFBfQ09OU1RBTlRTID0ge1xuICBBUElfTkVUV09SS19FUlJPUjogJ0FQUF9BUElfTkVUV09SS19FUlJPUicsXG4gIEFQSV9ORVRXT1JLX1NVQ0NFU1M6ICdBUFBfQVBJX05FVFdPUktfU1VDQ0VTUydcbn0gYXMgY29uc3Q7XG5cbmludGVyZmFjZSBBcHBTdGF0ZSB7XG4gIG5ldHdvcms/OiB7XG4gICAgZXJyb3I/OiBFcnJvcjtcbiAgICBzdGF0dXM/OiBib29sZWFuO1xuICB9O1xufVxuXG5leHBvcnQgY29uc3QgZGVmYXVsdFZhbHVlczogQXBwU3RhdGUgPSB7fTtcblxuZXhwb3J0IGNvbnN0IGFwcFN0b3JlID0gKHR5cGU6IHN0cmluZywgZGF0YTogUGFydGlhbDxBcHBTdGF0ZT4sIHN0YXRlID0gZGVmYXVsdFZhbHVlcyk6IEFwcFN0YXRlID0+IHtcbiAgc3dpdGNoKHR5cGUpIHtcbiAgICBkZWZhdWx0OiB7XG4gICAgICByZXR1cm4gc3RhdGU7XG4gICAgfVxuICB9XG59O1xuXG5leHBvcnQgY29uc3QgYXBwID0ge1xuICBhY3Rpb246IGFwcFN0b3JlLFxuICBpbml0aWFsU3RhdGU6IGRlZmF1bHRWYWx1ZXMsXG4gIG5hbWU6ICdhcHAnXG59O1xuIl0sIm5hbWVzIjpbIkFQUF9DT05TVEFOVFMiLCJBUElfTkVUV09SS19FUlJPUiIsIkFQSV9ORVRXT1JLX1NVQ0NFU1MiLCJkZWZhdWx0VmFsdWVzIiwiYXBwU3RvcmUiLCJ0eXBlIiwiZGF0YSIsInN0YXRlIiwiYXBwIiwiYWN0aW9uIiwiaW5pdGlhbFN0YXRlIiwibmFtZSJdLCJtYXBwaW5ncyI6IkFBQUE7OztDQUdDLEdBRUQsT0FBTyxNQUFNQSxnQkFBZ0I7SUFDM0JDLG1CQUFtQjtJQUNuQkMscUJBQXFCO0FBQ3ZCLEVBQVc7QUFTWCxPQUFPLE1BQU1DLGdCQUEwQixDQUFDLEVBQUU7QUFFMUMsT0FBTyxNQUFNQyxXQUFXLENBQUNDLE1BQWNDLE1BQXlCQyxRQUFRSixhQUFhO0lBQ25GLE9BQU9FO1FBQ0w7WUFBUztnQkFDUCxPQUFPRTtZQUNUO0lBQ0Y7QUFDRixFQUFFO0FBRUYsT0FBTyxNQUFNQyxNQUFNO0lBQ2pCQyxRQUFRTDtJQUNSTSxjQUFjUDtJQUNkUSxNQUFNO0FBQ1IsRUFBRSJ9

package/lib/stores/contentStore.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+import type { ContentType } from '../adapters/contentAdapter/contentAdapter.js';
+export declare const CONTENT_CONSTANTS: {
+    readonly ADD_ITEM_ERROR: "CONTENT_ADD_ITEM_ERROR";
+    readonly ADD_ITEM_SUCCESS: "CONTENT_ADD_ITEM_SUCCESS";
+    readonly GET_ITEM_ERROR: "CONTENT_GET_ITEM_ERROR";
+    readonly GET_ITEM_SUCCESS: "CONTENT_GET_ITEM_SUCCESS";
+    readonly GET_LIST_ERROR: "CONTENT_GET_LIST_ERROR";
+    readonly GET_LIST_SUCCESS: "CONTENT_GET_LIST_SUCCESS";
+    readonly REMOVE_ITEM_ERROR: "CONTENT_REMOVE_ITEM_ERROR";
+    readonly REMOVE_ITEM_SUCCESS: "CONTENT_REMOVE_ITEM_SUCCESS";
+    readonly UPDATE_ITEM_ERROR: "CONTENT_UPDATE_ITEM_ERROR";
+    readonly UPDATE_ITEM_SUCCESS: "CONTENT_UPDATE_ITEM_SUCCESS";
+};
+export type ContentConstantsType = typeof CONTENT_CONSTANTS[keyof typeof CONTENT_CONSTANTS];
+interface ContentState {
+    error?: Error;
+    content: Record<string, Partial<ContentType>>;
+    lists: Record<string, unknown>;
+}
+interface ContentData {
+    readonly content?: ContentType;
+    readonly error?: Error;
+    readonly list?: ContentType[];
+}
+export declare const contentStore: (type: string, data: ContentData, state?: ContentState) => ContentState;
+export declare const contents: {
+    action: (type: string, data: ContentData, state?: ContentState) => ContentState;
+    initialState: ContentState;
+    name: string;
+};
+export {};
+//# sourceMappingURL=contentStore.d.ts.map

package/lib/stores/contentStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contentStore.d.ts","sourceRoot":"","sources":["../../src/stores/contentStore.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8CAA8C,CAAC;AAEhF,eAAO,MAAM,iBAAiB;;;;;;;;;;;CAWpB,CAAC;AAEX,MAAM,MAAM,oBAAoB,GAAG,OAAO,iBAAiB,CAAC,MAAM,OAAO,iBAAiB,CAAC,CAAC;AAE5F,UAAU,YAAY;IACpB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC;IAC9C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChC;AAOD,UAAU,WAAW;IACnB,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC;IAC/B,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,WAAW,EAAE,CAAC;CAC/B;AAED,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,EAAE,MAAM,WAAW,EAAE,oBAAqB,KAAG,YAkErF,CAAC;AAEF,eAAO,MAAM,QAAQ;mBApEc,MAAM,QAAQ,WAAW,2BAA0B,YAAY;;;CAwEjG,CAAC"}