@expo/metro-file-map 55.0.0-0

package/build/lib/checkWatchmanCapabilities.d.ts

@@ -0,0 +1,9 @@
+/**
+ * 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 default function checkWatchmanCapabilities(requiredCapabilities: readonly string[]): Promise<{
+    version: string;
+}>;

package/build/lib/checkWatchmanCapabilities.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = checkWatchmanCapabilities;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+async function checkWatchmanCapabilities(requiredCapabilities) {
+    const execFilePromise = (0, util_1.promisify)(child_process_1.execFile);
+    let rawResponse;
+    try {
+        const result = await execFilePromise('watchman', [
+            'list-capabilities',
+            '--output-encoding=json',
+            '--no-pretty',
+            '--no-spawn', // The client can answer this, so don't spawn a server
+        ]);
+        rawResponse = result.stdout;
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT') {
+            throw new Error('Watchman is not installed or not available on PATH');
+        }
+        throw e;
+    }
+    let parsedResponse;
+    try {
+        parsedResponse = JSON.parse(rawResponse);
+    }
+    catch {
+        throw new Error('Failed to parse response from `watchman list-capabilities`');
+    }
+    if (parsedResponse == null ||
+        typeof parsedResponse !== 'object' ||
+        typeof parsedResponse.version !== 'string' ||
+        !Array.isArray(parsedResponse.capabilities)) {
+        throw new Error('Unexpected response from `watchman list-capabilities`');
+    }
+    const version = parsedResponse.version;
+    const capabilities = new Set(parsedResponse.capabilities);
+    const missingCapabilities = requiredCapabilities.filter((requiredCapability) => !capabilities.has(requiredCapability));
+    if (missingCapabilities.length > 0) {
+        throw new Error(`The installed version of Watchman (${version}) is missing required capabilities: ${missingCapabilities.join(', ')}`);
+    }
+    return { version };
+}

package/build/lib/normalizePathSeparatorsToPosix.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 let normalizePathSeparatorsToPosix: (filePath: string) => string;
+export default normalizePathSeparatorsToPosix;

package/build/lib/normalizePathSeparatorsToPosix.js

@@ -0,0 +1,20 @@
+"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 });
+const path_1 = __importDefault(require("path"));
+let normalizePathSeparatorsToPosix;
+if (path_1.default.sep === '/') {
+    normalizePathSeparatorsToPosix = (filePath) => filePath;
+}
+else {
+    normalizePathSeparatorsToPosix = (filePath) => filePath.replace(/\\/g, '/');
+}
+exports.default = normalizePathSeparatorsToPosix;

package/build/lib/normalizePathSeparatorsToSystem.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 let normalizePathSeparatorsToSystem: (filePath: string) => string;
+export default normalizePathSeparatorsToSystem;

package/build/lib/normalizePathSeparatorsToSystem.js

@@ -0,0 +1,20 @@
+"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 });
+const path_1 = __importDefault(require("path"));
+let normalizePathSeparatorsToSystem;
+if (path_1.default.sep === '/') {
+    normalizePathSeparatorsToSystem = (filePath) => filePath;
+}
+else {
+    normalizePathSeparatorsToSystem = (filePath) => filePath.replace(/\//g, path_1.default.sep);
+}
+exports.default = normalizePathSeparatorsToSystem;

package/build/lib/removeOverlappingRoots.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.
+ *
+ * @flow strict
+ * @format
+ */
+export default function removeOverlappingRoots(roots: readonly string[]): readonly string[];

package/build/lib/removeOverlappingRoots.js

@@ -0,0 +1,37 @@
+"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.
+ *
+ * @flow strict
+ * @format
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = removeOverlappingRoots;
+const path_1 = __importDefault(require("path"));
+function removeOverlappingRoots(roots) {
+    const sorted = roots
+        .map((r) => path_1.default.resolve(r))
+        .sort((a, b) => {
+        const aRoot = a + path_1.default.sep;
+        const bRoot = b + path_1.default.sep;
+        return aRoot < bRoot ? -1 : aRoot > bRoot ? 1 : 0;
+    });
+    if (sorted.length === 0) {
+        return sorted;
+    }
+    const result = [sorted[0]];
+    for (let i = 1; i < sorted.length; i++) {
+        const rootPath = sorted[i] + path_1.default.sep;
+        const prevPath = result[result.length - 1] + path_1.default.sep;
+        if (!rootPath.startsWith(prevPath)) {
+            result.push(sorted[i]);
+        }
+    }
+    return result;
+}

package/build/lib/rootRelativeCacheKeys.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 } from '../types';
+export default function rootRelativeCacheKeys(buildParameters: BuildParameters): {
+    rootDirHash: string;
+    relativeConfigHash: string;
+};

package/build/lib/rootRelativeCacheKeys.js

