@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/utils/index.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ // Export API utilities
+export { appMutation, appQuery, getGraphql, publicMutation, publicQuery, refreshSession, uploadImage } from './api.js';
+// Export action factory
+export { createAction, createActions, createAllActions } from './actionFactory.js';
+// Export base action factory
+export { createBaseActions } from './baseActionFactory.js';
+// Export validator factory
+export { createValidatorFactory, createValidatorManager } from './validatorFactory.js';
+// Export React hooks
+export { MetropolisContext, MetropolisProvider } from './MetropolisProvider.js';
+export { PermissionGuard, PermissionLevel, usePermissions } from './permissionUtils.js';
+export { useMetropolis } from './useMetropolis.js';
+export { useConversationTyping } from './useConversationTyping.js';
+export { useTranslations } from './useTranslations.js';
+// Export utility functions
+export * from './app.js';
+export * from './dateUtils.js';
+export * from './file.js';
+export * from './i18n.js';
+export * from './location.js';
+export * from './session.js';
+
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9Vc2Vycy9uaXRyb2c3L0RldmVsb3BtZW50L21ldHJvcG9saXNqcy9zcmMvdXRpbHMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTktUHJlc2VudCwgTml0cm9nZW4gTGFicywgSW5jLlxuICogQ29weXJpZ2h0cyBsaWNlbnNlZCB1bmRlciB0aGUgTUlUIExpY2Vuc2UuIFNlZSB0aGUgYWNjb21wYW55aW5nIExJQ0VOU0UgZmlsZSBmb3IgdGVybXMuXG4gKi9cblxuLy8gRXhwb3J0IEFQSSB1dGlsaXRpZXNcbmV4cG9ydCB7XG4gIGFwcE11dGF0aW9uLFxuICBhcHBRdWVyeSxcbiAgZ2V0R3JhcGhxbCxcbiAgcHVibGljTXV0YXRpb24sXG4gIHB1YmxpY1F1ZXJ5LFxuICByZWZyZXNoU2Vzc2lvbixcbiAgdXBsb2FkSW1hZ2UsXG4gIHR5cGUgQXBpUmVzdWx0c1R5cGUsXG4gIHR5cGUgUmVha3RvckRiQ29sbGVjdGlvbixcbiAgdHlwZSBTZXNzaW9uVHlwZVxufSBmcm9tICcuL2FwaS5qcyc7XG5cbi8vIEV4cG9ydCBhY3Rpb24gZmFjdG9yeVxuZXhwb3J0IHtcbiAgY3JlYXRlQWN0aW9uLFxuICBjcmVhdGVBY3Rpb25zLFxuICBjcmVhdGVBbGxBY3Rpb25zLFxuICB0eXBlIEFjdGlvbk9wdGlvbnMsXG4gIHR5cGUgQWN0aW9uUmV0dXJuVHlwZSxcbiAgdHlwZSBBY3Rpb25UeXBlLFxuICB0eXBlIEFjdGlvblR5cGVzXG59IGZyb20gJy4vYWN0aW9uRmFjdG9yeS5qcyc7XG5cbi8vIEV4cG9ydCBiYXNlIGFjdGlvbiBmYWN0b3J5XG5leHBvcnQge1xuICBjcmVhdGVCYXNlQWN0aW9ucyxcbiAgdHlwZSBCYXNlQWN0aW9uT3B0aW9uc1xufSBmcm9tICcuL2Jhc2VBY3Rpb25GYWN0b3J5LmpzJztcblxuLy8gRXhwb3J0IHZhbGlkYXRvciBmYWN0b3J5XG5leHBvcnQge1xuICBjcmVhdGVWYWxpZGF0b3JGYWN0b3J5LFxuICBjcmVhdGVWYWxpZGF0b3JNYW5hZ2VyLFxuICB0eXBlIEJhc2VBZGFwdGVyT3B0aW9uc1xufSBmcm9tICcuL3ZhbGlkYXRvckZhY3RvcnkuanMnO1xuXG4vLyBFeHBvcnQgUmVhY3QgaG9va3NcbmV4cG9ydCB7TWV0cm9wb2xpc0NvbnRleHQsIE1ldHJvcG9saXNQcm92aWRlcn0gZnJvbSAnLi9NZXRyb3BvbGlzUHJvdmlkZXIuanMnO1xuZXhwb3J0IHtcbiAgUGVybWlzc2lvbkd1YXJkLFxuICBQZXJtaXNzaW9uTGV2ZWwsXG4gIHVzZVBlcm1pc3Npb25zLFxuICB0eXBlIFBlcm1pc3Npb24sXG4gIHR5cGUgUGVybWlzc2lvbkd1YXJkUHJvcHMsXG4gIHR5cGUgVXNlUGVybWlzc2lvbnNSZXR1cm5cbn0gZnJvbSAnLi9wZXJtaXNzaW9uVXRpbHMuanMnO1xuZXhwb3J0IHt1c2VNZXRyb3BvbGlzfSBmcm9tICcuL3VzZU1ldHJvcG9saXMuanMnO1xuZXhwb3J0IHt1c2VDb252ZXJzYXRpb25UeXBpbmcsIHR5cGUgQ29udmVyc2F0aW9uVHlwaW5nT3B0aW9ucywgdHlwZSBVc2VDb252ZXJzYXRpb25UeXBpbmdPcHRpb25zfSBmcm9tICcuL3VzZUNvbnZlcnNhdGlvblR5cGluZy5qcyc7XG5leHBvcnQge3VzZVRyYW5zbGF0aW9uc30gZnJvbSAnLi91c2VUcmFuc2xhdGlvbnMuanMnO1xuXG4vLyBFeHBvcnQgdXRpbGl0eSBmdW5jdGlvbnNcbmV4cG9ydCAqIGZyb20gJy4vYXBwLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vZGF0ZVV0aWxzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vZmlsZS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2kxOG4uanMnO1xuZXhwb3J0ICogZnJvbSAnLi9sb2NhdGlvbi5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3Nlc3Npb24uanMnO1xuXG4iXSwibmFtZXMiOlsiYXBwTXV0YXRpb24iLCJhcHBRdWVyeSIsImdldEdyYXBocWwiLCJwdWJsaWNNdXRhdGlvbiIsInB1YmxpY1F1ZXJ5IiwicmVmcmVzaFNlc3Npb24iLCJ1cGxvYWRJbWFnZSIsImNyZWF0ZUFjdGlvbiIsImNyZWF0ZUFjdGlvbnMiLCJjcmVhdGVBbGxBY3Rpb25zIiwiY3JlYXRlQmFzZUFjdGlvbnMiLCJjcmVhdGVWYWxpZGF0b3JGYWN0b3J5IiwiY3JlYXRlVmFsaWRhdG9yTWFuYWdlciIsIk1ldHJvcG9saXNDb250ZXh0IiwiTWV0cm9wb2xpc1Byb3ZpZGVyIiwiUGVybWlzc2lvbkd1YXJkIiwiUGVybWlzc2lvbkxldmVsIiwidXNlUGVybWlzc2lvbnMiLCJ1c2VNZXRyb3BvbGlzIiwidXNlQ29udmVyc2F0aW9uVHlwaW5nIiwidXNlVHJhbnNsYXRpb25zIl0sIm1hcHBpbmdzIjoiQUFBQTs7O0NBR0MsR0FFRCx1QkFBdUI7QUFDdkIsU0FDRUEsV0FBVyxFQUNYQyxRQUFRLEVBQ1JDLFVBQVUsRUFDVkMsY0FBYyxFQUNkQyxXQUFXLEVBQ1hDLGNBQWMsRUFDZEMsV0FBVyxRQUlOLFdBQVc7QUFFbEIsd0JBQXdCO0FBQ3hCLFNBQ0VDLFlBQVksRUFDWkMsYUFBYSxFQUNiQyxnQkFBZ0IsUUFLWCxxQkFBcUI7QUFFNUIsNkJBQTZCO0FBQzdCLFNBQ0VDLGlCQUFpQixRQUVaLHlCQUF5QjtBQUVoQywyQkFBMkI7QUFDM0IsU0FDRUMsc0JBQXNCLEVBQ3RCQyxzQkFBc0IsUUFFakIsd0JBQXdCO0FBRS9CLHFCQUFxQjtBQUNyQixTQUFRQyxpQkFBaUIsRUFBRUMsa0JBQWtCLFFBQU8sMEJBQTBCO0FBQzlFLFNBQ0VDLGVBQWUsRUFDZkMsZUFBZSxFQUNmQyxjQUFjLFFBSVQsdUJBQXVCO0FBQzlCLFNBQVFDLGFBQWEsUUFBTyxxQkFBcUI7QUFDakQsU0FBUUMscUJBQXFCLFFBQTBFLDZCQUE2QjtBQUNwSSxTQUFRQyxlQUFlLFFBQU8sdUJBQXVCO0FBRXJELDJCQUEyQjtBQUMzQixjQUFjLFdBQVc7QUFDekIsY0FBYyxpQkFBaUI7QUFDL0IsY0FBYyxZQUFZO0FBQzFCLGNBQWMsWUFBWTtBQUMxQixjQUFjLGdCQUFnQjtBQUM5QixjQUFjLGVBQWUifQ==

