@kevisual/api 0.0.42 → 0.0.43

package/dist/query-shop.js

@@ -0,0 +1,447 @@
+// node_modules/.pnpm/@kevisual+query@0.0.39/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.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 {
+    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;
+  }
+}
+
+// node_modules/.pnpm/@kevisual+router@0.0.69/node_modules/@kevisual/router/dist/router-define.js
+class Chain {
+  object;
+  app;
+  constructor(object, opts) {
+    this.object = object;
+    this.app = opts?.app;
+  }
+  get key() {
+    return this.object.key;
+  }
+  get path() {
+    return this.object.path;
+  }
+  setDescription(desc) {
+    this.object.description = desc;
+    return this;
+  }
+  setMeta(metadata) {
+    this.object.metadata = metadata;
+    return this;
+  }
+  setPath(path) {
+    this.object.path = path;
+    return this;
+  }
+  setMiddleware(middleware) {
+    this.object.middleware = middleware;
+    return this;
+  }
+  setKey(key) {
+    this.object.key = key;
+    return this;
+  }
+  setId(key) {
+    this.object.id = key;
+    return this;
+  }
+  setRun(run) {
+    this.object.run = run;
+    return this;
+  }
+  define(run) {
+    this.object.run = run;
+    return this;
+  }
+  createRoute() {
+    this.app.route(this.object).addTo(this.app);
+    return this;
+  }
+}
+
+class QueryChain {
+  obj = {};
+  query;
+  omitKeys = ["metadata", "description", "validator"];
+  constructor(value, opts) {
+    this.obj = value || {};
+    this.query = opts?.query;
+    if (opts?.omitKeys)
+      this.omitKeys = opts.omitKeys;
+  }
+  omit(obj, key = []) {
+    const newObj = { ...obj };
+    key.forEach((k) => {
+      delete newObj[k];
+    });
+    return newObj;
+  }
+  getKey(queryData) {
+    const obj = this.omit(this.obj, this.omitKeys);
+    return {
+      ...obj,
+      ...queryData
+    };
+  }
+  post(data, options) {
+    const _queryData = this.getKey(data);
+    return this.query.post(_queryData, options);
+  }
+  get(data, options) {
+    const _queryData = this.getKey(data);
+    return this.query.get(_queryData, options);
+  }
+}
+class QueryUtil {
+  obj;
+  app;
+  query;
+  constructor(object, opts) {
+    this.obj = object;
+    this.app = opts?.app;
+    this.query = opts?.query;
+  }
+  static createFormObj(object, opts) {
+    return new QueryUtil(object, opts);
+  }
+  static create(value, opts) {
+    const obj = value;
+    return new QueryUtil(obj, opts);
+  }
+  get(key) {
+    return this.obj[key];
+  }
+  chain(key, opts) {
+    const obj = this.obj[key];
+    let newOpts = { app: this.app, ...opts };
+    return new QueryUtil.Chain(obj, newOpts);
+  }
+  queryChain(key, opts) {
+    const value = this.obj[key];
+    let newOpts = { query: this.query, ...opts };
+    return new QueryUtil.QueryChain(value, newOpts);
+  }
+  static Chain = Chain;
+  static QueryChain = QueryChain;
+  get routeObject() {
+    return this.obj;
+  }
+}
+
+// query/index.ts
+var query = new Query;
+var clientQuery = new Query({ url: "/client/router" });
+
+// query/query-shop/defines/query-shop-define.ts
+var shopDefine = QueryUtil.create({
+  getRegistry: {
+    path: "shop",
+    key: "get-registry",
+    description: "获取应用商店注册表信息"
+  },
+  listInstalled: {
+    path: "shop",
+    key: "list-installed",
+    description: "列出当前已安装的所有应用"
+  },
+  install: {
+    path: "shop",
+    key: "install",
+    description: "安装指定的应用，可以指定 id、type、force 和 yes 参数"
+  },
+  uninstall: {
+    path: "shop",
+    key: "uninstall",
+    description: "卸载指定的应用，可以指定 id 和 type 参数"
+  }
+});
+
+// node_modules/.pnpm/@kevisual+query@0.0.39/node_modules/@kevisual/query/dist/query.js
+class BaseQuery {
+  query;
+  queryDefine;
+  constructor(opts) {
+    if (opts?.clientQuery) {
+      this.query = opts.clientQuery;
+    } else {
+      this.query = opts?.query;
+    }
+    if (opts.queryDefine) {
+      this.queryDefine = opts.queryDefine;
+      this.queryDefine.query = this.query;
+    }
+  }
+  get chain() {
+    return this.queryDefine.queryChain;
+  }
+  post(data, options) {
+    return this.query.post(data, options);
+  }
+  get(data, options) {
+    return this.query.get(data, options);
+  }
+}
+
+// query/query-shop/query-shop.ts
+class QueryShop extends BaseQuery {
+  constructor(opts) {
+    super({
+      query: opts?.query
+    });
+  }
+  getInstall(data, opts) {
+    return this.query.post(data, opts);
+  }
+}
+export {
+  shopDefine,
+  QueryShop
+};

