@4399ywkf/cli 0.0.22 → 1.0.3

package/dist/templates/src/utils/updateVersion.ts

@@ -0,0 +1,186 @@
+import { message, notification } from 'antd';
+import React from 'react';
+
+const APP_NAME = process.env.APP_NAME;
+interface IVersionRecord {
+  action: '' | 'refreshedByClick';
+  stack: string[];
+}
+// 对应的数组的key
+const RECORD_KEY = `${APP_NAME}_version_record`;
+
+// 当前版本号
+let CUR_VERSION = '';
+// 页面是否有通知
+let CUR_STATE = false;
+// 是否通过点击通知触发刷新
+let REFRESHED_BY_CLICK = false;
+
+window.addEventListener('beforeunload', () => {
+  if (!REFRESHED_BY_CLICK) {
+    const recordStr = localStorage.getItem(RECORD_KEY);
+    if (recordStr === null) return;
+    const record: IVersionRecord = JSON.parse(recordStr);
+    if (record.action !== '') {
+      record.action = '';
+      localStorage.setItem(RECORD_KEY, JSON.stringify(record));
+    }
+  }
+});
+
+const Interval = {
+  clearInterval: function () {
+    cancelAnimationFrame(this.timer);
+  },
+  setInterval: function (callback: any, interval: any) {
+    let startTime = new Date().valueOf();
+    let endTime = new Date().valueOf();
+    const self: any = this; // eslint-disable-line
+    const loop = () => {
+      self.timer = requestAnimationFrame(loop);
+      endTime = new Date().valueOf();
+      if (endTime - startTime >= interval) {
+        endTime = startTime = new Date().valueOf();
+        callback?.(); // eslint-disable-line
+      }
+    };
+    this.timer = requestAnimationFrame(loop);
+    return this.timer;
+  },
+  timer: 0,
+};
+
+/**
+ * 读取到更新的json文件版本内容
+ */
+const fetchUpdateVersionFile = () => {
+  return new Promise((resolve, reject) => {
+    fetch('/update_version.json')
+      .then(res => {
+        return res.body;
+      })
+      .then(body => {
+        const reader = body?.getReader();
+        if (reader) {
+          reader
+            .read()
+            .then(val => {
+              let str = '';
+              if (val.value) {
+                for (let i = 0; i < val.value.length; i++) {
+                  str += String.fromCharCode(val.value[i]);
+                }
+              }
+              return JSON.parse(str);
+            })
+            .then(json => {
+              resolve(json);
+            })
+            .catch(err => {
+              reject(err);
+            });
+        }
+      })
+      .catch(err => {
+        reject(err);
+      });
+  });
+};
+
+const ENV = process.env.NODE_ENV;
+
+const notifyUserUpdate = () => {
+  const handleClick = () => {
+    REFRESHED_BY_CLICK = true;
+    const recordStr = localStorage.getItem(RECORD_KEY);
+    if (recordStr === null) return;
+    const record: IVersionRecord = JSON.parse(recordStr);
+    record.action = 'refreshedByClick';
+    localStorage.setItem(RECORD_KEY, JSON.stringify(record));
+    window.location.reload();
+  };
+  const handleClose = () => {
+    Interval.clearInterval();
+    message.open({
+      content: '页面将不会提示更新',
+      type: 'warning',
+    });
+  };
+  const openNotification = () => {
+    const element = React.createElement(
+      'div', // 类型
+      {
+        onClick: handleClick,
+        style: { color: '#1677ff', cursor: 'pointer' },
+      }, // 属性
+      '页面已更新，请点击此处刷新页面!', // 子元素
+    );
+    notification.warning({
+      description: element,
+      duration: null,
+      message: '温馨提示',
+      onClose: handleClose,
+      placement: 'bottomRight',
+    });
+  };
+  openNotification();
+  CUR_STATE = true;
+};
+
+const handleMain = (version: string, handleCb: any, fetchDelay: number) => {
+  // 记录当前版本号
+  CUR_VERSION = version;
+  // 从本地获取历史记录
+  const oldVersionRecordStr = localStorage.getItem(RECORD_KEY);
+  // 继承历史记录中的action、stack
+  let oldAction: IVersionRecord['action'] = '';
+  const oldStack: IVersionRecord['stack'] = [version];
+  if (oldVersionRecordStr !== null) {
+    const record: IVersionRecord = JSON.parse(oldVersionRecordStr);
+    oldAction = record.action;
+  }
+  // 创建变量记录版本、操作
+  const curVersionRecord: IVersionRecord = {
+    action: oldAction,
+    stack: oldStack,
+  };
+
+  localStorage.setItem(RECORD_KEY, JSON.stringify(curVersionRecord));
+
+  Interval.setInterval(() => {
+    fetchUpdateVersionFile().then((res: any) => {
+      // 读取版本记录
+      const versionRecordStr = localStorage.getItem(RECORD_KEY);
+      if (typeof versionRecordStr === 'string') {
+        const versionRecord: IVersionRecord = JSON.parse(versionRecordStr);
+        // 读取对应栈
+        const lastVersion = versionRecord.stack[0];
+        localStorage.setItem(RECORD_KEY, JSON.stringify(versionRecord));
+        // 在服务器的版本与当前版本不一致
+        if (res.version !== CUR_VERSION) {
+          if (CUR_STATE === false) {
+            // 发起通知
+            handleCb();
+          } else if (
+            versionRecord.action === 'refreshedByClick' &&
+            lastVersion !== CUR_VERSION
+          ) {
+            // 上一个标签页更新过，且当前标签页未更新
+            REFRESHED_BY_CLICK = true;
+            window.location.reload();
+          }
+        }
+      }
+    });
+  }, fetchDelay);
+};
+
+export const openUpdateVersionNotify = (fetchDelay: number) => {
+  // 开发环境没有必要开启版本检测功能
+  if (ENV === 'development') {
+    return;
+  }
+  fetchUpdateVersionFile().then((res: any) => {
+    handleMain(res.version, notifyUserUpdate, fetchDelay);
+  });
+};

