@atlaspack/packager-js 2.14.5-canary.35 → 2.14.5-canary.350

package/dist/helpers.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.helpers = exports.bundleQueuePrelude = exports.fnExpr = exports.preludeNew = exports.preludeOld = void 0;
+const preludeOld = (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.preludeOld = preludeOld;
+const preludeNew = (parcelRequireName) => `
+var $parcel$modules = {};
+var $parcel$inits = {};
+
+var parcelRequire = $parcel$global[${JSON.stringify(parcelRequireName)}];
+
+if (parcelRequire == null) {
+  parcelRequire = function(id) {
+    var mod = $parcel$modules[id];
+    if (mod !== undefined) {
+      return mod.exports;
+    }
+    var init = $parcel$inits[id];
+    if (init !== undefined) {
+      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.preludeNew = preludeNew;
+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 = ${(0, exports.fnExpr)(env, ['bundle'], ['$parcel$global.lb.add(bundle);', '$parcel$global.pq();'])}
+
+  // Run when ready
+  $parcel$global.rwr = ${(0, exports.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 = ${(0, exports.fnExpr)(env, [], [
+    `var runnableEntry = $parcel$global.bq.find(${(0, exports.fnExpr)(env, ['i'], [
+        `return i.d.every(${(0, exports.fnExpr)(env, ['dep'], ['return $parcel$global.lb.has(dep);'])});`,
+    ])});`,
+    'if (runnableEntry) {',
+    `$parcel$global.bq = $parcel$global.bq.filter(${(0, exports.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});
+}
+`;
+exports.helpers = {
+    $parcel$export,
+    $parcel$exportWildcard,
+    $parcel$interopDefault,
+    $parcel$global,
+    $parcel$defineInteropFlag,
+};

package/dist/index.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin_1 = require("@atlaspack/plugin");
+const utils_1 = require("@atlaspack/utils");
+const diagnostic_1 = require("@atlaspack/diagnostic");
+const rust_1 = require("@atlaspack/rust");
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const DevPackager_1 = require("./DevPackager");
+const ScopeHoistingPackager_1 = require("./ScopeHoistingPackager");
+const CONFIG_SCHEMA = {
+    type: 'object',
+    properties: {
+        unstable_asyncBundleRuntime: {
+            type: 'boolean',
+        },
+        unstable_manualStaticBindingExports: {
+            type: 'array',
+            items: {
+                type: 'string',
+            },
+        },
+    },
+    additionalProperties: false,
+};
+exports.default = new plugin_1.Packager({
+    async loadConfig({ config, options }) {
+        let packageKey = '@atlaspack/packager-js';
+        let conf = await config.getConfigFrom(options.projectRoot + '/index', [], {
+            packageKey,
+        });
+        if (conf?.contents) {
+            utils_1.validateSchema.diagnostic(CONFIG_SCHEMA, {
+                data: conf?.contents,
+                source: () => options.inputFS.readFileSync(conf.filePath, 'utf8'),
+                filePath: conf.filePath,
+                prependKey: `/${(0, diagnostic_1.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?.contents ?? '';
+        return {
+            parcelRequireName: 'parcelRequire' + (0, rust_1.hashString)(name).slice(-4),
+            unstable_asyncBundleRuntime: Boolean(conf?.contents?.unstable_asyncBundleRuntime),
+            unstable_manualStaticBindingExports: conf?.contents?.unstable_manualStaticBindingExports ?? null,
+        };
+    },
+    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;
+        let scopeHoistingStats;
+        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) {
+            if (bundle.env.shouldScopeHoist) {
+                let packager = new ScopeHoistingPackager_1.ScopeHoistingPackager(options, bundleGraph, bundle, (0, nullthrows_1.default)(config).parcelRequireName, (0, nullthrows_1.default)(config).unstable_asyncBundleRuntime, (0, nullthrows_1.default)(config).unstable_manualStaticBindingExports, logger);
+                let packageResult = await packager.package();
+                ({ contents, map } = packageResult);
+                scopeHoistingStats = packageResult.scopeHoistingStats;
+            }
+            else {
+                let packager = new DevPackager_1.DevPackager(options, bundleGraph, bundle, (0, nullthrows_1.default)(config).parcelRequireName);
+                let packageResult = await packager.package();
+                ({ contents, map } = packageResult);
+            }
+        }
+        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_1.replaceURLReferences)({
+                bundle,
+                bundleGraph,
+                contents,
+                map,
+                getReplacement: (s) => JSON.stringify(s).slice(1, -1),
+            }));
+        }
+        let result = await (0, utils_1.replaceInlineReferences)({
+            bundle,
+            bundleGraph,
+            contents,
+            getInlineReplacement: (dependency, inlineType, content) => ({
+                from: `"${dependency.id}"`,
+                to: inlineType === 'string' ? JSON.stringify(content) : content,
+            }),
+            getInlineBundleContents,
+            map,
+        });
+        if (utils_1.debugTools['scope-hoisting-stats']) {
+            return { ...result, scopeHoistingStats };
+        }
+        return result;
+    },
+});
+async function getSourceMapSuffix(getSourceMapReference, map) {
+    let sourcemapReference = await getSourceMapReference(map);
+    if (sourcemapReference != null) {
+        return '//# sourceMappingURL=' + sourcemapReference + '\n';
+    }
+    else {
+        return '';
+    }
+}

