@expo/metro-file-map 55.0.0-0

package/build/lib/FileProcessor.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { FileMapPluginWorker, FileMetadata, PerfLogger } from '../types';
+interface ProcessFileRequest {
+    /**
+     * Populate metadata[H.SHA1] with the SHA1 of the file's contents.
+     */
+    readonly computeSha1: boolean;
+    /**
+     * Only if processing has already required reading the file's contents, return
+     * the contents as a Buffer - null otherwise. Not supported for batches.
+     */
+    readonly maybeReturnContent: boolean;
+}
+interface MaybeCodedError extends Error {
+    code?: string;
+}
+export declare class FileProcessor {
+    #private;
+    constructor(opts: Readonly<{
+        maxFilesPerWorker?: number | null;
+        maxWorkers: number;
+        pluginWorkers?: readonly FileMapPluginWorker[] | null;
+        perfLogger?: PerfLogger | null;
+        rootDir: string;
+    }>);
+    processBatch(files: readonly [relativePath: string, FileMetadata][], req: ProcessFileRequest): Promise<{
+        errors: {
+            normalFilePath: string;
+            error: MaybeCodedError;
+        }[];
+    }>;
+    processRegularFile(normalPath: string, fileMetadata: FileMetadata, req: ProcessFileRequest): Promise<{
+        content: Buffer | undefined | null;
+    } | null>;
+    end(): Promise<void>;
+}
+export {};

