@atlaspack/core 2.12.1-canary.3354

package/src/public/PluginOptions.js

@@ -0,0 +1,99 @@
+// @flow
+import type {
+  BuildMode,
+  EnvMap,
+  FilePath,
+  LogLevel,
+  PluginOptions as IPluginOptions,
+  ServerOptions,
+  HMROptions,
+  DetailedReportOptions,
+} from '@atlaspack/types';
+import type {FileSystem} from '@atlaspack/fs';
+import type {PackageManager} from '@atlaspack/package-manager';
+import type {AtlaspackOptions} from '../types';
+import {type FeatureFlags} from '@atlaspack/feature-flags';
+
+let atlaspackOptionsToPluginOptions: WeakMap<AtlaspackOptions, PluginOptions> =
+  new WeakMap();
+
+export default class PluginOptions implements IPluginOptions {
+  #options /*: AtlaspackOptions */;
+
+  constructor(options: AtlaspackOptions): PluginOptions {
+    let existing = atlaspackOptionsToPluginOptions.get(options);
+    if (existing != null) {
+      return existing;
+    }
+
+    this.#options = options;
+    atlaspackOptionsToPluginOptions.set(options, this);
+    return this;
+  }
+
+  get instanceId(): string {
+    return this.#options.instanceId;
+  }
+
+  get mode(): BuildMode {
+    return this.#options.mode;
+  }
+
+  get env(): EnvMap {
+    return this.#options.env;
+  }
+
+  get atlaspackVersion(): string {
+    return this.#options.atlaspackVersion;
+  }
+
+  get hmrOptions(): ?HMROptions {
+    return this.#options.hmrOptions;
+  }
+
+  get serveOptions(): ServerOptions | false {
+    return this.#options.serveOptions;
+  }
+
+  get shouldBuildLazily(): boolean {
+    return this.#options.shouldBuildLazily;
+  }
+
+  get shouldAutoInstall(): boolean {
+    return this.#options.shouldAutoInstall;
+  }
+
+  get logLevel(): LogLevel {
+    return this.#options.logLevel;
+  }
+
+  get cacheDir(): FilePath {
+    // TODO: remove this. Probably bad if there are other types of caches.
+    // Maybe expose the Cache object instead?
+    return this.#options.cacheDir;
+  }
+
+  get projectRoot(): FilePath {
+    return this.#options.projectRoot;
+  }
+
+  get inputFS(): FileSystem {
+    return this.#options.inputFS;
+  }
+
+  get outputFS(): FileSystem {
+    return this.#options.outputFS;
+  }
+
+  get packageManager(): PackageManager {
+    return this.#options.packageManager;
+  }
+
+  get detailedReport(): ?DetailedReportOptions {
+    return this.#options.detailedReport;
+  }
+
+  get featureFlags(): FeatureFlags {
+    return this.#options.featureFlags;
+  }
+}

package/src/public/Symbols.js

