@atlaspack/core 2.12.1-canary.3354

package/src/atlaspack-v3/jsCallable.js

@@ -0,0 +1,13 @@
+// @flow strict-local
+
+export function jsCallable<Args: $ReadOnlyArray<mixed>, Return>(
+  fn: (...Args) => Return,
+): (...Args) => Return {
+  return (...args: Args) => {
+    try {
+      return fn(...args);
+    } catch (err) {
+      return err;
+    }
+  };
+}

package/src/atlaspack-v3/plugins/Resolver.js

@@ -0,0 +1,9 @@
+// @flow
+
+export class ResolverNapi {
+  constructor() {}
+
+  loadConfig() {}
+
+  resolve() {}
+}

package/src/atlaspack-v3/plugins/index.js

@@ -0,0 +1,3 @@
+// @flow
+
+export * from './Resolver';

package/src/atlaspack-v3/worker/index.js

@@ -0,0 +1,8 @@
+if (
+  process.env.ATLASPACK_BUILD_ENV !== 'production' ||
+  process.env.ATLASPACK_SELF_BUILD
+) {
+  require('@atlaspack/babel-register');
+}
+
+require('./worker');

package/src/atlaspack-v3/worker/worker.js

@@ -0,0 +1,14 @@
+// @flow
+import * as napi from '@atlaspack/rust';
+import {workerData} from 'worker_threads';
+import type {ResolverNapi} from '../plugins/Resolver';
+
+export class AtlaspackWorker {
+  #resolvers: Map<string, ResolverNapi>;
+
+  ping() {
+    // console.log('Hi');
+  }
+}
+
+napi.registerWorker(workerData.tx_worker, new AtlaspackWorker());

package/src/buildCache.js

@@ -0,0 +1,15 @@
+// @flow
+
+const buildCaches: Array<Map<any, any>> = [];
+
+export function createBuildCache<K, V>(): Map<K, V> {
+  let cache = new Map<K, V>();
+  buildCaches.push(cache);
+  return cache;
+}
+
+export function clearBuildCaches() {
+  for (let cache of buildCaches) {
+    cache.clear();
+  }
+}

package/src/constants.js

@@ -0,0 +1,22 @@
+// @flow strict-local
+
+// $FlowFixMe
+import {version} from '../package.json';
+
+export const ATLASPACK_VERSION = version;
+export const HASH_REF_PREFIX = 'HASH_REF_';
+export const HASH_REF_HASH_LEN = 16;
+export const HASH_REF_REGEX: RegExp = new RegExp(
+  `${HASH_REF_PREFIX}\\w{${HASH_REF_HASH_LEN}}`,
+  'g',
+);
+
+export const VALID = 0;
+export const INITIAL_BUILD = 1 << 0;
+export const FILE_CREATE = 1 << 1;
+export const FILE_UPDATE = 1 << 2;
+export const FILE_DELETE = 1 << 3;
+export const ENV_CHANGE = 1 << 4;
+export const OPTION_CHANGE = 1 << 5;
+export const STARTUP = 1 << 6;
+export const ERROR = 1 << 7;

package/src/dumpGraphToGraphViz.js

