@expo/metro-file-map 55.0.0-0

package/build/watchers/FallbackWatcher.js

@@ -0,0 +1,411 @@
+"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.
+ *
+ * @format
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const AbstractWatcher_1 = require("./AbstractWatcher");
+const common = __importStar(require("./common"));
+// NOTE(@kitten): No typings
+const walker = require('walker');
+const platform = os_1.default.platform();
+const fsPromises = fs_1.default.promises;
+const TOUCH_EVENT = common.TOUCH_EVENT;
+const DELETE_EVENT = common.DELETE_EVENT;
+/**
+ * This setting delays all events. It suppresses 'change' events that
+ * immediately follow an 'add', and debounces successive 'change' events to
+ * only emit the latest.
+ */
+const DEBOUNCE_MS = 100;
+class FallbackWatcher extends AbstractWatcher_1.AbstractWatcher {
+    #changeTimers = new Map();
+    #dirRegistry = Object.create(null);
+    #watched = Object.create(null);
+    async startWatching() {
+        this.#watchdir(this.root);
+        await new Promise((resolve) => {
+            recReaddir(this.root, (dir) => {
+                this.#watchdir(dir);
+            }, (filename) => {
+                this.#register(filename, 'f');
+            }, (symlink) => {
+                this.#register(symlink, 'l');
+            }, () => {
+                resolve();
+            }, this.#checkedEmitError, this.ignored);
+        });
+    }
+    /**
+     * Register files that matches our globs to know what to type of event to
+     * emit in the future.
+     *
+     * Registry looks like the following:
+     *
+     *  dirRegister => Map {
+     *    dirpath => Map {
+     *       filename => true
+     *    }
+     *  }
+     *
+     *  Return false if ignored or already registered.
+     */
+    #register(filepath, type) {
+        const dir = path_1.default.dirname(filepath);
+        const filename = path_1.default.basename(filepath);
+        if (this.#dirRegistry[dir] && this.#dirRegistry[dir][filename]) {
+            return false;
+        }
+        const relativePath = path_1.default.relative(this.root, filepath);
+        if (this.doIgnore(relativePath) ||
+            (type === 'f' && !common.includedByGlob('f', this.globs, this.dot, relativePath))) {
+            return false;
+        }
+        if (!this.#dirRegistry[dir]) {
+            this.#dirRegistry[dir] = Object.create(null);
+        }
+        this.#dirRegistry[dir][filename] = true;
+        return true;
+    }
+    /**
+     * Removes a file from the registry.
+     */
+    #unregister(filepath) {
+        const dir = path_1.default.dirname(filepath);
+        if (this.#dirRegistry[dir]) {
+            const filename = path_1.default.basename(filepath);
+            delete this.#dirRegistry[dir][filename];
+        }
+    }
+    /**
+     * Removes a dir from the registry, returning all files that were registered
+     * under it (recursively).
+     */
+    #unregisterDir(dirpath) {
+        const removedFiles = [];
+        // Find and remove all entries under this directory
+        for (const registeredDir of Object.keys(this.#dirRegistry)) {
+            if (registeredDir === dirpath || registeredDir.startsWith(dirpath + path_1.default.sep)) {
+                // Collect all files in this directory
+                for (const filename of Object.keys(this.#dirRegistry[registeredDir])) {
+                    removedFiles.push(path_1.default.join(registeredDir, filename));
+                }
+                delete this.#dirRegistry[registeredDir];
+            }
+        }
+        return removedFiles;
+    }
+    /**
+     * Checks if a file or directory exists in the registry.
+     */
+    #registered(fullpath) {
+        const dir = path_1.default.dirname(fullpath);
+        return !!(this.#dirRegistry[fullpath] ||
+            (this.#dirRegistry[dir] && this.#dirRegistry[dir][path_1.default.basename(fullpath)]));
+    }
+    /**
+     * Emit "error" event if it's not an ignorable event
+     */
+    #checkedEmitError = (error) => {
+        if (!isIgnorableFileError(error)) {
+            this.emitError(error);
+        }
+    };
+    /**
+     * Watch a directory.
+     */
+    #watchdir = (dir) => {
+        if (this.#watched[dir]) {
+            return false;
+        }
+        const watcher = fs_1.default.watch(dir, { persistent: true }, (event, filename) => this.#normalizeChange(dir, event, filename));
+        this.#watched[dir] = watcher;
+        watcher.on('error', this.#checkedEmitError);
+        if (this.root !== dir) {
+            this.#register(dir, 'd');
+        }
+        return true;
+    };
+    /**
+     * Stop watching a directory.
+     */
+    async #stopWatching(dir) {
+        const watcher = this.#watched[dir];
+        if (watcher) {
+            await new Promise((resolve) => {
+                watcher.once('close', () => process.nextTick(resolve));
+                watcher.close();
+                delete this.#watched[dir];
+            });
+        }
+    }
+    /**
+     * End watching.
+     */
+    async stopWatching() {
+        await super.stopWatching();
+        const promises = Object.keys(this.#watched).map((dir) => this.#stopWatching(dir));
+        await Promise.all(promises);
+    }
+    /**
+     * On some platforms, as pointed out on the fs docs (most likely just win32)
+     * the file argument might be missing from the fs event. Try to detect what
+     * change by detecting if something was deleted or the most recent file change.
+     */
+    #detectChangedFile(dir, event, callback) {
+        if (!this.#dirRegistry[dir]) {
+            return;
+        }
+        let found = false;
+        let closest = null;
+        let c = 0;
+        Object.keys(this.#dirRegistry[dir]).forEach((file, i, arr) => {
+            fs_1.default.lstat(path_1.default.join(dir, file), (error, stat) => {
+                if (found) {
+                    return;
+                }
+                if (error) {
+                    if (isIgnorableFileError(error)) {
+                        found = true;
+                        callback(file);
+                    }
+                    else {
+                        this.emitError(error);
+                    }
+                }
+                else {
+                    if (closest == null || stat.mtime > closest.mtime) {
+                        closest = { file, mtime: stat.mtime };
+                    }
+                    if (arr.length === ++c) {
+                        callback(closest.file);
+                    }
+                }
+            });
+        });
+    }
+    /**
+     * Normalize fs events and pass it on to be processed.
+     */
+    #normalizeChange(dir, event, file) {
+        if (!file) {
+            this.#detectChangedFile(dir, event, (actualFile) => {
+                if (actualFile) {
+                    this.#processChange(dir, event, actualFile).catch((error) => {
+                        this.emitError(error);
+                    });
+                }
+            });
+        }
+        else {
+            this.#processChange(dir, event, path_1.default.normalize(file)).catch((error) => {
+                this.emitError(error);
+            });
+        }
+    }
+    /**
+     * Process changes.
+     */
+    async #processChange(dir, event, file) {
+        const fullPath = path_1.default.join(dir, file);
+        const relativePath = path_1.default.join(path_1.default.relative(this.root, dir), file);
+        const registered = this.#registered(fullPath);
+        try {
+            const stat = await fsPromises.lstat(fullPath);
+            if (stat.isDirectory()) {
+                // win32 emits usless change events on dirs.
+                if (event === 'change') {
+                    return;
+                }
+                if (this.doIgnore(relativePath) ||
+                    !common.includedByGlob('d', this.globs, this.dot, relativePath)) {
+                    return;
+                }
+                recReaddir(path_1.default.resolve(this.root, relativePath), (dir, stats) => {
+                    if (this.#watchdir(dir)) {
+                        this.#emitEvent({
+                            event: TOUCH_EVENT,
+                            relativePath: path_1.default.relative(this.root, dir),
+                            metadata: {
+                                modifiedTime: stats.mtime.getTime(),
+                                size: stats.size,
+                                type: 'd',
+                            },
+                        });
+                    }
+                }, (file, stats) => {
+                    if (this.#register(file, 'f')) {
+                        this.#emitEvent({
+                            event: TOUCH_EVENT,
+                            relativePath: path_1.default.relative(this.root, file),
+                            metadata: {
+                                modifiedTime: stats.mtime.getTime(),
+                                size: stats.size,
+                                type: 'f',
+                            },
+                        });
+                    }
+                }, (symlink, stats) => {
+                    if (this.#register(symlink, 'l')) {
+                        this.emitFileEvent({
+                            event: TOUCH_EVENT,
+                            relativePath: path_1.default.relative(this.root, symlink),
+                            metadata: {
+                                modifiedTime: stats.mtime.getTime(),
+                                size: stats.size,
+                                type: 'l',
+                            },
+                        });
+                    }
+                }, function endCallback() { }, this.#checkedEmitError, this.ignored);
+            }
+            else {
+                const type = common.typeFromStat(stat);
+                if (type == null) {
+                    return;
+                }
+                const metadata = {
+                    modifiedTime: stat.mtime.getTime(),
+                    size: stat.size,
+                    type,
+                };
+                if (registered) {
+                    this.#emitEvent({ event: TOUCH_EVENT, relativePath, metadata });
+                }
+                else {
+                    if (this.#register(fullPath, type)) {
+                        this.#emitEvent({ event: TOUCH_EVENT, relativePath, metadata });
+                    }
+                }
+            }
+        }
+        catch (error) {
+            if (!isIgnorableFileError(error)) {
+                this.emitError(error);
+                return;
+            }
+            this.#unregister(fullPath);
+            // When a directory is deleted, emit delete events for all files we
+            // knew about under that directory
+            const removedFiles = this.#unregisterDir(fullPath);
+            for (const removedFile of removedFiles) {
+                this.#emitEvent({
+                    event: DELETE_EVENT,
+                    relativePath: path_1.default.relative(this.root, removedFile),
+                });
+            }
+            if (registered) {
+                this.#emitEvent({ event: DELETE_EVENT, relativePath });
+            }
+            await this.#stopWatching(fullPath);
+        }
+    }
+    /**
+     * Emits the given event after debouncing, to emit only the latest
+     * information when we receive several events in quick succession. E.g.,
+     * Linux emits two events for every new file.
+     *
+     * See also note above for DEBOUNCE_MS.
+     */
+    #emitEvent(change) {
+        const { event, relativePath } = change;
+        const key = event + '-' + relativePath;
+        const existingTimer = this.#changeTimers.get(key);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        this.#changeTimers.set(key, setTimeout(() => {
+            this.#changeTimers.delete(key);
+            this.emitFileEvent(change);
+        }, DEBOUNCE_MS));
+    }
+    getPauseReason() {
+        return null;
+    }
+}
+exports.default = FallbackWatcher;
+/**
+ * Determine if a given FS error can be ignored
+ */
+function isIgnorableFileError(error) {
+    return (error.code === 'ENOENT' ||
+        // Workaround Windows EPERM on watched folder deletion, and when
+        // reading locked files (pending further writes or pending deletion).
+        // In such cases, we'll receive a subsequent event when the file is
+        // deleted or ready to read.
+        // https://github.com/facebook/metro/issues/1001
+        // https://github.com/nodejs/node-v0.x-archive/issues/4337
+        (error.code === 'EPERM' && platform === 'win32'));
+}
+/**
+ * Traverse a directory recursively calling `callback` on every directory.
+ */
+function recReaddir(dir, dirCallback, fileCallback, symlinkCallback, endCallback, errorCallback, ignored) {
+    const walk = walker(dir);
+    if (ignored) {
+        walk.filterDir((currentDir) => !common.posixPathMatchesPattern(ignored, currentDir));
+    }
+    walk
+        .on('dir', normalizeProxy(dirCallback))
+        .on('file', normalizeProxy(fileCallback))
+        .on('symlink', normalizeProxy(symlinkCallback))
+        .on('error', errorCallback)
+        .on('end', () => {
+        if (platform === 'win32') {
+            setTimeout(endCallback, 1000);
+        }
+        else {
+            endCallback();
+        }
+    });
+}
+/**
+ * Returns a callback that when called will normalize a path and call the
+ * original callback
+ */
+function normalizeProxy(callback) {
+    return (filepath, stats) => callback(path_1.default.normalize(filepath), stats);
+}

