crossws 0.1.2 → 0.2.0

package/dist/shared/crossws.a2e5c71e.d.mts

@@ -0,0 +1,112 @@
+declare class WSError extends Error {
+    constructor(...args: any[]);
+}
+
+declare class Message {
+    readonly rawData: any;
+    readonly isBinary?: boolean | undefined;
+    constructor(rawData: any, isBinary?: boolean | undefined);
+    text(): string;
+    toString(): string;
+}
+
+type ReadyState = 0 | 1 | 2 | 3;
+declare abstract class Peer<AdapterContext = any> implements WSRequest {
+    ctx: AdapterContext;
+    _subscriptions: Set<string>;
+    constructor(ctx: AdapterContext);
+    get id(): string | undefined;
+    get url(): string;
+    get headers(): HeadersInit;
+    get readyState(): ReadyState | -1;
+    abstract send(message: any, options?: {
+        compress?: boolean;
+    }): number;
+    publish(topic: string, message: any, options?: {
+        compress?: boolean;
+    }): void;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    toString(): string;
+}
+
+type MaybePromise<T> = T | Promise<T>;
+type Caller<T extends Record<string, (...args: any[]) => Promise<any>>, RT = null> = <K extends keyof T>(key: K, ...args: Parameters<T[K]>) => RT extends null ? Promise<ReturnType<T[K]>> : RT;
+interface AdapterOptions {
+    resolve?: ResolveHooks;
+    hooks?: Hooks;
+    adapterHooks?: AdapterHooks;
+}
+type Adapter<AdapterT, Options extends AdapterOptions> = (options?: Options) => AdapterT;
+declare function defineWebSocketAdapter<AdapterT, Options extends AdapterOptions = AdapterOptions>(factory: Adapter<AdapterT, Options>): Adapter<AdapterT, Options>;
+interface CrossWS {
+    $callHook: Caller<AdapterHooks>;
+    callHook: Caller<Exclude<Hooks, "upgrade">, void>;
+    upgrade: (req: WSRequest) => Promise<{
+        headers?: HeadersInit;
+    }>;
+}
+interface WSRequest {
+    readonly url: string;
+    readonly headers: HeadersInit;
+}
+declare function defineHooks<T extends Partial<Hooks> = Partial<Hooks>>(hooks: T): T;
+type ResolveHooks = (info: WSRequest | Peer) => Partial<Hooks> | Promise<Partial<Hooks>>;
+type HookFn<ArgsT extends any[] = any, RT = void> = (info: Peer, ...args: ArgsT) => MaybePromise<RT>;
+interface Hooks extends Record<string, HookFn<any[], any>> {
+    /** Upgrading */
+    upgrade: (req: WSRequest) => MaybePromise<void | {
+        headers?: HeadersInit;
+    }>;
+    /** A message is received */
+    message: (peer: Peer, message: Message) => MaybePromise<void>;
+    /** A socket is opened */
+    open: (peer: Peer) => MaybePromise<void>;
+    /** A socket is closed */
+    close: (peer: Peer, details: {
+        code?: number;
+        reason?: string;
+    }) => MaybePromise<void>;
+    /** An error occurs */
+    error: (peer: Peer, error: WSError) => MaybePromise<void>;
+}
+interface AdapterHooks extends Record<string, HookFn<any[], any>> {
+    "bun:message": HookFn<[ws: any, message: any]>;
+    "bun:open": HookFn<[ws: any]>;
+    "bun:close": HookFn<[ws: any]>;
+    "bun:drain": HookFn<[]>;
+    "bun:error": HookFn<[ws: any, error: any]>;
+    "bun:ping": HookFn<[ws: any, data: any]>;
+    "bun:pong": HookFn<[ws: any, data: any]>;
+    "cloudflare:accept": HookFn<[]>;
+    "cloudflare:message": HookFn<[event: any]>;
+    "cloudflare:error": HookFn<[event: any]>;
+    "cloudflare:close": HookFn<[event: any]>;
+    "deno:open": HookFn<[]>;
+    "deno:message": HookFn<[event: any]>;
+    "deno:close": HookFn<[]>;
+    "deno:error": HookFn<[error: any]>;
+    "node:open": HookFn<[]>;
+    "node:message": HookFn<[data: any, isBinary: boolean]>;
+    "node:close": HookFn<[code: number, reason: Buffer]>;
+    "node:error": HookFn<[error: any]>;
+    "node:ping": HookFn<[data: Buffer]>;
+    "node:pong": HookFn<[data: Buffer]>;
+    "node:unexpected-response": HookFn<[req: any, res: any]>;
+    "node:upgrade": HookFn<[req: any]>;
+    "uws:open": HookFn<[ws: any]>;
+    "uws:message": HookFn<[ws: any, message: any, isBinary: boolean]>;
+    "uws:close": HookFn<[ws: any, code: number, message: any]>;
+    "uws:ping": HookFn<[ws: any, message: any]>;
+    "uws:pong": HookFn<[ws: any, message: any]>;
+    "uws:drain": HookFn<[ws: any]>;
+    "uws:upgrade": HookFn<[res: any, req: any, context: any]>;
+    "uws:subscription": HookFn<[
+        ws: any,
+        topic: any,
+        newCount: number,
+        oldCount: number
+    ]>;
+}
+
+export { type AdapterOptions as A, type CrossWS as C, type Hooks as H, Message as M, Peer as P, type ResolveHooks as R, WSError as W, type Caller as a, type Adapter as b, type WSRequest as c, defineWebSocketAdapter as d, defineHooks as e, type AdapterHooks as f };

