@4399ywkf/cli 0.0.22 → 1.0.2

package/dist/templates/convert-locales-to-json.js

@@ -0,0 +1,47 @@
+const fs = require("fs");
+const path = require("path");
+
+const sourceDir = path.join(__dirname, "../src/locales/default");
+
+// 动态读取源目录下所有 .ts 文件（排除 index.ts）
+const files = fs
+  .readdirSync(sourceDir)
+  .filter((file) => {
+    return (
+      file.endsWith(".ts") && // 只处理 .ts 文件
+      file !== "index.ts" // 排除 index.ts
+    );
+  })
+  .map((file) => path.basename(file, ".ts")); // 去掉 .ts 扩展名
+
+// 使用 ts-node 加载 TypeScript 文件
+require("ts-node/register");
+
+const targetDir = path.join(__dirname, "../locales/zh-CN");
+
+// 确保目标目录存在
+if (!fs.existsSync(targetDir)) {
+  fs.mkdirSync(targetDir, { recursive: true });
+}
+
+console.log("开始转换 TypeScript 文件到 JSON...\n");
+
+files.forEach((fileName) => {
+  try {
+    // 动态导入 TypeScript 模块
+    const modulePath = path.join(sourceDir, `${fileName}.ts`);
+    delete require.cache[require.resolve(modulePath)]; // 清除缓存
+    const moduleContent = require(modulePath).default;
+
+    // 转换为 JSON 并保存
+    const jsonContent = JSON.stringify(moduleContent, null, 2);
+    const targetPath = path.join(targetDir, `${fileName}.json`);
+
+    fs.writeFileSync(targetPath, jsonContent, "utf8");
+    console.log(`✅ ${fileName}.ts → ${fileName}.json`);
+  } catch (error) {
+    console.error(`❌ 转换 ${fileName}.ts 失败:`, error.message);
+  }
+});
+
+console.log("\n✨ 转换完成！");

package/dist/templates/convert.ts

@@ -0,0 +1,40 @@
+/**
+ * 将文件大小从一个单位转换为另一个单位。
+ *
+ * @param {number} size 文件大小。
+ * @param {string} fromUnit 初始单位（'B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'）。
+ * @param {string} toUnit 目标单位（'B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'）。
+ * @param {number} [decimalPoint=2] 结果保留的小数位数，默认为2。
+ * @return {string} 转换后的文件大小，带单位。
+ */
+export const convertFileSize = (
+  size: number,
+  fromUnit: string,
+  toUnit: string,
+  decimalPoint = 2,
+): string => {
+  // 定义单位与字节之间的转换关系
+  const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
+  // 获取初始单位和目标单位的索引
+  const fromIndex = units.indexOf(fromUnit);
+  const toIndex = units.indexOf(toUnit);
+
+  // 如果单位不在列表中，抛出错误
+  if (fromIndex === -1 || toIndex === -1) {
+    throw new Error('Invalid units');
+  }
+
+  // 计算初始单位与目标单位之间的转换系数
+  const exponent = toIndex - fromIndex;
+  // 计算结果大小
+  const resultSize = size / 1024 ** exponent;
+
+  // 返回格式化后的结果
+  return `${Number.parseFloat(resultSize.toFixed(decimalPoint))} ${toUnit}`;
+};
+
+// // 示例使用
+// console.log(convertFileSize(1, 'GB', 'MB')); // 输出: 1024.00 MB
+// console.log(convertFileSize(1, 'MB', 'KB')); // 输出: 1024.00 KB
+// console.log(convertFileSize(1, 'KB', 'B'));  // 输出: 1024.00 B
+// console.log(convertFileSize(1, 'MB', 'GB', 5)); // 输出: 0.00098 GB

package/dist/templates/cookie.ts

