@pluv/platform-node 0.0.0

package/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+    root: true,
+    extends: ["pluv"],
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,17 @@
+
+> @pluv/platform-node@0.0.0 build /home/runner/work/pluv/pluv/packages/platform-node
+> tsup src/index.ts --format esm,cjs --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v6.5.0
+CLI Target: es6
+ESM Build start
+CJS Build start
+ESM dist/index.mjs 3.06 KB
+ESM ⚡️ Build success in 89ms
+CJS dist/index.js 4.41 KB
+CJS ⚡️ Build success in 94ms
+DTS Build start
+DTS ⚡️ Build success in 5602ms
+DTS dist/index.d.ts 1.35 KB

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { WebSocket } from 'ws';
+export { WebSocket } from 'ws';
+import { AbstractWebSocket, AbstractEventMap, AbstractListener, AbstractWebSocketConfig, AbstractPersistance, AbstractPubSub, AbstractPlatform, ConvertWebSocketConfig } from '@pluv/io';
+
+type NodeWebSocketConfig = AbstractWebSocketConfig;
+declare class NodeWebSocket extends AbstractWebSocket {
+    webSocket: WebSocket;
+    get readyState(): 0 | 1 | 2 | 3;
+    constructor(webSocket: WebSocket, config: NodeWebSocketConfig);
+    addEventListener<TType extends keyof AbstractEventMap>(type: TType, handler: AbstractListener<TType>): void;
+    close(code?: number | undefined, reason?: string | undefined): void;
+    initialize(): Promise<() => void>;
+    send(message: string | ArrayBuffer | ArrayBufferView): void;
+    terminate(): void;
+}
+
+type NodePlatformOptions = {
+    persistance?: undefined;
+    pubSub?: undefined;
+} | {
+    persistance: AbstractPersistance;
+    pubSub: AbstractPubSub;
+};
+declare class NodePlatform extends AbstractPlatform<WebSocket> {
+    constructor(options?: NodePlatformOptions);
+    convertWebSocket(webSocket: WebSocket, config: ConvertWebSocketConfig): NodeWebSocket;
+    parseData(data: string | ArrayBuffer): Record<string, any>;
+    randomUUID(): string;
+}
+
+declare const platformNode: (options?: NodePlatformOptions) => NodePlatform;
+
+export { NodePlatformOptions, platformNode };

package/dist/index.js

@@ -0,0 +1,157 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  platformNode: () => platformNode
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/NodePlatform.ts
+var import_io2 = require("@pluv/io");
+var import_crypto = __toESM(require("crypto"));
+var import_util = require("util");
+
+// src/NodeWebSocket.ts
+var import_io = require("@pluv/io");
+var NodeWebSocket = class extends import_io.AbstractWebSocket {
+  constructor(webSocket, config) {
+    const { room } = config;
+    super({ room });
+    this.webSocket = webSocket;
+  }
+  get readyState() {
+    return this.webSocket.readyState;
+  }
+  addEventListener(type, handler) {
+    switch (type) {
+      case "close":
+        this.webSocket.on("close", (code, reason) => __async(this, null, function* () {
+          yield Promise.resolve(
+            handler({
+              code,
+              reason: reason.toString("utf-8")
+            })
+          );
+        }));
+        return;
+      case "error":
+        this.webSocket.on("error", (error) => __async(this, null, function* () {
+          yield Promise.resolve(
+            handler({
+              error,
+              message: error.message
+            })
+          );
+        }));
+        return;
+      case "message":
+        this.webSocket.on("message", (data) => __async(this, null, function* () {
+          yield Promise.resolve(
+            handler({
+              data
+            })
+          );
+        }));
+        return;
+      default:
+    }
+  }
+  close(code, reason) {
+    const canClose = [this.CONNECTING, this.OPEN].some(
+      (readyState) => readyState === this.readyState
+    );
+    if (!canClose)
+      return;
+    this.webSocket.close(code, reason);
+  }
+  initialize() {
+    return __async(this, null, function* () {
+      return Promise.resolve(() => void 0);
+    });
+  }
+  send(message) {
+    if (this.readyState !== this.OPEN)
+      return;
+    this.webSocket.send(message, (error) => {
+      if (error)
+        throw error;
+    });
+  }
+  terminate() {
+    this.webSocket.terminate();
+  }
+};
+
+// src/NodePlatform.ts
+var NodePlatform = class extends import_io2.AbstractPlatform {
+  constructor(options = {}) {
+    const { persistance, pubSub } = options;
+    super(persistance && pubSub ? { persistance, pubSub } : {});
+  }
+  convertWebSocket(webSocket, config) {
+    const { room } = config;
+    return new NodeWebSocket(webSocket, { room });
+  }
+  parseData(data) {
+    if (typeof data === "string")
+      return JSON.parse(data);
+    const decoder = new import_util.TextDecoder("utf8");
+    return JSON.parse(decoder.decode(data));
+  }
+  randomUUID() {
+    return import_crypto.default.randomUUID();
+  }
+};
+
+// src/platformNode.ts
+var platformNode = (options = {}) => {
+  return new NodePlatform(options);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  platformNode
+});

