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

package/lib/types/public/Config.d.ts

@@ -0,0 +1,75 @@
+import type { Config as IConfig, ConfigResult, FileCreateInvalidation, FilePath, PackageJSON, ConfigResultWithFilePath, DevDepOptions } from '@atlaspack/types';
+import type { Config, AtlaspackOptions } from '../types';
+import Environment from './Environment';
+/**
+ * Implements read tracking over an object.
+ *
+ * Calling this function with a non-trivial object like a class instance will fail to work.
+ *
+ * We track reads to fields that resolve to:
+ *
+ * - primitive values
+ * - arrays
+ *
+ * That is, reading a nested field `a.b.c` will make a single call to `onRead` with the path
+ * `['a', 'b', 'c']`.
+ *
+ * In case the value is null or an array, we will track the read as well.
+ *
+ * Iterating over `Object.keys(obj.field)` will register a read for the `['field']` path.
+ * Other reads work normally.
+ *
+ * @example
+ *
+ *     const usedPaths = new Set();
+ *     const onRead = (path) => {
+ *        usedPaths.add(path);
+ *     };
+ *
+ *     const config = makeConfigProxy(onRead, {a: {b: {c: 'd'}}})
+ *     console.log(config.a.b.c);
+ *     console.log(Array.from(usedPaths));
+ *     // We get a single read for the path
+ *     // ['a', 'b', 'c']
+ *
+ */
+export declare function makeConfigProxy<T>(onRead: (path: string[]) => void, config: T): T;
+export default class PublicConfig implements IConfig {
+    #private;
+    constructor(config: Config, options: AtlaspackOptions);
+    get env(): Environment;
+    get searchPath(): FilePath;
+    get result(): ConfigResult;
+    get isSource(): boolean;
+    setResult(result: any): void;
+    setCacheKey(cacheKey: string): void;
+    invalidateOnFileChange(filePath: FilePath): void;
+    invalidateOnConfigKeyChange(filePath: FilePath, configKey: string[]): void;
+    addDevDependency(devDep: DevDepOptions): void;
+    invalidateOnFileCreate(invalidation: FileCreateInvalidation): void;
+    invalidateOnEnvChange(env: string): void;
+    invalidateOnStartup(): void;
+    invalidateOnBuild(): void;
+    getConfigFrom<T>(searchPath: FilePath, fileNames: Array<string>, options: {
+        /**
+         * @deprecated Use `configKey` instead.
+         */
+        packageKey?: string;
+        parse?: boolean;
+        exclude?: boolean;
+    } | null | undefined | {
+        /**
+         * If specified, this function will return a proxy object that will track reads to
+         * config fields and only register invalidations for when those keys change.
+         */
+        readTracking?: boolean;
+    } | null | undefined): Promise<ConfigResultWithFilePath<T> | null | undefined>;
+    getConfig<T>(filePaths: Array<FilePath>, options: {
+        packageKey?: string;
+        parse?: boolean;
+        exclude?: boolean;
+    } | null | undefined | {
+        readTracking?: boolean;
+    }): Promise<ConfigResultWithFilePath<T> | null | undefined>;
+    getPackage(): Promise<PackageJSON | null | undefined>;
+}

package/lib/types/public/Dependency.d.ts

@@ -0,0 +1,32 @@
+import type { Dependency as IDependency, Environment as IEnvironment, FilePath, Meta, MutableDependencySymbols as IMutableDependencySymbols, SourceLocation, SpecifierType, DependencyPriority, BundleBehavior } from '@atlaspack/types';
+import type { Dependency as InternalDependency, AtlaspackOptions } from '../types';
+import Target from './Target';
+declare const inspect: unique symbol;
+export declare function dependencyToInternalDependency(dependency: IDependency): InternalDependency;
+export declare function getPublicDependency(dep: InternalDependency, options: AtlaspackOptions): Dependency;
+export default class Dependency implements IDependency {
+    #private;
+    constructor(dep: InternalDependency, options: AtlaspackOptions);
+    [inspect](): string;
+    get id(): string;
+    get specifier(): string;
+    get specifierType(): SpecifierType;
+    get priority(): DependencyPriority;
+    get needsStableName(): boolean;
+    get bundleBehavior(): BundleBehavior | null | undefined;
+    get isEntry(): boolean;
+    get isOptional(): boolean;
+    get loc(): SourceLocation | null | undefined;
+    get env(): IEnvironment;
+    get packageConditions(): Array<string> | null | undefined;
+    get meta(): Meta;
+    get symbols(): IMutableDependencySymbols;
+    get target(): Target | null | undefined;
+    get sourceAssetId(): string | null | undefined;
+    get sourcePath(): FilePath | null | undefined;
+    get sourceAssetType(): string | null | undefined;
+    get resolveFrom(): string | null | undefined;
+    get range(): string | null | undefined;
+    get pipeline(): string | null | undefined;
+}
+export {};