@@ -0,0 +1,244 @@
+// @flow
+
+import type {Asset, BundleBehavior} from '@atlaspack/types';
+import type {Graph} from '@atlaspack/graph';
+import type {AssetGraphNode, BundleGraphNode, Environment} from './types';
+import {bundleGraphEdgeTypes} from './BundleGraph';
+import {requestGraphEdgeTypes} from './RequestTracker';
+
+import path from 'path';
+import {fromNodeId} from '@atlaspack/graph';
+import {fromProjectPathRelative} from './projectPath';
+import {SpecifierType, Priority} from './types';
+
+const COLORS = {
+  root: 'gray',
+  asset: 'green',
+  dependency: 'orange',
+  transformer_request: 'cyan',
+  file: 'gray',
+  default: 'white',
+};
+
+const TYPE_COLORS = {
+  // bundle graph
+  bundle: 'blue',
+  contains: 'grey',
+  internal_async: 'orange',
+  references: 'red',
+  sibling: 'green',
+  // asset graph
+  // request graph
+  invalidated_by_create: 'green',
+  invalidated_by_create_above: 'orange',
+  invalidate_by_update: 'cyan',
+  invalidated_by_delete: 'red',
+};
+
+export default async function dumpGraphToGraphViz(
+  graph:
+    | Graph<AssetGraphNode>
+    | Graph<{|
+        assets: Set<Asset>,
+        sourceBundles: Set<number>,
+        bundleBehavior?: ?BundleBehavior,
+      |}>
+    | Graph<BundleGraphNode>,
+  name: string,
+  edgeTypes?: typeof bundleGraphEdgeTypes | typeof requestGraphEdgeTypes,
+): Promise<void> {
+  if (
+    process.env.ATLASPACK_BUILD_ENV === 'production' &&
+    !process.env.ATLASPACK_BUILD_REPL
+  ) {
+    return;
+  }
+
+  let mode: ?string = process.env.ATLASPACK_BUILD_REPL
+    ? // $FlowFixMe
+      globalThis.ATLASPACK_DUMP_GRAPHVIZ?.mode
+    : process.env.ATLASPACK_DUMP_GRAPHVIZ;
+
+  // $FlowFixMe[invalid-compare]
+  if (mode == null || mode == false) {
+    return;
+  }
+
+  let detailedSymbols = mode === 'symbols';
+
+  let GraphVizGraph = require('graphviz/lib/deps/graph').Graph;
+  let g = new GraphVizGraph(null, 'G');
+  g.type = 'digraph';
+  // $FlowFixMe
+  for (let [id, node] of graph.nodes.entries()) {
+    if (node == null) continue;
+    let n = g.addNode(nodeId(id));
+    // $FlowFixMe default is fine. Not every type needs to be in the map.
+    n.set('color', COLORS[node.type || 'default']);
+    n.set('shape', 'box');
+    n.set('style', 'filled');
+    let label;
+    if (typeof node === 'string') {
+      label = node;
+    } else if (node.assets) {
+      label = `(${nodeId(id)}), (assetIds: ${[...node.assets]
+        .map(a => {
+          let arr = a.filePath.split('/');
+          return arr[arr.length - 1];
+        })
+        .join(', ')}) (sourceBundles: ${[...node.sourceBundles].join(
+        ', ',
+      )}) (bb ${node.bundleBehavior ?? 'none'})`;
+    } else if (node.type) {
+      label = `[${fromNodeId(id)}] ${node.type || 'No Type'}: [${node.id}]: `;
+      if (node.type === 'dependency') {
+        label += node.value.specifier;
+        let parts = [];
+        if (node.value.priority !== Priority.sync) {
+          parts.push(
+            Object.entries(Priority).find(
+              ([, v]) => v === node.value.priority,
+            )?.[0],
+          );
+        }
+        if (node.value.isOptional) parts.push('optional');
+        if (node.value.specifierType === SpecifierType.url) parts.push('url');
+        if (node.hasDeferred) parts.push('deferred');
+        if (node.deferred) parts.push('deferred');
+        if (node.excluded) parts.push('excluded');
+        if (parts.length) label += ' (' + parts.join(', ') + ')';
+        if (node.value.env) label += ` (${getEnvDescription(node.value.env)})`;
+        let depSymbols = node.value.symbols;
+        if (detailedSymbols) {
+          if (depSymbols) {
+            if (depSymbols.size) {
+              label +=
+                '\\nsymbols: ' +
+                [...depSymbols].map(([e, {local}]) => [e, local]).join(';');
+            }
+            let weakSymbols = [...depSymbols]
+              .filter(([, {isWeak}]) => isWeak)
+              .map(([s]) => s);
+            if (weakSymbols.length) {
+              label += '\\nweakSymbols: ' + weakSymbols.join(',');
+            }
+            if (node.usedSymbolsUp.size > 0) {
+              label +=
+                '\\nusedSymbolsUp: ' +
+                [...node.usedSymbolsUp]
+                  .map(([s, sAsset]) =>
+                    sAsset
+                      ? `${s}(${sAsset.asset}.${sAsset.symbol ?? ''})`
+                      : sAsset === null
+                      ? `${s}(external)`
+                      : `${s}(ambiguous)`,
+                  )
+                  .join(',');
+            }
+            if (node.usedSymbolsDown.size > 0) {
+              label +=
+                '\\nusedSymbolsDown: ' + [...node.usedSymbolsDown].join(',');
+            }
+            // if (node.usedSymbolsDownDirty) label += '\\nusedSymbolsDownDirty';
+            // if (node.usedSymbolsUpDirtyDown)
+            //   label += '\\nusedSymbolsUpDirtyDown';
+            // if (node.usedSymbolsUpDirtyUp) label += '\\nusedSymbolsUpDirtyUp';
+          } else {
+            label += '\\nsymbols: cleared';
+          }
+        }
+      } else if (node.type === 'asset') {
+        label +=
+          path.basename(fromProjectPathRelative(node.value.filePath)) +
+          '#' +
+          node.value.type;
+        if (detailedSymbols) {
+          if (!node.value.symbols) {
+            label += '\\nsymbols: cleared';
+          } else if (node.value.symbols.size) {
+            label +=
+              '\\nsymbols: ' +
+              [...node.value.symbols]
+                .map(([e, {local}]) => [e, local])
+                .join(';');
+          }
+          if (node.usedSymbols.size) {
+            label += '\\nusedSymbols: ' + [...node.usedSymbols].join(',');
+          }
+          // if (node.usedSymbolsDownDirty) label += '\\nusedSymbolsDownDirty';
+          // if (node.usedSymbolsUpDirty) label += '\\nusedSymbolsUpDirty';
+        } else {
+          label += '\\nsymbols: cleared';
+        }
+      } else if (node.type === 'asset_group') {
+        if (node.deferred) label += '(deferred)';
+      } else if (node.type === 'file') {
+        label += path.basename(node.id);
+      } else if (node.type === 'transformer_request') {
+        label +=
+          path.basename(node.value.filePath) +
+          ` (${getEnvDescription(node.value.env)})`;
+      } else if (node.type === 'bundle') {
+        let parts = [];
+        if (node.value.needsStableName) parts.push('stable name');
+        parts.push(node.value.name);
+        parts.push('bb:' + (node.value.bundleBehavior ?? 'null'));
+        if (node.value.isPlaceholder) parts.push('placeholder');
+        if (parts.length) label += ' (' + parts.join(', ') + ')';
+        if (node.value.env) label += ` (${getEnvDescription(node.value.env)})`;
+      } else if (node.type === 'request') {
+        label = node.requestType + ':' + node.id;
+      }
+    }
+    n.set('label', label);
+  }
+
+  let edgeNames;
+  if (edgeTypes) {
+    edgeNames = Object.fromEntries(
+      Object.entries(edgeTypes).map(([k, v]) => [v, k]),
+    );
+  }
+
+  for (let edge of graph.getAllEdges()) {
+    let gEdge = g.addEdge(nodeId(edge.from), nodeId(edge.to));
+    let color = null;
+    if (edge.type != 1 && edgeNames) {
+      color = TYPE_COLORS[edgeNames[edge.type]];
+    }
+    if (color != null) {
+      gEdge.set('color', color);
+    }
+  }
+
+  if (process.env.ATLASPACK_BUILD_REPL) {
+    // $FlowFixMe
+    globalThis.ATLASPACK_DUMP_GRAPHVIZ?.(name, g.to_dot());
+  } else {
+    const tempy = require('tempy');
+    let tmp = tempy.file({name: `atlaspack-${name}.png`});
+    await g.output('png', tmp);
+    // eslint-disable-next-line no-console
+    console.log('Dumped', tmp);
+  }
+}
+
+function nodeId(id) {
+  // $FlowFixMe
+  return `node${id}`;
+}
+
+function getEnvDescription(env: Environment) {
+  let description;
+  if (typeof env.engines.browsers === 'string') {
+    description = `${env.context}: ${env.engines.browsers}`;
+  } else if (Array.isArray(env.engines.browsers)) {
+    description = `${env.context}: ${env.engines.browsers.join(', ')}`;
+  } else if (env.engines.node) {
+    description = `node: ${env.engines.node}`;
+  } else if (env.engines.electron) {
+    description = `electron: ${env.engines.electron}`;
+  }
+
+  return description ?? '';
+}

