@lobehub/lobehub 2.0.0-next.59 → 2.0.0-next.60

package/src/store/middleware/createHyperStorage/index.test.ts

@@ -1,341 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-
-import { createHyperStorage } from './index';
-import { createIndexedDB } from './indexedDB';
-import { createKeyMapper } from './keyMapper';
-import { createLocalStorage } from './localStorage';
-import { creatUrlStorage } from './urlStorage';
-
-// Mock the dependent modules
-vi.mock('./indexedDB', () => {
-  return {
-    createIndexedDB: vi.fn(),
-  };
-});
-
-vi.mock('./localStorage', () => ({
-  createLocalStorage: vi.fn(),
-}));
-
-vi.mock('./urlStorage', () => ({
-  creatUrlStorage: vi.fn(),
-}));
-
-vi.mock('./keyMapper', () => ({
-  createKeyMapper: vi.fn().mockReturnValue({
-    mapStateKeyToStorageKey: vi.fn((k) => k),
-    getStateKeyFromStorageKey: vi.fn((k) => k),
-  }),
-}));
-
-afterEach(() => {
-  vi.mocked(createKeyMapper).mockClear();
-});
-
-describe('createHyperStorage', () => {
-  it('should create storage with default configuration if no options provided', async () => {
-    const storage = createHyperStorage({});
-    expect(storage).toBeDefined();
-    // Add more assertions to verify default behavior
-  });
-
-  it('should skip local storage if explicitly disabled', async () => {
-    const storage = createHyperStorage({ localStorage: false });
-    await storage.setItem('key', { state: {}, version: 1 });
-
-    // The setItem should not call the local storage functions
-    const indexDBSetItemMock = vi.fn();
-
-    vi.mocked(createIndexedDB).mockImplementation(() => ({
-      getItem: vi.fn(),
-      removeItem: vi.fn(),
-      setItem: indexDBSetItemMock,
-    }));
-
-    const localStorageSetItemMock = vi.fn();
-
-    vi.mocked(createLocalStorage).mockImplementation(() => ({
-      getItem: vi.fn(),
-      removeItem: vi.fn(),
-      setItem: localStorageSetItemMock,
-    }));
-
-    expect(indexDBSetItemMock).not.toHaveBeenCalled();
-    expect(localStorageSetItemMock).not.toHaveBeenCalled();
-  });
-
-  it('should use indexedDB mode if set in local storage options', async () => {
-    // The setItem should call the indexedDB functions
-    // The setItem should not call the local storage functions
-    const indexDBSetItemMock = vi.fn();
-
-    vi.mocked(createIndexedDB).mockImplementation(() => ({
-      getItem: vi.fn(),
-      removeItem: vi.fn(),
-      setItem: indexDBSetItemMock,
-    }));
-
-    const storage = createHyperStorage({
-      localStorage: { mode: 'indexedDB', dbName: 'testDB', selectors: [] },
-    });
-
-    await storage.setItem('key', { state: {}, version: 1 });
-
-    expect(indexDBSetItemMock).toHaveBeenCalled();
-  });
-
-  it('should use the provided dbName for indexedDB', async () => {
-    const dbName = 'customDB';
-    createHyperStorage({ localStorage: { mode: 'indexedDB', dbName, selectors: [] } });
-
-    expect(vi.mocked(createIndexedDB)).toHaveBeenCalledWith(dbName);
-  });
-
-  it('should handle URL storage if URL options are provided', async () => {
-    const urlMode = 'hash';
-    const setItemMock = vi.fn();
-
-    vi.mocked(creatUrlStorage).mockImplementation(() => ({
-      getItem: vi.fn(),
-      removeItem: vi.fn(),
-      setItem: setItemMock,
-    }));
-
-    const storage = createHyperStorage({ url: { mode: urlMode, selectors: [] } });
-
-    await storage.setItem('key', { state: {}, version: 1 });
-
-    expect(creatUrlStorage).toHaveBeenCalledWith(urlMode);
-    // The setItem should call the urlStorage functions
-    expect(setItemMock).toHaveBeenCalled();
-  });
-
-  describe('getItem method', () => {
-    it('should retrieve item from indexedDB when useIndexedDB is true', async () => {
-      const indexedDBGetItemMock = vi
-        .fn()
-        .mockResolvedValue({ state: { key: 'value' }, version: 1 });
-      vi.mocked(createIndexedDB).mockImplementation(() => ({
-        getItem: indexedDBGetItemMock,
-        removeItem: vi.fn(),
-        setItem: vi.fn(),
-      }));
-
-      const storage = createHyperStorage({ localStorage: { mode: 'indexedDB', selectors: [] } });
-      const item = await storage.getItem('key');
-
-      expect(indexedDBGetItemMock).toHaveBeenCalledWith('key');
-      expect(item).toEqual({ state: { key: 'value' }, version: 1 });
-    });
-
-    it('should fallback to localStorage if item not found in indexedDB', async () => {
-      const indexedDBGetItemMock = vi.fn().mockResolvedValue(undefined);
-      const localStorageGetItemMock = vi
-        .fn()
-        .mockReturnValue({ state: { key: 'value' }, version: 1 });
-
-      vi.mocked(createIndexedDB).mockImplementation(() => ({
-        getItem: indexedDBGetItemMock,
-        removeItem: vi.fn(),
-        setItem: vi.fn(),
-      }));
-
-      vi.mocked(createLocalStorage).mockImplementation(() => ({
-        getItem: localStorageGetItemMock,
-        removeItem: vi.fn(),
-        setItem: vi.fn(),
-      }));
-
-      const storage = createHyperStorage({ localStorage: { mode: 'indexedDB', selectors: [] } });
-      const item = await storage.getItem('key');
-
-      expect(indexedDBGetItemMock).toHaveBeenCalledWith('key');
-      expect(localStorageGetItemMock).toHaveBeenCalledWith('key');
-      expect(item).toEqual({ state: { key: 'value' }, version: 1 });
-    });
-
-    it('should not attempt to retrieve from any storage if skipLocalStorage is true', async () => {
-      const storage = createHyperStorage({ localStorage: false });
-      const item = await storage.getItem('key');
-
-      const indexedDBGetItemMock = vi.fn().mockResolvedValue(undefined);
-      const localStorageGetItemMock = vi
-        .fn()
-        .mockReturnValue({ state: { key: 'value' }, version: 1 });
-
-      vi.mocked(createIndexedDB).mockImplementation(() => ({
-        getItem: indexedDBGetItemMock,
-        removeItem: vi.fn(),
-        setItem: vi.fn(),
-      }));
-
-      vi.mocked(createLocalStorage).mockImplementation(() => ({
-        getItem: localStorageGetItemMock,
-        removeItem: vi.fn(),
-        setItem: vi.fn(),
-      }));
-
-      expect(indexedDBGetItemMock).not.toHaveBeenCalled();
-      expect(localStorageGetItemMock).not.toHaveBeenCalled();
-      expect(item).toEqual({ state: {}, version: undefined });
-    });
-
-    describe('getItem method with URL storage', () => {
-      it('should override state from URL storage if hasUrl is true', async () => {
-        const urlStorageGetItemMock = vi.fn().mockReturnValue({ state: { urlKey: 'urlValue' } });
-        vi.mocked(creatUrlStorage).mockImplementation(() => ({
-          getItem: urlStorageGetItemMock,
-          removeItem: vi.fn(),
-          setItem: vi.fn(),
-        }));
-
-        // Mock createKeyMapper to simulate state key mapping from URL storage keys
-        vi.mocked(createKeyMapper).mockReturnValue({
-          mapStateKeyToStorageKey: vi.fn((k) => k),
-          getStateKeyFromStorageKey: vi.fn((k) => (k === 'urlKey' ? 'mappedKey' : undefined)),
-        });
-
-        const storage = createHyperStorage({
-          url: { mode: 'hash', selectors: [] },
-          localStorage: false,
-        });
-        const item = await storage.getItem('key');
-
-        expect(urlStorageGetItemMock).toHaveBeenCalled();
-        expect(item?.state).toEqual({ mappedKey: 'urlValue' });
-      });
-
-      it('should not include URL storage state if key mapping is undefined', async () => {
-        const urlStorageGetItemMock = vi.fn().mockReturnValue({ state: { urlKey: 'urlValue' } });
-        vi.mocked(creatUrlStorage).mockImplementation(() => ({
-          getItem: urlStorageGetItemMock,
-          removeItem: vi.fn(),
-          setItem: vi.fn(),
-        }));
-
-        // Mock createKeyMapper to simulate state key mapping from URL storage keys
-        vi.mocked(createKeyMapper).mockReturnValue({
-          mapStateKeyToStorageKey: vi.fn((k) => k),
-          getStateKeyFromStorageKey: vi.fn(() => undefined), // No key will be mapped
-        });
-
-        const storage = createHyperStorage({
-          url: { mode: 'hash', selectors: [] },
-          localStorage: false,
-        });
-        const item = await storage.getItem('key');
-
-        expect(urlStorageGetItemMock).toHaveBeenCalled();
-        expect(item?.state).toEqual({}); // No state from URL storage should be included
-      });
-
-      it('should not attempt to retrieve from URL storage if hasUrl is false', async () => {
-        const urlStorageGetItemMock = vi.fn();
-        vi.mocked(creatUrlStorage).mockImplementation(() => ({
-          getItem: urlStorageGetItemMock,
-          removeItem: vi.fn(),
-          setItem: vi.fn(),
-        }));
-
-        const storage = createHyperStorage({ localStorage: false }); // No URL options provided
-        await storage.getItem('key');
-
-        expect(urlStorageGetItemMock).not.toHaveBeenCalled();
-      });
-    });
-  });
-
-  describe('removeItem method', () => {
-    it('should remove item from indexedDB when useIndexedDB is true', async () => {
-      const indexedDBRemoveItemMock = vi.fn().mockResolvedValue(undefined);
-      vi.mocked(createIndexedDB).mockImplementation(() => ({
-        getItem: vi.fn(),
-        removeItem: indexedDBRemoveItemMock,
-        setItem: vi.fn(),
-      }));
-
-      const storage = createHyperStorage({ localStorage: { mode: 'indexedDB', selectors: [] } });
-      await storage.removeItem('key');
-
-      expect(indexedDBRemoveItemMock).toHaveBeenCalledWith('key');
-    });
-
-    it('should remove item from localStorage when useIndexedDB is false', async () => {
-      const localStorageRemoveItemMock = vi.fn().mockResolvedValue(undefined);
-      vi.mocked(createLocalStorage).mockImplementation(() => ({
-        getItem: vi.fn(),
-        removeItem: localStorageRemoveItemMock,
-        setItem: vi.fn(),
-      }));
-
-      const storage = createHyperStorage({});
-      await storage.removeItem('key');
-
-      expect(localStorageRemoveItemMock).toHaveBeenCalledWith('key');
-    });
-
-    it('should remove item from URL storage if URL options provided', async () => {
-      const urlStorageRemoveItemMock = vi.fn();
-
-      vi.mocked(creatUrlStorage).mockImplementation(() => ({
-        getItem: vi.fn(),
-        removeItem: urlStorageRemoveItemMock,
-        setItem: vi.fn(),
-      }));
-      // Mock createKeyMapper to simulate state key mapping from URL storage keys
-      vi.mocked(createKeyMapper).mockReturnValue({
-        mapStateKeyToStorageKey: vi.fn((k) => k),
-        getStateKeyFromStorageKey: vi.fn((k) => k), // No key will be mapped
-      });
-
-      const storage = createHyperStorage({ url: { mode: 'hash', selectors: ['key'] } });
-      await storage.removeItem('key');
-
-      expect(urlStorageRemoveItemMock).toHaveBeenCalledWith('key');
-    });
-  });
-
-  describe('setItem method', () => {
-    it('should save item to indexedDB when useIndexedDB is true', async () => {
-      const indexedDBSetItemMock = vi.fn().mockResolvedValue(undefined);
-      vi.mocked(createIndexedDB).mockImplementation(() => ({
-        getItem: vi.fn(),
-        removeItem: vi.fn(),
-        setItem: indexedDBSetItemMock,
-      }));
-
-      const storage = createHyperStorage({ localStorage: { mode: 'indexedDB', selectors: [] } });
-      await storage.setItem('key', { state: { key: 'value' }, version: 1 });
-
-      expect(indexedDBSetItemMock).toHaveBeenCalledWith('key', { key: 'value' }, 1);
-    });
-
-    it('should save item to localStorage when useIndexedDB is false', async () => {
-      const localStorageSetItemMock = vi.fn().mockResolvedValue(undefined);
-      vi.mocked(createLocalStorage).mockImplementation(() => ({
-        getItem: vi.fn(),
-        removeItem: vi.fn(),
-        setItem: localStorageSetItemMock,
-      }));
-
-      const storage = createHyperStorage({});
-      await storage.setItem('key', { state: { key: 'value' }, version: 1 });
-
-      expect(localStorageSetItemMock).toHaveBeenCalledWith('key', { key: 'value' }, 1);
-    });
-
-    it('should save state to URL storage if URL options provided', async () => {
-      const urlStorageSetItemMock = vi.fn().mockResolvedValue(undefined);
-      vi.mocked(creatUrlStorage).mockImplementation(() => ({
-        getItem: vi.fn(),
-        removeItem: vi.fn(),
-        setItem: urlStorageSetItemMock,
-      }));
-
-      const storage = createHyperStorage({ url: { mode: 'hash', selectors: [] } });
-      await storage.setItem('key', { state: { key: 'value' }, version: 1 });
-
-      expect(urlStorageSetItemMock).toHaveBeenCalled();
-    });
-  });
-});

