seroval-plugins 1.5.5 → 1.6.0

package/web/file.ts

@@ -1,50 +0,0 @@
-import type { SerovalNode } from 'seroval';
-import { createPlugin } from 'seroval';
-
-type 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

@@ -1,105 +0,0 @@
-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 = [];
-  instance.forEach((value, key) => {
-    items.push([key, value]);
-  });
-  return items;
-}
-
-const FORM_DATA_FACTORY = {};
-
-const FORM_DATA_FACTORY_CONSTRUCTOR = (
-  e: [key: string, value: FormDataEntryValue][],
-  f = new FormData(),
-  i = 0,
-  s = e.length,
-  t?: [key: string, value: FormDataEntryValue],
-) => {
-  for (; i < s; i++) {
-    t = e[i];
-    f.append(t[0], t[1]);
-  }
-  return f;
-};
-
-const FormDataFactoryPlugin = /* @__PURE__ */ createPlugin<object, {}>({
-  tag: 'seroval-plugins/web/FormDataFactory',
-  test(value) {
-    return value === FORM_DATA_FACTORY;
-  },
-  parse: {
-    sync() {
-      return FORM_DATA_FACTORY;
-    },
-    async async() {
-      return await Promise.resolve(FORM_DATA_FACTORY);
-    },
-    stream() {
-      return FORM_DATA_FACTORY;
-    },
-  },
-  serialize() {
-    return FORM_DATA_FACTORY_CONSTRUCTOR.toString();
-  },
-  deserialize() {
-    return FORM_DATA_FACTORY;
-  },
-});
-
-type 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) {
-    return FORM_DATA_FACTORY_CONSTRUCTOR(
-      ctx.deserialize(node.entries) as FormDataInit,
-    );
-  },
-});
-
-export default FormDataPlugin;

package/web/headers.ts

@@ -1,49 +0,0 @@
-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,
-  { value: SerovalNode }
->({
-  tag: 'seroval-plugins/web/Headers',
-  test(value) {
-    if (typeof Headers === 'undefined') {
-      return false;
-    }
-    return value instanceof Headers;
-  },
-  parse: {
-    sync(value, ctx) {
-      return {
-        value: ctx.parse(convertHeaders(value)),
-      };
-    },
-    async async(value, ctx) {
-      return {
-        value: await ctx.parse(convertHeaders(value)),
-      };
-    },
-    stream(value, ctx) {
-      return {
-        value: ctx.parse(convertHeaders(value)),
-      };
-    },
-  },
-  serialize(node, ctx) {
-    return 'new Headers(' + ctx.serialize(node.value) + ')';
-  },
-  deserialize(node, ctx) {
-    return new Headers(ctx.deserialize(node.value) as HeadersInit);
-  },
-});
-
-export default HeadersPlugin;

package/web/image-data.ts

@@ -1,74 +0,0 @@
-import type { SerovalNode } from 'seroval';
-import { createPlugin } from 'seroval';
-
-type 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<ArrayBuffer>,
-      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

@@ -1,14 +0,0 @@
-export { default as AbortSignalPlugin } from './abort-signal';
-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 RequestPlugin } from './request';
-export { default as ResponsePlugin } from './response';
-export { default as URLPlugin } from './url';
-export { default as URLSearchParamsPlugin } from './url-search-params';

package/web/readable-stream.ts

