@nlabs/metropolisjs 0.1.1 → 0.2.0

package/lib/utils/permissionUtils.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, Fragment as _Fragment } 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 { useCallback, useEffect, useState } from 'react';
+import { useFlux } from '@nlabs/arkhamjs-utils-react';
+import { hasPermission as checkPermission, isAdmin as checkIsAdmin, isGuest as checkIsGuest, isModerator as checkIsModerator, isSuperAdmin as checkIsSuperAdmin, isUser as checkIsUser } from '../adapters/permissionAdapter/permissionAdapter.js';
+export const usePermissions = ()=>{
+    const flux = useFlux();
+    const [userLevel, setUserLevel] = useState(0);
+    useEffect(()=>{
+        const updateUserLevel = ()=>{
+            const session = flux.getState('user.session', {});
+            const level = session.userAccess ?? 0;
+            setUserLevel(level);
+        };
+        updateUserLevel();
+        const unsubscribe = flux.on('USER_SIGN_IN_SUCCESS', updateUserLevel);
+        const unsubscribeUpdate = flux.on('USER_UPDATE_ITEM_SUCCESS', updateUserLevel);
+        const unsubscribeSession = flux.on('USER_GET_SESSION_SUCCESS', updateUserLevel);
+        const unsubscribeSignOut = flux.on('USER_SIGN_OUT_SUCCESS', ()=>setUserLevel(0));
+        return ()=>{
+            unsubscribe();
+            unsubscribeUpdate();
+            unsubscribeSession();
+            unsubscribeSignOut();
+        };
+    }, [
+        flux
+    ]);
+    const hasPermissionLevel = useCallback((requiredLevel)=>{
+        return checkPermission(userLevel, requiredLevel);
+    }, [
+        userLevel
+    ]);
+    const checkResourcePermission = useCallback((resource, requiredLevel)=>{
+        const permissions = flux.getState(`permission.userPermissions.${flux.getState('user.session.userId')}`, []);
+        const resourcePermission = permissions.find((p)=>p.resource === resource);
+        if (resourcePermission && resourcePermission.level !== undefined) {
+            return resourcePermission.level >= requiredLevel;
+        }
+        return checkPermission(userLevel, requiredLevel);
+    }, [
+        flux,
+        userLevel
+    ]);
+    return {
+        userLevel,
+        hasPermission: hasPermissionLevel,
+        isGuest: checkIsGuest(userLevel),
+        isUser: checkIsUser(userLevel),
+        isModerator: checkIsModerator(userLevel),
+        isAdmin: checkIsAdmin(userLevel),
+        isSuperAdmin: checkIsSuperAdmin(userLevel),
+        checkResource: checkResourcePermission
+    };
+};
+export const PermissionGuard = ({ requiredLevel, resource, fallback = null, children })=>{
+    const { hasPermission, checkResource } = usePermissions();
+    const hasAccess = resource ? checkResource(resource, requiredLevel) : hasPermission(requiredLevel);
+    if (!hasAccess) {
+        return /*#__PURE__*/ _jsx(_Fragment, {
+            children: fallback
+        });
+    }
+    return /*#__PURE__*/ _jsx(_Fragment, {
+        children: children
+    });
+};
+export { PermissionLevel } from '../adapters/permissionAdapter/permissionAdapter.js';
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/utils/permissionUtils.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 {useCallback, useEffect, useState} from 'react';\nimport {useFlux} from '@nlabs/arkhamjs-utils-react';\n\nimport {\n  hasPermission as checkPermission,\n  isAdmin as checkIsAdmin,\n  isGuest as checkIsGuest,\n  isModerator as checkIsModerator,\n  isSuperAdmin as checkIsSuperAdmin,\n  isUser as checkIsUser,\n  PermissionLevel\n} from '../adapters/permissionAdapter/permissionAdapter.js';\nimport type {Permission} from '../adapters/permissionAdapter/permissionAdapter.js';\nimport type {User} from '../adapters/userAdapter/userAdapter.js';\n\nexport interface PermissionGuardProps {\n  requiredLevel: PermissionLevel;\n  resource?: string;\n  fallback?: React.ReactNode;\n  children: React.ReactNode;\n}\n\nexport interface UsePermissionsReturn {\n  userLevel: number;\n  hasPermission: (requiredLevel: PermissionLevel) => boolean;\n  isGuest: boolean;\n  isUser: boolean;\n  isModerator: boolean;\n  isAdmin: boolean;\n  isSuperAdmin: boolean;\n  checkResource: (resource: string, requiredLevel: PermissionLevel) => boolean;\n}\n\nexport const usePermissions = (): UsePermissionsReturn => {\n  const flux = useFlux();\n  const [userLevel, setUserLevel] = useState<number>(0);\n\n  useEffect(() => {\n    const updateUserLevel = () => {\n      const session: Partial<User> = flux.getState('user.session', {});\n      const level = session.userAccess ?? 0;\n      setUserLevel(level);\n    };\n\n    updateUserLevel();\n\n    const unsubscribe = flux.on('USER_SIGN_IN_SUCCESS', updateUserLevel);\n    const unsubscribeUpdate = flux.on('USER_UPDATE_ITEM_SUCCESS', updateUserLevel);\n    const unsubscribeSession = flux.on('USER_GET_SESSION_SUCCESS', updateUserLevel);\n    const unsubscribeSignOut = flux.on('USER_SIGN_OUT_SUCCESS', () => setUserLevel(0));\n\n    return () => {\n      unsubscribe();\n      unsubscribeUpdate();\n      unsubscribeSession();\n      unsubscribeSignOut();\n    };\n  }, [flux]);\n\n  const hasPermissionLevel = useCallback(\n    (requiredLevel: PermissionLevel) => {\n      return checkPermission(userLevel, requiredLevel);\n    },\n    [userLevel]\n  );\n\n  const checkResourcePermission = useCallback(\n    (resource: string, requiredLevel: PermissionLevel): boolean => {\n      const permissions: Permission[] = flux.getState(`permission.userPermissions.${flux.getState('user.session.userId')}`, []);\n      \n      const resourcePermission = permissions.find((p) => p.resource === resource);\n      if (resourcePermission && resourcePermission.level !== undefined) {\n        return resourcePermission.level >= requiredLevel;\n      }\n\n      return checkPermission(userLevel, requiredLevel);\n    },\n    [flux, userLevel]\n  );\n\n  return {\n    userLevel,\n    hasPermission: hasPermissionLevel,\n    isGuest: checkIsGuest(userLevel),\n    isUser: checkIsUser(userLevel),\n    isModerator: checkIsModerator(userLevel),\n    isAdmin: checkIsAdmin(userLevel),\n    isSuperAdmin: checkIsSuperAdmin(userLevel),\n    checkResource: checkResourcePermission\n  };\n};\n\nexport const PermissionGuard: React.FC<PermissionGuardProps> = ({\n  requiredLevel,\n  resource,\n  fallback = null,\n  children\n}) => {\n  const {hasPermission, checkResource} = usePermissions();\n\n  const hasAccess = resource \n    ? checkResource(resource, requiredLevel) \n    : hasPermission(requiredLevel);\n\n  if (!hasAccess) {\n    return <>{fallback}</>;\n  }\n\n  return <>{children}</>;\n};\n\nexport {PermissionLevel} from '../adapters/permissionAdapter/permissionAdapter.js';\nexport type {Permission} from '../adapters/permissionAdapter/permissionAdapter.js';\n"],"names":["useCallback","useEffect","useState","useFlux","hasPermission","checkPermission","isAdmin","checkIsAdmin","isGuest","checkIsGuest","isModerator","checkIsModerator","isSuperAdmin","checkIsSuperAdmin","isUser","checkIsUser","usePermissions","flux","userLevel","setUserLevel","updateUserLevel","session","getState","level","userAccess","unsubscribe","on","unsubscribeUpdate","unsubscribeSession","unsubscribeSignOut","hasPermissionLevel","requiredLevel","checkResourcePermission","resource","permissions","resourcePermission","find","p","undefined","checkResource","PermissionGuard","fallback","children","hasAccess","PermissionLevel"],"mappings":";AAAA;;;CAGC,GACD,SAAQA,WAAW,EAAEC,SAAS,EAAEC,QAAQ,QAAO,QAAQ;AACvD,SAAQC,OAAO,QAAO,8BAA8B;AAEpD,SACEC,iBAAiBC,eAAe,EAChCC,WAAWC,YAAY,EACvBC,WAAWC,YAAY,EACvBC,eAAeC,gBAAgB,EAC/BC,gBAAgBC,iBAAiB,EACjCC,UAAUC,WAAW,QAEhB,qDAAqD;AAsB5D,OAAO,MAAMC,iBAAiB;IAC5B,MAAMC,OAAOd;IACb,MAAM,CAACe,WAAWC,aAAa,GAAGjB,SAAiB;IAEnDD,UAAU;QACR,MAAMmB,kBAAkB;YACtB,MAAMC,UAAyBJ,KAAKK,QAAQ,CAAC,gBAAgB,CAAC;YAC9D,MAAMC,QAAQF,QAAQG,UAAU,IAAI;YACpCL,aAAaI;QACf;QAEAH;QAEA,MAAMK,cAAcR,KAAKS,EAAE,CAAC,wBAAwBN;QACpD,MAAMO,oBAAoBV,KAAKS,EAAE,CAAC,4BAA4BN;QAC9D,MAAMQ,qBAAqBX,KAAKS,EAAE,CAAC,4BAA4BN;QAC/D,MAAMS,qBAAqBZ,KAAKS,EAAE,CAAC,yBAAyB,IAAMP,aAAa;QAE/E,OAAO;YACLM;YACAE;YACAC;YACAC;QACF;IACF,GAAG;QAACZ;KAAK;IAET,MAAMa,qBAAqB9B,YACzB,CAAC+B;QACC,OAAO1B,gBAAgBa,WAAWa;IACpC,GACA;QAACb;KAAU;IAGb,MAAMc,0BAA0BhC,YAC9B,CAACiC,UAAkBF;QACjB,MAAMG,cAA4BjB,KAAKK,QAAQ,CAAC,CAAC,2BAA2B,EAAEL,KAAKK,QAAQ,CAAC,wBAAwB,EAAE,EAAE;QAExH,MAAMa,qBAAqBD,YAAYE,IAAI,CAAC,CAACC,IAAMA,EAAEJ,QAAQ,KAAKA;QAClE,IAAIE,sBAAsBA,mBAAmBZ,KAAK,KAAKe,WAAW;YAChE,OAAOH,mBAAmBZ,KAAK,IAAIQ;QACrC;QAEA,OAAO1B,gBAAgBa,WAAWa;IACpC,GACA;QAACd;QAAMC;KAAU;IAGnB,OAAO;QACLA;QACAd,eAAe0B;QACftB,SAASC,aAAaS;QACtBJ,QAAQC,YAAYG;QACpBR,aAAaC,iBAAiBO;QAC9BZ,SAASC,aAAaW;QACtBN,cAAcC,kBAAkBK;QAChCqB,eAAeP;IACjB;AACF,EAAE;AAEF,OAAO,MAAMQ,kBAAkD,CAAC,EAC9DT,aAAa,EACbE,QAAQ,EACRQ,WAAW,IAAI,EACfC,QAAQ,EACT;IACC,MAAM,EAACtC,aAAa,EAAEmC,aAAa,EAAC,GAAGvB;IAEvC,MAAM2B,YAAYV,WACdM,cAAcN,UAAUF,iBACxB3B,cAAc2B;IAElB,IAAI,CAACY,WAAW;QACd,qBAAO;sBAAGF;;IACZ;IAEA,qBAAO;kBAAGC;;AACZ,EAAE;AAEF,SAAQE,eAAe,QAAO,qDAAqD"}

