@expo/metro-file-map 55.0.0-0

package/build/types.d.ts

@@ -0,0 +1,404 @@
+/**
+ * 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 { PerfLogger, RootPerfLogger } from '@expo/metro/metro-config';
+import type { HType, HTypeValue } from './constants';
+export type { HType, HTypeValue };
+export type { PerfLoggerFactory, PerfLogger } from '@expo/metro/metro-config';
+export interface BuildParameters {
+    readonly computeSha1: boolean;
+    readonly enableSymlinks: boolean;
+    readonly extensions: readonly string[];
+    /** @deprecated */
+    readonly forceNodeFilesystemAPI?: boolean;
+    readonly ignorePattern: RegExp;
+    readonly plugins: readonly InputFileMapPlugin[];
+    readonly retainAllFiles: boolean;
+    readonly rootDir: string;
+    readonly roots: readonly string[];
+    readonly cacheBreaker: string;
+}
+export interface BuildResult {
+    fileSystem: FileSystem;
+}
+export interface CacheData {
+    readonly clocks: WatchmanClocks;
+    readonly fileSystemData: unknown;
+    readonly plugins: ReadonlyMap<string, void | V8Serializable>;
+}
+export interface CacheManager {
+    /**
+     * Called during startup to load initial state, if available. Provided to
+     * a crawler, which will return the delta between the initial state and the
+     * current file system state.
+     */
+    read(): Promise<CacheData | undefined | null>;
+    /**
+     * Called when metro-file-map `build()` has applied changes returned by the
+     * crawler - i.e. internal state reflects the current file system state.
+     *
+     * getSnapshot may be retained and called at any time before end(), such as
+     * in response to eventSource 'change' events.
+     */
+    write(getSnapshot: () => CacheData, opts: CacheManagerWriteOptions): Promise<void>;
+    /**
+     * The last call that will be made to this CacheManager. Any handles should
+     * be closed by the time this settles.
+     */
+    end(): Promise<void>;
+}
+export interface CacheManagerEventSource {
+    onChange(listener: () => void): () => void;
+}
+export type CacheManagerFactory = (options: CacheManagerFactoryOptions) => CacheManager;
+export interface CacheManagerFactoryOptions {
+    readonly buildParameters: BuildParameters;
+}
+export interface CacheManagerWriteOptions {
+    readonly changedSinceCacheRead: boolean;
+    readonly eventSource: CacheManagerEventSource;
+    readonly onWriteError: (error: Error) => void;
+}
+export type CanonicalPath = string;
+export interface ChangedFileMetadata {
+    readonly isSymlink: boolean;
+    readonly modifiedTime?: number | undefined | null;
+}
+export interface ChangeEvent {
+    readonly logger: RootPerfLogger | undefined | null;
+    readonly changes: ReadonlyFileSystemChanges<ChangedFileMetadata>;
+    readonly rootDir: string;
+}
+export interface ChangeEventMetadata {
+    modifiedTime: number | undefined | null;
+    size: number | undefined | null;
+    type: 'f' | 'd' | 'l';
+}
+export type Console = typeof globalThis.console;
+interface CrawlerPreviousState {
+    readonly clocks: ReadonlyMap<CanonicalPath, WatchmanClockSpec>;
+    readonly fileSystem: FileSystem;
+}
+export interface CrawlerOptions {
+    abortSignal: AbortSignal | undefined | null;
+    computeSha1: boolean;
+    console: Console;
+    extensions: readonly string[];
+    /** @deprecated */
+    forceNodeFilesystemAPI?: boolean;
+    ignore: IgnoreMatcher;
+    includeSymlinks: boolean;
+    perfLogger?: PerfLogger | null | undefined;
+    previousState: CrawlerPreviousState;
+    rootDir: string;
+    roots: readonly string[];
+    onStatus: (status: WatcherStatus) => void;
+    subpath?: string;
+}
+export type CrawlResult = {
+    changedFiles: FileData;
+    removedFiles: Set<Path>;
+    clocks: WatchmanClocks;
+} | {
+    changedFiles: FileData;
+    removedFiles: Set<Path>;
+};
+export type DependencyExtractor = {
+    extract: (content: string, absoluteFilePath: string, defaultExtractor?: DependencyExtractor['extract']) => Set<string>;
+    getCacheKey: () => string;
+};
+export type WatcherStatus = {
+    type: 'watchman_slow_command';
+    timeElapsed: number;
+    command: 'watch-project' | 'query';
+} | {
+    type: 'watchman_slow_command_complete';
+    timeElapsed: number;
+    command: 'watch-project' | 'query';
+} | {
+    type: 'watchman_warning';
+    warning: unknown;
+    command: 'watch-project' | 'query';
+};
+export type DuplicatesSet = Map<string, /* type */ number>;
+export type DuplicatesIndex = Map<string, Map<string, DuplicatesSet>>;
+interface FileMapPluginInitOptionsFiles<PerFileData = undefined> {
+    fileIterator(opts: Readonly<{
+        includeNodeModules: boolean;
+        includeSymlinks: boolean;
+    }>): Iterable<{
+        baseName: string;
+        canonicalPath: string;
+        readonly pluginData: PerFileData | null | undefined;
+    }>;
+    lookup(mixedPath: string): {
+        exists: false;
+    } | {
+        exists: true;
+        type: 'f';
+        readonly pluginData: PerFileData;
+    } | {
+        exists: true;
+        type: 'd';
+    };
+}
+export interface FileMapPluginInitOptions<SerializableState, PerFileData = undefined> {
+    readonly files: FileMapPluginInitOptionsFiles<PerFileData>;
+    readonly pluginState: SerializableState | undefined | null;
+}
+interface FileMapPluginWorkerOptions {
+    readonly modulePath: string;
+    readonly setupArgs: JsonData;
+}
+export interface FileMapPluginWorker {
+    readonly worker: FileMapPluginWorkerOptions;
+    readonly filter: (input: {
+        normalPath: string;
+        isNodeModules: boolean;
+    }) => boolean;
+}
+export type V8Serializable = string | number | boolean | null | readonly V8Serializable[] | ReadonlySet<V8Serializable> | ReadonlyMap<string, V8Serializable> | Readonly<{
+    [key: string]: V8Serializable;
+}>;
+export interface FileMapPlugin<SerializableState extends undefined | V8Serializable = undefined | V8Serializable, PerFileData extends undefined | V8Serializable = undefined | V8Serializable> {
+    readonly name: string;
+    initialize(initOptions: FileMapPluginInitOptions<SerializableState, PerFileData>): Promise<void>;
+    assertValid(): void;
+    onChanged(changes: ReadonlyFileSystemChanges<PerFileData | undefined | null>): void;
+    getSerializableSnapshot(): void | V8Serializable;
+    getCacheKey(): string;
+    getWorker(): FileMapPluginWorker | undefined | null;
+}
+export type InputFileMapPlugin = FileMapPlugin<never, never>;
+export interface MetadataWorkerParams {
+    getContent(): Promise<Buffer>;
+}
+export interface MetadataWorker {
+    processFile(message: WorkerMessage, params: MetadataWorkerParams): V8Serializable | Promise<V8Serializable>;
+}
+export type IgnoreMatcher = (item: string) => boolean;
+export type FileData = Map<CanonicalPath, FileMetadata>;
+export type FileMetadata = [
+    mtime: number | null,
+    size: number,
+    visited: 0 | 1,
+    sha1: string | null,
+    symlink: 0 | 1 | string,
+    ...any[]
+];
+export interface FileStats {
+    readonly fileType: 'f' | 'l';
+    readonly modifiedTime: number | undefined | null;
+    readonly size: number | undefined | null;
+}
+export interface FileSystem {
+    exists(file: Path): boolean;
+    getAllFiles(): Path[];
+    /**
+     * Given a map of files, determine which of them are new or modified
+     * (changedFiles), and which of them are missing from the input
+     * (removedFiles), vs the current state of this instance of FileSystem.
+     */
+    getDifference(files: FileData, options?: Readonly<{
+        /**
+         * Only consider files under this subpath (which should be a directory)
+         * when computing removedFiles. If not provided, all files in the file
+         * system are considered.
+         */
+        subpath?: string;
+    }>): {
+        changedFiles: FileData;
+        removedFiles: Set<string>;
+    };
+    getSerializableSnapshot(): CacheData['fileSystemData'];
+    getMtimeByNormalPath(file: Path): number | undefined | null;
+    getSha1(file: Path): string | undefined | null;
+    getOrComputeSha1(file: Path): Promise<{
+        sha1: string;
+        content?: Buffer;
+    } | undefined | null>;
+    /**
+     * Given a start path (which need not exist), a subpath and type, and
+     * optionally a 'breakOnSegment', performs the following:
+     *
+     * X = mixedStartPath
+     * do
+     *   if basename(X) === opts.breakOnSegment
+     *     return null
+     *   if X + subpath exists and has type opts.subpathType
+     *     return {
+     *       absolutePath: realpath(X + subpath)
+     *       containerRelativePath: relative(mixedStartPath, X)
+     *     }
+     *   X = dirname(X)
+     * while X !== dirname(X)
+     *
+     * If opts.invalidatedBy is given, collects all absolute, real paths that if
+     * added or removed may invalidate this result.
+     *
+     * Useful for finding the closest package scope (subpath: package.json,
+     * type f, breakOnSegment: node_modules) or closest potential package root
+     * (subpath: node_modules/pkg, type: d) in Node.js resolution.
+     */
+    hierarchicalLookup(mixedStartPath: string, subpath: string, opts: {
+        breakOnSegment: string | undefined | null;
+        invalidatedBy: Set<string> | undefined | null;
+        subpathType: 'f' | 'd';
+    }): {
+        absolutePath: string;
+        containerRelativePath: string;
+    } | undefined | null;
+    /**
+     * Analogous to posix lstat. If the file at `file` is a symlink, return
+     * information about the symlink without following it.
+     */
+    linkStats(file: Path): FileStats | undefined | null;
+    /**
+     * Return information about the given path, whether a directory or file.
+     * Always follow symlinks, and return a real path if it exists.
+     */
+    lookup(mixedPath: Path): LookupResult;
+    matchFiles(opts: {
+        filter?: RegExp | null | undefined;
+        filterCompareAbsolute?: boolean | undefined;
+        filterComparePosix?: boolean | undefined;
+        follow?: boolean | undefined;
+        recursive?: boolean | undefined;
+        rootDir?: Path | null | undefined;
+    }): Iterable<Path>;
+}
+export type Glob = string;
+export type JsonData = string | number | boolean | null | JsonData[] | {
+    [key: string]: JsonData;
+};
+export type LookupResult = {
+    exists: false;
+    links: ReadonlySet<string>;
+    missing: string;
+} | {
+    exists: true;
+    links: ReadonlySet<string>;
+    realPath: string;
+    type: 'd';
+} | {
+    exists: true;
+    links: ReadonlySet<string>;
+    realPath: string;
+    type: 'f';
+    metadata: FileMetadata;
+};
+export interface MockMap {
+    getMockModule(name: string): Path | undefined | null;
+}
+export interface HasteConflict {
+    id: string;
+    platform: string | null;
+    absolutePaths: string[];
+    type: 'duplicate' | 'shadowing';
+}
+export interface HasteMap {
+    getModule(name: string, platform?: string | undefined | null, supportsNativePlatform?: boolean | undefined | null, type?: HTypeValue | undefined | null): Path | undefined | null;
+    getModuleNameByPath(file: Path): string | undefined | null;
+    getPackage(name: string, platform: string | undefined | null, _supportsNativePlatform: boolean | undefined | null): Path | undefined | null;
+    computeConflicts(): HasteConflict[];
+}
+export type HasteMapData = Map<string, HasteMapItem>;
+export type HasteMapItem = {
+    [platform: string]: HasteMapItemMetadata;
+};
+export type HasteMapItemMetadata = [/* path */ string, /* type */ number];
+export interface FileSystemListener {
+    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;
+}
+export interface ReadonlyFileSystemChanges<T = FileMetadata> {
+    readonly addedDirectories: Iterable<CanonicalPath>;
+    readonly removedDirectories: Iterable<CanonicalPath>;
+    readonly addedFiles: Iterable<Readonly<[CanonicalPath, T]>>;
+    readonly modifiedFiles: Iterable<Readonly<[CanonicalPath, T]>>;
+    readonly removedFiles: Iterable<Readonly<[CanonicalPath, T]>>;
+}
+export interface MutableFileSystem extends FileSystem {
+    remove(filePath: Path, listener?: FileSystemListener | undefined): void;
+    addOrModify(filePath: Path, fileMetadata: FileMetadata, listener?: FileSystemListener | undefined): void;
+    bulkAddOrModify(addedOrModifiedFiles: FileData, listener?: FileSystemListener | undefined): void;
+}
+export type Path = string;
+type DirectoryNode = Map<string, MixedNode | null>;
+type MixedNode = FileMetadata | DirectoryNode;
+export interface FallbackFilesystem {
+    lookup(normalPath: Path, absolutePath: string, prevNode: MixedNode | null | undefined): MixedNode | null;
+    readdir(normalPath: Path, absolutePath: string, dirNode: DirectoryNode | null | undefined): DirectoryNode | null;
+}
+export type ProcessFileFunction = (normalPath: string, metadata: FileMetadata, request: Readonly<{
+    computeSha1: boolean;
+}>) => Promise<Buffer | undefined | null>;
+export type RawMockMap = {
+    /** posix-separated mock name to posix-separated project-relative paths */
+    readonly duplicates: Map<string, Set<string>>;
+    /** posix-separated mock name to posix-separated project-relative path */
+    readonly mocks: Map<string, Path>;
+    readonly version: number;
+};
+export interface ReadOnlyRawMockMap {
+    readonly duplicates: ReadonlyMap<string, ReadonlySet<string>>;
+    readonly mocks: ReadonlyMap<string, Path>;
+    readonly version: number;
+}
+export interface WatcherBackend {
+    getPauseReason(): string | undefined | null;
+    onError(listener: (error: Error) => void): () => void;
+    onFileEvent(listener: (event: WatcherBackendChangeEvent) => void): () => void;
+    startWatching(): Promise<void>;
+    stopWatching(): Promise<void>;
+}
+export type ChangeEventClock = [absoluteWatchRoot: string, opaqueClock: string];
+export type WatcherBackendChangeEvent = {
+    readonly event: 'touch';
+    readonly clock?: ChangeEventClock | undefined;
+    readonly relativePath: string;
+    readonly root: string;
+    readonly metadata: ChangeEventMetadata;
+} | {
+    readonly event: 'delete';
+    readonly clock?: ChangeEventClock | undefined;
+    readonly relativePath: string;
+    readonly root: string;
+    readonly metadata?: undefined;
+} | {
+    readonly event: 'recrawl';
+    readonly clock?: ChangeEventClock | undefined;
+    readonly relativePath: string;
+    readonly root: string;
+};
+export interface WatcherBackendOptions {
+    readonly ignored: RegExp | undefined | null;
+    readonly globs: readonly string[];
+    readonly dot: boolean;
+}
+export type WatchmanClockSpec = string | {
+    readonly scm: {
+        readonly 'mergebase-with': string;
+    };
+};
+export type WatchmanClocks = Map<Path, WatchmanClockSpec>;
+export interface WorkerMessage {
+    readonly computeSha1: boolean;
+    readonly filePath: string;
+    readonly maybeReturnContent: boolean;
+    readonly pluginsToRun: readonly number[];
+}
+export interface WorkerMetadata {
+    readonly sha1?: string | undefined | null;
+    readonly content?: Buffer | undefined | null;
+    readonly pluginData?: readonly V8Serializable[];
+}
+export interface WorkerSetupArgs {
+    readonly plugins?: readonly FileMapPluginWorker['worker'][];
+}

