@atlaspack/packager-js 2.14.0 → 2.14.1-canary.6

package/lib/dev-prelude.js

@@ -0,0 +1,145 @@
+// modules are defined as an array
+// [ module function, map of requires ]
+//
+// map of requires is short require name -> numeric require
+//
+// anything defined in a previous bundle is accessed via the
+// orig method which is the require for previous bundles
+
+(function (modules, entry, mainEntry, parcelRequireName, globalName) {
+  /* eslint-disable no-undef */
+  var globalObject =
+    typeof globalThis !== 'undefined'
+      ? globalThis
+      : typeof self !== 'undefined'
+      ? self
+      : typeof window !== 'undefined'
+      ? window
+      : typeof global !== 'undefined'
+      ? global
+      : {};
+  /* eslint-enable no-undef */
+
+  // Save the require from previous bundle to this closure if any
+  var previousRequire =
+    typeof globalObject[parcelRequireName] === 'function' &&
+    globalObject[parcelRequireName];
+
+  var cache = previousRequire.cache || {};
+  // Do not use `require` to prevent Webpack from trying to bundle this call
+  var nodeRequire =
+    typeof module !== 'undefined' &&
+    typeof module.require === 'function' &&
+    module.require.bind(module);
+
+  function newRequire(name, jumped) {
+    if (!cache[name]) {
+      if (!modules[name]) {
+        // if we cannot find the module within our internal map or
+        // cache jump to the current global require ie. the last bundle
+        // that was added to the page.
+        var currentRequire =
+          typeof globalObject[parcelRequireName] === 'function' &&
+          globalObject[parcelRequireName];
+        if (!jumped && currentRequire) {
+          return currentRequire(name, true);
+        }
+
+        // If there are other bundles on this page the require from the
+        // previous one is saved to 'previousRequire'. Repeat this as
+        // many times as there are bundles until the module is found or
+        // we exhaust the require chain.
+        if (previousRequire) {
+          return previousRequire(name, true);
+        }
+
+        // Try the node require function if it exists.
+        if (nodeRequire && typeof name === 'string') {
+          return nodeRequire(name);
+        }
+
+        var err = new Error("Cannot find module '" + name + "'");
+        err.code = 'MODULE_NOT_FOUND';
+        throw err;
+      }
+
+      localRequire.resolve = resolve;
+      localRequire.cache = {};
+
+      var module = (cache[name] = new newRequire.Module(name));
+
+      modules[name][0].call(
+        module.exports,
+        localRequire,
+        module,
+        module.exports,
+        globalObject
+      );
+    }
+
+    return cache[name].exports;
+
+    function localRequire(x) {
+      var res = localRequire.resolve(x);
+      return res === false ? {} : newRequire(res);
+    }
+
+    function resolve(x) {
+      var id = modules[name][1][x];
+      return id != null ? id : x;
+    }
+  }
+
+  function Module(moduleName) {
+    this.id = moduleName;
+    this.bundle = newRequire;
+    this.exports = {};
+  }
+
+  newRequire.isParcelRequire = true;
+  newRequire.Module = Module;
+  newRequire.modules = modules;
+  newRequire.cache = cache;
+  newRequire.parent = previousRequire;
+  newRequire.register = function (id, exports) {
+    modules[id] = [
+      function (require, module) {
+        module.exports = exports;
+      },
+      {},
+    ];
+  };
+
+  Object.defineProperty(newRequire, 'root', {
+    get: function () {
+      return globalObject[parcelRequireName];
+    },
+  });
+
+  globalObject[parcelRequireName] = newRequire;
+
+  for (var i = 0; i < entry.length; i++) {
+    newRequire(entry[i]);
+  }
+
+  if (mainEntry) {
+    // Expose entry point to Node, AMD or browser globals
+    // Based on https://github.com/ForbesLindesay/umd/blob/master/template.js
+    var mainExports = newRequire(mainEntry);
+
+    // CommonJS
+    if (typeof exports === 'object' && typeof module !== 'undefined') {
+      module.exports = mainExports;
+
+      // RequireJS
+    } else if (typeof define === 'function' && define.amd) {
+      define(function () {
+        return mainExports;
+      });
+
+      // <script>
+    } else if (globalName) {
+      this[globalName] = mainExports;
+    }
+  }
+});

