@expo/metro-file-map 55.0.0-0

package/README.md

@@ -0,0 +1 @@
+# `@expo/metro-file-map`

package/build/Watcher.d.ts

@@ -0,0 +1,53 @@
+/**
+ * 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 EventEmitter from 'events';
+import type { Console, CrawlerOptions, CrawlResult, PerfLogger, WatcherBackendChangeEvent } from './types';
+interface WatcherOptions {
+    abortSignal: AbortSignal;
+    computeSha1: boolean;
+    console: Console;
+    enableSymlinks: boolean;
+    extensions: readonly string[];
+    /** @deprecated */
+    forceNodeFilesystemAPI?: boolean;
+    healthCheckFilePrefix: string;
+    ignoreForCrawl: (filePath: string) => boolean;
+    ignorePatternForWatch: RegExp;
+    previousState: CrawlerOptions['previousState'];
+    perfLogger: PerfLogger | undefined | null;
+    roots: readonly string[];
+    rootDir: string;
+    useWatchman: boolean;
+    watch: boolean;
+    watchmanDeferStates: readonly string[];
+}
+export type HealthCheckResult = {
+    type: 'error';
+    timeout: number;
+    error: Error;
+    watcher: string | undefined | null;
+} | {
+    type: 'success';
+    timeout: number;
+    timeElapsed: number;
+    watcher: string | undefined | null;
+} | {
+    type: 'timeout';
+    timeout: number;
+    watcher: string | undefined | null;
+    pauseReason: string | undefined | null;
+};
+export declare class Watcher extends EventEmitter {
+    #private;
+    constructor(options: WatcherOptions);
+    crawl(): Promise<CrawlResult>;
+    recrawl(subpath: string, currentFileSystem: CrawlerOptions['previousState']['fileSystem']): Promise<CrawlResult>;
+    watch(onChange: (change: WatcherBackendChangeEvent) => void): Promise<void>;
+    close(): Promise<void>;
+    checkHealth(timeout: number): Promise<HealthCheckResult>;
+}
+export {};

package/build/Watcher.js