package/dist/query-upload.d.ts

@@ -0,0 +1,153 @@
+interface UploadNProgress {
+    start: (msg?: string) => void;
+    done: () => void;
+    set: (progress: number) => void;
+}
+type UploadProgressData = {
+    progress: number;
+    progressFixed: number;
+    filename?: string;
+    taskId?: string;
+};
+type UploadProgressOpts = {
+    onStart?: () => void;
+    onDone?: () => void;
+    onProgress?: (progress: number, data?: UploadProgressData) => void;
+};
+declare class UploadProgress implements UploadNProgress {
+    /**
+     * 进度
+     */
+    progress: number;
+    /**
+     * 开始回调
+     */
+    onStart: (() => void) | undefined;
+    /**
+     * 结束回调
+     */
+    onDone: (() => void) | undefined;
+    /**
+     * 消息回调
+     */
+    onProgress: ((progress: number, data?: UploadProgressData) => void) | undefined;
+    /**
+     * 数据
+     */
+    data: any;
+    /**
+     * 是否结束
+     */
+    end: boolean;
+    constructor(uploadOpts: UploadProgressOpts);
+    start(msg?: string): void;
+    done(): void;
+    set(progress: number, data?: UploadProgressData): void;
+    /**
+     * 开始回调
+     */
+    setOnStart(callback: () => void): void;
+    /**
+     * 结束回调
+     */
+    setOnDone(callback: () => void): void;
+    /**
+     * 消息回调
+     */
+    setOnProgress(callback: (progress: number, data?: UploadProgressData) => void): void;
+    /**
+     * 打印信息
+     */
+    info(msg: string): void;
+    /**
+     * 打印错误
+     */
+    error(msg: string): void;
+    /**
+     * 打印警告
+     */
+    warn(msg: string): void;
+}
+
+type ConvertOpts$2 = {
+    appKey?: string;
+    version?: string;
+    username?: string;
+    directory?: string;
+    isPublic?: boolean;
+    filename?: string;
+    /**
+     * 是否不检查应用文件, 默认 true，默认不检测
+     */
+    noCheckAppFiles?: boolean;
+};
+type UploadOpts = {
+    uploadProgress: UploadProgress;
+    /**
+     * 创建 EventSource 兼容 nodejs
+     * @param baseUrl 基础 URL
+     * @param searchParams 查询参数
+     * @returns EventSource
+     */
+    createEventSource: (baseUrl: string, searchParams: URLSearchParams) => EventSource;
+    baseUrl?: string;
+    token: string;
+    FormDataFn: any;
+};
+declare const uploadFileChunked: (file: File, opts: ConvertOpts$2, opts2: UploadOpts) => Promise<unknown>;
+
+type ConvertOpts$1 = {
+    appKey?: string;
+    version?: string;
+    username?: string;
+    directory?: string;
+    /**
+     * 文件大小限制
+     */
+    maxSize?: number;
+    /**
+     * 文件数量限制
+     */
+    maxCount?: number;
+    /**
+     * 是否不检查应用文件, 默认 true，默认不检测
+     */
+    noCheckAppFiles?: boolean;
+};
+declare const uploadFiles: (files: File[], opts: ConvertOpts$1, opts2: UploadOpts) => Promise<unknown>;
+
+/**
+ * 把字符串转为文件流，并返回文件流，根据filename的扩展名，自动设置文件类型.
+ * 当不是文本类型，自动需要把base64的字符串转为blob
+ * @param content 字符串
+ * @param filename 文件名
+ * @returns 文件流
+ */
+declare const toFile: (content: string, filename: string) => File;
+
+declare const randomId: () => string;
+
+type UploadFileProps = {
+    onStart?: () => void;
+    onDone?: () => void;
+    onProgress?: (progress: number, data: UploadProgressData) => void;
+    onSuccess?: (res: any) => void;
+    onError?: (err: any) => void;
+    token?: string;
+};
+type ConvertOpts = {
+    appKey?: string;
+    version?: string;
+    username?: string;
+    directory?: string;
+    isPublic?: boolean;
+    filename?: string;
+    /**
+     * 是否不检查应用文件, 默认 true，默认不检测
+     */
+    noCheckAppFiles?: boolean;
+};
+declare const uploadChunk: (file: File, opts: ConvertOpts, props?: UploadFileProps) => Promise<unknown>;
+
+export { UploadProgress, randomId, toFile, uploadChunk, uploadFileChunked, uploadFiles };
+export type { ConvertOpts };