@aws-amplify/ui-react-storage 0.0.0-studio-console-80bb2e2-20230921222703 → 0.0.0-testdelay-84839eb-20250107181059

package/dist/esm/components/StorageBrowser/controls/hooks/useActionExit.mjs

@@ -0,0 +1,8 @@
+import { useControlsContext } from '../context.mjs';
+
+const useActionExit = () => {
+    const { data: { actionExitLabel: label, isActionExitDisabled: isDisabled }, onActionExit: onExit, } = useControlsContext();
+    return { label, isDisabled, onExit };
+};
+
+export { useActionExit };

package/dist/esm/components/StorageBrowser/controls/hooks/useActionStart.mjs

@@ -0,0 +1,12 @@
+import { useControlsContext } from '../context.mjs';
+
+const useActionStart = () => {
+    const { data: { actionStartLabel, isActionStartDisabled }, onActionStart, } = useControlsContext();
+    return {
+        label: actionStartLabel,
+        isDisabled: isActionStartDisabled,
+        onStart: onActionStart,
+    };
+};
+
+export { useActionStart };

package/dist/esm/components/StorageBrowser/controls/hooks/useActionsList.mjs

@@ -0,0 +1,12 @@
+import { useControlsContext } from '../context.mjs';
+
+const useActionsList = () => {
+    const { data: { actions, isActionsListDisabled }, onActionSelect, } = useControlsContext();
+    return {
+        isDisabled: isActionsListDisabled,
+        items: actions ?? [],
+        onActionSelect,
+    };
+};
+
+export { useActionsList };

package/dist/esm/components/StorageBrowser/controls/hooks/useAddFiles.mjs

@@ -0,0 +1,12 @@
+import { useControlsContext } from '../context.mjs';
+
+const useAddFiles = () => {
+    const { data: { addFilesLabel, isAddFilesDisabled }, onAddFiles, } = useControlsContext();
+    return {
+        isDisabled: isAddFilesDisabled,
+        label: addFilesLabel,
+        onAddFiles,
+    };
+};
+
+export { useAddFiles };

package/dist/esm/components/StorageBrowser/controls/hooks/useAddFolder.mjs

@@ -0,0 +1,12 @@
+import { useControlsContext } from '../context.mjs';
+
+const useAddFolder = () => {
+    const { data: { addFolderLabel, isAddFolderDisabled }, onAddFolder, } = useControlsContext();
+    return {
+        isDisabled: isAddFolderDisabled,
+        label: addFolderLabel,
+        onAddFolder,
+    };
+};
+
+export { useAddFolder };

package/dist/esm/components/StorageBrowser/controls/hooks/useDataRefresh.mjs

@@ -0,0 +1,8 @@
+import { useControlsContext } from '../context.mjs';
+
+const useDataRefresh = () => {
+    const { data: { isDataRefreshDisabled }, onRefresh, } = useControlsContext();
+    return { isDisabled: isDataRefreshDisabled, onRefresh };
+};
+
+export { useDataRefresh };

package/dist/esm/components/StorageBrowser/controls/hooks/useDataTable.mjs

