@atlaspack/packager-js 2.23.1 → 2.23.2

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,101 @@
+"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',
+        },
+    },
+    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: await options.inputFS.readFile(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 {
+            // @ts-expect-error TS2345
+            parcelRequireName: 'parcelRequire' + (0, rust_1.hashString)(name).slice(-4),
+            unstable_asyncBundleRuntime: Boolean(
+            // @ts-expect-error TS2339
+            conf?.contents?.unstable_asyncBundleRuntime),
+        };
+    },
+    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_1.ScopeHoistingPackager(options, bundleGraph, bundle, (0, nullthrows_1.default)(config).parcelRequireName, (0, nullthrows_1.default)(config).unstable_asyncBundleRuntime, logger)
+                : new DevPackager_1.DevPackager(options, bundleGraph, bundle, (0, nullthrows_1.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_1.replaceURLReferences)({
+                bundle,
+                bundleGraph,
+                contents,
+                map,
+                getReplacement: (s) => JSON.stringify(s).slice(1, -1),
+            }));
+        }
+        return (0, utils_1.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/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/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++;