@atlaspack/core 2.16.2-canary.21 → 2.16.2-canary.211

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

@@ -0,0 +1,27 @@
+import type { ContentKey } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { StaticRunOpts } from '../RequestTracker';
+import { requestTypes } from '../RequestTracker';
+import type { Bundle } from '../types';
+import type BundleGraph from '../BundleGraph';
+import type { BundleInfo } from '../PackagerRunner';
+type PackageRequestInput = {
+    bundleGraph: BundleGraph;
+    bundle: Bundle;
+    bundleGraphReference: SharedReference;
+    optionsRef: SharedReference;
+    useMainThread?: boolean;
+};
+export type PackageRequestResult = BundleInfo;
+type RunInput<TResult> = {
+    input: PackageRequestInput;
+} & StaticRunOpts<TResult>;
+export type PackageRequest = {
+    id: ContentKey;
+    readonly type: typeof requestTypes.package_request;
+    run: (arg1: RunInput<BundleInfo>) => Async<BundleInfo>;
+    input: PackageRequestInput;
+};
+export declare function createPackageRequest(input: PackageRequestInput): PackageRequest;
+export {};

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

@@ -0,0 +1,48 @@
+import type { Diagnostic } from '@atlaspack/diagnostic';
+import type { Async, FileCreateInvalidation, FilePath, Resolver } from '@atlaspack/types';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { AssetGroup, Config, Dependency, DevDepRequest, AtlaspackOptions, DevDepRequestRef } from '../types';
+import PluginOptions from '../public/PluginOptions';
+import { AtlaspackConfig, LoadedPlugin } from '../AtlaspackConfig';
+import { requestTypes } from '../RequestTracker';
+export type PathRequest = {
+    id: string;
+    readonly type: typeof requestTypes.path_request;
+    run: (arg1: RunOpts<PathRequestResult>) => Async<PathRequestResult>;
+    input: PathRequestInput;
+};
+export type PathRequestResult = null | undefined | AssetGroup;
+export type PathRequestInput = {
+    dependency: Dependency;
+    name: string;
+};
+type RunOpts<TResult> = {
+    input: PathRequestInput;
+} & StaticRunOpts<TResult>;
+export default function createPathRequest(input: PathRequestInput): PathRequest;
+type ResolverRunnerOpts = {
+    config: AtlaspackConfig;
+    options: AtlaspackOptions;
+    previousDevDeps: Map<string, string>;
+};
+type ResolverResult = {
+    assetGroup: AssetGroup | null | undefined;
+    invalidateOnFileCreate?: Array<FileCreateInvalidation>;
+    invalidateOnFileChange?: Array<FilePath>;
+    invalidateOnEnvChange?: Array<string>;
+    diagnostics?: Array<Diagnostic>;
+};
+export declare class ResolverRunner {
+    config: AtlaspackConfig;
+    options: AtlaspackOptions;
+    pluginOptions: PluginOptions;
+    previousDevDeps: Map<string, string>;
+    devDepRequests: Map<string, DevDepRequest>;
+    configs: Map<string, Config>;
+    constructor({ config, options, previousDevDeps }: ResolverRunnerOpts);
+    getDiagnostic(dependency: Dependency, message: string): Promise<Async<Diagnostic>>;
+    loadConfigs(resolvers: Array<LoadedPlugin<Resolver<unknown>>>): Promise<void>;
+    runDevDepRequest(devDepRequest: DevDepRequest | DevDepRequestRef): void;
+    resolve(dependency: Dependency): Promise<ResolverResult>;
+}
+export {};

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

@@ -0,0 +1,48 @@
+import type { FileSystem } from '@atlaspack/fs';
+import type { Async, FilePath, PackageJSON, PackageTargetDescriptor, OutputFormat } from '@atlaspack/types';
+import type { StaticRunOpts, RunAPI } from '../RequestTracker';
+import type { Entry, AtlaspackOptions, Target } from '../types';
+import { requestTypes } from '../RequestTracker';
+type RunOpts<TResult> = {
+    input: Entry;
+} & StaticRunOpts<TResult>;
+export type TargetRequest = {
+    id: string;
+    readonly type: typeof requestTypes.target_request;
+    run: (arg1: RunOpts<TargetRequestResult>) => Async<TargetRequestResult>;
+    input: Entry;
+};
+export type TargetRequestResult = Target[];
+export default function createTargetRequest(input: Entry): TargetRequest;
+export declare function skipTarget(targetName: string, exclusiveTarget?: FilePath, descriptorSource?: FilePath | Array<FilePath>): boolean;
+type TargetInfo = {
+    output: TargetKeyInfo;
+    engines: TargetKeyInfo;
+    context: TargetKeyInfo;
+    includeNodeModules: TargetKeyInfo;
+    outputFormat: TargetKeyInfo;
+    isLibrary: TargetKeyInfo;
+    shouldOptimize: TargetKeyInfo;
+    shouldScopeHoist: TargetKeyInfo;
+};
+type TargetKeyInfo = {
+    path: string;
+    type?: 'key' | 'value';
+} | {
+    inferred: string;
+    type?: 'key' | 'value';
+    message: string;
+} | {
+    message: string;
+};
+export declare class TargetResolver {
+    fs: FileSystem;
+    api: RunAPI<Array<Target>>;
+    options: AtlaspackOptions;
+    targetInfo: Map<string, TargetInfo>;
+    constructor(api: RunAPI<Array<Target>>, options: AtlaspackOptions);
+    resolve(rootDir: FilePath, exclusiveTarget?: string): Promise<Array<Target>>;
+    resolvePackageTargets(rootDir: FilePath, exclusiveTarget?: string): Promise<Map<string, Target | null>>;
+    inferOutputFormat(distEntry: FilePath | null | undefined, descriptor: PackageTargetDescriptor, targetName: string, pkg: PackageJSON, pkgFilePath?: FilePath | null, pkgContents?: string | null): [OutputFormat | null | undefined, string | null | undefined];
+}
+export {};

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

