@atlaspack/core 2.24.1 → 2.24.2

package/dist/utils.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildAbortError = void 0;
+exports.getBundleGroupId = getBundleGroupId;
+exports.assertSignalNotAborted = assertSignalNotAborted;
+exports.getPublicId = getPublicId;
+exports.optionsProxy = optionsProxy;
+exports.hashFromOption = hashFromOption;
+exports.invalidateOnFileCreateToInternal = invalidateOnFileCreateToInternal;
+exports.createInvalidations = createInvalidations;
+exports.fromInternalSourceLocation = fromInternalSourceLocation;
+exports.toInternalSourceLocation = toInternalSourceLocation;
+exports.toInternalSymbols = toInternalSymbols;
+const assert_1 = __importDefault(require("assert"));
+const base_x_1 = __importDefault(require("base-x"));
+const utils_1 = require("@atlaspack/utils");
+const projectPath_1 = require("./projectPath");
+// /flow-to-ts helpers
+const base62 = (0, base_x_1.default)('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
+function getBundleGroupId(bundleGroup) {
+    return 'bundle_group:' + bundleGroup.target.name + bundleGroup.entryAssetId;
+}
+function assertSignalNotAborted(signal) {
+    if (signal && signal.aborted) {
+        throw new BuildAbortError();
+    }
+}
+class BuildAbortError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'BuildAbortError';
+    }
+}
+exports.BuildAbortError = BuildAbortError;
+function getPublicId(id, alreadyExists) {
+    let encoded = base62.encode(Buffer.from(id, 'hex'));
+    for (let end = 5; end <= encoded.length; end++) {
+        let candidate = encoded.slice(0, end);
+        if (!alreadyExists(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error('Original id was not unique');
+}
+// These options don't affect compilation and should cause invalidations
+const ignoreOptions = new Set([
+    'env', // handled by separate invalidateOnEnvChange
+    'inputFS',
+    'outputFS',
+    'workerFarm',
+    'packageManager',
+    'detailedReport',
+    'shouldDisableCache',
+    'cacheDir',
+    'shouldAutoInstall',
+    'logLevel',
+    'shouldProfile',
+    'shouldTrace',
+    'shouldPatchConsole',
+    'projectRoot',
+    'additionalReporters',
+]);
+function optionsProxy(options, invalidateOnOptionChange, addDevDependency) {
+    let packageManager = addDevDependency
+        ? proxyPackageManager(options.projectRoot, options.packageManager, addDevDependency)
+        : options.packageManager;
+    return new Proxy(options, {
+        get(target, prop) {
+            if (prop === 'packageManager') {
+                return packageManager;
+            }
+            if (!ignoreOptions.has(prop)) {
+                invalidateOnOptionChange(prop);
+            }
+            // @ts-expect-error TS7053
+            return target[prop];
+        },
+    });
+}
+function proxyPackageManager(projectRoot, packageManager, addDevDependency) {
+    let require = (id, from, opts) => {
+        addDevDependency({
+            specifier: id,
+            resolveFrom: (0, projectPath_1.toProjectPath)(projectRoot, from),
+            range: opts?.range,
+        });
+        return packageManager.require(id, from, opts);
+    };
+    return new Proxy(packageManager, {
+        get(target, prop) {
+            if (prop === 'require') {
+                return require;
+            }
+            // @ts-expect-error TS7053
+            return target[prop];
+        },
+    });
+}
+function hashFromOption(value) {
+    if (typeof value === 'object' && value != null) {
+        // @ts-expect-error TS2345
+        return (0, utils_1.hashObject)(value);
+    }
+    return String(value);
+}
+function invalidateOnFileCreateToInternal(projectRoot, invalidation) {
+    // @ts-expect-error TS2339
+    if (invalidation.glob != null) {
+        // @ts-expect-error TS2339
+        return { glob: (0, projectPath_1.toProjectPath)(projectRoot, invalidation.glob) };
+        // @ts-expect-error TS2339
+    }
+    else if (invalidation.filePath != null) {
+        return {
+            // @ts-expect-error TS2339
+            filePath: (0, projectPath_1.toProjectPath)(projectRoot, invalidation.filePath),
+        };
+    }
+    else {
+        (0, assert_1.default)(
+        // @ts-expect-error TS2339
+        invalidation.aboveFilePath != null && invalidation.fileName != null);
+        return {
+            // @ts-expect-error TS2339
+            fileName: invalidation.fileName,
+            // @ts-expect-error TS2339
+            aboveFilePath: (0, projectPath_1.toProjectPath)(projectRoot, invalidation.aboveFilePath),
+        };
+    }
+}
+function createInvalidations() {
+    return {
+        invalidateOnBuild: false,
+        invalidateOnStartup: false,
+        invalidateOnOptionChange: new Set(),
+        invalidateOnEnvChange: new Set(),
+        invalidateOnFileChange: new Set(),
+        invalidateOnFileCreate: [],
+    };
+}
+function fromInternalSourceLocation(projectRoot, loc) {
+    if (!loc)
+        return loc;
+    return {
+        filePath: (0, projectPath_1.fromProjectPath)(projectRoot, loc.filePath),
+        start: loc.start,
+        end: loc.end,
+    };
+}
+function toInternalSourceLocation(projectRoot, loc) {
+    if (!loc)
+        return loc;
+    return {
+        filePath: (0, projectPath_1.toProjectPath)(projectRoot, loc.filePath),
+        start: loc.start,
+        end: loc.end,
+    };
+}
+function toInternalSymbols(projectRoot, symbols) {
+    if (!symbols)
+        return symbols;
+    return new Map([...symbols].map(([k, { loc, ...v }]) => [
+        k,
+        {
+            ...v,
+            loc: toInternalSourceLocation(projectRoot, loc),
+        },
+    ]));
+}

package/dist/worker.js

@@ -0,0 +1,123 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearWorkerBuildCaches = clearWorkerBuildCaches;
+exports.runTransform = runTransform;
+exports.runValidate = runValidate;
+exports.runPackage = runPackage;
+exports.childInit = childInit;
+exports.invalidateRequireCache = invalidateRequireCache;
+exports.ping = ping;
+const utils_1 = require("@atlaspack/utils");
+const assert_1 = __importDefault(require("assert"));
+const nullthrows_1 = __importDefault(require("nullthrows"));
+const BundleGraph_1 = __importDefault(require("./BundleGraph"));
+const Transformation_1 = __importDefault(require("./Transformation"));
+const ReporterRunner_1 = require("./ReporterRunner");
+const PackagerRunner_1 = __importDefault(require("./PackagerRunner"));
+const Validation_1 = __importDefault(require("./Validation"));
+const AtlaspackConfig_1 = require("./AtlaspackConfig");
+const registerCoreWithSerializer_1 = require("./registerCoreWithSerializer");
+const build_cache_1 = require("@atlaspack/build-cache");
+const source_map_1 = require("@parcel/source-map");
+// @ts-expect-error TS2305
+const rust_1 = require("@atlaspack/rust");
+const workers_1 = __importDefault(require("@atlaspack/workers"));
+const feature_flags_1 = require("@atlaspack/feature-flags");
+require("@atlaspack/cache"); // register with serializer
+require("@atlaspack/package-manager");
+require("@atlaspack/fs");
+// /flow-to-ts helpers
+(0, registerCoreWithSerializer_1.registerCoreWithSerializer)();
+// TODO: this should eventually be replaced by an in memory cache layer
+let atlaspackConfigCache = new Map();
+function loadOptions(ref, workerApi) {
+    return (0, nullthrows_1.default)(workerApi.getSharedReference(ref));
+}
+async function loadConfig(cachePath, options) {
+    let config = atlaspackConfigCache.get(cachePath);
+    if (config && config.options === options) {
+        return config;
+    }
+    let processedConfig = (0, nullthrows_1.default)(await options.cache.get(cachePath));
+    config = new AtlaspackConfig_1.AtlaspackConfig(processedConfig, options);
+    atlaspackConfigCache.set(cachePath, config);
+    (0, feature_flags_1.setFeatureFlags)(options.featureFlags);
+    return config;
+}
+function clearWorkerBuildCaches() {
+    utils_1.loadConfig.clear();
+    (0, build_cache_1.clearBuildCaches)();
+}
+async function runTransform(workerApi, opts) {
+    let { optionsRef, configCachePath, ...rest } = opts;
+    let options = loadOptions(optionsRef, workerApi);
+    let config = await loadConfig(configCachePath, options);
+    return new Transformation_1.default({
+        workerApi,
+        options,
+        // @ts-expect-error TS2783
+        config,
+        ...rest,
+    }).run();
+}
+async function runValidate(workerApi, opts) {
+    let { optionsRef, configCachePath, ...rest } = opts;
+    let options = loadOptions(optionsRef, workerApi);
+    let config = await loadConfig(configCachePath, options);
+    return new Validation_1.default({
+        workerApi,
+        // @ts-expect-error TS2783
+        report: ReporterRunner_1.reportWorker.bind(null, workerApi),
+        options,
+        // @ts-expect-error TS2783
+        config,
+        ...rest,
+    }).run();
+}
+async function runPackage(workerApi, { bundle, bundleGraphReference, configCachePath, optionsRef, previousDevDeps, invalidDevDeps, previousInvalidations, }) {
+    let bundleGraph = workerApi.getSharedReference(bundleGraphReference);
+    (0, assert_1.default)(bundleGraph instanceof BundleGraph_1.default);
+    let options = loadOptions(optionsRef, workerApi);
+    let atlaspackConfig = await loadConfig(configCachePath, options);
+    let runner = new PackagerRunner_1.default({
+        config: atlaspackConfig,
+        options,
+        // @ts-expect-error TS2322
+        report: workers_1.default.isWorker() ? ReporterRunner_1.reportWorker.bind(null, workerApi) : ReporterRunner_1.report,
+        previousDevDeps,
+        previousInvalidations,
+    });
+    return runner.run(bundleGraph, bundle, invalidDevDeps);
+}
+async function childInit() {
+    await source_map_1.init;
+    await (0, rust_1.init)?.();
+}
+const PKG_RE = /node_modules[/\\]((?:@[^/\\]+[/\\][^/\\]+)|[^/\\]+)(?!.*[/\\]node_modules[/\\])/;
+function invalidateRequireCache(workerApi, file) {
+    if (process.env.ATLASPACK_BUILD_ENV === 'test') {
+        // Delete this module and all children in the same node_modules folder
+        let module = require.cache[file];
+        if (module) {
+            delete require.cache[file];
+            let pkg = file.match(PKG_RE)?.[1];
+            for (let child of module.children) {
+                if (pkg === child.id.match(PKG_RE)?.[1]) {
+                    invalidateRequireCache(workerApi, child.id);
+                }
+            }
+        }
+        atlaspackConfigCache.clear();
+        return;
+    }
+    throw new Error('invalidateRequireCache is only for tests');
+}
+/**
+ * This is used to wait until workers are responding to messages.
+ */
+function ping() {
+    return true;
+}

package/lib/AssetGraph.js

@@ -129,6 +129,7 @@ class AssetGraph extends _graph().ContentGraph {
         disableIncrementalBundling,
         ...rest
       } = opts;
+      // @ts-expect-error TS2345
       super(rest);
       this.hash = hash;
       this.#bundlingVersion = bundlingVersion ?? 0;

package/lib/SymbolPropagation.js

@@ -4,13 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.propagateSymbols = propagateSymbols;
-function _featureFlags() {
-  const data = require("@atlaspack/feature-flags");
-  _featureFlags = function () {
-    return data;
-  };
-  return data;
-}
 function _assert() {
   const data = _interopRequireDefault(require("assert"));
   _assert = function () {
@@ -79,11 +72,9 @@ function propagateSymbols({
 
     // Propagate the requested symbols down from the root to the leaves
     propagateSymbolsDown(assetGraph, changedAssets, assetGroupsWithRemovedParents, (assetNode, incomingDeps, outgoingDeps) => {
-      if ((0, _featureFlags().getFeatureFlag)('emptyFileStarRexportFix')) {
-        if (assetNode.value.meta.emptyFileStarReexport && incomingDeps.every(d => d.value.specifierType === _types.SpecifierType.esm)) {
-          var _assetNode$value$symb;
-          (_assetNode$value$symb = assetNode.value.symbols) === null || _assetNode$value$symb === void 0 || _assetNode$value$symb.delete('*');
-        }
+      if (assetNode.value.meta.emptyFileStarReexport && incomingDeps.every(d => d.value.specifierType === _types.SpecifierType.esm)) {
+        var _assetNode$value$symb;
+        (_assetNode$value$symb = assetNode.value.symbols) === null || _assetNode$value$symb === void 0 || _assetNode$value$symb.delete('*');
       }
 
       // exportSymbol -> identifier

package/lib/worker.js

@@ -84,13 +84,6 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 // flow-to-ts helpers
 
 // /flow-to-ts helpers
-// @ts-expect-error TS2339
-if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
-  /* eslint-disable import/no-extraneous-dependencies, monorepo/no-internal-import */
-  require('@atlaspack/repl/src/atlaspack/BrowserPackageManager.js');
-  require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
-  /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
-}
 
 (0, _registerCoreWithSerializer.registerCoreWithSerializer)();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.24.1",
+  "version": "2.24.2",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -19,26 +19,25 @@
     "test": "mocha",
     "test-ci": "mocha",
     "generate-ts": "tsc --emitDeclarationOnly",
-    "check-ts": "tsc --emitDeclarationOnly --rootDir src",
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
   },
   "dependencies": {
     "@mischnic/json-sourcemap": "^0.1.0",
     "@atlaspack/build-cache": "2.13.6",
-    "@atlaspack/cache": "3.2.26",
+    "@atlaspack/cache": "3.2.27",
     "@atlaspack/diagnostic": "2.14.4",
     "@atlaspack/events": "2.14.4",
-    "@atlaspack/feature-flags": "2.25.1",
-    "@atlaspack/fs": "2.15.26",
-    "@atlaspack/graph": "3.5.20",
-    "@atlaspack/logger": "2.14.23",
-    "@atlaspack/package-manager": "2.14.31",
-    "@atlaspack/plugin": "2.14.31",
-    "@atlaspack/profiler": "2.14.28",
-    "@atlaspack/rust": "3.8.1",
-    "@atlaspack/types": "2.15.21",
-    "@atlaspack/utils": "2.19.3",
-    "@atlaspack/workers": "2.14.31",
+    "@atlaspack/feature-flags": "2.25.2",
+    "@atlaspack/fs": "2.15.27",
+    "@atlaspack/graph": "3.5.21",
+    "@atlaspack/logger": "2.14.24",
+    "@atlaspack/package-manager": "2.14.32",
+    "@atlaspack/plugin": "2.14.32",
+    "@atlaspack/profiler": "2.14.29",
+    "@atlaspack/rust": "3.8.2",
+    "@atlaspack/types": "2.15.22",
+    "@atlaspack/utils": "3.0.0",
+    "@atlaspack/workers": "2.14.32",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",

package/src/AssetGraph.ts

@@ -140,6 +140,7 @@ export default class AssetGraph extends ContentGraph<AssetGraphNode> {
   constructor(opts?: AssetGraphOpts | null) {
     if (opts) {
       let {hash, bundlingVersion, disableIncrementalBundling, ...rest} = opts;
+      // @ts-expect-error TS2345
       super(rest);
       this.hash = hash;
       this.#bundlingVersion = bundlingVersion ?? 0;

package/src/SymbolPropagation.ts

@@ -61,15 +61,11 @@ export function propagateSymbols({
       changedAssets,
       assetGroupsWithRemovedParents,
       (assetNode, incomingDeps, outgoingDeps) => {
-        if (getFeatureFlag('emptyFileStarRexportFix')) {
-          if (
-            assetNode.value.meta.emptyFileStarReexport &&
-            incomingDeps.every(
-              (d) => d.value.specifierType === SpecifierType.esm,
-            )
-          ) {
-            assetNode.value.symbols?.delete('*');
-          }
+        if (
+          assetNode.value.meta.emptyFileStarReexport &&
+          incomingDeps.every((d) => d.value.specifierType === SpecifierType.esm)
+        ) {
+          assetNode.value.symbols?.delete('*');
         }
 
         // exportSymbol -> identifier

package/src/worker.ts

@@ -39,14 +39,6 @@ export type Diff<T extends U, U extends object> = Pick<
 >;
 // /flow-to-ts helpers
 
-// @ts-expect-error TS2339
-if (process.env.ATLASPACK_BUILD_REPL && process.browser) {
-  /* eslint-disable import/no-extraneous-dependencies, monorepo/no-internal-import */
-  require('@atlaspack/repl/src/atlaspack/BrowserPackageManager.js');
-  require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
-  /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
-}
-
 registerCoreWithSerializer();
 
 // Remove the workerApi type from the TransformationOpts and ValidationOpts types:

package/tsconfig.json

@@ -1,4 +1,57 @@
 {
-  "extends": "../../../tsconfig.json",
-  "include": ["src"]
+  "extends": "../../../tsconfig.base.json",
+  "include": ["./src/", "./package.json"],
+  "compilerOptions": {
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../../dev/babel-register/tsconfig.json"
+    },
+    {
+      "path": "../../utils/events/tsconfig.json"
+    },
+    {
+      "path": "../build-cache/tsconfig.json"
+    },
+    {
+      "path": "../cache/tsconfig.json"
+    },
+    {
+      "path": "../diagnostic/tsconfig.json"
+    },
+    {
+      "path": "../feature-flags/tsconfig.json"
+    },
+    {
+      "path": "../fs/tsconfig.json"
+    },
+    {
+      "path": "../graph/tsconfig.json"
+    },
+    {
+      "path": "../logger/tsconfig.json"
+    },
+    {
+      "path": "../package-manager/tsconfig.json"
+    },
+    {
+      "path": "../plugin/tsconfig.json"
+    },
+    {
+      "path": "../profiler/tsconfig.json"
+    },
+    {
+      "path": "../rust/tsconfig.json"
+    },
+    {
+      "path": "../types/tsconfig.json"
+    },
+    {
+      "path": "../utils/tsconfig.json"
+    },
+    {
+      "path": "../workers/tsconfig.json"
+    }
+  ]
 }