react-native-platform-override 1.9.21 → 1.9.22

package/lib-commonjs/CrossProcessLock.d.ts

@@ -1,44 +1,44 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- *
- * @format
- */
-/**
- * CrossProcessLock implements a non-polling cross-process asynchronous barrier.
- *
- * - The lock is acquired by creating a named pipe
- *
- * - If named pipe creation fails due to an existing pipe, the process
- *   subscribes to the pipe, waiting asynchronously until it dies.
- *
- * - Once the pipe dies, any subscribers will race to acquire the lock (create
- *   the pipe server)
- */
-export default class CrossProcessLock {
-    private readonly ipcPath;
-    private readonly server;
-    private readonly connections;
-    /**
-     * Create the lock instance. Does not yet allocate any resources.
-     *
-     * @param lockName unique name of the shared resource. Must be under 256
-     * chars and not use special characters.
-     */
-    constructor(lockName: string);
-    /**
-     * Try to acquire the shared resource. Returns false if it is already in use
-     * without acquiring the resource. Subsequent tryLock calls after obtaining a
-     * lock will return false.
-     */
-    tryLock(): Promise<boolean>;
-    /**
-     * Acquire the shared resource, waiting for it to be available.
-     */
-    lock(): Promise<void>;
-    private waitUntilPipeDeath;
-    /**
-     * Release the shared resource
-     */
-    unlock(): Promise<void>;
-}
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @format
+ */
+/**
+ * CrossProcessLock implements a non-polling cross-process asynchronous barrier.
+ *
+ * - The lock is acquired by creating a named pipe
+ *
+ * - If named pipe creation fails due to an existing pipe, the process
+ *   subscribes to the pipe, waiting asynchronously until it dies.
+ *
+ * - Once the pipe dies, any subscribers will race to acquire the lock (create
+ *   the pipe server)
+ */
+export default class CrossProcessLock {
+    private readonly ipcPath;
+    private readonly server;
+    private readonly connections;
+    /**
+     * Create the lock instance. Does not yet allocate any resources.
+     *
+     * @param lockName unique name of the shared resource. Must be under 256
+     * chars and not use special characters.
+     */
+    constructor(lockName: string);
+    /**
+     * Try to acquire the shared resource. Returns false if it is already in use
+     * without acquiring the resource. Subsequent tryLock calls after obtaining a
+     * lock will return false.
+     */
+    tryLock(): Promise<boolean>;
+    /**
+     * Acquire the shared resource, waiting for it to be available.
+     */
+    lock(): Promise<void>;
+    private waitUntilPipeDeath;
+    /**
+     * Release the shared resource
+     */
+    unlock(): Promise<void>;
+}

package/lib-commonjs/CrossProcessLock.js

