@atlaspack/core 2.19.3-typescript-b27501580.0 → 2.19.3-typescript-5b4d3ad41.0

package/lib/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/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/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/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;

package/lib/BundleGraph.d.ts

@@ -0,0 +1,181 @@
+import type { GraphVisitor, FilePath, TraversalActions, BundleBehavior as IBundleBehavior } from '@atlaspack/types';
+import type { ContentGraphOpts, NodeId, SerializedContentGraph } from '@atlaspack/graph';
+import type { Asset, AssetNode, Bundle, BundleGraphNode, BundleGroup, Dependency, DependencyNode, InternalSourceLocation, Target, Condition } from './types';
+import type AssetGraph from './AssetGraph';
+import type { ProjectPath } from './projectPath';
+import { ContentGraph } from '@atlaspack/graph';
+import type { EnvironmentRef } from './EnvironmentManager';
+export declare const bundleGraphEdgeTypes: {
+    readonly null: 1;
+    readonly contains: 2;
+    readonly bundle: 3;
+    readonly references: 4;
+    readonly internal_async: 5;
+    readonly conditional: 5;
+};
+export type BundleGraphEdgeType = (typeof bundleGraphEdgeTypes)[keyof typeof bundleGraphEdgeTypes];
+type InternalSymbolResolution = {
+    asset: Asset;
+    exportSymbol: string;
+    symbol: symbol | null | undefined | false;
+    loc: InternalSourceLocation | null | undefined;
+};
+type InternalExportSymbolResolution = InternalSymbolResolution & {
+    readonly exportAs: symbol | string;
+};
+type BundleGraphOpts = {
+    graph: ContentGraphOpts<BundleGraphNode, BundleGraphEdgeType>;
+    bundleContentHashes: Map<string, string>;
+    assetPublicIds: Set<string>;
+    publicIdByAssetId: Map<string, string>;
+    conditions: Map<string, Condition>;
+};
+type SerializedBundleGraph = {
+    $$raw: true;
+    graph: SerializedContentGraph<BundleGraphNode, BundleGraphEdgeType>;
+    bundleContentHashes: Map<string, string>;
+    assetPublicIds: Set<string>;
+    publicIdByAssetId: Map<string, string>;
+    conditions: Map<string, Condition>;
+};
+/**
+ * Stores assets, dependencies, bundle groups, bundles, and the relationships between them.
+ * The BundleGraph is passed to the bundler plugin wrapped in a MutableBundleGraph,
+ * and is passed to packagers and optimizers wrapped in the public BundleGraph object, both
+ * of which implement public api for this structure. This is the internal structure.
+ */
+export default class BundleGraph {
+    /** A set of all existing concise asset ids present in the BundleGraph */
+    _assetPublicIds: Set<string>;
+    /** Maps full asset ids (currently 32-character strings) to concise ids (minimum of 5 character strings) */
+    _publicIdByAssetId: Map<string, string>;
+    /**
+     * A cache of bundle hashes by bundle id.
+     *
+     * TODO: These hashes are being invalidated in mutative methods, but this._graph is not a private
+     * property so it is possible to reach in and mutate the graph without invalidating these hashes.
+     * It needs to be exposed in BundlerRunner for now based on how applying runtimes works and the
+     * BundlerRunner takes care of invalidating hashes when runtimes are applied, but this is not ideal.
+     */
+    _bundleContentHashes: Map<string, string>;
+    _targetEntryRoots: Map<ProjectPath, FilePath>;
+    /** The internal core Graph structure */
+    _graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>;
+    _bundlePublicIds: Set<string>;
+    _conditions: Map<string, Condition>;
+    constructor({ graph, publicIdByAssetId, assetPublicIds, bundleContentHashes, conditions, }: {
+        graph: ContentGraph<BundleGraphNode, BundleGraphEdgeType>;
+        publicIdByAssetId: Map<string, string>;
+        assetPublicIds: Set<string>;
+        bundleContentHashes: Map<string, string>;
+        conditions: Map<string, Condition>;
+    });
+    /**
+     * Produce a BundleGraph from an AssetGraph by removing asset groups and retargeting dependencies
+     * based on the symbol data (resolving side-effect free reexports).
+     */
+    static fromAssetGraph(assetGraph: AssetGraph, isProduction: boolean, publicIdByAssetId?: Map<string, string>, assetPublicIds?: Set<string>): BundleGraph;
+    serialize(): SerializedBundleGraph;
+    static deserialize(serialized: BundleGraphOpts): BundleGraph;
+    createBundle(opts: {
+        readonly entryAsset: Asset;
+        readonly target: Target;
+        readonly needsStableName?: boolean | null | undefined;
+        readonly bundleBehavior?: IBundleBehavior | null | undefined;
+        readonly shouldContentHash: boolean;
+        readonly env: EnvironmentRef;
+    } | {
+        readonly type: string;
+        readonly env: EnvironmentRef;
+        readonly uniqueKey: string;
+        readonly target: Target;
+        readonly needsStableName?: boolean | null | undefined;
+        readonly bundleBehavior?: IBundleBehavior | null | undefined;
+        readonly isSplittable?: boolean | null | undefined;
+        readonly pipeline?: string | null | undefined;
+        readonly shouldContentHash: boolean;
+    }): Bundle;
+    addAssetToBundle(asset: Asset, bundle: Bundle): void;
+    addAssetGraphToBundle(asset: Asset, bundle: Bundle, shouldSkipDependency?: (arg1: Dependency) => boolean): void;
+    markDependencyReferenceable(dependency: Dependency): void;
+    addEntryToBundle(asset: Asset, bundle: Bundle, shouldSkipDependency?: (arg1: Dependency) => boolean): void;
+    internalizeAsyncDependency(bundle: Bundle, dependency: Dependency): void;
+    isDependencySkipped(dependency: Dependency): boolean;
+    getParentBundlesOfBundleGroup(bundleGroup: BundleGroup): Array<Bundle>;
+    resolveAsyncDependency(dependency: Dependency, bundle?: Bundle | null): {
+        type: 'bundle_group';
+        value: BundleGroup;
+    } | {
+        type: 'asset';
+        value: Asset;
+    } | null | undefined;
+    getReferencedBundle(dependency: Dependency, fromBundle: Bundle): Bundle | null | undefined;
+    removeAssetGraphFromBundle(asset: Asset, bundle: Bundle): void;
+    /**
+     * Remove a bundle from the bundle graph. Remove its bundle group if it is
+     * the only bundle in the group.
+     */
+    removeBundle(bundle: Bundle): Set<BundleGroup>;
+    removeBundleGroup(bundleGroup: BundleGroup): void;
+    _removeExternalDependency(bundle: Bundle, dependency: Dependency): void;
+    createAssetReference(dependency: Dependency, asset: Asset, bundle: Bundle): void;
+    createBundleReference(from: Bundle, to: Bundle): void;
+    createBundleConditionalReference(from: Bundle, to: Bundle): void;
+    getBundlesWithAsset(asset: Asset): Array<Bundle>;
+    getBundlesWithDependency(dependency: Dependency): Array<Bundle>;
+    getDependencyAssets(dependency: Dependency): Array<Asset>;
+    getResolvedAsset(dep: Dependency, bundle?: Bundle | null): Asset | null | undefined;
+    getDependencies(asset: Asset): Array<Dependency>;
+    traverseAssets<TContext>(bundle: Bundle, visit: GraphVisitor<Asset, TContext>, startAsset?: Asset): TContext | null | undefined;
+    isAssetReferenced(bundle: Bundle, asset: Asset): boolean;
+    hasParentBundleOfType(bundle: Bundle, type: string): boolean;
+    getParentBundles(bundle: Bundle): Array<Bundle>;
+    isAssetReachableFromBundle(asset: Asset, bundle: Bundle): boolean;
+    /**
+     * TODO: Document why this works like this & why visitor order matters
+     * on these use-cases.
+     */
+    traverseBundle<TContext>(bundle: Bundle, visit: GraphVisitor<AssetNode | DependencyNode, TContext>, startAsset?: Asset): TContext | null | undefined;
+    traverse<TContext>(visit: GraphVisitor<AssetNode | DependencyNode, TContext>, start?: Asset): TContext | null | undefined;
+    getChildBundles(bundle: Bundle): Array<Bundle>;
+    traverseBundles<TContext>(visit: GraphVisitor<Bundle, TContext>, startBundle?: Bundle | null): TContext | null | undefined;
+    getBundles(opts?: {
+        includeInline: boolean;
+    }): Array<Bundle>;
+    getTotalSize(asset: Asset): number;
+    getReferencingBundles(bundle: Bundle): Array<Bundle>;
+    getBundleGroupsContainingBundle(bundle: Bundle): Array<BundleGroup>;
+    getDirectParentBundleGroups(bundle: Bundle): Array<BundleGroup>;
+    getBundlesInBundleGroup(bundleGroup: BundleGroup, opts?: {
+        includeInline: boolean;
+    }): Array<Bundle>;
+    getReferencedBundles(bundle: Bundle, opts?: {
+        recursive?: boolean;
+        includeInline?: boolean;
+    }): Array<Bundle>;
+    getIncomingDependencies(asset: Asset): Array<Dependency>;
+    getAssetWithDependency(dep: Dependency): Asset | null | undefined;
+    bundleHasAsset(bundle: Bundle, asset: Asset): boolean;
+    bundleHasDependency(bundle: Bundle, dependency: Dependency): boolean;
+    filteredTraverse<TValue, TContext>(bundleNodeId: NodeId, filter: (arg1: NodeId, arg2: TraversalActions) => TValue | null | undefined, visit: GraphVisitor<TValue, TContext>): TContext | null | undefined;
+    getSymbolResolution(asset: Asset, symbol: symbol, boundary?: Bundle | null): InternalSymbolResolution;
+    getAssetById(contentKey: string): Asset;
+    getAssetPublicId(asset: Asset): string;
+    getExportedSymbols(asset: Asset, boundary?: Bundle | null): Array<InternalExportSymbolResolution>;
+    getContentHash(bundle: Bundle): string;
+    getInlineBundles(bundle: Bundle): Array<Bundle>;
+    getHash(bundle: Bundle): string;
+    getBundleGraphHash(): string;
+    addBundleToBundleGroup(bundle: Bundle, bundleGroup: BundleGroup): void;
+    getUsedSymbolsAsset(asset: Asset): ReadonlySet<symbol> | null | undefined;
+    getUsedSymbolsDependency(dep: Dependency): ReadonlySet<symbol> | null | undefined;
+    merge(other: BundleGraph): void;
+    isEntryBundleGroup(bundleGroup: BundleGroup): boolean;
+    /**
+     * Update the asset in a Bundle Graph and clear the associated Bundle hash.
+     */
+    updateAsset(asset: AssetNode): void;
+    getEntryRoot(projectRoot: FilePath, target: Target): FilePath;
+    getReferencedConditionalBundles(bundle: Bundle): Array<Bundle>;
+}
+export {};

