@atlaspack/core 2.12.1-dev.3368 → 2.12.1-dev.3401

package/index.d.ts

@@ -15,6 +15,14 @@ export class Atlaspack {
   ): Promise<AsyncSubscription>;
 }
 
+export class Parcel {
+  constructor(options: InitialAtlaspackOptions);
+  run(): Promise<BuildSuccessEvent>;
+  watch(
+    cb?: (err: Error | null | undefined, buildEvent?: BuildEvent) => unknown,
+  ): Promise<AsyncSubscription>;
+}
+
 export declare function createWorkerFarm(
   options?: Partial<FarmOptions>,
 ): WorkerFarm;

package/lib/AtlaspackConfig.js

@@ -104,7 +104,7 @@ class AtlaspackConfig {
   }
   async getResolvers() {
     if (this.resolvers.length === 0) {
-      throw await this.missingPluginError(this.resolvers, 'No resolver plugins specified in .atlaspackrc config', '/resolvers');
+      throw await this.missingPluginError(this.resolvers, 'No resolver plugins specified in .parcelrc config', '/resolvers');
     }
     return this.loadPlugins(this.resolvers);
   }
@@ -135,13 +135,13 @@ class AtlaspackConfig {
   }
   async getBundler() {
     if (!this.bundler) {
-      throw await this.missingPluginError([], 'No bundler specified in .atlaspackrc config', '/bundler');
+      throw await this.missingPluginError([], 'No bundler specified in .parcelrc config', '/bundler');
     }
     return this.loadPlugin(this.bundler);
   }
   async getNamers() {
     if (this.namers.length === 0) {
-      throw await this.missingPluginError(this.namers, 'No namer plugins specified in .atlaspackrc config', '/namers');
+      throw await this.missingPluginError(this.namers, 'No namer plugins specified in .parcelrc config', '/namers');
     }
     return this.loadPlugins(this.namers);
   }

package/lib/AtlaspackConfig.schema.js

@@ -21,20 +21,24 @@ function validatePackageName(pkg, pluginType, key) {
     return;
   }
   (0, _assert().default)(typeof pkg === 'string', `"${key}" must be a string`);