@@ -0,0 +1,106 @@
+import React__default from 'react';
+import { useControlsContext } from '../context.mjs';
+import { compareButtonData } from './compareFunctions/compareButtonData.mjs';
+import { compareDateData } from './compareFunctions/compareDateData.mjs';
+import { compareNumberData } from './compareFunctions/compareNumberData.mjs';
+import { compareTextData } from './compareFunctions/compareTextData.mjs';
+
+const GROUP_ORDER = [
+    'checkbox',
+    'button',
+    'date',
+    'number',
+    'text',
+];
+const UNSORTABLE_GROUPS = ['checkbox'];
+const useDataTable = () => {
+    const { data } = useControlsContext();
+    const { tableData } = data;
+    const defaultSortIndex = React__default.useMemo(() => tableData?.headers?.findIndex(({ type }) => type === 'sort') ?? -1, [tableData]);
+    const [sortState, setSortState] = React__default.useState({
+        index: defaultSortIndex,
+        direction: 'ascending',
+    });
+    const mappedHeaders = React__default.useMemo(() => tableData?.headers.map((header, index) => {
+        const { type } = header;
+        switch (type) {
+            case 'sort': {
+                return {
+                    ...header,
+                    content: {
+                        ...header.content,
+                        onSort: () => {
+                            setSortState({
+                                index,
+                                direction: sortState.index === index
+                                    ? sortState.direction === 'ascending'
+                                        ? 'descending'
+                                        : 'ascending'
+                                    : 'ascending',
+                            });
+                        },
+                        sortDirection: sortState.index === index ? sortState.direction : undefined,
+                    },
+                };
+            }
+            case 'checkbox':
+            case 'text':
+            default: {
+                return header;
+            }
+        }
+    }), [sortState, tableData]);
+    const sortedRows = React__default.useMemo(() => {
+        // Early return if there is no table data
+        if (!tableData) {
+            return;
+        }
+        // Return rows as is if there are no sortable columns
+        if (sortState.index < 0) {
+            return tableData.rows;
+        }
+        const { index, direction } = sortState;
+        const groupedRows = {
+            button: [],
+            checkbox: [],
+            date: [],
+            number: [],
+            text: [],
+        };
+        tableData.rows.forEach((row) => {
+            const { type } = row.content[index];
+            groupedRows[type].push(row);
+        });
+        const groupOrder = direction === 'ascending' ? GROUP_ORDER : [...GROUP_ORDER].reverse();
+        return groupOrder
+            .map((groupType) => {
+            if (UNSORTABLE_GROUPS.includes(groupType)) {
+                return groupedRows[groupType];
+            }
+            return groupedRows[groupType].sort((rowA, rowB) => {
+                switch (groupType) {
+                    case 'button': {
+                        return compareButtonData(rowA.content[index], rowB.content[index], direction);
+                    }
+                    case 'date': {
+                        return compareDateData(rowA.content[index], rowB.content[index], direction);
+                    }
+                    case 'number': {
+                        return compareNumberData(rowA.content[index], rowB.content[index], direction);
+                    }
+                    case 'text':
+                    default: {
+                        return compareTextData(rowA.content[index], rowB.content[index], direction);
+                    }
+                }
+            });
+        })
+            .flat();
+    }, [sortState, tableData]);
+    return {
+        headers: mappedHeaders ?? [],
+        rows: sortedRows ?? [],
+    };
+};
+
+export { useDataTable };

package/dist/esm/components/StorageBrowser/controls/hooks/useDropZone.mjs

@@ -0,0 +1,12 @@
+import { useControlsContext } from '../context.mjs';
+
+/**
+ * This hook, not to be confused with the useDropZone vended from @aws-amplify/ui-react-core, is only intended for use
+ * with its corresponding DropZone control.
+ */
+const useDropZone = () => {
+    const { onDropFiles } = useControlsContext();
+    return { onDropFiles };
+};
+
+export { useDropZone };

package/dist/esm/components/StorageBrowser/controls/hooks/useFolderNameField.mjs

@@ -0,0 +1,17 @@
+import { useControlsContext } from '../context.mjs';
+
+const useFolderNameField = () => {
+    const { data, onValidateFolderName, onFolderNameChange } = useControlsContext();
+    const { folderNameId, folderNameLabel, folderNamePlaceholder, folderNameValidationMessage, isFolderNameDisabled, } = data;
+    return {
+        id: folderNameId,
+        isDisabled: isFolderNameDisabled,
+        label: folderNameLabel,
+        onChange: onFolderNameChange,
+        onValidate: onValidateFolderName,
+        placeholder: folderNamePlaceholder,
+        validationMessage: folderNameValidationMessage,
+    };
+};
+
+export { useFolderNameField };

package/dist/esm/components/StorageBrowser/controls/hooks/useLoadingIndicator.mjs

@@ -0,0 +1,8 @@
+import { useControlsContext } from '../context.mjs';
+
+const useLoadingIndicator = () => {
+    const { data: { isLoading, loadingIndicatorLabel: label }, } = useControlsContext();
+    return { isLoading, label };
+};
+
+export { useLoadingIndicator };

package/dist/esm/components/StorageBrowser/controls/hooks/useMessage.mjs

@@ -0,0 +1,8 @@
+import { useControlsContext } from '../context.mjs';
+
+const useMessage = () => {
+    const { data: { message = {} }, } = useControlsContext();
+    return message;
+};
+
+export { useMessage };

package/dist/esm/components/StorageBrowser/controls/hooks/useNavigation.mjs

