@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/src/atlaspack-v3/AtlaspackV3.js

@@ -1,87 +0,0 @@
-// @flow
-
-import {
-  atlaspackNapiCreate,
-  atlaspackNapiBuildAssetGraph,
-  atlaspackNapiRespondToFsEvents,
-  type AtlaspackNapi,
-  type Lmdb,
-  type AtlaspackNapiOptions,
-} from '@atlaspack/rust';
-import {NapiWorkerPool} from './NapiWorkerPool';
-import ThrowableDiagnostic from '@atlaspack/diagnostic';
-import type {Event} from '@parcel/watcher';
-import type {NapiWorkerPool as INapiWorkerPool} from '@atlaspack/types';
-
-export type AtlaspackV3Options = {|
-  fs?: AtlaspackNapiOptions['fs'],
-  packageManager?: AtlaspackNapiOptions['packageManager'],
-  threads?: number,
-  /**
-   * A reference to LMDB lite's rust object
-   */
-  lmdb: Lmdb,
-  featureFlags?: {[string]: string | boolean},
-  napiWorkerPool?: INapiWorkerPool,
-  ...AtlaspackNapiOptions['options'],
-|};
-
-export class AtlaspackV3 {
-  _atlaspack_napi: AtlaspackNapi;
-
-  constructor(atlaspack_napi: AtlaspackNapi) {
-    this._atlaspack_napi = atlaspack_napi;
-  }
-
-  static async create({
-    fs,
-    packageManager,
-    threads,
-    lmdb,
-    napiWorkerPool = new NapiWorkerPool(),
-    ...options
-  }: AtlaspackV3Options): Promise<AtlaspackV3> {
-    options.logLevel = options.logLevel || 'error';
-    options.defaultTargetOptions = options.defaultTargetOptions || {};
-    // $FlowFixMe "engines" are readonly
-    options.defaultTargetOptions.engines =
-      options.defaultTargetOptions.engines || {};
-
-    const [internal, error] = await atlaspackNapiCreate(
-      {
-        fs,
-        packageManager,
-        threads,
-        options,
-        napiWorkerPool,
-      },
-      lmdb,
-    );
-
-    if (error !== null) {
-      throw new ThrowableDiagnostic({
-        diagnostic: error,
-      });
-    }
-
-    return new AtlaspackV3(internal);
-  }
-
-  async buildAssetGraph(): Promise<any> {
-    let [graph, error] = await atlaspackNapiBuildAssetGraph(
-      this._atlaspack_napi,
-    );
-
-    if (error !== null) {
-      throw new ThrowableDiagnostic({
-        diagnostic: error,
-      });
-    }
-
-    return graph;
-  }
-
-  respondToFsEvents(events: Array<Event>): boolean {
-    return atlaspackNapiRespondToFsEvents(this._atlaspack_napi, events);
-  }
-}

package/src/atlaspack-v3/NapiWorkerPool.js