package/lib/utils/location.d.ts

@@ -3,7 +3,8 @@
  * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
  */
 import { FluxFramework } from '@nlabs/arkhamjs';
-import { parseLocation } from '../adapters/locationAdapter/locationAdapter';
-import type { LocationType } from '../adapters/locationAdapter/locationAdapter';
-export declare const autoCompleteLocation: (flux: FluxFramework, address: string, latitude?: number | undefined, longitude?: number | undefined, locationProps?: string[] | undefined, CustomClass?: ((location: LocationType) => LocationType) | undefined) => Promise<LocationType[]>;
+import { parseLocation } from '../adapters/locationAdapter/locationAdapter.js';
+import type { LocationType } from '../adapters/locationAdapter/locationAdapter.js';
+export declare const autoCompleteLocation: (this: unknown, flux: FluxFramework, address: string, latitude?: number, longitude?: number, locationProps?: string[], CustomClass?: (location: LocationType) => LocationType) => Promise<LocationType[]>;
 export declare const searchLocations: (flux: FluxFramework, address: string, latitude?: number, longitude?: number, locationProps?: string[], CustomClass?: typeof parseLocation) => Promise<LocationType[]>;
+//# sourceMappingURL=location.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"location.d.ts","sourceRoot":"","sources":["../../src/utils/location.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIhD,OAAO,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AAG/E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gDAAgD,CAAC;AAKnF,eAAO,MAAM,oBAAoB,2MA4C1B,CAAC;AAER,eAAO,MAAM,eAAe,GAC1B,MAAM,aAAa,EACnB,SAAS,MAAM,EACf,WAAW,MAAM,EACjB,YAAY,MAAM,EAClB,gBAAe,MAAM,EAAO,EAC5B,cAAa,OAAO,aAA6B,KAChD,OAAO,CAAC,YAAY,EAAE,CAqCxB,CAAC"}

