or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

index.md

tile.json

tessl/npm-jest-serializer

Module for serializing and deserializing JavaScript objects using Node.js v8 APIs with filesystem utilities

Workspace: tessl
Visibility: Public
Created: 4 months ago
Last updated: 4 months ago
Describes: pkg:npm/jest-serializer@28.0.x

To install, run

npx @tessl/cli install tessl/npm-jest-serializer@28.0.0

Jest Serializer

Jest Serializer is a module for serializing and deserializing JavaScript objects using Node.js v8 APIs. It provides both in-memory serialization functions that work with Buffer objects and synchronous filesystem functions for persistent storage. The library leverages v8's native serialization capabilities to handle complex JavaScript types that JSON cannot serialize, including Map, Set, undefined, NaN, and other advanced types.

Note: This package is deprecated. Use Node.js v8 APIs directly: https://nodejs.org/api/v8.html#serialization-api

Package Information

Package Name: jest-serializer
Package Type: npm
Language: TypeScript
Installation: npm install jest-serializer
Version: 28.0.0
License: MIT

Core Imports

import { serialize, deserialize, readFileSync, writeFileSync } from "jest-serializer";

For CommonJS:

const { serialize, deserialize, readFileSync, writeFileSync } = require("jest-serializer");

Default import (object containing all functions):

import serializer from "jest-serializer";

Basic Usage

import { serialize, deserialize, readFileSync, writeFileSync } from "jest-serializer";

// In-memory serialization
const myObject = {
  foo: 'bar',
  baz: [0, true, '2', [], {}],
  special: { map: new Map([[NaN, 4]]), set: new Set([undefined, NaN]) }
};

const buffer = serialize(myObject);
const restored = deserialize(buffer);

// Filesystem serialization
const filePath = '/tmp/my-data';
writeFileSync(filePath, myObject);
const restoredFromFile = readFileSync(filePath);

Capabilities

In-Memory Serialization

Converts JavaScript objects to/from Buffer objects using Node.js v8 serialization APIs.

/**
 * Serializes a JavaScript value to a Buffer using v8.serialize
 * @param content - Any JavaScript value to serialize
 * @returns Buffer containing serialized data
 */
function serialize(content: unknown): Buffer;

/**
 * Deserializes a Buffer back to a JavaScript value using v8.deserialize
 * @param buffer - Buffer containing v8-serialized data
 * @returns Deserialized JavaScript value
 * @throws Error if buffer contains invalid serialization data
 */
function deserialize(buffer: Buffer): unknown;

Usage Examples:

import { serialize, deserialize } from "jest-serializer";

// Serialize complex data structures
const complexData = {
  number: 42,
  string: "hello",
  date: new Date(),
  map: new Map([["key1", "value1"], [NaN, "nan-value"]]),
  set: new Set([1, 2, undefined]),
  buffer: Buffer.from([1, 2, 3])
};

const serialized = serialize(complexData);
console.log(serialized); // <Buffer 1f 2d ...>

const deserialized = deserialize(serialized);
console.log(deserialized); // Original object restored with all types preserved

Filesystem Serialization

Synchronously reads/writes serialized objects to/from the filesystem.

/**
 * Synchronously writes a serialized object to the filesystem
 * @param filePath - Path where to write the serialized file
 * @param content - Any JavaScript value to serialize and write
 * @returns void
 * @throws Error for filesystem errors (permission, path issues, etc.)
 */
function writeFileSync(filePath: string, content: unknown): void;

/**
 * Synchronously reads and deserializes an object from the filesystem
 * @param filePath - Path to the file to read and deserialize
 * @returns Deserialized JavaScript value
 * @throws Error if file doesn't exist, permission errors, or invalid serialized data
 */
function readFileSync(filePath: string): unknown;

Usage Examples:

import { readFileSync, writeFileSync } from "jest-serializer";

// Save application state to disk
const applicationState = {
  user: { id: 123, preferences: new Map([["theme", "dark"]]) },
  cache: new Set(["item1", "item2"]),
  timestamp: new Date()
};

const stateFile = "./app-state.data";
writeFileSync(stateFile, applicationState);

// Restore application state later
const restoredState = readFileSync(stateFile);
console.log(restoredState.user.preferences instanceof Map); // true

Default Export

The package also provides a default export containing all functions as an object.

interface SerializerInterface {
  serialize: (content: unknown) => Buffer;
  deserialize: (buffer: Buffer) => unknown;
  writeFileSync: (filePath: string, content: unknown) => void;
  readFileSync: (filePath: string) => unknown;
}

declare const serializer: SerializerInterface;
export default serializer;

Usage Example:

import serializer from "jest-serializer";

const data = { test: "value" };
const buffer = serializer.serialize(data);
const restored = serializer.deserialize(buffer);

serializer.writeFileSync("./data.bin", data);
const fromFile = serializer.readFileSync("./data.bin");

Supported Data Types

Jest Serializer supports all data types that Node.js v8 serialization can handle:

Primitives: number, string, boolean, null, undefined, BigInt
Objects: Plain objects, arrays
Special Values: NaN, Infinity, -Infinity
Built-in Objects: Date, RegExp, Map, Set, Buffer, ArrayBuffer, typed arrays
Complex Structures: Nested objects and arrays with any combination of above types

Error Handling

Functions may throw errors in the following cases:

deserialize(buffer): Throws if the buffer contains invalid v8 serialization data
readFileSync(filePath): Throws for file system errors (file not found, permission denied) or invalid serialization data
writeFileSync(filePath, content): Throws for file system errors (path not writable, disk full, permission denied)

import { deserialize, readFileSync } from "jest-serializer";

try {
  const invalidBuffer = Buffer.from([0, 85, 170, 255]);
  deserialize(invalidBuffer); // Throws error
} catch (error) {
  console.error("Invalid serialization data:", error.message);
}

try {
  readFileSync("./nonexistent-file.data"); // Throws error
} catch (error) {
  console.error("File read error:", error.message);
}

Dependencies

graceful-fs: Robust filesystem operations (used internally for file I/O)
@types/node: TypeScript definitions for Node.js APIs