package/dist/shared/crossws.a2e5c71e.d.ts

@@ -0,0 +1,112 @@
+declare class WSError extends Error {
+    constructor(...args: any[]);
+}
+
+declare class Message {
+    readonly rawData: any;
+    readonly isBinary?: boolean | undefined;
+    constructor(rawData: any, isBinary?: boolean | undefined);
+    text(): string;
+    toString(): string;
+}
+
+type ReadyState = 0 | 1 | 2 | 3;
+declare abstract class Peer<AdapterContext = any> implements WSRequest {
+    ctx: AdapterContext;
+    _subscriptions: Set<string>;
+    constructor(ctx: AdapterContext);
+    get id(): string | undefined;
+    get url(): string;
+    get headers(): HeadersInit;
+    get readyState(): ReadyState | -1;
+    abstract send(message: any, options?: {
+        compress?: boolean;
+    }): number;
+    publish(topic: string, message: any, options?: {
+        compress?: boolean;
+    }): void;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    toString(): string;
+}
+
+type MaybePromise<T> = T | Promise<T>;
+type Caller<T extends Record<string, (...args: any[]) => Promise<any>>, RT = null> = <K extends keyof T>(key: K, ...args: Parameters<T[K]>) => RT extends null ? Promise<ReturnType<T[K]>> : RT;
+interface AdapterOptions {
+    resolve?: ResolveHooks;
+    hooks?: Hooks;
+    adapterHooks?: AdapterHooks;
+}
+type Adapter<AdapterT, Options extends AdapterOptions> = (options?: Options) => AdapterT;
+declare function defineWebSocketAdapter<AdapterT, Options extends AdapterOptions = AdapterOptions>(factory: Adapter<AdapterT, Options>): Adapter<AdapterT, Options>;
+interface CrossWS {
+    $callHook: Caller<AdapterHooks>;
+    callHook: Caller<Exclude<Hooks, "upgrade">, void>;
+    upgrade: (req: WSRequest) => Promise<{
+        headers?: HeadersInit;
+    }>;
+}
+interface WSRequest {
+    readonly url: string;
+    readonly headers: HeadersInit;
+}
+declare function defineHooks<T extends Partial<Hooks> = Partial<Hooks>>(hooks: T): T;
+type ResolveHooks = (info: WSRequest | Peer) => Partial<Hooks> | Promise<Partial<Hooks>>;
+type HookFn<ArgsT extends any[] = any, RT = void> = (info: Peer, ...args: ArgsT) => MaybePromise<RT>;
+interface Hooks extends Record<string, HookFn<any[], any>> {
+    /** Upgrading */
+    upgrade: (req: WSRequest) => MaybePromise<void | {
+        headers?: HeadersInit;
+    }>;
+    /** A message is received */
+    message: (peer: Peer, message: Message) => MaybePromise<void>;
+    /** A socket is opened */
+    open: (peer: Peer) => MaybePromise<void>;
+    /** A socket is closed */
+    close: (peer: Peer, details: {
+        code?: number;
+        reason?: string;
+    }) => MaybePromise<void>;
+    /** An error occurs */
+    error: (peer: Peer, error: WSError) => MaybePromise<void>;
+}
+interface AdapterHooks extends Record<string, HookFn<any[], any>> {
+    "bun:message": HookFn<[ws: any, message: any]>;
+    "bun:open": HookFn<[ws: any]>;
+    "bun:close": HookFn<[ws: any]>;
+    "bun:drain": HookFn<[]>;
+    "bun:error": HookFn<[ws: any, error: any]>;
+    "bun:ping": HookFn<[ws: any, data: any]>;
+    "bun:pong": HookFn<[ws: any, data: any]>;
+    "cloudflare:accept": HookFn<[]>;
+    "cloudflare:message": HookFn<[event: any]>;
+    "cloudflare:error": HookFn<[event: any]>;
+    "cloudflare:close": HookFn<[event: any]>;
+    "deno:open": HookFn<[]>;
+    "deno:message": HookFn<[event: any]>;
+    "deno:close": HookFn<[]>;
+    "deno:error": HookFn<[error: any]>;
+    "node:open": HookFn<[]>;
+    "node:message": HookFn<[data: any, isBinary: boolean]>;
+    "node:close": HookFn<[code: number, reason: Buffer]>;
+    "node:error": HookFn<[error: any]>;
+    "node:ping": HookFn<[data: Buffer]>;
+    "node:pong": HookFn<[data: Buffer]>;
+    "node:unexpected-response": HookFn<[req: any, res: any]>;
+    "node:upgrade": HookFn<[req: any]>;
+    "uws:open": HookFn<[ws: any]>;
+    "uws:message": HookFn<[ws: any, message: any, isBinary: boolean]>;
+    "uws:close": HookFn<[ws: any, code: number, message: any]>;
+    "uws:ping": HookFn<[ws: any, message: any]>;
+    "uws:pong": HookFn<[ws: any, message: any]>;
+    "uws:drain": HookFn<[ws: any]>;
+    "uws:upgrade": HookFn<[res: any, req: any, context: any]>;
+    "uws:subscription": HookFn<[
+        ws: any,
+        topic: any,
+        newCount: number,
+        oldCount: number
+    ]>;
+}
+
+export { type AdapterOptions as A, type CrossWS as C, type Hooks as H, Message as M, Peer as P, type ResolveHooks as R, WSError as W, type Caller as a, type Adapter as b, type WSRequest as c, defineWebSocketAdapter as d, defineHooks as e, type AdapterHooks as f };