@@ -1,148 +1,148 @@
-"use strict";
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- *
- * @format
- */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const net_1 = __importDefault(require("net"));
-const path_1 = __importDefault(require("path"));
-const os_1 = require("os");
-/**
- * CrossProcessLock implements a non-polling cross-process asynchronous barrier.
- *
- * - The lock is acquired by creating a named pipe
- *
- * - If named pipe creation fails due to an existing pipe, the process
- *   subscribes to the pipe, waiting asynchronously until it dies.
- *
- * - Once the pipe dies, any subscribers will race to acquire the lock (create
- *   the pipe server)
- */
-class CrossProcessLock {
-    /**
-     * Create the lock instance. Does not yet allocate any resources.
-     *
-     * @param lockName unique name of the shared resource. Must be under 256
-     * chars and not use special characters.
-     */
-    constructor(lockName) {
-        if ((0, os_1.platform)() === 'win32') {
-            this.ipcPath = `\\\\.\\pipe\\${lockName}`;
-        }
-        else {
-            this.ipcPath = path_1.default.join((0, os_1.tmpdir)(), `${lockName}`);
-        }
-        this.server = net_1.default.createServer();
-        this.connections = new Set();
-        this.server.on('connection', conn => {
-            this.connections.add(conn);
-            conn.on('close', () => this.connections.delete(conn));
-        });
-    }
-    /**
-     * Try to acquire the shared resource. Returns false if it is already in use
-     * without acquiring the resource. Subsequent tryLock calls after obtaining a
-     * lock will return false.
-     */
-    tryLock() {
-        if (this.server.listening) {
-            return Promise.resolve(false);
-        }
-        return new Promise((resolve, reject) => {
-            const onListening = () => {
-                this.server.off('error', onError);
-                resolve(true);
-            };
-            const onError = (err) => {
-                this.server.off('listening', onListening);
-                // @ts-ignore Typings for EventEmitter only know about generic JS errors
-                if (err.code === 'EADDRINUSE') {
-                    resolve(false);
-                }
-                else {
-                    reject(err);
-                }
-            };
-            this.server.once('listening', onListening);
-            this.server.once('error', onError);
-            try {
-                this.server.listen({
-                    path: this.ipcPath,
-                    exclusive: true,
-                    readableAll: true,
-                });
-            }
-            catch (ex) {
-                // Old versions of Node will throw an extra TypeError when address is
-                // in use that we need to ignore https://github.com/nodejs/node/issues/23917
-                if (ex.name !== 'TypeError') {
-                    throw ex;
-                }
-            }
-        });
-    }
-    /**
-     * Acquire the shared resource, waiting for it to be available.
-     */
-    async lock() {
-        if (this.server.listening) {
-            return;
-        }
-        if (!(await this.tryLock())) {
-            await this.waitUntilPipeDeath();
-            return this.lock();
-        }
-    }
-    waitUntilPipeDeath() {
-        return new Promise((resolve, reject) => {
-            const socket = new net_1.default.Socket();
-            // Treat some errors as potential pipe death, since it could have died
-            // between the time to create a server and attempting to connect to the
-            // existing.
-            socket.once('error', err => {
-                // @ts-ignore Typings for EventEmitter only know about generic JS errors
-                if (err.code === 'ECONNREFUSED' || err.code === 'ECONNRESET') {
-                    resolve();
-                }
-                else {
-                    reject(err);
-                }
-            });
-            socket.once('close', () => resolve());
-            socket.setTimeout(0);
-            socket.connect({ path: this.ipcPath });
-        });
-    }
-    /**
-     * Release the shared resource
-     */
-    unlock() {
-        if (!this.server.listening) {
-            return Promise.resolve();
-        }
-        return new Promise((resolve, reject) => {
-            const onClose = () => {
-                this.server.off('error', onError);
-                resolve();
-            };
-            const onError = (err) => {
-                this.server.off('close', onClose);
-                reject(err);
-            };
-            this.server.once('close', onClose);
-            this.server.once('error', onError);
-            // Closing will only prevent new connections, instead of killing old
-            // ones. Manually destroy all existing connections to let them retry the
-            // lock.
-            this.server.close();
-            this.connections.forEach(conn => conn.destroy());
-        });
-    }
-}
-exports.default = CrossProcessLock;
+"use strict";
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @format
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const net_1 = __importDefault(require("net"));
+const path_1 = __importDefault(require("path"));
+const os_1 = require("os");
+/**
+ * CrossProcessLock implements a non-polling cross-process asynchronous barrier.
+ *
+ * - The lock is acquired by creating a named pipe
+ *
+ * - If named pipe creation fails due to an existing pipe, the process
+ *   subscribes to the pipe, waiting asynchronously until it dies.
+ *
+ * - Once the pipe dies, any subscribers will race to acquire the lock (create
+ *   the pipe server)
+ */
+class CrossProcessLock {
+    /**
+     * Create the lock instance. Does not yet allocate any resources.
+     *
+     * @param lockName unique name of the shared resource. Must be under 256
+     * chars and not use special characters.
+     */
+    constructor(lockName) {
+        if ((0, os_1.platform)() === 'win32') {
+            this.ipcPath = `\\\\.\\pipe\\${lockName}`;
+        }
+        else {
+            this.ipcPath = path_1.default.join((0, os_1.tmpdir)(), `${lockName}`);
+        }
+        this.server = net_1.default.createServer();
+        this.connections = new Set();
+        this.server.on('connection', conn => {
+            this.connections.add(conn);
+            conn.on('close', () => this.connections.delete(conn));
+        });
+    }
+    /**
+     * Try to acquire the shared resource. Returns false if it is already in use
+     * without acquiring the resource. Subsequent tryLock calls after obtaining a
+     * lock will return false.
+     */
+    tryLock() {
+        if (this.server.listening) {
+            return Promise.resolve(false);
+        }
+        return new Promise((resolve, reject) => {
+            const onListening = () => {
+                this.server.off('error', onError);
+                resolve(true);
+            };
+            const onError = (err) => {
+                this.server.off('listening', onListening);
+                // @ts-ignore Typings for EventEmitter only know about generic JS errors
+                if (err.code === 'EADDRINUSE') {
+                    resolve(false);
+                }
+                else {
+                    reject(err);
+                }
+            };
+            this.server.once('listening', onListening);
+            this.server.once('error', onError);
+            try {
+                this.server.listen({
+                    path: this.ipcPath,
+                    exclusive: true,
+                    readableAll: true,
+                });
+            }
+            catch (ex) {
+                // Old versions of Node will throw an extra TypeError when address is
+                // in use that we need to ignore https://github.com/nodejs/node/issues/23917
+                if (ex.name !== 'TypeError') {
+                    throw ex;
+                }
+            }
+        });
+    }
+    /**
+     * Acquire the shared resource, waiting for it to be available.
+     */
+    async lock() {
+        if (this.server.listening) {
+            return;
+        }
+        if (!(await this.tryLock())) {
+            await this.waitUntilPipeDeath();
+            return this.lock();
+        }
+    }
+    waitUntilPipeDeath() {
+        return new Promise((resolve, reject) => {
+            const socket = new net_1.default.Socket();
+            // Treat some errors as potential pipe death, since it could have died
+            // between the time to create a server and attempting to connect to the
+            // existing.
+            socket.once('error', err => {
+                // @ts-ignore Typings for EventEmitter only know about generic JS errors
+                if (err.code === 'ECONNREFUSED' || err.code === 'ECONNRESET') {
+                    resolve();
+                }
+                else {
+                    reject(err);
+                }
+            });
+            socket.once('close', () => resolve());
+            socket.setTimeout(0);
+            socket.connect({ path: this.ipcPath });
+        });
+    }
+    /**
+     * Release the shared resource
+     */
+    unlock() {
+        if (!this.server.listening) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            const onClose = () => {
+                this.server.off('error', onError);
+                resolve();
+            };
+            const onError = (err) => {
+                this.server.off('close', onClose);
+                reject(err);
+            };
+            this.server.once('close', onClose);
+            this.server.once('error', onError);
+            // Closing will only prevent new connections, instead of killing old
+            // ones. Manually destroy all existing connections to let them retry the
+            // lock.
+            this.server.close();
+            this.connections.forEach(conn => conn.destroy());
+        });
+    }
+}
+exports.default = CrossProcessLock;
 //# sourceMappingURL=CrossProcessLock.js.map

