@promoboxx/use-filter 1.11.1 → 2.0.0

package/src/useSimpleFilter.ts

@@ -0,0 +1,397 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import getOffsetFromPage from './lib/getOffsetFromPage'
+import getPageFromOffset from './lib/getPageFromOffset'
+import shallowEqual from './lib/shallowEqual'
+import { getFilterStore } from './store'
+import type { FilterStore } from './store'
+import type { UseFilterUpdateReason } from './useFilter'
+
+interface UseSimpleFilterOptions<TFilter> {
+  /**
+   * Default values for your filter. When calling `.reset` your filter will be
+   * set to this.
+   * Changing these values does not cause a call to happen.
+   */
+  defaultFilterInfo?: Partial<SimpleFilterInfo<TFilter>>
+  /**
+   * In case you want to change the default debounce duration.
+   */
+  debounceDuration?: number
+  onBeforeSaveFilter?: (
+    filterInfo: SimpleFilterInfo<TFilter>,
+  ) => SimpleFilterInfo<TFilter>
+
+  store?: FilterStore
+}
+
+export interface SimpleFilterApi<TFilter> {
+  /**
+   * Really more "is debouncing", since simple mode doesn't know when your code
+   * is doing anything.
+   */
+  isLoading: boolean
+  /**
+   * Access to the filter and its metadata.
+   */
+  filterInfo: SimpleFilterInfo<TFilter>
+  /**
+   * Same as the regular `filterInfo`, but updates in a debounced fashion.
+   */
+  debouncedFilterInfo: SimpleFilterInfo<TFilter>
+  /**
+   * Why the last update happened.
+   */
+  updateReason: UseFilterUpdateReason
+
+  /**
+   * Update one or more values in your filter.
+   */
+  updateFilter: (
+    filter: Partial<TFilter>,
+    shouldRunImmediately?: boolean,
+  ) => void
+
+  /**
+   * Does the boring math for you based on your `pageSize` and `totalResults`.
+   */
+  pagingInfo: (total: string | number | null | undefined) => {
+    totalResults: number
+    totalPages: number
+  }
+
+  /**
+   * Resets the filter back to `defaultFilterInfo`.
+   */
+  resetFilter: (shouldRunImmediately?: boolean) => void
+
+  /**
+   * Changes the offset. Will update `page`.
+   */
+  setOffset: (offset: number | string, shouldRunImmediately?: boolean) => void
+
+  /**
+   * Changes the page. Will update `offset`.
+   */
+  setPage: (page: number | string, shouldRunImmediately?: boolean) => void
+
+  /**
+   * Changes the page size.
+   */
+  setPageSize: (
+    pageSize: number | string,
+    shouldRunImmediately?: boolean,
+  ) => void
+
+  /**
+   * Change the sort method.
+   */
+  setSort: (sort: string, shouldRunImmediately?: boolean) => void
+
+  /**
+   * Changes the cursor.
+   */
+  setCursor: (
+    cursor: string | null | undefined,
+    shouldRunImmediately?: boolean,
+  ) => void
+
+  /**
+   * Forces a refresh of the filter.
+   */
+  forceRefresh: (shouldRunImmediately?: boolean) => void
+}
+
+export interface SimpleFilterInfo<TFilter> {
+  filter: TFilter
+  sort?: string
+  offset: number
+  page: number
+  pageSize: number
+  lastRefreshAt: number
+  cursor?: string | null
+  shouldRunImmediately: boolean
+}
+
+function useSimpleFilter<TFilter extends Record<string, unknown>>(
+  namespace: string,
+  options: UseSimpleFilterOptions<TFilter>,
+) {
+  // Having these types of refs helps get around rules of hooks, and they need
+  // to be updated each render.
+  const ctxRefValue = {
+    namespace,
+    debounceDuration: options.debounceDuration,
+    defaultFilterInfo: options.defaultFilterInfo,
+    onBeforeSaveFilter: options.onBeforeSaveFilter,
+    store: options.store,
+  }
+  const ctxRef = useRef(ctxRefValue)
+  useEffect(() => {
+    ctxRef.current = ctxRefValue
+  })
+
+  const [isLoading, setIsLoading] = useState(false)
+  const [filterInfo, setFilterInfoState] = useState(() => {
+    const fromStore = getFilterStore(ctxRef.current.store).getFilter<TFilter>(
+      namespace,
+    )
+
+    // If the filter is already in the store, we have to make sure it ...
+    // - has both the filter and filterInfo
+    // - has all the fields the user passed to the hook
+    if (fromStore) {
+      const filterInfo = buildDefaultFilterInfo({
+        ...fromStore,
+        shouldRunImmediately: true,
+        filter: {
+          ...options.defaultFilterInfo?.filter,
+          ...fromStore.filter,
+        },
+      })
+
+      return filterInfo
+    } else {
+      return buildDefaultFilterInfo({
+        ...options.defaultFilterInfo,
+        shouldRunImmediately: true,
+      })
+    }
+  })
+  const [debouncedFilterInfo, setDebouncedFilterInfo] = useState(filterInfo)
+
+  // Not sure this is needed in simple mode?
+  const lastRefreshAtRef = useRef(-1)
+
+  const updateReasonRef = useRef<UseFilterUpdateReason>('initial')
+
+  useEffect(() => {
+    setIsLoading(true)
+
+    // If the lastRefreshAt hasn't changed, don't do anything.
+    if (lastRefreshAtRef.current === filterInfo.lastRefreshAt) {
+      setIsLoading(false)
+      return
+    }
+
+    let timeout: ReturnType<typeof setTimeout> | undefined = undefined
+
+    function makeRequest() {
+      lastRefreshAtRef.current = filterInfo.lastRefreshAt
+      getFilterStore(ctxRef.current.store).saveFilter(
+        ctxRef.current.namespace,
+        (ctxRef.current.onBeforeSaveFilter
+          ? ctxRef.current.onBeforeSaveFilter(filterInfo)
+          : filterInfo) as any,
+      )
+      setDebouncedFilterInfo(filterInfo)
+      setIsLoading(false)
+    }
+
+    if (filterInfo.shouldRunImmediately) {
+      makeRequest()
+    } else {
+      timeout = setTimeout(makeRequest, ctxRef.current.debounceDuration ?? 500)
+    }
+
+    return () => {
+      if (timeout) {
+        clearTimeout(timeout)
+      }
+    }
+  }, [filterInfo])
+
+  const previousTotalRef = useRef(0)
+
+  const api: SimpleFilterApi<TFilter> = {
+    isLoading,
+    filterInfo,
+    debouncedFilterInfo,
+    updateReason: updateReasonRef.current,
+
+    updateFilter: useCallback(
+      (filter: Partial<TFilter>, shouldRunImmediately = false) => {
+        updateReasonRef.current = 'filter'
+
+        setFilterInfoState((previous) => {
+          const nextFilter = {
+            ...previous.filter,
+            ...filter,
+          }
+
+          if (shallowEqual(previous.filter, nextFilter)) {
+            return previous
+          }
+
+          return {
+            ...previous,
+            shouldRunImmediately,
+            offset: 0,
+            page: 1,
+            totalResults: 1,
+            totalPages: 1,
+            filter: nextFilter,
+            cursor: undefined,
+            lastRefreshAt: new Date().getTime(),
+          }
+        })
+      },
+      [],
+    ),
+
+    pagingInfo: useCallback(
+      (total: string | number | null | undefined) => {
+        const normalized = Number(
+          // Because we accept `null` as an argument, we can't do something as
+          // simple as `total ?? ...`
+          total == null ? previousTotalRef.current : total,
+        )
+        previousTotalRef.current = normalized
+
+        return {
+          totalResults: normalized,
+          totalPages: Math.ceil(normalized / filterInfo.pageSize),
+        }
+      },
+      [filterInfo.pageSize],
+    ),
+
+    resetFilter: useCallback((shouldRunImmediately: boolean = false) => {
+      updateReasonRef.current = 'filter'
+
+      setFilterInfoState({
+        ...buildDefaultFilterInfo(ctxRef.current.defaultFilterInfo),
+        shouldRunImmediately,
+      })
+    }, []),
+
+    setOffset: useCallback(
+      (offset: number | string, shouldRunImmediately: boolean = false) => {
+        updateReasonRef.current = 'pagination'
+
+        const offsetNumber = Number(offset)
+
+        setFilterInfoState((previous) => ({
+          ...previous,
+          offset: offsetNumber,
+          page: getPageFromOffset(offsetNumber, previous.pageSize),
+          lastRefreshAt: new Date().getTime(),
+          shouldRunImmediately,
+        }))
+      },
+      [],
+    ),
+
+    setPage: useCallback(
+      (page: number | string, shouldRunImmediately: boolean = false) => {
+        updateReasonRef.current = 'pagination'
+
+        const pageNumber = Number(page)
+
+        setFilterInfoState((previous) => ({
+          ...previous,
+          offset: getOffsetFromPage(pageNumber, previous.pageSize),
+          page: pageNumber,
+          lastRefreshAt: new Date().getTime(),
+          shouldRunImmediately,
+        }))
+      },
+      [],
+    ),
+
+    setPageSize: useCallback(
+      (pageSize: number | string, shouldRunImmediately: boolean = false) => {
+        updateReasonRef.current = 'pagination'
+
+        setFilterInfoState((previous) => {
+          const pageSizeNumber = Number(pageSize)
+          const page = getPageFromOffset(previous.offset, pageSizeNumber)
+          const offset = getOffsetFromPage(page, pageSizeNumber)
+
+          return {
+            ...previous,
+            pageSize: pageSizeNumber,
+            offset,
+            page,
+            lastRefreshAt: new Date().getTime(),
+            shouldRunImmediately,
+          }
+        })
+      },
+      [],
+    ),
+
+    setSort: useCallback(
+      (sort: string, shouldRunImmediately: boolean = false) => {
+        updateReasonRef.current = 'filter'
+
+        setFilterInfoState((previous) => ({
+          ...previous,
+          sort,
+          lastRefreshAt: new Date().getTime(),
+          shouldRunImmediately,
+        }))
+      },
+      [],
+    ),
+
+    setCursor: useCallback(
+      (
+        cursor: string | null | undefined,
+        shouldRunImmediately: boolean = false,
+      ) => {
+        updateReasonRef.current = 'pagination'
+
+        setFilterInfoState((previous) => ({
+          ...previous,
+          cursor,
+          lastRefreshAt: new Date().getTime(),
+          shouldRunImmediately,
+        }))
+      },
+      [],
+    ),
+
+    forceRefresh: useCallback((shouldRunImmediately: boolean = false) => {
+      updateReasonRef.current = 'filter'
+
+      setFilterInfoState((previous) => ({
+        ...previous,
+        lastRefreshAt: new Date().getTime(),
+        shouldRunImmediately,
+      }))
+    }, []),
+  }
+
+  return api
+}
+
+function buildDefaultFilterInfo<T>(
+  filterInfo: Partial<SimpleFilterInfo<T>> = {},
+): SimpleFilterInfo<T> {
+  const merged: SimpleFilterInfo<T> = {
+    // Cast here to work around "'T' could be instantiated with an arbitrary
+    // type which could be unrelated to '{}'"
+    filter: {} as T,
+
+    sort: undefined,
+    pageSize: 20,
+    lastRefreshAt: new Date().getTime(),
+    offset: 0,
+    page: 1,
+    shouldRunImmediately: false,
+    ...filterInfo,
+  }
+
+  // If there's a page but no offset, set the offset.
+  if (filterInfo.page != null && filterInfo.offset == null) {
+    merged.offset = getOffsetFromPage(filterInfo.page, merged.pageSize)
+    // If there's an offset but no page, set the page.
+  } else if (filterInfo.page == null && filterInfo.offset != null) {
+    merged.page = getPageFromOffset(filterInfo.offset, merged.pageSize)
+  }
+
+  return merged
+}
+
+export default useSimpleFilter

