@bigmistqke/rpc 0.1.0

package/dist/messenger.js

@@ -0,0 +1,540 @@
+// ../../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 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/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 createCommander(apply) {
+  function _createCommander(topics, apply2) {
+    return new Proxy(function() {
+    }, {
+      get(_, topic) {
+        if (typeof topic === "symbol")
+          return void 0;
+        return _createCommander([...topics, topic], apply2);
+      },
+      apply(_, __, args) {
+        return apply2(topics, args);
+      }
+    });
+  }
+  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];
+    return result;
+  }, methods);
+  if (typeof method !== "function") {
+    throw new Error(`Topics did not resolve to a function: [${topics.join(",")}]`);
+  }
+  return method(...args);
+}
+
+// src/message-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: 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 })
+);
+
+// src/messenger.ts
+var $TRANSFER = "WORKER-TRANSFER";
+function isWindowProxy(target) {
+  return typeof target === "object" && typeof target?.postMessage === "function" && typeof target?.closed === "boolean";
+}
+function usePostMessage(messenger) {
+  if (isWindowProxy(messenger)) {
+    return (message, transferables) => messenger.postMessage(message, "*", transferables);
+  } else {
+    return (message, transferables) => messenger.postMessage(message, transferables);
+  }
+}
+function createRequester(messenger, options = {}) {
+  const promiseRegistry = createIdRegistry();
+  const postMessage = usePostMessage(messenger);
+  messenger.addEventListener(
+    "message",
+    (event) => {
+      const data = 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);
+      }
+    },
+    options
+  );
+  if ("start" in messenger) {
+    messenger.start?.();
+  }
+  return (payload, transferables) => {
+    const { promise, resolve, reject } = defer();
+    const id = promiseRegistry.register({ resolve, reject });
+    postMessage(RequestShape.create(id, payload), transferables);
+    return promise;
+  };
+}
+function createResponder(messenger, callback, options = {}) {
+  const postMessage = usePostMessage(messenger);
+  messenger.addEventListener(
+    "message",
+    (event) => {
+      const data = event.data;
+      if (RequestShape.validate(data)) {
+        try {
+          postMessage(ResponseShape.create(data, callback(data)));
+        } catch (error) {
+          postMessage(ErrorShape.create(data, error));
+        }
+      }
+    },
+    options
+  );
+  if ("start" in messenger) {
+    messenger.start?.();
+  }
+}
+function expose(methods, { to = self, signal } = {}) {
+  createResponder(
+    to,
+    (data) => {
+      if (RPCPayloadShape.validate(data.payload)) {
+        try {
+          const { topics, args } = data.payload;
+          return callMethod(methods, topics, args);
+        } catch (error) {
+          console.error("Error while processing rpc request:", error, data.payload, methods);
+        }
+      }
+    },
+    { signal }
+  );
+}
+function rpc(messenger, options) {
+  const request = createRequester(messenger, options);
+  return createCommander((topics, args) => request(RPCPayloadShape.create(topics, args)));
+}
+export {
+  $TRANSFER,
+  createResponder,
+  expose,
+  rpc
+};
+//# sourceMappingURL=messenger.js.map