package/lib/helpers.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prelude = exports.helpers = exports.fnExpr = exports.bundleQueuePrelude = void 0;
+const prelude = parcelRequireName => `
+var $parcel$modules = {};
+var $parcel$inits = {};
+
+var parcelRequire = $parcel$global[${JSON.stringify(parcelRequireName)}];
+
+if (parcelRequire == null) {
+  parcelRequire = function(id) {
+    if (id in $parcel$modules) {
+      return $parcel$modules[id].exports;
+    }
+    if (id in $parcel$inits) {
+      var init = $parcel$inits[id];
+      delete $parcel$inits[id];
+      var module = {id: id, exports: {}};
+      $parcel$modules[id] = module;
+      init.call(module.exports, module, module.exports);
+      return module.exports;
+    }
+    var err = new Error("Cannot find module '" + id + "'");
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+  };
+
+  parcelRequire.register = function register(id, init) {
+    $parcel$inits[id] = init;
+  };
+
+  $parcel$global[${JSON.stringify(parcelRequireName)}] = parcelRequire;
+}
+
+var parcelRegister = parcelRequire.register;
+`;
+exports.prelude = prelude;
+const fnExpr = (env, params, body) => {
+  let block = `{ ${body.join(' ')} }`;
+  if (env.supports('arrow-functions')) {
+    return `(${params.join(', ')}) => ${block}`;
+  }
+  return `function (${params.join(', ')}) ${block}`;
+};
+exports.fnExpr = fnExpr;
+const bundleQueuePrelude = env => `
+if (!$parcel$global.lb) {
+  // Set of loaded bundles
+  $parcel$global.lb = new Set();
+  // Queue of bundles to execute once they're dep bundles are loaded
+  $parcel$global.bq = [];
+
+  // Register loaded bundle
+  $parcel$global.rlb = ${fnExpr(env, ['bundle'], ['$parcel$global.lb.add(bundle);', '$parcel$global.pq();'])}
+
+  // Run when ready
+  $parcel$global.rwr = ${fnExpr(env,
+// b = bundle public id
+// r = run function to execute the bundle entry
+// d = list of dependent bundles this bundle requires before executing
+['b', 'r', 'd'], ['$parcel$global.bq.push({b, r, d});', '$parcel$global.pq();'])}
+
+  // Process queue
+  $parcel$global.pq = ${fnExpr(env, [], [`var runnableEntry = $parcel$global.bq.find(${fnExpr(env, ['i'], [`return i.d.every(${fnExpr(env, ['dep'], ['return $parcel$global.lb.has(dep);'])});`])});`, 'if (runnableEntry) {', `$parcel$global.bq = $parcel$global.bq.filter(${fnExpr(env, ['i'], ['return i.b !== runnableEntry.b;'])});`, 'runnableEntry.r();', '$parcel$global.pq();', '}'])}
+}
+`;
+exports.bundleQueuePrelude = bundleQueuePrelude;
+const $parcel$export = `
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+`;
+const $parcel$exportWildcard = `
+function $parcel$exportWildcard(dest, source) {
+  Object.keys(source).forEach(function(key) {
+    if (key === 'default' || key === '__esModule' || Object.prototype.hasOwnProperty.call(dest, key)) {
+      return;
+    }
+
+    Object.defineProperty(dest, key, {
+      enumerable: true,
+      get: function get() {
+        return source[key];
+      }
+    });
+  });
+
+  return dest;
+}
+`;
+const $parcel$interopDefault = `
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+`;
+const $parcel$global = env => {
+  if (env.supports('global-this')) {
+    return `
+      var $parcel$global = globalThis;
+    `;
+  }
+  return `
+      var $parcel$global =
+        typeof globalThis !== 'undefined'
+          ? globalThis
+          : typeof self !== 'undefined'
+          ? self
+          : typeof window !== 'undefined'
+          ? window
+          : typeof global !== 'undefined'
+          ? global
+          : {};
+  `;
+};
+const $parcel$defineInteropFlag = `
+function $parcel$defineInteropFlag(a) {
+  Object.defineProperty(a, '__esModule', {value: true, configurable: true});
+}
+`;
+const helpers = exports.helpers = {
+  $parcel$export,
+  $parcel$exportWildcard,
+  $parcel$interopDefault,
+  $parcel$global,
+  $parcel$defineInteropFlag
+};

package/lib/index.js

