@atlaspack/core 2.24.1 → 2.24.2-dev-ts-project-refs-d30e9754f.0

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,130 @@
+"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
+// @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_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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.24.1",
+  "version": "2.24.2-dev-ts-project-refs-d30e9754f.0",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -11,7 +11,7 @@
   },
   "main": "./lib/index.js",
   "source": "./src/index.ts",
-  "types": "./lib/types/index.d.ts",
+  "types": "./lib/types/src/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
@@ -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": {
+    "@atlaspack/build-cache": "2.13.7-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/cache": "3.2.27-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/diagnostic": "2.14.5-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/events": "2.14.5-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/feature-flags": "2.25.2-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/fs": "2.15.27-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/graph": "3.5.21-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/logger": "2.14.24-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/package-manager": "2.14.32-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/plugin": "2.14.32-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/profiler": "2.14.29-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/rust": "3.8.2-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/types": "2.15.22-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/utils": "2.19.4-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/workers": "2.14.32-dev-ts-project-refs-d30e9754f.0",
     "@mischnic/json-sourcemap": "^0.1.0",
-    "@atlaspack/build-cache": "2.13.6",
-    "@atlaspack/cache": "3.2.26",
-    "@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",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
     "browserslist": "^4.6.6",
@@ -51,15 +50,16 @@
     "semver": "^7.5.2"
   },
   "devDependencies": {
-    "@atlaspack/babel-register": "2.14.4",
+    "@atlaspack/babel-register": "2.14.5-dev-ts-project-refs-d30e9754f.0",
     "@types/node": ">= 18",
-    "rfdc": "1",
-    "jest-diff": "*",
     "graphviz": "^0.0.9",
+    "jest-diff": "*",
+    "rfdc": "1",
     "tempy": "^0.2.1"
   },
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "gitHead": "d30e9754f8d423d53261ec54ec87e6fa1299578a"
 }

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/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"
+    }
+  ]
 }