@bigmistqke/rpc 0.1.2 → 0.1.4

package/dist/{types-4d4495dd.d.ts → types-9f54da43.d.ts}

@@ -1,4 +1,8 @@
 type Fn = (...arg: Array<any>) => any;
+/** Check if T is a Handled type and extract the inner type */
+type UnwrapHandled<T> = T extends {
+    readonly ['__rpc_handled__']: infer U extends object;
+} ? RPC<U> : T;
 type isObject<T> = T extends object ? true : false;
 type HasMethod<T> = T extends object ? {
     [K in keyof T]: T[K] extends Fn ? true : HasMethod<T[K]>;
@@ -19,7 +23,7 @@ type FilterNoResponseMethod<T> = {
 /**********************************************************************************/
 /**********************************************************************************/
 interface ResponseMethod<T extends Fn> {
-    (...args: Parameters<T>): Promise<ReturnType<T>>;
+    (...args: Parameters<T>): Promise<UnwrapHandled<Awaited<ReturnType<T>>>>;
 }
 type ResponseRPCNode<T> = T extends Fn ? ResponseMethod<T> : T extends readonly [any, ...any[]] ? {
     [K in keyof T]: ResponseRPCNode<T[K]>;

package/dist/websocket.d.ts

@@ -0,0 +1,50 @@
+import { R as RPC$1 } from './types-9f54da43.js';
+export { H as Handled, h as handle } from './handle-18d6fe9b.js';
+
+declare const $WEBSOCKET: unique symbol;
+interface WebSocketLike {
+    send(data: string): void;
+    close(): void;
+    addEventListener(type: string, listener: (event: unknown) => void): void;
+}
+type RPC<T extends object, WS extends WebSocketLike = WebSocketLike> = RPC$1<T> & {
+    [$WEBSOCKET]: WS;
+};
+/**********************************************************************************/
+/**********************************************************************************/
+/**
+ * Exposes methods as an RPC endpoint over the given WebSocket.
+ *
+ * @param methods - Object containing methods to expose
+ * @param options - Target WebSocket and optional abort signal
+ *
+ * @example
+ * ```ts
+ * expose({
+ *   add: (a, b) => a + b,
+ *   multiply: (a, b) => a * b,
+ * }, { to: ws })
+ * ```
+ */
+declare function expose<TMethods extends object>(methods: TMethods, { to }: {
+    to: WebSocketLike;
+}): void;
+/**
+ * Creates an RPC proxy for calling remote methods on the given WebSocket.
+ *
+ * @param ws - The WebSocket to communicate with
+ * @param options - Optional abort signal
+ * @returns A proxy object for calling remote methods
+ *
+ * @example
+ * ```ts
+ * const server = rpc<ServerMethods>(ws)
+ * const result = await server.add(2, 3)
+ *
+ * // Access underlying WebSocket
+ * server[$WEBSOCKET].close()
+ * ```
+ */
+declare function rpc<T extends object, WS extends WebSocketLike = WebSocketLike>(ws: WS): RPC<T, WS>;
+
+export { $WEBSOCKET, RPC, WebSocketLike, expose, rpc };

package/dist/websocket.js

@@ -0,0 +1,617 @@
+// ../../node_modules/.pnpm/valibot@1.0.0_typescript@5.7.2/node_modules/valibot/dist/index.js
+var store;
+function getGlobalConfig(config2) {
+  return {
+    lang: config2?.lang ?? store?.lang,
+    message: config2?.message,
+    abortEarly: config2?.abortEarly ?? store?.abortEarly,
+    abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+  };
+}
+var store2;
+function getGlobalMessage(lang) {
+  return store2?.get(lang);
+}
+var store3;
+function getSchemaMessage(lang) {
+  return store3?.get(lang);
+}
+var store4;
+function getSpecificMessage(reference, lang) {
+  return store4?.get(reference)?.get(lang);
+}
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") {
+    return `"${input}"`;
+  }
+  if (type === "number" || type === "bigint" || type === "boolean") {
+    return `${input}`;
+  }
+  if (type === "object" || type === "function") {
+    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  }
+  return type;
+}
+function _addIssue(context, label, dataset, config2, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config2.lang,
+    abortEarly: config2.abortEarly,
+    abortPipeEarly: config2.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message = other?.message ?? context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config2.message ?? getGlobalMessage(issue.lang);
+  if (message !== void 0) {
+    issue.message = typeof message === "function" ? (
+      // @ts-expect-error
+      message(issue)
+    ) : message;
+  }
+  if (isSchema) {
+    dataset.typed = false;
+  }
+  if (dataset.issues) {
+    dataset.issues.push(issue);
+  } else {
+    dataset.issues = [issue];
+  }
+}
+function _getStandardProps(context) {
+  return {
+    version: 1,
+    vendor: "valibot",
+    validate(value2) {
+      return context["~run"]({ value: value2 }, getGlobalConfig());
+    }
+  };
+}
+function getFallback(schema, dataset, config2) {
+  return typeof schema.fallback === "function" ? (
+    // @ts-expect-error
+    schema.fallback(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.fallback
+  );
+}
+function getDefault(schema, dataset, config2) {
+  return typeof schema.default === "function" ? (
+    // @ts-expect-error
+    schema.default(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.default
+  );
+}
+function any() {
+  return {
+    kind: "schema",
+    type: "any",
+    reference: any,
+    expects: "any",
+    async: false,
+    get "~standard"() {
+      return _getStandardProps(this);
+    },
+    "~run"(dataset) {
+      dataset.typed = true;
+      return dataset;
+    }
+  };
+}
+function array(item, message) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array,
+    expects: "Array",
+    async: false,
+    item,
+    message,
+    get "~standard"() {
+      return _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0; key < input.length; key++) {
+          const value2 = input[key];
+          const itemDataset = this.item["~run"]({ value: value2 }, config2);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value2
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path) {
+                issue.path.unshift(pathItem);
+              } else {
+                issue.path = [pathItem];
+              }
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) {
+              dataset.issues = itemDataset.issues;
+            }
+            if (config2.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed) {
+            dataset.typed = false;
+          }
+          dataset.value.push(itemDataset.value);
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function boolean(message) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message,
+    get "~standard"() {
+      return _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "boolean") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function number(message) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message,
+    get "~standard"() {
+      return _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function object(entries, message) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries,
+    message,
+    get "~standard"() {
+      return _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && // @ts-expect-error
+          valueSchema.default !== void 0) {
+            const value2 = key in input ? (
+              // @ts-expect-error
+              input[key]
+            ) : getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value2
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) {
+                  issue.path.unshift(pathItem);
+                } else {
+                  issue.path = [pathItem];
+                }
+                dataset.issues?.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = valueDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) {
+              dataset.typed = false;
+            }
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) {
+            dataset.value[key] = getFallback(valueSchema);
+          } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config2, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [
+                {
+                  type: "object",
+                  origin: "key",
+                  input,
+                  key,
+                  // @ts-expect-error
+                  value: input[key]
+                }
+              ]
+            });
+            if (config2.abortEarly) {
+              break;
+            }
+          }
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) {
+          dataset.value = getDefault(this, dataset, config2);
+        }
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config2);
+    }
+  };
+}
+function string(message) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message,
+    get "~standard"() {
+      return _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "string") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+function unknown() {
+  return {
+    kind: "schema",
+    type: "unknown",
+    reference: unknown,
+    expects: "unknown",
+    async: false,
+    get "~standard"() {
+      return _getStandardProps(this);
+    },
+    "~run"(dataset) {
+      dataset.typed = true;
+      return dataset;
+    }
+  };
+}
+function safeParse(schema, input, config2) {
+  const dataset = schema["~run"]({ value: input }, getGlobalConfig(config2));
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+
+// src/handle.ts
+var $HANDLE_MARKER = Symbol("RPC-HANDLE-MARKER");
+function handle(methods) {
+  return { [$HANDLE_MARKER]: true, methods };
+}
+function isHandleMarker(value) {
+  return !!value && typeof value === "object" && $HANDLE_MARKER in value;
+}
+var HANDLE_NAMESPACE_PREFIX = "__rpc_handle_";
+var handleNamespaceCounter = 0;
+function nextHandleNamespaceId() {
+  return `${HANDLE_NAMESPACE_PREFIX}${handleNamespaceCounter++}`;
+}
+
+// src/utils.ts
+function createIdAllocator() {
+  const freeIds = new Array();
+  let id = 0;
+  return {
+    create() {
+      if (freeIds.length) {
+        return freeIds.pop();
+      }
+      return id++;
+    },
+    free(id2) {
+      freeIds.push(id2);
+    }
+  };
+}
+function createIdRegistry() {
+  const map = /* @__PURE__ */ new Map();
+  const idFactory = createIdAllocator();
+  return {
+    register(value) {
+      const id = idFactory.create();
+      map.set(id, value);
+      return id;
+    },
+    free(id) {
+      idFactory.free(id);
+      return map.get(id);
+    }
+  };
+}
+function defer() {
+  let resolve = null;
+  let reject = null;
+  return {
+    promise: new Promise((_resolve, _reject) => (resolve = _resolve, reject = _reject)),
+    resolve,
+    reject
+  };
+}
+function createShape(schema, create) {
+  return {
+    validate: (value) => safeParse(schema, value).success,
+    create
+  };
+}
+
+// src/protocol.ts
+var $MESSENGER_REQUEST = "RPC_PROXY_REQUEST";
+var requestSchema = object({
+  [$MESSENGER_REQUEST]: number(),
+  payload: unknown()
+});
+var RequestShape = createShape(requestSchema, (id, payload) => ({
+  [$MESSENGER_REQUEST]: id,
+  payload
+}));
+var $MESSENGER_RESPONSE = "RPC_PROXY_RESPONSE";
+var ResponseShape = createShape(
+  object({
+    [$MESSENGER_RESPONSE]: number(),
+    payload: optional(unknown())
+  }),
+  (request, payload) => ({
+    [$MESSENGER_RESPONSE]: request[$MESSENGER_REQUEST],
+    payload
+  })
+);
+var $MESSENGER_ERROR = "RPC_PROXY_ERROR";
+var ErrorShape = createShape(
+  object({
+    [$MESSENGER_ERROR]: number(),
+    error: unknown()
+  }),
+  (data, error) => ({
+    [$MESSENGER_ERROR]: data[$MESSENGER_REQUEST],
+    error
+  })
+);
+var $MESSENGER_RPC_REQUEST = "RPC_PROXY_RPC_REQUEST";
+var RPCPayloadShape = createShape(
+  object({
+    [$MESSENGER_RPC_REQUEST]: boolean(),
+    topics: array(string()),
+    args: array(any())
+  }),
+  (topics, args) => ({ [$MESSENGER_RPC_REQUEST]: true, topics, args })
+);
+var $MESSENGER_HANDLE = "RPC_PROXY_HANDLE";
+var HandleResponseShape = createShape(
+  object({
+    [$MESSENGER_HANDLE]: string()
+    // namespace ID
+  }),
+  (namespaceId) => ({ [$MESSENGER_HANDLE]: namespaceId })
+);
+
+// src/core.ts
+function createCommander(apply) {
+  function _createCommander(topics, apply2) {
+    return new Proxy(function() {
+    }, {
+      get(target, topic) {
+        if (typeof topic === "symbol")
+          return target[topic];
+        if (topic === "then")
+          return void 0;
+        return _createCommander([...topics, topic], apply2);
+      },
+      apply(_, __, args) {
+        return apply2(topics, args);
+      }
+    });
+  }
+  return _createCommander([], apply);
+}
+function callMethod(methods, topics, args) {
+  const method = topics.reduce((acc, topic) => {
+    const result = acc?.[topic];
+    return result;
+  }, methods);
+  if (typeof method !== "function") {
+    throw new Error(`Topics did not resolve to a function: [${topics.join(",")}]`);
+  }
+  return method(...args);
+}
+function isHandleResponse(value) {
+  return !!value && typeof value === "object" && $MESSENGER_HANDLE in value && typeof value[$MESSENGER_HANDLE] === "string";
+}
+function createExposeRequestHandler(methods) {
+  const namespaceHandlers = /* @__PURE__ */ new Map();
+  const processResult = (result) => {
+    if (isHandleMarker(result)) {
+      const namespaceId = nextHandleNamespaceId();
+      namespaceHandlers.set(namespaceId, result.methods);
+      return HandleResponseShape.create(namespaceId);
+    }
+    return result;
+  };
+  return async (topics, args) => {
+    const firstTopic = topics[0];
+    if (firstTopic && firstTopic.startsWith(HANDLE_NAMESPACE_PREFIX)) {
+      const handler = namespaceHandlers.get(firstTopic);
+      if (!handler) {
+        throw new Error(`Unknown namespace: ${firstTopic}`);
+      }
+      const result2 = await callMethod(handler, topics.slice(1), args);
+      return processResult(result2);
+    }
+    const result = await callMethod(methods, topics, args);
+    return processResult(result);
+  };
+}
+function createRpcCommander(request, topicPrefix = []) {
+  return createCommander((topics, methodArgs) => {
+    const fullTopics = [...topicPrefix, ...topics];
+    return request(fullTopics, methodArgs).then((result) => {
+      if (isHandleResponse(result)) {
+        return createRpcCommander(
+          request,
+          result[$MESSENGER_HANDLE] ? [result[$MESSENGER_HANDLE]] : []
+        );
+      }
+      return result;
+    });
+  });
+}
+
+// src/websocket/index.ts
+var $WEBSOCKET = Symbol.for("RPC-WEBSOCKET");
+var MessageEventShape = createShape(object({ data: unknown() }), (data) => ({
+  data
+}));
+function parseData(raw) {
+  return JSON.parse(typeof raw === "string" ? raw : String(raw));
+}
+function createRequester(ws) {
+  const promiseRegistry = createIdRegistry();
+  ws.addEventListener("message", (event) => {
+    if (!MessageEventShape.validate(event))
+      return;
+    try {
+      const data = parseData(event.data);
+      if (ErrorShape.validate(data)) {
+        promiseRegistry.free(data[$MESSENGER_ERROR])?.reject(data.error);
+      } else if (ResponseShape.validate(data)) {
+        promiseRegistry.free(data[$MESSENGER_RESPONSE])?.resolve(data.payload);
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  });
+  return (payload) => {
+    const { promise, resolve, reject } = defer();
+    const id = promiseRegistry.register({ resolve, reject });
+    ws.send(JSON.stringify(RequestShape.create(id, payload)));
+    return promise;
+  };
+}
+function expose(methods, { to }) {
+  const handleRequest = createExposeRequestHandler(methods);
+  to.addEventListener("message", async (event) => {
+    if (!MessageEventShape.validate(event))
+      return;
+    try {
+      const data = parseData(event.data);
+      if (RequestShape.validate(data)) {
+        try {
+          if (RPCPayloadShape.validate(data.payload)) {
+            const result = await handleRequest(data.payload.topics, data.payload.args);
+            to.send(JSON.stringify(ResponseShape.create(data, result)));
+          }
+        } catch (error) {
+          console.error("Error while processing rpc request:", error, data.payload);
+          to.send(JSON.stringify(ErrorShape.create(data, error)));
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  });
+}
+function rpc(ws) {
+  const request = createRequester(ws);
+  const proxy = createRpcCommander((topics, args) => {
+    return request(RPCPayloadShape.create(topics, args));
+  });
+  return Object.assign(proxy, { [$WEBSOCKET]: ws });
+}
+export {
+  $WEBSOCKET,
+  expose,
+  handle,
+  rpc
+};
+//# sourceMappingURL=websocket.js.map