package/lib-commonjs/DiffStrategy.d.ts

@@ -1,24 +1,24 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- *
- * @format
- */
-import GitReactFileRepository from './GitReactFileRepository';
-import { WritableFileRepository } from './FileRepository';
-/**
- * An UpgradeStrategy describes the process to diff an override to its base
- */
-export default interface DiffStrategy {
-    diff(gitReactRepo: GitReactFileRepository, overrideRepo: WritableFileRepository): Promise<string>;
-}
-export declare const DiffStrategies: {
-    /**
-     * Assume the override is the same as the original
-     */
-    assumeSame: () => DiffStrategy;
-    /**
-     * Assume the override is the same as the original
-     */
-    compareBaseFile: (overrideFile: string, baseFile: string, baseVersion: string) => DiffStrategy;
-};
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @format
+ */
+import GitReactFileRepository from './GitReactFileRepository';
+import { WritableFileRepository } from './FileRepository';
+/**
+ * An UpgradeStrategy describes the process to diff an override to its base
+ */
+export default interface DiffStrategy {
+    diff(gitReactRepo: GitReactFileRepository, overrideRepo: WritableFileRepository): Promise<string>;
+}
+export declare const DiffStrategies: {
+    /**
+     * Assume the override is the same as the original
+     */
+    assumeSame: () => DiffStrategy;
+    /**
+     * Assume the override is the same as the original
+     */
+    compareBaseFile: (overrideFile: string, baseFile: string, baseVersion: string) => DiffStrategy;
+};

package/lib-commonjs/DiffStrategy.js

@@ -1,35 +1,35 @@
-"use strict";
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- *
- * @format
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiffStrategies = void 0;
-exports.DiffStrategies = {
-    /**
-     * Assume the override is the same as the original
-     */
-    assumeSame: () => ({
-        diff: async () => '',
-    }),
-    /**
-     * Assume the override is the same as the original
-     */
-    compareBaseFile: (overrideFile, baseFile, baseVersion) => ({
-        diff: async (gitReactRepo, overrideRepo) => {
-            const overrideContents = await overrideRepo.readFile(overrideFile);
-            if (!overrideContents) {
-                throw new Error(`Couldn't read override "${overrideFile}"`);
-            }
-            const patch = await gitReactRepo.generatePatch(baseFile, baseVersion, overrideContents);
-            return patch
-                .trim()
-                .split('\n')
-                .slice(4) // Ignore Git gunk
-                .join('\n');
-        },
-    }),
-};
+"use strict";
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @format
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffStrategies = void 0;
+exports.DiffStrategies = {
+    /**
+     * Assume the override is the same as the original
+     */
+    assumeSame: () => ({
+        diff: async () => '',
+    }),
+    /**
+     * Assume the override is the same as the original
+     */
+    compareBaseFile: (overrideFile, baseFile, baseVersion) => ({
+        diff: async (gitReactRepo, overrideRepo) => {
+            const overrideContents = await overrideRepo.readFile(overrideFile);
+            if (!overrideContents) {
+                throw new Error(`Couldn't read override "${overrideFile}"`);
+            }
+            const patch = await gitReactRepo.generatePatch(baseFile, baseVersion, overrideContents);
+            return patch
+                .trim()
+                .split('\n')
+                .slice(4) // Ignore Git gunk
+                .join('\n');
+        },
+    }),
+};
 //# sourceMappingURL=DiffStrategy.js.map