@@ -0,0 +1,56 @@
+"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.default = rootRelativeCacheKeys;
+const crypto_1 = require("crypto");
+const RootPathUtils_1 = require("./RootPathUtils");
+const normalizePathSeparatorsToPosix_1 = __importDefault(require("./normalizePathSeparatorsToPosix"));
+function rootRelativeCacheKeys(buildParameters) {
+    const { rootDir, plugins, ...otherParameters } = buildParameters;
+    const rootDirHash = (0, crypto_1.createHash)('md5')
+        .update((0, normalizePathSeparatorsToPosix_1.default)(rootDir))
+        .digest('hex');
+    const pathUtils = new RootPathUtils_1.RootPathUtils(rootDir);
+    const cacheComponents = Object.keys(otherParameters)
+        .sort()
+        .map((key) => {
+        switch (key) {
+            case 'roots':
+                return buildParameters[key].map((root) => (0, normalizePathSeparatorsToPosix_1.default)(pathUtils.absoluteToNormal(root)));
+            case 'cacheBreaker':
+            case 'extensions':
+            case 'computeSha1':
+            case 'enableSymlinks':
+            case 'retainAllFiles':
+                return buildParameters[key] ?? null;
+            case 'ignorePattern':
+                return buildParameters[key].toString();
+            case 'forceNodeFilesystemAPI':
+                return null;
+            default:
+                key;
+                throw new Error('Unrecognised key in build parameters: ' + key);
+        }
+    });
+    for (const plugin of plugins) {
+        cacheComponents.push(plugin.getCacheKey());
+    }
+    // JSON.stringify is stable here because we only deal in (nested) arrays of
+    // primitives. Use a different approach if this is expanded to include
+    // objects/Sets/Maps, etc.
+    const relativeConfigHash = (0, crypto_1.createHash)('md5')
+        .update(JSON.stringify(cacheComponents))
+        .digest('hex');
+    return {
+        rootDirHash,
+        relativeConfigHash,
+    };
+}

package/build/lib/sorting.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.
+ */
+export declare function compareStrings(a: null | string, b: null | string): number;
+export declare function chainComparators<T>(...comparators: ((a: T, b: T) => number)[]): (a: T, b: T) => number;

package/build/lib/sorting.js

@@ -0,0 +1,31 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareStrings = compareStrings;
+exports.chainComparators = chainComparators;
+// Utilities for working with Array.prototype.sort
+function compareStrings(a, b) {
+    if (a == null) {
+        return b == null ? 0 : -1;
+    }
+    if (b == null) {
+        return 1;
+    }
+    return a.localeCompare(b);
+}
+function chainComparators(...comparators) {
+    return (a, b) => {
+        for (const comparator of comparators) {
+            const result = comparator(a, b);
+            if (result !== 0) {
+                return result;
+            }
+        }
+        return 0;
+    };
+}

package/build/plugins/DependencyPlugin.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.
+ */
+import type { Path } from '../types';
+import FileDataPlugin from './FileDataPlugin';
+export interface DependencyPluginOptions {
+    /** Path to custom dependency extractor module */
+    readonly dependencyExtractor: string | null;
+    /** Whether to compute dependencies (performance optimization) */
+    readonly computeDependencies: boolean;
+}
+export default class DependencyPlugin extends FileDataPlugin<readonly string[] | null> {
+    constructor(options: DependencyPluginOptions);
+    /**
+     * Get the list of dependencies for a given file.
+     * @param mixedPath Absolute or project-relative path to the file
+     * @returns Array of dependency module names, or null if the file doesn't exist
+     */
+    getDependencies(mixedPath: Path): readonly string[] | null | undefined;
+}

package/build/plugins/DependencyPlugin.js

@@ -0,0 +1,61 @@
+"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 });
+const workerExclusionList_1 = __importDefault(require("../workerExclusionList"));
+const FileDataPlugin_1 = __importDefault(require("./FileDataPlugin"));
+class DependencyPlugin extends FileDataPlugin_1.default {
+    constructor(options) {
+        const { dependencyExtractor, computeDependencies } = options;
+        let cacheKey;
+        if (dependencyExtractor != null) {
+            const mod = require(dependencyExtractor);
+            const getCacheKey = mod?.getCacheKey ??
+                (mod.__esModule === true && 'default' in mod ? mod.default : mod).getCacheKey;
+            cacheKey = getCacheKey?.() ?? dependencyExtractor;
+        }
+        else {
+            cacheKey = 'default-dependency-extractor';
+        }
+        super({
+            name: 'dependencies',
+            cacheKey,
+            worker: {
+                modulePath: require.resolve('./dependencies/worker'),
+                setupArgs: {
+                    dependencyExtractor: dependencyExtractor ?? null,
+                },
+            },
+            filter: ({ normalPath, isNodeModules }) => {
+                if (!computeDependencies) {
+                    return false;
+                }
+                if (isNodeModules) {
+                    return false;
+                }
+                const ext = normalPath.substr(normalPath.lastIndexOf('.'));
+                return !workerExclusionList_1.default.has(ext);
+            },
+        });
+    }
+    /**
+     * Get the list of dependencies for a given file.
+     * @param mixedPath Absolute or project-relative path to the file
+     * @returns Array of dependency module names, or null if the file doesn't exist
+     */
+    getDependencies(mixedPath) {
+        const result = this.getFileSystem().lookup(mixedPath);
+        if (result.exists && result.type === 'f') {
+            return result.pluginData ?? [];
+        }
+        return null;
+    }
+}
+exports.default = DependencyPlugin;