package/src/vitest-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vitest/globals" />

package/tsconfig.json

@@ -0,0 +1,76 @@
+{
+  "compilerOptions": {
+    /* Visit https://aka.ms/tsconfig.json to read more about this file */
+
+    /* Basic Options */
+    // "incremental": true,                         /* Enable incremental compilation */
+    "target": "es2021" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', 'ES2021', or 'ESNEXT'. */,
+    "module": "esnext" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'. */,
+    // "lib": [
+    //   "DOM",
+    //   "es2018"
+    // ] /* Specify library files to be included in the compilation. */,
+    // "allowJs": true,                             /* Allow javascript files to be compiled. */
+    // "checkJs": true,                             /* Report errors in .js files. */
+    "jsx": "react-jsx" /* Specify JSX code generation: 'preserve', 'react-native', 'react', 'react-jsx' or 'react-jsxdev'. */,
+    "declaration": true /* Generates corresponding '.d.ts' file. */,
+    // "declarationMap": true,                      /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                           /* Generates corresponding '.map' file. */
+    // "outFile": "./",                             /* Concatenate and emit output to single file. */
+    "outDir": "./dist" /* Redirect output structure to the directory. */,
+    // "rootDir": "./src" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
+    // "composite": true,                           /* Enable project compilation */
+    // "tsBuildInfoFile": "./",                     /* Specify file to store incremental compilation information */
+    // "removeComments": true,                      /* Do not emit comments to output. */
+    // "noEmit": true,                              /* Do not emit outputs. */
+    // "importHelpers": true,                       /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,                  /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,                     /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    /* Strict Type-Checking Options */
+    "strict": true /* Enable all strict type-checking options. */,
+    // "noImplicitAny": true,                       /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                    /* Enable strict null checks. */
+    // "strictFunctionTypes": true,                 /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,                 /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,        /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                      /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                        /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                      /* Report errors on unused locals. */
+    // "noUnusedParameters": true,                  /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,                   /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,          /* Report errors for fallthrough cases in switch statement. */
+    // "noUncheckedIndexedAccess": true,            /* Include 'undefined' in index signature results */
+    // "noImplicitOverride": true,                  /* Ensure overriding members in derived classes are marked with an 'override' modifier. */
+    // "noPropertyAccessFromIndexSignature": true,  /* Require undeclared properties from index signatures to use element accesses. */
+
+    /* Module Resolution Options */
+    "moduleResolution": "bundler" /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */,
+    // "baseUrl": "./",                             /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                                 /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                              /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                             /* List of folders to include type definitions from. */
+    // "types": [],                                 /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,        /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */,
+    // "preserveSymlinks": true,                    /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,                /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                            /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                               /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                     /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                       /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,              /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,               /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    "skipLibCheck": true /* Skip type checking of declaration files. */,
+    "forceConsistentCasingInFileNames": true /* Disallow inconsistently-cased references to the same file. */
+  },
+  "include": ["src/", "vite.config.ts", "tsdown.config.ts"]
+}