package/src/index.js

@@ -0,0 +1,22 @@
+// @flow
+
+// Needs to be exported first because of circular imports
+export {
+  registerSerializableClass,
+  unregisterSerializableClass,
+  prepareForSerialization,
+  restoreDeserializedObject,
+  serialize,
+  deserialize,
+} from './serializer';
+
+export {
+  default,
+  default as Atlaspack,
+  BuildError,
+  createWorkerFarm,
+  INTERNAL_RESOLVE,
+  INTERNAL_TRANSFORM,
+} from './Atlaspack';
+
+export * from './atlaspack-v3';

package/src/loadAtlaspackPlugin.js

@@ -0,0 +1,239 @@
+// @flow
+import type {
+  FilePath,
+  PackageName,
+  Semver,
+  SemverRange,
+} from '@atlaspack/types';
+import type {AtlaspackOptions} from './types';
+
+import path from 'path';
+import semver from 'semver';
+import logger from '@atlaspack/logger';
+import nullthrows from 'nullthrows';
+import ThrowableDiagnostic, {
+  generateJSONCodeHighlights,
+  md,
+} from '@atlaspack/diagnostic';
+import {
+  findAlternativeNodeModules,
+  loadConfig,
+  resolveConfig,
+} from '@atlaspack/utils';
+import {type ProjectPath, toProjectPath} from './projectPath';
+import {version as ATLASPACK_VERSION} from '../package.json';
+
+const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
+const CONFIG = Symbol.for('atlaspack-plugin-config');
+
+export default async function loadPlugin<T>(
+  pluginName: PackageName,
+  configPath: FilePath,
+  keyPath?: string,
+  options: AtlaspackOptions,
+): Promise<{|
+  plugin: T,
+  version: Semver,
+  resolveFrom: ProjectPath,
+  range: ?SemverRange,
+|}> {
+  let resolveFrom = configPath;
+  let range;
+  if (resolveFrom.includes(NODE_MODULES)) {
+    // Config packages can reference plugins, but cannot contain other plugins within them.
+    // This forces every published plugin to be published separately so they can be mixed and matched if needed.
+    if (pluginName.startsWith('.')) {
+      let configContents = await options.inputFS.readFile(configPath, 'utf8');
+      throw new ThrowableDiagnostic({
+        diagnostic: {
+          message: md`Local plugins are not supported in Atlaspack config packages. Please publish "${pluginName}" as a separate npm package.`,
+          origin: '@atlaspack/core',
+          codeFrames: keyPath
+            ? [
+                {
+                  filePath: configPath,
+                  language: 'json5',
+                  code: configContents,
+                  codeHighlights: generateJSONCodeHighlights(configContents, [
+                    {
+                      key: keyPath,
+                      type: 'value',
+                    },
+                  ]),
+                },
+              ]
+            : undefined,
+        },
+      });
+    }
+
+    let configPkg = await loadConfig(
+      options.inputFS,
+      resolveFrom,
+      ['package.json'],
+      options.projectRoot,
+    );
+    if (
+      configPkg != null &&
+      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];
+
+      if (range == null) {
+        let contents = await options.inputFS.readFile(
+          configPkg.files[0].filePath,
+          'utf8',
+        );
+        throw new ThrowableDiagnostic({
+          diagnostic: {
+            message: md`Could not determine version of ${pluginName} in ${path.relative(
+              process.cwd(),
+              resolveFrom,
+            )}. Either include it in "dependencies" or "atlaspackDependencies".`,
+            origin: '@atlaspack/core',
+            codeFrames:
+              configPkg.config.dependencies ||
+              configPkg.config.atlaspackDependencies
+                ? [
+                    {
+                      filePath: configPkg.files[0].filePath,
+                      language: 'json5',
+                      code: contents,
+                      codeHighlights: generateJSONCodeHighlights(contents, [
+                        {
+                          key: configPkg.config.atlaspackDependencies
+                            ? '/atlaspackDependencies'
+                            : '/dependencies',
+                          type: 'key',
+                        },
+                      ]),
+                    },
+                  ]
+                : undefined,
+          },
+        });
+      }
+
+      // Resolve from project root if not in the config's dependencies.
+      resolveFrom = path.join(options.projectRoot, 'index');
+    }
+  }
+
+  let resolved, pkg;
+  try {
+    ({resolved, pkg} = await options.packageManager.resolve(
+      pluginName,
+      resolveFrom,
+      {
+        shouldAutoInstall: options.shouldAutoInstall,
+        range,
+      },
+    ));
+  } catch (err) {
+    if (err.code !== 'MODULE_NOT_FOUND') {
+      throw err;
+    }
+
+    let configContents = await options.inputFS.readFile(configPath, 'utf8');
+    let alternatives = await findAlternativeNodeModules(
+      options.inputFS,
+      pluginName,
+      path.dirname(resolveFrom),
+    );
+    throw new ThrowableDiagnostic({
+      diagnostic: {
+        message: md`Cannot find Atlaspack plugin "${pluginName}"`,
+        origin: '@atlaspack/core',
+        codeFrames: keyPath
+          ? [
+              {
+                filePath: configPath,
+                language: 'json5',
+                code: configContents,
+                codeHighlights: generateJSONCodeHighlights(configContents, [
+                  {
+                    key: keyPath,
+                    type: 'value',
+                    message: md`Cannot find module "${pluginName}"${
+                      alternatives[0]
+                        ? `, did you mean "${alternatives[0]}"?`
+                        : ''
+                    }`,
+                  },
+                ]),
+              },
+            ]
+          : undefined,
+      },
+    });
+  }
+
+  // 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) {
+        logger.warn({
+          origin: '@atlaspack/core',
+          message: `The plugin "${pluginName}" needs to specify a \`package.json#engines.atlaspack\` field with the supported Atlaspack version range.`,
+        });
+      }
+
+      if (
+        atlaspackVersionRange &&
+        !semver.satisfies(ATLASPACK_VERSION, atlaspackVersionRange)
+      ) {
+        let pkgFile = nullthrows(
+          await resolveConfig(
+            options.inputFS,
+            resolved,
+            ['package.json'],
+            options.projectRoot,
+          ),
+        );
+        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}".`,
+            origin: '@atlaspack/core',
+            codeFrames: [
+              {
+                filePath: pkgFile,
+                language: 'json5',
+                code: pkgContents,
+                codeHighlights: generateJSONCodeHighlights(pkgContents, [
+                  {
+                    key: '/engines/atlaspack',
+                  },
+                ]),
+              },
+            ],
+          },
+        });
+      }
+    }
+  }
+
+  let plugin = await options.packageManager.require(pluginName, resolveFrom, {
+    shouldAutoInstall: options.shouldAutoInstall,
+  });
+  plugin = plugin.default ? plugin.default : plugin;
+  if (!plugin) {
+    throw new Error(`Plugin ${pluginName} has no exports.`);
+  }
+  plugin = plugin[CONFIG];
+  if (!plugin) {
+    throw new Error(
+      `Plugin ${pluginName} is not a valid Atlaspack plugin, should export an instance of a Atlaspack plugin ex. "export default new Reporter({ ... })".`,
+    );
+  }
+  return {
+    plugin,
+    version: nullthrows(pkg).version,
+    resolveFrom: toProjectPath(options.projectRoot, resolveFrom),
+    range,
+  };
+}

