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

416
build/node_modules/prepack/lib/evaluators/JSXElement.js generated vendored Normal file
View File

@@ -0,0 +1,416 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }(); /**
* 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.
*/
exports.default = function (ast, strictCode, env, realm) {
(0, _invariant2.default)(realm.react.enabled, "JSXElements can only be evaluated with the reactEnabled option");
var openingElement = ast.openingElement;
var type = evaluateJSXIdentifier(openingElement.name, strictCode, env, realm);
var _evaluateJSXAttribute = evaluateJSXAttributes(openingElement.name, openingElement.attributes, ast.children, strictCode, env, realm),
attributes = _evaluateJSXAttribute.attributes,
children = _evaluateJSXAttribute.children;
var key = attributes.get("key") || realm.intrinsics.null;
var ref = attributes.get("ref") || realm.intrinsics.null;
if (key === realm.intrinsics.undefined) {
key = realm.intrinsics.null;
}
if (ref === realm.intrinsics.undefined) {
ref = realm.intrinsics.null;
}
// React uses keys to identify nodes as they get updated through the reconcilation
// phase. Keys are used in a map and thus need to be converted to strings
if (key !== realm.intrinsics.null) {
key = (0, _BinaryExpression.computeBinary)(realm, "+", realm.intrinsics.emptyString, key);
}
var props = createReactProps(realm, type, attributes, children, env);
return createReactElement(realm, type, key, ref, props);
};
var _errors = require("../errors.js");
var _index = require("../values/index.js");
var _utils = require("../react/utils.js");
var _jsx = require("../react/jsx.js");
var _babelTypes = require("babel-types");
var t = _interopRequireWildcard(_babelTypes);
var _index2 = require("../methods/index.js");
var _singletons = require("../singletons.js");
var _invariant = require("../invariant.js");
var _invariant2 = _interopRequireDefault(_invariant);
var _BinaryExpression = require("./BinaryExpression.js");
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
var RESERVED_PROPS = {
key: true,
ref: true,
__self: true,
__source: true
};
// taken from Babel
function cleanJSXElementLiteralChild(child) {
var lines = child.split(/\r\n|\n|\r/);
var lastNonEmptyLine = 0;
for (var i = 0; i < lines.length; i++) {
if (lines[i].match(/[^ \t]/)) {
lastNonEmptyLine = i;
}
}
var str = "";
for (var _i = 0; _i < lines.length; _i++) {
var line = lines[_i];
var isFirstLine = _i === 0;
var isLastLine = _i === lines.length - 1;
var isLastNonEmptyLine = _i === lastNonEmptyLine;
// replace rendered whitespace tabs with spaces
var trimmedLine = line.replace(/\t/g, " ");
// trim whitespace touching a newline
if (!isFirstLine) {
trimmedLine = trimmedLine.replace(/^[ ]+/, "");
}
// trim whitespace touching an endline
if (!isLastLine) {
trimmedLine = trimmedLine.replace(/[ ]+$/, "");
}
if (trimmedLine) {
if (!isLastNonEmptyLine) {
trimmedLine += " ";
}
str += trimmedLine;
}
}
if (str) {
return str;
}
return null;
}
function evaluateJSXMemberExpression(ast, strictCode, env, realm) {
switch (ast.type) {
case "JSXIdentifier":
return _singletons.Environment.GetValue(realm, _singletons.Environment.ResolveBinding(realm, ast.name, strictCode, env));
case "JSXMemberExpression":
return _singletons.Environment.GetValue(realm, env.evaluate((0, _jsx.convertJSXExpressionToIdentifier)(ast), strictCode));
default:
(0, _invariant2.default)(false, "Unknown JSX Identifier");
}
}
function evaluateJSXIdentifier(ast, strictCode, env, realm) {
if (isTagName(ast)) {
// special cased lower-case and custom elements
return new _index.StringValue(realm, ast.name);
}
return evaluateJSXMemberExpression(ast, strictCode, env, realm);
}
function evaluateJSXValue(value, strictCode, env, realm) {
if (value != null) {
switch (value.type) {
case "JSXText":
return new _index.StringValue(realm, value.value);
case "StringLiteral":
return new _index.StringValue(realm, value.value);
case "JSXExpressionContainer":
return _singletons.Environment.GetValue(realm, env.evaluate(value.expression, strictCode));
case "JSXElement":
return _singletons.Environment.GetValue(realm, env.evaluate(value, strictCode));
default:
(0, _invariant2.default)(false, "Unknown JSX value type: " + value.type);
}
}
(0, _invariant2.default)(false, "Null or undefined value passed when trying to evaluate JSX node value");
}
function isTagName(ast) {
return ast.type === "JSXIdentifier" && /^[a-z]|\-/.test(ast.name);
}
function getDefaultProps(elementType, env, realm) {
var name = void 0;
if (elementType.type === "JSXIdentifier") {
name = elementType.name;
}
if (!isTagName(elementType) && typeof name === "string") {
// find the value of "ComponentXXX.defaultProps"
var defaultProps = _singletons.Environment.GetValue(realm, env.evaluate(t.memberExpression(t.identifier(name), t.identifier("defaultProps")), false));
if (defaultProps instanceof _index.ObjectValue) {
return defaultProps;
}
}
return null;
}
function evaluateJSXChildren(children, strictCode, env, realm) {
if (children.length === 0) {
return null;
}
if (children.length === 1) {
var singleChild = evaluateJSXValue(children[0], strictCode, env, realm);
if (singleChild instanceof _index.StringValue) {
var text = cleanJSXElementLiteralChild(singleChild.value);
if (text !== null) {
singleChild.value = text;
}
}
return singleChild;
}
var array = _singletons.Create.ArrayCreate(realm, 0);
var dynamicChildrenLength = children.length;
var dynamicIterator = 0;
var lastChildValue = null;
for (var i = 0; i < children.length; i++) {
var value = evaluateJSXValue(children[i], strictCode, env, realm);
if (value instanceof _index.StringValue) {
var _text = cleanJSXElementLiteralChild(value.value);
if (_text === null) {
dynamicChildrenLength--;
// this is a space full of whitespace, so let's proceed
continue;
} else {
value.value = _text;
}
}
lastChildValue = value;
_singletons.Create.CreateDataPropertyOrThrow(realm, array, "" + dynamicIterator, value);
dynamicIterator++;
}
if (dynamicChildrenLength === 1) {
return lastChildValue;
}
_singletons.Properties.Set(realm, array, "length", new _index.NumberValue(realm, dynamicChildrenLength), false);
return array;
}
function evaluateJSXAttributes(elementType, astAttributes, astChildren, strictCode, env, realm) {
var attributes = new Map();
var children = evaluateJSXChildren(astChildren, strictCode, env, realm);
var defaultProps = getDefaultProps(elementType, env, realm);
// defaultProps are a bit like default function arguments
// if an actual value exists, it should overwrite the default value
if (defaultProps !== null) {
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = defaultProps.properties[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _ref = _step.value;
var _ref2 = _slicedToArray(_ref, 1);
var key = _ref2[0];
var defaultPropValue = (0, _index2.Get)(realm, defaultProps, key);
if (defaultPropValue instanceof _index.Value) {
if (key === "children") {
if (children === null) {
children = defaultPropValue;
}
} else {
attributes.set(key, defaultPropValue);
}
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = astAttributes[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var astAttribute = _step2.value;
switch (astAttribute.type) {
case "JSXAttribute":
var name = astAttribute.name,
value = astAttribute.value;
(0, _invariant2.default)(name.type === "JSXIdentifier", "JSX attribute name type not supported: " + astAttribute.type);
attributes.set(name.name, evaluateJSXValue(value, strictCode, env, realm));
break;
case "JSXSpreadAttribute":
var spreadValue = _singletons.Environment.GetValue(realm, env.evaluate(astAttribute.argument, strictCode));
if (spreadValue instanceof _index.ObjectValue) {
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = spreadValue.properties[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var _ref3 = _step3.value;
var _ref4 = _slicedToArray(_ref3, 2);
var _key = _ref4[0];
var spreadProp = _ref4[1];
if (spreadProp !== undefined && spreadProp.descriptor !== undefined) {
var spreadPropValue = spreadProp.descriptor.value;
if (spreadPropValue instanceof _index.Value) {
if (_key === "children") {
children = spreadPropValue;
} else {
attributes.set(_key, spreadPropValue);
}
}
}
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
} else {
throw new _errors.FatalError("ObjectValues are the only supported value for JSX Spread Attributes");
}
break;
default:
(0, _invariant2.default)(false, "Unknown JSX attribute type:: " + astAttribute.type);
}
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
return {
attributes: attributes,
children: children
};
}
function createReactProps(realm, type, attributes, children, env) {
var obj = _singletons.Create.ObjectCreate(realm, realm.intrinsics.ObjectPrototype);
var _iteratorNormalCompletion4 = true;
var _didIteratorError4 = false;
var _iteratorError4 = undefined;
try {
for (var _iterator4 = attributes[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
var _ref5 = _step4.value;
var _ref6 = _slicedToArray(_ref5, 2);
var key = _ref6[0];
var value = _ref6[1];
if (typeof key === "string") {
if (RESERVED_PROPS.hasOwnProperty(key)) {
continue;
}
_singletons.Create.CreateDataPropertyOrThrow(realm, obj, key, value);
}
}
} catch (err) {
_didIteratorError4 = true;
_iteratorError4 = err;
} finally {
try {
if (!_iteratorNormalCompletion4 && _iterator4.return) {
_iterator4.return();
}
} finally {
if (_didIteratorError4) {
throw _iteratorError4;
}
}
}
if (children !== null) {
_singletons.Create.CreateDataPropertyOrThrow(realm, obj, "children", children);
}
return obj;
}
function createReactElement(realm, type, key, ref, props) {
var obj = _singletons.Create.ObjectCreate(realm, realm.intrinsics.ObjectPrototype);
_singletons.Create.CreateDataPropertyOrThrow(realm, obj, "$$typeof", (0, _utils.getReactSymbol)("react.element", realm));
_singletons.Create.CreateDataPropertyOrThrow(realm, obj, "type", type);
_singletons.Create.CreateDataPropertyOrThrow(realm, obj, "key", key);
_singletons.Create.CreateDataPropertyOrThrow(realm, obj, "ref", ref);
_singletons.Create.CreateDataPropertyOrThrow(realm, obj, "props", props);
_singletons.Create.CreateDataPropertyOrThrow(realm, obj, "_owner", realm.intrinsics.null);
return obj;
}
//# sourceMappingURL=JSXElement.js.map