@kevisual/api 0.0.46 → 0.0.48

package/dist/query-mark.d.ts

@@ -0,0 +1,100 @@
+import { Query } from '@kevisual/query';
+import { Result, DataOpts } from '@kevisual/query/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 ShowMarkPick = Pick<Mark, 'id' | 'title' | 'description' | 'summary' | 'link' | 'tags' | 'thumbnail' | 'updatedAt'>;
+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;
+    };
+};
+type QueryMarkData = {
+    id?: string;
+    title?: string;
+    description?: string;
+    [key: string]: any;
+};
+type QueryMarkResult = {
+    accessToken: string;
+    refreshToken: string;
+};
+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<Result<ResultMarkList>>;
+    getMark(id: string, opts?: DataOpts): Promise<Result<Mark>>;
+    getVersion(id: string, opts?: DataOpts): Promise<Result<{
+        version: number;
+        id: string;
+    }>>;
+    /**
+     * 检查版本
+     * 当需要更新时，返回true
+     * @param id
+     * @param version
+     * @param opts
+     * @returns
+     */
+    checkVersion(id: string, version?: number, opts?: DataOpts): Promise<boolean>;
+    updateMark(data: any, opts?: DataOpts): Promise<Result<Mark>>;
+    deleteMark(id: string, opts?: DataOpts): Promise<Result<Mark>>;
+}
+declare class QueryMark extends QueryMarkBase<SimpleObject> {
+    markType: string;
+    constructor(opts?: QueryMarkOpts & {
+        markType?: MarkType;
+    });
+    getMarkList(search?: SearchOpts, opts?: DataOpts): Promise<Result<ResultMarkList>>;
+    updateMark(data: any, opts?: DataOpts): Promise<Result<Mark>>;
+}
+
+export { QueryMark, QueryMarkBase, markType };
+export type { Mark, MarkData, MarkType, QueryMarkData, QueryMarkOpts, QueryMarkResult, ResultMarkList, SearchOpts, ShowMarkPick, SimpleObject };

package/dist/query-mark.js