package/lib/types/public/Environment.d.ts

@@ -0,0 +1,34 @@
+import type { Environment as IEnvironment, EnvironmentContext, EnvironmentFeature, Engines, OutputFormat, PackageName, VersionMap, SourceLocation, SourceType, TargetSourceMapOptions, EnvMap } from '@atlaspack/types';
+import type { Environment as InternalEnvironment, AtlaspackOptions } from '../types';
+declare const inspect: unique symbol;
+export declare const BROWSER_ENVS: Set<string>;
+export declare const ISOLATED_ENVS: Set<string>;
+export declare function environmentToInternalEnvironment(environment: IEnvironment): InternalEnvironment;
+export default class Environment implements IEnvironment {
+    #private;
+    constructor(env: InternalEnvironment, options: AtlaspackOptions);
+    get id(): string;
+    get context(): EnvironmentContext;
+    get engines(): Engines;
+    get includeNodeModules(): boolean | Array<PackageName> | Partial<Record<PackageName, boolean>>;
+    get outputFormat(): OutputFormat;
+    get sourceType(): SourceType;
+    get isLibrary(): boolean;
+    get shouldOptimize(): boolean;
+    get shouldScopeHoist(): boolean;
+    get sourceMap(): TargetSourceMapOptions | null | undefined;
+    get loc(): SourceLocation | null | undefined;
+    get unstableSingleFileOutput(): boolean;
+    get customEnv(): EnvMap | null | undefined;
+    [inspect](): string;
+    isBrowser(): boolean;
+    isNode(): boolean;
+    isElectron(): boolean;
+    isIsolated(): boolean;
+    isWorker(): boolean;
+    isWorklet(): boolean;
+    isTesseract(): boolean;
+    matchesEngines(minVersions: VersionMap, defaultValue?: boolean): boolean;
+    supports(feature: EnvironmentFeature, defaultValue?: boolean): boolean;
+}
+export {};

package/lib/types/public/MutableBundleGraph.d.ts

@@ -0,0 +1,26 @@
+import type { Asset as IAsset, Bundle as IBundle, BundleGroup as IBundleGroup, CreateBundleOpts, Dependency as IDependency, MutableBundleGraph as IMutableBundleGraph, Target } from '@atlaspack/types';
+import type { AtlaspackOptions } from '../types';
+import BundleGraph from './BundleGraph';
+import InternalBundleGraph from '../BundleGraph';
+import { Bundle } from './Bundle';
+export default class MutableBundleGraph extends BundleGraph<IBundle> implements IMutableBundleGraph {
+    #private;
+    constructor(graph: InternalBundleGraph, options: AtlaspackOptions);
+    addAssetToBundle(asset: IAsset, bundle: IBundle): void;
+    addAssetGraphToBundle(asset: IAsset, bundle: IBundle, shouldSkipDependency?: (arg1: IDependency) => boolean): void;
+    addEntryToBundle(asset: IAsset, bundle: IBundle, shouldSkipDependency?: (arg1: IDependency) => boolean): void;
+    createBundleGroup(dependency: IDependency, target: Target): IBundleGroup;
+    removeBundleGroup(bundleGroup: IBundleGroup): void;
+    internalizeAsyncDependency(bundle: IBundle, dependency: IDependency): void;
+    createBundle(opts: CreateBundleOpts): Bundle;
+    addBundleToBundleGroup(bundle: IBundle, bundleGroup: IBundleGroup): void;
+    createAssetReference(dependency: IDependency, asset: IAsset, bundle: IBundle): void;
+    createBundleReference(from: IBundle, to: IBundle): void;
+    createBundleConditionalReference(from: IBundle, to: IBundle): void;
+    getDependencyAssets(dependency: IDependency): Array<IAsset>;
+    getBundleGroupsContainingBundle(bundle: IBundle): Array<IBundleGroup>;
+    getParentBundlesOfBundleGroup(bundleGroup: IBundleGroup): Array<IBundle>;
+    getTotalSize(asset: IAsset): number;
+    isAssetReachableFromBundle(asset: IAsset, bundle: IBundle): boolean;
+    removeAssetGraphFromBundle(asset: IAsset, bundle: IBundle): void;
+}

