xhs-mp-pack 1.1.0-beta.0

package/dist/ConcatenationScope.d.ts

@@ -0,0 +1,37 @@
+import Module from './module/Module';
+interface ExternalModuleInfo {
+    index: number;
+    module: Module;
+}
+interface ConcatenatedModuleInfo extends ExternalModuleInfo {
+    exportMap: Map<string, string>;
+    rawExportMap: Map<string, string>;
+    namespaceExportSymbol?: string;
+}
+type ModuleInfo = ConcatenatedModuleInfo | ExternalModuleInfo;
+declare class ConcatenationScope {
+    static DEFAULT_EXPORT: string;
+    static NAMESPACE_OBJECT_EXPORT: string;
+    _currentModule: any;
+    _modulesMap: Map<Module, ModuleInfo>;
+    constructor(modulesMap: ModuleInfo[] | Map<Module, ModuleInfo>, currentModule: any);
+    isModuleInScope(module: Module): boolean;
+    registerExport(exportName: string, symbol: string): void;
+    registerRawExport(exportName: string, expression: string): void;
+    registerNamespaceExport(symbol: string): void;
+    createModuleReference(module: any, { ids, call, directImport, asiSafe }: {
+        ids?: undefined;
+        call?: boolean | undefined;
+        directImport?: boolean | undefined;
+        asiSafe?: boolean | undefined;
+    }): string;
+    static isModuleReference(name: string): boolean;
+    static matchModuleReference(name: string): {
+        index: number;
+        ids: any;
+        call: boolean;
+        directImport: boolean;
+        asiSafe: boolean | undefined;
+    } | null;
+}
+export default ConcatenationScope;

package/dist/ConcatenationScope.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const MODULE_REFERENCE_REGEXP = /^__WEBPACK_MODULE_REFERENCE__(\d+)_([\da-f]+|ns)(_call)?(_directImport)?(?:_asiSafe(\d))?__$/;
+const DEFAULT_EXPORT = '__WEBPACK_DEFAULT_EXPORT__';
+const NAMESPACE_OBJECT_EXPORT = '__WEBPACK_NAMESPACE_OBJECT__';
+class ConcatenationScope {
+    constructor(modulesMap, currentModule) {
+        this._currentModule = currentModule;
+        if (Array.isArray(modulesMap)) {
+            const map = new Map();
+            for (const info of modulesMap) {
+                map.set(info.module, info);
+            }
+            modulesMap = map;
+        }
+        this._modulesMap = modulesMap;
+    }
+    isModuleInScope(module) {
+        return this._modulesMap.has(module);
+    }
+    registerExport(exportName, symbol) {
+        if (!this._currentModule.exportMap) {
+            this._currentModule.exportMap = new Map();
+        }
+        if (!this._currentModule.exportMap.has(exportName)) {
+            this._currentModule.exportMap.set(exportName, symbol);
+        }
+    }
+    registerRawExport(exportName, expression) {
+        if (!this._currentModule.rawExportMap) {
+            this._currentModule.rawExportMap = new Map();
+        }
+        if (!this._currentModule.rawExportMap.has(exportName)) {
+            this._currentModule.rawExportMap.set(exportName, expression);
+        }
+    }
+    registerNamespaceExport(symbol) {
+        this._currentModule.namespaceExportSymbol = symbol;
+    }
+    createModuleReference(module, { ids = undefined, call = false, directImport = false, asiSafe = false }) {
+        const info = this._modulesMap.get(module);
+        const callFlag = call ? '_call' : '';
+        const directImportFlag = directImport ? '_directImport' : '';
+        const asiSafeFlag = asiSafe ? '_asiSafe1' : asiSafe === false ? '_asiSafe0' : '';
+        const exportData = ids ? Buffer.from(JSON.stringify(ids), 'utf-8').toString('hex') : 'ns';
+        // a "._" is appended to allow "delete ...", which would cause a SyntaxError in strict mode
+        return `__WEBPACK_MODULE_REFERENCE__${info.index}_${exportData}${callFlag}${directImportFlag}${asiSafeFlag}__._`;
+    }
+    static isModuleReference(name) {
+        return MODULE_REFERENCE_REGEXP.test(name);
+    }
+    static matchModuleReference(name) {
+        const match = MODULE_REFERENCE_REGEXP.exec(name);
+        if (!match)
+            return null;
+        const index = +match[1];
+        const asiSafe = match[5];
+        return {
+            index,
+            ids: match[2] === 'ns' ? [] : JSON.parse(Buffer.from(match[2], 'hex').toString('utf-8')),
+            call: !!match[3],
+            directImport: !!match[4],
+            asiSafe: asiSafe ? asiSafe === '1' : undefined,
+        };
+    }
+}
+ConcatenationScope.DEFAULT_EXPORT = DEFAULT_EXPORT;
+ConcatenationScope.NAMESPACE_OBJECT_EXPORT = NAMESPACE_OBJECT_EXPORT;
+exports.default = ConcatenationScope;

