xhs-mp-pack 1.1.0-beta.0

package/dist/module/Module.d.ts

@@ -0,0 +1,175 @@
+import ChunkGraph from '@/chunk/ChunkGraph';
+import DependenciesBlock from '@/dependencies/DependenciesBlock';
+import DependencyTemplates from '@/dependencies/DependencyTemplates';
+import RuntimeTemplate from '@/template/RuntimeTemplate';
+import { RuntimeSpec } from '@/module/RuntimeHelpers';
+import Hash from '@/base/Hash';
+import RequestShortener from '@/base/RequestShortener';
+import LazySet from '@/base/LazySet';
+import BaseError from '@/base/errors/BaseError';
+import { ResolveOptions } from 'enhanced-resolve';
+import ConcatenationScope from '../ConcatenationScope';
+import CodeGenerationResults from '../chunk/CodeGenerationResults';
+import Compilation from '../Compilation';
+import { FileSystemInfo } from '../FileSystemInfo';
+import Chunk from '../chunk/Chunk';
+import Dependency from '../dependencies/Dependency';
+import ModuleGraph from './ModuleGraph';
+export interface SourceContext {
+    dependencyTemplates: DependencyTemplates;
+    runtimeTemplate: RuntimeTemplate;
+    moduleGraph: ModuleGraph;
+    chunkGraph: ChunkGraph;
+    runtime: RuntimeSpec;
+    type?: string;
+}
+interface CodeGenerationContext {
+    dependencyTemplates?: DependencyTemplates;
+    runtimeTemplate: RuntimeTemplate;
+    moduleGraph: ModuleGraph;
+    chunkGraph: ChunkGraph;
+    runtime: RuntimeSpec;
+    concatenationScope?: ConcatenationScope;
+    codeGenerationResults?: CodeGenerationResults;
+    compilation?: Compilation;
+    sourceTypes?: ReadonlySet<string>;
+}
+interface KnownBuildMeta {
+    moduleArgument?: string;
+    exportsArgument?: string;
+    strict?: boolean;
+    moduleConcatenationBailout?: string;
+    exportsType?: 'default' | 'namespace' | 'flagged' | 'dynamic';
+    defaultObject?: false | 'redirect' | 'redirect-warn';
+    strictHarmonyModule?: boolean;
+    async?: boolean;
+    sideEffectFree?: boolean;
+}
+interface NeedBuildContext {
+    compilation: Compilation;
+    fileSystemInfo: FileSystemInfo;
+    valueCacheVersions: Map<string, string | Set<string>>;
+}
+type BuildMeta = KnownBuildMeta & Record<string, any>;
+type BuildInfo = Record<string, any>;
+interface FactoryMeta {
+    sideEffectFree?: boolean;
+}
+declare class Module extends DependenciesBlock {
+    type: any;
+    context: string | null;
+    layer: string | null;
+    needId: boolean;
+    debugId: number;
+    resolveOptions: ResolveOptions | undefined;
+    factoryMeta: FactoryMeta | undefined;
+    useSourceMap: boolean;
+    useSimpleSourceMap: boolean;
+    _warnings: BaseError[];
+    _errors: BaseError[];
+    buildMeta: BuildMeta;
+    buildInfo: BuildInfo;
+    presentationalDependencies: Dependency[];
+    codeGenerationDependencies: Dependency[];
+    constructor(type: any, context?: string | null, layer?: string | null);
+    get id(): any;
+    set id(value: any);
+    get hash(): any;
+    get renderedHash(): any;
+    get profile(): any;
+    set profile(value: any);
+    get index(): any;
+    set index(value: any);
+    get index2(): any;
+    set index2(value: any);
+    get depth(): any;
+    set depth(value: any);
+    get issuer(): any;
+    set issuer(value: any);
+    get usedExports(): any;
+    get optimizationBailout(): any;
+    get optional(): boolean;
+    addChunk(chunk: Chunk): boolean;
+    removeChunk(chunk: any): any;
+    isInChunk(chunk: any): any;
+    isEntryModule(): any;
+    getChunks(): any;
+    getNumberOfChunks(): any;
+    get chunksIterable(): any;
+    isProvided(exportName: string): any;
+    get exportsArgument(): any;
+    get moduleArgument(): any;
+    /**
+     * "namespace": Exports is already a namespace object. namespace = exports.
+     * "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }.
+     * "default-only": Provide a namespace object with only default export. namespace = { default: exports }
+     * "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }
+     */
+    getExportsType(moduleGraph: ModuleGraph, strict?: boolean): "namespace" | "dynamic" | "default-with-named" | "default-only";
+    addPresentationalDependency(presentationalDependency: Dependency): void;
+    addCodeGenerationDependency(codeGenerationDependency: Dependency): void;
+    clearDependenciesAndBlocks(): void;
+    addWarning(warning: any): void;
+    getWarnings(): BaseError[];
+    getNumberOfWarnings(): number;
+    addError(error: any): void;
+    getErrors(): BaseError[];
+    /**
+     * @returns {number} number of errors
+     */
+    getNumberOfErrors(): number;
+    clearWarningsAndErrors(): void;
+    isOptional(moduleGraph: any): boolean;
+    isAccessibleInChunk(chunkGraph: any, chunk: any, ignoreChunk?: any): boolean;
+    isAccessibleInChunkGroup(chunkGraph: any, chunkGroup: any, ignoreChunk?: any): boolean;
+    hasReasonForChunk(chunk: any, moduleGraph: any, chunkGraph: any): boolean;
+    hasReasons(moduleGraph: any, runtime: any): boolean;
+    toString(): string;
+    needBuild(context: NeedBuildContext, callback: any): void;
+    needRebuild(fileTimestamps: Map<string, number | null>, contextTimestamps: Map<string, number | null>): boolean;
+    updateHash(hash: Hash, context?: {
+        chunkGraph: any;
+        runtime: undefined;
+    }): void;
+    invalidateBuild(): void;
+    identifier(): void;
+    readableIdentifier(requestShortener: RequestShortener): void;
+    build(options: any, compilation: any, resolver: any, fs: any, callback: any): void;
+    getSourceTypes(): Set<string>;
+    source(dependencyTemplates: any, runtimeTemplate: any, type?: string): any;
+    size(type?: any): void;
+    libIdent(options: any): any;
+    nameForCondition(): null;
+    getConcatenationBailoutReason(context: any): string;
+    getSideEffectsConnectionState(moduleGraph: any): boolean;
+    codeGeneration(context: CodeGenerationContext): any;
+    chunkCondition(chunk: any, compilation: any): boolean;
+    hasChunkCondition(): boolean;
+    /**
+     * Assuming this module is in the cache. Update the (cached) module with
+     * the fresh module from the factory. Usually updates internal references
+     * and properties.
+     */
+    updateCacheModule(module: any): void;
+    /**
+     * Module should be unsafe cached. Get data that's needed for that.
+     * This data will be passed to restoreFromUnsafeCache later.
+     */
+    getUnsafeCacheData(): {
+        factoryMeta: FactoryMeta | undefined;
+        resolveOptions: ResolveOptions | undefined;
+    };
+    /**
+     * restore unsafe cache data
+     */
+    _restoreFromUnsafeCache(unsafeCacheData: any, normalModuleFactory: any): void;
+    /**
+     * Assuming this module is in the cache. Remove internal references to allow freeing some memory.
+     */
+    cleanupForCache(): void;
+    originalSource(): null;
+    addCacheDependencies(fileDependencies: LazySet, contextDependencies: LazySet, missingDependencies: LazySet, buildDependencies: LazySet): void;
+    serialize(context: any): void;
+    deserialize(context: any): void;
+}
+export default Module;