@@ -0,0 +1,342 @@
+// node_modules/.pnpm/@kevisual+query@0.0.40/node_modules/@kevisual/query/dist/query-browser.js
+var isTextForContentType = (contentType) => {
+  if (!contentType)
+    return false;
+  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md"];
+  return textTypes.some((type) => contentType.includes(type));
+};
+var adapter = async (opts = {}, overloadOpts) => {
+  const controller = new AbortController;
+  const signal = controller.signal;
+  const isPostFile = opts.isPostFile || false;
+  let responseType = opts.responseType || "json";
+  if (opts.isBlob) {
+    responseType = "blob";
+  } else if (opts.isText) {
+    responseType = "text";
+  }
+  const timeout = opts.timeout || 60000 * 3;
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+  let method = overloadOpts?.method || opts?.method || "POST";
+  let headers = { ...opts?.headers, ...overloadOpts?.headers };
+  let origin = "";
+  let url;
+  if (opts?.url?.startsWith("http")) {
+    url = new URL(opts.url);
+  } else {
+    origin = window?.location?.origin || "http://localhost:51515";
+    url = new URL(opts?.url || "", origin);
+  }
+  const isGet = method === "GET";
+  const oldSearchParams = url.searchParams;
+  if (isGet) {
+    let searchParams = new URLSearchParams({ ...Object.fromEntries(oldSearchParams), ...opts?.params, ...opts?.body });
+    url.search = searchParams.toString();
+  } else {
+    const params = {
+      ...Object.fromEntries(oldSearchParams),
+      ...opts.params
+    };
+    const searchParams = new URLSearchParams(params);
+    if (typeof opts.body === "object" && opts.body !== null) {
+      let body2 = opts.body || {};
+      if (!params.path && body2?.path) {
+        searchParams.set("path", body2.path);
+        if (body2?.key) {
+          searchParams.set("key", body2.key);
+        }
+      }
+    }
+    url.search = searchParams.toString();
+  }
+  let body = undefined;
+  if (isGet) {
+    body = undefined;
+  } else if (isPostFile) {
+    body = opts.body;
+  } else {
+    if (opts.body && typeof opts.body === "object" && !(opts.body instanceof FormData)) {
+      headers = {
+        "Content-Type": "application/json",
+        ...headers
+      };
+      body = JSON.stringify(opts.body);
+    }
+  }
+  return fetch(url, {
+    method: method.toUpperCase(),
+    signal,
+    body,
+    ...overloadOpts,
+    headers
+  }).then(async (response) => {
+    const contentType = response.headers.get("Content-Type");
+    if (responseType === "blob") {
+      return await response.blob();
+    }
+    const isText = responseType === "text";
+    const isJson = contentType && contentType.includes("application/json");
+    if (isJson && !isText) {
+      return await response.json();
+    } else if (isTextForContentType(contentType)) {
+      return {
+        code: response.status,
+        status: response.status,
+        data: await response.text()
+      };
+    } else {
+      return response;
+    }
+  }).catch((err) => {
+    if (err.name === "AbortError") {
+      return {
+        code: 408,
+        message: "请求超时"
+      };
+    }
+    return {
+      code: 500,
+      message: err.message || "网络错误"
+    };
+  }).finally(() => {
+    clearTimeout(timer);
+  });
+};
+var wrapperError = ({ code, message }) => {
+  const result = {
+    code: code || 500,
+    success: false,
+    message: message || "api request error",
+    showError: (fn) => {},
+    noMsg: true
+  };
+  return result;
+};
+
+class Query {
+  adapter;
+  url;
+  beforeRequest;
+  afterResponse;
+  headers;
+  timeout;
+  stop;
+  qws;
+  isClient = false;
+  constructor(opts) {
+    this.adapter = opts?.adapter || adapter;
+    const defaultURL = opts?.isClient ? "/client/router" : "/api/router";
+    this.url = opts?.url || defaultURL;
+    this.headers = opts?.headers || {
+      "Content-Type": "application/json"
+    };
+    this.timeout = opts?.timeout || 60000 * 3;
+    if (opts?.beforeRequest) {
+      this.beforeRequest = opts.beforeRequest;
+    } else {
+      this.beforeRequest = async (opts2) => {
+        const token = globalThis?.localStorage?.getItem("token");
+        if (token) {
+          opts2.headers = {
+            ...opts2.headers,
+            Authorization: `Bearer ${token}`
+          };
+        }
+        return opts2;
+      };
+    }
+  }
+  setQueryWs(qws) {
+    this.qws = qws;
+  }
+  setStop(stop) {
+    this.stop = stop;
+  }
+  async get(params, options) {
+    return this.post(params, options);
+  }
+  async post(body, options) {
+    const url = options?.url || this.url;
+    const { headers, adapter: adapter2, beforeRequest, afterResponse, timeout, ...rest } = options || {};
+    const _headers = { ...this.headers, ...headers };
+    const _adapter = adapter2 || this.adapter;
+    const _beforeRequest = beforeRequest || this.beforeRequest;
+    const _afterResponse = afterResponse || this.afterResponse;
+    const _timeout = timeout || this.timeout;
+    const req = {
+      url,
+      headers: _headers,
+      body,
+      timeout: _timeout,
+      ...rest
+    };
+    try {
+      if (_beforeRequest) {
+        const res = await _beforeRequest(req);
+        if (res === false) {
+          return wrapperError({
+            code: 500,
+            message: "request is cancel",
+            req
+          });
+        }
+      }
+    } catch (e) {
+      console.error("request beforeFn error", e, req);
+      return wrapperError({
+        code: 500,
+        message: "api request beforeFn error"
+      });
+    }
+    if (this.stop && !options?.noStop) {
+      const that = this;
+      await new Promise((resolve) => {
+        let timer = 0;
+        const detect = setInterval(() => {
+          if (!that.stop) {
+            clearInterval(detect);
+            resolve(true);
+          }
+          timer++;
+          if (timer > 30) {
+            console.error("request stop: timeout", req.url, timer);
+          }
+        }, 1000);
+      });
+    }
+    return _adapter(req).then(async (res) => {
+      try {
+        if (_afterResponse) {
+          return await _afterResponse(res, {
+            req,
+            res,
+            fetch: adapter2
+          });
+        }
+        return res;
+      } catch (e) {
+        console.error("request afterFn error", e, req);
+        return wrapperError({
+          code: 500,
+          message: "api request afterFn error"
+        });
+      }
+    });
+  }
+  before(fn) {
+    this.beforeRequest = fn;
+  }
+  after(fn) {
+    this.afterResponse = fn;
+  }
+  async fetchText(urlOrOptions, options) {
+    let _options = { ...options };
+    if (typeof urlOrOptions === "string" && !_options.url) {
+      _options.url = urlOrOptions;
+    }
+    if (typeof urlOrOptions === "object") {
+      _options = { ...urlOrOptions, ..._options };
+    }
+    const res = await adapter({
+      method: "GET",
+      ..._options,
+      headers: {
+        ...this.headers,
+        ..._options?.headers || {}
+      }
+    });
+    if (res && !res.code) {
+      return {
+        code: 200,
+        data: res
+      };
+    }
+    return res;
+  }
+}
+
+// query/query-mark/index.ts
+var markType = ["simple", "md", "mdx", "wallnote", "excalidraw", "chat"];
+
+class QueryMarkBase {
+  query;
+  isBrowser;
+  load;
+  storage;
+  onLoad;
+  constructor(opts) {
+    this.query = opts?.query || new Query;
+    this.isBrowser = opts?.isBrowser ?? true;
+    this.init();
+    this.onLoad = opts?.onLoad;
+  }
+  setQuery(query) {
+    this.query = query;
+  }
+  async init() {
+    this.load = true;
+    this.onLoad?.();
+  }
+  async post(data, opts) {
+    try {
+      return this.query.post({ path: "mark", ...data }, opts);
+    } catch (error) {
+      console.log("error", error);
+      return {
+        code: 400
+      };
+    }
+  }
+  async getMarkList(search, opts) {
+    return this.post({ key: "list", ...search }, opts);
+  }
+  async getMark(id, opts) {
+    return this.post({ key: "get", id }, opts);
+  }
+  async getVersion(id, opts) {
+    return this.post({ key: "getVersion", id }, opts);
+  }
+  async checkVersion(id, version, opts) {
+    if (!version) {
+      return true;
+    }
+    const res = await this.getVersion(id, opts);
+    if (res.code === 200) {
+      if (res.data.version > version) {
+        return true;
+      }
+      return false;
+    }
+    return true;
+  }
+  async updateMark(data, opts) {
+    return this.post({ key: "update", data }, opts);
+  }
+  async deleteMark(id, opts) {
+    return this.post({ key: "delete", id }, opts);
+  }
+}
+
+class QueryMark extends QueryMarkBase {
+  markType;
+  constructor(opts) {
+    super(opts);
+    this.markType = opts?.markType || "simple";
+  }
+  async getMarkList(search, opts) {
+    return this.post({ key: "list", ...search, markType: this.markType }, opts);
+  }
+  async updateMark(data, opts) {
+    if (!data.id) {
+      data.markType = this.markType || "simple";
+    }
+    return super.updateMark(data, opts);
+  }
+}
+export {
+  markType,
+  QueryMarkBase,
+  QueryMark
+};

