@atlaspack/core 2.12.1-canary.3478 → 2.12.1-canary.3480

package/lib/atlaspack-v3/worker/compat/plugin-config.js

@@ -4,55 +4,75 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.PluginConfig = void 0;
+var _Config = _interopRequireDefault(require("../../../public/Config"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 class PluginConfig {
+  #projectRoot;
+  #inner;
   constructor({
     env,
     isSource,
-    searchPath
+    searchPath,
+    projectRoot,
+    fs,
+    packageManager
   }) {
     this.env = env;
     this.isSource = isSource;
     this.searchPath = searchPath;
+    this.#inner = new _Config.default(
+    // $FlowFixMe
+    {
+      invalidateOnConfigKeyChange: [],
+      invalidateOnFileCreate: [],
+      invalidateOnFileChange: new Set(),
+      devDeps: [],
+      // $FlowFixMe
+      searchPath: searchPath.replace(projectRoot + '/', '')
+    },
+    // $FlowFixMe
+    {
+      projectRoot,
+      inputFS: fs,
+      outputFS: fs,
+      packageManager
+    });
   }
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileChange() {
-    throw new Error('PluginOptions.invalidateOnFileChange');
-  }
+  invalidateOnFileChange() {}
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileCreate() {
-    throw new Error('PluginOptions.invalidateOnFileCreate');
-  }
+  invalidateOnFileCreate() {}
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnEnvChange() {
-    throw new Error('PluginOptions.invalidateOnEnvChange');
-  }
-  invalidateOnStartup() {
-    throw new Error('PluginOptions.invalidateOnStartup');
-  }
-  invalidateOnBuild() {
-    throw new Error('PluginOptions.invalidateOnBuild');
-  }
+  invalidateOnEnvChange() {}
+  invalidateOnStartup() {}
+  invalidateOnBuild() {}
 
   // eslint-disable-next-line no-unused-vars
-  addDevDependency() {
-    throw new Error('PluginOptions.addDevDependency');
-  }
+  addDevDependency() {}
 
   // eslint-disable-next-line no-unused-vars
-  setCacheKey() {
-    throw new Error('PluginOptions.setCacheKey');
-  }
-  getConfig() {
-    throw new Error('PluginOptions.getConfig');
+  setCacheKey() {}
+  getConfig(
+  // eslint-disable-next-line no-unused-vars
+  filePaths,
+  // eslint-disable-next-line no-unused-vars
+  options) {
+    return this.#inner.getConfig(filePaths, options);
   }
-  getConfigFrom() {
-    throw new Error('PluginOptions.getConfigFrom');
+  getConfigFrom(
+  // eslint-disable-next-line no-unused-vars
+  searchPath,
+  // eslint-disable-next-line no-unused-vars
+  filePaths,
+  // eslint-disable-next-line no-unused-vars
+  options) {
+    return this.#inner.getConfigFrom(searchPath, filePaths, options);
   }
   getPackage() {
-    throw new Error('PluginOptions.getPackage');
+    return this.#inner.getPackage();
   }
 }
 exports.PluginConfig = PluginConfig;

package/lib/atlaspack-v3/worker/worker.js

@@ -96,7 +96,7 @@ class AtlaspackWorker {
     dependency: napiDependency,
     specifier,
     pipeline,
-    options
+    pluginOptions
   }) => {
     const state = this.#resolvers.get(key);
     if (!state) {
@@ -104,7 +104,7 @@ class AtlaspackWorker {
     }
     let packageManager = state.packageManager;
     if (!packageManager) {
-      packageManager = new (_packageManager().NodePackageManager)(this.#fs, options.projectRoot);
+      packageManager = new (_packageManager().NodePackageManager)(this.#fs, pluginOptions.projectRoot);
       state.packageManager = packageManager;
     }
     const env = new _compat.Environment(napiDependency.env);
@@ -113,7 +113,7 @@ class AtlaspackWorker {
       logger: new _compat.PluginLogger(),
       tracer: new _compat.PluginTracer(),
       options: new _compat.PluginOptions({
-        ...options,
+        ...pluginOptions,
         packageManager,
         shouldAutoInstall: false,
         inputFS: this.#fs,
@@ -126,7 +126,10 @@ class AtlaspackWorker {
         config: new _compat.PluginConfig({
           env,
           isSource: true,
-          searchPath: ''
+          searchPath: specifier,
+          projectRoot: pluginOptions.projectRoot,
+          fs: this.#fs,
+          packageManager
         }),
         ...defaultOptions
       }));
@@ -198,7 +201,10 @@ class AtlaspackWorker {
       config: new _compat.PluginConfig({
         env,
         isSource: true,
-        searchPath: ''
+        searchPath: innerAsset.filePath.replace(options.projectRoot + '/', ''),
+        projectRoot: options.projectRoot,
+        fs: this.#fs,
+        packageManager
       }),
       ...defaultOptions
     }));

package/lib/requests/AssetGraphRequestRust.js

@@ -18,7 +18,15 @@ function _diagnostic() {
   };
   return data;
 }
+function _rust() {
+  const data = require("@atlaspack/rust");
+  _rust = function () {
+    return data;
+  };
+  return data;
+}
 var _AssetGraph = _interopRequireWildcard(require("../AssetGraph"));
+var _constants = require("../constants");
 var _projectPath = require("../projectPath");
 var _RequestTracker = require("../RequestTracker");
 var _SymbolPropagation = require("../SymbolPropagation");
@@ -163,6 +171,12 @@ function getAssetGraph(serializedGraph, options) {
         filePath: (0, _projectPath.toProjectPath)(options.projectRoot, asset.filePath),
         symbols: asset.symbols != null ? new Map(asset.symbols.map(mapSymbols)) : null
       };
+      if (asset.map) {
+        let mapKey = (0, _rust().hashString)(`${_constants.ATLASPACK_VERSION}:map:${asset.id}`);
+        asset.mapKey = mapKey;
+        options.cache.setBlob(mapKey, asset.map);
+        delete asset.map;
+      }
       cachedAssets.set(id, asset.code);
       changedAssets.set(id, asset);
       graph.addNodeByContentKey(id, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-canary.3478+7832352eb",
+  "version": "2.12.1-canary.3480+cce14fe9d",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -20,21 +20,21 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/cache": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/diagnostic": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/events": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/feature-flags": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/fs": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/graph": "3.2.1-canary.3478+7832352eb",
-    "@atlaspack/logger": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/package-manager": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/plugin": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/profiler": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/rust": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/types": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/utils": "2.12.1-canary.3478+7832352eb",
-    "@atlaspack/workers": "2.12.1-canary.3478+7832352eb",
+    "@atlaspack/build-cache": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/cache": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/diagnostic": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/events": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/feature-flags": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/fs": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/graph": "3.2.1-canary.3480+cce14fe9d",
+    "@atlaspack/logger": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/package-manager": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/plugin": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/profiler": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/rust": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/types": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/utils": "2.12.1-canary.3480+cce14fe9d",
+    "@atlaspack/workers": "2.12.1-canary.3480+cce14fe9d",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -65,5 +65,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "7832352eb05e5982f2221de5666d8ae0a6e9cb30"
+  "gitHead": "cce14fe9d03ac450dee42be4d0d4ab7d1e15bd68"
 }

package/src/atlaspack-v3/worker/compat/plugin-config.js

@@ -8,57 +8,78 @@ import type {
   FileCreateInvalidation,
   ConfigResultWithFilePath,
   PackageJSON,
+  PackageManager as IPackageManager,
 } from '@atlaspack/types';
 
+import type {FileSystem as IFileSystem} from '@atlaspack/fs';
+import ClassicPublicConfig from '../../../public/Config';
+
 export type PluginConfigOptions = {|
   isSource: boolean,
   searchPath: FilePath,
+  projectRoot: FilePath,
   env: Environment,
+  fs: IFileSystem,
+  packageManager: IPackageManager,
 |};
 
 export class PluginConfig implements IPluginConfig {
   isSource: boolean;
   searchPath: FilePath;
+  #projectRoot: FilePath;
   env: Environment;
+  #inner: ClassicPublicConfig;
 
-  constructor({env, isSource, searchPath}: PluginConfigOptions) {
+  constructor({
+    env,
+    isSource,
+    searchPath,
+    projectRoot,
+    fs,
+    packageManager,
+  }: PluginConfigOptions) {
     this.env = env;
     this.isSource = isSource;
     this.searchPath = searchPath;
+
+    this.#inner = new ClassicPublicConfig(
+      // $FlowFixMe
+      {
+        invalidateOnConfigKeyChange: [],
+        invalidateOnFileCreate: [],
+        invalidateOnFileChange: new Set(),
+        devDeps: [],
+        // $FlowFixMe
+        searchPath: searchPath.replace(projectRoot + '/', ''),
+      },
+      // $FlowFixMe
+      {
+        projectRoot,
+        inputFS: fs,
+        outputFS: fs,
+        packageManager,
+      },
+    );
   }
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileChange(filePath: FilePath): void {
-    throw new Error('PluginOptions.invalidateOnFileChange');
-  }
+  invalidateOnFileChange(filePath: FilePath): void {}
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnFileCreate(invalidations: FileCreateInvalidation): void {
-    throw new Error('PluginOptions.invalidateOnFileCreate');
-  }
+  invalidateOnFileCreate(invalidations: FileCreateInvalidation): void {}
 
   // eslint-disable-next-line no-unused-vars
-  invalidateOnEnvChange(invalidation: string): void {
-    throw new Error('PluginOptions.invalidateOnEnvChange');
-  }
+  invalidateOnEnvChange(invalidation: string): void {}
 
-  invalidateOnStartup(): void {
-    throw new Error('PluginOptions.invalidateOnStartup');
-  }
+  invalidateOnStartup(): void {}
 
-  invalidateOnBuild(): void {
-    throw new Error('PluginOptions.invalidateOnBuild');
-  }
+  invalidateOnBuild(): void {}
 
   // eslint-disable-next-line no-unused-vars
-  addDevDependency(options: DevDepOptions): void {
-    throw new Error('PluginOptions.addDevDependency');
-  }
+  addDevDependency(options: DevDepOptions): void {}
 
   // eslint-disable-next-line no-unused-vars
-  setCacheKey(key: string): void {
-    throw new Error('PluginOptions.setCacheKey');
-  }
+  setCacheKey(key: string): void {}
 
   getConfig<T>(
     // eslint-disable-next-line no-unused-vars
@@ -70,7 +91,7 @@ export class PluginConfig implements IPluginConfig {
       exclude?: boolean,
     |},
   ): Promise<?ConfigResultWithFilePath<T>> {
-    throw new Error('PluginOptions.getConfig');
+    return this.#inner.getConfig(filePaths, options);
   }
 
   getConfigFrom<T>(
@@ -85,10 +106,10 @@ export class PluginConfig implements IPluginConfig {
       exclude?: boolean,
     |},
   ): Promise<?ConfigResultWithFilePath<T>> {
-    throw new Error('PluginOptions.getConfigFrom');
+    return this.#inner.getConfigFrom(searchPath, filePaths, options);
   }
 
   getPackage(): Promise<?PackageJSON> {
-    throw new Error('PluginOptions.getPackage');
+    return this.#inner.getPackage();
   }
 }

package/src/atlaspack-v3/worker/worker.js

@@ -76,7 +76,13 @@ export class AtlaspackWorker {
     [RunResolverResolveOptions],
     Promise<RunResolverResolveResult>,
   > = jsCallable(
-    async ({key, dependency: napiDependency, specifier, pipeline, options}) => {
+    async ({
+      key,
+      dependency: napiDependency,
+      specifier,
+      pipeline,
+      pluginOptions,
+    }) => {
       const state = this.#resolvers.get(key);
       if (!state) {
         throw new Error(`Resolver not found: ${key}`);
@@ -84,7 +90,10 @@ export class AtlaspackWorker {
 
       let packageManager = state.packageManager;
       if (!packageManager) {
-        packageManager = new NodePackageManager(this.#fs, options.projectRoot);
+        packageManager = new NodePackageManager(
+          this.#fs,
+          pluginOptions.projectRoot,
+        );
         state.packageManager = packageManager;
       }
 
@@ -95,7 +104,7 @@ export class AtlaspackWorker {
         logger: new PluginLogger(),
         tracer: new PluginTracer(),
         options: new PluginOptions({
-          ...options,
+          ...pluginOptions,
           packageManager,
           shouldAutoInstall: false,
           inputFS: this.#fs,
@@ -108,7 +117,10 @@ export class AtlaspackWorker {
           config: new PluginConfig({
             env,
             isSource: true,
-            searchPath: '',
+            searchPath: specifier,
+            projectRoot: pluginOptions.projectRoot,
+            fs: this.#fs,
+            packageManager,
           }),
           ...defaultOptions,
         });
@@ -182,7 +194,10 @@ export class AtlaspackWorker {
       config: new PluginConfig({
         env,
         isSource: true,
-        searchPath: '',
+        searchPath: innerAsset.filePath.replace(options.projectRoot + '/', ''),
+        projectRoot: options.projectRoot,
+        fs: this.#fs,
+        packageManager,
       }),
       ...defaultOptions,
     });
@@ -287,7 +302,7 @@ type RunResolverResolveOptions = {|
   dependency: napi.Dependency,
   specifier: FilePath,
   pipeline: ?string,
-  options: RpcPluginOptions,
+  pluginOptions: RpcPluginOptions,
 |};
 
 type RunResolverResolveResult = {|

package/src/requests/AssetGraphRequestRust.js

@@ -3,10 +3,12 @@
 import invariant from 'assert';
 
 import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import {hashString} from '@atlaspack/rust';
 import type {Async} from '@atlaspack/types';
 
 import AssetGraph, {nodeFromAssetGroup} from '../AssetGraph';
 import type {AtlaspackV3} from '../atlaspack-v3';
+import {ATLASPACK_VERSION} from '../constants';
 import {toProjectPath} from '../projectPath';
 import {requestTypes, type StaticRunOpts} from '../RequestTracker';
 import {propagateSymbols} from '../SymbolPropagation';
@@ -200,6 +202,14 @@ function getAssetGraph(serializedGraph, options) {
           asset.symbols != null ? new Map(asset.symbols.map(mapSymbols)) : null,
       };
 
+      if (asset.map) {
+        let mapKey = hashString(`${ATLASPACK_VERSION}:map:${asset.id}`);
+
+        asset.mapKey = mapKey;
+        options.cache.setBlob(mapKey, asset.map);
+        delete asset.map;
+      }
+
       cachedAssets.set(id, asset.code);
       changedAssets.set(id, asset);