@kevisual/api 0.0.48 → 0.0.50

package/dist/query-proxy.d.ts

@@ -1,4 +1,4 @@
-import { QueryClient, Result } from '@kevisual/query';
+import { QueryClient } from '@kevisual/query';
 import { QueryRouterServer, Route } from '@kevisual/router/browser';
 import { EventEmitter } from 'eventemitter3';
 import { QueryRouterServer as QueryRouterServer$1, App } from '@kevisual/router';
@@ -60,7 +60,7 @@ type RouterViewWorker = {
     };
 } & RouteViewBase;
 /**
- * 去掉不需要保存都服务器的数据
+ * 去掉不需要保存的服务器的数据
  * @param item
  * @returns
  */
@@ -113,7 +113,7 @@ declare const pickRouterViewData: (item: RouterViewItem) => {
     enabled?: boolean;
 };
 /**
- * 注入 js 的url地址，使用importScripts加载
+ * 注入 js 的url地址，使用 importScripts 加载
  */
 type RouteViewPage = {
     type: 'page';
@@ -126,6 +126,9 @@ type RouterViewQuery = {
     query: string;
     title: string;
 };
+/**
+ * 后端存储结构
+ */
 type RouterViewData = {
     data: {
         items: RouterViewItem[];
@@ -145,9 +148,9 @@ declare class QueryProxy {
         token?: string;
         routerViewData?: RouterViewData;
     });
-    getDefulatToken(): string;
+    private getDefulatToken;
     initRouterViewQuery(): void;
-    initRouterView(item: RouterViewItem): RouterViewItem<{}>;
+    private initRouterView;
     /**
      * 初始化路由
      * main
@@ -162,10 +165,10 @@ declare class QueryProxy {
     initApi(item?: RouterViewApi): Promise<void>;
     initContext(item?: RouterViewContext): Promise<void>;
     generateId(): string;
-    callWorker(msg: any, viewItem: RouterViewWorker['worker']): Promise<Result>;
-    initWorker(item?: RouterViewWorker, initRoutes?: boolean): Promise<void>;
-    initPage(item?: RouteViewPage): Promise<void>;
-    getQueryByViewId(viewId: string): string | undefined;
+    private callWorker;
+    private initWorker;
+    private initPage;
+    private getQueryByViewId;
     /**
      * 列出路由
      * @param filter
@@ -175,8 +178,8 @@ declare class QueryProxy {
     listRoutes(filterFn?: (item: Route) => boolean, opts?: {
         viewId?: string;
         query?: string;
-    }): Promise<any>;
-    getViewQuery(viewId: string): Promise<string>;
+    }): Promise<any[]>;
+    getViewQuery(viewId: string): Promise<string | undefined>;
     /**
      * 运行路由
      * @param msg
@@ -197,6 +200,7 @@ type RouterItem = {
     middleware?: string[];
     metadata?: Record<string, any>;
 };
+declare const createViewData: (routerViewData: RouterViewItem | RouterViewItem[], data?: RouterViewData) => RouterViewData;
 
 declare const initApi: (opts: {
     item?: RouterViewApi;
@@ -207,9 +211,9 @@ declare const initApi: (opts: {
      */
     exclude?: string;
 }) => Promise<{
-    code: any;
+    code: number;
     message: string;
 }>;
 
-export { QueryProxy, RouteTypeList, initApi, pickRouterViewData };
+export { QueryProxy, RouteTypeList, createViewData, initApi, pickRouterViewData };
 export type { RouteViewPage, RouterItem, RouterViewApi, RouterViewContext, RouterViewData, RouterViewItem, RouterViewItemInfo, RouterViewQuery, RouterViewWorker };

package/dist/query-proxy.js

