@atlaspack/core 2.12.1-canary.3354

package/src/public/BundleGroup.js

@@ -0,0 +1,55 @@
+// @flow
+import type {
+  BundleGroup as IBundleGroup,
+  Target as ITarget,
+} from '@atlaspack/types';
+import type {
+  BundleGroup as InternalBundleGroup,
+  AtlaspackOptions,
+} from '../types';
+
+import nullthrows from 'nullthrows';
+import Target from './Target';
+
+const internalBundleGroupToBundleGroup: WeakMap<
+  InternalBundleGroup,
+  BundleGroup,
+> = new WeakMap();
+const _bundleGroupToInternalBundleGroup: WeakMap<
+  IBundleGroup,
+  InternalBundleGroup,
+> = new WeakMap();
+export function bundleGroupToInternalBundleGroup(
+  target: IBundleGroup,
+): InternalBundleGroup {
+  return nullthrows(_bundleGroupToInternalBundleGroup.get(target));
+}
+
+export default class BundleGroup implements IBundleGroup {
+  #bundleGroup /*: InternalBundleGroup */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(
+    bundleGroup: InternalBundleGroup,
+    options: AtlaspackOptions,
+  ): BundleGroup {
+    let existing = internalBundleGroupToBundleGroup.get(bundleGroup);
+    if (existing != null) {
+      return existing;
+    }
+
+    this.#bundleGroup = bundleGroup;
+    this.#options = options;
+    _bundleGroupToInternalBundleGroup.set(this, bundleGroup);
+    internalBundleGroupToBundleGroup.set(bundleGroup, this);
+    return this;
+  }
+
+  get target(): ITarget {
+    return new Target(this.#bundleGroup.target, this.#options);
+  }
+
+  get entryAssetId(): string {
+    return this.#bundleGroup.entryAssetId;
+  }
+}

package/src/public/Config.js

