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

package/lib/types/BundleGraph.d.ts

@@ -0,0 +1,182 @@
+import type { GraphVisitor, FilePath, TraversalActions, BundleBehavior as IBundleBehavior, Symbol } 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 bundleRoots?: Array<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/types/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/types/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/types/Environment.d.ts

@@ -0,0 +1,11 @@
+import type { EnvironmentOptions, Environment as IEnvironment, FilePath, EnvMap } from '@atlaspack/types';
+import type { Environment, InternalSourceLocation } from './types';
+import type { EnvironmentRef } from './EnvironmentManager';
+type EnvironmentOpts = EnvironmentOptions & {
+    loc?: InternalSourceLocation | null | undefined;
+    customEnv?: EnvMap | null | undefined;
+};
+export declare function createEnvironment({ context, engines, includeNodeModules, outputFormat, sourceType, shouldOptimize, isLibrary, shouldScopeHoist, sourceMap, unstableSingleFileOutput, loc, customEnv, }?: 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/types/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/types/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/types/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/types/PackagerRunner.d.ts

@@ -0,0 +1,85 @@
+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;
+    readonly scopeHoistingStats?: {
+        totalAssets: number;
+        wrappedAssets: number;
+    };
+};
+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;
+        scopeHoistingStats?: BundleResult['scopeHoistingStats'];
+    }>;
+    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 {};

package/lib/types/ReporterRunner.d.ts

@@ -0,0 +1,25 @@
+import type { ReporterEvent, Reporter } from '@atlaspack/types';
+import type { WorkerApi } from '@atlaspack/workers';
+import type { AtlaspackOptions } from './types';
+import type { LoadedPlugin } from './AtlaspackConfig';
+import WorkerFarm from '@atlaspack/workers';
+import PluginOptions from './public/PluginOptions';
+type Opts = {
+    options: AtlaspackOptions;
+    reporters: Array<LoadedPlugin<Reporter>>;
+    workerFarm: WorkerFarm;
+};
+export default class ReporterRunner {
+    workerFarm: WorkerFarm;
+    errors: Error[];
+    options: AtlaspackOptions;
+    pluginOptions: PluginOptions;
+    reporters: Array<LoadedPlugin<Reporter>>;
+    constructor(opts: Opts);
+    eventHandler: (arg1: ReporterEvent) => void;
+    report(unsanitisedEvent: ReporterEvent): Promise<void>;
+    dispose(): void;
+}
+export declare function reportWorker(workerApi: WorkerApi, event: ReporterEvent): void;
+export declare function report(event: ReporterEvent): Promise<void>;
+export {};