astro-ghostcms/.pnpm-store/v3/files/86/d44ab35f54c594af54f1b793aca...

713 lines
16 KiB
Plaintext
Raw Permalink Normal View History

2024-02-14 14:10:47 +00:00
/*
* This file was automatically generated.
* DO NOT MODIFY BY HAND.
* Run `yarn special-lint-fix` to update
*/
import { Dirent } from "fs";
import { AsyncSeriesBailHook, AsyncSeriesHook, SyncHook } from "tapable";
type Alias = string | false | string[];
declare interface AliasOption {
alias: Alias;
name: string;
onlyModule?: boolean;
}
type AliasOptionNewRequest = string | false | string[];
declare interface AliasOptions {
[index: string]: AliasOptionNewRequest;
}
declare interface BaseResolveRequest {
path: string | false;
context?: object;
descriptionFilePath?: string;
descriptionFileRoot?: string;
descriptionFileData?: JsonObject;
relativePath?: string;
ignoreSymlinks?: boolean;
fullySpecified?: boolean;
__innerRequest?: string;
__innerRequest_request?: string;
__innerRequest_relativePath?: string;
}
declare class CachedInputFileSystem {
constructor(fileSystem: any, duration: number);
fileSystem: any;
lstat?: {
(arg0: string, arg1: FileSystemCallback<FileSystemStats>): void;
(
arg0: string,
arg1: object,
arg2: FileSystemCallback<string | Buffer>
): void;
};
lstatSync?: (arg0: string, arg1?: object) => FileSystemStats;
stat: {
(arg0: string, arg1: FileSystemCallback<FileSystemStats>): void;
(
arg0: string,
arg1: object,
arg2: FileSystemCallback<string | Buffer>
): void;
};
statSync: (arg0: string, arg1?: object) => FileSystemStats;
readdir: (
arg0: string,
arg1?:
| null
| ((
arg0?: null | NodeJS.ErrnoException,
arg1?: (string | Buffer)[] | Dirent[]
) => void)
| ReaddirOptions
| "ascii"
| "utf8"
| "utf-8"
| "utf16le"
| "ucs2"
| "ucs-2"
| "base64"
| "base64url"
| "latin1"
| "binary"
| "hex"
| "buffer",
arg2?: (
arg0?: null | NodeJS.ErrnoException,
arg1?: (string | Buffer)[] | Dirent[]
) => void
) => void;
readdirSync: (
arg0: string,
arg1?: object
) => (string | Buffer)[] | FileSystemDirent[];
readFile: {
(arg0: string, arg1: FileSystemCallback<string | Buffer>): void;
(
arg0: string,
arg1: object,
arg2: FileSystemCallback<string | Buffer>
): void;
};
readFileSync: (arg0: string, arg1?: object) => string | Buffer;
readJson?: {
(arg0: string, arg1: FileSystemCallback<object>): void;
(arg0: string, arg1: object, arg2: FileSystemCallback<object>): void;
};
readJsonSync?: (arg0: string, arg1?: object) => object;
readlink: {
(arg0: string, arg1: FileSystemCallback<string | Buffer>): void;
(
arg0: string,
arg1: object,
arg2: FileSystemCallback<string | Buffer>
): void;
};
readlinkSync: (arg0: string, arg1?: object) => string | Buffer;
purge(what?: string | Set<string> | string[]): void;
}
declare class CloneBasenamePlugin {
constructor(
source:
| string
| AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>,
target:
| string
| AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>
);
source:
| string
| AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>;
target:
| string
| AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>;
apply(resolver: Resolver): void;
}
type ErrorWithDetail = Error & { details?: string };
declare interface ExtensionAliasOption {
alias: string | string[];
extension: string;
}
declare interface ExtensionAliasOptions {
[index: string]: string | string[];
}
declare interface FileSystem {
readFile: {
(arg0: string, arg1: FileSystemCallback<string | Buffer>): void;
(
arg0: string,
arg1: object,
arg2: FileSystemCallback<string | Buffer>
): void;
};
readdir: (
arg0: string,
arg1?:
| null
| ((
arg0?: null | NodeJS.ErrnoException,
arg1?: (string | Buffer)[] | Dirent[]
) => void)
| ReaddirOptions
| "ascii"
| "utf8"
| "utf-8"
| "utf16le"
| "ucs2"
| "ucs-2"
| "base64"
| "base64url"
| "latin1"
| "binary"
| "hex"
| "buffer",
arg2?: (
arg0?: null | NodeJS.ErrnoException,
arg1?: (string | Buffer)[] | Dirent[]
) => void
) => void;
readJson?: {
(arg0: string, arg1: FileSystemCallback<object>): void;
(arg0: string, arg1: object, arg2: FileSystemCallback<object>): void;
};
readlink: {
(arg0: string, arg1: FileSystemCallback<string | Buffer>): void;
(
arg0: string,
arg1: object,
arg2: FileSystemCallback<string | Buffer>
): void;
};
lstat?: {
(arg0: string, arg1: FileSystemCallback<FileSystemStats>): void;
(
arg0: string,
arg1: object,
arg2: FileSystemCallback<string | Buffer>
): void;
};
stat: {
(arg0: string, arg1: FileSystemCallback<FileSystemStats>): void;
(
arg0: string,
arg1: object,
arg2: FileSystemCallback<string | Buffer>
): void;
};
}
declare interface FileSystemCallback<T> {
(err?: null | (PossibleFileSystemError & Error), result?: T): any;
}
declare interface FileSystemDirent {
name: string | Buffer;
isDirectory: () => boolean;
isFile: () => boolean;
}
declare interface FileSystemStats {
isDirectory: () => boolean;
isFile: () => boolean;
}
declare interface Iterator<T, Z> {
(
item: T,
callback: (err?: null | Error, result?: null | Z) => void,
i: number
): void;
}
type JsonObject = { [index: string]: JsonValue } & {
[index: string]:
| undefined
| null
| string
| number
| boolean
| JsonObject
| JsonValue[];
};
type JsonValue = null | string | number | boolean | JsonObject | JsonValue[];
declare interface KnownHooks {
resolveStep: SyncHook<
[
AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>,
ResolveRequest
]
>;
noResolve: SyncHook<[ResolveRequest, Error]>;
resolve: AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>;
result: AsyncSeriesHook<[ResolveRequest, ResolveContext]>;
}
declare class LogInfoPlugin {
constructor(
source:
| string
| AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>
);
source:
| string
| AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>;
apply(resolver: Resolver): void;
}
declare interface ParsedIdentifier {
request: string;
query: string;
fragment: string;
directory: boolean;
module: boolean;
file: boolean;
internal: boolean;
}
type Plugin =
| undefined
| null
| false
| ""
| 0
| { apply: (arg0: Resolver) => void }
| ((this: Resolver, arg1: Resolver) => void);
declare interface PnpApiImpl {
resolveToUnqualified: (arg0: string, arg1: string, arg2: object) => string;
}
declare interface PossibleFileSystemError {
code?: string;
errno?: number;
path?: string;
syscall?: string;
}
declare interface ReaddirOptions {
encoding?:
| null
| "ascii"
| "utf8"
| "utf-8"
| "utf16le"
| "ucs2"
| "ucs-2"
| "base64"
| "base64url"
| "latin1"
| "binary"
| "hex"
| "buffer";
withFileTypes?: boolean;
}
/**
* Resolve context
*/
declare interface ResolveContext {
contextDependencies?: WriteOnlySet<string>;
/**
* files that was found on file system
*/
fileDependencies?: WriteOnlySet<string>;
/**
* dependencies that was not found on file system
*/
missingDependencies?: WriteOnlySet<string>;
/**
* set of hooks' calls. For instance, `resolve → parsedResolve → describedResolve`,
*/
stack?: Set<string>;
/**
* log function
*/
log?: (arg0: string) => void;
/**
* yield result, if provided plugins can return several results
*/
yield?: (arg0: ResolveRequest) => void;
}
declare interface ResolveFunction {
(context: object, path: string, request: string): string | false;
(path: string, request: string): string | false;
}
declare interface ResolveFunctionAsync {
(
context: object,
path: string,
request: string,
resolveContext: ResolveContext,
callback: (
err: null | ErrorWithDetail,
res?: string | false,
req?: ResolveRequest
) => void
): void;
(
context: object,
path: string,
request: string,
callback: (
err: null | ErrorWithDetail,
res?: string | false,
req?: ResolveRequest
) => void
): void;
(
path: string,
request: string,
resolveContext: ResolveContext,
callback: (
err: null | ErrorWithDetail,
res?: string | false,
req?: ResolveRequest
) => void
): void;
(
path: string,
request: string,
callback: (
err: null | ErrorWithDetail,
res?: string | false,
req?: ResolveRequest
) => void
): void;
}
declare interface ResolveOptions {
alias: AliasOption[];
fallback: AliasOption[];
aliasFields: Set<string | string[]>;
extensionAlias: ExtensionAliasOption[];
cachePredicate: (arg0: ResolveRequest) => boolean;
cacheWithContext: boolean;
/**
* A list of exports field condition names.
*/
conditionNames: Set<string>;
descriptionFiles: string[];
enforceExtension: boolean;
exportsFields: Set<string | string[]>;
importsFields: Set<string | string[]>;
extensions: Set<string>;
fileSystem: FileSystem;
unsafeCache: false | object;
symlinks: boolean;
resolver?: Resolver;
modules: (string | string[])[];
mainFields: { name: string[]; forceRelative: boolean }[];
mainFiles: Set<string>;
plugins: Plugin[];
pnpApi: null | PnpApiImpl;
roots: Set<string>;
fullySpecified: boolean;
resolveToContext: boolean;
restrictions: Set<string | RegExp>;
preferRelative: boolean;
preferAbsolute: boolean;
}
type ResolveOptionsOptionalFS = Omit<UserResolveOptions, "fileSystem"> &
Partial<Pick<UserResolveOptions, "fileSystem">>;
type ResolveRequest = BaseResolveRequest & Partial<ParsedIdentifier>;
declare abstract class Resolver {
fileSystem: FileSystem;
options: ResolveOptions;
hooks: KnownHooks;
ensureHook(
name:
| string
| AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>
): AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>;
getHook(
name:
| string
| AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>
): AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>;
resolveSync(context: object, path: string, request: string): string | false;
resolve(
context: object,
path: string,
request: string,
resolveContext: ResolveContext,
callback: (
err: null | ErrorWithDetail,
res?: string | false,
req?: ResolveRequest
) => void
): void;
doResolve(
hook: AsyncSeriesBailHook<
[ResolveRequest, ResolveContext],
null | ResolveRequest
>,
request: ResolveRequest,
message: null | string,
resolveContext: ResolveContext,
callback: (err?: null | Error, result?: ResolveRequest) => void
): void;
parse(identifier: string): ParsedIdentifier;
isModule(path: string): boolean;
isPrivate(path: string): boolean;
isDirectory(path: string): boolean;
join(path: string, request: string): string;
normalize(path: string): string;
}
declare interface UserResolveOptions {
/**
* A list of module alias configurations or an object which maps key to value
*/
alias?: AliasOptions | AliasOption[];
/**
* A list of module alias configurations or an object which maps key to value, applied only after modules option
*/
fallback?: AliasOptions | AliasOption[];
/**
* An object which maps extension to extension aliases
*/
extensionAlias?: ExtensionAliasOptions;
/**
* A list of alias fields in description files
*/
aliasFields?: (string | string[])[];
/**
* A function which decides whether a request should be cached or not. An object is passed with at least `path` and `request` properties.
*/
cachePredicate?: (arg0: ResolveRequest) => boolean;
/**
* Whether or not the unsafeCache should include request context as part of the cache key.
*/
cacheWithContext?: boolean;
/**
* A list of description files to read from
*/
descriptionFiles?: string[];
/**
* A list of exports field condition names.
*/
conditionNames?: string[];
/**
* Enforce that a extension from extensions must be used
*/
enforceExtension?: boolean;
/**
* A list of exports fields in description files
*/
exportsFields?: (string | string[])[];
/**
* A list of imports fields in description files
*/
importsFields?: (string | string[])[];
/**
* A list of extensions which should be tried for files
*/
extensions?: string[];
/**
* The file system which should be used
*/
fileSystem: FileSystem;
/**
* Use this cache object to unsafely cache the successful requests
*/
unsafeCache?: boolean | object;
/**
* Resolve symlinks to their symlinked location
*/
symlinks?: boolean;
/**
* A prepared Resolver to which the plugins are attached
*/
resolver?: Resolver;
/**
* A list of directories to resolve modules from, can be absolute path or folder name
*/
modules?: string | string[];
/**
* A list of main fields in description files
*/
mainFields?: (
| string
| string[]
| { name: string | string[]; forceRelative: boolean }
)[];
/**
* A list of main files in directories
*/
mainFiles?: string[];
/**
* A list of additional resolve plugins which should be applied
*/
plugins?: Plugin[];
/**
* A PnP API that should be used - null is "never", undefined is "auto"
*/
pnpApi?: null | PnpApiImpl;
/**
* A list of root paths
*/
roots?: string[];
/**
* The request is already fully specified and no extensions or directories are resolved for it
*/
fullySpecified?: boolean;
/**
* Resolve to a context instead of a file
*/
resolveToContext?: boolean;
/**
* A list of resolve restrictions
*/
restrictions?: (string | RegExp)[];
/**
* Use only the sync constraints of the file system calls
*/
useSyncFileSystemCalls?: boolean;
/**
* Prefer to resolve module requests as relative requests before falling back to modules
*/
preferRelative?: boolean;
/**
* Prefer to resolve server-relative urls as absolute paths before falling back to resolve in roots
*/
preferAbsolute?: boolean;
}
declare interface WriteOnlySet<T> {
add: (item: T) => void;
}
declare function exports(
context: object,
path: string,
request: string,
resolveContext: ResolveContext,
callback: (
err: null | ErrorWithDetail,
res?: string | false,
req?: ResolveRequest
) => void
): void;
declare function exports(
context: object,
path: string,
request: string,
callback: (
err: null | ErrorWithDetail,
res?: string | false,
req?: ResolveRequest
) => void
): void;
declare function exports(
path: string,
request: string,
resolveContext: ResolveContext,
callback: (
err: null | ErrorWithDetail,
res?: string | false,
req?: ResolveRequest
) => void
): void;
declare function exports(
path: string,
request: string,
callback: (
err: null | ErrorWithDetail,
res?: string | false,
req?: ResolveRequest
) => void
): void;
declare namespace exports {
export const sync: ResolveFunction;
export function create(
options: ResolveOptionsOptionalFS
): ResolveFunctionAsync;
export namespace create {
export const sync: (options: ResolveOptionsOptionalFS) => ResolveFunction;
}
export namespace ResolverFactory {
export let createResolver: (options: UserResolveOptions) => Resolver;
}
export const forEachBail: <T, Z>(
array: T[],
iterator: Iterator<T, Z>,
callback: (err?: null | Error, result?: null | Z) => void
) => void;
export type ResolveCallback = (
err: null | ErrorWithDetail,
res?: string | false,
req?: ResolveRequest
) => void;
export {
CachedInputFileSystem,
CloneBasenamePlugin,
LogInfoPlugin,
ResolveOptionsOptionalFS,
PnpApiImpl as PnpApi,
Resolver,
FileSystem,
ResolveContext,
ResolveRequest,
Plugin,
UserResolveOptions as ResolveOptions,
ResolveFunctionAsync,
ResolveFunction
};
}
export = exports;