@atlaspack/core 2.12.1-canary.3354

package/src/resolveOptions.js

@@ -0,0 +1,278 @@
+// @flow strict-local
+
+import type {
+  FilePath,
+  InitialAtlaspackOptions,
+  DependencySpecifier,
+  InitialServerOptions,
+} from '@atlaspack/types';
+import type {FileSystem} from '@atlaspack/fs';
+import type {AtlaspackOptions} from './types';
+
+import path from 'path';
+import {hashString} from '@atlaspack/rust';
+import {NodeFS} from '@atlaspack/fs';
+import {LMDBCache, FSCache} from '@atlaspack/cache';
+import {NodePackageManager} from '@atlaspack/package-manager';
+import {
+  getRootDir,
+  relativePath,
+  resolveConfig,
+  isGlob,
+  globToRegex,
+} from '@atlaspack/utils';
+import loadDotEnv from './loadDotEnv';
+import {toProjectPath} from './projectPath';
+import {getResolveFrom} from './requests/AtlaspackConfigRequest';
+
+import {DEFAULT_FEATURE_FLAGS} from '@atlaspack/feature-flags';
+import {ATLASPACK_VERSION} from './constants';
+
+// Default cache directory name
+const DEFAULT_CACHE_DIRNAME = '.atlaspack-cache';
+const LOCK_FILE_NAMES = ['yarn.lock', 'package-lock.json', 'pnpm-lock.yaml'];
+
+// Generate a unique instanceId, will change on every run of atlaspack
+function generateInstanceId(entries: Array<FilePath>): string {
+  return hashString(
+    `${entries.join(',')}-${Date.now()}-${Math.round(Math.random() * 100)}`,
+  );
+}
+
+// Compiles an array of globs to regex - used for lazy include/excludes
+function compileGlobs(globs: string[]): RegExp[] {
+  return globs.map(glob => globToRegex(glob));
+}
+
+export default async function resolveOptions(
+  initialOptions: InitialAtlaspackOptions,
+): Promise<AtlaspackOptions> {
+  let inputFS = initialOptions.inputFS || new NodeFS();
+  let outputFS = initialOptions.outputFS || new NodeFS();
+
+  let inputCwd = inputFS.cwd();
+  let outputCwd = outputFS.cwd();
+
+  let entries: Array<FilePath>;
+  if (initialOptions.entries == null || initialOptions.entries === '') {
+    entries = [];
+  } else if (Array.isArray(initialOptions.entries)) {
+    entries = initialOptions.entries.map(entry =>
+      path.resolve(inputCwd, entry),
+    );
+  } else {
+    entries = [path.resolve(inputCwd, initialOptions.entries)];
+  }
+
+  let shouldMakeEntryReferFolder = false;
+  if (entries.length === 1 && !isGlob(entries[0])) {
+    let [entry] = entries;
+    try {
+      shouldMakeEntryReferFolder = (await inputFS.stat(entry)).isDirectory();
+    } catch {
+      // ignore failing stat call
+    }
+  }
+
+  // getRootDir treats the input as files, so getRootDir(["/home/user/myproject"]) returns "/home/user".
+  // Instead we need to make the the entry refer to some file inside the specified folders if entries refers to the directory.
+  let entryRoot = getRootDir(
+    shouldMakeEntryReferFolder ? [path.join(entries[0], 'index')] : entries,
+  );
+  let projectRootFile =
+    (await resolveConfig(
+      inputFS,
+      path.join(entryRoot, 'index'),
+      [...LOCK_FILE_NAMES, '.git', '.hg'],
+      path.parse(entryRoot).root,
+    )) || path.join(inputCwd, 'index'); // ? Should this just be rootDir
+
+  let projectRoot = path.dirname(projectRootFile);
+
+  let packageManager =
+    initialOptions.packageManager ||
+    new NodePackageManager(inputFS, projectRoot);
+
+  let cacheDir =
+    // If a cacheDir is provided, resolve it relative to cwd. Otherwise,
+    // use a default directory resolved relative to the project root.
+    initialOptions.cacheDir != null
+      ? path.resolve(outputCwd, initialOptions.cacheDir)
+      : path.resolve(projectRoot, DEFAULT_CACHE_DIRNAME);
+
+  // Make the root watch directory configurable. This is useful in some cases
+  // where symlinked dependencies outside the project root need to trigger HMR
+  // updates. Default to the project root if not provided.
+  let watchDir =
+    initialOptions.watchDir != null
+      ? path.resolve(initialOptions.watchDir)
+      : projectRoot;
+
+  let cache =
+    initialOptions.cache ??
+    (outputFS instanceof NodeFS
+      ? new LMDBCache(cacheDir)
+      : new FSCache(outputFS, cacheDir));
+
+  let mode = initialOptions.mode ?? 'development';
+  let shouldOptimize =
+    initialOptions?.defaultTargetOptions?.shouldOptimize ??
+    mode === 'production';
+
+  let publicUrl = initialOptions?.defaultTargetOptions?.publicUrl ?? '/';
+  let distDir =
+    initialOptions?.defaultTargetOptions?.distDir != null
+      ? path.resolve(inputCwd, initialOptions?.defaultTargetOptions?.distDir)
+      : undefined;
+
+  let shouldBuildLazily = initialOptions.shouldBuildLazily ?? false;
+  let lazyIncludes = compileGlobs(initialOptions.lazyIncludes ?? []);
+  if (lazyIncludes.length > 0 && !shouldBuildLazily) {
+    throw new Error(
+      'Lazy includes can only be provided when lazy building is enabled',
+    );
+  }
+  let lazyExcludes = compileGlobs(initialOptions.lazyExcludes ?? []);
+  if (lazyExcludes.length > 0 && !shouldBuildLazily) {
+    throw new Error(
+      'Lazy excludes can only be provided when lazy building is enabled',
+    );
+  }
+
+  let shouldContentHash =
+    initialOptions.shouldContentHash ?? initialOptions.mode === 'production';
+  if (shouldBuildLazily && shouldContentHash) {
+    throw new Error('Lazy bundling does not work with content hashing');
+  }
+
+  let env = {
+    ...(await loadDotEnv(
+      initialOptions.env ?? {},
+      inputFS,
+      path.join(projectRoot, 'index'),
+      projectRoot,
+    )),
+    ...process.env,
+    ...initialOptions.env,
+  };
+
+  let port = determinePort(initialOptions.serveOptions, env.PORT);
+
+  return {
+    config: getRelativeConfigSpecifier(
+      inputFS,
+      projectRoot,
+      initialOptions.config,
+    ),
+    defaultConfig: getRelativeConfigSpecifier(
+      inputFS,
+      projectRoot,
+      initialOptions.defaultConfig,
+    ),
+    shouldPatchConsole: initialOptions.shouldPatchConsole ?? false,
+    env,
+    mode,
+    shouldAutoInstall: initialOptions.shouldAutoInstall ?? false,
+    hmrOptions: initialOptions.hmrOptions ?? null,
+    shouldBuildLazily,
+    lazyIncludes,
+    lazyExcludes,
+    unstableFileInvalidations: initialOptions.unstableFileInvalidations,
+    shouldBundleIncrementally: initialOptions.shouldBundleIncrementally ?? true,
+    shouldContentHash,
+    serveOptions: initialOptions.serveOptions
+      ? {
+          ...initialOptions.serveOptions,
+          distDir: distDir ?? path.join(outputCwd, 'dist'),
+          port,
+        }
+      : false,
+    shouldDisableCache: initialOptions.shouldDisableCache ?? false,
+    shouldProfile: initialOptions.shouldProfile ?? false,
+    shouldTrace: initialOptions.shouldTrace ?? false,
+    cacheDir,
+    watchDir,
+    watchBackend: initialOptions.watchBackend,
+    watchIgnore: initialOptions.watchIgnore,
+    entries: entries.map(e => toProjectPath(projectRoot, e)),
+    targets: initialOptions.targets,
+    logLevel: initialOptions.logLevel ?? 'info',
+    projectRoot,
+    inputFS,
+    outputFS,
+    cache,
+    packageManager,
+    additionalReporters:
+      initialOptions.additionalReporters?.map(({packageName, resolveFrom}) => ({
+        packageName,
+        resolveFrom: toProjectPath(projectRoot, resolveFrom),
+      })) ?? [],
+    instanceId: generateInstanceId(entries),
+    detailedReport: initialOptions.detailedReport,
+    defaultTargetOptions: {
+      shouldOptimize,
+      shouldScopeHoist: initialOptions?.defaultTargetOptions?.shouldScopeHoist,
+      sourceMaps: initialOptions?.defaultTargetOptions?.sourceMaps ?? true,
+      publicUrl,
+      ...(distDir != null
+        ? {distDir: toProjectPath(projectRoot, distDir)}
+        : {
+            /*::...null*/
+          }),
+      engines: initialOptions?.defaultTargetOptions?.engines,
+      outputFormat: initialOptions?.defaultTargetOptions?.outputFormat,
+      isLibrary: initialOptions?.defaultTargetOptions?.isLibrary,
+    },
+    featureFlags: {...DEFAULT_FEATURE_FLAGS, ...initialOptions?.featureFlags},
+    atlaspackVersion: ATLASPACK_VERSION,
+  };
+}
+
+function getRelativeConfigSpecifier(
+  fs: FileSystem,
+  projectRoot: FilePath,
+  specifier: ?DependencySpecifier,
+) {
+  if (specifier == null) {
+    return undefined;
+  } else if (path.isAbsolute(specifier)) {
+    let resolveFrom = getResolveFrom(fs, projectRoot);
+    let relative = relativePath(path.dirname(resolveFrom), specifier);
+    // If the config is outside the project root, use an absolute path so that if the project root
+    // moves the path still works. Otherwise, use a relative path so that the cache is portable.
+    return relative.startsWith('..') ? specifier : relative;
+  } else {
+    return specifier;
+  }
+}
+
+function determinePort(
+  initialServerOptions: InitialServerOptions | false | void,
+  portInEnv: string | void,
+  defaultPort: number = 1234,
+): number {
+  function parsePort(port: string): number | void {
+    let parsedPort = Number(port);
+
+    // return undefined if port number defined in .env is not valid integer
+    if (!Number.isInteger(parsedPort)) {
+      return undefined;
+    }
+    return parsedPort;
+  }
+
+  if (!initialServerOptions) {
+    return typeof portInEnv !== 'undefined'
+      ? parsePort(portInEnv) ?? defaultPort
+      : defaultPort;
+  }
+
+  // if initialServerOptions.port is equal to defaultPort, then this means that port number is provided via PORT=~~~~ on cli. In this case, we should ignore port number defined in .env.
+  if (initialServerOptions.port !== defaultPort) {
+    return initialServerOptions.port;
+  }
+
+  return typeof portInEnv !== 'undefined'
+    ? parsePort(portInEnv) ?? defaultPort
+    : defaultPort;
+}

