@kevisual/api 0.0.46 → 0.0.47

package/dist/query-remote.d.ts

@@ -0,0 +1 @@
+export { RemoteApp } from '@kevisual/remote-app';

package/dist/query-remote.js

@@ -0,0 +1,433 @@
+// node_modules/.pnpm/@kevisual+remote-app@0.0.4/node_modules/@kevisual/remote-app/dist/app.js
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var require_eventemitter3 = __commonJS((exports, module) => {
+  var has = Object.prototype.hasOwnProperty;
+  var prefix = "~";
+  function Events() {}
+  if (Object.create) {
+    Events.prototype = Object.create(null);
+    if (!new Events().__proto__)
+      prefix = false;
+  }
+  function EE(fn, context, once) {
+    this.fn = fn;
+    this.context = context;
+    this.once = once || false;
+  }
+  function addListener(emitter, event, fn, context, once) {
+    if (typeof fn !== "function") {
+      throw new TypeError("The listener must be a function");
+    }
+    var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+    if (!emitter._events[evt])
+      emitter._events[evt] = listener, emitter._eventsCount++;
+    else if (!emitter._events[evt].fn)
+      emitter._events[evt].push(listener);
+    else
+      emitter._events[evt] = [emitter._events[evt], listener];
+    return emitter;
+  }
+  function clearEvent(emitter, evt) {
+    if (--emitter._eventsCount === 0)
+      emitter._events = new Events;
+    else
+      delete emitter._events[evt];
+  }
+  function EventEmitter() {
+    this._events = new Events;
+    this._eventsCount = 0;
+  }
+  EventEmitter.prototype.eventNames = function eventNames() {
+    var names = [], events, name;
+    if (this._eventsCount === 0)
+      return names;
+    for (name in events = this._events) {
+      if (has.call(events, name))
+        names.push(prefix ? name.slice(1) : name);
+    }
+    if (Object.getOwnPropertySymbols) {
+      return names.concat(Object.getOwnPropertySymbols(events));
+    }
+    return names;
+  };
+  EventEmitter.prototype.listeners = function listeners(event) {
+    var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+    if (!handlers)
+      return [];
+    if (handlers.fn)
+      return [handlers.fn];
+    for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+      ee[i] = handlers[i].fn;
+    }
+    return ee;
+  };
+  EventEmitter.prototype.listenerCount = function listenerCount(event) {
+    var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+    if (!listeners)
+      return 0;
+    if (listeners.fn)
+      return 1;
+    return listeners.length;
+  };
+  EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return false;
+    var listeners = this._events[evt], len = arguments.length, args, i;
+    if (listeners.fn) {
+      if (listeners.once)
+        this.removeListener(event, listeners.fn, undefined, true);
+      switch (len) {
+        case 1:
+          return listeners.fn.call(listeners.context), true;
+        case 2:
+          return listeners.fn.call(listeners.context, a1), true;
+        case 3:
+          return listeners.fn.call(listeners.context, a1, a2), true;
+        case 4:
+          return listeners.fn.call(listeners.context, a1, a2, a3), true;
+        case 5:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+        case 6:
+          return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+      }
+      for (i = 1, args = new Array(len - 1);i < len; i++) {
+        args[i - 1] = arguments[i];
+      }
+      listeners.fn.apply(listeners.context, args);
+    } else {
+      var length = listeners.length, j;
+      for (i = 0;i < length; i++) {
+        if (listeners[i].once)
+          this.removeListener(event, listeners[i].fn, undefined, true);
+        switch (len) {
+          case 1:
+            listeners[i].fn.call(listeners[i].context);
+            break;
+          case 2:
+            listeners[i].fn.call(listeners[i].context, a1);
+            break;
+          case 3:
+            listeners[i].fn.call(listeners[i].context, a1, a2);
+            break;
+          case 4:
+            listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+            break;
+          default:
+            if (!args)
+              for (j = 1, args = new Array(len - 1);j < len; j++) {
+                args[j - 1] = arguments[j];
+              }
+            listeners[i].fn.apply(listeners[i].context, args);
+        }
+      }
+    }
+    return true;
+  };
+  EventEmitter.prototype.on = function on(event, fn, context) {
+    return addListener(this, event, fn, context, false);
+  };
+  EventEmitter.prototype.once = function once(event, fn, context) {
+    return addListener(this, event, fn, context, true);
+  };
+  EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {
+    var evt = prefix ? prefix + event : event;
+    if (!this._events[evt])
+      return this;
+    if (!fn) {
+      clearEvent(this, evt);
+      return this;
+    }
+    var listeners = this._events[evt];
+    if (listeners.fn) {
+      if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+        clearEvent(this, evt);
+      }
+    } else {
+      for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+        if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+          events.push(listeners[i]);
+        }
+      }
+      if (events.length)
+        this._events[evt] = events.length === 1 ? events[0] : events;
+      else
+        clearEvent(this, evt);
+    }
+    return this;
+  };
+  EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {
+    var evt;
+    if (event) {
+      evt = prefix ? prefix + event : event;
+      if (this._events[evt])
+        clearEvent(this, evt);
+    } else {
+      this._events = new Events;
+      this._eventsCount = 0;
+    }
+    return this;
+  };
+  EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+  EventEmitter.prototype.addListener = EventEmitter.prototype.on;
+  EventEmitter.prefixed = prefix;
+  EventEmitter.EventEmitter = EventEmitter;
+  if (typeof module !== "undefined") {
+    module.exports = EventEmitter;
+  }
+});
+var import__ = __toESM(require_eventemitter3(), 1);
+
+class RemoteApp {
+  mainApp;
+  url;
+  id;
+  emitter;
+  isConnected;
+  ws;
+  remoteIsConnected;
+  isError = false;
+  autoReconnect;
+  maxReconnectAttempts;
+  reconnectDelay;
+  maxReconnectDelay;
+  enableBackoff;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  isManuallyClosed = false;
+  constructor(opts) {
+    this.mainApp = opts?.app;
+    const token = opts.token;
+    const url = opts.url;
+    const id = opts.id;
+    this.emitter = opts?.emitter || new import__.default;
+    const _url = new URL(url);
+    if (token) {
+      _url.searchParams.set("token", token);
+    }
+    _url.searchParams.set("id", id);
+    this.url = _url.toString();
+    this.id = id;
+    this.autoReconnect = opts?.autoReconnect ?? true;
+    this.maxReconnectAttempts = opts?.maxReconnectAttempts ?? Infinity;
+    this.reconnectDelay = opts?.reconnectDelay ?? 1000;
+    this.maxReconnectDelay = opts?.maxReconnectDelay ?? 30000;
+    this.enableBackoff = opts?.enableBackoff ?? true;
+    this.init();
+  }
+  async isConnect() {
+    const that = this;
+    if (this.isConnected) {
+      return true;
+    }
+    if (this.reconnectTimer !== null) {
+      console.log(`远程应用 ${this.id} 正在重连中...`);
+    }
+    return new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        resolve(false);
+        that.emitter.off("open", listenOnce);
+      }, 5000);
+      const listenOnce = () => {
+        clearTimeout(timeout);
+        that.isConnected = true;
+        that.remoteIsConnected = true;
+        resolve(true);
+      };
+      that.emitter.once("open", listenOnce);
+    });
+  }
+  getWsURL(url) {
+    const { protocol } = new URL(url);
+    const wsProtocol = protocol === "https:" ? "wss:" : "ws:";
+    const wsURL = url.toString().replace(protocol, wsProtocol);
+    return wsURL;
+  }
+  async init() {
+    if (!this.url) {
+      throw new Error("No url provided for remote app");
+    }
+    if (!this.id) {
+      throw new Error("No id provided for remote app");
+    }
+    this.isError = false;
+    if (this.ws) {
+      this.ws.close();
+    }
+    const ws = new WebSocket(this.getWsURL(this.url));
+    const that = this;
+    ws.onopen = function() {
+      that.isConnected = true;
+      that.onOpen();
+    };
+    ws.onclose = function() {
+      that.isConnected = false;
+      that.onClose();
+    };
+    ws.onmessage = function(event) {
+      that.onMessage(event.data);
+    };
+    ws.onerror = function(error) {
+      that.onError(error);
+    };
+    this.ws = ws;
+  }
+  onOpen() {
+    this.isError = false;
+    this.reconnectAttempts = 0;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.emitter.emit("open", this.id);
+  }
+  onClose() {
+    console.log("远程应用关闭:", this.id);
+    this.isConnected = false;
+    this.emitter.emit("close", this.id);
+    if (this.autoReconnect && !this.isManuallyClosed) {
+      this.scheduleReconnect();
+    }
+  }
+  calculateReconnectDelay() {
+    if (!this.enableBackoff) {
+      return this.reconnectDelay;
+    }
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts);
+    return Math.min(delay, this.maxReconnectDelay);
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      console.error(`远程应用 ${this.id} 已达到最大重连次数 ${this.maxReconnectAttempts}，停止重连`);
+      this.emitter.emit("maxReconnectAttemptsReached", this.id);
+      return;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+    }
+    const delay = this.calculateReconnectDelay();
+    this.reconnectAttempts++;
+    console.log(`远程应用 ${this.id} 将在 ${delay}ms 后尝试第 ${this.reconnectAttempts} 次重连`);
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      try {
+        this.init();
+      } catch (error) {
+        console.error(`远程应用 ${this.id} 重连失败:`, error);
+        this.emitter.emit("reconnectFailed", { id: this.id, attempt: this.reconnectAttempts, error });
+        this.scheduleReconnect();
+      }
+    }, delay);
+  }
+  disconnect() {
+    this.isManuallyClosed = true;
+    this.autoReconnect = false;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+    }
+  }
+  reconnect() {
+    this.isManuallyClosed = false;
+    this.reconnectAttempts = 0;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.init();
+  }
+  onMessage(data) {
+    this.emitter.emit("message", data);
+  }
+  onError(error) {
+    console.error("远程应用错误:", this.id, error);
+    this.isError = true;
+    this.emitter.emit("error", error);
+  }
+  on(event, listener) {
+    this.emitter.on(event, listener);
+    return () => {
+      this.emitter.off(event, listener);
+    };
+  }
+  json(data) {
+    this.ws.send(JSON.stringify(data));
+  }
+  listenProxy() {
+    const remoteApp = this;
+    const app = this.mainApp;
+    const listenFn = async (event) => {
+      try {
+        const data = event.toString();
+        const body = JSON.parse(data);
+        const bodyData = body?.data;
+        const message = bodyData?.message || {};
+        const context = bodyData?.context || {};
+        if (body?.code === 401) {
+          console.error("远程应用认证失败，请检查 token 是否正确");
+          this.isError = true;
+          return;
+        }
+        if (body?.type !== "proxy")
+          return;
+        if (!body.id) {
+          remoteApp.json({
+            id: body.id,
+            data: {
+              code: 400,
+              message: "id is required"
+            }
+          });
+          return;
+        }
+        const res = await app.run(message, context);
+        remoteApp.json({
+          id: body.id,
+          data: {
+            code: res.code,
+            data: res.data,
+            message: res.message
+          }
+        });
+      } catch (error) {
+        console.error("处理远程代理请求出错:", error);
+      }
+    };
+    remoteApp.json({
+      id: this.id,
+      type: "registryClient"
+    });
+    remoteApp.emitter.on("message", listenFn);
+    const closeMessage = () => {
+      remoteApp.emitter.off("message", listenFn);
+    };
+    remoteApp.emitter.once("close", () => {
+      closeMessage();
+    });
+    return () => {
+      closeMessage();
+    };
+  }
+}
+export {
+  RemoteApp
+};