package/tsdown.config.ts

@@ -0,0 +1,30 @@
+import { defineConfig } from 'tsdown'
+import type { UserConfig } from 'tsdown'
+
+const shared: UserConfig = {
+  entry: [
+    './src/**/*.{ts,tsx}',
+    '!./src/**/*.test.{ts,tsx}',
+    '!./src/vitest-env.d.ts',
+  ],
+  root: 'src',
+  unbundle: true,
+  hash: false,
+  minify: false,
+  treeshake: false,
+  dts: true,
+  clean: false,
+  deps: {
+    skipNodeModulesBundle: true,
+  },
+}
+
+export default defineConfig([
+  { ...shared, format: 'esm', outDir: 'dist/esm' },
+  {
+    ...shared,
+    format: 'cjs',
+    outDir: 'dist/cjs',
+    outExtensions: () => ({ js: '.js', dts: '.d.ts' }),
+  },
+])

package/vite.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    reporters: 'verbose',
+  },
+})

package/dist/lib/buildDefaultFilterInfo.d.ts

@@ -1,3 +0,0 @@
-import { FilterInfo } from '../useFilter';
-declare function buildDefaultFilterInfo<T>(filterInfo?: Partial<FilterInfo<T>>): FilterInfo<T>;
-export default buildDefaultFilterInfo;