@@ -0,0 +1,28 @@
+import React__default from 'react';
+import { useControlsContext } from '../context.mjs';
+import { getNavigationItems } from './getNavigationItems.mjs';
+import { getNavigationParts } from './getNavigationParts.mjs';
+
+const useNavigation = () => {
+    const { data, onNavigate, onNavigateHome } = useControlsContext();
+    const { location } = data;
+    return React__default.useMemo(() => {
+        if (!location?.current) {
+            return { items: [] };
+        }
+        const { current, path } = location;
+        const destinationParts = getNavigationParts({
+            location: current,
+            path,
+            includeBucketInPrefix: true,
+        });
+        const homeItem = [
+            { name: 'Home', onNavigate: onNavigateHome },
+        ];
+        return {
+            items: homeItem.concat(getNavigationItems({ location: current, destinationParts, onNavigate })),
+        };
+    }, [location, onNavigate, onNavigateHome]);
+};
+
+export { useNavigation };

package/dist/esm/components/StorageBrowser/controls/hooks/useOverwriteToggle.mjs

@@ -0,0 +1,13 @@
+import { useControlsContext } from '../context.mjs';
+
+const useOverwriteToggle = () => {
+    const { data: { isOverwritingEnabled, isOverwriteToggleDisabled, overwriteToggleLabel, }, onToggleOverwrite, } = useControlsContext();
+    return {
+        isDisabled: isOverwriteToggleDisabled,
+        isOverwritingEnabled,
+        label: overwriteToggleLabel,
+        onToggle: onToggleOverwrite,
+    };
+};
+
+export { useOverwriteToggle };

package/dist/esm/components/StorageBrowser/controls/hooks/usePagination.mjs

@@ -0,0 +1,9 @@
+import { useControlsContext } from '../context.mjs';
+
+const usePagination = () => {
+    const { data, onPaginate } = useControlsContext();
+    const { paginationData } = data;
+    return { ...paginationData, onPaginate };
+};
+
+export { usePagination };

package/dist/esm/components/StorageBrowser/controls/hooks/useResolvedComposable.mjs

@@ -0,0 +1,17 @@
+import React__default from 'react';
+import { useComposables } from '../../composables/context.mjs';
+
+function useResolvedComposable(DefaultComposable, name) {
+    const { composables } = useComposables();
+    const Composable = React__default.useMemo(() => {
+        const ResolvedComposable = (props) => {
+            const Resolved = composables?.[name] ?? DefaultComposable;
+            return React__default.createElement(Resolved, { ...props });
+        };
+        ResolvedComposable.displayName = name;
+        return ResolvedComposable;
+    }, [composables, DefaultComposable, name]);
+    return Composable;
+}
+
+export { useResolvedComposable };

package/dist/esm/components/StorageBrowser/controls/hooks/useSearchField.mjs

@@ -0,0 +1,17 @@
+import { useControlsContext } from '../context.mjs';
+
+const useSearchField = () => {
+    const { data, onSearch, onSearchClear, onSearchQueryChange } = useControlsContext();
+    const { searchPlaceholder, searchClearLabel, searchQuery, searchSubmitLabel, } = data;
+    return {
+        clearLabel: searchClearLabel,
+        placeholder: searchPlaceholder,
+        query: searchQuery,
+        submitLabel: searchSubmitLabel,
+        onClear: onSearchClear,
+        onQueryChange: onSearchQueryChange,
+        onSearch,
+    };
+};
+
+export { useSearchField };

package/dist/esm/components/StorageBrowser/controls/hooks/useSearchSubfoldersToggle.mjs

@@ -0,0 +1,12 @@
+import { useControlsContext } from '../context.mjs';
+
+const useSearchSubfoldersToggle = () => {
+    const { data: { isSearchingSubfolders, searchSubfoldersToggleLabel }, onToggleSearchSubfolders, } = useControlsContext();
+    return {
+        isSearchingSubfolders,
+        label: searchSubfoldersToggleLabel,
+        onToggle: onToggleSearchSubfolders,
+    };
+};
+
+export { useSearchSubfoldersToggle };

package/dist/esm/components/StorageBrowser/controls/hooks/useStatusDisplay.mjs