@@ -0,0 +1,153 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _plugin() {
+  const data = require("@atlaspack/plugin");
+  _plugin = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = require("@atlaspack/diagnostic");
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _DevPackager = require("./DevPackager");
+var _ScopeHoistingPackager = require("./ScopeHoistingPackager");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const CONFIG_SCHEMA = {
+  type: 'object',
+  properties: {
+    unstable_asyncBundleRuntime: {
+      type: 'boolean'
+    },
+    unstable_forceSkipWrapAssets: {
+      type: 'array',
+      items: {
+        type: 'string'
+      }
+    }
+  },
+  additionalProperties: false
+};
+var _default = exports.default = new (_plugin().Packager)({
+  async loadConfig({
+    config,
+    options
+  }) {
+    var _conf$contents, _conf$contents2;
+    let packageKey = '@atlaspack/packager-js';
+    let conf = await config.getConfigFrom(options.projectRoot + '/index', [], {
+      packageKey
+    });
+    if (conf !== null && conf !== void 0 && conf.contents) {
+      _utils().validateSchema.diagnostic(CONFIG_SCHEMA, {
+        data: conf === null || conf === void 0 ? void 0 : conf.contents,
+        source: await options.inputFS.readFile(conf.filePath, 'utf8'),
+        filePath: conf.filePath,
+        prependKey: `/${(0, _diagnostic().encodeJSONKeyComponent)(packageKey)}`
+      }, packageKey, `Invalid config for ${packageKey}`);
+    }
+
+    // Generate a name for the global parcelRequire function that is unique to this project.
+    // This allows multiple parcel builds to coexist on the same page.
+    let packageName = await config.getConfigFrom(options.projectRoot + '/index', [], {
+      packageKey: 'name'
+    });
+    let name = (packageName === null || packageName === void 0 ? void 0 : packageName.contents) ?? '';
+    return {
+      parcelRequireName: 'parcelRequire' + (0, _rust().hashString)(name).slice(-4),
+      unstable_asyncBundleRuntime: Boolean(conf === null || conf === void 0 || (_conf$contents = conf.contents) === null || _conf$contents === void 0 ? void 0 : _conf$contents.unstable_asyncBundleRuntime),
+      unstable_forceSkipWrapAssets: (conf === null || conf === void 0 || (_conf$contents2 = conf.contents) === null || _conf$contents2 === void 0 ? void 0 : _conf$contents2.unstable_forceSkipWrapAssets) ?? []
+    };
+  },
+  async package({
+    bundle,
+    bundleGraph,
+    getInlineBundleContents,
+    getSourceMapReference,
+    config,
+    options,
+    logger
+  }) {
+    // If this is a non-module script, and there is only one asset with no dependencies,
+    // then we don't need to package at all and can pass through the original code un-wrapped.
+    let contents, map;
+    if (bundle.env.sourceType === 'script') {
+      let entries = bundle.getEntryAssets();
+      if (entries.length === 1 && bundleGraph.getDependencies(entries[0]).length === 0) {
+        contents = await entries[0].getCode();
+        map = await entries[0].getMap();
+      }
+    }
+    if (contents == null) {
+      let packager = bundle.env.shouldScopeHoist ? new _ScopeHoistingPackager.ScopeHoistingPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).parcelRequireName, (0, _nullthrows().default)(config).unstable_asyncBundleRuntime, (0, _nullthrows().default)(config).unstable_forceSkipWrapAssets, logger) : new _DevPackager.DevPackager(options, bundleGraph, bundle, (0, _nullthrows().default)(config).parcelRequireName);
+      ({
+        contents,
+        map
+      } = await packager.package());
+    }
+    contents += '\n' + (await getSourceMapSuffix(getSourceMapReference, map));
+
+    // For library builds, we need to replace URL references with their final resolved paths.
+    // For non-library builds, this is handled in the JS runtime.
+    if (bundle.env.isLibrary) {
+      ({
+        contents,
+        map
+      } = (0, _utils().replaceURLReferences)({
+        bundle,
+        bundleGraph,
+        contents,
+        map,
+        getReplacement: s => JSON.stringify(s).slice(1, -1)
+      }));
+    }
+    return (0, _utils().replaceInlineReferences)({
+      bundle,
+      bundleGraph,
+      contents,
+      getInlineReplacement: (dependency, inlineType, content) => ({
+        from: `"${dependency.id}"`,
+        to: inlineType === 'string' ? JSON.stringify(content) : content
+      }),
+      getInlineBundleContents,
+      map
+    });
+  }
+});
+async function getSourceMapSuffix(getSourceMapReference, map) {
+  let sourcemapReference = await getSourceMapReference(map);
+  if (sourcemapReference != null) {
+    return '//# sourceMappingURL=' + sourcemapReference + '\n';
+  } else {
+    return '';
+  }
+}