package/dist/templates/store/auth/index.tsx

@@ -0,0 +1,82 @@
+import { create } from "zustand";
+const Cookie = require("js-cookie");
+import jwt from "@config/jwt";
+import {
+  apiLogin,
+  apiLogout
+} from './indexApi';
+
+interface BearState {
+  showCaptcha: boolean,
+  captchaR: string,
+  loginStatus: boolean,
+  login: (params: LoginProps) => Promise<{loginStatus: boolean}>,
+  loginLoading: boolean,
+
+  logout: () => Promise<void>,
+}
+
+interface LoginProps {
+  payload: Object,
+  redirect?: string,
+}
+
+const useStore = create<BearState>()((set) => ({
+  showCaptcha: false,
+  loginStatus: false,
+  captchaR: (Math.random().toString(36).substr(2) + Math.random().toString(36).substr(2))
+    .slice(2, 18),
+  loginLoading: false,
+  login: async (params: LoginProps) => {
+    set({ loginLoading: true })
+    const { payload, redirect } = params;
+    let defaultUrl = ""
+    let client = Cookie.get("client");
+    if (!client) {
+      client = (Math.random().toString(36).substr(2) + Math.random().toString(36).substr(2))
+        .slice(2, 18);
+      Cookie.set('client', client);
+    }
+    try {
+      const { data } = await apiLogin({ ...payload, _xsrf: client })
+      // const { data } = yield call(apiLogin, { ...payload, _xsrf: client });
+      // yield put({ type: 'showCaptcha', payload: false });
+      set({ showCaptcha: false });
+      jwt.setAccessToken(data);
+      if (data?.path != "") {
+        defaultUrl = data?.path
+      }
+      if (redirect) {
+        defaultUrl = redirect
+      }
+      set({ loginStatus: true, loginLoading: false, })
+      return { loginStatus: true }
+      // yield put({ type: "setLoginStatus", payload: true })
+    } catch (error) {
+      // yield put({ type: 'updateCaptcha' });
+      set({
+        captchaR: (Math.random().toString(36).substr(2) + Math.random().toString(36).substr(2))
+          .slice(2, 18)
+      })
+
+      // yield put({ type: 'global/showMsg', payload: error });
+      if ((error as Error).message === '请输入验证码') {
+        set({ showCaptcha: true })
+        // yield put({ type: 'showCaptcha', payload: true });
+      }
+      set({ loginStatus: false, loginLoading: false })
+      // yield put({ type: "setLoginStatus", payload: false })
+      return { loginStatus: false }
+    }
+  },
+
+  logout:async () => {
+    await apiLogout({})
+    Cookie.remove(jwt.key);
+    Cookie.remove('_xsrf');
+  }
+
+}))
+
+
+export default useStore;

package/dist/templates/store/auth/indexApi.tsx

@@ -0,0 +1,11 @@
+import { Request } from '@config/request';
+
+const request = new Request({});
+
+export function apiLogin(params: any) {
+  return request.post('/main/gateway/login', params);
+}
+
+export function apiLogout(params: any) {
+  return request.put('/main/gateway/logout', params);
+}

package/dist/templates/store/global/index.tsx

@@ -0,0 +1,133 @@
+import type { SiderRoutesProps } from '@store/types';
+import _ from 'lodash-es';
+import { create } from 'zustand';
+import {
+  apiGetCopyright,
+  apiGetCurrentUser,
+  apiGetModule,
+  apiGetNav,
+} from './indexApi';
+import type { BearState, MicroActiveAppsProps } from './types';
+
+function addApp(stateMicroActiveApps, appInfo, set) {
+  // 如果已存在相同 id，则不处理
+  if (stateMicroActiveApps.find(o => o.id === appInfo.id)) return;
+  stateMicroActiveApps.push(appInfo);
+  set({ microActiveApps: stateMicroActiveApps });
+}
+
+function removeApp(stateMicroActiveApps, appInfo, set) {
+  const removeIndex = stateMicroActiveApps.findIndex(o => o.id === appInfo.id);
+  if (removeIndex === -1) return;
+  stateMicroActiveApps.splice(removeIndex, 1);
+  set({ microActiveApps: stateMicroActiveApps });
+}
+
+function updateApp(stateMicroActiveApps, appInfo, set) {
+  const updateIndex = stateMicroActiveApps.findIndex(o => o.id === appInfo.id);
+  if (updateIndex === -1) return;
+  stateMicroActiveApps[updateIndex] = appInfo;
+  set({ microActiveApps: stateMicroActiveApps });
+}
+
+const useGlobalStore = create<BearState>()((set, get) => ({
+  year: {
+    s: '0',
+    e: '0',
+  },
+  currentUser: {},
+  navCode: [],
+  microActiveApps: [],
+  siderRoutes: {}, // 侧边栏路由配置
+  getYearData: async (params: any) => {
+    const { data } = await apiGetCopyright(params);
+    set({ year: data.year });
+  },
+  syncGetCurrentUser: (params: any) => {
+    apiGetCurrentUser(params).then(res => {
+      const { data } = res;
+      set({ currentUser: data?.user });
+    });
+  },
+  getCurrentUser: async () => {
+    const { data } = await apiGetCurrentUser({});
+    set({ currentUser: data?.user });
+    return { currentUser: data?.user };
+  },
+  syncGetNav: (params: any) => {
+    apiGetNav(params).then(res => {
+      const { data } = res;
+      set({ navCode: data });
+    });
+  },
+  getNav: async (params: any) => {
+    const { data } = await apiGetNav(params);
+    set({ navCode: data });
+    return { navCode: data };
+  },
+  modules: [],
+  syncGetModule: (params: any) => {
+    apiGetModule(params).then(res => {
+      const { data } = res;
+      set({ modules: data });
+    });
+  },
+  // 获取各个模块的信息 [{name: "模块名字", path: "激活路径", "perarr": "权限位", id: "xx", defaultroute: "应用默认打开路由"}]
+  getModule: async (params: any) => {
+    const { data } = await apiGetModule(params);
+    set({ modules: data });
+    return { modules: data };
+  },
+  getBasicInfo: async (params: any) => {
+    try {
+      const getCurrentUser = get().getCurrentUser;
+      const currentUserRes = await getCurrentUser(params);
+      const getNav = get().getNav;
+      const navCodeRes = await getNav(params);
+      const getModule = get().getModule;
+      const modulesRes = await getModule(params);
+      return {
+        ...currentUserRes,
+        ...navCodeRes,
+        ...modulesRes,
+      };
+    } catch (error: any) {
+      console.log(error);
+      return {
+        currentUser: '',
+        navCode: [],
+        modules: [],
+      };
+    }
+  },
+  layout: {
+    renderFooter: false,
+    renderHeader: true,
+    renderSider: true,
+  },
+  setLayout: (params: BearState['layout']) => {
+    const stateLayout = get().layout;
+    set({ layout: { ...stateLayout, ...params } });
+  },
+  setMicroActiveApps: (params: MicroActiveAppsProps) => {
+    const { action, appInfo } = params;
+    const stateMicroActiveApps = _.cloneDeep(get().microActiveApps);
+    switch (action) {
+      case 'add':
+        addApp(stateMicroActiveApps, appInfo, set);
+        return;
+      case 'delete':
+        removeApp(stateMicroActiveApps, appInfo, set);
+        return;
+      case 'update':
+        updateApp(stateMicroActiveApps, appInfo, set);
+        return;
+    }
+  },
+  setSiderRoutes: (params: SiderRoutesProps) => {
+    const stateSiderRoutes = get().siderRoutes;
+    set({ siderRoutes: { ...stateSiderRoutes, ...params } });
+  },
+}));
+
+export default useGlobalStore;

package/dist/templates/store/global/indexApi.tsx

@@ -0,0 +1,19 @@
+import { Request } from '@config/request';
+
+const request = new Request({});
+
+export function apiGetCopyright(params: any) {
+  return request.get('/main/gateway/copyright', params);
+}
+
+export function apiGetCurrentUser(params: any) {
+  return request.get('/main/gateway/profile', params);
+}
+
+export function apiGetNav(params: any) {
+  return request.get('/main/gateway/perarr', params);
+}
+
+export function apiGetModule(params: any) {
+  return request.get('/main/gateway/module', params);
+}

package/dist/templates/store/global/types.ts

@@ -0,0 +1,62 @@
+import type { SiderRoutesProps } from '@store/types';
+
+export interface YearProps {
+  s: string;
+  e: string;
+}
+
+export interface moduleItemProps {
+  defaultroute?: string;
+  id: string;
+  name: string;
+  path: string;
+  perarr: string;
+}
+
+export interface currentUserProps {
+  apipasswd?: string;
+  cname?: string;
+  email?: string;
+  name?: string;
+  stype?: string;
+}
+
+export interface BearState {
+  year: YearProps;
+  getYearData: (params: any) => Promise<void>;
+  currentUser: currentUserProps;
+  getCurrentUser: (params: any) => Promise<{ currentUser: currentUserProps }>;
+  navCode: string[];
+  getNav: (params: any) => Promise<{ navCode: string[] }>;
+  modules: moduleItemProps[];
+  getModule: (params: any) => Promise<{ modules: moduleItemProps[] }>;
+  getBasicInfo: (params: any) => Promise<BasicInfoResponse>;
+
+  layout: {
+    renderSider?: boolean;
+    renderHeader?: boolean;
+    renderFooter?: boolean;
+  };
+
+  setLayout: (params: BearState['layout']) => void;
+
+  syncGetCurrentUser: (params: any) => void;
+  syncGetNav: (params: any) => void;
+  syncGetModule: (params: any) => void;
+
+  microActiveApps: any[];
+  setMicroActiveApps: (params: MicroActiveAppsProps) => void;
+  siderRoutes: SiderRoutesProps;
+  setSiderRoutes: (params: SiderRoutesProps) => void;
+}
+
+export interface MicroActiveAppsProps {
+  action: 'add' | 'delete' | 'update';
+  appInfo: any;
+}
+
+export interface BasicInfoResponse {
+  currentUser: Object;
+  navCode: string[];
+  modules: moduleItemProps[];
+}

package/dist/templates/store/middleware/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/store/middleware/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/store/middleware/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,
+    );
+  },
+});