asciidisco/asciidisco.com
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
s.golasch
2023-08-01 13:49:46 +02:00
commit 1fc239fd54
20238 changed files with 3112246 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

301
build/node_modules/prepack/lib/react/reconcilation.js generated vendored Normal file
View File

@@ -0,0 +1,301 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.Reconciler = undefined;
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /**
* Copyright (c) 2017-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.
*/
var _realm = require("../realm.js");
var _modules = require("../serializer/modules.js");
var _index = require("../values/index.js");
var _types = require("../serializer/types.js");
var _utils = require("./utils");
var _index2 = require("../methods/index.js");
var _invariant = require("../invariant.js");
var _invariant2 = _interopRequireDefault(_invariant);
var _errors = require("../errors.js");
var _branching = require("./branching.js");
var _components = require("./components.js");
var _errors2 = require("./errors.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
var Reconciler = exports.Reconciler = function () {
function Reconciler(realm, moduleTracer, statistics, reactSerializerState, simpleClassComponents) {
_classCallCheck(this, Reconciler);
this.realm = realm;
this.moduleTracer = moduleTracer;
this.statistics = statistics;
this.reactSerializerState = reactSerializerState;
this.simpleClassComponents = simpleClassComponents;
}
_createClass(Reconciler, [{
key: "render",
value: function render(componentType) {
var _this = this;
return this.realm.wrapInGlobalEnv(function () {
return (
// TODO: (sebmarkbage): You could use the return value of this to detect if there are any mutations on objects other
// than newly created ones. Then log those to the error logger. That'll help us track violations in
// components. :)
_this.realm.evaluateForEffects(function () {
// initialProps and initialContext are created from Flow types from:
// - if a functional component, the 1st and 2nd paramater of function
// - if a class component, use this.props and this.context
// if there are no Flow types for props or context, we will throw a
// FatalError, unless it's a functional component that has no paramater
// i.e let MyComponent = () => <div>Hello world</div>
try {
var initialProps = (0, _components.getInitialProps)(_this.realm, componentType);
var initialContext = (0, _components.getInitialContext)(_this.realm, componentType);
var _renderComponent2 = _this._renderComponent(componentType, initialProps, initialContext, "ROOT", null),
result = _renderComponent2.result;
_this.statistics.optimizedTrees++;
return result;
} catch (error) {
// if there was a bail-out on the root component in this reconcilation process, then this
// should be an invariant as the user has explicitly asked for this component to get folded
if (error instanceof _errors2.ExpectedBailOut) {
var diagnostic = new _errors.CompilerDiagnostic("__registerReactComponentRoot() failed due to - " + error.message, _this.realm.currentLocation, "PP0020", "FatalError");
_this.realm.handleError(diagnostic);
throw new _errors.FatalError();
}
throw error;
}
},
/*state*/null, "react component: " + componentType.getName())
);
});
}
}, {
key: "_renderComplexClassComponent",
value: function _renderComplexClassComponent(componentType, props, context, branchStatus, branchState) {
if (branchStatus !== "ROOT") {
throw new _errors2.ExpectedBailOut("only complex class components at the root of __registerReactComponentRoot() are supported");
}
// create a new instance of this React class component
var instance = (0, _components.createClassInstance)(this.realm, componentType, props, context);
// get the "render" method off the instance
var renderMethod = (0, _index2.Get)(this.realm, instance, "render");
(0, _invariant2.default)(renderMethod instanceof _index.ECMAScriptSourceFunctionValue && renderMethod.$Call, "Expected render method to be a FunctionValue with $Call method");
// the render method doesn't have any arguments, so we just assign the context of "this" to be the instance
return renderMethod.$Call(instance, []);
}
}, {
key: "_renderSimpleClassComponent",
value: function _renderSimpleClassComponent(componentType, props, context, branchStatus, branchState) {
// create a new simple instance of this React class component
var instance = (0, _components.createSimpleClassInstance)(this.realm, componentType, props, context);
// get the "render" method off the instance
var renderMethod = (0, _index2.Get)(this.realm, instance, "render");
(0, _invariant2.default)(renderMethod instanceof _index.ECMAScriptSourceFunctionValue && renderMethod.$Call, "Expected render method to be a FunctionValue with $Call method");
// the render method doesn't have any arguments, so we just assign the context of "this" to be the instance
return renderMethod.$Call(instance, []);
}
}, {
key: "_renderFunctionalComponent",
value: function _renderFunctionalComponent(componentType, props, context) {
(0, _invariant2.default)(componentType.$Call, "Expected componentType to be a FunctionValue with $Call method");
return componentType.$Call(this.realm.intrinsics.undefined, [props, context]);
}
}, {
key: "_renderComponent",
value: function _renderComponent(componentType, props, context, branchStatus, branchState) {
var value = void 0;
var childContext = context;
// first we check if it's a legacy class component
if ((0, _utils.valueIsLegacyCreateClassComponent)(this.realm, componentType)) {
throw new _errors2.ExpectedBailOut("components created with create-react-class are not supported");
} else if ((0, _utils.valueIsClassComponent)(this.realm, componentType)) {
// We first need to know what type of class component we're dealing with.
// A "simple" class component is defined as:
//
// - having only a "render" method or many method, i.e. render(), _renderHeader(), _renderFooter()
// - having no lifecycle events
// - having no state
// - having no instance variables
//
// the only things a class component should be able to access on "this" are:
// - this.props
// - this.context
// - this._someRenderMethodX() etc
//
// Otherwise, the class component is a "complex" one.
// To begin with, we don't know what type of component it is, so we try and render it as if it were
// a simple component using the above heuristics. If an error occurs during this process, we assume
// that the class wasn't simple, then try again with the "complex" heuristics.
try {
value = this._renderSimpleClassComponent(componentType, props, context, branchStatus, branchState);
this.simpleClassComponents.add(value);
} catch (error) {
// if we get back a SimpleClassBailOut error, we know that this class component
// wasn't a simple one and is likely to be a complex class component instead
if (error instanceof _errors2.SimpleClassBailOut) {
// the component was not simple, so we continue with complex case
} else {
// else we rethrow the error
throw error;
}
}
// handle the complex class component if there is not value
if (value === undefined) {
value = this._renderComplexClassComponent(componentType, props, context, branchStatus, branchState);
}
} else {
value = this._renderFunctionalComponent(componentType, props, context);
}
(0, _invariant2.default)(value !== undefined);
return {
result: this._resolveDeeply(value, context, branchStatus === "ROOT" ? "NO_BRANCH" : branchStatus, branchState),
childContext: childContext
};
}
}, {
key: "_resolveDeeply",
value: function _resolveDeeply(value, context, branchStatus, branchState) {
if (value instanceof _index.StringValue || value instanceof _index.NumberValue || value instanceof _index.BooleanValue || value instanceof _index.NullValue || value instanceof _index.UndefinedValue) {
// terminal values
return value;
} else if (value instanceof _index.AbstractValue) {
var length = value.args.length;
if (length > 0) {
var newBranchState = new _branching.BranchState();
// TODO investigate what other kinds than "conditional" might be safe to deeply resolve
for (var i = 0; i < length; i++) {
value.args[i] = this._resolveDeeply(value.args[i], context, "NEW_BRANCH", newBranchState);
}
newBranchState.applyBranchedLogic(this.realm, this.reactSerializerState);
}
return value;
}
// TODO investigate what about other iterables type objects
if (value instanceof _index.ArrayValue) {
this._resolveFragment(value, context, branchStatus, branchState);
return value;
}
if (value instanceof _index.ObjectValue && (0, _utils.isReactElement)(value)) {
// we call value reactElement, to make it clearer what we're dealing with in this block
var reactElement = value;
var typeValue = (0, _index2.Get)(this.realm, reactElement, "type");
var propsValue = (0, _index2.Get)(this.realm, reactElement, "props");
var refValue = (0, _index2.Get)(this.realm, reactElement, "ref");
if (typeValue instanceof _index.StringValue) {
// terminal host component. Start evaluating its children.
if (propsValue instanceof _index.ObjectValue) {
var childrenProperty = propsValue.properties.get("children");
if (childrenProperty) {
var childrenPropertyDescriptor = childrenProperty.descriptor;
// if the descriptor is undefined, the property is likely deleted, if it exists
// proceed to resolve the children
if (childrenPropertyDescriptor !== undefined) {
var childrenPropertyValue = childrenPropertyDescriptor.value;
(0, _invariant2.default)(childrenPropertyValue instanceof _index.Value, "Bad \"children\" prop passed in JSXElement");
var resolvedChildren = this._resolveDeeply(childrenPropertyValue, context, branchStatus, branchState);
childrenPropertyDescriptor.value = resolvedChildren;
}
}
}
return reactElement;
}
// we do not support "ref" on <Component /> ReactElements
if (!(refValue instanceof _index.NullValue)) {
this._assignBailOutMessage(reactElement, "Bail-out: refs are not supported on <Components />");
return reactElement;
}
if (!(propsValue instanceof _index.ObjectValue || propsValue instanceof _index.AbstractObjectValue)) {
this._assignBailOutMessage(reactElement, "Bail-out: props on <Component /> was not not an ObjectValue or an AbstractValue");
return reactElement;
}
if (!(typeValue instanceof _index.ECMAScriptSourceFunctionValue)) {
this._assignBailOutMessage(reactElement, "Bail-out: type on <Component /> was not a ECMAScriptSourceFunctionValue");
return reactElement;
}
try {
var _renderComponent3 = this._renderComponent(typeValue, propsValue, context, branchStatus === "NEW_BRANCH" ? "BRANCH" : branchStatus, null),
result = _renderComponent3.result;
if (result instanceof _index.UndefinedValue) {
this._assignBailOutMessage(reactElement, "Bail-out: undefined was returned from render");
if (branchStatus === "NEW_BRANCH" && branchState) {
return branchState.captureBranchedValue(typeValue, reactElement);
}
return reactElement;
}
this.statistics.inlinedComponents++;
if (branchStatus === "NEW_BRANCH" && branchState) {
return branchState.captureBranchedValue(typeValue, result);
}
return result;
} catch (error) {
// assign a bail out message
if (error instanceof _errors2.ExpectedBailOut) {
this._assignBailOutMessage(reactElement, "Bail-out: " + error.message);
} else if (error instanceof _errors.FatalError) {
this._assignBailOutMessage(reactElement, "Evaluation bail-out");
} else {
throw error;
}
// a child component bailed out during component folding, so return the function value and continue
if (branchStatus === "NEW_BRANCH" && branchState) {
return branchState.captureBranchedValue(typeValue, reactElement);
}
return reactElement;
}
} else {
throw new _errors2.ExpectedBailOut("unsupported value type during reconcilation");
}
}
}, {
key: "_assignBailOutMessage",
value: function _assignBailOutMessage(reactElement, message) {
// $BailOutReason is a field on ObjectValue that allows us to specify a message
// that gets serialized as a comment node during the ReactElement serialization stage
if (reactElement.$BailOutReason !== undefined) {
// merge bail out messages if one already exists
reactElement.$BailOutReason += ", " + message;
} else {
reactElement.$BailOutReason = message;
}
}
}, {
key: "_resolveFragment",
value: function _resolveFragment(arrayValue, context, branchStatus, branchState) {
var _this2 = this;
(0, _utils.mapOverArrayValue)(this.realm, arrayValue, function (elementValue, elementPropertyDescriptor) {
elementPropertyDescriptor.value = _this2._resolveDeeply(elementValue, context, branchStatus, branchState);
});
}
}]);
return Reconciler;
}();
//# sourceMappingURL=reconcilation.js.map