package/dist/lib/buildDefaultFilterInfo.js

@@ -1,35 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var getOffsetFromPage_1 = __importDefault(require("./getOffsetFromPage"));
-var getPageFromOffset_1 = __importDefault(require("./getPageFromOffset"));
-function buildDefaultFilterInfo(filterInfo) {
-    if (filterInfo === void 0) { filterInfo = {}; }
-    var merged = __assign({ 
-        // Cast here to work around "'T' could be instantiated with an arbitrary
-        // type which could be unrelated to '{}'"
-        filter: {}, sort: undefined, pageSize: 20, lastRefreshAt: new Date().getTime(), totalResults: 1, totalPages: 1, offset: 0, page: 1, shouldRunImmediately: false }, filterInfo);
-    // If there's a page but no offset, set the offset.
-    if (filterInfo.page != null && filterInfo.offset == null) {
-        merged.offset = getOffsetFromPage_1.default(filterInfo.page, merged.pageSize);
-        // If there's an offset but no page, set the page.
-    }
-    else if (filterInfo.page == null && filterInfo.offset != null) {
-        merged.page = getPageFromOffset_1.default(filterInfo.offset, merged.pageSize);
-    }
-    return merged;
-}
-exports.default = buildDefaultFilterInfo;

package/dist/lib/getOffsetFromPage.d.ts

