@nlabs/metropolisjs 0.1.2 → 0.2.0

package/lib/actions/index.d.ts

@@ -1,9 +1,21 @@
-export * from './eventActions/eventActions';
-export * from './imageActions/imageActions';
-export * from './locationActions/locationActions';
-export * from './messageActions/messageActions';
-export * from './postActions/postActions';
-export * from './reactionActions/reactionActions';
-export * from './tagActions/tagActions';
-export * from './userActions/userActions';
-export * from './websocketActions/websocketActions';
+export * from './appActions/appActions.js';
+export * from './connectionActions/connectionActions.js';
+export * from './contentActions/contentActions.js';
+export * from './conversationActions/conversationActions.js';
+export * from './eventActions/eventActions.js';
+export * from './groupActions/groupActions.js';
+export * from './imageActions/imageActions.js';
+export * from './locationActions/locationActions.js';
+export * from './messageActions/messageActions.js';
+export * from './permissionActions/permissionActions.js';
+export * from './postActions/postActions.js';
+export * from './personaActions/personaActions.js';
+export * from './reactionActions/reactionActions.js';
+export * from './sseActions/sseActions.js';
+export * from './subscriptionActions/subscriptionActions.js';
+export * from './tagActions/tagActions.js';
+export * from './translationActions/translationActions.js';
+export * from './userActions/userActions.js';
+export * from './videoActions/videoActions.js';
+export * from './websocketActions/websocketActions.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/actions/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,0CAA0C,CAAC;AACzD,cAAc,oCAAoC,CAAC;AACnD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,oCAAoC,CAAC;AACnD,cAAc,0CAA0C,CAAC;AACzD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oCAAoC,CAAC;AACnD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,8CAA8C,CAAC;AAC7D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4CAA4C,CAAC;AAC3D,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wCAAwC,CAAC"}

package/lib/actions/index.js

@@ -1,2 +1,22 @@
-export*from"./eventActions/eventActions";export*from"./imageActions/imageActions";export*from"./locationActions/locationActions";export*from"./messageActions/messageActions";export*from"./postActions/postActions";export*from"./reactionActions/reactionActions";export*from"./tagActions/tagActions";export*from"./userActions/userActions";export*from"./websocketActions/websocketActions";
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FjdGlvbnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbImV4cG9ydCAqIGZyb20gJy4vZXZlbnRBY3Rpb25zL2V2ZW50QWN0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL2ltYWdlQWN0aW9ucy9pbWFnZUFjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9sb2NhdGlvbkFjdGlvbnMvbG9jYXRpb25BY3Rpb25zJztcbmV4cG9ydCAqIGZyb20gJy4vbWVzc2FnZUFjdGlvbnMvbWVzc2FnZUFjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi9wb3N0QWN0aW9ucy9wb3N0QWN0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL3JlYWN0aW9uQWN0aW9ucy9yZWFjdGlvbkFjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi90YWdBY3Rpb25zL3RhZ0FjdGlvbnMnO1xuZXhwb3J0ICogZnJvbSAnLi91c2VyQWN0aW9ucy91c2VyQWN0aW9ucyc7XG5leHBvcnQgKiBmcm9tICcuL3dlYnNvY2tldEFjdGlvbnMvd2Vic29ja2V0QWN0aW9ucyc7XG5cbiJdLAogICJtYXBwaW5ncyI6ICJBQUFBLFdBQWMsOEJBQ2QsV0FBYyw4QkFDZCxXQUFjLG9DQUNkLFdBQWMsa0NBQ2QsV0FBYyw0QkFDZCxXQUFjLG9DQUNkLFdBQWMsMEJBQ2QsV0FBYyw0QkFDZCxXQUFjIiwKICAibmFtZXMiOiBbXQp9Cg==
+export * from './appActions/appActions.js';
+export * from './connectionActions/connectionActions.js';
+export * from './contentActions/contentActions.js';
+export * from './conversationActions/conversationActions.js';
+export * from './eventActions/eventActions.js';
+export * from './groupActions/groupActions.js';
+export * from './imageActions/imageActions.js';
+export * from './locationActions/locationActions.js';
+export * from './messageActions/messageActions.js';
+export * from './permissionActions/permissionActions.js';
+export * from './postActions/postActions.js';
+export * from './personaActions/personaActions.js';
+export * from './reactionActions/reactionActions.js';
+export * from './sseActions/sseActions.js';
+export * from './subscriptionActions/subscriptionActions.js';
+export * from './tagActions/tagActions.js';
+export * from './translationActions/translationActions.js';
+export * from './userActions/userActions.js';
+export * from './videoActions/videoActions.js';
+export * from './websocketActions/websocketActions.js';
+
+//# sourceMappingURL=data:application/json;base64,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

package/lib/actions/locationActions/locationActions.d.ts

@@ -1,5 +1,6 @@
 import type { FluxFramework } from '@nlabs/arkhamjs';
