@bigmistqke/rpc 0.1.2 → 0.1.4

package/dist/fetch.d.ts

@@ -1,4 +1,4 @@
-import { R as RPC } from './types-4d4495dd.js';
+import { R as RPC } from './types-9f54da43.js';
 
 declare const isFetchRequest: (event: {
     request: Request;

package/dist/fetch.js

@@ -167,6 +167,48 @@ function array(item, message) {
     }
   };
 }
+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",
@@ -250,6 +292,32 @@ function object(entries, message) {
     }
   };
 }
+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",
@@ -271,6 +339,22 @@ function string(message) {
     }
   };
 }
+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 {
@@ -281,13 +365,76 @@ function safeParse(schema, input, config2) {
   };
 }
 
+// src/handle.ts
+var $HANDLE_MARKER = Symbol("RPC-HANDLE-MARKER");
+
 // src/utils.ts
+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(_, topic) {
+      get(target, topic) {
         if (typeof topic === "symbol")
+          return target[topic];
+        if (topic === "then")
           return void 0;
         return _createCommander([...topics, topic], apply2);
       },
@@ -298,12 +445,6 @@ function createCommander(apply) {
   }
   return _createCommander([], apply);
 }
-function createShape(schema, create) {
-  return {
-    validate: (value) => safeParse(schema, value).success,
-    create
-  };
-}
 function callMethod(methods, topics, args) {
   const method = topics.reduce((acc, topic) => {
     const result = acc?.[topic];