@atlaspack/core 2.12.1-canary.3354

package/src/CommittedAsset.js

@@ -0,0 +1,143 @@
+// @flow strict-local
+
+import type {AST, Blob} from '@atlaspack/types';
+import type {Asset, Dependency, AtlaspackOptions} from './types';
+
+import {Readable} from 'stream';
+import SourceMap from '@parcel/source-map';
+import {bufferStream, blobToStream, streamFromPromise} from '@atlaspack/utils';
+import {generateFromAST} from './assetUtils';
+import {deserializeRaw} from './serializer';
+
+export default class CommittedAsset {
+  key: ?string;
+  value: Asset;
+  options: AtlaspackOptions;
+  content: ?Promise<Buffer | string>;
+  mapBuffer: ?Promise<?Buffer>;
+  map: ?Promise<?SourceMap>;
+  ast: ?Promise<AST>;
+  idBase: ?string;
+  generatingPromise: ?Promise<void>;
+
+  constructor(value: Asset, options: AtlaspackOptions) {
+    this.value = value;
+    this.key = this.value.contentKey;
+    this.options = options;
+  }
+
+  getContent(): Blob | Promise<Buffer | string> {
+    if (this.content == null) {
+      if (this.key != null) {
+        if (this.value.isLargeBlob) {
+          return this.options.cache.getStream(this.key);
+        } else {
+          return this.options.cache.getBlob(this.key);
+        }
+      } else if (this.value.astKey != null) {
+        return streamFromPromise(
+          generateFromAST(this).then(({content}) => {
+            if (!(content instanceof Readable)) {
+              this.content = Promise.resolve(content);
+            }
+            return content;
+          }),
+        );
+      } else {
+        throw new Error('Asset has no content');
+      }
+    }
+
+    return this.content;
+  }
+
+  async getCode(): Promise<string> {
+    let content;
+    if (this.content == null && this.key != null) {
+      this.content = this.options.cache.getBlob(this.key);
+      content = await this.content;
+    } else {
+      content = await this.getContent();
+    }
+
+    if (typeof content === 'string' || content instanceof Buffer) {
+      return content.toString();
+    } else if (content != null) {
+      this.content = bufferStream(content);
+      return (await this.content).toString();
+    }
+
+    return '';
+  }
+
+  async getBuffer(): Promise<Buffer> {
+    let content = await this.getContent();
+
+    if (content == null) {
+      return Buffer.alloc(0);
+    } else if (typeof content === 'string' || content instanceof Buffer) {
+      return Buffer.from(content);
+    }
+
+    this.content = bufferStream(content);
+    return this.content;
+  }
+
+  getStream(): Readable {
+    let content = this.getContent();
+    return content instanceof Promise
+      ? streamFromPromise(content)
+      : blobToStream(content);
+  }
+
+  getMapBuffer(): Promise<?Buffer> {
+    let mapKey = this.value.mapKey;
+    if (mapKey != null && this.mapBuffer == null) {
+      this.mapBuffer = (async () => {
+        try {
+          return await this.options.cache.getBlob(mapKey);
+        } catch (err) {
+          if (err.code === 'ENOENT' && this.value.astKey != null) {
+            return (await generateFromAST(this)).map?.toBuffer();
+          } else {
+            throw err;
+          }
+        }
+      })();
+    }
+
+    return this.mapBuffer ?? Promise.resolve();
+  }
+
+  getMap(): Promise<?SourceMap> {
+    if (this.map == null) {
+      this.map = (async () => {
+        let mapBuffer = await this.getMapBuffer();
+        if (mapBuffer) {
+          // Get sourcemap from flatbuffer
+          return new SourceMap(this.options.projectRoot, mapBuffer);
+        }
+      })();
+    }
+
+    return this.map;
+  }
+
+  getAST(): Promise<?AST> {
+    if (this.value.astKey == null) {
+      return Promise.resolve(null);
+    }
+
+    if (this.ast == null) {
+      this.ast = this.options.cache
+        .getBlob(this.value.astKey)
+        .then(serializedAst => deserializeRaw(serializedAst));
+    }
+
+    return this.ast;
+  }
+
+  getDependencies(): Array<Dependency> {
+    return Array.from(this.value.dependencies.values());
+  }
+}

package/src/Dependency.js

