@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/actions/reactionActions/reactionActions.d.ts

@@ -1,5 +1,6 @@
 import type { FluxFramework } from '@nlabs/arkhamjs';
-import type { ReactionType } from '../../adapters/reactionAdapter/reactionAdapter';
+import type { ReactionType } from '../../adapters/reactionAdapter/reactionAdapter.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
 export interface ReactionAdapterOptions {
     strict?: boolean;
     allowPartial?: boolean;
@@ -12,41 +13,26 @@ export interface ReactionActionsOptions {
 }
 export type ReactionApiResultsType = {
     reactions: {
+        addPersonaReaction: ReactionType;
         addReaction: ReactionType;
+        deletePersonaReaction: ReactionType;
         deleteReaction: ReactionType;
         getReactionCount: number;
+        hasPersonaReaction: boolean;
         hasReaction: boolean;
     };
 };
 export interface ReactionActions {
-    addReaction: (itemId: string, itemType: string, reaction: Partial<ReactionType>, reactionProps?: string[]) => Promise<ReactionType>;
-    deleteReaction: (itemId: string, itemType: string, reactionName: string, reactionProps?: string[]) => Promise<ReactionType>;
-    getReactionCount: (itemId: string, itemType: string, reactionName: string) => Promise<number>;
-    hasReaction: (itemId: string, itemType: string, reactionName: string, direction: string) => Promise<boolean>;
+    addPersonaReaction: (personaId: string, itemId: string, itemType: string, reaction: Partial<ReactionType>, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;
+    addReaction: (itemId: string, itemType: string, reaction: Partial<ReactionType>, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;
+    deletePersonaReaction: (personaId: string, itemId: string, itemType: string, reactionName: string, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;
+    deleteReaction: (itemId: string, itemType: string, reactionName: string, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;
+    getReactionCount: (itemId: string, itemType: string, reactionName: string, requestOptions?: ActionRequestOptions) => Promise<number>;
+    hasPersonaReaction: (personaId: string, itemId: string, itemType: string, reactionName: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;
+    hasReaction: (itemId: string, itemType: string, reactionName: string, direction: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;
     abbreviateCount: (count: number) => string;
     updateReactionAdapter: (adapter: (input: unknown, options?: ReactionAdapterOptions) => any) => void;
     updateReactionAdapterOptions: (options: ReactionAdapterOptions) => void;
 }
-/**
- * Factory function to create ReactionActions with enhanced adapter injection capabilities.
- * Custom adapters are merged with default behavior, allowing partial overrides.
- *
- * @example
- * // Basic usage with default adapters
- * const reactionActions = createReactionActions(flux);
- *
- * @example
- * // Custom adapter that extends default behavior
- * const customReactionAdapter = (input: unknown, options?: ReactionAdapterOptions) => {
- *   // input is already validated by default adapter
- *   if (input.value && input.value > 5) {
- *     throw new Error('Reaction value too high');
- *   }
- *   return input;
- * };
- *
- * const reactionActions = createReactionActions(flux, {
- *   reactionAdapter: customReactionAdapter
- * });
- */
 export declare const createReactionActions: (flux: FluxFramework, options?: ReactionActionsOptions) => ReactionActions;
+//# sourceMappingURL=reactionActions.d.ts.map

package/lib/actions/reactionActions/reactionActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactionActions.d.ts","sourceRoot":"","sources":["../../../src/actions/reactionActions/reactionActions.ts"],"names":[],"mappings":"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"}

package/lib/actions/reactionActions/reactionActions.js

@@ -1,2 +1,413 @@
-import{Flux as A}from"@nlabs/arkhamjs";import{validateReactionInput as C}from"../../adapters/reactionAdapter/reactionAdapter";import{REACTION_CONSTANTS as R}from"../../stores/reactionStore";import{appMutation as O,appQuery as T}from"../../utils/api";const g="reactions",w=(a,y)=>C(a),h=(a,y)=>(p,u)=>{const d={...y,...u};let l=w(p,d);return a&&(l=a(l,d)),d?.customValidation&&(l=d.customValidation(l)),l},M=(a,y)=>{let p=y?.reactionAdapterOptions||{},u=y?.reactionAdapter,d=h(u,p);return{addReaction:async(e,n,r,c=[])=>{const t=d(r,p),{value:o}=t,s=o!==void 0?o.toString():o;try{const i={itemId:{type:"ID!",value:`${n}/${e}`},reaction:{type:"ReactionInput",value:{...t,value:s}}},m=S=>{const{reactions:{addReaction:v={}}}=S;return A.dispatch({itemId:e,itemType:n,reaction:v,type:R.ADD_ITEM_SUCCESS})},{reaction:b}=await O(a,"addReaction",g,i,["id","name","value",...c],{onSuccess:m});return b}catch(i){throw a.dispatch({error:i,type:R.ADD_ITEM_ERROR}),i}},deleteReaction:async(e,n,r,c=[])=>{try{const t={itemId:{type:"ID!",value:`${n}/${e}`},reactionName:{type:"String",value:r}},o=i=>{const{reactions:{deleteReaction:m={}}}=i;return A.dispatch({itemId:e,itemType:n,reaction:m,type:R.REMOVE_ITEM_SUCCESS})},{reaction:s}=await O(a,"deleteReaction",g,t,["id","name","value",...c],{onSuccess:o});return s}catch(t){throw a.dispatch({error:t,type:R.REMOVE_ITEM_ERROR}),t}},getReactionCount:async(e,n,r)=>{try{const c={itemId:{type:"ID!",value:`${n}/${e}`},reactionName:{type:"String",value:r}},t=s=>{const{reactions:{getReactionCount:i}}=s;return a.dispatch({count:i,itemId:e,name:r,type:R.GET_COUNT_SUCCESS})},{count:o}=await T(a,"reactionCount",g,c,["count"],{onSuccess:t});return o}catch(c){throw a.dispatch({error:c,type:R.GET_COUNT_ERROR}),c}},hasReaction:async(e,n,r,c)=>{try{const t={direction:{type:"String",value:c},itemId:{type:"ID!",value:`${n}/${e}`},reactionName:{type:"String",value:r}},o=i=>{const{reactions:{hasReaction:m}}=i;return A.dispatch({hasReaction:m,itemId:`${n}/${e}`,name:r,type:R.HAS_SUCCESS})},{hasReaction:s}=await T(a,"hasReaction",g,t,[],{onSuccess:o});return s}catch(t){throw a.dispatch({error:t,type:R.HAS_ERROR}),t}},abbreviateCount:e=>{const n=e||0;let r=n.toString();if(n>=1e3){const c=["","k","m","b","t"],t=Math.floor(`${n}`.length/3);let o=0,s="";for(let i=2;i>=1&&(o=parseFloat((t!==0?n/Math.pow(1e3,t):n).toPrecision(i)),s=o.toString(),!(`${o}`.replace(/[^a-zA-Z 0-9]+/g,"").length<=2));i--);o%1!==0&&(s=o.toFixed(1)),r=s+c[t]}return r},updateReactionAdapter:e=>{u=e,d=h(u,p)},updateReactionAdapterOptions:e=>{p={...p,...e},d=h(u,p)}}};export{M as createReactionActions};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/actions/reactionActions/reactionActions.ts"],
  "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 {Flux} from '@nlabs/arkhamjs';\n\nimport {validateReactionInput} from '../../adapters/reactionAdapter/reactionAdapter';\nimport {REACTION_CONSTANTS} from '../../stores/reactionStore';\nimport {appMutation, appQuery} from '../../utils/api';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {ReactionType} from '../../adapters/reactionAdapter/reactionAdapter';\nimport type {ReaktorDbCollection} from '../../utils/api';\n\nconst DATA_TYPE: ReaktorDbCollection = 'reactions';\n\nexport interface ReactionAdapterOptions {\n  strict?: boolean;\n  allowPartial?: boolean;\n  environment?: 'development' | 'production' | 'test';\n  customValidation?: (input: unknown) => unknown;\n}\n\nexport interface ReactionActionsOptions {\n  reactionAdapter?: (input: unknown, options?: ReactionAdapterOptions) => any;\n  reactionAdapterOptions?: ReactionAdapterOptions;\n}\n\nexport type ReactionApiResultsType = {\n  reactions: {\n    addReaction: ReactionType;\n    deleteReaction: ReactionType;\n    getReactionCount: number;\n    hasReaction: boolean;\n  };\n};\n\nexport interface ReactionActions {\n  addReaction: (itemId: string, itemType: string, reaction: Partial<ReactionType>, reactionProps?: string[]) => Promise<ReactionType>;\n  deleteReaction: (itemId: string, itemType: string, reactionName: string, reactionProps?: string[]) => Promise<ReactionType>;\n  getReactionCount: (itemId: string, itemType: string, reactionName: string) => Promise<number>;\n  hasReaction: (itemId: string, itemType: string, reactionName: string, direction: string) => Promise<boolean>;\n  abbreviateCount: (count: number) => string;\n  updateReactionAdapter: (adapter: (input: unknown, options?: ReactionAdapterOptions) => any) => void;\n  updateReactionAdapterOptions: (options: ReactionAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultReactionValidator = (input: unknown, options?: ReactionAdapterOptions) => validateReactionInput(input);\n\n// Enhanced validation function that merges custom logic with defaults\nconst createReactionValidator = (\n  customAdapter?: (input: unknown, options?: ReactionAdapterOptions) => any,\n  options?: ReactionAdapterOptions\n) => (input: unknown, validatorOptions?: ReactionAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  // Start with default validation\n  let validated = defaultReactionValidator(input, mergedOptions);\n\n  // Apply custom validation if provided\n  if(customAdapter) {\n    validated = customAdapter(validated, mergedOptions);\n  }\n\n  // Apply custom validation from options if provided\n  if(mergedOptions?.customValidation) {\n    validated = mergedOptions.customValidation(validated) as ReactionType;\n  }\n\n  return validated;\n};\n\n/**\n * Factory function to create ReactionActions with enhanced adapter injection capabilities.\n * Custom adapters are merged with default behavior, allowing partial overrides.\n *\n * @example\n * // Basic usage with default adapters\n * const reactionActions = createReactionActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customReactionAdapter = (input: unknown, options?: ReactionAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.value && input.value > 5) {\n *     throw new Error('Reaction value too high');\n *   }\n *   return input;\n * };\n *\n * const reactionActions = createReactionActions(flux, {\n *   reactionAdapter: customReactionAdapter\n * });\n */\nexport const createReactionActions = (\n  flux: FluxFramework,\n  options?: ReactionActionsOptions\n): ReactionActions => {\n  // Initialize adapter state\n  let reactionAdapterOptions: ReactionAdapterOptions = options?.reactionAdapterOptions || {};\n  let customReactionAdapter = options?.reactionAdapter;\n\n  // Create validators that merge custom adapters with defaults\n  let validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);\n\n  // Update functions that recreate validators\n  const updateReactionAdapter = (adapter: (input: unknown, options?: ReactionAdapterOptions) => any): void => {\n    customReactionAdapter = adapter;\n    validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);\n  };\n\n  const updateReactionAdapterOptions = (options: ReactionAdapterOptions): void => {\n    reactionAdapterOptions = {...reactionAdapterOptions, ...options};\n    validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);\n  };\n\n  // Action implementations\n  const addReaction = async (\n    itemId: string,\n    itemType: string,\n    reaction: Partial<ReactionType>,\n    reactionProps: string[] = []\n  ): Promise<ReactionType> => {\n    const validatedReaction = validateReaction(reaction, reactionAdapterOptions);\n    const {value} = validatedReaction;\n    const formatValue = value !== undefined ? value.toString() : value;\n\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reaction: {\n          type: 'ReactionInput',\n          value: {\n            ...validatedReaction,\n            value: formatValue\n          }\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const {reactions: {addReaction: reaction = {}}} = data;\n        return Flux.dispatch({itemId, itemType, reaction, type: REACTION_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      const {reaction: addedReaction} = await appMutation(flux, 'addReaction', DATA_TYPE, queryVariables, ['id', 'name', 'value', ...reactionProps], {\n        onSuccess\n      });\n\n      return addedReaction as ReactionType;\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteReaction = async (\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    reactionProps: string[] = []\n  ): Promise<ReactionType> => {\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reactionName: {\n          type: 'String',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const {reactions: {deleteReaction: reaction = {}}} = data;\n        return Flux.dispatch({\n          itemId,\n          itemType,\n          reaction,\n          type: REACTION_CONSTANTS.REMOVE_ITEM_SUCCESS\n        });\n      };\n\n      const {reaction: deletedReaction} = await appMutation(flux, 'deleteReaction', DATA_TYPE, queryVariables, ['id', 'name', 'value', ...reactionProps], {\n        onSuccess\n      });\n\n      return deletedReaction as ReactionType;\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const getReactionCount = async (itemId: string, itemType: string, reactionName: string): Promise<number> => {\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reactionName: {\n          type: 'String',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const {reactions: {getReactionCount}} = data;\n        return flux.dispatch({\n          count: getReactionCount,\n          itemId,\n          name: reactionName,\n          type: REACTION_CONSTANTS.GET_COUNT_SUCCESS\n        });\n      };\n\n      const {count: reactionCount} = await appQuery(\n        flux,\n        'reactionCount',\n        DATA_TYPE,\n        queryVariables,\n        ['count'],\n        {onSuccess}\n      );\n      return reactionCount as number;\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.GET_COUNT_ERROR});\n      throw error;\n    }\n  };\n\n  const hasReaction = async (itemId: string, itemType: string, reactionName: string, direction: string): Promise<boolean> => {\n    try {\n      const queryVariables = {\n        direction: {\n          type: 'String',\n          value: direction\n        },\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reactionName: {\n          type: 'String',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const {reactions: {hasReaction}} = data;\n        return Flux.dispatch({\n          hasReaction,\n          itemId: `${itemType}/${itemId}`,\n          name: reactionName,\n          type: REACTION_CONSTANTS.HAS_SUCCESS\n        });\n      };\n\n      const {hasReaction: hasReactionResult} = await appQuery(\n        flux,\n        'hasReaction',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {onSuccess}\n      );\n      return hasReactionResult as boolean;\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.HAS_ERROR});\n      throw error;\n    }\n  };\n\n  const abbreviateCount = (count: number): string => {\n    const value: number = count || 0;\n    let newValue: string = value.toString();\n\n    if(value >= 1000) {\n      const suffixes: string[] = ['', 'k', 'm', 'b', 't'];\n      const suffixNum: number = Math.floor(`${value}`.length / 3);\n      let shortValue: number = 0;\n      let shortString: string = '';\n\n      for(let precision = 2; precision >= 1; precision--) {\n        shortValue = parseFloat((suffixNum !== 0 ? value / Math.pow(1000, suffixNum) : value).toPrecision(precision));\n        shortString = shortValue.toString();\n        const dotLessShortValue: string = `${shortValue}`.replace(/[^a-zA-Z 0-9]+/g, '');\n\n        if(dotLessShortValue.length <= 2) {\n          break;\n        }\n      }\n\n      if(shortValue % 1 !== 0) {\n        shortString = shortValue.toFixed(1);\n      }\n\n      newValue = shortString + suffixes[suffixNum];\n    }\n\n    return newValue;\n  };\n\n  // Return the actions object\n  return {\n    addReaction,\n    deleteReaction,\n    getReactionCount,\n    hasReaction,\n    abbreviateCount,\n    updateReactionAdapter,\n    updateReactionAdapterOptions\n  };\n};\n\n"],
  "mappings": "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",
  "names": ["Flux", "validateReactionInput", "REACTION_CONSTANTS", "appMutation", "appQuery", "DATA_TYPE", "defaultReactionValidator", "input", "options", "createReactionValidator", "customAdapter", "validatorOptions", "mergedOptions", "validated", "createReactionActions", "flux", "reactionAdapterOptions", "customReactionAdapter", "validateReaction", "itemId", "itemType", "reaction", "reactionProps", "validatedReaction", "value", "formatValue", "queryVariables", "onSuccess", "data", "addedReaction", "error", "reactionName", "deletedReaction", "getReactionCount", "reactionCount", "direction", "hasReaction", "hasReactionResult", "count", "newValue", "suffixes", "suffixNum", "shortValue", "shortString", "precision", "adapter"]
}

+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { Flux } from '@nlabs/arkhamjs';
+import { validateReactionInput } from '../../adapters/reactionAdapter/reactionAdapter.js';
+import { REACTION_CONSTANTS } from '../../stores/reactionStore.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'reactions';
+const defaultReactionValidator = (input, options)=>validateReactionInput(input);
+const createReactionValidator = (customAdapter, options)=>(input, validatorOptions)=>{
+        const mergedOptions = {
+            ...options,
+            ...validatorOptions
+        };
+        let validated = defaultReactionValidator(input, mergedOptions);
+        if (customAdapter) {
+            validated = customAdapter(validated, mergedOptions);
+        }
+        if (mergedOptions?.customValidation) {
+            validated = mergedOptions.customValidation(validated);
+        }
+        return validated;
+    };
+export const createReactionActions = (flux, options)=>{
+    let reactionAdapterOptions = options?.reactionAdapterOptions || {};
+    let customReactionAdapter = options?.reactionAdapter;
+    let validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);
+    const updateReactionAdapter = (adapter)=>{
+        customReactionAdapter = adapter;
+        validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);
+    };
+    const updateReactionAdapterOptions = (options)=>{
+        reactionAdapterOptions = {
+            ...reactionAdapterOptions,
+            ...options
+        };
+        validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);
+    };
+    const addReaction = async (itemId, itemType, reaction, reactionProps = [], requestOptions = {})=>{
+        const validatedReaction = validateReaction(reaction, reactionAdapterOptions);
+        const { value } = validatedReaction;
+        const formatValue = value !== undefined ? value.toString() : value;
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                reaction: {
+                    type: 'ReactionInput',
+                    value: {
+                        ...validatedReaction,
+                        value: formatValue
+                    }
+                }
+            };
+            const onSuccess = (data)=>{
+                const reaction = data?.reactions?.addReaction || {};
+                return Flux.dispatch({
+                    itemId,
+                    itemType,
+                    reaction,
+                    type: REACTION_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addReaction', DATA_TYPE, queryVariables, [
+                'id',
+                'name',
+                'value',
+                ...reactionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reaction.name || ''}`);
+            await clearCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reaction.name || ''}`);
+        }
+    };
+    const addPersonaReaction = async (personaId, itemId, itemType, reaction, reactionProps = [], requestOptions = {})=>{
+        const validatedReaction = validateReaction(reaction, reactionAdapterOptions);
+        const { value } = validatedReaction;
+        const formatValue = value !== undefined ? value.toString() : value;
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                personaId: {
+                    type: 'ID',
+                    value: personaId
+                },
+                reaction: {
+                    type: 'ReactionInput',
+                    value: {
+                        ...validatedReaction,
+                        value: formatValue
+                    }
+                }
+            };
+            const onSuccess = (data)=>{
+                const reaction = data?.reactions?.addPersonaReaction || {};
+                return Flux.dispatch({
+                    itemId,
+                    itemType,
+                    reaction,
+                    type: REACTION_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addPersonaReaction', DATA_TYPE, queryVariables, [
+                'id',
+                'name',
+                'type',
+                'value',
+                ...reactionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reaction.name || ''}`);
+            await clearCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reaction.name || ''}`);
+        }
+    };
+    const deleteReaction = async (itemId, itemType, reactionName, reactionProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                reactionName: {
+                    type: 'String',
+                    value: reactionName
+                }
+            };
+            const onSuccess = (data)=>{
+                const reaction = data?.reactions?.deleteReaction || {};
+                return Flux.dispatch({
+                    itemId,
+                    itemType,
+                    reaction,
+                    type: REACTION_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deleteReaction', DATA_TYPE, queryVariables, [
+                'id',
+                'name',
+                'value',
+                ...reactionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`);
+            await clearCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`);
+        }
+    };
+    const deletePersonaReaction = async (personaId, itemId, itemType, reactionName, reactionProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                personaId: {
+                    type: 'ID',
+                    value: personaId
+                },
+                reactionName: {
+                    type: 'String!',
+                    value: reactionName
+                }
+            };
+            const onSuccess = (data)=>{
+                const reaction = data?.reactions?.deletePersonaReaction || {};
+                return Flux.dispatch({
+                    itemId,
+                    itemType,
+                    reaction,
+                    type: REACTION_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deletePersonaReaction', DATA_TYPE, queryVariables, [
+                'id',
+                'name',
+                'type',
+                'value',
+                ...reactionProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`);
+            await clearCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`);
+        }
+    };
+    const getReactionCount = async (itemId, itemType, reactionName, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`, {
+                itemId,
+                itemType,
+                reactionName
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                reactionName: {
+                    type: 'String',
+                    value: reactionName
+                }
+            };
+            const onSuccess = (data)=>{
+                const getReactionCount = data?.reactions?.getReactionCount ?? 0;
+                return flux.dispatch({
+                    count: getReactionCount,
+                    itemId,
+                    name: reactionName,
+                    type: REACTION_CONSTANTS.GET_COUNT_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'getReactionCount', DATA_TYPE, queryVariables, [], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`, {
+                itemId,
+                itemType,
+                reactionName
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.GET_COUNT_ERROR
+            });
+            throw error;
+        }
+    };
+    const hasReaction = async (itemId, itemType, reactionName, direction, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`, {
+                direction,
+                itemId,
+                itemType,
+                reactionName
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                direction: {
+                    type: 'String',
+                    value: direction
+                },
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                reactionName: {
+                    type: 'String',
+                    value: reactionName
+                }
+            };
+            const onSuccess = (data)=>{
+                const hasReaction = data?.reactions?.hasReaction ?? false;
+                return Flux.dispatch({
+                    hasReaction,
+                    itemId: `${itemType}/${itemId}`,
+                    name: reactionName,
+                    type: REACTION_CONSTANTS.HAS_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'hasReaction', DATA_TYPE, queryVariables, [], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`, {
+                direction,
+                itemId,
+                itemType,
+                reactionName
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.HAS_ERROR
+            });
+            throw error;
+        }
+    };
+    const hasPersonaReaction = async (personaId, itemId, itemType, reactionName, requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`, {
+                itemId,
+                itemType,
+                personaId,
+                reactionName
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: `${itemType}/${itemId}`
+                },
+                personaId: {
+                    type: 'ID',
+                    value: personaId
+                },
+                reactionName: {
+                    type: 'String!',
+                    value: reactionName
+                }
+            };
+            const onSuccess = (data)=>{
+                const hasReaction = data?.reactions?.hasPersonaReaction ?? false;
+                return Flux.dispatch({
+                    hasReaction,
+                    itemId: `${itemType}/${itemId}`,
+                    name: reactionName,
+                    type: REACTION_CONSTANTS.HAS_SUCCESS
+                });
+            };
+            const result = await appQuery(flux, 'hasPersonaReaction', DATA_TYPE, queryVariables, [], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`, {
+                itemId,
+                itemType,
+                personaId,
+                reactionName
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: REACTION_CONSTANTS.HAS_ERROR
+            });
+            throw error;
+        }
+    };
+    const abbreviateCount = (count)=>{
+        const value = count || 0;
+        let newValue = value.toString();
+        if (value >= 1000) {
+            const suffixes = [
+                '',
+                'k',
+                'm',
+                'b',
+                't'
+            ];
+            const suffixNum = Math.floor(`${value}`.length / 3);
+            let shortValue = 0;
+            let shortString = '';
+            for(let precision = 2; precision >= 1; precision--){
+                shortValue = parseFloat((suffixNum !== 0 ? value / Math.pow(1000, suffixNum) : value).toPrecision(precision));
+                shortString = shortValue.toString();
+                const dotLessShortValue = `${shortValue}`.replace(/[^a-zA-Z 0-9]+/g, '');
+                if (dotLessShortValue.length <= 2) {
+                    break;
+                }
+            }
+            if (shortValue % 1 !== 0) {
+                shortString = shortValue.toFixed(1);
+            }
+            newValue = shortString + suffixes[suffixNum];
+        }
+        return newValue;
+    };
+    // Return the actions object
+    return {
+        addPersonaReaction,
+        addReaction,
+        deletePersonaReaction,
+        deleteReaction,
+        getReactionCount,
+        hasPersonaReaction,
+        hasReaction,
+        abbreviateCount,
+        updateReactionAdapter,
+        updateReactionAdapterOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/reactionActions/reactionActions.ts"],"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 {Flux} from '@nlabs/arkhamjs';\n\nimport {validateReactionInput} from '../../adapters/reactionAdapter/reactionAdapter.js';\nimport {REACTION_CONSTANTS} from '../../stores/reactionStore.js';\nimport {appMutation, appQuery} from '../../utils/api.js';\nimport {clearCachedRequest, getCachedRequest, setCachedRequest} from '../../utils/requestCache.js';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {ReactionType} from '../../adapters/reactionAdapter/reactionAdapter.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'reactions';\n\nexport interface ReactionAdapterOptions {\n  strict?: boolean;\n  allowPartial?: boolean;\n  environment?: 'development' | 'production' | 'test';\n  customValidation?: (input: unknown) => unknown;\n}\n\nexport interface ReactionActionsOptions {\n  reactionAdapter?: (input: unknown, options?: ReactionAdapterOptions) => any;\n  reactionAdapterOptions?: ReactionAdapterOptions;\n}\n\nexport type ReactionApiResultsType = {\n  reactions: {\n    addPersonaReaction: ReactionType;\n    addReaction: ReactionType;\n    deletePersonaReaction: ReactionType;\n    deleteReaction: ReactionType;\n    getReactionCount: number;\n    hasPersonaReaction: boolean;\n    hasReaction: boolean;\n  };\n};\n\nexport interface ReactionActions {\n  addPersonaReaction: (personaId: string, itemId: string, itemType: string, reaction: Partial<ReactionType>, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;\n  addReaction: (itemId: string, itemType: string, reaction: Partial<ReactionType>, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;\n  deletePersonaReaction: (personaId: string, itemId: string, itemType: string, reactionName: string, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;\n  deleteReaction: (itemId: string, itemType: string, reactionName: string, reactionProps?: string[], requestOptions?: ActionRequestOptions) => Promise<ReactionType>;\n  getReactionCount: (itemId: string, itemType: string, reactionName: string, requestOptions?: ActionRequestOptions) => Promise<number>;\n  hasPersonaReaction: (personaId: string, itemId: string, itemType: string, reactionName: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  hasReaction: (itemId: string, itemType: string, reactionName: string, direction: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  abbreviateCount: (count: number) => string;\n  updateReactionAdapter: (adapter: (input: unknown, options?: ReactionAdapterOptions) => any) => void;\n  updateReactionAdapterOptions: (options: ReactionAdapterOptions) => void;\n}\n\nconst defaultReactionValidator = (input: unknown, options?: ReactionAdapterOptions) => validateReactionInput(input);\n\nconst createReactionValidator = (\n  customAdapter?: (input: unknown, options?: ReactionAdapterOptions) => any,\n  options?: ReactionAdapterOptions\n) => (input: unknown, validatorOptions?: ReactionAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  let validated = defaultReactionValidator(input, mergedOptions);\n\n  if(customAdapter) {\n    validated = customAdapter(validated, mergedOptions);\n  }\n\n  if(mergedOptions?.customValidation) {\n    validated = mergedOptions.customValidation(validated) as ReactionType;\n  }\n\n  return validated;\n};\n\nexport const createReactionActions = (\n  flux: FluxFramework,\n  options?: ReactionActionsOptions\n): ReactionActions => {\n  let reactionAdapterOptions = options?.reactionAdapterOptions || {};\n  let customReactionAdapter = options?.reactionAdapter;\n  let validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);\n\n  const updateReactionAdapter = (adapter: (input: unknown, options?: ReactionAdapterOptions) => any): void => {\n    customReactionAdapter = adapter;\n    validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);\n  };\n\n  const updateReactionAdapterOptions = (options: ReactionAdapterOptions): void => {\n    reactionAdapterOptions = {...reactionAdapterOptions, ...options};\n    validateReaction = createReactionValidator(customReactionAdapter, reactionAdapterOptions);\n  };\n\n  const addReaction = async (\n    itemId: string,\n    itemType: string,\n    reaction: Partial<ReactionType>,\n    reactionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ReactionType> => {\n    const validatedReaction = validateReaction(reaction, reactionAdapterOptions);\n    const {value} = validatedReaction;\n    const formatValue = value !== undefined ? value.toString() : value;\n\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reaction: {\n          type: 'ReactionInput',\n          value: {\n            ...validatedReaction,\n            value: formatValue\n          }\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const reaction = data?.reactions?.addReaction || {};\n        return Flux.dispatch({itemId, itemType, reaction, type: REACTION_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<ReactionType>(flux, 'addReaction', DATA_TYPE, queryVariables, ['id', 'name', 'value', ...reactionProps], {\n        onSuccess\n      });\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reaction.name || ''}`);\n      await clearCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reaction.name || ''}`);\n    }\n  };\n\n  const addPersonaReaction = async (\n    personaId: string,\n    itemId: string,\n    itemType: string,\n    reaction: Partial<ReactionType>,\n    reactionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ReactionType> => {\n    const validatedReaction = validateReaction(reaction, reactionAdapterOptions);\n    const {value} = validatedReaction;\n    const formatValue = value !== undefined ? value.toString() : value;\n\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        personaId: {\n          type: 'ID',\n          value: personaId\n        },\n        reaction: {\n          type: 'ReactionInput',\n          value: {\n            ...validatedReaction,\n            value: formatValue\n          }\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const reaction = data?.reactions?.addPersonaReaction || {};\n        return Flux.dispatch({itemId, itemType, reaction, type: REACTION_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<ReactionType>(flux, 'addPersonaReaction', DATA_TYPE, queryVariables, ['id', 'name', 'type', 'value', ...reactionProps], {\n        onSuccess\n      });\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reaction.name || ''}`);\n      await clearCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reaction.name || ''}`);\n    }\n  };\n\n  const deleteReaction = async (\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    reactionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ReactionType> => {\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reactionName: {\n          type: 'String',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const reaction = data?.reactions?.deleteReaction || {};\n        return Flux.dispatch({\n          itemId,\n          itemType,\n          reaction,\n          type: REACTION_CONSTANTS.REMOVE_ITEM_SUCCESS\n        });\n      };\n\n      return await appMutation<ReactionType>(flux, 'deleteReaction', DATA_TYPE, queryVariables, ['id', 'name', 'value', ...reactionProps], {\n        onSuccess\n      });\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`);\n      await clearCachedRequest(flux, `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`);\n    }\n  };\n\n  const deletePersonaReaction = async (\n    personaId: string,\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    reactionProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<ReactionType> => {\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        personaId: {\n          type: 'ID',\n          value: personaId\n        },\n        reactionName: {\n          type: 'String!',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const reaction = data?.reactions?.deletePersonaReaction || {};\n        return Flux.dispatch({\n          itemId,\n          itemType,\n          reaction,\n          type: REACTION_CONSTANTS.REMOVE_ITEM_SUCCESS\n        });\n      };\n\n      return await appMutation<ReactionType>(flux, 'deletePersonaReaction', DATA_TYPE, queryVariables, ['id', 'name', 'type', 'value', ...reactionProps], {\n        onSuccess\n      });\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`);\n      await clearCachedRequest(flux, `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`);\n    }\n  };\n\n  const getReactionCount = async (\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<number> => {\n    try {\n      const cachedResult = getCachedRequest<number>(\n        flux,\n        `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`,\n        {itemId, itemType, reactionName},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reactionName: {\n          type: 'String',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const getReactionCount = data?.reactions?.getReactionCount ?? 0;\n        return flux.dispatch({\n          count: getReactionCount,\n          itemId,\n          name: reactionName,\n          type: REACTION_CONSTANTS.GET_COUNT_SUCCESS\n        });\n      };\n\n      const result = await appQuery<number>(\n        flux,\n        'getReactionCount',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(\n        flux,\n        `reaction.getReactionCount:${itemType}:${itemId}:${reactionName}`,\n        {itemId, itemType, reactionName},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.GET_COUNT_ERROR});\n      throw error;\n    }\n  };\n\n  const hasReaction = async (\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    direction: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<boolean> => {\n    try {\n      const cachedResult = getCachedRequest<boolean>(\n        flux,\n        `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`,\n        {direction, itemId, itemType, reactionName},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        direction: {\n          type: 'String',\n          value: direction\n        },\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        reactionName: {\n          type: 'String',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const hasReaction = data?.reactions?.hasReaction ?? false;\n        return Flux.dispatch({\n          hasReaction,\n          itemId: `${itemType}/${itemId}`,\n          name: reactionName,\n          type: REACTION_CONSTANTS.HAS_SUCCESS\n        });\n      };\n\n      const result = await appQuery<boolean>(\n        flux,\n        'hasReaction',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(\n        flux,\n        `reaction.hasReaction:${itemType}:${itemId}:${reactionName}`,\n        {direction, itemId, itemType, reactionName},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.HAS_ERROR});\n      throw error;\n    }\n  };\n\n  const hasPersonaReaction = async (\n    personaId: string,\n    itemId: string,\n    itemType: string,\n    reactionName: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<boolean> => {\n    try {\n      const cachedResult = getCachedRequest<boolean>(\n        flux,\n        `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`,\n        {itemId, itemType, personaId, reactionName},\n        requestOptions\n      );\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: `${itemType}/${itemId}`\n        },\n        personaId: {\n          type: 'ID',\n          value: personaId\n        },\n        reactionName: {\n          type: 'String!',\n          value: reactionName\n        }\n      };\n\n      const onSuccess = (data: ReactionApiResultsType) => {\n        const hasReaction = data?.reactions?.hasPersonaReaction ?? false;\n        return Flux.dispatch({\n          hasReaction,\n          itemId: `${itemType}/${itemId}`,\n          name: reactionName,\n          type: REACTION_CONSTANTS.HAS_SUCCESS\n        });\n      };\n\n      const result = await appQuery<boolean>(\n        flux,\n        'hasPersonaReaction',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(\n        flux,\n        `reaction.hasPersonaReaction:${personaId}:${itemType}:${itemId}:${reactionName}`,\n        {itemId, itemType, personaId, reactionName},\n        result,\n        requestOptions\n      );\n    } catch(error) {\n      flux.dispatch({error, type: REACTION_CONSTANTS.HAS_ERROR});\n      throw error;\n    }\n  };\n\n  const abbreviateCount = (count: number): string => {\n    const value = count || 0;\n    let newValue = value.toString();\n\n    if(value >= 1000) {\n      const suffixes = ['', 'k', 'm', 'b', 't'];\n      const suffixNum = Math.floor(`${value}`.length / 3);\n      let shortValue = 0;\n      let shortString = '';\n\n      for(let precision = 2; precision >= 1; precision--) {\n        shortValue = parseFloat((suffixNum !== 0 ? value / Math.pow(1000, suffixNum) : value).toPrecision(precision));\n        shortString = shortValue.toString();\n        const dotLessShortValue = `${shortValue}`.replace(/[^a-zA-Z 0-9]+/g, '');\n\n        if(dotLessShortValue.length <= 2) {\n          break;\n        }\n      }\n\n      if(shortValue % 1 !== 0) {\n        shortString = shortValue.toFixed(1);\n      }\n\n      newValue = shortString + suffixes[suffixNum];\n    }\n\n    return newValue;\n  };\n\n  // Return the actions object\n  return {\n    addPersonaReaction,\n    addReaction,\n    deletePersonaReaction,\n    deleteReaction,\n    getReactionCount,\n    hasPersonaReaction,\n    hasReaction,\n    abbreviateCount,\n    updateReactionAdapter,\n    updateReactionAdapterOptions\n  };\n};\n"],"names":["Flux","validateReactionInput","REACTION_CONSTANTS","appMutation","appQuery","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultReactionValidator","input","options","createReactionValidator","customAdapter","validatorOptions","mergedOptions","validated","customValidation","createReactionActions","flux","reactionAdapterOptions","customReactionAdapter","reactionAdapter","validateReaction","updateReactionAdapter","adapter","updateReactionAdapterOptions","addReaction","itemId","itemType","reaction","reactionProps","requestOptions","validatedReaction","value","formatValue","undefined","toString","queryVariables","type","onSuccess","data","reactions","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","name","addPersonaReaction","personaId","deleteReaction","reactionName","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","deletePersonaReaction","getReactionCount","cachedResult","count","GET_COUNT_SUCCESS","result","GET_COUNT_ERROR","hasReaction","direction","HAS_SUCCESS","HAS_ERROR","hasPersonaReaction","abbreviateCount","newValue","suffixes","suffixNum","Math","floor","length","shortValue","shortString","precision","parseFloat","pow","toPrecision","dotLessShortValue","replace","toFixed"],"mappings":"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"}

package/lib/actions/sseActions/sseActions.d.ts

@@ -35,3 +35,4 @@ export interface SSEActions {
     readonly updateSSEOptions: (options: SSEActionsOptions) => void;
 }
 export declare const createSSEActions: (flux: FluxFramework, options?: SSEActionsOptions) => SSEActions;
+//# sourceMappingURL=sseActions.d.ts.map

package/lib/actions/sseActions/sseActions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sseActions.d.ts","sourceRoot":"","sources":["../../../src/actions/sseActions/sseActions.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,iBAAiB,CAAC;AAEnD,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC1C,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,eAAe,CAAC,EAAE,OAAO,CAAC;CACpC;AAED,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;IAC/C,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC1C,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,CAAC;IAC/C,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACzC,QAAQ,CAAC,UAAU,CAAC,EAAE,oBAAoB,CAAC;CAC5C;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IACpE,QAAQ,CAAC,UAAU,EAAE,MAAM,IAAI,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,OAAO,CAAC;IACpC,QAAQ,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,IAAI,CAAC;IACjE,QAAQ,CAAC,gBAAgB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,KAAK,IAAI,CAAC;IAC3F,QAAQ,CAAC,mBAAmB,EAAE,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,KAAK,EAAE,QAAQ,KAAK,IAAI,KAAK,IAAI,CAAC;IAC9F,QAAQ,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,IAAI,CAAC;CACjE;AAED,eAAO,MAAM,gBAAgB,GAC3B,MAAM,aAAa,EACnB,UAAU,iBAAiB,KAC1B,UAwKF,CAAC"}