package/src/serializer.js

@@ -0,0 +1,255 @@
+// @flow
+import {createBuildCache} from './buildCache';
+import {serializeRaw, deserializeRaw} from './serializerCore';
+
+export {serializeRaw, deserializeRaw} from './serializerCore';
+
+const nameToCtor: Map<string, Class<any>> = new Map();
+const ctorToName: Map<Class<any>, string> = new Map();
+
+export function registerSerializableClass(name: string, ctor: Class<any>) {
+  if (ctorToName.has(ctor)) {
+    throw new Error('Class already registered with serializer');
+  }
+
+  nameToCtor.set(name, ctor);
+  ctorToName.set(ctor, name);
+}
+
+export function unregisterSerializableClass(name: string, ctor: Class<any>) {
+  if (nameToCtor.get(name) === ctor) {
+    nameToCtor.delete(name);
+  }
+
+  if (ctorToName.get(ctor) === name) {
+    ctorToName.delete(ctor);
+  }
+}
+
+function shallowCopy(object: any) {
+  if (object && typeof object === 'object') {
+    if (Array.isArray(object)) {
+      return [...object];
+    }
+
+    if (object instanceof Map) {
+      return new Map(object);
+    }
+
+    if (object instanceof Set) {
+      return new Set(object);
+    }
+
+    return Object.create(
+      Object.getPrototypeOf(object),
+      Object.getOwnPropertyDescriptors(object),
+    );
+  }
+
+  return object;
+}
+
+function isBuffer(object) {
+  return (
+    object.buffer instanceof ArrayBuffer ||
+    (typeof SharedArrayBuffer !== 'undefined' &&
+      object.buffer instanceof SharedArrayBuffer)
+  );
+}
+
+function shouldContinueMapping(value) {
+  return value && typeof value === 'object' && value.$$raw !== true;
+}
+
+function mapObject(object: any, fn: (val: any) => any, preOrder = false): any {
+  let cache = new Map();
+  let memo = new Map();
+
+  // Memoize the passed function to ensure it always returns the exact same
+  // output by reference for the same input. This is important to maintain
+  // reference integrity when deserializing rather than cloning.
+  let memoizedFn = (val: any) => {
+    let res = memo.get(val);
+    if (res == null) {
+      res = fn(val);
+      memo.set(val, res);
+    }
+
+    return res;
+  };
+
+  let walk = (object: any, shouldCopy = false) => {
+    // Check the cache first, both for performance and cycle detection.
+    if (cache.has(object)) {
+      return cache.get(object);
+    }
+
+    let result = object;
+    cache.set(object, result);
+
+    let processKey = (key: any, value: any) => {
+      let newValue = value;
+      if (preOrder && value && typeof value === 'object') {
+        newValue = memoizedFn(value);
+      }
+
+      // Recursively walk the children
+      if (
+        preOrder
+          ? shouldContinueMapping(newValue)
+          : newValue &&
+            typeof newValue === 'object' &&
+            shouldContinueMapping(object)
+      ) {
+        newValue = walk(newValue, newValue === value);
+      }
+
+      if (!preOrder && newValue && typeof newValue === 'object') {
+        newValue = memoizedFn(newValue);
+      }
+
+      if (newValue !== value) {
+        // Copy on write. We only need to do this when serializing, not deserializing.
+        if (object === result && preOrder && shouldCopy) {
+          result = shallowCopy(object);
+          cache.set(object, result);
+        }
+
+        // Replace the key with the new value
+        if (result instanceof Map) {
+          result.set(key, newValue);
+        } else if (result instanceof Set) {
+          let _result = result; // For Flow
+          // TODO: do we care about iteration order??
+          _result.delete(value);
+          _result.add(newValue);
+        } else {
+          result[key] = newValue;
+        }
+      }
+    };
+
+    // Iterate in various ways depending on type.
+    if (Array.isArray(object)) {
+      for (let i = 0; i < object.length; i++) {
+        processKey(i, object[i]);
+      }
+    } else if (object instanceof Map || object instanceof Set) {
+      for (let [key, val] of object.entries()) {
+        processKey(key, val);
+      }
+    } else if (!isBuffer(object)) {
+      for (let key in object) {
+        processKey(key, object[key]);
+      }
+    }
+
+    return result;
+  };
+
+  let mapped = memoizedFn(object);
+  if (
+    preOrder
+      ? shouldContinueMapping(mapped)
+      : mapped && typeof mapped === 'object' && shouldContinueMapping(object)
+  ) {
+    return walk(mapped, mapped === object);
+  }
+
+  return mapped;
+}
+
+export function prepareForSerialization(object: any): any {
+  if (object?.$$raw) {
+    return object;
+  }
+
+  return mapObject(
+    object,
+    value => {
+      // Add a $$type property with the name of this class, if any is registered.
+      if (
+        value &&
+        typeof value === 'object' &&
+        typeof value.constructor === 'function'
+      ) {
+        let type = ctorToName.get(value.constructor);
+        if (type != null) {
+          let serialized = value;
+          let raw = false;
+          if (value && typeof value.serialize === 'function') {
+            // If the object has a serialize method, call it
+            serialized = value.serialize();
+            raw = (serialized && serialized.$$raw) ?? true;
+            if (serialized) {
+              delete serialized.$$raw;
+            }
+          }
+
+          return {
+            $$type: type,
+            $$raw: raw,
+            value: {...serialized},
+          };
+        }
+      }
+
+      return value;
+    },
+    true,
+  );
+}
+
+export function restoreDeserializedObject(object: any): any {
+  return mapObject(object, value => {
+    // If the value has a $$type property, use it to restore the object type
+    if (value && value.$$type) {
+      let ctor = nameToCtor.get(value.$$type);
+      if (ctor == null) {
+        throw new Error(
+          `Expected constructor ${value.$$type} to be registered with serializer to deserialize`,
+        );
+      }
+
+      if (typeof ctor.deserialize === 'function') {
+        return ctor.deserialize(value.value);
+      }
+
+      value = value.value;
+      Object.setPrototypeOf(value, ctor.prototype);
+    }
+
+    return value;
+  });
+}
+
+const serializeCache = createBuildCache();
+
+export function serialize(object: any): Buffer {
+  let cached = serializeCache.get(object);
+  if (cached) {
+    return cached;
+  }
+
+  let mapped = prepareForSerialization(object);
+  return serializeRaw(mapped);
+}
+
+export function deserialize(buffer: Buffer): any {
+  let obj = deserializeRaw(buffer);
+  return restoreDeserializedObject(obj);
+}
+
+export function cacheSerializedObject(object: any, buffer?: Buffer): void {
+  serializeCache.set(object, buffer || serialize(object));
+}
+
+export function deserializeToCache(buffer: Buffer): any {
+  let deserialized = deserialize(buffer);
+  serializeCache.set(deserialized, buffer);
+  return deserialized;
+}
+
+export function removeSerializedObjectFromCache(object: any) {
+  serializeCache.delete(object);
+}