package/dist/FileSystemInfo.d.ts

@@ -0,0 +1,183 @@
+import AsyncQueue from '@/base/AsyncQueue';
+import StackedCacheMap from '@/base/StackedCacheMap';
+declare class SnapshotIterator {
+    next: any;
+    constructor(next: any);
+}
+declare class SnapshotIterable {
+    snapshot: any;
+    getMaps: any;
+    constructor(snapshot: any, getMaps: any);
+    [Symbol.iterator](): SnapshotIterator;
+}
+declare class Snapshot {
+    _flags: number;
+    _cachedFileIterable?: Iterable<string>;
+    _cachedContextIterable?: Iterable<string>;
+    _cachedMissingIterable?: Iterable<string>;
+    startTime?: number;
+    fileTimestamps?: any;
+    fileHashes?: Map<string, string | null>;
+    fileTshs?: Map<string, any | string | null>;
+    contextTimestamps?: Map<string, any | null>;
+    contextHashes?: Map<string, string | null>;
+    contextTshs?: Map<string, string | null>;
+    missingExistence?: Map<string, boolean>;
+    managedItemInfo?: Map<string, string>;
+    managedFiles?: Set<string>;
+    managedContexts?: Set<string>;
+    managedMissing?: Set<string>;
+    children: Set<Snapshot>;
+    constructor();
+    hasStartTime(): boolean;
+    setStartTime(value: any): void;
+    setMergedStartTime(value: any, snapshot: any): void;
+    hasFileTimestamps(): boolean;
+    setFileTimestamps(value: any): void;
+    hasFileHashes(): boolean;
+    setFileHashes(value: any): void;
+    hasFileTshs(): boolean;
+    setFileTshs(value: any): void;
+    hasContextTimestamps(): boolean;
+    setContextTimestamps(value: any): void;
+    hasContextHashes(): boolean;
+    setContextHashes(value: any): void;
+    hasContextTshs(): boolean;
+    setContextTshs(value: any): void;
+    hasMissingExistence(): boolean;
+    setMissingExistence(value: any): void;
+    hasManagedItemInfo(): boolean;
+    setManagedItemInfo(value: any): void;
+    hasManagedFiles(): boolean;
+    setManagedFiles(value: any): void;
+    hasManagedContexts(): boolean;
+    setManagedContexts(value: any): void;
+    hasManagedMissing(): boolean;
+    setManagedMissing(value: any): void;
+    hasChildren(): boolean;
+    setChildren(value: any): void;
+    addChild(child: any): void;
+    serialize({ write }: {
+        write: any;
+    }): void;
+    deserialize({ read }: {
+        read: any;
+    }): void;
+    _createIterable(getMaps: any): SnapshotIterable;
+    getFileIterable(): Iterable<string>;
+    getContextIterable(): Iterable<string>;
+    getMissingIterable(): Iterable<string>;
+}
+declare class SnapshotOptimization {
+    _has: any;
+    _get: any;
+    _set: any;
+    _useStartTime: boolean;
+    _isSet: boolean;
+    _map: Map<any, any>;
+    _statItemsShared: number;
+    _statItemsUnshared: number;
+    _statSharedSnapshots: number;
+    _statReusedSharedSnapshots: number;
+    constructor(has: any, get: any, set: any, useStartTime?: boolean, isSet?: boolean);
+    getStatisticMessage(): string | undefined;
+    clear(): void;
+    optimize(newSnapshot: any, capturedFiles: any): void;
+}
+declare class FileSystemInfo {
+    fs: any;
+    logger: any;
+    _remainingLogs: number;
+    _loggedPaths: Set<any>;
+    _hashFunction: string;
+    _snapshotCache: WeakMap<any, any>;
+    _fileTimestampsOptimization: SnapshotOptimization;
+    _fileHashesOptimization: SnapshotOptimization;
+    _fileTshsOptimization: SnapshotOptimization;
+    _contextTimestampsOptimization: SnapshotOptimization;
+    _contextHashesOptimization: SnapshotOptimization;
+    _contextTshsOptimization: SnapshotOptimization;
+    _missingExistenceOptimization: SnapshotOptimization;
+    _managedItemInfoOptimization: SnapshotOptimization;
+    _managedFilesOptimization: SnapshotOptimization;
+    _managedContextsOptimization: SnapshotOptimization;
+    _managedMissingOptimization: SnapshotOptimization;
+    _fileTimestamps: StackedCacheMap;
+    _fileHashes: Map<any, any>;
+    _fileTshs: Map<any, any>;
+    _contextTimestamps: StackedCacheMap;
+    _contextHashes: Map<any, any>;
+    _contextTshs: Map<any, any>;
+    _managedItems: Map<any, any>;
+    fileTimestampQueue: AsyncQueue;
+    fileHashQueue: AsyncQueue;
+    contextTimestampQueue: AsyncQueue;
+    contextHashQueue: AsyncQueue;
+    contextTshQueue: AsyncQueue;
+    managedItemQueue: AsyncQueue;
+    managedItemDirectoryQueue: AsyncQueue;
+    managedPaths: never[];
+    managedPathsWithSlash: any;
+    managedPathsRegExps: any;
+    immutablePaths: never[];
+    immutablePathsWithSlash: any;
+    immutablePathsRegExps: any;
+    _cachedDeprecatedFileTimestamps: any;
+    _cachedDeprecatedContextTimestamps: any;
+    _warnAboutExperimentalEsmTracking: boolean;
+    _statCreatedSnapshots: number;
+    _statTestedSnapshotsCached: number;
+    _statTestedSnapshotsNotCached: number;
+    _statTestedChildrenCached: number;
+    _statTestedChildrenNotCached: number;
+    _statTestedEntries: number;
+    constructor(fs: any, { managedPaths, immutablePaths, logger, hashFunction }?: any);
+    logStatistics(): void;
+    _log(path: any, reason: any, ...args: any[]): void;
+    clear(): void;
+    addFileTimestamps(map: ReadonlyMap<string, any | 'ignore' | null>, immutable?: boolean): void;
+    addContextTimestamps(map: ReadonlyMap<string, any | 'ignore' | null>, immutable?: boolean): void;
+    getFileTimestamp(path: any, callback: any): any;
+    getContextTimestamp(path: any, callback: any): any;
+    _getUnresolvedContextTimestamp(path: any, callback: any): any;
+    getFileHash(path: any, callback: any): any;
+    getContextHash(path: any, callback: any): any;
+    _getUnresolvedContextHash(path: any, callback: any): any;
+    getContextTsh(path: any, callback: any): any;
+    _getUnresolvedContextTsh(path: any, callback: any): any;
+    _createBuildDependenciesResolvers(): {
+        resolveContext: import("enhanced-resolve").ResolveFunctionAsync;
+        resolveEsm: import("enhanced-resolve").ResolveFunctionAsync;
+        resolveCjs: import("enhanced-resolve").ResolveFunctionAsync;
+        resolveCjsAsChild: import("enhanced-resolve").ResolveFunctionAsync;
+    };
+    resolveBuildDependencies(context: any, deps: any, callback: any): void;
+    checkResolveResultsValid(resolveResults: any, callback: any): void;
+    createSnapshot(startTime: number | null | undefined, files: Iterable<string>, directories: Iterable<string>, missing: Iterable<string>, options?: any, callback?: any): void;
+    mergeSnapshots(snapshot1: Snapshot, snapshot2: Snapshot): Snapshot;
+    checkSnapshotValid(snapshot: any, callback: any): void;
+    _checkSnapshotValidNoCache(snapshot: any, callback: any): void;
+    _readFileTimestamp(path: any, callback: any): void;
+    _readFileHash(path: any, callback: any): void;
+    _getFileTimestampAndHash(path: any, callback: any): void;
+    _readContext({ path, fromImmutablePath, fromManagedItem, fromSymlink, fromFile, fromDirectory, reduce }: {
+        path: any;
+        fromImmutablePath: any;
+        fromManagedItem: any;
+        fromSymlink: any;
+        fromFile: any;
+        fromDirectory: any;
+        reduce: any;
+    }, callback: any): void;
+    _readContextTimestamp(path: any, callback: any): void;
+    _resolveContextTimestamp(entry: any, callback: any): void;
+    _readContextHash(path: any, callback: any): void;
+    _resolveContextHash(entry: any, callback: any): void;
+    _readContextTimestampAndHash(path: any, callback: any): void;
+    _resolveContextTsh(entry: any, callback: any): void;
+    _getManagedItemDirectoryInfo(path: any, callback: any): void;
+    _getManagedItemInfo(path: any, callback: any): void;
+    getDeprecatedFileTimestamps(): any;
+    getDeprecatedContextTimestamps(): any;
+}
+export { FileSystemInfo, Snapshot };