@@ -0,0 +1,18 @@
+import { useControlsContext } from '../context.mjs';
+
+const useStatusDisplay = () => {
+    const { data } = useControlsContext();
+    const { statusCounts, statusDisplayCanceledLabel, statusDisplayCompletedLabel, statusDisplayFailedLabel, statusDisplayQueuedLabel, } = data;
+    if (!statusCounts?.TOTAL) {
+        return { statuses: [], total: 0 };
+    }
+    const statuses = [
+        { name: statusDisplayCompletedLabel ?? '', count: statusCounts.COMPLETE },
+        { name: statusDisplayFailedLabel ?? '', count: statusCounts.FAILED },
+        { name: statusDisplayCanceledLabel ?? '', count: statusCounts.CANCELED },
+        { name: statusDisplayQueuedLabel ?? '', count: statusCounts.QUEUED },
+    ];
+    return { statuses, total: statusCounts.TOTAL };
+};
+
+export { useStatusDisplay };

package/dist/esm/components/StorageBrowser/controls/hooks/useTitle.mjs

@@ -0,0 +1,10 @@
+import { useControlsContext } from '../context.mjs';
+
+const useTitle = () => {
+    const { data } = useControlsContext();
+    return {
+        title: data?.title,
+    };
+};
+
+export { useTitle };

package/dist/esm/components/StorageBrowser/createStorageBrowser.mjs

@@ -0,0 +1,105 @@
+import React__default from 'react';
+import { setUserAgent } from '@aws-amplify/ui';
+import { VERSION } from '../../version.mjs';
+import '@aws-amplify/storage/internals';
+import { assertRegisterAuthListener } from './validators/assertRegisterAuthListener.mjs';
+import 'aws-amplify/storage';
+import { ActionConfigsProvider } from './actions/configs/context.mjs';
+import { defaultActionConfigs } from './actions/configs/defaults.mjs';
+import { getActionConfigs } from './actions/configs/utils.mjs';
+import './composables/context.mjs';
+import { DEFAULT_COMPOSABLES } from './composables/defaults.mjs';
+import { elementsDefault } from './context/elements/defaults.mjs';
+import './context/elements/definitions.mjs';
+import './context/elements/IconElement.mjs';
+import { ComponentsProvider } from './ComponentsProvider.mjs';
+import { componentsDefault } from './componentsDefault.mjs';
+import { ErrorBoundary } from './ErrorBoundary/ErrorBoundary.mjs';
+import { createConfigurationProvider } from './providers/configuration/createConfigurationProvider.mjs';
+import './providers/configuration/context.mjs';
+import { StoreProvider } from './providers/store/StoreProvider.mjs';
+import './providers/store/actionType/context.mjs';
+import './providers/store/files/context.mjs';
+import './providers/store/location/context.mjs';
+import './providers/store/locationItems/context.mjs';
+import { StorageBrowserDefault } from './StorageBrowserDefault.mjs';
+import { CopyView } from './views/LocationActionView/CopyView/CopyView.mjs';
+import { ActionHandlersProvider } from './useAction/context.mjs';
+import { useAction } from './useAction/useAction.mjs';
+import '@aws-amplify/ui-react-core';
+import { getActionHandlers } from './useAction/utils.mjs';
+import { CreateFolderView } from './views/LocationActionView/CreateFolderView/CreateFolderView.mjs';
+import { DeleteView } from './views/LocationActionView/DeleteView/DeleteView.mjs';
+import { LocationActionView } from './views/LocationActionView/LocationActionView.mjs';
+import { UploadView } from './views/LocationActionView/UploadView/UploadView.mjs';
+import { LocationDetailView } from './views/LocationDetailView/LocationDetailView.mjs';
+import { LocationsView } from './views/LocationsView/LocationsView.mjs';
+import { useView } from './views/useView.mjs';
+import { ViewsProvider } from './views/context/views.mjs';
+import { DisplayTextProvider } from './displayText/context.mjs';
+
+function createStorageBrowser(input) {
+    assertRegisterAuthListener(input.config.registerAuthListener);
+    const { accountId, customEndpoint, registerAuthListener, getLocationCredentials, region, } = input.config;
+    setUserAgent({
+        componentName: 'StorageBrowser',
+        packageName: 'react-storage',
+        version: VERSION,
+    });
+    const actions = {
+        default: {
+            ...defaultActionConfigs,
+            ...input.actions?.default,
+            // always last
+            listLocations: input.config.listLocations,
+        },
+        custom: input.actions?.custom,
+    };
+    const handlers = getActionHandlers(actions);
+    const actionConfigs = getActionConfigs(actions);
+    const ConfigurationProvider = createConfigurationProvider({
+        accountId,
+        customEndpoint,
+        displayName: 'ConfigurationProvider',
+        getLocationCredentials,
+        region,
+        registerAuthListener,
+    });
+    const composables = {
+        // fallback composables
+        ...DEFAULT_COMPOSABLES,
+        // default components
+        ...componentsDefault,
+        // override components
+        ...input.components,
+    };
+    /**
+     * Provides state, configuration and action values that are shared between
+     * the primary View components
+     */
+    function Provider({ children, displayText, views, ...props }) {
+        return (React__default.createElement(StoreProvider, { ...props },
+            React__default.createElement(ConfigurationProvider, null,
+                React__default.createElement(ActionConfigsProvider, { actionConfigs: actionConfigs },
+                    React__default.createElement(ActionHandlersProvider, { handlers: handlers },
+                        React__default.createElement(DisplayTextProvider, { displayText: displayText },
+                            React__default.createElement(ViewsProvider, { actions: actions, views: views },
+                                React__default.createElement(ComponentsProvider, { composables: composables, elements: elementsDefault }, children))))))));
+    }
+    const StorageBrowser = ({ views, displayText }) => (React__default.createElement(ErrorBoundary, null,
+        React__default.createElement(Provider, { displayText: displayText, views: views },
+            React__default.createElement(StorageBrowserDefault, null))));
+    StorageBrowser.LocationActionView =
+        LocationActionView;
+    StorageBrowser.LocationDetailView = LocationDetailView;
+    StorageBrowser.LocationsView = LocationsView;
+    StorageBrowser.CopyView = CopyView;
+    StorageBrowser.CreateFolderView = CreateFolderView;
+    StorageBrowser.DeleteView = DeleteView;
+    StorageBrowser.UploadView = UploadView;
+    StorageBrowser.Provider = Provider;
+    StorageBrowser.displayName = 'StorageBrowser';
+    return { StorageBrowser, useAction, useView };
+}
+
+export { createStorageBrowser };

package/dist/esm/components/StorageBrowser/credentials/store/constants.mjs

@@ -0,0 +1,4 @@
+const CREDENTIALS_STORE_DEFAULT_SIZE = 10;
+const CREDENTIALS_REFRESH_WINDOW_MS = 30000;
+
+export { CREDENTIALS_REFRESH_WINDOW_MS, CREDENTIALS_STORE_DEFAULT_SIZE };

package/dist/esm/components/StorageBrowser/credentials/store/create.mjs

@@ -0,0 +1,30 @@
+import { assertValidationError, StorageValidationErrorCode } from '@aws-amplify/storage/internals';
+import { createStore, removeStore, getValue } from './registry.mjs';
+
+const validateS3Uri = (uri) => {
+    const s3UrlSchemaRegex = /^s3:\/\/[^/]+/;
+    assertValidationError(s3UrlSchemaRegex.test(uri), StorageValidationErrorCode.InvalidS3Uri);
+};
+const createLocationCredentialsStore = (input) => {
+    const storeSymbol = createStore(input.handler);
+    const store = {
+        getProvider(providerLocation) {
+            const locationCredentialsProvider = async ({ forceRefresh = false, } = {}) => {
+                validateS3Uri(providerLocation.scope);
+                // TODO(@AllanZhengYP): validate the action bucket and paths matches provider scope.
+                return getValue({
+                    storeSymbol,
+                    location: { ...providerLocation },
+                    forceRefresh,
+                });
+            };
+            return locationCredentialsProvider;
+        },
+        destroy() {
+            removeStore(storeSymbol);
+        },
+    };
+    return store;
+};
+
+export { createLocationCredentialsStore };

package/dist/esm/components/StorageBrowser/credentials/store/registry.mjs