package/lib-commonjs/FileRepository.d.ts

@@ -1,62 +1,62 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- *
- * @format
- */
-/// <reference types="node" />
-/**
- * A filesystem abstraction that allows listing and reading files
- */
-export default interface FileRepository {
-    /**
-     * Return the repository-relative path to files
-     * @param globs optional list of globs which files must match
-     */
-    listFiles(globs?: string[]): Promise<Array<string>>;
-    /**
-     * Read the contents of a patch file.
-     * @param filename is expected to be relative to the repository root.
-     */
-    readFile(filename: string): Promise<Buffer | null>;
-    /**
-     * Check whether a file exists, and if so whether its a file or directory
-     */
-    stat(filename: string): Promise<'file' | 'directory' | 'none'>;
-}
-/**
- * Provides access to files
- */
-export interface WritableFileRepository extends FileRepository {
-    /**
-     * Sets the contents of a file. Rejects the promise if the file doesn't
-     * exist.
-     */
-    writeFile(filename: string, content: Buffer | string): Promise<void>;
-    /**
-     * Deletes the file/directory, rejecting the promise if it doesn't exist.
-     */
-    deleteFile(filename: string): Promise<void>;
-}
-/**
- * Provides access to React Native source files
- */
-export interface ReactFileRepository extends FileRepository {
-    /**
-     * Get the React Native version the repo is exploring
-     */
-    getVersion(): string;
-}
-/**
- * Provides access to React Native source files of arbitrary version
- * {@see ReactFileRepository} for more details
- */
-export interface VersionedReactFileRepository {
-    listFiles(globs: string[] | undefined, version: string): Promise<Array<string>>;
-    readFile(filename: string, version: string): Promise<Buffer | null>;
-    stat(filename: string, version: string): Promise<'file' | 'directory' | 'none'>;
-}
-/**
- * Convert from a VersionedReactFileRepository to ReactFileRepository
- */
-export declare function bindVersion(repository: VersionedReactFileRepository, version: string): ReactFileRepository;
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @format
+ */
+/// <reference types="node" />
+/**
+ * A filesystem abstraction that allows listing and reading files
+ */
+export default interface FileRepository {
+    /**
+     * Return the repository-relative path to files
+     * @param globs optional list of globs which files must match
+     */
+    listFiles(globs?: string[]): Promise<Array<string>>;
+    /**
+     * Read the contents of a patch file.
+     * @param filename is expected to be relative to the repository root.
+     */
+    readFile(filename: string): Promise<Buffer | null>;
+    /**
+     * Check whether a file exists, and if so whether its a file or directory
+     */
+    stat(filename: string): Promise<'file' | 'directory' | 'none'>;
+}
+/**
+ * Provides access to files
+ */
+export interface WritableFileRepository extends FileRepository {
+    /**
+     * Sets the contents of a file. Rejects the promise if the file doesn't
+     * exist.
+     */
+    writeFile(filename: string, content: Buffer | string): Promise<void>;
+    /**
+     * Deletes the file/directory, rejecting the promise if it doesn't exist.
+     */
+    deleteFile(filename: string): Promise<void>;
+}
+/**
+ * Provides access to React Native source files
+ */
+export interface ReactFileRepository extends FileRepository {
+    /**
+     * Get the React Native version the repo is exploring
+     */
+    getVersion(): string;
+}
+/**
+ * Provides access to React Native source files of arbitrary version
+ * {@see ReactFileRepository} for more details
+ */
+export interface VersionedReactFileRepository {
+    listFiles(globs: string[] | undefined, version: string): Promise<Array<string>>;
+    readFile(filename: string, version: string): Promise<Buffer | null>;
+    stat(filename: string, version: string): Promise<'file' | 'directory' | 'none'>;
+}
+/**
+ * Convert from a VersionedReactFileRepository to ReactFileRepository
+ */
+export declare function bindVersion(repository: VersionedReactFileRepository, version: string): ReactFileRepository;