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.

Table of Contents

• Installation
• Usage
• API
  • valueToEstree(value, options?)
• Compatibility
• License

Installation

npm install estree-util-value-to-estree

Usage

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

Currently the following types are supported:

• bigint
• boolean
• null
• number (Including Infinity and NaN)
• string
• symbol (shared and well-known)
• object
• null-prototype Object
• undefined
• Array
• BigInt64Array
• BigUint64Array
• Boolean
• Buffer
• Date
• Float32Array
• Float64Array
• Int16Array
• Int32Array
• Int8Array
• Map
• Number
• RegExp
• Set
• String
• Uint16Array
• Uint32Array
• Uint8Array
• Uint8ClampedArray
• URL
• URLSearchParams

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

import assert from 'node:assert/strict'

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' }
})

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

class Point {
  line: number

  column: number

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

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

// `instanceAsObject: true` treats them as plain objects.
assert.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' },
      value: { type: 'Literal', value: 2 }
    },
    {
      type: 'Property',
      method: false,
      shorthand: false,
      computed: false,
      kind: 'init',
      key: { type: 'Literal', value: 'column' },
      value: { type: 'Literal', value: 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.
• preserveReferences (boolean, default: false) — If true, preserve references to the same object found within the input. This also allows to serialize recursive structures. If needed, the resulting expression will be an iife.

Compatibility

This project is compatible with Node.js 16 or greater.

License

MIT © Remco Haszing