package/dist/shared/{crossws.6009d265.cjs → crossws.c0275b79.cjs}

@@ -1,52 +1,34 @@
 'use strict';
 
-function defineWebSocketAdapter(factory) {
-  return factory;
-}
-
-function createCrossWS(hooks, options) {
-  const _callHook = options.resolve ? async function(name, info, ...args) {
-    const hooks2 = await options.resolve?.(info);
-    const hook = hooks2?.[name];
-    return hook?.(info, ...args);
-  } : void 0;
+function createCrossWS(opts = {}) {
+  const resolveHook = async (req, name) => {
+    const hooks = await opts.resolve?.(req);
+    return hooks?.[name];
+  };
   return {
-    async $(name, ...args) {
-      await Promise.all([hooks.$?.(name, ...args), _callHook?.(name, ...args)]);
+    // WS Hooks
+    async callHook(name, ...args) {
+      await opts.hooks?.[name]?.apply(void 0, args);
+      const hook = await resolveHook(args[0], name);
+      await hook?.apply(void 0, args);
     },
+    // Upgrade
     async upgrade(req) {
-      const upgradeResults = await Promise.all([
-        hooks.upgrade?.(req),
-        _callHook?.("upgrade", req)
+      const [res1, res2] = await Promise.all([
+        opts.hooks?.upgrade?.(req),
+        await resolveHook(req, "upgrade").then((h) => h?.(req))
       ]);
-      const headers = /* @__PURE__ */ Object.create(null);
-      for (const result of upgradeResults) {
-        if (result?.headers) {
-          Object.assign(headers, result.headers);
+      const headers = new Headers(res1?.headers);
+      if (res2?.headers) {
+        for (const [key, value] of new Headers(res2?.headers)) {
+          headers.append(key, value);
         }
       }
       return { headers };
     },
-    async message(peer, message) {
-      await Promise.all([
-        hooks.message?.(peer, message),
-        _callHook?.("message", peer, message)
-      ]);
-    },
-    async open(peer) {
-      await Promise.all([hooks.open?.(peer), _callHook?.("open", peer)]);
-    },
-    async close(peer, { code, reason }) {
-      await Promise.all([
-        hooks.close?.(peer, { code, reason }),
-        _callHook?.("close", peer, { code, reason })
-      ]);
-    },
-    async error(peer, error) {
-      await Promise.all([
-        hooks.error?.(peer, error),
-        _callHook?.("error", peer, error)
-      ]);
+    // Adapter hook
+    $callHook(name, ...args) {
+      return opts.adapterHooks?.[name].apply(void 0, args);
     }
   };
 }
@@ -80,7 +62,7 @@ function isPlainObject(value) {
   return true;
 }
 
-class WSMessage {
+class Message {
   constructor(rawData, isBinary) {
     this.rawData = rawData;
     this.isBinary = isBinary;
@@ -116,7 +98,7 @@ const ReadyStateMap = {
   2: "closing",
   3: "closed"
 };
-class WSPeer {
+class Peer {
   constructor(ctx) {
     this.ctx = ctx;
     __publicField(this, "_subscriptions", /* @__PURE__ */ new Set());
@@ -149,8 +131,16 @@ class WSPeer {
   }
 }
 
-exports.WSMessage = WSMessage;
-exports.WSPeer = WSPeer;
+function defineWebSocketAdapter(factory) {
+  return factory;
+}
+function defineHooks(hooks) {
+  return hooks;
+}
+
+exports.Message = Message;
+exports.Peer = Peer;
 exports.createCrossWS = createCrossWS;
+exports.defineHooks = defineHooks;
 exports.defineWebSocketAdapter = defineWebSocketAdapter;
 exports.toBufferLike = toBufferLike;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crossws",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Cross-platform WebSocket Servers for Node.js, Deno, Bun and Cloudflare Workers",
   "repository": "unjs/crossws",
   "license": "MIT",
@@ -75,7 +75,7 @@
     "play:deno": "deno run --unstable-sloppy-imports -A playground/deno.ts",
     "play:node": "jiti playground/node.ts",
     "play:uws": "jiti playground/uws.ts",
-    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
+    "release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
     "test": "pnpm lint && pnpm test:types",
     "test:types": "tsc --noEmit --skipLibCheck"
   },

package/dist/shared/crossws.6f7f02b3.mjs

@@ -1,8 +0,0 @@
-class WebSocketError extends Error {
-  constructor(...args) {
-    super(...args);
-    this.name = "WebSocketError";
-  }
-}
-
-export { WebSocketError as W };

package/dist/shared/crossws.deae10fd.cjs

@@ -1,10 +0,0 @@
-'use strict';
-
-class WebSocketError extends Error {
-  constructor(...args) {
-    super(...args);
-    this.name = "WebSocketError";
-  }
-}
-
-exports.WebSocketError = WebSocketError;