@expo/metro-file-map 55.0.0-0

package/build/plugins/haste/DuplicateHasteCandidatesError.js

@@ -0,0 +1,51 @@
+"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.DuplicateHasteCandidatesError = void 0;
+const constants_1 = __importDefault(require("../../constants"));
+class DuplicateHasteCandidatesError extends Error {
+    hasteName;
+    platform;
+    supportsNativePlatform;
+    duplicatesSet;
+    constructor(name, platform, supportsNativePlatform, duplicatesSet) {
+        const platformMessage = getPlatformMessage(platform);
+        super(`The name \`${name}\` was looked up in the Haste module map. It ` +
+            'cannot be resolved, because there exists several different ' +
+            'files, or packages, that provide a module for ' +
+            `that particular name and platform. ${platformMessage} You must ` +
+            'delete or exclude files until there remains only one of these:\n\n' +
+            Array.from(duplicatesSet)
+                .map(([dupFilePath, dupFileType]) => `  * \`${dupFilePath}\` (${getTypeMessage(dupFileType)})\n`)
+                .sort()
+                .join(''));
+        this.hasteName = name;
+        this.platform = platform;
+        this.supportsNativePlatform = supportsNativePlatform;
+        this.duplicatesSet = duplicatesSet;
+    }
+}
+exports.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError;
+function getPlatformMessage(platform) {
+    if (platform === constants_1.default.GENERIC_PLATFORM) {
+        return 'The platform is generic (no extension).';
+    }
+    return `The platform extension is \`${platform}\`.`;
+}
+function getTypeMessage(type) {
+    switch (type) {
+        case constants_1.default.MODULE:
+            return 'module';
+        case constants_1.default.PACKAGE:
+            return 'package';
+    }
+    return 'unknown';
+}

package/build/plugins/haste/HasteConflictsError.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 { HasteConflict } from '../../types';
+export declare class HasteConflictsError extends Error {
+    #private;
+    constructor(conflicts: readonly HasteConflict[]);
+    getDetailedMessage(pathsRelativeToRoot: string | null): string;
+}

package/build/plugins/haste/HasteConflictsError.js

@@ -0,0 +1,49 @@
+"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.HasteConflictsError = void 0;
+const path_1 = __importDefault(require("path"));
+class HasteConflictsError extends Error {
+    #conflicts;
+    constructor(conflicts) {
+        super(`Found ${conflicts.length} Haste conflict(s). Haste module IDs must be globally unique in the codebase.`);
+        this.#conflicts = conflicts;
+    }
+    getDetailedMessage(pathsRelativeToRoot) {
+        const messages = [];
+        const conflicts = this.#conflicts;
+        if (conflicts.some((conflict) => conflict.type === 'duplicate')) {
+            messages.push('Advice: Resolve conflicts of type "duplicate" by renaming one or both of the conflicting modules, or by excluding conflicting paths from Haste.');
+        }
+        if (conflicts.some((conflict) => conflict.type === 'shadowing')) {
+            messages.push('Advice: Resolve conflicts of type "shadowing" by moving the modules to the same folder, or by excluding conflicting paths from Haste.');
+        }
+        let index = 0;
+        for (const conflict of conflicts) {
+            const itemHeader = index + 1 + '. ';
+            const indent = ' '.repeat(itemHeader.length + 2);
+            messages.push('\n' +
+                itemHeader +
+                conflict.id +
+                (conflict.platform != null ? `.${conflict.platform}` : '') +
+                ` (${conflict.type})`);
+            for (const modulePath of conflict.absolutePaths) {
+                messages.push(indent +
+                    (pathsRelativeToRoot != null
+                        ? path_1.default.relative(pathsRelativeToRoot, modulePath)
+                        : modulePath));
+            }
+            ++index;
+        }
+        return messages.join('\n');
+    }
+}
+exports.HasteConflictsError = HasteConflictsError;

package/build/plugins/haste/computeConflicts.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 { HasteMapItem } from '../../types';
+interface Conflict {
+    id: string;
+    platform: string | null;
+    absolutePaths: string[];
+    type: 'duplicate' | 'shadowing';
+}
+export declare function computeHasteConflicts(options: {
+    readonly duplicates: ReadonlyMap<string, ReadonlyMap<string, ReadonlyMap<string, number>>>;
+    readonly map: ReadonlyMap<string, HasteMapItem>;
+    readonly rootDir: string;
+}): Conflict[];
+export {};

package/build/plugins/haste/computeConflicts.js

