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

package/lib/types/atlaspack-v3/worker/worker.d.ts

@@ -0,0 +1,81 @@
+import * as napi from '@atlaspack/rust';
+import type { JsCallable } from '@atlaspack/rust';
+import { NodePackageManager } from '@atlaspack/package-manager';
+import type { Transformer, FilePath, FileSystem } from '@atlaspack/types';
+import type { FeatureFlags } from '@atlaspack/feature-flags';
+export declare class AtlaspackWorker {
+    #private;
+    constructor();
+    clearState(): void;
+    loadPlugin: JsCallable<[LoadPluginOptions], Promise<undefined>>;
+    runResolverResolve: JsCallable<[
+        RunResolverResolveOptions
+    ], Promise<RunResolverResolveResult>>;
+    runTransformerTransform: JsCallable<[
+        RunTransformerTransformOptions,
+        Buffer,
+        string | null | undefined
+    ], Promise<RunTransformerTransformResult>>;
+    get options(): Options;
+    initializeTransformer(instance: Transformer<any>, specifier: string): Promise<{
+        conditions: import("@atlaspack/types-internal").TransformerConditions | undefined;
+        config: any;
+        env: {
+            [k: string]: string | undefined;
+        };
+        disableCache: boolean | undefined;
+    } | undefined>;
+}
+type LoadPluginOptions = {
+    kind: 'resolver' | 'transformer';
+    specifier: string;
+    resolveFrom: string;
+    options: RpcPluginOptions;
+};
+type RpcPluginOptions = {
+    projectRoot: string;
+    mode: string;
+    featureFlags: FeatureFlags;
+};
+type Options = RpcPluginOptions & {
+    inputFS: FileSystem;
+    outputFS: FileSystem;
+    packageManager: NodePackageManager;
+    shouldAutoInstall: boolean;
+};
+type RunResolverResolveOptions = {
+    key: string;
+    dependency: napi.Dependency;
+    specifier: FilePath;
+    pipeline: string | null | undefined;
+};
+type RunResolverResolveResult = {
+    invalidations: Array<any>;
+    resolution: {
+        type: 'unresolved';
+    } | {
+        type: 'excluded';
+    } | {
+        type: 'resolved';
+        canDefer: boolean;
+        filePath: string;
+        sideEffects: boolean;
+        code?: string;
+        meta?: unknown;
+        pipeline?: string;
+        priority?: number | null | undefined;
+        query?: string;
+    };
+};
+type RunTransformerTransformOptions = {
+    key: string;
+    env: napi.Environment;
+    asset: napi.Asset;
+};
+type RunTransformerTransformResult = [
+    napi.RpcAssetResult,
+    Buffer,
+    string,
+    boolean
+];
+export {};

package/lib/types/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const ATLASPACK_VERSION: string;
+export declare const HASH_REF_PREFIX = "HASH_REF_";
+export declare const HASH_REF_HASH_LEN = 16;
+export declare const HASH_REF_REGEX: RegExp;
+export declare const VALID = 0;
+export declare const INITIAL_BUILD: number;
+export declare const FILE_CREATE: number;
+export declare const FILE_UPDATE: number;
+export declare const FILE_DELETE: number;
+export declare const ENV_CHANGE: number;
+export declare const OPTION_CHANGE: number;
+export declare const STARTUP: number;
+export declare const ERROR: number;

package/lib/types/dumpGraphToGraphViz.d.ts

@@ -0,0 +1,10 @@
+import type { Asset, BundleBehavior } from '@atlaspack/types';
+import type { Graph } from '@atlaspack/graph';
+import type { AssetGraphNode, BundleGraphNode } from './types';
+import { bundleGraphEdgeTypes } from './BundleGraph';
+import { requestGraphEdgeTypes } from './RequestTracker';
+export default function dumpGraphToGraphViz(graph: Graph<AssetGraphNode> | Graph<{
+    assets: Set<Asset>;
+    sourceBundles: Set<number>;
+    bundleBehavior?: BundleBehavior | null | undefined;
+}> | Graph<BundleGraphNode>, name: string, edgeTypes?: typeof bundleGraphEdgeTypes | typeof requestGraphEdgeTypes): Promise<void>;

package/lib/types/index.d.ts

@@ -0,0 +1,8 @@
+import * as EnvironmentManager from './EnvironmentManager';
+export { default, default as Atlaspack, default as Parcel, BuildError, createWorkerFarm, INTERNAL_RESOLVE, INTERNAL_TRANSFORM, WORKER_PATH, } from './Atlaspack';
+export { ATLASPACK_VERSION } from './constants';
+export { default as resolveOptions } from './resolveOptions';
+export { createEnvironment } from './Environment';
+export { default as Environment } from './public/Environment';
+export * from './atlaspack-v3';
+export { EnvironmentManager };

