@babel/plugin-proposal-record-and-tuple

// ES modules
import recordTuplePlugin from "@babel/plugin-proposal-record-and-tuple";

// CommonJS
const recordTuplePlugin = require("@babel/plugin-proposal-record-and-tuple");

// For type definitions (TypeScript)
import type { Options } from "@babel/plugin-proposal-record-and-tuple";
import type { types as t, NodePath } from "@babel/core";
import type { declare } from "@babel/helper-plugin-utils";

// Babel configuration (.babelrc.js or babel.config.js)
module.exports = {
  plugins: [
    ["@babel/plugin-proposal-record-and-tuple", {
      syntaxType: "hash",
      importPolyfill: true
    }]
  ]
};

// Input code with Record and Tuple syntax
const record = #{
  name: "Alice",
  age: 30,
  hobbies: #["reading", "gaming"]
};

const tuple = #[1, 2, 3, #{x: 4, y: 5}];

// Transformed output (when importPolyfill: true)
import { Record as _Record, Tuple as _Tuple } from "@bloomberg/record-tuple-polyfill";

const record = _Record({
  name: "Alice", 
  age: 30,
  hobbies: _Tuple("reading", "gaming")
});

const tuple = _Tuple(1, 2, 3, _Record({x: 4, y: 5}));

import { declare } from "@babel/helper-plugin-utils";
import syntaxRecordAndTuple from "@babel/plugin-syntax-record-and-tuple";
import type { Options as SyntaxOptions } from "@babel/plugin-syntax-record-and-tuple";
import { types as t, type NodePath } from "@babel/core";

/**
 * Babel plugin factory function for transforming Record and Tuple syntax
 * @param api - Babel API object with version assertion
 * @param options - Plugin configuration options
 * @returns Babel plugin object with visitor methods
 */
const recordTuplePlugin = declare<State>((api, options: Options) => {
  api.assertVersion(7);
  return {
    name: "proposal-record-and-tuple",
    inherits: syntaxRecordAndTuple,
    visitor: {
      Program(path: NodePath<t.Program>, state: State): void;
      RecordExpression(path: NodePath<t.RecordExpression>, state: State): void;
      TupleExpression(path: NodePath<t.TupleExpression>, state: State): void;
    }
  };
});

export default recordTuplePlugin;

import type { Options as SyntaxOptions } from "@babel/plugin-syntax-record-and-tuple";

interface SyntaxOptions {
  /**
   * Which syntax variant to use for Record and Tuple literals
   * "hash" uses #{} and #[] syntax
   * "bar" uses {||} and [||] syntax (deprecated in Babel 8)
   */
  syntaxType: "hash" | "bar";
}

interface Options extends SyntaxOptions {
  /**
   * Name of the polyfill module to import Record/Tuple from
   * @default "@bloomberg/record-tuple-polyfill"
   */
  polyfillModuleName?: string;

  /**
   * Whether to automatically import polyfill functions
   * @default !!options.polyfillModuleName
   */
  importPolyfill?: boolean;
}

export type { Options, SyntaxOptions };

const person = #{
  name: "John",
  age: 25,
  address: #{
    street: "123 Main St",
    city: "Boston"
  }
};

const person = Record({
  name: "John",
  age: 25, 
  address: Record({
    street: "123 Main St",
    city: "Boston"
  })
});

import { Record as _Record } from "@bloomberg/record-tuple-polyfill";

const person = _Record({
  name: "John",
  age: 25,
  address: _Record({
    street: "123 Main St", 
    city: "Boston"
  })
});

const coordinates = #[10, 20];
const nested = #[1, #[2, 3], 4];
const empty = #[];

const coordinates = Tuple(10, 20);
const nested = Tuple(1, Tuple(2, 3), 4);
const empty = Tuple();

import { Tuple as _Tuple } from "@bloomberg/record-tuple-polyfill";

const coordinates = _Tuple(10, 20);
const nested = _Tuple(1, _Tuple(2, 3), 4);
const empty = _Tuple();

// Records use #{}
const record = #{a: 1, b: 2};

// Tuples use #[]
const tuple = #[1, 2, 3];

// Records use {||}
const record = {| a: 1, b: 2 |};

// Tuples use [||]
const tuple = [| 1, 2, 3 |];

import { types as t, type NodePath } from "@babel/core";

/**
 * Internal state object passed between visitor methods
 */
type State = {
  programPath: NodePath<t.Program>;
};

/**
 * Cache for storing import binding names by cache key
 * Format: "Record:true" or "Tuple:false" (name:isModule)
 */
type Cache = Map<string, string>;

/**
 * WeakMap for caching imports per program AST node
 * Ensures single imports per file and avoids duplicates
 */
type ImportCache = WeakMap<t.Program, Cache>;

// babel.config.js
module.exports = {
  plugins: [
    ["@babel/plugin-proposal-record-and-tuple", {
      syntaxType: "hash"
    }]
  ]
};

// babel.config.js  
module.exports = {
  plugins: [
    ["@babel/plugin-proposal-record-and-tuple", {
      syntaxType: "hash",
      polyfillModuleName: "my-custom-polyfill",
      importPolyfill: true
    }]
  ]
};

// babel.config.js
module.exports = {
  plugins: [
    ["@babel/plugin-proposal-record-and-tuple", {
      syntaxType: "hash",
      importPolyfill: false
    }]
  ]
};

// This will throw an error in Babel 8
{
  plugins: [
    ["@babel/plugin-proposal-record-and-tuple", {
      syntaxType: "hash" // ❌ Error in Babel 8
    }]
  ]
}

// Correct usage in Babel 8
{
  plugins: [
    "@babel/plugin-proposal-record-and-tuple" // ✅ No options needed
  ]
}

// Internal error when Program node cannot be found
if (!programPath) {
  throw new Error("Internal error: unable to find the Program node.");
}