prepack/lib/intrinsics/fb-www/fb-mocks.js

Execute a JS bundle, serialize global state and side effects to a snapshot that can be quickly restored.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createFbMocks = createFbMocks;

var _index = require("../../domains/index.js");

var _index2 = require("../../values/index.js");

var _singletons = require("../../singletons.js");

var _index3 = require("../../methods/index.js");

var _invariant = _interopRequireDefault(require("../../invariant.js"));

var _utils = require("../../react/utils.js");

var _generator = require("../../utils/generator.js");

var _descriptors = require("../../descriptors.js");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * 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.
 */
const fbMagicGlobalFunctions = ["asset", "cx", "cssVar", "csx", "errorDesc", "errorHelpCenterID", "errorSummary", "gkx", "glyph", "ifRequired", "ix", "fbglyph", "requireWeak", "xuiglyph"];
const fbMagicGlobalObjects = ["JSResource", "fbt"];

function createBabelHelpers(realm, global) {
  let babelHelpersValue = new _index2.ObjectValue(realm, realm.intrinsics.ObjectPrototype, `babelHelpers`, true);
  let objectAssign = (0, _index3.Get)(realm, realm.intrinsics.Object, "assign");
  let objectCreate = (0, _index3.Get)(realm, realm.intrinsics.Object, "create"); //babelHelpers.objectWithoutProperties

  let inheritsValue = new _index2.NativeFunctionValue(realm, undefined, `inherits`, 2, (context, [subClass, superClass]) => {
    (0, _invariant.default)(objectAssign instanceof _index2.NativeFunctionValue);
    let objectAssignCall = objectAssign.$Call;
    (0, _invariant.default)(objectAssignCall !== undefined);
    objectAssignCall(realm.intrinsics.undefined, [subClass, superClass]);
    (0, _invariant.default)(superClass instanceof _index2.ObjectValue);
    let superClassPrototype = (0, _index3.Get)(realm, superClass, "prototype");
    (0, _invariant.default)(objectCreate instanceof _index2.NativeFunctionValue);
    let objectCreateCall = objectCreate.$Call;
    (0, _invariant.default)(typeof objectCreateCall === "function");
    let newPrototype = objectCreateCall(realm.intrinsics.undefined, [superClassPrototype]);
    (0, _invariant.default)(subClass instanceof _index2.ObjectValue);
    (0, _invariant.default)(newPrototype instanceof _index2.ObjectValue);

    _singletons.Properties.Set(realm, subClass, "prototype", newPrototype, true);

    _singletons.Properties.Set(realm, newPrototype, "constructor", subClass, true);

    _singletons.Properties.Set(realm, subClass, "__superConstructor__", superClass, true);

    return superClass;
  });
  babelHelpersValue.defineNativeProperty("inherits", inheritsValue, {
    writable: false,
    enumerable: false,
    configurable: true
  });
  inheritsValue.intrinsicName = `babelHelpers.inherits`;

  const createObjectWithoutProperties = (obj, keys) => {
    let removeKeys = new Set();
    (0, _utils.forEachArrayValue)(realm, keys, key => {
      if (key instanceof _index2.StringValue || key instanceof _index2.NumberValue) {
        removeKeys.add(key.value);
      }
    });

    let newObject = _singletons.Create.ObjectCreate(realm, realm.intrinsics.ObjectPrototype);

    for (let [propName, binding] of obj.properties) {
      if (!removeKeys.has(propName)) {
        if (binding && binding.descriptor && binding.descriptor.throwIfNotConcrete(realm).enumerable) {
          let value = (0, _index3.Get)(realm, obj, propName);

          _singletons.Properties.Set(realm, newObject, propName, value, true);
        }
      }
    }

    return newObject;
  }; //babelHelpers.objectWithoutProperties


  let objectWithoutPropertiesValue = new _index2.NativeFunctionValue(realm, undefined, `objectWithoutProperties`, 2, (context, [obj, keys]) => {
    (0, _invariant.default)(obj instanceof _index2.ObjectValue || obj instanceof _index2.AbstractObjectValue || obj instanceof _index2.AbstractValue);
    (0, _invariant.default)(keys instanceof _index2.ArrayValue);

    if (obj.mightBeObject() && (obj instanceof _index2.AbstractValue && obj.values.isTop() || obj.isPartialObject())) {
      let temporalArgs = [objectWithoutPropertiesValue, obj, keys];
      let temporalConfig = {
        skipInvariant: true,
        isPure: true
      };

      let value = _index2.AbstractValue.createTemporalFromBuildFunction(realm, _index2.ObjectValue, temporalArgs, (0, _generator.createOperationDescriptor)("BABEL_HELPERS_OBJECT_WITHOUT_PROPERTIES"), temporalConfig);

      (0, _invariant.default)(value instanceof _index2.AbstractObjectValue);

      if (obj instanceof _index2.ObjectValue) {
        let template = createObjectWithoutProperties(obj, keys);
        value.values = new _index.ValuesDomain(template);
      } // as we are returning an abstract object, we mark it as simple


      value.makeSimple();
      return value;
    } else {
      (0, _invariant.default)(obj instanceof _index2.ObjectValue);
      return createObjectWithoutProperties(obj, keys);
    }
  });
  babelHelpersValue.defineNativeProperty("objectWithoutProperties", objectWithoutPropertiesValue, {
    writable: false,
    enumerable: false,
    configurable: true
  });
  objectWithoutPropertiesValue.intrinsicName = `babelHelpers.objectWithoutProperties`; //babelHelpers.taggedTemplateLiteralLoose

  let taggedTemplateLiteralLooseValue = new _index2.NativeFunctionValue(realm, undefined, `taggedTemplateLiteralLoose`, 2, (context, [strings, raw]) => {
    (0, _invariant.default)(strings instanceof _index2.ObjectValue);

    _singletons.Properties.Set(realm, strings, "raw", raw, true);

    return strings;
  });
  babelHelpersValue.defineNativeProperty("taggedTemplateLiteralLoose", taggedTemplateLiteralLooseValue, {
    writable: false,
    enumerable: false,
    configurable: true
  });
  taggedTemplateLiteralLooseValue.intrinsicName = `babelHelpers.taggedTemplateLiteralLoose`; //babelHelpers.extends & babelHelpers._extends

  babelHelpersValue.defineNativeProperty("extends", objectAssign, {
    writable: true,
    enumerable: true,
    configurable: true
  });
  babelHelpersValue.defineNativeProperty("_extends", objectAssign, {
    writable: true,
    enumerable: true,
    configurable: true
  }); //babelHelpers.bind

  let functionBind = (0, _index3.Get)(realm, realm.intrinsics.FunctionPrototype, "bind");
  babelHelpersValue.defineNativeProperty("bind", functionBind, {
    writable: true,
    enumerable: true,
    configurable: true
  });
  global.$DefineOwnProperty("babelHelpers", new _descriptors.PropertyDescriptor({
    value: babelHelpersValue,
    writable: true,
    enumerable: true,
    configurable: true
  }));
  babelHelpersValue.refuseSerialization = false;
}

function createMagicGlobalFunction(realm, global, functionName) {
  global.$DefineOwnProperty(functionName, new _descriptors.PropertyDescriptor({
    value: new _index2.NativeFunctionValue(realm, functionName, functionName, 0, (context, args) => {
      let val = _index2.AbstractValue.createTemporalFromBuildFunction(realm, _index2.FunctionValue, [new _index2.StringValue(realm, functionName), ...args], (0, _generator.createOperationDescriptor)("FB_MOCKS_MAGIC_GLOBAL_FUNCTION"), {
        skipInvariant: true,
        isPure: true
      });

      (0, _invariant.default)(val instanceof _index2.AbstractValue);
      return val;
    }),
    writable: true,
    enumerable: false,
    configurable: true
  }));
}

function createMagicGlobalObject(realm, global, objectName) {
  let globalObject = _index2.AbstractValue.createAbstractObject(realm, objectName);

  globalObject.kind = "resolved";
  global.$DefineOwnProperty(objectName, new _descriptors.PropertyDescriptor({
    value: globalObject,
    writable: true,
    enumerable: false,
    configurable: true
  }));
}

function createBootloader(realm, global) {
  let bootloader = new _index2.ObjectValue(realm, realm.intrinsics.ObjectPrototype);
  let loadModules = new _index2.NativeFunctionValue(realm, "loadModules", "loadModules", 1, (context, args) => {
    (0, _invariant.default)(context.$Realm.generator);

    let val = _index2.AbstractValue.createTemporalFromBuildFunction(realm, _index2.FunctionValue, args, (0, _generator.createOperationDescriptor)("FB_MOCKS_BOOTLOADER_LOAD_MODULES"), {
      skipInvariant: true
    });

    (0, _invariant.default)(val instanceof _index2.AbstractValue);
    return val;
  });

  _singletons.Properties.Set(realm, bootloader, "loadModules", loadModules, false);

  global.$DefineOwnProperty("Bootloader", new _descriptors.PropertyDescriptor({
    value: bootloader,
    writable: true,
    enumerable: false,
    configurable: true
  }));
  return _index2.AbstractValue.createAbstractObject(realm, "Bootloader", bootloader);
}

function createFbMocks(realm, global) {
  global.$DefineOwnProperty("__DEV__", new _descriptors.PropertyDescriptor({
    // TODO: we'll likely want to make this configurable from the outside.
    value: realm.intrinsics.false,
    writable: true,
    enumerable: false,
    configurable: true
  }));
  createBabelHelpers(realm, global);

  for (let functionName of fbMagicGlobalFunctions) {
    createMagicGlobalFunction(realm, global, functionName);
  }

  for (let objectName of fbMagicGlobalObjects) {
    createMagicGlobalObject(realm, global, objectName);
  }

  createBootloader(realm, global);
}
//# sourceMappingURL=fb-mocks.js.map