package/lib/types/loadAtlaspackPlugin.d.ts

@@ -0,0 +1,8 @@
+import type { FilePath, PackageName, Semver } from '@atlaspack/types';
+import type { AtlaspackOptions } from './types';
+import { ProjectPath } from './projectPath';
+export default function loadPlugin<T>(pluginName: PackageName, configPath: FilePath, keyPath: string | null | undefined, options: AtlaspackOptions): Promise<{
+    plugin: T;
+    version: Semver;
+    resolveFrom: ProjectPath;
+}>;

package/lib/types/loadDotEnv.d.ts

@@ -0,0 +1,3 @@
+import type { FileSystem } from '@atlaspack/fs';
+import type { EnvMap, FilePath } from '@atlaspack/types';
+export default function loadEnv(env: EnvMap, fs: FileSystem, filePath: FilePath, projectRoot: FilePath): Promise<EnvMap>;

package/lib/types/projectPath.d.ts

@@ -0,0 +1,19 @@
+import type { FilePath } from '@atlaspack/types';
+/**
+ * A path that's relative to the project root.
+ */
+export type ProjectPath = string;
+export declare const toProjectPath: ((projectRoot: FilePath, p: FilePath) => ProjectPath) & ((projectRoot: FilePath, p: FilePath | undefined) => ProjectPath | undefined) & ((projectRoot: FilePath, p?: FilePath | null | undefined) => ProjectPath | null | undefined);
+export declare const fromProjectPath: ((projectRoot: FilePath, p: ProjectPath) => FilePath) & ((projectRoot: FilePath, p?: ProjectPath | null | undefined) => FilePath | null | undefined);
+/**
+ * Returns a path relative to the project root. This should be used when computing cache keys
+ */
+export declare function fromProjectPathRelative(p: ProjectPath): FilePath;
+/**
+ * This function should be avoided, it doesn't change the actual value.
+ */
+export declare function toProjectPathUnsafe(p: FilePath): ProjectPath;
+/**
+ * Joins a project root with relative paths (similar to `path.join`)
+ */
+export declare function joinProjectPath(a: ProjectPath, ...b: Array<FilePath>): ProjectPath;

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

@@ -0,0 +1,74 @@
+import type SourceMap from '@atlaspack/source-map';
+import type { Readable } from 'stream';
+import type { FileSystem } from '@atlaspack/fs';
+import type { Asset as IAsset, AST, ASTGenerator, Dependency as IDependency, DependencyOptions, Environment as IEnvironment, EnvironmentOptions, FileCreateInvalidation, FilePath, Meta, MutableAsset as IMutableAsset, Stats, MutableAssetSymbols as IMutableAssetSymbols, AssetSymbols as IAssetSymbols, BundleBehavior } from '@atlaspack/types';
+import type { Asset as AssetValue, AtlaspackOptions } from '../types';
+import UncommittedAsset from '../UncommittedAsset';
+import CommittedAsset from '../CommittedAsset';
+declare const inspect: unique symbol;
+export declare function assetToAssetValue(asset: IAsset | IMutableAsset): AssetValue;
+export declare function mutableAssetToUncommittedAsset(mutableAsset: IMutableAsset): UncommittedAsset;
+export declare function assetFromValue(value: AssetValue, options: AtlaspackOptions): Asset;
+declare class BaseAsset {
+    #private;
+    constructor(asset: CommittedAsset | UncommittedAsset);
+    [inspect](): string;
+    get id(): string;
+    get type(): string;
+    get env(): IEnvironment;
+    get fs(): FileSystem;
+    get filePath(): FilePath;
+    get query(): URLSearchParams;
+    get meta(): Meta;
+    get bundleBehavior(): BundleBehavior | null | undefined;
+    get isBundleSplittable(): boolean;
+    get isSource(): boolean;
+    get sideEffects(): boolean;
+    get symbols(): IAssetSymbols;
+    get uniqueKey(): string | null | undefined;
+    get astGenerator(): ASTGenerator | null | undefined;
+    get pipeline(): string | null | undefined;
+    getDependencies(): ReadonlyArray<IDependency>;
+    getCode(): Promise<string>;
+    getBuffer(): Promise<Buffer>;
+    getStream(): Readable;
+    getMap(): Promise<SourceMap | null | undefined>;
+    getAST(): Promise<AST | null | undefined>;
+    getMapBuffer(): Promise<Buffer | null | undefined>;
+}
+export declare class Asset extends BaseAsset implements IAsset {
+    #private;
+    constructor(asset: CommittedAsset | UncommittedAsset);
+    get env(): IEnvironment;
+    get stats(): Stats;
+}
+export declare class MutableAsset extends BaseAsset implements IMutableAsset {
+    #private;
+    constructor(asset: UncommittedAsset);
+    setMap(map?: SourceMap | null): void;
+    get type(): string;
+    set type(type: string): void;
+    get bundleBehavior(): BundleBehavior | null | undefined;
+    set bundleBehavior(bundleBehavior?: BundleBehavior | null): void;
+    get isBundleSplittable(): boolean;
+    set isBundleSplittable(isBundleSplittable: boolean): void;
+    get sideEffects(): boolean;
+    set sideEffects(sideEffects: boolean): void;
+    get uniqueKey(): string | null | undefined;
+    set uniqueKey(uniqueKey?: string | null): void;
+    get symbols(): IMutableAssetSymbols;
+    addDependency(dep: DependencyOptions): string;
+    invalidateOnFileChange(filePath: FilePath): void;
+    invalidateOnFileCreate(invalidation: FileCreateInvalidation): void;
+    invalidateOnEnvChange(env: string): void;
+    invalidateOnStartup(): void;
+    invalidateOnBuild(): void;
+    isASTDirty(): boolean;
+    setBuffer(buffer: Buffer): void;
+    setCode(code: string): void;
+    setStream(stream: Readable): void;
+    setAST(ast: AST): void;
+    addURLDependency(url: string, opts: Partial<DependencyOptions>): string;
+    setEnvironment(env: EnvironmentOptions): void;
+}
+export {};

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