@@ -1,2 +0,0 @@
-declare function getOffsetFromPage(page: number, pageSize: number): number;
-export default getOffsetFromPage;

package/dist/lib/getOffsetFromPage.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function getOffsetFromPage(page, pageSize) {
-    return pageSize * (page - 1);
-}
-exports.default = getOffsetFromPage;

package/dist/lib/getPageFromOffset.d.ts

@@ -1,2 +0,0 @@
-declare function getPageFromOffset(offset: number, pageSize: number): number;
-export default getPageFromOffset;

package/dist/lib/getPageFromOffset.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function getPageFromOffset(offset, pageSize) {
-    return Math.floor(offset / pageSize) + 1;
-}
-exports.default = getPageFromOffset;

package/dist/lib/shallowEqual.d.ts

@@ -1,2 +0,0 @@
-declare const shallowEqual: (objA: any, objB: any) => boolean;
-export default shallowEqual;

package/dist/lib/shallowEqual.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var shallowEqual = function (objA, objB) {
-    if (Object.is(objA, objB)) {
-        return true;
-    }
-    if (typeof objA !== 'object' || !objA || typeof objB !== 'object' || !objB) {
-        return false;
-    }
-    var keysA = Object.keys(objA);
-    var keysB = Object.keys(objB);
-    if (keysA.length !== keysB.length) {
-        return false;
-    }
-    for (var _i = 0, keysA_1 = keysA; _i < keysA_1.length; _i++) {
-        var key = keysA_1[_i];
-        if (!Object.is(objA[key], objB[key])) {
-            return false;
-        }
-    }
-    return true;
-};
-exports.default = shallowEqual;

package/dist/store/index.d.ts

@@ -1,10 +0,0 @@
-import { FilterInfo } from '../useFilter';
-export interface FilterStore {
-    getFilter<TFilter = any>(namespace: string): FilterInfo<TFilter> | null | undefined;
-    saveFilter<TFilter = any>(namespace: string, filter: FilterInfo<TFilter>): void;
-    getData<TResult = any>(namespace: string): TResult | null | undefined;
-    saveData<TResult = any>(namespace: string, data: TResult): void;
-    clear(): void;
-}
-export declare function setFilterStore(newStore: FilterStore): void;
-export declare function getFilterStore(optionalStore?: FilterStore): FilterStore;

package/dist/store/index.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFilterStore = exports.setFilterStore = void 0;
-var globalStore;
-function setFilterStore(newStore) {
-    globalStore = newStore;
-}
-exports.setFilterStore = setFilterStore;
-function getFilterStore(optionalStore) {
-    var resolvedStore = optionalStore || globalStore;
-    if (!resolvedStore) {
-        throw new Error('A store must be set with setFilterStore');
-    }
-    return resolvedStore;
-}
-exports.getFilterStore = getFilterStore;

package/dist/store/localStorageStore.d.ts

@@ -1,3 +0,0 @@
-import { FilterStore } from '.';
-declare const localStorageStore: FilterStore;
-export default localStorageStore;

package/dist/store/localStorageStore.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var prefix = 'useFilter';
-var localStorageStore = {
-    getFilter: function (namespace) {
-        var item = localStorage.getItem(prefix + "/" + namespace + "/filter");
-        if (item) {
-            return JSON.parse(item);
-        }
-    },
-    saveFilter: function (namespace, filter) {
-        localStorage.setItem(prefix + "/" + namespace + "/filter", JSON.stringify(filter));
-    },
-    getData: function (namespace) {
-        var item = localStorage.getItem(prefix + "/" + namespace + "/data");
-        if (item) {
-            return JSON.parse(item);
-        }
-    },
-    saveData: function (namespace, data) {
-        localStorage.setItem(prefix + "/" + namespace + "/data", JSON.stringify(data));
-    },
-    clear: function () {
-        for (var key in localStorage) {
-            if (key.startsWith(prefix)) {
-                localStorage.removeItem(key);
-            }
-        }
-    },
-};
-exports.default = localStorageStore;