@@ -0,0 +1,142 @@
+// @flow
+import type {
+  FilePath,
+  Meta,
+  DependencySpecifier,
+  SourceLocation,
+  Symbol,
+  BundleBehavior as IBundleBehavior,
+  SemverRange,
+} from '@atlaspack/types';
+import type {Dependency, Environment, Target} from './types';
+import {hashString} from '@atlaspack/rust';
+import {
+  SpecifierType,
+  Priority,
+  BundleBehavior,
+  ExportsCondition,
+} from './types';
+
+import {toInternalSourceLocation} from './utils';
+import {toProjectPath} from './projectPath';
+
+type DependencyOpts = {|
+  id?: string,
+  sourcePath?: FilePath,
+  sourceAssetId?: string,
+  specifier: DependencySpecifier,
+  specifierType: $Keys<typeof SpecifierType>,
+  priority?: $Keys<typeof Priority>,
+  needsStableName?: boolean,
+  bundleBehavior?: ?IBundleBehavior,
+  isEntry?: boolean,
+  isOptional?: boolean,
+  loc?: SourceLocation,
+  env: Environment,
+  packageConditions?: Array<string>,
+  meta?: Meta,
+  resolveFrom?: FilePath,
+  range?: SemverRange,
+  target?: Target,
+  symbols?: ?Map<
+    Symbol,
+    {|local: Symbol, loc: ?SourceLocation, isWeak: boolean, meta?: ?Meta|},
+  >,
+  pipeline?: ?string,
+|};
+
+export function createDependency(
+  projectRoot: FilePath,
+  opts: DependencyOpts,
+): Dependency {
+  let id =
+    opts.id ||
+    hashString(
+      (opts.sourceAssetId ?? '') +
+        opts.specifier +
+        opts.env.id +
+        (opts.target ? JSON.stringify(opts.target) : '') +
+        (opts.pipeline ?? '') +
+        opts.specifierType +
+        (opts.bundleBehavior ?? '') +
+        (opts.priority ?? 'sync') +
+        (opts.packageConditions ? JSON.stringify(opts.packageConditions) : ''),
+    );
+
+  let dep: Dependency = {
+    id,
+    specifier: opts.specifier,
+    specifierType: SpecifierType[opts.specifierType],
+    priority: Priority[opts.priority ?? 'sync'],
+    needsStableName: opts.needsStableName ?? false,
+    bundleBehavior: opts.bundleBehavior
+      ? BundleBehavior[opts.bundleBehavior]
+      : null,
+    isEntry: opts.isEntry ?? false,
+    isOptional: opts.isOptional ?? false,
+    loc: toInternalSourceLocation(projectRoot, opts.loc),
+    env: opts.env,
+    meta: opts.meta || {},
+    target: opts.target,
+    sourceAssetId: opts.sourceAssetId,
+    sourcePath: toProjectPath(projectRoot, opts.sourcePath),
+    resolveFrom: toProjectPath(projectRoot, opts.resolveFrom),
+    range: opts.range,
+    symbols:
+      opts.symbols &&
+      new Map(
+        [...opts.symbols].map(([k, v]) => [
+          k,
+          {
+            local: v.local,
+            meta: v.meta,
+            isWeak: v.isWeak,
+            loc: toInternalSourceLocation(projectRoot, v.loc),
+          },
+        ]),
+      ),
+    pipeline: opts.pipeline,
+  };
+
+  if (opts.packageConditions) {
+    convertConditions(opts.packageConditions, dep);
+  }
+
+  return dep;
+}
+
+export function mergeDependencies(a: Dependency, b: Dependency): void {
+  let {meta, symbols, needsStableName, isEntry, isOptional, ...other} = b;
+  Object.assign(a, other);
+  Object.assign(a.meta, meta);
+  if (a.symbols && symbols) {
+    for (let [k, v] of symbols) {
+      a.symbols.set(k, v);
+    }
+  }
+  if (needsStableName) a.needsStableName = true;
+  if (isEntry) a.isEntry = true;
+  if (!isOptional) a.isOptional = false;
+}
+
+function convertConditions(conditions: Array<string>, dep: Dependency) {
+  // Store common package conditions as bit flags to reduce size.
+  // Custom conditions are stored as strings.
+  let packageConditions = 0;
+  let customConditions = [];
+  for (let condition of conditions) {
+    if (ExportsCondition[condition]) {
+      packageConditions |= ExportsCondition[condition];
+    } else {
+      customConditions.push(condition);
+    }
+  }
+
+  if (packageConditions) {
+    dep.packageConditions = packageConditions;
+  }
+
+  if (customConditions.length) {
+    dep.customPackageConditions = customConditions;
+  }
+}

package/src/Environment.js