package/dist/index.mjs

@@ -0,0 +1,125 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/NodePlatform.ts
+import { AbstractPlatform } from "@pluv/io";
+import crypto from "crypto";
+import { TextDecoder } from "util";
+
+// src/NodeWebSocket.ts
+import { AbstractWebSocket } from "@pluv/io";
+var NodeWebSocket = class extends AbstractWebSocket {
+  constructor(webSocket, config) {
+    const { room } = config;
+    super({ room });
+    this.webSocket = webSocket;
+  }
+  get readyState() {
+    return this.webSocket.readyState;
+  }
+  addEventListener(type, handler) {
+    switch (type) {
+      case "close":
+        this.webSocket.on("close", (code, reason) => __async(this, null, function* () {
+          yield Promise.resolve(
+            handler({
+              code,
+              reason: reason.toString("utf-8")
+            })
+          );
+        }));
+        return;
+      case "error":
+        this.webSocket.on("error", (error) => __async(this, null, function* () {
+          yield Promise.resolve(
+            handler({
+              error,
+              message: error.message
+            })
+          );
+        }));
+        return;
+      case "message":
+        this.webSocket.on("message", (data) => __async(this, null, function* () {
+          yield Promise.resolve(
+            handler({
+              data
+            })
+          );
+        }));
+        return;
+      default:
+    }
+  }
+  close(code, reason) {
+    const canClose = [this.CONNECTING, this.OPEN].some(
+      (readyState) => readyState === this.readyState
+    );
+    if (!canClose)
+      return;
+    this.webSocket.close(code, reason);
+  }
+  initialize() {
+    return __async(this, null, function* () {
+      return Promise.resolve(() => void 0);
+    });
+  }
+  send(message) {
+    if (this.readyState !== this.OPEN)
+      return;
+    this.webSocket.send(message, (error) => {
+      if (error)
+        throw error;
+    });
+  }
+  terminate() {
+    this.webSocket.terminate();
+  }
+};
+
+// src/NodePlatform.ts
+var NodePlatform = class extends AbstractPlatform {
+  constructor(options = {}) {
+    const { persistance, pubSub } = options;
+    super(persistance && pubSub ? { persistance, pubSub } : {});
+  }
+  convertWebSocket(webSocket, config) {
+    const { room } = config;
+    return new NodeWebSocket(webSocket, { room });
+  }
+  parseData(data) {
+    if (typeof data === "string")
+      return JSON.parse(data);
+    const decoder = new TextDecoder("utf8");
+    return JSON.parse(decoder.decode(data));
+  }
+  randomUUID() {
+    return crypto.randomUUID();
+  }
+};
+
+// src/platformNode.ts
+var platformNode = (options = {}) => {
+  return new NodePlatform(options);
+};
+export {
+  platformNode
+};

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@pluv/platform-node",
+  "version": "0.0.0",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pluv/io": "^0.0.0",
+    "@pluv/types": "^0.0.0",
+    "@types/node": "^18.11.18",
+    "@types/ws": "^8.5.4"
+  },
+  "devDependencies": {
+    "@pluv/tsconfig": "^0.0.0",
+    "eslint-config-pluv": "^0.0.0",
+    "tsup": "^6.5.0",
+    "typescript": "^4.9.4"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}

package/src/NodePlatform.ts

