@nlabs/metropolisjs 0.1.1 → 0.2.0

package/lib/index.js

@@ -0,0 +1,248 @@
+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":"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"}

package/lib/stores/appStore.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+export declare const APP_CONSTANTS: {
+    readonly API_NETWORK_ERROR: "APP_API_NETWORK_ERROR";
+    readonly API_NETWORK_SUCCESS: "APP_API_NETWORK_SUCCESS";
+};
+interface AppState {
+    network?: {
+        error?: Error;
+        status?: boolean;
+    };
+}
+export declare const defaultValues: AppState;
+export declare const appStore: (type: string, data: Partial<AppState>, state?: AppState) => AppState;
+export declare const app: {
+    action: (type: string, data: Partial<AppState>, state?: AppState) => AppState;
+    initialState: AppState;
+    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

@@ -0,0 +1,23 @@
+/**
+ * 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"}

package/lib/stores/contentStore.js

@@ -0,0 +1,139 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ export const CONTENT_CONSTANTS = {
+    ADD_ITEM_ERROR: 'CONTENT_ADD_ITEM_ERROR',
+    ADD_ITEM_SUCCESS: 'CONTENT_ADD_ITEM_SUCCESS',
+    GET_ITEM_ERROR: 'CONTENT_GET_ITEM_ERROR',
+    GET_ITEM_SUCCESS: 'CONTENT_GET_ITEM_SUCCESS',
+    GET_LIST_ERROR: 'CONTENT_GET_LIST_ERROR',
+    GET_LIST_SUCCESS: 'CONTENT_GET_LIST_SUCCESS',
+    REMOVE_ITEM_ERROR: 'CONTENT_REMOVE_ITEM_ERROR',
+    REMOVE_ITEM_SUCCESS: 'CONTENT_REMOVE_ITEM_SUCCESS',
+    UPDATE_ITEM_ERROR: 'CONTENT_UPDATE_ITEM_ERROR',
+    UPDATE_ITEM_SUCCESS: 'CONTENT_UPDATE_ITEM_SUCCESS'
+};
+const defaultValues = {
+    content: {},
+    lists: {}
+};
+export const contentStore = (type, data, state = defaultValues)=>{
+    switch(type){
+        case CONTENT_CONSTANTS.ADD_ITEM_SUCCESS:
+            {
+                const { content } = data;
+                if (content && content.contentId) {
+                    const contents = {
+                        ...state.content
+                    };
+                    contents[content.contentId] = {
+                        ...content,
+                        timestamp: Date.now()
+                    };
+                    return {
+                        ...state,
+                        content: contents
+                    };
+                }
+                return state;
+            }
+        case CONTENT_CONSTANTS.GET_ITEM_SUCCESS:
+            {
+                const { content } = data;
+                if (content && content.contentId) {
+                    const contents = {
+                        ...state.content
+                    };
+                    contents[content.contentId] = {
+                        ...content,
+                        timestamp: Date.now()
+                    };
+                    return {
+                        ...state,
+                        content: contents
+                    };
+                }
+                return state;
+            }
+        case CONTENT_CONSTANTS.GET_LIST_SUCCESS:
+            {
+                const { list } = data;
+                if (list) {
+                    const contents = {
+                        ...state.content
+                    };
+                    list.forEach((content)=>{
+                        if (content.contentId) {
+                            const cachedContent = contents[content.contentId] || {};
+                            contents[content.contentId] = {
+                                ...cachedContent,
+                                ...content
+                            };
+                        }
+                    });
+                    return {
+                        ...state,
+                        content: contents
+                    };
+                }
+                return state;
+            }
+        case CONTENT_CONSTANTS.REMOVE_ITEM_SUCCESS:
+            {
+                const { content } = data;
+                if (content && content.contentId) {
+                    const contents = {
+                        ...state.content
+                    };
+                    delete contents[content.contentId];
+                    return {
+                        ...state,
+                        content: contents
+                    };
+                }
+                return state;
+            }
+        case CONTENT_CONSTANTS.UPDATE_ITEM_SUCCESS:
+            {
+                const { content } = data;
+                if (content && content.contentId) {
+                    const contents = {
+                        ...state.content
+                    };
+                    contents[content.contentId] = {
+                        ...contents[content.contentId],
+                        ...content,
+                        timestamp: Date.now()
+                    };
+                    return {
+                        ...state,
+                        content: contents
+                    };
+                }
+                return state;
+            }
+        case CONTENT_CONSTANTS.ADD_ITEM_ERROR:
+        case CONTENT_CONSTANTS.GET_ITEM_ERROR:
+        case CONTENT_CONSTANTS.GET_LIST_ERROR:
+        case CONTENT_CONSTANTS.REMOVE_ITEM_ERROR:
+        case CONTENT_CONSTANTS.UPDATE_ITEM_ERROR:
+            {
+                const { error } = data;
+                return {
+                    ...state,
+                    error
+                };
+            }
+        default:
+            {
+                return state;
+            }
+    }
+};
+export const contents = {
+    action: contentStore,
+    initialState: defaultValues,
+    name: 'content'
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/stores/contentStore.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\n\nimport type { ContentType } from '../adapters/contentAdapter/contentAdapter.js';\n\nexport const CONTENT_CONSTANTS = {\n  ADD_ITEM_ERROR: 'CONTENT_ADD_ITEM_ERROR',\n  ADD_ITEM_SUCCESS: 'CONTENT_ADD_ITEM_SUCCESS',\n  GET_ITEM_ERROR: 'CONTENT_GET_ITEM_ERROR',\n  GET_ITEM_SUCCESS: 'CONTENT_GET_ITEM_SUCCESS',\n  GET_LIST_ERROR: 'CONTENT_GET_LIST_ERROR',\n  GET_LIST_SUCCESS: 'CONTENT_GET_LIST_SUCCESS',\n  REMOVE_ITEM_ERROR: 'CONTENT_REMOVE_ITEM_ERROR',\n  REMOVE_ITEM_SUCCESS: 'CONTENT_REMOVE_ITEM_SUCCESS',\n  UPDATE_ITEM_ERROR: 'CONTENT_UPDATE_ITEM_ERROR',\n  UPDATE_ITEM_SUCCESS: 'CONTENT_UPDATE_ITEM_SUCCESS'\n} as const;\n\nexport type ContentConstantsType = typeof CONTENT_CONSTANTS[keyof typeof CONTENT_CONSTANTS];\n\ninterface ContentState {\n  error?: Error;\n  content: Record<string, Partial<ContentType>>;\n  lists: Record<string, unknown>;\n}\n\nconst defaultValues: ContentState = {\n  content: {},\n  lists: {}\n};\n\ninterface ContentData {\n  readonly content?: ContentType;\n  readonly error?: Error;\n  readonly list?: ContentType[];\n}\n\nexport const contentStore = (type: string, data: ContentData, state = defaultValues): ContentState => {\n  switch(type) {\n    case CONTENT_CONSTANTS.ADD_ITEM_SUCCESS: {\n      const {content} = data;\n      if(content && content.contentId) {\n        const contents = {...state.content};\n        contents[content.contentId] = {...content, timestamp: Date.now()};\n        return {...state, content: contents};\n      }\n      return state;\n    }\n    case CONTENT_CONSTANTS.GET_ITEM_SUCCESS: {\n      const {content} = data;\n      if(content && content.contentId) {\n        const contents = {...state.content};\n        contents[content.contentId] = {...content, timestamp: Date.now()};\n        return {...state, content: contents};\n      }\n      return state;\n    }\n    case CONTENT_CONSTANTS.GET_LIST_SUCCESS: {\n      const {list} = data;\n      if(list) {\n        const contents = {...state.content};\n\n        list.forEach((content: ContentType) => {\n          if(content.contentId) {\n            const cachedContent: Partial<ContentType> = contents[content.contentId] || {};\n            contents[content.contentId] = {...cachedContent, ...content};\n          }\n        });\n\n        return {...state, content: contents};\n      }\n      return state;\n    }\n    case CONTENT_CONSTANTS.REMOVE_ITEM_SUCCESS: {\n      const {content} = data;\n      if(content && content.contentId) {\n        const contents = {...state.content};\n        delete contents[content.contentId];\n        return {...state, content: contents};\n      }\n      return state;\n    }\n    case CONTENT_CONSTANTS.UPDATE_ITEM_SUCCESS: {\n      const {content} = data;\n      if(content && content.contentId) {\n        const contents = {...state.content};\n        contents[content.contentId] = {...contents[content.contentId], ...content, timestamp: Date.now()};\n        return {...state, content: contents};\n      }\n      return state;\n    }\n    case CONTENT_CONSTANTS.ADD_ITEM_ERROR:\n    case CONTENT_CONSTANTS.GET_ITEM_ERROR:\n    case CONTENT_CONSTANTS.GET_LIST_ERROR:\n    case CONTENT_CONSTANTS.REMOVE_ITEM_ERROR:\n    case CONTENT_CONSTANTS.UPDATE_ITEM_ERROR: {\n      const {error} = data;\n      return {...state, error};\n    }\n    default: {\n      return state;\n    }\n  }\n};\n\nexport const contents = {\n  action: contentStore,\n  initialState: defaultValues,\n  name: 'content'\n};\n"],"names":["CONTENT_CONSTANTS","ADD_ITEM_ERROR","ADD_ITEM_SUCCESS","GET_ITEM_ERROR","GET_ITEM_SUCCESS","GET_LIST_ERROR","GET_LIST_SUCCESS","REMOVE_ITEM_ERROR","REMOVE_ITEM_SUCCESS","UPDATE_ITEM_ERROR","UPDATE_ITEM_SUCCESS","defaultValues","content","lists","contentStore","type","data","state","contentId","contents","timestamp","Date","now","list","forEach","cachedContent","error","action","initialState","name"],"mappings":"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"}

package/lib/stores/conversationStore.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+export declare const CONVERSATION_CONSTANTS: {
+    readonly ADD_ITEM_ERROR: "CONVERSATION_ADD_ITEM_ERROR";
+    readonly ADD_ITEM_SUCCESS: "CONVERSATION_ADD_ITEM_SUCCESS";
+    readonly GET_ITEM_ERROR: "CONVERSATION_GET_ITEM_ERROR";
+    readonly GET_ITEM_SUCCESS: "CONVERSATION_GET_ITEM_SUCCESS";
+    readonly GET_LIST_ERROR: "CONVERSATION_GET_LIST_ERROR";
+    readonly GET_LIST_SUCCESS: "CONVERSATION_GET_LIST_SUCCESS";
+    readonly REMOVE_ITEM_ERROR: "CONVERSATION_REMOVE_ITEM_ERROR";
+    readonly REMOVE_ITEM_SUCCESS: "CONVERSATION_REMOVE_ITEM_SUCCESS";
+    readonly UPDATE_ITEM_ERROR: "CONVERSATION_UPDATE_ITEM_ERROR";
+    readonly UPDATE_ITEM_SUCCESS: "CONVERSATION_UPDATE_ITEM_SUCCESS";
+};
+export type ConversationConstantsType = typeof CONVERSATION_CONSTANTS[keyof typeof CONVERSATION_CONSTANTS];
+interface ConversationState {
+    error?: Error;
+    item?: Record<string, any>;
+    list?: any[];
+    conversations?: Record<string, any>;
+}
+export declare const defaultValues: ConversationState;
+interface ConversationData {
+    readonly conversation?: Record<string, any>;
+    readonly conversations?: Record<string, any>;
+    readonly error?: Error;
+    readonly list?: any[];
+}
+export declare const conversationStore: (type: string, data: ConversationData, state?: ConversationState) => ConversationState;
+export declare const conversation: {
+    action: (type: string, data: ConversationData, state?: ConversationState) => ConversationState;
+    initialState: ConversationState;
+    name: string;
+};
+export {};
+//# sourceMappingURL=conversationStore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conversationStore.d.ts","sourceRoot":"","sources":["../../src/stores/conversationStore.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;CAWzB,CAAC;AAEX,MAAM,MAAM,yBAAyB,GAAG,OAAO,sBAAsB,CAAC,MAAM,OAAO,sBAAsB,CAAC,CAAC;AAE3G,UAAU,iBAAiB;IACzB,KAAK,CAAC,EAAE,KAAK,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC3B,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CACrC;AAED,eAAO,MAAM,aAAa,EAAE,iBAG3B,CAAC;AAEF,UAAU,gBAAgB;IACxB,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5C,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC7C,QAAQ,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;CACvB;AAED,eAAO,MAAM,iBAAiB,GAC5B,MAAM,MAAM,EACZ,MAAM,gBAAgB,EACtB,yBAAqB,KACpB,iBAoDF,CAAC;AAEF,eAAO,MAAM,YAAY;mBAzDjB,MAAM,QACN,gBAAgB,gCAErB,iBAAiB;;;CA0DnB,CAAC"}