package/lib/types/public/PluginOptions.d.ts

@@ -0,0 +1,25 @@
+import type { BuildMode, EnvMap, FilePath, LogLevel, PluginOptions as IPluginOptions, ServerOptions, HMROptions, DetailedReportOptions } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+import type { PackageManager } from '@atlaspack/package-manager';
+import type { AtlaspackOptions } from '../types';
+import { FeatureFlags } from '@atlaspack/feature-flags';
+export default class PluginOptions implements IPluginOptions {
+    #private;
+    constructor(options: AtlaspackOptions);
+    get instanceId(): string;
+    get mode(): BuildMode;
+    get env(): EnvMap;
+    get parcelVersion(): string;
+    get hmrOptions(): HMROptions | null | undefined;
+    get serveOptions(): ServerOptions | false;
+    get shouldBuildLazily(): boolean;
+    get shouldAutoInstall(): boolean;
+    get logLevel(): LogLevel;
+    get cacheDir(): FilePath;
+    get projectRoot(): FilePath;
+    get inputFS(): FileSystem;
+    get outputFS(): FileSystem;
+    get packageManager(): PackageManager;
+    get detailedReport(): DetailedReportOptions | null | undefined;
+    get featureFlags(): FeatureFlags;
+}

package/lib/types/public/Symbols.d.ts

@@ -0,0 +1,81 @@
+import type { Symbol as ISymbol, MutableAssetSymbols as IMutableAssetSymbols, AssetSymbols as IAssetSymbols, MutableDependencySymbols as IMutableDependencySymbols, SourceLocation, Meta } from '@atlaspack/types';
+import type { Asset, Dependency, AtlaspackOptions } from '../types';
+declare const inspect: unique symbol;
+export declare class AssetSymbols implements IAssetSymbols {
+    #private;
+    constructor(options: AtlaspackOptions, asset: Asset);
+    hasExportSymbol(exportSymbol: ISymbol): boolean;
+    hasLocalSymbol(local: ISymbol): boolean;
+    get(exportSymbol: ISymbol): {
+        local: ISymbol;
+        loc: SourceLocation | null | undefined;
+        meta?: Meta | null | undefined;
+    } | null | undefined;
+    get isCleared(): boolean;
+    exportSymbols(): Iterable<ISymbol>;
+    [Symbol.iterator](): {
+        readonly next: () => {
+            done: boolean;
+        };
+    } | MapIterator<[string, {
+        local: ISymbol;
+        loc: import("../types").InternalSourceLocation | null | undefined;
+        meta?: Meta | null | undefined;
+    }]>;
+    [inspect](): string;
+}
+export declare class MutableAssetSymbols implements IMutableAssetSymbols {
+    #private;
+    constructor(options: AtlaspackOptions, asset: Asset);
+    hasExportSymbol(exportSymbol: ISymbol): boolean;
+    hasLocalSymbol(local: ISymbol): boolean;
+    get(exportSymbol: ISymbol): {
+        local: ISymbol;
+        loc: SourceLocation | null | undefined;
+        meta?: Meta | null | undefined;
+    } | null | undefined;
+    get isCleared(): boolean;
+    exportSymbols(): Iterable<ISymbol>;
+    [Symbol.iterator](): {
+        readonly next: () => {
+            done: boolean;
+        };
+    } | MapIterator<[string, {
+        local: ISymbol;
+        loc: import("../types").InternalSourceLocation | null | undefined;
+        meta?: Meta | null | undefined;
+    }]>;
+    [inspect](): string;
+    ensure(): void;
+    set(exportSymbol: ISymbol, local: ISymbol, loc?: SourceLocation | null, meta?: Meta | null): void;
+    delete(exportSymbol: ISymbol): void;
+}
+export declare class MutableDependencySymbols implements IMutableDependencySymbols {
+    #private;
+    constructor(options: AtlaspackOptions, dep: Dependency);
+    hasExportSymbol(exportSymbol: ISymbol): boolean;
+    hasLocalSymbol(local: ISymbol): boolean;
+    get(exportSymbol: ISymbol): {
+        local: ISymbol;
+        loc: SourceLocation | null | undefined;
+        isWeak: boolean;
+        meta?: Meta | null | undefined;
+    } | null | undefined;
+    get isCleared(): boolean;
+    exportSymbols(): Iterable<ISymbol>;
+    [Symbol.iterator](): MapIterator<[string, {
+        local: ISymbol;
+        loc: import("../types").InternalSourceLocation | null | undefined;
+        isWeak: boolean;
+        meta?: Meta | null | undefined;
+    }]> | {
+        readonly next: () => {
+            done: boolean;
+        };
+    };
+    [inspect](): string;
+    ensure(): void;
+    set(exportSymbol: ISymbol, local: ISymbol, loc?: SourceLocation | null, isWeak?: boolean | null): void;
+    delete(exportSymbol: ISymbol): void;
+}
+export {};

