@nlabs/metropolisjs 0.1.1 → 0.2.0

package/lib/utils/useMetropolis.js

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

package/lib/utils/useTranslations.js

@@ -0,0 +1,105 @@
+/**
+ * Copyright (c) 2025-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useMetropolis } from './useMetropolis.js';
+export const useTranslations = (options = {})=>{
+    const { locale = 'en', namespace, autoProcess = true, processInterval = 1000 } = options;
+    const { translationActions } = useMetropolis();
+    const processTimeoutRef = useRef(null);
+    const lastProcessRef = useRef(0);
+    const t = useCallback((key, fallback)=>{
+        if (!translationActions) {
+            return fallback || key;
+        }
+        const translation = translationActions.getTranslation(key, locale, namespace);
+        if (translation) {
+            return translation;
+        }
+        if (autoProcess && !translationActions.hasTranslation(key, locale, namespace)) {
+            translationActions.queueTranslationKey(key, locale, namespace);
+        }
+        return fallback || key;
+    }, [
+        translationActions,
+        locale,
+        namespace,
+        autoProcess
+    ]);
+    const hasTranslation = useCallback((key)=>{
+        if (!translationActions) {
+            return false;
+        }
+        return translationActions.hasTranslation(key, locale, namespace);
+    }, [
+        translationActions,
+        locale,
+        namespace
+    ]);
+    const queueTranslation = useCallback((key)=>{
+        if (!translationActions) return;
+        translationActions.queueTranslationKey(key, locale, namespace);
+    }, [
+        translationActions,
+        locale,
+        namespace
+    ]);
+    const processPending = useCallback(async ()=>{
+        if (!translationActions) return;
+        const now = Date.now();
+        if (now - lastProcessRef.current < processInterval) {
+            return;
+        }
+        lastProcessRef.current = now;
+        await translationActions.processPendingTranslations(locale, namespace);
+    }, [
+        translationActions,
+        locale,
+        namespace,
+        processInterval
+    ]);
+    useEffect(()=>{
+        if (!autoProcess || !translationActions) return;
+        const processQueued = ()=>{
+            processPending();
+        };
+        if (processTimeoutRef.current) {
+            clearTimeout(processTimeoutRef.current);
+        }
+        processTimeoutRef.current = setTimeout(processQueued, processInterval);
+        return ()=>{
+            if (processTimeoutRef.current) {
+                clearTimeout(processTimeoutRef.current);
+            }
+        };
+    }, [
+        autoProcess,
+        translationActions,
+        processPending,
+        processInterval
+    ]);
+    const isLoading = useMemo(()=>{
+        if (!translationActions) return false;
+        const state = translationActions.flux?.getState('translations');
+        return state?.isQueueing || false;
+    }, [
+        translationActions
+    ]);
+    const error = useMemo(()=>{
+        if (!translationActions) return null;
+        const state = translationActions.flux?.getState('translations');
+        return state?.error || null;
+    }, [
+        translationActions
+    ]);
+    return {
+        t,
+        hasTranslation,
+        queueTranslation,
+        processPending,
+        isLoading,
+        error
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/utils/useTranslations.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 */\nimport { useCallback, useEffect, useMemo, useRef } from 'react';\n\nimport { useMetropolis } from './useMetropolis.js';\n\nexport interface UseTranslationsOptions {\n  readonly locale?: string;\n  readonly namespace?: string;\n  readonly autoProcess?: boolean;\n  readonly processInterval?: number;\n}\n\nexport interface UseTranslationsReturn {\n  readonly t: (key: string, fallback?: string) => string;\n  readonly hasTranslation: (key: string) => boolean;\n  readonly queueTranslation: (key: string) => void;\n  readonly processPending: () => Promise<void>;\n  readonly isLoading: boolean;\n  readonly error: Error | null;\n}\n\nexport const useTranslations = (options: UseTranslationsOptions = {}): UseTranslationsReturn => {\n  const {\n    locale = 'en',\n    namespace,\n    autoProcess = true,\n    processInterval = 1000\n  } = options;\n\n  const {translationActions} = useMetropolis();\n  const processTimeoutRef = useRef<NodeJS.Timeout | null>(null);\n  const lastProcessRef = useRef<number>(0);\n\n  const t = useCallback((key: string, fallback?: string): string => {\n    if (!translationActions) {\n      return fallback || key;\n    }\n\n    const translation = translationActions.getTranslation(key, locale, namespace);\n\n    if (translation) {\n      return translation;\n    }\n\n    if (autoProcess && !translationActions.hasTranslation(key, locale, namespace)) {\n      translationActions.queueTranslationKey(key, locale, namespace);\n    }\n\n    return fallback || key;\n  }, [translationActions, locale, namespace, autoProcess]);\n\n  const hasTranslation = useCallback((key: string): boolean => {\n    if (!translationActions) {\n      return false;\n    }\n\n    return translationActions.hasTranslation(key, locale, namespace);\n  }, [translationActions, locale, namespace]);\n\n  const queueTranslation = useCallback((key: string): void => {\n    if (!translationActions) return;\n    translationActions.queueTranslationKey(key, locale, namespace);\n  }, [translationActions, locale, namespace]);\n\n  const processPending = useCallback(async (): Promise<void> => {\n    if (!translationActions) return;\n\n    const now = Date.now();\n    if (now - lastProcessRef.current < processInterval) {\n      return;\n    }\n\n    lastProcessRef.current = now;\n    await translationActions.processPendingTranslations(locale, namespace);\n  }, [translationActions, locale, namespace, processInterval]);\n\n  useEffect(() => {\n    if (!autoProcess || !translationActions) return;\n\n    const processQueued = () => {\n      processPending();\n    };\n\n    if (processTimeoutRef.current) {\n      clearTimeout(processTimeoutRef.current);\n    }\n\n    processTimeoutRef.current = setTimeout(processQueued, processInterval);\n\n    return () => {\n      if (processTimeoutRef.current) {\n        clearTimeout(processTimeoutRef.current);\n      }\n    };\n  }, [autoProcess, translationActions, processPending, processInterval]);\n\n  const isLoading = useMemo(() => {\n    if (!translationActions) return false;\n    const state = (translationActions as any).flux?.getState('translations');\n    return state?.isQueueing || false;\n  }, [translationActions]);\n\n  const error = useMemo(() => {\n    if (!translationActions) return null;\n    const state = (translationActions as any).flux?.getState('translations');\n    return state?.error || null;\n  }, [translationActions]);\n\n  return {\n    t,\n    hasTranslation,\n    queueTranslation,\n    processPending,\n    isLoading,\n    error\n  };\n};"],"names":["useCallback","useEffect","useMemo","useRef","useMetropolis","useTranslations","options","locale","namespace","autoProcess","processInterval","translationActions","processTimeoutRef","lastProcessRef","t","key","fallback","translation","getTranslation","hasTranslation","queueTranslationKey","queueTranslation","processPending","now","Date","current","processPendingTranslations","processQueued","clearTimeout","setTimeout","isLoading","state","flux","getState","isQueueing","error"],"mappings":"AAAA;;;CAGC,GACD,SAASA,WAAW,EAAEC,SAAS,EAAEC,OAAO,EAAEC,MAAM,QAAQ,QAAQ;AAEhE,SAASC,aAAa,QAAQ,qBAAqB;AAkBnD,OAAO,MAAMC,kBAAkB,CAACC,UAAkC,CAAC,CAAC;IAClE,MAAM,EACJC,SAAS,IAAI,EACbC,SAAS,EACTC,cAAc,IAAI,EAClBC,kBAAkB,IAAI,EACvB,GAAGJ;IAEJ,MAAM,EAACK,kBAAkB,EAAC,GAAGP;IAC7B,MAAMQ,oBAAoBT,OAA8B;IACxD,MAAMU,iBAAiBV,OAAe;IAEtC,MAAMW,IAAId,YAAY,CAACe,KAAaC;QAClC,IAAI,CAACL,oBAAoB;YACvB,OAAOK,YAAYD;QACrB;QAEA,MAAME,cAAcN,mBAAmBO,cAAc,CAACH,KAAKR,QAAQC;QAEnE,IAAIS,aAAa;YACf,OAAOA;QACT;QAEA,IAAIR,eAAe,CAACE,mBAAmBQ,cAAc,CAACJ,KAAKR,QAAQC,YAAY;YAC7EG,mBAAmBS,mBAAmB,CAACL,KAAKR,QAAQC;QACtD;QAEA,OAAOQ,YAAYD;IACrB,GAAG;QAACJ;QAAoBJ;QAAQC;QAAWC;KAAY;IAEvD,MAAMU,iBAAiBnB,YAAY,CAACe;QAClC,IAAI,CAACJ,oBAAoB;YACvB,OAAO;QACT;QAEA,OAAOA,mBAAmBQ,cAAc,CAACJ,KAAKR,QAAQC;IACxD,GAAG;QAACG;QAAoBJ;QAAQC;KAAU;IAE1C,MAAMa,mBAAmBrB,YAAY,CAACe;QACpC,IAAI,CAACJ,oBAAoB;QACzBA,mBAAmBS,mBAAmB,CAACL,KAAKR,QAAQC;IACtD,GAAG;QAACG;QAAoBJ;QAAQC;KAAU;IAE1C,MAAMc,iBAAiBtB,YAAY;QACjC,IAAI,CAACW,oBAAoB;QAEzB,MAAMY,MAAMC,KAAKD,GAAG;QACpB,IAAIA,MAAMV,eAAeY,OAAO,GAAGf,iBAAiB;YAClD;QACF;QAEAG,eAAeY,OAAO,GAAGF;QACzB,MAAMZ,mBAAmBe,0BAA0B,CAACnB,QAAQC;IAC9D,GAAG;QAACG;QAAoBJ;QAAQC;QAAWE;KAAgB;IAE3DT,UAAU;QACR,IAAI,CAACQ,eAAe,CAACE,oBAAoB;QAEzC,MAAMgB,gBAAgB;YACpBL;QACF;QAEA,IAAIV,kBAAkBa,OAAO,EAAE;YAC7BG,aAAahB,kBAAkBa,OAAO;QACxC;QAEAb,kBAAkBa,OAAO,GAAGI,WAAWF,eAAejB;QAEtD,OAAO;YACL,IAAIE,kBAAkBa,OAAO,EAAE;gBAC7BG,aAAahB,kBAAkBa,OAAO;YACxC;QACF;IACF,GAAG;QAAChB;QAAaE;QAAoBW;QAAgBZ;KAAgB;IAErE,MAAMoB,YAAY5B,QAAQ;QACxB,IAAI,CAACS,oBAAoB,OAAO;QAChC,MAAMoB,QAAQ,AAACpB,mBAA2BqB,IAAI,EAAEC,SAAS;QACzD,OAAOF,OAAOG,cAAc;IAC9B,GAAG;QAACvB;KAAmB;IAEvB,MAAMwB,QAAQjC,QAAQ;QACpB,IAAI,CAACS,oBAAoB,OAAO;QAChC,MAAMoB,QAAQ,AAACpB,mBAA2BqB,IAAI,EAAEC,SAAS;QACzD,OAAOF,OAAOI,SAAS;IACzB,GAAG;QAACxB;KAAmB;IAEvB,OAAO;QACLG;QACAK;QACAE;QACAC;QACAQ;QACAK;IACF;AACF,EAAE"}

package/lib/utils/validatorFactory.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */
+export interface BaseAdapterOptions {
+    strict?: boolean;
+    allowPartial?: boolean;
+    environment?: 'development' | 'production' | 'test';
+    customValidation?: (input: unknown) => unknown;
+}
+/**
+ * Creates a validator factory that merges custom adapters with default behavior.
+ * This eliminates code duplication across all action files.
+ *
+ * @param defaultValidator - The default validation function
+ * @param customAdapter - Optional custom adapter function
+ * @param options - Adapter options
+ * @returns A validator function that applies default + custom validation
+ *
+ * @example
+ * const validateUser = createValidatorFactory(
+ *   defaultUserValidator,
+ *   customUserAdapter,
+ *   userAdapterOptions
+ * );
+ */
+export declare const createValidatorFactory: <T extends BaseAdapterOptions>(defaultValidator: (input: unknown, options?: T) => any, customAdapter?: (input: unknown, options?: T) => any, options?: T) => (input: unknown, validatorOptions?: T) => any;
+/**
+ * Creates a validator manager that handles adapter updates and recreation.
+ * This centralizes the update logic that's duplicated across action files.
+ *
+ * @param defaultValidator - The default validation function
+ * @param initialOptions - Initial adapter options
+ * @returns An object with validator and update functions
+ *
+ * @example
+ * const { validator, updateAdapter, updateOptions } = createValidatorManager(
+ *   defaultUserValidator,
+ *   userAdapterOptions
+ * );
+ */
+export declare const createValidatorManager: <T extends BaseAdapterOptions>(defaultValidator: (input: unknown, options?: T) => any, initialOptions?: T) => {
+    getCustomAdapter: () => (input: unknown, options?: T) => any;
+    getOptions: () => T;
+    updateAdapter: (adapter: (input: unknown, options?: T) => any) => void;
+    updateOptions: (options: T) => void;
+    validator: (input: unknown, validatorOptions?: T) => any;
+};
+//# sourceMappingURL=validatorFactory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"validatorFactory.d.ts","sourceRoot":"","sources":["../../src/utils/validatorFactory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,WAAW,CAAC,EAAE,aAAa,GAAG,YAAY,GAAG,MAAM,CAAC;IACpD,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;CAChD;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,kBAAkB,EACjE,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,GAAG,EACtD,gBAAgB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,GAAG,EACpD,UAAU,CAAC,MACP,OAAO,OAAO,EAAE,mBAAmB,CAAC,QAczC,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,sBAAsB,GAAI,CAAC,SAAS,kBAAkB,EACjE,kBAAkB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,GAAG,EAEtD,iBAAgB,CAAW;oCAMC,OAAO,YAAY,CAAC,KAAK,GAAG;;6BAExB,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,GAAG,KAAG,IAAI;6BAI3C,CAAC,KAAG,IAAI;uBAMd,OAAO,qBAAqB,CAAC;CAuBxD,CAAC"}

