seroval-plugins 1.4.0 → 1.5.0

package/web/abort-signal.ts

@@ -1,114 +1,65 @@
 import type { SerovalNode } from 'seroval';
 import { createPlugin } from 'seroval';
 
+const PROMISE_TO_ABORT_SIGNAL = (promise: Promise<unknown>) => {
+  const controller = new AbortController();
+  const abort = controller.abort.bind(controller);
+  promise.then(abort, abort);
+  return controller;
+};
+
 function resolveAbortSignalResult(
   this: AbortSignal,
-  resolve: (value: any) => void,
+  resolve: (value: unknown) => void,
 ): void {
   resolve(this.reason);
 }
 
 function resolveAbortSignal(
   this: AbortSignal,
-  resolve: (value: any) => void,
+  resolve: (value: unknown) => void,
 ): void {
   this.addEventListener('abort', resolveAbortSignalResult.bind(this, resolve), {
     once: true,
   });
 }
 
-export function abortSignalToPromise(signal: AbortSignal): Promise<any> {
+function abortSignalToPromise(signal: AbortSignal): Promise<unknown> {
   return new Promise(resolveAbortSignal.bind(signal));
 }
 
-class AbortSignalController {
-  controller = new AbortController();
-}
+const ABORT_CONTROLLER = {};
 
-const AbortSignalControllerPlugin = createPlugin<
-  AbortSignalController,
-  undefined
->({
-  tag: 'seroval-plugins/web/AbortSignalController',
+const AbortControllerFactoryPlugin = /* @__PURE__ */ createPlugin<object, {}>({
+  tag: 'seroval-plugins/web/AbortControllerFactoryPlugin',
   test(value) {
-    // We didn't actually use the AbortController class
-    // directly because of some assumptions
-    return value instanceof AbortSignalController;
+    return value === ABORT_CONTROLLER;
   },
   parse: {
+    sync() {
+      return ABORT_CONTROLLER;
+    },
+    async async() {
+      return await Promise.resolve(ABORT_CONTROLLER);
+    },
     stream() {
-      return undefined;
+      return ABORT_CONTROLLER;
     },
   },
-  serialize(_node) {
-    return 'new AbortController';
+  serialize() {
+    return PROMISE_TO_ABORT_SIGNAL.toString();
   },
-  deserialize(_node) {
-    return new AbortSignalController();
+  deserialize() {
+    return PROMISE_TO_ABORT_SIGNAL;
   },
 });
 
-interface AbortSignalAbortNode {
-  controller: SerovalNode;
-  reason: SerovalNode;
-}
-
-class AbortSignalAbort {
-  constructor(
-    public controller: AbortSignalController,
-    public reason: unknown,
-  ) {}
-}
-
-const AbortSignalAbortPlugin = createPlugin<
-  AbortSignalAbort,
-  AbortSignalAbortNode
+const AbortSignalPlugin = /* @__PURE__ */ createPlugin<
+  AbortSignal,
+  { reason?: SerovalNode; controller?: SerovalNode; factory?: SerovalNode }
 >({
-  extends: [AbortSignalControllerPlugin],
-  tag: 'seroval-plugins/web/AbortSignalAbort',
-  test(value) {
-    return value instanceof AbortSignalAbort;
-  },
-  parse: {
-    stream(value, ctx) {
-      return {
-        controller: ctx.parse(value.controller),
-        reason: ctx.parse(value.reason),
-      };
-    },
-  },
-  serialize(node, ctx) {
-    return (
-      ctx.serialize(node.controller) +
-      '.abort(' +
-      ctx.serialize(node.reason) +
-      ')'
-    );
-  },
-  deserialize(node, ctx) {
-    const controller = ctx.deserialize(
-      node.controller,
-    ) as AbortSignalController;
-    const reason = ctx.deserialize(node.reason);
-    controller.controller.abort(reason);
-    return new AbortSignalAbort(controller, reason);
-  },
-});
-
-const enum AbortSignalState {
-  Pending = 0,
-  Aborted = 1,
-  Streaming = 2,
-}
-
-type AbortSignalNode =
-  | { type: AbortSignalState.Pending }
-  | { type: AbortSignalState.Aborted; reason: SerovalNode }
-  | { type: AbortSignalState.Streaming; controller: SerovalNode };
-
-const AbortSignalPlugin = createPlugin<AbortSignal, AbortSignalNode>({
   tag: 'seroval-plugins/web/AbortSignal',
-  extends: [AbortSignalAbortPlugin],
+  extends: [AbortControllerFactoryPlugin],
   test(value) {
     if (typeof AbortSignal === 'undefined') {
       return false;
@@ -119,78 +70,61 @@ const AbortSignalPlugin = createPlugin<AbortSignal, AbortSignalNode>({
     sync(value, ctx) {
       if (value.aborted) {
         return {
-          type: AbortSignalState.Aborted,
           reason: ctx.parse(value.reason),
         };
       }
-      return {
-        type: AbortSignalState.Pending,
-      };
+      return {};
     },
     async async(value, ctx) {
       if (value.aborted) {
         return {
-          type: AbortSignalState.Aborted,
           reason: await ctx.parse(value.reason),
         };
       }
       const result = await abortSignalToPromise(value);
       return {
-        type: AbortSignalState.Aborted,
         reason: await ctx.parse(result),
       };
     },
     stream(value, ctx) {
       if (value.aborted) {
         return {
-          type: AbortSignalState.Aborted,
           reason: ctx.parse(value.reason),
         };
       }
-      const controller = new AbortSignalController();
 
-      ctx.pushPendingState();
-      value.addEventListener(
-        'abort',
-        () => {
-          const result = ctx.parseWithError(
-            new AbortSignalAbort(controller, value.reason),
-          );
-          if (result) {
-            ctx.onParse(result);
-          }
-          ctx.popPendingState();
-        },
-        { once: true },
-      );
+      const promise = abortSignalToPromise(value);
 
       return {
-        type: AbortSignalState.Streaming,
-        controller: ctx.parse(controller),
+        factory: ctx.parse(ABORT_CONTROLLER),
+        controller: ctx.parse(promise),
       };
     },
   },
   serialize(node, ctx) {
-    if (node.type === AbortSignalState.Pending) {
-      return '(new AbortController).signal';
-    }
-    if (node.type === AbortSignalState.Aborted) {
+    if (node.reason) {
       return 'AbortSignal.abort(' + ctx.serialize(node.reason) + ')';
     }
-    return '(' + ctx.serialize(node.controller) + ').signal';
+    if (node.controller && node.factory) {
+      return (
+        '(' +
+        ctx.serialize(node.factory) +
+        ')(' +
+        ctx.serialize(node.controller) +
+        ').signal'
+      );
+    }
+    return '(new AbortController).signal';
   },
   deserialize(node, ctx) {
-    if (node.type === AbortSignalState.Pending) {
-      const controller = new AbortController();
-      return controller.signal;
-    }
-    if (node.type === AbortSignalState.Aborted) {
+    if (node.reason) {
       return AbortSignal.abort(ctx.deserialize(node.reason));
     }
-    const controller = ctx.deserialize(
-      node.controller,
-    ) as AbortSignalController;
-    return controller.controller.signal;
+    if (node.controller) {
+      return PROMISE_TO_ABORT_SIGNAL(ctx.deserialize(node.controller)).signal;
+    }
+    const controller = new AbortController();
+    return controller.signal;
   },
 });
 

package/web/blob.ts

@@ -1,10 +1,10 @@
 import type { SerovalNode } from 'seroval';
 import { createPlugin } from 'seroval';
 
-interface BlobNode {
+type BlobNode = {
   type: SerovalNode;
   buffer: SerovalNode;
-}
+};
 
 const BlobPlugin = /* @__PURE__ */ createPlugin<Blob, BlobNode>({
   tag: 'seroval-plugins/web/Blob',

package/web/custom-event.ts

@@ -10,10 +10,10 @@ function createCustomEventOptions(current: CustomEvent): CustomEventInit {
   };
 }
 
-interface CustomEventNode {
+type CustomEventNode = {
   type: SerovalNode;
   options: SerovalNode;
-}
+};
 
 const CustomEventPlugin = /* @__PURE__ */ createPlugin<
   CustomEvent,

package/web/dom-exception.ts

@@ -1,10 +1,10 @@
 import type { SerovalNode } from 'seroval';
 import { createPlugin } from 'seroval';
 
-interface DOMExceptionNode {
+type DOMExceptionNode = {
   name: SerovalNode;
   message: SerovalNode;
-}
+};
 
 const DOMExceptionPlugin = /* @__PURE__ */ createPlugin<
   DOMException,

package/web/event.ts

@@ -9,10 +9,10 @@ function createEventOptions(current: Event): EventInit {
   };
 }
 
-interface EventNode {
+type EventNode = {
   type: SerovalNode;
   options: SerovalNode;
-}
+};
 
 const EventPlugin = /* @__PURE__ */ createPlugin<Event, EventNode>({
   tag: 'seroval-plugins/web/Event',

package/web/file.ts

@@ -1,11 +1,11 @@
 import type { SerovalNode } from 'seroval';
 import { createPlugin } from 'seroval';
 
-interface FileNode {
+type FileNode = {
   name: SerovalNode;
   options: SerovalNode;
   buffer: SerovalNode;
-}
+};
 
 const FilePlugin = /* @__PURE__ */ createPlugin<File, FileNode>({
   tag: 'seroval-plugins/web/File',

package/web/form-data.ts

@@ -28,20 +28,20 @@ const FORM_DATA_FACTORY_CONSTRUCTOR = (
   return f;
 };
 
-const FormDataFactoryPlugin = /* @__PURE__ */ createPlugin<object, undefined>({
+const FormDataFactoryPlugin = /* @__PURE__ */ createPlugin<object, {}>({
   tag: 'seroval-plugins/web/FormDataFactory',
   test(value) {
     return value === FORM_DATA_FACTORY;
   },
   parse: {
     sync() {
-      return undefined;
+      return FORM_DATA_FACTORY;
     },
     async async() {
-      return await Promise.resolve(undefined);
+      return await Promise.resolve(FORM_DATA_FACTORY);
     },
     stream() {
-      return undefined;
+      return FORM_DATA_FACTORY;
     },
   },
   serialize() {
@@ -52,10 +52,10 @@ const FormDataFactoryPlugin = /* @__PURE__ */ createPlugin<object, undefined>({
   },
 });
 
-interface FormDataNode {
+type FormDataNode = {
   factory: SerovalNode;
   entries: SerovalNode;
-}
+};
 
 const FormDataPlugin = /* @__PURE__ */ createPlugin<FormData, FormDataNode>({
   tag: 'seroval-plugins/web/FormData',

package/web/headers.ts

@@ -10,7 +10,10 @@ function convertHeaders(instance: Headers): HeadersInit {
   return items;
 }
 
-const HeadersPlugin = /* @__PURE__ */ createPlugin<Headers, SerovalNode>({
+const HeadersPlugin = /* @__PURE__ */ createPlugin<
+  Headers,
+  { value: SerovalNode }
+>({
   tag: 'seroval-plugins/web/Headers',
   test(value) {
     if (typeof Headers === 'undefined') {
@@ -20,20 +23,26 @@ const HeadersPlugin = /* @__PURE__ */ createPlugin<Headers, SerovalNode>({
   },
   parse: {
     sync(value, ctx) {
-      return ctx.parse(convertHeaders(value));
+      return {
+        value: ctx.parse(convertHeaders(value)),
+      };
     },
     async async(value, ctx) {
-      return await ctx.parse(convertHeaders(value));
+      return {
+        value: await ctx.parse(convertHeaders(value)),
+      };
     },
     stream(value, ctx) {
-      return ctx.parse(convertHeaders(value));
+      return {
+        value: ctx.parse(convertHeaders(value)),
+      };
     },
   },
   serialize(node, ctx) {
-    return 'new Headers(' + ctx.serialize(node) + ')';
+    return 'new Headers(' + ctx.serialize(node.value) + ')';
   },
   deserialize(node, ctx) {
-    return new Headers(ctx.deserialize(node) as HeadersInit);
+    return new Headers(ctx.deserialize(node.value) as HeadersInit);
   },
 });
 

package/web/image-data.ts

@@ -1,12 +1,12 @@
 import type { SerovalNode } from 'seroval';
 import { createPlugin } from 'seroval';
 
-interface ImageDataNode {
+type ImageDataNode = {
   data: SerovalNode;
   width: SerovalNode;
   height: SerovalNode;
   options: SerovalNode;
-}
+};
 
 const ImageDataPlugin = /* @__PURE__ */ createPlugin<ImageData, ImageDataNode>({
   tag: 'seroval-plugins/web/ImageData',

package/web/readable-stream.ts

@@ -3,33 +3,34 @@ 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 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,
-  undefined
+  {}
 >({
   tag: 'seroval-plugins/web/ReadableStreamFactory',
   test(value) {
@@ -37,13 +38,13 @@ const ReadableStreamFactoryPlugin = /* @__PURE__ */ createPlugin<
   },
   parse: {
     sync() {
-      return undefined;
+      return READABLE_STREAM_FACTORY;
     },
     async async() {
-      return await Promise.resolve(undefined);
+      return await Promise.resolve(READABLE_STREAM_FACTORY);
     },
     stream() {
-      return undefined;
+      return READABLE_STREAM_FACTORY;
     },
   },
   serialize() {
@@ -80,10 +81,10 @@ function toStream<T>(value: ReadableStream<T>): Stream<T | undefined> {
   return stream;
 }
 
-interface ReadableStreamNode {
+type ReadableStreamNode = {
   factory: SerovalNode;
   stream: SerovalNode;
-}
+};
 
 const ReadableStreamPlugin = /* @__PURE__ */ createPlugin<
   ReadableStream,

package/web/request.ts

@@ -1,7 +1,7 @@
 import type { SerovalNode } from 'seroval';
 import { createPlugin } from 'seroval';
-import ReadableStreamPlugin from './readable-stream';
 import HeadersPlugin from './headers';
+import ReadableStreamPlugin from './readable-stream';
 
 function createRequestOptions(
   current: Request,
@@ -22,10 +22,10 @@ function createRequestOptions(
   };
 }
 
-interface RequestNode {
+type RequestNode = {
   url: SerovalNode;
   options: SerovalNode;
-}
+};
 
 const RequestPlugin = /* @__PURE__ */ createPlugin<Request, RequestNode>({
   tag: 'seroval-plugins/web/Request',

package/web/response.ts

@@ -1,7 +1,7 @@
 import type { SerovalNode } from 'seroval';
 import { createPlugin } from 'seroval';
-import ReadableStreamPlugin from './readable-stream';
 import HeadersPlugin from './headers';
+import ReadableStreamPlugin from './readable-stream';
 
 function createResponseOptions(current: Response): ResponseInit {
   return {
@@ -11,10 +11,10 @@ function createResponseOptions(current: Response): ResponseInit {
   };
 }
 
-interface ResponseNode {
+type ResponseNode = {
   body: SerovalNode;
   options: SerovalNode;
-}
+};
 
 const ResponsePlugin = /* @__PURE__ */ createPlugin<Response, ResponseNode>({
   tag: 'seroval-plugins/web/Response',

package/web/url-search-params.ts

@@ -3,7 +3,7 @@ import { createPlugin } from 'seroval';
 
 const URLSearchParamsPlugin = /* @__PURE__ */ createPlugin<
   URLSearchParams,
-  SerovalNode
+  { value: SerovalNode }
 >({
   tag: 'seroval-plugins/web/URLSearchParams',
   test(value) {
@@ -14,20 +14,26 @@ const URLSearchParamsPlugin = /* @__PURE__ */ createPlugin<
   },
   parse: {
     sync(value, ctx) {
-      return ctx.parse(value.toString());
+      return {
+        value: ctx.parse(value.toString()),
+      };
     },
     async async(value, ctx) {
-      return await ctx.parse(value.toString());
+      return {
+        value: await ctx.parse(value.toString()),
+      };
     },
     stream(value, ctx) {
-      return ctx.parse(value.toString());
+      return {
+        value: ctx.parse(value.toString()),
+      };
     },
   },
   serialize(node, ctx) {
-    return 'new URLSearchParams(' + ctx.serialize(node) + ')';
+    return 'new URLSearchParams(' + ctx.serialize(node.value) + ')';
   },
   deserialize(node, ctx) {
-    return new URLSearchParams(ctx.deserialize(node) as string);
+    return new URLSearchParams(ctx.deserialize(node.value) as string);
   },
 });
 

package/web/url.ts

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