package/dist/query-proxy.d.ts

@@ -0,0 +1,215 @@
+import { QueryClient, Result } from '@kevisual/query';
+import { QueryRouterServer, Route } from '@kevisual/router/browser';
+import { EventEmitter } from 'eventemitter3';
+import { QueryRouterServer as QueryRouterServer$1, App } from '@kevisual/router';
+
+declare const RouteTypeList: readonly ["api", "context", "worker", "page"];
+type RouterViewItemInfo = RouterViewApi | RouterViewContext | RouterViewWorker | RouteViewPage;
+type RouterViewItem<T = {}> = RouterViewItemInfo & T;
+type RouteViewBase = {
+    /**
+     * _id 用于纯本地存储标识
+     */
+    _id?: string;
+    id?: string;
+    title?: string;
+    description?: string;
+    enabled?: boolean;
+    /**
+     *  响应数据
+     */
+    response?: any;
+    /**
+     * 默认动作配置
+     */
+    action?: {
+        path?: string;
+        key?: string;
+        id?: string;
+        payload?: any;
+        [key: string]: any;
+    };
+};
+type RouterViewApi = {
+    type: 'api';
+    api: {
+        url: string;
+        query?: QueryClient;
+    };
+} & RouteViewBase;
+type RouterViewContext = {
+    type: 'context';
+    context: {
+        key: string;
+        router?: QueryRouterServer;
+    };
+} & RouteViewBase;
+type RouterViewWorker = {
+    type: 'worker';
+    worker: {
+        type: 'Worker' | 'SharedWorker' | 'serviceWorker';
+        url: string;
+        worker?: Worker | SharedWorker | ServiceWorker;
+        /**
+         * worker选项
+         * default: { type: 'module' }
+         */
+        workerOptions?: {
+            type: 'module' | 'classic';
+        };
+    };
+} & RouteViewBase;
+/**
+ * 去掉不需要保存都服务器的数据
+ * @param item
+ * @returns
+ */
+declare const pickRouterViewData: (item: RouterViewItem) => {
+    type: "api";
+    api: {
+        url: string;
+        query?: QueryClient;
+    };
+    id?: string;
+    title?: string;
+    description?: string;
+    enabled?: boolean;
+} | {
+    type: "context";
+    context: {
+        key: string;
+        router?: QueryRouterServer;
+    };
+    id?: string;
+    title?: string;
+    description?: string;
+    enabled?: boolean;
+} | {
+    type: "worker";
+    worker: {
+        type: "Worker" | "SharedWorker" | "serviceWorker";
+        url: string;
+        worker?: Worker | SharedWorker | ServiceWorker;
+        /**
+         * worker选项
+         * default: { type: 'module' }
+         */
+        workerOptions?: {
+            type: "module" | "classic";
+        };
+    };
+    id?: string;
+    title?: string;
+    description?: string;
+    enabled?: boolean;
+} | {
+    type: "page";
+    page: {
+        url: string;
+    };
+    id?: string;
+    title?: string;
+    description?: string;
+    enabled?: boolean;
+};
+/**
+ * 注入 js 的url地址，使用importScripts加载
+ */
+type RouteViewPage = {
+    type: 'page';
+    page: {
+        url: string;
+    };
+} & RouteViewBase;
+type RouterViewQuery = {
+    id: string;
+    query: string;
+    title: string;
+};
+type RouterViewData = {
+    data: {
+        items: RouterViewItem[];
+    };
+    views: RouterViewQuery[];
+    viewId?: string;
+    [key: string]: any;
+};
+declare class QueryProxy {
+    router: QueryRouterServer;
+    token?: string;
+    routerViewItems: RouterViewItem[];
+    views: RouterViewQuery[];
+    emitter: EventEmitter;
+    constructor(opts?: {
+        router?: QueryRouterServer;
+        token?: string;
+        routerViewData?: RouterViewData;
+    });
+    getDefulatToken(): string;
+    initRouterViewQuery(): void;
+    initRouterView(item: RouterViewItem): RouterViewItem<{}>;
+    /**
+     * 初始化路由
+     * main
+     * @returns
+     */
+    init(): Promise<void>;
+    /**
+     * 监听初始化完成
+     * @returns
+     */
+    listenInitComplete(): Promise<boolean>;
+    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;
+    /**
+     * 列出路由
+     * @param filter
+     * @param query WHERE metadata.tags CONTAINS 'premium'
+     * @returns
+     */
+    listRoutes(filterFn?: (item: Route) => boolean, opts?: {
+        viewId?: string;
+        query?: string;
+    }): Promise<any>;
+    getViewQuery(viewId: string): Promise<string>;
+    /**
+     * 运行路由
+     * @param msg
+     * @returns
+     */
+    run(msg: {
+        id?: string;
+        path?: string;
+        key?: string;
+    }): Promise<any>;
+    runByRouteView(routeView: RouterViewItem): Promise<RouterViewItem<{}>>;
+}
+type RouterItem = {
+    id?: string;
+    path?: string;
+    key?: string;
+    description?: string;
+    middleware?: string[];
+    metadata?: Record<string, any>;
+};
+
+declare const initApi: (opts: {
+    item?: RouterViewApi;
+    router: QueryRouterServer$1 | App;
+    token?: string;
+    /**
+     * WHERE path = 'auth' OR path = 'router' OR path = 'call'
+     */
+    exclude?: string;
+}) => Promise<{
+    code: any;
+    message: string;
+}>;
+
+export { QueryProxy, RouteTypeList, initApi, pickRouterViewData };
+export type { RouteViewPage, RouterItem, RouterViewApi, RouterViewContext, RouterViewData, RouterViewItem, RouterViewItemInfo, RouterViewQuery, RouterViewWorker };