@@ -8839,6 +8839,7 @@ var initApi = async (opts) => {
       let metadata = r.metadata || {};
       metadata.viewItem = item;
       metadata.url = query.url;
+      metadata.source = "query-proxy-api";
       router.route({
         path: r.path,
         key: r.key || "",
@@ -10307,6 +10308,7 @@ class QueryProxy {
       console.debug(`注册路由: [${r.path}] ${r?.key}`, "Context");
       let metadata = r.metadata || {};
       metadata.viewItem = item;
+      metadata.source = "query-proxy-context";
       this.router.route({
         path: r.path,
         key: r.key || "",
@@ -10399,6 +10401,7 @@ class QueryProxy {
         console.debug(`注册路由: [${r.path}] ${r?.key}`, "API");
         let metadata = r.metadata || {};
         metadata.viewItem = item;
+        metadata.source = "query-proxy-worker";
         this.router.route({
           path: r.path,
           key: r.key || "",
@@ -10504,13 +10507,24 @@ class QueryProxy {
       item.response = res;
       return item;
     }
-    item.response = { code: 500, message: "无法处理的路由类型" };
+    item.response = { code: 500, message: "无法处理的路由类型", data: item };
     return item;
   }
 }
+var createViewData = (routerViewData, data) => {
+  return {
+    views: [],
+    viewId: undefined,
+    data: {
+      items: Array.isArray(routerViewData) ? routerViewData : [routerViewData]
+    },
+    ...data
+  };
+};
 export {
   pickRouterViewData,
   initApi,
+  createViewData,
   RouteTypeList,
   QueryProxy
 };

package/dist/query-secret.d.ts

@@ -28,17 +28,39 @@ type PostOpts = {
 declare class QueryConfig {
     query: Query;
     constructor(opts?: QueryConfigOpts);
-    post<T = Config>(data: any): Promise<any>;
+    post<T = Config>(data: any): Promise<{
+        code: number;
+        data?: T | undefined;
+        message?: string;
+    }>;
     getItem({ id, key }: {
         id?: string;
         key?: string;
-    }, opts?: PostOpts): Promise<any>;
-    updateItem(data: Config, opts?: PostOpts): Promise<any>;
+    }, opts?: PostOpts): Promise<{
+        code: number;
+        data?: Config<any> | undefined;
+        message?: string;
+    }>;
+    updateItem(data: Config, opts?: PostOpts): Promise<{
+        code: number;
+        data?: Config<any> | undefined;
+        message?: string;
+    }>;
     deleteItem(data: {
         id?: string;
         key?: string;
-    }, opts?: PostOpts): Promise<any>;
-    listItems(opts?: PostOpts): Promise<any>;
+    }, opts?: PostOpts): Promise<{
+        code: number;
+        data?: Config<any> | undefined;
+        message?: string;
+    }>;
+    listItems(opts?: PostOpts): Promise<{
+        code: number;
+        data?: {
+            list: Config[];
+        } | undefined;
+        message?: string;
+    }>;
 }
 
 export { QueryConfig };

package/dist/query-shop.d.ts

@@ -1,12 +1,38 @@
 import { Query, BaseQuery, DataOpts } from '@kevisual/query/query';
+import { QueryUtil } from '@kevisual/router/define';
 
-declare const shopDefine: any;
+declare const shopDefine: QueryUtil<{
+    getRegistry: {
+        path: string;
+        key: string;
+        description: string;
+    };
+    listInstalled: {
+        path: string;
+        key: string;
+        description: string;
+    };
+    install: {
+        path: string;
+        key: string;
+        description: string;
+    };
+    uninstall: {
+        path: string;
+        key: string;
+        description: string;
+    };
+}>;
 
 declare class QueryShop<T extends Query = Query> extends BaseQuery<T> {
     constructor(opts?: {
         query: T;
     });
-    getInstall(data: any, opts?: DataOpts): any;
+    getInstall(data: any, opts?: DataOpts): Promise<{
+        code: number;
+        data?: any;
+        message?: string;
+    }>;
 }
 
 export { QueryShop, shopDefine };

package/dist/store-auth.d.ts

@@ -0,0 +1,30 @@
+import * as zustand from 'zustand';
+
+type Me = {
+    id?: string;
+    username?: string;
+    nickname?: string | null;
+    needChangePassword?: boolean;
+    role?: string;
+    description?: string | null;
+    type?: 'user' | 'org';
+    orgs?: string[];
+    avatar?: string;
+};
+type LayoutStore = {
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    me: Me;
+    setMe: (me: Me) => void;
+    getMe: () => Promise<void>;
+    openUser: boolean;
+    setOpenUser: (openUser: boolean) => void;
+    switchOrg: (username?: string, type?: 'user' | 'org') => Promise<void>;
+    isAdmin: boolean;
+    setIsAdmin: (isAdmin: boolean) => void;
+    checkHasOrg: () => boolean;
+};
+declare const useLayoutStore: zustand.UseBoundStore<zustand.StoreApi<LayoutStore>>;
+
+export { useLayoutStore };
+export type { LayoutStore };

package/dist/store-auth.js

@@ -0,0 +1,43 @@
+// store/store-auth/index.ts
+import { create } from "zustand";
+import { toast } from "sonner";
+import { useContextKey } from "@kevisual/context";
+var queryLogin = useContextKey("queryLogin");
+var useLayoutStore = create((set, get) => ({
+  open: false,
+  setOpen: (open) => set({ open }),
+  me: {},
+  setMe: (me) => set({ me }),
+  getMe: async () => {
+    const res = await queryLogin.getMe();
+    if (res.code === 200) {
+      set({ me: res.data });
+      set({ isAdmin: res.data.orgs?.includes("admin") });
+    }
+  },
+  openUser: false,
+  setOpenUser: (openUser) => set({ openUser }),
+  switchOrg: async (username, type) => {
+    const res = await queryLogin.switchUser(username || "");
+    if (res.code === 200) {
+      toast.success("Switch success");
+      setTimeout(() => {
+        window.location.reload();
+      }, 1000);
+    } else {
+      toast.error(res.message || "Request failed");
+    }
+  },
+  isAdmin: false,
+  setIsAdmin: (isAdmin) => set({ isAdmin }),
+  checkHasOrg: () => {
+    const user = get().me || {};
+    if (!user.orgs) {
+      return false;
+    }
+    return user?.orgs?.length > 0;
+  }
+}));
+export {
+  useLayoutStore
+};

package/dist/store-mark.d.ts

@@ -0,0 +1,154 @@
+import * as zustand from 'zustand';
+import { Result, DataOpts } from '@kevisual/query/query';
+import { Query } from '@kevisual/query';
+
+type SimpleObject = Record<string, any>;
+declare const markType: readonly ["simple", "md", "mdx", "wallnote", "excalidraw", "chat"];
+type MarkType = (typeof markType)[number];
+type MarkData = {
+    nodes?: any[];
+    edges?: any[];
+    elements?: any[];
+    permission?: any;
+    [key: string]: any;
+};
+type Mark = {
+    id: string;
+    title: string;
+    description: string;
+    markType: MarkType;
+    link: string;
+    data?: MarkData;
+    uid: string;
+    puid: string;
+    summary: string;
+    thumbnail?: string;
+    tags: string[];
+    createdAt: string;
+    updatedAt: string;
+    version: number;
+};
+type SearchOpts = {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    sort?: string;
+    markType?: MarkType;
+    [key: string]: any;
+};
+type QueryMarkOpts<T extends SimpleObject = SimpleObject> = {
+    query?: Query;
+    isBrowser?: boolean;
+    onLoad?: () => void;
+} & T;
+type ResultMarkList = {
+    list: Mark[];
+    pagination: {
+        pageSize: number;
+        current: number;
+        total: number;
+    };
+};
+declare class QueryMarkBase<T extends SimpleObject = SimpleObject> {
+    query: Query;
+    isBrowser: boolean;
+    load?: boolean;
+    storage?: Storage;
+    onLoad?: () => void;
+    constructor(opts?: QueryMarkOpts<T>);
+    setQuery(query: Query): void;
+    private init;
+    post<T = Result<any>>(data: any, opts?: DataOpts): Promise<T>;
+    getMarkList(search: SearchOpts, opts?: DataOpts): Promise<{
+        code: number;
+        data?: ResultMarkList | undefined;
+        message?: string;
+    }>;
+    getMark(id: string, opts?: DataOpts): Promise<{
+        code: number;
+        data?: Mark | undefined;
+        message?: string;
+    }>;
+    getVersion(id: string, opts?: DataOpts): Promise<{
+        code: number;
+        data?: {
+            version: number;
+            id: string;
+        } | undefined;
+        message?: string;
+    }>;
+    /**
+     * 检查版本
+     * 当需要更新时，返回true
+     * @param id
+     * @param version
+     * @param opts
+     * @returns
+     */
+    checkVersion(id: string, version?: number, opts?: DataOpts): Promise<boolean>;
+    updateMark(data: any, opts?: DataOpts): Promise<{
+        code: number;
+        data?: Mark | undefined;
+        message?: string;
+    }>;
+    deleteMark(id: string, opts?: DataOpts): Promise<{
+        code: number;
+        data?: Mark | undefined;
+        message?: string;
+    }>;
+}
+declare class QueryMark extends QueryMarkBase<SimpleObject> {
+    markType: string;
+    constructor(opts?: QueryMarkOpts & {
+        markType?: MarkType;
+    });
+    getMarkList(search?: SearchOpts, opts?: DataOpts): Promise<{
+        code: number;
+        data?: ResultMarkList | undefined;
+        message?: string;
+    }>;
+    updateMark(data: any, opts?: DataOpts): Promise<{
+        code: number;
+        data?: Mark | undefined;
+        message?: string;
+    }>;
+}
+
+type ManagerStore = {
+    /** 当前选中的Mark */
+    currentMarkId: string;
+    setCurrentMarkId: (markId: string) => void;
+    markData?: Mark | undefined;
+    setMarkData: (mark?: Partial<Mark>) => void;
+    /** 获取Mark列表 */
+    getList: () => Promise<any>;
+    getMarkFromList: (markId: string) => Mark | undefined;
+    updateMark: (mark: Mark) => Promise<any>;
+    getMark: (markId: string) => Promise<Result<Mark>>;
+    deleteMark: (markId: string) => Promise<any>;
+    /** Mark列表 */
+    list: Mark[];
+    setList: (list: Mark[]) => void;
+    pagination: {
+        current: number;
+        pageSize: number;
+        total: number;
+    };
+    setPagination: (pagination: {
+        current: number;
+        pageSize: number;
+        total: number;
+    }) => void;
+    /** 搜索 */
+    search: string;
+    setSearch: (search: string) => void;
+    /** 初始化 */
+    init: (markType: MarkType) => Promise<void>;
+    queryMark?: QueryMark;
+    markType?: MarkType;
+    open: boolean;
+    setOpen: (open: boolean) => void;
+};
+declare const useMarkStore: zustand.UseBoundStore<zustand.StoreApi<ManagerStore>>;
+
+export { useMarkStore };