package/build/types.js

@@ -0,0 +1,8 @@
+"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 });

package/build/watchers/AbstractWatcher.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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 { WatcherBackend, WatcherBackendChangeEvent, WatcherBackendOptions } from '../types';
+type EachOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;
+export type WatcherBackendChangeEventWithoutRoot = EachOmit<WatcherBackendChangeEvent, 'root'>;
+export interface Listeners {
+    onFileEvent(event: WatcherBackendChangeEvent): void;
+    onError(error: Error): void;
+}
+export declare class AbstractWatcher implements WatcherBackend {
+    #private;
+    readonly root: string;
+    readonly ignored: RegExp | undefined | null;
+    readonly globs: readonly string[];
+    readonly dot: boolean;
+    readonly doIgnore: (path: string) => boolean;
+    constructor(dir: string, opts: WatcherBackendOptions);
+    onFileEvent(listener: (event: WatcherBackendChangeEvent) => void): () => void;
+    onError(listener: (error: Error) => void): () => void;
+    startWatching(): Promise<void>;
+    stopWatching(): Promise<void>;
+    emitFileEvent(event: WatcherBackendChangeEventWithoutRoot): void;
+    emitError(error: Error): void;
+    getPauseReason(): string | undefined | null;
+}
+export {};

package/build/watchers/AbstractWatcher.js

