@soundx/ws 1.0.50

package/.fatherrc.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'father';
+
+export default defineConfig({
+  esm: {
+    input: 'src',
+    output: 'dist/esm'
+  },
+  cjs: {
+    input: 'src',
+    output: 'dist/cjs',
+    transformer: 'babel',
+  }
+});

package/dist/cjs/index.d.ts

@@ -0,0 +1,28 @@
+export interface SocketConnectOptions {
+    /** Connection URL */
+    url: string;
+    /** Auth Token */
+    token: string;
+    /** User ID */
+    userId: number;
+    /** Device Name for identification */
+    deviceName: string;
+    /** Extra query params */
+    query?: Record<string, any>;
+}
+export declare class SharedSocketService {
+    private socket;
+    private listeners;
+    /**
+     * Initialize a connection.
+     * Safe to call multiple times; will ignore if already connected with same socket instance (but usually you should check connected status).
+     */
+    connect(options: SocketConnectOptions): void;
+    disconnect(): void;
+    emit(event: string, data: any): void;
+    on(event: string, callback: Function): void;
+    off(event: string, callback?: Function): void;
+    get id(): string | undefined;
+    get connected(): boolean;
+}
+export declare const socketService: SharedSocketService;

package/dist/cjs/index.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.socketService = exports.SharedSocketService = void 0;
+var _socket = require("socket.io-client");
+class SharedSocketService {
+  socket = null;
+  listeners = new Map();
+
+  /**
+   * Initialize a connection. 
+   * Safe to call multiple times; will ignore if already connected with same socket instance (but usually you should check connected status).
+   */
+  connect(options) {
+    if (this.socket?.connected) {
+      // Optional: logic to disconnect if options changed significantly?
+      // For now, assume single connection per instance lifecycle or manual disconnect first.
+      return;
+    }
+    const {
+      url,
+      token,
+      userId,
+      deviceName,
+      query
+    } = options;
+    this.socket = (0, _socket.io)(url, {
+      query: {
+        userId,
+        deviceName,
+        ...query
+      },
+      transports: ["websocket"],
+      auth: {
+        token
+      }
+    });
+    this.socket.on("connect", () => {
+      console.log("[SharedSocket] Connected:", this.socket?.id);
+    });
+    this.socket.on("disconnect", () => {
+      console.log("[SharedSocket] Disconnected");
+    });
+
+    // Re-attach listeners if any were added before connection
+    this.listeners.forEach((callbacks, event) => {
+      callbacks.forEach(cb => this.socket?.on(event, cb));
+    });
+  }
+  disconnect() {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+  emit(event, data) {
+    if (this.socket?.connected) {
+      this.socket.emit(event, data);
+    } else {
+      console.warn("[SharedSocket] Not connected, cannot emit:", event);
+    }
+  }
+  on(event, callback) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event)?.push(callback);
+    if (this.socket) {
+      this.socket.on(event, callback);
+    }
+  }
+  off(event, callback) {
+    if (callback) {
+      const callbacks = this.listeners.get(event) || [];
+      const idx = callbacks.indexOf(callback);
+      if (idx !== -1) {
+        callbacks.splice(idx, 1);
+      }
+      this.socket?.off(event, callback);
+    } else {
+      this.listeners.delete(event);
+      this.socket?.off(event);
+    }
+  }
+  get id() {
+    return this.socket?.id;
+  }
+  get connected() {
+    return this.socket?.connected || false;
+  }
+}
+exports.SharedSocketService = SharedSocketService;
+const socketService = exports.socketService = new SharedSocketService();

package/dist/esm/index.d.ts

