v1.1.0

This feature adds a very basic OpaqueReference class. The purpose of this class is to wrap user-specified values into "opaque references": references that are hidden from the serializer. An OpaqueReference contains two values: the original value it is trying to hide, and an optional replacement value, which is what the serializer "sees".

A replacement value can only be a value that seroval can serialize. By default, a replacement value is undefined.

Example:

import { serialize, deserialize, OpaqueReference } from 'seroval';

const example = {
  transparent: "This is a transparent value.",
  opaque: new OpaqueReference('This is an opaque value.'),
};

// You can still access the original value:
console.log(example.opaque.value);

// but now it's different
const deserialized = deserialize(serialize(example));
console.log(deserialized.opaque); // undefined

v1.0.0

What's Changed

• Introduce createStream a403955
  • This function provides a universal streaming primitive that users can use. ReadableStream isn't a JS standard and so there was no counterpart to Promise when it comes to streaming data, so I had to introduce a minimal streaming primitive that is both portable and serializable.
• Create seroval-plugins 22dcc59
  • This package is dedicated for authoring plugins.
  • Given that createStream has been introduced, seroval is no longer dependent from the ReadableStream API, which makes seroval no longer tied to the Web API too.
• Move the following Web API support to seroval-plugins/web
  • Blob
  • CustomEvent
  • DOMException
  • Event
  • File
  • FormData
  • Headers
  • ReadableStream
  • Request
  • Response
  • URLSearchParams
  • URL
• Deprecate some feature flags. The following features can no longer be disabled:
  • Set
  • Map
  • Promise
  • BigInt
  • TypedArray
  • Symbol
  • WebAPI
• Plugin parsing is now on a higher priority, which would allow users to customize serialization for things like plain objects.
• Promise and AsyncIterable is now supported in sync mode, but will only generate a non-resolving instance.
• Add extends option to Plugins API. This allows the plugins to require other plugins in case the feature is required (e.g. Request relies on both Headers and ReadableStream)

Fixes

• Fix RegExp serialization
• Fix string deserialization
• Fix plugin tag deserialization check
• Fix treeshaking for top-level variables

Full Changelog: v0.15.1...v1.0.0

0.13.0

• Add the following APIs:
  • toCrossJSON
  • toCrossJSONAsync
  • toCrossJSONStream
  • fromCrossJSON
• Add support for ReadableStream in async modes
• Add support for AsyncIterable in async and streaming modes
• Add Symbol.toStringTag and Symbol.isConcatSpreadable in serialized properties
• Deprecate MethodShorthand and ArrayPrototypeValues in Feature
• Rework Iterable serialization output
• Dedupe hidden references
• Fix Plugin API-related behavior
• Remove Plugin API's isIterable

v0.12.0

• Add the Plugin API
  • This feature allows custom serialization/deserialization API in seroval. The feature required massive restructuring in the core, such as moving the whole parser, serializer and deserializer code from functions to class-based, which will allow deduping and a lot more. It's required so that the underlying methods can be exposed for the plugin methods.
  • This resolves #17
  • This resolves #14
  • Example:

  import {
    createPlugin,
    serialize,
    type SerovalNode,
  } from 'seroval';
  
  const BufferPlugin = createPlugin<Buffer, SerovalNode>({
    tag: 'Buffer',
    test(value) {
      return value instanceof Buffer;
    },
    parse: {
      sync(value, ctx) {
        return ctx.parse(value.toString('base64'));
      },
      async async(value, ctx) {
        return ctx.parse(value.toString('base64'));
      },
      stream(value, ctx) {
        return ctx.parse(value.toString('base64'));
      },
    },
    serialize(node, ctx) {
      return `Buffer.from(${ctx.serialize(node)}, "base64")`;
    },
    deserialize(node, ctx) {
      return Buffer.from(ctx.deserialize(node) as string, 'base64');
    },
    isIterable() {
      return true;
    },
  });
  
  const serializedJS = serialize(
    Buffer.from('Hello World', 'utf-8'),
    {
      plugins: [BufferPlugin],
    },
  );

• Fixes #27
• Fixes #28

v0.11.0

• Add Request support
• Add Response support
• Add Event support
• Add CustomEvent support
• Add DOMException support
• Fix runtime feature flag check during parsing process
  • This way, the feature flag not only applies to the target runtime of the compiled output, but also for the parsing runtime.
  • This change affects the following behavior:
    • Map and Set now falls back to Symbol.iterator if disabled.
    • ArrayBuffer and DataView to require Feature.TypedArray (due to how both requires Uint8Array)
    • Indirectly, classes like Blob and File is now indirectly affected by the Feature.TypedArray

v0.10.0

• Add the cross-referencing serializer mode
  • This mode allows multiple calls of serialization to share the same reference maps, a behavior that's not present in current existing modes. This introduces crossSerialize and crossSerializeAsync. JSON variants will be introduced in the future.
• Add the streaming serializer mode (#5)
  • With the addition of the cross-referencing serializer, it's now possible for seroval to stream serialized data but with a new API. This release introduces the crossSerializeStream and the Serializer class, both provides two kinds of streaming format (the former being a one-time read-only stream, while the latter allowing push data).
• Fix Promise serialization to consider rejected instances.
  • Previously seroval throws on rejected Promises, which shouldn't be the case and is most likely a bad design, given that seroval can also serialize Error instances.
• Add ReadableStream support.
  • Currently only available in crossSerializeStream and Serializer class.
• Restructure docs
  • Since there are two READMEs in the repo, it's a bit of redundant work to maintain one of it (and paste it to the other) so I've decided to separate the docs. Docs are still a WIP but most of it is still usable.

Full Changelog: v0.9.0...v0.10.0

v0.9.0

• Adds support for serializing object state (e.g. Object.freeze, Object.seal and Object.preventExtensions)
• Fix object assign compat

v0.8.0

• Resolves #16
  • Iterable is no longer a separate kind of node, it's now a subset of either Object or NullConstructor (depending on constructor).
  • Feature.Symbol no longer disables the use of Symbol.iterator in Iterable. Iterable protocol is now skipped.
• Replace Undefined, Null, Boolean, NaN, NegativeZero, Infinity and NegativeInfinity with the Constant Node.
• Fix deserialization step for objects with zero properties returning a different reference.
• Drop support for PromiseLike (aka Thenables) due to the potential DoS
• Add support for boxed primitives
• Fix parsing errors to be descriptive
• optimize serialization

What's Changed

• fix "logical OR" when mean "bitwise OR" by @samualtnorman in #20
• 0.8.0 by @lxsmnsyc in #18

New Contributors

• @samualtnorman made their first contribution in #20

Full Changelog: v0.7.0...v0.8.0

v0.7.0

• Add support for ArrayBuffer cdd0ed8
• Fix serialization for Typed Arrays
  • Since ArrayBuffer support has been added, this change includes deduping TypedArray.prototype.buffer references, applying proper byte offset and length, as well as changes to encoding format (which is now delegated to the ArrayBuffer source)
• Fix deserialization for Typed Arrays encoded in JSON format
  • Since typed arrays cannot resize, there has been issues where typed arrays remained empty.
• Add support for DataView 28fd1ac
• Add support for Blob ec017d7
• Fix serialization issues of types with serialized properties
• Add support for File d598849
• Add support for Headers 3ee4191
• Add support for FormData a466500

Full Changelog: v0.6.0...v0.7.0

v0.6.0

• Add support for URL
• Add support for URLSearchParams
• Add WebAPI feature flag
• Add support for serializable references