package/lib/utils.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getSpecifier = getSpecifier;
+exports.isValidIdentifier = isValidIdentifier;
+exports.makeValidIdentifier = makeValidIdentifier;
+exports.replaceScriptDependencies = replaceScriptDependencies;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// This replaces __parcel__require__ references left by the transformer with
+// parcelRequire calls of the resolved asset id. This lets runtimes work within
+// script bundles, which must be outside the bundle wrapper so their variables are global.
+function replaceScriptDependencies(bundleGraph, bundle, code, map, parcelRequireName) {
+  let entry = (0, _nullthrows().default)(bundle.getMainEntry());
+  let dependencies = bundleGraph.getDependencies(entry);
+  let lineCount = 0;
+  let offset = 0;
+  let columnStartIndex = 0;
+  code = code.replace(/\n|__parcel__require__\(['"](.*?)['"]\)/g, (m, s, i) => {
+    if (m === '\n') {
+      columnStartIndex = i + offset + 1;
+      lineCount++;
+      return '\n';
+    }
+    let dep = (0, _nullthrows().default)(dependencies.find(d => getSpecifier(d) === s));
+    let resolved = (0, _nullthrows().default)(bundleGraph.getResolvedAsset(dep, bundle));
+    let publicId = bundleGraph.getAssetPublicId(resolved);
+    let replacement = `${parcelRequireName}("${publicId}")`;
+    if (map) {
+      let lengthDifference = replacement.length - m.length;
+      if (lengthDifference !== 0) {
+        map.offsetColumns(lineCount + 1, i + offset - columnStartIndex + m.length, lengthDifference);
+        offset += lengthDifference;
+      }
+    }
+    return replacement;
+  });
+  return code;
+}
+function getSpecifier(dep) {
+  if (typeof dep.meta.placeholder === 'string') {
+    return dep.meta.placeholder;
+  }
+  return dep.specifier;
+}
+
+// https://262.ecma-international.org/6.0/#sec-names-and-keywords
+const IDENTIFIER_RE = /^[$_\p{ID_Start}][$_\u200C\u200D\p{ID_Continue}]*$/u;
+const ID_START_RE = /^[$_\p{ID_Start}]/u;
+const NON_ID_CONTINUE_RE = /[^$_\u200C\u200D\p{ID_Continue}]/gu;
+function isValidIdentifier(id) {
+  return IDENTIFIER_RE.test(id);
+}
+function makeValidIdentifier(name) {
+  name = name.replace(NON_ID_CONTINUE_RE, '');
+  if (!ID_START_RE.test(name)) {
+    name = '_' + name;
+  }
+  return name;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/packager-js",
-  "version": "2.14.0",
+  "version": "2.14.1-canary.6+57e29c592",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -12,19 +12,20 @@
   "main": "lib/index.js",
   "source": "src/index.js",
   "engines": {
-    "atlaspack": "^2.12.0",
+    "atlaspack": "2.14.1-canary.6+57e29c592",
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.0",
-    "@atlaspack/feature-flags": "2.14.0",
-    "@atlaspack/plugin": "2.14.0",
-    "@atlaspack/rust": "3.0.0",
+    "@atlaspack/diagnostic": "2.14.1-canary.6+57e29c592",
+    "@atlaspack/feature-flags": "2.14.1-canary.6+57e29c592",
+    "@atlaspack/plugin": "2.14.1-canary.6+57e29c592",
+    "@atlaspack/rust": "3.0.1-canary.6+57e29c592",
+    "@atlaspack/types": "2.14.1-canary.6+57e29c592",
+    "@atlaspack/utils": "2.14.1-canary.6+57e29c592",
     "@parcel/source-map": "^2.1.1",
-    "@atlaspack/types": "2.14.0",
-    "@atlaspack/utils": "2.14.0",
     "globals": "^13.2.0",
     "nullthrows": "^1.1.1"
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "gitHead": "57e29c592cff406d084b3c676a1c899f0bb6e78f"
 }