package/src/store/middleware/createHyperStorage/index.ts

@@ -1,126 +0,0 @@
-import { PersistStorage, StorageValue } from 'zustand/middleware';
-
-import { createIndexedDB } from './indexedDB';
-import { createKeyMapper } from './keyMapper';
-import { createLocalStorage } from './localStorage';
-import { HyperStorageOptions } from './type';
-import { creatUrlStorage } from './urlStorage';
-
-export const createHyperStorage = <T extends object>(
-  options: HyperStorageOptions,
-): PersistStorage<T> => {
-  const optionsObj = typeof options === 'function' ? options() : options;
-
-  const getLocalStorageConfig = () => {
-    if (optionsObj.localStorage === false) {
-      return { dbName: '', skipLocalStorage: true, useIndexedDB: false };
-    }
-
-    const useIndexedDB = optionsObj.localStorage?.mode === 'indexedDB';
-    const dbName = optionsObj.localStorage?.dbName || 'indexedDB';
-
-    return { dbName, skipLocalStorage: false, useIndexedDB };
-  };
-
-  const hasUrl = !!optionsObj.url;
-
-  const { skipLocalStorage, useIndexedDB, dbName } = getLocalStorageConfig();
-
-  const { mapStateKeyToStorageKey, getStateKeyFromStorageKey } = createKeyMapper(optionsObj);
-
-  const indexedDB = createIndexedDB(dbName);
-  const localStorage = createLocalStorage();
-  const urlStorage = creatUrlStorage(optionsObj.url?.mode);
-  return {
-    getItem: async (name): Promise<StorageValue<T>> => {
-      const state: any = {};
-      let version: number | undefined;
-
-      // ============== 处理 Local Storage  ============== //
-      if (!skipLocalStorage) {
-        let localState: StorageValue<T> | undefined;
-
-        // 如果使用 indexedDB，优先从 indexedDB 中获取
-        if (useIndexedDB) {
-          localState = await indexedDB.getItem(name);
-        }
-        // 如果 indexedDB 中不存在，则再试试 localStorage
-        if (!localState) localState = localStorage.getItem(name);
-
-        if (localState) {
-          version = localState.version;
-          for (const [k, v] of Object.entries(localState.state)) {
-            const key = getStateKeyFromStorageKey(k, 'localStorage');
-            if (key) state[key] = v;
-          }
-        }
-      }
-
-      // ============== 处理 URL Storage  ============== //
-      // 不从 URL 中获取 version，由于 url 状态是临时态 不作为版本控制的依据
-      if (hasUrl) {
-        const urlState = urlStorage.getItem();
-
-        if (urlState) {
-          for (const [k, v] of Object.entries(urlState.state)) {
-            const key = getStateKeyFromStorageKey(k, 'url');
-            // 当存在 UrlSelector 逻辑，且 key 有效时，才将状态加入终态 state
-            if (hasUrl && key) {
-              state[key] = v;
-            }
-          }
-        }
-      }
-
-      return { state, version };
-    },
-    removeItem: async (key) => {
-      // ============== 处理 Local Storage  ============== //
-      if (!skipLocalStorage) {
-        if (useIndexedDB) {
-          await indexedDB.removeItem(key);
-        } else {
-          localStorage.removeItem(key);
-        }
-      }
-
-      // ============== 处理 URL Storage  ============== //
-      if (hasUrl) {
-        const storageKey = getStateKeyFromStorageKey(key, 'url');
-
-        urlStorage.removeItem(storageKey);
-      }
-    },
-
-    setItem: async (name, newValue) => {
-      // ============== 处理 Local Storage  ============== //
-      const localState: Record<string, any> = {};
-      for (const [k, v] of Object.entries(newValue.state)) {
-        const localKey = mapStateKeyToStorageKey(k, 'localStorage');
-        if (localKey) localState[localKey] = v;
-      }
-
-      if (!skipLocalStorage) {
-        if (useIndexedDB) {
-          await indexedDB.setItem(name, localState, newValue.version);
-        } else {
-          localStorage.setItem(name, localState, newValue.version);
-        }
-      }
-
-      // ============== 处理 URL Storage  ============== //
-      if (hasUrl) {
-        // 转换 key 为目标 key
-        const finalEntries = Object.entries(newValue.state)
-          .map(([k, v]) => {
-            const urlKey = mapStateKeyToStorageKey(k, 'url');
-            if (!urlKey) return undefined;
-            return [urlKey, v];
-          })
-          .filter(Boolean) as [string, any][];
-
-        urlStorage.setItem(name, Object.fromEntries(finalEntries));
-      }
-    },
-  };
-};

package/src/store/middleware/createHyperStorage/indexedDB.test.ts

@@ -1,64 +0,0 @@
-import { delMany, getMany, setMany } from 'idb-keyval';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-
-import { createIndexedDB } from './indexedDB';
-
-// Mock idb-keyval methods
-vi.mock('idb-keyval', () => ({
-  createStore: vi.fn().mockImplementation(() => 'abc'),
-  getMany: vi.fn(),
-  setMany: vi.fn(),
-  delMany: vi.fn(),
-}));
-
-describe('createIndexedDB', () => {
-  const dbName = 'testDB';
-  const storeName = 'testStore';
-  const indexedDB = createIndexedDB(dbName);
-
-  beforeEach(() => {
-    // Reset all mocks before each test
-    vi.resetAllMocks();
-  });
-
-  it('getItem should return the correct state and version', async () => {
-    const mockState = { key: 'value' };
-    const mockVersion = 1;
-
-    // Setup mock behavior for getMany
-    vi.mocked(getMany).mockResolvedValue([mockVersion, mockState]);
-
-    const result = await indexedDB.getItem(storeName);
-
-    expect(vi.mocked(getMany).mock.calls[0][0]).toEqual(['version', 'state']);
-    expect(result).toEqual({ state: mockState, version: mockVersion });
-  });
-
-  it('getItem should return undefined if state does not exist', async () => {
-    // Setup mock behavior for getMany
-    vi.mocked(getMany).mockResolvedValue([undefined, undefined]);
-
-    const result = await indexedDB.getItem(storeName);
-
-    expect(vi.mocked(getMany).mock.calls[0][0]).toEqual(['version', 'state']);
-    expect(result).toBeUndefined();
-  });
-
-  it('removeItem should call delMany with the correct keys', async () => {
-    await indexedDB.removeItem(storeName);
-
-    expect(vi.mocked(delMany).mock.calls[0][0]).toEqual(['version', 'state']);
-  });
-
-  it('setItem should call setMany with the correct keys and values', async () => {
-    const mockState = { key: 'value' };
-    const mockVersion = 1;
-
-    await indexedDB.setItem(storeName, mockState, mockVersion);
-
-    expect(vi.mocked(setMany).mock.calls[0][0]).toEqual([
-      ['version', mockVersion],
-      ['state', mockState],
-    ]);
-  });
-});