package/lib/types/public/Target.d.ts

@@ -0,0 +1,16 @@
+import type { FilePath, Target as ITarget, Environment as IEnvironment, SourceLocation } from '@atlaspack/types';
+import type { Target as TargetValue, AtlaspackOptions } from '../types';
+declare const inspect: unique symbol;
+export declare function targetToInternalTarget(target: ITarget): TargetValue;
+export default class Target implements ITarget {
+    #private;
+    constructor(target: TargetValue, options: AtlaspackOptions);
+    get distEntry(): FilePath | null | undefined;
+    get distDir(): FilePath;
+    get env(): IEnvironment;
+    get name(): string;
+    get publicUrl(): string;
+    get loc(): SourceLocation | null | undefined;
+    [inspect](): string;
+}
+export {};

package/lib/types/registerCoreWithSerializer.d.ts

@@ -0,0 +1,2 @@
+export type Class<T> = new (...args: any[]) => T;
+export declare function registerCoreWithSerializer(): void;

package/lib/types/requests/AssetGraphRequest.d.ts

@@ -0,0 +1,74 @@
+import type { NodeId } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { Asset, AssetGroup, Dependency, Entry, AtlaspackOptions } from '../types';
+import type { StaticRunOpts, RunAPI } from '../RequestTracker';
+import type { Diagnostic } from '@atlaspack/diagnostic';
+import { PromiseQueue } from '@atlaspack/utils';
+import AssetGraph from '../AssetGraph';
+import { ProjectPath } from '../projectPath';
+import { requestTypes } from '../RequestTracker';
+export type AssetGraphRequestInput = {
+    entries?: Array<ProjectPath>;
+    assetGroups?: Array<AssetGroup>;
+    optionsRef: SharedReference;
+    name: string;
+    shouldBuildLazily?: boolean;
+    lazyIncludes?: RegExp[];
+    lazyExcludes?: RegExp[];
+    requestedAssetIds?: Set<string>;
+};
+export type AssetGraphRequestResult = {
+    assetGraph: AssetGraph;
+    /** Assets added/modified since the last successful build. */
+    changedAssets: Map<string, Asset>;
+    /** Assets added/modified since the last symbol propagation invocation. */
+    changedAssetsPropagation: Set<string>;
+    assetGroupsWithRemovedParents: Set<NodeId> | null | undefined;
+    previousSymbolPropagationErrors: Map<NodeId, Array<Diagnostic>> | null | undefined;
+    assetRequests: Array<AssetGroup>;
+};
+type RunInput = {
+    input: AssetGraphRequestInput;
+} & StaticRunOpts<AssetGraphRequestResult>;
+type AssetGraphRequest = {
+    id: string;
+    readonly type: typeof requestTypes.asset_graph_request;
+    run: (arg1: RunInput) => Async<AssetGraphRequestResult>;
+    input: AssetGraphRequestInput;
+};
+export default function createAssetGraphRequest(requestInput: AssetGraphRequestInput): AssetGraphRequest;
+export declare class AssetGraphBuilder {
+    assetGraph: AssetGraph;
+    assetRequests: Array<AssetGroup>;
+    queue: PromiseQueue<unknown>;
+    changedAssets: Map<string, Asset>;
+    changedAssetsPropagation: Set<string>;
+    prevChangedAssetsPropagation: Set<string> | null | undefined;
+    optionsRef: SharedReference;
+    options: AtlaspackOptions;
+    api: RunAPI<AssetGraphRequestResult>;
+    name: string;
+    cacheKey: string;
+    shouldBuildLazily: boolean;
+    lazyIncludes: RegExp[];
+    lazyExcludes: RegExp[];
+    requestedAssetIds: Set<string>;
+    isSingleChangeRebuild: boolean;
+    assetGroupsWithRemovedParents: Set<NodeId>;
+    previousSymbolPropagationErrors: Map<NodeId, Array<Diagnostic>>;
+    constructor({ input, api, options }: RunInput, prevResult?: AssetGraphRequestResult | null);
+    build(): Promise<AssetGraphRequestResult>;
+    shouldVisitChild(nodeId: NodeId, childNodeId: NodeId): boolean;
+    shouldSkipRequest(nodeId: NodeId): boolean;
+    queueCorrespondingRequest(nodeId: NodeId, errors: Array<Error>): Promise<null>;
+    runEntryRequest(input: ProjectPath): Promise<void>;
+    runTargetRequest(input: Entry): Promise<void>;
+    runPathRequest(input: Dependency): Promise<void>;
+    runAssetRequest(input: AssetGroup): Promise<void>;
+    /**
+     * Used for incremental bundling of modified assets
+     */
+    _areDependenciesEqualForAssets(asset: Asset, otherAsset: Asset): boolean;
+}
+export {};