package/dist/utils.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceScriptDependencies = replaceScriptDependencies;
+exports.getSpecifier = getSpecifier;
+exports.isValidIdentifier = isValidIdentifier;
+exports.makeValidIdentifier = makeValidIdentifier;
+const nullthrows_1 = __importDefault(require("nullthrows"));
+// 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_1.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_1.default)(dependencies.find((d) => getSpecifier(d) === s));
+        let resolved = (0, nullthrows_1.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/lib/DevPackager.js

@@ -12,12 +12,19 @@ function _utils() {
   return data;
 }
 function _sourceMap() {
-  const data = _interopRequireDefault(require("@parcel/source-map"));
+  const data = _interopRequireDefault(require("@atlaspack/source-map"));
   _sourceMap = function () {
     return data;
   };
   return data;
 }
+function _featureFlags() {
+  const data = require("@atlaspack/feature-flags");
+  _featureFlags = function () {
+    return data;
+  };
+  return data;
+}
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
   _assert = function () {
@@ -91,6 +98,7 @@ class DevPackager {
         // If this is the main entry of a script rather than a module, we need to hoist it
         // outside the bundle wrapper function so that its variables are exposed as globals.
         if (this.bundle.env.sourceType === 'script' && asset === this.bundle.getMainEntry()) {
+          // @ts-expect-error TS2322
           script = results[i++];
           return;
         }
@@ -108,6 +116,19 @@ class DevPackager {
             deps[specifier] = dep.specifier;
           }
         }
+        if ((0, _featureFlags().getFeatureFlag)('hmrImprovements')) {
+          // Add dependencies for parcelRequire calls added by runtimes
+          // so that the HMR runtime can correctly traverse parents.
+          let hmrDeps = asset.meta.hmrDeps;
+          if (this.options.hmrOptions && Array.isArray(hmrDeps)) {
+            for (let id of hmrDeps) {
+              (0, _assert().default)(typeof id === 'string');
+              deps[id] = id;
+            }
+          }
+        }
+
+        // @ts-expect-error TS2339
         let {
           code,
           mapBuffer
@@ -152,11 +173,14 @@ class DevPackager {
     // runtimes with a parcelRequire call.
     if (this.bundle.env.sourceType === 'script' && script) {
       let entryMap;
+      // @ts-expect-error TS2339
       let mapBuffer = script.mapBuffer;
       if (mapBuffer) {
         entryMap = new (_sourceMap().default)(this.options.projectRoot, mapBuffer);
       }
-      contents += (0, _utils2.replaceScriptDependencies)(this.bundleGraph, this.bundle, script.code, entryMap, this.parcelRequireName);
+      contents += (0, _utils2.replaceScriptDependencies)(this.bundleGraph, this.bundle,
+      // @ts-expect-error TS2339
+      script.code, entryMap, this.parcelRequireName);
       if (this.bundle.env.sourceMap && entryMap) {
         map.addSourceMap(entryMap, lineOffset);
       }
@@ -175,7 +199,7 @@ class DevPackager {
       interpreter = _interpreter;
     }
     let importScripts = '';
-    if (this.bundle.env.isWorker()) {
+    if (this.bundle.env.isWorker() || this.bundle.env.isTesseract()) {
       let bundles = this.bundleGraph.getReferencedBundles(this.bundle);
       for (let b of bundles) {
         importScripts += `importScripts("${(0, _utils().relativeBundlePath)(this.bundle, b)}");\n`;
@@ -187,7 +211,7 @@ class DevPackager {
     );
   }
   isEntry() {
-    return !this.bundleGraph.hasParentBundleOfType(this.bundle, 'js') || this.bundle.env.isIsolated() || this.bundle.bundleBehavior === 'isolated';
+    return !this.bundleGraph.hasParentBundleOfType(this.bundle, 'js') || this.bundle.env.isIsolated() || this.bundle.bundleBehavior === 'isolated' || this.bundle.bundleBehavior === 'inlineIsolated';
   }
 }
 exports.DevPackager = DevPackager;

package/lib/ESMOutputFormat.js

@@ -75,7 +75,7 @@ class ESMOutputFormat {
       local,
       exportAs
     } of this.packager.exportedSymbols.values()) {
-      if (this.packager.wrappedAssets.has(asset.id)) {
+      if (this.packager.wrappedAssets.has(asset)) {
         let obj = `parcelRequire("${this.packager.bundleGraph.getAssetPublicId(asset)}")`;
         res += `\nvar ${local} = ${this.packager.getPropertyAccess(obj, exportSymbol)};`;
         lines++;