package/src/store/middleware/createHyperStorage/indexedDB.ts

@@ -1,26 +0,0 @@
-import { createStore, delMany, getMany, setMany } from 'idb-keyval';
-import { StorageValue } from 'zustand/middleware';
-
-export const createIndexedDB = <State extends any>(dbName: string = 'indexedDB') => ({
-  getItem: async <T extends State>(name: string): Promise<StorageValue<T> | undefined> => {
-    const [version, state] = await getMany(['version', 'state'], createStore(dbName, name));
-
-    if (!state) return undefined;
-
-    return { state, version };
-  },
-  removeItem: async (name: string) => {
-    await delMany(['version', 'state'], createStore(dbName, name));
-  },
-  setItem: async (name: string, state: any, version: number | undefined) => {
-    const store = createStore(dbName, name);
-
-    await setMany(
-      [
-        ['version', version],
-        ['state', state],
-      ],
-      store,
-    );
-  },
-});

package/src/store/middleware/createHyperStorage/keyMapper.ts

@@ -1,57 +0,0 @@
-import { HyperStorageOptionsObj } from './type';
-
-export const createKeyMapper = (options: HyperStorageOptionsObj) => {
-  const mapStateKeyToStorageKey = (
-    key: string,
-    mode: keyof HyperStorageOptionsObj = 'localStorage',
-  ) => {
-    const media = options[mode];
-    if (media === false) return key;
-
-    const selectors = media?.selectors;
-    if (!selectors) return key;
-
-    let storageKey: string | undefined;
-
-    for (const selector of selectors) {
-      if (typeof selector === 'string') {
-        if (selector === key) storageKey = key;
-      } else {
-        if (selector[key]) storageKey = selector[key];
-      }
-    }
-
-    return storageKey;
-  };
-
-  const getStateKeyFromStorageKey = (
-    key: string,
-    mode: keyof HyperStorageOptionsObj = 'localStorage',
-  ) => {
-    const media = options[mode];
-    if (media === false) return key;
-
-    const selectors = media?.selectors;
-    if (!selectors) return key;
-
-    let stateKey: string | undefined;
-
-    for (const item of selectors) {
-      // 对象如果是 字符串，直接返回该 item key
-      if (typeof item === 'string') {
-        if (item === key) stateKey = key;
-      } else {
-        for (const [k, v] of Object.entries(item)) {
-          if (v === key) stateKey = k;
-        }
-      }
-    }
-
-    return stateKey;
-  };
-
-  return {
-    getStateKeyFromStorageKey,
-    mapStateKeyToStorageKey,
-  };
-};