package/build/watchers/NativeWatcher.d.ts

@@ -0,0 +1,39 @@
+/**
+ * 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 { WatcherBackendOptions } from '../types';
+import { AbstractWatcher } from './AbstractWatcher';
+/**
+ * NativeWatcher uses Node's native fs.watch API with recursive: true.
+ *
+ * Supported on macOS (and potentially Windows), because both natively have a
+ * concept of recurisve watching, via FSEvents and ReadDirectoryChangesW
+ * respectively. Notably Linux lacks this capability at the OS level.
+ *
+ * Node.js has at times supported the `recursive` option to fs.watch on Linux
+ * by walking the directory tree and creating a watcher on each directory, but
+ * this fits poorly with the synchronous `watch` API - either it must block for
+ * arbitrarily large IO, or it may drop changes after `watch` returns. See:
+ * https://github.com/nodejs/node/issues/48437
+ *
+ * Therefore, we retain a fallback to our own application-level recursive
+ * FallbackWatcher for Linux, which has async `startWatching`.
+ *
+ * On Windows, this watcher could be used in principle, but needs work around
+ * some Windows-specific edge cases handled in FallbackWatcher, like
+ * deduping file change events, ignoring directory changes, and handling EPERM.
+ */
+export default class NativeWatcher extends AbstractWatcher {
+    #private;
+    static isSupported(): boolean;
+    constructor(dir: string, opts: WatcherBackendOptions);
+    startWatching(): Promise<void>;
+    /**
+     * End watching.
+     */
+    stopWatching(): Promise<void>;
+    _handleEvent(event: string, relativePath: string | null): Promise<void>;
+}