@@ -1,148 +0,0 @@
-import type { SerovalNode, Stream } from 'seroval';
-import { createPlugin, createStream } from 'seroval';
-
-const READABLE_STREAM_FACTORY = {};
-
-const READABLE_STREAM_FACTORY_CONSTRUCTOR = (stream: Stream<unknown>) =>
-  new ReadableStream({
-    start: controller => {
-      stream.on({
-        next: value => {
-          try {
-            controller.enqueue(value);
-          } catch (_error) {
-            // no-op
-          }
-        },
-        throw: value => {
-          controller.error(value);
-        },
-        return: () => {
-          try {
-            controller.close();
-          } catch (_error) {
-            // no-op
-          }
-        },
-      });
-    },
-  });
-
-const ReadableStreamFactoryPlugin = /* @__PURE__ */ createPlugin<object, {}>({
-  tag: 'seroval-plugins/web/ReadableStreamFactory',
-  test(value) {
-    return value === READABLE_STREAM_FACTORY;
-  },
-  parse: {
-    sync() {
-      return READABLE_STREAM_FACTORY;
-    },
-    async async() {
-      return await Promise.resolve(READABLE_STREAM_FACTORY);
-    },
-    stream() {
-      return READABLE_STREAM_FACTORY;
-    },
-  },
-  serialize() {
-    return READABLE_STREAM_FACTORY_CONSTRUCTOR.toString();
-  },
-  deserialize() {
-    return READABLE_STREAM_FACTORY;
-  },
-});
-
-async function drainStream<T>(
-  stream: Stream<T | undefined>,
-  reader: ReadableStreamDefaultReader<T>,
-): Promise<void> {
-  try {
-    const result = await reader.read();
-    if (result.done) {
-      stream.return(result.value);
-      reader.releaseLock();
-    } else {
-      stream.next(result.value);
-      await drainStream(stream, reader);
-    }
-  } catch (error) {
-    stream.throw(error);
-  }
-}
-
-function cleanupStream<T>(reader: ReadableStreamDefaultReader<T>): void {
-  reader.cancel().catch(() => {
-    // no-op
-  });
-  reader.releaseLock();
-}
-
-function toStream<T>(
-  value: ReadableStream<T>,
-): [Stream<T | undefined>, () => void] {
-  const stream = createStream<T | undefined>();
-
-  const reader = value.getReader();
-
-  const cleanup = cleanupStream.bind(null, reader);
-
-  drainStream(stream, reader).catch(cleanup);
-
-  return [stream, cleanup];
-}
-
-type 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)[0]),
-      };
-    },
-    stream(value, ctx) {
-      const [stream, cleanup] = toStream(value);
-      ctx.addCleanup(cleanup);
-      return {
-        factory: ctx.parse(READABLE_STREAM_FACTORY),
-        stream: ctx.parse(stream),
-      };
-    },
-  },
-  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 READABLE_STREAM_FACTORY_CONSTRUCTOR(stream);
-  },
-});
-
-export default ReadableStreamPlugin;

package/web/request.ts

@@ -1,82 +0,0 @@
-import type { SerovalNode } from 'seroval';
-import { createPlugin } from 'seroval';
-import HeadersPlugin from './headers';
-import ReadableStreamPlugin from './readable-stream';
-
-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,
-  };
-}
-
-type 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 && !value.bodyUsed
-              ? await value.clone().arrayBuffer()
-              : null,
-          ),
-        ),
-      };
-    },
-    stream(value, ctx) {
-      return {
-        url: ctx.parse(value.url),
-        options: ctx.parse(
-          createRequestOptions(
-            value,
-            value.body && !value.bodyUsed ? value.clone().body : null,
-          ),
-        ),
-      };
-    },
-  },
-  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

@@ -1,65 +0,0 @@
-import type { SerovalNode } from 'seroval';
-import { createPlugin } from 'seroval';
-import HeadersPlugin from './headers';
-import ReadableStreamPlugin from './readable-stream';
-
-function createResponseOptions(current: Response): ResponseInit {
-  return {
-    headers: current.headers,
-    status: current.status,
-    statusText: current.statusText,
-  };
-}
-
-type 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 && !value.bodyUsed
-            ? await value.clone().arrayBuffer()
-            : null,
-        ),
-        options: await ctx.parse(createResponseOptions(value)),
-      };
-    },
-    stream(value, ctx) {
-      return {
-        body: ctx.parse(
-          value.body && !value.bodyUsed ? value.clone().body : null,
-        ),
-        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

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

package/web/url.ts

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