package/lib/types/requests/AssetGraphRequestRust.d.ts

@@ -0,0 +1,21 @@
+import type { Async } from '@atlaspack/types';
+import AssetGraph from '../AssetGraph';
+import type { AtlaspackV3 } from '../atlaspack-v3';
+import { requestTypes, StaticRunOpts } from '../RequestTracker';
+import type { Asset } from '../types';
+import type { AssetGraphRequestInput, AssetGraphRequestResult } from './AssetGraphRequest';
+type RunInput = {
+    input: AssetGraphRequestInput;
+} & StaticRunOpts<AssetGraphRequestResult>;
+type AssetGraphRequest = {
+    id: string;
+    readonly type: typeof requestTypes.asset_graph_request;
+    run: (arg1: RunInput) => Async<AssetGraphRequestResult>;
+    input: AssetGraphRequestInput;
+};
+export declare function createAssetGraphRequestRust(rustAtlaspack: AtlaspackV3): (input: AssetGraphRequestInput) => AssetGraphRequest;
+export declare function getAssetGraph(serializedGraph: any, prevAssetGraph?: AssetGraph): {
+    assetGraph: AssetGraph;
+    changedAssets: Map<string, Asset>;
+};
+export {};

package/lib/types/requests/AssetRequest.d.ts

@@ -0,0 +1,16 @@
+import type { ContentKey } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { AssetRequestInput, AssetRequestResult } from '../types';
+import { requestTypes } from '../RequestTracker';
+type RunInput<TResult> = {
+    input: AssetRequestInput;
+} & StaticRunOpts<TResult>;
+export type AssetRequest = {
+    id: ContentKey;
+    readonly type: typeof requestTypes.asset_request;
+    run: (arg1: RunInput<AssetRequestResult>) => Async<AssetRequestResult>;
+    input: AssetRequestInput;
+};
+export default function createAssetRequest(input: AssetRequestInput): AssetRequest;
+export {};

package/lib/types/requests/AtlaspackBuildRequest.d.ts