package/lib/utils/requestCache.d.ts

@@ -0,0 +1,8 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+export interface ActionRequestOptions {
+    readonly cacheTimeout?: number;
+}
+export declare const getCachedRequest: <T>(flux: FluxFramework, scope: string, payload?: Record<string, unknown>, options?: ActionRequestOptions) => T | undefined;
+export declare const setCachedRequest: <T>(flux: FluxFramework, scope: string, payload: Record<string, unknown>, data: T, options?: ActionRequestOptions) => Promise<T>;
+export declare const clearCachedRequest: (flux: FluxFramework, scope: string) => Promise<void>;
+//# sourceMappingURL=requestCache.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"requestCache.d.ts","sourceRoot":"","sources":["../../src/utils/requestCache.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAEnD,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAiCD,eAAO,MAAM,gBAAgB,GAAI,CAAC,EAChC,MAAM,aAAa,EACnB,OAAO,MAAM,EACb,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACrC,UAAS,oBAAyB,KACjC,CAAC,GAAG,SAsBN,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAU,CAAC,EACtC,MAAM,aAAa,EACnB,OAAO,MAAM,EACb,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EACrC,MAAM,CAAC,EACP,UAAS,oBAAyB,KACjC,OAAO,CAAC,CAAC,CAeX,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,MAAM,aAAa,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,IAAI,CAMzF,CAAC"}

