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

package/lib/types/types.d.ts

@@ -0,0 +1,493 @@
+import type { ContentKey } from '@atlaspack/graph';
+import type { ASTGenerator, BuildMode, Engines, EnvironmentContext, EnvMap, FilePath, Glob, LogLevel, Meta, DependencySpecifier, PackageName, ReporterEvent, SemverRange, ServerOptions, SourceType, Stats, TargetSourceMapOptions, ConfigResult, OutputFormat, TargetDescriptor, HMROptions, DetailedReportOptions, Symbol } from '@atlaspack/types';
+import type { SharedReference } from '@atlaspack/workers';
+import type { FileSystem } from '@atlaspack/fs';
+import type { Cache } from '@atlaspack/cache';
+import type { PackageManager } from '@atlaspack/package-manager';
+import type { ProjectPath } from './projectPath';
+import type { Event } from '@parcel/watcher';
+import type { FeatureFlags } from '@atlaspack/feature-flags';
+import type { BackendType } from '@parcel/watcher';
+import type { EnvironmentRef } from './EnvironmentManager';
+export type SetComplement<A, B extends A> = A extends B ? never : A;
+export type Diff<T extends U, U extends object> = Pick<T, SetComplement<keyof T, keyof U>>;
+export type AtlaspackPluginNode = {
+    packageName: PackageName;
+    resolveFrom: ProjectPath;
+    keyPath?: string;
+};
+export type ParcelPluginNode = AtlaspackPluginNode;
+export type PureAtlaspackConfigPipeline = ReadonlyArray<AtlaspackPluginNode>;
+export type ExtendableAtlaspackConfigPipeline = ReadonlyArray<AtlaspackPluginNode | '...'>;
+export type ProcessedAtlaspackConfig = {
+    resolvers?: PureAtlaspackConfigPipeline;
+    transformers?: Partial<Record<Glob, ExtendableAtlaspackConfigPipeline>>;
+    bundler: ParcelPluginNode | null | undefined;
+    namers?: PureAtlaspackConfigPipeline;
+    runtimes?: PureAtlaspackConfigPipeline;
+    packagers?: Partial<Record<Glob, ParcelPluginNode>>;
+    optimizers?: Partial<Record<Glob, ExtendableAtlaspackConfigPipeline>>;
+    compressors?: Partial<Record<Glob, ExtendableAtlaspackConfigPipeline>>;
+    reporters?: PureAtlaspackConfigPipeline;
+    validators?: Partial<Record<Glob, ExtendableAtlaspackConfigPipeline>>;
+    filePath: ProjectPath;
+    resolveFrom?: ProjectPath;
+};
+export type Environment = {
+    id: string;
+    context: EnvironmentContext;
+    engines: Engines;
+    includeNodeModules: boolean | Array<PackageName> | Partial<Record<PackageName, boolean>>;
+    outputFormat: OutputFormat;
+    sourceType: SourceType;
+    isLibrary: boolean;
+    shouldOptimize: boolean;
+    shouldScopeHoist: boolean;
+    sourceMap: TargetSourceMapOptions | null | undefined;
+    loc: InternalSourceLocation | null | undefined;
+    unstableSingleFileOutput: boolean;
+    customEnv: EnvMap | null | undefined;
+};
+export type InternalSourceLocation = {
+    readonly filePath: ProjectPath;
+    /** inclusive */
+    readonly start: {
+        readonly line: number;
+        readonly column: number;
+    };
+    /** exclusive */
+    readonly end: {
+        readonly line: number;
+        readonly column: number;
+    };
+};
+export type Target = {
+    distEntry?: FilePath | null | undefined;
+    distDir: ProjectPath;
+    env: EnvironmentRef;
+    name: string;
+    publicUrl: string;
+    loc?: InternalSourceLocation | null | undefined;
+    pipeline?: string;
+    source?: FilePath | Array<FilePath>;
+};
+export declare const SpecifierType: {
+    readonly esm: 0;
+    readonly commonjs: 1;
+    readonly url: 2;
+    readonly custom: 3;
+};
+export declare const Priority: {
+    readonly sync: 0;
+    readonly parallel: 1;
+    readonly lazy: 2;
+    readonly conditional: 3;
+};
+export declare const ExportsCondition: {
+    readonly import: number;
+    readonly require: number;
+    readonly module: number;
+    readonly style: number;
+    readonly sass: number;
+    readonly less: number;
+};
+export type Dependency = {
+    id: string;
+    specifier: DependencySpecifier;
+    specifierType: (typeof SpecifierType)[keyof typeof SpecifierType];
+    priority: (typeof Priority)[keyof typeof Priority];
+    needsStableName: boolean;
+    bundleBehavior: (typeof BundleBehavior)[keyof typeof BundleBehavior] | null | undefined;
+    isEntry: boolean;
+    isOptional: boolean;
+    loc: InternalSourceLocation | null | undefined;
+    env: EnvironmentRef;
+    packageConditions?: number;
+    customPackageConditions?: Array<string>;
+    meta: Meta;
+    resolverMeta?: Meta | null | undefined;
+    resolverPriority?: (typeof Priority)[keyof typeof Priority];
+    target: Target | null | undefined;
+    sourceAssetId: string | null | undefined;
+    sourcePath: ProjectPath | null | undefined;
+    sourceAssetType?: string | null | undefined;
+    resolveFrom: ProjectPath | null | undefined;
+    range: SemverRange | null | undefined;
+    symbols: Map<Symbol, {
+        local: Symbol;
+        loc: InternalSourceLocation | null | undefined;
+        isWeak: boolean;
+        meta?: Meta | null | undefined;
+    }> | null | undefined;
+    pipeline?: string | null | undefined;
+};
+export declare const BundleBehavior: {
+    readonly inline: 0;
+    readonly isolated: 1;
+    readonly inlineIsolated: 2;
+};
+export declare const BundleBehaviorNames: Array<keyof typeof BundleBehavior>;
+export type Asset = {
+    id: ContentKey;
+    committed: boolean;
+    filePath: ProjectPath;
+    query: string | null | undefined;
+    type: string;
+    dependencies: Map<string, Dependency>;
+    bundleBehavior: (typeof BundleBehavior)[keyof typeof BundleBehavior] | null | undefined;
+    isBundleSplittable: boolean;
+    isSource: boolean;
+    env: EnvironmentRef;
+    meta: Meta;
+    stats: Stats;
+    contentKey: string | null | undefined;
+    mapKey: string | null | undefined;
+    outputHash: string | null | undefined;
+    pipeline: string | null | undefined;
+    astKey: string | null | undefined;
+    astGenerator: ASTGenerator | null | undefined;
+    symbols: Map<Symbol, {
+        local: Symbol;
+        loc: InternalSourceLocation | null | undefined;
+        meta?: Meta | null | undefined;
+    }> | null | undefined;
+    sideEffects: boolean;
+    uniqueKey: string | null | undefined;
+    configPath?: ProjectPath;
+    plugin: PackageName | null | undefined;
+    configKeyPath?: string;
+    isLargeBlob?: boolean;
+};
+export type InternalGlob = ProjectPath;
+export type InternalFile = {
+    readonly filePath: ProjectPath;
+    readonly hash?: string;
+};
+export type FileInvalidation = {
+    type: 'file';
+    filePath: ProjectPath;
+};
+export type EnvInvalidation = {
+    type: 'env';
+    key: string;
+};
+export type OptionInvalidation = {
+    type: 'option';
+    key: string;
+};
+export type RequestInvalidation = FileInvalidation | EnvInvalidation | OptionInvalidation;
+export type InternalFileInvalidation = {
+    filePath: ProjectPath;
+};
+export type InternalGlobInvalidation = {
+    glob: InternalGlob;
+};
+export type InternalFileAboveInvalidation = {
+    fileName: string;
+    aboveFilePath: ProjectPath;
+};
+export type InternalFileCreateInvalidation = InternalFileInvalidation | InternalGlobInvalidation | InternalFileAboveInvalidation;
+export type Invalidations = {
+    invalidateOnFileChange: Set<ProjectPath>;
+    invalidateOnFileCreate: Array<InternalFileCreateInvalidation>;
+    invalidateOnEnvChange: Set<string>;
+    invalidateOnOptionChange: Set<string>;
+    invalidateOnStartup: boolean;
+    invalidateOnBuild: boolean;
+};
+export type DevDepRequestRef = {
+    type: 'ref';
+    specifier: DependencySpecifier;
+    resolveFrom: ProjectPath;
+    hash: string;
+};
+export type DevDepRequest = {
+    specifier: DependencySpecifier;
+    resolveFrom: ProjectPath;
+    hash: string;
+    invalidateOnFileCreate: Array<InternalFileCreateInvalidation>;
+    invalidateOnFileChange: Set<ProjectPath>;
+    invalidateOnStartup: boolean;
+    additionalInvalidations?: Array<{
+        specifier: DependencySpecifier;
+        resolveFrom: ProjectPath;
+        range?: SemverRange | null | undefined;
+    }>;
+};
+declare type GlobPattern = string;
+export type AtlaspackOptions = {
+    entries: Array<ProjectPath>;
+    config?: DependencySpecifier;
+    defaultConfig?: DependencySpecifier;
+    env: EnvMap;
+    parcelVersion: string;
+    targets: Array<string> | {
+        readonly [key: string]: TargetDescriptor;
+    } | null | undefined;
+    shouldDisableCache: boolean;
+    cacheDir: FilePath;
+    watchDir: FilePath;
+    watchIgnore?: Array<FilePath | GlobPattern>;
+    watchBackend?: BackendType;
+    mode: BuildMode;
+    hmrOptions: HMROptions | null | undefined;
+    shouldContentHash: boolean;
+    serveOptions: ServerOptions | false;
+    shouldBuildLazily: boolean;
+    lazyIncludes: RegExp[];
+    lazyExcludes: RegExp[];
+    shouldBundleIncrementally: boolean;
+    shouldAutoInstall: boolean;
+    logLevel: LogLevel;
+    projectRoot: FilePath;
+    shouldProfile: boolean;
+    shouldTrace: boolean;
+    shouldPatchConsole: boolean;
+    detailedReport?: DetailedReportOptions | null | undefined;
+    unstableFileInvalidations?: Array<Event>;
+    inputFS: FileSystem;
+    outputFS: FileSystem;
+    cache: Cache;
+    packageManager: PackageManager;
+    additionalReporters: Array<{
+        packageName: DependencySpecifier;
+        resolveFrom: ProjectPath;
+    }>;
+    instanceId: string;
+    readonly defaultTargetOptions: {
+        readonly shouldOptimize: boolean;
+        readonly shouldScopeHoist?: boolean;
+        readonly sourceMaps: boolean;
+        readonly publicUrl: string;
+        readonly distDir?: ProjectPath;
+        readonly engines?: Engines;
+        readonly outputFormat?: OutputFormat;
+        readonly isLibrary?: boolean;
+    };
+    readonly featureFlags: FeatureFlags;
+};
+export type ParcelOptions = AtlaspackOptions;
+export type AssetNode = {
+    id: ContentKey;
+    readonly type: 'asset';
+    value: Asset;
+    usedSymbols: Set<Symbol>;
+    hasDeferred?: boolean;
+    usedSymbolsDownDirty: boolean;
+    usedSymbolsUpDirty: boolean;
+    requested?: boolean;
+};
+export type DependencyNode = {
+    id: ContentKey;
+    type: 'dependency';
+    value: Dependency;
+    complete?: boolean;
+    correspondingRequest?: string;
+    deferred: boolean;
+    /** dependency was deferred (= no used symbols (in immediate parents) & side-effect free) */
+    hasDeferred?: boolean;
+    usedSymbolsDown: Set<Symbol>;
+    /**
+     * a requested symbol -> either
+     *  - if ambiguous (e.g. dependency to asset group with both CSS modules and JS asset): undefined
+     *  - if external: null
+     *  - the asset it resolved to, and the potentially renamed export name
+     */
+    usedSymbolsUp: Map<Symbol, {
+        asset: ContentKey;
+        symbol: Symbol | null | undefined;
+    } | undefined | null>;
+    usedSymbolsDownDirty: boolean;
+    /**
+     * In the down pass, `usedSymbolsDown` changed. This needs to be propagated to the resolutionAsset
+     * in the up pass.
+     */
+    usedSymbolsUpDirtyDown: boolean;
+    /**
+     * In the up pass, `usedSymbolsUp` changed. This needs to be propagated to the sourceAsset in the
+     * up pass.
+     */
+    usedSymbolsUpDirtyUp: boolean;
+    /** dependency was excluded (= no used symbols (globally) & side-effect free) */
+    excluded: boolean;
+};
+export type RootNode = {
+    id: ContentKey;
+    readonly type: 'root';
+    value: string | null;
+};
+export type AssetRequestInput = {
+    name?: string;
+    filePath: ProjectPath;
+    env: EnvironmentRef;
+    isSource?: boolean;
+    canDefer?: boolean;
+    sideEffects?: boolean;
+    runtimeAssetRequiringExecutionOnLoad?: boolean;
+    code?: string;
+    pipeline?: string | null | undefined;
+    optionsRef: SharedReference;
+    isURL?: boolean;
+    query?: string | null | undefined;
+    isSingleChangeRebuild?: boolean;
+};
+export type AssetRequestResult = Array<Asset>;
+export type AssetGroup = Partial<Diff<AssetRequestInput, {
+    optionsRef: SharedReference;
+}>>;
+export type AssetGroupNode = {
+    id: ContentKey;
+    readonly type: 'asset_group';
+    value: AssetGroup;
+    correspondingRequest?: string;
+    /** this node was deferred (= no used symbols (in immediate parents) & side-effect free) */
+    deferred?: boolean;
+    hasDeferred?: boolean;
+    usedSymbolsDownDirty: boolean;
+};
+export type TransformationRequest = AssetGroup & {
+    invalidateReason: number;
+    devDeps: Map<PackageName, string>;
+    invalidDevDeps: Array<{
+        specifier: DependencySpecifier;
+        resolveFrom: ProjectPath;
+    }>;
+};
+export type DepPathRequestNode = {
+    id: ContentKey;
+    readonly type: 'dep_path_request';
+    value: Dependency;
+};
+export type AssetRequestNode = {
+    id: ContentKey;
+    readonly type: 'asset_request';
+    value: AssetRequestInput;
+};
+export type EntrySpecifierNode = {
+    id: ContentKey;
+    readonly type: 'entry_specifier';
+    value: ProjectPath;
+    correspondingRequest?: string;
+};
+export type Entry = {
+    filePath: ProjectPath;
+    packagePath: ProjectPath;
+    target?: string;
+    loc?: InternalSourceLocation | null | undefined;
+};
+export type EntryFileNode = {
+    id: ContentKey;
+    readonly type: 'entry_file';
+    value: Entry;
+    correspondingRequest?: string;
+};
+export type AssetGraphNode = AssetGroupNode | AssetNode | DependencyNode | EntrySpecifierNode | EntryFileNode | RootNode;
+export type BundleGraphNode = AssetNode | DependencyNode | EntrySpecifierNode | EntryFileNode | RootNode | BundleGroupNode | BundleNode;
+export type InternalDevDepOptions = {
+    specifier: DependencySpecifier;
+    resolveFrom: ProjectPath;
+    range?: SemverRange | null | undefined;
+    additionalInvalidations?: Array<{
+        specifier: DependencySpecifier;
+        resolveFrom: ProjectPath;
+        range?: SemverRange | null | undefined;
+    }>;
+};
+export type Config = {
+    id: string;
+    isSource: boolean;
+    searchPath: ProjectPath;
+    env: EnvironmentRef;
+    cacheKey: string | null | undefined;
+    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 type EntryRequest = {
+    specifier: DependencySpecifier;
+    result?: ProjectPath;
+};
+export type EntryRequestNode = {
+    id: ContentKey;
+    readonly type: 'entry_request';
+    value: string;
+};
+export type TargetRequestNode = {
+    id: ContentKey;
+    readonly type: 'target_request';
+    value: ProjectPath;
+};
+export type CacheEntry = {
+    filePath: ProjectPath;
+    env: Environment;
+    hash: string;
+    assets: Array<Asset>;
+    initialAssets: Array<Asset> | null | undefined;
+};
+export type Bundle = {
+    id: ContentKey;
+    publicId: string | null | undefined;
+    hashReference: string;
+    type: string;
+    env: EnvironmentRef;
+    entryAssetIds: Array<ContentKey>;
+    mainEntryId: ContentKey | null | undefined;
+    needsStableName: boolean | null | undefined;
+    bundleBehavior: (typeof BundleBehavior)[keyof typeof BundleBehavior] | null | undefined;
+    isSplittable: boolean | null | undefined;
+    isPlaceholder?: boolean;
+    target: Target;
+    name: string | null | undefined;
+    displayName: string | null | undefined;
+    pipeline: string | null | undefined;
+    manualSharedBundle?: string | null | undefined;
+    conditions?: Map<string, string>;
+};
+export type BundleNode = {
+    id: ContentKey;
+    readonly type: 'bundle';
+    value: Bundle;
+};
+export type BundleGroup = {
+    target: Target;
+    entryAssetId: string;
+};
+export type BundleGroupNode = {
+    id: ContentKey;
+    readonly type: 'bundle_group';
+    value: BundleGroup;
+};
+export type PackagedBundleInfo = {
+    filePath: ProjectPath;
+    bundleId: ContentKey;
+    type: string;
+    stats: Stats;
+};
+export type TransformationOpts = {
+    request: AssetGroup;
+    optionsRef: SharedReference;
+    configCachePath: string;
+};
+export type ValidationOpts = {
+    requests: AssetGroup[];
+    optionsRef: SharedReference;
+    configCachePath: string;
+};
+export type ReportFn = (event: ReporterEvent) => undefined | Promise<undefined>;
+export type Condition = {
+    publicId: string;
+    assets: Set<Asset>;
+    key: string;
+    ifTrueDependency: Dependency;
+    ifFalseDependency: Dependency;
+};
+export {};

package/lib/types/utils.d.ts

@@ -0,0 +1,23 @@
+import type { FilePath, FileCreateInvalidation, SourceLocation } from '@atlaspack/types';
+import type { BundleGroup, AtlaspackOptions, InternalFileCreateInvalidation, InternalSourceLocation, InternalDevDepOptions, Invalidations } from './types';
+export type SetComplement<A, B extends A> = A extends B ? never : A;
+export type Diff<T extends U, U extends object> = Pick<T, SetComplement<keyof T, keyof U>>;
+export declare function getBundleGroupId(bundleGroup: BundleGroup): string;
+export declare function assertSignalNotAborted(signal?: AbortSignal | null): void;
+export declare class BuildAbortError extends Error {
+    name: string;
+}
+export declare function getPublicId(id: string, alreadyExists: (arg1: string) => boolean): string;
+export declare function optionsProxy(options: AtlaspackOptions, invalidateOnOptionChange: (arg1: string) => void, addDevDependency?: (devDep: InternalDevDepOptions) => void): AtlaspackOptions;
+export declare function hashFromOption(value: unknown): string;
+export declare function invalidateOnFileCreateToInternal(projectRoot: FilePath, invalidation: FileCreateInvalidation): InternalFileCreateInvalidation;
+export declare function createInvalidations(): Invalidations;
+export declare function fromInternalSourceLocation(projectRoot: FilePath, loc?: InternalSourceLocation | null): SourceLocation | null | undefined;
+export declare function toInternalSourceLocation(projectRoot: FilePath, loc?: SourceLocation | null): InternalSourceLocation | null | undefined;
+export declare function toInternalSymbols<T extends {
+    loc: SourceLocation | null | undefined;
+}>(projectRoot: FilePath, symbols?: Map<symbol, T> | null): Map<symbol, {
+    loc: InternalSourceLocation | null | undefined;
+} & Partial<Diff<T, {
+    loc: SourceLocation | null | undefined;
+}>>> | null | undefined;

package/lib/types/worker.d.ts

@@ -0,0 +1,44 @@
+import type { Bundle, AtlaspackOptions, RequestInvalidation } from './types';
+import type { SharedReference, WorkerApi } from '@atlaspack/workers';
+import type { DevDepSpecifier } from './requests/DevDepRequest';
+import { TransformationOpts, TransformationResult } from './Transformation';
+import { RunPackagerRunnerResult } from './PackagerRunner';
+import { ValidationOpts } from './Validation';
+import '@atlaspack/cache';
+import '@atlaspack/package-manager';
+import '@atlaspack/fs';
+export type SetComplement<A, B extends A> = A extends B ? never : A;
+export type Diff<T extends U, U extends object> = Pick<T, SetComplement<keyof T, keyof U>>;
+type WorkerTransformationOpts = Diff<TransformationOpts, {
+    workerApi: unknown;
+    options: AtlaspackOptions;
+}> & {
+    optionsRef: SharedReference;
+    configCachePath: string;
+};
+type WorkerValidationOpts = Diff<ValidationOpts, {
+    workerApi: unknown;
+    options: AtlaspackOptions;
+}> & {
+    optionsRef: SharedReference;
+    configCachePath: string;
+};
+export declare function clearWorkerBuildCaches(): void;
+export declare function runTransform(workerApi: WorkerApi, opts: WorkerTransformationOpts): Promise<TransformationResult>;
+export declare function runValidate(workerApi: WorkerApi, opts: WorkerValidationOpts): Promise<void>;
+export declare function runPackage(workerApi: WorkerApi, { bundle, bundleGraphReference, configCachePath, optionsRef, previousDevDeps, invalidDevDeps, previousInvalidations, }: {
+    bundle: Bundle;
+    bundleGraphReference: SharedReference;
+    configCachePath: string;
+    optionsRef: SharedReference;
+    previousDevDeps: Map<string, string>;
+    invalidDevDeps: Array<DevDepSpecifier>;
+    previousInvalidations: Array<RequestInvalidation>;
+}): Promise<RunPackagerRunnerResult>;
+export declare function childInit(): Promise<void>;
+export declare function invalidateRequireCache(workerApi: WorkerApi, file: string): void;
+/**
+ * This is used to wait until workers are responding to messages.
+ */
+export declare function ping(): boolean;
+export {};

package/lib/types.js

@@ -4,6 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SpecifierType = exports.Priority = exports.ExportsCondition = exports.BundleBehaviorNames = exports.BundleBehavior = void 0;
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
 const SpecifierType = exports.SpecifierType = {
   esm: 0,
   commonjs: 1,
@@ -28,8 +32,11 @@ const ExportsCondition = exports.ExportsCondition = {
 };
 const BundleBehavior = exports.BundleBehavior = {
   inline: 0,
-  isolated: 1
+  isolated: 1,
+  inlineIsolated: 2
 };
+
+// @ts-expect-error TS2322
 const BundleBehaviorNames = exports.BundleBehaviorNames = Object.keys(BundleBehavior);
 
 // Asset group nodes are essentially used as placeholders for the results of an asset request

package/lib/utils.js

@@ -37,6 +37,10 @@ function _utils() {
 }
 var _projectPath = require("./projectPath");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// flow-to-ts helpers
+
+// /flow-to-ts helpers
+
 const base62 = (0, _baseX().default)('0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ');
 function getBundleGroupId(bundleGroup) {
   return 'bundle_group:' + bundleGroup.target.name + bundleGroup.entryAssetId;
@@ -75,6 +79,8 @@ function optionsProxy(options, invalidateOnOptionChange, addDevDependency) {
       if (!ignoreOptions.has(prop)) {
         invalidateOnOptionChange(prop);
       }
+
+      // @ts-expect-error TS7053
       return target[prop];
     }
   });
@@ -94,30 +100,39 @@ function proxyPackageManager(projectRoot, packageManager, addDevDependency) {
         return require;
       }
 
-      // $FlowFixMe
+      // @ts-expect-error TS7053
       return target[prop];
     }
   });
 }
 function hashFromOption(value) {
   if (typeof value === 'object' && value != null) {
+    // @ts-expect-error TS2345
     return (0, _utils().hashObject)(value);
   }
   return String(value);
 }
 function invalidateOnFileCreateToInternal(projectRoot, invalidation) {
+  // @ts-expect-error TS2339
   if (invalidation.glob != null) {
+    // @ts-expect-error TS2339
     return {
       glob: (0, _projectPath.toProjectPath)(projectRoot, invalidation.glob)
     };
+    // @ts-expect-error TS2339
   } else if (invalidation.filePath != null) {
     return {
+      // @ts-expect-error TS2339
       filePath: (0, _projectPath.toProjectPath)(projectRoot, invalidation.filePath)
     };
   } else {
-    (0, _assert().default)(invalidation.aboveFilePath != null && invalidation.fileName != null);
+    (0, _assert().default)(
+    // @ts-expect-error TS2339
+    invalidation.aboveFilePath != null && invalidation.fileName != null);
     return {
+      // @ts-expect-error TS2339
       fileName: invalidation.fileName,
+      // @ts-expect-error TS2339
       aboveFilePath: (0, _projectPath.toProjectPath)(projectRoot, invalidation.aboveFilePath)
     };
   }