@@ -0,0 +1,33 @@
+import type { ContentKey } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { Asset, AssetGroup, PackagedBundleInfo } from '../types';
+import type BundleGraph from '../BundleGraph';
+import { requestTypes } from '../RequestTracker';
+type AtlaspackBuildRequestInput = {
+    optionsRef: SharedReference;
+    requestedAssetIds: Set<string>;
+    signal?: AbortSignal;
+};
+export type AtlaspackBuildRequestResult = {
+    bundleGraph: BundleGraph;
+    bundleInfo: Map<string, PackagedBundleInfo>;
+    changedAssets: Map<string, Asset>;
+    assetRequests: Array<AssetGroup>;
+    scopeHoistingStats?: {
+        totalAssets: number;
+        wrappedAssets: number;
+    };
+};
+type RunInput<TResult> = {
+    input: AtlaspackBuildRequestInput;
+} & StaticRunOpts<TResult>;
+export type AtlaspackBuildRequest = {
+    id: ContentKey;
+    readonly type: typeof requestTypes.atlaspack_build_request;
+    run: (arg1: RunInput<AtlaspackBuildRequestResult>) => Async<AtlaspackBuildRequestResult>;
+    input: AtlaspackBuildRequestInput;
+};
+export default function createAtlaspackBuildRequest(input: AtlaspackBuildRequestInput): AtlaspackBuildRequest;
+export {};

package/lib/types/requests/AtlaspackConfigRequest.d.ts

@@ -0,0 +1,45 @@
+import type { Async, FilePath, RawAtlaspackConfig, ResolvedAtlaspackConfigFile } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { ExtendableAtlaspackConfigPipeline, AtlaspackOptions, ProcessedAtlaspackConfig } from '../types';
+import { AtlaspackConfig } from '../AtlaspackConfig';
+import { requestTypes } from '../RequestTracker';
+type ConfigMap<K, V> = Partial<Record<K, V>>;
+export type ConfigAndCachePath = {
+    config: ProcessedAtlaspackConfig;
+    cachePath: string;
+};
+type RunOpts<TResult> = {
+    input: null;
+} & StaticRunOpts<TResult>;
+export type AtlaspackConfigRequest = {
+    id: string;
+    type: typeof requestTypes.atlaspack_config_request;
+    input: null;
+    run: (arg1: RunOpts<AtlaspackConfigRequestResult>) => Async<AtlaspackConfigRequestResult>;
+};
+export type AtlaspackConfigRequestResult = ConfigAndCachePath;
+type AtlaspackConfigChain = {
+    config: ProcessedAtlaspackConfig;
+    extendedFiles: Array<FilePath>;
+};
+export default function createAtlaspackConfigRequest(): AtlaspackConfigRequest;
+export declare function getCachedAtlaspackConfig(result: ConfigAndCachePath, options: AtlaspackOptions): AtlaspackConfig;
+export declare function loadAtlaspackConfig(options: AtlaspackOptions): Promise<AtlaspackConfigChain & {
+    usedDefault: boolean;
+}>;
+export declare function resolveAtlaspackConfig(options: AtlaspackOptions): Promise<(AtlaspackConfigChain & {
+    usedDefault: boolean;
+}) | null | undefined>;
+export declare function create(config: ResolvedAtlaspackConfigFile, options: AtlaspackOptions): Promise<AtlaspackConfigChain>;
+export declare function parseAndProcessConfig(configPath: FilePath, contents: string, options: AtlaspackOptions): Promise<AtlaspackConfigChain>;
+export declare function processConfig(configFile: ResolvedAtlaspackConfigFile, options: AtlaspackOptions): Promise<ProcessedAtlaspackConfig>;
+export declare function processConfigChain(configFile: RawAtlaspackConfig | ResolvedAtlaspackConfigFile, filePath: FilePath, options: AtlaspackOptions): Promise<AtlaspackConfigChain>;
+export declare function resolveExtends(ext: string, configPath: FilePath, extendsKey: string, options: AtlaspackOptions): Promise<FilePath>;
+export declare function validateConfigFile(config: RawAtlaspackConfig | ResolvedAtlaspackConfigFile, relativePath: FilePath): void;
+export declare function validateNotEmpty(config: RawAtlaspackConfig | ResolvedAtlaspackConfigFile, relativePath: FilePath): void;
+export declare function mergeConfigs(base: ProcessedAtlaspackConfig, ext: ProcessedAtlaspackConfig): ProcessedAtlaspackConfig;
+export declare function getResolveFrom(fs: FileSystem, projectRoot: FilePath): FilePath;
+export declare function mergePipelines(base?: ExtendableAtlaspackConfigPipeline | null, ext?: ExtendableAtlaspackConfigPipeline | null): ExtendableAtlaspackConfigPipeline;
+export declare function mergeMaps<K extends string, V>(base?: ConfigMap<K, V> | null, ext?: ConfigMap<K, V> | null, merger?: (a: V, b: V) => V): ConfigMap<K, V>;
+export {};