@@ -0,0 +1,45 @@
+import type { Bundle as InternalBundle, AtlaspackOptions, PackagedBundleInfo } from '../types';
+import type { Asset as IAsset, Bundle as IBundle, BundleTraversable, Dependency as IDependency, Environment as IEnvironment, GraphVisitor, NamedBundle as INamedBundle, PackagedBundle as IPackagedBundle, Stats, Target as ITarget, BundleBehavior } from '@atlaspack/types';
+import type BundleGraph from '../BundleGraph';
+declare const inspect: unique symbol;
+export declare function bundleToInternalBundle(bundle: IBundle): InternalBundle;
+export declare function bundleToInternalBundleGraph(bundle: IBundle): BundleGraph;
+export declare class Bundle implements IBundle {
+    #private;
+    [inspect](): string;
+    constructor(sentinel: unknown, bundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions);
+    static get(internalBundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions): Bundle;
+    get id(): string;
+    get hashReference(): string;
+    get type(): string;
+    get env(): IEnvironment;
+    get needsStableName(): boolean | null | undefined;
+    get bundleBehavior(): BundleBehavior | null | undefined;
+    get isSplittable(): boolean | null | undefined;
+    get manualSharedBundle(): string | null | undefined;
+    get target(): ITarget;
+    hasAsset(asset: IAsset): boolean;
+    hasDependency(dep: IDependency): boolean;
+    getEntryAssets(): Array<IAsset>;
+    getMainEntry(): IAsset | null | undefined;
+    traverse<TContext>(visit: GraphVisitor<BundleTraversable, TContext>): TContext | null | undefined;
+    traverseAssets<TContext>(visit: GraphVisitor<IAsset, TContext>, startAsset?: IAsset): TContext | null | undefined;
+}
+export declare class NamedBundle extends Bundle implements INamedBundle {
+    #private;
+    constructor(sentinel: unknown, bundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions);
+    static get(internalBundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions): NamedBundle;
+    get name(): string;
+    get displayName(): string;
+    get publicId(): string;
+}
+export declare class PackagedBundle extends NamedBundle implements IPackagedBundle {
+    #private;
+    constructor(sentinel: unknown, bundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions);
+    static get(internalBundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions): PackagedBundle;
+    static getWithInfo(internalBundle: InternalBundle, bundleGraph: BundleGraph, options: AtlaspackOptions, bundleInfo?: PackagedBundleInfo | null): PackagedBundle;
+    get filePath(): string;
+    get type(): string;
+    get stats(): Stats;
+}
+export {};

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