@@ -0,0 +1,42 @@
+import type { AbstractPersistance, ConvertWebSocketConfig } from "@pluv/io";
+import { AbstractPlatform, AbstractPubSub } from "@pluv/io";
+import crypto from "crypto";
+import { TextDecoder } from "util";
+import type { WebSocket } from "ws";
+import { NodeWebSocket } from "./NodeWebSocket";
+
+export type NodePlatformOptions =
+    | { persistance?: undefined; pubSub?: undefined }
+    | {
+          persistance: AbstractPersistance;
+          pubSub: AbstractPubSub;
+      };
+
+export class NodePlatform extends AbstractPlatform<WebSocket> {
+    constructor(options: NodePlatformOptions = {}) {
+        const { persistance, pubSub } = options;
+
+        super(persistance && pubSub ? { persistance, pubSub } : {});
+    }
+
+    public convertWebSocket(
+        webSocket: WebSocket,
+        config: ConvertWebSocketConfig
+    ): NodeWebSocket {
+        const { room } = config;
+
+        return new NodeWebSocket(webSocket, { room });
+    }
+
+    public parseData(data: string | ArrayBuffer): Record<string, any> {
+        if (typeof data === "string") return JSON.parse(data);
+
+        const decoder = new TextDecoder("utf8");
+
+        return JSON.parse(decoder.decode(data));
+    }
+
+    public randomUUID(): string {
+        return crypto.randomUUID();
+    }
+}

package/src/NodeWebSocket.ts

@@ -0,0 +1,101 @@
+import type {
+    AbstractCloseEvent,
+    AbstractErrorEvent,
+    AbstractEventMap,
+    AbstractListener,
+    AbstractMessageEvent,
+    AbstractWebSocketConfig,
+} from "@pluv/io";
+import { AbstractWebSocket } from "@pluv/io";
+import type { WebSocket } from "ws";
+
+export interface NodeWebSocketEventMap {
+    close: AbstractCloseEvent;
+    message: AbstractMessageEvent;
+    error: AbstractErrorEvent;
+}
+
+export type NodeWebSocketConfig = AbstractWebSocketConfig;
+
+export class NodeWebSocket extends AbstractWebSocket {
+    public webSocket: WebSocket;
+
+    public get readyState(): 0 | 1 | 2 | 3 {
+        return this.webSocket.readyState;
+    }
+
+    constructor(webSocket: WebSocket, config: NodeWebSocketConfig) {
+        const { room } = config;
+
+        super({ room });
+
+        this.webSocket = webSocket;
+    }
+
+    public addEventListener<TType extends keyof AbstractEventMap>(
+        type: TType,
+        handler: AbstractListener<TType>
+    ): void {
+        switch (type) {
+            case "close":
+                this.webSocket.on("close", async (code, reason) => {
+                    await Promise.resolve(
+                        (handler as AbstractListener<"close">)({
+                            code,
+                            reason: reason.toString("utf-8"),
+                        })
+                    );
+                });
+
+                return;
+            case "error":
+                this.webSocket.on("error", async (error) => {
+                    await Promise.resolve(
+                        (handler as AbstractListener<"error">)({
+                            error,
+                            message: error.message,
+                        })
+                    );
+                });
+
+                return;
+            case "message":
+                this.webSocket.on("message", async (data) => {
+                    await Promise.resolve(
+                        (handler as AbstractListener<"message">)({
+                            data,
+                        })
+                    );
+                });
+
+                return;
+            default:
+        }
+    }
+
+    public close(code?: number | undefined, reason?: string | undefined): void {
+        const canClose = [this.CONNECTING, this.OPEN].some(
+            (readyState) => readyState === this.readyState
+        );
+
+        if (!canClose) return;
+
+        this.webSocket.close(code, reason);
+    }
+
+    public async initialize(): Promise<() => void> {
+        return Promise.resolve(() => undefined);
+    }
+
+    public send(message: string | ArrayBuffer | ArrayBufferView): void {
+        if (this.readyState !== this.OPEN) return;
+
+        this.webSocket.send(message, (error) => {
+            if (error) throw error;
+        });
+    }
+
+    public terminate(): void {
+        this.webSocket.terminate();
+    }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export type { WebSocket } from "ws";
+export type { NodePlatformOptions } from "./NodePlatform";
+export { platformNode } from "./platformNode";

package/src/platformNode.ts

@@ -0,0 +1,8 @@
+import type { NodePlatformOptions } from "./NodePlatform";
+import { NodePlatform } from "./NodePlatform";
+
+export const platformNode = (
+    options: NodePlatformOptions = {}
+): NodePlatform => {
+    return new NodePlatform(options);
+};

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "@pluv/tsconfig/library.json",
+	"include": ["**/*.ts"],
+	"exclude": ["node_modules"],
+	"compilerOptions": {
+		"types": ["@types/node"]
+	}
+}