@atlaspack/core 2.16.2-canary.27 → 2.16.2-canary.270

package/lib/requests/WriteBundlesRequest.js

@@ -12,6 +12,8 @@ function _featureFlags() {
   return data;
 }
 var _RequestTracker = require("../RequestTracker");
+var _types = require("../types");
+var _ReporterRunner = require("../ReporterRunner");
 var _constants = require("../constants");
 var _projectPath = require("../projectPath");
 function _nullthrows() {
@@ -30,7 +32,26 @@ function _rust() {
 }
 var _PackageRequest = require("./PackageRequest");
 var _WriteBundleRequest = _interopRequireDefault(require("./WriteBundleRequest"));
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function reportPackagingProgress(completeBundles, totalBundles) {
+  if (!(0, _featureFlags().getFeatureFlag)('cliProgressReportingImprovements')) {
+    return;
+  }
+  (0, _ReporterRunner.report)({
+    type: 'buildProgress',
+    phase: 'packagingAndOptimizing',
+    totalBundles,
+    completeBundles
+  });
+}
+
 /**
  * Packages, optimizes, and writes all bundles to the dist directory.
  */
@@ -67,7 +88,7 @@ async function run({
   const allBundles = bundleGraph.getBundles({
     includeInline: (0, _featureFlags().getFeatureFlag)('inlineBundlesSourceMapFixes')
   });
-  const bundles = allBundles.filter(bundle => bundle.bundleBehavior !== 'inline').filter(bundle => {
+  const bundles = allBundles.filter(bundle => bundle.bundleBehavior !== _types.BundleBehavior.inline && bundle.bundleBehavior !== _types.BundleBehavior.inlineIsolated).filter(bundle => {
     // Do not package and write placeholder bundles to disk. We just
     // need to update the name so other bundles can reference it.
     if (bundle.isPlaceholder) {
@@ -76,6 +97,7 @@ async function run({
       let name = (0, _nullthrows().default)(bundle.name, `Expected ${bundle.type} bundle to have a name`).replace(bundle.hashReference, hash);
       res.set(bundle.id, {
         filePath: (0, _projectPath.joinProjectPath)(bundle.target.distDir, name),
+        bundleId: bundle.id,
         type: bundle.type,
         // FIXME: this is wrong if the packager changes the type...
         stats: {
@@ -87,11 +109,14 @@ async function run({
     }
     return true;
   });
+  let cachedBundles = new Set(bundles.filter(b => api.canSkipSubrequest(bundleGraph.getHash(b))));
 
   // Package on the main thread if there is only one bundle to package.
   // This avoids the cost of serializing the bundle graph for single file change builds.
-  let useMainThread = bundles.length === 1 || bundles.filter(b => !api.canSkipSubrequest(bundleGraph.getHash(b))).length === 1;
+  let useMainThread = bundles.length === 1 || bundles.length - cachedBundles.size <= 1;
   try {
+    let completeBundles = cachedBundles.size;
+    reportPackagingProgress(completeBundles, bundles.length);
     await Promise.all(bundles.map(async bundle => {
       let request = (0, _PackageRequest.createPackageRequest)({
         bundle,
@@ -101,6 +126,10 @@ async function run({
         useMainThread
       });
       let info = await api.runRequest(request);
+      if (!cachedBundles.has(bundle)) {
+        completeBundles++;
+        reportPackagingProgress(completeBundles, bundles.length);
+      }
       if (!useMainThread) {
         // Force a refresh of the cache to avoid a race condition
         // between threaded reads and writes that can result in an LMDB cache miss:
@@ -137,8 +166,26 @@ async function run({
       }));
       return promise.then(r => res.set(bundle.id, r));
     }));
-    api.storeResult(res);
-    return res;
+    let result = {
+      bundleInfo: res
+    };
+    if (_utils().debugTools['scope-hoisting-stats']) {
+      // Aggregate scope hoisting stats from all bundles
+      let aggregatedScopeHoistingStats = {
+        totalAssets: 0,
+        wrappedAssets: 0
+      };
+      for (let bundle of bundles) {
+        let bundleInfo = bundleInfoMap[bundle.id];
+        if (bundleInfo !== null && bundleInfo !== void 0 && bundleInfo.scopeHoistingStats) {
+          aggregatedScopeHoistingStats.totalAssets += bundleInfo.scopeHoistingStats.totalAssets;
+          aggregatedScopeHoistingStats.wrappedAssets += bundleInfo.scopeHoistingStats.wrappedAssets;
+        }
+      }
+      result.scopeHoistingStats = aggregatedScopeHoistingStats;
+    }
+    api.storeResult(result);
+    return result;
   } finally {
     await dispose();
   }

package/lib/requests/asset-graph-diff.js

@@ -14,11 +14,11 @@ function _jestDiff() {
   };
   return data;
 }
-var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
 var _projectPath = require("../projectPath");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-/* eslint-disable no-console */ // $FlowFixMe
-// $FlowFixMe
+/* eslint-disable no-console */
+// @ts-expect-error missing types
+
 function filterNode(node) {
   let clone = (0, _default().default)(node);
 
@@ -43,6 +43,8 @@ function filterNode(node) {
   delete clone.value.dependencies;
   return clone;
 }
+
+// @ts-expect-error missing return type
 function compactDeep(obj, ignoredPatterns = [], currentPath = '$') {
   if (obj instanceof Map) {
     const copy = {};
@@ -53,6 +55,7 @@ function compactDeep(obj, ignoredPatterns = [], currentPath = '$') {
     });
     return copy;
   } else if (Array.isArray(obj)) {
+    // @ts-expect-error implicit any
     return obj.map(v => compactDeep(v, ignoredPatterns, `${currentPath}[]`));
   } else if (typeof obj === 'object') {
     const copy = {};
@@ -74,17 +77,19 @@ function compactDeep(obj, ignoredPatterns = [], currentPath = '$') {
     return obj;
   }
 }
-function assetGraphDiff(jsAssetGraph, rustAssetGraph) {
+function assetGraphDiff(jsAssetGraph, rustAssetGraph, projectRoot) {
   const getNodes = graph => {
     let nodes = {};
+
+    // @ts-expect-error implicit any
     graph.traverse(nodeId => {
       let node = graph.getNode(nodeId) ?? null;
       if (!node) return;
       if (node.type === 'dependency') {
-        let sourcePath = node.value.sourcePath ?? (0, _projectPath.toProjectPath)('', 'entry');
-        nodes[`dep:${(0, _projectPath.fromProjectPathRelative)(sourcePath)}:${node.value.specifier}`] = filterNode(node);
+        let sourcePath = node.value.sourcePath ? (0, _projectPath.toProjectPath)(projectRoot, node.value.sourcePath) : (0, _projectPath.toProjectPath)(projectRoot, 'entry');
+        nodes[`dep:${sourcePath}:${node.value.specifier}`] = filterNode(node);
       } else if (node.type === 'asset') {
-        nodes[`asset:${(0, _projectPath.fromProjectPathRelative)(node.value.filePath)}`] = filterNode(node);
+        nodes[`asset:${(0, _projectPath.toProjectPath)(projectRoot, node.value.filePath)}`] = filterNode(node);
       }
     });
     return nodes;

package/lib/requests/asset-graph-dot.js

@@ -13,7 +13,6 @@ function _path() {
   };
   return data;
 }
-var _AssetGraph = _interopRequireDefault(require("../AssetGraph"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 /** @description Renders AssetGraph into GraphViz Dot format */
 function assetGraphToDot(assetGraph, {
@@ -41,8 +40,6 @@ function assetGraphToDot(assetGraph, {
       edges.push(entry);
     }
   });
-
-  // $FlowFixMe
   const nodeStylesList = Object.entries(nodeStyles);
   if (sort) {
     edges.sort();
@@ -83,18 +80,15 @@ function fromCwd(input) {
 }
 function getNodeName(node) {
   if (node.type === 'asset_group') {
-    // $FlowFixMe
+    // @ts-expect-error TS2345
     return [`asset_group`, node.id, fromCwd(node.value.filePath)].join('\\n');
   } else if (node.type === 'asset') {
-    // $FlowFixMe
     return [`asset`, node.id, fromCwd(node.value.filePath)].join('\\n');
   } else if (node.type === 'dependency') {
     return [`dependency`, node.id, node.value.specifier].join('\\n');
   } else if (node.type === 'entry_specifier') {
-    // $FlowFixMe
     return [`entry_specifier`, node.value].join('\\n');
   } else if (node.type === 'entry_file') {
-    // $FlowFixMe
     return [`entry_file`, fromCwd(node.value.filePath)].join('\\n');
   }
   return 'ROOT';

package/lib/resolveOptions.js

@@ -106,6 +106,21 @@ async function resolveOptions(initialOptions) {
   } else {
     entries = [_path().default.resolve(inputCwd, initialOptions.entries)];
   }
+
+  // When allowExplicitTargetEntries is enabled and no entries are provided,
+  // automatically derive entries from target sources
+  if ((0, _featureFlags().getFeatureFlag)('allowExplicitTargetEntries') && initialOptions.targets && !Array.isArray(initialOptions.targets) && entries.length === 0) {
+    const targetSources = new Set();
+    for (const [, target] of Object.entries(initialOptions.targets)) {
+      if (target.source) {
+        const sources = Array.isArray(target.source) ? target.source : [target.source];
+        for (const source of sources) {
+          targetSources.add(source);
+        }
+      }
+    }
+    entries = Array.from(targetSources);
+  }
   let shouldMakeEntryReferFolder = false;
   if (entries.length === 1 && !(0, _utils().isGlob)(entries[0])) {
     let [entry] = entries;
@@ -115,13 +130,21 @@ async function resolveOptions(initialOptions) {
       // ignore failing stat call
     }
   }
+  let projectRoot;
+  if (initialOptions.projectRoot) {
+    // Use explicitly provided projectRoot
+    if (!_path().default.isAbsolute(initialOptions.projectRoot)) {
+      throw new Error('Specified project root must be an absolute path');
+    }
+    projectRoot = initialOptions.projectRoot;
+  } else {
+    // 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 = (0, _utils().getRootDir)(shouldMakeEntryReferFolder ? [_path().default.join(entries[0], 'index')] : entries);
+    let projectRootFile = (await (0, _utils().resolveConfig)(inputFS, _path().default.join(entryRoot, 'index'), [...LOCK_FILE_NAMES, '.git', '.hg'], _path().default.parse(entryRoot).root)) || _path().default.join(inputCwd, 'index'); // ? Should this just be rootDir
 
-  // 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 = (0, _utils().getRootDir)(shouldMakeEntryReferFolder ? [_path().default.join(entries[0], 'index')] : entries);
-  let projectRootFile = (await (0, _utils().resolveConfig)(inputFS, _path().default.join(entryRoot, 'index'), [...LOCK_FILE_NAMES, '.git', '.hg'], _path().default.parse(entryRoot).root)) || _path().default.join(inputCwd, 'index'); // ? Should this just be rootDir
-
-  let projectRoot = _path().default.dirname(projectRootFile);
+    projectRoot = _path().default.dirname(projectRootFile);
+  }
   const gitRoot = await findGitRepositoryRoot(inputFS, projectRoot);
   if (inputFS instanceof _fs().NodeVCSAwareFS) {
     inputFS.setGitRepoPath(gitRoot);
@@ -139,16 +162,19 @@ async function resolveOptions(initialOptions) {
   // 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().default.resolve(initialOptions.watchDir) : projectRoot;
-  let cache = function createCache() {
+  function createCache() {
     if (initialOptions.cache) {
       return initialOptions.cache;
     }
     const needsRustLmdbCache = (0, _featureFlags().getFeatureFlag)('atlaspackV3');
-    if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
-      return new (_cache().FSCache)(outputFS, cacheDir);
+    if (!(0, _featureFlags().getFeatureFlag)('cachePerformanceImprovements')) {
+      if (!needsRustLmdbCache && !(outputFS instanceof _fs().NodeFS)) {
+        return new (_cache().FSCache)(outputFS, cacheDir);
+      }
     }
     return new (_cache().LMDBLiteCache)(cacheDir);
-  }();
+  }
+  let cache = createCache();
   let mode = initialOptions.mode ?? 'development';
   let shouldOptimize = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau = initialOptions.defaultTargetOptions) === null || _initialOptions$defau === void 0 ? void 0 : _initialOptions$defau.shouldOptimize) ?? mode === 'production';
   let publicUrl = (initialOptions === null || initialOptions === void 0 || (_initialOptions$defau2 = initialOptions.defaultTargetOptions) === null || _initialOptions$defau2 === void 0 ? void 0 : _initialOptions$defau2.publicUrl) ?? '/';

package/lib/rustWorkerThreadDylibHack.js

@@ -14,7 +14,6 @@ exports.loadRustWorkerThreadDylibHack = loadRustWorkerThreadDylibHack;
  */
 function loadRustWorkerThreadDylibHack() {
   try {
-    // $FlowFixMe
     require('@parcel/rust'); // eslint-disable-line
   } catch (err) {
     /* ignore */

package/lib/types/AssetGraph.d.ts

@@ -0,0 +1,80 @@
+import type { GraphVisitor } from '@atlaspack/types';
+import type { ContentGraphOpts, ContentKey, NodeId, SerializedContentGraph } from '@atlaspack/graph';
+import type { Asset, AssetGraphNode, AssetGroup, AssetGroupNode, AssetNode, Dependency, DependencyNode, Entry, EntryFileNode, EntrySpecifierNode, Environment, Target } from './types';
+import { ContentGraph } from '@atlaspack/graph';
+import { ProjectPath } from './projectPath';
+type InitOpts = {
+    entries?: Array<ProjectPath>;
+    targets?: Array<Target>;
+    assetGroups?: Array<AssetGroup>;
+};
+type AssetGraphOpts = ContentGraphOpts<AssetGraphNode> & {
+    bundlingVersion?: number;
+    disableIncrementalBundling?: boolean;
+    hash?: string | null | undefined;
+};
+type SerializedAssetGraph = SerializedContentGraph<AssetGraphNode> & {
+    bundlingVersion: number;
+    disableIncrementalBundling: boolean;
+    hash?: string | null | undefined;
+};
+export declare function nodeFromDep(dep: Dependency): DependencyNode;
+export declare function nodeFromAssetGroup(assetGroup: AssetGroup): AssetGroupNode;
+export declare function nodeFromAsset(asset: Asset): AssetNode;
+export declare function nodeFromEntrySpecifier(entry: ProjectPath): EntrySpecifierNode;
+export declare function nodeFromEntryFile(entry: Entry): EntryFileNode;
+export default class AssetGraph extends ContentGraph<AssetGraphNode> {
+    #private;
+    onNodeRemoved: ((nodeId: NodeId) => unknown) | null | undefined;
+    hash: string | null | undefined;
+    envCache: Map<string, Environment>;
+    /**
+     * @deprecated
+     */
+    safeToIncrementallyBundle: boolean;
+    undeferredDependencies: Set<Dependency>;
+    constructor(opts?: AssetGraphOpts | null);
+    static deserialize(opts: AssetGraphOpts): AssetGraph;
+    serialize(): SerializedAssetGraph;
+    /**
+     * Force incremental bundling to be disabled.
+     */
+    setDisableIncrementalBundling(disable: boolean): void;
+    testing_getDisableIncrementalBundling(): boolean;
+    /**
+     * Make sure this asset graph is marked as needing a full bundling pass.
+     */
+    setNeedsBundling(): void;
+    /**
+     * Get the current bundling version.
+     *
+     * Each bundle pass should keep this version around. Whenever an asset graph has a new version,
+     * bundling should be re-run.
+     */
+    getBundlingVersion(): number;
+    /**
+     * If the `bundlingVersion` has not changed since the last bundling pass,
+     * we can incrementally bundle, which will not require a full bundling pass
+     * but just update assets into the bundle graph output.
+     */
+    canIncrementallyBundle(lastVersion: number): boolean;
+    normalizeEnvironment(input: Asset | Dependency | AssetGroup): void;
+    setRootConnections({ entries, assetGroups }: InitOpts): void;
+    addNode(node: AssetGraphNode): NodeId;
+    removeNode(nodeId: NodeId): void;
+    resolveEntry(entry: ProjectPath, resolved: Array<Entry>, correspondingRequest: ContentKey): void;
+    resolveTargets(entry: Entry, targets: Array<Target>, correspondingRequest: string): void;
+    resolveDependency(dependency: Dependency, assetGroup: AssetGroup | null | undefined, correspondingRequest: string): void;
+    shouldVisitChild(nodeId: NodeId, childNodeId: NodeId): boolean;
+    markParentsWithHasDeferred(nodeId: NodeId): void;
+    unmarkParentsWithHasDeferred(nodeId: NodeId): void;
+    shouldDeferDependency(dependency: Dependency, sideEffects: boolean | null | undefined, canDefer: boolean): boolean;
+    resolveAssetGroup(assetGroup: AssetGroup, assets: Array<Asset>, correspondingRequest: ContentKey): void;
+    resolveAsset(assetNode: AssetNode, dependentAssets: Array<Asset>): void;
+    getIncomingDependencies(asset: Asset): Array<Dependency>;
+    traverseAssets<TContext>(visit: GraphVisitor<Asset, TContext>, startNodeId?: NodeId | null): TContext | null | undefined;
+    getEntryAssetGroupNodes(): Array<AssetGroupNode>;
+    getEntryAssets(): Array<Asset>;
+    getHash(): string;
+}
+export {};

package/lib/types/Atlaspack.d.ts

@@ -0,0 +1,52 @@
+import type { Asset, AsyncSubscription, BuildEvent, BuildSuccessEvent, InitialAtlaspackOptions, AtlaspackTransformOptions, AtlaspackResolveOptions, AtlaspackResolveResult } from '@atlaspack/types';
+import type { AtlaspackOptions } from './types';
+import type { FarmOptions } from '@atlaspack/workers';
+import type { Diagnostic } from '@atlaspack/diagnostic';
+import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import WorkerFarm from '@atlaspack/workers';
+import { AtlaspackV3 } from './atlaspack-v3';
+import type { AssetGraphRequestResult } from './requests/AssetGraphRequest';
+export declare const INTERNAL_TRANSFORM: symbol;
+export declare const INTERNAL_RESOLVE: symbol;
+export declare let WORKER_PATH: string;
+export default class Atlaspack {
+    #private;
+    rustAtlaspack: AtlaspackV3 | null | undefined;
+    isProfiling: boolean;
+    constructor(options: InitialAtlaspackOptions);
+    _init(): Promise<void>;
+    run(): Promise<BuildSuccessEvent>;
+    _end(): Promise<void>;
+    writeRequestTrackerToCache(): Promise<void>;
+    _startNextBuild(): Promise<BuildEvent | null | undefined>;
+    watch(cb?: (err?: Error | null | undefined, buildEvent?: BuildEvent) => unknown): Promise<AsyncSubscription>;
+    _build({ signal, startTime, }?: {
+        signal?: AbortSignal;
+        startTime?: number;
+    }): Promise<BuildEvent>;
+    _getWatcherSubscription(): Promise<AsyncSubscription>;
+    _getResolvedAtlaspackOptions(): AtlaspackOptions;
+    startProfiling(): Promise<void>;
+    stopProfiling(): Promise<void>;
+    takeHeapSnapshot(): Promise<void>;
+    /**
+     * Must be called between builds otherwise there is global state that will
+     * break things unexpectedly.
+     */
+    clearBuildCaches(): Promise<void>;
+    unstable_invalidate(): Promise<void>;
+    /**
+     * Build the asset graph
+     */
+    unstable_buildAssetGraph(writeToCache?: boolean): Promise<AssetGraphRequestResult>;
+    /**
+     * Copy the cache to a new directory and compact it.
+     */
+    unstable_compactCache(): Promise<void>;
+    unstable_transform(options: AtlaspackTransformOptions): Promise<Array<Asset>>;
+    unstable_resolve(request: AtlaspackResolveOptions): Promise<AtlaspackResolveResult | null | undefined>;
+}
+export declare class BuildError extends ThrowableDiagnostic {
+    constructor(diagnostic: Array<Diagnostic> | Diagnostic);
+}
+export declare function createWorkerFarm(options?: Partial<FarmOptions>): WorkerFarm;

package/lib/types/AtlaspackConfig.d.ts

@@ -0,0 +1,65 @@
+import type { Glob, Transformer, Resolver, Bundler, Namer, Runtime, PackageName, Optimizer, Compressor, Packager, Reporter, Semver, Validator, FilePath } from '@atlaspack/types';
+import type { ProcessedAtlaspackConfig, AtlaspackPluginNode, PureAtlaspackConfigPipeline, ExtendableAtlaspackConfigPipeline, AtlaspackOptions } from './types';
+import ThrowableDiagnostic from '@atlaspack/diagnostic';
+import { ProjectPath } from './projectPath';
+type GlobMap<T> = Partial<Record<Glob, T>>;
+type SerializedAtlaspackConfig = {
+    $$raw: boolean;
+    config: ProcessedAtlaspackConfig;
+    options: AtlaspackOptions;
+};
+export type LoadedPlugin<T> = {
+    name: string;
+    version: Semver;
+    plugin: T;
+    resolveFrom: ProjectPath;
+    keyPath?: string;
+};
+export declare class AtlaspackConfig {
+    options: AtlaspackOptions;
+    filePath: ProjectPath;
+    resolvers: PureAtlaspackConfigPipeline;
+    transformers: GlobMap<ExtendableAtlaspackConfigPipeline>;
+    bundler: AtlaspackPluginNode | null | undefined;
+    namers: PureAtlaspackConfigPipeline;
+    runtimes: PureAtlaspackConfigPipeline;
+    packagers: GlobMap<AtlaspackPluginNode>;
+    validators: GlobMap<ExtendableAtlaspackConfigPipeline>;
+    optimizers: GlobMap<ExtendableAtlaspackConfigPipeline>;
+    compressors: GlobMap<ExtendableAtlaspackConfigPipeline>;
+    reporters: PureAtlaspackConfigPipeline;
+    pluginCache: Map<PackageName, any>;
+    regexCache: Map<string, RegExp>;
+    constructor(config: ProcessedAtlaspackConfig, options: AtlaspackOptions);
+    static deserialize(serialized: SerializedAtlaspackConfig): AtlaspackConfig;
+    getConfig(): ProcessedAtlaspackConfig;
+    serialize(): SerializedAtlaspackConfig;
+    _loadPlugin<T>(node: AtlaspackPluginNode): Promise<{
+        plugin: T;
+        version: Semver;
+        resolveFrom: ProjectPath;
+    }>;
+    loadPlugin<T>(node: AtlaspackPluginNode): Promise<LoadedPlugin<T>>;
+    invalidatePlugin(packageName: PackageName): void;
+    loadPlugins<T>(plugins: PureAtlaspackConfigPipeline): Promise<Array<LoadedPlugin<T>>>;
+    getResolvers(): Promise<Array<LoadedPlugin<Resolver<unknown>>>>;
+    _getValidatorNodes(filePath: ProjectPath): ReadonlyArray<AtlaspackPluginNode>;
+    getValidatorNames(filePath: ProjectPath): Array<string>;
+    getValidators(filePath: ProjectPath): Promise<Array<LoadedPlugin<Validator>>>;
+    getNamedPipelines(): ReadonlyArray<string>;
+    getTransformers(filePath: ProjectPath, pipeline?: string | null, allowEmpty?: boolean): Promise<Array<LoadedPlugin<Transformer<unknown>>>>;
+    getBundler(): Promise<LoadedPlugin<Bundler<unknown>>>;
+    getNamers(): Promise<Array<LoadedPlugin<Namer<unknown>>>>;
+    getRuntimes(): Promise<Array<LoadedPlugin<Runtime<unknown>>>>;
+    getPackager(filePath: FilePath): Promise<LoadedPlugin<Packager<unknown, unknown>>>;
+    _getOptimizerNodes(filePath: FilePath, pipeline?: string | null): PureAtlaspackConfigPipeline;
+    getOptimizerNames(filePath: FilePath, pipeline?: string | null): Array<string>;
+    getOptimizers(filePath: FilePath, pipeline?: string | null): Promise<Array<LoadedPlugin<Optimizer<unknown, unknown>>>>;
+    getCompressors(filePath: FilePath): Promise<Array<LoadedPlugin<Compressor>>>;
+    getReporters(): Promise<Array<LoadedPlugin<Reporter>>>;
+    isGlobMatch(projectPath: ProjectPath, pattern: Glob, pipeline?: string | null): boolean;
+    matchGlobMap<T>(filePath: ProjectPath, globMap: Partial<Record<Glob, T>>): T | null | undefined;
+    matchGlobMapPipelines(filePath: ProjectPath, globMap: Partial<Record<Glob, ExtendableAtlaspackConfigPipeline>>, pipeline?: string | null): PureAtlaspackConfigPipeline;
+    missingPluginError(plugins: GlobMap<ExtendableAtlaspackConfigPipeline> | GlobMap<AtlaspackPluginNode> | PureAtlaspackConfigPipeline, message: string, key: string): Promise<ThrowableDiagnostic>;
+}
+export {};

package/lib/types/AtlaspackConfig.schema.d.ts

@@ -0,0 +1,46 @@
+import type { PackageName } from '@atlaspack/types';
+import type { SchemaEntity } from '@atlaspack/utils';
+export declare function validatePackageName(pkg: PackageName | null | undefined, pluginType: string, key: string): void;
+declare const _default: {
+    type: string;
+    properties: {
+        $schema: {
+            type: string;
+        };
+        extends: {
+            oneOf: ({
+                type: string;
+                __validate: (val: string) => void;
+                items?: undefined;
+            } | {
+                type: string;
+                items: {
+                    type: string;
+                    __validate: (val: string) => void;
+                };
+                __validate?: undefined;
+            })[];
+        };
+        bundler: {
+            type: string;
+            __validate: (arg1: string) => void;
+        };
+        resolvers: SchemaEntity;
+        transformers: SchemaEntity;
+        validators: SchemaEntity;
+        namers: SchemaEntity;
+        packagers: SchemaEntity;
+        optimizers: SchemaEntity;
+        compressors: SchemaEntity;
+        reporters: SchemaEntity;
+        runtimes: SchemaEntity;
+        filePath: {
+            type: string;
+        };
+        resolveFrom: {
+            type: string;
+        };
+    };
+    additionalProperties: boolean;
+};
+export default _default;