@@ -0,0 +1,261 @@
+// @flow strict-local
+import type {
+  Config as IConfig,
+  ConfigResult,
+  FileCreateInvalidation,
+  FilePath,
+  PackageJSON,
+  ConfigResultWithFilePath,
+  DevDepOptions,
+} from '@atlaspack/types';
+import type {Config, AtlaspackOptions} from '../types';
+
+import invariant from 'assert';
+import path from 'path';
+import {
+  DefaultWeakMap,
+  resolveConfig,
+  readConfig,
+  relativePath,
+} from '@atlaspack/utils';
+import Environment from './Environment';
+import {fromProjectPath, toProjectPath} from '../projectPath';
+
+const internalConfigToConfig: DefaultWeakMap<
+  AtlaspackOptions,
+  WeakMap<Config, PublicConfig>,
+> = new DefaultWeakMap(() => new WeakMap());
+
+export default class PublicConfig implements IConfig {
+  #config /*: Config */;
+  #pkg /*: ?PackageJSON */;
+  #pkgFilePath /*: ?FilePath */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(config: Config, options: AtlaspackOptions): PublicConfig {
+    let existing = internalConfigToConfig.get(options).get(config);
+    if (existing != null) {
+      return existing;
+    }
+
+    this.#config = config;
+    this.#options = options;
+    internalConfigToConfig.get(options).set(config, this);
+    return this;
+  }
+
+  get env(): Environment {
+    return new Environment(this.#config.env, this.#options);
+  }
+
+  get searchPath(): FilePath {
+    return fromProjectPath(this.#options.projectRoot, this.#config.searchPath);
+  }
+
+  get result(): ConfigResult {
+    return this.#config.result;
+  }
+
+  get isSource(): boolean {
+    return this.#config.isSource;
+  }
+
+  // $FlowFixMe
+  setResult(result: any): void {
+    this.#config.result = result;
+  }
+
+  setCacheKey(cacheKey: string) {
+    this.#config.cacheKey = cacheKey;
+  }
+
+  invalidateOnFileChange(filePath: FilePath) {
+    this.#config.invalidateOnFileChange.add(
+      toProjectPath(this.#options.projectRoot, filePath),
+    );
+  }
+
+  invalidateOnConfigKeyChange(filePath: FilePath, configKey: string) {
+    this.#config.invalidateOnConfigKeyChange.push({
+      filePath: toProjectPath(this.#options.projectRoot, filePath),
+      configKey,
+    });
+  }
+
+  addDevDependency(devDep: DevDepOptions) {
+    this.#config.devDeps.push({
+      ...devDep,
+      resolveFrom: toProjectPath(this.#options.projectRoot, devDep.resolveFrom),
+      additionalInvalidations: devDep.additionalInvalidations?.map(i => ({
+        ...i,
+        resolveFrom: toProjectPath(this.#options.projectRoot, i.resolveFrom),
+      })),
+    });
+  }
+
+  invalidateOnFileCreate(invalidation: FileCreateInvalidation) {
+    if (invalidation.glob != null) {
+      // $FlowFixMe
+      this.#config.invalidateOnFileCreate.push(invalidation);
+    } else if (invalidation.filePath != null) {
+      this.#config.invalidateOnFileCreate.push({
+        filePath: toProjectPath(
+          this.#options.projectRoot,
+          invalidation.filePath,
+        ),
+      });
+    } else {
+      invariant(invalidation.aboveFilePath != null);
+      this.#config.invalidateOnFileCreate.push({
+        // $FlowFixMe
+        fileName: invalidation.fileName,
+        aboveFilePath: toProjectPath(
+          this.#options.projectRoot,
+          invalidation.aboveFilePath,
+        ),
+      });
+    }
+  }
+
+  invalidateOnEnvChange(env: string) {
+    this.#config.invalidateOnEnvChange.add(env);
+  }
+
+  invalidateOnStartup() {
+    this.#config.invalidateOnStartup = true;
+  }
+
+  invalidateOnBuild() {
+    this.#config.invalidateOnBuild = true;
+  }
+
+  async getConfigFrom<T>(
+    searchPath: FilePath,
+    fileNames: Array<string>,
+    options: ?{|
+      packageKey?: string,
+      parse?: boolean,
+      exclude?: boolean,
+    |},
+  ): Promise<?ConfigResultWithFilePath<T>> {
+    let packageKey = options?.packageKey;
+    if (packageKey != null) {
+      let pkg = await this.getConfigFrom(searchPath, ['package.json'], {
+        exclude: true,
+      });
+
+      if (pkg && pkg.contents[packageKey]) {
+        // Invalidate only when the package key changes
+        this.invalidateOnConfigKeyChange(pkg.filePath, packageKey);
+
+        return {
+          contents: pkg.contents[packageKey],
+          filePath: pkg.filePath,
+        };
+      }
+    }
+
+    if (fileNames.length === 0) {
+      return null;
+    }
+
+    // Invalidate when any of the file names are created above the search path.
+    for (let fileName of fileNames) {
+      this.invalidateOnFileCreate({
+        fileName,
+        aboveFilePath: searchPath,
+      });
+    }
+
+    let parse = options && options.parse;
+    let configFilePath = await resolveConfig(
+      this.#options.inputFS,
+      searchPath,
+      fileNames,
+      this.#options.projectRoot,
+    );
+    if (configFilePath == null) {
+      return null;
+    }
+
+    if (!options || !options.exclude) {
+      this.invalidateOnFileChange(configFilePath);
+    }
+
+    // If this is a JavaScript file, load it with the package manager.
+    let extname = path.extname(configFilePath);
+    if (extname === '.js' || extname === '.cjs' || extname === '.mjs') {
+      let specifier = relativePath(path.dirname(searchPath), configFilePath);
+
+      // Add dev dependency so we reload the config and any dependencies in watch mode.
+      this.addDevDependency({
+        specifier,
+        resolveFrom: searchPath,
+      });
+
+      // Invalidate on startup in case the config is non-deterministic,
+      // e.g. uses unknown environment variables, reads from the filesystem, etc.
+      this.invalidateOnStartup();
+
+      let config = await this.#options.packageManager.require(
+        specifier,
+        searchPath,
+      );
+
+      if (
+        // $FlowFixMe
+        Object.prototype.toString.call(config) === '[object Module]' &&
+        config.default != null
+      ) {
+        // Native ESM config. Try to use a default export, otherwise fall back to the whole namespace.
+        config = config.default;
+      }
+
+      return {
+        contents: config,
+        filePath: configFilePath,
+      };
+    }
+
+    let conf = await readConfig(
+      this.#options.inputFS,
+      configFilePath,
+      parse == null ? null : {parse},
+    );
+    if (conf == null) {
+      return null;
+    }
+
+    return {
+      contents: conf.config,
+      filePath: configFilePath,
+    };
+  }
+
+  getConfig<T>(
+    filePaths: Array<FilePath>,
+    options: ?{|
+      packageKey?: string,
+      parse?: boolean,
+      exclude?: boolean,
+    |},
+  ): Promise<?ConfigResultWithFilePath<T>> {
+    return this.getConfigFrom(this.searchPath, filePaths, options);
+  }
+
+  async getPackage(): Promise<?PackageJSON> {
+    if (this.#pkg) {
+      return this.#pkg;
+    }
+
+    let pkgConfig = await this.getConfig<PackageJSON>(['package.json']);
+    if (!pkgConfig) {
+      return null;
+    }
+
+    this.#pkg = pkgConfig.contents;
+    this.#pkgFilePath = pkgConfig.filePath;
+
+    return this.#pkg;
+  }
+}

package/src/public/Dependency.js

