@ekhein/sekiro-node-client 1.0.1 → 1.0.2

package/dist/SekiroClient.cjs

@@ -0,0 +1,101 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/SekiroClient.ts
+var SekiroClient_exports = {};
+__export(SekiroClient_exports, {
+  SekiroClient: () => SekiroClient
+});
+module.exports = __toCommonJS(SekiroClient_exports);
+var import_util = require("util");
+var import_crypto = require("crypto");
+var import_partysocket = require("partysocket");
+var import_ws = require("ws");
+
+// src/SekiroResult.ts
+var SekiroResult = class {
+  static success({ __sekiro_seq__ }, data) {
+    return JSON.stringify({ __sekiro_seq__, data, status: 0 });
+  }
+  static unknown({ __sekiro_seq__ }, message) {
+    return JSON.stringify({ __sekiro_seq__, message, status: -1 });
+  }
+};
+
+// src/SekiroLogger.ts
+var SekiroLogger = class {
+  static info(...args) {
+    console.info("[I] [" + (/* @__PURE__ */ new Date()).toLocaleString() + "]", ...args);
+  }
+  static warn(...args) {
+    console.warn("[W] [" + (/* @__PURE__ */ new Date()).toLocaleString() + "]", ...args);
+  }
+};
+
+// src/SekiroClient.ts
+var SekiroClient = class extends import_partysocket.WebSocket {
+  handlers = /* @__PURE__ */ new Map([]);
+  constructor(scope, host = "192.168.2.102", prot = 5612, clientId = (0, import_crypto.randomUUID)().replace(/-/g, "")) {
+    super("wss://", [], {
+      debug: false,
+      maxEnqueuedMessages: -1,
+      WebSocket: class extends import_ws.WebSocket {
+        constructor() {
+          const site = (0, import_util.format)("ws://%s:%s", host, prot);
+          const wsURL = new URL("/business-demo/register", site);
+          wsURL.searchParams.append("group", scope);
+          wsURL.searchParams.append("clientId", clientId);
+          super(wsURL);
+        }
+      }
+    });
+    super.addEventListener("open", () => this.onOpen.bind(this));
+    super.addEventListener("message", () => this.onData.bind(this));
+    super.addEventListener("close", () => this.onClose.bind(this));
+    super.addEventListener("error", () => this.onError.bind(this));
+  }
+  async onOpen() {
+    SekiroLogger.info("Connection established");
+  }
+  async onClose() {
+    SekiroLogger.warn("Connection closed");
+  }
+  async onError(error) {
+    SekiroLogger.warn("WebSocket error:", error);
+  }
+  async onData(event) {
+    SekiroLogger.info("Received request", event.data);
+    const request = JSON.parse(event.data);
+    try {
+      const data = await this.handlers.get(request.action)?.apply(this, [request]);
+      const pack = SekiroResult.success(request, data);
+      this.send(pack);
+    } catch (error) {
+      const pack = SekiroResult.unknown(request, error.message);
+      this.send(pack);
+    }
+  }
+  async registerAction(action, handler) {
+    this.handlers.set(action, handler);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SekiroClient
+});

package/dist/SekiroClient.d.cts

@@ -0,0 +1,13 @@
+import { WebSocket } from 'partysocket';
+
+declare class SekiroClient extends WebSocket {
+    private readonly handlers;
+    constructor(scope: string, host?: string, prot?: number, clientId?: string);
+    private onOpen;
+    private onClose;
+    private onError;
+    private onData;
+    registerAction(action: string, handler: ISekiroHandler): Promise<void>;
+}
+
+export { SekiroClient };

package/dist/SekiroClient.d.ts

@@ -0,0 +1,13 @@
+import { WebSocket } from 'partysocket';
+
+declare class SekiroClient extends WebSocket {
+    private readonly handlers;
+    constructor(scope: string, host?: string, prot?: number, clientId?: string);
+    private onOpen;
+    private onClose;
+    private onError;
+    private onData;
+    registerAction(action: string, handler: ISekiroHandler): Promise<void>;
+}
+
+export { SekiroClient };

