@pluv/platform-cloudflare 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-cloudflare@0.0.0 build /home/runner/work/pluv/pluv/packages/platform-cloudflare
+> 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 1.50 KB
+ESM ⚡️ Build success in 80ms
+CJS dist/index.js 2.52 KB
+CJS ⚡️ Build success in 82ms
+DTS Build start
+DTS ⚡️ Build success in 3633ms
+DTS dist/index.d.ts 1.03 KB

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { AbstractWebSocket, AbstractEventMap, AbstractListener, AbstractWebSocketConfig, AbstractPlatform } from '@pluv/io';
+
+type CloudflareWebSocketConfig = AbstractWebSocketConfig;
+declare class CloudflareWebSocket extends AbstractWebSocket {
+    webSocket: WebSocket;
+    get readyState(): 0 | 1 | 2 | 3;
+    constructor(webSocket: WebSocket, config: CloudflareWebSocketConfig);
+    addEventListener<TType extends keyof AbstractEventMap>(type: TType, handler: AbstractListener<TType>): void;
+    close(code?: number | undefined, reason?: string | undefined): void;
+    initialize(): Promise<() => undefined>;
+    send(message: string | ArrayBuffer | ArrayBufferView): void;
+    terminate(): void;
+}
+
+declare class CloudflarePlatform extends AbstractPlatform<WebSocket> {
+    convertWebSocket(webSocket: WebSocket, config: AbstractWebSocketConfig): CloudflareWebSocket;
+    parseData(data: string | ArrayBuffer): Record<string, any>;
+    randomUUID(): string;
+}
+
+declare const platformCloudflare: () => CloudflarePlatform;
+
+export { platformCloudflare };

package/dist/index.js

@@ -0,0 +1,89 @@
+"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/index.ts
+var src_exports = {};
+__export(src_exports, {
+  platformCloudflare: () => platformCloudflare
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/CloudflarePlatform.ts
+var import_io2 = require("@pluv/io");
+
+// src/CloudflareWebSocket.ts
+var import_io = require("@pluv/io");
+var CloudflareWebSocket = 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) {
+    this.webSocket.addEventListener(type, handler);
+  }
+  close(code, reason) {
+    const canClose = [this.CONNECTING, this.OPEN].some(
+      (readyState) => readyState === this.readyState
+    );
+    if (!canClose)
+      return;
+    this.webSocket.close(code, reason);
+  }
+  initialize() {
+    this.webSocket.accept();
+    return Promise.resolve(() => void 0);
+  }
+  send(message) {
+    if (this.readyState !== this.OPEN)
+      return;
+    this.webSocket.send(message);
+  }
+  terminate() {
+    return this.webSocket.close(1011, "Terminated");
+  }
+};
+
+// src/CloudflarePlatform.ts
+var CloudflarePlatform = class extends import_io2.AbstractPlatform {
+  convertWebSocket(webSocket, config) {
+    return new CloudflareWebSocket(webSocket, config);
+  }
+  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/platformCloudflare.ts
+var platformCloudflare = () => {
+  return new CloudflarePlatform();
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  platformCloudflare
+});

package/dist/index.mjs

@@ -0,0 +1,64 @@
+// src/CloudflarePlatform.ts
+import { AbstractPlatform } from "@pluv/io";
+
+// src/CloudflareWebSocket.ts
+import {
+  AbstractWebSocket
+} from "@pluv/io";
+var CloudflareWebSocket = class extends AbstractWebSocket {
+  constructor(webSocket, config) {
+    const { room } = config;
+    super({ room });
+    this.webSocket = webSocket;
+  }
+  get readyState() {
+    return this.webSocket.readyState;
+  }
+  addEventListener(type, handler) {
+    this.webSocket.addEventListener(type, handler);
+  }
+  close(code, reason) {
+    const canClose = [this.CONNECTING, this.OPEN].some(
+      (readyState) => readyState === this.readyState
+    );
+    if (!canClose)
+      return;
+    this.webSocket.close(code, reason);
+  }
+  initialize() {
+    this.webSocket.accept();
+    return Promise.resolve(() => void 0);
+  }
+  send(message) {
+    if (this.readyState !== this.OPEN)
+      return;
+    this.webSocket.send(message);
+  }
+  terminate() {
+    return this.webSocket.close(1011, "Terminated");
+  }
+};
+
+// src/CloudflarePlatform.ts
+var CloudflarePlatform = class extends AbstractPlatform {
+  convertWebSocket(webSocket, config) {
+    return new CloudflareWebSocket(webSocket, config);
+  }
+  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/platformCloudflare.ts
+var platformCloudflare = () => {
+  return new CloudflarePlatform();
+};
+export {
+  platformCloudflare
+};

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@pluv/platform-cloudflare",
+  "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"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^3.18.0",
+    "@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/CloudflarePlatform.ts

@@ -0,0 +1,24 @@
+import type { AbstractWebSocketConfig } from "@pluv/io";
+import { AbstractPlatform } from "@pluv/io";
+import { CloudflareWebSocket } from "./CloudflareWebSocket";
+
+export class CloudflarePlatform extends AbstractPlatform<WebSocket> {
+    public convertWebSocket(
+        webSocket: WebSocket,
+        config: AbstractWebSocketConfig
+    ): CloudflareWebSocket {
+        return new CloudflareWebSocket(webSocket, config);
+    }
+
+    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/CloudflareWebSocket.ts

@@ -0,0 +1,64 @@
+import {
+    AbstractEventMap,
+    AbstractListener,
+    AbstractWebSocket,
+    AbstractWebSocketConfig,
+} from "@pluv/io";
+
+export interface CloudflareWebSocketEventMap {
+    close: CloseEvent;
+    message: MessageEvent;
+    open: Event;
+    error: ErrorEvent;
+}
+
+export type CloudflareWebSocketConfig = AbstractWebSocketConfig;
+
+export class CloudflareWebSocket extends AbstractWebSocket {
+    public webSocket: WebSocket;
+
+    public get readyState(): 0 | 1 | 2 | 3 {
+        return this.webSocket.readyState as 0 | 1 | 2 | 3;
+    }
+
+    constructor(webSocket: WebSocket, config: CloudflareWebSocketConfig) {
+        const { room } = config;
+
+        super({ room });
+
+        this.webSocket = webSocket;
+    }
+
+    public addEventListener<TType extends keyof AbstractEventMap>(
+        type: TType,
+        handler: AbstractListener<TType>
+    ) {
+        this.webSocket.addEventListener(type, handler as any);
+    }
+
+    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 initialize(): Promise<() => undefined> {
+        this.webSocket.accept();
+
+        return Promise.resolve(() => undefined);
+    }
+
+    public send(message: string | ArrayBuffer | ArrayBufferView): void {
+        if (this.readyState !== this.OPEN) return;
+
+        this.webSocket.send(message);
+    }
+
+    public terminate(): void {
+        return this.webSocket.close(1011, "Terminated");
+    }
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { platformCloudflare } from "./platformCloudflare";

package/src/platformCloudflare.ts

@@ -0,0 +1,5 @@
+import { CloudflarePlatform } from "./CloudflarePlatform";
+
+export const platformCloudflare = (): CloudflarePlatform => {
+    return new CloudflarePlatform();
+};

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "@pluv/tsconfig/library.json",
+	"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+	"exclude": ["node_modules"],
+	"compilerOptions": {
+		"types": ["@cloudflare/workers-types"]
+	}
+}