@@ -0,0 +1,249 @@
+"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.Watcher = void 0;
+const events_1 = __importDefault(require("events"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const perf_hooks_1 = require("perf_hooks");
+const node_1 = __importDefault(require("./crawlers/node"));
+const watchman_1 = __importDefault(require("./crawlers/watchman"));
+const FallbackWatcher_1 = __importDefault(require("./watchers/FallbackWatcher"));
+const NativeWatcher_1 = __importDefault(require("./watchers/NativeWatcher"));
+const WatchmanWatcher_1 = __importDefault(require("./watchers/WatchmanWatcher"));
+const common_1 = require("./watchers/common");
+const debug = require('debug')('Metro:Watcher');
+const MAX_WAIT_TIME = 240000;
+let nextInstanceId = 0;
+class Watcher extends events_1.default {
+    #activeWatcher;
+    #backends = [];
+    #instanceId;
+    #nextHealthCheckId = 0;
+    #options;
+    #pendingHealthChecks = new Map();
+    constructor(options) {
+        super();
+        this.#options = options;
+        this.#instanceId = nextInstanceId++;
+    }
+    async crawl() {
+        this.#options.perfLogger?.point('crawl_start');
+        const options = this.#options;
+        const result = await this.#crawl({
+            previousState: options.previousState,
+            roots: options.roots,
+            useWatchman: options.useWatchman,
+        });
+        this.#options.perfLogger?.point('crawl_end');
+        return result;
+    }
+    async recrawl(subpath, currentFileSystem) {
+        return this.#crawl({
+            previousState: {
+                clocks: new Map(),
+                fileSystem: currentFileSystem,
+            },
+            roots: [path_1.default.join(this.#options.rootDir, subpath)],
+            subpath,
+            useWatchman: false,
+        });
+    }
+    async #crawl(crawlOptions) {
+        const options = this.#options;
+        const { useWatchman, subpath } = crawlOptions;
+        const ignoreForCrawl = (filePath) => options.ignoreForCrawl(filePath) ||
+            path_1.default.basename(filePath).startsWith(this.#options.healthCheckFilePrefix);
+        const crawl = useWatchman ? watchman_1.default : node_1.default;
+        let crawler = crawl === watchman_1.default ? 'watchman' : 'node';
+        options.abortSignal.throwIfAborted();
+        const crawlerOptions = {
+            abortSignal: options.abortSignal,
+            computeSha1: options.computeSha1,
+            console: options.console,
+            includeSymlinks: options.enableSymlinks,
+            extensions: options.extensions,
+            forceNodeFilesystemAPI: options.forceNodeFilesystemAPI,
+            ignore: ignoreForCrawl,
+            onStatus: (status) => {
+                this.emit('status', status);
+            },
+            perfLogger: options.perfLogger,
+            previousState: crawlOptions.previousState,
+            rootDir: options.rootDir,
+            roots: crawlOptions.roots,
+            subpath,
+        };
+        debug('Crawling roots: %s with %s crawler.', crawlOptions.roots, crawler);
+        let delta;
+        try {
+            delta = await crawl(crawlerOptions);
+        }
+        catch (firstError) {
+            if (crawl !== watchman_1.default) {
+                throw firstError;
+            }
+            crawler = 'node';
+            options.console.warn('metro-file-map: Watchman crawl failed. Retrying once with node ' +
+                'crawler.\n' +
+                "  Usually this happens when watchman isn't running. Create an " +
+                "empty `.watchmanconfig` file in your project's root folder or " +
+                'initialize a git or hg repository in your project.\n' +
+                '  ' +
+                firstError.toString());
+            try {
+                delta = await (0, node_1.default)(crawlerOptions);
+            }
+            catch (retryError) {
+                throw new Error('Crawler retry failed:\n' +
+                    `  Original error: ${firstError.message}\n` +
+                    `  Retry error: ${retryError.message}\n`);
+            }
+        }
+        debug('Crawler "%s" returned %d added/modified, %d removed, %d clock(s).', crawler, delta.changedFiles.size, delta.removedFiles.size, 'clocks' in delta ? (delta.clocks?.size ?? 0) : 0);
+        return delta;
+    }
+    async watch(onChange) {
+        const { extensions, ignorePatternForWatch, useWatchman } = this.#options;
+        // WatchmanWatcher > NativeWatcher > FallbackWatcher
+        const WatcherImpl = (useWatchman
+            ? WatchmanWatcher_1.default
+            : NativeWatcher_1.default.isSupported()
+                ? NativeWatcher_1.default
+                : FallbackWatcher_1.default);
+        let watcher = 'fallback';
+        if (WatcherImpl === WatchmanWatcher_1.default) {
+            watcher = 'watchman';
+        }
+        else if (WatcherImpl === NativeWatcher_1.default) {
+            watcher = 'native';
+        }
+        debug(`Using watcher: ${watcher}`);
+        this.#options.perfLogger?.annotate({ string: { watcher } });
+        this.#activeWatcher = watcher;
+        const createWatcherBackend = (root) => {
+            const watcherOptions = {
+                dot: true,
+                globs: [
+                    // Ensure we always include package.json files, which are crucial for
+                    /// module resolution.
+                    '**/package.json',
+                    // Ensure we always watch any health check files
+                    '**/' + this.#options.healthCheckFilePrefix + '*',
+                    ...extensions.map((extension) => '**/*.' + extension),
+                ],
+                ignored: ignorePatternForWatch,
+                watchmanDeferStates: this.#options.watchmanDeferStates,
+            };
+            const watcher = new WatcherImpl(root, watcherOptions);
+            return new Promise(async (resolve, reject) => {
+                const rejectTimeout = setTimeout(() => reject(new Error('Failed to start watch mode.')), MAX_WAIT_TIME);
+                watcher.onFileEvent((change) => {
+                    const basename = path_1.default.basename(change.relativePath);
+                    if (basename.startsWith(this.#options.healthCheckFilePrefix)) {
+                        if (change.event === common_1.TOUCH_EVENT) {
+                            debug('Observed possible health check cookie: %s in %s', change.relativePath, root);
+                            this.#handleHealthCheckObservation(basename);
+                        }
+                        return;
+                    }
+                    // Watchman handles recrawls internally - receiving a recrawl event
+                    // when using Watchman would indicate a bug. Log an error and ignore.
+                    if (change.event === 'recrawl' && useWatchman) {
+                        this.#options.console.error('metro-file-map: Received unexpected recrawl event while using ' +
+                            'Watchman. Watchman recrawls are not implemented.');
+                        return;
+                    }
+                    onChange(change);
+                });
+                await watcher.startWatching();
+                clearTimeout(rejectTimeout);
+                resolve(watcher);
+            });
+        };
+        this.#backends = await Promise.all(this.#options.roots.map(createWatcherBackend));
+    }
+    #handleHealthCheckObservation(basename) {
+        const resolveHealthCheck = this.#pendingHealthChecks.get(basename);
+        if (!resolveHealthCheck) {
+            return;
+        }
+        resolveHealthCheck();
+    }
+    async close() {
+        await Promise.all(this.#backends.map((watcher) => watcher.stopWatching()));
+        this.#activeWatcher = null;
+    }
+    async checkHealth(timeout) {
+        const healthCheckId = this.#nextHealthCheckId++;
+        if (healthCheckId === Number.MAX_SAFE_INTEGER) {
+            this.#nextHealthCheckId = 0;
+        }
+        const watcher = this.#activeWatcher;
+        const basename = this.#options.healthCheckFilePrefix +
+            '-' +
+            process.pid +
+            '-' +
+            this.#instanceId +
+            '-' +
+            healthCheckId;
+        const healthCheckPath = path_1.default.join(this.#options.rootDir, basename);
+        let result;
+        const timeoutPromise = new Promise((resolve) => setTimeout(resolve, timeout)).then(() => {
+            if (!result) {
+                result = {
+                    type: 'timeout',
+                    pauseReason: this.#backends[0]?.getPauseReason(),
+                    timeout,
+                    watcher,
+                };
+            }
+        });
+        const startTime = perf_hooks_1.performance.now();
+        debug('Creating health check cookie: %s', healthCheckPath);
+        const creationPromise = fs_1.default.promises
+            .writeFile(healthCheckPath, String(startTime))
+            .catch((error) => {
+            if (!result) {
+                result = {
+                    type: 'error',
+                    error,
+                    timeout,
+                    watcher,
+                };
+            }
+        });
+        const observationPromise = new Promise((resolve) => {
+            this.#pendingHealthChecks.set(basename, resolve);
+        }).then(() => {
+            if (!result) {
+                result = {
+                    type: 'success',
+                    timeElapsed: perf_hooks_1.performance.now() - startTime,
+                    timeout,
+                    watcher,
+                };
+            }
+        });
+        await Promise.race([timeoutPromise, creationPromise.then(() => observationPromise)]);
+        this.#pendingHealthChecks.delete(basename);
+        // Chain a deletion to the creation promise (which may not have even settled yet!),
+        // don't await it, and swallow errors. This is just best-effort cleanup.
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        creationPromise.then(() => fs_1.default.promises.unlink(healthCheckPath).catch(() => { }));
+        debug('Health check result: %o', result);
+        if (result == null) {
+            throw new Error('health check result was not set by any promise branch');
+        }
+        return result;
+    }
+}
+exports.Watcher = Watcher;

package/build/cache/DiskCacheManager.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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 { BuildParameters, CacheData, CacheManager, CacheManagerFactoryOptions, CacheManagerWriteOptions } from '../types';
+interface AutoSaveOptions {
+    readonly debounceMs: number;
+}
+interface DiskCacheConfig {
+    readonly autoSave?: Partial<AutoSaveOptions> | boolean | undefined;
+    readonly cacheFilePrefix?: string | undefined | null;
+    readonly cacheDirectory?: string | undefined | null;
+}
+export declare class DiskCacheManager implements CacheManager {
+    #private;
+    constructor({ buildParameters }: CacheManagerFactoryOptions, { autoSave, cacheDirectory, cacheFilePrefix }: DiskCacheConfig);
+    static getCacheFilePath(buildParameters: BuildParameters, cacheFilePrefix?: string | null, cacheDirectory?: string | null): string;
+    getCacheFilePath(): string;
+    read(): Promise<CacheData | undefined | null>;
+    write(getSnapshot: () => CacheData, { changedSinceCacheRead, eventSource, onWriteError }: CacheManagerWriteOptions): Promise<void>;
+    end(): Promise<void>;
+}
+export {};

package/build/cache/DiskCacheManager.js

@@ -0,0 +1,110 @@
+"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.DiskCacheManager = void 0;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = __importDefault(require("path"));
+const timers_1 = require("timers");
+const v8_1 = require("v8");
+const rootRelativeCacheKeys_1 = __importDefault(require("../lib/rootRelativeCacheKeys"));
+const debug = require('debug')('Metro:FileMapCache');
+const DEFAULT_PREFIX = 'metro-file-map';
+const DEFAULT_DIRECTORY = (0, os_1.tmpdir)();
+const DEFAULT_AUTO_SAVE_DEBOUNCE_MS = 5000;
+// NOTE(@kitten): We're incompatible with Metro, so need our own naming
+const FIXED_PREFIX = 'expo';
+class DiskCacheManager {
+    #autoSaveOpts;
+    #cachePath;
+    #debounceTimeout = null;
+    #writePromise = Promise.resolve();
+    #hasUnwrittenChanges = false;
+    #tryWrite;
+    #stopListening;
+    constructor({ buildParameters }, { autoSave = {}, cacheDirectory, cacheFilePrefix }) {
+        this.#cachePath = DiskCacheManager.getCacheFilePath(buildParameters, cacheFilePrefix, cacheDirectory);
+        // Normalise auto-save options.
+        if (autoSave) {
+            const { debounceMs = DEFAULT_AUTO_SAVE_DEBOUNCE_MS } = autoSave === true ? {} : autoSave;
+            this.#autoSaveOpts = { debounceMs };
+        }
+    }
+    static getCacheFilePath(buildParameters, cacheFilePrefix, cacheDirectory) {
+        const { rootDirHash, relativeConfigHash } = (0, rootRelativeCacheKeys_1.default)(buildParameters);
+        return path_1.default.join(cacheDirectory ?? DEFAULT_DIRECTORY, `${cacheFilePrefix ?? DEFAULT_PREFIX}-${FIXED_PREFIX}-${rootDirHash}-${relativeConfigHash}`);
+    }
+    getCacheFilePath() {
+        return this.#cachePath;
+    }
+    async read() {
+        try {
+            return (0, v8_1.deserialize)(await fs_1.promises.readFile(this.#cachePath));
+        }
+        catch (e) {
+            if (e?.code === 'ENOENT') {
+                // Cache file not found - not considered an error.
+                return null;
+            }
+            // Rethrow anything else.
+            throw e;
+        }
+    }
+    async write(getSnapshot, { changedSinceCacheRead, eventSource, onWriteError }) {
+        // Initialise a writer function using a promise queue to ensure writes are
+        // sequenced.
+        // eslint-disable-next-line no-multi-assign
+        const tryWrite = (this.#tryWrite = () => {
+            this.#writePromise = this.#writePromise
+                .then(async () => {
+                if (!this.#hasUnwrittenChanges) {
+                    return;
+                }
+                const data = getSnapshot();
+                this.#hasUnwrittenChanges = false;
+                await fs_1.promises.writeFile(this.#cachePath, (0, v8_1.serialize)(data));
+                debug('Written cache to %s', this.#cachePath);
+            })
+                .catch(onWriteError);
+            return this.#writePromise;
+        });
+        // Set up auto-save on changes, if enabled.
+        if (this.#autoSaveOpts) {
+            const autoSave = this.#autoSaveOpts;
+            this.#stopListening?.();
+            this.#stopListening = eventSource.onChange(() => {
+                this.#hasUnwrittenChanges = true;
+                if (this.#debounceTimeout) {
+                    this.#debounceTimeout.refresh();
+                }
+                else {
+                    this.#debounceTimeout = (0, timers_1.setTimeout)(() => tryWrite(), autoSave.debounceMs).unref();
+                }
+            });
+        }
+        // Write immediately if state has changed since the cache was read.
+        if (changedSinceCacheRead) {
+            this.#hasUnwrittenChanges = true;
+            await tryWrite();
+        }
+    }
+    async end() {
+        // Clear any timers
+        if (this.#debounceTimeout) {
+            (0, timers_1.clearTimeout)(this.#debounceTimeout);
+        }
+        // Remove event listeners
+        this.#stopListening?.();
+        // Flush unwritten changes to disk (no-op if no changes)
+        await this.#tryWrite?.();
+    }
+}
+exports.DiskCacheManager = DiskCacheManager;

package/build/constants.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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 interface HType {
+    readonly MTIME: 0;
+    readonly SIZE: 1;
+    readonly VISITED: 2;
+    readonly SHA1: 3;
+    readonly SYMLINK: 4;
+    readonly PLUGINDATA: 5;
+    readonly PATH: 0;
+    readonly TYPE: 1;
+    readonly MODULE: 0;
+    readonly PACKAGE: 1;
+    readonly GENERIC_PLATFORM: 'g';
+    readonly NATIVE_PLATFORM: 'native';
+}
+export type HTypeValue = 0 | 1 | 2 | 3 | 4 | 5 | 'g' | 'native';
+declare const H: HType;
+export default H;

package/build/constants.js

@@ -0,0 +1,27 @@
+"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 });
+const H = {
+    /* file map attributes */
+    MTIME: 0,
+    SIZE: 1,
+    VISITED: 2,
+    SHA1: 3,
+    SYMLINK: 4,
+    PLUGINDATA: 5,
+    /* module map attributes */
+    PATH: 0,
+    TYPE: 1,
+    /* module types */
+    MODULE: 0,
+    PACKAGE: 1,
+    /* platforms */
+    GENERIC_PLATFORM: 'g',
+    NATIVE_PLATFORM: 'native',
+};
+exports.default = H;

package/build/crawlers/node/fallback.d.ts

@@ -0,0 +1,20 @@
+import { RootPathUtils } from '../../lib/RootPathUtils';
+import type { FallbackFilesystem, IgnoreMatcher } from '../../types';
+type FallbackFilesystemOptions = {
+    rootPathUtils: RootPathUtils;
+    extensions: readonly string[];
+    ignore: IgnoreMatcher;
+    includeSymlinks: boolean;
+};
+/**
+ * Create a FallbackFilesystem that synchronously queries the real filesystem.
+ *
+ * - `lookup` uses lstatSync to check a single path (for traversal).
+ * - `readdir` uses readdirSync to list directory contents (for enumeration).
+ *
+ * Both methods apply the same filtering as the node crawler: ignore patterns,
+ * extension filtering, and symlink inclusion.
+ */
+export default function createFallbackFilesystem(opts: FallbackFilesystemOptions): FallbackFilesystem;
+export declare function shouldFallbackCrawlDir(canonicalPath: string): boolean;
+export {};

package/build/crawlers/node/fallback.js

@@ -0,0 +1,148 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createFallbackFilesystem;
+exports.shouldFallbackCrawlDir = shouldFallbackCrawlDir;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const normalizePathSeparatorsToPosix_1 = __importDefault(require("../../lib/normalizePathSeparatorsToPosix"));
+const readdirMarker = Symbol.for('fallbackDir');
+function markDir(dirNode) {
+    dirNode[readdirMarker] = true;
+}
+function isMarkedDir(dirNode) {
+    return !!dirNode[readdirMarker];
+}
+function isDirectory(node) {
+    return node instanceof Map;
+}
+/**
+ * Create a FallbackFilesystem that synchronously queries the real filesystem.
+ *
+ * - `lookup` uses lstatSync to check a single path (for traversal).
+ * - `readdir` uses readdirSync to list directory contents (for enumeration).
+ *
+ * Both methods apply the same filtering as the node crawler: ignore patterns,
+ * extension filtering, and symlink inclusion.
+ */
+function createFallbackFilesystem(opts) {
+    const { rootPathUtils, extensions, ignore, includeSymlinks } = opts;
+    const exts = extensions.reduce((acc, ext) => {
+        acc[ext] = true;
+        return acc;
+    }, {});
+    function readdir(_normalPath, absolutePath, dirNode) {
+        if (dirNode != null && isMarkedDir(dirNode)) {
+            return dirNode;
+        }
+        let dirEntries;
+        try {
+            dirEntries = fs_1.default.readdirSync(absolutePath, { withFileTypes: true });
+        }
+        catch {
+            return null;
+        }
+        const result = dirNode ?? new Map();
+        for (const entry of dirEntries) {
+            const name = entry.name.toString();
+            const childAbsolutePath = absolutePath + path_1.default.sep + name;
+            if (ignore(childAbsolutePath)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                if (!result.has(name)) {
+                    result.set(name, new Map());
+                }
+            }
+            else if (entry.isSymbolicLink()) {
+                // We can skip reading the symlink target here, since it'll be read lazily
+                if (includeSymlinks && !result.has(name)) {
+                    result.set(name, [null, 0, 0, null, 1, null]);
+                }
+            }
+            else if (entry.isFile()) {
+                const ext = path_1.default.extname(name).slice(1);
+                if (exts[ext] && !result.has(name)) {
+                    result.set(name, [null, 0, 0, null, 0, null]);
+                }
+            }
+        }
+        markDir(result);
+        return result;
+    }
+    return {
+        readdir,
+        lookup(normalPath, absolutePath, prevNode) {
+            if (ignore(absolutePath)) {
+                return null;
+            }
+            let stat;
+            try {
+                stat = fs_1.default.lstatSync(absolutePath);
+            }
+            catch {
+                return null;
+            }
+            if (stat.isDirectory()) {
+                const dirNode = isDirectory(prevNode) ? prevNode : null;
+                return shouldFallbackCrawlDir(absolutePath)
+                    ? readdir(normalPath, absolutePath, dirNode)
+                    : (dirNode ?? new Map());
+            }
+            else if (stat.isSymbolicLink()) {
+                if (!includeSymlinks) {
+                    return null;
+                }
+                try {
+                    // We might as well read the symlink target here and assume it'll be used
+                    const symlinkTarget = fs_1.default.readlinkSync(absolutePath);
+                    // Cached value should be in posix format
+                    const target = (0, normalizePathSeparatorsToPosix_1.default)(rootPathUtils.resolveSymlinkToNormal(normalPath, symlinkTarget));
+                    return [stat.mtime.getTime(), stat.size, 0, null, target, null];
+                }
+                catch {
+                    return null;
+                }
+            }
+            else if (stat.isFile()) {
+                // Check extension — symlinks bypass this check (same as node crawler)
+                const ext = path_1.default.extname(absolutePath).slice(1);
+                if (!exts[ext]) {
+                    return null;
+                }
+                else {
+                    return [stat.mtime.getTime(), stat.size, 0, null, 0, null];
+                }
+            }
+            else {
+                return null;
+            }
+        },
+    };
+}
+// Whether a directory at the given canonical path should be eagerly
+// populated via readdir. Returns false for directories that are typically
+// too large (node_modules) or not useful (.git, .hg, etc.) to enumerate.
+function shouldFallbackCrawlDir(canonicalPath) {
+    const lastSepIdx = canonicalPath.lastIndexOf(path_1.default.sep);
+    const baseStart = lastSepIdx + 1;
+    const baseLen = canonicalPath.length - baseStart;
+    if (baseLen === 2 &&
+        canonicalPath.charCodeAt(baseStart) === 46 /*'.'*/ &&
+        canonicalPath.charCodeAt(baseStart + 1) === 46 /*'.'*/) {
+        // '..' is the parent-of-rootDir indirection, not a hidden directory.
+        return true;
+    }
+    else if (canonicalPath.charCodeAt(baseStart) === 46 /*'.'*/) {
+        // starts with '.'
+        return false;
+    }
+    else if (baseLen === 12 && canonicalPath.startsWith('node_modules', baseStart)) {
+        return false;
+    }
+    else {
+        return true;
+    }
+}

package/build/crawlers/node/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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
+ */
+import type { CrawlerOptions, CrawlResult } from '../../types';
+export default function nodeCrawl(options: CrawlerOptions): Promise<CrawlResult>;