package/lib/utils/location.js

@@ -1,2 +1,82 @@
-import{isEmpty as l}from"@nlabs/utils";import y from"p-debounce";import{parseLocation as c}from"../adapters/locationAdapter/locationAdapter";import{appQuery as s}from"../utils/api";const m="locations",F=y(async(e,t,r,a,n=[],i=c)=>{if(l(t))return[];try{const o={address:{type:"String",value:t},latitude:{type:"Float",value:r},longitude:{type:"Float",value:a}},{autoCompleteLocation:p=[]}=await s(e,"autoCompleteLocation",m,o,["address","latitude","longitude",...n]);return p.map(u=>i(u))}catch{return[]}},500),b=async(e,t,r,a,n=[],i=c)=>{if(l(t))return[];try{const o={address:{type:"String",value:t},latitude:{type:"Float",value:r},longitude:{type:"Float",value:a}},{autoCompleteLocation:p=[]}=await s(e,"autoCompleteLocation",m,o,["address","latitude","longitude",...n]);return p.map(u=>i(u))}catch{return[]}};export{F as autoCompleteLocation,b as searchLocations};
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Copyright (c) 2012-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { isEmpty } from '@nlabs/utils';
+import pDebounce from 'p-debounce';
+import { parseLocation } from '../adapters/locationAdapter/locationAdapter.js';
+import { appQuery } from '../utils/api.js';
+const DATA_TYPE = 'locations';
+export const autoCompleteLocation = pDebounce(async (flux, address, latitude, longitude, locationProps = [], CustomClass = parseLocation)=>{
+    if (isEmpty(address)) {
+        return [];
+    }
+    try {
+        const queryVariables = {
+            address: {
+                type: 'String',
+                value: address
+            },
+            latitude: {
+                type: 'Float',
+                value: latitude
+            },
+            longitude: {
+                type: 'Float',
+                value: longitude
+            }
+        };
+        const { autoCompleteLocation = [] } = await appQuery(flux, 'autoCompleteLocation', DATA_TYPE, queryVariables, [
+            'address',
+            'city',
+            'country',
+            'latitude',
+            'location',
+            'longitude',
+            'state',
+            'street',
+            'zip',
+            ...locationProps
+        ]);
+        return autoCompleteLocation.map((item)=>CustomClass(item));
+    } catch (_error) {
+        return [];
+    }
+}, 500);
+export const searchLocations = async (flux, address, latitude, longitude, locationProps = [], CustomClass = parseLocation)=>{
+    if (isEmpty(address)) {
+        return [];
+    }
+    try {
+        const queryVariables = {
+            address: {
+                type: 'String',
+                value: address
+            },
+            latitude: {
+                type: 'Float',
+                value: latitude
+            },
+            longitude: {
+                type: 'Float',
+                value: longitude
+            }
+        };
+        const { autoCompleteLocation = [] } = await appQuery(flux, 'autoCompleteLocation', DATA_TYPE, queryVariables, [
+            'address',
+            'city',
+            'country',
+            'latitude',
+            'location',
+            'longitude',
+            'state',
+            'street',
+            'zip',
+            ...locationProps
+        ]);
+        return autoCompleteLocation.map((item)=>CustomClass(item));
+    } catch (_error) {
+        return [];
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils/permissionUtils.d.ts

@@ -0,0 +1,22 @@
+import { PermissionLevel } from '../adapters/permissionAdapter/permissionAdapter.js';
+export interface PermissionGuardProps {
+    requiredLevel: PermissionLevel;
+    resource?: string;
+    fallback?: React.ReactNode;
+    children: React.ReactNode;
+}
+export interface UsePermissionsReturn {
+    userLevel: number;
+    hasPermission: (requiredLevel: PermissionLevel) => boolean;
+    isGuest: boolean;
+    isUser: boolean;
+    isModerator: boolean;
+    isAdmin: boolean;
+    isSuperAdmin: boolean;
+    checkResource: (resource: string, requiredLevel: PermissionLevel) => boolean;
+}
+export declare const usePermissions: () => UsePermissionsReturn;
+export declare const PermissionGuard: React.FC<PermissionGuardProps>;
+export { PermissionLevel } from '../adapters/permissionAdapter/permissionAdapter.js';
+export type { Permission } from '../adapters/permissionAdapter/permissionAdapter.js';
+//# sourceMappingURL=permissionUtils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"permissionUtils.d.ts","sourceRoot":"","sources":["../../src/utils/permissionUtils.tsx"],"names":[],"mappings":"AAOA,OAAO,EAOL,eAAe,EAChB,MAAM,oDAAoD,CAAC;AAI5D,MAAM,WAAW,oBAAoB;IACnC,aAAa,EAAE,eAAe,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAC;IAC3B,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC3B;AAED,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,CAAC,aAAa,EAAE,eAAe,KAAK,OAAO,CAAC;IAC3D,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,OAAO,CAAC;IACrB,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,OAAO,CAAC;IACtB,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,aAAa,EAAE,eAAe,KAAK,OAAO,CAAC;CAC9E;AAED,eAAO,MAAM,cAAc,QAAO,oBAyDjC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAiB1D,CAAC;AAEF,OAAO,EAAC,eAAe,EAAC,MAAM,oDAAoD,CAAC;AACnF,YAAY,EAAC,UAAU,EAAC,MAAM,oDAAoD,CAAC"}

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"}