seroval-plugins 1.0.0

package/web/file.ts

@@ -0,0 +1,50 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+
+interface FileNode {
+  name: SerovalNode;
+  options: SerovalNode;
+  buffer: SerovalNode;
+}
+
+const FilePlugin = /* @__PURE__ */ createPlugin<File, FileNode>({
+  tag: 'seroval-plugins/web/File',
+  test(value) {
+    if (typeof File === 'undefined') {
+      return false;
+    }
+    return value instanceof File;
+  },
+  parse: {
+    async async(value, ctx) {
+      return {
+        name: await ctx.parse(value.name),
+        options: await ctx.parse({
+          type: value.type,
+          lastModified: value.lastModified,
+        }),
+        buffer: await ctx.parse(await value.arrayBuffer()),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      'new File([' +
+      ctx.serialize(node.buffer) +
+      '],' +
+      ctx.serialize(node.name) +
+      ',' +
+      ctx.serialize(node.options) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return new File(
+      [ctx.deserialize(node.buffer) as ArrayBuffer],
+      ctx.deserialize(node.name) as string,
+      ctx.deserialize(node.options) as FilePropertyBag,
+    );
+  },
+});
+
+export default FilePlugin;

package/web/form-data.ts

@@ -0,0 +1,99 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+import FilePlugin from './file';
+
+type FormDataInit = [key: string, value: FormDataEntryValue][];
+
+function convertFormData(instance: FormData): FormDataInit {
+  const items: FormDataInit = [];
+  // biome-ignore lint/complexity/noForEach: <explanation>
+  instance.forEach((value, key) => {
+    items.push([key, value]);
+  });
+  return items;
+}
+
+const FORM_DATA_FACTORY = {};
+
+const FormDataFactoryPlugin = /* @__PURE__ */ createPlugin<object, undefined>({
+  tag: 'seroval-plugins/web/FormDataFactory',
+  test(value) {
+    return value === FORM_DATA_FACTORY;
+  },
+  parse: {
+    sync() {
+      return undefined;
+    },
+    async async() {
+      return await Promise.resolve(undefined);
+    },
+    stream() {
+      return undefined;
+    },
+  },
+  serialize(_node, ctx) {
+    return ctx.createEffectfulFunction(
+      ['e', 'f', 'i', 's', 't'],
+      'f=new FormData;for(i=0,s=e.length;i<s;i++)f.append((t=e[i])[0],t[1]);return f',
+    );
+  },
+  deserialize() {
+    return FORM_DATA_FACTORY;
+  },
+});
+
+interface FormDataNode {
+  factory: SerovalNode;
+  entries: SerovalNode;
+}
+
+const FormDataPlugin = /* @__PURE__ */ createPlugin<FormData, FormDataNode>({
+  tag: 'seroval-plugins/web/FormData',
+  extends: [FilePlugin, FormDataFactoryPlugin],
+  test(value) {
+    if (typeof FormData === 'undefined') {
+      return false;
+    }
+    return value instanceof FormData;
+  },
+  parse: {
+    sync(value, ctx) {
+      return {
+        factory: ctx.parse(FORM_DATA_FACTORY),
+        entries: ctx.parse(convertFormData(value)),
+      };
+    },
+    async async(value, ctx) {
+      return {
+        factory: await ctx.parse(FORM_DATA_FACTORY),
+        entries: await ctx.parse(convertFormData(value)),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        factory: ctx.parse(FORM_DATA_FACTORY),
+        entries: ctx.parse(convertFormData(value)),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      '(' +
+      ctx.serialize(node.factory) +
+      ')(' +
+      ctx.serialize(node.entries) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    const instance = new FormData();
+    const entries = ctx.deserialize(node.entries) as FormDataInit;
+    for (let i = 0, len = entries.length; i < len; i++) {
+      const entry = entries[i];
+      instance.append(entry[0], entry[1]);
+    }
+    return instance;
+  },
+});
+
+export default FormDataPlugin;

package/web/headers.ts

@@ -0,0 +1,40 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+
+function convertHeaders(instance: Headers): HeadersInit {
+  const items: HeadersInit = [];
+  // biome-ignore lint/complexity/noForEach: <explanation>
+  instance.forEach((value, key) => {
+    items.push([key, value]);
+  });
+  return items;
+}
+
+const HeadersPlugin = /* @__PURE__ */ createPlugin<Headers, SerovalNode>({
+  tag: 'seroval-plugins/web/Headers',
+  test(value) {
+    if (typeof Headers === 'undefined') {
+      return false;
+    }
+    return value instanceof Headers;
+  },
+  parse: {
+    sync(value, ctx) {
+      return ctx.parse(convertHeaders(value));
+    },
+    async async(value, ctx) {
+      return await ctx.parse(convertHeaders(value));
+    },
+    stream(value, ctx) {
+      return ctx.parse(convertHeaders(value));
+    },
+  },
+  serialize(node, ctx) {
+    return 'new Headers(' + ctx.serialize(node) + ')';
+  },
+  deserialize(node, ctx) {
+    return new Headers(ctx.deserialize(node) as HeadersInit);
+  },
+});
+
+export default HeadersPlugin;

package/web/image-data.ts

@@ -0,0 +1,74 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+
+interface ImageDataNode {
+  data: SerovalNode;
+  width: SerovalNode;
+  height: SerovalNode;
+  options: SerovalNode;
+}
+
+const ImageDataPlugin = /* @__PURE__ */ createPlugin<ImageData, ImageDataNode>({
+  tag: 'seroval-plugins/web/ImageData',
+  test(value) {
+    if (typeof ImageData === 'undefined') {
+      return false;
+    }
+    return value instanceof ImageData;
+  },
+  parse: {
+    sync(value, ctx) {
+      return {
+        data: ctx.parse(value.data),
+        width: ctx.parse(value.width),
+        height: ctx.parse(value.height),
+        options: ctx.parse({
+          colorSpace: value.colorSpace,
+        }),
+      };
+    },
+    async async(value, ctx) {
+      return {
+        data: await ctx.parse(value.data),
+        width: await ctx.parse(value.width),
+        height: await ctx.parse(value.height),
+        options: await ctx.parse({
+          colorSpace: value.colorSpace,
+        }),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        data: ctx.parse(value.data),
+        width: ctx.parse(value.width),
+        height: ctx.parse(value.height),
+        options: ctx.parse({
+          colorSpace: value.colorSpace,
+        }),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      'new ImageData(' +
+      ctx.serialize(node.data) +
+      ',' +
+      ctx.serialize(node.width) +
+      ',' +
+      ctx.serialize(node.height) +
+      ',' +
+      ctx.serialize(node.options) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return new ImageData(
+      ctx.deserialize(node.data) as Uint8ClampedArray,
+      ctx.deserialize(node.width) as number,
+      ctx.deserialize(node.height) as number,
+      ctx.deserialize(node.options) as ImageDataSettings,
+    );
+  },
+});
+
+export default ImageDataPlugin;

package/web/index.ts

@@ -0,0 +1,13 @@
+export { default as BlobPlugin } from './blob';
+export { default as CustomEventPlugin } from './custom-event';
+export { default as DOMExceptionPlugin } from './dom-exception';
+export { default as EventPlugin } from './event';
+export { default as FilePlugin } from './file';
+export { default as FormDataPlugin } from './form-data';
+export { default as HeadersPlugin } from './headers';
+export { default as ImageDataPlugin } from './image-data';
+export { default as ReadableStreamPlugin } from './readable-stream';
+export { default as Request } from './request';
+export { default as Response } from './response';
+export { default as URLSearchParamsPlugin } from './url-search-params';
+export { default as URL } from './url';

package/web/readable-stream.ts

@@ -0,0 +1,139 @@
+import type { SerovalNode, Stream } from 'seroval';
+import { createPlugin, createStream } from 'seroval';
+
+const READABLE_STREAM_FACTORY = {};
+
+const ReadableStreamFactoryPlugin = /* @__PURE__ */ createPlugin<
+  object,
+  undefined
+>({
+  tag: 'seroval-plugins/web/ReadableStreamFactory',
+  test(value) {
+    return value === READABLE_STREAM_FACTORY;
+  },
+  parse: {
+    sync() {
+      return undefined;
+    },
+    async async() {
+      return await Promise.resolve(undefined);
+    },
+    stream() {
+      return undefined;
+    },
+  },
+  serialize(_node, ctx) {
+    return ctx.createFunction(
+      ['d'],
+      'new ReadableStream({start:' +
+        ctx.createEffectfulFunction(
+          ['c'],
+          'd.on({next:' +
+            ctx.createEffectfulFunction(['v'], 'c.enqueue(v)') +
+            ',throw:' +
+            ctx.createEffectfulFunction(['v'], 'c.error(v)') +
+            ',return:' +
+            ctx.createEffectfulFunction([], 'c.close()') +
+            '})',
+        ) +
+        '})',
+    );
+  },
+  deserialize() {
+    return READABLE_STREAM_FACTORY;
+  },
+});
+
+function toStream<T>(value: ReadableStream<T>): Stream<T | undefined> {
+  const stream = createStream<T | undefined>();
+
+  const reader = value.getReader();
+
+  async function push(): Promise<void> {
+    try {
+      const result = await reader.read();
+      if (result.done) {
+        stream.return(result.value);
+      } else {
+        stream.next(result.value);
+        await push();
+      }
+    } catch (error) {
+      stream.throw(error);
+    }
+  }
+
+  push().catch(() => {
+    //
+  });
+
+  return stream;
+}
+
+interface ReadableStreamNode {
+  factory: SerovalNode;
+  stream: SerovalNode;
+}
+
+const ReadableStreamPlugin = /* @__PURE__ */ createPlugin<
+  ReadableStream,
+  ReadableStreamNode
+>({
+  tag: 'seroval/plugins/web/ReadableStream',
+  extends: [ReadableStreamFactoryPlugin],
+  test(value) {
+    if (typeof ReadableStream === 'undefined') {
+      return false;
+    }
+    return value instanceof ReadableStream;
+  },
+  parse: {
+    sync(_value, ctx) {
+      return {
+        factory: ctx.parse(READABLE_STREAM_FACTORY),
+        stream: ctx.parse(createStream()),
+      };
+    },
+    async async(value, ctx) {
+      return {
+        factory: await ctx.parse(READABLE_STREAM_FACTORY),
+        stream: await ctx.parse(toStream(value)),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        factory: ctx.parse(READABLE_STREAM_FACTORY),
+        stream: ctx.parse(toStream(value)),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      '(' +
+      ctx.serialize(node.factory) +
+      ')(' +
+      ctx.serialize(node.stream) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    const stream = ctx.deserialize(node.stream) as Stream<any>;
+    return new ReadableStream({
+      start(controller): void {
+        stream.on({
+          next(value) {
+            controller.enqueue(value);
+          },
+          throw(value) {
+            controller.error(value);
+          },
+          return() {
+            controller.close();
+          },
+        });
+      },
+    });
+  },
+});
+
+export default ReadableStreamPlugin;

package/web/request.ts

@@ -0,0 +1,75 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+import ReadableStreamPlugin from './readable-stream';
+import HeadersPlugin from './headers';
+
+function createRequestOptions(
+  current: Request,
+  body: ArrayBuffer | ReadableStream | null,
+): RequestInit {
+  return {
+    body,
+    cache: current.cache,
+    credentials: current.credentials,
+    headers: current.headers,
+    integrity: current.integrity,
+    keepalive: current.keepalive,
+    method: current.method,
+    mode: current.mode,
+    redirect: current.redirect,
+    referrer: current.referrer,
+    referrerPolicy: current.referrerPolicy,
+  };
+}
+
+interface RequestNode {
+  url: SerovalNode;
+  options: SerovalNode;
+}
+
+const RequestPlugin = /* @__PURE__ */ createPlugin<Request, RequestNode>({
+  tag: 'seroval-plugins/web/Request',
+  extends: [ReadableStreamPlugin, HeadersPlugin],
+  test(value) {
+    if (typeof Request === 'undefined') {
+      return false;
+    }
+    return value instanceof Request;
+  },
+  parse: {
+    async async(value, ctx) {
+      return {
+        url: await ctx.parse(value.url),
+        options: await ctx.parse(
+          createRequestOptions(
+            value,
+            value.body ? await value.clone().arrayBuffer() : null,
+          ),
+        ),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        url: ctx.parse(value.url),
+        options: ctx.parse(createRequestOptions(value, value.clone().body)),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      'new Request(' +
+      ctx.serialize(node.url) +
+      ',' +
+      ctx.serialize(node.options) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return new Request(
+      ctx.deserialize(node.url) as string,
+      ctx.deserialize(node.options) as RequestInit,
+    );
+  },
+});
+
+export default RequestPlugin;

package/web/response.ts

@@ -0,0 +1,61 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+import ReadableStreamPlugin from './readable-stream';
+import HeadersPlugin from './headers';
+
+function createResponseOptions(current: Response): ResponseInit {
+  return {
+    headers: current.headers,
+    status: current.status,
+    statusText: current.statusText,
+  };
+}
+
+interface ResponseNode {
+  body: SerovalNode;
+  options: SerovalNode;
+}
+
+const ResponsePlugin = /* @__PURE__ */ createPlugin<Response, ResponseNode>({
+  tag: 'seroval-plugins/web/Response',
+  extends: [ReadableStreamPlugin, HeadersPlugin],
+  test(value) {
+    if (typeof Response === 'undefined') {
+      return false;
+    }
+    return value instanceof Response;
+  },
+  parse: {
+    async async(value, ctx) {
+      return {
+        body: await ctx.parse(
+          value.body ? await value.clone().arrayBuffer() : null,
+        ),
+        options: await ctx.parse(createResponseOptions(value)),
+      };
+    },
+    stream(value, ctx) {
+      return {
+        body: ctx.parse(value.clone().body),
+        options: ctx.parse(createResponseOptions(value)),
+      };
+    },
+  },
+  serialize(node, ctx) {
+    return (
+      'new Response(' +
+      ctx.serialize(node.body) +
+      ',' +
+      ctx.serialize(node.options) +
+      ')'
+    );
+  },
+  deserialize(node, ctx) {
+    return new Response(
+      ctx.deserialize(node.body) as BodyInit,
+      ctx.deserialize(node.options) as ResponseInit,
+    );
+  },
+});
+
+export default ResponsePlugin;

package/web/url-search-params.ts

@@ -0,0 +1,34 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+
+const URLSearchParamsPlugin = /* @__PURE__ */ createPlugin<
+  URLSearchParams,
+  SerovalNode
+>({
+  tag: 'seroval-plugins/web/URLSearchParams',
+  test(value) {
+    if (typeof URLSearchParams === 'undefined') {
+      return false;
+    }
+    return value instanceof URLSearchParams;
+  },
+  parse: {
+    sync(value, ctx) {
+      return ctx.parse(value.toString());
+    },
+    async async(value, ctx) {
+      return await ctx.parse(value.toString());
+    },
+    stream(value, ctx) {
+      return ctx.parse(value.toString());
+    },
+  },
+  serialize(node, ctx) {
+    return 'new URLSearchParams(' + ctx.serialize(node) + ')';
+  },
+  deserialize(node, ctx) {
+    return new URLSearchParams(ctx.deserialize(node) as string);
+  },
+});
+
+export default URLSearchParamsPlugin;

package/web/url.ts

@@ -0,0 +1,31 @@
+import type { SerovalNode } from 'seroval';
+import { createPlugin } from 'seroval';
+
+const URLPlugin = /* @__PURE__ */ createPlugin<URL, SerovalNode>({
+  tag: 'seroval-plugins/web/URL',
+  test(value) {
+    if (typeof URL === 'undefined') {
+      return false;
+    }
+    return value instanceof URL;
+  },
+  parse: {
+    sync(value, ctx) {
+      return ctx.parse(value.href);
+    },
+    async async(value, ctx) {
+      return await ctx.parse(value.href);
+    },
+    stream(value, ctx) {
+      return ctx.parse(value.href);
+    },
+  },
+  serialize(node, ctx) {
+    return 'new URL(' + ctx.serialize(node) + ')';
+  },
+  deserialize(node, ctx) {
+    return new URL(ctx.deserialize(node) as string);
+  },
+});
+
+export default URLPlugin;