package/lib/types/requests/BundleGraphRequest.d.ts

@@ -0,0 +1,28 @@
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { Asset, AssetGroup } from '../types';
+import InternalBundleGraph from '../BundleGraph';
+import { requestTypes } from '../RequestTracker';
+type BundleGraphRequestInput = {
+    requestedAssetIds: Set<string>;
+    signal?: AbortSignal;
+    optionsRef: SharedReference;
+};
+type RunInput = {
+    input: BundleGraphRequestInput;
+} & StaticRunOpts<BundleGraphResult>;
+export type BundleGraphResult = {
+    bundleGraph: InternalBundleGraph;
+    assetGraphBundlingVersion: number;
+    changedAssets: Map<string, Asset>;
+    assetRequests: Array<AssetGroup>;
+};
+type BundleGraphRequest = {
+    id: string;
+    readonly type: typeof requestTypes.bundle_graph_request;
+    run: (arg1: RunInput) => Async<BundleGraphResult>;
+    input: BundleGraphRequestInput;
+};
+export default function createBundleGraphRequest(input: BundleGraphRequestInput): BundleGraphRequest;
+export {};

package/lib/types/requests/ConfigRequest.d.ts

@@ -0,0 +1,59 @@
+import type { Async, Config as IConfig, PluginOptions as IPluginOptions, PluginLogger as IPluginLogger, PluginTracer as IPluginTracer, NamedBundle as INamedBundle, BundleGraph as IBundleGraph } from '@atlaspack/types';
+import type { Config, AtlaspackOptions, InternalFileCreateInvalidation } from '../types';
+import type { LoadedPlugin } from '../AtlaspackConfig';
+import type { RequestResult, RunAPI } from '../RequestTracker';
+import type { ProjectPath } from '../projectPath';
+export type PluginWithLoadConfig = {
+    loadConfig?: (arg1: {
+        config: IConfig;
+        options: IPluginOptions;
+        logger: IPluginLogger;
+        tracer: IPluginTracer;
+    }) => Async<unknown>;
+};
+export type PluginWithBundleConfig = {
+    loadConfig?: (arg1: {
+        config: IConfig;
+        options: IPluginOptions;
+        logger: IPluginLogger;
+        tracer: IPluginTracer;
+    }) => Async<unknown>;
+    loadBundleConfig?: (arg1: {
+        bundle: INamedBundle;
+        bundleGraph: IBundleGraph<INamedBundle>;
+        config: IConfig;
+        options: IPluginOptions;
+        logger: IPluginLogger;
+        tracer: IPluginTracer;
+    }) => Async<unknown>;
+};
+export type ConfigRequest = {
+    id: string;
+    invalidateOnFileChange: Set<ProjectPath>;
+    invalidateOnConfigKeyChange: Array<{
+        filePath: ProjectPath;
+        configKey: string[];
+    }>;
+    invalidateOnFileCreate: Array<InternalFileCreateInvalidation>;
+    invalidateOnEnvChange: Set<string>;
+    invalidateOnOptionChange: Set<string>;
+    invalidateOnStartup: boolean;
+    invalidateOnBuild: boolean;
+};
+export type ConfigRequestResult = undefined;
+export declare function loadPluginConfig<T extends PluginWithLoadConfig>(loadedPlugin: LoadedPlugin<T>, config: Config, options: AtlaspackOptions): Promise<void>;
+/**
+ * Return value at a given key path within an object.
+ *
+ * @example
+ *     const obj = { a: { b: { c: 'd' } } };
+ *     getValueAtPath(obj, ['a', 'b', 'c']);        // 'd'
+ *     getValueAtPath(obj, ['a', 'b', 'd']);        // undefined
+ *     getValueAtPath(obj, ['a', 'b']);             // { c: 'd' }
+ *     getValueAtPath(obj, ['a', 'b', 'c', 'd']);   // undefined
+ */
+export declare function getValueAtPath(obj: any, key: string[]): any;
+export declare function getConfigKeyContentHash(filePath: ProjectPath, configKey: string[], options: AtlaspackOptions): Promise<Async<string>>;
+export declare function runConfigRequest<TResult extends RequestResult>(api: RunAPI<TResult>, configRequest: ConfigRequest): Promise<void>;
+export declare function getConfigHash(config: Config, pluginName: string, options: AtlaspackOptions): Promise<string>;
+export declare function getConfigRequests(configs: Array<Config>): Array<ConfigRequest>;