package/src/serializerCore.browser.js

@@ -0,0 +1,8 @@
+// @flow
+import {Buffer} from 'buffer';
+import * as msgpackr from 'msgpackr';
+
+let encoder = new msgpackr.Encoder({structuredClone: true});
+
+export let serializeRaw: any => Buffer = v => Buffer.from(encoder.encode(v));
+export let deserializeRaw: Buffer => any = v => encoder.decode(v);

package/src/serializerCore.js

@@ -0,0 +1,5 @@
+// @flow
+import v8 from 'v8';
+
+export let serializeRaw: any => Buffer = v8.serialize;
+export let deserializeRaw: Buffer => any = v8.deserialize;

package/src/summarizeRequest.js

@@ -0,0 +1,47 @@
+// @flow strict-local
+import type {Blob, FilePath} from '@atlaspack/types';
+import type {FileSystem} from '@atlaspack/fs';
+
+import path from 'path';
+
+const NODE_MODULES = `${path.sep}node_modules${path.sep}`;
+
+const BUFFER_LIMIT = 5000000; // 5mb
+
+export default async function summarizeRequest(
+  fs: FileSystem,
+  req: {|filePath: FilePath, code?: string|},
+): Promise<{|content: Blob, size: number, isSource: boolean|}> {
+  let {content, size} = await summarizeDiskRequest(fs, req);
+  let isSource = isFilePathSource(fs, req.filePath);
+  return {content, size, isSource};
+}
+
+function isFilePathSource(fs: FileSystem, filePath: FilePath) {
+  return !filePath.includes(NODE_MODULES);
+}
+
+async function summarizeDiskRequest(
+  fs: FileSystem,
+  req: {|filePath: FilePath, code?: string|},
+): Promise<{|content: Blob, size: number|}> {
+  let code = req.code;
+  let content: Blob;
+  let size: number;
+  if (code == null) {
+    // Get the filesize. If greater than BUFFER_LIMIT, use a stream to
+    // compute the hash. In the common case, it's faster to just read the entire
+    // file first and do the hash all at once without the overhead of streams.
+    size = (await fs.stat(req.filePath)).size;
+    if (size > BUFFER_LIMIT) {
+      content = fs.createReadStream(req.filePath);
+    } else {
+      content = await fs.readFile(req.filePath);
+    }
+  } else {
+    content = code;
+    size = Buffer.byteLength(code);
+  }
+
+  return {content, size};
+}