package/dist/query-resources.d.ts

@@ -0,0 +1,58 @@
+import { DataOpts, Result } from '@kevisual/query';
+
+type Process = {};
+type QueryResourcesOptions = {
+    prefix?: string;
+    storage?: Storage;
+    username?: string;
+    onProcess?: (opts?: Process) => void;
+    [key: string]: any;
+};
+declare class QueryResources {
+    prefix: string;
+    storage: Storage;
+    onProcess?: (opts?: Process) => void;
+    constructor(opts: QueryResourcesOptions);
+    setUsername(username: string): void;
+    setPrefix(prefix: string): void;
+    header(headers?: Record<string, string>, json?: boolean): Record<string, string>;
+    get(data: any, opts: DataOpts): Promise<any>;
+    getList(prefix: string, data?: {
+        recursive?: boolean;
+    }, opts?: DataOpts): Promise<Result<any[]>>;
+    fetchFile(filepath: string, opts?: DataOpts): Promise<Result<any>>;
+    uploadFile(filepath: string, content: string | Blob, opts?: DataOpts & {
+        chunkSize?: number;
+        maxSize?: number;
+    }): Promise<Result<any>>;
+    uploadChunkedFile(filepath: string, file: Blob, hash: string, opts?: DataOpts & {
+        chunkSize?: number;
+    }): Promise<Result<any>>;
+    getStat(filepath: string, opts?: DataOpts): Promise<Result<Stat>>;
+    /**
+     * @deprecated use getStat instead
+     * @param filepath
+     * @param opts
+     * @returns
+     */
+    getState(filepath: string, opts?: DataOpts): Promise<Result<Stat>>;
+    createFolder(folderpath: string, opts?: DataOpts): Promise<Result<any>>;
+    rename(oldpath: string, newpath: string, opts?: DataOpts): Promise<Result<any>>;
+    deleteFile(filepath: string, opts?: DataOpts): Promise<Result<any>>;
+}
+declare const getContentType: (filename: string) => string;
+type Stat = {
+    "standardHeaders": any;
+    "size": string;
+    "etag": string;
+    "lastModified": string;
+    "metaData": {
+        "app-source": string;
+        "cache-control": string;
+        "content-type": string;
+        "share"?: string;
+    };
+    "versionId": null;
+};
+
+export { QueryResources, getContentType };