@@ -0,0 +1,28 @@
+export interface SocketConnectOptions {
+    /** Connection URL */
+    url: string;
+    /** Auth Token */
+    token: string;
+    /** User ID */
+    userId: number;
+    /** Device Name for identification */
+    deviceName: string;
+    /** Extra query params */
+    query?: Record<string, any>;
+}
+export declare class SharedSocketService {
+    private socket;
+    private listeners;
+    /**
+     * Initialize a connection.
+     * Safe to call multiple times; will ignore if already connected with same socket instance (but usually you should check connected status).
+     */
+    connect(options: SocketConnectOptions): void;
+    disconnect(): void;
+    emit(event: string, data: any): void;
+    on(event: string, callback: Function): void;
+    off(event: string, callback?: Function): void;
+    get id(): string | undefined;
+    get connected(): boolean;
+}
+export declare const socketService: SharedSocketService;

package/dist/esm/index.js

@@ -0,0 +1,125 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { io } from "socket.io-client";
+export var SharedSocketService = /*#__PURE__*/function () {
+  function SharedSocketService() {
+    _classCallCheck(this, SharedSocketService);
+    _defineProperty(this, "socket", null);
+    _defineProperty(this, "listeners", new Map());
+  }
+  _createClass(SharedSocketService, [{
+    key: "connect",
+    value:
+    /**
+     * Initialize a connection. 
+     * Safe to call multiple times; will ignore if already connected with same socket instance (but usually you should check connected status).
+     */
+    function connect(options) {
+      var _this$socket,
+        _this = this;
+      if ((_this$socket = this.socket) !== null && _this$socket !== void 0 && _this$socket.connected) {
+        // Optional: logic to disconnect if options changed significantly?
+        // For now, assume single connection per instance lifecycle or manual disconnect first.
+        return;
+      }
+      var url = options.url,
+        token = options.token,
+        userId = options.userId,
+        deviceName = options.deviceName,
+        query = options.query;
+      this.socket = io(url, {
+        query: _objectSpread({
+          userId: userId,
+          deviceName: deviceName
+        }, query),
+        transports: ["websocket"],
+        auth: {
+          token: token
+        }
+      });
+      this.socket.on("connect", function () {
+        var _this$socket2;
+        console.log("[SharedSocket] Connected:", (_this$socket2 = _this.socket) === null || _this$socket2 === void 0 ? void 0 : _this$socket2.id);
+      });
+      this.socket.on("disconnect", function () {
+        console.log("[SharedSocket] Disconnected");
+      });
+
+      // Re-attach listeners if any were added before connection
+      this.listeners.forEach(function (callbacks, event) {
+        callbacks.forEach(function (cb) {
+          var _this$socket3;
+          return (_this$socket3 = _this.socket) === null || _this$socket3 === void 0 ? void 0 : _this$socket3.on(event, cb);
+        });
+      });
+    }
+  }, {
+    key: "disconnect",
+    value: function disconnect() {
+      if (this.socket) {
+        this.socket.disconnect();
+        this.socket = null;
+      }
+    }
+  }, {
+    key: "emit",
+    value: function emit(event, data) {
+      var _this$socket4;
+      if ((_this$socket4 = this.socket) !== null && _this$socket4 !== void 0 && _this$socket4.connected) {
+        this.socket.emit(event, data);
+      } else {
+        console.warn("[SharedSocket] Not connected, cannot emit:", event);
+      }
+    }
+  }, {
+    key: "on",
+    value: function on(event, callback) {
+      var _this$listeners$get;
+      if (!this.listeners.has(event)) {
+        this.listeners.set(event, []);
+      }
+      (_this$listeners$get = this.listeners.get(event)) === null || _this$listeners$get === void 0 || _this$listeners$get.push(callback);
+      if (this.socket) {
+        this.socket.on(event, callback);
+      }
+    }
+  }, {
+    key: "off",
+    value: function off(event, callback) {
+      if (callback) {
+        var _this$socket5;
+        var callbacks = this.listeners.get(event) || [];
+        var idx = callbacks.indexOf(callback);
+        if (idx !== -1) {
+          callbacks.splice(idx, 1);
+        }
+        (_this$socket5 = this.socket) === null || _this$socket5 === void 0 || _this$socket5.off(event, callback);
+      } else {
+        var _this$socket6;
+        this.listeners.delete(event);
+        (_this$socket6 = this.socket) === null || _this$socket6 === void 0 || _this$socket6.off(event);
+      }
+    }
+  }, {
+    key: "id",
+    get: function get() {
+      var _this$socket7;
+      return (_this$socket7 = this.socket) === null || _this$socket7 === void 0 ? void 0 : _this$socket7.id;
+    }
+  }, {
+    key: "connected",
+    get: function get() {
+      var _this$socket8;
+      return ((_this$socket8 = this.socket) === null || _this$socket8 === void 0 ? void 0 : _this$socket8.connected) || false;
+    }
+  }]);
+  return SharedSocketService;
+}();
+export var socketService = new SharedSocketService();

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@soundx/ws",
+  "version": "1.0.50",
+  "description": "Shared WebSocket client for SoundX",
+  "author": "mmdctjj <mmdctjj@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mmdctjj/AudioDock"
+  },
+  "homepage": "https://github.com/mmdctjj/AudioDock",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "scripts": {
+    "dev": "father dev",
+    "build": "father build",
+    "prepublishOnly": "father doctor && npm run build"
+  },
+  "types": "dist/esm/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "socket.io-client": "^4.8.1"
+  },
+  "devDependencies": {
+    "father": "^4.5.3",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "socket.io-client": "^4.8.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,108 @@
+import { io, Socket } from "socket.io-client";
+
+export interface SocketConnectOptions {
+    /** Connection URL */
+    url: string;
+    /** Auth Token */
+    token: string;
+    /** User ID */
+    userId: number;
+    /** Device Name for identification */
+    deviceName: string;
+    /** Extra query params */
+    query?: Record<string, any>;
+}
+
+export class SharedSocketService {
+  private socket: Socket | null = null;
+  private listeners: Map<string, Function[]> = new Map();
+
+  /**
+   * Initialize a connection. 
+   * Safe to call multiple times; will ignore if already connected with same socket instance (but usually you should check connected status).
+   */
+  connect(options: SocketConnectOptions) {
+    if (this.socket?.connected) {
+        // Optional: logic to disconnect if options changed significantly?
+        // For now, assume single connection per instance lifecycle or manual disconnect first.
+        return;
+    }
+
+    const { url, token, userId, deviceName, query } = options;
+
+    this.socket = io(url, {
+      query: {
+        userId,
+        deviceName,
+        ...query
+      },
+      transports: ["websocket"],
+      auth: {
+        token,
+      }
+    });
+
+    this.socket.on("connect", () => {
+      console.log("[SharedSocket] Connected:", this.socket?.id);
+    });
+
+    this.socket.on("disconnect", () => {
+      console.log("[SharedSocket] Disconnected");
+    });
+
+    // Re-attach listeners if any were added before connection
+    this.listeners.forEach((callbacks, event) => {
+      callbacks.forEach(cb => this.socket?.on(event, cb as any));
+    });
+  }
+
+  disconnect() {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+
+  emit(event: string, data: any) {
+    if (this.socket?.connected) {
+      this.socket.emit(event, data);
+    } else {
+      console.warn("[SharedSocket] Not connected, cannot emit:", event);
+    }
+  }
+
+  on(event: string, callback: Function) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event)?.push(callback);
+
+    if (this.socket) {
+      this.socket.on(event, callback as any);
+    }
+  }
+
+  off(event: string, callback?: Function) {
+    if (callback) {
+      const callbacks = this.listeners.get(event) || [];
+      const idx = callbacks.indexOf(callback);
+      if (idx !== -1) {
+        callbacks.splice(idx, 1);
+      }
+      this.socket?.off(event, callback as any);
+    } else {
+      this.listeners.delete(event);
+      this.socket?.off(event);
+    }
+  }
+
+  get id() {
+    return this.socket?.id;
+  }
+  
+  get connected() {
+      return this.socket?.connected || false;
+  }
+}
+
+export const socketService = new SharedSocketService();

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "strict": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "baseUrl": "./",
+    "outDir": "dist",
+    "rootDir": "src",
+    "lib": ["es2015", "dom"]
+  },
+  "include": ["src"]
+}