@@ -0,0 +1,72 @@
+import type { Asset as IAsset, Bundle as IBundle, BundleGraph as IBundleGraph, BundleGraphTraversable, BundleGroup as IBundleGroup, Dependency as IDependency, ExportSymbolResolution, FilePath, GraphVisitor, NamedBundle, SymbolResolution, Symbol, Target } from '@atlaspack/types';
+import type { Bundle as InternalBundle, AtlaspackOptions } from '../types';
+import type InternalBundleGraph from '../BundleGraph';
+import { Asset } from './Asset';
+export declare function bundleGraphToInternalBundleGraph(bundleGraph: IBundleGraph<IBundle>): InternalBundleGraph;
+type BundleFactory<TBundle extends IBundle> = (arg1: InternalBundle, arg2: InternalBundleGraph, arg3: AtlaspackOptions) => TBundle;
+export default class BundleGraph<TBundle extends IBundle> implements IBundleGraph<TBundle> {
+    #private;
+    constructor(graph: InternalBundleGraph, createBundle: BundleFactory<TBundle>, options: AtlaspackOptions);
+    getAssetById(id: string): Asset;
+    getAssetPublicId(asset: IAsset): string;
+    isDependencySkipped(dep: IDependency): boolean;
+    getResolvedAsset(dep: IDependency, bundle?: IBundle | null): IAsset | null | undefined;
+    getIncomingDependencies(asset: IAsset): Array<IDependency>;
+    getAssetWithDependency(dep: IDependency): IAsset | null | undefined;
+    getBundleGroupsContainingBundle(bundle: IBundle): Array<IBundleGroup>;
+    getReferencedBundles(bundle: IBundle, opts?: {
+        recursive?: boolean;
+        includeInline?: boolean;
+    }): Array<TBundle>;
+    getReferencingBundles(bundle: IBundle): Array<TBundle>;
+    resolveAsyncDependency(dependency: IDependency, bundle?: IBundle | null): {
+        type: 'bundle_group';
+        value: IBundleGroup;
+    } | {
+        type: 'asset';
+        value: IAsset;
+    } | null | undefined;
+    getReferencedBundle(dependency: IDependency, bundle: IBundle): TBundle | null | undefined;
+    getDependencies(asset: IAsset): Array<IDependency>;
+    isAssetReachableFromBundle(asset: IAsset, bundle: IBundle): boolean;
+    isAssetReferenced(bundle: IBundle, asset: IAsset): boolean;
+    isAssetReferencedFastCheck(bundle: IBundle, asset: IAsset): boolean | null;
+    getReferencedAssets(bundle: IBundle): Set<IAsset>;
+    hasParentBundleOfType(bundle: IBundle, type: string): boolean;
+    getBundlesInBundleGroup(bundleGroup: IBundleGroup, opts?: {
+        includeInline: boolean;
+    }): Array<TBundle>;
+    getBundles(opts?: {
+        includeInline: boolean;
+    }): Array<TBundle>;
+    isEntryBundleGroup(bundleGroup: IBundleGroup): boolean;
+    getChildBundles(bundle: IBundle): Array<TBundle>;
+    getParentBundles(bundle: IBundle): Array<TBundle>;
+    getSymbolResolution(asset: IAsset, symbol: Symbol, boundary?: IBundle | null): SymbolResolution;
+    getExportedSymbols(asset: IAsset, boundary?: IBundle | null): Array<ExportSymbolResolution>;
+    traverse<TContext>(visit: GraphVisitor<BundleGraphTraversable, TContext>, start?: IAsset | null, opts?: {
+        skipUnusedDependencies?: boolean;
+    } | null): TContext | null | undefined;
+    traverseBundles<TContext>(visit: GraphVisitor<TBundle, TContext>, startBundle?: IBundle | null): TContext | null | undefined;
+    getBundlesWithAsset(asset: IAsset): Array<TBundle>;
+    getBundlesWithDependency(dependency: IDependency): Array<TBundle>;
+    getUsedSymbols(v: IAsset | IDependency): ReadonlySet<Symbol> | null | undefined;
+    getEntryRoot(target: Target): FilePath;
+    getConditionsForDependencies(deps: Array<IDependency>, bundle: NamedBundle): Set<{
+        publicId: string;
+        key: string;
+        ifTrueDependency: IDependency;
+        ifFalseDependency: IDependency;
+        ifTrueBundles: Array<TBundle>;
+        ifFalseBundles: Array<TBundle>;
+        ifTrueAssetId: string;
+        ifFalseAssetId: string;
+    }>;
+    getConditionalBundleMapping(): Map<string, Map<string, {
+        bundle: TBundle;
+        ifTrueBundles: Array<TBundle>;
+        ifFalseBundles: Array<TBundle>;
+    }>>;
+    getReferencedConditionalBundles(bundle: IBundle): Array<TBundle>;
+}
+export {};

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

@@ -0,0 +1,12 @@
+import type { BundleGroup as IBundleGroup, Target as ITarget } from '@atlaspack/types';
+import type { BundleGroup as InternalBundleGroup, AtlaspackOptions } from '../types';
+export declare function bundleGroupToInternalBundleGroup(target: IBundleGroup): InternalBundleGroup;
+declare const inspect: unique symbol;
+export default class BundleGroup implements IBundleGroup {
+    #private;
+    constructor(bundleGroup: InternalBundleGroup, options: AtlaspackOptions);
+    get target(): ITarget;
+    get entryAssetId(): string;
+    [inspect](): string;
+}
+export {};

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;