package/build/watchers/NativeWatcher.js

@@ -0,0 +1,156 @@
+"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 __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path = __importStar(require("path"));
+const AbstractWatcher_1 = require("./AbstractWatcher");
+const common_1 = require("./common");
+const debug = require('debug')('Metro:NativeWatcher');
+const TOUCH_EVENT = 'touch';
+const DELETE_EVENT = 'delete';
+const RECRAWL_EVENT = 'recrawl';
+/**
+ * NativeWatcher uses Node's native fs.watch API with recursive: true.
+ *
+ * Supported on macOS (and potentially Windows), because both natively have a
+ * concept of recurisve watching, via FSEvents and ReadDirectoryChangesW
+ * respectively. Notably Linux lacks this capability at the OS level.
+ *
+ * Node.js has at times supported the `recursive` option to fs.watch on Linux
+ * by walking the directory tree and creating a watcher on each directory, but
+ * this fits poorly with the synchronous `watch` API - either it must block for
+ * arbitrarily large IO, or it may drop changes after `watch` returns. See:
+ * https://github.com/nodejs/node/issues/48437
+ *
+ * Therefore, we retain a fallback to our own application-level recursive
+ * FallbackWatcher for Linux, which has async `startWatching`.
+ *
+ * On Windows, this watcher could be used in principle, but needs work around
+ * some Windows-specific edge cases handled in FallbackWatcher, like
+ * deduping file change events, ignoring directory changes, and handling EPERM.
+ */
+class NativeWatcher extends AbstractWatcher_1.AbstractWatcher {
+    #fsWatcher;
+    static isSupported() {
+        return (0, os_1.platform)() === 'darwin';
+    }
+    // eslint-disable-next-line @typescript-eslint/no-useless-constructor
+    constructor(dir, opts) {
+        // NOTE(@kitten): `!NativeWatcher.isSupported` was always truthy, so omitting check here
+        super(dir, opts);
+    }
+    async startWatching() {
+        this.#fsWatcher = (0, fs_1.watch)(this.root, {
+            // Don't hold the process open if we forget to close()
+            persistent: false,
+            // FSEvents or ReadDirectoryChangesW should mean this is cheap and
+            // ~instant on macOS or Windows.
+            recursive: true,
+        }, (event, relativePath) => {
+            this._handleEvent(event, relativePath).catch((error) => {
+                this.emitError(error);
+            });
+        });
+        debug('Watching %s', this.root);
+    }
+    /**
+     * End watching.
+     */
+    async stopWatching() {
+        await super.stopWatching();
+        if (this.#fsWatcher) {
+            this.#fsWatcher.close();
+        }
+    }
+    async _handleEvent(event, relativePath) {
+        if (relativePath == null) {
+            return;
+        }
+        const absolutePath = path.resolve(this.root, relativePath);
+        if (this.doIgnore(relativePath)) {
+            debug('Ignoring event "%s" on %s (root: %s)', event, relativePath, this.root);
+            return;
+        }
+        debug('Handling event "%s" on %s (root: %s)', event, relativePath, this.root);
+        try {
+            const stat = await fs_1.promises.lstat(absolutePath);
+            const type = (0, common_1.typeFromStat)(stat);
+            // Ignore files of an unrecognized type
+            if (!type) {
+                return;
+            }
+            if (!(0, common_1.includedByGlob)(type, this.globs, this.dot, relativePath)) {
+                return;
+            }
+            // For directory "rename" events, notify that we need a recrawl since we
+            // wont' receive events for unmodified files underneath a moved (or
+            // cloned) directory. Renames are fired by the OS on moves, clones, and
+            // creations. We ignore "change" events because they indiciate a change
+            // to directory metadata, rather than its path or existence.
+            if (type === 'd' && event === 'rename') {
+                debug('Directory rename detected on %s, requesting recrawl', relativePath);
+                this.emitFileEvent({
+                    event: RECRAWL_EVENT,
+                    relativePath,
+                });
+                return;
+            }
+            this.emitFileEvent({
+                event: TOUCH_EVENT,
+                relativePath,
+                metadata: {
+                    type,
+                    modifiedTime: stat.mtime.getTime(),
+                    size: stat.size,
+                },
+            });
+        }
+        catch (error) {
+            if (error?.code !== 'ENOENT') {
+                this.emitError(error);
+                return;
+            }
+            this.emitFileEvent({ event: DELETE_EVENT, relativePath });
+        }
+    }
+}
+exports.default = NativeWatcher;

