@expo/metro-file-map 55.0.0-0

package/build/watchers/WatchmanWatcher.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 { AbstractWatcher } from './AbstractWatcher';
+import type { WatcherOptions } from './common';
+/**
+ * Watches `dir`.
+ */
+export default class WatchmanWatcher extends AbstractWatcher {
+    #private;
+    readonly subscriptionName: string;
+    constructor(dir: string, opts: WatcherOptions);
+    startWatching(): Promise<void>;
+    /**
+     * Closes the watcher.
+     */
+    stopWatching(): Promise<void>;
+    getPauseReason(): string | undefined | null;
+}

package/build/watchers/WatchmanWatcher.js

@@ -0,0 +1,263 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const crypto_1 = require("crypto");
+const fb_watchman_1 = __importDefault(require("fb-watchman"));
+const invariant_1 = __importDefault(require("invariant"));
+const AbstractWatcher_1 = require("./AbstractWatcher");
+const RecrawlWarning_1 = __importDefault(require("./RecrawlWarning"));
+const common = __importStar(require("./common"));
+const normalizePathSeparatorsToSystem_1 = __importDefault(require("../lib/normalizePathSeparatorsToSystem"));
+const debug = require('debug')('Metro:WatchmanWatcher');
+const DELETE_EVENT = common.DELETE_EVENT;
+const TOUCH_EVENT = common.TOUCH_EVENT;
+const SUB_PREFIX = 'metro-file-map';
+/**
+ * Watches `dir`.
+ */
+class WatchmanWatcher extends AbstractWatcher_1.AbstractWatcher {
+    #client;
+    subscriptionName;
+    #watchProjectInfo;
+    #watchmanDeferStates;
+    #deferringStates = null;
+    constructor(dir, opts) {
+        const { watchmanDeferStates, ...baseOpts } = opts;
+        super(dir, baseOpts);
+        this.#watchmanDeferStates = watchmanDeferStates;
+        // Use a unique subscription name per process per watched directory
+        const watchKey = (0, crypto_1.createHash)('md5').update(this.root).digest('hex');
+        const readablePath = this.root
+            .replace(/[/\\]/g, '-') // \ and / to -
+            .replace(/[^\-\w]/g, ''); // Remove non-word/hyphen
+        this.subscriptionName = `${SUB_PREFIX}-${process.pid}-${readablePath}-${watchKey}`;
+    }
+    async startWatching() {
+        await new Promise((resolve, reject) => this.#init(resolve, reject));
+    }
+    /**
+     * Run the watchman `watch` command on the root and subscribe to changes.
+     */
+    #init(onReady, onError) {
+        if (this.#client) {
+            this.#client.removeAllListeners();
+        }
+        const self = this;
+        this.#client = new fb_watchman_1.default.Client();
+        this.#client.on('error', (error) => {
+            this.emitError(error);
+        });
+        this.#client.on('subscription', (changeEvent) => this.#handleChangeEvent(changeEvent));
+        this.#client.on('end', () => {
+            console.warn('[metro-file-map] Warning: Lost connection to Watchman, reconnecting..');
+            self.#init(() => { }, (error) => self.emitError(error));
+        });
+        this.#watchProjectInfo = null;
+        function getWatchRoot() {
+            return self.#watchProjectInfo ? self.#watchProjectInfo.root : self.root;
+        }
+        function onWatchProject(error, resp) {
+            if (error) {
+                onError(error);
+                return;
+            }
+            debug('Received watch-project response: %s', resp.relative_path);
+            handleWarning(resp);
+            // NB: Watchman outputs posix-separated paths even on Windows, convert
+            // them to system-native separators.
+            self.#watchProjectInfo = {
+                relativePath: resp.relative_path ? (0, normalizePathSeparatorsToSystem_1.default)(resp.relative_path) : '',
+                root: (0, normalizePathSeparatorsToSystem_1.default)(resp.watch),
+            };
+            self.#client.command(['clock', getWatchRoot()], onClock);
+        }
+        function onClock(error, resp) {
+            if (error) {
+                onError(error);
+                return;
+            }
+            debug('Received clock response: %s', resp.clock);
+            const watchProjectInfo = self.#watchProjectInfo;
+            (0, invariant_1.default)(watchProjectInfo != null, 'watch-project response should have been set before clock response');
+            handleWarning(resp);
+            const options = {
+                fields: ['name', 'exists', 'new', 'type', 'size', 'mtime_ms'],
+                since: resp.clock,
+                defer: self.#watchmanDeferStates,
+                relative_root: watchProjectInfo.relativePath,
+            };
+            // Make sure we honor the dot option if even we're not using globs.
+            if (self.globs.length === 0 && !self.dot) {
+                options.expression = [
+                    'match',
+                    '**',
+                    'wholename',
+                    {
+                        includedotfiles: false,
+                    },
+                ];
+            }
+            self.#client.command(['subscribe', getWatchRoot(), self.subscriptionName, options], onSubscribe);
+        }
+        const onSubscribe = (error, resp) => {
+            if (error) {
+                onError(error);
+                return;
+            }
+            debug('Received subscribe response: %s', resp.subscribe);
+            handleWarning(resp);
+            if (resp['asserted-states'] != null) {
+                this.#deferringStates = new Set(resp['asserted-states']);
+            }
+            onReady();
+        };
+        self.#client.command(['watch-project', getWatchRoot()], onWatchProject);
+    }
+    /**
+     * Handles a change event coming from the subscription.
+     */
+    #handleChangeEvent(resp) {
+        debug('Received subscription response: %s (fresh: %s, files: %s, enter: %s, leave: %s, clock: %s)', resp.subscription, resp.is_fresh_instance, resp.files?.length, resp['state-enter'], resp['state-leave'], resp.clock);
+        assert_1.default.equal(resp.subscription, this.subscriptionName, 'Invalid subscription event.');
+        if (Array.isArray(resp.files)) {
+            resp.files.forEach((change) => this.#handleFileChange(change, resp.clock));
+        }
+        const { 'state-enter': stateEnter, 'state-leave': stateLeave } = resp;
+        if (stateEnter != null && (this.#watchmanDeferStates ?? []).includes(stateEnter)) {
+            this.#deferringStates?.add(stateEnter);
+            debug('Watchman reports "%s" just started. Filesystem notifications are paused.', stateEnter);
+        }
+        if (stateLeave != null && (this.#watchmanDeferStates ?? []).includes(stateLeave)) {
+            this.#deferringStates?.delete(stateLeave);
+            debug('Watchman reports "%s" ended. Filesystem notifications resumed.', stateLeave);
+        }
+    }
+    /**
+     * Handles a single change event record.
+     */
+    #handleFileChange(changeDescriptor, rawClock) {
+        const self = this;
+        const watchProjectInfo = self.#watchProjectInfo;
+        (0, invariant_1.default)(watchProjectInfo != null, 'watch-project response should have been set before receiving subscription events');
+        const { name: relativePosixPath, new: isNew = false, exists = false, type, mtime_ms, size, } = changeDescriptor;
+        // Watchman emits posix-separated paths on Windows, which is inconsistent
+        // with other watchers. Normalize to system-native separators.
+        const relativePath = (0, normalizePathSeparatorsToSystem_1.default)(relativePosixPath);
+        debug('Handling change to: %s (new: %s, exists: %s, type: %s)', relativePath, isNew, exists, type);
+        // Ignore files of an unrecognized type
+        if (type != null && !(type === 'f' || type === 'd' || type === 'l')) {
+            return;
+        }
+        if (this.doIgnore(relativePath) ||
+            !common.includedByGlob(type, this.globs, this.dot, relativePath)) {
+            return;
+        }
+        const clock = typeof rawClock === 'string' && this.#watchProjectInfo != null
+            ? [this.#watchProjectInfo.root, rawClock]
+            : undefined;
+        if (!exists) {
+            self.emitFileEvent({ event: DELETE_EVENT, clock, relativePath });
+        }
+        else {
+            (0, invariant_1.default)(type != null && mtime_ms != null && size != null, 'Watchman file change event for "%s" missing some requested metadata. ' +
+                'Got type: %s, mtime_ms: %s, size: %s', relativePath, type, mtime_ms, size);
+            if (
+            // Change event on dirs are mostly useless.
+            !(type === 'd' && !isNew)) {
+                const mtime = Number(mtime_ms);
+                self.emitFileEvent({
+                    event: TOUCH_EVENT,
+                    clock,
+                    relativePath,
+                    metadata: {
+                        modifiedTime: mtime !== 0 ? mtime : null,
+                        size,
+                        type,
+                    },
+                });
+            }
+        }
+    }
+    /**
+     * Closes the watcher.
+     */
+    async stopWatching() {
+        await super.stopWatching();
+        if (this.#client) {
+            this.#client.removeAllListeners();
+            this.#client.end();
+        }
+        this.#deferringStates = null;
+    }
+    getPauseReason() {
+        if (this.#deferringStates == null || this.#deferringStates.size === 0) {
+            return null;
+        }
+        const states = [...this.#deferringStates];
+        if (states.length === 1) {
+            return `The watch is in the '${states[0]}' state.`;
+        }
+        return `The watch is in the ${states
+            .slice(0, -1)
+            .map((s) => `'${s}'`)
+            .join(', ')} and '${states[states.length - 1]}' states.`;
+    }
+}
+exports.default = WatchmanWatcher;
+/**
+ * Handles a warning in the watchman resp object.
+ */
+function handleWarning(resp) {
+    if ('warning' in resp) {
+        if (RecrawlWarning_1.default.isRecrawlWarningDupe(resp.warning)) {
+            return true;
+        }
+        console.warn(resp.warning);
+        return true;
+    }
+    else {
+        return false;
+    }
+}

package/build/watchers/common.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.
+ *
+ * Originally vendored from
+ * https://github.com/amasad/sane/blob/64ff3a870c42e84f744086884bf55a4f9c22d376/src/common.js
+ */
+import type { Stats } from 'fs';
+import type { ChangeEventMetadata } from '../types';
+export declare const DELETE_EVENT = "delete";
+export declare const TOUCH_EVENT = "touch";
+export declare const RECRAWL_EVENT = "recrawl";
+export declare const ALL_EVENT = "all";
+export interface WatcherOptions {
+    readonly globs: readonly string[];
+    readonly dot: boolean;
+    readonly ignored: RegExp | null | undefined;
+    readonly watchmanDeferStates: readonly string[];
+    readonly watchman?: unknown;
+    readonly watchmanPath?: string;
+}
+/**
+ * Checks a file relative path against the globs array.
+ */
+export declare function includedByGlob(type: 'f' | 'l' | 'd' | null | undefined, globs: readonly string[], dot: boolean, relativePath: string): boolean;
+/**
+ * Whether the given filePath matches the given RegExp, after converting
+ * (on Windows only) system separators to posix separators.
+ *
+ * Conversion to posix is for backwards compatibility with the previous
+ * anymatch matcher, which normlises all inputs[1]. This may not be consistent
+ * with other parts of metro-file-map.
+ *
+ * [1]: https://github.com/micromatch/anymatch/blob/3.1.1/index.js#L50
+ */
+export declare const posixPathMatchesPattern: (pattern: RegExp, filePath: string) => boolean;
+export declare function typeFromStat(stat: Stats): ChangeEventMetadata['type'] | null;

package/build/watchers/common.js

@@ -0,0 +1,60 @@
+"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/common.js
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.posixPathMatchesPattern = exports.ALL_EVENT = exports.RECRAWL_EVENT = exports.TOUCH_EVENT = exports.DELETE_EVENT = void 0;
+exports.includedByGlob = includedByGlob;
+exports.typeFromStat = typeFromStat;
+const micromatch_1 = __importDefault(require("micromatch"));
+const path_1 = __importDefault(require("path"));
+exports.DELETE_EVENT = 'delete';
+exports.TOUCH_EVENT = 'touch';
+exports.RECRAWL_EVENT = 'recrawl';
+exports.ALL_EVENT = 'all';
+/**
+ * Checks a file relative path against the globs array.
+ */
+function includedByGlob(type, globs, dot, relativePath) {
+    // For non-regular files or if there are no glob matchers, just respect the
+    // `dot` option to filter dotfiles if dot === false.
+    if (globs.length === 0 || type !== 'f') {
+        return dot || micromatch_1.default.some(relativePath, '**/*');
+    }
+    return micromatch_1.default.some(relativePath, globs, { dot });
+}
+/**
+ * Whether the given filePath matches the given RegExp, after converting
+ * (on Windows only) system separators to posix separators.
+ *
+ * Conversion to posix is for backwards compatibility with the previous
+ * anymatch matcher, which normlises all inputs[1]. This may not be consistent
+ * with other parts of metro-file-map.
+ *
+ * [1]: https://github.com/micromatch/anymatch/blob/3.1.1/index.js#L50
+ */
+exports.posixPathMatchesPattern = path_1.default.sep === '/'
+    ? (pattern, filePath) => pattern.test(filePath)
+    : (pattern, filePath) => pattern.test(filePath.replaceAll(path_1.default.sep, '/'));
+function typeFromStat(stat) {
+    // Note: These tests are not mutually exclusive - a symlink passes isFile
+    if (stat.isSymbolicLink()) {
+        return 'l';
+    }
+    if (stat.isDirectory()) {
+        return 'd';
+    }
+    if (stat.isFile()) {
+        return 'f'; // "Regular" file
+    }
+    return null;
+}

package/build/worker.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.
+ */
+import type { WorkerMessage, WorkerMetadata, WorkerSetupArgs } from './types';
+/**
+ * Exposed for use outside a jest-worker context, ie when processing in-band.
+ */
+export declare class Worker {
+    #private;
+    constructor({ plugins }: WorkerSetupArgs);
+    processFile(data: WorkerMessage): Promise<WorkerMetadata>;
+}
+/**
+ * Called automatically by jest-worker before the first call to `worker` when
+ * this module is used as worker thread or child process.
+ */
+export declare function setup(args: WorkerSetupArgs): void;
+/**
+ * Called by jest-worker with each workload
+ */
+export declare function processFile(data: WorkerMessage): Promise<WorkerMetadata>;

package/build/worker.js

@@ -0,0 +1,80 @@
+"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.Worker = void 0;
+exports.setup = setup;
+exports.processFile = processFile;
+const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
+function sha1hex(content) {
+    return (0, crypto_1.createHash)('sha1').update(content).digest('hex');
+}
+/**
+ * Exposed for use outside a jest-worker context, ie when processing in-band.
+ */
+class Worker {
+    #plugins;
+    constructor({ plugins = [] }) {
+        this.#plugins = plugins.map(({ modulePath, setupArgs }) => {
+            const mod = require(modulePath);
+            const PluginWorker = mod.__esModule === true && 'default' in mod ? mod.default : mod;
+            return new PluginWorker(setupArgs);
+        });
+    }
+    async processFile(data) {
+        let contentPromise;
+        let sha1Promise;
+        const { computeSha1, filePath, pluginsToRun } = data;
+        const getContent = () => {
+            if (contentPromise == null) {
+                contentPromise = fs_1.default.promises.readFile(filePath);
+            }
+            return contentPromise;
+        };
+        const workerUtils = { getContent };
+        const pluginDataPromise = Promise.all(pluginsToRun.map((pluginIdx) => this.#plugins[pluginIdx].processFile(data, workerUtils)));
+        // If a SHA-1 is requested on update, compute it.
+        if (computeSha1) {
+            sha1Promise = getContent().then(sha1hex);
+        }
+        return contentPromise != null && data.maybeReturnContent
+            ? {
+                content: await contentPromise,
+                pluginData: await pluginDataPromise,
+                sha1: await sha1Promise,
+            }
+            : {
+                pluginData: await pluginDataPromise,
+                sha1: await sha1Promise,
+            };
+    }
+}
+exports.Worker = Worker;
+let singletonWorker;
+/**
+ * Called automatically by jest-worker before the first call to `worker` when
+ * this module is used as worker thread or child process.
+ */
+function setup(args) {
+    if (singletonWorker) {
+        throw new Error('metro-file-map: setup() should only be called once');
+    }
+    singletonWorker = new Worker(args);
+}
+/**
+ * Called by jest-worker with each workload
+ */
+async function processFile(data) {
+    if (!singletonWorker) {
+        throw new Error('metro-file-map: setup() must be called before processFile()');
+    }
+    return singletonWorker.processFile(data);
+}

package/build/workerExclusionList.d.ts

@@ -0,0 +1,8 @@
+/**
+ * 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.
+ */
+declare const extensions: ReadonlySet<string>;
+export default extensions;

package/build/workerExclusionList.js

@@ -0,0 +1,57 @@
+"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 });
+// This list is compiled after the MDN list of the most common MIME types (see
+// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/
+// Complete_list_of_MIME_types).
+//
+// Only MIME types starting with "image/", "video/", "audio/" and "font/" are
+// reflected in the list. Adding "application/" is too risky since some text
+// file formats (like ".js" and ".json") have an "application/" MIME type.
+//
+// Feel free to add any extensions that cannot be a Haste module.
+const extensions = new Set([
+    // JSONs are never haste modules, except for "package.json", which is handled.
+    '.json',
+    // Image extensions.
+    '.bmp',
+    '.gif',
+    '.ico',
+    '.jpeg',
+    '.jpg',
+    '.png',
+    '.svg',
+    '.tiff',
+    '.tif',
+    '.webp',
+    // Video extensions.
+    '.avi',
+    '.mp4',
+    '.mpeg',
+    '.mpg',
+    '.ogv',
+    '.webm',
+    '.3gp',
+    '.3g2',
+    // Audio extensions.
+    '.aac',
+    '.midi',
+    '.mid',
+    '.mp3',
+    '.oga',
+    '.wav',
+    '.3gp',
+    '.3g2',
+    // Font extensions.
+    '.eot',
+    '.otf',
+    '.ttf',
+    '.woff',
+    '.woff2',
+]);
+exports.default = extensions;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@expo/metro-file-map",
+  "version": "55.0.0-0",
+  "description": "A metro-file-map fork for Expo used with the Metro bundler",
+  "main": "build/index.js",
+  "types": "build/index.d.ts",
+  "scripts": {
+    "build": "expo-module tsc",
+    "clean": "expo-module clean",
+    "lint": "expo-module lint",
+    "prepublishOnly": "pnpm run clean && pnpm run build",
+    "test": "expo-module test",
+    "typecheck": "expo-module typecheck",
+    "watch": "expo-module tsc --watch --preserveWatchOutput"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/expo/expo.git",
+    "directory": "packages/@expo/metro-file-map"
+  },
+  "keywords": [
+    "expo",
+    "metro"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/expo/expo/issues"
+  },
+  "homepage": "https://github.com/expo/expo/tree/main/packages/@expo/metro-file-map#readme",
+  "files": [
+    "build"
+  ],
+  "dependencies": {
+    "debug": "^4.3.4",
+    "fb-watchman": "^2.0.2",
+    "invariant": "^2.2.4",
+    "jest-worker": "^29.7.0",
+    "micromatch": "^4.0.4",
+    "walker": "^1.0.8"
+  },
+  "devDependencies": {
+    "@expo/metro": "56.0.0-rc.2",
+    "@types/debug": "^4.1.7",
+    "@types/fb-watchman": "^2.0.6",
+    "@types/invariant": "^2.2.37",
+    "@types/micromatch": "^4.0.10",
+    "@types/node": "^22.14.0",
+    "expo-module-scripts": "workspace:*",
+    "memfs": "^3.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}