14123

pending completion

Build # 14123

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Revert normalized text node fix (#8231)

This reverts the implementation in 33325ad00.

I didn't mean to merge the implementation since it is incorrect and incomplete.
I meant to just merge the unit test.

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

8343 of 9413 relevant lines covered (88.63%)

3051.05 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/src/renderers/dom/fiber/ReactDOMFiber.js

/**
 * Copyright 2013-present, Facebook, Inc.
 * All rights reserved.
 *
 * This source code is licensed under the BSD-style license found in the
 * LICENSE file in the root directory of this source tree. An additional grant
 * of patent rights can be found in the PATENTS file in the same directory.
 *
 * @providesModule ReactDOMFiber
 * @flow
 */

'use strict';

import type { HostChildren } from 'ReactFiberReconciler';

var ReactFiberReconciler = require('ReactFiberReconciler');
var ReactDOMFeatureFlags = require('ReactDOMFeatureFlags');

var warning = require('warning');

type DOMContainerElement = Element & { _reactRootContainer: ?Object };

type Container = Element;
type Props = { className ?: string };
type Instance = Element;
type TextInstance = Text;

function recursivelyAppendChildren(parent : Element, child : HostChildren<Instance | TextInstance>) {
  if (!child) {
    return;
  }
  /* $FlowFixMe: Element and Text should have this property. */
  if (child.nodeType === 1 || child.nodeType === 3) {
    /* $FlowFixMe: Refinement issue. I don't know how to express different. */
    parent.appendChild(child);
  } else {
    /* As a result of the refinement issue this type isn't known. */
    let node : any = child;
    do {
      recursivelyAppendChildren(parent, node.output);
    } while (node = node.sibling);
  }
}

var DOMRenderer = ReactFiberReconciler({

  updateContainer(container : Container, children : HostChildren<Instance | TextInstance>) : void {
    // TODO: Containers should update similarly to other parents.
    container.innerHTML = '';
    recursivelyAppendChildren(container, children);
  },

  createInstance(type : string, props : Props, children : HostChildren<Instance | TextInstance>) : Instance {
    const domElement = document.createElement(type);
    recursivelyAppendChildren(domElement, children);
    if (typeof props.className !== 'undefined') {
      domElement.className = props.className;
    }
    if (typeof props.children === 'string') {
      domElement.textContent = props.children;
    } else if (typeof props.children === 'number') {
      domElement.textContent = props.children.toString();
    }
    return domElement;
  },

  prepareUpdate(
    domElement : Instance,
    oldProps : Props,
    newProps : Props
  ) : boolean {
    return true;
  },

  commitUpdate(domElement : Instance, oldProps : Props, newProps : Props) : void {
    if (typeof newProps.className !== 'undefined') {
      domElement.className = newProps.className;
    }
    if (typeof newProps.children === 'string') {
      domElement.textContent = newProps.children;
    } else if (typeof newProps.children === 'number') {
      domElement.textContent = newProps.children.toString();
    }
  },

  createTextInstance(text : string) : TextInstance {
    return document.createTextNode(text);
  },

  commitTextUpdate(textInstance : TextInstance, oldText : string, newText : string) : void {
    textInstance.nodeValue = newText;
  },

  appendChild(parentInstance : Instance, child : Instance | TextInstance) : void {
    parentInstance.appendChild(child);
  },

  insertBefore(
    parentInstance : Instance,
    child : Instance | TextInstance,
    beforeChild : Instance | TextInstance
  ) : void {
    parentInstance.insertBefore(child, beforeChild);
  },

  removeChild(parentInstance : Instance, child : Instance | TextInstance) : void {
    parentInstance.removeChild(child);
  },

  scheduleAnimationCallback: window.requestAnimationFrame,

  scheduleDeferredCallback: window.requestIdleCallback,

  useSyncScheduling: true,

});

var warned = false;

function warnAboutUnstableUse() {
  // Ignore this warning is the feature flag is turned on. E.g. for tests.
  warning(
    warned || ReactDOMFeatureFlags.useFiber,
    'You are using React DOM Fiber which is an experimental renderer. ' +
    'It is likely to have bugs, breaking changes and is unsupported.'
  );
  warned = true;
}

var ReactDOM = {

  render(element : ReactElement<any>, container : DOMContainerElement, callback: ?Function) {
    warnAboutUnstableUse();
    let root;

    if (!container._reactRootContainer) {
      root = container._reactRootContainer = DOMRenderer.mountContainer(element, container, callback);
    } else {
      DOMRenderer.updateContainer(element, root = container._reactRootContainer, callback);
    }
    return DOMRenderer.getPublicRootInstance(root);
  },

  unmountComponentAtNode(container : DOMContainerElement) {
    warnAboutUnstableUse();
    const root = container._reactRootContainer;
    if (root) {
      // TODO: Is it safe to reset this now or should I wait since this
      // unmount could be deferred?
      container._reactRootContainer = null;
      DOMRenderer.unmountContainer(root);
    }
  },

  findDOMNode(componentOrElement : Element | ?ReactComponent<any, any, any>) : null | Element | Text {
    if (componentOrElement == null) {
      return null;
    }
    // Unsound duck typing.
    const component = (componentOrElement : any);
    if (component.nodeType === 1) {
      return component;
    }
    return DOMRenderer.findHostInstance(component);
  },

  unstable_batchedUpdates<A>(fn : () => A) : A {
    return DOMRenderer.batchedUpdates(fn);
  },

};

module.exports = ReactDOM;

1	/**
2	* Copyright 2013-present, Facebook, Inc.
3	* All rights reserved.
4	*
5	* This source code is licensed under the BSD-style license found in the
6	* LICENSE file in the root directory of this source tree. An additional grant
7	* of patent rights can be found in the PATENTS file in the same directory.
8	*
9	* @providesModule ReactDOMFiber
10	* @flow
11	*/
12
13	'use strict';
14
15	import type { HostChildren } from 'ReactFiberReconciler';
16
17	var ReactFiberReconciler = require('ReactFiberReconciler');	×
18	var ReactDOMFeatureFlags = require('ReactDOMFeatureFlags');	×
19
20	var warning = require('warning');	×
21
22	type DOMContainerElement = Element & { _reactRootContainer: ?Object };
23
24	type Container = Element;
25	type Props = { className ?: string };
26	type Instance = Element;
27	type TextInstance = Text;
28
29	function recursivelyAppendChildren(parent : Element, child : HostChildren<Instance \| TextInstance>) {
30	if (!child) {	×
31	return;	×
32	}
33	/* $FlowFixMe: Element and Text should have this property. */
34	if (child.nodeType === 1 \|\| child.nodeType === 3) {	×
35	/* $FlowFixMe: Refinement issue. I don't know how to express different. */
36	parent.appendChild(child);	×
37	} else {
38	/* As a result of the refinement issue this type isn't known. */
39	let node : any = child;	×
40	do {	×
41	recursivelyAppendChildren(parent, node.output);	×
42	} while (node = node.sibling);
43	}
44	}
45
46	var DOMRenderer = ReactFiberReconciler({	×
47
48	updateContainer(container : Container, children : HostChildren<Instance \| TextInstance>) : void {
49	// TODO: Containers should update similarly to other parents.
50	container.innerHTML = '';	×
51	recursivelyAppendChildren(container, children);	×
52	},
53
54	createInstance(type : string, props : Props, children : HostChildren<Instance \| TextInstance>) : Instance {
55	const domElement = document.createElement(type);	×
56	recursivelyAppendChildren(domElement, children);	×
57	if (typeof props.className !== 'undefined') {	×
58	domElement.className = props.className;	×
59	}
60	if (typeof props.children === 'string') {	×
61	domElement.textContent = props.children;	×
62	} else if (typeof props.children === 'number') {	×
63	domElement.textContent = props.children.toString();	×
64	}
65	return domElement;	×
66	},
67
68	prepareUpdate(
69	domElement : Instance,
70	oldProps : Props,
71	newProps : Props
72	) : boolean {
73	return true;	×
74	},
75
76	commitUpdate(domElement : Instance, oldProps : Props, newProps : Props) : void {
77	if (typeof newProps.className !== 'undefined') {	×
78	domElement.className = newProps.className;	×
79	}
80	if (typeof newProps.children === 'string') {	×
81	domElement.textContent = newProps.children;	×
82	} else if (typeof newProps.children === 'number') {	×
83	domElement.textContent = newProps.children.toString();	×
84	}
85	},
86
87	createTextInstance(text : string) : TextInstance {
88	return document.createTextNode(text);	×
89	},
90
91	commitTextUpdate(textInstance : TextInstance, oldText : string, newText : string) : void {
92	textInstance.nodeValue = newText;	×
93	},
94
95	appendChild(parentInstance : Instance, child : Instance \| TextInstance) : void {
96	parentInstance.appendChild(child);	×
97	},
98
99	insertBefore(
100	parentInstance : Instance,
101	child : Instance \| TextInstance,
102	beforeChild : Instance \| TextInstance
103	) : void {
104	parentInstance.insertBefore(child, beforeChild);	×
105	},
106
107	removeChild(parentInstance : Instance, child : Instance \| TextInstance) : void {
108	parentInstance.removeChild(child);	×
109	},
110
111	scheduleAnimationCallback: window.requestAnimationFrame,
112
113	scheduleDeferredCallback: window.requestIdleCallback,
114
115	useSyncScheduling: true,
116
117	});
118
119	var warned = false;	×
120
121	function warnAboutUnstableUse() {
122	// Ignore this warning is the feature flag is turned on. E.g. for tests.
123	warning(	×
124	warned \|\| ReactDOMFeatureFlags.useFiber,
125	'You are using React DOM Fiber which is an experimental renderer. ' +
126	'It is likely to have bugs, breaking changes and is unsupported.'
127	);
128	warned = true;	×
129	}
130
131	var ReactDOM = {	×
132
133	render(element : ReactElement<any>, container : DOMContainerElement, callback: ?Function) {
134	warnAboutUnstableUse();	×
135	let root;	×
136
137	if (!container._reactRootContainer) {	×
138	root = container._reactRootContainer = DOMRenderer.mountContainer(element, container, callback);	×
139	} else {
140	DOMRenderer.updateContainer(element, root = container._reactRootContainer, callback);	×
141	}
142	return DOMRenderer.getPublicRootInstance(root);	×
143	},
144
145	unmountComponentAtNode(container : DOMContainerElement) {
146	warnAboutUnstableUse();	×
147	const root = container._reactRootContainer;	×
148	if (root) {	×
149	// TODO: Is it safe to reset this now or should I wait since this
150	// unmount could be deferred?
151	container._reactRootContainer = null;	×
152	DOMRenderer.unmountContainer(root);	×
153	}
154	},
155
156	findDOMNode(componentOrElement : Element \| ?ReactComponent<any, any, any>) : null \| Element \| Text {
157	if (componentOrElement == null) {	×
158	return null;	×
159	}
160	// Unsound duck typing.
161	const component = (componentOrElement : any);	×
162	if (component.nodeType === 1) {	×
163	return component;	×
164	}
165	return DOMRenderer.findHostInstance(component);	×
166	},
167
168	unstable_batchedUpdates<A>(fn : () => A) : A {
169	return DOMRenderer.batchedUpdates(fn);	×
170	},
171
172	};
173
174	module.exports = ReactDOM;	×

facebook / react / 14123

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous