@blocklet/pages-kit 0.2.299 → 0.2.301

package/lib/esm/builtin/async/ai-runtime/hooks/subscribe.js

@@ -1,33 +0,0 @@
-import { joinURL, withQuery } from 'ufo';
-import { useSessionContext } from '../../../session';
-import { getComponentMountPoint } from '../../../utils';
-import { PAYMENT_KIT_DID } from '../constants';
-import { useAssistantState } from '../state/assistant';
-import { useSubscriptionState } from '../state/subscription';
-export function useSubscribeLink({ assistantId }) {
-    var _a, _b, _c, _d, _e;
-    const [, state] = useSubscriptionState({ aid: assistantId });
-    const [assistant] = useAssistantState({ assistantId });
-    const { session: authSession } = useSessionContext();
-    const requireSubscribe = ((_b = (_a = assistant.release) === null || _a === void 0 ? void 0 : _a.payment) === null || _b === void 0 ? void 0 : _b.enable) && !state.subscription;
-    const isPaymentProject = (_d = (_c = assistant.release) === null || _c === void 0 ? void 0 : _c.payment) === null || _d === void 0 ? void 0 : _d.enable;
-    const subscribeLink = requireSubscribe && authSession.user && ((_e = state.release) === null || _e === void 0 ? void 0 : _e.paymentLinkId)
-        ? getSubscribeLink({
-            aid: assistantId,
-            userId: authSession.user.did,
-            paymentLinkId: state.release.paymentLinkId,
-        })
-        : undefined;
-    return {
-        requireSubscribe,
-        subscribeLink,
-        isPaymentProject,
-    };
-}
-function getSubscribeLink({ aid, userId, paymentLinkId }) {
-    return withQuery(joinURL('/', getComponentMountPoint(PAYMENT_KIT_DID), '/checkout/pay', paymentLinkId), {
-        'metadata.aid': aid,
-        'metadata.userId': userId,
-        redirect: window.location.href,
-    });
-}

package/lib/esm/builtin/async/ai-runtime/hooks/useAsync.js

@@ -1,29 +0,0 @@
-const PROMISE_CACHE = {};
-export default function useAsync(fn, keys) {
-    const key = keys.join('_');
-    let cache = PROMISE_CACHE[key];
-    if (!cache) {
-        const promise = fn();
-        const isPromise = promise instanceof Promise;
-        cache = {
-            promise: Promise.resolve(promise)
-                .then((result) => {
-                PROMISE_CACHE[key].result = result;
-            })
-                .catch((error) => {
-                PROMISE_CACHE[key].error = error;
-            })
-                .finally(() => {
-                PROMISE_CACHE[key].done = true;
-            }),
-            done: !isPromise,
-            result: isPromise ? undefined : promise,
-        };
-        PROMISE_CACHE[key] = cache;
-    }
-    if (cache.error)
-        throw cache.error;
-    if (cache.done)
-        return cache.result;
-    throw cache.promise;
-}

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

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

@@ -1,423 +0,0 @@
-"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/subscription.js

@@ -1,47 +0,0 @@
-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 { getRelease, getSubscription } from '../api/subscription';
-const STATES = {};
-export const createSubscriptionState = ({ aid }) => {
-    var _a;
-    (_a = STATES[aid]) !== null && _a !== void 0 ? _a : (STATES[aid] = create()(immer((set) => ({
-        load: () => __awaiter(void 0, void 0, void 0, function* () {
-            set((state) => {
-                state.loading = true;
-            });
-            try {
-                const [{ subscription }, release] = yield Promise.all([getSubscription({ aid }), getRelease({ aid })]);
-                set((state) => {
-                    state.subscription = subscription;
-                    state.release = release;
-                });
-            }
-            finally {
-                set((state) => {
-                    state.loading = false;
-                    state.loaded = true;
-                });
-            }
-        }),
-    }))));
-    return STATES[aid];
-};
-const LOADING_TASKS = {};
-export function useSubscriptionState({ aid }) {
-    var _a;
-    const state = createSubscriptionState({ aid })();
-    if (!state.loaded && !state.subscription) {
-        (_a = LOADING_TASKS[aid]) !== null && _a !== void 0 ? _a : (LOADING_TASKS[aid] = state.load());
-        throw LOADING_TASKS[aid];
-    }
-    return [state.subscription, state];
-}

package/lib/esm/builtin/async/ai-runtime/utils.js

@@ -1,42 +0,0 @@
-import { Base64 } from 'js-base64';
-export function parseIdentity(aid, options) {
-    let projectId;
-    let projectRef;
-    let assistantId;
-    try {
-        const s = Base64.decode(aid).split('/');
-        [projectId, projectRef, assistantId] = s.length === 3 ? s : s.length === 2 ? [s[0], 'main', s[1]] : [];
-    }
-    catch (error) {
-        console.error('parse assistantId error', { error });
-    }
-    if (projectId && projectRef && assistantId)
-        return { projectId, projectRef, assistantId };
-    if (options === null || options === void 0 ? void 0 : options.rejectWhenError)
-        throw new Error(`Invalid assistant identity ${aid}`);
-    return undefined;
-}
-export function stringifyIdentity({ projectId, projectRef, assistantId, }) {
-    return Base64.encodeURI([projectId, projectRef, assistantId].join('/'));
-}
-function isObject(obj) {
-    return typeof obj === 'object' && !Array.isArray(obj);
-}
-export function deepMerge(target, source) {
-    if (isObject(target) && isObject(source)) {
-        for (const key of Object.keys(source)) {
-            if (isObject(source[key])) {
-                if (!target[key] || !isObject(target[key]))
-                    target[key] = source[key];
-                deepMerge(target[key], source[key]);
-            }
-            else {
-                target[key] = source[key];
-            }
-        }
-    }
-}
-export const mergeSx = (initial, sx) => {
-    const mergedSx = [initial, ...(Array.isArray(sx) ? sx : [sx])];
-    return mergedSx;
-};

package/lib/types/builtin/async/ai-runtime/components/LoadingListItemButton.d.ts

@@ -1,5 +0,0 @@
-import { ListItemButtonProps } from '@mui/material';
-import { ReactNode } from 'react';
-export default function LoadingListItemButton({ children, confirmation, ...props }: ListItemButtonProps & {
-    confirmation?: ReactNode;
-}): import("react/jsx-runtime").JSX.Element;

package/lib/types/builtin/async/ai-runtime/components/PoweredBy.d.ts

@@ -1,4 +0,0 @@
-import { StackProps } from '@mui/material';
-export default function PoweredBy({ assistantId, ...props }: {
-    assistantId: string;
-} & StackProps): import("react/jsx-runtime").JSX.Element;

package/lib/types/builtin/async/ai-runtime/components/common/ChatBot.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="react" />
-type SizeProps = number | string;
-export interface ChatBotProps {
-    assistantId: string;
-    size?: SizeProps;
-    bottom?: SizeProps;
-    right?: SizeProps;
-    popperHeight?: SizeProps;
-    popperWidth?: SizeProps;
-    children?: React.ReactNode;
-}
-export default function ChatBot({ assistantId, size, bottom, right, children, popperWidth, popperHeight, }: ChatBotProps): import("react/jsx-runtime").JSX.Element | null;
-export {};