package/dist/SekiroClient.js

@@ -0,0 +1,76 @@
+// src/SekiroClient.ts
+import { format } from "util";
+import { randomUUID } from "crypto";
+import { WebSocket } from "partysocket";
+import { WebSocket as Client } from "ws";
+
+// src/SekiroResult.ts
+var SekiroResult = class {
+  static success({ __sekiro_seq__ }, data) {
+    return JSON.stringify({ __sekiro_seq__, data, status: 0 });
+  }
+  static unknown({ __sekiro_seq__ }, message) {
+    return JSON.stringify({ __sekiro_seq__, message, status: -1 });
+  }
+};
+
+// src/SekiroLogger.ts
+var SekiroLogger = class {
+  static info(...args) {
+    console.info("[I] [" + (/* @__PURE__ */ new Date()).toLocaleString() + "]", ...args);
+  }
+  static warn(...args) {
+    console.warn("[W] [" + (/* @__PURE__ */ new Date()).toLocaleString() + "]", ...args);
+  }
+};
+
+// src/SekiroClient.ts
+var SekiroClient = class extends WebSocket {
+  handlers = /* @__PURE__ */ new Map([]);
+  constructor(scope, host = "192.168.2.102", prot = 5612, clientId = randomUUID().replace(/-/g, "")) {
+    super("wss://", [], {
+      debug: false,
+      maxEnqueuedMessages: -1,
+      WebSocket: class extends Client {
+        constructor() {
+          const site = format("ws://%s:%s", host, prot);
+          const wsURL = new URL("/business-demo/register", site);
+          wsURL.searchParams.append("group", scope);
+          wsURL.searchParams.append("clientId", clientId);
+          super(wsURL);
+        }
+      }
+    });
+    super.addEventListener("open", () => this.onOpen.bind(this));
+    super.addEventListener("message", () => this.onData.bind(this));
+    super.addEventListener("close", () => this.onClose.bind(this));
+    super.addEventListener("error", () => this.onError.bind(this));
+  }
+  async onOpen() {
+    SekiroLogger.info("Connection established");
+  }
+  async onClose() {
+    SekiroLogger.warn("Connection closed");
+  }
+  async onError(error) {
+    SekiroLogger.warn("WebSocket error:", error);
+  }
+  async onData(event) {
+    SekiroLogger.info("Received request", event.data);
+    const request = JSON.parse(event.data);
+    try {
+      const data = await this.handlers.get(request.action)?.apply(this, [request]);
+      const pack = SekiroResult.success(request, data);
+      this.send(pack);
+    } catch (error) {
+      const pack = SekiroResult.unknown(request, error.message);
+      this.send(pack);
+    }
+  }
+  async registerAction(action, handler) {
+    this.handlers.set(action, handler);
+  }
+};
+export {
+  SekiroClient
+};

package/package.json

@@ -1,10 +1,20 @@
 {
   "name": "@ekhein/sekiro-node-client",
-  "version": "1.0.1",
-  "main": "SekiroClient.js",
+  "version": "1.0.2",
   "type": "module",
+  "license": "MIT",
+  "main": "./dist/SekiroClient.cjs",
+  "module": "./dist/SekiroClient.js",
+  "types": "./dist/SekiroClient.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "build": "tsup src/SekiroClient.ts --format cjs,esm --dts --clean",
+    "watch": "pnpm build --watch src",
+    "dev": "tsx example/index.ts"
+  },
   "author": "ekhein",
-  "license": "ISC",
   "description": "",
   "engines": {
     "node": ">=18.0.0"
@@ -12,5 +22,11 @@
   "dependencies": {
     "partysocket": "^1.1.4",
     "ws": "^8.18.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.18",
+    "tsup": "^8.5.0",
+    "tsx": "^4.19.4",
+    "typescript": "^5.8.3"
   }
 }

package/SekiroClient.js