@@ -0,0 +1,97 @@
+"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 });
+exports.AbstractWatcher = void 0;
+const events_1 = __importDefault(require("events"));
+const path = __importStar(require("path"));
+const common_1 = require("./common");
+class AbstractWatcher {
+    root;
+    ignored;
+    globs;
+    dot;
+    doIgnore;
+    #emitter = new events_1.default();
+    constructor(dir, opts) {
+        const { ignored, globs, dot } = opts;
+        this.dot = dot || false;
+        this.ignored = ignored;
+        this.globs = globs;
+        this.doIgnore = ignored
+            ? (filePath) => (0, common_1.posixPathMatchesPattern)(ignored, filePath)
+            : () => false;
+        this.root = path.resolve(dir);
+    }
+    onFileEvent(listener) {
+        this.#emitter.on('fileevent', listener);
+        return () => {
+            this.#emitter.removeListener('fileevent', listener);
+        };
+    }
+    onError(listener) {
+        this.#emitter.on('error', listener);
+        return () => {
+            this.#emitter.removeListener('error', listener);
+        };
+    }
+    async startWatching() {
+        // Must be implemented by subclasses
+    }
+    async stopWatching() {
+        this.#emitter.removeAllListeners();
+    }
+    emitFileEvent(event) {
+        this.#emitter.emit('fileevent', {
+            ...event,
+            root: this.root,
+        });
+    }
+    emitError(error) {
+        this.#emitter.emit('error', error);
+    }
+    getPauseReason() {
+        return null;
+    }
+}
+exports.AbstractWatcher = AbstractWatcher;

package/build/watchers/FallbackWatcher.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.
+ *
+ * @format
+ */
+import { AbstractWatcher } from './AbstractWatcher';
+export default class FallbackWatcher extends AbstractWatcher {
+    #private;
+    startWatching(): Promise<void>;
+    /**
+     * End watching.
+     */
+    stopWatching(): Promise<void>;
+    getPauseReason(): string | undefined | null;
+}