Izmjenjena struktura, dodan backand

web/node_modules/jsx-ast-utils/__tests__/src/elementType-test.js

@@ -0,0 +1,82 @@
+/* eslint-env mocha */
+import assert from 'assert';
+import { getOpeningElement } from '../helper';
+import elementType from '../../src/elementType';
+
+describe('elementType tests', () => {
+  it('should export a function', () => {
+    const expected = 'function';
+    const actual = typeof elementType;
+
+    assert.equal(expected, actual);
+  });
+
+  it('should throw an error if the argument is missing', () => {
+    assert.throws(() => { elementType(); }, Error);
+  });
+
+  it('should throw an error if the argument not a JSX node', () => {
+    assert.throws(() => { elementType({ a: 'foo' }); }, Error);
+  });
+
+  it('should return the correct type of the DOM element given its node object', () => {
+    const code = '<div />';
+    const node = getOpeningElement(code);
+
+    const expected = 'div';
+    const actual = elementType(node);
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return the correct type of the custom element given its node object', () => {
+    const code = '<Slider />';
+    const node = getOpeningElement(code);
+
+    const expected = 'Slider';
+    const actual = elementType(node);
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return the correct type of the custom object element given its node object', () => {
+    const code = '<UX.Slider />';
+    const node = getOpeningElement(code);
+
+    const expected = 'UX.Slider';
+    const actual = elementType(node);
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return the correct type of the namespaced element given its node object', () => {
+    const code = '<UX:Slider />';
+    const node = getOpeningElement(code);
+
+    const expected = 'UX:Slider';
+    const actual = elementType(node);
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return the correct type of the multiple custom object element given its node object',
+    () => {
+      const code = '<UX.Slider.Blue.Light />';
+      const node = getOpeningElement(code);
+
+      const expected = 'UX.Slider.Blue.Light';
+      const actual = elementType(node);
+
+      assert.equal(expected, actual);
+    });
+
+  it('should return this.Component when given its node object', () => {
+    const code = '<this.Component />';
+    const node = getOpeningElement(code);
+
+    const expected = 'this.Component';
+    const actual = elementType(node);
+
+    assert.equal(expected, actual);
+  });
+});

web/node_modules/jsx-ast-utils/__tests__/src/eventHandlers-test.js

@@ -0,0 +1,100 @@
+/* eslint-env mocha */
+import assert from 'assert';
+import eventHandlers, { eventHandlersByType } from '../../src/eventHandlers';
+
+describe('eventHandlers', () => {
+  it('should contain a list of common JSX event handlers', () => {
+    assert([
+      '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',
+    ].every(handlerName => eventHandlers.includes(handlerName)));
+  });
+});
+
+describe('eventHandlersByType', () => {
+  it('should be keyed by type', () => {
+    assert([
+      'clipboard',
+      'composition',
+      'keyboard',
+      'focus',
+      'form',
+      'mouse',
+      'selection',
+      'touch',
+      'ui',
+      'wheel',
+      'media',
+      'image',
+      'animation',
+      'transition',
+    ].every(type => !!eventHandlersByType[type]));
+  });
+});

web/node_modules/jsx-ast-utils/__tests__/src/getProp-test.js

@@ -0,0 +1,71 @@
+/* eslint-env mocha */
+import assert from 'assert';
+import { getOpeningElement } from '../helper';
+import getProp from '../../src/getProp';
+
+describe('getProp', () => {
+  it('should export a function', () => {
+    const expected = 'function';
+    const actual = typeof getProp;
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return undefined if no arguments are provided', () => {
+    const expected = undefined;
+    const actual = getProp();
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return undefined if the attribute is absent', () => {
+    const code = '<div />';
+    const node = getOpeningElement(code);
+    const { attributes: props } = node;
+    const prop = 'id';
+
+    const expected = undefined;
+    const actual = getProp(props, prop);
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return the correct attribute if the attribute exists', () => {
+    const code = '<div id="foo" />';
+    const node = getOpeningElement(code);
+    const { attributes: props } = node;
+    const prop = 'id';
+
+    const expected = 'id';
+    const actual = getProp(props, prop).name.name;
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return undefined if the attribute may exist in spread', () => {
+    const code = '<div {...props} />';
+    const node = getOpeningElement(code);
+    const { attributes: props } = node;
+    const prop = 'id';
+
+    const expected = undefined;
+    const actual = getProp(props, prop);
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return undefined if the attribute 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 = undefined;
+    const actual = getProp(props, prop, options);
+
+    assert.equal(expected, actual);
+  });
+});

web/node_modules/jsx-ast-utils/__tests__/src/getPropLiteralValue-test.js

@@ -0,0 +1,457 @@
+/* eslint-env mocha */
+/* eslint no-template-curly-in-string: 0 */
+import assert from 'assert';
+import { extractProp } from '../helper';
+import { getLiteralPropValue } from '../../src/getPropValue';
+
+describe('getLiteralPropValue', () => {
+  it('should export a function', () => {
+    const expected = 'function';
+    const actual = typeof getLiteralPropValue;
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return undefined when not provided with a JSXAttribute', () => {
+    const expected = undefined;
+    const actual = getLiteralPropValue(1);
+
+    assert.equal(expected, actual);
+  });
+
+  it('should throw error when trying to get value from unknown node type', () => {
+    const prop = {
+      type: 'JSXAttribute',
+      value: {
+        type: 'JSXExpressionContainer',
+      },
+    };
+
+    assert.throws(() => {
+      getLiteralPropValue(prop);
+    }, Error);
+  });
+
+  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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    it('should convert "true" to boolean type', () => {
+      const prop = extractProp('<div foo="true" />');
+
+      const expected = true;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should convert "TrUE" to boolean type', () => {
+      const prop = extractProp('<div foo="TrUE" />');
+
+      const expected = true;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should convert "false" to boolean type', () => {
+      const prop = extractProp('<div foo="false" />');
+
+      const expected = false;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should convert "FaLsE" to boolean type', () => {
+      const prop = extractProp('<div foo="FaLsE" />');
+
+      const expected = false;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should return String null when value is null', () => {
+      const prop = extractProp('<div foo={null} />');
+
+      const expected = 'null';
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('JSXElement', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo=<bar /> />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('Identifier', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo={bar} />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should return undefined when identifier is literally `undefined`', () => {
+      const prop = extractProp('<div foo={undefined} />');
+
+      const expected = undefined;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    it('should drop variables in template literals that are literally undefined', () => {
+      const prop = extractProp('<div foo={`bar ${undefined}`} />');
+
+      const expected = 'bar ';
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    it('should drop variables in template literals that are literally undefined', () => {
+      const prop = extractProp('<div foo={noop`bar ${undefined}`} />');
+
+      const expected = 'bar ';
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('Arrow function expression', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo={ () => { return "bar"; }} />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('Function expression', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo={ function() { return "bar"; } } />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    it('should return null for || operator', () => {
+      const prop = extractProp('<div foo={bar || baz} />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('Member expression', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo={bar.baz} />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('Call expression', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo={bar()} />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  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 = isNaN(getLiteralPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that prefixes with -', () => {
+      const prop = extractProp('<div foo={-42} />');
+
+      const expected = -42;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that prefixes with +', () => {
+      const prop = extractProp('<div foo={+bar} />');
+
+      // +"bar" => NaN
+      const expected = true;
+      const actual = isNaN(getLiteralPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that prefixes with +', () => {
+      const prop = extractProp('<div foo={+42} />');
+
+      const expected = 42;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    it('should return true when evaluating `delete foo`', () => {
+      const prop = extractProp('<div foo={delete x} />');
+
+      const expected = true;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should return undefined when evaluating `void foo`', () => {
+      const prop = extractProp('<div foo={void x} />');
+
+      const expected = undefined;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    // 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(expected, actual);
+    });
+  });
+
+  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 = isNaN(getLiteralPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that prefixes with --', () => {
+      const prop = extractProp('<div foo={--bar} />');
+
+      // --"bar" => NaN
+      const expected = true;
+      const actual = isNaN(getLiteralPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that suffixes with ++', () => {
+      const prop = extractProp('<div foo={bar++} />');
+
+      // "bar"++ => NaN
+      const expected = true;
+      const actual = isNaN(getLiteralPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that suffixes with --', () => {
+      const prop = extractProp('<div foo={bar--} />');
+
+      // "bar"-- => NaN
+      const expected = true;
+      const actual = isNaN(getLiteralPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('This expression', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo={this} />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('Conditional expression', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo={bar ? baz : bam} />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('Binary expression', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo={1 == "1"} />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('Object expression', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo={ { bar: "baz" } } />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.deepEqual(expected, actual);
+    });
+  });
+
+  describe('New expression', () => {
+    it('should return null', () => {
+      const prop = extractProp('<div foo={new Bar()} />');
+
+      const expected = null;
+      const actual = getLiteralPropValue(prop);
+
+      assert.deepEqual(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+  });
+});

web/node_modules/jsx-ast-utils/__tests__/src/getPropValue-test.js

@@ -0,0 +1,803 @@
+/* eslint-env mocha */
+/* eslint no-template-curly-in-string: 0 */
+import assert from 'assert';
+import { extractProp } from '../helper';
+import getPropValue from '../../src/getPropValue';
+
+describe('getPropValue', () => {
+  it('should export a function', () => {
+    const expected = 'function';
+    const actual = typeof getPropValue;
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return undefined when not provided with a JSXAttribute', () => {
+    const expected = undefined;
+    const actual = getPropValue(1);
+
+    assert.equal(expected, actual);
+  });
+
+  it('should throw error when trying to get value from unknown node type', () => {
+    const prop = {
+      type: 'JSXAttribute',
+      value: {
+        type: 'JSXExpressionContainer',
+      },
+    };
+
+    assert.throws(() => {
+      getPropValue(prop);
+    }, Error);
+  });
+
+  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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    it('should convert "true" to boolean type', () => {
+      const prop = extractProp('<div foo="true" />');
+
+      const expected = true;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should convert "false" to boolean type', () => {
+      const prop = extractProp('<div foo="false" />');
+
+      const expected = false;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    it('should return undefined when identifier is literally `undefined`', () => {
+      const prop = extractProp('<div foo={undefined} />');
+
+      const expected = undefined;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    it('should drop variables in template literals that are literally undefined', () => {
+      const prop = extractProp('<div foo={`bar ${undefined}`} />');
+
+      const expected = 'bar ';
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    it('should drop variables in template literals that are literally undefined', () => {
+      const prop = extractProp('<div foo={noop`bar ${undefined}`} />');
+
+      const expected = 'bar ';
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    it('should return undefined when evaluating `undefined && undefined` ', () => {
+      const prop = extractProp('<div foo={undefined && undefined} />');
+
+      const expected = undefined;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    it('should return undefined when evaluating `undefined || undefined` ', () => {
+      const prop = extractProp('<div foo={undefined || undefined} />');
+
+      const expected = undefined;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    it('should return string representation of callee', () => {
+      const prop = extractProp('<div foo={bar.call()} />');
+
+      const expected = 'bar.call';
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  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 = isNaN(getPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that prefixes with -', () => {
+      const prop = extractProp('<div foo={-42} />');
+
+      const expected = -42;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that prefixes with +', () => {
+      const prop = extractProp('<div foo={+bar} />');
+
+      // +"bar" => NaN
+      const expected = true;
+      const actual = isNaN(getPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that prefixes with +', () => {
+      const prop = extractProp('<div foo={+42} />');
+
+      const expected = 42;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    it('should return true when evaluating `delete foo`', () => {
+      const prop = extractProp('<div foo={delete x} />');
+
+      const expected = true;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should return undefined when evaluating `void foo`', () => {
+      const prop = extractProp('<div foo={void x} />');
+
+      const expected = undefined;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    // 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(expected, actual);
+    });
+  });
+
+  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 = isNaN(getPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that prefixes with --', () => {
+      const prop = extractProp('<div foo={--bar} />');
+
+      const expected = true;
+      const actual = isNaN(getPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that suffixes with ++', () => {
+      const prop = extractProp('<div foo={bar++} />');
+
+      // "bar"++ => NaN
+      const expected = true;
+      const actual = isNaN(getPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+
+    it('should correctly evaluate an expression that suffixes with --', () => {
+      const prop = extractProp('<div foo={bar--} />');
+
+      const expected = true;
+      const actual = isNaN(getPropValue(prop));
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  describe('This expression', () => {
+    it('should return string value `this`', () => {
+      const prop = extractProp('<div foo={this} />');
+
+      const expected = 'this';
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+
+    it('should evaluate the `>>` operator correctly', () => {
+      const prop = extractProp('<div foo={1 >> 2} />');
+
+      const expected = 0;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `>>>` operator correctly', () => {
+      const prop = extractProp('<div foo={2 >>> 1} />');
+
+      const expected = 1;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `+` operator correctly', () => {
+      const prop = extractProp('<div foo={1 + 1} />');
+
+      const expected = 2;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `-` operator correctly', () => {
+      const prop = extractProp('<div foo={1 - 1} />');
+
+      const expected = 0;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `*` operator correctly', () => {
+      const prop = extractProp('<div foo={10 * 10} />');
+
+      const expected = 100;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `/` operator correctly', () => {
+      const prop = extractProp('<div foo={10 / 2} />');
+
+      const expected = 5;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `%` operator correctly', () => {
+      const prop = extractProp('<div foo={10 % 3} />');
+
+      const expected = 1;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `|` operator correctly', () => {
+      const prop = extractProp('<div foo={10 | 1} />');
+
+      const expected = 11;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `^` operator correctly', () => {
+      const prop = extractProp('<div foo={10 ^ 1} />');
+
+      const expected = 11;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `&` operator correctly', () => {
+      const prop = extractProp('<div foo={10 & 1} />');
+
+      const expected = 0;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `in` operator correctly', () => {
+      const prop = extractProp('<div foo={foo in bar} />');
+
+      const expected = false;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    it('should evaluate the `instanceof` operator correctly', () => {
+      const prop = extractProp('<div foo={{} instanceof Object} />');
+
+      const expected = true;
+      const actual = getPropValue(prop);
+
+      assert.equal(expected, actual);
+    });
+
+    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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+    });
+  });
+
+  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, null];
+      const actual = getPropValue(prop);
+
+      assert.deepEqual(expected, actual);
+    });
+  });
+
+  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(expected, actual);
+  });
+});

web/node_modules/jsx-ast-utils/__tests__/src/hasProp-test.js

@@ -0,0 +1,409 @@
+/* eslint-env mocha */
+import assert from 'assert';
+import { getOpeningElement } from '../helper';
+import hasProp, { hasAnyProp, hasEveryProp } from '../../src/hasProp';
+
+describe('hasProp', () => {
+  it('should export a function', () => {
+    const expected = 'function';
+    const actual = typeof hasProp;
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return false if no arguments are provided', () => {
+    const expected = false;
+    const actual = hasProp();
+
+    assert.equal(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+});
+
+describe('hasAnyProp tests', () => {
+  it('should export a function', () => {
+    const expected = 'function';
+    const actual = typeof hasAnyProp;
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return false if no arguments are provided', () => {
+    const expected = false;
+    const actual = hasAnyProp();
+
+    assert.equal(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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 = hasAnyProp(props, prop, options);
+
+    assert.equal(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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 = hasAnyProp(props, prop, options);
+
+    assert.equal(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+});
+
+describe('hasEveryProp tests', () => {
+  it('should export a function', () => {
+    const expected = 'function';
+    const actual = typeof hasEveryProp;
+
+    assert.equal(expected, actual);
+  });
+
+  it('should return true if no arguments are provided', () => {
+    const expected = true;
+    const actual = hasEveryProp();
+
+    assert.equal(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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 = hasEveryProp(props, propsToCheck);
+
+    assert.equal(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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 = hasEveryProp(props, propsToCheck);
+
+    assert.equal(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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 = hasEveryProp(props, prop, options);
+
+    assert.equal(expected, actual);
+  });
+
+  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 = hasEveryProp(props, prop, options);
+
+    assert.equal(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+});

web/node_modules/jsx-ast-utils/__tests__/src/index-test.js

@@ -0,0 +1,35 @@
+/* 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(expected, actual);
+  });
+
+  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(expected, actual);
+    });
+  });
+});

web/node_modules/jsx-ast-utils/__tests__/src/propName-test.js

@@ -0,0 +1,54 @@
+/* eslint-env mocha */
+import assert from 'assert';
+import { extractProp } from '../helper';
+import propName from '../../src/propName';
+
+describe('propName', () => {
+  it('should export a function', () => {
+    const expected = 'function';
+    const actual = typeof propName;
+
+    assert.equal(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  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(expected, actual);
+  });
+
+  // Note: this shouldn't happen, but safe guard anyway.
+  it('should return undefined if prop name is not JSXIdentifier or JSXNamespacedName', () => {
+    const prop = {
+      type: 'JSXAttribute',
+      name: {
+        type: 'Literal',
+      },
+    };
+
+    const expected = undefined;
+    const actual = propName(prop);
+
+    assert.equal(expected, actual);
+  });
+});