@@ -0,0 +1,25 @@
+import dayjs from 'dayjs';
+
+export const COOKIE_CACHE_DAYS = 30;
+
+export const setCookie = (
+  key: string,
+  value: string | undefined,
+  expireDays: string | number = COOKIE_CACHE_DAYS,
+) => {
+  if (typeof value === 'undefined') {
+    // Set the expiration time to yesterday (expire immediately)
+    const expiredDate = new Date(0).toUTCString(); // 1970-01-01T00:00:00Z
+
+    // eslint-disable-next-line unicorn/no-document-cookie
+    document.cookie = `${key}=; expires=${expiredDate}; path=/;`;
+  } else {
+    const expires =
+      typeof expireDays === 'string'
+        ? expireDays
+        : dayjs().add(expireDays, 'day').toDate().toUTCString();
+
+    // eslint-disable-next-line unicorn/no-document-cookie
+    document.cookie = `${key}=${value};expires=${expires};path=/;`;
+  }
+};

package/dist/templates/copyToClipboard.ts

@@ -0,0 +1,13 @@
+export const copyToClipboard = async (text: string) => {
+  try {
+    await navigator.clipboard.writeText(text);
+  } catch {
+    const textArea = document.createElement('textarea');
+    textArea.value = text;
+    document.body.append(textArea);
+    textArea.focus();
+    textArea.select();
+    document.execCommand('copy');
+    textArea.remove();
+  }
+};

package/dist/templates/create.ts

@@ -0,0 +1,56 @@
+import i18n from 'i18next';
+import LanguageDetector from 'i18next-browser-languagedetector';
+import resourcesToBackend from 'i18next-resources-to-backend';
+import { initReactI18next } from 'react-i18next';
+import { isRtlLang } from 'rtl-detect';
+
+import { DEFAULT_LANG } from '@/const/locale';
+import { normalizeLocale } from '@/locales/resources';
+
+const isDev = process.env.NODE_ENV === 'development';
+const debugMode = isDev;
+
+export const createI18nNext = (lang?: string) => {
+  const instance = i18n
+    .use(initReactI18next)
+    .use(LanguageDetector)
+    .use(
+      resourcesToBackend(async (lng: string, ns: string) => {
+        return import(`@locales/${normalizeLocale(lng)}/${ns}.json`);
+      }),
+    );
+  // Dynamically set HTML direction on language change
+  instance.on('languageChanged', (lng) => {
+    if (typeof window !== 'undefined') {
+      const direction = isRtlLang(lng) ? 'rtl' : 'ltr';
+      document.documentElement.dir = direction;
+    }
+  });
+  return {
+    init: () =>
+      instance.init({
+        debug: debugMode,
+        defaultNS: ['error', 'common', 'chat'],
+        // detection: {
+        //   caches: ['cookie'],
+        //   cookieMinutes: 60 * 24 * COOKIE_CACHE_DAYS,
+        //   /**
+        //      Set `sameSite` to `lax` so that the i18n cookie can be passed to the
+        //      server side when returning from the OAuth authorization website.
+        //      ref: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie#samesitesamesite-value
+        //      discussion: https://github.com/lobehub/lobe-chat/pull/1474
+        //   */
+        //   cookieOptions: {
+        //     sameSite: 'lax',
+        //   },
+        //   lookupCookie: LOBE_LOCALE_COOKIE,
+        // },
+        fallbackLng: DEFAULT_LANG,
+        interpolation: {
+          escapeValue: false,
+        },
+        lng: lang,
+      }),
+    instance,
+  };
+};

package/dist/templates/createDevtools.ts

@@ -0,0 +1,23 @@
+import { optionalDevtools } from 'zustand-utils';
+import type { devtools as _devtools } from 'zustand/middleware';
+
+import { isDev } from '@/utils/env';
+
+export const createDevtools =
+  (name: string): typeof _devtools =>
+  initializer => {
+    let showDevtools = false;
+
+    // check url to show devtools
+    if (typeof window !== 'undefined') {
+      const url = new URL(window.location.href);
+      const debug = url.searchParams.get('debug');
+      if (debug?.includes(name)) {
+        showDevtools = true;
+      }
+    }
+
+    return optionalDevtools(showDevtools)(initializer, {
+      name: `LobeChat_${name}${isDev ? '_DEV' : ''}`,
+    });
+  };

package/dist/templates/createHyperStorage/index.ts

@@ -0,0 +1,127 @@
+import type { PersistStorage, StorageValue } from 'zustand/middleware';
+
+import { createIndexedDB } from './indexedDB';
+import { createKeyMapper } from './keyMapper';
+import { createLocalStorage } from './localStorage';
+import type { 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/dist/templates/createHyperStorage/indexedDB.ts

@@ -0,0 +1,31 @@
+import { createStore, delMany, getMany, setMany } from 'idb-keyval';
+import type { StorageValue } from 'zustand/middleware';
+
+export const createIndexedDB = <State>(dbName = '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/dist/templates/createHyperStorage/keyMapper.ts

@@ -0,0 +1,57 @@
+import type { 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/dist/templates/createHyperStorage/localStorage.ts

@@ -0,0 +1,23 @@
+import type { StorageValue } from 'zustand/middleware';
+
+export const createLocalStorage = <State>() => ({
+  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/dist/templates/createHyperStorage/type.ts

@@ -0,0 +1,27 @@
+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;

package/dist/templates/createHyperStorage/urlStorage.ts

@@ -0,0 +1,85 @@
+import { isEmpty } from 'lodash-es';
+import type { StorageValue } from 'zustand/middleware';
+
+interface UrlSearchHelper {
+  getUrlSearch: () => string;
+  setUrlSearch: (params: URLSearchParams) => void;
+}
+
+const createUrlSearch = (mode: 'search' | 'hash' = 'hash'): UrlSearchHelper => {
+  if (mode === 'hash')
+    return {
+      getUrlSearch: () => location.hash.slice(1),
+      setUrlSearch: (params: URLSearchParams) => {
+        location.hash = params.toString();
+      },
+    };
+
+  return {
+    getUrlSearch: () => location.search.slice(1),
+    setUrlSearch: (params: URLSearchParams) => {
+      if (params.size === 0) return;
+
+      history.replaceState({}, '', `?${params.toString()}`);
+    },
+  };
+};
+
+export const creatUrlStorage = <State extends object>(
+  mode: 'hash' | 'search' = 'hash',
+) => {
+  const { setUrlSearch, getUrlSearch } = createUrlSearch(mode);
+
+  return {
+    getItem: <T extends State>(): StorageValue<T> | undefined => {
+      const searchParameters = new URLSearchParams(getUrlSearch());
+
+      if (searchParameters.size === 0) return undefined;
+
+      const state = Object.fromEntries(searchParameters.entries()) as T;
+
+      return { state };
+    },
+    removeItem: (key?: string) => {
+      const searchParameters = new URLSearchParams(getUrlSearch());
+      if (key) searchParameters.delete(key);
+
+      setUrlSearch(searchParameters);
+    },
+    setItem: <T extends State>(name: string, state: T) => {
+      const searchParameters = new URLSearchParams(getUrlSearch());
+
+      for (const [urlKey, v] of Object.entries(state)) {
+        switch (typeof v) {
+          case 'boolean': {
+            searchParameters.set(urlKey, (v ? 1 : 0).toString());
+            break;
+          }
+
+          case 'bigint':
+          case 'number': {
+            searchParameters.set(urlKey, v.toString());
+            break;
+          }
+
+          case 'string': {
+            searchParameters.set(urlKey, v);
+            break;
+          }
+
+          case 'object': {
+            if (isEmpty(v)) {
+              searchParameters.delete(urlKey);
+              continue;
+            }
+
+            searchParameters.set(urlKey, JSON.stringify(v));
+            break;
+          }
+        }
+      }
+
+      setUrlSearch(searchParameters);
+    },
+  };
+};