@@ -1,53 +0,0 @@
-// @flow
-import type {NapiWorkerPool as INapiWorkerPool} from '@atlaspack/types';
-import {Worker} from 'worker_threads';
-import path from 'path';
-import process from 'process';
-import type {Transferable} from '@atlaspack/rust';
-import {getAvailableThreads} from '@atlaspack/rust';
-
-const WORKER_PATH = path.join(__dirname, 'worker', 'index.js');
-const ATLASPACK_NAPI_WORKERS =
-  process.env.ATLASPACK_NAPI_WORKERS &&
-  parseInt(process.env.ATLASPACK_NAPI_WORKERS, 10);
-
-export type NapiWorkerPoolOptions = {|
-  workerCount?: number,
-|};
-
-export class NapiWorkerPool implements INapiWorkerPool {
-  #workers: Worker[];
-  #napiWorkers: Array<Promise<Transferable>>;
-  #workerCount: number;
-
-  constructor({workerCount}: NapiWorkerPoolOptions = {workerCount: undefined}) {
-    this.#workerCount =
-      workerCount ?? ATLASPACK_NAPI_WORKERS ?? getAvailableThreads();
-    if (!this.#workerCount) {
-      // TODO use main thread if workerCount is 0
-    }
-
-    this.#workers = [];
-    this.#napiWorkers = [];
-
-    for (let i = 0; i < this.#workerCount; i++) {
-      let worker = new Worker(WORKER_PATH);
-      this.#workers.push(worker);
-      this.#napiWorkers.push(new Promise((res) => worker.once('message', res)));
-    }
-  }
-
-  workerCount(): number {
-    return this.#workerCount;
-  }
-
-  getWorkers(): Promise<Array<Transferable>> {
-    return Promise.all(this.#napiWorkers);
-  }
-
-  shutdown(): void {
-    for (const worker of this.#workers) {
-      worker.terminate();
-    }
-  }
-}

package/src/atlaspack-v3/jsCallable.js

@@ -1,18 +0,0 @@
-// @flow strict-local
-
-export function jsCallable<Args: $ReadOnlyArray<mixed>, Return>(
-  fn: (...Args) => Return | Promise<Return>,
-): (...Args) => Promise<Return> {
-  return async (...args: Args): Promise<Return> => {
-    try {
-      // $FlowFixMe "await" is needed to log the error from
-      // Promises and is safe to use on non-promises
-      return await fn(...args);
-      // $FlowFixMe
-    } catch (error) {
-      // eslint-disable-next-line no-console
-      console.error(error);
-      throw error;
-    }
-  };
-}

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

@@ -1,100 +0,0 @@
-// @flow
-
-import type {
-  BundleBehavior,
-  DependencyPriority,
-  SpecifierType,
-} from '@atlaspack/types';
-
-/// BitFlags is used to map number/string types from napi types
-export class BitFlags<K, V> {
-  #kv: {[key: K]: V};
-  #vk: {[key: V]: K};
-
-  constructor(source: {[key: K]: V}) {
-    this.#kv = source;
-    this.#vk = Object.fromEntries(
-      // $FlowFixMe
-      Object.entries(source).map((a) => a.reverse()),
-    );
-  }
-
-  into(key: K): V {
-    const found = this.#kv[key];
-    if (found === undefined) {
-      // $FlowFixMe
-      throw new Error(`Invalid BundleBehavior(${key})`);
-    }
-    return found;
-  }
-
-  intoNullable(key: ?K): ?V {
-    if (key === undefined || key === null) {
-      return undefined;
-    }
-    return this.into(key);
-  }
-
-  intoArray(keys: K[]): V[] {
-    return keys.map((key) => this.into(key));
-  }
-
-  from(key: V): K {
-    const found = this.#vk[key];
-    if (found === undefined) {
-      // $FlowFixMe
-      throw new Error(`Invalid BundleBehavior(${key})`);
-    }
-    return found;
-  }
-
-  fromNullable(key: ?V): ?K {
-    if (key === undefined || key === null) {
-      return undefined;
-    }
-    return this.from(key);
-  }
-
-  fromArray(keys: V[]): K[] {
-    return keys.map((key) => this.from(key));
-  }
-}
-
-export const bundleBehaviorMap: BitFlags<BundleBehavior, number> = new BitFlags(
-  {
-    inline: 0,
-    isolated: 1,
-  },
-);
-
-export const dependencyPriorityMap: BitFlags<DependencyPriority, number> =
-  new BitFlags({
-    sync: 0,
-    parallel: 1,
-    lazy: 2,
-    conditional: 3,
-  });
-
-export const packageConditionsMap: BitFlags<string, number> = new BitFlags({
-  import: 0,
-  require: 1,
-  module: 2,
-  node: 3,
-  browser: 4,
-  worker: 5,
-  worklet: 6,
-  electron: 7,
-  development: 8,
-  production: 9,
-  types: 10,
-  default: 11,
-  style: 12,
-  sass: 13,
-});
-
-export const specifierTypeMap: BitFlags<SpecifierType, number> = new BitFlags({
-  esm: 0,
-  commonjs: 1,
-  url: 2,
-  custom: 3,
-});

package/src/atlaspack-v3/worker/compat/plugin-logger.js