package/build/plugins/FileDataPlugin.d.ts

@@ -0,0 +1,28 @@
+/**
+ * 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 { FileMapPlugin, FileMapPluginInitOptions, FileMapPluginWorker, ReadonlyFileSystemChanges, V8Serializable } from '../types';
+export interface FileDataPluginOptions extends FileMapPluginWorker {
+    readonly name: string;
+    readonly cacheKey: string;
+}
+/**
+ * Base class for FileMap plugins that store per-file data via a worker and
+ * have no separate serializable state. Provides default no-op implementations
+ * of lifecycle methods that subclasses can override as needed.
+ */
+export default class FileDataPlugin<PerFileData extends undefined | V8Serializable = undefined | V8Serializable> implements FileMapPlugin<null, PerFileData> {
+    #private;
+    readonly name: string;
+    constructor({ name, worker, filter, cacheKey }: FileDataPluginOptions);
+    initialize(initOptions: FileMapPluginInitOptions<null, PerFileData>): Promise<void>;
+    getFileSystem(): FileMapPluginInitOptions<null, PerFileData>['files'];
+    onChanged(_changes: ReadonlyFileSystemChanges<PerFileData | undefined | null>): void;
+    assertValid(): void;
+    getSerializableSnapshot(): null;
+    getCacheKey(): string;
+    getWorker(): FileMapPluginWorker;
+}

package/build/plugins/FileDataPlugin.js

@@ -0,0 +1,46 @@
+"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 });
+/**
+ * Base class for FileMap plugins that store per-file data via a worker and
+ * have no separate serializable state. Provides default no-op implementations
+ * of lifecycle methods that subclasses can override as needed.
+ */
+class FileDataPlugin {
+    name;
+    #worker;
+    #cacheKey;
+    #files;
+    constructor({ name, worker, filter, cacheKey }) {
+        this.name = name;
+        this.#worker = { worker, filter };
+        this.#cacheKey = cacheKey;
+    }
+    async initialize(initOptions) {
+        this.#files = initOptions.files;
+    }
+    getFileSystem() {
+        const files = this.#files;
+        if (files == null) {
+            throw new Error(`${this.name} plugin has not been initialized`);
+        }
+        return files;
+    }
+    onChanged(_changes) { }
+    assertValid() { }
+    getSerializableSnapshot() {
+        return null;
+    }
+    getCacheKey() {
+        return this.#cacheKey;
+    }
+    getWorker() {
+        return this.#worker;
+    }
+}
+exports.default = FileDataPlugin;

package/build/plugins/HastePlugin.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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 { Console, FileMapPlugin, FileMapPluginInitOptions, FileMapPluginWorker, HasteConflict, HasteMap, HasteMapItemMetadata, HTypeValue, Path, PerfLogger, ReadonlyFileSystemChanges } from '../types';
+export interface HasteMapOptions {
+    readonly console?: Console | null;
+    readonly enableHastePackages: boolean;
+    readonly hasteImplModulePath: string | null;
+    readonly perfLogger?: PerfLogger | null;
+    readonly platforms: ReadonlySet<string>;
+    readonly rootDir: Path;
+    readonly failValidationOnConflicts: boolean;
+}
+export default class HastePlugin implements HasteMap, FileMapPlugin<null, string | null> {
+    #private;
+    readonly name: 'haste';
+    constructor(options: HasteMapOptions);
+    initialize({ files }: FileMapPluginInitOptions<null, string | null>): Promise<void>;
+    getSerializableSnapshot(): null;
+    getModule(name: string, platform?: string | undefined | null, supportsNativePlatform?: boolean | undefined | null, type?: HTypeValue | undefined | null): Path | undefined | null;
+    getModuleNameByPath(mixedPath: Path): string | undefined | null;
+    getPackage(name: string, platform: string | undefined | null, _supportsNativePlatform?: boolean | undefined | null): Path | undefined | null;
+    onChanged(delta: ReadonlyFileSystemChanges<string | null | undefined>): void;
+    setModule(id: string, module: HasteMapItemMetadata): void;
+    assertValid(): void;
+    computeConflicts(): HasteConflict[];
+    getCacheKey(): string;
+    getWorker(): FileMapPluginWorker;
+}