@solidjs/web 2.0.0-beta.18 → 2.0.0-beta.19

package/server-functions/dist/client.cjs

@@ -0,0 +1,370 @@
+'use strict';
+
+var seroval = require('seroval');
+var web = require('seroval-plugins/web');
+
+seroval.Feature.AggregateError | seroval.Feature.BigIntTypedArray;
+const DEFAULT_WEB_PLUGINS = Object.freeze([web.AbortSignalPlugin,
+web.CustomEventPlugin, web.DOMExceptionPlugin, web.EventPlugin,
+web.FormDataPlugin, web.HeadersPlugin, web.ReadableStreamPlugin, web.RequestPlugin, web.ResponsePlugin, web.URLSearchParamsPlugin, web.URLPlugin]);
+function resolveSerializerPlugins(customPlugins) {
+  return customPlugins ? [...customPlugins, ...DEFAULT_WEB_PLUGINS] : [...DEFAULT_WEB_PLUGINS];
+}
+const JSON_CODEC_DISABLED_FEATURES = seroval.Feature.RegExp;
+const JSON_CODEC_DEPTH_LIMIT = 64;
+function resolveCodecOptions({
+  plugins,
+  disabledFeatures,
+  depthLimit
+} = {}) {
+  return {
+    plugins: resolveSerializerPlugins(plugins),
+    disabledFeatures: disabledFeatures === undefined ? JSON_CODEC_DISABLED_FEATURES : disabledFeatures,
+    depthLimit: depthLimit === undefined ? JSON_CODEC_DEPTH_LIMIT : depthLimit
+  };
+}
+function serializeJSON(value, {
+  onParse,
+  onDone,
+  onError,
+  ...codecOptions
+}) {
+  return seroval.toCrossJSONStream(value, {
+    onParse,
+    onDone,
+    onError,
+    ...resolveCodecOptions(codecOptions)
+  });
+}
+function createJSONDeserializer(options) {
+  const refs = new Map();
+  const resolved = resolveCodecOptions(options);
+  return function deserializeJSONChunk(node) {
+    return seroval.fromCrossJSON(node, {
+      refs,
+      ...resolved
+    });
+  };
+}
+
+const codecConfig = {
+  codec: undefined
+};
+function configureServerFunctionsCodec(codec) {
+  codecConfig.codec = codec;
+}
+function getServerFunctionsCodec() {
+  return codecConfig.codec;
+}
+const FUNCTION_HEADER = "X-Server-Function-Id";
+const INSTANCE_HEADER = "X-Server-Function-Instance";
+const BODY_FORMAT_HEADER = "X-Server-Function-Format";
+const FILE_FORM_KEY = "__server_function_file__";
+const BodyFormat = {
+  Serialized: "0",
+  String: "1",
+  FormData: "2",
+  URLSearchParams: "3",
+  Blob: "4",
+  File: "5",
+  ArrayBuffer: "6",
+  Uint8Array: "7"
+};
+function getHeadersAndBody(body) {
+  switch (true) {
+    case typeof body === "string":
+      return {
+        headers: {
+          "Content-Type": "text/plain",
+          [BODY_FORMAT_HEADER]: BodyFormat.String
+        },
+        body
+      };
+    case body instanceof FormData:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.FormData
+        },
+        body
+      };
+    case body instanceof URLSearchParams:
+      return {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          [BODY_FORMAT_HEADER]: BodyFormat.URLSearchParams
+        },
+        body
+      };
+    case typeof File !== "undefined" && body instanceof File:
+      {
+        const formData = new FormData();
+        formData.append(FILE_FORM_KEY, body, body.name);
+        return {
+          headers: {
+            [BODY_FORMAT_HEADER]: BodyFormat.File
+          },
+          body: formData
+        };
+      }
+    case body instanceof Blob:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.Blob
+        },
+        body
+      };
+    case body instanceof ArrayBuffer:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.ArrayBuffer
+        },
+        body
+      };
+    case body instanceof Uint8Array:
+      return {
+        headers: {
+          [BODY_FORMAT_HEADER]: BodyFormat.Uint8Array
+        },
+        body: new Uint8Array(body)
+      };
+    default:
+      return undefined;
+  }
+}
+async function extractBody(source, codecOptions) {
+  const contentType = source.headers.get("content-type");
+  const format = source.headers.get(BODY_FORMAT_HEADER);
+  const clone = source.clone();
+  switch (true) {
+    case format === BodyFormat.Serialized:
+      return await deserializeStream(clone, codecOptions);
+    case format === BodyFormat.String:
+      return await clone.text();
+    case format === BodyFormat.File:
+      {
+        const formData = await clone.formData();
+        return formData.get(FILE_FORM_KEY);
+      }
+    case format === BodyFormat.FormData:
+    case contentType && contentType.startsWith("multipart/form-data"):
+      return await clone.formData();
+    case format === BodyFormat.URLSearchParams:
+    case contentType && contentType.startsWith("application/x-www-form-urlencoded"):
+      return new URLSearchParams(await clone.text());
+    case format === BodyFormat.Blob:
+      return await clone.blob();
+    case format === BodyFormat.ArrayBuffer:
+      return await clone.arrayBuffer();
+    case format === BodyFormat.Uint8Array:
+      return new Uint8Array(await clone.arrayBuffer());
+  }
+  return undefined;
+}
+function createChunk(data) {
+  const encodeData = new TextEncoder().encode(data);
+  const bytes = encodeData.length;
+  const baseHex = bytes.toString(16);
+  const totalHex = "00000000".substring(0, 8 - baseHex.length) + baseHex;
+  const head = new TextEncoder().encode(`;0x${totalHex};`);
+  const chunk = new Uint8Array(12 + bytes);
+  chunk.set(head);
+  chunk.set(encodeData, 12);
+  return chunk;
+}
+class ChunkReader {
+  constructor(stream) {
+    this.reader = stream.getReader();
+    this.buffer = new Uint8Array(0);
+    this.done = false;
+  }
+  async readChunk() {
+    const chunk = await this.reader.read();
+    if (!chunk.done) {
+      const newBuffer = new Uint8Array(this.buffer.length + chunk.value.length);
+      newBuffer.set(this.buffer);
+      newBuffer.set(chunk.value, this.buffer.length);
+      this.buffer = newBuffer;
+    } else {
+      this.done = true;
+    }
+  }
+  async next() {
+    if (this.buffer.length === 0) {
+      if (this.done) {
+        return {
+          done: true,
+          value: undefined
+        };
+      }
+      await this.readChunk();
+      return await this.next();
+    }
+    const head = new TextDecoder().decode(this.buffer.subarray(1, 11));
+    const bytes = Number.parseInt(head, 16);
+    if (Number.isNaN(bytes)) {
+      throw new Error("Malformed server function stream.");
+    }
+    while (bytes > this.buffer.length - 12) {
+      if (this.done) {
+        throw new Error("Malformed server function stream.");
+      }
+      await this.readChunk();
+    }
+    const partial = new TextDecoder().decode(this.buffer.subarray(12, 12 + bytes));
+    this.buffer = this.buffer.subarray(12 + bytes);
+    return {
+      done: false,
+      value: partial
+    };
+  }
+  async drain(interpret) {
+    while (true) {
+      const result = await this.next();
+      if (result.done) {
+        break;
+      }
+      interpret(result.value);
+    }
+  }
+}
+function serializeStream(value, codecOptions) {
+  return new ReadableStream({
+    start(controller) {
+      serializeJSON(value, {
+        ...codecOptions,
+        onParse(node) {
+          controller.enqueue(createChunk(JSON.stringify(node)));
+        },
+        onDone() {
+          controller.close();
+        },
+        onError(error) {
+          controller.error(error);
+        }
+      });
+    }
+  });
+}
+async function serializeString(value, codecOptions) {
+  const response = new Response(serializeStream(value, codecOptions));
+  return await response.text();
+}
+async function deserializeStream(source, codecOptions) {
+  if (!source.body) {
+    throw new Error("missing body");
+  }
+  const reader = new ChunkReader(source.body);
+  const result = await reader.next();
+  if (!result.done) {
+    const deserializeChunk = createJSONDeserializer(codecOptions);
+    function interpretChunk(chunk) {
+      return deserializeChunk(JSON.parse(chunk));
+    }
+    void reader.drain(interpretChunk);
+    return interpretChunk(result.value);
+  }
+  return undefined;
+}
+async function decodeResponse(response, codecOptions) {
+  if (!response.body) return undefined;
+  return await extractBody(response, codecOptions === undefined ? codecConfig.codec : codecOptions);
+}
+
+const config = {
+  endpoint: "/_server"
+};
+function configureServerFunctionsClient({
+  endpoint,
+  codec
+} = {}) {
+  if (endpoint !== undefined) config.endpoint = endpoint;
+  if (codec !== undefined) configureServerFunctionsCodec(codec);
+}
+let INSTANCE = 0;
+function createRequest(base, id, instance, options) {
+  return fetch(base, {
+    method: "POST",
+    ...options,
+    headers: {
+      ...options.headers,
+      [FUNCTION_HEADER]: id,
+      [INSTANCE_HEADER]: instance
+    }
+  });
+}
+async function initializeResponse(base, id, instance, options, args) {
+  if (args.length === 0) {
+    return createRequest(base, id, instance, options);
+  }
+  if (args.length === 1) {
+    const result = getHeadersAndBody(args[0]);
+    if (result) {
+      return createRequest(base, id, instance, {
+        ...options,
+        body: result.body,
+        headers: {
+          ...options.headers,
+          ...result.headers
+        }
+      });
+    }
+  }
+  return createRequest(base, id, instance, {
+    ...options,
+    body: await serializeString(args, getServerFunctionsCodec()),
+    headers: {
+      ...options.headers,
+      "Content-Type": "text/plain",
+      [BODY_FORMAT_HEADER]: BodyFormat.Serialized
+    }
+  });
+}
+async function fetchServerFunction(base, id, options, args) {
+  const instance = `server-function:${INSTANCE++}`;
+  const response = await initializeResponse(base, id, instance, options, args);
+  if (response.headers.has("Location") || response.headers.has("X-Revalidate") || response.headers.has("X-Single-Flight")) {
+    return response;
+  }
+  const result = await decodeResponse(response.clone());
+  if (response.headers.has("X-Server-Function-Error")) {
+    throw result;
+  }
+  return result;
+}
+function createServerReference(id) {
+  const fn = (...args) => fetchServerFunction(config.endpoint, id, {}, args);
+  return new Proxy(fn, {
+    get(target, prop, receiver) {
+      if (prop === "url") {
+        return `${config.endpoint}?id=${encodeURIComponent(id)}`;
+      }
+      if (prop === "GET") {
+        return receiver.withOptions({
+          method: "GET"
+        });
+      }
+      if (prop === "withOptions") {
+        const url = `${config.endpoint}?id=${encodeURIComponent(id)}`;
+        return options => {
+          const wrapped = async (...args) => {
+            const encodeArgs = options.method && options.method.toUpperCase() === "GET";
+            return fetchServerFunction(encodeArgs ? url + (args.length ? `&args=${encodeURIComponent(await serializeString(args, getServerFunctionsCodec()))}` : "") : config.endpoint, id, options, encodeArgs ? [] : args);
+          };
+          wrapped.url = url;
+          return wrapped;
+        };
+      }
+      return target[prop];
+    }
+  });
+}
+function registerServerReference() {
+  throw new Error("registerServerReference must not be called in the client build");
+}
+
+exports.FUNCTION_HEADER = FUNCTION_HEADER;
+exports.INSTANCE_HEADER = INSTANCE_HEADER;
+exports.configureServerFunctionsClient = configureServerFunctionsClient;
+exports.createServerReference = createServerReference;
+exports.decodeResponse = decodeResponse;
+exports.registerServerReference = registerServerReference;