package/lib/CommittedAsset.d.ts

@@ -0,0 +1,23 @@
+import { Readable } from 'stream';
+import type { AST, Blob } from '@atlaspack/types';
+import SourceMap from '@parcel/source-map';
+import type { Asset, Dependency, AtlaspackOptions } from './types';
+export default class CommittedAsset {
+    key: string | null | undefined;
+    value: Asset;
+    options: AtlaspackOptions;
+    content: Promise<Buffer | string> | null | undefined;
+    mapBuffer: Promise<Buffer | null | undefined> | null | undefined;
+    map: Promise<SourceMap | null | undefined> | null | undefined;
+    ast: Promise<AST> | null | undefined;
+    code: string | null | undefined;
+    constructor(value: Asset, options: AtlaspackOptions);
+    getContent(): Blob | Promise<Buffer | string>;
+    getCode(): Promise<string>;
+    getBuffer(): Promise<Buffer>;
+    getStream(): Readable;
+    getMapBuffer(): Promise<Buffer | null | undefined>;
+    getMap(): Promise<SourceMap | null | undefined>;
+    getAST(): Promise<AST | null | undefined>;
+    getDependencies(): Array<Dependency>;
+}

package/lib/Dependency.d.ts

@@ -0,0 +1,44 @@
+import type { FilePath, Meta, DependencySpecifier, SourceLocation, BundleBehavior as IBundleBehavior, SemverRange } from '@atlaspack/types';
+import type { Dependency, Target } from './types';
+import { SpecifierType, Priority } from './types';
+import type { EnvironmentRef } from './EnvironmentManager';
+type DependencyOpts = {
+    id?: string;
+    sourcePath?: FilePath;
+    sourceAssetId?: string;
+    specifier: DependencySpecifier;
+    specifierType: keyof typeof SpecifierType;
+    priority?: keyof typeof Priority;
+    needsStableName?: boolean;
+    bundleBehavior?: IBundleBehavior | null | undefined;
+    isEntry?: boolean;
+    isOptional?: boolean;
+    loc?: SourceLocation;
+    env: EnvironmentRef;
+    packageConditions?: Array<string>;
+    meta?: Meta;
+    resolveFrom?: FilePath;
+    range?: SemverRange;
+    target?: Target;
+    symbols?: Map<symbol, {
+        local: symbol;
+        loc: SourceLocation | null | undefined;
+        isWeak: boolean;
+        meta?: Meta | null | undefined;
+    }> | null | undefined;
+    pipeline?: string | null | undefined;
+};
+export declare function createDependencyId({ sourceAssetId, specifier, env, target, pipeline, specifierType, bundleBehavior, priority, packageConditions, }: {
+    sourceAssetId?: string | undefined;
+    specifier: DependencySpecifier;
+    env: EnvironmentRef;
+    target?: Target | undefined;
+    pipeline?: string | null | undefined;
+    specifierType: keyof typeof SpecifierType;
+    bundleBehavior?: IBundleBehavior | null | undefined;
+    priority?: keyof typeof Priority | undefined;
+    packageConditions?: Array<string> | undefined;
+}): string;
+export declare function createDependency(projectRoot: FilePath, opts: DependencyOpts): Dependency;
+export declare function mergeDependencies(a: Dependency, b: Dependency): void;
+export {};

package/lib/Environment.d.ts

@@ -0,0 +1,10 @@
+import type { EnvironmentOptions, Environment as IEnvironment, FilePath } from '@atlaspack/types';
+import type { Environment, InternalSourceLocation } from './types';
+import type { EnvironmentRef } from './EnvironmentManager';
+type EnvironmentOpts = EnvironmentOptions & {
+    loc?: InternalSourceLocation | null | undefined;
+};
+export declare function createEnvironment({ context, engines, includeNodeModules, outputFormat, sourceType, shouldOptimize, isLibrary, shouldScopeHoist, sourceMap, unstableSingleFileOutput, loc, }?: EnvironmentOpts): EnvironmentRef;
+export declare function mergeEnvironments(projectRoot: FilePath, a: Environment, b?: EnvironmentOptions | IEnvironment | null): EnvironmentRef;
+export declare function getEnvironmentHash(env: Environment): string;
+export {};

package/lib/EnvironmentManager.d.ts

@@ -0,0 +1,37 @@
+/*!
+ * At the moment we're doing this change for `CoreEnvironment`,
+ * but the same change must be made for `TypesEnvironment` in @atlaspack/types.
+ */
+import type { Environment as CoreEnvironment } from './types';
+import { Cache } from '@atlaspack/cache';
+export type EnvironmentId = string;
+/**
+ * When deduplication is cleaned-up this will always be a string.
+ */
+export type EnvironmentRef = EnvironmentId | CoreEnvironment;
+/**
+ * Convert environment to a ref.
+ * This is what we should be using to store environments.
+ */
+export declare function toEnvironmentRef(env: CoreEnvironment): EnvironmentRef;
+/**
+ * Convert environment to a string ID
+ */
+export declare function toEnvironmentId(
+/**
+ * Redundant type during roll-out
+ */
+env: CoreEnvironment | EnvironmentRef): string;
+export declare function fromEnvironmentId(id: EnvironmentRef): CoreEnvironment;
+/**
+ * Writes all environments and their IDs to the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+export declare function writeEnvironmentsToCache(cache: Cache): Promise<void>;
+/**
+ * Loads all environments and their IDs from the cache
+ * @param {Cache} cache
+ * @returns {Promise<void>}
+ */
+export declare function loadEnvironmentsFromCache(cache: Cache): Promise<void>;

