@atlaspack/core 2.16.2-dev.55 → 2.16.2-dev.69

package/src/public/Dependency.js

@@ -27,6 +27,7 @@ import {
 } from '../types';
 import {fromProjectPath} from '../projectPath';
 import {fromInternalSourceLocation} from '../utils';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const SpecifierTypeNames = Object.keys(SpecifierTypeMap);
 const PriorityNames = Object.keys(Priority);
@@ -112,7 +113,7 @@ export default class Dependency implements IDependency {
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#dep.env, this.#options);
+    return new Environment(fromEnvironmentId(this.#dep.env), this.#options);
   }
 
   get packageConditions(): ?Array<string> {

package/src/public/MutableBundleGraph.js

@@ -32,6 +32,7 @@ import {BundleBehavior} from '../types';
 import BundleGroup, {bundleGroupToInternalBundleGroup} from './BundleGroup';
 import type {ProjectPath} from '../projectPath';
 import {identifierRegistry} from '../IdentifierRegistry';
+import {toEnvironmentRef} from '../EnvironmentManager';
 
 function createBundleId(data: {|
   entryAssetId: string | null,
@@ -236,7 +237,7 @@ export default class MutableBundleGraph
           : bundleId.slice(-8),
         type: opts.entryAsset ? opts.entryAsset.type : opts.type,
         env: opts.env
-          ? environmentToInternalEnvironment(opts.env)
+          ? toEnvironmentRef(environmentToInternalEnvironment(opts.env))
           : nullthrows(entryAsset).env,
         entryAssetIds: entryAsset ? [entryAsset.id] : [],
         mainEntryId: entryAsset?.id,

package/src/public/PluginOptions.js

@@ -47,6 +47,10 @@ export default class PluginOptions implements IPluginOptions {
     return this.#options.parcelVersion;
   }
 
+  get isAtlaspackSuper(): boolean {
+    return Boolean(this.#options.isAtlaspackSuper);
+  }
+
   get hmrOptions(): ?HMROptions {
     return this.#options.hmrOptions;
   }

package/src/public/Target.js

@@ -11,6 +11,7 @@ import nullthrows from 'nullthrows';
 import Environment from './Environment';
 import {fromProjectPath} from '../projectPath';
 import {fromInternalSourceLocation} from '../utils';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 
@@ -46,7 +47,7 @@ export default class Target implements ITarget {
   }
 
   get env(): IEnvironment {
-    return new Environment(this.#target.env, this.#options);
+    return new Environment(fromEnvironmentId(this.#target.env), this.#options);
   }
 
   get name(): string {

package/src/requests/AssetRequest.js

@@ -21,6 +21,7 @@ import {fromProjectPath, fromProjectPathRelative} from '../projectPath';
 import {report} from '../ReporterRunner';
 import {requestTypes} from '../RequestTracker';
 import type {DevDepRequestResult} from './DevDepRequest';
+import {toEnvironmentId} from '../EnvironmentManager';
 
 type RunInput<TResult> = {|
   input: AssetRequestInput,
@@ -51,7 +52,7 @@ function getId(input: AssetRequestInput) {
   return hashString(
     type +
       fromProjectPathRelative(input.filePath) +
-      input.env.id +
+      toEnvironmentId(input.env) +
       String(input.isSource) +
       String(input.sideEffects) +
       (input.code ?? '') +

package/src/requests/AtlaspackConfigRequest.js

@@ -30,15 +30,17 @@ import ThrowableDiagnostic, {
   md,
   errorToDiagnostic,
 } from '@atlaspack/diagnostic';
-import {parse} from 'json5';
+import json5 from 'json5';
 import path from 'path';
 import invariant from 'assert';
 
+import atlaspackInternalPlugins from '../internal-plugins';
 import {AtlaspackConfig} from '../AtlaspackConfig';
 import AtlaspackConfigSchema from '../AtlaspackConfig.schema';
 import {toProjectPath} from '../projectPath';
 import {requestTypes} from '../RequestTracker';
 import {optionsProxy} from '../utils';
+import {isSuperPackage} from '../isSuperPackage';
 
 type ConfigMap<K, V> = {[K]: V, ...};
 
@@ -159,34 +161,60 @@ export async function resolveAtlaspackConfig(
         );
 
   let usedDefault = false;
-  if (configPath == null && options.defaultConfig != null) {
+  let config, extendedFiles;
+
+  if (
+    configPath == null &&
+    options.defaultConfig != null &&
+    isSuperPackage() &&
+    options.defaultConfig.endsWith('.js')
+  ) {
     usedDefault = true;
-    configPath = (
-      await options.packageManager.resolve(options.defaultConfig, resolveFrom)
-    ).resolved;
-  }
+    // Load the super package default config
+    let result: AtlaspackConfigChain = await processConfigChain(
+      atlaspackInternalPlugins['@atlaspack/config-default'](),
+      // $FlowFixMe
+      options.defaultConfig,
+      options,
+    );
+    config = result.config;
+    extendedFiles = result.extendedFiles;
+  } else {
+    if (configPath == null && options.defaultConfig != null) {
+      usedDefault = true;
 
-  if (configPath == null) {
-    return null;
-  }
+      configPath = (
+        await options.packageManager.resolve(options.defaultConfig, resolveFrom)
+      ).resolved;
+    }
 
-  let contents;
-  try {
-    contents = await options.inputFS.readFile(configPath, 'utf8');
-  } catch (e) {
-    throw new ThrowableDiagnostic({
-      diagnostic: {
-        message: md`Could not find parcel config at ${path.relative(
-          options.projectRoot,
-          configPath,
-        )}`,
-        origin: '@atlaspack/core',
-      },
-    });
-  }
+    if (configPath == null) {
+      return null;
+    }
+
+    let contents;
+    try {
+      contents = await options.inputFS.readFile(configPath, 'utf8');
+    } catch (e) {
+      throw new ThrowableDiagnostic({
+        diagnostic: {
+          message: md`Could not find parcel config at ${path.relative(
+            options.projectRoot,
+            configPath,
+          )}`,
+          origin: '@atlaspack/core',
+        },
+      });
+    }
 
-  let {config, extendedFiles}: AtlaspackConfigChain =
-    await parseAndProcessConfig(configPath, contents, options);
+    let result: AtlaspackConfigChain = await parseAndProcessConfig(
+      configPath,
+      contents,
+      options,
+    );
+    config = result.config;
+    extendedFiles = result.extendedFiles;
+  }
 
   if (options.additionalReporters.length > 0) {
     config.reporters = [
@@ -216,7 +244,7 @@ export async function parseAndProcessConfig(
 ): Promise<AtlaspackConfigChain> {
   let config: RawAtlaspackConfig;
   try {
-    config = parse(contents);
+    config = json5.parse(contents);
   } catch (e) {
     let pos = {
       line: e.lineNumber,
@@ -446,11 +474,29 @@ export async function processConfigChain(
           let key = Array.isArray(configFile.extends)
             ? `/extends/${i}`
             : '/extends';
-          let resolved = await resolveExtends(ext, filePath, key, options);
-          extendedFiles.push(resolved);
-          let {extendedFiles: moreExtendedFiles, config: nextConfig} =
-            await processExtendedConfig(filePath, key, ext, resolved, options);
-          extendedFiles = extendedFiles.concat(moreExtendedFiles);
+
+          let nextConfig;
+          if (atlaspackInternalPlugins[ext]) {
+            nextConfig = (
+              await processConfigChain(
+                atlaspackInternalPlugins[ext](),
+                /*#__ATLASPACK_IGNORE__*/ __dirname,
+                options,
+              )
+            ).config;
+          } else {
+            let resolved = await resolveExtends(ext, filePath, key, options);
+            extendedFiles.push(resolved);
+            let result = await processExtendedConfig(
+              filePath,
+              key,
+              ext,
+              resolved,
+              options,
+            );
+            extendedFiles = extendedFiles.concat(result.extendedFiles);
+            nextConfig = result.config;
+          }
           extStartConfig = extStartConfig
             ? mergeConfigs(extStartConfig, nextConfig)
             : nextConfig;

package/src/requests/ConfigRequest.js

@@ -63,7 +63,7 @@ export type ConfigRequest = {
   invalidateOnFileChange: Set<ProjectPath>,
   invalidateOnConfigKeyChange: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange: Set<string>,
@@ -108,34 +108,58 @@ export async function loadPluginConfig<T: PluginWithLoadConfig>(
   }
 }
 
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+export function getValueAtPath(obj: Object, key: string[]): any {
+  let current = obj;
+  for (let part of key) {
+    if (current == null) {
+      return undefined;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
 const configKeyCache = createBuildCache();
 
 export async function getConfigKeyContentHash(
   filePath: ProjectPath,
-  configKey: string,
+  configKey: string[],
   options: AtlaspackOptions,
 ): Async<string> {
-  let cacheKey = `${fromProjectPathRelative(filePath)}:${configKey}`;
+  let cacheKey = `${fromProjectPathRelative(filePath)}:${JSON.stringify(
+    configKey,
+  )}`;
   let cachedValue = configKeyCache.get(cacheKey);
 
   if (cachedValue) {
     return cachedValue;
   }
 
-  let conf = await readConfig(
+  const conf = await readConfig(
     options.inputFS,
     fromProjectPath(options.projectRoot, filePath),
   );
 
-  if (conf == null || conf.config[configKey] == null) {
+  const value = getValueAtPath(conf?.config, configKey);
+  if (conf == null || value == null) {
     // This can occur when a config key has been removed entirely during `respondToFSEvents`
     return '';
   }
 
-  let contentHash =
-    typeof conf.config[configKey] === 'object'
-      ? hashObject(conf.config[configKey])
-      : hashString(JSON.stringify(conf.config[configKey]));
+  const contentHash =
+    typeof value === 'object'
+      ? hashObject(value)
+      : hashString(JSON.stringify(value));
 
   configKeyCache.set(cacheKey, contentHash);
 

package/src/requests/TargetRequest.js

@@ -49,6 +49,7 @@ import {BROWSER_ENVS} from '../public/Environment';
 import {optionsProxy, toInternalSourceLocation} from '../utils';
 import {fromProjectPath, toProjectPath, joinProjectPath} from '../projectPath';
 import {requestTypes} from '../RequestTracker';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 type RunOpts<TResult> = {|
   input: Entry,
@@ -345,7 +346,7 @@ export class TargetResolver {
             },
           });
         }
-        if (!BROWSER_ENVS.has(targets[0].env.context)) {
+        if (!BROWSER_ENVS.has(fromEnvironmentId(targets[0].env).context)) {
           throw new ThrowableDiagnostic({
             diagnostic: {
               message: `Only browser targets are supported in serve mode`,
@@ -1491,21 +1492,22 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
     // Resolve relevant engines for context.
     let engines;
-    switch (target.env.context) {
+    const env = fromEnvironmentId(target.env);
+    switch (env.context) {
       case 'browser':
       case 'web-worker':
       case 'service-worker':
       case 'worklet': {
-        let browsers = target.env.engines.browsers;
+        let browsers = env.engines.browsers;
         engines = Array.isArray(browsers) ? browsers.join(', ') : browsers;
         break;
       }
       case 'node':
-        engines = target.env.engines.node;
+        engines = env.engines.node;
         break;
       case 'electron-main':
       case 'electron-renderer':
-        engines = target.env.engines.electron;
+        engines = env.engines.electron;
         break;
     }
 
@@ -1547,9 +1549,7 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
       }
 
       if (keyInfo.inferred) {
-        highlight.inferred.push(
-          md`${key} to be ${JSON.stringify(target.env[key])}`,
-        );
+        highlight.inferred.push(md`${key} to be ${JSON.stringify(env[key])}`);
       }
     }
 
@@ -1578,22 +1578,20 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
 
     // Format includeNodeModules to be human readable.
     let includeNodeModules;
-    if (typeof target.env.includeNodeModules === 'boolean') {
-      includeNodeModules = String(target.env.includeNodeModules);
-    } else if (Array.isArray(target.env.includeNodeModules)) {
+    if (typeof env.includeNodeModules === 'boolean') {
+      includeNodeModules = String(env.includeNodeModules);
+    } else if (Array.isArray(env.includeNodeModules)) {
       includeNodeModules =
         'only ' +
-        listFormat.format(
-          target.env.includeNodeModules.map((m) => JSON.stringify(m)),
-        );
+        listFormat.format(env.includeNodeModules.map((m) => JSON.stringify(m)));
     } else if (
-      target.env.includeNodeModules &&
-      typeof target.env.includeNodeModules === 'object'
+      env.includeNodeModules &&
+      typeof env.includeNodeModules === 'object'
     ) {
       includeNodeModules =
         'all except ' +
         listFormat.format(
-          Object.entries(target.env.includeNodeModules)
+          Object.entries(env.includeNodeModules)
             .filter(([, v]) => v === false)
             .map(([k]) => JSON.stringify(k)),
         );
@@ -1609,18 +1607,14 @@ async function debugResolvedTargets(input, targets, targetInfo, options) {
                  fromProjectPath(options.projectRoot, input.filePath),
                )}
               **Output**: ${path.relative(process.cwd(), output)}
-              **Format**: ${target.env.outputFormat} ${format(
-        info.outputFormat,
-      )}
-             **Context**: ${target.env.context} ${format(info.context)}
+              **Format**: ${env.outputFormat} ${format(info.outputFormat)}
+             **Context**: ${env.context} ${format(info.context)}
              **Engines**: ${engines || ''} ${format(info.engines)}
-        **Library Mode**: ${String(target.env.isLibrary)} ${format(
-        info.isLibrary,
-      )}
+        **Library Mode**: ${String(env.isLibrary)} ${format(info.isLibrary)}
 **Include Node Modules**: ${includeNodeModules} ${format(
         info.includeNodeModules,
       )}
-            **Optimize**: ${String(target.env.shouldOptimize)} ${format(
+            **Optimize**: ${String(env.shouldOptimize)} ${format(
         info.shouldOptimize,
       )}`,
       codeFrames: target.loc

package/src/requests/WriteBundleRequest.js

@@ -41,6 +41,7 @@ import ThrowableDiagnostic, {errorToDiagnostic} from '@atlaspack/diagnostic';
 import {PluginTracer, tracer} from '@atlaspack/profiler';
 import {requestTypes} from '../RequestTracker';
 import {getFeatureFlag} from '@atlaspack/feature-flags';
+import {fromEnvironmentId} from '../EnvironmentManager';
 
 const HASH_REF_PREFIX_LEN = HASH_REF_PREFIX.length;
 const BOUNDARY_LENGTH = HASH_REF_PREFIX.length + 32 - 1;
@@ -111,7 +112,9 @@ async function run({input, options, api}) {
   let cacheKeys = info.cacheKeys;
   let mapKey = cacheKeys.map;
   let fullPath = fromProjectPath(options.projectRoot, filePath);
-  if (mapKey && bundle.env.sourceMap && !bundle.env.sourceMap.inline) {
+  const env = fromEnvironmentId(bundle.env);
+
+  if (mapKey && env.sourceMap && !env.sourceMap.inline) {
     api.invalidateOnFileDelete(
       toProjectPath(options.projectRoot, fullPath + '.map'),
     );
@@ -171,12 +174,7 @@ async function run({input, options, api}) {
   const hasSourceMap = getFeatureFlag('cachePerformanceImprovements')
     ? await options.cache.hasLargeBlob(mapKey)
     : await options.cache.has(mapKey);
-  if (
-    mapKey &&
-    bundle.env.sourceMap &&
-    !bundle.env.sourceMap.inline &&
-    hasSourceMap
-  ) {
+  if (mapKey && env.sourceMap && !env.sourceMap.inline && hasSourceMap) {
     const mapEntry = getFeatureFlag('cachePerformanceImprovements')
       ? await options.cache.getLargeBlob(mapKey)
       : await options.cache.getBlob(mapKey);
@@ -196,6 +194,7 @@ async function run({input, options, api}) {
 
   let res = {
     filePath,
+    bundleId: bundle.id,
     type: info.type,
     stats: {
       size,

package/src/requests/WriteBundlesRequest.js

@@ -84,6 +84,7 @@ async function run({input, api, farm, options}) {
         ).replace(bundle.hashReference, hash);
         res.set(bundle.id, {
           filePath: joinProjectPath(bundle.target.distDir, name),
+          bundleId: bundle.id,
           type: bundle.type, // FIXME: this is wrong if the packager changes the type...
           stats: {
             time: 0,

package/src/resolveOptions.js

@@ -25,6 +25,7 @@ import {
 import loadDotEnv from './loadDotEnv';
 import {toProjectPath} from './projectPath';
 import {getResolveFrom} from './requests/AtlaspackConfigRequest';
+import {isSuperPackage} from './isSuperPackage';
 
 import {DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
 import {ATLASPACK_VERSION} from './constants';
@@ -277,6 +278,7 @@ export default async function resolveOptions(
     // feature-flags
     featureFlags: {...DEFAULT_FEATURE_FLAGS, ...initialOptions?.featureFlags},
     parcelVersion: ATLASPACK_VERSION,
+    isAtlaspackSuper: isSuperPackage(),
   };
 }
 

package/src/types.js

@@ -34,6 +34,7 @@ import type {ProjectPath} from './projectPath';
 import type {Event} from '@parcel/watcher';
 import type {FeatureFlags} from '@atlaspack/feature-flags';
 import type {BackendType} from '@parcel/watcher';
+import type {EnvironmentRef} from './EnvironmentManager';
 
 export type AtlaspackPluginNode = {|
   packageName: PackageName,
@@ -97,7 +98,7 @@ export type InternalSourceLocation = {|
 export type Target = {|
   distEntry?: ?FilePath,
   distDir: ProjectPath,
-  env: Environment,
+  env: EnvironmentRef,
   name: string,
   publicUrl: string,
   loc?: ?InternalSourceLocation,
@@ -139,7 +140,7 @@ export type Dependency = {|
   isEntry: boolean,
   isOptional: boolean,
   loc: ?InternalSourceLocation,
-  env: Environment,
+  env: EnvironmentRef,
   packageConditions?: number,
   customPackageConditions?: Array<string>,
   meta: Meta,
@@ -180,7 +181,7 @@ export type Asset = {|
   bundleBehavior: ?$Values<typeof BundleBehavior>,
   isBundleSplittable: boolean,
   isSource: boolean,
-  env: Environment,
+  env: EnvironmentRef,
   meta: Meta,
   stats: Stats,
   contentKey: ?string,
@@ -284,6 +285,7 @@ export type AtlaspackOptions = {|
   defaultConfig?: DependencySpecifier,
   env: EnvMap,
   parcelVersion: string,
+  isAtlaspackSuper?: boolean,
   targets: ?(Array<string> | {+[string]: TargetDescriptor, ...}),
   shouldDisableCache: boolean,
   cacheDir: FilePath,
@@ -388,7 +390,7 @@ export type RootNode = {|id: ContentKey, +type: 'root', value: string | null|};
 export type AssetRequestInput = {|
   name?: string, // AssetGraph name, needed so that different graphs can isolated requests since the results are not stored
   filePath: ProjectPath,
-  env: Environment,
+  env: EnvironmentRef,
   isSource?: boolean,
   canDefer?: boolean,
   sideEffects?: boolean,
@@ -492,13 +494,13 @@ export type Config = {|
   id: string,
   isSource: boolean,
   searchPath: ProjectPath,
-  env: Environment,
+  env: EnvironmentRef,
   cacheKey: ?string,
   result: ConfigResult,
   invalidateOnFileChange: Set<ProjectPath>,
   invalidateOnConfigKeyChange: Array<{|
     filePath: ProjectPath,
-    configKey: string,
+    configKey: string[],
   |}>,
   invalidateOnFileCreate: Array<InternalFileCreateInvalidation>,
   invalidateOnEnvChange: Set<string>,
@@ -539,7 +541,7 @@ export type Bundle = {|
   publicId: ?string,
   hashReference: string,
   type: string,
-  env: Environment,
+  env: EnvironmentRef,
   entryAssetIds: Array<ContentKey>,
   mainEntryId: ?ContentKey,
   needsStableName: ?boolean,
@@ -573,6 +575,7 @@ export type BundleGroupNode = {|
 
 export type PackagedBundleInfo = {|
   filePath: ProjectPath,
+  bundleId: ContentKey,
   type: string,
   stats: Stats,
 |};

package/src/worker.js

@@ -32,14 +32,15 @@ import '@atlaspack/cache'; // register with serializer
 import '@atlaspack/package-manager';
 import '@atlaspack/fs';
 
+// Repl builds are currently not enabled
 // $FlowFixMe
-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');
-  // $FlowFixMe
-  require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
-  /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
-}
+// 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');
+//   // $FlowFixMe
+//   require('@atlaspack/repl/src/atlaspack/ExtendedMemoryFS.js');
+//   /* eslint-enable import/no-extraneous-dependencies, monorepo/no-internal-import */
+// }
 
 registerCoreWithSerializer();