@@ -0,0 +1,176 @@
+// @flow
+import type {
+  Dependency as IDependency,
+  Environment as IEnvironment,
+  FilePath,
+  Meta,
+  MutableDependencySymbols as IMutableDependencySymbols,
+  SourceLocation,
+  SpecifierType,
+  DependencyPriority,
+  BundleBehavior,
+} from '@atlaspack/types';
+import type {
+  Dependency as InternalDependency,
+  AtlaspackOptions,
+} from '../types';
+import {BundleBehaviorNames} from '../types';
+
+import nullthrows from 'nullthrows';
+import Environment from './Environment';
+import Target from './Target';
+import {MutableDependencySymbols} from './Symbols';
+import {
+  SpecifierType as SpecifierTypeMap,
+  Priority,
+  ExportsCondition,
+} from '../types';
+import {fromProjectPath} from '../projectPath';
+import {fromInternalSourceLocation} from '../utils';
+
+const SpecifierTypeNames = Object.keys(SpecifierTypeMap);
+const PriorityNames = Object.keys(Priority);
+
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+
+const internalDependencyToDependency: WeakMap<InternalDependency, Dependency> =
+  new WeakMap();
+const _dependencyToInternalDependency: WeakMap<
+  IDependency,
+  InternalDependency,
+> = new WeakMap();
+export function dependencyToInternalDependency(
+  dependency: IDependency,
+): InternalDependency {
+  return nullthrows(_dependencyToInternalDependency.get(dependency));
+}
+
+export function getPublicDependency(
+  dep: InternalDependency,
+  options: AtlaspackOptions,
+): Dependency {
+  let existing = internalDependencyToDependency.get(dep);
+  if (existing != null) {
+    return existing;
+  }
+
+  return new Dependency(dep, options);
+}
+
+export default class Dependency implements IDependency {
+  #dep /*: InternalDependency */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(dep: InternalDependency, options: AtlaspackOptions): Dependency {
+    this.#dep = dep;
+    this.#options = options;
+    _dependencyToInternalDependency.set(this, dep);
+    internalDependencyToDependency.set(dep, this);
+    return this;
+  }
+
+  // $FlowFixMe
+  [inspect](): string {
+    return `Dependency(${String(this.sourcePath)} -> ${this.specifier})`;
+  }
+
+  get id(): string {
+    return this.#dep.id;
+  }
+
+  get specifier(): string {
+    return this.#dep.specifier;
+  }
+
+  get specifierType(): SpecifierType {
+    return SpecifierTypeNames[this.#dep.specifierType];
+  }
+
+  get priority(): DependencyPriority {
+    return PriorityNames[this.#dep.priority];
+  }
+
+  get needsStableName(): boolean {
+    return this.#dep.needsStableName;
+  }
+
+  get bundleBehavior(): ?BundleBehavior {
+    let bundleBehavior = this.#dep.bundleBehavior;
+    return bundleBehavior == null ? null : BundleBehaviorNames[bundleBehavior];
+  }
+
+  get isEntry(): boolean {
+    return this.#dep.isEntry;
+  }
+
+  get isOptional(): boolean {
+    return this.#dep.isOptional;
+  }
+
+  get loc(): ?SourceLocation {
+    return fromInternalSourceLocation(this.#options.projectRoot, this.#dep.loc);
+  }
+
+  get env(): IEnvironment {
+    return new Environment(this.#dep.env, this.#options);
+  }
+
+  get packageConditions(): ?Array<string> {
+    // Merge custom conditions with conditions stored as bitflags.
+    // Order is not important because exports conditions are resolved
+    // in the order they are declared in the package.json.
+    let conditions = this.#dep.customPackageConditions;
+    if (this.#dep.packageConditions) {
+      conditions = conditions ? [...conditions] : [];
+      for (let key in ExportsCondition) {
+        if (this.#dep.packageConditions & ExportsCondition[key]) {
+          conditions.push(key);
+        }
+      }
+    }
+
+    return conditions;
+  }
+
+  get meta(): Meta {
+    return this.#dep.meta;
+  }
+
+  get symbols(): IMutableDependencySymbols {
+    return new MutableDependencySymbols(this.#options, this.#dep);
+  }
+
+  get target(): ?Target {
+    let target = this.#dep.target;
+    return target ? new Target(target, this.#options) : null;
+  }
+
+  get sourceAssetId(): ?string {
+    // TODO: does this need to be public?
+    return this.#dep.sourceAssetId;
+  }
+
+  get sourcePath(): ?FilePath {
+    // TODO: does this need to be public?
+    return fromProjectPath(this.#options.projectRoot, this.#dep.sourcePath);
+  }
+
+  get sourceAssetType(): ?string {
+    return this.#dep.sourceAssetType;
+  }
+
+  get resolveFrom(): ?string {
+    return fromProjectPath(
+      this.#options.projectRoot,
+      this.#dep.resolveFrom ?? this.#dep.sourcePath,
+    );
+  }
+
+  get range(): ?string {
+    return this.#dep.range;
+  }
+
+  get pipeline(): ?string {
+    return this.#dep.pipeline;
+  }
+}