package/lib/IdentifierRegistry.d.ts

@@ -0,0 +1,6 @@
+export declare class IdentifierRegistry {
+    #private;
+    constructor(enabled: boolean);
+    addIdentifier(type: string, identifier: string, data: unknown): void;
+}
+export declare const identifierRegistry: IdentifierRegistry;

package/lib/InternalConfig.d.ts

@@ -0,0 +1,24 @@
+import type { PackageName, ConfigResult } from '@atlaspack/types';
+import type { Config, InternalFileCreateInvalidation, InternalDevDepOptions } from './types';
+import type { ProjectPath } from './projectPath';
+import type { EnvironmentRef } from './EnvironmentManager';
+type ConfigOpts = {
+    plugin: PackageName;
+    searchPath: ProjectPath;
+    isSource?: boolean;
+    env?: EnvironmentRef;
+    result?: ConfigResult;
+    invalidateOnFileChange?: Set<ProjectPath>;
+    invalidateOnConfigKeyChange?: Array<{
+        filePath: ProjectPath;
+        configKey: string[];
+    }>;
+    invalidateOnFileCreate?: Array<InternalFileCreateInvalidation>;
+    invalidateOnEnvChange?: Set<string>;
+    invalidateOnOptionChange?: Set<string>;
+    devDeps?: Array<InternalDevDepOptions>;
+    invalidateOnStartup?: boolean;
+    invalidateOnBuild?: boolean;
+};
+export declare function createConfig({ plugin, isSource, searchPath, env, result, invalidateOnFileChange, invalidateOnConfigKeyChange, invalidateOnFileCreate, invalidateOnEnvChange, invalidateOnOptionChange, devDeps, invalidateOnStartup, invalidateOnBuild, }: ConfigOpts): Config;
+export {};