package/lib/types/requests/DevDepRequest.d.ts

@@ -0,0 +1,30 @@
+import type { DependencySpecifier, SemverRange } from '@atlaspack/types';
+import type { AtlaspackConfig } from '../AtlaspackConfig';
+import type { DevDepRequest, AtlaspackOptions, InternalDevDepOptions, DevDepRequestRef } from '../types';
+import type { RequestResult, RunAPI } from '../RequestTracker';
+import type { ProjectPath } from '../projectPath';
+export declare function createDevDependency(opts: InternalDevDepOptions, requestDevDeps: Map<string, string>, options: AtlaspackOptions): Promise<DevDepRequest | DevDepRequestRef>;
+export type DevDepSpecifier = {
+    specifier: DependencySpecifier;
+    resolveFrom: ProjectPath;
+};
+type DevDepRequests = {
+    devDeps: Map<string, string>;
+    invalidDevDeps: Array<DevDepSpecifier>;
+};
+export declare function getDevDepRequests<TResult extends RequestResult>(api: RunAPI<TResult>): Promise<DevDepRequests>;
+export declare function invalidateDevDeps(invalidDevDeps: Array<DevDepSpecifier>, options: AtlaspackOptions, config: AtlaspackConfig): void;
+export type DevDepRequestResult = {
+    specifier: DependencySpecifier;
+    resolveFrom: ProjectPath;
+    hash: string;
+    additionalInvalidations: undefined | Array<{
+        range?: SemverRange | null | undefined;
+        resolveFrom: ProjectPath;
+        specifier: DependencySpecifier;
+    }>;
+};
+export declare function resolveDevDepRequestRef(devDepRequestRef: DevDepRequest | DevDepRequestRef): DevDepRequest;
+export declare function runDevDepRequest<TResult extends RequestResult>(api: RunAPI<TResult>, devDepRequestRef: DevDepRequest | DevDepRequestRef): Promise<void>;
+export declare function getWorkerDevDepRequests(devDepRequests: Array<DevDepRequest | DevDepRequestRef>): Array<DevDepRequest | DevDepRequestRef>;
+export {};

package/lib/types/requests/EntryRequest.d.ts

@@ -0,0 +1,36 @@
+import type { Async, FilePath, PackageJSON, Glob } from '@atlaspack/types';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { Entry, InternalFile, AtlaspackOptions } from '../types';
+import { Mapping } from '@mischnic/json-sourcemap';
+import { requestTypes } from '../RequestTracker';
+import { ProjectPath } from '../projectPath';
+type RunOpts<TResult> = {
+    input: ProjectPath;
+} & StaticRunOpts<TResult>;
+export type EntryRequest = {
+    id: string;
+    readonly type: typeof requestTypes.entry_request;
+    run: (arg1: RunOpts<EntryRequestResult>) => Async<EntryRequestResult>;
+    input: ProjectPath;
+};
+export type EntryRequestResult = {
+    entries: Array<Entry>;
+    files: Array<InternalFile>;
+    globs: Array<Glob>;
+};
+export default function createEntryRequest(input: ProjectPath): EntryRequest;
+export declare class EntryResolver {
+    options: AtlaspackOptions;
+    constructor(options: AtlaspackOptions);
+    resolveEntry(entry: FilePath): Promise<EntryRequestResult>;
+    readPackage(entry: FilePath): Promise<(PackageJSON & {
+        filePath: FilePath;
+        map: {
+            data: unknown;
+            pointers: {
+                [key: string]: Mapping;
+            };
+        };
+    }) | null | undefined>;
+}
+export {};