@lobehub/chat 1.0.0

package/src/utils/compass.ts

@@ -0,0 +1,94 @@
+import brotliPromise from 'brotli-wasm';
+
+/**
+ * @title 字符串压缩器
+ */
+export class StrCompressor {
+  /**
+   * @ignore
+   */
+  private instance!: {
+    compress(buf: Uint8Array, options?: any): Uint8Array;
+    decompress(buf: Uint8Array): Uint8Array;
+  };
+
+  async init(): Promise<void> {
+    this.instance = await brotliPromise; // Import is async in browsers due to wasm requirements!
+  }
+
+  /**
+   * @title 压缩字符串
+   * @param str - 要压缩的字符串
+   * @returns 压缩后的字符串
+   */
+  compress(str: string): string {
+    const input = new TextEncoder().encode(str);
+
+    const compressedData = this.instance.compress(input);
+
+    return this.urlSafeBase64Encode(compressedData);
+  }
+
+  /**
+   * @title 解压缩字符串
+   * @param str - 要解压缩的字符串
+   * @returns 解压缩后的字符串
+   */
+  decompress(str: string): string {
+    const compressedData = this.urlSafeBase64Decode(str);
+
+    const decompressedData = this.instance.decompress(compressedData);
+
+    return new TextDecoder().decode(decompressedData);
+  }
+
+  /**
+   * @title 异步压缩字符串
+   * @param str - 要压缩的字符串
+   * @returns Promise
+   */
+  async compressAsync(str: string) {
+    const brotli = await brotliPromise;
+
+    const input = new TextEncoder().encode(str);
+
+    const compressedData = brotli.compress(input);
+
+    return this.urlSafeBase64Encode(compressedData);
+  }
+
+  /**
+   * @title 异步解压缩字符串
+   * @param str - 要解压缩的字符串
+   * @returns Promise
+   */
+  async decompressAsync(str: string) {
+    const brotli = await brotliPromise;
+
+    const compressedData = this.urlSafeBase64Decode(str);
+
+    const decompressedData = brotli.decompress(compressedData);
+
+    return new TextDecoder().decode(decompressedData);
+  }
+
+  private urlSafeBase64Encode = (data: Uint8Array): string => {
+    const base64Str = btoa(String.fromCharCode(...data));
+    return base64Str.replaceAll('+', '_0_').replaceAll('/', '_').replace(/=+$/, '');
+  };
+
+  private urlSafeBase64Decode = (data: string): Uint8Array => {
+    let after = data.replaceAll('_0_', '+').replaceAll('_', '/');
+    while (after.length % 4) {
+      after += '=';
+    }
+
+    return new Uint8Array(
+      atob(after)
+        .split('')
+        .map((c) => c.charCodeAt(0)),
+    );
+  };
+}
+
+export const Compressor = new StrCompressor();

package/src/utils/fetch.ts

@@ -0,0 +1,132 @@
+// import { notification } from '@/layout';
+import { fetchChatModel } from '@/services/chatModel';
+import { ChatMessageError } from '@/types/chatMessage';
+
+const codeMessage: Record<number, string> = {
+  200: '成功获取数据，服务已响应',
+  201: '操作成功，数据已保存',
+  202: '您的请求已进入后台排队，请耐心等待异步任务完成',
+  204: '数据已成功删除',
+  400: '很抱歉，您的请求出错，服务器未执行任何数据的创建或修改操作',
+  401: '很抱歉，您的权限不足。请确认用户名或密码是否正确',
+  403: '很抱歉，您无权访问此内容',
+  404: '很抱歉，您请求的记录不存在，服务器未能执行任何操作',
+  406: '很抱歉，服务器不支持该请求格式',
+  410: '很抱歉，你所请求的资源已永久删除',
+  422: '很抱歉，在创建对象时遇到验证错误，请稍后再试',
+  500: '很抱歉，服务器出现了问题，请稍后再试',
+  502: '很抱歉，您遇到了网关错误。这可能是由于网络故障或服务器问题导致的。请稍后再试，或联系管理员以获取更多帮助',
+  503: '很抱歉，我们的服务器过载或处在维护中，服务暂时不可用',
+  504: '很抱歉，网关请求超时，请稍后再试',
+};
+
+export interface FetchSSEOptions {
+  onErrorHandle?: (error: ChatMessageError) => void;
+  onMessageHandle?: (text: string) => void;
+}
+
+/**
+ * 使用流式方法获取数据
+ * @param fetchFn
+ * @param options
+ */
+export const fetchSSE = async (fetchFn: () => Promise<Response>, options: FetchSSEOptions = {}) => {
+  const response = await fetchFn();
+
+  // 如果不 ok 说明有连接请求错误
+  if (!response.ok) {
+    const chatMessageError: ChatMessageError = {
+      message: codeMessage[response.status],
+      status: response.status,
+      type: 'general',
+    };
+
+    options.onErrorHandle?.(chatMessageError);
+    return;
+  }
+
+  const returnRes = response.clone();
+
+  const data = response.body;
+
+  if (!data) return;
+
+  const reader = data.getReader();
+  const decoder = new TextDecoder();
+
+  let done = false;
+
+  while (!done) {
+    const { value, done: doneReading } = await reader.read();
+    done = doneReading;
+    const chunkValue = decoder.decode(value);
+
+    options.onMessageHandle?.(chunkValue);
+  }
+
+  return returnRes;
+};
+
+interface FetchAITaskResultParams<T> {
+  abortController?: AbortController;
+  /**
+   * 错误处理函数
+   */
+  onError?: (e: Error) => void;
+  /**
+   * 加载状态变化处理函数
+   * @param loading - 是否处于加载状态
+   */
+  onLoadingChange?: (loading: boolean) => void;
+  /**
+   * 消息处理函数
+   * @param text - 消息内容
+   */
+  onMessageHandle?: (text: string) => void;
+
+  /**
+   * 请求对象
+   */
+  params: T;
+}
+
+export const fetchAIFactory =
+  <T>(fetcher: (params: T, signal?: AbortSignal) => Promise<Response>) =>
+  async ({
+    params,
+    onMessageHandle,
+    onError,
+    onLoadingChange,
+    abortController,
+  }: FetchAITaskResultParams<T>) => {
+    const errorHandle = (error: Error) => {
+      onLoadingChange?.(false);
+      if (abortController?.signal.aborted) {
+        // notification.primaryInfo({
+        //   message: '已中断当前节点的执行任务',
+        // });
+        return;
+      }
+
+      // notification?.error({
+      //   message: `请求失败(${error.message})`,
+      //   placement: 'bottomRight',
+      // });
+      onError?.(error);
+    };
+
+    onLoadingChange?.(true);
+
+    const data = await fetchSSE(() => fetcher(params, abortController?.signal), {
+      onErrorHandle: (error) => {
+        errorHandle(new Error(error.message));
+      },
+      onMessageHandle,
+    }).catch(errorHandle);
+
+    onLoadingChange?.(false);
+
+    return await data?.text();
+  };
+
+export const fetchPresetTaskResult = fetchAIFactory(fetchChatModel);

package/src/utils/filter.test.ts

@@ -0,0 +1,120 @@
+test('placeholder', () => {});
+// describe('filterWithKeywords', () => {
+//   const data: Record<string, BaseDataModel> = {
+//     1: {
+//       id: '1',
+//       meta: {
+//         title: 'hello world',
+//         description: 'test case',
+//         tag: ['a', 'b'],
+//       },
+//     },
+//     2: {
+//       id: '2',
+//       meta: {
+//         title: 'goodbye',
+//         description: 'hello world',
+//         tag: ['c', 'd'],
+//       },
+//     },
+//   };
+//
+//   it('should return an empty object if map is empty', () => {
+//     const result = filterWithKeywords({}, 'hello');
+//     expect(result).toEqual({});
+//   });
+//
+//   it('should return the original map if keywords is empty', () => {
+//     const result = filterWithKeywords(data, '');
+//     expect(result).toEqual(data);
+//   });
+//
+//   it('should return a filtered map if keywords is not empty', () => {
+//     const result = filterWithKeywords(data, 'world');
+//     expect(result).toEqual({
+//       1: {
+//         id: '1',
+//         meta: {
+//           title: 'hello world',
+//           description: 'test case',
+//           tag: ['a', 'b'],
+//         },
+//       },
+//       2: {
+//         id: '2',
+//         meta: {
+//           title: 'goodbye',
+//           description: 'hello world',
+//           tag: ['c', 'd'],
+//         },
+//       },
+//     });
+//   });
+//
+//   it('should only consider title, description and tag properties if extraSearchStr is not provided', () => {
+//     const result = filterWithKeywords(data, 'test');
+//     expect(result).toEqual({
+//       1: {
+//         id: '1',
+//         meta: {
+//           title: 'hello world',
+//           description: 'test case',
+//           tag: ['a', 'b'],
+//         },
+//       },
+//     });
+//   });
+//
+//   it('should consider extraSearchStr in addition to title, description and tag properties if provided', () => {
+//     const extraSearchStr = (item: BaseDataModel) => {
+//       return item.meta.avatar || '';
+//     };
+//     const data: Record<string, BaseDataModel> = {
+//       a: {
+//         id: 'a',
+//         meta: {
+//           title: 'hello world',
+//           description: 'test case',
+//           tag: ['a', 'b'],
+//           avatar: 'xxx',
+//         },
+//       },
+//       b: {
+//         id: 'b',
+//         meta: {
+//           title: 'goodbye',
+//           description: 'hello world',
+//           tag: ['c', 'd'],
+//           avatar: 'yyy',
+//         },
+//       },
+//     };
+//
+//     const result = filterWithKeywords(data, 'yyy', extraSearchStr);
+//     expect(result).toEqual({
+//       b: {
+//         id: 'b',
+//         meta: {
+//           title: 'goodbye',
+//           description: 'hello world',
+//           tag: ['c', 'd'],
+//           avatar: 'yyy',
+//         },
+//       },
+//     });
+//   });
+//
+//   it('should ensure that each filtered object has at least one property that includes the keyword or extraSearchStr', () => {
+//     const result = filterWithKeywords(data, 't');
+//     expect(result).toEqual({
+//       1: {
+//         id: '1',
+//         meta: {
+//           title: 'hello world',
+//           description: 'test case',
+//           tag: ['a', 'b'],
+//         },
+//       },
+//     });
+//   });
+// });

package/src/utils/filter.ts

@@ -0,0 +1,29 @@
+import { BaseDataModel } from '@/types/meta';
+
+export const filterWithKeywords = <T extends BaseDataModel>(
+  map: Record<string, T>,
+  keywords: string,
+  extraSearchStr?: (item: T) => string | string[],
+) => {
+  if (!keywords) return map;
+
+  return Object.fromEntries(
+    Object.entries(map).filter(([, item]) => {
+      const meta = item.meta;
+
+      const keyList = [meta.title, meta.description, meta.tag?.join('')].filter(
+        Boolean,
+      ) as string[];
+
+      const defaultSearchKey = keyList.join('');
+
+      let extraSearchKey: string = '';
+      if (extraSearchStr) {
+        const searchStr = extraSearchStr(item);
+        extraSearchKey = Array.isArray(searchStr) ? searchStr.join('') : searchStr;
+      }
+
+      return `${defaultSearchKey}${extraSearchKey}`.toLowerCase().includes(keywords.toLowerCase());
+    }),
+  );
+};

package/src/utils/uploadFIle.ts

@@ -0,0 +1,8 @@
+export const createUploadImageHandler =
+  (onUploadImage: (base64: string) => void) => (file: any) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file);
+    reader.addEventListener('load', () => {
+      onUploadImage(String(reader.result));
+    });
+  };

package/src/utils/uuid.ts

@@ -0,0 +1,9 @@
+// generate('1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 16); //=> "4f90d13a42"
+import { customAlphabet } from 'nanoid/non-secure';
+
+export const nanoid = customAlphabet(
+  '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+  8,
+);
+
+export { v4 as uuid } from 'uuid';

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "target": "ESNext",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "forceConsistentCasingInFileNames": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "preserve",
+    "incremental": true,
+    "baseUrl": ".",
+    "types": ["vitest/globals"],
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "exclude": ["node_modules"],
+  "include": ["next-env.d.ts", "**/*.ts", "**/*.d.ts", "**/*.tsx"]
+}

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'jsdom',
+    globals: true,
+    alias: {
+      '@': './src',
+    },
+  },
+});