package/lib/PackagerRunner.d.ts

@@ -0,0 +1,80 @@
+import type { Blob, FilePath, BundleResult, Async } from '@atlaspack/types';
+import type SourceMap from '@parcel/source-map';
+import type { Bundle as InternalBundle, Config, DevDepRequest, AtlaspackOptions, ReportFn, RequestInvalidation, DevDepRequestRef } from './types';
+import type { AtlaspackConfig, LoadedPlugin } from './AtlaspackConfig';
+import type InternalBundleGraph from './BundleGraph';
+import type { ConfigRequest } from './requests/ConfigRequest';
+import type { DevDepSpecifier } from './requests/DevDepRequest';
+import { Readable } from 'stream';
+import { NamedBundle } from './public/Bundle';
+import PluginOptions from './public/PluginOptions';
+import { PluginWithBundleConfig } from './requests/ConfigRequest';
+type Opts = {
+    config: AtlaspackConfig;
+    options: AtlaspackOptions;
+    report: ReportFn;
+    previousDevDeps: Map<string, string>;
+    previousInvalidations: Array<RequestInvalidation>;
+};
+export type RunPackagerRunnerResult = {
+    bundleInfo: BundleInfo;
+    configRequests: Array<ConfigRequest>;
+    devDepRequests: Array<DevDepRequest | DevDepRequestRef>;
+    invalidations: Array<RequestInvalidation>;
+};
+export type BundleInfo = {
+    readonly type: string;
+    readonly size: number;
+    readonly hash: string;
+    readonly hashReferences: Array<string>;
+    readonly time?: number;
+    readonly cacheKeys: CacheKeyMap;
+    readonly isLargeBlob: boolean;
+};
+type CacheKeyMap = {
+    content: string;
+    map: string;
+    info: string;
+};
+export default class PackagerRunner {
+    config: AtlaspackConfig;
+    options: AtlaspackOptions;
+    pluginOptions: PluginOptions;
+    distDir: FilePath;
+    distExists: Set<FilePath>;
+    report: ReportFn;
+    previousDevDeps: Map<string, string>;
+    devDepRequests: Map<string, DevDepRequest | DevDepRequestRef>;
+    invalidations: Map<string, RequestInvalidation>;
+    previousInvalidations: Array<RequestInvalidation>;
+    constructor({ config, options, report, previousDevDeps, previousInvalidations, }: Opts);
+    run(bundleGraph: InternalBundleGraph, bundle: InternalBundle, invalidDevDeps: Array<DevDepSpecifier>): Promise<RunPackagerRunnerResult>;
+    loadConfigs(bundleGraph: InternalBundleGraph, bundle: InternalBundle): Promise<{
+        configs: Map<string, Config>;
+        bundleConfigs: Map<string, Config>;
+    }>;
+    loadConfig(bundleGraph: InternalBundleGraph, bundle: InternalBundle, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<void>;
+    loadPluginConfig<T extends PluginWithBundleConfig>(bundleGraph: InternalBundleGraph, bundle: InternalBundle, plugin: LoadedPlugin<T>, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<void>;
+    getBundleInfoFromCache(bundleGraph: InternalBundleGraph, bundle: InternalBundle, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<Async<BundleInfo | null | undefined>>;
+    getBundleInfo(bundle: InternalBundle, bundleGraph: InternalBundleGraph, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<BundleInfo>;
+    getBundleResult(bundle: InternalBundle, bundleGraph: InternalBundleGraph, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<{
+        type: string;
+        contents: Blob;
+        map: string | null | undefined;
+    }>;
+    getSourceMapReference(bundle: NamedBundle, map?: SourceMap | null): Async<string | null | undefined>;
+    package(internalBundle: InternalBundle, bundleGraph: InternalBundleGraph, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<BundleResult>;
+    optimize(internalBundle: InternalBundle, internalBundleGraph: InternalBundleGraph, type: string, contents: Blob, map: SourceMap | null | undefined, configs: Map<string, Config>, bundleConfigs: Map<string, Config>): Promise<BundleResult>;
+    generateSourceMap(bundle: InternalBundle, map: SourceMap): Promise<string>;
+    getCacheKey(bundle: InternalBundle, bundleGraph: InternalBundleGraph, configs: Map<string, Config>, bundleConfigs: Map<string, Config>, invalidations: Array<RequestInvalidation>): Promise<string>;
+    getDevDepHashes(bundle: InternalBundle): Promise<string>;
+    readFromCache(cacheKey: string): Promise<{
+        contents: Readable;
+        map: Readable | null | undefined;
+    } | null | undefined>;
+    writeToCache(cacheKeys: CacheKeyMap, type: string, contents: Blob, map?: string | null): Promise<BundleInfo>;
+    static getContentKey(cacheKey: string): string;
+    static getMapKey(cacheKey: string): string;
+    static getInfoKey(cacheKey: string): string;
+}
+export {};