package/build/lib/FileProcessor.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileProcessor = void 0;
+const jest_worker_1 = require("jest-worker");
+const path_1 = require("path");
+const constants_1 = __importDefault(require("../constants"));
+const worker_1 = require("../worker");
+const RootPathUtils_1 = require("./RootPathUtils");
+const debug = require('debug')('Metro:FileMap');
+const NODE_MODULES_SEP = 'node_modules' + path_1.sep;
+const MAX_FILES_PER_WORKER = 100;
+class FileProcessor {
+    #maxFilesPerWorker;
+    #maxWorkers;
+    #perfLogger;
+    #pluginWorkers;
+    #inBandWorker;
+    #rootPathUtils;
+    constructor(opts) {
+        this.#maxFilesPerWorker = opts.maxFilesPerWorker ?? MAX_FILES_PER_WORKER;
+        this.#maxWorkers = opts.maxWorkers;
+        this.#pluginWorkers = opts.pluginWorkers ?? [];
+        this.#inBandWorker = new worker_1.Worker({
+            plugins: this.#pluginWorkers.map((plugin) => plugin.worker),
+        });
+        this.#perfLogger = opts.perfLogger;
+        this.#rootPathUtils = new RootPathUtils_1.RootPathUtils(opts.rootDir);
+    }
+    async processBatch(files, req) {
+        const errors = [];
+        const workerJobs = files
+            .map(([normalFilePath, fileMetadata]) => {
+            const maybeWorkerInput = this.#getWorkerInput(normalFilePath, fileMetadata, req);
+            if (!maybeWorkerInput) {
+                return null;
+            }
+            return [maybeWorkerInput, fileMetadata];
+        })
+            .filter((x) => x != null);
+        const numWorkers = Math.min(this.#maxWorkers, Math.ceil(workerJobs.length / this.#maxFilesPerWorker));
+        const batchWorker = this.#getBatchWorker(numWorkers);
+        if (req.maybeReturnContent) {
+            throw new Error('Batch processing does not support returning file contents');
+        }
+        await Promise.all(workerJobs.map(([workerInput, fileMetadata]) => {
+            return batchWorker
+                .processFile(workerInput)
+                .then((reply) => processWorkerReply(reply, workerInput.pluginsToRun, fileMetadata))
+                .catch((error) => errors.push({
+                normalFilePath: this.#rootPathUtils.absoluteToNormal(workerInput.filePath),
+                error: normalizeWorkerError(error),
+            }));
+        }));
+        await batchWorker.end();
+        return { errors };
+    }
+    async processRegularFile(normalPath, fileMetadata, req) {
+        const workerInput = this.#getWorkerInput(normalPath, fileMetadata, req);
+        return workerInput
+            ? {
+                content: processWorkerReply(await this.#inBandWorker.processFile(workerInput), workerInput.pluginsToRun, fileMetadata),
+            }
+            : null;
+    }
+    #getWorkerInput(normalPath, fileMetadata, req) {
+        if (fileMetadata[constants_1.default.SYMLINK] !== 0) {
+            // Only process regular files
+            return null;
+        }
+        const computeSha1 = req.computeSha1 && fileMetadata[constants_1.default.SHA1] == null;
+        const { maybeReturnContent } = req;
+        const nodeModulesIdx = normalPath.indexOf(NODE_MODULES_SEP);
+        // Path may begin 'node_modules/' or contain '/node_modules/'.
+        const isNodeModules = nodeModulesIdx === 0 || (nodeModulesIdx > 0 && normalPath[nodeModulesIdx - 1] === path_1.sep);
+        // Indices of plugins with a passing filter
+        const pluginsToRun = this.#pluginWorkers?.reduce((prev, plugin, idx) => {
+            if (plugin.filter({ isNodeModules, normalPath })) {
+                prev.push(idx);
+            }
+            return prev;
+        }, []) ?? [];
+        if (!computeSha1 && pluginsToRun.length === 0) {
+            // Nothing to process
+            return null;
+        }
+        // Use a cheaper worker configuration for node_modules files, because
+        // they may never be Haste modules or packages.
+        //
+        // Note that we'd only expect node_modules files to reach this point if
+        // retainAllFiles is true, or they're touched during watch mode.
+        if (isNodeModules) {
+            if (computeSha1) {
+                return {
+                    computeSha1: true,
+                    filePath: this.#rootPathUtils.normalToAbsolute(normalPath),
+                    maybeReturnContent,
+                    pluginsToRun,
+                };
+            }
+            return null;
+        }
+        return {
+            computeSha1,
+            filePath: this.#rootPathUtils.normalToAbsolute(normalPath),
+            maybeReturnContent,
+            pluginsToRun,
+        };
+    }
+    /**
+     * Creates workers or parses files and extracts metadata in-process.
+     */
+    #getBatchWorker(numWorkers) {
+        if (numWorkers <= 1) {
+            // In-band worker with the same interface as a Jest worker farm
+            return {
+                processFile: async (message) => this.#inBandWorker.processFile(message),
+                end: async () => { },
+            };
+        }
+        const workerPath = require.resolve('../worker');
+        debug('Creating worker farm of %d worker threads', numWorkers);
+        this.#perfLogger?.point('initWorkers_start');
+        const jestWorker = new jest_worker_1.Worker(workerPath, {
+            exposedMethods: ['processFile'],
+            maxRetries: 3,
+            numWorkers,
+            enableWorkerThreads: true,
+            forkOptions: {
+                // Don't pass Node arguments down to workers. In particular, avoid
+                // unnecessarily registering Babel when we're running Metro from
+                // source (our worker is plain CommonJS).
+                execArgv: [],
+            },
+            setupArgs: [
+                {
+                    plugins: this.#pluginWorkers.map((plugin) => plugin.worker),
+                },
+            ],
+        });
+        this.#perfLogger?.point('initWorkers_end');
+        // Only log worker init once
+        this.#perfLogger = null;
+        return jestWorker;
+    }
+    async end() { }
+}
+exports.FileProcessor = FileProcessor;
+function processWorkerReply(metadata, pluginsRun, fileMetadata) {
+    fileMetadata[constants_1.default.VISITED] = 1;
+    const pluginData = metadata.pluginData;
+    if (pluginData) {
+        for (const [i, pluginIdx] of pluginsRun.entries()) {
+            fileMetadata[constants_1.default.PLUGINDATA + pluginIdx] = pluginData[i];
+        }
+    }
+    if (metadata.sha1 != null) {
+        fileMetadata[constants_1.default.SHA1] = metadata.sha1;
+    }
+    return metadata.content;
+}
+function normalizeWorkerError(mixedError) {
+    if (mixedError == null ||
+        typeof mixedError !== 'object' ||
+        mixedError.message == null ||
+        mixedError.stack == null) {
+        const error = new Error(mixedError);
+        error.stack = ''; // Remove stack for stack-less errors.
+        return error;
+    }
+    return mixedError;
+}

package/build/lib/FileSystemChangeAggregator.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import type { CanonicalPath, FileMetadata, FileSystemListener, ReadonlyFileSystemChanges } from '../types';
+export declare class FileSystemChangeAggregator implements FileSystemListener {
+    #private;
+    directoryAdded(canonicalPath: CanonicalPath): void;
+    directoryRemoved(canonicalPath: CanonicalPath): void;
+    fileAdded(canonicalPath: CanonicalPath, data: FileMetadata): void;
+    fileModified(canonicalPath: CanonicalPath, oldData: FileMetadata, newData: FileMetadata): void;
+    fileRemoved(canonicalPath: CanonicalPath, data: FileMetadata): void;
+    getSize(): number;
+    getView(): ReadonlyFileSystemChanges<FileMetadata>;
+    getMappedView<T>(metadataMapFn: (metadata: FileMetadata) => T): ReadonlyFileSystemChanges<T>;
+}

package/build/lib/FileSystemChangeAggregator.js

