Edit

[EDIT] FILE: jsx-ast-utils.zip

PK�������Y[>q>8\���\�����hasEveryProp.jsnu�ȯ����������module.exports = require('./lib').hasEveryProp; // eslint-disable-line import/no-unresolved
PK�������Y[}:��W���W���
��hasProp.jsnu�ȯ����������module.exports = require('./lib').hasProp; // eslint-disable-line import/no-unresolved
PK�������Y[��]���]�����eventHandlers.jsnu�ȯ����������module.exports = require('./lib').eventHandlers; // eslint-disable-line import/no-unresolved
PK�������Y[�n����������.babelrcnu�ȯ����������{
  "presets": ["env"],
  "plugins": [
    ["transform-replace-object-assign", { "moduleSpecifier": "object.assign" }],
    "transform-object-rest-spread",
    // "@babel/plugin-proposal-nullish-coalescing-operator", // TODO: update to babel 7
  ],
}
PK�������Y[���\��������src/hasProp.jsnu�ȯ����������import propName from './propName';

const DEFAULT_OPTIONS = {
  spreadStrict: true,
  ignoreCase: true,
};

/**
 * Returns boolean indicating whether an prop exists on the props
 * property of a JSX element node.
 */
export default function hasProp(props = [], prop = '', options = DEFAULT_OPTIONS) {
  const propToCheck = options.ignoreCase ? prop.toUpperCase() : prop;

return props.some((attribute) => {
    // If the props contain a spread prop, then refer to strict param.
    if (attribute.type === 'JSXSpreadAttribute') {
      return !options.spreadStrict;
    }

const currentProp = options.ignoreCase
      ? propName(attribute).toUpperCase()
      : propName(attribute);

return propToCheck === currentProp;
  });
}

/**
 * Given the props on a node and a list of props to check, this returns a boolean
 * indicating if any of them exist on the node.
 */
export function hasAnyProp(nodeProps = [], props = [], options = DEFAULT_OPTIONS) {
  const propsToCheck = typeof props === 'string' ? props.split(' ') : props;

return propsToCheck.some((prop) => hasProp(nodeProps, prop, options));
}

/**
 * Given the props on a node and a list of props to check, this returns a boolean
 * indicating if all of them exist on the node
 */
export function hasEveryProp(nodeProps = [], props = [], options = DEFAULT_OPTIONS) {
  const propsToCheck = typeof props === 'string' ? props.split(' ') : props;

return propsToCheck.every((prop) => hasProp(nodeProps, prop, options));
}
PK�������Y[����������src/eventHandlers.jsnu�ȯ����������/**
 * Common event handlers for JSX element event binding.
 */

const eventHandlersByType = {
  clipboard: [
    'onCopy',
    'onCut',
    'onPaste',
  ],
  composition: [
    'onCompositionEnd',
    'onCompositionStart',
    'onCompositionUpdate',
  ],
  keyboard: [
    'onKeyDown',
    'onKeyPress',
    'onKeyUp',
  ],
  focus: [
    'onFocus',
    'onBlur',
  ],
  form: [
    'onChange',
    'onInput',
    'onSubmit',
  ],
  mouse: [
    'onClick',
    'onContextMenu',
    'onDblClick',
    'onDoubleClick',
    'onDrag',
    'onDragEnd',
    'onDragEnter',
    'onDragExit',
    'onDragLeave',
    'onDragOver',
    'onDragStart',
    'onDrop',
    'onMouseDown',
    'onMouseEnter',
    'onMouseLeave',
    'onMouseMove',
    'onMouseOut',
    'onMouseOver',
    'onMouseUp',
  ],
  selection: [
    'onSelect',
  ],
  touch: [
    'onTouchCancel',
    'onTouchEnd',
    'onTouchMove',
    'onTouchStart',
  ],
  ui: [
    'onScroll',
  ],
  wheel: [
    'onWheel',
  ],
  media: [
    'onAbort',
    'onCanPlay',
    'onCanPlayThrough',
    'onDurationChange',
    'onEmptied',
    'onEncrypted',
    'onEnded',
    'onError',
    'onLoadedData',
    'onLoadedMetadata',
    'onLoadStart',
    'onPause',
    'onPlay',
    'onPlaying',
    'onProgress',
    'onRateChange',
    'onSeeked',
    'onSeeking',
    'onStalled',
    'onSuspend',
    'onTimeUpdate',
    'onVolumeChange',
    'onWaiting',
  ],
  image: [
    'onLoad',
    'onError',
  ],
  animation: [
    'onAnimationStart',
    'onAnimationEnd',
    'onAnimationIteration',
  ],
  transition: [
    'onTransitionEnd',
  ],
};

const eventHandlers = Object.keys(eventHandlersByType).reduce(
  (accumulator, type) => accumulator.concat(eventHandlersByType[type]),
  [],
);

export default eventHandlers;

export { eventHandlersByType };
PK�������Y[G��/��/����src/values/Literal.jsnu�ȯ����������/**
 * Extractor function for a Literal type value node.
 *
 * @param - value - AST Value object with type `Literal`
 * @returns { String|Boolean } - The extracted value converted to correct type.
 */
export default function extractValueFromLiteral(value) {
  const { value: extractedValue } = value;

const normalizedStringValue = typeof extractedValue === 'string' && extractedValue.toLowerCase();
  if (normalizedStringValue === 'true') {
    return true;
  }

if (normalizedStringValue === 'false') {
    return false;
  }

return extractedValue;
}
PK�������Y[j|�X��X��$��src/values/expressions/Identifier.jsnu�ȯ����������const JS_RESERVED = {
  Array,
  Date,
  Infinity,
  Math,
  Number,
  Object,
  String,
  undefined,
};

/**
 * Extractor function for a Identifier type value node.
 * An Identifier is usually a reference to a variable.
 * Just return variable name to determine its existence.
 *
 * @param - value - AST Value object with type `Identifier`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromIdentifier(value) {
  const { name } = value;

if (Object.hasOwnProperty.call(JS_RESERVED, name)) {
    return JS_RESERVED[name];
  }

return name;
}
PK�������Y[�%g�����*��src/values/expressions/UpdateExpression.jsnu�ȯ����������/**
 * Extractor function for an UpdateExpression type value node.
 * An update expression is an expression with an update operator.
 * For example, foo++ will evaluate to foo + 1.
 *
 * @param - value - AST Value object with type `UpdateExpression`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromUpdateExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  const { operator, argument, prefix } = value;

let val = getValue(argument);

switch (operator) {
    case '++':
      return prefix ? ++val : val++; // eslint-disable-line no-plusplus
    case '--':
      return prefix ? --val : val--; // eslint-disable-line no-plusplus
    default:
      return undefined;
  }
}
PK�������Y[��F��F��2��src/values/expressions/TaggedTemplateExpression.jsnu�ȯ����������import extractValueFromTemplateLiteral from './TemplateLiteral';

/**
 * Returns the string value of a tagged template literal object.
 * Redirects the bulk of the work to `TemplateLiteral`.
 */
export default function extractValueFromTaggedTemplateExpression(value) {
  return extractValueFromTemplateLiteral(value.quasi);
}
PK�������Y[�%$,��������(��src/values/expressions/ThisExpression.jsnu�ȯ����������/**
 * Extractor function for a ThisExpression type value node.
 * A this expression is using `this` as an identifier.
 *
 * @returns - 'this' as a string.
 */
export default function extractValueFromThisExpression() {
  return 'this';
}
PK�������Y[K�������,��src/values/expressions/SequenceExpression.jsnu�ȯ����������/**
 * Extractor function for a SequenceExpression type value node.
 * A Sequence expression is an object with an attribute named
 * expressions which contains an array of different types
 *  of expression objects.
 *
 * @returns - An array of the extracted elements.
 */
export default function extractValueFromSequenceExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  return value.expressions.map((element) => getValue(element));
}
PK�������Y[���6��6��2��src/values/expressions/OptionalMemberExpression.jsnu�ȯ����������/**
 * Extractor function for a OptionalMemberExpression type value node.
 * A member expression is accessing a property on an object `obj.property`.
 *
 * @param - value - AST Value object with type `OptionalMemberExpression`
 * @returns - The extracted value converted to correct type
 *  and maintaing `obj?.property` convention.
 */
export default function extractValueFromOptionalMemberExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  return `${getValue(value.object)}?.${getValue(value.property)}`;
}
PK�������Y[�O�K��K��*��src/values/expressions/ObjectExpression.jsnu�ȯ����������import assign from 'object.assign';

/**
 * Extractor function for an ObjectExpression type value node.
 * An object expression is using {}.
 *
 * @returns - a representation of the object
 */
export default function extractValueFromObjectExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  return value.properties.reduce((obj, property) => {
    const object = { ...obj };
    // Support types: SpreadProperty and ExperimentalSpreadProperty
    if (/^(?:Experimental)?Spread(?:Property|Element)$/.test(property.type)) {
      if (property.argument.type === 'ObjectExpression') {
        return assign(object, extractValueFromObjectExpression(property.argument));
      }
    } else {
      object[getValue(property.key)] = getValue(property.value);
    }
    return object;
  }, {});
}
PK�������Y[U�������)��src/values/expressions/ChainExpression.jsnu�ȯ����������/**
 * Extractor function for a ChainExpression type value node.
 * A member expression is accessing a property on an object `obj.property`.
 *
 * @param - value - AST Value object with type `ChainExpression`
 * @returns - The extracted value converted to correct type
 *  and maintaing `obj?.property` convention.
 */
export default function extractValueFromChainExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  return getValue(value.expression || value);
}
PK�������Y[C>�������)��src/values/expressions/TemplateLiteral.jsnu�ȯ����������function sortStarts(a, b) {
  return (a.range ? a.range[0] : a.start) - (b.range ? b.range[0] : b.start);
}

/**
 * Returns the string value of a template literal object.
 * Tries to build it as best as it can based on the passed
 * prop. For instance `This is a ${prop}` will return 'This is a {prop}'.
 *
 * If the template literal builds to undefined (`${undefined}`), then
 * this should return "undefined".
 */
export default function extractValueFromTemplateLiteral(value) {
  const {
    quasis,
    expressions,
  } = value;
  const partitions = quasis.concat(expressions);

return partitions.sort(sortStarts).reduce((raw, part) => {
    const {
      type,
    } = part;
    if (type === 'TemplateElement') {
      return raw + part.value.raw;
    }

if (type === 'Identifier') {
      return part.name === 'undefined' ? `${raw}${part.name}` : `${raw}{${part.name}}`;
    }

if (type.indexOf('Expression') > -1) {
      return `${raw}{${type}}`;
    }

return raw;
  }, '');
}
PK�������Y[I�2�9��9��*��src/values/expressions/MemberExpression.jsnu�ȯ����������/**
 * Extractor function for a MemberExpression type value node.
 * A member expression is accessing a property on an object `obj.property`.
 *
 * @param - value - AST Value object with type `MemberExpression`
 * @returns - The extracted value converted to correct type
 *  and maintaing `obj.property` convention.
 */
export default function extractValueFromMemberExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  return `${getValue(value.object)}${value.optional ? '?.' : '.'}${getValue(value.property)}`;
}
PK�������Y[���������/��src/values/expressions/ConditionalExpression.jsnu�ȯ����������/**
 * Extractor function for a ConditionalExpression type value node.
 *
 * @param - value - AST Value object with type `ConditionalExpression`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromConditionalExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  const {
    test,
    alternate,
    consequent,
  } = value;

return getValue(test) ? getValue(consequent) : getValue(alternate);
}
PK�������Y[�C)����'��src/values/expressions/NewExpression.jsnu�ȯ����������/**
 * Extractor function for a NewExpression type value node.
 * A new expression instantiates an object with `new` keyword.
 *
 * @returns - an empty object.
 */
export default function extractValueFromNewExpression() {
  return new Object(); // eslint-disable-line
}
PK�������Y[(�������,��src/values/expressions/FunctionExpression.jsnu�ȯ����������/**
 * Extractor function for a FunctionExpression type value node.
 * Statically, we can't execute the given function, so just return a function
 * to indicate that the value is present.
 *
 * @param - value - AST Value object with type `FunctionExpression`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromFunctionExpression(value) {
  return () => value;
}
PK�������Y[���g��g��+��src/values/expressions/LogicalExpression.jsnu�ȯ����������/**
 * Extractor function for a LogicalExpression type value node.
 * A logical expression is `a && b` or `a || b`, so we evaluate both sides
 * and return the extracted value of the expression.
 *
 * @param - value - AST Value object with type `LogicalExpression`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromLogicalExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  const { operator, left, right } = value;
  const leftVal = getValue(left);
  const rightVal = getValue(right);

if (operator === '&&') {
    return leftVal && rightVal;
  }
  if (operator === '??') {
    // return leftVal ?? rightVal; // TODO: update to babel 7
    return (leftVal === null || typeof leftVal === 'undefined') ? rightVal : leftVal;
  }
  return leftVal || rightVal;
}
PK�������Y[��G_��_��0��src/values/expressions/OptionalCallExpression.jsnu�ȯ����������/**
 * Extractor function for a OptionalCallExpression type value node.
 * A member expression is accessing a property on an object `obj.property` and invoking it.
 *
 * @param - value - AST Value object with type `OptionalCallExpression`
 * @returns - The extracted value converted to correct type
 *  and maintaing `obj.property?.()` convention.
 */
export default function extractValueFromOptionalCallExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  return `${getValue(value.callee)}?.(${value.arguments.map((x) => getValue(x)).join(', ')})`;
}
PK�������Y[�F�	������)��src/values/expressions/ArrayExpression.jsnu�ȯ����������/**
 * Extractor function for an ArrayExpression type value node.
 * An array expression is an expression with [] syntax.
 *
 * @returns - An array of the extracted elements.
 */
export default function extractValueFromArrayExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  return value.elements.map((element) => {
    if (element === null) return undefined;
    return getValue(element);
  });
}
PK�������Y[�=ix������(��src/values/expressions/BindExpression.jsnu�ȯ����������/**
 * Extractor function for a BindExpression type value node.
 * A bind expression looks like `::this.foo`
 * This will return `this.foo.bind(this)` as the value to indicate its existence,
 * since we can not execute the function this.foo.bind(this) in a static environment.
 *
 * @param - value - AST Value object with type `BindExpression`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromBindExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  const callee = getValue(value.callee);

// If value.object === null, the callee must be a MemberExpression.
  // https://github.com/babel/babylon/blob/master/ast/spec.md#bindexpression
  const object = value.object === null ? getValue(value.callee.object) : getValue(value.object);

if (value.object && value.object.property) {
    return `${object}.${callee}.bind(${object})`;
  }

return `${callee}.bind(${object})`;
}
PK�������Y[^B�������)��src/values/expressions/UnaryExpression.jsnu�ȯ����������/**
 * Extractor function for a UnaryExpression type value node.
 * A unary expression is an expression with a unary operator.
 * For example, !"foobar" will evaluate to false, so this will return false.
 *
 * @param - value - AST Value object with type `UnaryExpression`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromUnaryExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  const { operator, argument } = value;

switch (operator) {
    case '-':
      return -getValue(argument);
    case '+':
      return +getValue(argument); // eslint-disable-line no-implicit-coercion
    case '!':
      return !getValue(argument);
    case '~':
      return ~getValue(argument); // eslint-disable-line no-bitwise
    case 'delete':
      // I believe delete statements evaluate to true.
      return true;
    case 'typeof':
    case 'void':
    default:
      return undefined;
  }
}
PK�������Y[{
������-��src/values/expressions/TSNonNullExpression.jsnu�ȯ����������const extractValueFromThisExpression = require('./ThisExpression').default;

function navigate(obj, prop, value) {
  if (value.computed) {
    return value.optional ? `${obj}?.[${prop}]` : `${obj}[${prop}]`;
  }
  return value.optional ? `${obj}?.${prop}` : `${obj}.${prop}`;
}

/**
 * Extractor function for a TSNonNullExpression type value node.
 * A TSNonNullExpression is accessing a TypeScript Non-Null Assertion
 * Operator !
 *
 * @param - value - AST Value object with type `TSNonNullExpression`
 * @returns - The extracted value converted to correct type
 *  and maintaing `obj.property` convention.
 */
export default function extractValueFromTSNonNullExpression(value) {
  // eslint-disable-next-line global-require
  // const getValue = require('.').default;
  const errorMessage = 'The prop value with an expression type of TSNonNullExpression could not be resolved. Please file an issue ( https://github.com/jsx-eslint/jsx-ast-utils/issues/new ) to get this fixed immediately.';

// it's just the name
  if (value.type === 'Identifier') {
    const { name } = value;
    return name;
  }

if (value.type === 'Literal') {
    return value.value;
  }

if (value.type === 'TSAsExpression') {
    return extractValueFromTSNonNullExpression(value.expression);
  }

if (value.type === 'ThisExpression') {
    return extractValueFromThisExpression();
  }

// does not contains properties & is not parenthesized
  if (value.type === 'TSNonNullExpression' && (!value.extra || value.extra.parenthesized === false)) {
    const { expression } = value;
    return `${extractValueFromTSNonNullExpression(expression)}${'!'}`;
  }

// does not contains properties & is parenthesized
  if (value.type === 'TSNonNullExpression' && value.extra && value.extra.parenthesized === true) {
    const { expression } = value;
    return `${'('}${extractValueFromTSNonNullExpression(expression)}${'!'}${')'}`;
  }

if (value.type === 'MemberExpression') {
    // contains a property & is not parenthesized
    if ((!value.extra || value.extra.parenthesized === false)) {
      return navigate(
        extractValueFromTSNonNullExpression(value.object),
        extractValueFromTSNonNullExpression(value.property),
        value,
      );
    }

// contains a property & is parenthesized
    if (value.extra && value.extra.parenthesized === true) {
      const result = navigate(
        extractValueFromTSNonNullExpression(value.object),
        extractValueFromTSNonNullExpression(value.property),
        value,
      );
      return `(${result})`;
    }
  }

// try to fail silently, if specs for TSNonNullExpression change
  // not throw, only log error. Similar to how it was done previously
  if (value.expression) {
    let { expression } = value;
    while (expression) {
      if (expression.type === 'Identifier') {
        // eslint-disable-next-line no-console
        console.error(errorMessage);
        return expression.name;
      }
      ({ expression } = expression);
    }
  }

// eslint-disable-next-line no-console
  console.error(errorMessage);
  return '';
}
PK�������Y[n��A��A��.��src/values/expressions/AssignmentExpression.jsnu�ȯ����������/**
 * Extractor function for a AssignmentExpression type value node.
 * An assignment expression looks like `x = y` or `x += y` in expression position.
 * This will return the assignment as the value.
 *
 * @param - value - AST Value object with type `AssignmentExpression`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromAssignmentExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  return `${getValue(value.left)} ${value.operator} ${getValue(value.right)}`;
}
PK�������Y[�{�DJ��J��'��src/values/expressions/SpreadElement.jsnu�ȯ����������/**
 * Extractor function for a SpreadElement type value node.
 * We can't statically evaluate an array spread, so just return
 * undefined.
 *
 * @param - value - AST Value object with type `SpreadElement`
 * @returns - An prototypeless object.
 */
export default function extractValueFromSpreadElement() {
  return undefined;
}
PK�������Y[t	&������*��src/values/expressions/BinaryExpression.jsnu�ȯ����������/**
 * Extractor function for a BinaryExpression type value node.
 * A binary expression has a left and right side separated by an operator
 * such as `a + b`.
 *
 * @param - value - AST Value object with type `BinaryExpression`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromBinaryExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  const { operator, left, right } = value;
  const leftVal = getValue(left);
  const rightVal = getValue(right);

switch (operator) {
    case '==':
      return leftVal == rightVal; // eslint-disable-line
    case '!=':
      return leftVal != rightVal; // eslint-disable-line
    case '===':
      return leftVal === rightVal;
    case '!==':
      return leftVal !== rightVal;
    case '<':
      return leftVal < rightVal;
    case '<=':
      return leftVal <= rightVal;
    case '>':
      return leftVal > rightVal;
    case '>=':
      return leftVal >= rightVal;
    case '<<':
      return leftVal << rightVal; // eslint-disable-line no-bitwise
    case '>>':
      return leftVal >> rightVal; // eslint-disable-line no-bitwise
    case '>>>':
      return leftVal >>> rightVal; // eslint-disable-line no-bitwise
    case '+':
      return leftVal + rightVal;
    case '-':
      return leftVal - rightVal;
    case '*':
      return leftVal * rightVal;
    case '/':
      return leftVal / rightVal;
    case '%':
      return leftVal % rightVal;
    case '|':
      return leftVal | rightVal; // eslint-disable-line no-bitwise
    case '^':
      return leftVal ^ rightVal; // eslint-disable-line no-bitwise
    case '&':
      return leftVal & rightVal; // eslint-disable-line no-bitwise
    case 'in':
      try {
        return leftVal in rightVal;
      } catch (err) {
        return false;
      }
    case 'instanceof':
      if (typeof rightVal !== 'function') {
        return false;
      }
      return leftVal instanceof rightVal;
    default:
      return undefined;
  }
}
PK�������Y[~��O����,��src/values/expressions/TypeCastExpression.jsnu�ȯ����������/**
 * Extractor function for a TypeCastExpression type value node.
 * A type cast expression looks like `(this.handleClick: (event: MouseEvent) => void))`
 * This will return the expression `this.handleClick`.
 *
 * @param - value - AST Value object with type `TypeCastExpression`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromTypeCastExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  return getValue(value.expression);
}
PK�������Y[\%d�������(��src/values/expressions/CallExpression.jsnu�ȯ����������/**
 * Extractor function for a CallExpression type value node.
 * A call expression looks like `bar()`
 * This will return `bar` as the value to indicate its existence,
 * since we can not execute the function bar in a static environment.
 *
 * @param - value - AST Value object with type `CallExpression`
 * @returns - The extracted value converted to correct type.
 */
export default function extractValueFromCallExpression(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;
  const args = Array.isArray(value.arguments) ? value.arguments.map((x) => getValue(x)).join(', ') : '';
  return `${getValue(value.callee)}${value.optional ? '?.' : ''}(${args})`;
}
PK�������Y[F��v������src/values/expressions/index.jsnu�ȯ����������import Literal from '../Literal';
import JSXElement from '../JSXElement';
import JSXFragment from '../JSXFragment';
import JSXText from '../JSXText';
import Identifier from './Identifier';
import TaggedTemplateExpression from './TaggedTemplateExpression';
import TemplateLiteral from './TemplateLiteral';
import FunctionExpression from './FunctionExpression';
import LogicalExpression from './LogicalExpression';
import MemberExpression from './MemberExpression';
import ChainExpression from './ChainExpression';
import OptionalCallExpression from './OptionalCallExpression';
import OptionalMemberExpression from './OptionalMemberExpression';
import CallExpression from './CallExpression';
import UnaryExpression from './UnaryExpression';
import ThisExpression from './ThisExpression';
import ConditionalExpression from './ConditionalExpression';
import BinaryExpression from './BinaryExpression';
import ObjectExpression from './ObjectExpression';
import NewExpression from './NewExpression';
import UpdateExpression from './UpdateExpression';
import ArrayExpression from './ArrayExpression';
import BindExpression from './BindExpression';
import SpreadElement from './SpreadElement';
import TypeCastExpression from './TypeCastExpression';
import SequenceExpression from './SequenceExpression';
import TSNonNullExpression from './TSNonNullExpression';
import AssignmentExpression from './AssignmentExpression';

// Composition map of types to their extractor functions.
const TYPES = {
  Identifier,
  Literal,
  JSXElement,
  JSXFragment,
  JSXText,
  TaggedTemplateExpression,
  TemplateLiteral,
  ArrowFunctionExpression: FunctionExpression,
  FunctionExpression,
  LogicalExpression,
  MemberExpression,
  ChainExpression,
  OptionalCallExpression,
  OptionalMemberExpression,
  CallExpression,
  UnaryExpression,
  ThisExpression,
  ConditionalExpression,
  BinaryExpression,
  ObjectExpression,
  NewExpression,
  UpdateExpression,
  ArrayExpression,
  BindExpression,
  SpreadElement,
  TypeCastExpression,
  SequenceExpression,
  TSNonNullExpression,
  AssignmentExpression,
};

const noop = () => null;

const errorMessage = (expression) => `The prop value with an expression type of ${expression} could not be resolved. Please file an issue ( https://github.com/jsx-eslint/jsx-ast-utils/issues/new ) to get this fixed immediately.`;

/**
 * This function maps an AST value node
 * to its correct extractor function for its
 * given type.
 *
 * This will map correctly for *all* possible expression types.
 *
 * @param - value - AST Value object with type `JSXExpressionContainer`
 * @returns The extracted value.
 */
export default function extract(value) {
  // Value will not have the expression property when we recurse.
  // The type for expression on ArrowFunctionExpression is a boolean.
  let expression;
  if (
    typeof value.expression !== 'boolean'
    && value.expression
  ) {
    expression = value.expression; // eslint-disable-line prefer-destructuring
  } else {
    expression = value;
  }
  let { type } = expression;

// Typescript NonNull Expression is wrapped & it would end up in the wrong extractor
  if (expression.object && expression.object.type === 'TSNonNullExpression') {
    type = 'TSNonNullExpression';
  }

while (type === 'TSAsExpression') {
    ({ type } = expression);
    if (expression.expression) {
      ({ expression } = expression);
    }
  }

if (TYPES[type] === undefined) {
    // eslint-disable-next-line no-console
    console.error(errorMessage(type));
    return null;
  }

return TYPES[type](expression);
}

// Composition map of types to their extractor functions to handle literals.
const LITERAL_TYPES = {
  ...TYPES,
  Literal: (value) => {
    const extractedVal = TYPES.Literal.call(undefined, value);
    const isNull = extractedVal === null;
    // This will be convention for attributes that have null
    // value explicitly defined (<div prop={null} /> maps to 'null').
    return isNull ? 'null' : extractedVal;
  },
  Identifier: (value) => {
    const isUndefined = TYPES.Identifier.call(undefined, value) === undefined;
    return isUndefined ? undefined : null;
  },
  JSXElement: noop,
  JSXFragment: noop,
  JSXText: noop,
  ArrowFunctionExpression: noop,
  FunctionExpression: noop,
  LogicalExpression: noop,
  MemberExpression: noop,
  OptionalCallExpression: noop,
  OptionalMemberExpression: noop,
  CallExpression: noop,
  UnaryExpression: (value) => {
    const extractedVal = TYPES.UnaryExpression.call(undefined, value);
    return extractedVal === undefined ? null : extractedVal;
  },
  UpdateExpression: (value) => {
    const extractedVal = TYPES.UpdateExpression.call(undefined, value);
    return extractedVal === undefined ? null : extractedVal;
  },
  ThisExpression: noop,
  ConditionalExpression: noop,
  BinaryExpression: noop,
  ObjectExpression: noop,
  NewExpression: noop,
  ArrayExpression: (value) => {
    const extractedVal = TYPES.ArrayExpression.call(undefined, value);
    return extractedVal.filter((val) => val !== null);
  },
  BindExpression: noop,
  SpreadElement: noop,
  TSNonNullExpression: noop,
  TSAsExpression: noop,
  TypeCastExpression: noop,
  SequenceExpression: noop,
  ChainExpression: noop,
};

/**
 * This function maps an AST value node
 * to its correct extractor function for its
 * given type.
 *
 * This will map correctly for *some* possible types that map to literals.
 *
 * @param - value - AST Value object with type `JSXExpressionContainer`
 * @returns The extracted value.
 */
export function extractLiteral(value) {
  // Value will not have the expression property when we recurse.
  const expression = value.expression || value;
  const { type } = expression;

if (LITERAL_TYPES[type] === undefined) {
    // eslint-disable-next-line no-console
    console.error(errorMessage(type));
    return null;
  }

return LITERAL_TYPES[type](expression);
}
PK�������Y[+������������src/values/JSXText.jsnu�ȯ����������/**
 * Extractor function for a JSXText type value node.
 *
 * Returns self-closing element with correct name.
 */
export default function extractValueFromJSXText(value) {
  return value.raw;
}
PK�������Y[x�ɽ��������src/values/JSXFragment.jsnu�ȯ����������/**
 * Extractor function for a JSXFragment type value node.
 *
 * Returns self-closing element with correct name.
 */
export default function extractValueFromJSXFragment(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;

if (value.children.length === 0) {
    return '<></>';
  }
  return `<>${[].concat(value.children).map((x) => getValue(x)).join('')}</>`;
}
PK�������Y[�^����������src/values/JSXElement.jsnu�ȯ����������/**
 * Extractor function for a JSXElement type value node.
 *
 * Returns self-closing element with correct name.
 */
export default function extractValueFromJSXElement(value) {
  // eslint-disable-next-line global-require
  const getValue = require('.').default;

// Composition map of types to their extractor functions.
const TYPES = {
  Literal,
  JSXElement,
  JSXExpressionContainer,
  JSXText,
};

// Composition map of types to their extractor functions to handle literals.
const LITERAL_TYPES = {
  ...TYPES,
  JSXElement: () => null,
  JSXExpressionContainer: extractLiteral,
};

/**
 * This function maps an AST value node
 * to its correct extractor function for its
 * given type.
 *
 * This will map correctly for *all* possible types.
 *
 * @param value - AST Value object on a JSX Attribute.
 */
export default function getValue(value) {
  return TYPES[value.type](value);
}

/**
 * This function maps an AST value node
 * to its correct extractor function for its
 * given type.
 *
 * This will map correctly for *some* possible types that map to literals.
 *
 * @param value - AST Value object on a JSX Attribute.
 */
export function getLiteralValue(value) {
  return LITERAL_TYPES[value.type](value);
}
PK�������Y[X3��������src/getPropValue.jsnu�ȯ����������import getValue, { getLiteralValue } from './values';

const extractValue = (attribute, extractor) => {
  if (attribute && attribute.type === 'JSXAttribute') {
    if (attribute.value === null) {
      // Null valued attributes imply truthiness.
      // For example: <div aria-hidden />
      // See: https://facebook.github.io/react/docs/jsx-in-depth.html#boolean-attributes
      return true;
    }

return extractor(attribute.value);
  }

return undefined;
};

/**
 * Returns the value of a given attribute.
 * Different types of attributes have their associated
 * values in different properties on the object.
 *
 * This function should return the most *closely* associated
 * value with the intention of the JSX.
 *
 * @param attribute - The JSXAttribute collected by AST parser.
 */
export default function getPropValue(attribute) {
  return extractValue(attribute, getValue);
}

/**
 * Returns the value of a given attribute.
 * Different types of attributes have their associated
 * values in different properties on the object.
 *
 * This function should return a value only if we can extract
 * a literal value from its attribute (i.e. values that have generic
 * types in JavaScript - strings, numbers, booleans, etc.)
 *
 * @param attribute - The JSXAttribute collected by AST parser.
 */
export function getLiteralPropValue(attribute) {
  return extractValue(attribute, getLiteralValue);
}
PK�������Y[�����������src/propName.jsnu�ȯ����������/**
 * Returns the name of the prop given the JSXAttribute object.
 */
export default function propName(prop = {}) {
  if (!prop.type || prop.type !== 'JSXAttribute') {
    throw new Error('The prop must be a JSXAttribute collected by the AST parser.');
  }

if (prop.name.type === 'JSXNamespacedName') {
    return `${prop.name.namespace.name}:${prop.name.name.name}`;
  }

return prop.name.name;
}
PK�������Y[��Ĺ	���	����src/getProp.jsnu�ȯ����������import propName from './propName';

const DEFAULT_OPTIONS = {
  ignoreCase: true,
};

/**
 * Returns the JSXAttribute itself or undefined, indicating the prop
 * is not present on the JSXOpeningElement.
 *
 */
export default function getProp(props = [], prop = '', options = DEFAULT_OPTIONS) {
  function getName(name) { return options.ignoreCase ? name.toUpperCase() : name; }
  const propToFind = getName(prop);
  function isPropToFind(property) {
    return property.type === 'Property'
      && property.key.type === 'Identifier'
      && propToFind === getName(property.key.name);
  }

const foundAttribute = props.find((attribute) => {
    // If the props contain a spread prop, try to find the property in the object expression.
    if (attribute.type === 'JSXSpreadAttribute') {
      return attribute.argument.type === 'ObjectExpression'
        && propToFind !== getName('key') // https://github.com/reactjs/rfcs/pull/107
        && attribute.argument.properties.some(isPropToFind);
    }

return propToFind === getName(propName(attribute));
  });

if (foundAttribute && foundAttribute.type === 'JSXSpreadAttribute') {
    return propertyToJSXAttribute(foundAttribute.argument.properties.find(isPropToFind));
  }

return foundAttribute;
}

function propertyToJSXAttribute(node) {
  const { key, value } = node;
  return {
    type: 'JSXAttribute',
    name: { type: 'JSXIdentifier', name: key.name, ...getBaseProps(key) },
    value: value.type === 'Literal'
      ? adjustRangeOfNode(value)
      : { type: 'JSXExpressionContainer', expression: adjustExpressionRange(value), ...getBaseProps(value) },
    ...getBaseProps(node),
  };
}

function adjustRangeOfNode(node) {
  const [start, end] = node.range || [node.start, node.end];

return {
    ...node,
    end: undefined,
    range: [start, end],
    start: undefined,
  };
}

function adjustExpressionRange({ expressions, quasis, ...expression }) {
  return {
    ...adjustRangeOfNode(expression),
    ...(expressions ? { expressions: expressions.map(adjustRangeOfNode) } : {}),
    ...(quasis ? { quasis: quasis.map(adjustRangeOfNode) } : {}),
  };
}

function getBaseProps({ loc, ...node }) {
  const { range } = adjustRangeOfNode(node);

return {
    loc: getBaseLocation(loc),
    range,
  };
}

function getBaseLocation({
  start,
  end,
  source,
  filename,
}) {
  return {
    start,
    end,
    ...(source !== undefined ? { source } : {}),
    ...(filename !== undefined ? { filename } : {}),
  };
}
PK�������Y[1�@��@����src/elementType.jsnu�ȯ����������function resolveMemberExpressions(object = {}, property = {}) {
  if (object.type === 'JSXMemberExpression') {
    return `${resolveMemberExpressions(object.object, object.property)}.${property.name}`;
  }

return `${object.name}.${property.name}`;
}

/**
 * Returns the tagName associated with a JSXElement.
 */
export default function elementType(node = {}) {
  const { name } = node;

if (node.type === 'JSXOpeningFragment') {
    return '<>';
  }

if (!name) {
    throw new Error('The argument provided is not a JSXElement node.');
  }

if (name.type === 'JSXMemberExpression') {
    const { object = {}, property = {} } = name;
    return resolveMemberExpressions(object, property);
  }

if (name.type === 'JSXNamespacedName') {
    return `${name.namespace.name}:${name.name.name}`;
  }

return node.name.name;
}
PK�������Y[��3��������src/index.jsnu�ȯ����������import hasProp, { hasAnyProp, hasEveryProp } from './hasProp';
import elementType from './elementType';
import eventHandlers, { eventHandlersByType } from './eventHandlers';
import getProp from './getProp';
import getPropValue, { getLiteralPropValue } from './getPropValue';
import propName from './propName';

module.exports = {
  hasProp,
  hasAnyProp,
  hasEveryProp,
  elementType,
  eventHandlers,
  eventHandlersByType,
  getProp,
  getPropValue,
  getLiteralPropValue,
  propName,
};
PK�������Y[A��&���&���
��.eslintignorenu�ȯ����������node_modules/
reports/
lib/
coverage/
PK�������Y[޺�,����������.github/FUNDING.ymlnu�ȯ����������# These are supported funding model platforms

github: [jsx-eslint, ljharb]
open_collective: eslint-plugin-jsx-a11y
tidelift: "npm/jsx-ast-utils"
PK�������Y[��q�#���#��	��README.mdnu�ȯ����������# jsx-ast-utils <sup>[![Version Badge][npm-version-svg]][package-url]</sup>

[![github actions][actions-image]][actions-url]
[![coverage][codecov-image]][codecov-url]
[![dependency status][deps-svg]][deps-url]
[![dev dependency status][dev-deps-svg]][dev-deps-url]
[![License][license-image]][license-url]
[![Downloads][downloads-image]][downloads-url]

[![npm badge][npm-badge-png]][package-url]

AST utility module for statically analyzing JSX.

## Installation
```sh
$ npm i jsx-ast-utils --save
```

## Usage
This is a utility module to evaluate AST objects for JSX syntax. This can be super useful when writing linting rules for JSX code. It was originally in the code for [eslint-plugin-jsx-a11y](https://github.com/jsx-eslint/eslint-plugin-jsx-a11y), however I thought it could be useful to be extracted and maintained separately so **you** could write new interesting rules to statically analyze JSX.

### ESLint example
```js
import { hasProp } from 'jsx-ast-utils';
// OR: var hasProp = require('jsx-ast-utils').hasProp;
// OR: const hasProp = require('jsx-ast-utils/hasProp');
// OR: import hasProp from 'jsx-ast-utils/hasProp';

module.exports = context => ({
  JSXOpeningElement: node => {
    const onChange = hasProp(node.attributes, 'onChange');

if (onChange) {
      context.report({
        node,
        message: `No onChange!`
      });
    }
  }
});
```

## API
### AST Resources
1. [JSX spec](https://github.com/facebook/jsx/blob/master/AST.md)
2. [JS spec](https://github.com/estree/estree/blob/master/spec.md)

### hasProp
```js
hasProp(props, prop, options);
```
Returns boolean indicating whether an prop exists as an attribute on a JSX element node.

#### Props
Object - The attributes on the visited node. (Usually `node.attributes`).
#### Prop
String - A string representation of the prop you want to check for existence.
#### Options
Object - An object representing options for existence checking
  1. `ignoreCase` - automatically set to `true`.
  2. `spreadStrict` - automatically set to `true`. This means if spread operator exists in
     props, it will assume the prop you are looking for is not in the spread.
     Example: `<div {...props} />` looking for specific prop here will return false if `spreadStrict` is `true`.

<hr />

### hasAnyProp

```js
hasAnyProp(props, prop, options);
```
Returns a boolean indicating if **any** of props in `prop` argument exist on the node.

#### Props
Object - The attributes on the visited node. (Usually `node.attributes`).
#### Prop
Array<String> - An array of strings representing the props you want to check for existence.
#### Options
Object - An object representing options for existence checking
  1. `ignoreCase` - automatically set to `true`.
  2. `spreadStrict` - automatically set to `true`. This means if spread operator exists in
     props, it will assume the prop you are looking for is not in the spread.
     Example: `<div {...props} />` looking for specific prop here will return false if `spreadStrict` is `true`.

<hr />

### hasEveryProp

```js
hasEveryProp(props, prop, options);
```
Returns a boolean indicating if **all** of props in `prop` argument exist on the node.

#### Props
Object - The attributes on the visited node. (Usually `node.attributes`).
#### Prop
Array<String> - An array of strings representing the props you want to check for existence.
#### Options
Object - An object representing options for existence checking
 1. `ignoreCase` - automatically set to `true`.
 2. `spreadStrict` - automatically set to `true`. This means if spread operator exists in
    props, it will assume the prop you are looking for is not in the spread.
    Example: `<div {...props} />` looking for specific prop here will return false if `spreadStrict` is `true`.

<hr />

### getProp

```js
getProp(props, prop, options);
```
Returns the JSXAttribute itself or undefined, indicating the prop is not present on the JSXOpeningElement.

<hr />

### elementType
```js
elementType(node)
```
Returns the tagName associated with a JSXElement.

#### Node
Object - The visited JSXElement node object.

<hr />

### getPropValue

```js
getPropValue(prop);
```
Returns the value of a given attribute. Different types of attributes have their associated values in different properties on the object.

This function should return the most *closely* associated value with the intention of the JSX.

#### Prop
Object - The JSXAttribute collected by AST parser.

<hr />

### getLiteralPropValue

```js
getLiteralPropValue(prop);
```
Returns the value of a given attribute. Different types of attributes have their associated values in different properties on the object.

This function should return a value only if we can extract a literal value from its attribute (i.e. values that have generic types in JavaScript - strings, numbers, booleans, etc.)

#### Prop
Object - The JSXAttribute collected by AST parser.

<hr />

### propName

```js
propName(prop);
```
Returns the name associated with a JSXAttribute. For example, given `<div foo="bar" />` and the JSXAttribute for `foo`, this will return the string `"foo"`.

#### Prop
Object - The JSXAttribute collected by AST parser.

<hr />

### eventHandlers

```js
console.log(eventHandlers);
/*
[
  'onCopy',
  'onCut',
  'onPaste',
  'onCompositionEnd',
  'onCompositionStart',
  'onCompositionUpdate',
  'onKeyDown',
  'onKeyPress',
  'onKeyUp',
  'onFocus',
  'onBlur',
  'onChange',
  'onInput',
  'onSubmit',
  'onClick',
  'onContextMenu',
  'onDblClick',
  'onDoubleClick',
  'onDrag',
  'onDragEnd',
  'onDragEnter',
  'onDragExit',
  'onDragLeave',
  'onDragOver',
  'onDragStart',
  'onDrop',
  'onMouseDown',
  'onMouseEnter',
  'onMouseLeave',
  'onMouseMove',
  'onMouseOut',
  'onMouseOver',
  'onMouseUp',
  'onSelect',
  'onTouchCancel',
  'onTouchEnd',
  'onTouchMove',
  'onTouchStart',
  'onScroll',
  'onWheel',
  'onAbort',
  'onCanPlay',
  'onCanPlayThrough',
  'onDurationChange',
  'onEmptied',
  'onEncrypted',
  'onEnded',
  'onError',
  'onLoadedData',
  'onLoadedMetadata',
  'onLoadStart',
  'onPause',
  'onPlay',
  'onPlaying',
  'onProgress',
  'onRateChange',
  'onSeeked',
  'onSeeking',
  'onStalled',
  'onSuspend',
  'onTimeUpdate',
  'onVolumeChange',
  'onWaiting',
  'onLoad',
  'onError',
  'onAnimationStart',
  'onAnimationEnd',
  'onAnimationIteration',
  'onTransitionEnd',
]
*/
```

Contains a flat list of common event handler props used in JSX to attach behaviors
to DOM events.

#### eventHandlersByType

The same list as `eventHandlers`, grouped into types.

```js
console.log(eventHandlersByType);
/*
{
  clipboard: [ 'onCopy', 'onCut', 'onPaste' ],
  composition: [ 'onCompositionEnd', 'onCompositionStart', 'onCompositionUpdate' ],
  keyboard: [ 'onKeyDown', 'onKeyPress', 'onKeyUp' ],
  focus: [ 'onFocus', 'onBlur' ],
  form: [ 'onChange', 'onInput', 'onSubmit' ],
  mouse: [ 'onClick', 'onContextMenu', 'onDblClick', 'onDoubleClick', 'onDrag', 'onDragEnd', 'onDragEnter', 'onDragExit', 'onDragLeave', 'onDragOver', 'onDragStart', 'onDrop', 'onMouseDown', 'onMouseEnter', 'onMouseLeave', 'onMouseMove', 'onMouseOut', 'onMouseOver', 'onMouseUp' ],
  selection: [ 'onSelect' ],
  touch: [ 'onTouchCancel', 'onTouchEnd', 'onTouchMove', 'onTouchStart' ],
  ui: [ 'onScroll' ],
  wheel: [ 'onWheel' ],
  media: [ 'onAbort', 'onCanPlay', 'onCanPlayThrough', 'onDurationChange', 'onEmptied', 'onEncrypted', 'onEnded', 'onError', 'onLoadedData', 'onLoadedMetadata', 'onLoadStart', 'onPause', 'onPlay', 'onPlaying', 'onProgress', 'onRateChange', 'onSeeked', 'onSeeking', 'onStalled', 'onSuspend', 'onTimeUpdate', 'onVolumeChange', 'onWaiting' ],
  image: [ 'onLoad', 'onError' ],
  animation: [ 'onAnimationStart', 'onAnimationEnd', 'onAnimationIteration' ],
  transition: [ 'onTransitionEnd' ],
}
*/
```

[1]: https://npmjs.org/package/jsx-ast-utils
[2]: https://versionbadg.es/jsx-eslint/jsx-ast-utils.svg
[5]: https://david-dm.org/jsx-eslint/jsx-ast-utils.svg
[6]: https://david-dm.org/jsx-eslint/jsx-ast-utils
[7]: https://david-dm.org/jsx-eslint/jsx-ast-utils/dev-status.svg
[8]: https://david-dm.org/jsx-eslint/jsx-ast-utils#info=devDependencies
[11]: https://nodei.co/npm/jsx-ast-utils.png?downloads=true&stars=true
[license-image]: https://img.shields.io/npm/l/jsx-ast-utils.svg
[license-url]: LICENSE
[downloads-image]: https://img.shields.io/npm/dm/jsx-ast-utils.svg
[downloads-url]: https://npm-stat.com/charts.html?package=jsx-ast-utils
[codecov-image]: https://codecov.io/gh/jsx-eslint/jsx-ast-utils/branch/main/graphs/badge.svg
[codecov-url]: https://app.codecov.io/gh/jsx-eslint/jsx-ast-utils/
[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/jsx-eslint/jsx-ast-utils
[actions-url]: https://github.com/jsx-eslint/jsx-ast-utils/actions
PK�������Y[f~��c���c�����getLiteralPropValue.jsnu�ȯ����������module.exports = require('./lib').getLiteralPropValue; // eslint-disable-line import/no-unresolved
PK�������Y[�R��5��5��
��LICENSE.mdnu�ȯ����������The MIT License (MIT)
Copyright (c) 2016 Ethan Cohen

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
PK�������Y[C��
\���\�����getPropValue.jsnu�ȯ����������module.exports = require('./lib').getPropValue; // eslint-disable-line import/no-unresolved
PK�������Y[Nf+QX���X�����propName.jsnu�ȯ����������module.exports = require('./lib').propName; // eslint-disable-line import/no-unresolved
PK�������Y[����o��o����CHANGELOG.mdnu�ȯ����������Unreleased
==================

3.3.3 / 2022-08-08
==================
- [Fix] Mark ChainExpression as a noop (#109)
- [Deps] update `object.assign`
- [Dev Deps] update `@babel/core`, `@babel/eslint-parser`, `@babel/parser`, `eslint`

3.3.2 / 2022-07-06
==================
- [Fix] Handle `as` casts in TSNonNullExpression

3.3.1 / 2022-06-22
==================
- [Fix] `ArrayExpression`: handle sparse array (#117)
- [Deps] update `array-includes`
- [meta] move jest config to separate file
- [meta] use `npmignore` to autogenerate an npmignore file
- [Dev Deps] update `@babel/core`, `@babel/eslint-parser`, `@babel/parser`, `eslint`

3.3.0 / 2022-04-30
==================
- [New] add `JSXFragment`, `JSXText`; fix `JSXElement` to handle children
- [Dev Deps] update `@babel/core`, `@babel/parser`, `eslint`, `eslint-plugin-import`

3.2.2 / 2022-03-31
==================
- [Fix] `TSNonNullExpression`: handle computed MemberExpressions (#109)
- [Fix] avoid a crash in ChainExpressions in a TSAsExpression

3.2.1 / 2021-09-16
==================
- [patch] include project name in error logging (#113)
- [readme] update badges, URLs
- [Deps] update `array-includes`
- [meta] don‘t lint coverage results
- [meta] add GitHub org to FUNDING.yml
- [meta] add OpenCollective to FUNDING.yml
- [meta] run `aud` in `posttest`
- [meta] add Automatic Rebase and Require Allow Edits workflows
- [actions] use `node/install` instead of `node/run`; use `codecov` action
- [Tests] unpin `caniuse-lite`, since breaking change is fixed
- [Tests] pin `caniuse-lite`, due to breaking change in patch version
- [Tests] fix linting errors
- [Tests] migrate tests to Github Actions
- [Tests] stop using coveralls
- [Tests] skip failing fragment test in node 4
- [Dev Deps] update `@babel/core`, `@babel/parser`, `aud`, `eslint`, `eslint-plugin-import`, `object.entries`, `object.fromentries`

3.2.0 / 2020-12-16
==================
- [New] add support for fragment syntax (`<>`) (#108)
- [Fix] `TSNonNullExpression`: handle `ThisExpression`s (#108)
- [Deps] update `array-includes`, `object.assign`
- [Dev Deps] update `@babel/core`, `@babel/parser`, `eslint`, `eslint-config-airbnb-base`, `object.entries`, `object.fromentries`

3.1.0 / 2020-10-13
==================
- [New] add `TSNonNullExpression` (#105)
- [New] add `AssignmentExpression` (#106)
- [Dev Deps] update `eslint`

3.0.0 / 2020-10-06
==================
- [Breaking] Don't return node.start & node.end (#100)
- [Breaking] add `ChainExpression`; `CallExpression` now includes arguments (#102)
- [New] add `SequenceExpression` (#101)
- [Deps] update `object.assign`
- [Dev Deps] update `eslint`, `eslint-plugin-import`
- [Dev Deps] update `@babel/core`, `@babel/parser`, `eslint`, `eslint-plugin-import`
- [Tests] use proper `actual, expected` ordering for non-confusing failure messages

2.4.1 / 2020-06-11
==================
- [Fix] `expressions/TemplateLiteral`: use `.range[0]` instead of `.start`

2.4.0 / 2020-06-11
==================
- [New] Provide both range and start & end property on Node, support eslint v7 (#97)
- [Dev Deps] update `@babel/core`, `@babel/parser`, `eslint`, `eslint-config-airbnb-base`, `eslint-plugin-import`, `flow-parser`
- [meta] remove yarn registry from npmrc, so `npm publish` works

2.3.0 / 2020-05-24
==================
- [New] add nullish coalescing (#99)
- [New] add OptionalCallExpression (#99)
- [Deps] update `array-includes`
- [meta] add `safe-publish-latest`
- [Dev Deps] update `@babel/parser`, `babel-eslint`, `coveralls`, `eslint`, `eslint-config-airbnb-base`, `eslint-plugin-import`, `in-publish`, `object.entries`, `object.fromentries`, `rimraf`
- [Tests] on `node` `v14`; test all branches

2.2.3 / 2019-10-24
==================
- (fix) Fix crash on spread (#94)

2.2.2 / 2019-10-24
==================
- (improvement) Add support for retrieving props from a spread with object expression (#93)

2.2.1 / 2019-06-30
==================
- (improvement) Account for TypeCastExpression in the utils

2.2.0 / 2019-06-25
==================
- (fix) Fix getLiteralPropValue for TS-specific node types.
- (chore) upgrade dependencies.
- (improvement) Stop throwing errors when unknown AST nodes are encountered.
- (dev) CI changes.

2.1.0 / 2018-04-19
==================
- Fix undefined bug for template strings. #45
- Adding support for `objectRestSpread` within props #60
- Accommodate ExperimentalSpreadProperty in prop values #75
- Account for SpreadElement AST Nodes #76
- Support OptionalMemberExpression AST nodes #77
- Add support to Typescript's node types #72

2.0.1 / 2017-08-31
==================
- [fix] Add support for BindExpression

2.0.0 / 2017-07-07
==================
- [breaking] Remove undefined return from `propName` so it always returns a value.

1.4.1 / 2017-04-19
==================
- [fix] - Fixing fatal throw in `getPropValue` for `ArrowFunctionExpression`

1.4.0 / 2017-02-02
==================
- [new] Add eventHandlers and eventHandlersByType to API. These are the event names for DOM elements on JSX-using libraries such as React, inferno, and preact.

1.3.5 / 2016-12-14
==================
- [fix] Normalize literals "true" and "false" before converting to boolean in Literal prop value extractor.

1.3.4 / 2016-11-15
==================
- [fix] Recursively resolve JSXMemberExpression names for elementType. (i.e. `<Component.Render.Me />`). Fixes [#9](https://github.com/evcohen/jsx-ast-utils/issues/9)

1.3.3 / 2016-10-28
==================
- [fix] Add support for `ArrayExpression`.

1.3.2 / 2016-10-11
==================
- [fix] Add support for `UpdateExpression`.

1.3.1 / 2016-07-13
==================
- [fix] Add `JSXElement` to expression types to handle recursively extracting prop value.

1.3.0 / 2016-07-12
==================
- [new] Add support for `TaggedTemplateExpression`.

1.2.1 / 2016-06-15
==================
- [fix] Point to `lib` instead of `src` for root exports.

1.2.0 / 2016-06-15
==================
- [new] Export functions from root so they can be imported like the following: `require('jsx-ast-utils/{function}')`.

1.1.1 / 2016-06-12
==================
- [fix] Better support for expressions in `TemplateLiteral` extraction.

1.1.0 / 2016-06-10
==================
- [new] Support for namespaced element names.
- [new] Add `propName` to API to get correct name for prop.

1.0.1 / 2016-06-10
==================
- [fix] Return actual reserved words instead of string representations of them.

1.0.0 / 2016-06-09
==================
- Initial stable release
PK�������Y[|A]��������package.jsonnu�ȯ����������{
  "name": "jsx-ast-utils",
  "version": "3.3.3",
  "description": "AST utility module for statically analyzing JSX",
  "main": "lib/index.js",
  "scripts": {
    "prepack": "npmignore --auto --commentLines=autogenerated",
    "prebuild": "rimraf lib",
    "build": "babel src --out-dir lib",
    "prepublishOnly": "safe-publish-latest && npm test && npm run build",
    "prepublish": "not-in-publish || npm run prepublishOnly",
    "prelint": "npm run build",
    "lint": "eslint .",
    "pretest": "npm run lint",
    "test": "npm run tests-only --",
    "posttest": "aud --production",
    "tests-only": "jest --coverage",
    "test:watch": "npm run tests-only -- --watch"
  },
  "devDependencies": {
    "@babel/core": "^7.18.10",
    "@babel/eslint-parser": "^7.18.9",
    "@babel/parser": "^7.18.11",
    "aud": "^2.0.0",
    "babel-cli": "^6.26.0",
    "babel-core": "^6.26.3",
    "babel-jest": "^20.0.3",
    "babel-plugin-transform-object-rest-spread": "^6.26.0",
    "babel-plugin-transform-replace-object-assign": "^1.0.0",
    "babel-polyfill": "^6.26.0",
    "babel-preset-env": "^1.7.0",
    "babylon": "^6.18.0",
    "eslint": "^8.21.0",
    "eslint-config-airbnb-base": "^15.0.0",
    "eslint-plugin-import": "^2.26.0",
    "flow-parser": "^0.126.1",
    "in-publish": "^2.0.1",
    "jest": "^20.0.4",
    "jest-cli": "^20.0.4",
    "npmignore": "^0.3.0",
    "object.entries": "^1.1.5",
    "object.fromentries": "^2.0.5",
    "rimraf": "^2.7.1",
    "safe-publish-latest": "^2.0.0"
  },
  "engines": {
    "node": ">=4.0"
  },
  "keywords": [
    "jsx",
    "ast",
    "lint",
    "eslint"
  ],
  "author": "Ethan Cohen",
  "repository": {
    "type": "git",
    "url": "https://github.com/jsx-eslint/jsx-ast-utils"
  },
  "license": "MIT",
  "dependencies": {
    "array-includes": "^3.1.5",
    "object.assign": "^4.1.3"
  },
  "publishConfig": {
    "ignore": [
      ".github/workflows",
      "jest.config.js"
    ]
  }
}
PK�������Y[�73��3��	��.eslintrcnu�ȯ����������{
  "root": true,

"extends": "airbnb-base",

"parser": "@babel/eslint-parser",

"rules": {
    "no-use-before-define": ["error", { "functions": false }],
  },

"overrides": [
    {
      "files": "src/index.js",
      "rules": {
        "import/no-import-module-exports": 0,
      },
    },
  ],
}
PK�������Y[;+,g,��g,����__tests__/src/hasProp-test.jsnu�ȯ����������/* eslint-env mocha */
import assert from 'assert';
import { getOpeningElement, setParserName } from '../helper';
import hasProp, { hasAnyProp, hasEveryProp } from '../../src/hasProp';

describe('hasProp', () => {
  beforeEach(() => {
    setParserName('babel');
  });
  it('should export a function', () => {
    const expected = 'function';
    const actual = typeof hasProp;

assert.equal(actual, expected);
  });

it('should return false if no arguments are provided', () => {
    const expected = false;
    const actual = hasProp();

assert.equal(actual, expected);
  });

it('should return false if the prop is absent', () => {
    const code = '<div />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'id';

const expected = false;
    const actual = hasProp(props, prop);

assert.equal(actual, expected);
  });

it('should return true if the prop exists', () => {
    const code = '<div id="foo" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'id';

const expected = true;
    const actual = hasProp(props, prop);

assert.equal(actual, expected);
  });

it('should return true if the prop may exist in spread loose mode', () => {
    const code = '<div {...props} />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'id';
    const options = {
      spreadStrict: false,
    };

const expected = true;
    const actual = hasProp(props, prop, options);

assert.equal(actual, expected);
  });

it('should return false if the prop is considered absent in case-sensitive mode', () => {
    const code = '<div ID="foo" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'id';
    const options = {
      ignoreCase: false,
    };

const expected = false;
    const actual = hasProp(props, prop, options);

assert.equal(actual, expected);
  });
});

describe('hasAnyProp tests', () => {
  it('should export a function', () => {
    const expected = 'function';
    const actual = typeof hasAnyProp;

assert.equal(actual, expected);
  });

it('should return false if no arguments are provided', () => {
    const expected = false;
    const actual = hasAnyProp();

assert.equal(actual, expected);
  });

it('should return false if the prop is absent', () => {
    const code = '<div />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'id';

const expected = false;
    const actual = hasAnyProp(props, prop);

assert.equal(actual, expected);
  });

it('should return false if all props are absent in array', () => {
    const code = '<div />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const propsToCheck = ['id', 'className'];

const expected = false;
    const actual = hasAnyProp(props, propsToCheck);

assert.equal(actual, expected);
  });

it('should return false if all props are absent in space delimited string', () => {
    const code = '<div />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const propsToCheck = 'id className';

const expected = false;
    const actual = hasAnyProp(props, propsToCheck);

assert.equal(actual, expected);
  });

it('should return true if the prop exists', () => {
    const code = '<div id="foo" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'id';

const expected = true;
    const actual = hasAnyProp(props, prop);

assert.equal(actual, expected);
  });

it('should return true if any prop exists in array', () => {
    const code = '<div id="foo" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = ['className', 'id'];

const expected = true;
    const actual = hasAnyProp(props, prop);

assert.equal(actual, expected);
  });

it('should return true if any prop exists in space delimited string', () => {
    const code = '<div id="foo" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'className id';

const expected = true;
    const actual = hasAnyProp(props, prop);

assert.equal(actual, expected);
  });

const expected = true;
    const actual = hasAnyProp(props, prop, options);

assert.equal(actual, expected);
  });

it('should return true if any prop may exist in spread loose mode', () => {
    const code = '<div {...props} />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = ['id', 'className'];
    const options = {
      spreadStrict: false,
    };

const expected = true;
    const actual = hasAnyProp(props, prop, options);

assert.equal(actual, expected);
  });

const expected = false;
    const actual = hasAnyProp(props, prop, options);

assert.equal(actual, expected);
  });

it('should return false if all props are considered absent in case-sensitive mode', () => {
    const code = '<div ID="foo" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = ['id', 'iD', 'className'];
    const options = {
      ignoreCase: false,
    };

const expected = false;
    const actual = hasAnyProp(props, prop, options);

assert.equal(actual, expected);
  });
});

describe('hasEveryProp tests', () => {
  it('should export a function', () => {
    const expected = 'function';
    const actual = typeof hasEveryProp;

assert.equal(actual, expected);
  });

it('should return true if no arguments are provided', () => {
    const expected = true;
    const actual = hasEveryProp();

assert.equal(actual, expected);
  });

it('should return false if the prop is absent', () => {
    const code = '<div />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'id';

const expected = false;
    const actual = hasEveryProp(props, prop);

assert.equal(actual, expected);
  });

it('should return false if any props are absent in array', () => {
    const code = '<div id="foo" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const propsToCheck = ['id', 'className'];

const expected = false;
    const actual = hasEveryProp(props, propsToCheck);

assert.equal(actual, expected);
  });

const expected = false;
    const actual = hasEveryProp(props, propsToCheck);

assert.equal(actual, expected);
  });

it('should return false if any props are absent in space delimited string', () => {
    const code = '<div id="foo" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const propsToCheck = 'id className';

const expected = false;
    const actual = hasEveryProp(props, propsToCheck);

assert.equal(actual, expected);
  });

const expected = false;
    const actual = hasEveryProp(props, propsToCheck);

assert.equal(actual, expected);
  });

it('should return true if the prop exists', () => {
    const code = '<div id="foo" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'id';

const expected = true;
    const actual = hasEveryProp(props, prop);

assert.equal(actual, expected);
  });

it('should return true if all props exist in array', () => {
    const code = '<div id="foo" className="box" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = ['className', 'id'];

const expected = true;
    const actual = hasEveryProp(props, prop);

assert.equal(actual, expected);
  });

it('should return true if all props exist in space delimited string', () => {
    const code = '<div id="foo" className="box" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'className id';

const expected = true;
    const actual = hasEveryProp(props, prop);

assert.equal(actual, expected);
  });

it('should return true if the props may exist in spread loose mode', () => {
    const code = '<div {...props} />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = 'id';
    const options = {
      spreadStrict: false,
    };

const expected = true;
    const actual = hasEveryProp(props, prop, options);

assert.equal(actual, expected);
  });

it('should return true if all props may exist in spread loose mode', () => {
    const code = '<div {...props} />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = ['id', 'className'];
    const options = {
      spreadStrict: false,
    };

const expected = true;
    const actual = hasEveryProp(props, prop, options);

assert.equal(actual, expected);
  });

const expected = false;
    const actual = hasEveryProp(props, prop, options);

assert.equal(actual, expected);
  });

const expected = false;
    const actual = hasEveryProp(props, prop, options);

assert.equal(actual, expected);
  });

it('should return true if all props are considered present in case-sensitive mode', () => {
    const code = '<div ID="foo" className="box" />';
    const node = getOpeningElement(code);
    const { attributes: props } = node;
    const prop = ['ID', 'className'];
    const options = {
      ignoreCase: false,
    };

const expected = true;
    const actual = hasEveryProp(props, prop, options);

assert.equal(actual, expected);
  });
});
PK�������Y[�o5|��|��$��__tests__/src/getProp-parser-test.jsnu�ȯ����������/* eslint-env mocha */
import assert from 'assert';
import entries from 'object.entries';
import fromEntries from 'object.fromentries';
import { getOpeningElement, setParserName, fallbackToBabylon } from '../helper';
import getProp from '../../src/getProp';

const literal = {
  source: '<div {...{ id: "foo" }} />',
  target: '<div id="foo" />',
  offset: { keyOffset: -6, valueOffset: -7 },
};

const expression1 = {
  source: '<div {...{ id }} />',
  target: '<div id={id} />',
  offset: { keyOffset: -6, valueOffset: -2 },
};

const expression2 = {
  source: '<div {...{ id: `foo${bar}baz` }} />', // eslint-disable-line no-template-curly-in-string
  target: '<div id={`foo${bar}baz`} />', // eslint-disable-line no-template-curly-in-string
  offset: { keyOffset: -6, valueOffset: -6 },
};

describe('getProp', () => {
  it('should create the correct AST for literal with flow parser', () => {
    actualTest('flow', literal);
  });
  it('should create the correct AST for literal with babel parser', () => {
    actualTest('babel', literal);
  });
  it('should create the correct AST for expression with flow parser (1)', () => {
    actualTest('flow', expression1);
  });
  it('should create the correct AST for expression with babel parser (1)', () => {
    actualTest('babel', expression1);
  });
  it('should create the correct AST for expression with flow parser (2)', () => {
    actualTest('flow', expression2);
  });
  it('should create the correct AST for expression with babel parser (2)', () => {
    actualTest('babel', expression2);
  });
});

function actualTest(parserName, test) {
  setParserName(parserName);
  const { source, target, offset } = test;
  const sourceProps = stripConstructors(getOpeningElement(source).attributes);
  const targetProps = stripConstructors(getOpeningElement(target).attributes);
  const prop = 'id';
  const sourceResult = getProp(sourceProps, prop);
  const targetResult = getProp(targetProps, prop);

if (fallbackToBabylon && parserName === 'babel' && test === literal) {
    // Babylon (node < 6) adds an `extra: null` prop to a literal if it is parsed from a
    // JSXAttribute, other literals don't get this.
    sourceResult.value.extra = null;
  }

assert.deepStrictEqual(
    adjustLocations(sourceResult, offset),
    adjustRange(targetResult),
  );
}

function adjustRange({ name, value: { expression, ...value }, ...node }) {
  return {
    ...adjustNodeRange(node),
    name: adjustNodeRange(name),
    value: {
      ...adjustNodeRange(value),
      ...(expression ? { expression: adjustNodeRangeRecursively(expression) } : {}),
    },
  };
}

function adjustNodeRange(node) {
  if (!node.loc) {
    return node;
  }

const [start, end] = node.range || [node.start, node.end];
  return {
    ...node,
    end: undefined,
    range: [start, end],
    start: undefined,
  };
}

function adjustNodeRangeRecursively(node) {
  if (Array.isArray(node)) {
    return node.map(adjustNodeRangeRecursively);
  }

if (node && typeof node === 'object') {
    return adjustNodeRange(mapValues(node, adjustNodeRangeRecursively));
  }

return node;
}

function stripConstructors(value) {
  return JSON.parse(JSON.stringify(value));
}

function adjustLocations(node, { keyOffset, valueOffset }) {
  const hasExpression = !!node.value.expression;
  return {
    ...adjustNodeLocations(node, {
      startOffset: keyOffset,
      endOffset: valueOffset + (hasExpression ? 1 : 0),
    }),
    name: adjustNodeLocations(node.name, { startOffset: keyOffset, endOffset: keyOffset }),
    value: {
      ...adjustNodeLocations(node.value, {
        startOffset: valueOffset - (hasExpression ? 1 : 0),
        endOffset: valueOffset + (hasExpression ? 1 : 0),
      }),
      ...(hasExpression
        ? {
          expression: adjustLocationsRecursively(
            node.value.expression,
            { startOffset: valueOffset, endOffset: valueOffset },
          ),
        }
        : {}
      ),
    },
  };
}

function adjustNodeLocations(node, { startOffset, endOffset }) {
  if (!node.loc) {
    return node;
  }

const [start, end] = node.range || [];
  return {
    ...node,
    end: undefined,
    loc: {
      ...node.loc,
      start: {
        ...node.loc.start,
        column: node.loc.start.column + startOffset,
      },
      end: {
        ...node.loc.end,
        column: node.loc.end.column + endOffset,
      },
    },
    range: [start + startOffset, end + endOffset],
    start: undefined,
  };
}

function adjustLocationsRecursively(node, { startOffset, endOffset }) {
  if (Array.isArray(node)) {
    return node.map((x) => adjustLocationsRecursively(x, { startOffset, endOffset }));
  }
  if (node && typeof node === 'object') {
    return adjustNodeLocations(
      mapValues(node, (x) => adjustLocationsRecursively(x, { startOffset, endOffset })),
      { startOffset, endOffset },
    );
  }

return node;
}

function mapValues(o, f) {
  return fromEntries(entries(o).map(([k, v]) => [k, f(v)]));
}
PK�������Y[KG<љ�������__tests__/src/index-test.jsnu�ȯ����������/* eslint-env mocha */
import fs from 'fs';
import path from 'path';
import assert from 'assert';
import core from '../../src/index';

const src = fs.readdirSync(path.resolve(__dirname, '../../src'))
  .filter((f) => f.indexOf('.js') >= 0)
  .map((f) => path.basename(f, '.js'));

describe('main export', () => {
  it('should export an object', () => {
    const expected = 'object';
    const actual = typeof core;

assert.equal(actual, expected);
  });

src.filter((f) => f !== 'index').forEach((f) => {
    it(`should export ${f}`, () => {
      assert.equal(
        core[f],
        require(path.join('../../src/', f)).default // eslint-disable-line
      );
    });

it(`should export ${f} from root`, () => {
      const file = `${f}.js`;
      const expected = true;
      const actual = fs.statSync(path.join(path.resolve('.'), file)).isFile();

assert.equal(actual, expected);
    });
  });
});
PK�������Y[.$�X���X���.��__tests__/src/getPropValue-babelparser-test.jsnu�ȯ����������/* eslint-env mocha */
/* eslint no-template-curly-in-string: 0 */
import assert from 'assert';
import {
  extractProp,
  changePlugins,
  fallbackToBabylon,
  describeIfNotBabylon,
  setParserName,
} from '../helper';
import getPropValue from '../../src/getPropValue';

describe('getPropValue', () => {
  beforeEach(() => {
    setParserName('babel');
  });

it('should export a function', () => {
    const expected = 'function';
    const actual = typeof getPropValue;

assert.equal(actual, expected);
  });

it('should return undefined when not provided with a JSXAttribute', () => {
    const expected = undefined;
    const actual = getPropValue(1);

assert.equal(actual, expected);
  });

it('should not throw error when trying to get value from unknown node type', () => {
    const prop = {
      type: 'JSXAttribute',
      value: {
        type: 'JSXExpressionContainer',
      },
    };
    let counter = 0;
    // eslint-disable-next-line no-console
    const errorOrig = console.error;
    // eslint-disable-next-line no-console
    console.error = () => {
      counter += 1;
    };
    let value;
    assert.doesNotThrow(() => {
      value = getPropValue(prop);
    }, Error);

assert.equal(null, value);
    assert.equal(counter, 1);
    // eslint-disable-next-line no-console
    console.error = errorOrig;
  });

describe('Null', () => {
    it('should return true when no value is given', () => {
      const prop = extractProp('<div foo />');

const expected = true;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Literal', () => {
    it('should return correct string if value is a string', () => {
      const prop = extractProp('<div foo="bar" />');

const expected = 'bar';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return correct string if value is a string expression', () => {
      const prop = extractProp('<div foo={"bar"} />');

const expected = 'bar';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return correct integer if value is a integer expression', () => {
      const prop = extractProp('<div foo={1} />');

const expected = 1;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "true" to boolean type', () => {
      const prop = extractProp('<div foo="true" />');

const expected = true;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "false" to boolean type', () => {
      const prop = extractProp('<div foo="false" />');

const expected = false;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('JSXElement', () => {
    it('should return correct representation of JSX element as a string', () => {
      const prop = extractProp('<div foo={<bar />} />');

const expected = '<bar />';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return correct representation of JSX element with children as a string', () => {
      const prop = extractProp('<div foo={<bar><baz />foo</bar>} />');

const expected = '<bar><baz />foo</bar>';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

(fallbackToBabylon ? describe.skip : describe)('JSXFragment', () => {
    it('should return correct representation of JSX fragment as a string', () => {
      const prop = extractProp('<div foo={<></>} />');

const expected = '<></>';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return correct representation of JSX fragment with children as a string', () => {
      const prop = extractProp('<div foo={<><div />abc</>} />');

const expected = '<><div />abc</>';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Identifier', () => {
    it('should return string representation of variable identifier', () => {
      const prop = extractProp('<div foo={bar} />');

const expected = 'bar';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when identifier is literally `undefined`', () => {
      const prop = extractProp('<div foo={undefined} />');

const expected = undefined;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return String object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={String} />');

const expected = String;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Array object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Array} />');

const expected = Array;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Date object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Date} />');

const expected = Date;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Infinity object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Infinity} />');

const expected = Infinity;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Math object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Math} />');

const expected = Math;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Number object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Number} />');

const expected = Number;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Object object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Object} />');

const expected = Object;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Template literal', () => {
    it('should return template literal with vars wrapped in curly braces', () => {
      const prop = extractProp('<div foo={`bar ${baz}`} />');

const expected = 'bar {baz}';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string "undefined" for expressions that evaluate to undefined', () => {
      const prop = extractProp('<div foo={`bar ${undefined}`} />');

const expected = 'bar undefined';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return template literal with expression type wrapped in curly braces', () => {
      const prop = extractProp('<div foo={`bar ${baz()}`} />');

const expected = 'bar {CallExpression}';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should ignore non-expressions in the template literal', () => {
      const prop = extractProp('<div foo={`bar ${<baz />}`} />');

const expected = 'bar ';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Tagged Template literal', () => {
    it('should return template literal with vars wrapped in curly braces', () => {
      const prop = extractProp('<div foo={noop`bar ${baz}`} />');

const expected = 'bar {baz}';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string "undefined" for expressions that evaluate to undefined', () => {
      const prop = extractProp('<div foo={noop`bar ${undefined}`} />');

const expected = 'bar undefined';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return template literal with expression type wrapped in curly braces', () => {
      const prop = extractProp('<div foo={noop`bar ${baz()}`} />');

const expected = 'bar {CallExpression}';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should ignore non-expressions in the template literal', () => {
      const prop = extractProp('<div foo={noop`bar ${<baz />}`} />');

const expected = 'bar ';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Arrow function expression', () => {
    it('should return a function', () => {
      const prop = extractProp('<div foo={ () => { return "bar"; }} />');

const expected = 'function';
      const actual = getPropValue(prop);

assert.equal(expected, typeof actual);

// For code coverage ¯\_(ツ)_/¯
      actual();
    });
    it('should handle ArrowFunctionExpression as conditional consequent', () => {
      const prop = extractProp('<div foo={ (true) ? () => null : () => ({})} />');

const expected = 'function';
      const actual = getPropValue(prop);

assert.equal(expected, typeof actual);

// For code coverage ¯\_(ツ)_/¯
      actual();
    });
  });

describe('Function expression', () => {
    it('should return a function', () => {
      const prop = extractProp('<div foo={ function() { return "bar"; } } />');

const expected = 'function';
      const actual = getPropValue(prop);

assert.equal(expected, typeof actual);

// For code coverage ¯\_(ツ)_/¯
      actual();
    });
  });

describe('Logical expression', () => {
    it('should correctly infer result of && logical expression based on derived values', () => {
      const prop = extractProp('<div foo={bar && baz} />');

const expected = 'baz';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when evaluating `undefined && undefined` ', () => {
      const prop = extractProp('<div foo={undefined && undefined} />');

const expected = undefined;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly infer result of || logical expression based on derived values', () => {
      const prop = extractProp('<div foo={bar || baz} />');

const expected = 'bar';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly infer result of || logical expression based on derived values', () => {
      const prop = extractProp('<div foo={undefined || baz} />');

const expected = 'baz';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when evaluating `undefined || undefined` ', () => {
      const prop = extractProp('<div foo={undefined || undefined} />');

const expected = undefined;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly infer result of ?? logical expression based on derived values', () => {
      const runTest = () => {
        const prop = extractProp('<div foo={bar ?? baz} />');

const expected = 'bar';
        const actual = getPropValue(prop);

assert.equal(actual, expected);
      };

if (fallbackToBabylon) {
        // eslint-disable-next-line no-undef
        expect(runTest).toThrow();
      } else {
        runTest();
      }
    });

it('should correctly infer result of ?? logical expression based on derived values', () => {
      const runTest = () => {
        const prop = extractProp('<div foo={undefined ?? baz} />');

const expected = 'baz';
        const actual = getPropValue(prop);

assert.equal(actual, expected);
      };

if (fallbackToBabylon) {
        // eslint-disable-next-line no-undef
        expect(runTest).toThrow();
      } else {
        runTest();
      }
    });

it('should return undefined when evaluating `undefined ?? undefined` ', () => {
      const runTest = () => {
        const prop = extractProp('<div foo={undefined ?? undefined} />');

const expected = undefined;
        const actual = getPropValue(prop);

assert.equal(actual, expected);
      };

if (fallbackToBabylon) {
        // eslint-disable-next-line no-undef
        expect(runTest).toThrow();
      } else {
        runTest();
      }
    });

it('should return undefined when evaluating `null ?? undefined` ', () => {
      const runTest = () => {
        const prop = extractProp('<div foo={null ?? undefined} />');

const expected = undefined;
        const actual = getPropValue(prop);

assert.equal(actual, expected);
      };

if (fallbackToBabylon) {
        // eslint-disable-next-line no-undef
        expect(runTest).toThrow();
      } else {
        runTest();
      }
    });

it('should return undefined when evaluating `undefined ?? null` ', () => {
      const runTest = () => {
        const prop = extractProp('<div foo={undefined ?? null} />');

const expected = null;
        const actual = getPropValue(prop);

assert.equal(actual, expected);
      };

if (fallbackToBabylon) {
        // eslint-disable-next-line no-undef
        expect(runTest).toThrow();
      } else {
        runTest();
      }
    });

it('should return null when evaluating `null ?? null` ', () => {
      const runTest = () => {
        const prop = extractProp('<div foo={null ?? null} />');

const expected = null;
        const actual = getPropValue(prop);

assert.equal(actual, expected);
      };

if (fallbackToBabylon) {
        // eslint-disable-next-line no-undef
        expect(runTest).toThrow();
      } else {
        runTest();
      }
    });
  });

describe('Member expression', () => {
    it('should return string representation of form `object.property`', () => {
      const prop = extractProp('<div foo={bar.baz} />');

const expected = 'bar.baz';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate to a correct representation of member expression with a nullable member', () => {
      const runTest = () => {
        const prop = extractProp('<div foo={bar?.baz} />');

const expected = 'bar?.baz';
        const actual = getPropValue(prop);

assert.equal(actual, expected);
      };

if (fallbackToBabylon) {
        // eslint-disable-next-line no-undef
        expect(runTest).toThrow();
      } else {
        runTest();
      }
    });

it('should evaluate to a correct representation of optional call expression', () => {
      const runTest = () => {
        const prop = extractProp('<div foo={bar.baz?.(quux)} />');

const expected = 'bar.baz?.(quux)';
        const actual = getPropValue(prop);

assert.equal(actual, expected);
      };

if (fallbackToBabylon) {
        // eslint-disable-next-line no-undef
        expect(runTest).toThrow();
      } else {
        runTest();
      }
    });
  });

describe('Call expression', () => {
    it('should return string representation of callee', () => {
      const prop = extractProp('<div foo={bar()} />');

const expected = 'bar()';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string representation of callee', () => {
      const prop = extractProp('<div foo={bar.call()} />');

const expected = 'bar.call()';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Unary expression', () => {
    it('should correctly evaluate an expression that prefixes with -', () => {
      const prop = extractProp('<div foo={-bar} />');

// -"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with -', () => {
      const prop = extractProp('<div foo={-42} />');

const expected = -42;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with +', () => {
      const prop = extractProp('<div foo={+bar} />');

// +"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with +', () => {
      const prop = extractProp('<div foo={+42} />');

const expected = 42;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with !', () => {
      const prop = extractProp('<div foo={!bar} />');

const expected = false; // !"bar" === false
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with ~', () => {
      const prop = extractProp('<div foo={~bar} />');

const expected = -1; // ~"bar" === -1
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return true when evaluating `delete foo`', () => {
      const prop = extractProp('<div foo={delete x} />');

const expected = true;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when evaluating `void foo`', () => {
      const prop = extractProp('<div foo={void x} />');

const expected = undefined;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

// TODO: We should fix this to check to see if we can evaluate it.
    it('should return undefined when evaluating `typeof foo`', () => {
      const prop = extractProp('<div foo={typeof x} />');

const expected = undefined;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Update expression', () => {
    it('should correctly evaluate an expression that prefixes with ++', () => {
      const prop = extractProp('<div foo={++bar} />');

// ++"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with --', () => {
      const prop = extractProp('<div foo={--bar} />');

const expected = true;
      const actual = Number.isNaN(getPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that suffixes with ++', () => {
      const prop = extractProp('<div foo={bar++} />');

// "bar"++ => NaN
      const expected = true;
      const actual = Number.isNaN(getPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that suffixes with --', () => {
      const prop = extractProp('<div foo={bar--} />');

const expected = true;
      const actual = Number.isNaN(getPropValue(prop));

assert.equal(actual, expected);
    });
  });

describe('This expression', () => {
    it('should return string value `this`', () => {
      const prop = extractProp('<div foo={this} />');

const expected = 'this';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Conditional expression', () => {
    it('should evaluate the conditional based on the derived values correctly', () => {
      const prop = extractProp('<div foo={bar ? baz : bam} />');

const expected = 'baz';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the conditional based on the derived values correctly', () => {
      const prop = extractProp('<div foo={undefined ? baz : bam} />');

const expected = 'bam';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the conditional based on the derived values correctly', () => {
      const prop = extractProp('<div foo={(1 > 2) ? baz : bam} />');

const expected = 'bam';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Binary expression', () => {
    it('should evaluate the `==` operator correctly', () => {
      const trueProp = extractProp('<div foo={1 == "1"} />');
      const falseProp = extractProp('<div foo={1 == bar} />');

const trueVal = getPropValue(trueProp);
      const falseVal = getPropValue(falseProp);

assert.equal(true, trueVal);
      assert.equal(false, falseVal);
    });

it('should evaluate the `!=` operator correctly', () => {
      const trueProp = extractProp('<div foo={1 != "2"} />');
      const falseProp = extractProp('<div foo={1 != "1"} />');

const trueVal = getPropValue(trueProp);
      const falseVal = getPropValue(falseProp);

assert.equal(true, trueVal);
      assert.equal(false, falseVal);
    });

it('should evaluate the `===` operator correctly', () => {
      const trueProp = extractProp('<div foo={1 === 1} />');
      const falseProp = extractProp('<div foo={1 === "1"} />');

const trueVal = getPropValue(trueProp);
      const falseVal = getPropValue(falseProp);

assert.equal(true, trueVal);
      assert.equal(false, falseVal);
    });

it('should evaluate the `!==` operator correctly', () => {
      const trueProp = extractProp('<div foo={1 !== "1"} />');
      const falseProp = extractProp('<div foo={1 !== 1} />');

const trueVal = getPropValue(trueProp);
      const falseVal = getPropValue(falseProp);

assert.equal(true, trueVal);
      assert.equal(false, falseVal);
    });

it('should evaluate the `<` operator correctly', () => {
      const trueProp = extractProp('<div foo={1 < 2} />');
      const falseProp = extractProp('<div foo={1 < 0} />');

const trueVal = getPropValue(trueProp);
      const falseVal = getPropValue(falseProp);

assert.equal(true, trueVal);
      assert.equal(false, falseVal);
    });

it('should evaluate the `>` operator correctly', () => {
      const trueProp = extractProp('<div foo={1 > 0} />');
      const falseProp = extractProp('<div foo={1 > 2} />');

const trueVal = getPropValue(trueProp);
      const falseVal = getPropValue(falseProp);

assert.equal(true, trueVal);
      assert.equal(false, falseVal);
    });

it('should evaluate the `<=` operator correctly', () => {
      const trueProp = extractProp('<div foo={1 <= 1} />');
      const falseProp = extractProp('<div foo={1 <= 0} />');

const trueVal = getPropValue(trueProp);
      const falseVal = getPropValue(falseProp);

assert.equal(true, trueVal);
      assert.equal(false, falseVal);
    });

it('should evaluate the `>=` operator correctly', () => {
      const trueProp = extractProp('<div foo={1 >= 1} />');
      const falseProp = extractProp('<div foo={1 >= 2} />');

const trueVal = getPropValue(trueProp);
      const falseVal = getPropValue(falseProp);

assert.equal(true, trueVal);
      assert.equal(false, falseVal);
    });

it('should evaluate the `<<` operator correctly', () => {
      const prop = extractProp('<div foo={1 << 2} />');

const expected = 4;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `>>` operator correctly', () => {
      const prop = extractProp('<div foo={1 >> 2} />');

const expected = 0;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `>>>` operator correctly', () => {
      const prop = extractProp('<div foo={2 >>> 1} />');

const expected = 1;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `+` operator correctly', () => {
      const prop = extractProp('<div foo={1 + 1} />');

const expected = 2;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `-` operator correctly', () => {
      const prop = extractProp('<div foo={1 - 1} />');

const expected = 0;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `*` operator correctly', () => {
      const prop = extractProp('<div foo={10 * 10} />');

const expected = 100;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `/` operator correctly', () => {
      const prop = extractProp('<div foo={10 / 2} />');

const expected = 5;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `%` operator correctly', () => {
      const prop = extractProp('<div foo={10 % 3} />');

const expected = 1;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `|` operator correctly', () => {
      const prop = extractProp('<div foo={10 | 1} />');

const expected = 11;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `^` operator correctly', () => {
      const prop = extractProp('<div foo={10 ^ 1} />');

const expected = 11;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `&` operator correctly', () => {
      const prop = extractProp('<div foo={10 & 1} />');

const expected = 0;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `in` operator correctly', () => {
      const prop = extractProp('<div foo={foo in bar} />');

const expected = false;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `instanceof` operator correctly', () => {
      const prop = extractProp('<div foo={{} instanceof Object} />');

const expected = true;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate the `instanceof` operator when right side is not a function', () => {
      const prop = extractProp('<div foo={"bar" instanceof Baz} />');

const expected = false;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Object expression', () => {
    it('should evaluate to a correct representation of the object in props', () => {
      const prop = extractProp('<div foo={ { bar: "baz" } } />');

const expected = { bar: 'baz' };
      const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
    });

it('should evaluate to a correct representation of the object, ignore spread properties', () => {
      const prop = extractProp('<div foo={{bar: "baz", ...{baz: "bar", foo: {...{bar: "meh"}}}}} />');

const expected = { bar: 'baz', baz: 'bar', foo: { bar: 'meh' } };
      const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
    });

it('should evaluate to a correct representation of the object, ignore spread properties', () => {
      const prop = extractProp('<div foo={{ pathname: manageRoute, state: {...data}}} />');

const expected = { pathname: 'manageRoute', state: {} };
      const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

describe('New expression', () => {
    it('should return a new empty object', () => {
      const prop = extractProp('<div foo={new Bar()} />');

const expected = {};
      const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

describe('Array expression', () => {
    it('should evaluate to correct representation of the the array in props', () => {
      const prop = extractProp('<div foo={["bar", 42, , null]} />');

const expected = ['bar', 42, undefined, null];
      const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
    });

it('should evaluate to a correct representation of an array with spread elements', () => {
      const prop = extractProp('<div foo={[...this.props.params, bar]} />');

const expected = [undefined, 'bar'];
      const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

it('should return an empty array provided an empty array in props', () => {
    const prop = extractProp('<div foo={[]} />');

const expected = [];
    const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
  });

describe('Bind expression', () => {
    it('should return string representation of bind function call when object is null', () => {
      const prop = extractProp('<div foo={::this.handleClick} />');

const expected = 'this.handleClick.bind(this)';
      const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
    });

it('should return string representation of bind function call when object is not null', () => {
      const prop = extractProp('<div foo={foo::bar} />');

const expected = 'bar.bind(foo)';
      const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
    });

it('should return string representation of bind function call when binding to object properties', () => {
      const prop = extractProp('<div foo={a.b::c} />');
      const otherProp = extractProp('<div foo={::a.b.c} />');

const expected = 'a.b.c.bind(a.b)';
      const actual = getPropValue(prop);

const otherExpected = 'a.b.c.bind(a.b)';
      const otherActual = getPropValue(otherProp);

assert.deepEqual(actual, expected);
      assert.deepEqual(otherExpected, otherActual);
    });
  });

describe('Type Cast Expression', () => {
    it('should throw a parsing error', () => {
      let counter = 0;
      // eslint-disable-next-line no-console
      const warnOrig = console.warn;
      // eslint-disable-next-line no-console
      console.warn = () => {
        counter += 1;
      };
      // eslint-disable-next-line no-undef
      expect(() => {
        extractProp('<div foo={(this.handleClick: (event: MouseEvent) => void))} />');
      }).toThrow();
      assert.equal(counter, 1);
      // eslint-disable-next-line no-console
      console.warn = warnOrig;
    });
  });

describe('AssignmentExpression', () => {
    it('should recognize and extract assignment', () => {
      const prop = extractProp('<div foo={foo = bar} />');

const expected = 'foo = bar';
      const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
    });

it('should recognize and extract combination assignments', () => {
      const prop = extractProp('<div foo={foo += bar} />');

const expected = 'foo += bar';
      const actual = getPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

describeIfNotBabylon('Typescript', () => {
    beforeEach(() => {
      changePlugins((pls) => [...pls, 'typescript']);
    });

it('should return string representation of variable identifier wrapped in a Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={bar!} />');

const expected = 'bar!';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string representation of variable identifier wrapped in a deep Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={(bar!)!} />');

const expected = '(bar!)!';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string representation of variable identifier wrapped in a Typescript type coercion', () => {
      const prop = extractProp('<div foo={bar as any} />');

const expected = 'bar';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describeIfNotBabylon('TSNonNullExpression', () => {
    beforeEach(() => {
      changePlugins((pls) => [...pls, 'typescript']);
    });

it('should return string representation of a TSNonNullExpression of form `variable!`', () => {
      const prop = extractProp('<div foo={bar!} />');
      const expected = 'bar!';
      const actual = getPropValue(prop);
      assert.equal(actual, expected);
    });

it('should return string representation of a TSNonNullExpression of form `object!.property`', () => {
      const prop = extractProp('<div foo={bar!.bar} />');
      const expected = 'bar!.bar';
      const actual = getPropValue(prop);
      assert.equal(actual, expected);
    });

it('should return string representation of a TSNonNullExpression of form `object!.property!`', () => {
      const prop = extractProp('<div foo={bar!.bar!} />');
      const actual = getPropValue(prop);
      const expected = 'bar!.bar!';
      assert.equal(actual, expected);
    });

it('should return string representation of a TSNonNullExpression of form `object.property!`', () => {
      const prop = extractProp('<div foo={bar.bar!} />');
      const actual = getPropValue(prop);
      const expected = 'bar.bar!';
      assert.equal(actual, expected);
    });

it('should return string representation of a TSNonNullExpression of form `object.property.property!`', () => {
      const prop = extractProp('<div foo={bar.bar.bar!} />');
      const actual = getPropValue(prop);
      const expected = 'bar.bar.bar!';
      assert.equal(actual, expected);
    });

it('should return string representation of a TSNonNullExpression of form `object!.property.property!`', () => {
      const prop = extractProp('<div foo={bar!.bar.bar!} />');
      const actual = getPropValue(prop);
      const expected = 'bar!.bar.bar!';
      assert.equal(actual, expected);
    });

it('should return string representation of an object wrapped in a deep Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={(bar!.bar)!} />');
      const expected = '(bar!.bar)!';
      const actual = getPropValue(prop);
      assert.equal(actual, expected);
    });

it('should return string representation of a cast wrapped in a deep Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={(bar as Bar).baz!} />');
      const actual = getPropValue(prop);
      const expected = 'bar.baz!';
      assert.equal(actual, expected);
    });

it('should return string representation of an object wrapped in a deep Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={(bar.bar)!} />');
      const expected = '(bar.bar)!';
      const actual = getPropValue(prop);
      assert.equal(actual, expected);
    });

it('should return string representation of an object wrapped in a deep Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={(bar!.bar.bar!)!} />');
      const expected = '(bar!.bar.bar!)!';
      const actual = getPropValue(prop);
      assert.equal(actual, expected);
    });

it('should return string representation of variable identifier wrapped in a deep Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={(bar!)!} />');
      const expected = '(bar!)!';
      const actual = getPropValue(prop);
      assert.equal(actual, expected);
    });

it('should work with a this.props value', () => {
      const prop = extractProp('<a foo={this.props.href!}>Download</a>');
      const expected = 'this.props.href!';
      const actual = getPropValue(prop);
      assert.equal(actual, expected);
    });

it('should correctly evaluate a bracketed navigation expression that prefixes with !', () => {
      const prop = extractProp('<Link foo={data![0].url} />');

const expected = 'data![0].url';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('works with an optional chain with an `as`', () => {
      const prop = extractProp('<img src={images?.footer as string} />', 'src');

const expected = 'images?.footer';
      const actual = getPropValue(prop, 'src');

assert.equal(actual, expected);
    });
  });

describe('JSX empty expression', () => {
    it('should work with an empty expression', () => {
      const prop = extractProp('<div>\n{/* Hello there */}\n</div>', 'children');
      const expected = undefined;
      const actual = getPropValue(prop);
      assert.equal(actual, expected);
    });
  });
});
PK�������Y[B�\�V��V����__tests__/src/propName-test.jsnu�ȯ����������/* eslint-env mocha */
import assert from 'assert';
import { extractProp, setParserName } from '../helper';
import propName from '../../src/propName';

describe('propName', () => {
  beforeEach(() => {
    setParserName('babel');
  });
  it('should export a function', () => {
    const expected = 'function';
    const actual = typeof propName;

assert.equal(actual, expected);
  });

it('should throw an error if the argument is missing', () => {
    assert.throws(() => { propName(); }, Error);
  });

it('should throw an error if the argument not a JSX node', () => {
    assert.throws(() => { propName({ a: 'foo' }); }, Error);
  });

it('should return correct name for normal prop', () => {
    const prop = extractProp('<div foo="bar" />');

const expected = 'foo';
    const actual = propName(prop);

assert.equal(actual, expected);
  });

it('should return correct name for namespaced prop', () => {
    const prop = extractProp('<div foo:bar="baz" />', 'foo:bar');

const expected = 'foo:bar';
    const actual = propName(prop);

assert.equal(actual, expected);
  });
});
PK�������Y[���N8��N8��4��__tests__/src/getPropLiteralValue-flowparser-test.jsnu�ȯ����������/* eslint-env mocha */
/* eslint no-template-curly-in-string: 0 */
import assert from 'assert';
import {
  extractProp,
  describeIfNotBabylon,
  changePlugins,
  setParserName,
} from '../helper';
import { getLiteralPropValue } from '../../src/getPropValue';

describe('getLiteralPropValue', () => {
  beforeEach(() => {
    setParserName('flow');
  });
  it('should export a function', () => {
    const expected = 'function';
    const actual = typeof getLiteralPropValue;

assert.equal(actual, expected);
  });

it('should return undefined when not provided with a JSXAttribute', () => {
    const expected = undefined;
    const actual = getLiteralPropValue(1);

assert.equal(actual, expected);
  });

assert.equal(null, value);
    assert.equal(counter, 1);
    // eslint-disable-next-line no-console
    console.error = errorOrig;
  });

describe('Null', () => {
    it('should return true when no value is given', () => {
      const prop = extractProp('<div foo />');

const expected = true;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Literal', () => {
    it('should return correct string if value is a string', () => {
      const prop = extractProp('<div foo="bar" />');

const expected = 'bar';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return correct string if value is a string expression', () => {
      const prop = extractProp('<div foo={"bar"} />');

const expected = 'bar';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return correct integer if value is a integer expression', () => {
      const prop = extractProp('<div foo={1} />');

const expected = 1;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "true" to boolean type', () => {
      const prop = extractProp('<div foo="true" />');

const expected = true;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "TrUE" to boolean type', () => {
      const prop = extractProp('<div foo="TrUE" />');

const expected = true;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "false" to boolean type', () => {
      const prop = extractProp('<div foo="false" />');

const expected = false;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "FaLsE" to boolean type', () => {
      const prop = extractProp('<div foo="FaLsE" />');

const expected = false;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return String null when value is null', () => {
      const prop = extractProp('<div foo={null} />');

const expected = 'null';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('JSXElement', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={<bar />} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Identifier', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={bar} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when identifier is literally `undefined`', () => {
      const prop = extractProp('<div foo={undefined} />');

const expected = undefined;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Template literal', () => {
    it('should return template literal with vars wrapped in curly braces', () => {
      const prop = extractProp('<div foo={`bar ${baz}`} />');

const expected = 'bar {baz}';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string "undefined" for expressions that evaluate to undefined', () => {
      const prop = extractProp('<div foo={`bar ${undefined}`} />');

const expected = 'bar undefined';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Tagged Template literal', () => {
    it('should return template literal with vars wrapped in curly braces', () => {
      const prop = extractProp('<div foo={noop`bar ${baz}`} />');

const expected = 'bar {baz}';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string "undefined" for expressions that evaluate to undefined', () => {
      const prop = extractProp('<div foo={noop`bar ${undefined}`} />');

const expected = 'bar undefined';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Arrow function expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={ () => { return "bar"; }} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Function expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={ function() { return "bar"; } } />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Logical expression', () => {
    it('should return null for && operator', () => {
      const prop = extractProp('<div foo={bar && baz} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return null for || operator', () => {
      const prop = extractProp('<div foo={bar || baz} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Member expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={bar.baz} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Call expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={bar()} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Unary expression', () => {
    it('should correctly evaluate an expression that prefixes with -', () => {
      const prop = extractProp('<div foo={-bar} />');

// -"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with -', () => {
      const prop = extractProp('<div foo={-42} />');

const expected = -42;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with +', () => {
      const prop = extractProp('<div foo={+bar} />');

// +"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with +', () => {
      const prop = extractProp('<div foo={+42} />');

const expected = 42;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with !', () => {
      const prop = extractProp('<div foo={!bar} />');

const expected = false; // !"bar" === false
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with ~', () => {
      const prop = extractProp('<div foo={~bar} />');

const expected = -1; // ~"bar" === -1
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return true when evaluating `delete foo`', () => {
      const prop = extractProp('<div foo={delete x} />');

const expected = true;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when evaluating `void foo`', () => {
      const prop = extractProp('<div foo={void x} />');

const expected = undefined;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

// TODO: We should fix this to check to see if we can evaluate it.
    it('should return undefined when evaluating `typeof foo`', () => {
      const prop = extractProp('<div foo={typeof x} />');

const expected = undefined;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Update expression', () => {
    it('should correctly evaluate an expression that prefixes with ++', () => {
      const prop = extractProp('<div foo={++bar} />');

// ++"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with --', () => {
      const prop = extractProp('<div foo={--bar} />');

// --"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that suffixes with ++', () => {
      const prop = extractProp('<div foo={bar++} />');

// "bar"++ => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that suffixes with --', () => {
      const prop = extractProp('<div foo={bar--} />');

// "bar"-- => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });
  });

describe('This expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={this} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Conditional expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={bar ? baz : bam} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Binary expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={1 == "1"} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Object expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={ { bar: "baz" } } />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

describe('New expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={new Bar()} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

describe('Array expression', () => {
    it('should evaluate to correct representation of the the array in props', () => {
      const prop = extractProp('<div foo={["bar", 42, null]} />');

const expected = ['bar', 42];
      const actual = getLiteralPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

it('should return an empty array provided an empty array in props', () => {
    const prop = extractProp('<div foo={[]} />');

const expected = [];
    const actual = getLiteralPropValue(prop);

assert.deepEqual(actual, expected);
  });

describe('Bind expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={::this.handleClick} />');

const expected = 'null';
      const actual = getLiteralPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

describeIfNotBabylon('Typescript', () => {
    beforeEach(() => {
      changePlugins((pls) => [...pls, 'typescript']);
    });

it('should return string representation of variable identifier wrapped in a Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={bar!} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string representation of variable identifier wrapped in a deep Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={(bar!)!} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string representation of variable identifier wrapped in a Typescript type coercion', () => {
      changePlugins((pls) => [...pls, 'typescript']);
      const prop = extractProp('<div foo={bar as any} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });
});
PK�������Y[
��`:��`:��5��__tests__/src/getPropLiteralValue-babelparser-test.jsnu�ȯ����������/* eslint-env mocha */
/* eslint no-template-curly-in-string: 0 */
import assert from 'assert';
import {
  extractProp,
  describeIfNotBabylon,
  changePlugins,
  setParserName,
} from '../helper';
import { getLiteralPropValue } from '../../src/getPropValue';

describe('getLiteralPropValue', () => {
  beforeEach(() => {
    setParserName('babel');
  });
  it('should export a function', () => {
    const expected = 'function';
    const actual = typeof getLiteralPropValue;

assert.equal(actual, expected);
  });

it('should return undefined when not provided with a JSXAttribute', () => {
    const expected = undefined;
    const actual = getLiteralPropValue(1);

assert.equal(actual, expected);
  });

assert.equal(null, value);
    assert.equal(counter, 1);
    // eslint-disable-next-line no-console
    console.error = errorOrig;
  });

describe('Null', () => {
    it('should return true when no value is given', () => {
      const prop = extractProp('<div foo />');

const expected = true;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Literal', () => {
    it('should return correct string if value is a string', () => {
      const prop = extractProp('<div foo="bar" />');

const expected = 'bar';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return correct string if value is a string expression', () => {
      const prop = extractProp('<div foo={"bar"} />');

const expected = 'bar';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return correct integer if value is a integer expression', () => {
      const prop = extractProp('<div foo={1} />');

const expected = 1;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "true" to boolean type', () => {
      const prop = extractProp('<div foo="true" />');

const expected = true;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "TrUE" to boolean type', () => {
      const prop = extractProp('<div foo="TrUE" />');

const expected = true;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "false" to boolean type', () => {
      const prop = extractProp('<div foo="false" />');

const expected = false;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "FaLsE" to boolean type', () => {
      const prop = extractProp('<div foo="FaLsE" />');

const expected = false;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return String null when value is null', () => {
      const prop = extractProp('<div foo={null} />');

const expected = 'null';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('JSXElement', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={<bar />} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Identifier', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={bar} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when identifier is literally `undefined`', () => {
      const prop = extractProp('<div foo={undefined} />');

const expected = undefined;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describeIfNotBabylon('Chain Expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={abc?.def} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Template literal', () => {
    it('should return template literal with vars wrapped in curly braces', () => {
      const prop = extractProp('<div foo={`bar ${baz}`} />');

const expected = 'bar {baz}';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string "undefined" for expressions that evaluate to undefined', () => {
      const prop = extractProp('<div foo={`bar ${undefined}`} />');

const expected = 'bar undefined';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Tagged Template literal', () => {
    it('should return template literal with vars wrapped in curly braces', () => {
      const prop = extractProp('<div foo={noop`bar ${baz}`} />');

const expected = 'bar {baz}';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string "undefined" for expressions that evaluate to undefined', () => {
      const prop = extractProp('<div foo={noop`bar ${undefined}`} />');

const expected = 'bar undefined';
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Arrow function expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={ () => { return "bar"; }} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Function expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={ function() { return "bar"; } } />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Logical expression', () => {
    it('should return null for && operator', () => {
      const prop = extractProp('<div foo={bar && baz} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return null for || operator', () => {
      const prop = extractProp('<div foo={bar || baz} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Member expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={bar.baz} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Call expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={bar()} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Unary expression', () => {
    it('should correctly evaluate an expression that prefixes with -', () => {
      const prop = extractProp('<div foo={-bar} />');

// -"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with -', () => {
      const prop = extractProp('<div foo={-42} />');

const expected = -42;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with +', () => {
      const prop = extractProp('<div foo={+bar} />');

// +"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with +', () => {
      const prop = extractProp('<div foo={+42} />');

const expected = 42;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with !', () => {
      const prop = extractProp('<div foo={!bar} />');

const expected = false; // !"bar" === false
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with ~', () => {
      const prop = extractProp('<div foo={~bar} />');

const expected = -1; // ~"bar" === -1
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return true when evaluating `delete foo`', () => {
      const prop = extractProp('<div foo={delete x} />');

const expected = true;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when evaluating `void foo`', () => {
      const prop = extractProp('<div foo={void x} />');

const expected = undefined;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

// TODO: We should fix this to check to see if we can evaluate it.
    it('should return undefined when evaluating `typeof foo`', () => {
      const prop = extractProp('<div foo={typeof x} />');

const expected = undefined;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Update expression', () => {
    it('should correctly evaluate an expression that prefixes with ++', () => {
      const prop = extractProp('<div foo={++bar} />');

// ++"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that prefixes with --', () => {
      const prop = extractProp('<div foo={--bar} />');

// --"bar" => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that suffixes with ++', () => {
      const prop = extractProp('<div foo={bar++} />');

// "bar"++ => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });

it('should correctly evaluate an expression that suffixes with --', () => {
      const prop = extractProp('<div foo={bar--} />');

// "bar"-- => NaN
      const expected = true;
      const actual = Number.isNaN(getLiteralPropValue(prop));

assert.equal(actual, expected);
    });
  });

describe('This expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={this} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Conditional expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={bar ? baz : bam} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Binary expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={1 == "1"} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Object expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={ { bar: "baz" } } />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

describe('New expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={new Bar()} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

describe('Array expression', () => {
    it('should evaluate to correct representation of the the array in props', () => {
      const prop = extractProp('<div foo={["bar", 42, null]} />');

const expected = ['bar', 42];
      const actual = getLiteralPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

it('should return an empty array provided an empty array in props', () => {
    const prop = extractProp('<div foo={[]} />');

const expected = [];
    const actual = getLiteralPropValue(prop);

assert.deepEqual(actual, expected);
  });

describe('Bind expression', () => {
    it('should return null', () => {
      const prop = extractProp('<div foo={::this.handleClick} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.deepEqual(actual, expected);
    });
  });

describeIfNotBabylon('Typescript', () => {
    beforeEach(() => {
      changePlugins((pls) => [...pls, 'typescript']);
    });

it('should return string representation of variable identifier wrapped in a Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={bar!} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string representation of variable identifier wrapped in a deep Typescript non-null assertion', () => {
      const prop = extractProp('<div foo={(bar!)!} />');

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

const expected = null;
      const actual = getLiteralPropValue(prop);

assert.equal(actual, expected);
    });

it('should work with a this.props value', () => {
      const prop = extractProp('<a href={this.props.href!}>Download</a>');
      const expected = null;
      const actual = getLiteralPropValue(prop);
      assert.equal(actual, expected);
    });
  });
});
PK�������Y[�3��m���m��-��__tests__/src/getPropValue-flowparser-test.jsnu�ȯ����������/* eslint-env mocha */
/* eslint no-template-curly-in-string: 0 */
import assert from 'assert';
import {
  extractProp,
  changePlugins,
  describeIfNotBabylon,
  setParserName,
} from '../helper';
import getPropValue from '../../src/getPropValue';

describe('getPropValue', () => {
  beforeEach(() => {
    setParserName('flow');
  });

it('should export a function', () => {
    const expected = 'function';
    const actual = typeof getPropValue;

assert.equal(actual, expected);
  });

it('should return undefined when not provided with a JSXAttribute', () => {
    const expected = undefined;
    const actual = getPropValue(1);

assert.equal(actual, expected);
  });

it('should throw not error when trying to get value from unknown node type', () => {
    const prop = {
      type: 'JSXAttribute',
      value: {
        type: 'JSXExpressionContainer',
      },
    };
    let counter = 0;
    // eslint-disable-next-line no-console
    const errorOrig = console.error;
    // eslint-disable-next-line no-console
    console.error = () => {
      counter += 1;
    };
    let value;
    assert.doesNotThrow(() => {
      value = getPropValue(prop);
    }, Error);

assert.equal(null, value);
    assert.equal(counter, 1);
    // eslint-disable-next-line no-console
    console.error = errorOrig;
  });

describe('Null', () => {
    it('should return true when no value is given', () => {
      const prop = extractProp('<div foo />');

const expected = true;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Literal', () => {
    it('should return correct string if value is a string', () => {
      const prop = extractProp('<div foo="bar" />');

const expected = 'bar';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return correct string if value is a string expression', () => {
      const prop = extractProp('<div foo={"bar"} />');

const expected = 'bar';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return correct integer if value is a integer expression', () => {
      const prop = extractProp('<div foo={1} />');

const expected = 1;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "true" to boolean type', () => {
      const prop = extractProp('<div foo="true" />');

const expected = true;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should convert "false" to boolean type', () => {
      const prop = extractProp('<div foo="false" />');

const expected = false;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('JSXElement', () => {
    it('should return correct representation of JSX element as a string', () => {
      const prop = extractProp('<div foo={<bar />} />');

const expected = '<bar />';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Identifier', () => {
    it('should return string representation of variable identifier', () => {
      const prop = extractProp('<div foo={bar} />');

const expected = 'bar';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when identifier is literally `undefined`', () => {
      const prop = extractProp('<div foo={undefined} />');

const expected = undefined;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return String object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={String} />');

const expected = String;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Array object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Array} />');

const expected = Array;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Date object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Date} />');

const expected = Date;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Infinity object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Infinity} />');

const expected = Infinity;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Math object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Math} />');

const expected = Math;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Number object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Number} />');

const expected = Number;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return Object object when using a reserved JavaScript object', () => {
      const prop = extractProp('<div foo={Object} />');

const expected = Object;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Template literal', () => {
    it('should return template literal with vars wrapped in curly braces', () => {
      const prop = extractProp('<div foo={`bar ${baz}`} />');

const expected = 'bar {baz}';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string "undefined" for expressions that evaluate to undefined', () => {
      const prop = extractProp('<div foo={`bar ${undefined}`} />');

const expected = 'bar undefined';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return template literal with expression type wrapped in curly braces', () => {
      const prop = extractProp('<div foo={`bar ${baz()}`} />');

const expected = 'bar {CallExpression}';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should ignore non-expressions in the template literal', () => {
      const prop = extractProp('<div foo={`bar ${<baz />}`} />');

const expected = 'bar ';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Tagged Template literal', () => {
    it('should return template literal with vars wrapped in curly braces', () => {
      const prop = extractProp('<div foo={noop`bar ${baz}`} />');

const expected = 'bar {baz}';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return string "undefined" for expressions that evaluate to undefined', () => {
      const prop = extractProp('<div foo={noop`bar ${undefined}`} />');

const expected = 'bar undefined';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return template literal with expression type wrapped in curly braces', () => {
      const prop = extractProp('<div foo={noop`bar ${baz()}`} />');

const expected = 'bar {CallExpression}';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should ignore non-expressions in the template literal', () => {
      const prop = extractProp('<div foo={noop`bar ${<baz />}`} />');

const expected = 'bar ';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Arrow function expression', () => {
    it('should return a function', () => {
      const prop = extractProp('<div foo={ () => { return "bar"; }} />');

const expected = 'function';
      const actual = getPropValue(prop);

assert.equal(expected, typeof actual);

const expected = 'function';
      const actual = getPropValue(prop);

assert.equal(expected, typeof actual);

// For code coverage ¯\_(ツ)_/¯
      actual();
    });
  });

describe('Function expression', () => {
    it('should return a function', () => {
      const prop = extractProp('<div foo={ function() { return "bar"; } } />');

const expected = 'function';
      const actual = getPropValue(prop);

assert.equal(expected, typeof actual);

// For code coverage ¯\_(ツ)_/¯
      actual();
    });
  });

describe('Logical expression', () => {
    it('should correctly infer result of && logical expression based on derived values', () => {
      const prop = extractProp('<div foo={bar && baz} />');

const expected = 'baz';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when evaluating `undefined && undefined` ', () => {
      const prop = extractProp('<div foo={undefined && undefined} />');

const expected = undefined;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly infer result of || logical expression based on derived values', () => {
      const prop = extractProp('<div foo={bar || baz} />');

const expected = 'bar';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should correctly infer result of || logical expression based on derived values', () => {
      const prop = extractProp('<div foo={undefined || baz} />');

const expected = 'baz';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should return undefined when evaluating `undefined || undefined` ', () => {
      const prop = extractProp('<div foo={undefined || undefined} />');

const expected = undefined;
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });
  });

describe('Member expression', () => {
    it('should return string representation of form `object.property`', () => {
      const prop = extractProp('<div foo={bar.baz} />');

const expected = 'bar.baz';
      const actual = getPropValue(prop);

assert.equal(actual, expected);
    });

it('should evaluate to a correct representation of member expression with a nullable member', () => {
      const prop = extractProp('<div foo={bar?.baz} />');

const expected = 'bar?.baz';
      const actual = getPropValue(prop);