package/lib/utils/validatorFactory.js

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ /**
+ * Creates a validator factory that merges custom adapters with default behavior.
+ * This eliminates code duplication across all action files.
+ *
+ * @param defaultValidator - The default validation function
+ * @param customAdapter - Optional custom adapter function
+ * @param options - Adapter options
+ * @returns A validator function that applies default + custom validation
+ *
+ * @example
+ * const validateUser = createValidatorFactory(
+ *   defaultUserValidator,
+ *   customUserAdapter,
+ *   userAdapterOptions
+ * );
+ */ export const createValidatorFactory = (defaultValidator, customAdapter, options)=>(input, validatorOptions)=>{
+        const mergedOptions = {
+            ...options,
+            ...validatorOptions
+        };
+        let validated = defaultValidator(input, mergedOptions);
+        if (customAdapter) {
+            validated = customAdapter(validated, mergedOptions);
+        }
+        if (mergedOptions?.customValidation) {
+            validated = mergedOptions.customValidation(validated);
+        }
+        return validated;
+    };
+/**
+ * Creates a validator manager that handles adapter updates and recreation.
+ * This centralizes the update logic that's duplicated across action files.
+ *
+ * @param defaultValidator - The default validation function
+ * @param initialOptions - Initial adapter options
+ * @returns An object with validator and update functions
+ *
+ * @example
+ * const { validator, updateAdapter, updateOptions } = createValidatorManager(
+ *   defaultUserValidator,
+ *   userAdapterOptions
+ * );
+ */ export const createValidatorManager = (defaultValidator, // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+initialOptions = {})=>{
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const defaultOptions = {};
+    let adapterOptions = {
+        ...defaultOptions,
+        ...initialOptions
+    };
+    let customAdapter;
+    const updateAdapter = (adapter)=>{
+        customAdapter = adapter;
+    };
+    const updateOptions = (options)=>{
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        adapterOptions = {
+            ...adapterOptions,
+            ...options
+        };
+    };
+    // Create validator function that always uses current customAdapter and adapterOptions
+    const validator = (input, validatorOptions)=>{
+        const mergedOptions = {
+            ...adapterOptions,
+            ...validatorOptions
+        };
+        let validated = defaultValidator(input, mergedOptions);
+        if (customAdapter) {
+            validated = customAdapter(validated, mergedOptions);
+        }
+        if (mergedOptions?.customValidation) {
+            validated = mergedOptions.customValidation(validated);
+        }
+        return validated;
+    };
+    return {
+        getCustomAdapter: ()=>customAdapter,
+        getOptions: ()=>{
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            const options = {
+                ...adapterOptions
+            };
+            return options;
+        },
+        updateAdapter,
+        updateOptions,
+        validator
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,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