@@ -0,0 +1,151 @@
+// @flow
+import type {
+  EnvironmentOptions,
+  Environment as IEnvironment,
+  FilePath,
+} from '@atlaspack/types';
+import type {Environment, InternalSourceLocation} from './types';
+import {hashString} from '@atlaspack/rust';
+import {toInternalSourceLocation} from './utils';
+import PublicEnvironment from './public/Environment';
+import {environmentToInternalEnvironment} from './public/Environment';
+
+const DEFAULT_ENGINES = {
+  browsers: ['> 0.25%'],
+  node: '>= 8.0.0',
+};
+
+type EnvironmentOpts = {|
+  ...EnvironmentOptions,
+  loc?: ?InternalSourceLocation,
+|};
+
+export function createEnvironment({
+  context,
+  engines,
+  includeNodeModules,
+  outputFormat,
+  sourceType = 'module',
+  shouldOptimize = false,
+  isLibrary = false,
+  shouldScopeHoist = false,
+  sourceMap,
+  loc,
+}: EnvironmentOpts = {
+  /*::...null*/
+}): Environment {
+  if (context == null) {
+    if (engines?.node) {
+      context = 'node';
+    } else if (engines?.browsers) {
+      context = 'browser';
+    } else {
+      context = 'browser';
+    }
+  }
+
+  if (engines == null) {
+    switch (context) {
+      case 'node':
+      case 'electron-main':
+        engines = {
+          node: DEFAULT_ENGINES.node,
+        };
+        break;
+      case 'browser':
+      case 'web-worker':
+      case 'service-worker':
+      case 'electron-renderer':
+        engines = {
+          browsers: DEFAULT_ENGINES.browsers,
+        };
+        break;
+      default:
+        engines = {};
+    }
+  }
+
+  if (includeNodeModules == null) {
+    switch (context) {
+      case 'node':
+      case 'electron-main':
+      case 'electron-renderer':
+        includeNodeModules = false;
+        break;
+      case 'browser':
+      case 'web-worker':
+      case 'service-worker':
+      default:
+        includeNodeModules = true;
+        break;
+    }
+  }
+
+  if (outputFormat == null) {
+    switch (context) {
+      case 'node':
+      case 'electron-main':
+      case 'electron-renderer':
+        outputFormat = 'commonjs';
+        break;
+      default:
+        outputFormat = 'global';
+        break;
+    }
+  }
+
+  let res: Environment = {
+    id: '',
+    context,
+    engines,
+    includeNodeModules,
+    outputFormat,
+    sourceType,
+    isLibrary,
+    shouldOptimize,
+    shouldScopeHoist,
+    sourceMap,
+    loc,
+  };
+
+  res.id = getEnvironmentHash(res);
+  return res;
+}
+
+export function mergeEnvironments(
+  projectRoot: FilePath,
+  a: Environment,
+  b: ?(EnvironmentOptions | IEnvironment),
+): Environment {
+  // If merging the same object, avoid copying.
+  if (a === b || !b) {
+    return a;
+  }
+
+  if (b instanceof PublicEnvironment) {
+    return environmentToInternalEnvironment(b);
+  }
+
+  // $FlowFixMe - ignore the `id` that is already on a
+  return createEnvironment({
+    ...a,
+    ...b,
+    loc: b.loc ? toInternalSourceLocation(projectRoot, b.loc) : a.loc,
+  });
+}
+
+function getEnvironmentHash(env: Environment): string {
+  return hashString(
+    JSON.stringify([
+      env.context,
+      env.engines,
+      env.includeNodeModules,
+      env.outputFormat,
+      env.sourceType,
+      env.isLibrary,
+      env.shouldOptimize,
+      env.shouldScopeHoist,
+      env.sourceMap,
+    ]),
+  );
+}

package/src/InternalConfig.js

@@ -0,0 +1,72 @@
+// @flow strict-local
+
+import type {PackageName, ConfigResult} from '@atlaspack/types';
+import type {
+  Config,
+  Environment,
+  InternalFileCreateInvalidation,
+  InternalDevDepOptions,
+} from './types';
+import type {ProjectPath} from './projectPath';
+
+import {fromProjectPathRelative} from './projectPath';
+import {createEnvironment} from './Environment';
+import {hashString} from '@atlaspack/rust';
+
+type ConfigOpts = {|
+  plugin: PackageName,
+  searchPath: ProjectPath,
+  isSource?: boolean,
+  env?: Environment,
+  result?: ConfigResult,
+  invalidateOnFileChange?: Set<ProjectPath>,
+  invalidateOnConfigKeyChange?: Array<{|
+    filePath: ProjectPath,
+    configKey: string,
+  |}>,
+  invalidateOnFileCreate?: Array<InternalFileCreateInvalidation>,
+  invalidateOnEnvChange?: Set<string>,
+  invalidateOnOptionChange?: Set<string>,
+  devDeps?: Array<InternalDevDepOptions>,
+  invalidateOnStartup?: boolean,
+  invalidateOnBuild?: boolean,
+|};
+
+export function createConfig({
+  plugin,
+  isSource,
+  searchPath,
+  env,
+  result,
+  invalidateOnFileChange,
+  invalidateOnConfigKeyChange,
+  invalidateOnFileCreate,
+  invalidateOnEnvChange,
+  invalidateOnOptionChange,
+  devDeps,
+  invalidateOnStartup,
+  invalidateOnBuild,
+}: ConfigOpts): Config {
+  let environment = env ?? createEnvironment();
+  return {
+    id: hashString(
+      plugin +
+        fromProjectPathRelative(searchPath) +
+        environment.id +
+        String(isSource),
+    ),
+    isSource: isSource ?? false,
+    searchPath,
+    env: environment,
+    result: result ?? null,
+    cacheKey: null,
+    invalidateOnFileChange: invalidateOnFileChange ?? new Set(),
+    invalidateOnConfigKeyChange: invalidateOnConfigKeyChange ?? [],
+    invalidateOnFileCreate: invalidateOnFileCreate ?? [],
+    invalidateOnEnvChange: invalidateOnEnvChange ?? new Set(),
+    invalidateOnOptionChange: invalidateOnOptionChange ?? new Set(),
+    devDeps: devDeps ?? [],
+    invalidateOnStartup: invalidateOnStartup ?? false,
+    invalidateOnBuild: invalidateOnBuild ?? false,
+  };
+}