@atlaspack/core 2.12.1-canary.3354

package/src/utils.js

@@ -0,0 +1,211 @@
+// @flow strict-local
+
+import type {
+  FilePath,
+  FileCreateInvalidation,
+  SourceLocation,
+} from '@atlaspack/types';
+import type {
+  BundleGroup,
+  AtlaspackOptions,
+  InternalFileCreateInvalidation,
+  InternalSourceLocation,
+  InternalDevDepOptions,
+  Invalidations,
+} from './types';
+import type {PackageManager} from '@atlaspack/package-manager';
+
+import invariant from 'assert';
+import baseX from 'base-x';
+import {hashObject} from '@atlaspack/utils';
+import {fromProjectPath, toProjectPath} from './projectPath';
+
+const base62 = baseX(
+  '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ',
+);
+
+export function getBundleGroupId(bundleGroup: BundleGroup): string {
+  return 'bundle_group:' + bundleGroup.target.name + bundleGroup.entryAssetId;
+}
+
+export function assertSignalNotAborted(signal: ?AbortSignal): void {
+  if (signal && signal.aborted) {
+    throw new BuildAbortError();
+  }
+}
+
+export class BuildAbortError extends Error {
+  name: string = 'BuildAbortError';
+}
+
+export function getPublicId(
+  id: string,
+  alreadyExists: string => boolean,
+): string {
+  let encoded = base62.encode(Buffer.from(id, 'hex'));
+  for (let end = 5; end <= encoded.length; end++) {
+    let candidate = encoded.slice(0, end);
+    if (!alreadyExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  throw new Error('Original id was not unique');
+}
+
+// These options don't affect compilation and should cause invalidations
+const ignoreOptions = new Set([
+  'env', // handled by separate invalidateOnEnvChange
+  'inputFS',
+  'outputFS',
+  'workerFarm',
+  'packageManager',
+  'detailedReport',
+  'shouldDisableCache',
+  'cacheDir',
+  'shouldAutoInstall',
+  'logLevel',
+  'shouldProfile',
+  'shouldTrace',
+  'shouldPatchConsole',
+  'projectRoot',
+  'additionalReporters',
+]);
+
+export function optionsProxy(
+  options: AtlaspackOptions,
+  invalidateOnOptionChange: string => void,
+  addDevDependency?: (devDep: InternalDevDepOptions) => void,
+): AtlaspackOptions {
+  let packageManager = addDevDependency
+    ? proxyPackageManager(
+        options.projectRoot,
+        options.packageManager,
+        addDevDependency,
+      )
+    : options.packageManager;
+  return new Proxy(options, {
+    get(target, prop) {
+      if (prop === 'packageManager') {
+        return packageManager;
+      }
+
+      if (!ignoreOptions.has(prop)) {
+        invalidateOnOptionChange(prop);
+      }
+
+      return target[prop];
+    },
+  });
+}
+
+function proxyPackageManager(
+  projectRoot: FilePath,
+  packageManager: PackageManager,
+  addDevDependency: (devDep: InternalDevDepOptions) => void,
+): PackageManager {
+  let require = (id: string, from: string, opts) => {
+    addDevDependency({
+      specifier: id,
+      resolveFrom: toProjectPath(projectRoot, from),
+      range: opts?.range,
+    });
+    return packageManager.require(id, from, opts);
+  };
+
+  return new Proxy(packageManager, {
+    get(target, prop) {
+      if (prop === 'require') {
+        return require;
+      }
+
+      // $FlowFixMe
+      return target[prop];
+    },
+  });
+}
+
+export function hashFromOption(value: mixed): string {
+  if (typeof value === 'object' && value != null) {
+    return hashObject(value);
+  }
+
+  return String(value);
+}
+
+export function invalidateOnFileCreateToInternal(
+  projectRoot: FilePath,
+  invalidation: FileCreateInvalidation,
+): InternalFileCreateInvalidation {
+  if (invalidation.glob != null) {
+    return {glob: toProjectPath(projectRoot, invalidation.glob)};
+  } else if (invalidation.filePath != null) {
+    return {
+      filePath: toProjectPath(projectRoot, invalidation.filePath),
+    };
+  } else {
+    invariant(
+      invalidation.aboveFilePath != null && invalidation.fileName != null,
+    );
+    return {
+      fileName: invalidation.fileName,
+      aboveFilePath: toProjectPath(projectRoot, invalidation.aboveFilePath),
+    };
+  }
+}
+
+export function createInvalidations(): Invalidations {
+  return {
+    invalidateOnBuild: false,
+    invalidateOnStartup: false,
+    invalidateOnOptionChange: new Set(),
+    invalidateOnEnvChange: new Set(),
+    invalidateOnFileChange: new Set(),
+    invalidateOnFileCreate: [],
+  };
+}
+
+export function fromInternalSourceLocation(
+  projectRoot: FilePath,
+  loc: ?InternalSourceLocation,
+): ?SourceLocation {
+  if (!loc) return loc;
+
+  return {
+    filePath: fromProjectPath(projectRoot, loc.filePath),
+    start: loc.start,
+    end: loc.end,
+  };
+}
+
+export function toInternalSourceLocation(
+  projectRoot: FilePath,
+  loc: ?SourceLocation,
+): ?InternalSourceLocation {
+  if (!loc) return loc;
+
+  return {
+    filePath: toProjectPath(projectRoot, loc.filePath),
+    start: loc.start,
+    end: loc.end,
+  };
+}
+export function toInternalSymbols<T: {|loc: ?SourceLocation|}>(
+  projectRoot: FilePath,
+  symbols: ?Map<Symbol, T>,
+): ?Map<
+  Symbol,
+  {|loc: ?InternalSourceLocation, ...$Rest<T, {|loc: ?SourceLocation|}>|},
+> {
+  if (!symbols) return symbols;
+
+  return new Map(
+    [...symbols].map(([k, {loc, ...v}]) => [
+      k,
+      {
+        ...v,
+        loc: toInternalSourceLocation(projectRoot, loc),
+      },
+    ]),
+  );
+}

package/src/worker.js

@@ -0,0 +1,189 @@
+// @flow strict-local
+
+import type {
+  Bundle,
+  AtlaspackOptions,
+  ProcessedAtlaspackConfig,
+  RequestInvalidation,
+} from './types';
+import type {SharedReference, WorkerApi} from '@atlaspack/workers';
+import {loadConfig as configCache} from '@atlaspack/utils';
+import type {DevDepSpecifier} from './requests/DevDepRequest';
+
+import invariant from 'assert';
+import nullthrows from 'nullthrows';
+import BundleGraph from './BundleGraph';
+import Transformation, {
+  type TransformationOpts,
+  type TransformationResult,
+} from './Transformation';
+import {reportWorker, report} from './ReporterRunner';
+import PackagerRunner, {type RunPackagerRunnerResult} from './PackagerRunner';
+import Validation, {type ValidationOpts} from './Validation';
+import AtlaspackConfig from './AtlaspackConfig';
+import {registerCoreWithSerializer} from './registerCoreWithSerializer';
+import {clearBuildCaches} from './buildCache';
+import {init as initSourcemaps} from '@parcel/source-map';
+import {init as initRust} from '@atlaspack/rust';
+import WorkerFarm from '@atlaspack/workers';
+import {setFeatureFlags} from '@atlaspack/feature-flags';
+
+import '@atlaspack/cache'; // register with serializer
+import '@atlaspack/package-manager';
+import '@atlaspack/fs';
+
+// $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 */
+}
+
+registerCoreWithSerializer();
+
+// Remove the workerApi type from the TransformationOpts and ValidationOpts types:
+// https://github.com/facebook/flow/issues/2835
+type WorkerTransformationOpts = {|
+  ...$Diff<TransformationOpts, {|workerApi: mixed, options: AtlaspackOptions|}>,
+  optionsRef: SharedReference,
+  configCachePath: string,
+|};
+type WorkerValidationOpts = {|
+  ...$Diff<ValidationOpts, {|workerApi: mixed, options: AtlaspackOptions|}>,
+  optionsRef: SharedReference,
+  configCachePath: string,
+|};
+
+// TODO: this should eventually be replaced by an in memory cache layer
+let atlaspackConfigCache = new Map();
+
+function loadOptions(ref, workerApi) {
+  return nullthrows(
+    ((workerApi.getSharedReference(
+      ref,
+      // $FlowFixMe
+    ): any): AtlaspackOptions),
+  );
+}
+
+async function loadConfig(cachePath, options) {
+  let config = atlaspackConfigCache.get(cachePath);
+  if (config && config.options === options) {
+    return config;
+  }
+
+  let processedConfig = nullthrows(
+    await options.cache.get<ProcessedAtlaspackConfig>(cachePath),
+  );
+  config = new AtlaspackConfig(processedConfig, options);
+  atlaspackConfigCache.set(cachePath, config);
+
+  setFeatureFlags(options.featureFlags);
+
+  return config;
+}
+
+export function clearConfigCache() {
+  configCache.clear();
+  clearBuildCaches();
+}
+
+export async function runTransform(
+  workerApi: WorkerApi,
+  opts: WorkerTransformationOpts,
+): Promise<TransformationResult> {
+  let {optionsRef, configCachePath, ...rest} = opts;
+  let options = loadOptions(optionsRef, workerApi);
+  let config = await loadConfig(configCachePath, options);
+
+  return new Transformation({
+    workerApi,
+    options,
+    config,
+    ...rest,
+  }).run();
+}
+
+export async function runValidate(
+  workerApi: WorkerApi,
+  opts: WorkerValidationOpts,
+): Promise<void> {
+  let {optionsRef, configCachePath, ...rest} = opts;
+  let options = loadOptions(optionsRef, workerApi);
+  let config = await loadConfig(configCachePath, options);
+
+  return new Validation({
+    workerApi,
+    report: reportWorker.bind(null, workerApi),
+    options,
+    config,
+    ...rest,
+  }).run();
+}
+
+export async function runPackage(
+  workerApi: WorkerApi,
+  {
+    bundle,
+    bundleGraphReference,
+    configCachePath,
+    optionsRef,
+    previousDevDeps,
+    invalidDevDeps,
+    previousInvalidations,
+  }: {|
+    bundle: Bundle,
+    bundleGraphReference: SharedReference,
+    configCachePath: string,
+    optionsRef: SharedReference,
+    previousDevDeps: Map<string, string>,
+    invalidDevDeps: Array<DevDepSpecifier>,
+    previousInvalidations: Array<RequestInvalidation>,
+  |},
+): Promise<RunPackagerRunnerResult> {
+  let bundleGraph = workerApi.getSharedReference(bundleGraphReference);
+  invariant(bundleGraph instanceof BundleGraph);
+  let options = loadOptions(optionsRef, workerApi);
+  let atlaspackConfig = await loadConfig(configCachePath, options);
+
+  let runner = new PackagerRunner({
+    config: atlaspackConfig,
+    options,
+    report: WorkerFarm.isWorker() ? reportWorker.bind(null, workerApi) : report,
+    previousDevDeps,
+    previousInvalidations,
+  });
+
+  return runner.run(bundleGraph, bundle, invalidDevDeps);
+}
+
+export async function childInit() {
+  await initSourcemaps;
+  await initRust?.();
+}
+
+const PKG_RE =
+  /node_modules[/\\]((?:@[^/\\]+[/\\][^/\\]+)|[^/\\]+)(?!.*[/\\]node_modules[/\\])/;
+export function invalidateRequireCache(workerApi: WorkerApi, file: string) {
+  if (process.env.ATLASPACK_BUILD_ENV === 'test') {
+    // Delete this module and all children in the same node_modules folder
+    let module = require.cache[file];
+    if (module) {
+      delete require.cache[file];
+
+      let pkg = file.match(PKG_RE)?.[1];
+      for (let child of module.children) {
+        if (pkg === child.id.match(PKG_RE)?.[1]) {
+          invalidateRequireCache(workerApi, child.id);
+        }
+      }
+    }
+
+    atlaspackConfigCache.clear();
+    return;
+  }
+
+  throw new Error('invalidateRequireCache is only for tests');
+}