@babel/plugin-proposal-optional-chaining

// babel.config.js
module.exports = {
  plugins: ["@babel/plugin-proposal-optional-chaining"]
};

import optionalChainingPlugin from "@babel/plugin-proposal-optional-chaining";

const optionalChainingPlugin = require("@babel/plugin-proposal-optional-chaining");

// babel.config.js
module.exports = {
  plugins: [
    ["@babel/plugin-proposal-optional-chaining", { loose: false }]
  ]
};

// Optional member access
const name = obj?.user?.name;
const value = obj?.['property-name'];

// Optional method calls
const result = obj?.method?.();
const data = api?.getData?.();

// Chained optional access
const nested = obj?.prop?.method?.()?.result;

// Delete operations
delete obj?.property;

// Strict mode output
var _obj, _obj$user;
const name = (_obj = obj) === null || _obj === void 0 ? void 0 : (_obj$user = _obj.user) === null || _obj$user === void 0 ? void 0 : _obj$user.name;
var _obj2;
const value = (_obj2 = obj) === null || _obj2 === void 0 ? void 0 : _obj2['property-name'];

var _obj3, _obj3$method;
const result = (_obj3 = obj) === null || _obj3 === void 0 ? void 0 : (_obj3$method = _obj3.method) === null || _obj3$method === void 0 ? void 0 : _obj3$method.call(_obj3);
var _api, _api$getData;
const data = (_api = api) === null || _api === void 0 ? void 0 : (_api$getData = _api.getData) === null || _api$getData === void 0 ? void 0 : _api$getData.call(_api);

/**
 * Creates a Babel plugin for transforming optional chaining syntax using declare helper
 * @param api - Babel plugin API object with version checking and assumptions
 * @param options - Plugin configuration options
 * @returns Babel plugin configuration object
 */
export default declare(
  (api: PluginAPI, options: Options) => PluginObject
);

interface Options {
  /** Enable loose transformation mode for smaller output (default: false) */
  loose?: boolean;
}

interface PluginObject {
  name: "proposal-optional-chaining";
  inherits: typeof syntaxOptionalChaining.default;
  visitor: {
    "OptionalCallExpression|OptionalMemberExpression": (
      path: NodePath<OptionalCallExpression | OptionalMemberExpression>
    ) => void;
  };
}

/**
 * Transforms optional chaining AST nodes into conditional expressions
 * @param path - NodePath for the optional chaining expression to transform
 * @param options - Transformation behavior options with pureGetters and noDocumentAll flags
 */
export function transform(
  path: NodePath<OptionalCallExpression | OptionalMemberExpression>,
  { pureGetters, noDocumentAll }: { pureGetters: boolean; noDocumentAll: boolean }
): void;

{
  "plugins": [
    ["@babel/plugin-proposal-optional-chaining", {
      "loose": false  // Use strict null checks (default)
    }]
  ]
}

{
  "plugins": [
    ["@babel/plugin-proposal-optional-chaining", {
      "loose": true  // Use simplified null checks
    }]
  ]
}

// Input: obj?.prop
// Loose output: obj == null ? void 0 : obj.prop
// Strict output: obj === null || obj === void 0 ? void 0 : obj.prop

// babel.config.js
module.exports = {
  assumptions: {
    "pureGetters": true,     // Assume getters have no side effects
    "noDocumentAll": true    // Use simplified null checks
  },
  plugins: ["@babel/plugin-proposal-optional-chaining"]
};

// Input
obj?.method?.();

// Output (strict mode)
var _obj, _obj$method;
(_obj = obj) === null || _obj === void 0 ? void 0 : (_obj$method = _obj.method) === null || _obj$method === void 0 ? void 0 : _obj$method.call(_obj);

// Input
getObject()?.property?.method?.();

// Output - memoizes getObject() call
var _getObject, _getObject$property, _getObject$property$m;
(_getObject = getObject()) === null || _getObject === void 0 ? void 0 : (_getObject$property = _getObject.property) === null || _getObject$property === void 0 ? void 0 : (_getObject$property$m = _getObject$property.method) === null || _getObject$property$m === void 0 ? void 0 : _getObject$property$m.call(_getObject$property);

// Input: obj?.prop?.method?.()
// With pureGetters: simpler output avoiding Function.call when possible
// Without pureGetters: always uses Function.call for method context

// Input: obj?.prop
// With noDocumentAll: obj != null ? obj.prop : void 0
// Without noDocumentAll: obj !== null && obj !== void 0 ? obj.prop : void 0

// Core types from @babel/helper-plugin-utils and @babel/core
function declare<State = {}, Option = {}>(
  builder: (
    api: PluginAPI,
    options: Option,
    dirname: string,
  ) => PluginObject<State & PluginPass>
): (api: PluginAPI, options: Option, dirname: string) => PluginObject<State & PluginPass>;

interface PluginAPI {
  assertVersion(version: number | string): void;
  assumption(name: string): boolean | undefined;
  version: string;
  targets(): any;
  env: any;
  caller(): any;
  types: typeof t;
  template: any;
  parse: any;
  transform: any;
  traverse: any;
}

interface PluginObject<State = {}> {
  name?: string;
  inherits?: any;
  visitor?: any;
  pre?: (state: State) => void;
  post?: (state: State) => void;
  manipulateOptions?: any;
}

interface PluginPass {
  key?: string;
  file: any;
  opts: any;
}

interface NodePath<T = any> {
  node: T;
  scope: Scope;
  parentPath: NodePath;
  isOptionalMemberExpression(): boolean;
  isOptionalCallExpression(): boolean;
  isPattern(): boolean;
  get(key: string): NodePath;
  replaceWith(node: any): void;
  findParent(callback: (path: NodePath) => boolean): NodePath | null;
}

// AST Node types
interface OptionalMemberExpression {
  type: "OptionalMemberExpression";
  object: Expression;
  property: Expression;
  computed: boolean;
  optional: boolean;
}

interface OptionalCallExpression {
  type: "OptionalCallExpression";
  callee: Expression;
  arguments: Expression[];
  optional: boolean;
}

interface Expression {
  type: string;
}

interface Scope {
  isStatic(node: any): boolean;
  maybeGenerateMemoised(node: any): any;
  path: NodePath;
}