package/src/store/middleware/createHyperStorage/localStorage.ts

@@ -1,18 +0,0 @@
-import { StorageValue } from 'zustand/middleware';
-
-export const createLocalStorage = <State extends any>() => ({
-  getItem: <T extends State>(name: string): StorageValue<T> | undefined => {
-    if (!global.localStorage) return undefined;
-    const string = localStorage.getItem(name);
-
-    if (string) return JSON.parse(string) as StorageValue<T>;
-
-    return undefined;
-  },
-  removeItem: (name: string) => {
-    if (global.localStorage) localStorage.removeItem(name);
-  },
-  setItem: <T extends State>(name: string, state: T, version: number | undefined) => {
-    if (global.localStorage) localStorage.setItem(name, JSON.stringify({ state, version }));
-  },
-});

package/src/store/middleware/createHyperStorage/type.ts

@@ -1,25 +0,0 @@
-export type StorageSelector = string | Record<string, string>;
-
-export interface LocalStorageOptions {
-  dbName?: string;
-  /**
-   * @default 'localStorage'
-   */
-  mode?: 'indexedDB' | 'localStorage';
-  selectors: StorageSelector[];
-}
-
-export type HyperStorageOptionsObj = {
-  localStorage?: LocalStorageOptions | false;
-  url?: {
-    /**
-     * @default 'hash'
-     */
-    mode?: 'hash' | 'search';
-    selectors: StorageSelector[];
-  };
-};
-
-export type HyperStorageOptionsFn = () => HyperStorageOptionsObj;
-
-export type HyperStorageOptions = HyperStorageOptionsObj | HyperStorageOptionsFn;