-  if (pkg.startsWith('@atlaspack')) {
+
+  // Probably all of these need to be removed
+  if (pkg.startsWith('@atlaspack') || pkg.startsWith('@parcel')) {
     (0, _assert().default)(pkg.replace(/^@atlaspack\//, '').startsWith(`${pluginType}-`), `Official atlaspack ${pluginType} packages must be named according to "@atlaspack/${pluginType}-{name}"`);
   } else if (pkg.startsWith('@')) {
-    // Disabling this validation to allow for migration to atlaspack
+    // Disabling this validation to allow for migration to parcel
     // let [scope, name] = pkg.split('/');
     // assert(
-    //   name.startsWith(`atlaspack-${pluginType}-`) ||
-    //     name === `atlaspack-${pluginType}` ||
+    //   name.startsWith(`parcel-${pluginType}-`) ||
+    //     name === `parcel-${pluginType}` ||
     //     name.startsWith(`parcel-${pluginType}-`) ||
     //     name === `parcel-${pluginType}`,
-    //   `Scoped atlaspack ${pluginType} packages must be named according to "${scope}/atlaspack-${pluginType}[-{name}]"`,
+    //   `Scoped parcel ${pluginType} packages must be named according to "${scope}/parcel-${pluginType}[-{name}]"`,
     // );
   } else if (!pkg.startsWith('.')) {
-    (0, _assert().default)(pkg.startsWith(`atlaspack-${pluginType}-`), `Atlaspack ${pluginType} packages must be named according to "atlaspack-${pluginType}-{name}"`);
+    (0, _assert().default)(pkg.startsWith(`parcel-${pluginType}-`) || pkg.startsWith(`atlaspack-${pluginType}`),
+    // let the error message be wrong for now
+    `Atlaspack ${pluginType} packages must be named according to "parcel-${pluginType}-{name}"`);
   }
 }
 const validatePluginName = (pluginType, key) => {

package/lib/BundleGraph.js

@@ -185,11 +185,11 @@ class BundleGraph {
         // code being generated).
         !node.usedSymbolsUp.has('*') &&
         // TODO We currently can't rename imports in async imports, e.g. from
-        //      (atlaspackRequire("...")).then(({ a }) => a);
+        //      (parcelRequire("...")).then(({ a }) => a);
         // to
-        //      (atlaspackRequire("...")).then(({ a: b }) => a);
+        //      (parcelRequire("...")).then(({ a: b }) => a);
         // or
-        //      (atlaspackRequire("...")).then((a)=>a);
+        //      (parcelRequire("...")).then((a)=>a);
         // if the reexporting asset did `export {a as b}` or `export * as a`
         node.value.priority === _types.Priority.sync &&
         // For every asset, no symbol is imported multiple times (with a different local name).

package/lib/PackagerRunner.js

@@ -388,7 +388,7 @@ class PackagerRunner {
       if (bundle.env.sourceMap && bundle.env.sourceMap.sourceRoot !== undefined) {
         sourceRoot = bundle.env.sourceMap.sourceRoot;
       } else if (this.options.serveOptions && bundle.target.env.context === 'browser') {
-        sourceRoot = '/__atlaspack_source_root';
+        sourceRoot = '/__parcel_source_root';
       }
       if (bundle.env.sourceMap && bundle.env.sourceMap.inlineSources !== undefined) {
         inlineSources = bundle.env.sourceMap.inlineSources;

package/lib/dumpGraphToGraphViz.js

@@ -180,7 +180,7 @@ async function dumpGraphToGraphViz(graph, name, edgeTypes) {
   } else {
     const tempy = require('tempy');
     let tmp = tempy.file({
-      name: `atlaspack-${name}.png`
+      name: `parcel-${name}.png`
     });
     await g.output('png', tmp);
     // eslint-disable-next-line no-console

package/lib/index.js

@@ -11,6 +11,7 @@ var _exportNames = {
   serialize: true,
   deserialize: true,
   Atlaspack: true,
+  Parcel: true,
   BuildError: true,
   createWorkerFarm: true,
   INTERNAL_RESOLVE: true,
@@ -40,6 +41,12 @@ Object.defineProperty(exports, "INTERNAL_TRANSFORM", {
     return _Atlaspack.INTERNAL_TRANSFORM;
   }
 });
+Object.defineProperty(exports, "Parcel", {
+  enumerable: true,
+  get: function () {
+    return _Atlaspack.default;
+  }
+});
 Object.defineProperty(exports, "createWorkerFarm", {
   enumerable: true,
   get: function () {

package/lib/loadAtlaspackPlugin.js

@@ -66,22 +66,22 @@ async function loadPlugin(pluginName, configPath, keyPath, options) {
     }
     let configPkg = await (0, _utils().loadConfig)(options.inputFS, resolveFrom, ['package.json'], options.projectRoot);
     if (configPkg != null && ((_configPkg$config$dep = configPkg.config.dependencies) === null || _configPkg$config$dep === void 0 ? void 0 : _configPkg$config$dep[pluginName]) == null) {
-      var _configPkg$config$atl;
+      var _configPkg$config$par;
       // If not in the config's dependencies, the plugin will be auto installed with
-      // the version declared in "atlaspackDependencies".
-      range = (_configPkg$config$atl = configPkg.config.atlaspackDependencies) === null || _configPkg$config$atl === void 0 ? void 0 : _configPkg$config$atl[pluginName];
+      // the version declared in "parcelDependencies".
+      range = (_configPkg$config$par = configPkg.config.parcelDependencies) === null || _configPkg$config$par === void 0 ? void 0 : _configPkg$config$par[pluginName];
       if (range == null) {
         let contents = await options.inputFS.readFile(configPkg.files[0].filePath, 'utf8');
         throw new (_diagnostic().default)({
           diagnostic: {
-            message: (0, _diagnostic().md)`Could not determine version of ${pluginName} in ${_path().default.relative(process.cwd(), resolveFrom)}. Either include it in "dependencies" or "atlaspackDependencies".`,
+            message: (0, _diagnostic().md)`Could not determine version of ${pluginName} in ${_path().default.relative(process.cwd(), resolveFrom)}. Either include it in "dependencies" or "parcelDependencies".`,
             origin: '@atlaspack/core',
-            codeFrames: configPkg.config.dependencies || configPkg.config.atlaspackDependencies ? [{
+            codeFrames: configPkg.config.dependencies || configPkg.config.parcelDependencies ? [{
               filePath: configPkg.files[0].filePath,
               language: 'json5',
               code: contents,
               codeHighlights: (0, _diagnostic().generateJSONCodeHighlights)(contents, [{
-                key: configPkg.config.atlaspackDependencies ? '/atlaspackDependencies' : '/dependencies',
+                key: configPkg.config.parcelDependencies ? '/parcelDependencies' : '/dependencies',
                 type: 'key'
               }])
             }] : undefined

package/lib/public/PluginOptions.js

@@ -4,17 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-let atlaspackOptionsToPluginOptions = new WeakMap();
+let parcelOptionsToPluginOptions = new WeakMap();
 class PluginOptions {
   #options /*: AtlaspackOptions */;
 
   constructor(options) {
-    let existing = atlaspackOptionsToPluginOptions.get(options);
+    let existing = parcelOptionsToPluginOptions.get(options);
     if (existing != null) {
       return existing;
     }
     this.#options = options;
-    atlaspackOptionsToPluginOptions.set(options, this);
+    parcelOptionsToPluginOptions.set(options, this);
     return this;
   }
   get instanceId() {
@@ -26,8 +26,8 @@ class PluginOptions {
   get env() {
     return this.#options.env;
   }
-  get atlaspackVersion() {
-    return this.#options.atlaspackVersion;
+  get parcelVersion() {
+    return this.#options.parcelVersion;
   }
   get hmrOptions() {
     return this.#options.hmrOptions;

package/lib/requests/AtlaspackConfigRequest.js

@@ -86,7 +86,7 @@ function createAtlaspackConfigRequest() {
       if (usedDefault) {
         let resolveFrom = getResolveFrom(options.inputFS, options.projectRoot);
         api.invalidateOnFileCreate({
-          fileName: '.atlaspackrc',
+          fileName: '.parcelrc',
           aboveFilePath: (0, _projectPath.toProjectPath)(options.projectRoot, resolveFrom)
         });
       }
@@ -120,13 +120,13 @@ function getCachedAtlaspackConfig(result, options) {
 async function loadAtlaspackConfig(options) {
   let atlaspackConfig = await resolveAtlaspackConfig(options);
   if (!atlaspackConfig) {
-    throw new Error('Could not find a .atlaspackrc');
+    throw new Error('Could not find a .parcelrc');
   }
   return atlaspackConfig;
 }
 async function resolveAtlaspackConfig(options) {
   let resolveFrom = getResolveFrom(options.inputFS, options.projectRoot);
-  let configPath = options.config != null ? (await options.packageManager.resolve(options.config, resolveFrom)).resolved : await (0, _utils().resolveConfig)(options.inputFS, resolveFrom, ['.atlaspackrc'], options.projectRoot);
+  let configPath = options.config != null ? (await options.packageManager.resolve(options.config, resolveFrom)).resolved : await (0, _utils().resolveConfig)(options.inputFS, resolveFrom, ['.parcelrc'], options.projectRoot);
   let usedDefault = false;
   if (configPath == null && options.defaultConfig != null) {
     usedDefault = true;
@@ -141,7 +141,7 @@ async function resolveAtlaspackConfig(options) {
   } catch (e) {
     throw new (_diagnostic().default)({
       diagnostic: {
-        message: (0, _diagnostic().md)`Could not find atlaspack config at ${_path().default.relative(options.projectRoot, configPath)}`,
+        message: (0, _diagnostic().md)`Could not find parcel config at ${_path().default.relative(options.projectRoot, configPath)}`,
         origin: '@atlaspack/core'
       }
     });
@@ -181,7 +181,7 @@ async function parseAndProcessConfig(configPath, contents, options) {
     };
     throw new (_diagnostic().default)({
       diagnostic: {
-        message: `Failed to parse .atlaspackrc`,
+        message: `Failed to parse .parcelrc`,
         origin: '@atlaspack/core',
         codeFrames: [{
           filePath: configPath,
@@ -342,7 +342,7 @@ async function resolveExtends(ext, configPath, extendsKey, options) {
       let alternatives = await (0, _utils().findAlternativeNodeModules)(options.inputFS, ext, _path().default.dirname(configPath));
       throw new (_diagnostic().default)({
         diagnostic: {
-          message: `Cannot find extended atlaspack config`,
+          message: `Cannot find extended parcel config`,
           origin: '@atlaspack/core',
           codeFrames: [{
             filePath: configPath,
@@ -368,7 +368,7 @@ async function processExtendedConfig(configPath, extendsKey, extendsSpecifier, r
     let alternatives = await (0, _utils().findAlternativeFiles)(options.inputFS, extendsSpecifier, _path().default.dirname(resolvedExtendedConfigPath), options.projectRoot);
     throw new (_diagnostic().default)({
       diagnostic: {
-        message: 'Cannot find extended atlaspack config',
+        message: 'Cannot find extended parcel config',
         origin: '@atlaspack/core',
         codeFrames: [{
           filePath: configPath,
@@ -399,7 +399,7 @@ function validateConfigFile(config, relativePath) {
   _utils().validateSchema.diagnostic(_AtlaspackConfig.default, {
     data: config,
     filePath: relativePath
-  }, '@atlaspack/core', 'Invalid Atlaspack Config');
+  }, '@atlaspack/core', 'Invalid Parcel Config');
 }
 function validateNotEmpty(config, relativePath) {
   _assert().default.notDeepStrictEqual(config, {}, `${relativePath} can't be empty`);

package/lib/resolveOptions.js

@@ -59,10 +59,10 @@ function _featureFlags() {
 var _constants = require("./constants");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // Default cache directory name
-const DEFAULT_CACHE_DIRNAME = '.atlaspack-cache';
+const DEFAULT_CACHE_DIRNAME = '.parcel-cache';
 const LOCK_FILE_NAMES = ['yarn.lock', 'package-lock.json', 'pnpm-lock.yaml'];
 
-// Generate a unique instanceId, will change on every run of atlaspack
+// Generate a unique instanceId, will change on every run of parcel
 function generateInstanceId(entries) {
   return (0, _rust().hashString)(`${entries.join(',')}-${Date.now()}-${Math.round(Math.random() * 100)}`);
 }
@@ -196,7 +196,7 @@ async function resolveOptions(initialOptions) {
       ..._featureFlags().DEFAULT_FEATURE_FLAGS,
       ...(initialOptions === null || initialOptions === void 0 ? void 0 : initialOptions.featureFlags)
     },
-    atlaspackVersion: _constants.ATLASPACK_VERSION
+    parcelVersion: _constants.ATLASPACK_VERSION
   };
 }
 function getRelativeConfigSpecifier(fs, projectRoot, specifier) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/core",
-  "version": "2.12.1-dev.3368+af1db7f65",
+  "version": "2.12.1-dev.3401+b483af77f",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -20,20 +20,20 @@
     "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/cache": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/diagnostic": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/events": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/feature-flags": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/fs": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/graph": "3.2.1-dev.3368+af1db7f65",
-    "@atlaspack/logger": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/package-manager": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/plugin": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/profiler": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/rust": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/types": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/utils": "2.12.1-dev.3368+af1db7f65",
-    "@atlaspack/workers": "2.12.1-dev.3368+af1db7f65",
+    "@atlaspack/cache": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/diagnostic": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/events": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/feature-flags": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/fs": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/graph": "3.2.1-dev.3401+b483af77f",
+    "@atlaspack/logger": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/package-manager": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/plugin": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/profiler": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/rust": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/types": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/utils": "2.12.1-dev.3401+b483af77f",
+    "@atlaspack/workers": "2.12.1-dev.3401+b483af77f",
     "@mischnic/json-sourcemap": "^0.1.0",
     "@parcel/source-map": "^2.1.1",
     "base-x": "^3.0.8",
@@ -55,5 +55,5 @@
   "browser": {
     "./src/serializerCore.js": "./src/serializerCore.browser.js"
   },
-  "gitHead": "af1db7f65c4816917ddf83716deedc536a1b8b27"
+  "gitHead": "b483af77f02d1258c8dad156e097b94f83671d8e"
 }

package/src/AtlaspackConfig.js

@@ -161,7 +161,7 @@ export default class AtlaspackConfig {
     if (this.resolvers.length === 0) {
       throw await this.missingPluginError(
         this.resolvers,
-        'No resolver plugins specified in .atlaspackrc config',
+        'No resolver plugins specified in .parcelrc config',
         '/resolvers',
       );
     }
@@ -225,7 +225,7 @@ export default class AtlaspackConfig {
     if (!this.bundler) {
       throw await this.missingPluginError(
         [],
-        'No bundler specified in .atlaspackrc config',
+        'No bundler specified in .parcelrc config',
         '/bundler',
       );
     }
@@ -237,7 +237,7 @@ export default class AtlaspackConfig {
     if (this.namers.length === 0) {
       throw await this.missingPluginError(
         this.namers,
-        'No namer plugins specified in .atlaspackrc config',
+        'No namer plugins specified in .parcelrc config',
         '/namers',
       );
     }

package/src/AtlaspackConfig.schema.js

@@ -17,25 +17,28 @@ export function validatePackageName(
 
   assert(typeof pkg === 'string', `"${key}" must be a string`);
 
-  if (pkg.startsWith('@atlaspack')) {
+  // Probably all of these need to be removed
+  if (pkg.startsWith('@atlaspack') || pkg.startsWith('@parcel')) {
     assert(
       pkg.replace(/^@atlaspack\//, '').startsWith(`${pluginType}-`),
       `Official atlaspack ${pluginType} packages must be named according to "@atlaspack/${pluginType}-{name}"`,
     );
   } else if (pkg.startsWith('@')) {
-    // Disabling this validation to allow for migration to atlaspack
+    // Disabling this validation to allow for migration to parcel
     // let [scope, name] = pkg.split('/');
     // assert(
-    //   name.startsWith(`atlaspack-${pluginType}-`) ||
-    //     name === `atlaspack-${pluginType}` ||
+    //   name.startsWith(`parcel-${pluginType}-`) ||
+    //     name === `parcel-${pluginType}` ||
     //     name.startsWith(`parcel-${pluginType}-`) ||
     //     name === `parcel-${pluginType}`,
-    //   `Scoped atlaspack ${pluginType} packages must be named according to "${scope}/atlaspack-${pluginType}[-{name}]"`,
+    //   `Scoped parcel ${pluginType} packages must be named according to "${scope}/parcel-${pluginType}[-{name}]"`,
     // );
   } else if (!pkg.startsWith('.')) {
     assert(
-      pkg.startsWith(`atlaspack-${pluginType}-`),
-      `Atlaspack ${pluginType} packages must be named according to "atlaspack-${pluginType}-{name}"`,
+      pkg.startsWith(`parcel-${pluginType}-`) ||
+        pkg.startsWith(`atlaspack-${pluginType}`),
+      // let the error message be wrong for now
+      `Atlaspack ${pluginType} packages must be named according to "parcel-${pluginType}-{name}"`,
     );
   }
 }

package/src/BundleGraph.js

@@ -246,11 +246,11 @@ export default class BundleGraph {
           // code being generated).
           !node.usedSymbolsUp.has('*') &&
           // TODO We currently can't rename imports in async imports, e.g. from
-          //      (atlaspackRequire("...")).then(({ a }) => a);
+          //      (parcelRequire("...")).then(({ a }) => a);
           // to
-          //      (atlaspackRequire("...")).then(({ a: b }) => a);
+          //      (parcelRequire("...")).then(({ a: b }) => a);
           // or
-          //      (atlaspackRequire("...")).then((a)=>a);
+          //      (parcelRequire("...")).then((a)=>a);
           // if the reexporting asset did `export {a as b}` or `export * as a`
           node.value.priority === Priority.sync &&
           // For every asset, no symbol is imported multiple times (with a different local name).

package/src/PackagerRunner.js

@@ -586,7 +586,7 @@ export default class PackagerRunner {
         this.options.serveOptions &&
         bundle.target.env.context === 'browser'
       ) {
-        sourceRoot = '/__atlaspack_source_root';
+        sourceRoot = '/__parcel_source_root';
       }
 
       if (

package/src/dumpGraphToGraphViz.js

@@ -216,7 +216,7 @@ export default async function dumpGraphToGraphViz(
     globalThis.ATLASPACK_DUMP_GRAPHVIZ?.(name, g.to_dot());
   } else {
     const tempy = require('tempy');
-    let tmp = tempy.file({name: `atlaspack-${name}.png`});
+    let tmp = tempy.file({name: `parcel-${name}.png`});
     await g.output('png', tmp);
     // eslint-disable-next-line no-console
     console.log('Dumped', tmp);

package/src/index.js

@@ -13,6 +13,7 @@ export {
 export {
   default,
   default as Atlaspack,
+  default as Parcel,
   BuildError,
   createWorkerFarm,
   INTERNAL_RESOLVE,

package/src/loadAtlaspackPlugin.js

@@ -78,8 +78,8 @@ export default async function loadPlugin<T>(
       configPkg.config.dependencies?.[pluginName] == null
     ) {
       // If not in the config's dependencies, the plugin will be auto installed with
-      // the version declared in "atlaspackDependencies".
-      range = configPkg.config.atlaspackDependencies?.[pluginName];
+      // the version declared in "parcelDependencies".
+      range = configPkg.config.parcelDependencies?.[pluginName];
 
       if (range == null) {
         let contents = await options.inputFS.readFile(
@@ -91,11 +91,11 @@ export default async function loadPlugin<T>(
             message: md`Could not determine version of ${pluginName} in ${path.relative(
               process.cwd(),
               resolveFrom,
-            )}. Either include it in "dependencies" or "atlaspackDependencies".`,
+            )}. Either include it in "dependencies" or "parcelDependencies".`,
             origin: '@atlaspack/core',
             codeFrames:
               configPkg.config.dependencies ||
-              configPkg.config.atlaspackDependencies
+              configPkg.config.parcelDependencies
                 ? [
                     {
                       filePath: configPkg.files[0].filePath,
@@ -103,8 +103,8 @@ export default async function loadPlugin<T>(
                       code: contents,
                       codeHighlights: generateJSONCodeHighlights(contents, [
                         {
-                          key: configPkg.config.atlaspackDependencies
-                            ? '/atlaspackDependencies'
+                          key: configPkg.config.parcelDependencies
+                            ? '/parcelDependencies'
                             : '/dependencies',
                           type: 'key',
                         },
@@ -173,18 +173,18 @@ export default async function loadPlugin<T>(
   // Remove plugin version compatiblility validation in canary builds as they don't use semver
   if (!process.env.SKIP_PLUGIN_COMPATIBILITY_CHECK) {
     if (!pluginName.startsWith('.')) {
-      // Validate the engines.atlaspack field in the plugin's package.json
-      let atlaspackVersionRange = pkg && pkg.engines && pkg.engines.atlaspack;
-      if (!atlaspackVersionRange) {
+      // Validate the engines.parcel field in the plugin's package.json
+      let parcelVersionRange = pkg && pkg.engines && pkg.engines.parcel;
+      if (!parcelVersionRange) {
         logger.warn({
           origin: '@atlaspack/core',
-          message: `The plugin "${pluginName}" needs to specify a \`package.json#engines.atlaspack\` field with the supported Atlaspack version range.`,
+          message: `The plugin "${pluginName}" needs to specify a \`package.json#engines.parcel\` field with the supported Atlaspack version range.`,
         });
       }
 
       if (
-        atlaspackVersionRange &&
-        !semver.satisfies(ATLASPACK_VERSION, atlaspackVersionRange)
+        parcelVersionRange &&
+        !semver.satisfies(ATLASPACK_VERSION, parcelVersionRange)
       ) {
         let pkgFile = nullthrows(
           await resolveConfig(
@@ -197,7 +197,7 @@ export default async function loadPlugin<T>(
         let pkgContents = await options.inputFS.readFile(pkgFile, 'utf8');
         throw new ThrowableDiagnostic({
           diagnostic: {
-            message: md`The plugin "${pluginName}" is not compatible with the current version of Atlaspack. Requires "${atlaspackVersionRange}" but the current version is "${ATLASPACK_VERSION}".`,
+            message: md`The plugin "${pluginName}" is not compatible with the current version of Atlaspack. Requires "${parcelVersionRange}" but the current version is "${ATLASPACK_VERSION}".`,
             origin: '@atlaspack/core',
             codeFrames: [
               {
@@ -206,7 +206,7 @@ export default async function loadPlugin<T>(
                 code: pkgContents,
                 codeHighlights: generateJSONCodeHighlights(pkgContents, [
                   {
-                    key: '/engines/atlaspack',
+                    key: '/engines/parcel',
                   },
                 ]),
               },

package/src/public/PluginOptions.js

@@ -14,20 +14,20 @@ import type {PackageManager} from '@atlaspack/package-manager';
 import type {AtlaspackOptions} from '../types';
 import {type FeatureFlags} from '@atlaspack/feature-flags';
 
-let atlaspackOptionsToPluginOptions: WeakMap<AtlaspackOptions, PluginOptions> =
+let parcelOptionsToPluginOptions: WeakMap<AtlaspackOptions, PluginOptions> =
   new WeakMap();
 
 export default class PluginOptions implements IPluginOptions {
   #options /*: AtlaspackOptions */;
 
   constructor(options: AtlaspackOptions): PluginOptions {
-    let existing = atlaspackOptionsToPluginOptions.get(options);
+    let existing = parcelOptionsToPluginOptions.get(options);
     if (existing != null) {
       return existing;
     }
 
     this.#options = options;
-    atlaspackOptionsToPluginOptions.set(options, this);
+    parcelOptionsToPluginOptions.set(options, this);
     return this;
   }
 
@@ -43,8 +43,8 @@ export default class PluginOptions implements IPluginOptions {
     return this.#options.env;
   }
 
-  get atlaspackVersion(): string {
-    return this.#options.atlaspackVersion;
+  get parcelVersion(): string {
+    return this.#options.parcelVersion;
   }
 
   get hmrOptions(): ?HMROptions {

package/src/requests/AtlaspackConfigRequest.js

@@ -98,7 +98,7 @@ export default function createAtlaspackConfigRequest(): AtlaspackConfigRequest {
       if (usedDefault) {
         let resolveFrom = getResolveFrom(options.inputFS, options.projectRoot);
         api.invalidateOnFileCreate({
-          fileName: '.atlaspackrc',
+          fileName: '.parcelrc',
           aboveFilePath: toProjectPath(options.projectRoot, resolveFrom),
         });
       }
@@ -137,7 +137,7 @@ export async function loadAtlaspackConfig(
   let atlaspackConfig = await resolveAtlaspackConfig(options);
 
   if (!atlaspackConfig) {
-    throw new Error('Could not find a .atlaspackrc');
+    throw new Error('Could not find a .parcelrc');
   }
 
   return atlaspackConfig;
@@ -154,7 +154,7 @@ export async function resolveAtlaspackConfig(
       : await resolveConfig(
           options.inputFS,
           resolveFrom,
-          ['.atlaspackrc'],
+          ['.parcelrc'],
           options.projectRoot,
         );
 
@@ -176,7 +176,7 @@ export async function resolveAtlaspackConfig(
   } catch (e) {
     throw new ThrowableDiagnostic({
       diagnostic: {
-        message: md`Could not find atlaspack config at ${path.relative(
+        message: md`Could not find parcel config at ${path.relative(
           options.projectRoot,
           configPath,
         )}`,
@@ -224,7 +224,7 @@ export async function parseAndProcessConfig(
     };
     throw new ThrowableDiagnostic({
       diagnostic: {
-        message: `Failed to parse .atlaspackrc`,
+        message: `Failed to parse .parcelrc`,
         origin: '@atlaspack/core',
 
         codeFrames: [
@@ -498,7 +498,7 @@ export async function resolveExtends(
       );
       throw new ThrowableDiagnostic({
         diagnostic: {
-          message: `Cannot find extended atlaspack config`,
+          message: `Cannot find extended parcel config`,
           origin: '@atlaspack/core',
           codeFrames: [
             {
@@ -547,7 +547,7 @@ async function processExtendedConfig(
     );
     throw new ThrowableDiagnostic({
       diagnostic: {
-        message: 'Cannot find extended atlaspack config',
+        message: 'Cannot find extended parcel config',
         origin: '@atlaspack/core',
         codeFrames: [
           {
@@ -591,7 +591,7 @@ export function validateConfigFile(
     AtlaspackConfigSchema,
     {data: config, filePath: relativePath},
     '@atlaspack/core',
-    'Invalid Atlaspack Config',
+    'Invalid Parcel Config',
   );
 }