@@ -1,106 +0,0 @@
-import { randomUUID } from 'crypto';
-import { WebSocket } from 'partysocket';
-import { WebSocket as Client } from 'ws';
-import { SekiroResult } from './SekiroResult.js';
-import { SekiroLogger } from './SekiroLogger.js';
-
-
-/**
- * Sekiro Client for Node.js
- * @class
- */
-export class SekiroClient extends WebSocket {
-
-  _handlers = new Map([])
-
-  /**
-   * Create a SekiroClient instance
-   * @param {string} wsURL - WebSocket server URL
-   * @param {object} [options] - Configuration options
-   * @param {number} [options.reconnectInterval=2000] - Base reconnect interval in ms
-   * @param {number} [options.maxReconnectAttempts=10] - Maximum reconnect attempts
-   * @param {object} [options.wsOptions] - Additional WebSocket options
-   */
-  constructor(
-    scope,
-    host = "192.168.2.102",
-    prot = 5612,
-    clientId = randomUUID().replace(/-/g, ""),
-  ) {
-    super("wss://", [], {
-      debug: false,
-      maxEnqueuedMessages: -1,
-      WebSocket: class extends Client {
-        constructor() {
-          const site  = String("ws://").concat(host, ":", prot)
-          const wsURL = new URL("/business-demo/register", site)
-          wsURL.searchParams.append("group", scope)
-          wsURL.searchParams.append("clientId", clientId)
-          super(wsURL)
-        }
-      }
-    })
-
-    super.addEventListener("open",    this.onOpen.bind(this))
-    super.addEventListener("message", this.onData.bind(this))
-    super.addEventListener("close",   this.onClose.bind(this))
-    super.addEventListener("error",   this.onError.bind(this))
-  }
-
-  /**
-   * Handle WebSocket open event
-   * @private
-   */
-  async onOpen() {
-    SekiroLogger.info("Connection established");
-  }
-
-  /**
-   * Handle WebSocket message event
-   * @private
-   * @param {string|Buffer} data - Received data
-   */
-  async onData(event) {
-    SekiroLogger.info("Received request", event.data)
-    const request = JSON.parse(event.data)
-    const handler = this._handlers.get(request.action)
-    try {
-      if (!request.action) throw new Error("Request parameter {action} is required")
-      if (!handler) throw new Error("No handler registered for action: " + request.action)
-      const data = await handler(request)
-      this.send(
-        SekiroResult.success(request, data)
-      )
-    } catch (error) {
-      this.send(
-        SekiroResult.unknown(request, error.message)
-      )
-    }
-  }
-
-  /**
-   * Handle WebSocket close event
-   * @private
-   */
-  async onClose() {
-    SekiroLogger.warn("Connection closed");
-  }
-
-  /**
-   * Handle WebSocket error event
-   * @private
-   * @param {Error} error - Error object
-   */
-  async onError(error) {
-    SekiroLogger.warn("WebSocket error:", error);
-  }
-
-  /**
-   * Register action handler
-   * @param {string} action - Action name
-   * @param {function} handler - Handler function
-   */
-  async registerAction(action, handler) {
-    this._handlers.set(action, handler)
-  }
-}

package/SekiroLogger.js

@@ -1,12 +0,0 @@
-
-export class SekiroLogger {
-
-  static info(...args) {
-    console.info("[I] [" + new Date().toLocaleString() + "]", ...args)
-  }
-
-  static warn(...args) {
-    console.warn("[W] [" + new Date().toLocaleString() + "]", ...args)
-  }
-
-}

package/SekiroResult.js

@@ -1,15 +0,0 @@
-export class SekiroResult {
-
-  static success({__sekiro_seq__}, data) {
-    return (
-      JSON.stringify({__sekiro_seq__, data, status: 0})
-    )
-  }
-
-  static unknown({__sekiro_seq__}, message) {
-    return (
-      JSON.stringify({__sekiro_seq__, message, status: -1})
-    )
-  }
-
-}