@bigmistqke/rpc 0.1.0

package/dist/stream.js

@@ -0,0 +1,601 @@
+// ../../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 createPromiseRegistry() {
+  return createIdRegistry();
+}
+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);
+}
+function streamToAsyncIterable(stream) {
+  if (Symbol.asyncIterator in stream) {
+    return stream;
+  }
+  const reader = stream.getReader();
+  return {
+    [Symbol.asyncIterator]() {
+      return {
+        async next() {
+          const result = await reader.read();
+          return result;
+        },
+        async return() {
+          reader.releaseLock();
+          return { value: void 0, done: true };
+        }
+      };
+    }
+  };
+}
+function createReadableStream() {
+  const closeHandlers = /* @__PURE__ */ new Set();
+  let controller = null;
+  let closed = false;
+  const stream = new ReadableStream({
+    start(_controller) {
+      controller = _controller;
+    },
+    cancel() {
+      closeHandlers.forEach((handler) => handler());
+      closed = true;
+    }
+  });
+  return {
+    controller,
+    stream,
+    enqueue: controller.enqueue.bind(controller),
+    closed() {
+      return closed;
+    },
+    onClose(cb) {
+      closeHandlers.add(cb);
+      return () => closeHandlers.delete(cb);
+    }
+  };
+}
+
+// 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/stream/index.ts
+var $STREAM_REQUEST_HEADER = "RPC_STREAM_REQUEST_HEADER";
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var isStreamRequest = (event) => event.request.headers.has($STREAM_REQUEST_HEADER);
+function rpc(reader, methods, codec = {
+  serialize(value, onChunk) {
+    onChunk(encoder.encode(`${JSON.stringify(value)}
+`));
+  },
+  async deserialize(stream, onChunk) {
+    let buffer = "";
+    for await (const value of streamToAsyncIterable(stream)) {
+      buffer += decoder.decode(value, { stream: true });
+      let newlineIndex;
+      while ((newlineIndex = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, newlineIndex);
+        buffer = buffer.slice(newlineIndex + 1);
+        onChunk(JSON.parse(line));
+      }
+    }
+  }
+}) {
+  const promiseRegistry = createPromiseRegistry();
+  const { stream, closed, onClose, enqueue } = createReadableStream();
+  (async () => {
+    const inputStream = await (typeof reader === "function" ? reader(stream) : reader);
+    codec.deserialize(inputStream, async (data) => {
+      if (methods && RequestShape.validate(data) && RPCPayloadShape.validate(data.payload)) {
+        const {
+          payload: { topics, args }
+        } = data;
+        codec.serialize(
+          ResponseShape.create(data, await callMethod(methods, topics, args)),
+          enqueue
+        );
+      } else if (ResponseShape.validate(data)) {
+        promiseRegistry.free(data[$MESSENGER_RESPONSE])?.resolve(data.payload);
+      }
+    });
+  })();
+  return {
+    proxy: createCommander(async (topics, args) => {
+      if (closed?.()) {
+        throw new Error(`[rpc/sse] Stream is closed.`);
+      }
+      const { promise, resolve, reject } = defer();
+      const id = promiseRegistry.register({ resolve, reject });
+      codec.serialize(RequestShape.create(id, RPCPayloadShape.create(topics, args)), enqueue);
+      return promise;
+    }),
+    closed,
+    onClose,
+    stream
+  };
+}
+function client(url, methods, codec) {
+  return rpc(
+    (stream) => fetch(url, {
+      method: "POST",
+      body: stream,
+      // @ts-expect-error
+      duplex: "half",
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive",
+        [$STREAM_REQUEST_HEADER]: "1"
+      }
+    }).then((response) => response.body),
+    methods,
+    codec
+  );
+}
+function server(reader, methods, codec) {
+  const { proxy, closed, onClose, stream } = rpc(reader, methods, codec);
+  return {
+    proxy,
+    closed,
+    onClose,
+    response: new Response(stream, {
+      headers: {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      }
+    })
+  };
+}
+export {
+  client,
+  isStreamRequest,
+  rpc,
+  server
+};
+//# sourceMappingURL=stream.js.map