@@ -0,0 +1,315 @@
+// @flow
+import type {
+  Symbol as ISymbol,
+  MutableAssetSymbols as IMutableAssetSymbols,
+  AssetSymbols as IAssetSymbols,
+  MutableDependencySymbols as IMutableDependencySymbols,
+  SourceLocation,
+  Meta,
+} from '@atlaspack/types';
+import type {Asset, Dependency, AtlaspackOptions} from '../types';
+
+import nullthrows from 'nullthrows';
+import {fromInternalSourceLocation, toInternalSourceLocation} from '../utils';
+
+const EMPTY_ITERABLE = {
+  [Symbol.iterator]() {
+    return EMPTY_ITERATOR;
+  },
+};
+
+const EMPTY_ITERATOR = {
+  next() {
+    return {done: true};
+  },
+};
+
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+
+let valueToSymbols: WeakMap<Asset, AssetSymbols> = new WeakMap();
+export class AssetSymbols implements IAssetSymbols {
+  /*::
+  @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|}]> { return ({}: any); }
+  */
+  #value: Asset;
+  #options: AtlaspackOptions;
+
+  constructor(options: AtlaspackOptions, asset: Asset): AssetSymbols {
+    let existing = valueToSymbols.get(asset);
+    if (existing != null) {
+      return existing;
+    }
+
+    this.#value = asset;
+    this.#options = options;
+    valueToSymbols.set(asset, this);
+    return this;
+  }
+
+  hasExportSymbol(exportSymbol: ISymbol): boolean {
+    return Boolean(this.#value.symbols?.has(exportSymbol));
+  }
+
+  hasLocalSymbol(local: ISymbol): boolean {
+    if (this.#value.symbols == null) {
+      return false;
+    }
+    for (let s of this.#value.symbols.values()) {
+      if (local === s.local) return true;
+    }
+    return false;
+  }
+
+  get(
+    exportSymbol: ISymbol,
+  ): ?{|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|} {
+    return fromInternalAssetSymbol(
+      this.#options.projectRoot,
+      this.#value.symbols?.get(exportSymbol),
+    );
+  }
+
+  get isCleared(): boolean {
+    return this.#value.symbols == null;
+  }
+
+  exportSymbols(): Iterable<ISymbol> {
+    return this.#value.symbols?.keys() ?? [];
+  }
+  // $FlowFixMe
+  [Symbol.iterator]() {
+    return this.#value.symbols
+      ? this.#value.symbols[Symbol.iterator]()
+      : EMPTY_ITERATOR;
+  }
+
+  // $FlowFixMe
+  [inspect]() {
+    return `AssetSymbols(${
+      this.#value.symbols
+        ? [...this.#value.symbols]
+            .map(([s, {local}]) => `${s}:${local}`)
+            .join(', ')
+        : null
+    })`;
+  }
+}
+
+let valueToMutableAssetSymbols: WeakMap<Asset, MutableAssetSymbols> =
+  new WeakMap();
+export class MutableAssetSymbols implements IMutableAssetSymbols {
+  /*::
+  @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|}]> { return ({}: any); }
+  */
+  #value: Asset;
+  #options: AtlaspackOptions;
+
+  constructor(options: AtlaspackOptions, asset: Asset): MutableAssetSymbols {
+    let existing = valueToMutableAssetSymbols.get(asset);
+    if (existing != null) {
+      return existing;
+    }
+    this.#value = asset;
+    this.#options = options;
+    return this;
+  }
+
+  // immutable
+
+  hasExportSymbol(exportSymbol: ISymbol): boolean {
+    return Boolean(this.#value.symbols?.has(exportSymbol));
+  }
+
+  hasLocalSymbol(local: ISymbol): boolean {
+    if (this.#value.symbols == null) {
+      return false;
+    }
+    for (let s of this.#value.symbols.values()) {
+      if (local === s.local) return true;
+    }
+    return false;
+  }
+
+  get(
+    exportSymbol: ISymbol,
+  ): ?{|local: ISymbol, loc: ?SourceLocation, meta?: ?Meta|} {
+    return fromInternalAssetSymbol(
+      this.#options.projectRoot,
+      this.#value.symbols?.get(exportSymbol),
+    );
+  }
+
+  get isCleared(): boolean {
+    return this.#value.symbols == null;
+  }
+
+  exportSymbols(): Iterable<ISymbol> {
+    // $FlowFixMe
+    return this.#value.symbols.keys();
+  }
+  // $FlowFixMe
+  [Symbol.iterator]() {
+    return this.#value.symbols
+      ? this.#value.symbols[Symbol.iterator]()
+      : EMPTY_ITERATOR;
+  }
+
+  // $FlowFixMe
+  [inspect]() {
+    return `MutableAssetSymbols(${
+      this.#value.symbols
+        ? [...this.#value.symbols]
+            .map(([s, {local}]) => `${s}:${local}`)
+            .join(', ')
+        : null
+    })`;
+  }
+
+  // mutating
+
+  ensure(): void {
+    if (this.#value.symbols == null) {
+      this.#value.symbols = new Map();
+    }
+  }
+
+  set(
+    exportSymbol: ISymbol,
+    local: ISymbol,
+    loc: ?SourceLocation,
+    meta: ?Meta,
+  ) {
+    nullthrows(this.#value.symbols).set(exportSymbol, {
+      local,
+      loc: toInternalSourceLocation(this.#options.projectRoot, loc),
+      meta,
+    });
+  }
+
+  delete(exportSymbol: ISymbol) {
+    nullthrows(this.#value.symbols).delete(exportSymbol);
+  }
+}
+
+let valueToMutableDependencySymbols: WeakMap<
+  Dependency,
+  MutableDependencySymbols,
+> = new WeakMap();
+export class MutableDependencySymbols implements IMutableDependencySymbols {
+  /*::
+  @@iterator(): Iterator<[ISymbol, {|local: ISymbol, loc: ?SourceLocation, isWeak: boolean, meta?: ?Meta|}]> { return ({}: any); }
+  */
+  #value: Dependency;
+  #options: AtlaspackOptions;
+
+  constructor(
+    options: AtlaspackOptions,
+    dep: Dependency,
+  ): MutableDependencySymbols {
+    let existing = valueToMutableDependencySymbols.get(dep);
+    if (existing != null) {
+      return existing;
+    }
+    this.#value = dep;
+    this.#options = options;
+    return this;
+  }
+
+  // immutable:
+
+  hasExportSymbol(exportSymbol: ISymbol): boolean {
+    return Boolean(this.#value.symbols?.has(exportSymbol));
+  }
+
+  hasLocalSymbol(local: ISymbol): boolean {
+    if (this.#value.symbols) {
+      for (let s of this.#value.symbols.values()) {
+        if (local === s.local) return true;
+      }
+    }
+    return false;
+  }
+
+  get(
+    exportSymbol: ISymbol,
+  ): ?{|local: ISymbol, loc: ?SourceLocation, isWeak: boolean, meta?: ?Meta|} {
+    return fromInternalDependencySymbol(
+      this.#options.projectRoot,
+      nullthrows(this.#value.symbols).get(exportSymbol),
+    );
+  }
+
+  get isCleared(): boolean {
+    return this.#value.symbols == null;
+  }
+
+  exportSymbols(): Iterable<ISymbol> {
+    // $FlowFixMe
+    return this.#value.symbols ? this.#value.symbols.keys() : EMPTY_ITERABLE;
+  }
+
+  // $FlowFixMe
+  [Symbol.iterator]() {
+    return this.#value.symbols
+      ? this.#value.symbols[Symbol.iterator]()
+      : EMPTY_ITERATOR;
+  }
+
+  // $FlowFixMe
+  [inspect]() {
+    return `MutableDependencySymbols(${
+      this.#value.symbols
+        ? [...this.#value.symbols]
+            .map(([s, {local, isWeak}]) => `${s}:${local}${isWeak ? '?' : ''}`)
+            .join(', ')
+        : null
+    })`;
+  }
+
+  // mutating:
+
+  ensure(): void {
+    if (this.#value.symbols == null) {
+      this.#value.symbols = new Map();
+    }
+  }
+
+  set(
+    exportSymbol: ISymbol,
+    local: ISymbol,
+    loc: ?SourceLocation,
+    isWeak: ?boolean,
+  ) {
+    let symbols = nullthrows(this.#value.symbols);
+    symbols.set(exportSymbol, {
+      local,
+      loc: toInternalSourceLocation(this.#options.projectRoot, loc),
+      isWeak: (symbols.get(exportSymbol)?.isWeak ?? true) && (isWeak ?? false),
+    });
+  }
+
+  delete(exportSymbol: ISymbol) {
+    nullthrows(this.#value.symbols).delete(exportSymbol);
+  }
+}
+
+function fromInternalAssetSymbol(projectRoot: string, value) {
+  return (
+    value && {
+      local: value.local,
+      meta: value.meta,
+      loc: fromInternalSourceLocation(projectRoot, value.loc),
+    }
+  );
+}
+
+function fromInternalDependencySymbol(projectRoot: string, value) {
+  return (
+    value && {
+      local: value.local,
+      meta: value.meta,
+      isWeak: value.isWeak,
+      loc: fromInternalSourceLocation(projectRoot, value.loc),
+    }
+  );
+}

package/src/public/Target.js

@@ -0,0 +1,71 @@
+// @flow
+import type {
+  FilePath,
+  Target as ITarget,
+  Environment as IEnvironment,
+  SourceLocation,
+} from '@atlaspack/types';
+import type {Target as TargetValue, AtlaspackOptions} from '../types';
+
+import nullthrows from 'nullthrows';
+import Environment from './Environment';
+import {fromProjectPath} from '../projectPath';
+import {fromInternalSourceLocation} from '../utils';
+
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+
+const internalTargetToTarget: WeakMap<TargetValue, Target> = new WeakMap();
+const _targetToInternalTarget: WeakMap<ITarget, TargetValue> = new WeakMap();
+export function targetToInternalTarget(target: ITarget): TargetValue {
+  return nullthrows(_targetToInternalTarget.get(target));
+}
+
+export default class Target implements ITarget {
+  #target /*: TargetValue */;
+  #options /*: AtlaspackOptions */;
+
+  constructor(target: TargetValue, options: AtlaspackOptions): Target {
+    let existing = internalTargetToTarget.get(target);
+    if (existing != null) {
+      return existing;
+    }
+
+    this.#target = target;
+    this.#options = options;
+    _targetToInternalTarget.set(this, target);
+    internalTargetToTarget.set(target, this);
+    return this;
+  }
+
+  get distEntry(): ?FilePath {
+    return this.#target.distEntry;
+  }
+
+  get distDir(): FilePath {
+    return fromProjectPath(this.#options.projectRoot, this.#target.distDir);
+  }
+
+  get env(): IEnvironment {
+    return new Environment(this.#target.env, this.#options);
+  }
+
+  get name(): string {
+    return this.#target.name;
+  }
+
+  get publicUrl(): string {
+    return this.#target.publicUrl;
+  }
+
+  get loc(): ?SourceLocation {
+    return fromInternalSourceLocation(
+      this.#options.projectRoot,
+      this.#target.loc,
+    );
+  }
+
+  // $FlowFixMe[unsupported-syntax]
+  [inspect](): string {
+    return `Target(${this.name} - ${this.env[inspect]()})`;
+  }
+}

package/src/registerCoreWithSerializer.js

@@ -0,0 +1,34 @@
+// @flow
+import {Graph} from '@atlaspack/graph';
+import {registerSerializableClass} from './serializer';
+import AssetGraph from './AssetGraph';
+import BundleGraph from './BundleGraph';
+import AtlaspackConfig from './AtlaspackConfig';
+import {RequestGraph} from './RequestTracker';
+import Config from './public/Config';
+import packageJson from '../package.json';
+
+let coreRegistered;
+export function registerCoreWithSerializer() {
+  if (coreRegistered) {
+    return;
+  }
+  const packageVersion: mixed = packageJson.version;
+  if (typeof packageVersion !== 'string') {
+    throw new Error('Expected package version to be a string');
+  }
+
+  // $FlowFixMe[incompatible-cast]
+  for (let [name, ctor] of (Object.entries({
+    AssetGraph,
+    Config,
+    BundleGraph,
+    Graph,
+    AtlaspackConfig,
+    RequestGraph,
+    // $FlowFixMe[unclear-type]
+  }): Array<[string, Class<any>]>)) {
+    registerSerializableClass(packageVersion + ':' + name, ctor);
+  }
+  coreRegistered = true;
+}