package/build/watchers/RecrawlWarning.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.
+ *
+ * Originally vendored from
+ * https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/utils/recrawl-warning-dedupe.js
+ */
+export default class RecrawlWarning {
+    static RECRAWL_WARNINGS: RecrawlWarning[];
+    static REGEXP: RegExp;
+    root: string;
+    count: number;
+    constructor(root: string, count: number);
+    static findByRoot(root: string): RecrawlWarning | undefined;
+    static isRecrawlWarningDupe(warningMessage: unknown): boolean;
+}

package/build/watchers/RecrawlWarning.js

@@ -0,0 +1,59 @@
+"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.
+ *
+ * Originally vendored from
+ * https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/utils/recrawl-warning-dedupe.js
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+class RecrawlWarning {
+    static RECRAWL_WARNINGS = [];
+    static REGEXP = /Recrawled this watch (\d+) times?, most recently because:\n([^:]+)/;
+    root;
+    count;
+    constructor(root, count) {
+        this.root = root;
+        this.count = count;
+    }
+    static findByRoot(root) {
+        for (let i = 0; i < this.RECRAWL_WARNINGS.length; i++) {
+            const warning = this.RECRAWL_WARNINGS[i];
+            if (warning.root === root) {
+                return warning;
+            }
+        }
+        return undefined;
+    }
+    static isRecrawlWarningDupe(warningMessage) {
+        if (typeof warningMessage !== 'string') {
+            return false;
+        }
+        const match = warningMessage.match(this.REGEXP);
+        if (!match) {
+            return false;
+        }
+        const count = Number(match[1]);
+        const root = match[2];
+        const warning = this.findByRoot(root);
+        if (warning) {
+            // only keep the highest count, assume count to either stay the same or
+            // increase.
+            if (warning.count >= count) {
+                return true;
+            }
+            else {
+                // update the existing warning to the latest (highest) count
+                warning.count = count;
+                return false;
+            }
+        }
+        else {
+            this.RECRAWL_WARNINGS.push(new RecrawlWarning(root, count));
+            return false;
+        }
+    }
+}
+exports.default = RecrawlWarning;