package/lib/utils/requestCache.js

@@ -0,0 +1,53 @@
+const REQUEST_CACHE_PATH = 'app.requestCache';
+const normalizePayload = (value)=>{
+    if (Array.isArray(value)) {
+        return value.map(normalizePayload);
+    }
+    if (value && typeof value === 'object') {
+        return Object.keys(value).sort().reduce((result, key)=>{
+            result[key] = normalizePayload(value[key]);
+            return result;
+        }, {});
+    }
+    return value;
+};
+const getPayloadKey = (payload = {})=>JSON.stringify(normalizePayload(payload));
+const getCachePath = (scope)=>`${REQUEST_CACHE_PATH}.${scope}`;
+export const getCachedRequest = (flux, scope, payload = {}, options = {})=>{
+    const cacheTimeout = Number(options?.cacheTimeout || 0);
+    if (cacheTimeout <= 0) {
+        return undefined;
+    }
+    const entry = flux.getState(getCachePath(scope));
+    if (!entry) {
+        return undefined;
+    }
+    const payloadKey = getPayloadKey(payload);
+    const timeoutMinutes = Number(entry.cacheTimeout || 0);
+    const expiresAt = entry.cacheTimestamp + timeoutMinutes * 60 * 1000;
+    if (entry.payloadKey !== payloadKey || Date.now() > expiresAt) {
+        return undefined;
+    }
+    return entry.data;
+};
+export const setCachedRequest = async (flux, scope, payload = {}, data, options = {})=>{
+    const cacheTimeout = Number(options?.cacheTimeout || 0);
+    if (cacheTimeout <= 0 || typeof flux?.setState !== 'function') {
+        return data;
+    }
+    await flux.setState(getCachePath(scope), {
+        cacheTimeout,
+        cacheTimestamp: Date.now(),
+        data,
+        payloadKey: getPayloadKey(payload)
+    });
+    return data;
+};
+export const clearCachedRequest = async (flux, scope)=>{
+    if (typeof flux?.setState !== 'function') {
+        return;
+    }
+    await flux.setState(getCachePath(scope), undefined);
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/session.d.ts

@@ -0,0 +1,14 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { SessionType } from './api.js';
+import type { ConfigAppSessionType } from '../config/index.js';
+export declare const parseJwtExpiryMs: (token: string) => number;
+export declare const parseJwtIssuedMs: (token: string) => number;
+export declare const normalizeSession: (session?: Record<string, unknown>) => Record<string, unknown>;
+export declare const isValidSession: (session?: Record<string, unknown>) => boolean;
+export declare const getRefreshWindowMinutes: (sessionLifetimeMinutes: number, sessionConfig?: ConfigAppSessionType) => number;
+export declare const storeSession: (flux: FluxFramework, session?: Record<string, unknown>) => Promise<SessionType>;
+export declare const readStoredSession: (flux: FluxFramework) => Promise<SessionType>;
+export declare const clearPersistedSession: (flux: FluxFramework) => Promise<void>;
+export declare const hydrateSessionFromStorage: (flux: FluxFramework) => Promise<SessionType>;
+export declare const isLoggedIn: (flux: FluxFramework) => boolean;
+//# sourceMappingURL=session.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../src/utils/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AACnD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,UAAU,CAAC;AAC1C,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,oBAAoB,CAAC;AA4D7D,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,MACF,CAAC;AAEhD,eAAO,MAAM,gBAAgB,GAAI,OAAO,MAAM,KAAG,MACF,CAAC;AAEhD,eAAO,MAAM,gBAAgB,GAAI,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,KAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAiB9F,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,KAAG,OAatE,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAClC,wBAAwB,MAAM,EAC9B,gBAAe,oBAAyB,KACvC,MASF,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,MAAM,aAAa,EACnB,UAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,KACpC,OAAO,CAAC,WAAW,CAYrB,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAU,MAAM,aAAa,KAAG,OAAO,CAAC,WAAW,CACsB,CAAC;AAExG,eAAO,MAAM,qBAAqB,GAAU,MAAM,aAAa,KAAG,OAAO,CAAC,IAAI,CAE7E,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAU,MAAM,aAAa,KAAG,OAAO,CAAC,WAAW,CAUxF,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,MAAM,aAAa,KAAG,OAIhD,CAAC"}

package/lib/utils/session.js

@@ -0,0 +1,107 @@
+const MILLIS_THRESHOLD = 1_000_000_000_000;
+const SECONDS_THRESHOLD = 1_000_000_000;
+const decodeJwtPayload = (token)=>{
+    try {
+        if (!token) {
+            return {};
+        }
+        const tokenParts = token.split('.');
+        if (tokenParts.length < 2 || typeof atob !== 'function') {
+            return {};
+        }
+        const payloadBase64 = tokenParts[1]?.replace(/-/g, '+').replace(/_/g, '/');
+        const normalized = payloadBase64?.padEnd(Math.ceil(payloadBase64.length / 4) * 4, '=');
+        return JSON.parse(atob(normalized || ''));
+    } catch (error) {
+        return {};
+    }
+};
+const parseTimestampMs = (value)=>{
+    const numericValue = Number(value || 0);
+    if (numericValue > MILLIS_THRESHOLD) {
+        return numericValue;
+    }
+    if (numericValue > SECONDS_THRESHOLD) {
+        return numericValue * 1000;
+    }
+    return 0;
+};
+const getSessionToken = (session)=>String(session.token || session.idToken?.jwtToken || session.accessToken?.jwtToken || '');
+const buildTokenValue = (token, currentToken)=>currentToken && typeof currentToken === 'object' ? currentToken : {
+        jwtToken: token
+    };
+const getNormalizedSessionTimestamps = (session, token)=>{
+    const payload = decodeJwtPayload(token);
+    const expires = parseTimestampMs(session.expires) || parseTimestampMs(payload.exp);
+    const issued = parseTimestampMs(session.issued) || parseTimestampMs(payload.iat);
+    return {
+        expires,
+        issued
+    };
+};
+export const parseJwtExpiryMs = (token)=>parseTimestampMs(decodeJwtPayload(token).exp);
+export const parseJwtIssuedMs = (token)=>parseTimestampMs(decodeJwtPayload(token).iat);
+export const normalizeSession = (session = {})=>{
+    const token = getSessionToken(session);
+    if (!token) {
+        return {};
+    }
+    const { expires, issued } = getNormalizedSessionTimestamps(session, token);
+    return {
+        ...session,
+        accessToken: buildTokenValue(token, session.accessToken),
+        expires,
+        idToken: buildTokenValue(token, session.idToken),
+        issued,
+        token
+    };
+};
+export const isValidSession = (session = {})=>{
+    const normalized = normalizeSession(session);
+    const token = String(normalized?.token || '');
+    if (!token) {
+        return false;
+    }
+    const sessionExpires = Number(normalized?.expires || 0);
+    const tokenExpires = parseJwtExpiryMs(token);
+    const expiresAt = sessionExpires > 0 ? sessionExpires : tokenExpires;
+    return Boolean(expiresAt && Date.now() < expiresAt);
+};
+export const getRefreshWindowMinutes = (sessionLifetimeMinutes, sessionConfig = {})=>{
+    const lifetimeMinutes = Math.max(1, Number(sessionLifetimeMinutes || 0));
+    const refreshAfterRatio = Number(sessionConfig.refreshAfterRatio || 0);
+    if (refreshAfterRatio > 0 && refreshAfterRatio < 1) {
+        return Math.max(1, Math.round(lifetimeMinutes * (1 - refreshAfterRatio)));
+    }
+    return Math.max(1, Number(sessionConfig.minMinutes || 5));
+};
+export const storeSession = (flux, session = {})=>{
+    return (async ()=>{
+        const normalizedSession = normalizeSession(session);
+        if (!Object.keys(normalizedSession).length) {
+            await clearPersistedSession(flux);
+            return {};
+        }
+        await Promise.resolve(flux.setState('user.session', normalizedSession));
+        return normalizedSession;
+    })();
+};
+export const readStoredSession = async (flux)=>normalizeSession(flux.getState('user.session', {}) || {});
+export const clearPersistedSession = async (flux)=>{
+    await Promise.resolve(flux.setState('user.session', {}));
+};
+export const hydrateSessionFromStorage = async (flux)=>{
+    const currentSession = await readStoredSession(flux);
+    if (isValidSession(currentSession)) {
+        await storeSession(flux, currentSession);
+        return currentSession;
+    }
+    await clearPersistedSession(flux);
+    return {};
+};
+export const isLoggedIn = (flux)=>{
+    const currentSession = flux.getState('user.session', {}) || {};
+    return isValidSession(currentSession);
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/utils/session.ts"],"sourcesContent":["import type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {SessionType} from './api.js';\nimport type {ConfigAppSessionType} from '../config/index.js';\n\nconst MILLIS_THRESHOLD = 1_000_000_000_000;\nconst SECONDS_THRESHOLD = 1_000_000_000;\n\nconst decodeJwtPayload = (token: string): Record<string, unknown> => {\n  try {\n    if(!token) {\n      return {};\n    }\n\n    const tokenParts = token.split('.');\n    if(tokenParts.length < 2 || typeof atob !== 'function') {\n      return {};\n    }\n\n    const payloadBase64 = tokenParts[1]?.replace(/-/g, '+').replace(/_/g, '/');\n    const normalized = payloadBase64?.padEnd(Math.ceil(payloadBase64.length / 4) * 4, '=');\n\n    return JSON.parse(atob(normalized || '')) as Record<string, unknown>;\n  } catch(error) {\n    return {};\n  }\n};\n\nconst parseTimestampMs = (value: unknown): number => {\n  const numericValue = Number(value || 0);\n\n  if(numericValue > MILLIS_THRESHOLD) {\n    return numericValue;\n  }\n\n  if(numericValue > SECONDS_THRESHOLD) {\n    return numericValue * 1000;\n  }\n\n  return 0;\n};\n\nconst getSessionToken = (session: Record<string, unknown>): string =>\n  String(\n    session.token\n    || (session.idToken as {jwtToken?: string} | undefined)?.jwtToken\n    || (session.accessToken as {jwtToken?: string} | undefined)?.jwtToken\n    || ''\n  );\n\nconst buildTokenValue = (token: string, currentToken?: unknown) =>\n  currentToken && typeof currentToken === 'object'\n    ? currentToken\n    : {jwtToken: token};\n\nconst getNormalizedSessionTimestamps = (session: Record<string, unknown>, token: string) => {\n  const payload = decodeJwtPayload(token);\n  const expires = parseTimestampMs(session.expires) || parseTimestampMs(payload.exp);\n  const issued = parseTimestampMs(session.issued) || parseTimestampMs(payload.iat);\n\n  return {expires, issued};\n};\n\nexport const parseJwtExpiryMs = (token: string): number =>\n  parseTimestampMs(decodeJwtPayload(token).exp);\n\nexport const parseJwtIssuedMs = (token: string): number =>\n  parseTimestampMs(decodeJwtPayload(token).iat);\n\nexport const normalizeSession = (session: Record<string, unknown> = {}): Record<string, unknown> => {\n  const token = getSessionToken(session);\n\n  if(!token) {\n    return {};\n  }\n\n  const {expires, issued} = getNormalizedSessionTimestamps(session, token);\n\n  return {\n    ...session,\n    accessToken: buildTokenValue(token, session.accessToken),\n    expires,\n    idToken: buildTokenValue(token, session.idToken),\n    issued,\n    token\n  };\n};\n\nexport const isValidSession = (session: Record<string, unknown> = {}): boolean => {\n  const normalized = normalizeSession(session);\n  const token = String(normalized?.token || '');\n\n  if(!token) {\n    return false;\n  }\n\n  const sessionExpires = Number(normalized?.expires || 0);\n  const tokenExpires = parseJwtExpiryMs(token);\n  const expiresAt = sessionExpires > 0 ? sessionExpires : tokenExpires;\n\n  return Boolean(expiresAt && Date.now() < expiresAt);\n};\n\nexport const getRefreshWindowMinutes = (\n  sessionLifetimeMinutes: number,\n  sessionConfig: ConfigAppSessionType = {}\n): number => {\n  const lifetimeMinutes = Math.max(1, Number(sessionLifetimeMinutes || 0));\n  const refreshAfterRatio = Number(sessionConfig.refreshAfterRatio || 0);\n\n  if(refreshAfterRatio > 0 && refreshAfterRatio < 1) {\n    return Math.max(1, Math.round(lifetimeMinutes * (1 - refreshAfterRatio)));\n  }\n\n  return Math.max(1, Number(sessionConfig.minMinutes || 5));\n};\n\nexport const storeSession = (\n  flux: FluxFramework,\n  session: Record<string, unknown> = {}\n): Promise<SessionType> => {\n  return (async () => {\n    const normalizedSession = normalizeSession(session) as SessionType;\n\n    if(!Object.keys(normalizedSession as Record<string, unknown>).length) {\n      await clearPersistedSession(flux);\n      return {} as SessionType;\n    }\n\n    await Promise.resolve(flux.setState('user.session', normalizedSession));\n    return normalizedSession;\n  })();\n};\n\nexport const readStoredSession = async (flux: FluxFramework): Promise<SessionType> =>\n  normalizeSession((flux.getState('user.session', {}) || {}) as Record<string, unknown>) as SessionType;\n\nexport const clearPersistedSession = async (flux: FluxFramework): Promise<void> => {\n  await Promise.resolve(flux.setState('user.session', {}));\n};\n\nexport const hydrateSessionFromStorage = async (flux: FluxFramework): Promise<SessionType> => {\n  const currentSession = await readStoredSession(flux);\n\n  if(isValidSession(currentSession as Record<string, unknown>)) {\n    await storeSession(flux, currentSession as unknown as Record<string, unknown>);\n    return currentSession;\n  }\n\n  await clearPersistedSession(flux);\n  return {} as SessionType;\n};\n\nexport const isLoggedIn = (flux: FluxFramework): boolean => {\n  const currentSession = (flux.getState('user.session', {}) || {}) as Record<string, unknown>;\n\n  return isValidSession(currentSession);\n};\n"],"names":["MILLIS_THRESHOLD","SECONDS_THRESHOLD","decodeJwtPayload","token","tokenParts","split","length","atob","payloadBase64","replace","normalized","padEnd","Math","ceil","JSON","parse","error","parseTimestampMs","value","numericValue","Number","getSessionToken","session","String","idToken","jwtToken","accessToken","buildTokenValue","currentToken","getNormalizedSessionTimestamps","payload","expires","exp","issued","iat","parseJwtExpiryMs","parseJwtIssuedMs","normalizeSession","isValidSession","sessionExpires","tokenExpires","expiresAt","Boolean","Date","now","getRefreshWindowMinutes","sessionLifetimeMinutes","sessionConfig","lifetimeMinutes","max","refreshAfterRatio","round","minMinutes","storeSession","flux","normalizedSession","Object","keys","clearPersistedSession","Promise","resolve","setState","readStoredSession","getState","hydrateSessionFromStorage","currentSession","isLoggedIn"],"mappings":"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"}

package/lib/utils/useConversationTyping.d.ts

@@ -0,0 +1,26 @@
+type TypingUser = {
+    readonly imageUrl?: string;
+    readonly name?: string;
+    readonly personaId?: string;
+    readonly thumbUrl?: string;
+    readonly userId?: string;
+    readonly username?: string;
+};
+export type ConversationTypingOptions = {
+    readonly name?: string;
+    readonly personaId?: string;
+    readonly userId?: string;
+    readonly username?: string;
+    readonly users?: TypingUser[];
+};
+export type UseConversationTypingOptions = {
+    readonly debounceMs?: number;
+    readonly idleMs?: number;
+};
+export declare const useConversationTyping: ({ debounceMs, idleMs }?: UseConversationTypingOptions) => {
+    setConversation: (conversationId: string, options?: ConversationTypingOptions) => void;
+    stopTyping: (conversationId?: string, options?: ConversationTypingOptions) => void;
+    syncDraft: (conversationId: string, draft: string, options?: ConversationTypingOptions) => void;
+};
+export {};
+//# sourceMappingURL=useConversationTyping.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useConversationTyping.d.ts","sourceRoot":"","sources":["../../src/utils/useConversationTyping.ts"],"names":[],"mappings":"AAIA,KAAK,UAAU,GAAG;IAChB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,CAAC,EAAE,UAAU,EAAE,CAAC;CAC/B,CAAC;AAEF,MAAM,MAAM,4BAA4B,GAAG;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAKF,eAAO,MAAM,qBAAqB,GAAI,yBAGnC,4BAAiC;sCAyEmB,MAAM,YAAW,yBAAyB;oDAiBJ,yBAAyB;gCA3CrE,MAAM,SAAS,MAAM,YAAW,yBAAyB;CA8DzG,CAAC"}

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

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