@@ -0,0 +1,74 @@
+"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.computeHasteConflicts = computeHasteConflicts;
+const path_1 = __importDefault(require("path"));
+const constants_1 = __importDefault(require("../../constants"));
+const sorting_1 = require("../../lib/sorting");
+function computeHasteConflicts(options) {
+    const { duplicates, map, rootDir } = options;
+    const conflicts = [];
+    // Add duplicates reported by metro-file-map
+    for (const [id, dupsByPlatform] of duplicates.entries()) {
+        for (const [platform, conflictingModules] of dupsByPlatform) {
+            conflicts.push({
+                id,
+                platform: platform === constants_1.default.GENERIC_PLATFORM ? null : platform,
+                absolutePaths: [...conflictingModules.keys()]
+                    .map((modulePath) => path_1.default.resolve(rootDir, modulePath))
+                    // Sort for ease of testing
+                    .sort(),
+                type: 'duplicate',
+            });
+        }
+    }
+    // Add cases of "shadowing at a distance": a module with a platform suffix and
+    // a module with a lower priority platform suffix (or no suffix), in different
+    // directories.
+    for (const [id, data] of map) {
+        const conflictPaths = new Set();
+        const basePaths = [];
+        for (const basePlatform of [constants_1.default.NATIVE_PLATFORM, constants_1.default.GENERIC_PLATFORM]) {
+            if (data[basePlatform] == null) {
+                continue;
+            }
+            const basePath = data[basePlatform][0];
+            basePaths.push(basePath);
+            const basePathDir = path_1.default.dirname(basePath);
+            // Find all platforms that can shadow basePlatform
+            // Given that X.(specific platform).js > x.native.js > X.js
+            // and basePlatform is either 'native' or generic (no platform).
+            for (const platform of Object.keys(data)) {
+                if (platform === basePlatform || platform === constants_1.default.GENERIC_PLATFORM /* lowest priority */) {
+                    continue;
+                }
+                const platformPath = data[platform][0];
+                if (path_1.default.dirname(platformPath) !== basePathDir) {
+                    conflictPaths.add(platformPath);
+                }
+            }
+        }
+        if (conflictPaths.size) {
+            conflicts.push({
+                id,
+                platform: null,
+                absolutePaths: [...new Set([...conflictPaths, ...basePaths])]
+                    .map((modulePath) => path_1.default.resolve(rootDir, modulePath))
+                    // Sort for ease of testing
+                    .sort(),
+                type: 'shadowing',
+            });
+        }
+    }
+    // Sort for ease of testing
+    conflicts.sort((0, sorting_1.chainComparators)((a, b) => (0, sorting_1.compareStrings)(a.type, b.type), (a, b) => (0, sorting_1.compareStrings)(a.id, b.id), (a, b) => (0, sorting_1.compareStrings)(a.platform, b.platform)));
+    return conflicts;
+}

package/build/plugins/haste/getPlatformExtension.d.ts

@@ -0,0 +1,7 @@
+/**
+ * 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 getPlatformExtension(file: string, platforms: ReadonlySet<string>): string | null;

package/build/plugins/haste/getPlatformExtension.js

@@ -0,0 +1,19 @@
+"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 = getPlatformExtension;
+// Extract platform extension: index.ios.js -> ios
+function getPlatformExtension(file, platforms) {
+    const last = file.lastIndexOf('.');
+    const secondToLast = file.lastIndexOf('.', last - 1);
+    if (secondToLast === -1) {
+        return null;
+    }
+    const platform = file.substring(secondToLast + 1, last);
+    return platforms.has(platform) ? platform : null;
+}

package/build/plugins/haste/worker.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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 { MetadataWorker, V8Serializable, WorkerMessage } from '../../types';
+export default class Worker implements MetadataWorker {
+    #private;
+    constructor({ hasteImplModulePath }: Readonly<{
+        hasteImplModulePath: string | null;
+    }>);
+    processFile(data: WorkerMessage, utils: {
+        readonly getContent: () => Promise<Buffer>;
+    }): Promise<V8Serializable>;
+}

package/build/plugins/haste/worker.js

@@ -0,0 +1,48 @@
+"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"));
+const workerExclusionList_1 = __importDefault(require("../../workerExclusionList"));
+const PACKAGE_JSON = path_1.default.sep + 'package.json';
+class Worker {
+    #hasteImpl = null;
+    constructor({ hasteImplModulePath }) {
+        if (hasteImplModulePath != null) {
+            const mod = require(hasteImplModulePath);
+            this.#hasteImpl = mod.__esModule === true && 'default' in mod ? mod.default : mod;
+        }
+    }
+    async processFile(data, utils) {
+        let hasteName = null;
+        const { filePath } = data;
+        if (filePath.endsWith(PACKAGE_JSON)) {
+            // Process a package.json that is returned as a PACKAGE type with its name.
+            try {
+                const fileData = JSON.parse((await utils.getContent()).toString());
+                if (fileData.name) {
+                    hasteName = fileData.name;
+                }
+            }
+            catch (err) {
+                throw new Error(`Cannot parse ${filePath} as JSON: ${err.message}`);
+            }
+        }
+        else if (!workerExclusionList_1.default.has(filePath.substr(filePath.lastIndexOf('.')))) {
+            if (!this.#hasteImpl) {
+                throw new Error('computeHaste is true but hasteImplModulePath not set');
+            }
+            // Process a random file that is returned as a MODULE.
+            hasteName = this.#hasteImpl.getHasteName(filePath) || null;
+        }
+        return hasteName;
+    }
+}
+exports.default = Worker;

package/build/plugins/mocks/getMockName.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 _default: (filePath: string) => string;
+export default _default;

package/build/plugins/mocks/getMockName.js

@@ -0,0 +1,17 @@
+"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"));
+const MOCKS_PATTERN = path_1.default.sep + '__mocks__' + path_1.default.sep;
+exports.default = (filePath) => {
+    const mockPath = filePath.split(MOCKS_PATTERN)[1];
+    return mockPath.substring(0, mockPath.lastIndexOf(path_1.default.extname(mockPath))).replaceAll('\\', '/');
+};

package/build/ts-declarations/fb-watchman.d.ts

@@ -0,0 +1,20 @@
+declare module 'fb-watchman' {
+    /** Information about a changed file */
+    interface FileChange {
+        dev?: number;
+        cclock?: string;
+        gid?: number;
+        ino?: number;
+        mode?: number;
+        mtime?: number;
+        mtime_us?: number;
+        mtime_ns?: number;
+        mtime_f?: number;
+        new?: boolean;
+        nlink?: number;
+        uid?: number;
+        'content.sha1hex'?: string;
+        symlink_target?: string;
+    }
+}
+export {};

package/build/ts-declarations/fb-watchman.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });