@blocklet/pages-kit 0.2.286 → 0.2.288

package/lib/esm/builtin/async/ai-runtime/locales/index.js

@@ -0,0 +1,144 @@
+export const translations = {
+    en: {
+        socialShare: {
+            shareToX: 'Share to X',
+            shareToTelegram: 'Share to Telegram',
+            shareToReddit: 'Share to Reddit',
+            shareToWeibo: 'Share to Weibo',
+            shareToFacebook: 'Share to Facebook',
+            shareToLinkedin: 'Share to Linkedin',
+            copyLink: 'Copy Link',
+        },
+        questionPlaceholder: 'Ask Anything...',
+        parameters: 'Parameters',
+        parametersTitle: 'Tell me what do you want?',
+        parametersSetting: 'Setting',
+        clearSession: 'Clear Session',
+        generate: 'Generate',
+        startChat: 'Start Chat',
+        collections: 'Collections',
+        collection: 'Collection',
+        collectionName: 'Collection Name',
+        document: 'Document',
+        rename: 'Rename',
+        delete: 'Delete',
+        confirmDelete: 'Confirm Delete?',
+        noData: 'No {data} yet',
+        createObject: 'Create {object}',
+        title: 'Title',
+        titlePlaceholder: 'Title',
+        content: 'Content',
+        contentPlaceholder: 'Write anything...',
+        cancel: 'Cancel',
+        save: 'Save',
+        edit: 'Edit',
+        chat: 'Chat',
+        subscribeNow: 'Subscribe Now',
+        requireNewSubscription: `Thank you for using our service!
+
+  To get more features and exclusive content, please subscribe to our service. After subscribing, you will enjoy the following privileges:
+
+  - Unlock all features and tools
+  - Support us to continue to provide quality services
+
+  Pricing: {price} ABT/Message
+
+  Subscribe now to unlock more possibilities!`,
+        requireNewSubscriptionFooter: 'You need to subscribe to access this feature:',
+        thanksForSubscription: 'Thanks for subscribing, now you can start enjoying it!',
+        clickTheButton: 'Click The Button 👉',
+        cleanSessionTip: 'Clean conversation messages',
+        poweredBy: 'Powered by',
+        selectPromptToStart: 'Select a prompt to get started',
+        history: 'History',
+        unnamed: 'Unnamed',
+        newObject: 'New {object}',
+        editObject: 'Edit {object}',
+        name: 'Name',
+        description: 'Description',
+        create: 'Create',
+        back: 'Back',
+        unauthorized: 'Unauthorized',
+        unauthorizedDescription: 'Please log in to visit this page',
+        login: 'Login',
+        copy: 'Copy',
+        copied: 'Copied',
+        copyToClipboard: 'Copy to clipboard',
+        saveToNoteTip: 'Save to collection',
+        saveToNote: 'Save',
+        savedToNote: 'Saved as a new document',
+        uploadFile: 'Upload File',
+        submit: 'Submit',
+    },
+    zh: {
+        socialShare: {
+            shareToX: '分享到 X',
+            shareToTelegram: '分享到 Telegram',
+            shareToReddit: '分享到 Reddit',
+            shareToWeibo: '分享到 微博',
+            shareToFacebook: '分享到 Facebook',
+            shareToLinkedin: '分享到 Linkedin',
+            copyLink: '复制链接',
+        },
+        questionPlaceholder: '问点什么...',
+        parameters: '参数',
+        parametersTitle: '告诉我你想要什么？',
+        parametersSetting: '设置',
+        clearSession: '清空对话',
+        generate: '生成',
+        startChat: '开始对话',
+        collections: '知识库',
+        collection: '知识库',
+        collectionName: '知识库名称',
+        document: '文档',
+        rename: '重命名',
+        delete: '删除',
+        confirmDelete: '确定删除？',
+        noData: '暂无{data}',
+        createObject: '创建{object}',
+        title: '标题',
+        titlePlaceholder: '标题',
+        content: '内容',
+        contentPlaceholder: '写点什么吧...',
+        cancel: '取消',
+        save: '保存',
+        edit: '编辑',
+        chat: '对话',
+        subscribeNow: '立即订阅',
+        requireNewSubscription: `感谢您使用我们的服务！
+
+  为了获得更多功能和专属内容，请订阅我们的服务。订阅后，您将享有以下特权：
+
+  - 解锁全部功能和工具
+  - 支持我们持续提供优质服务
+
+  价格： {price} ABT/次对话
+
+  立即订阅以解锁更多可能性！`,
+        requireNewSubscriptionFooter: '您需要订阅才能访问此功能：',
+        thanksForSubscription: '感谢您的订阅，现在，您可以开始尽情体验了！',
+        clickTheButton: '点我生成 👉',
+        cleanSessionTip: '清除会话消息记录',
+        poweredBy: '技术支持来自',
+        selectPromptToStart: '选择一个提示词开始吧',
+        history: '历史记录',
+        unnamed: '未命名',
+        newObject: '新建{object}',
+        editObject: '编辑{object}',
+        name: '名称',
+        description: '描述',
+        create: '创建',
+        back: '返回',
+        unauthorized: '未登录',
+        unauthorizedDescription: '请登录后访问该页面',
+        login: '登录',
+        copy: '复制',
+        copied: '已复制',
+        copyToClipboard: '复制到剪贴板',
+        saveToNoteTip: '保存到知识库',
+        saveToNote: '保存',
+        savedToNote: '已保存到知识库',
+        uploadFile: '上传文件',
+        submit: '提交',
+    },
+};

package/lib/esm/builtin/async/ai-runtime/state/assistant.js

@@ -0,0 +1,54 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+import { getAssistant } from '../api/assistant';
+const STATES = {};
+export const createAssistantState = ({ assistantId, assistant }) => {
+    var _a;
+    (_a = STATES[assistantId]) !== null && _a !== void 0 ? _a : (STATES[assistantId] = create()(immer((set) => ({
+        assistant,
+        load: () => __awaiter(void 0, void 0, void 0, function* () {
+            set((state) => {
+                state.loading = true;
+            });
+            try {
+                const assistant = yield getAssistant({ assistantId });
+                set((state) => {
+                    state.assistant = assistant;
+                });
+            }
+            catch (error) {
+                console.error(error);
+                set((state) => {
+                    state.error = error;
+                });
+            }
+            finally {
+                set((state) => {
+                    state.loading = false;
+                });
+            }
+        }),
+    }))));
+    return STATES[assistantId];
+};
+const LOADING_TASKS = {};
+export function useAssistantState({ assistantId }) {
+    var _a;
+    const state = createAssistantState({ assistantId })();
+    if (!state.assistant) {
+        if (state.error)
+            throw state.error;
+        (_a = LOADING_TASKS[assistantId]) !== null && _a !== void 0 ? _a : (LOADING_TASKS[assistantId] = state.load());
+        throw LOADING_TASKS[assistantId];
+    }
+    return [state.assistant, state];
+}

package/lib/esm/builtin/async/ai-runtime/state/index.js

@@ -0,0 +1,423 @@
+"use strict";
+// import { StoreApi, UseBoundStore, create } from 'zustand';
+// import { immer } from 'zustand/middleware/immer';
+// import { EventSourceParserStream } from '../../../stream';
+// import { getComponentMountPoint, joinURL } from '../../../utils';
+// import { Assistant, getAssistant } from '../api/assistant';
+// import {
+//   Dataset,
+//   createDataset,
+//   createDocument,
+//   deleteDataset,
+//   deleteDocument,
+//   getDataset,
+//   getDatasets,
+//   getDocuments,
+//   updateDataset,
+//   updateDocument,
+// } from '../api/dataset';
+// import { deleteMessages, getMessages } from '../api/message';
+// import { Session, createSession, getSessions, updateSession } from '../api/session';
+// import { Subscription, getSubscription } from '../api/subscription';
+// import { AI_STUDIO_DID } from '../constants';
+// import { parseIdentity } from '../utils';
+// const STATES: {
+//   assistant: { [key: string]: UseBoundStore<StoreApi<State>> };
+//   dataset: { [key: string]: ReturnType<typeof createDatasetState> };
+//   datasetDetail: { [key: string]: ReturnType<typeof createDatasetDetailState> };
+// } = { assistant: {}, dataset: {}, datasetDetail: {} };
+// export interface State {
+//   loading: boolean;
+//   loaded: boolean;
+//   assistant?: Assistant;
+//   sessions?: Session[];
+//   subscription?: Subscription;
+//   sessionMap: { [sessionId: string]: { session: Session } };
+//   computed: {
+//     get isChat(): boolean | undefined;
+//     get requireNewSubscription(): boolean | undefined;
+//   };
+// }
+// export const createState = ({
+//   releaseId,
+//   preload: { assistant, sessions, subscription } = {},
+// }: {
+//   releaseId: string;
+//   preload?: {
+//     assistant?: Assistant;
+//     sessions?: Session[];
+//     subscription?: Subscription;
+//   };
+// }) => {
+//   STATES.assistant[releaseId] ??= create<State>()(
+//     immer<State>((set, get) => ({
+//       loading: false,
+//       loaded: false,
+//       assistant,
+//       sessions,
+//       subscription,
+//       sessionMap: Object.fromEntries((sessions ?? []).map((session) => [session.id, { session }])),
+//       computed: {
+//         get isChat() {
+//           const parameters = get().assistant?.parameters;
+//           return parameters?.some((i) => i.key === 'question');
+//         },
+//         get requireNewSubscription() {
+//           // TODO: implement payment
+//           // const { subscription } = get();
+//           // const { paymentEnabled, paymentLinkId } = release;
+//           // return !!paymentEnabled && !!paymentLinkId && !subscription;
+//           return false;
+//         },
+//         get withCollection() {
+//           const parameters = get().assistant?.parameters;
+//           return parameters?.some((i) => i.key === 'datasetId');
+//         },
+//       },
+//       getPaymentLink({ userId }: { userId: string }) {
+//         // TODO: implement
+//         // return withQuery(
+//         //   joinURL('/', getComponentMountPoint(PAYMENT_KIT_DID), '/checkout/pay', release.paymentLinkId),
+//         //   {
+//         //     'metadata.releaseId': release.id,
+//         //     'metadata.userId': userId,
+//         //     redirect: window.location.href,
+//         //   }
+//         // );
+//       },
+//       getAssistant: async () => {
+//         set((state) => {
+//           state.loading = true;
+//         });
+//         try {
+//           const { subscription } = await getSubscription({ releaseId });
+//           const identity = parseIdentity(releaseId, { rejectWhenError: true });
+//           const [assistant, { sessions }] = await Promise.all([getAssistant(identity), getSessions(identity)]);
+//           set((state) => {
+//             state.assistant = assistant;
+//             state.sessions = sessions;
+//             state.subscription = subscription;
+//             state.sessionMap = Object.fromEntries(
+//               (sessions ?? []).map((session) => [session.id, { ...state.sessionMap[session.id], session }])
+//             );
+//           });
+//         } finally {
+//           set((state) => {
+//             state.loading = false;
+//             state.loaded = true;
+//           });
+//         }
+//       },
+//       getSessions: async () => {
+//         const identity = parseIdentity(releaseId, { rejectWhenError: true });
+//         const { sessions } = await getSessions(identity);
+//         set((state) => {
+//           state.sessions = sessions;
+//           state.sessionMap = Object.fromEntries(
+//             (sessions ?? []).map((session) => [session.id, { ...state.sessionMap[session.id], session }])
+//           );
+//         });
+//       },
+//       reloadMessages: async ({ sessionId }) => {
+//         set((state) => {
+//           const s = state.sessionMap[sessionId];
+//           if (!s) return;
+//           s.loading = true;
+//         });
+//         try {
+//           const { messages, count } = await getMessages({ sessionId });
+//           set((state) => {
+//             const s = state.sessionMap[sessionId];
+//             if (!s) return;
+//             s.messages = messages;
+//             s.messageCount = count;
+//           });
+//         } finally {
+//           set((state) => {
+//             const s = state.sessionMap[sessionId];
+//             if (!s) return;
+//             s.loading = false;
+//           });
+//         }
+//       },
+//       cleanSession: async ({ sessionId }) => {
+//         set((state) => {
+//           const s = state.sessionMap[sessionId];
+//           if (s) s.sessionReseting = true;
+//         });
+//         await deleteMessages({ sessionId });
+//         set((state) => {
+//           const s = state.sessionMap[sessionId];
+//           if (s) {
+//             s.sessionReseting = false;
+//             s.messages = [];
+//           }
+//         });
+//       },
+//       createSession: async ({ name, parameters, entry }) => {
+//         const identity = parseIdentity(releaseId);
+//         const { sessions, created } = await createSession({ ...identity, name, parameters, entry });
+//         set((state) => {
+//           state.sessions = sessions;
+//           state.sessionMap = Object.fromEntries(
+//             (sessions ?? []).map((session) => [session.id, { ...state.sessionMap[session.id], session }])
+//           );
+//         });
+//         return created;
+//       },
+//       updateSession: async ({ sessionId, parameters }) => {
+//         set((state) => {
+//           const s = state.sessionMap[sessionId].session;
+//           if (s.parameters) Object.assign(s.parameters, parameters);
+//         });
+//         const { sessions } = await updateSession({ sessionId, parameters });
+//         set((state) => {
+//           state.sessions = sessions;
+//           state.sessionMap = Object.fromEntries(
+//             (sessions ?? []).map((session) => [session.id, { ...state.sessionMap[session.id], session }])
+//           );
+//         });
+//       },
+//       execute: async ({ sessionId, parameters, onResponseStart, assistantIdentity }) => {
+//         const identity = parseIdentity(releaseId);
+//         let message;
+//         const childMessages = [];
+//         const childMessagesMap = {};
+//         set((state) => {
+//           const session = state.sessionMap[sessionId];
+//           if (session) session.executing = true;
+//         });
+//         try {
+//           const res = await fetch(joinURL(getComponentMountPoint(AI_STUDIO_DID), '/api/ai/call'), {
+//             method: 'POST',
+//             headers: {
+//               'Content-Type': 'application/json',
+//               Accept: 'text/event-stream',
+//             },
+//             body: JSON.stringify({
+//               sessionId,
+//               parameters: { ...parameters, $clientTime: new Date().toISOString() },
+//               ...(assistantIdentity || identity),
+//               ref: (assistantIdentity || identity).projectRef,
+//               working: true,
+//             }),
+//           });
+//           if (!(res.status >= 200 && res.status < 300)) {
+//             let json: any;
+//             try {
+//               json = await res.json();
+//             } catch (error) {}
+//             const { message } = json.error;
+//             if (typeof message === 'string') {
+//               throw new Error(message);
+//             }
+//             throw new Error(`Unknown Error: ${res.status}`);
+//           }
+//           const stream = res
+//             .body!.pipeThrough(new TextDecoderStream())
+//             .pipeThrough(new EventSourceParserStream())
+//             .getReader();
+//           let responseStarted = false;
+//           for (;;) {
+//             const { value, done } = await stream.read();
+//             if (!responseStarted) {
+//               responseStarted = true;
+//               onResponseStart?.();
+//             }
+//             if (value?.type === 'CHUNK') {
+//               if (!message) {
+//                 message = {
+//                   taskId: value.taskId,
+//                   parameters,
+//                   loading: true,
+//                   createdAt: new Date().toISOString(),
+//                 };
+//                 set((state) => {
+//                   state.sessionMap[sessionId] ??= {};
+//                   state.sessionMap[sessionId].messages ??= [];
+//                   state.sessionMap[sessionId].messages.push(message);
+//                 });
+//               }
+//               if (message.taskId === value.taskId) {
+//                 set((state) => {
+//                   const msg = state.sessionMap[sessionId]?.messages?.findLast((i) => i.taskId === message.taskId);
+//                   if (!msg) return;
+//                   msg.result ??= {};
+//                   msg.result.content = (msg.result.content || '') + (value.delta.content || '');
+//                   if (value.delta.object) {
+//                     msg.result.objects ??= [];
+//                     msg.result.objects.push(value.delta.object);
+//                     if (value.delta.object.metadata) {
+//                       const session = state.sessionMap[sessionId];
+//                       session.metadata ??= {};
+//                       deepMerge(session.metadata, value.delta.object.metadata);
+//                     }
+//                   }
+//                   if (value.delta?.images?.length) {
+//                     msg.result.images = (msg.result.images ?? []).concat(value.delta.images);
+//                   }
+//                 });
+//               } else if (value.respondAs && value.respondAs !== 'none') {
+//                 let childMessage = childMessagesMap[value.taskId];
+//                 if (!childMessage) {
+//                   childMessage = {
+//                     taskId: value.taskId,
+//                     createdAt: new Date().toISOString(),
+//                     respondAs: value.respondAs,
+//                   };
+//                   childMessagesMap[value.taskId] = childMessage;
+//                   childMessages.push(childMessage);
+//                 }
+//                 childMessage.result ??= {};
+//                 childMessage.result.content = (childMessage.result.content || '') + (value.delta.content || '');
+//                 if (value.delta?.images?.length) {
+//                   childMessage.result.images = (childMessage.result.images ?? []).concat(value.delta.images);
+//                 }
+//                 set((state) => {
+//                   const msg = state.sessionMap[sessionId]?.messages?.findLast((i) => i.taskId === message.taskId);
+//                   if (!msg) return;
+//                   msg.result ??= {};
+//                   msg.result.messages = JSON.parse(JSON.stringify(childMessages));
+//                 });
+//               }
+//             }
+//             if (value?.type === 'ERROR') {
+//               set((state) => {
+//                 const msg = state.sessionMap[sessionId]?.messages?.findLast((i) => i.taskId === message.taskId);
+//                 if (msg) msg.error = value.error;
+//                 else throw new Error(value.error.message);
+//               });
+//             }
+//             if (done) break;
+//           }
+//         } finally {
+//           set((state) => {
+//             const session = state.sessionMap[sessionId];
+//             session.executing = false;
+//             if (session && message) {
+//               const msg = session.messages?.findLast((i) => i.taskId === message.taskId);
+//               if (msg) msg.loading = false;
+//             }
+//           });
+//         }
+//       },
+//     }))
+//   );
+//   return STATES.assistant[releaseId]!;
+// };
+// export function createDatasetState({ releaseId, datasets }: { releaseId: string; datasets?: Dataset[] }) {
+//   STATES.dataset[releaseId] ??= create()(
+//     immer((set) => ({
+//       loading: false,
+//       list: datasets,
+//       error: undefined,
+//       creating: false,
+//       async reload() {
+//         try {
+//           set((state) => {
+//             state.loading = true;
+//           });
+//           const datasets = await getDatasets({ appId: releaseId });
+//           set((state) => {
+//             state.loading = false;
+//             state.list = datasets;
+//             state.error = undefined;
+//           });
+//         } catch (error) {
+//           set((state) => {
+//             state.loading = false;
+//             state.error = error;
+//           });
+//         }
+//       },
+//       async createDataset({ name, description }: { name: string; description?: string }) {
+//         try {
+//           set((state) => {
+//             state.creating = true;
+//           });
+//           const created = await createDataset({ appId: releaseId, name, description });
+//           await this.reload();
+//           return created;
+//         } finally {
+//           set((state) => {
+//             state.creating = false;
+//           });
+//         }
+//       },
+//       async updateDataset(datasetId: string, { name, description }: { name: string; description?: string }) {
+//         const updated = await updateDataset(datasetId, { name, description });
+//         await this.reload();
+//         return updated;
+//       },
+//       async deleteDataset(datasetId: string) {
+//         await deleteDataset(datasetId);
+//         await this.reload();
+//       },
+//     }))
+//   );
+//   return STATES.dataset[releaseId];
+// }
+// export function createDatasetDetailState({ datasetId, list }: { datasetId: string; list?: Document[] }) {
+//   STATES.datasetDetail[datasetId] ??= create()(
+//     immer((set, get) => ({
+//       loading: false,
+//       dataset: undefined,
+//       list,
+//       error: undefined,
+//       creating: false,
+//       async reload() {
+//         if (get().loading) return;
+//         set((state) => {
+//           state.loading = true;
+//         });
+//         try {
+//           const [dataset, { items }] = await Promise.all([getDataset({ datasetId }), getDocuments(datasetId)]);
+//           set((state) => {
+//             state.dataset = dataset;
+//             state.loading = false;
+//             state.list = items;
+//             state.error = undefined;
+//           });
+//         } catch (error) {
+//           set((state) => {
+//             state.loading = false;
+//             state.error = error;
+//           });
+//         }
+//       },
+//       async createDocument(type: 'text' | 'file', input: Parameters<typeof createDocument>[1]) {
+//         try {
+//           set((state) => {
+//             state.creating = true;
+//           });
+//           const created = await createDocument(datasetId, type, input);
+//           await this.reload();
+//           return created;
+//         } finally {
+//           set((state) => {
+//             state.creating = false;
+//           });
+//         }
+//       },
+//       async updateDocument(documentId: string, type: 'text', input: Parameters<typeof updateDocument>[1]) {
+//         try {
+//           set((state) => {
+//             state.updating = true;
+//           });
+//           const updated = await updateDocument(datasetId, documentId, type, input);
+//           await this.reload();
+//           return updated;
+//         } finally {
+//           set((state) => {
+//             state.updating = false;
+//           });
+//         }
+//       },
+//       async deleteDocument(documentId) {
+//         await deleteDocument(datasetId, documentId);
+//         await this.reload();
+//       },
+//     }))
+//   );
+//   return STATES.datasetDetail[datasetId];
+// }

package/lib/esm/builtin/async/ai-runtime/state/loading.js

@@ -0,0 +1,36 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+export const globalLoadingState = create()(immer((set, get) => ({
+    loading: false,
+    count: 0,
+    run: (fn) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            get().start();
+            return (yield (typeof fn === 'function' ? fn() : fn));
+        }
+        finally {
+            get().end();
+        }
+    }),
+    start: () => {
+        set((state) => {
+            state.count += 1;
+            state.loading = true;
+        });
+    },
+    end: () => {
+        set((state) => {
+            state.count = Math.max(0, state.count - 1);
+            state.loading = state.count > 0;
+        });
+    },
+})));