@@ -0,0 +1,40 @@
+import { assertValidationError, StorageValidationErrorCode } from '@aws-amplify/storage/internals';
+import { initStore, getCacheValue, fetchNewValue } from './store.mjs';
+
+/**
+ * Keep all cache records for all instances of credentials store in a singleton
+ * so we can reliably de-reference from the memory when we destroy a store
+ * instance.
+ */
+const storeRegistry = new WeakMap();
+/**
+ * @internal
+ */
+const createStore = (refreshHandler, size) => {
+    const storeSymbol = { value: Symbol('LocationCredentialsStore') };
+    storeRegistry.set(storeSymbol, initStore(refreshHandler, size));
+    return storeSymbol;
+};
+const getCredentialsStore = (storeSymbol) => {
+    assertValidationError(storeRegistry.has(storeSymbol), StorageValidationErrorCode.LocationCredentialsStoreDestroyed);
+    return storeRegistry.get(storeSymbol);
+};
+/**
+ * @internal
+ */
+const getValue = async (input) => {
+    const { storeSymbol: storeReference, location, forceRefresh } = input;
+    const store = getCredentialsStore(storeReference);
+    if (!forceRefresh) {
+        const credentials = getCacheValue(store, location);
+        if (credentials !== null) {
+            return { credentials };
+        }
+    }
+    return fetchNewValue(store, location);
+};
+const removeStore = (storeSymbol) => {
+    storeRegistry.delete(storeSymbol);
+};
+
+export { createStore, getValue, removeStore };

package/dist/esm/components/StorageBrowser/credentials/store/store.mjs

@@ -0,0 +1,93 @@
+import { assertValidationError, StorageValidationErrorCode } from '@aws-amplify/storage/internals';
+import { CREDENTIALS_STORE_DEFAULT_SIZE, CREDENTIALS_REFRESH_WINDOW_MS } from './constants.mjs';
+
+const serializedPermissions = (permissions) => permissions.sort().join('_');
+const createCacheKey = (location) => `${location.scope}_${serializedPermissions(location.permissions)}`;
+const pastTTL = (credentials) => {
+    const { expiration } = credentials;
+    return expiration.getTime() - CREDENTIALS_REFRESH_WINDOW_MS <= Date.now();
+};
+const setCacheRecord = (store, key, value) => {
+    if (store.capacity === store.values.size) {
+        // Pop least used entry. The Map's key are in insertion order.
+        // So first key is the last recently inserted.
+        const [oldestKey] = store.values.keys();
+        store.values.delete(oldestKey);
+        // TODO(@AllanZhengYP): Add log info when record is evicted.
+    }
+    // Add latest used value to the cache.
+    store.values.set(key, value);
+};
+const dispatchRefresh = (refreshHandler, value, onRefreshFailure) => {
+    if (value.inflightCredentials) {
+        return value.inflightCredentials;
+    }
+    value.inflightCredentials = (async () => {
+        try {
+            const { credentials } = await refreshHandler({
+                scope: value.scope,
+                permissions: value.permissions,
+            });
+            value.credentials = credentials;
+            return { credentials };
+        }
+        catch (e) {
+            onRefreshFailure();
+            throw e;
+        }
+        finally {
+            value.inflightCredentials = undefined;
+        }
+    })();
+    return value.inflightCredentials;
+};
+/**
+ * @internal
+ */
+const initStore = (refreshHandler, size = CREDENTIALS_STORE_DEFAULT_SIZE) => {
+    assertValidationError(size > 0, StorageValidationErrorCode.InvalidLocationCredentialsCacheSize);
+    return {
+        capacity: size,
+        refreshHandler,
+        values: new Map(),
+    };
+};
+const getCacheValue = (store, location) => {
+    const cacheKey = createCacheKey(location);
+    const cachedValue = store.values.get(cacheKey);
+    const cachedCredentials = cachedValue?.credentials;
+    if (!cachedCredentials) {
+        return null;
+    }
+    // Delete and re-insert to key to map to indicate a latest reference in LRU.
+    store.values.delete(cacheKey);
+    if (!pastTTL(cachedCredentials)) {
+        // TODO(@AllanZhengYP): If the credential is still valid but will expire
+        // soon, we should return credentials AND dispatch a refresh.
+        store.values.set(cacheKey, cachedValue);
+        return cachedCredentials;
+    }
+    return null;
+};
+/**
+ * Fetch new credentials value with refresh handler and cache the result in
+ * LRU cache.
+ * @internal
+ */
+const fetchNewValue = async (store, location) => {
+    const storeValues = store.values;
+    const key = createCacheKey(location);
+    if (!storeValues.has(key)) {
+        const newStoreValue = {
+            scope: location.scope,
+            permissions: location.permissions,
+        };
+        setCacheRecord(store, key, newStoreValue);
+    }
+    const storeValue = storeValues.get(key);
+    return dispatchRefresh(store.refreshHandler, storeValue, () => {
+        store.values.delete(key);
+    });
+};
+
+export { fetchNewValue, getCacheValue, initStore };