@@ -1,47 +0,0 @@
-// @flow
-
-import type {PluginLogger as IPlguinLogger} from '@atlaspack/types';
-import type {
-  Diagnostifiable,
-  DiagnosticWithoutOrigin,
-} from '@atlaspack/diagnostic';
-
-export class PluginLogger implements IPlguinLogger {
-  verbose(
-    diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>,
-  ): void {
-    // eslint-disable-next-line no-console
-    console.log(diagnostic);
-  }
-
-  info(
-    diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>,
-  ): void {
-    // eslint-disable-next-line no-console
-    console.info(diagnostic);
-  }
-
-  log(
-    diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>,
-  ): void {
-    // eslint-disable-next-line no-console
-    console.log(diagnostic);
-  }
-
-  warn(
-    diagnostic: DiagnosticWithoutOrigin | Array<DiagnosticWithoutOrigin>,
-  ): void {
-    // eslint-disable-next-line no-console
-    console.warn(diagnostic);
-  }
-
-  error(
-    input:
-      | Diagnostifiable
-      | DiagnosticWithoutOrigin
-      | Array<DiagnosticWithoutOrigin>,
-  ): void {
-    // eslint-disable-next-line no-console
-    console.error(input);
-  }
-}

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

@@ -1,369 +0,0 @@
-// @flow
-import assert from 'assert';
-import * as napi from '@atlaspack/rust';
-import type {JsCallable} from '@atlaspack/rust';
-import {NodeFS} from '@atlaspack/fs';
-import {NodePackageManager} from '@atlaspack/package-manager';
-import type {
-  Resolver,
-  Transformer,
-  FilePath,
-  FileSystem,
-} from '@atlaspack/types';
-import {parentPort} from 'worker_threads';
-import * as module from 'module';
-
-import {jsCallable} from '../jsCallable';
-import {
-  Environment,
-  Dependency,
-  PluginConfig,
-  PluginLogger,
-  PluginTracer,
-  PluginOptions,
-  MutableAsset,
-  bundleBehaviorMap,
-  dependencyPriorityMap,
-} from './compat';
-
-const CONFIG = Symbol.for('parcel-plugin-config');
-
-export class AtlaspackWorker {
-  #resolvers: Map<string, ResolverState<any>>;
-  #transformers: Map<string, TransformerState<any>>;
-  #fs: FileSystem;
-
-  constructor() {
-    this.#resolvers = new Map();
-    this.#transformers = new Map();
-    this.#fs = new NodeFS();
-  }
-
-  loadPlugin: JsCallable<[LoadPluginOptions], Promise<void>> = jsCallable(
-    async ({kind, specifier, resolveFrom}) => {
-      let customRequire = module.createRequire(resolveFrom);
-      let resolvedPath = customRequire.resolve(specifier);
-      // $FlowFixMe
-      let resolvedModule = await import(resolvedPath);
-
-      let instance = undefined;
-      if (resolvedModule.default && resolvedModule.default[CONFIG]) {
-        instance = resolvedModule.default[CONFIG];
-      } else if (
-        resolvedModule.default &&
-        resolvedModule.default.default &&
-        resolvedModule.default.default[CONFIG]
-      ) {
-        instance = resolvedModule.default.default[CONFIG];
-      } else {
-        throw new Error(
-          `Plugin could not be resolved\n\t${kind}\n\t${resolveFrom}\n\t${specifier}`,
-        );
-      }
-
-      switch (kind) {
-        case 'resolver':
-          this.#resolvers.set(specifier, {resolver: instance});
-          break;
-        case 'transformer':
-          this.#transformers.set(specifier, {transformer: instance});
-          break;
-      }
-    },
-  );
-
-  runResolverResolve: JsCallable<
-    [RunResolverResolveOptions],
-    Promise<RunResolverResolveResult>,
-  > = jsCallable(
-    async ({
-      key,
-      dependency: napiDependency,
-      specifier,
-      pipeline,
-      pluginOptions,
-    }) => {
-      const state = this.#resolvers.get(key);
-      if (!state) {
-        throw new Error(`Resolver not found: ${key}`);
-      }
-
-      let packageManager = state.packageManager;
-      if (!packageManager) {
-        packageManager = new NodePackageManager(
-          this.#fs,
-          pluginOptions.projectRoot,
-        );
-        state.packageManager = packageManager;
-      }
-
-      const env = new Environment(napiDependency.env);
-      const dependency = new Dependency(napiDependency, env);
-
-      const defaultOptions = {
-        logger: new PluginLogger(),
-        tracer: new PluginTracer(),
-        options: new PluginOptions({
-          ...pluginOptions,
-          packageManager,
-          shouldAutoInstall: false,
-          inputFS: this.#fs,
-          outputFS: this.#fs,
-        }),
-      };
-
-      if (!('config' in state)) {
-        state.config = await state.resolver.loadConfig?.({
-          config: new PluginConfig({
-            env,
-            isSource: true,
-            searchPath: specifier,
-            projectRoot: pluginOptions.projectRoot,
-            fs: this.#fs,
-            packageManager,
-          }),
-          ...defaultOptions,
-        });
-      }
-
-      const result = await state.resolver.resolve({
-        specifier,
-        dependency,
-        pipeline,
-        config: state.config,
-        ...defaultOptions,
-      });
-
-      if (!result) {
-        return {
-          invalidations: [],
-          resolution: {type: 'unresolved'},
-        };
-      }
-
-      if (result.isExcluded) {
-        return {
-          invalidations: [],
-          resolution: {type: 'excluded'},
-        };
-      }
-
-      return {
-        invalidations: [],
-        resolution: {
-          type: 'resolved',
-          filePath: result.filePath || '',
-          canDefer: result.canDefer || false,
-          sideEffects: result.sideEffects || false,
-          code: result.code || undefined,
-          meta: result.meta || undefined,
-          pipeline: result.pipeline || undefined,
-          priority: dependencyPriorityMap.intoNullable(result.priority),
-          query: result.query && result.query.toString(),
-        },
-      };
-    },
-  );
-
-  runTransformerTransform: JsCallable<
-    [RunTransformerTransformOptions, Buffer, ?string],
-    Promise<RunTransformerTransformResult>,
-  > = jsCallable(
-    async ({key, env: napiEnv, options, asset: innerAsset}, contents, map) => {
-      const state = this.#transformers.get(key);
-      if (!state) {
-        throw new Error(`Transformer not found: ${key}`);
-      }
-
-      let packageManager = state.packageManager;
-      if (!packageManager) {
-        packageManager = new NodePackageManager(this.#fs, options.projectRoot);
-        state.packageManager = packageManager;
-      }
-
-      const transformer: Transformer<any> = state.transformer;
-      const resolveFunc = (from: string, to: string): Promise<any> => {
-        let customRequire = module.createRequire(from);
-        let resolvedPath = customRequire.resolve(to);
-
-        return Promise.resolve(resolvedPath);
-      };
-
-      const env = new Environment(napiEnv);
-      const mutableAsset = new MutableAsset(
-        innerAsset,
-        contents,
-        env,
-        this.#fs,
-        map,
-        options.projectRoot,
-      );
-
-      const defaultOptions = {
-        logger: new PluginLogger(),
-        tracer: new PluginTracer(),
-        options: new PluginOptions({
-          ...options,
-          packageManager,
-          shouldAutoInstall: false,
-          inputFS: this.#fs,
-          outputFS: this.#fs,
-        }),
-      };
-
-      const config = await transformer.loadConfig?.({
-        config: new PluginConfig({
-          env,
-          isSource: true,
-          searchPath: innerAsset.filePath,
-          projectRoot: options.projectRoot,
-          fs: this.#fs,
-          packageManager,
-        }),
-        ...defaultOptions,
-      });
-
-      if (transformer.parse) {
-        const ast = await transformer.parse({
-          asset: mutableAsset,
-          config,
-          resolve: resolveFunc,
-          ...defaultOptions,
-        });
-        if (ast) {
-          mutableAsset.setAST(ast);
-        }
-      }
-
-      const result = await state.transformer.transform({
-        asset: mutableAsset,
-        config,
-        resolve: resolveFunc,
-        ...defaultOptions,
-      });
-
-      if (transformer.generate) {
-        const ast = await mutableAsset.getAST();
-        if (ast) {
-          // $FlowFixMe "Cannot call `transformer.generate` because  undefined [1] is not a function." 🤷‍♀️
-          const output = await transformer.generate({
-            asset: mutableAsset,
-            ast,
-            ...defaultOptions,
-          });
-
-          if (typeof output.content === 'string') {
-            mutableAsset.setCode(output.content);
-          } else if (output.content instanceof Buffer) {
-            mutableAsset.setBuffer(output.content);
-          } else {
-            mutableAsset.setStream(output.content);
-          }
-
-          if (output.map) {
-            mutableAsset.setMap(output.map);
-          }
-        }
-      }
-
-      assert(
-        result.length === 1,
-        '[V3] Unimplemented: Multiple asset return from Node transformer',
-      );
-
-      assert(
-        result[0] === mutableAsset,
-        '[V3] Unimplemented: New asset returned from Node transformer',
-      );
-
-      return [
-        {
-          id: mutableAsset.id,
-          bundleBehavior: bundleBehaviorMap.intoNullable(
-            mutableAsset.bundleBehavior,
-          ),
-          code: [],
-          filePath: mutableAsset.filePath,
-          isBundleSplittable: mutableAsset.isBundleSplittable,
-          isSource: mutableAsset.isSource,
-          meta: mutableAsset.meta,
-          pipeline: mutableAsset.pipeline,
-          // Query should be undefined if it's empty
-          query: mutableAsset.query.toString() || undefined,
-          sideEffects: mutableAsset.sideEffects,
-          symbols: mutableAsset.symbols.intoNapi(),
-          type: mutableAsset.type,
-          uniqueKey: mutableAsset.uniqueKey,
-        },
-        await mutableAsset.getBuffer(),
-        // Only send back the map if it has changed
-        mutableAsset.isMapDirty
-          ? // $FlowFixMe A dirty map means this will be valid
-            JSON.stringify((await mutableAsset.getMap()).toVLQ())
-          : '',
-      ];
-    },
-  );
-}
-
-// Create napi worker and send it back to main thread
-const worker = new AtlaspackWorker();
-const napiWorker = napi.newNodejsWorker(worker);
-parentPort?.postMessage(napiWorker);
-
-type ResolverState<T> = {|
-  resolver: Resolver<T>,
-  config?: T,
-  packageManager?: NodePackageManager,
-|};
-
-type TransformerState<T> = {|
-  packageManager?: NodePackageManager,
-  transformer: Transformer<T>,
-|};
-
-type LoadPluginOptions = {|
-  kind: 'resolver' | 'transformer',
-  specifier: string,
-  resolveFrom: string,
-|};
-
-type RpcPluginOptions = {|
-  projectRoot: string,
-  mode: string,
-|};
-
-type RunResolverResolveOptions = {|
-  key: string,
-  dependency: napi.Dependency,
-  specifier: FilePath,
-  pipeline: ?string,
-  pluginOptions: RpcPluginOptions,
-|};
-
-type RunResolverResolveResult = {|
-  invalidations: Array<*>,
-  resolution:
-    | {|type: 'unresolved'|}
-    | {|type: 'excluded'|}
-    | {|
-        type: 'resolved',
-        canDefer: boolean,
-        filePath: string,
-        sideEffects: boolean,
-        code?: string,
-        meta?: mixed,
-        pipeline?: string,
-        priority?: ?number,
-        query?: string,
-      |},
-|};
-
-type RunTransformerTransformOptions = {|
-  key: string,
-  env: napi.Environment,
-  options: RpcPluginOptions,
-  asset: napi.Asset,
-|};
-
-type RunTransformerTransformResult = [napi.RpcAssetResult, Buffer, string];

package/src/index.js

@@ -1,13 +0,0 @@
-// @flow
-
-export {
-  default,
-  default as Atlaspack,
-  default as Parcel,
-  BuildError,
-  createWorkerFarm,
-  INTERNAL_RESOLVE,
-  INTERNAL_TRANSFORM,
-} from './Atlaspack';
-
-export * from './atlaspack-v3';