package/src/loadDotEnv.js

@@ -0,0 +1,56 @@
+// @flow strict-local
+
+import type {FileSystem} from '@atlaspack/fs';
+import type {EnvMap, FilePath} from '@atlaspack/types';
+
+import {resolveConfig} from '@atlaspack/utils';
+import dotenv from 'dotenv';
+import variableExpansion from 'dotenv-expand';
+
+export default async function loadEnv(
+  env: EnvMap,
+  fs: FileSystem,
+  filePath: FilePath,
+  projectRoot: FilePath,
+): Promise<EnvMap> {
+  const NODE_ENV = env.NODE_ENV ?? 'development';
+
+  const dotenvFiles = [
+    '.env',
+    // Don't include `.env.local` for `test` environment
+    // since normally you expect tests to produce the same
+    // results for everyone
+    NODE_ENV === 'test' ? null : '.env.local',
+    `.env.${NODE_ENV}`,
+    `.env.${NODE_ENV}.local`,
+  ].filter(Boolean);
+
+  let envs = await Promise.all(
+    dotenvFiles.map(async dotenvFile => {
+      const envPath = await resolveConfig(
+        fs,
+        filePath,
+        [dotenvFile],
+        projectRoot,
+      );
+      if (envPath == null) {
+        return;
+      }
+
+      // `ignoreProcessEnv` prevents dotenv-expand from writing values into `process.env`:
+      // https://github.com/motdotla/dotenv-expand/blob/ddb73d02322fe8522b4e05b73e1c1ad24ea7c14a/lib/main.js#L5
+      let output = variableExpansion({
+        parsed: dotenv.parse(await fs.readFile(envPath)),
+        ignoreProcessEnv: true,
+      });
+
+      if (output.error != null) {
+        throw output.error;
+      }
+
+      return output.parsed;
+    }),
+  );
+
+  return Object.assign({}, ...envs);
+}