@@ -0,0 +1,114 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemChangeAggregator = void 0;
+class FileSystemChangeAggregator {
+    // Mutually exclusive with removedDirectories
+    #addedDirectories = new Set();
+    // Mutually exclusive with addedDirectories
+    #removedDirectories = new Set();
+    // Mutually exclusive with modified and removed files
+    #addedFiles = new Map();
+    // Mutually exclusive with added and removed files
+    #modifiedFiles = new Map();
+    // Mutually exclusive with added and modified files
+    #removedFiles = new Map();
+    // Removed files must be paired with the file's metadata the last time it was
+    // observable by consumers - ie, immediately *before* this batch. To report
+    // this accurately with minimal overhead, we'll note the current metadata of
+    // a file the first time it is modified or removed within a batch. If it is
+    // re-added, modified and removed again, we still have the initial metadata.
+    // This is particularly important if, say, a regular file is replaced by a
+    // symlink, or vice-versa.
+    #initialMetadata = new Map();
+    directoryAdded(canonicalPath) {
+        // Only add to newDirectories if this directory wasn't previously removed
+        // (i.e., it's truly new). If it was removed and re-added, the net effect
+        // is no directory change.
+        if (!this.#removedDirectories.delete(canonicalPath)) {
+            this.#addedDirectories.add(canonicalPath);
+        }
+    }
+    directoryRemoved(canonicalPath) {
+        if (!this.#addedDirectories.delete(canonicalPath)) {
+            this.#removedDirectories.add(canonicalPath);
+        }
+    }
+    fileAdded(canonicalPath, data) {
+        if (this.#removedFiles.delete(canonicalPath)) {
+            // File was removed then re-added in the same batch - treat as modification
+            this.#modifiedFiles.set(canonicalPath, data);
+        }
+        else {
+            // New file
+            this.#addedFiles.set(canonicalPath, data);
+        }
+    }
+    fileModified(canonicalPath, oldData, newData) {
+        if (this.#addedFiles.has(canonicalPath)) {
+            // File did not exist before this batch. Further modification only
+            // updates metadata
+            this.#addedFiles.set(canonicalPath, newData);
+        }
+        else {
+            if (!this.#initialMetadata.has(canonicalPath)) {
+                this.#initialMetadata.set(canonicalPath, oldData);
+            }
+            this.#modifiedFiles.set(canonicalPath, newData);
+        }
+    }
+    fileRemoved(canonicalPath, data) {
+        // Check if this file was added in the same batch
+        if (!this.#addedFiles.delete(canonicalPath)) {
+            let initialData = this.#initialMetadata.get(canonicalPath);
+            if (!initialData) {
+                initialData = data;
+                this.#initialMetadata.set(canonicalPath, initialData);
+            }
+            // File was not added in this batch, so add to removed with last metadata
+            this.#modifiedFiles.delete(canonicalPath);
+            this.#removedFiles.set(canonicalPath, initialData);
+        }
+        // else: File was added then removed in the same batch - no net change
+    }
+    getSize() {
+        return (this.#addedDirectories.size +
+            this.#removedDirectories.size +
+            this.#addedFiles.size +
+            this.#modifiedFiles.size +
+            this.#removedFiles.size);
+    }
+    getView() {
+        return {
+            addedDirectories: this.#addedDirectories,
+            removedDirectories: this.#removedDirectories,
+            addedFiles: this.#addedFiles,
+            modifiedFiles: this.#modifiedFiles,
+            removedFiles: this.#removedFiles,
+        };
+    }
+    getMappedView(metadataMapFn) {
+        return {
+            addedDirectories: this.#addedDirectories,
+            removedDirectories: this.#removedDirectories,
+            addedFiles: mapIterable(this.#addedFiles, metadataMapFn),
+            modifiedFiles: mapIterable(this.#modifiedFiles, metadataMapFn),
+            removedFiles: mapIterable(this.#removedFiles, metadataMapFn),
+        };
+    }
+}
+exports.FileSystemChangeAggregator = FileSystemChangeAggregator;
+function mapIterable(map, metadataMapFn) {
+    return {
+        *[Symbol.iterator]() {
+            for (const [path, metadata] of map) {
+                yield [path, metadataMapFn(metadata)];
+            }
+        },
+    };
+}

package/build/lib/RootPathUtils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+export declare class RootPathUtils {
+    #private;
+    constructor(rootDir: string);
+    getBasenameOfNthAncestor(n: number): string;
+    getParts(): readonly string[];
+    absoluteToNormal(absolutePath: string): string;
+    normalToAbsolute(normalPath: string): string;
+    relativeToNormal(relativePath: string): string;
+    resolveSymlinkToNormal(symlinkNormalPath: string, readlinkResult: string): string;
+    getAncestorOfRootIdx(normalPath: string): number | null;
+    joinNormalToRelative(normalPath: string, relativePath: string): {
+        normalPath: string;
+        collapsedSegments: number;
+    };
+    relative(from: string, to: string): string;
+}
+export declare function getAncestorOfRootIdx(normalPath: string): number;
+export declare function pathsToPattern(paths: readonly string[], pathUtils: RootPathUtils): RegExp | null;