-import type { LocationType } from '../../adapters/locationAdapter/locationAdapter';
+import type { LocationType } from '../../adapters/locationAdapter/locationAdapter.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
 export interface LocationAdapterOptions {
     strict?: boolean;
     allowPartial?: boolean;
@@ -18,18 +19,18 @@ export type LocationApiResultsType = {
     updateLocation: LocationType;
 };
 export interface LocationActions {
-    autocompleteLocation: (address: string, latitude?: number, longitude?: number, locationProps?: string[]) => Promise<LocationType[]>;
-    add: (location: Partial<LocationType>, locationProps?: string[]) => Promise<LocationType>;
-    delete: (locationId: string) => Promise<LocationType>;
-    getCurrentLocation: (setLocation?: (location: LocationType) => void) => Promise<LocationType>;
-    getGoogleLocation: (address: string) => Promise<{
+    autocompleteLocation: (address: string, latitude?: number, longitude?: number, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType[]>;
+    add: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;
+    delete: (locationId: string, requestOptions?: ActionRequestOptions) => Promise<LocationType>;
+    getCurrentLocation: (setLocation?: (location: LocationType) => void, requestOptions?: ActionRequestOptions) => Promise<LocationType>;
+    getGoogleLocation: (address: string, requestOptions?: ActionRequestOptions) => Promise<{
         latitude: number;
         location: string;
         longitude: number;
     }>;
-    getLocation: (location: Partial<LocationType>, locationProps?: string[]) => Promise<LocationType>;
-    listByItem: (itemId: string, locationProps?: string[]) => Promise<LocationType[]>;
-    update: (location: Partial<LocationType>, locationProps?: string[]) => Promise<LocationType>;
+    getLocation: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;
+    listByItem: (itemId: string, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType[]>;
+    update: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;
     updateLocationAdapter: (adapter: (input: unknown, options?: LocationAdapterOptions) => any) => void;
     updateLocationAdapterOptions: (options: LocationAdapterOptions) => void;
 }
@@ -56,3 +57,4 @@ export interface LocationActions {
  * });
  */
 export declare const createLocationActions: (flux: FluxFramework, options?: LocationActionsOptions) => LocationActions;
+//# sourceMappingURL=locationActions.d.ts.map

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

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

package/lib/actions/locationActions/locationActions.js

@@ -1,2 +1,388 @@
-import{get as I}from"@nlabs/rip-hunter";import{validateLocationInput as S}from"../../adapters/locationAdapter/locationAdapter";import{Config as h}from"../../config";import{LOCATION_CONSTANTS as s}from"../../stores/locationStore";import{appMutation as g}from"../../utils/api";import{autoCompleteLocation as C}from"../../utils/location";const m="locations",_=(o,L)=>S(o),O=(o,L)=>(p,l)=>{const d={...L,...l};let u=_(p,d);return o&&(u=o(u,d)),d?.customValidation&&(u=d.customValidation(u)),u},$=(o,L)=>{let p=L?.locationAdapterOptions||{},l=L?.locationAdapter,d=O(l,p);return{autocompleteLocation:async(e,n,t,i=[])=>C(o,e,n,t,i),add:async(e,n=[])=>{try{const t={location:{type:"LocationInput!",value:d(e,p)}},i=(c={})=>{const{addLocation:r={}}=c;return o.dispatch({location:r,type:s.ADD_ITEM_SUCCESS})},{location:a}=await g(o,"addLocation",m,t,["added","address","city","country","id","latitude","longitude","modified","state","street","zip",...n],{onSuccess:i});return a}catch(t){throw o.dispatch({error:t,type:s.ADD_ITEM_ERROR}),t}},delete:async e=>{try{const n={locationId:{type:"ID!",value:e}},t=(a={})=>{const{deleteLocation:c={}}=a;return o.dispatch({location:c,type:s.REMOVE_ITEM_SUCCESS})},{location:i}=await g(o,"deleteLocation",m,n,["id"],{onSuccess:t});return i}catch(n){throw o.dispatch({error:n,type:s.REMOVE_ITEM_ERROR}),n}},getCurrentLocation:async e=>new Promise((n,t)=>{const{userId:i}=o.getState("user.session",{}),{city:a,country:c,latitude:r,longitude:A,state:E}=o.getState(["user","users",i||""],{}),R=[a,E,c].join(", "),y={latitude:r,location:R,longitude:A};navigator.geolocation?navigator.geolocation.getCurrentPosition(async({coords:T})=>{const P={latitude:T.latitude,location:"Current Location",longitude:T.longitude};await o.dispatch({current:P,type:s.SET_CURRENT}),e&&e(P),n(P)},T=>{e&&e(y),o.dispatch({current:y,type:s.SET_CURRENT}),t(T)},{enableHighAccuracy:!1,maximumAge:0,timeout:3e4}):(e&&e(y),o.dispatch({current:y,type:s.SET_CURRENT}),t("Geolocation is not supported by this browser."))}),getGoogleLocation:async e=>{const{key:n,url:t}=h.get("google.maps"),i=encodeURI(e),a=`${t}?address=${i}&key=${n}`;return a?{latitude:0,location:"",longitude:0}:I(a).then(c=>{const{results:r}=c,A=r&&r.length?r[0]:{},{formatted_address:E,geometry:{location:{lat:R,lng:y}}}=A;return{latitude:R,location:E,longitude:y}})},getLocation:async(e,n=[])=>{try{const t={location:{type:"LocationInput!",value:d(e,p)}},i=(c={})=>{const{getLocation:r={}}=c;return o.dispatch({location:r,type:s.GET_ITEM_SUCCESS})},{location:a}=await g(o,"getLocation",m,t,["added","address","city","country","id","latitude","longitude","modified","state","street","zip",...n],{onSuccess:i});return a}catch(t){throw o.dispatch({error:t,type:s.GET_ITEM_ERROR}),t}},listByItem:async(e,n=[])=>{try{const t={itemId:{type:"ID!",value:e}},i=(c={})=>{const{locationsByItem:r=[]}=c;return o.dispatch({itemId:e,list:r,type:s.GET_LIST_SUCCESS})},{locationsByItem:a}=await g(o,"locationsByItem",m,t,["added","address","city","country","id","latitude","longitude","modified","state","street","zip",...n],{onSuccess:i});return a}catch(t){throw o.dispatch({error:t,type:s.GET_LIST_ERROR}),t}},update:async(e,n=[])=>{try{const t={location:{type:"LocationUpdateInput!",value:d(e,p)}},i=(c={})=>{const{updateLocation:r={}}=c;return o.dispatch({location:r,type:s.UPDATE_ITEM_SUCCESS})},{location:a}=await g(o,"updateLocation",m,t,["added","address","city","country","id","latitude","longitude","modified","state","street","zip",...n],{onSuccess:i});return a}catch(t){throw o.dispatch({error:t,type:s.UPDATE_ITEM_ERROR}),t}},updateLocationAdapter:e=>{l=e,d=O(l,p)},updateLocationAdapterOptions:e=>{p={...p,...e},d=O(l,p)}}};export{$ as createLocationActions};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/actions/locationActions/locationActions.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 {get as httpGet} from '@nlabs/rip-hunter';\n\nimport {validateLocationInput} from '../../adapters/locationAdapter/locationAdapter';\nimport {Config} from '../../config';\nimport {LOCATION_CONSTANTS} from '../../stores/locationStore';\nimport {appMutation} from '../../utils/api';\nimport {autoCompleteLocation} from '../../utils/location';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {User} from '../../adapters';\nimport type {LocationType} from '../../adapters/locationAdapter/locationAdapter';\nimport type {ApiResultsType, ReaktorDbCollection} from '../../utils/api';\n\nconst DATA_TYPE: ReaktorDbCollection = 'locations';\n\nexport interface LocationAdapterOptions {\n  strict?: boolean;\n  allowPartial?: boolean;\n  environment?: 'development' | 'production' | 'test';\n  customValidation?: (input: unknown) => unknown;\n}\n\nexport interface LocationActionsOptions {\n  locationAdapter?: (input: unknown, options?: LocationAdapterOptions) => any;\n  locationAdapterOptions?: LocationAdapterOptions;\n}\n\nexport type LocationApiResultsType = {\n  addLocation: LocationType;\n  deleteLocation: LocationType;\n  getLocation: LocationType;\n  getLocationsByItem: LocationType[];\n  updateLocation: LocationType;\n};\n\nexport interface LocationActions {\n  autocompleteLocation: (address: string, latitude?: number, longitude?: number, locationProps?: string[]) => Promise<LocationType[]>;\n  add: (location: Partial<LocationType>, locationProps?: string[]) => Promise<LocationType>;\n  delete: (locationId: string) => Promise<LocationType>;\n  getCurrentLocation: (setLocation?: (location: LocationType) => void) => Promise<LocationType>;\n  getGoogleLocation: (address: string) => Promise<{latitude: number; location: string; longitude: number}>;\n  getLocation: (location: Partial<LocationType>, locationProps?: string[]) => Promise<LocationType>;\n  listByItem: (itemId: string, locationProps?: string[]) => Promise<LocationType[]>;\n  update: (location: Partial<LocationType>, locationProps?: string[]) => Promise<LocationType>;\n  updateLocationAdapter: (adapter: (input: unknown, options?: LocationAdapterOptions) => any) => void;\n  updateLocationAdapterOptions: (options: LocationAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultLocationValidator = (input: unknown, options?: LocationAdapterOptions) => validateLocationInput(input);\n\n// Enhanced validation function that merges custom logic with defaults\nconst createLocationValidator = (\n  customAdapter?: (input: unknown, options?: LocationAdapterOptions) => any,\n  options?: LocationAdapterOptions\n) => (input: unknown, validatorOptions?: LocationAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  // Start with default validation\n  let validated = defaultLocationValidator(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 LocationType;\n  }\n\n  return validated;\n};\n\n/**\n * Factory function to create LocationActions 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 locationActions = createLocationActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customLocationAdapter = (input: unknown, options?: LocationAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.latitude && (input.latitude < -90 || input.latitude > 90)) {\n *     throw new Error('Invalid latitude');\n *   }\n *   return input;\n * };\n *\n * const locationActions = createLocationActions(flux, {\n *   locationAdapter: customLocationAdapter\n * });\n */\nexport const createLocationActions = (\n  flux: FluxFramework,\n  options?: LocationActionsOptions\n): LocationActions => {\n  // Initialize adapter state\n  let locationAdapterOptions: LocationAdapterOptions = options?.locationAdapterOptions || {};\n  let customLocationAdapter = options?.locationAdapter;\n\n  // Create validators that merge custom adapters with defaults\n  let validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);\n\n  // Update functions that recreate validators\n  const updateLocationAdapter = (adapter: (input: unknown, options?: LocationAdapterOptions) => any): void => {\n    customLocationAdapter = adapter;\n    validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);\n  };\n\n  const updateLocationAdapterOptions = (options: LocationAdapterOptions): void => {\n    locationAdapterOptions = {...locationAdapterOptions, ...options};\n    validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);\n  };\n\n  // Action implementations\n  const autocompleteLocation = async (\n    address: string,\n    latitude?: number,\n    longitude?: number,\n    locationProps: string[] = []\n  ): Promise<LocationType[]> => autoCompleteLocation(flux, address, latitude, longitude, locationProps);\n\n  const add = async (\n    location: Partial<LocationType>,\n    locationProps: string[] = []\n  ): Promise<LocationType> => {\n    try {\n      const queryVariables = {\n        location: {\n          type: 'LocationInput!',\n          value: validateLocation(location, locationAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const {addLocation = {}} = data;\n        return flux.dispatch({location: addLocation, type: LOCATION_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      const {location: addedLocation} = await appMutation(\n        flux,\n        'addLocation',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n      return addedLocation as LocationType;\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteLocation = async (locationId: string): Promise<LocationType> => {\n    try {\n      const queryVariables = {\n        locationId: {\n          type: 'ID!',\n          value: locationId\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const {deleteLocation: location = {}} = data;\n        return flux.dispatch({location, type: LOCATION_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      const {location: deletedLocation} = await appMutation(\n        flux,\n        'deleteLocation',\n        DATA_TYPE,\n        queryVariables,\n        ['id'],\n        {onSuccess}\n      );\n      return deletedLocation as LocationType;\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const getCurrentLocation = async (setLocation?: (location: LocationType) => void): Promise<LocationType> => new Promise((resolve, reject) => {\n    const {userId}: User = flux.getState('user.session', {});\n    const {city, country, latitude, longitude, state}: User = flux.getState(['user', 'users', userId || ''], {});\n    const locationStr: string = [city, state, country].join(', ');\n    const profileLocation = {\n      latitude,\n      location: locationStr,\n      longitude\n    } as LocationType;\n\n    if(navigator.geolocation) {\n      navigator.geolocation.getCurrentPosition(\n        async ({coords}) => {\n          const current = {\n            latitude: coords.latitude,\n            location: 'Current Location',\n            longitude: coords.longitude\n          } as LocationType;\n          await flux.dispatch({current, type: LOCATION_CONSTANTS.SET_CURRENT});\n          if(setLocation) {\n            setLocation(current);\n          }\n          resolve(current);\n        },\n        (locationError) => {\n          console.log('getCurrentLocation::locationError', locationError);\n          console.log('getCurrentLocation::profileLocation1', profileLocation);\n          if(setLocation) {\n            setLocation(profileLocation);\n          }\n\n          flux.dispatch({current: profileLocation, type: LOCATION_CONSTANTS.SET_CURRENT});\n          reject(locationError);\n        },\n        {enableHighAccuracy: false, maximumAge: 0, timeout: 30000}\n      );\n    } else {\n      console.log('getCurrentLocation::profileLocation2', profileLocation);\n      if(setLocation) {\n        setLocation(profileLocation);\n      }\n\n      flux.dispatch({current: profileLocation, type: LOCATION_CONSTANTS.SET_CURRENT});\n      reject('Geolocation is not supported by this browser.');\n    }\n  });\n\n  const getGoogleLocation = async (address: string): Promise<{latitude: number; location: string; longitude: number}> => {\n    const {key: googleKey, url: googleUrl} = Config.get('google.maps') as {key: string; url: string};\n    const formatAddress: string = encodeURI(address);\n    const url: string = `${googleUrl}?address=${formatAddress}&key=${googleKey}`;\n\n    if(url) {\n      return {latitude: 0, location: '', longitude: 0};\n    }\n    return httpGet(url).then((data) => {\n      const {results} = data;\n      const locationData = results && results.length ? results[0] : {};\n      const {\n        formatted_address: location,\n        geometry: {\n          location: {lat: latitude, lng: longitude}\n        }\n      } = locationData;\n      return {latitude, location, longitude};\n    });\n  };\n\n  const getLocation = async (\n    location: Partial<LocationType>,\n    locationProps: string[] = []\n  ): Promise<LocationType> => {\n    try {\n      const queryVariables = {\n        location: {\n          type: 'LocationInput!',\n          value: validateLocation(location, locationAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const {getLocation = {}} = data;\n        return flux.dispatch({location: getLocation, type: LOCATION_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const {location: locationResult} = await appMutation(\n        flux,\n        'getLocation',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n      return locationResult as LocationType;\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const listByItem = async (\n    itemId: string,\n    locationProps: string[] = []\n  ): Promise<LocationType[]> => {\n    try {\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: itemId\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const {locationsByItem = []} = data as {locationsByItem: LocationType[]};\n        return flux.dispatch({\n          itemId,\n          list: locationsByItem,\n          type: LOCATION_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const {locationsByItem} = await appMutation(\n        flux,\n        'locationsByItem',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n      return locationsByItem as LocationType[];\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const update = async (\n    location: Partial<LocationType>,\n    locationProps: string[] = []\n  ): Promise<LocationType> => {\n    try {\n      const queryVariables = {\n        location: {\n          type: 'LocationUpdateInput!',\n          value: validateLocation(location, locationAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const {updateLocation = {}} = data;\n        return flux.dispatch({location: updateLocation, type: LOCATION_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      const {location: updatedLocation} = await appMutation(\n        flux,\n        'updateLocation',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n      return updatedLocation as LocationType;\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  // Return the actions object\n  return {\n    autocompleteLocation,\n    add,\n    delete: deleteLocation,\n    getCurrentLocation,\n    getGoogleLocation,\n    getLocation,\n    listByItem,\n    update,\n    updateLocationAdapter,\n    updateLocationAdapterOptions\n  };\n};\n\n"],
  "mappings": "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",
  "names": ["httpGet", "validateLocationInput", "Config", "LOCATION_CONSTANTS", "appMutation", "autoCompleteLocation", "DATA_TYPE", "defaultLocationValidator", "input", "options", "createLocationValidator", "customAdapter", "validatorOptions", "mergedOptions", "validated", "createLocationActions", "flux", "locationAdapterOptions", "customLocationAdapter", "validateLocation", "address", "latitude", "longitude", "locationProps", "location", "queryVariables", "onSuccess", "data", "addLocation", "addedLocation", "error", "locationId", "deletedLocation", "setLocation", "resolve", "reject", "userId", "city", "country", "state", "locationStr", "profileLocation", "coords", "current", "locationError", "googleKey", "googleUrl", "formatAddress", "url", "results", "locationData", "getLocation", "locationResult", "itemId", "locationsByItem", "updateLocation", "updatedLocation", "adapter"]
}

+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { validateLocationInput } from '../../adapters/locationAdapter/locationAdapter.js';
+import { LOCATION_CONSTANTS } from '../../stores/locationStore.js';
+import { appMutation } from '../../utils/api.js';
+import { autoCompleteLocation } from '../../utils/location.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'locations';
+// Default validation function
+const defaultLocationValidator = (input, options)=>validateLocationInput(input);
+// Enhanced validation function that merges custom logic with defaults
+const createLocationValidator = (customAdapter, options)=>(input, validatorOptions)=>{
+        const mergedOptions = {
+            ...options,
+            ...validatorOptions
+        };
+        // Start with default validation
+        let validated = defaultLocationValidator(input, mergedOptions);
+        // Apply custom validation if provided
+        if (customAdapter) {
+            validated = customAdapter(validated, mergedOptions);
+        }
+        // Apply custom validation from options if provided
+        if (mergedOptions?.customValidation) {
+            validated = mergedOptions.customValidation(validated);
+        }
+        return validated;
+    };
+/**
+ * Factory function to create LocationActions with enhanced adapter injection capabilities.
+ * Custom adapters are merged with default behavior, allowing partial overrides.
+ *
+ * @example
+ * // Basic usage with default adapters
+ * const locationActions = createLocationActions(flux);
+ *
+ * @example
+ * // Custom adapter that extends default behavior
+ * const customLocationAdapter = (input: unknown, options?: LocationAdapterOptions) => {
+ *   // input is already validated by default adapter
+ *   if (input.latitude && (input.latitude < -90 || input.latitude > 90)) {
+ *     throw new Error('Invalid latitude');
+ *   }
+ *   return input;
+ * };
+ *
+ * const locationActions = createLocationActions(flux, {
+ *   locationAdapter: customLocationAdapter
+ * });
+ */ export const createLocationActions = (flux, options)=>{
+    // Initialize adapter state
+    let locationAdapterOptions = options?.locationAdapterOptions || {};
+    let customLocationAdapter = options?.locationAdapter;
+    // Create validators that merge custom adapters with defaults
+    let validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);
+    // Update functions that recreate validators
+    const updateLocationAdapter = (adapter)=>{
+        customLocationAdapter = adapter;
+        validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);
+    };
+    const updateLocationAdapterOptions = (options)=>{
+        locationAdapterOptions = {
+            ...locationAdapterOptions,
+            ...options
+        };
+        validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);
+    };
+    // Action implementations
+    const autocompleteLocation = async (address, latitude, longitude, locationProps = [], requestOptions = {})=>{
+        const cachedResult = getCachedRequest(flux, 'location.autocompleteLocation', {
+            address,
+            latitude,
+            locationProps,
+            longitude
+        }, requestOptions);
+        if (cachedResult) {
+            return cachedResult;
+        }
+        const result = await autoCompleteLocation(flux, address, latitude, longitude, locationProps);
+        return await setCachedRequest(flux, 'location.autocompleteLocation', {
+            address,
+            latitude,
+            locationProps,
+            longitude
+        }, result, requestOptions);
+    };
+    const add = async (location, locationProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                location: {
+                    type: 'LocationInput!',
+                    value: validateLocation(location, locationAdapterOptions)
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const addLocation = data?.addLocation || {};
+                return flux.dispatch({
+                    location: addLocation,
+                    type: LOCATION_CONSTANTS.ADD_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'addLocation', DATA_TYPE, queryVariables, [
+                'added',
+                'address',
+                'city',
+                'country',
+                'id',
+                'latitude',
+                'longitude',
+                'modified',
+                'state',
+                'street',
+                'zip',
+                ...locationProps
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: LOCATION_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'location.autocompleteLocation');
+        }
+    };
+    const deleteLocation = async (locationId, requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                locationId: {
+                    type: 'ID!',
+                    value: locationId
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const location = data?.deleteLocation || {};
+                return flux.dispatch({
+                    location,
+                    type: LOCATION_CONSTANTS.REMOVE_ITEM_SUCCESS
+                });
+            };
+            return await appMutation(flux, 'deleteLocation', DATA_TYPE, queryVariables, [
+                'id'
+            ], {
+                onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: LOCATION_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `location.listByItem:${locationId}`);
+        }
+    };
+    const getCurrentLocation = async (setLocation, requestOptions = {})=>new Promise((resolve, reject)=>{
+            const { userId } = flux.getState('user.session', {});
+            const { city, country, latitude, longitude, state } = flux.getState([
+                'user',
+                'users',
+                userId || ''
+            ], {});
+            const locationStr = [
+                city,
+                state,
+                country
+            ].join(', ');
+            const personaLocation = {
+                latitude,
+                location: locationStr,
+                longitude
+            };
+            if (navigator.geolocation) {
+                navigator.geolocation.getCurrentPosition(async ({ coords })=>{
+                    const current = {
+                        latitude: coords.latitude,
+                        location: 'Current Location',
+                        longitude: coords.longitude
+                    };
+                    await flux.dispatch({
+                        current,
+                        type: LOCATION_CONSTANTS.SET_CURRENT
+                    });
+                    if (setLocation) {
+                        setLocation(current);
+                    }
+                    resolve(current);
+                }, (locationError)=>{
+                    console.log('getCurrentLocation::locationError', locationError);
+                    console.log('getCurrentLocation::personaLocation1', personaLocation);
+                    if (setLocation) {
+                        setLocation(personaLocation);
+                    }
+                    flux.dispatch({
+                        current: personaLocation,
+                        type: LOCATION_CONSTANTS.SET_CURRENT
+                    });
+                    reject(locationError);
+                }, {
+                    enableHighAccuracy: false,
+                    maximumAge: 0,
+                    timeout: 30000
+                });
+            } else {
+                console.log('getCurrentLocation::personaLocation2', personaLocation);
+                if (setLocation) {
+                    setLocation(personaLocation);
+                }
+                flux.dispatch({
+                    current: personaLocation,
+                    type: LOCATION_CONSTANTS.SET_CURRENT
+                });
+                reject('Geolocation is not supported by this browser.');
+            }
+        });
+    const getGoogleLocation = async (address, requestOptions = {})=>{
+        const locations = await autocompleteLocation(address, undefined, undefined, [], requestOptions);
+        const [firstLocation = {}] = locations;
+        return {
+            latitude: firstLocation.latitude || 0,
+            location: firstLocation.location || '',
+            longitude: firstLocation.longitude || 0
+        };
+    };
+    const getLocation = async (location, locationProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'location.getLocation', {
+                location,
+                locationProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                location: {
+                    type: 'LocationInput!',
+                    value: validateLocation(location, locationAdapterOptions)
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const getLocation = data?.getLocation || {};
+                return flux.dispatch({
+                    location: getLocation,
+                    type: LOCATION_CONSTANTS.GET_ITEM_SUCCESS
+                });
+            };
+            const result = await appMutation(flux, 'getLocation', DATA_TYPE, queryVariables, [
+                'added',
+                'address',
+                'city',
+                'country',
+                'id',
+                'latitude',
+                'longitude',
+                'modified',
+                'state',
+                'street',
+                'zip',
+                ...locationProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, 'location.getLocation', {
+                location,
+                locationProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: LOCATION_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByItem = async (itemId, locationProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `location.listByItem:${itemId}`, {
+                itemId,
+                locationProps
+            }, requestOptions);
+            if (cachedResult) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                itemId: {
+                    type: 'ID!',
+                    value: itemId
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const locationsByItem = Array.isArray(data?.locationsByItem) ? data.locationsByItem || [] : [];
+                return flux.dispatch({
+                    itemId,
+                    list: locationsByItem,
+                    type: LOCATION_CONSTANTS.GET_LIST_SUCCESS
+                });
+            };
+            const result = await appMutation(flux, 'locationsByItem', DATA_TYPE, queryVariables, [
+                'added',
+                'address',
+                'city',
+                'country',
+                'id',
+                'latitude',
+                'longitude',
+                'modified',
+                'state',
+                'street',
+                'zip',
+                ...locationProps
+            ], {
+                onSuccess
+            });
+            return await setCachedRequest(flux, `location.listByItem:${itemId}`, {
+                itemId,
+                locationProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: LOCATION_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const update = async (location, locationProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                location: {
+                    type: 'LocationUpdateInput!',
+                    value: validateLocation(location, locationAdapterOptions)
+                }
+            };
+            const onSuccess = (data = {})=>{
+                const updateLocation = data?.updateLocation || {};
+                return flux.dispatch({
+                    location: updateLocation,
+                    type: LOCATION_CONSTANTS.UPDATE_ITEM_SUCCESS
+                });
+            };
+            const result = await appMutation(flux, 'updateLocation', DATA_TYPE, queryVariables, [
+                'added',
+                'address',
+                'city',
+                'country',
+                'id',
+                'latitude',
+                'longitude',
+                'modified',
+                'state',
+                'street',
+                'zip',
+                ...locationProps
+            ], {
+                onSuccess
+            });
+            return result;
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: LOCATION_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'location.getLocation');
+            await clearCachedRequest(flux, 'location.autocompleteLocation');
+            await clearCachedRequest(flux, `location.listByItem:${String(location?.itemId || '')}`);
+        }
+    };
+    // Return the actions object
+    return {
+        autocompleteLocation,
+        add,
+        delete: deleteLocation,
+        getCurrentLocation,
+        getGoogleLocation,
+        getLocation,
+        listByItem,
+        update,
+        updateLocationAdapter,
+        updateLocationAdapterOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/locationActions/locationActions.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 { validateLocationInput } from '../../adapters/locationAdapter/locationAdapter.js';\nimport { LOCATION_CONSTANTS } from '../../stores/locationStore.js';\nimport { appMutation } from '../../utils/api.js';\nimport { autoCompleteLocation } from '../../utils/location.js';\nimport { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';\n\nimport type { FluxFramework } from '@nlabs/arkhamjs';\nimport type { User } from '../../adapters/index.js';\nimport type { LocationType } from '../../adapters/locationAdapter/locationAdapter.js';\nimport type { ApiResultsType } from '../../utils/api.js';\nimport type { ActionRequestOptions } from '../../utils/requestCache.js';\n\nconst DATA_TYPE = 'locations';\n\nexport interface LocationAdapterOptions {\n  strict?: boolean;\n  allowPartial?: boolean;\n  environment?: 'development' | 'production' | 'test';\n  customValidation?: (input: unknown) => unknown;\n}\n\nexport interface LocationActionsOptions {\n  locationAdapter?: (input: unknown, options?: LocationAdapterOptions) => any;\n  locationAdapterOptions?: LocationAdapterOptions;\n}\n\nexport type LocationApiResultsType = {\n  addLocation: LocationType;\n  deleteLocation: LocationType;\n  getLocation: LocationType;\n  getLocationsByItem: LocationType[];\n  updateLocation: LocationType;\n};\n\nexport interface LocationActions {\n  autocompleteLocation: (address: string, latitude?: number, longitude?: number, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType[]>;\n  add: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;\n  delete: (locationId: string, requestOptions?: ActionRequestOptions) => Promise<LocationType>;\n  getCurrentLocation: (setLocation?: (location: LocationType) => void, requestOptions?: ActionRequestOptions) => Promise<LocationType>;\n  getGoogleLocation: (address: string, requestOptions?: ActionRequestOptions) => Promise<{latitude: number; location: string; longitude: number}>;\n  getLocation: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;\n  listByItem: (itemId: string, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType[]>;\n  update: (location: Partial<LocationType>, locationProps?: string[], requestOptions?: ActionRequestOptions) => Promise<LocationType>;\n  updateLocationAdapter: (adapter: (input: unknown, options?: LocationAdapterOptions) => any) => void;\n  updateLocationAdapterOptions: (options: LocationAdapterOptions) => void;\n}\n\n// Default validation function\nconst defaultLocationValidator = (input: unknown, options?: LocationAdapterOptions) => validateLocationInput(input);\n\n// Enhanced validation function that merges custom logic with defaults\nconst createLocationValidator = (\n  customAdapter?: (input: unknown, options?: LocationAdapterOptions) => any,\n  options?: LocationAdapterOptions\n) => (input: unknown, validatorOptions?: LocationAdapterOptions) => {\n  const mergedOptions = {...options, ...validatorOptions};\n\n  // Start with default validation\n  let validated = defaultLocationValidator(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 LocationType;\n  }\n\n  return validated;\n};\n\n/**\n * Factory function to create LocationActions 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 locationActions = createLocationActions(flux);\n *\n * @example\n * // Custom adapter that extends default behavior\n * const customLocationAdapter = (input: unknown, options?: LocationAdapterOptions) => {\n *   // input is already validated by default adapter\n *   if (input.latitude && (input.latitude < -90 || input.latitude > 90)) {\n *     throw new Error('Invalid latitude');\n *   }\n *   return input;\n * };\n *\n * const locationActions = createLocationActions(flux, {\n *   locationAdapter: customLocationAdapter\n * });\n */\nexport const createLocationActions = (\n  flux: FluxFramework,\n  options?: LocationActionsOptions\n): LocationActions => {\n  // Initialize adapter state\n  let locationAdapterOptions = options?.locationAdapterOptions || {};\n  let customLocationAdapter = options?.locationAdapter;\n\n  // Create validators that merge custom adapters with defaults\n  let validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);\n\n  // Update functions that recreate validators\n  const updateLocationAdapter = (adapter: (input: unknown, options?: LocationAdapterOptions) => any): void => {\n    customLocationAdapter = adapter;\n    validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);\n  };\n\n  const updateLocationAdapterOptions = (options: LocationAdapterOptions): void => {\n    locationAdapterOptions = {...locationAdapterOptions, ...options};\n    validateLocation = createLocationValidator(customLocationAdapter, locationAdapterOptions);\n  };\n\n  // Action implementations\n  const autocompleteLocation = async (\n    address: string,\n    latitude?: number,\n    longitude?: number,\n    locationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType[]> => {\n    const cachedResult = getCachedRequest<LocationType[]>(\n      flux,\n      'location.autocompleteLocation',\n      {address, latitude, locationProps, longitude},\n      requestOptions\n    );\n\n    if(cachedResult) {\n      return cachedResult;\n    }\n\n    const result = await autoCompleteLocation(flux, address, latitude, longitude, locationProps);\n    return await setCachedRequest(flux, 'location.autocompleteLocation', {address, latitude, locationProps, longitude}, result, requestOptions);\n  };\n\n  const add = async (\n    location: Partial<LocationType>,\n    locationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType> => {\n    try {\n      const queryVariables = {\n        location: {\n          type: 'LocationInput!',\n          value: validateLocation(location, locationAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const addLocation = data?.addLocation || {};\n        return flux.dispatch({location: addLocation, type: LOCATION_CONSTANTS.ADD_ITEM_SUCCESS});\n      };\n\n      return await appMutation<LocationType>(\n        flux,\n        'addLocation',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'location.autocompleteLocation');\n    }\n  };\n\n  const deleteLocation = async (locationId: string, requestOptions: ActionRequestOptions = {}): Promise<LocationType> => {\n    try {\n      const queryVariables = {\n        locationId: {\n          type: 'ID!',\n          value: locationId\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const location = data?.deleteLocation || {};\n        return flux.dispatch({location, type: LOCATION_CONSTANTS.REMOVE_ITEM_SUCCESS});\n      };\n\n      return await appMutation<LocationType>(\n        flux,\n        'deleteLocation',\n        DATA_TYPE,\n        queryVariables,\n        ['id'],\n        {onSuccess}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `location.listByItem:${locationId}`);\n    }\n  };\n\n  const getCurrentLocation = async (\n    setLocation?: (location: LocationType) => void,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType> => new Promise((resolve, reject) => {\n    const {userId}: User = flux.getState('user.session', {});\n    const {city, country, latitude, longitude, state}: User = flux.getState(['user', 'users', userId || ''], {});\n    const locationStr = [city, state, country].join(', ');\n    const personaLocation = {\n      latitude,\n      location: locationStr,\n      longitude\n    } as LocationType;\n\n    if(navigator.geolocation) {\n      navigator.geolocation.getCurrentPosition(\n        async ({coords}) => {\n          const current = {\n            latitude: coords.latitude,\n            location: 'Current Location',\n            longitude: coords.longitude\n          } as LocationType;\n          await flux.dispatch({current, type: LOCATION_CONSTANTS.SET_CURRENT});\n          if(setLocation) {\n            setLocation(current);\n          }\n          resolve(current);\n        },\n        (locationError) => {\n          console.log('getCurrentLocation::locationError', locationError);\n          console.log('getCurrentLocation::personaLocation1', personaLocation);\n          if(setLocation) {\n            setLocation(personaLocation);\n          }\n\n          flux.dispatch({current: personaLocation, type: LOCATION_CONSTANTS.SET_CURRENT});\n          reject(locationError);\n        },\n        {enableHighAccuracy: false, maximumAge: 0, timeout: 30000}\n      );\n    } else {\n      console.log('getCurrentLocation::personaLocation2', personaLocation);\n      if(setLocation) {\n        setLocation(personaLocation);\n      }\n\n      flux.dispatch({current: personaLocation, type: LOCATION_CONSTANTS.SET_CURRENT});\n      reject('Geolocation is not supported by this browser.');\n    }\n  });\n\n  const getGoogleLocation = async (\n    address: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<{latitude: number; location: string; longitude: number}> => {\n    const locations = await autocompleteLocation(address, undefined, undefined, [], requestOptions);\n    const [firstLocation = {} as LocationType] = locations;\n\n    return {\n      latitude: firstLocation.latitude || 0,\n      location: firstLocation.location || '',\n      longitude: firstLocation.longitude || 0\n    };\n  };\n\n  const getLocation = async (\n    location: Partial<LocationType>,\n    locationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType> => {\n    try {\n      const cachedResult = getCachedRequest<LocationType>(flux, 'location.getLocation', {location, locationProps}, requestOptions);\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        location: {\n          type: 'LocationInput!',\n          value: validateLocation(location, locationAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const getLocation = data?.getLocation || {};\n        return flux.dispatch({location: getLocation, type: LOCATION_CONSTANTS.GET_ITEM_SUCCESS});\n      };\n\n      const result = await appMutation<LocationType>(\n        flux,\n        'getLocation',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, 'location.getLocation', {location, locationProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const listByItem = async (\n    itemId: string,\n    locationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType[]> => {\n    try {\n      const cachedResult = getCachedRequest<LocationType[]>(\n        flux,\n        `location.listByItem:${itemId}`,\n        {itemId, locationProps},\n        requestOptions\n      );\n\n      if(cachedResult) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        itemId: {\n          type: 'ID!',\n          value: itemId\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const locationsByItem = Array.isArray((data as {locationsByItem?: LocationType[]})?.locationsByItem)\n          ? (data as {locationsByItem?: LocationType[]}).locationsByItem || []\n          : [];\n        return flux.dispatch({\n          itemId,\n          list: locationsByItem,\n          type: LOCATION_CONSTANTS.GET_LIST_SUCCESS\n        });\n      };\n\n      const result = await appMutation<LocationType[]>(\n        flux,\n        'locationsByItem',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n\n      return await setCachedRequest(flux, `location.listByItem:${itemId}`, {itemId, locationProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const update = async (\n    location: Partial<LocationType>,\n    locationProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<LocationType> => {\n    try {\n      const queryVariables = {\n        location: {\n          type: 'LocationUpdateInput!',\n          value: validateLocation(location, locationAdapterOptions)\n        }\n      };\n\n      const onSuccess = (data: ApiResultsType = {}) => {\n        const updateLocation = data?.updateLocation || {};\n        return flux.dispatch({location: updateLocation, type: LOCATION_CONSTANTS.UPDATE_ITEM_SUCCESS});\n      };\n\n      const result = await appMutation<LocationType>(\n        flux,\n        'updateLocation',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'added',\n          'address',\n          'city',\n          'country',\n          'id',\n          'latitude',\n          'longitude',\n          'modified',\n          'state',\n          'street',\n          'zip',\n          ...locationProps\n        ],\n        {onSuccess}\n      );\n\n      return result;\n    } catch(error) {\n      flux.dispatch({error, type: LOCATION_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'location.getLocation');\n      await clearCachedRequest(flux, 'location.autocompleteLocation');\n      await clearCachedRequest(flux, `location.listByItem:${String(location?.itemId || '')}`);\n    }\n  };\n\n  // Return the actions object\n  return {\n    autocompleteLocation,\n    add,\n    delete: deleteLocation,\n    getCurrentLocation,\n    getGoogleLocation,\n    getLocation,\n    listByItem,\n    update,\n    updateLocationAdapter,\n    updateLocationAdapterOptions\n  };\n};\n"],"names":["validateLocationInput","LOCATION_CONSTANTS","appMutation","autoCompleteLocation","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultLocationValidator","input","options","createLocationValidator","customAdapter","validatorOptions","mergedOptions","validated","customValidation","createLocationActions","flux","locationAdapterOptions","customLocationAdapter","locationAdapter","validateLocation","updateLocationAdapter","adapter","updateLocationAdapterOptions","autocompleteLocation","address","latitude","longitude","locationProps","requestOptions","cachedResult","result","add","location","queryVariables","type","value","onSuccess","data","addLocation","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","deleteLocation","locationId","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","getCurrentLocation","setLocation","Promise","resolve","reject","userId","getState","city","country","state","locationStr","join","personaLocation","navigator","geolocation","getCurrentPosition","coords","current","SET_CURRENT","locationError","console","log","enableHighAccuracy","maximumAge","timeout","getGoogleLocation","locations","undefined","firstLocation","getLocation","GET_ITEM_SUCCESS","GET_ITEM_ERROR","listByItem","itemId","locationsByItem","Array","isArray","list","GET_LIST_SUCCESS","GET_LIST_ERROR","update","updateLocation","UPDATE_ITEM_SUCCESS","UPDATE_ITEM_ERROR","String","delete"],"mappings":"AAAA;;;CAGC,GACD,SAASA,qBAAqB,QAAQ,oDAAoD;AAC1F,SAASC,kBAAkB,QAAQ,gCAAgC;AACnE,SAASC,WAAW,QAAQ,qBAAqB;AACjD,SAASC,oBAAoB,QAAQ,0BAA0B;AAC/D,SAASC,kBAAkB,EAAEC,gBAAgB,EAAEC,gBAAgB,QAAQ,8BAA8B;AAQrG,MAAMC,YAAY;AAmClB,8BAA8B;AAC9B,MAAMC,2BAA2B,CAACC,OAAgBC,UAAqCV,sBAAsBS;AAE7G,sEAAsE;AACtE,MAAME,0BAA0B,CAC9BC,eACAF,UACG,CAACD,OAAgBI;QACpB,MAAMC,gBAAgB;YAAC,GAAGJ,OAAO;YAAE,GAAGG,gBAAgB;QAAA;QAEtD,gCAAgC;QAChC,IAAIE,YAAYP,yBAAyBC,OAAOK;QAEhD,sCAAsC;QACtC,IAAGF,eAAe;YAChBG,YAAYH,cAAcG,WAAWD;QACvC;QAEA,mDAAmD;QACnD,IAAGA,eAAeE,kBAAkB;YAClCD,YAAYD,cAAcE,gBAAgB,CAACD;QAC7C;QAEA,OAAOA;IACT;AAEA;;;;;;;;;;;;;;;;;;;;;CAqBC,GACD,OAAO,MAAME,wBAAwB,CACnCC,MACAR;IAEA,2BAA2B;IAC3B,IAAIS,yBAAyBT,SAASS,0BAA0B,CAAC;IACjE,IAAIC,wBAAwBV,SAASW;IAErC,6DAA6D;IAC7D,IAAIC,mBAAmBX,wBAAwBS,uBAAuBD;IAEtE,4CAA4C;IAC5C,MAAMI,wBAAwB,CAACC;QAC7BJ,wBAAwBI;QACxBF,mBAAmBX,wBAAwBS,uBAAuBD;IACpE;IAEA,MAAMM,+BAA+B,CAACf;QACpCS,yBAAyB;YAAC,GAAGA,sBAAsB;YAAE,GAAGT,OAAO;QAAA;QAC/DY,mBAAmBX,wBAAwBS,uBAAuBD;IACpE;IAEA,yBAAyB;IACzB,MAAMO,uBAAuB,OAC3BC,SACAC,UACAC,WACAC,gBAA0B,EAAE,EAC5BC,iBAAuC,CAAC,CAAC;QAEzC,MAAMC,eAAe3B,iBACnBa,MACA,iCACA;YAACS;YAASC;YAAUE;YAAeD;QAAS,GAC5CE;QAGF,IAAGC,cAAc;YACf,OAAOA;QACT;QAEA,MAAMC,SAAS,MAAM9B,qBAAqBe,MAAMS,SAASC,UAAUC,WAAWC;QAC9E,OAAO,MAAMxB,iBAAiBY,MAAM,iCAAiC;YAACS;YAASC;YAAUE;YAAeD;QAAS,GAAGI,QAAQF;IAC9H;IAEA,MAAMG,MAAM,OACVC,UACAL,gBAA0B,EAAE,EAC5BC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMK,iBAAiB;gBACrBD,UAAU;oBACRE,MAAM;oBACNC,OAAOhB,iBAAiBa,UAAUhB;gBACpC;YACF;YAEA,MAAMoB,YAAY,CAACC,OAAuB,CAAC,CAAC;gBAC1C,MAAMC,cAAcD,MAAMC,eAAe,CAAC;gBAC1C,OAAOvB,KAAKwB,QAAQ,CAAC;oBAACP,UAAUM;oBAAaJ,MAAMpC,mBAAmB0C,gBAAgB;gBAAA;YACxF;YAEA,OAAO,MAAMzC,YACXgB,MACA,eACAX,WACA6B,gBACA;gBACE;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;mBACGN;aACJ,EACD;gBAACS;YAAS;QAEd,EAAE,OAAMK,OAAO;YACb1B,KAAKwB,QAAQ,CAAC;gBAACE;gBAAOP,MAAMpC,mBAAmB4C,cAAc;YAAA;YAC7D,MAAMD;QACR,SAAU;YACR,MAAMxC,mBAAmBc,MAAM;QACjC;IACF;IAEA,MAAM4B,iBAAiB,OAAOC,YAAoBhB,iBAAuC,CAAC,CAAC;QACzF,IAAI;YACF,MAAMK,iBAAiB;gBACrBW,YAAY;oBACVV,MAAM;oBACNC,OAAOS;gBACT;YACF;YAEA,MAAMR,YAAY,CAACC,OAAuB,CAAC,CAAC;gBAC1C,MAAML,WAAWK,MAAMM,kBAAkB,CAAC;gBAC1C,OAAO5B,KAAKwB,QAAQ,CAAC;oBAACP;oBAAUE,MAAMpC,mBAAmB+C,mBAAmB;gBAAA;YAC9E;YAEA,OAAO,MAAM9C,YACXgB,MACA,kBACAX,WACA6B,gBACA;gBAAC;aAAK,EACN;gBAACG;YAAS;QAEd,EAAE,OAAMK,OAAO;YACb1B,KAAKwB,QAAQ,CAAC;gBAACE;gBAAOP,MAAMpC,mBAAmBgD,iBAAiB;YAAA;YAChE,MAAML;QACR,SAAU;YACR,MAAMxC,mBAAmBc,MAAM,CAAC,oBAAoB,EAAE6B,YAAY;QACpE;IACF;IAEA,MAAMG,qBAAqB,OACzBC,aACApB,iBAAuC,CAAC,CAAC,GACf,IAAIqB,QAAQ,CAACC,SAASC;YAChD,MAAM,EAACC,MAAM,EAAC,GAASrC,KAAKsC,QAAQ,CAAC,gBAAgB,CAAC;YACtD,MAAM,EAACC,IAAI,EAAEC,OAAO,EAAE9B,QAAQ,EAAEC,SAAS,EAAE8B,KAAK,EAAC,GAASzC,KAAKsC,QAAQ,CAAC;gBAAC;gBAAQ;gBAASD,UAAU;aAAG,EAAE,CAAC;YAC1G,MAAMK,cAAc;gBAACH;gBAAME;gBAAOD;aAAQ,CAACG,IAAI,CAAC;YAChD,MAAMC,kBAAkB;gBACtBlC;gBACAO,UAAUyB;gBACV/B;YACF;YAEA,IAAGkC,UAAUC,WAAW,EAAE;gBACxBD,UAAUC,WAAW,CAACC,kBAAkB,CACtC,OAAO,EAACC,MAAM,EAAC;oBACb,MAAMC,UAAU;wBACdvC,UAAUsC,OAAOtC,QAAQ;wBACzBO,UAAU;wBACVN,WAAWqC,OAAOrC,SAAS;oBAC7B;oBACA,MAAMX,KAAKwB,QAAQ,CAAC;wBAACyB;wBAAS9B,MAAMpC,mBAAmBmE,WAAW;oBAAA;oBAClE,IAAGjB,aAAa;wBACdA,YAAYgB;oBACd;oBACAd,QAAQc;gBACV,GACA,CAACE;oBACCC,QAAQC,GAAG,CAAC,qCAAqCF;oBACjDC,QAAQC,GAAG,CAAC,wCAAwCT;oBACpD,IAAGX,aAAa;wBACdA,YAAYW;oBACd;oBAEA5C,KAAKwB,QAAQ,CAAC;wBAACyB,SAASL;wBAAiBzB,MAAMpC,mBAAmBmE,WAAW;oBAAA;oBAC7Ed,OAAOe;gBACT,GACA;oBAACG,oBAAoB;oBAAOC,YAAY;oBAAGC,SAAS;gBAAK;YAE7D,OAAO;gBACLJ,QAAQC,GAAG,CAAC,wCAAwCT;gBACpD,IAAGX,aAAa;oBACdA,YAAYW;gBACd;gBAEA5C,KAAKwB,QAAQ,CAAC;oBAACyB,SAASL;oBAAiBzB,MAAMpC,mBAAmBmE,WAAW;gBAAA;gBAC7Ed,OAAO;YACT;QACF;IAEA,MAAMqB,oBAAoB,OACxBhD,SACAI,iBAAuC,CAAC,CAAC;QAEzC,MAAM6C,YAAY,MAAMlD,qBAAqBC,SAASkD,WAAWA,WAAW,EAAE,EAAE9C;QAChF,MAAM,CAAC+C,gBAAgB,CAAC,CAAiB,CAAC,GAAGF;QAE7C,OAAO;YACLhD,UAAUkD,cAAclD,QAAQ,IAAI;YACpCO,UAAU2C,cAAc3C,QAAQ,IAAI;YACpCN,WAAWiD,cAAcjD,SAAS,IAAI;QACxC;IACF;IAEA,MAAMkD,cAAc,OAClB5C,UACAL,gBAA0B,EAAE,EAC5BC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMC,eAAe3B,iBAA+Ba,MAAM,wBAAwB;gBAACiB;gBAAUL;YAAa,GAAGC;YAE7G,IAAGC,cAAc;gBACf,OAAOA;YACT;YAEA,MAAMI,iBAAiB;gBACrBD,UAAU;oBACRE,MAAM;oBACNC,OAAOhB,iBAAiBa,UAAUhB;gBACpC;YACF;YAEA,MAAMoB,YAAY,CAACC,OAAuB,CAAC,CAAC;gBAC1C,MAAMuC,cAAcvC,MAAMuC,eAAe,CAAC;gBAC1C,OAAO7D,KAAKwB,QAAQ,CAAC;oBAACP,UAAU4C;oBAAa1C,MAAMpC,mBAAmB+E,gBAAgB;gBAAA;YACxF;YAEA,MAAM/C,SAAS,MAAM/B,YACnBgB,MACA,eACAX,WACA6B,gBACA;gBACE;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;mBACGN;aACJ,EACD;gBAACS;YAAS;YAGZ,OAAO,MAAMjC,iBAAiBY,MAAM,wBAAwB;gBAACiB;gBAAUL;YAAa,GAAGG,QAAQF;QACjG,EAAE,OAAMa,OAAO;YACb1B,KAAKwB,QAAQ,CAAC;gBAACE;gBAAOP,MAAMpC,mBAAmBgF,cAAc;YAAA;YAC7D,MAAMrC;QACR;IACF;IAEA,MAAMsC,aAAa,OACjBC,QACArD,gBAA0B,EAAE,EAC5BC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMC,eAAe3B,iBACnBa,MACA,CAAC,oBAAoB,EAAEiE,QAAQ,EAC/B;gBAACA;gBAAQrD;YAAa,GACtBC;YAGF,IAAGC,cAAc;gBACf,OAAOA;YACT;YAEA,MAAMI,iBAAiB;gBACrB+C,QAAQ;oBACN9C,MAAM;oBACNC,OAAO6C;gBACT;YACF;YAEA,MAAM5C,YAAY,CAACC,OAAuB,CAAC,CAAC;gBAC1C,MAAM4C,kBAAkBC,MAAMC,OAAO,CAAE9C,MAA6C4C,mBAChF,AAAC5C,KAA4C4C,eAAe,IAAI,EAAE,GAClE,EAAE;gBACN,OAAOlE,KAAKwB,QAAQ,CAAC;oBACnByC;oBACAI,MAAMH;oBACN/C,MAAMpC,mBAAmBuF,gBAAgB;gBAC3C;YACF;YAEA,MAAMvD,SAAS,MAAM/B,YACnBgB,MACA,mBACAX,WACA6B,gBACA;gBACE;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;mBACGN;aACJ,EACD;gBAACS;YAAS;YAGZ,OAAO,MAAMjC,iBAAiBY,MAAM,CAAC,oBAAoB,EAAEiE,QAAQ,EAAE;gBAACA;gBAAQrD;YAAa,GAAGG,QAAQF;QACxG,EAAE,OAAMa,OAAO;YACb1B,KAAKwB,QAAQ,CAAC;gBAACE;gBAAOP,MAAMpC,mBAAmBwF,cAAc;YAAA;YAC7D,MAAM7C;QACR;IACF;IAEA,MAAM8C,SAAS,OACbvD,UACAL,gBAA0B,EAAE,EAC5BC,iBAAuC,CAAC,CAAC;QAEzC,IAAI;YACF,MAAMK,iBAAiB;gBACrBD,UAAU;oBACRE,MAAM;oBACNC,OAAOhB,iBAAiBa,UAAUhB;gBACpC;YACF;YAEA,MAAMoB,YAAY,CAACC,OAAuB,CAAC,CAAC;gBAC1C,MAAMmD,iBAAiBnD,MAAMmD,kBAAkB,CAAC;gBAChD,OAAOzE,KAAKwB,QAAQ,CAAC;oBAACP,UAAUwD;oBAAgBtD,MAAMpC,mBAAmB2F,mBAAmB;gBAAA;YAC9F;YAEA,MAAM3D,SAAS,MAAM/B,YACnBgB,MACA,kBACAX,WACA6B,gBACA;gBACE;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;gBACA;mBACGN;aACJ,EACD;gBAACS;YAAS;YAGZ,OAAON;QACT,EAAE,OAAMW,OAAO;YACb1B,KAAKwB,QAAQ,CAAC;gBAACE;gBAAOP,MAAMpC,mBAAmB4F,iBAAiB;YAAA;YAChE,MAAMjD;QACR,SAAU;YACR,MAAMxC,mBAAmBc,MAAM;YAC/B,MAAMd,mBAAmBc,MAAM;YAC/B,MAAMd,mBAAmBc,MAAM,CAAC,oBAAoB,EAAE4E,OAAO3D,UAAUgD,UAAU,KAAK;QACxF;IACF;IAEA,4BAA4B;IAC5B,OAAO;QACLzD;QACAQ;QACA6D,QAAQjD;QACRI;QACAyB;QACAI;QACAG;QACAQ;QACAnE;QACAE;IACF;AACF,EAAE"}