@@ -0,0 +1,20 @@
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { AssetGroup } from '../types';
+import { requestTypes } from '../RequestTracker';
+type ValidationRequest = {
+    id: string;
+    readonly type: typeof requestTypes.validation_request;
+    run: (arg1: RunOpts<undefined>) => Async<void>;
+    input: ValidationRequestInput;
+};
+type RunOpts<TResult> = {
+    input: ValidationRequestInput;
+} & StaticRunOpts<TResult>;
+type ValidationRequestInput = {
+    assetRequests: Array<AssetGroup>;
+    optionsRef: SharedReference;
+};
+export default function createValidationRequest(input: ValidationRequestInput): ValidationRequest;
+export {};

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

@@ -0,0 +1,28 @@
+import type { ContentKey } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { StaticRunOpts } from '../RequestTracker';
+import type { Bundle, PackagedBundleInfo } from '../types';
+import type BundleGraph from '../BundleGraph';
+import type { BundleInfo } from '../PackagerRunner';
+import { requestTypes } from '../RequestTracker';
+type WriteBundleRequestInput = {
+    bundleGraph: BundleGraph;
+    bundle: Bundle;
+    info: BundleInfo;
+    hashRefToNameHash: Map<string, string>;
+};
+export type WriteBundleRequestResult = PackagedBundleInfo;
+type RunInput<TResult> = {
+    input: WriteBundleRequestInput;
+} & StaticRunOpts<TResult>;
+export type WriteBundleRequest = {
+    id: ContentKey;
+    readonly type: typeof requestTypes.write_bundle_request;
+    run: (arg1: RunInput<PackagedBundleInfo>) => Async<PackagedBundleInfo>;
+    input: WriteBundleRequestInput;
+};
+/**
+ * Writes a bundle to the dist directory, replacing hash references with the final content hashes.
+ */
+export default function createWriteBundleRequest(input: WriteBundleRequestInput): WriteBundleRequest;
+export {};

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

@@ -0,0 +1,26 @@
+import type { ContentKey } from '@atlaspack/graph';
+import type { Async } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { StaticRunOpts } from '../RequestTracker';
+import { requestTypes } from '../RequestTracker';
+import { type PackagedBundleInfo } from '../types';
+import type BundleGraph from '../BundleGraph';
+type WriteBundlesRequestInput = {
+    bundleGraph: BundleGraph;
+    optionsRef: SharedReference;
+};
+export type WriteBundlesRequestResult = Map<string, PackagedBundleInfo>;
+type RunInput<TResult> = {
+    input: WriteBundlesRequestInput;
+} & StaticRunOpts<TResult>;
+export type WriteBundlesRequest = {
+    id: ContentKey;
+    readonly type: typeof requestTypes.write_bundles_request;
+    run: (arg1: RunInput<WriteBundlesRequestResult>) => Async<WriteBundlesRequestResult>;
+    input: WriteBundlesRequestInput;
+};
+/**
+ * Packages, optimizes, and writes all bundles to the dist directory.
+ */
+export default function createWriteBundlesRequest(input: WriteBundlesRequestInput): WriteBundlesRequest;
+export {};

package/lib/types/requests/asset-graph-diff.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/types/requests/asset-graph-dot.d.ts

@@ -0,0 +1,9 @@
+import AssetGraph from '../AssetGraph';
+export type AssetGraphToDotOptions = {
+    style?: boolean;
+    sort?: boolean;
+};
+/** @description Renders AssetGraph into GraphViz Dot format */
+export declare function assetGraphToDot(assetGraph: AssetGraph, { sort, style }?: AssetGraphToDotOptions): string;
+export declare function getDebugAssetGraphDotPath(): string | null;
+export declare function getDebugAssetGraphDotOptions(): AssetGraphToDotOptions;

package/lib/types/resolveOptions.d.ts

@@ -0,0 +1,3 @@
+import type { InitialAtlaspackOptions } from '@atlaspack/types';
+import type { AtlaspackOptions } from './types';
+export default function resolveOptions(initialOptions: InitialAtlaspackOptions): Promise<AtlaspackOptions>;

package/lib/types/rustWorkerThreadDylibHack.d.ts

@@ -0,0 +1,9 @@
+/**
+ * This is a workaround for https://github.com/rust-lang/rust/issues/91979
+ * when running atlaspack with parcel bindings, it is possible that the parcel
+ * dylib will be loaded from a node worker thread, which causes a crash on exit.
+ *
+ * This is a workaround to ensure that the parcel dylib is loaded in the main
+ * thread, which fixes the crash.
+ */
+export declare function loadRustWorkerThreadDylibHack(): void;

package/lib/types/serializerCore.browser.d.ts

@@ -0,0 +1,3 @@
+import { Buffer } from 'buffer';
+export declare let serializeRaw: (arg1?: any) => Buffer;
+export declare let deserializeRaw: (arg1: Buffer) => any;

package/lib/types/summarizeRequest.d.ts

@@ -0,0 +1,10 @@
+import type { Blob, FilePath } from '@atlaspack/types';
+import type { FileSystem } from '@atlaspack/fs';
+export default function summarizeRequest(fs: FileSystem, req: {
+    filePath: FilePath;
+    code?: string;
+}): Promise<{
+    content: Blob;
+    size: number;
+    isSource: boolean;
+}>;