estree-util-value-to-estree

What is estree-util-value-to-estree?

The estree-util-value-to-estree package is a utility that converts JavaScript values to ESTree nodes. ESTree is a standardized format for representing JavaScript code as an abstract syntax tree (AST). This package is useful for generating or manipulating JavaScript code programmatically.

What are estree-util-value-to-estree's main functionalities?

Convert Primitive Values to ESTree Nodes

This feature allows you to convert primitive values like numbers, strings, and booleans into their corresponding ESTree nodes. In this example, the number 42 is converted into an ESTree node.

const { valueToEstree } = require('estree-util-value-to-estree');
const estreeNode = valueToEstree(42);
console.log(estreeNode);

Convert Arrays to ESTree Nodes

This feature allows you to convert arrays into ESTree nodes. In this example, the array [1, 2, 3] is converted into an ESTree node.

const { valueToEstree } = require('estree-util-value-to-estree');
const estreeNode = valueToEstree([1, 2, 3]);
console.log(estreeNode);

Convert Objects to ESTree Nodes

This feature allows you to convert objects into ESTree nodes. In this example, the object { key: 'value' } is converted into an ESTree node.

const { valueToEstree } = require('estree-util-value-to-estree');
const estreeNode = valueToEstree({ key: 'value' });
console.log(estreeNode);

Other packages similar to estree-util-value-to-estree

babel-types

babel-types is a utility library for AST nodes used by Babel. It provides methods to build, validate, and traverse AST nodes. Compared to estree-util-value-to-estree, babel-types offers a broader range of functionalities for AST manipulation but is more complex to use for simple value-to-node conversions.

esprima

esprima is a high-performance, standard-compliant ECMAScript parser that produces ASTs. While it focuses on parsing JavaScript code into ASTs, it does not provide direct utilities for converting values to ESTree nodes like estree-util-value-to-estree.

acorn

acorn is a small, fast, JavaScript-based JavaScript parser that produces ESTree-compliant ASTs. Similar to esprima, acorn focuses on parsing JavaScript code rather than converting values to ESTree nodes.

README

estree-util-value-to-estree

Convert a JavaScript value to an estree expression

Installation

npm install estree-util-value-to-estree

Usage

This package converts a JavaScript value to an estree for values that can be constructed without the need for a context.

Currently the following types are supported:

• arrays
• bigints
• booleans
• dates
• maps
• null
• numbers (including Infinity, NaN, and negative numbers)
• objects (plain objects only)
• regular expressions
• sets
• strings
• symbols (only global symbols)
• typed arrays (BigInt64Array, BigUint64Array, Float32Array, Float64Array, Int8Array, Int16Array, Int32Array, Uint8Array, Uint8ClampedArray, Uint16Array, andUint32Array)
• undefined
• URL objects
• URLSearchParams objects

if options.instanceAsObject is set to true, other objects are turned into plain object.

import { deepEqual, throws } from 'assert';

import { valueToEstree } from 'estree-util-value-to-estree';

const result = valueToEstree({
  null: null,
  undefined,
  string: 'Hello world!',
  number: 42,
  negativeNumber: -1337,
  infinity: Number.POSITIVE_INFINITY,
  notANumber: Number.NaN,
  regex: /\w+/i,
  date: new Date('1970-01-01'),
  array: ['I’m an array item!'],
  object: { nested: 'value' },
});

deepEqual(result, {
  type: 'ObjectExpression',
  properties: [
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'null', raw: '"null"' },
      value: { type: 'Literal', value: null, raw: 'null' },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'undefined', raw: '"undefined"' },
      value: { type: 'Identifier', name: 'undefined' },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'string', raw: '"string"' },
      value: { type: 'Literal', value: 'Hello world!', raw: '"Hello world!"' },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'number', raw: '"number"' },
      value: { type: 'Literal', value: 42, raw: '42' },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: {
        type: 'Literal',
        value: 'negativeNumber',
        raw: '"negativeNumber"',
      },
      value: {
        type: 'UnaryExpression',
        operator: '-',
        prefix: true,
        argument: { type: 'Literal', value: 1337, raw: '1337' },
      },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'infinity', raw: '"infinity"' },
      value: { type: 'Identifier', name: 'Infinity' },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'notANumber', raw: '"notANumber"' },
      value: { type: 'Identifier', name: 'NaN' },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'regex', raw: '"regex"' },
      value: {
        type: 'Literal',
        value: /\w+/i,
        raw: '/\\w+/i',
        regex: { pattern: '\\w+', flags: 'i' },
      },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'date', raw: '"date"' },
      value: {
        type: 'NewExpression',
        callee: { type: 'Identifier', name: 'Date' },
        arguments: [{ type: 'Literal', value: 0, raw: '0' }],
      },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'array', raw: '"array"' },
      value: {
        type: 'ArrayExpression',
        elements: [
          {
            type: 'Literal',
            value: 'I’m an array item!',
            raw: '"I’m an array item!"',
          },
        ],
      },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'object', raw: '"object"' },
      value: {
        type: 'ObjectExpression',
        properties: [
          {
            type: 'Property',
            method: false,
            shorthand: false,
            computed: false,
            kind: 'init',
            key: { type: 'Literal', value: 'nested', raw: '"nested"' },
            value: { type: 'Literal', value: 'value', raw: '"value"' },
          },
        ],
      },
    },
  ],
});

class Point {
  line: number;
  column: number;
  constructor(line: number, column: number) {
    this.line = line;
    this.column = column;
  }
}

// Normally complex objects throw.
throws(() => valueToEstree(new Point(2, 3)));

// `instanceAsObject: true` treats them as plain objects.
deepEqual(valueToEstree(new Point(2, 3), { instanceAsObject: true }), {
  type: 'ObjectExpression',
  properties: [
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'line', raw: '"line"' },
      value: { type: 'Literal', value: 2, raw: '2' },
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'column', raw: '"column"' },
      value: { type: 'Literal', value: 3, raw: '3' },
    },
  ],
});

API

This API exports the function valueToEstree.

valueToEstree(value, options?)

Convert a value to an ESTree node.

options

• instanceAsObject (boolean, default: false) — If true, treat objects that have a prototype as plain objects.