@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/utils/useConversationTyping.js

@@ -0,0 +1,117 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useWebsocketActions } from './useMetropolis.js';
+const DEFAULT_DEBOUNCE_MS = 300;
+const DEFAULT_IDLE_MS = 60000;
+export const useConversationTyping = ({ debounceMs = DEFAULT_DEBOUNCE_MS, idleMs = DEFAULT_IDLE_MS } = {})=>{
+    const websocketActions = useWebsocketActions();
+    const typingTimeoutRef = useRef(null);
+    const typingDebounceRef = useRef(null);
+    const typingConversationIdRef = useRef('');
+    const typingOptionsRef = useRef({});
+    const typingStateRef = useRef(false);
+    const clearTypingTimer = useCallback(()=>{
+        if (typingTimeoutRef.current) {
+            clearTimeout(typingTimeoutRef.current);
+            typingTimeoutRef.current = null;
+        }
+    }, []);
+    const clearTypingDebounce = useCallback(()=>{
+        if (typingDebounceRef.current) {
+            clearTimeout(typingDebounceRef.current);
+            typingDebounceRef.current = null;
+        }
+    }, []);
+    const updateTypingState = useCallback((conversationId, isTyping, options = {})=>{
+        const previousConversationId = typingConversationIdRef.current;
+        const typingOptions = Object.keys(options).length ? options : typingOptionsRef.current;
+        typingOptionsRef.current = typingOptions;
+        if (previousConversationId && previousConversationId !== conversationId && typingStateRef.current) {
+            websocketActions.sendTyping(previousConversationId, false, typingOptions);
+            typingStateRef.current = false;
+        }
+        if (!conversationId) {
+            typingConversationIdRef.current = '';
+            typingStateRef.current = false;
+            return;
+        }
+        if (previousConversationId === conversationId && typingStateRef.current === isTyping) {
+            return;
+        }
+        websocketActions.sendTyping(conversationId, isTyping, typingOptions);
+        typingConversationIdRef.current = conversationId;
+        typingStateRef.current = isTyping;
+    }, [
+        websocketActions
+    ]);
+    const syncDraft = useCallback((conversationId, draft, options = {})=>{
+        typingOptionsRef.current = options;
+        clearTypingDebounce();
+        clearTypingTimer();
+        if (!conversationId) {
+            return;
+        }
+        if (draft.trim()) {
+            if (!typingStateRef.current || typingConversationIdRef.current !== conversationId) {
+                typingDebounceRef.current = setTimeout(()=>{
+                    updateTypingState(conversationId, true, options);
+                    typingDebounceRef.current = null;
+                }, debounceMs);
+            }
+            typingTimeoutRef.current = setTimeout(()=>{
+                updateTypingState(conversationId, false, options);
+            }, idleMs);
+            return;
+        }
+        updateTypingState(conversationId, false, options);
+    }, [
+        clearTypingDebounce,
+        clearTypingTimer,
+        debounceMs,
+        idleMs,
+        updateTypingState
+    ]);
+    const setConversation = useCallback((conversationId, options = {})=>{
+        clearTypingDebounce();
+        clearTypingTimer();
+        typingOptionsRef.current = options;
+        if (typingConversationIdRef.current && typingConversationIdRef.current !== conversationId && typingStateRef.current) {
+            websocketActions.sendTyping(typingConversationIdRef.current, false, typingOptionsRef.current);
+            typingStateRef.current = false;
+        }
+        typingConversationIdRef.current = conversationId;
+        if (!conversationId) {
+            typingStateRef.current = false;
+        }
+    }, [
+        clearTypingDebounce,
+        clearTypingTimer,
+        websocketActions
+    ]);
+    const stopTyping = useCallback((conversationId = typingConversationIdRef.current, options = {})=>{
+        clearTypingDebounce();
+        clearTypingTimer();
+        updateTypingState(conversationId, false, options);
+    }, [
+        clearTypingDebounce,
+        clearTypingTimer,
+        updateTypingState
+    ]);
+    useEffect(()=>{
+        return ()=>{
+            clearTypingDebounce();
+            clearTypingTimer();
+            updateTypingState(typingConversationIdRef.current, false, typingOptionsRef.current);
+        };
+    }, [
+        clearTypingDebounce,
+        clearTypingTimer,
+        updateTypingState
+    ]);
+    return {
+        setConversation,
+        stopTyping,
+        syncDraft
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/utils/useConversationTyping.ts"],"sourcesContent":["import {useCallback, useEffect, useRef} from 'react';\n\nimport {useWebsocketActions} from './useMetropolis.js';\n\ntype TypingUser = {\n  readonly imageUrl?: string;\n  readonly name?: string;\n  readonly personaId?: string;\n  readonly thumbUrl?: string;\n  readonly userId?: string;\n  readonly username?: string;\n};\n\nexport type ConversationTypingOptions = {\n  readonly name?: string;\n  readonly personaId?: string;\n  readonly userId?: string;\n  readonly username?: string;\n  readonly users?: TypingUser[];\n};\n\nexport type UseConversationTypingOptions = {\n  readonly debounceMs?: number;\n  readonly idleMs?: number;\n};\n\nconst DEFAULT_DEBOUNCE_MS = 300;\nconst DEFAULT_IDLE_MS = 60000;\n\nexport const useConversationTyping = ({\n  debounceMs = DEFAULT_DEBOUNCE_MS,\n  idleMs = DEFAULT_IDLE_MS\n}: UseConversationTypingOptions = {}) => {\n  const websocketActions = useWebsocketActions();\n  const typingTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const typingDebounceRef = useRef<ReturnType<typeof setTimeout> | null>(null);\n  const typingConversationIdRef = useRef('');\n  const typingOptionsRef = useRef<ConversationTypingOptions>({});\n  const typingStateRef = useRef(false);\n\n  const clearTypingTimer = useCallback(() => {\n    if(typingTimeoutRef.current) {\n      clearTimeout(typingTimeoutRef.current);\n      typingTimeoutRef.current = null;\n    }\n  }, []);\n\n  const clearTypingDebounce = useCallback(() => {\n    if(typingDebounceRef.current) {\n      clearTimeout(typingDebounceRef.current);\n      typingDebounceRef.current = null;\n    }\n  }, []);\n\n  const updateTypingState = useCallback((conversationId: string, isTyping: boolean, options: ConversationTypingOptions = {}) => {\n    const previousConversationId = typingConversationIdRef.current;\n    const typingOptions = Object.keys(options).length ? options : typingOptionsRef.current;\n    typingOptionsRef.current = typingOptions;\n\n    if(previousConversationId && previousConversationId !== conversationId && typingStateRef.current) {\n      websocketActions.sendTyping(previousConversationId, false, typingOptions);\n      typingStateRef.current = false;\n    }\n\n    if(!conversationId) {\n      typingConversationIdRef.current = '';\n      typingStateRef.current = false;\n      return;\n    }\n\n    if(previousConversationId === conversationId && typingStateRef.current === isTyping) {\n      return;\n    }\n\n    websocketActions.sendTyping(conversationId, isTyping, typingOptions);\n    typingConversationIdRef.current = conversationId;\n    typingStateRef.current = isTyping;\n  }, [websocketActions]);\n\n  const syncDraft = useCallback((conversationId: string, draft: string, options: ConversationTypingOptions = {}) => {\n    typingOptionsRef.current = options;\n    clearTypingDebounce();\n    clearTypingTimer();\n\n    if(!conversationId) {\n      return;\n    }\n\n    if(draft.trim()) {\n      if(!typingStateRef.current || typingConversationIdRef.current !== conversationId) {\n        typingDebounceRef.current = setTimeout(() => {\n          updateTypingState(conversationId, true, options);\n          typingDebounceRef.current = null;\n        }, debounceMs);\n      }\n\n      typingTimeoutRef.current = setTimeout(() => {\n        updateTypingState(conversationId, false, options);\n      }, idleMs);\n      return;\n    }\n\n    updateTypingState(conversationId, false, options);\n  }, [clearTypingDebounce, clearTypingTimer, debounceMs, idleMs, updateTypingState]);\n\n  const setConversation = useCallback((conversationId: string, options: ConversationTypingOptions = {}) => {\n    clearTypingDebounce();\n    clearTypingTimer();\n    typingOptionsRef.current = options;\n\n    if(typingConversationIdRef.current && typingConversationIdRef.current !== conversationId && typingStateRef.current) {\n      websocketActions.sendTyping(typingConversationIdRef.current, false, typingOptionsRef.current);\n      typingStateRef.current = false;\n    }\n\n    typingConversationIdRef.current = conversationId;\n\n    if(!conversationId) {\n      typingStateRef.current = false;\n    }\n  }, [clearTypingDebounce, clearTypingTimer, websocketActions]);\n\n  const stopTyping = useCallback((conversationId = typingConversationIdRef.current, options: ConversationTypingOptions = {}) => {\n    clearTypingDebounce();\n    clearTypingTimer();\n    updateTypingState(conversationId, false, options);\n  }, [clearTypingDebounce, clearTypingTimer, updateTypingState]);\n\n  useEffect(() => {\n    return () => {\n      clearTypingDebounce();\n      clearTypingTimer();\n      updateTypingState(typingConversationIdRef.current, false, typingOptionsRef.current);\n    };\n  }, [clearTypingDebounce, clearTypingTimer, updateTypingState]);\n\n  return {\n    setConversation,\n    stopTyping,\n    syncDraft\n  };\n};\n"],"names":["useCallback","useEffect","useRef","useWebsocketActions","DEFAULT_DEBOUNCE_MS","DEFAULT_IDLE_MS","useConversationTyping","debounceMs","idleMs","websocketActions","typingTimeoutRef","typingDebounceRef","typingConversationIdRef","typingOptionsRef","typingStateRef","clearTypingTimer","current","clearTimeout","clearTypingDebounce","updateTypingState","conversationId","isTyping","options","previousConversationId","typingOptions","Object","keys","length","sendTyping","syncDraft","draft","trim","setTimeout","setConversation","stopTyping"],"mappings":"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"}

package/lib/utils/useMetropolis.d.ts

@@ -1,12 +1,67 @@
-export declare const useMetropolis: () => {
-    eventActions: any;
-    imageActions: any;
-    locationActions: any;
-    messageActions: any;
-    postActions: any;
-    profileActions: any;
-    reactionActions: any;
-    tagActions: any;
-    userActions: any;
-    websocketActions: any;
-};
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { MetropolisEnvironmentConfiguration } from '../config/index.js';
+import type { ActionType } from '../utils/actionFactory.js';
+/**
+ * Main hook to access Metropolis actions.
+ *
+ * @param actionTypes - Optional array of action types to create. If not provided, creates all actions.
+ * @returns Object containing the requested actions
+ *
+ * @example
+ * ```tsx
+ * // Get all actions (default behavior)
+ * const {userActions, postActions} = useMetropolis();
+ *
+ * // Get only specific actions (more performant)
+ * const {userActions} = useMetropolis(['user']);
+ * const {userActions, postActions} = useMetropolis(['user', 'post']);
+ * ```
+ */
+export declare const useMetropolis: <T extends ActionType[] = ActionType[]>(actionTypes?: T) => Record<string, any>;
+/**
+ * Hook to access the Metropolis configuration from context.
+ *
+ * @returns The resolved environment-specific configuration
+ * @throws Error if used outside of Metropolis component
+ *
+ * @example
+ * ```tsx
+ * const config = useMetropolisConfig();
+ * const apiUrl = config.app?.api?.url;
+ * ```
+ */
+export declare const useMetropolisConfig: () => MetropolisEnvironmentConfiguration;
+/**
+ * Hook to access the Flux framework instance from context.
+ *
+ * @returns The Flux framework instance
+ * @throws Error if used outside of Metropolis component and no Flux available
+ *
+ * @example
+ * ```tsx
+ * const flux = useMetropolisFlux();
+ * const state = flux.getState('user.session');
+ * ```
+ */
+export declare const useMetropolisFlux: () => FluxFramework;
+/**
+ * Specialized hooks for individual action types.
+ * These hooks only create the specific action type, improving performance.
+ */
+export declare const useContentActions: () => any;
+export declare const useEventActions: () => any;
+export declare const useGroupActions: () => any;
+export declare const useImageActions: () => any;
+export declare const useLocationActions: () => any;
+export declare const useMessageActions: () => any;
+export declare const useSubscriptionActions: () => any;
+export declare const usePermissionActions: () => any;
+export declare const usePostActions: () => any;
+export declare const usePersonaActions: () => any;
+export declare const useReactionActions: () => any;
+export declare const useTagActions: () => any;
+export declare const useVideoActions: () => any;
+export declare const useTranslationActions: () => any;
+export declare const useUserActions: () => any;
+export declare const useWebsocketActions: () => any;
+//# sourceMappingURL=useMetropolis.d.ts.map

package/lib/utils/useMetropolis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMetropolis.d.ts","sourceRoot":"","sources":["../../src/utils/useMetropolis.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAC,kCAAkC,EAAC,MAAM,oBAAoB,CAAC;AAI3E,OAAO,KAAK,EAAgB,UAAU,EAAC,MAAM,2BAA2B,CAAC;AAmHzE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa,GAAI,CAAC,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE,EACjE,cAAc,CAAC,wBA0BhB,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,mBAAmB,QAAO,kCAWtC,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,QAAO,aAMpC,CAAC;AAEF;;;GAGG;AAEH,eAAO,MAAM,iBAAiB,WAG7B,CAAC;AAEF,eAAO,MAAM,eAAe,WAG3B,CAAC;AAEF,eAAO,MAAM,eAAe,WAG3B,CAAC;AAEF,eAAO,MAAM,eAAe,WAG3B,CAAC;AAEF,eAAO,MAAM,kBAAkB,WAG9B,CAAC;AAEF,eAAO,MAAM,iBAAiB,WAG7B,CAAC;AAEF,eAAO,MAAM,sBAAsB,WAGlC,CAAC;AAEF,eAAO,MAAM,oBAAoB,WAGhC,CAAC;AAEF,eAAO,MAAM,cAAc,WAG1B,CAAC;AAEF,eAAO,MAAM,iBAAiB,WAG7B,CAAC;AAEF,eAAO,MAAM,kBAAkB,WAG9B,CAAC;AAEF,eAAO,MAAM,aAAa,WAGzB,CAAC;AAEF,eAAO,MAAM,eAAe,WAG3B,CAAC;AAEF,eAAO,MAAM,qBAAqB,WAGjC,CAAC;AAEF,eAAO,MAAM,cAAc,WAG1B,CAAC;AAEF,eAAO,MAAM,mBAAmB,WAG/B,CAAC"}

package/lib/utils/useMetropolis.js

@@ -1,2 +1,311 @@
-import{useFlux as b}from"@nlabs/arkhamjs-utils-react";import{useContext as k,useMemo as w}from"react";import{createAllActions as C}from"../utils/actionFactory";import{MetropolisContext as P}from"./MetropolisProvider";const R=()=>{const p=b(),{adapters:c}=k(P),{Event:e,Image:t,Location:a,Message:n,Post:o,Profile:s,Reaction:r,Tag:i,User:d}=c||{};return w(()=>{const{event:A,image:u,location:f,message:m,post:g,profile:l,reaction:y,tag:v,user:x,websocket:M}=C(p,{event:e?{eventAdapter:e}:void 0,image:t?{imageAdapter:t}:void 0,location:a?{locationAdapter:a}:void 0,message:n?{messageAdapter:n}:void 0,post:o?{postAdapter:o}:void 0,profile:s?{profileAdapter:s}:void 0,reaction:r?{reactionAdapter:r}:void 0,tag:i?{tagAdapter:i}:void 0,user:d?{userAdapter:d}:void 0});return{eventActions:A,imageActions:u,locationActions:f,messageActions:m,postActions:g,profileActions:l,reactionActions:y,tagActions:v,userActions:x,websocketActions:M}},[p,e,t,a,n,o,s,r,i,d])};export{R as useMetropolis};
-//# sourceMappingURL=data:application/json;base64,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
+import { useFlux } from '@nlabs/arkhamjs-utils-react';
+import { useContext, useMemo } from 'react';
+import { createActions, createAllActions } from '../utils/actionFactory.js';
+import { MetropolisContext } from './MetropolisProvider.js';
+/**
+ * Builds action options from adapters in a type-safe way.
+ */ const buildActionOptions = (adapters)=>{
+    if (!adapters) {
+        return {};
+    }
+    const options = {};
+    if (adapters.Content) {
+        options.content = {
+            contentAdapter: adapters.Content
+        };
+    }
+    if (adapters.Event) {
+        options.event = {
+            eventAdapter: adapters.Event
+        };
+    }
+    if (adapters.Image) {
+        options.image = {
+            imageAdapter: adapters.Image
+        };
+    }
+    if (adapters.Location) {
+        options.location = {
+            locationAdapter: adapters.Location
+        };
+    }
+    if (adapters.Message) {
+        options.message = {
+            messageAdapter: adapters.Message
+        };
+    }
+    if (adapters.Permission) {
+        options.permission = {
+            permissionAdapter: adapters.Permission
+        };
+    }
+    if (adapters.Post) {
+        options.post = {
+            postAdapter: adapters.Post
+        };
+    }
+    if (adapters.Persona) {
+        options.persona = {
+            personaAdapter: adapters.Persona
+        };
+    }
+    if (adapters.Reaction) {
+        options.reaction = {
+            reactionAdapter: adapters.Reaction
+        };
+    }
+    if (adapters.Tag) {
+        options.tag = {
+            tagAdapter: adapters.Tag
+        };
+    }
+    if (adapters.Translation) {
+        options.translation = {
+            translationAdapter: adapters.Translation
+        };
+    }
+    if (adapters.User) {
+        options.user = {
+            userAdapter: adapters.User
+        };
+    }
+    if (adapters.Video) {
+        options.video = {
+            videoAdapter: adapters.Video
+        };
+    }
+    return options;
+};
+/**
+ * Maps action type keys to their action names for return object.
+ */ const mapActionsToReturnKeys = (actions)=>{
+    const mapped = {};
+    if (actions.content) {
+        mapped.contentActions = actions.content;
+    }
+    if (actions.event) {
+        mapped.eventActions = actions.event;
+    }
+    if (actions.group) {
+        mapped.groupActions = actions.group;
+    }
+    if (actions.image) {
+        mapped.imageActions = actions.image;
+    }
+    if (actions.location) {
+        mapped.locationActions = actions.location;
+    }
+    if (actions.message) {
+        mapped.messageActions = actions.message;
+    }
+    if (actions.permission) {
+        mapped.permissionActions = actions.permission;
+    }
+    if (actions.post) {
+        mapped.postActions = actions.post;
+    }
+    if (actions.persona) {
+        mapped.personaActions = actions.persona;
+    }
+    if (actions.reaction) {
+        mapped.reactionActions = actions.reaction;
+    }
+    if (actions.subscription) {
+        mapped.subscriptionActions = actions.subscription;
+    }
+    if (actions.tag) {
+        mapped.tagActions = actions.tag;
+    }
+    if (actions.translation) {
+        mapped.translationActions = actions.translation;
+    }
+    if (actions.user) {
+        mapped.userActions = actions.user;
+    }
+    if (actions.video) {
+        mapped.videoActions = actions.video;
+    }
+    if (actions.websocket) {
+        mapped.websocketActions = actions.websocket;
+    }
+    return mapped;
+};
+/**
+ * Main hook to access Metropolis actions.
+ *
+ * @param actionTypes - Optional array of action types to create. If not provided, creates all actions.
+ * @returns Object containing the requested actions
+ *
+ * @example
+ * ```tsx
+ * // Get all actions (default behavior)
+ * const {userActions, postActions} = useMetropolis();
+ *
+ * // Get only specific actions (more performant)
+ * const {userActions} = useMetropolis(['user']);
+ * const {userActions, postActions} = useMetropolis(['user', 'post']);
+ * ```
+ */ export const useMetropolis = (actionTypes)=>{
+    const context = useContext(MetropolisContext);
+    // Use flux from context if available, otherwise fall back to useFlux() for backward compatibility
+    const contextFlux = context?.flux;
+    const hookFlux = useFlux();
+    const flux = contextFlux || hookFlux;
+    const { adapters } = context;
+    const actionOptions = useMemo(()=>buildActionOptions(adapters), [
+        adapters
+    ]);
+    return useMemo(()=>{
+        let actions;
+        if (actionTypes && actionTypes.length > 0) {
+            // Create only requested actions
+            actions = createActions(actionTypes, flux, actionOptions);
+        } else {
+            // Create all actions (default behavior for backward compatibility)
+            const allActions = createAllActions(flux, actionOptions);
+            actions = allActions;
+        }
+        // Map to return keys (contentActions, userActions, etc.)
+        return mapActionsToReturnKeys(actions);
+    }, [
+        flux,
+        actionOptions,
+        actionTypes?.join(',')
+    ]);
+};
+/**
+ * Hook to access the Metropolis configuration from context.
+ *
+ * @returns The resolved environment-specific configuration
+ * @throws Error if used outside of Metropolis component
+ *
+ * @example
+ * ```tsx
+ * const config = useMetropolisConfig();
+ * const apiUrl = config.app?.api?.url;
+ * ```
+ */ export const useMetropolisConfig = ()=>{
+    const context = useContext(MetropolisContext);
+    if (!context?.config) {
+        throw new Error('useMetropolisConfig must be used within a Metropolis component. ' + 'Make sure your component is wrapped with <Metropolis> provider.');
+    }
+    return context.config;
+};
+/**
+ * Hook to access the Flux framework instance from context.
+ *
+ * @returns The Flux framework instance
+ * @throws Error if used outside of Metropolis component and no Flux available
+ *
+ * @example
+ * ```tsx
+ * const flux = useMetropolisFlux();
+ * const state = flux.getState('user.session');
+ * ```
+ */ export const useMetropolisFlux = ()=>{
+    const context = useContext(MetropolisContext);
+    const hookFlux = useFlux();
+    // Use flux from context if available, otherwise fall back to useFlux() for backward compatibility
+    return context?.flux || hookFlux;
+};
+/**
+ * Specialized hooks for individual action types.
+ * These hooks only create the specific action type, improving performance.
+ */ export const useContentActions = ()=>{
+    const { contentActions } = useMetropolis([
+        'content'
+    ]);
+    return contentActions;
+};
+export const useEventActions = ()=>{
+    const { eventActions } = useMetropolis([
+        'event'
+    ]);
+    return eventActions;
+};
+export const useGroupActions = ()=>{
+    const { groupActions } = useMetropolis([
+        'group'
+    ]);
+    return groupActions;
+};
+export const useImageActions = ()=>{
+    const { imageActions } = useMetropolis([
+        'image'
+    ]);
+    return imageActions;
+};
+export const useLocationActions = ()=>{
+    const { locationActions } = useMetropolis([
+        'location'
+    ]);
+    return locationActions;
+};
+export const useMessageActions = ()=>{
+    const { messageActions } = useMetropolis([
+        'message'
+    ]);
+    return messageActions;
+};
+export const useSubscriptionActions = ()=>{
+    const { subscriptionActions } = useMetropolis([
+        'subscription'
+    ]);
+    return subscriptionActions;
+};
+export const usePermissionActions = ()=>{
+    const { permissionActions } = useMetropolis([
+        'permission'
+    ]);
+    return permissionActions;
+};
+export const usePostActions = ()=>{
+    const { postActions } = useMetropolis([
+        'post'
+    ]);
+    return postActions;
+};
+export const usePersonaActions = ()=>{
+    const { personaActions } = useMetropolis([
+        'persona'
+    ]);
+    return personaActions;
+};
+export const useReactionActions = ()=>{
+    const { reactionActions } = useMetropolis([
+        'reaction'
+    ]);
+    return reactionActions;
+};
+export const useTagActions = ()=>{
+    const { tagActions } = useMetropolis([
+        'tag'
+    ]);
+    return tagActions;
+};
+export const useVideoActions = ()=>{
+    const { videoActions } = useMetropolis([
+        'video'
+    ]);
+    return videoActions;
+};
+export const useTranslationActions = ()=>{
+    const { translationActions } = useMetropolis([
+        'translation'
+    ]);
+    return translationActions;
+};
+export const useUserActions = ()=>{
+    const { userActions } = useMetropolis([
+        'user'
+    ]);
+    return userActions;
+};
+export const useWebsocketActions = ()=>{
+    const { websocketActions } = useMetropolis([
+        'websocket'
+    ]);
+    return websocketActions;
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/utils/useMetropolis.ts"],"sourcesContent":["import {useFlux} from '@nlabs/arkhamjs-utils-react';\nimport {useContext, useMemo} from 'react';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {MetropolisEnvironmentConfiguration} from '../config/index.js';\nimport {createActions, createAllActions} from '../utils/actionFactory.js';\nimport type {MetropolisAdapters} from './MetropolisProvider.js';\nimport {MetropolisContext} from './MetropolisProvider.js';\nimport type {ActionOptions, ActionType} from '../utils/actionFactory.js';\n\n/**\n * Builds action options from adapters in a type-safe way.\n */\nconst buildActionOptions = (\n  adapters?: MetropolisAdapters\n): Partial<Record<ActionType, ActionOptions>> => {\n  if (!adapters) {\n    return {};\n  }\n\n  const options: Partial<Record<ActionType, ActionOptions>> = {};\n\n  if (adapters.Content) {\n    options.content = {contentAdapter: adapters.Content};\n  }\n  if (adapters.Event) {\n    options.event = {eventAdapter: adapters.Event};\n  }\n  if (adapters.Image) {\n    options.image = {imageAdapter: adapters.Image};\n  }\n  if (adapters.Location) {\n    options.location = {locationAdapter: adapters.Location};\n  }\n  if (adapters.Message) {\n    options.message = {messageAdapter: adapters.Message};\n  }\n  if (adapters.Permission) {\n    options.permission = {permissionAdapter: adapters.Permission};\n  }\n  if (adapters.Post) {\n    options.post = {postAdapter: adapters.Post};\n  }\n  if (adapters.Persona) {\n    options.persona = {personaAdapter: adapters.Persona};\n  }\n  if (adapters.Reaction) {\n    options.reaction = {reactionAdapter: adapters.Reaction};\n  }\n  if (adapters.Tag) {\n    options.tag = {tagAdapter: adapters.Tag};\n  }\n  if (adapters.Translation) {\n    options.translation = {translationAdapter: adapters.Translation};\n  }\n  if (adapters.User) {\n    options.user = {userAdapter: adapters.User};\n  }\n  if (adapters.Video) {\n    options.video = {videoAdapter: adapters.Video};\n  }\n\n  return options;\n};\n\n/**\n * Maps action type keys to their action names for return object.\n */\nconst mapActionsToReturnKeys = (actions: Record<string, any>): Record<string, any> => {\n  const mapped: Record<string, any> = {};\n\n  if (actions.content) {\n    mapped.contentActions = actions.content;\n  }\n  if (actions.event) {\n    mapped.eventActions = actions.event;\n  }\n  if (actions.group) {\n    mapped.groupActions = actions.group;\n  }\n  if (actions.image) {\n    mapped.imageActions = actions.image;\n  }\n  if (actions.location) {\n    mapped.locationActions = actions.location;\n  }\n  if (actions.message) {\n    mapped.messageActions = actions.message;\n  }\n  if (actions.permission) {\n    mapped.permissionActions = actions.permission;\n  }\n  if (actions.post) {\n    mapped.postActions = actions.post;\n  }\n  if (actions.persona) {\n    mapped.personaActions = actions.persona;\n  }\n  if (actions.reaction) {\n    mapped.reactionActions = actions.reaction;\n  }\n  if (actions.subscription) {\n    mapped.subscriptionActions = actions.subscription;\n  }\n  if (actions.tag) {\n    mapped.tagActions = actions.tag;\n  }\n  if (actions.translation) {\n    mapped.translationActions = actions.translation;\n  }\n  if (actions.user) {\n    mapped.userActions = actions.user;\n  }\n  if (actions.video) {\n    mapped.videoActions = actions.video;\n  }\n  if (actions.websocket) {\n    mapped.websocketActions = actions.websocket;\n  }\n\n  return mapped;\n};\n\n/**\n * Main hook to access Metropolis actions.\n *\n * @param actionTypes - Optional array of action types to create. If not provided, creates all actions.\n * @returns Object containing the requested actions\n *\n * @example\n * ```tsx\n * // Get all actions (default behavior)\n * const {userActions, postActions} = useMetropolis();\n *\n * // Get only specific actions (more performant)\n * const {userActions} = useMetropolis(['user']);\n * const {userActions, postActions} = useMetropolis(['user', 'post']);\n * ```\n */\nexport const useMetropolis = <T extends ActionType[] = ActionType[]>(\n  actionTypes?: T\n) => {\n  const context = useContext(MetropolisContext);\n  // Use flux from context if available, otherwise fall back to useFlux() for backward compatibility\n  const contextFlux = context?.flux;\n  const hookFlux = useFlux();\n  const flux = contextFlux || hookFlux;\n\n  const {adapters} = context;\n  const actionOptions = useMemo(() => buildActionOptions(adapters), [adapters]);\n\n  return useMemo(() => {\n    let actions: Record<string, any>;\n\n    if (actionTypes && actionTypes.length > 0) {\n      // Create only requested actions\n      actions = createActions(actionTypes, flux, actionOptions);\n    } else {\n      // Create all actions (default behavior for backward compatibility)\n      const allActions = createAllActions(flux, actionOptions);\n      actions = allActions;\n    }\n\n    // Map to return keys (contentActions, userActions, etc.)\n    return mapActionsToReturnKeys(actions);\n  }, [flux, actionOptions, actionTypes?.join(',')]);\n};\n\n/**\n * Hook to access the Metropolis configuration from context.\n *\n * @returns The resolved environment-specific configuration\n * @throws Error if used outside of Metropolis component\n *\n * @example\n * ```tsx\n * const config = useMetropolisConfig();\n * const apiUrl = config.app?.api?.url;\n * ```\n */\nexport const useMetropolisConfig = (): MetropolisEnvironmentConfiguration => {\n  const context = useContext(MetropolisContext);\n\n  if (!context?.config) {\n    throw new Error(\n      'useMetropolisConfig must be used within a Metropolis component. ' +\n      'Make sure your component is wrapped with <Metropolis> provider.'\n    );\n  }\n\n  return context.config;\n};\n\n/**\n * Hook to access the Flux framework instance from context.\n *\n * @returns The Flux framework instance\n * @throws Error if used outside of Metropolis component and no Flux available\n *\n * @example\n * ```tsx\n * const flux = useMetropolisFlux();\n * const state = flux.getState('user.session');\n * ```\n */\nexport const useMetropolisFlux = (): FluxFramework => {\n  const context = useContext(MetropolisContext);\n  const hookFlux = useFlux();\n\n  // Use flux from context if available, otherwise fall back to useFlux() for backward compatibility\n  return context?.flux || hookFlux;\n};\n\n/**\n * Specialized hooks for individual action types.\n * These hooks only create the specific action type, improving performance.\n */\n\nexport const useContentActions = () => {\n  const {contentActions} = useMetropolis(['content']);\n  return contentActions;\n};\n\nexport const useEventActions = () => {\n  const {eventActions} = useMetropolis(['event']);\n  return eventActions;\n};\n\nexport const useGroupActions = () => {\n  const {groupActions} = useMetropolis(['group']);\n  return groupActions;\n};\n\nexport const useImageActions = () => {\n  const {imageActions} = useMetropolis(['image']);\n  return imageActions;\n};\n\nexport const useLocationActions = () => {\n  const {locationActions} = useMetropolis(['location']);\n  return locationActions;\n};\n\nexport const useMessageActions = () => {\n  const {messageActions} = useMetropolis(['message']);\n  return messageActions;\n};\n\nexport const useSubscriptionActions = () => {\n  const {subscriptionActions} = useMetropolis(['subscription']);\n  return subscriptionActions;\n};\n\nexport const usePermissionActions = () => {\n  const {permissionActions} = useMetropolis(['permission']);\n  return permissionActions;\n};\n\nexport const usePostActions = () => {\n  const {postActions} = useMetropolis(['post']);\n  return postActions;\n};\n\nexport const usePersonaActions = () => {\n  const {personaActions} = useMetropolis(['persona']);\n  return personaActions;\n};\n\nexport const useReactionActions = () => {\n  const {reactionActions} = useMetropolis(['reaction']);\n  return reactionActions;\n};\n\nexport const useTagActions = () => {\n  const {tagActions} = useMetropolis(['tag']);\n  return tagActions;\n};\n\nexport const useVideoActions = () => {\n  const {videoActions} = useMetropolis(['video']);\n  return videoActions;\n};\n\nexport const useTranslationActions = () => {\n  const {translationActions} = useMetropolis(['translation']);\n  return translationActions;\n};\n\nexport const useUserActions = () => {\n  const {userActions} = useMetropolis(['user']);\n  return userActions;\n};\n\nexport const useWebsocketActions = () => {\n  const {websocketActions} = useMetropolis(['websocket']);\n  return websocketActions;\n};\n"],"names":["useFlux","useContext","useMemo","createActions","createAllActions","MetropolisContext","buildActionOptions","adapters","options","Content","content","contentAdapter","Event","event","eventAdapter","Image","image","imageAdapter","Location","location","locationAdapter","Message","message","messageAdapter","Permission","permission","permissionAdapter","Post","post","postAdapter","Persona","persona","personaAdapter","Reaction","reaction","reactionAdapter","Tag","tag","tagAdapter","Translation","translation","translationAdapter","User","user","userAdapter","Video","video","videoAdapter","mapActionsToReturnKeys","actions","mapped","contentActions","eventActions","group","groupActions","imageActions","locationActions","messageActions","permissionActions","postActions","personaActions","reactionActions","subscription","subscriptionActions","tagActions","translationActions","userActions","videoActions","websocket","websocketActions","useMetropolis","actionTypes","context","contextFlux","flux","hookFlux","actionOptions","length","allActions","join","useMetropolisConfig","config","Error","useMetropolisFlux","useContentActions","useEventActions","useGroupActions","useImageActions","useLocationActions","useMessageActions","useSubscriptionActions","usePermissionActions","usePostActions","usePersonaActions","useReactionActions","useTagActions","useVideoActions","useTranslationActions","useUserActions","useWebsocketActions"],"mappings":"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"}

package/lib/utils/useTranslations.d.ts

@@ -0,0 +1,16 @@
+export interface UseTranslationsOptions {
+    readonly locale?: string;
+    readonly namespace?: string;
+    readonly autoProcess?: boolean;
+    readonly processInterval?: number;
+}
+export interface UseTranslationsReturn {
+    readonly t: (key: string, fallback?: string) => string;
+    readonly hasTranslation: (key: string) => boolean;
+    readonly queueTranslation: (key: string) => void;
+    readonly processPending: () => Promise<void>;
+    readonly isLoading: boolean;
+    readonly error: Error | null;
+}
+export declare const useTranslations: (options?: UseTranslationsOptions) => UseTranslationsReturn;
+//# sourceMappingURL=useTranslations.d.ts.map

package/lib/utils/useTranslations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTranslations.d.ts","sourceRoot":"","sources":["../../src/utils/useTranslations.ts"],"names":[],"mappings":"AAQA,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,CAAC,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;CACnC;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IACvD,QAAQ,CAAC,cAAc,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC;IAClD,QAAQ,CAAC,gBAAgB,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IACjD,QAAQ,CAAC,cAAc,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CAC9B;AAED,eAAO,MAAM,eAAe,GAAI,UAAS,sBAA2B,KAAG,qBA+FtE,CAAC"}