Add node modules and new code for release (#39)
Co-authored-by: tbarnes94 <tbarnes94@users.noreply.github.com>
This commit is contained in:
github-actions[bot]
GitHub
parent
a10d84bc2e
commit
7ad2aa66bb
7655 changed files with 1763577 additions and 14 deletions
27
node_modules/jest-haste-map/build/HasteFS.d.ts
generated
vendored
Normal file
27
node_modules/jest-haste-map/build/HasteFS.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
import type { Config } from '@jest/types';
|
||||
import type { FileData } from './types';
|
||||
export default class HasteFS {
|
||||
private readonly _rootDir;
|
||||
private readonly _files;
|
||||
constructor({ rootDir, files }: {
|
||||
rootDir: Config.Path;
|
||||
files: FileData;
|
||||
});
|
||||
getModuleName(file: Config.Path): string | null;
|
||||
getSize(file: Config.Path): number | null;
|
||||
getDependencies(file: Config.Path): Array<string> | null;
|
||||
getSha1(file: Config.Path): string | null;
|
||||
exists(file: Config.Path): boolean;
|
||||
getAllFiles(): Array<Config.Path>;
|
||||
getFileIterator(): Iterable<Config.Path>;
|
||||
getAbsoluteFileIterator(): Iterable<Config.Path>;
|
||||
matchFiles(pattern: RegExp | string): Array<Config.Path>;
|
||||
matchFilesWithGlob(globs: Array<Config.Glob>, root: Config.Path | null): Set<Config.Path>;
|
||||
private _getFileData;
|
||||
}
|
||||
179
node_modules/jest-haste-map/build/HasteFS.js
generated
vendored
Normal file
179
node_modules/jest-haste-map/build/HasteFS.js
generated
vendored
Normal file
|
|
@ -0,0 +1,179 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
function _jestUtil() {
|
||||
const data = require('jest-util');
|
||||
|
||||
_jestUtil = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
var fastPath = _interopRequireWildcard(require('./lib/fast_path'));
|
||||
|
||||
var _constants = _interopRequireDefault(require('./constants'));
|
||||
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
|
||||
function _getRequireWildcardCache() {
|
||||
if (typeof WeakMap !== 'function') return null;
|
||||
var cache = new WeakMap();
|
||||
_getRequireWildcardCache = function () {
|
||||
return cache;
|
||||
};
|
||||
return cache;
|
||||
}
|
||||
|
||||
function _interopRequireWildcard(obj) {
|
||||
if (obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
||||
return {default: obj};
|
||||
}
|
||||
var cache = _getRequireWildcardCache();
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {};
|
||||
var hasPropertyDescriptor =
|
||||
Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor
|
||||
? Object.getOwnPropertyDescriptor(obj, key)
|
||||
: null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
function _defineProperty(obj, key, value) {
|
||||
if (key in obj) {
|
||||
Object.defineProperty(obj, key, {
|
||||
value: value,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
writable: true
|
||||
});
|
||||
} else {
|
||||
obj[key] = value;
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
class HasteFS {
|
||||
constructor({rootDir, files}) {
|
||||
_defineProperty(this, '_rootDir', void 0);
|
||||
|
||||
_defineProperty(this, '_files', void 0);
|
||||
|
||||
this._rootDir = rootDir;
|
||||
this._files = files;
|
||||
}
|
||||
|
||||
getModuleName(file) {
|
||||
const fileMetadata = this._getFileData(file);
|
||||
|
||||
return (fileMetadata && fileMetadata[_constants.default.ID]) || null;
|
||||
}
|
||||
|
||||
getSize(file) {
|
||||
const fileMetadata = this._getFileData(file);
|
||||
|
||||
return (fileMetadata && fileMetadata[_constants.default.SIZE]) || null;
|
||||
}
|
||||
|
||||
getDependencies(file) {
|
||||
const fileMetadata = this._getFileData(file);
|
||||
|
||||
if (fileMetadata) {
|
||||
return fileMetadata[_constants.default.DEPENDENCIES]
|
||||
? fileMetadata[_constants.default.DEPENDENCIES].split(
|
||||
_constants.default.DEPENDENCY_DELIM
|
||||
)
|
||||
: [];
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
getSha1(file) {
|
||||
const fileMetadata = this._getFileData(file);
|
||||
|
||||
return (fileMetadata && fileMetadata[_constants.default.SHA1]) || null;
|
||||
}
|
||||
|
||||
exists(file) {
|
||||
return this._getFileData(file) != null;
|
||||
}
|
||||
|
||||
getAllFiles() {
|
||||
return Array.from(this.getAbsoluteFileIterator());
|
||||
}
|
||||
|
||||
getFileIterator() {
|
||||
return this._files.keys();
|
||||
}
|
||||
|
||||
*getAbsoluteFileIterator() {
|
||||
for (const file of this.getFileIterator()) {
|
||||
yield fastPath.resolve(this._rootDir, file);
|
||||
}
|
||||
}
|
||||
|
||||
matchFiles(pattern) {
|
||||
if (!(pattern instanceof RegExp)) {
|
||||
pattern = new RegExp(pattern);
|
||||
}
|
||||
|
||||
const files = [];
|
||||
|
||||
for (const file of this.getAbsoluteFileIterator()) {
|
||||
if (pattern.test(file)) {
|
||||
files.push(file);
|
||||
}
|
||||
}
|
||||
|
||||
return files;
|
||||
}
|
||||
|
||||
matchFilesWithGlob(globs, root) {
|
||||
const files = new Set();
|
||||
const matcher = (0, _jestUtil().globsToMatcher)(globs);
|
||||
|
||||
for (const file of this.getAbsoluteFileIterator()) {
|
||||
const filePath = root ? fastPath.relative(root, file) : file;
|
||||
|
||||
if (matcher((0, _jestUtil().replacePathSepForGlob)(filePath))) {
|
||||
files.add(file);
|
||||
}
|
||||
}
|
||||
|
||||
return files;
|
||||
}
|
||||
|
||||
_getFileData(file) {
|
||||
const relativePath = fastPath.relative(this._rootDir, file);
|
||||
return this._files.get(relativePath);
|
||||
}
|
||||
}
|
||||
|
||||
exports.default = HasteFS;
|
||||
48
node_modules/jest-haste-map/build/ModuleMap.d.ts
generated
vendored
Normal file
48
node_modules/jest-haste-map/build/ModuleMap.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
import type { Config } from '@jest/types';
|
||||
import type { DuplicatesSet, HTypeValue, MockData, ModuleMapData, RawModuleMap } from './types';
|
||||
declare type ValueType<T> = T extends Map<string, infer V> ? V : never;
|
||||
export declare type SerializableModuleMap = {
|
||||
duplicates: ReadonlyArray<[string, [string, [string, [string, number]]]]>;
|
||||
map: ReadonlyArray<[string, ValueType<ModuleMapData>]>;
|
||||
mocks: ReadonlyArray<[string, ValueType<MockData>]>;
|
||||
rootDir: Config.Path;
|
||||
};
|
||||
export default class ModuleMap {
|
||||
static DuplicateHasteCandidatesError: typeof DuplicateHasteCandidatesError;
|
||||
private readonly _raw;
|
||||
private json;
|
||||
private static mapToArrayRecursive;
|
||||
private static mapFromArrayRecursive;
|
||||
constructor(raw: RawModuleMap);
|
||||
getModule(name: string, platform?: string | null, supportsNativePlatform?: boolean | null, type?: HTypeValue | null): Config.Path | null;
|
||||
getPackage(name: string, platform: string | null | undefined, _supportsNativePlatform: boolean | null): Config.Path | null;
|
||||
getMockModule(name: string): Config.Path | undefined;
|
||||
getRawModuleMap(): RawModuleMap;
|
||||
toJSON(): SerializableModuleMap;
|
||||
static fromJSON(serializableModuleMap: SerializableModuleMap): ModuleMap;
|
||||
/**
|
||||
* When looking up a module's data, we walk through each eligible platform for
|
||||
* the query. For each platform, we want to check if there are known
|
||||
* duplicates for that name+platform pair. The duplication logic normally
|
||||
* removes elements from the `map` object, but we want to check upfront to be
|
||||
* extra sure. If metadata exists both in the `duplicates` object and the
|
||||
* `map`, this would be a bug.
|
||||
*/
|
||||
private _getModuleMetadata;
|
||||
private _assertNoDuplicates;
|
||||
static create(rootDir: Config.Path): ModuleMap;
|
||||
}
|
||||
declare class DuplicateHasteCandidatesError extends Error {
|
||||
hasteName: string;
|
||||
platform: string | null;
|
||||
supportsNativePlatform: boolean;
|
||||
duplicatesSet: DuplicatesSet;
|
||||
constructor(name: string, platform: string, supportsNativePlatform: boolean, duplicatesSet: DuplicatesSet);
|
||||
}
|
||||
export {};
|
||||
305
node_modules/jest-haste-map/build/ModuleMap.js
generated
vendored
Normal file
305
node_modules/jest-haste-map/build/ModuleMap.js
generated
vendored
Normal file
|
|
@ -0,0 +1,305 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var fastPath = _interopRequireWildcard(require('./lib/fast_path'));
|
||||
|
||||
var _constants = _interopRequireDefault(require('./constants'));
|
||||
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
|
||||
function _getRequireWildcardCache() {
|
||||
if (typeof WeakMap !== 'function') return null;
|
||||
var cache = new WeakMap();
|
||||
_getRequireWildcardCache = function () {
|
||||
return cache;
|
||||
};
|
||||
return cache;
|
||||
}
|
||||
|
||||
function _interopRequireWildcard(obj) {
|
||||
if (obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
||||
return {default: obj};
|
||||
}
|
||||
var cache = _getRequireWildcardCache();
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {};
|
||||
var hasPropertyDescriptor =
|
||||
Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor
|
||||
? Object.getOwnPropertyDescriptor(obj, key)
|
||||
: null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
function _defineProperty(obj, key, value) {
|
||||
if (key in obj) {
|
||||
Object.defineProperty(obj, key, {
|
||||
value: value,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
writable: true
|
||||
});
|
||||
} else {
|
||||
obj[key] = value;
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
const EMPTY_OBJ = {};
|
||||
const EMPTY_MAP = new Map();
|
||||
|
||||
class ModuleMap {
|
||||
static mapToArrayRecursive(map) {
|
||||
let arr = Array.from(map);
|
||||
|
||||
if (arr[0] && arr[0][1] instanceof Map) {
|
||||
arr = arr.map(el => [el[0], this.mapToArrayRecursive(el[1])]);
|
||||
}
|
||||
|
||||
return arr;
|
||||
}
|
||||
|
||||
static mapFromArrayRecursive(arr) {
|
||||
if (arr[0] && Array.isArray(arr[1])) {
|
||||
arr = arr.map(el => [el[0], this.mapFromArrayRecursive(el[1])]);
|
||||
}
|
||||
|
||||
return new Map(arr);
|
||||
}
|
||||
|
||||
constructor(raw) {
|
||||
_defineProperty(this, '_raw', void 0);
|
||||
|
||||
_defineProperty(this, 'json', void 0);
|
||||
|
||||
this._raw = raw;
|
||||
}
|
||||
|
||||
getModule(name, platform, supportsNativePlatform, type) {
|
||||
if (type == null) {
|
||||
type = _constants.default.MODULE;
|
||||
}
|
||||
|
||||
const module = this._getModuleMetadata(
|
||||
name,
|
||||
platform,
|
||||
!!supportsNativePlatform
|
||||
);
|
||||
|
||||
if (module && module[_constants.default.TYPE] === type) {
|
||||
const modulePath = module[_constants.default.PATH];
|
||||
return modulePath && fastPath.resolve(this._raw.rootDir, modulePath);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
getPackage(name, platform, _supportsNativePlatform) {
|
||||
return this.getModule(name, platform, null, _constants.default.PACKAGE);
|
||||
}
|
||||
|
||||
getMockModule(name) {
|
||||
const mockPath =
|
||||
this._raw.mocks.get(name) || this._raw.mocks.get(name + '/index');
|
||||
|
||||
return mockPath && fastPath.resolve(this._raw.rootDir, mockPath);
|
||||
}
|
||||
|
||||
getRawModuleMap() {
|
||||
return {
|
||||
duplicates: this._raw.duplicates,
|
||||
map: this._raw.map,
|
||||
mocks: this._raw.mocks,
|
||||
rootDir: this._raw.rootDir
|
||||
};
|
||||
}
|
||||
|
||||
toJSON() {
|
||||
if (!this.json) {
|
||||
this.json = {
|
||||
duplicates: ModuleMap.mapToArrayRecursive(this._raw.duplicates),
|
||||
map: Array.from(this._raw.map),
|
||||
mocks: Array.from(this._raw.mocks),
|
||||
rootDir: this._raw.rootDir
|
||||
};
|
||||
}
|
||||
|
||||
return this.json;
|
||||
}
|
||||
|
||||
static fromJSON(serializableModuleMap) {
|
||||
return new ModuleMap({
|
||||
duplicates: ModuleMap.mapFromArrayRecursive(
|
||||
serializableModuleMap.duplicates
|
||||
),
|
||||
map: new Map(serializableModuleMap.map),
|
||||
mocks: new Map(serializableModuleMap.mocks),
|
||||
rootDir: serializableModuleMap.rootDir
|
||||
});
|
||||
}
|
||||
/**
|
||||
* When looking up a module's data, we walk through each eligible platform for
|
||||
* the query. For each platform, we want to check if there are known
|
||||
* duplicates for that name+platform pair. The duplication logic normally
|
||||
* removes elements from the `map` object, but we want to check upfront to be
|
||||
* extra sure. If metadata exists both in the `duplicates` object and the
|
||||
* `map`, this would be a bug.
|
||||
*/
|
||||
|
||||
_getModuleMetadata(name, platform, supportsNativePlatform) {
|
||||
const map = this._raw.map.get(name) || EMPTY_OBJ;
|
||||
const dupMap = this._raw.duplicates.get(name) || EMPTY_MAP;
|
||||
|
||||
if (platform != null) {
|
||||
this._assertNoDuplicates(
|
||||
name,
|
||||
platform,
|
||||
supportsNativePlatform,
|
||||
dupMap.get(platform)
|
||||
);
|
||||
|
||||
if (map[platform] != null) {
|
||||
return map[platform];
|
||||
}
|
||||
}
|
||||
|
||||
if (supportsNativePlatform) {
|
||||
this._assertNoDuplicates(
|
||||
name,
|
||||
_constants.default.NATIVE_PLATFORM,
|
||||
supportsNativePlatform,
|
||||
dupMap.get(_constants.default.NATIVE_PLATFORM)
|
||||
);
|
||||
|
||||
if (map[_constants.default.NATIVE_PLATFORM]) {
|
||||
return map[_constants.default.NATIVE_PLATFORM];
|
||||
}
|
||||
}
|
||||
|
||||
this._assertNoDuplicates(
|
||||
name,
|
||||
_constants.default.GENERIC_PLATFORM,
|
||||
supportsNativePlatform,
|
||||
dupMap.get(_constants.default.GENERIC_PLATFORM)
|
||||
);
|
||||
|
||||
if (map[_constants.default.GENERIC_PLATFORM]) {
|
||||
return map[_constants.default.GENERIC_PLATFORM];
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
_assertNoDuplicates(name, platform, supportsNativePlatform, relativePathSet) {
|
||||
if (relativePathSet == null) {
|
||||
return;
|
||||
} // Force flow refinement
|
||||
|
||||
const previousSet = relativePathSet;
|
||||
const duplicates = new Map();
|
||||
|
||||
for (const [relativePath, type] of previousSet) {
|
||||
const duplicatePath = fastPath.resolve(this._raw.rootDir, relativePath);
|
||||
duplicates.set(duplicatePath, type);
|
||||
}
|
||||
|
||||
throw new DuplicateHasteCandidatesError(
|
||||
name,
|
||||
platform,
|
||||
supportsNativePlatform,
|
||||
duplicates
|
||||
);
|
||||
}
|
||||
|
||||
static create(rootDir) {
|
||||
return new ModuleMap({
|
||||
duplicates: new Map(),
|
||||
map: new Map(),
|
||||
mocks: new Map(),
|
||||
rootDir
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
exports.default = ModuleMap;
|
||||
|
||||
_defineProperty(ModuleMap, 'DuplicateHasteCandidatesError', void 0);
|
||||
|
||||
class DuplicateHasteCandidatesError extends Error {
|
||||
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('')
|
||||
);
|
||||
|
||||
_defineProperty(this, 'hasteName', void 0);
|
||||
|
||||
_defineProperty(this, 'platform', void 0);
|
||||
|
||||
_defineProperty(this, 'supportsNativePlatform', void 0);
|
||||
|
||||
_defineProperty(this, 'duplicatesSet', void 0);
|
||||
|
||||
this.hasteName = name;
|
||||
this.platform = platform;
|
||||
this.supportsNativePlatform = supportsNativePlatform;
|
||||
this.duplicatesSet = duplicatesSet;
|
||||
}
|
||||
}
|
||||
|
||||
function getPlatformMessage(platform) {
|
||||
if (platform === _constants.default.GENERIC_PLATFORM) {
|
||||
return 'The platform is generic (no extension).';
|
||||
}
|
||||
|
||||
return `The platform extension is \`${platform}\`.`;
|
||||
}
|
||||
|
||||
function getTypeMessage(type) {
|
||||
switch (type) {
|
||||
case _constants.default.MODULE:
|
||||
return 'module';
|
||||
|
||||
case _constants.default.PACKAGE:
|
||||
return 'package';
|
||||
}
|
||||
|
||||
return 'unknown';
|
||||
}
|
||||
|
||||
ModuleMap.DuplicateHasteCandidatesError = DuplicateHasteCandidatesError;
|
||||
8
node_modules/jest-haste-map/build/blacklist.d.ts
generated
vendored
Normal file
8
node_modules/jest-haste-map/build/blacklist.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
declare const extensions: Set<string>;
|
||||
export default extensions;
|
||||
59
node_modules/jest-haste-map/build/blacklist.js
generated
vendored
Normal file
59
node_modules/jest-haste-map/build/blacklist.js
generated
vendored
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
// This list is compiled after the MDN list of the most common MIME types (see
|
||||
// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/MIME_types/
|
||||
// Complete_list_of_MIME_types).
|
||||
//
|
||||
// Only MIME types starting with "image/", "video/", "audio/" and "font/" are
|
||||
// reflected in the list. Adding "application/" is too risky since some text
|
||||
// file formats (like ".js" and ".json") have an "application/" MIME type.
|
||||
//
|
||||
// Feel free to add any extensions that cannot be a Haste module.
|
||||
const extensions = new Set([
|
||||
// JSONs are never haste modules, except for "package.json", which is handled.
|
||||
'.json', // Image extensions.
|
||||
'.bmp',
|
||||
'.gif',
|
||||
'.ico',
|
||||
'.jpeg',
|
||||
'.jpg',
|
||||
'.png',
|
||||
'.svg',
|
||||
'.tiff',
|
||||
'.tif',
|
||||
'.webp', // Video extensions.
|
||||
'.avi',
|
||||
'.mp4',
|
||||
'.mpeg',
|
||||
'.mpg',
|
||||
'.ogv',
|
||||
'.webm',
|
||||
'.3gp',
|
||||
'.3g2', // Audio extensions.
|
||||
'.aac',
|
||||
'.midi',
|
||||
'.mid',
|
||||
'.mp3',
|
||||
'.oga',
|
||||
'.wav',
|
||||
'.3gp',
|
||||
'.3g2', // Font extensions.
|
||||
'.eot',
|
||||
'.otf',
|
||||
'.ttf',
|
||||
'.woff',
|
||||
'.woff2'
|
||||
]);
|
||||
var _default = extensions;
|
||||
exports.default = _default;
|
||||
9
node_modules/jest-haste-map/build/constants.d.ts
generated
vendored
Normal file
9
node_modules/jest-haste-map/build/constants.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
import type { HType } from './types';
|
||||
declare const constants: HType;
|
||||
export default constants;
|
||||
52
node_modules/jest-haste-map/build/constants.js
generated
vendored
Normal file
52
node_modules/jest-haste-map/build/constants.js
generated
vendored
Normal file
|
|
@ -0,0 +1,52 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file exports a set of constants that are used for Jest's haste map
|
||||
* serialization. On very large repositories, the haste map cache becomes very
|
||||
* large to the point where it is the largest overhead in starting up Jest.
|
||||
*
|
||||
* This constant key map allows to keep the map smaller without having to build
|
||||
* a custom serialization library.
|
||||
*/
|
||||
|
||||
/* eslint-disable sort-keys */
|
||||
const constants = {
|
||||
/* dependency serialization */
|
||||
DEPENDENCY_DELIM: '\0',
|
||||
|
||||
/* file map attributes */
|
||||
ID: 0,
|
||||
MTIME: 1,
|
||||
SIZE: 2,
|
||||
VISITED: 3,
|
||||
DEPENDENCIES: 4,
|
||||
SHA1: 5,
|
||||
|
||||
/* module map attributes */
|
||||
PATH: 0,
|
||||
TYPE: 1,
|
||||
|
||||
/* module types */
|
||||
MODULE: 0,
|
||||
PACKAGE: 1,
|
||||
|
||||
/* platforms */
|
||||
GENERIC_PLATFORM: 'g',
|
||||
NATIVE_PLATFORM: 'native'
|
||||
};
|
||||
/* eslint-enable */
|
||||
|
||||
var _default = constants;
|
||||
exports.default = _default;
|
||||
12
node_modules/jest-haste-map/build/crawlers/node.d.ts
generated
vendored
Normal file
12
node_modules/jest-haste-map/build/crawlers/node.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
import type { CrawlerOptions, FileData, InternalHasteMap } from '../types';
|
||||
declare const _default: (options: CrawlerOptions) => Promise<{
|
||||
removedFiles: FileData;
|
||||
hasteMap: InternalHasteMap;
|
||||
}>;
|
||||
export = _default;
|
||||
320
node_modules/jest-haste-map/build/crawlers/node.js
generated
vendored
Normal file
320
node_modules/jest-haste-map/build/crawlers/node.js
generated
vendored
Normal file
|
|
@ -0,0 +1,320 @@
|
|||
'use strict';
|
||||
|
||||
function path() {
|
||||
const data = _interopRequireWildcard(require('path'));
|
||||
|
||||
path = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _child_process() {
|
||||
const data = require('child_process');
|
||||
|
||||
_child_process = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function fs() {
|
||||
const data = _interopRequireWildcard(require('graceful-fs'));
|
||||
|
||||
fs = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _constants() {
|
||||
const data = _interopRequireDefault(require('../constants'));
|
||||
|
||||
_constants = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function fastPath() {
|
||||
const data = _interopRequireWildcard(require('../lib/fast_path'));
|
||||
|
||||
fastPath = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
|
||||
function _getRequireWildcardCache() {
|
||||
if (typeof WeakMap !== 'function') return null;
|
||||
var cache = new WeakMap();
|
||||
_getRequireWildcardCache = function () {
|
||||
return cache;
|
||||
};
|
||||
return cache;
|
||||
}
|
||||
|
||||
function _interopRequireWildcard(obj) {
|
||||
if (obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
||||
return {default: obj};
|
||||
}
|
||||
var cache = _getRequireWildcardCache();
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {};
|
||||
var hasPropertyDescriptor =
|
||||
Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor
|
||||
? Object.getOwnPropertyDescriptor(obj, key)
|
||||
: null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
async function hasNativeFindSupport(forceNodeFilesystemAPI) {
|
||||
if (forceNodeFilesystemAPI) {
|
||||
return false;
|
||||
}
|
||||
|
||||
try {
|
||||
return await new Promise(resolve => {
|
||||
// Check the find binary supports the non-POSIX -iname parameter wrapped in parens.
|
||||
const args = [
|
||||
'.',
|
||||
'-type',
|
||||
'f',
|
||||
'(',
|
||||
'-iname',
|
||||
'*.ts',
|
||||
'-o',
|
||||
'-iname',
|
||||
'*.js',
|
||||
')'
|
||||
];
|
||||
const child = (0, _child_process().spawn)('find', args, {
|
||||
cwd: __dirname
|
||||
});
|
||||
child.on('error', () => {
|
||||
resolve(false);
|
||||
});
|
||||
child.on('exit', code => {
|
||||
resolve(code === 0);
|
||||
});
|
||||
});
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function find(roots, extensions, ignore, callback) {
|
||||
const result = [];
|
||||
let activeCalls = 0;
|
||||
|
||||
function search(directory) {
|
||||
activeCalls++;
|
||||
fs().readdir(
|
||||
directory,
|
||||
{
|
||||
withFileTypes: true
|
||||
},
|
||||
(err, entries) => {
|
||||
activeCalls--;
|
||||
|
||||
if (err) {
|
||||
callback(result);
|
||||
return;
|
||||
} // node < v10.10 does not support the withFileTypes option, and
|
||||
// entry will be a string.
|
||||
|
||||
entries.forEach(entry => {
|
||||
const file = path().join(
|
||||
directory,
|
||||
typeof entry === 'string' ? entry : entry.name
|
||||
);
|
||||
|
||||
if (ignore(file)) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (typeof entry !== 'string') {
|
||||
if (entry.isSymbolicLink()) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (entry.isDirectory()) {
|
||||
search(file);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
activeCalls++;
|
||||
fs().lstat(file, (err, stat) => {
|
||||
activeCalls--; // This logic is unnecessary for node > v10.10, but leaving it in
|
||||
// since we need it for backwards-compatibility still.
|
||||
|
||||
if (!err && stat && !stat.isSymbolicLink()) {
|
||||
if (stat.isDirectory()) {
|
||||
search(file);
|
||||
} else {
|
||||
const ext = path().extname(file).substr(1);
|
||||
|
||||
if (extensions.indexOf(ext) !== -1) {
|
||||
result.push([file, stat.mtime.getTime(), stat.size]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (activeCalls === 0) {
|
||||
callback(result);
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
if (activeCalls === 0) {
|
||||
callback(result);
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
if (roots.length > 0) {
|
||||
roots.forEach(search);
|
||||
} else {
|
||||
callback(result);
|
||||
}
|
||||
}
|
||||
|
||||
function findNative(roots, extensions, ignore, callback) {
|
||||
const args = Array.from(roots);
|
||||
args.push('-type', 'f');
|
||||
|
||||
if (extensions.length) {
|
||||
args.push('(');
|
||||
}
|
||||
|
||||
extensions.forEach((ext, index) => {
|
||||
if (index) {
|
||||
args.push('-o');
|
||||
}
|
||||
|
||||
args.push('-iname');
|
||||
args.push('*.' + ext);
|
||||
});
|
||||
|
||||
if (extensions.length) {
|
||||
args.push(')');
|
||||
}
|
||||
|
||||
const child = (0, _child_process().spawn)('find', args);
|
||||
let stdout = '';
|
||||
|
||||
if (child.stdout === null) {
|
||||
throw new Error(
|
||||
'stdout is null - this should never happen. Please open up an issue at https://github.com/facebook/jest'
|
||||
);
|
||||
}
|
||||
|
||||
child.stdout.setEncoding('utf-8');
|
||||
child.stdout.on('data', data => (stdout += data));
|
||||
child.stdout.on('close', () => {
|
||||
const lines = stdout
|
||||
.trim()
|
||||
.split('\n')
|
||||
.filter(x => !ignore(x));
|
||||
const result = [];
|
||||
let count = lines.length;
|
||||
|
||||
if (!count) {
|
||||
callback([]);
|
||||
} else {
|
||||
lines.forEach(path => {
|
||||
fs().stat(path, (err, stat) => {
|
||||
if (!err && stat) {
|
||||
result.push([path, stat.mtime.getTime(), stat.size]);
|
||||
}
|
||||
|
||||
if (--count === 0) {
|
||||
callback(result);
|
||||
}
|
||||
});
|
||||
});
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
module.exports = async function nodeCrawl(options) {
|
||||
const {
|
||||
data,
|
||||
extensions,
|
||||
forceNodeFilesystemAPI,
|
||||
ignore,
|
||||
rootDir,
|
||||
roots
|
||||
} = options;
|
||||
const useNativeFind = await hasNativeFindSupport(forceNodeFilesystemAPI);
|
||||
return new Promise(resolve => {
|
||||
const callback = list => {
|
||||
const files = new Map();
|
||||
const removedFiles = new Map(data.files);
|
||||
list.forEach(fileData => {
|
||||
const [filePath, mtime, size] = fileData;
|
||||
const relativeFilePath = fastPath().relative(rootDir, filePath);
|
||||
const existingFile = data.files.get(relativeFilePath);
|
||||
|
||||
if (
|
||||
existingFile &&
|
||||
existingFile[_constants().default.MTIME] === mtime
|
||||
) {
|
||||
files.set(relativeFilePath, existingFile);
|
||||
} else {
|
||||
// See ../constants.js; SHA-1 will always be null and fulfilled later.
|
||||
files.set(relativeFilePath, ['', mtime, size, 0, '', null]);
|
||||
}
|
||||
|
||||
removedFiles.delete(relativeFilePath);
|
||||
});
|
||||
data.files = files;
|
||||
resolve({
|
||||
hasteMap: data,
|
||||
removedFiles
|
||||
});
|
||||
};
|
||||
|
||||
if (useNativeFind) {
|
||||
findNative(roots, extensions, ignore, callback);
|
||||
} else {
|
||||
find(roots, extensions, ignore, callback);
|
||||
}
|
||||
});
|
||||
};
|
||||
13
node_modules/jest-haste-map/build/crawlers/watchman.d.ts
generated
vendored
Normal file
13
node_modules/jest-haste-map/build/crawlers/watchman.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
import type { CrawlerOptions, FileData, InternalHasteMap } from '../types';
|
||||
declare const _default: (options: CrawlerOptions) => Promise<{
|
||||
changedFiles?: FileData | undefined;
|
||||
removedFiles: FileData;
|
||||
hasteMap: InternalHasteMap;
|
||||
}>;
|
||||
export = _default;
|
||||
327
node_modules/jest-haste-map/build/crawlers/watchman.js
generated
vendored
Normal file
327
node_modules/jest-haste-map/build/crawlers/watchman.js
generated
vendored
Normal file
|
|
@ -0,0 +1,327 @@
|
|||
'use strict';
|
||||
|
||||
function path() {
|
||||
const data = _interopRequireWildcard(require('path'));
|
||||
|
||||
path = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _fbWatchman() {
|
||||
const data = _interopRequireDefault(require('fb-watchman'));
|
||||
|
||||
_fbWatchman = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function fastPath() {
|
||||
const data = _interopRequireWildcard(require('../lib/fast_path'));
|
||||
|
||||
fastPath = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _normalizePathSep() {
|
||||
const data = _interopRequireDefault(require('../lib/normalizePathSep'));
|
||||
|
||||
_normalizePathSep = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _constants() {
|
||||
const data = _interopRequireDefault(require('../constants'));
|
||||
|
||||
_constants = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
|
||||
function _getRequireWildcardCache() {
|
||||
if (typeof WeakMap !== 'function') return null;
|
||||
var cache = new WeakMap();
|
||||
_getRequireWildcardCache = function () {
|
||||
return cache;
|
||||
};
|
||||
return cache;
|
||||
}
|
||||
|
||||
function _interopRequireWildcard(obj) {
|
||||
if (obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
||||
return {default: obj};
|
||||
}
|
||||
var cache = _getRequireWildcardCache();
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {};
|
||||
var hasPropertyDescriptor =
|
||||
Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor
|
||||
? Object.getOwnPropertyDescriptor(obj, key)
|
||||
: null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
const watchmanURL = 'https://facebook.github.io/watchman/docs/troubleshooting';
|
||||
|
||||
function WatchmanError(error) {
|
||||
error.message =
|
||||
`Watchman error: ${error.message.trim()}. Make sure watchman ` +
|
||||
`is running for this project. See ${watchmanURL}.`;
|
||||
return error;
|
||||
}
|
||||
|
||||
module.exports = async function watchmanCrawl(options) {
|
||||
const fields = ['name', 'exists', 'mtime_ms', 'size'];
|
||||
const {data, extensions, ignore, rootDir, roots} = options;
|
||||
const defaultWatchExpression = [
|
||||
'allof',
|
||||
['type', 'f'],
|
||||
['anyof', ...extensions.map(extension => ['suffix', extension])]
|
||||
];
|
||||
const clocks = data.clocks;
|
||||
const client = new (_fbWatchman().default.Client)();
|
||||
let clientError;
|
||||
client.on('error', error => (clientError = WatchmanError(error))); // TODO: type better than `any`
|
||||
|
||||
const cmd = (...args) =>
|
||||
new Promise((resolve, reject) =>
|
||||
client.command(args, (error, result) =>
|
||||
error ? reject(WatchmanError(error)) : resolve(result)
|
||||
)
|
||||
);
|
||||
|
||||
if (options.computeSha1) {
|
||||
const {capabilities} = await cmd('list-capabilities');
|
||||
|
||||
if (capabilities.indexOf('field-content.sha1hex') !== -1) {
|
||||
fields.push('content.sha1hex');
|
||||
}
|
||||
}
|
||||
|
||||
async function getWatchmanRoots(roots) {
|
||||
const watchmanRoots = new Map();
|
||||
await Promise.all(
|
||||
roots.map(async root => {
|
||||
const response = await cmd('watch-project', root);
|
||||
const existing = watchmanRoots.get(response.watch); // A root can only be filtered if it was never seen with a
|
||||
// relative_path before.
|
||||
|
||||
const canBeFiltered = !existing || existing.length > 0;
|
||||
|
||||
if (canBeFiltered) {
|
||||
if (response.relative_path) {
|
||||
watchmanRoots.set(
|
||||
response.watch,
|
||||
(existing || []).concat(response.relative_path)
|
||||
);
|
||||
} else {
|
||||
// Make the filter directories an empty array to signal that this
|
||||
// root was already seen and needs to be watched for all files or
|
||||
// directories.
|
||||
watchmanRoots.set(response.watch, []);
|
||||
}
|
||||
}
|
||||
})
|
||||
);
|
||||
return watchmanRoots;
|
||||
}
|
||||
|
||||
async function queryWatchmanForDirs(rootProjectDirMappings) {
|
||||
const files = new Map();
|
||||
let isFresh = false;
|
||||
await Promise.all(
|
||||
Array.from(rootProjectDirMappings).map(
|
||||
async ([root, directoryFilters]) => {
|
||||
const expression = Array.from(defaultWatchExpression);
|
||||
const glob = [];
|
||||
|
||||
if (directoryFilters.length > 0) {
|
||||
expression.push([
|
||||
'anyof',
|
||||
...directoryFilters.map(dir => ['dirname', dir])
|
||||
]);
|
||||
|
||||
for (const directory of directoryFilters) {
|
||||
for (const extension of extensions) {
|
||||
glob.push(`${directory}/**/*.${extension}`);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (const extension of extensions) {
|
||||
glob.push(`**/*.${extension}`);
|
||||
}
|
||||
}
|
||||
|
||||
const relativeRoot = fastPath().relative(rootDir, root);
|
||||
const query = clocks.has(relativeRoot) // Use the `since` generator if we have a clock available
|
||||
? {
|
||||
expression,
|
||||
fields,
|
||||
since: clocks.get(relativeRoot)
|
||||
} // Otherwise use the `glob` filter
|
||||
: {
|
||||
expression,
|
||||
fields,
|
||||
glob,
|
||||
glob_includedotfiles: true
|
||||
};
|
||||
const response = await cmd('query', root, query);
|
||||
|
||||
if ('warning' in response) {
|
||||
console.warn('watchman warning: ', response.warning);
|
||||
}
|
||||
|
||||
isFresh = isFresh || response.is_fresh_instance;
|
||||
files.set(root, response);
|
||||
}
|
||||
)
|
||||
);
|
||||
return {
|
||||
files,
|
||||
isFresh
|
||||
};
|
||||
}
|
||||
|
||||
let files = data.files;
|
||||
let removedFiles = new Map();
|
||||
const changedFiles = new Map();
|
||||
let watchmanFiles;
|
||||
let isFresh = false;
|
||||
|
||||
try {
|
||||
const watchmanRoots = await getWatchmanRoots(roots);
|
||||
const watchmanFileResults = await queryWatchmanForDirs(watchmanRoots); // Reset the file map if watchman was restarted and sends us a list of
|
||||
// files.
|
||||
|
||||
if (watchmanFileResults.isFresh) {
|
||||
files = new Map();
|
||||
removedFiles = new Map(data.files);
|
||||
isFresh = true;
|
||||
}
|
||||
|
||||
watchmanFiles = watchmanFileResults.files;
|
||||
} finally {
|
||||
client.end();
|
||||
}
|
||||
|
||||
if (clientError) {
|
||||
throw clientError;
|
||||
} // TODO: remove non-null
|
||||
|
||||
for (const [watchRoot, response] of watchmanFiles) {
|
||||
const fsRoot = (0, _normalizePathSep().default)(watchRoot);
|
||||
const relativeFsRoot = fastPath().relative(rootDir, fsRoot);
|
||||
clocks.set(relativeFsRoot, response.clock);
|
||||
|
||||
for (const fileData of response.files) {
|
||||
const filePath =
|
||||
fsRoot + path().sep + (0, _normalizePathSep().default)(fileData.name);
|
||||
const relativeFilePath = fastPath().relative(rootDir, filePath);
|
||||
const existingFileData = data.files.get(relativeFilePath); // If watchman is fresh, the removed files map starts with all files
|
||||
// and we remove them as we verify they still exist.
|
||||
|
||||
if (isFresh && existingFileData && fileData.exists) {
|
||||
removedFiles.delete(relativeFilePath);
|
||||
}
|
||||
|
||||
if (!fileData.exists) {
|
||||
// No need to act on files that do not exist and were not tracked.
|
||||
if (existingFileData) {
|
||||
files.delete(relativeFilePath); // If watchman is not fresh, we will know what specific files were
|
||||
// deleted since we last ran and can track only those files.
|
||||
|
||||
if (!isFresh) {
|
||||
removedFiles.set(relativeFilePath, existingFileData);
|
||||
}
|
||||
}
|
||||
} else if (!ignore(filePath)) {
|
||||
const mtime =
|
||||
typeof fileData.mtime_ms === 'number'
|
||||
? fileData.mtime_ms
|
||||
: fileData.mtime_ms.toNumber();
|
||||
const size = fileData.size;
|
||||
let sha1hex = fileData['content.sha1hex'];
|
||||
|
||||
if (typeof sha1hex !== 'string' || sha1hex.length !== 40) {
|
||||
sha1hex = null;
|
||||
}
|
||||
|
||||
let nextData;
|
||||
|
||||
if (
|
||||
existingFileData &&
|
||||
existingFileData[_constants().default.MTIME] === mtime
|
||||
) {
|
||||
nextData = existingFileData;
|
||||
} else if (
|
||||
existingFileData &&
|
||||
sha1hex &&
|
||||
existingFileData[_constants().default.SHA1] === sha1hex
|
||||
) {
|
||||
nextData = [
|
||||
existingFileData[0],
|
||||
mtime,
|
||||
existingFileData[2],
|
||||
existingFileData[3],
|
||||
existingFileData[4],
|
||||
existingFileData[5]
|
||||
];
|
||||
} else {
|
||||
// See ../constants.ts
|
||||
nextData = ['', mtime, size, 0, '', sha1hex];
|
||||
}
|
||||
|
||||
files.set(relativeFilePath, nextData);
|
||||
changedFiles.set(relativeFilePath, nextData);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
data.files = files;
|
||||
return {
|
||||
changedFiles: isFresh ? undefined : changedFiles,
|
||||
hasteMap: data,
|
||||
removedFiles
|
||||
};
|
||||
};
|
||||
8
node_modules/jest-haste-map/build/getMockName.d.ts
generated
vendored
Normal file
8
node_modules/jest-haste-map/build/getMockName.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
declare const getMockName: (filePath: string) => string;
|
||||
export default getMockName;
|
||||
76
node_modules/jest-haste-map/build/getMockName.js
generated
vendored
Normal file
76
node_modules/jest-haste-map/build/getMockName.js
generated
vendored
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
function path() {
|
||||
const data = _interopRequireWildcard(require('path'));
|
||||
|
||||
path = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _getRequireWildcardCache() {
|
||||
if (typeof WeakMap !== 'function') return null;
|
||||
var cache = new WeakMap();
|
||||
_getRequireWildcardCache = function () {
|
||||
return cache;
|
||||
};
|
||||
return cache;
|
||||
}
|
||||
|
||||
function _interopRequireWildcard(obj) {
|
||||
if (obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
||||
return {default: obj};
|
||||
}
|
||||
var cache = _getRequireWildcardCache();
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {};
|
||||
var hasPropertyDescriptor =
|
||||
Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor
|
||||
? Object.getOwnPropertyDescriptor(obj, key)
|
||||
: null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
const MOCKS_PATTERN = path().sep + '__mocks__' + path().sep;
|
||||
|
||||
const getMockName = filePath => {
|
||||
const mockPath = filePath.split(MOCKS_PATTERN)[1];
|
||||
return mockPath
|
||||
.substring(0, mockPath.lastIndexOf(path().extname(mockPath)))
|
||||
.replace(/\\/g, '/');
|
||||
};
|
||||
|
||||
var _default = getMockName;
|
||||
exports.default = _default;
|
||||
187
node_modules/jest-haste-map/build/index.d.ts
generated
vendored
Normal file
187
node_modules/jest-haste-map/build/index.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,187 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
/// <reference types="node" />
|
||||
import { EventEmitter } from 'events';
|
||||
import type { Config } from '@jest/types';
|
||||
import H from './constants';
|
||||
import HasteFS from './HasteFS';
|
||||
import HasteModuleMap, { SerializableModuleMap as HasteSerializableModuleMap } from './ModuleMap';
|
||||
import type { ChangeEvent, HasteRegExp, InternalHasteMap, HasteMap as InternalHasteMapObject } from './types';
|
||||
declare type HType = typeof H;
|
||||
declare type Options = {
|
||||
cacheDirectory?: string;
|
||||
computeDependencies?: boolean;
|
||||
computeSha1?: boolean;
|
||||
console?: Console;
|
||||
dependencyExtractor?: string | null;
|
||||
extensions: Array<string>;
|
||||
forceNodeFilesystemAPI?: boolean;
|
||||
hasteImplModulePath?: string;
|
||||
ignorePattern?: HasteRegExp;
|
||||
maxWorkers: number;
|
||||
mocksPattern?: string;
|
||||
name: string;
|
||||
platforms: Array<string>;
|
||||
resetCache?: boolean;
|
||||
retainAllFiles: boolean;
|
||||
rootDir: string;
|
||||
roots: Array<string>;
|
||||
skipPackageJson?: boolean;
|
||||
throwOnModuleCollision?: boolean;
|
||||
useWatchman?: boolean;
|
||||
watch?: boolean;
|
||||
};
|
||||
declare namespace HasteMap {
|
||||
type ModuleMap = HasteModuleMap;
|
||||
type SerializableModuleMap = HasteSerializableModuleMap;
|
||||
type FS = HasteFS;
|
||||
type HasteMapObject = InternalHasteMapObject;
|
||||
type HasteChangeEvent = ChangeEvent;
|
||||
}
|
||||
/**
|
||||
* HasteMap is a JavaScript implementation of Facebook's haste module system.
|
||||
*
|
||||
* This implementation is inspired by https://github.com/facebook/node-haste
|
||||
* and was built with for high-performance in large code repositories with
|
||||
* hundreds of thousands of files. This implementation is scalable and provides
|
||||
* predictable performance.
|
||||
*
|
||||
* Because the haste map creation and synchronization is critical to startup
|
||||
* performance and most tasks are blocked by I/O this class makes heavy use of
|
||||
* synchronous operations. It uses worker processes for parallelizing file
|
||||
* access and metadata extraction.
|
||||
*
|
||||
* The data structures created by `jest-haste-map` can be used directly from the
|
||||
* cache without further processing. The metadata objects in the `files` and
|
||||
* `map` objects contain cross-references: a metadata object from one can look
|
||||
* up the corresponding metadata object in the other map. Note that in most
|
||||
* projects, the number of files will be greater than the number of haste
|
||||
* modules one module can refer to many files based on platform extensions.
|
||||
*
|
||||
* type HasteMap = {
|
||||
* clocks: WatchmanClocks,
|
||||
* files: {[filepath: string]: FileMetaData},
|
||||
* map: {[id: string]: ModuleMapItem},
|
||||
* mocks: {[id: string]: string},
|
||||
* }
|
||||
*
|
||||
* // Watchman clocks are used for query synchronization and file system deltas.
|
||||
* type WatchmanClocks = {[filepath: string]: string};
|
||||
*
|
||||
* type FileMetaData = {
|
||||
* id: ?string, // used to look up module metadata objects in `map`.
|
||||
* mtime: number, // check for outdated files.
|
||||
* size: number, // size of the file in bytes.
|
||||
* visited: boolean, // whether the file has been parsed or not.
|
||||
* dependencies: Array<string>, // all relative dependencies of this file.
|
||||
* sha1: ?string, // SHA-1 of the file, if requested via options.
|
||||
* };
|
||||
*
|
||||
* // Modules can be targeted to a specific platform based on the file name.
|
||||
* // Example: platform.ios.js and Platform.android.js will both map to the same
|
||||
* // `Platform` module. The platform should be specified during resolution.
|
||||
* type ModuleMapItem = {[platform: string]: ModuleMetaData};
|
||||
*
|
||||
* //
|
||||
* type ModuleMetaData = {
|
||||
* path: string, // the path to look up the file object in `files`.
|
||||
* type: string, // the module type (either `package` or `module`).
|
||||
* };
|
||||
*
|
||||
* Note that the data structures described above are conceptual only. The actual
|
||||
* implementation uses arrays and constant keys for metadata storage. Instead of
|
||||
* `{id: 'flatMap', mtime: 3421, size: 42, visited: true, dependencies: []}` the real
|
||||
* representation is similar to `['flatMap', 3421, 42, 1, []]` to save storage space
|
||||
* and reduce parse and write time of a big JSON blob.
|
||||
*
|
||||
* The HasteMap is created as follows:
|
||||
* 1. read data from the cache or create an empty structure.
|
||||
*
|
||||
* 2. crawl the file system.
|
||||
* * empty cache: crawl the entire file system.
|
||||
* * cache available:
|
||||
* * if watchman is available: get file system delta changes.
|
||||
* * if watchman is unavailable: crawl the entire file system.
|
||||
* * build metadata objects for every file. This builds the `files` part of
|
||||
* the `HasteMap`.
|
||||
*
|
||||
* 3. parse and extract metadata from changed files.
|
||||
* * this is done in parallel over worker processes to improve performance.
|
||||
* * the worst case is to parse all files.
|
||||
* * the best case is no file system access and retrieving all data from
|
||||
* the cache.
|
||||
* * the average case is a small number of changed files.
|
||||
*
|
||||
* 4. serialize the new `HasteMap` in a cache file.
|
||||
* Worker processes can directly access the cache through `HasteMap.read()`.
|
||||
*
|
||||
*/
|
||||
declare class HasteMap extends EventEmitter {
|
||||
private _buildPromise;
|
||||
private _cachePath;
|
||||
private _changeInterval?;
|
||||
private _console;
|
||||
private _options;
|
||||
private _watchers;
|
||||
private _worker;
|
||||
constructor(options: Options);
|
||||
static getCacheFilePath(tmpdir: Config.Path, name: string, ...extra: Array<string>): string;
|
||||
getCacheFilePath(): string;
|
||||
build(): Promise<InternalHasteMapObject>;
|
||||
/**
|
||||
* 1. read data from the cache or create an empty structure.
|
||||
*/
|
||||
read(): InternalHasteMap;
|
||||
readModuleMap(): HasteModuleMap;
|
||||
/**
|
||||
* 2. crawl the file system.
|
||||
*/
|
||||
private _buildFileMap;
|
||||
/**
|
||||
* 3. parse and extract metadata from changed files.
|
||||
*/
|
||||
private _processFile;
|
||||
private _buildHasteMap;
|
||||
private _cleanup;
|
||||
/**
|
||||
* 4. serialize the new `HasteMap` in a cache file.
|
||||
*/
|
||||
private _persist;
|
||||
/**
|
||||
* Creates workers or parses files and extracts metadata in-process.
|
||||
*/
|
||||
private _getWorker;
|
||||
private _crawl;
|
||||
/**
|
||||
* Watch mode
|
||||
*/
|
||||
private _watch;
|
||||
/**
|
||||
* This function should be called when the file under `filePath` is removed
|
||||
* or changed. When that happens, we want to figure out if that file was
|
||||
* part of a group of files that had the same ID. If it was, we want to
|
||||
* remove it from the group. Furthermore, if there is only one file
|
||||
* remaining in the group, then we want to restore that single file as the
|
||||
* correct resolution for its ID, and cleanup the duplicates index.
|
||||
*/
|
||||
private _recoverDuplicates;
|
||||
end(): Promise<void>;
|
||||
/**
|
||||
* Helpers
|
||||
*/
|
||||
private _ignore;
|
||||
private _createEmptyMap;
|
||||
static H: HType;
|
||||
static DuplicateError: typeof DuplicateError;
|
||||
static ModuleMap: typeof HasteModuleMap;
|
||||
}
|
||||
declare class DuplicateError extends Error {
|
||||
mockPath1: string;
|
||||
mockPath2: string;
|
||||
constructor(mockPath1: string, mockPath2: string);
|
||||
}
|
||||
export = HasteMap;
|
||||
1246
node_modules/jest-haste-map/build/index.js
generated
vendored
Normal file
1246
node_modules/jest-haste-map/build/index.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load diff
44
node_modules/jest-haste-map/build/lib/FSEventsWatcher.d.ts
generated
vendored
Normal file
44
node_modules/jest-haste-map/build/lib/FSEventsWatcher.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,44 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*
|
||||
*/
|
||||
/// <reference types="node" />
|
||||
import { EventEmitter } from 'events';
|
||||
import { Matcher } from 'anymatch';
|
||||
/**
|
||||
* Export `FSEventsWatcher` class.
|
||||
* Watches `dir`.
|
||||
*/
|
||||
declare class FSEventsWatcher extends EventEmitter {
|
||||
readonly root: string;
|
||||
readonly ignored?: Matcher;
|
||||
readonly glob: Array<string>;
|
||||
readonly dot: boolean;
|
||||
readonly hasIgnore: boolean;
|
||||
readonly doIgnore: (path: string) => boolean;
|
||||
readonly fsEventsWatchStopper: () => Promise<void>;
|
||||
private _tracked;
|
||||
static isSupported(): boolean;
|
||||
private static normalizeProxy;
|
||||
private static recReaddir;
|
||||
constructor(dir: string, opts: {
|
||||
root: string;
|
||||
ignored?: Matcher;
|
||||
glob: string | Array<string>;
|
||||
dot: boolean;
|
||||
});
|
||||
/**
|
||||
* End watching.
|
||||
*/
|
||||
close(callback?: () => void): void;
|
||||
private isFileIncluded;
|
||||
private handleEvent;
|
||||
/**
|
||||
* Emit events.
|
||||
*/
|
||||
private _emit;
|
||||
}
|
||||
export = FSEventsWatcher;
|
||||
295
node_modules/jest-haste-map/build/lib/FSEventsWatcher.js
generated
vendored
Normal file
295
node_modules/jest-haste-map/build/lib/FSEventsWatcher.js
generated
vendored
Normal file
|
|
@ -0,0 +1,295 @@
|
|||
'use strict';
|
||||
|
||||
function path() {
|
||||
const data = _interopRequireWildcard(require('path'));
|
||||
|
||||
path = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _events() {
|
||||
const data = require('events');
|
||||
|
||||
_events = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function fs() {
|
||||
const data = _interopRequireWildcard(require('graceful-fs'));
|
||||
|
||||
fs = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _anymatch() {
|
||||
const data = _interopRequireDefault(require('anymatch'));
|
||||
|
||||
_anymatch = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _micromatch() {
|
||||
const data = _interopRequireDefault(require('micromatch'));
|
||||
|
||||
_micromatch = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _walker() {
|
||||
const data = _interopRequireDefault(require('walker'));
|
||||
|
||||
_walker = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
|
||||
function _getRequireWildcardCache() {
|
||||
if (typeof WeakMap !== 'function') return null;
|
||||
var cache = new WeakMap();
|
||||
_getRequireWildcardCache = function () {
|
||||
return cache;
|
||||
};
|
||||
return cache;
|
||||
}
|
||||
|
||||
function _interopRequireWildcard(obj) {
|
||||
if (obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
||||
return {default: obj};
|
||||
}
|
||||
var cache = _getRequireWildcardCache();
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {};
|
||||
var hasPropertyDescriptor =
|
||||
Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor
|
||||
? Object.getOwnPropertyDescriptor(obj, key)
|
||||
: null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
function _defineProperty(obj, key, value) {
|
||||
if (key in obj) {
|
||||
Object.defineProperty(obj, key, {
|
||||
value: value,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
writable: true
|
||||
});
|
||||
} else {
|
||||
obj[key] = value;
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
|
||||
// @ts-ignore: this is for CI which runs linux and might not have this
|
||||
let fsevents = null;
|
||||
|
||||
try {
|
||||
fsevents = require('fsevents');
|
||||
} catch {
|
||||
// Optional dependency, only supported on Darwin.
|
||||
}
|
||||
|
||||
const CHANGE_EVENT = 'change';
|
||||
const DELETE_EVENT = 'delete';
|
||||
const ADD_EVENT = 'add';
|
||||
const ALL_EVENT = 'all';
|
||||
|
||||
/**
|
||||
* Export `FSEventsWatcher` class.
|
||||
* Watches `dir`.
|
||||
*/
|
||||
class FSEventsWatcher extends _events().EventEmitter {
|
||||
static isSupported() {
|
||||
return fsevents !== null;
|
||||
}
|
||||
|
||||
static normalizeProxy(callback) {
|
||||
return (filepath, stats) => callback(path().normalize(filepath), stats);
|
||||
}
|
||||
|
||||
static recReaddir(
|
||||
dir,
|
||||
dirCallback,
|
||||
fileCallback,
|
||||
endCallback,
|
||||
errorCallback,
|
||||
ignored
|
||||
) {
|
||||
(0, _walker().default)(dir)
|
||||
.filterDir(
|
||||
currentDir => !ignored || !(0, _anymatch().default)(ignored, currentDir)
|
||||
)
|
||||
.on('dir', FSEventsWatcher.normalizeProxy(dirCallback))
|
||||
.on('file', FSEventsWatcher.normalizeProxy(fileCallback))
|
||||
.on('error', errorCallback)
|
||||
.on('end', () => {
|
||||
endCallback();
|
||||
});
|
||||
}
|
||||
|
||||
constructor(dir, opts) {
|
||||
if (!fsevents) {
|
||||
throw new Error(
|
||||
'`fsevents` unavailable (this watcher can only be used on Darwin)'
|
||||
);
|
||||
}
|
||||
|
||||
super();
|
||||
|
||||
_defineProperty(this, 'root', void 0);
|
||||
|
||||
_defineProperty(this, 'ignored', void 0);
|
||||
|
||||
_defineProperty(this, 'glob', void 0);
|
||||
|
||||
_defineProperty(this, 'dot', void 0);
|
||||
|
||||
_defineProperty(this, 'hasIgnore', void 0);
|
||||
|
||||
_defineProperty(this, 'doIgnore', void 0);
|
||||
|
||||
_defineProperty(this, 'fsEventsWatchStopper', void 0);
|
||||
|
||||
_defineProperty(this, '_tracked', void 0);
|
||||
|
||||
this.dot = opts.dot || false;
|
||||
this.ignored = opts.ignored;
|
||||
this.glob = Array.isArray(opts.glob) ? opts.glob : [opts.glob];
|
||||
this.hasIgnore =
|
||||
Boolean(opts.ignored) && !(Array.isArray(opts) && opts.length > 0);
|
||||
this.doIgnore = opts.ignored
|
||||
? (0, _anymatch().default)(opts.ignored)
|
||||
: () => false;
|
||||
this.root = path().resolve(dir);
|
||||
this.fsEventsWatchStopper = fsevents.watch(
|
||||
this.root,
|
||||
this.handleEvent.bind(this)
|
||||
);
|
||||
this._tracked = new Set();
|
||||
FSEventsWatcher.recReaddir(
|
||||
this.root,
|
||||
filepath => {
|
||||
this._tracked.add(filepath);
|
||||
},
|
||||
filepath => {
|
||||
this._tracked.add(filepath);
|
||||
},
|
||||
this.emit.bind(this, 'ready'),
|
||||
this.emit.bind(this, 'error'),
|
||||
this.ignored
|
||||
);
|
||||
}
|
||||
/**
|
||||
* End watching.
|
||||
*/
|
||||
|
||||
close(callback) {
|
||||
this.fsEventsWatchStopper().then(() => {
|
||||
this.removeAllListeners();
|
||||
|
||||
if (typeof callback === 'function') {
|
||||
process.nextTick(callback.bind(null, null, true));
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
isFileIncluded(relativePath) {
|
||||
if (this.doIgnore(relativePath)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return this.glob.length
|
||||
? (0, _micromatch().default)([relativePath], this.glob, {
|
||||
dot: this.dot
|
||||
}).length > 0
|
||||
: this.dot ||
|
||||
(0, _micromatch().default)([relativePath], '**/*').length > 0;
|
||||
}
|
||||
|
||||
handleEvent(filepath) {
|
||||
const relativePath = path().relative(this.root, filepath);
|
||||
|
||||
if (!this.isFileIncluded(relativePath)) {
|
||||
return;
|
||||
}
|
||||
|
||||
fs().lstat(filepath, (error, stat) => {
|
||||
if (error && error.code !== 'ENOENT') {
|
||||
this.emit('error', error);
|
||||
return;
|
||||
}
|
||||
|
||||
if (error) {
|
||||
// Ignore files that aren't tracked and don't exist.
|
||||
if (!this._tracked.has(filepath)) {
|
||||
return;
|
||||
}
|
||||
|
||||
this._emit(DELETE_EVENT, relativePath);
|
||||
|
||||
this._tracked.delete(filepath);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (this._tracked.has(filepath)) {
|
||||
this._emit(CHANGE_EVENT, relativePath, stat);
|
||||
} else {
|
||||
this._tracked.add(filepath);
|
||||
|
||||
this._emit(ADD_EVENT, relativePath, stat);
|
||||
}
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Emit events.
|
||||
*/
|
||||
|
||||
_emit(type, file, stat) {
|
||||
this.emit(type, file, this.root, stat);
|
||||
this.emit(ALL_EVENT, type, file, this.root, stat);
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = FSEventsWatcher;
|
||||
442
node_modules/jest-haste-map/build/lib/WatchmanWatcher.js
generated
vendored
Normal file
442
node_modules/jest-haste-map/build/lib/WatchmanWatcher.js
generated
vendored
Normal file
|
|
@ -0,0 +1,442 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = WatchmanWatcher;
|
||||
|
||||
function _path() {
|
||||
const data = _interopRequireDefault(require('path'));
|
||||
|
||||
_path = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _assert() {
|
||||
const data = _interopRequireDefault(require('assert'));
|
||||
|
||||
_assert = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _events() {
|
||||
const data = require('events');
|
||||
|
||||
_events = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function fs() {
|
||||
const data = _interopRequireWildcard(require('graceful-fs'));
|
||||
|
||||
fs = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _fbWatchman() {
|
||||
const data = _interopRequireDefault(require('fb-watchman'));
|
||||
|
||||
_fbWatchman = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _common() {
|
||||
const data = _interopRequireDefault(require('sane/src/common'));
|
||||
|
||||
_common = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _recrawlWarningDedupe() {
|
||||
const data = _interopRequireDefault(
|
||||
require('sane/src/utils/recrawl-warning-dedupe')
|
||||
);
|
||||
|
||||
_recrawlWarningDedupe = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _getRequireWildcardCache() {
|
||||
if (typeof WeakMap !== 'function') return null;
|
||||
var cache = new WeakMap();
|
||||
_getRequireWildcardCache = function () {
|
||||
return cache;
|
||||
};
|
||||
return cache;
|
||||
}
|
||||
|
||||
function _interopRequireWildcard(obj) {
|
||||
if (obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
||||
return {default: obj};
|
||||
}
|
||||
var cache = _getRequireWildcardCache();
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {};
|
||||
var hasPropertyDescriptor =
|
||||
Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor
|
||||
? Object.getOwnPropertyDescriptor(obj, key)
|
||||
: null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
const CHANGE_EVENT = _common().default.CHANGE_EVENT;
|
||||
|
||||
const DELETE_EVENT = _common().default.DELETE_EVENT;
|
||||
|
||||
const ADD_EVENT = _common().default.ADD_EVENT;
|
||||
|
||||
const ALL_EVENT = _common().default.ALL_EVENT;
|
||||
|
||||
const SUB_NAME = 'sane-sub';
|
||||
/**
|
||||
* Watches `dir`.
|
||||
*
|
||||
* @class PollWatcher
|
||||
* @param String dir
|
||||
* @param {Object} opts
|
||||
* @public
|
||||
*/
|
||||
|
||||
function WatchmanWatcher(dir, opts) {
|
||||
_common().default.assignOptions(this, opts);
|
||||
|
||||
this.root = _path().default.resolve(dir);
|
||||
this.init();
|
||||
} // eslint-disable-next-line no-proto
|
||||
|
||||
WatchmanWatcher.prototype.__proto__ = _events().EventEmitter.prototype;
|
||||
/**
|
||||
* Run the watchman `watch` command on the root and subscribe to changes.
|
||||
*
|
||||
* @private
|
||||
*/
|
||||
|
||||
WatchmanWatcher.prototype.init = function () {
|
||||
if (this.client) {
|
||||
this.client.removeAllListeners();
|
||||
}
|
||||
|
||||
const self = this;
|
||||
this.client = new (_fbWatchman().default.Client)();
|
||||
this.client.on('error', error => {
|
||||
self.emit('error', error);
|
||||
});
|
||||
this.client.on('subscription', this.handleChangeEvent.bind(this));
|
||||
this.client.on('end', () => {
|
||||
console.warn('[sane] Warning: Lost connection to watchman, reconnecting..');
|
||||
self.init();
|
||||
});
|
||||
this.watchProjectInfo = null;
|
||||
|
||||
function getWatchRoot() {
|
||||
return self.watchProjectInfo ? self.watchProjectInfo.root : self.root;
|
||||
}
|
||||
|
||||
function onCapability(error, resp) {
|
||||
if (handleError(self, error)) {
|
||||
// The Watchman watcher is unusable on this system, we cannot continue
|
||||
return;
|
||||
}
|
||||
|
||||
handleWarning(resp);
|
||||
self.capabilities = resp.capabilities;
|
||||
|
||||
if (self.capabilities.relative_root) {
|
||||
self.client.command(['watch-project', getWatchRoot()], onWatchProject);
|
||||
} else {
|
||||
self.client.command(['watch', getWatchRoot()], onWatch);
|
||||
}
|
||||
}
|
||||
|
||||
function onWatchProject(error, resp) {
|
||||
if (handleError(self, error)) {
|
||||
return;
|
||||
}
|
||||
|
||||
handleWarning(resp);
|
||||
self.watchProjectInfo = {
|
||||
relativePath: resp.relative_path ? resp.relative_path : '',
|
||||
root: resp.watch
|
||||
};
|
||||
self.client.command(['clock', getWatchRoot()], onClock);
|
||||
}
|
||||
|
||||
function onWatch(error, resp) {
|
||||
if (handleError(self, error)) {
|
||||
return;
|
||||
}
|
||||
|
||||
handleWarning(resp);
|
||||
self.client.command(['clock', getWatchRoot()], onClock);
|
||||
}
|
||||
|
||||
function onClock(error, resp) {
|
||||
if (handleError(self, error)) {
|
||||
return;
|
||||
}
|
||||
|
||||
handleWarning(resp);
|
||||
const options = {
|
||||
fields: ['name', 'exists', 'new'],
|
||||
since: resp.clock
|
||||
}; // If the server has the wildmatch capability available it supports
|
||||
// the recursive **/*.foo style match and we can offload our globs
|
||||
// to the watchman server. This saves both on data size to be
|
||||
// communicated back to us and compute for evaluating the globs
|
||||
// in our node process.
|
||||
|
||||
if (self.capabilities.wildmatch) {
|
||||
if (self.globs.length === 0) {
|
||||
if (!self.dot) {
|
||||
// Make sure we honor the dot option if even we're not using globs.
|
||||
options.expression = [
|
||||
'match',
|
||||
'**',
|
||||
'wholename',
|
||||
{
|
||||
includedotfiles: false
|
||||
}
|
||||
];
|
||||
}
|
||||
} else {
|
||||
options.expression = ['anyof'];
|
||||
|
||||
for (const i in self.globs) {
|
||||
options.expression.push([
|
||||
'match',
|
||||
self.globs[i],
|
||||
'wholename',
|
||||
{
|
||||
includedotfiles: self.dot
|
||||
}
|
||||
]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (self.capabilities.relative_root) {
|
||||
options.relative_root = self.watchProjectInfo.relativePath;
|
||||
}
|
||||
|
||||
self.client.command(
|
||||
['subscribe', getWatchRoot(), SUB_NAME, options],
|
||||
onSubscribe
|
||||
);
|
||||
}
|
||||
|
||||
function onSubscribe(error, resp) {
|
||||
if (handleError(self, error)) {
|
||||
return;
|
||||
}
|
||||
|
||||
handleWarning(resp);
|
||||
self.emit('ready');
|
||||
}
|
||||
|
||||
self.client.capabilityCheck(
|
||||
{
|
||||
optional: ['wildmatch', 'relative_root']
|
||||
},
|
||||
onCapability
|
||||
);
|
||||
};
|
||||
/**
|
||||
* Handles a change event coming from the subscription.
|
||||
*
|
||||
* @param {Object} resp
|
||||
* @private
|
||||
*/
|
||||
|
||||
WatchmanWatcher.prototype.handleChangeEvent = function (resp) {
|
||||
_assert().default.equal(
|
||||
resp.subscription,
|
||||
SUB_NAME,
|
||||
'Invalid subscription event.'
|
||||
);
|
||||
|
||||
if (resp.is_fresh_instance) {
|
||||
this.emit('fresh_instance');
|
||||
}
|
||||
|
||||
if (resp.is_fresh_instance) {
|
||||
this.emit('fresh_instance');
|
||||
}
|
||||
|
||||
if (Array.isArray(resp.files)) {
|
||||
resp.files.forEach(this.handleFileChange, this);
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Handles a single change event record.
|
||||
*
|
||||
* @param {Object} changeDescriptor
|
||||
* @private
|
||||
*/
|
||||
|
||||
WatchmanWatcher.prototype.handleFileChange = function (changeDescriptor) {
|
||||
const self = this;
|
||||
let absPath;
|
||||
let relativePath;
|
||||
|
||||
if (this.capabilities.relative_root) {
|
||||
relativePath = changeDescriptor.name;
|
||||
absPath = _path().default.join(
|
||||
this.watchProjectInfo.root,
|
||||
this.watchProjectInfo.relativePath,
|
||||
relativePath
|
||||
);
|
||||
} else {
|
||||
absPath = _path().default.join(this.root, changeDescriptor.name);
|
||||
relativePath = changeDescriptor.name;
|
||||
}
|
||||
|
||||
if (
|
||||
!(self.capabilities.wildmatch && !this.hasIgnore) &&
|
||||
!_common().default.isFileIncluded(
|
||||
this.globs,
|
||||
this.dot,
|
||||
this.doIgnore,
|
||||
relativePath
|
||||
)
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (!changeDescriptor.exists) {
|
||||
self.emitEvent(DELETE_EVENT, relativePath, self.root);
|
||||
} else {
|
||||
fs().lstat(absPath, (error, stat) => {
|
||||
// Files can be deleted between the event and the lstat call
|
||||
// the most reliable thing to do here is to ignore the event.
|
||||
if (error && error.code === 'ENOENT') {
|
||||
return;
|
||||
}
|
||||
|
||||
if (handleError(self, error)) {
|
||||
return;
|
||||
}
|
||||
|
||||
const eventType = changeDescriptor.new ? ADD_EVENT : CHANGE_EVENT; // Change event on dirs are mostly useless.
|
||||
|
||||
if (!(eventType === CHANGE_EVENT && stat.isDirectory())) {
|
||||
self.emitEvent(eventType, relativePath, self.root, stat);
|
||||
}
|
||||
});
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Dispatches the event.
|
||||
*
|
||||
* @param {string} eventType
|
||||
* @param {string} filepath
|
||||
* @param {string} root
|
||||
* @param {fs.Stat} stat
|
||||
* @private
|
||||
*/
|
||||
|
||||
WatchmanWatcher.prototype.emitEvent = function (
|
||||
eventType,
|
||||
filepath,
|
||||
root,
|
||||
stat
|
||||
) {
|
||||
this.emit(eventType, filepath, root, stat);
|
||||
this.emit(ALL_EVENT, eventType, filepath, root, stat);
|
||||
};
|
||||
/**
|
||||
* Closes the watcher.
|
||||
*
|
||||
* @param {function} callback
|
||||
* @private
|
||||
*/
|
||||
|
||||
WatchmanWatcher.prototype.close = function (callback) {
|
||||
this.client.removeAllListeners();
|
||||
this.client.end();
|
||||
callback && callback(null, true);
|
||||
};
|
||||
/**
|
||||
* Handles an error and returns true if exists.
|
||||
*
|
||||
* @param {WatchmanWatcher} self
|
||||
* @param {Error} error
|
||||
* @private
|
||||
*/
|
||||
|
||||
function handleError(self, error) {
|
||||
if (error != null) {
|
||||
self.emit('error', error);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Handles a warning in the watchman resp object.
|
||||
*
|
||||
* @param {object} resp
|
||||
* @private
|
||||
*/
|
||||
|
||||
function handleWarning(resp) {
|
||||
if ('warning' in resp) {
|
||||
if (_recrawlWarningDedupe().default.isRecrawlWarningDupe(resp.warning)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
console.warn(resp.warning);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
7
node_modules/jest-haste-map/build/lib/dependencyExtractor.d.ts
generated
vendored
Normal file
7
node_modules/jest-haste-map/build/lib/dependencyExtractor.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* 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 extract(code: string): Set<string>;
|
||||
99
node_modules/jest-haste-map/build/lib/dependencyExtractor.js
generated
vendored
Normal file
99
node_modules/jest-haste-map/build/lib/dependencyExtractor.js
generated
vendored
Normal file
|
|
@ -0,0 +1,99 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.extract = extract;
|
||||
|
||||
var _isRegExpSupported = _interopRequireDefault(require('./isRegExpSupported'));
|
||||
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
// Negative look behind is only supported in Node 9+
|
||||
const NOT_A_DOT = (0, _isRegExpSupported.default)('(?<!\\.\\s*)')
|
||||
? '(?<!\\.\\s*)'
|
||||
: '(?:^|[^.]\\s*)';
|
||||
|
||||
const CAPTURE_STRING_LITERAL = pos => `([\`'"])([^'"\`]*?)(?:\\${pos})`;
|
||||
|
||||
const WORD_SEPARATOR = '\\b';
|
||||
const LEFT_PARENTHESIS = '\\(';
|
||||
const RIGHT_PARENTHESIS = '\\)';
|
||||
const WHITESPACE = '\\s*';
|
||||
const OPTIONAL_COMMA = '(:?,\\s*)?';
|
||||
|
||||
function createRegExp(parts, flags) {
|
||||
return new RegExp(parts.join(''), flags);
|
||||
}
|
||||
|
||||
function alternatives(...parts) {
|
||||
return `(?:${parts.join('|')})`;
|
||||
}
|
||||
|
||||
function functionCallStart(...names) {
|
||||
return [
|
||||
NOT_A_DOT,
|
||||
WORD_SEPARATOR,
|
||||
alternatives(...names),
|
||||
WHITESPACE,
|
||||
LEFT_PARENTHESIS,
|
||||
WHITESPACE
|
||||
];
|
||||
}
|
||||
|
||||
const BLOCK_COMMENT_RE = /\/\*[^]*?\*\//g;
|
||||
const LINE_COMMENT_RE = /\/\/.*/g;
|
||||
const REQUIRE_OR_DYNAMIC_IMPORT_RE = createRegExp(
|
||||
[
|
||||
...functionCallStart('require', 'import'),
|
||||
CAPTURE_STRING_LITERAL(1),
|
||||
WHITESPACE,
|
||||
OPTIONAL_COMMA,
|
||||
RIGHT_PARENTHESIS
|
||||
],
|
||||
'g'
|
||||
);
|
||||
const IMPORT_OR_EXPORT_RE = createRegExp(
|
||||
[
|
||||
'\\b(?:import|export)\\s+(?!type(?:of)?\\s+)(?:[^\'"]+\\s+from\\s+)?',
|
||||
CAPTURE_STRING_LITERAL(1)
|
||||
],
|
||||
'g'
|
||||
);
|
||||
const JEST_EXTENSIONS_RE = createRegExp(
|
||||
[
|
||||
...functionCallStart(
|
||||
'jest\\s*\\.\\s*(?:requireActual|requireMock|genMockFromModule|createMockFromModule)'
|
||||
),
|
||||
CAPTURE_STRING_LITERAL(1),
|
||||
WHITESPACE,
|
||||
OPTIONAL_COMMA,
|
||||
RIGHT_PARENTHESIS
|
||||
],
|
||||
'g'
|
||||
);
|
||||
|
||||
function extract(code) {
|
||||
const dependencies = new Set();
|
||||
|
||||
const addDependency = (match, _, dep) => {
|
||||
dependencies.add(dep);
|
||||
return match;
|
||||
};
|
||||
|
||||
code
|
||||
.replace(BLOCK_COMMENT_RE, '')
|
||||
.replace(LINE_COMMENT_RE, '')
|
||||
.replace(IMPORT_OR_EXPORT_RE, addDependency)
|
||||
.replace(REQUIRE_OR_DYNAMIC_IMPORT_RE, addDependency)
|
||||
.replace(JEST_EXTENSIONS_RE, addDependency);
|
||||
return dependencies;
|
||||
}
|
||||
8
node_modules/jest-haste-map/build/lib/fast_path.d.ts
generated
vendored
Normal file
8
node_modules/jest-haste-map/build/lib/fast_path.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* 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 relative(rootDir: string, filename: string): string;
|
||||
export declare function resolve(rootDir: string, relativeFilename: string): string;
|
||||
81
node_modules/jest-haste-map/build/lib/fast_path.js
generated
vendored
Normal file
81
node_modules/jest-haste-map/build/lib/fast_path.js
generated
vendored
Normal file
|
|
@ -0,0 +1,81 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.relative = relative;
|
||||
exports.resolve = resolve;
|
||||
|
||||
function path() {
|
||||
const data = _interopRequireWildcard(require('path'));
|
||||
|
||||
path = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _getRequireWildcardCache() {
|
||||
if (typeof WeakMap !== 'function') return null;
|
||||
var cache = new WeakMap();
|
||||
_getRequireWildcardCache = function () {
|
||||
return cache;
|
||||
};
|
||||
return cache;
|
||||
}
|
||||
|
||||
function _interopRequireWildcard(obj) {
|
||||
if (obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
||||
return {default: obj};
|
||||
}
|
||||
var cache = _getRequireWildcardCache();
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {};
|
||||
var hasPropertyDescriptor =
|
||||
Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor
|
||||
? Object.getOwnPropertyDescriptor(obj, key)
|
||||
: null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
// rootDir and filename must be absolute paths (resolved)
|
||||
function relative(rootDir, filename) {
|
||||
return filename.indexOf(rootDir + path().sep) === 0
|
||||
? filename.substr(rootDir.length + 1)
|
||||
: path().relative(rootDir, filename);
|
||||
}
|
||||
|
||||
const INDIRECTION_FRAGMENT = '..' + path().sep; // rootDir must be an absolute path and relativeFilename must be simple
|
||||
// (e.g.: foo/bar or ../foo/bar, but never ./foo or foo/../bar)
|
||||
|
||||
function resolve(rootDir, relativeFilename) {
|
||||
return relativeFilename.indexOf(INDIRECTION_FRAGMENT) === 0
|
||||
? path().resolve(rootDir, relativeFilename)
|
||||
: rootDir + path().sep + relativeFilename;
|
||||
}
|
||||
7
node_modules/jest-haste-map/build/lib/getPlatformExtension.d.ts
generated
vendored
Normal file
7
node_modules/jest-haste-map/build/lib/getPlatformExtension.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* 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?: Array<string>): string | null;
|
||||
31
node_modules/jest-haste-map/build/lib/getPlatformExtension.js
generated
vendored
Normal file
31
node_modules/jest-haste-map/build/lib/getPlatformExtension.js
generated
vendored
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = getPlatformExtension;
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
const SUPPORTED_PLATFORM_EXTS = new Set(['android', 'ios', 'native', 'web']); // 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); // If an overriding platform array is passed, check that first
|
||||
|
||||
if (platforms && platforms.indexOf(platform) !== -1) {
|
||||
return platform;
|
||||
}
|
||||
|
||||
return SUPPORTED_PLATFORM_EXTS.has(platform) ? platform : null;
|
||||
}
|
||||
7
node_modules/jest-haste-map/build/lib/isRegExpSupported.d.ts
generated
vendored
Normal file
7
node_modules/jest-haste-map/build/lib/isRegExpSupported.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* 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 isRegExpSupported(value: string): boolean;
|
||||
22
node_modules/jest-haste-map/build/lib/isRegExpSupported.js
generated
vendored
Normal file
22
node_modules/jest-haste-map/build/lib/isRegExpSupported.js
generated
vendored
Normal file
|
|
@ -0,0 +1,22 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = isRegExpSupported;
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
function isRegExpSupported(value) {
|
||||
try {
|
||||
// eslint-disable-next-line no-new
|
||||
new RegExp(value);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
8
node_modules/jest-haste-map/build/lib/normalizePathSep.d.ts
generated
vendored
Normal file
8
node_modules/jest-haste-map/build/lib/normalizePathSep.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
declare let normalizePathSep: (string: string) => string;
|
||||
export default normalizePathSep;
|
||||
75
node_modules/jest-haste-map/build/lib/normalizePathSep.js
generated
vendored
Normal file
75
node_modules/jest-haste-map/build/lib/normalizePathSep.js
generated
vendored
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
function path() {
|
||||
const data = _interopRequireWildcard(require('path'));
|
||||
|
||||
path = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function _getRequireWildcardCache() {
|
||||
if (typeof WeakMap !== 'function') return null;
|
||||
var cache = new WeakMap();
|
||||
_getRequireWildcardCache = function () {
|
||||
return cache;
|
||||
};
|
||||
return cache;
|
||||
}
|
||||
|
||||
function _interopRequireWildcard(obj) {
|
||||
if (obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
||||
return {default: obj};
|
||||
}
|
||||
var cache = _getRequireWildcardCache();
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {};
|
||||
var hasPropertyDescriptor =
|
||||
Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor
|
||||
? Object.getOwnPropertyDescriptor(obj, key)
|
||||
: null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
let normalizePathSep;
|
||||
|
||||
if (path().sep === '/') {
|
||||
normalizePathSep = filePath => filePath;
|
||||
} else {
|
||||
normalizePathSep = filePath => filePath.replace(/\//g, path().sep);
|
||||
}
|
||||
|
||||
var _default = normalizePathSep;
|
||||
exports.default = _default;
|
||||
95
node_modules/jest-haste-map/build/types.d.ts
generated
vendored
Normal file
95
node_modules/jest-haste-map/build/types.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,95 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
/// <reference types="node" />
|
||||
import type { Stats } from 'graceful-fs';
|
||||
import type { Config } from '@jest/types';
|
||||
import type ModuleMap from './ModuleMap';
|
||||
import type HasteFS from './HasteFS';
|
||||
export declare type IgnoreMatcher = (item: string) => boolean;
|
||||
export declare type WorkerMessage = {
|
||||
computeDependencies: boolean;
|
||||
computeSha1: boolean;
|
||||
dependencyExtractor?: string | null;
|
||||
rootDir: string;
|
||||
filePath: string;
|
||||
hasteImplModulePath?: string;
|
||||
};
|
||||
export declare type WorkerMetadata = {
|
||||
dependencies: Array<string> | undefined | null;
|
||||
id: string | undefined | null;
|
||||
module: ModuleMetaData | undefined | null;
|
||||
sha1: string | undefined | null;
|
||||
};
|
||||
export declare type CrawlerOptions = {
|
||||
computeSha1: boolean;
|
||||
data: InternalHasteMap;
|
||||
extensions: Array<string>;
|
||||
forceNodeFilesystemAPI: boolean;
|
||||
ignore: IgnoreMatcher;
|
||||
rootDir: string;
|
||||
roots: Array<string>;
|
||||
};
|
||||
export declare type HasteImpl = {
|
||||
getHasteName(filePath: Config.Path): string | undefined;
|
||||
};
|
||||
export declare type FileData = Map<Config.Path, FileMetaData>;
|
||||
export declare type FileMetaData = [string, number, number, 0 | 1, string, string | null | undefined];
|
||||
export declare type MockData = Map<string, Config.Path>;
|
||||
export declare type ModuleMapData = Map<string, ModuleMapItem>;
|
||||
export declare type WatchmanClocks = Map<Config.Path, string>;
|
||||
export declare type HasteRegExp = RegExp | ((str: string) => boolean);
|
||||
export declare type DuplicatesSet = Map<string, /* type */ number>;
|
||||
export declare type DuplicatesIndex = Map<string, Map<string, DuplicatesSet>>;
|
||||
export declare type InternalHasteMap = {
|
||||
clocks: WatchmanClocks;
|
||||
duplicates: DuplicatesIndex;
|
||||
files: FileData;
|
||||
map: ModuleMapData;
|
||||
mocks: MockData;
|
||||
};
|
||||
export declare type HasteMap = {
|
||||
hasteFS: HasteFS;
|
||||
moduleMap: ModuleMap;
|
||||
__hasteMapForTest?: InternalHasteMap | null;
|
||||
};
|
||||
export declare type RawModuleMap = {
|
||||
rootDir: Config.Path;
|
||||
duplicates: DuplicatesIndex;
|
||||
map: ModuleMapData;
|
||||
mocks: MockData;
|
||||
};
|
||||
declare type ModuleMapItem = {
|
||||
[platform: string]: ModuleMetaData;
|
||||
};
|
||||
export declare type ModuleMetaData = [Config.Path, /* type */ number];
|
||||
export declare type HType = {
|
||||
ID: 0;
|
||||
MTIME: 1;
|
||||
SIZE: 2;
|
||||
VISITED: 3;
|
||||
DEPENDENCIES: 4;
|
||||
SHA1: 5;
|
||||
PATH: 0;
|
||||
TYPE: 1;
|
||||
MODULE: 0;
|
||||
PACKAGE: 1;
|
||||
GENERIC_PLATFORM: 'g';
|
||||
NATIVE_PLATFORM: 'native';
|
||||
DEPENDENCY_DELIM: '\0';
|
||||
};
|
||||
export declare type HTypeValue = HType[keyof HType];
|
||||
export declare type EventsQueue = Array<{
|
||||
filePath: Config.Path;
|
||||
stat: Stats | undefined;
|
||||
type: string;
|
||||
}>;
|
||||
export declare type ChangeEvent = {
|
||||
eventsQueue: EventsQueue;
|
||||
hasteFS: HasteFS;
|
||||
moduleMap: ModuleMap;
|
||||
};
|
||||
export {};
|
||||
1
node_modules/jest-haste-map/build/types.js
generated
vendored
Normal file
1
node_modules/jest-haste-map/build/types.js
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
'use strict';
|
||||
9
node_modules/jest-haste-map/build/worker.d.ts
generated
vendored
Normal file
9
node_modules/jest-haste-map/build/worker.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
import type { WorkerMessage, WorkerMetadata } from './types';
|
||||
export declare function worker(data: WorkerMessage): Promise<WorkerMetadata>;
|
||||
export declare function getSha1(data: WorkerMessage): Promise<WorkerMetadata>;
|
||||
197
node_modules/jest-haste-map/build/worker.js
generated
vendored
Normal file
197
node_modules/jest-haste-map/build/worker.js
generated
vendored
Normal file
|
|
@ -0,0 +1,197 @@
|
|||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.worker = worker;
|
||||
exports.getSha1 = getSha1;
|
||||
|
||||
function _crypto() {
|
||||
const data = require('crypto');
|
||||
|
||||
_crypto = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function path() {
|
||||
const data = _interopRequireWildcard(require('path'));
|
||||
|
||||
path = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
function fs() {
|
||||
const data = _interopRequireWildcard(require('graceful-fs'));
|
||||
|
||||
fs = function () {
|
||||
return data;
|
||||
};
|
||||
|
||||
return data;
|
||||
}
|
||||
|
||||
var _blacklist = _interopRequireDefault(require('./blacklist'));
|
||||
|
||||
var _constants = _interopRequireDefault(require('./constants'));
|
||||
|
||||
var dependencyExtractor = _interopRequireWildcard(
|
||||
require('./lib/dependencyExtractor')
|
||||
);
|
||||
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
|
||||
function _getRequireWildcardCache() {
|
||||
if (typeof WeakMap !== 'function') return null;
|
||||
var cache = new WeakMap();
|
||||
_getRequireWildcardCache = function () {
|
||||
return cache;
|
||||
};
|
||||
return cache;
|
||||
}
|
||||
|
||||
function _interopRequireWildcard(obj) {
|
||||
if (obj && obj.__esModule) {
|
||||
return obj;
|
||||
}
|
||||
if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
|
||||
return {default: obj};
|
||||
}
|
||||
var cache = _getRequireWildcardCache();
|
||||
if (cache && cache.has(obj)) {
|
||||
return cache.get(obj);
|
||||
}
|
||||
var newObj = {};
|
||||
var hasPropertyDescriptor =
|
||||
Object.defineProperty && Object.getOwnPropertyDescriptor;
|
||||
for (var key in obj) {
|
||||
if (Object.prototype.hasOwnProperty.call(obj, key)) {
|
||||
var desc = hasPropertyDescriptor
|
||||
? Object.getOwnPropertyDescriptor(obj, key)
|
||||
: null;
|
||||
if (desc && (desc.get || desc.set)) {
|
||||
Object.defineProperty(newObj, key, desc);
|
||||
} else {
|
||||
newObj[key] = obj[key];
|
||||
}
|
||||
}
|
||||
}
|
||||
newObj.default = obj;
|
||||
if (cache) {
|
||||
cache.set(obj, newObj);
|
||||
}
|
||||
return newObj;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
const PACKAGE_JSON = path().sep + 'package.json';
|
||||
let hasteImpl = null;
|
||||
let hasteImplModulePath = null;
|
||||
|
||||
function sha1hex(content) {
|
||||
return (0, _crypto().createHash)('sha1').update(content).digest('hex');
|
||||
}
|
||||
|
||||
async function worker(data) {
|
||||
if (
|
||||
data.hasteImplModulePath &&
|
||||
data.hasteImplModulePath !== hasteImplModulePath
|
||||
) {
|
||||
if (hasteImpl) {
|
||||
throw new Error('jest-haste-map: hasteImplModulePath changed');
|
||||
}
|
||||
|
||||
hasteImplModulePath = data.hasteImplModulePath;
|
||||
hasteImpl = require(hasteImplModulePath);
|
||||
}
|
||||
|
||||
let content;
|
||||
let dependencies;
|
||||
let id;
|
||||
let module;
|
||||
let sha1;
|
||||
const {computeDependencies, computeSha1, rootDir, filePath} = data;
|
||||
|
||||
const getContent = () => {
|
||||
if (content === undefined) {
|
||||
content = fs().readFileSync(filePath, 'utf8');
|
||||
}
|
||||
|
||||
return content;
|
||||
};
|
||||
|
||||
if (filePath.endsWith(PACKAGE_JSON)) {
|
||||
// Process a package.json that is returned as a PACKAGE type with its name.
|
||||
try {
|
||||
const fileData = JSON.parse(getContent());
|
||||
|
||||
if (fileData.name) {
|
||||
const relativeFilePath = path().relative(rootDir, filePath);
|
||||
id = fileData.name;
|
||||
module = [relativeFilePath, _constants.default.PACKAGE];
|
||||
}
|
||||
} catch (err) {
|
||||
throw new Error(`Cannot parse ${filePath} as JSON: ${err.message}`);
|
||||
}
|
||||
} else if (
|
||||
!_blacklist.default.has(filePath.substr(filePath.lastIndexOf('.')))
|
||||
) {
|
||||
// Process a random file that is returned as a MODULE.
|
||||
if (hasteImpl) {
|
||||
id = hasteImpl.getHasteName(filePath);
|
||||
}
|
||||
|
||||
if (computeDependencies) {
|
||||
const content = getContent();
|
||||
dependencies = Array.from(
|
||||
data.dependencyExtractor
|
||||
? require(data.dependencyExtractor).extract(
|
||||
content,
|
||||
filePath,
|
||||
dependencyExtractor.extract
|
||||
)
|
||||
: dependencyExtractor.extract(content)
|
||||
);
|
||||
}
|
||||
|
||||
if (id) {
|
||||
const relativeFilePath = path().relative(rootDir, filePath);
|
||||
module = [relativeFilePath, _constants.default.MODULE];
|
||||
}
|
||||
} // If a SHA-1 is requested on update, compute it.
|
||||
|
||||
if (computeSha1) {
|
||||
sha1 = sha1hex(getContent() || fs().readFileSync(filePath));
|
||||
}
|
||||
|
||||
return {
|
||||
dependencies,
|
||||
id,
|
||||
module,
|
||||
sha1
|
||||
};
|
||||
}
|
||||
|
||||
async function getSha1(data) {
|
||||
const sha1 = data.computeSha1
|
||||
? sha1hex(fs().readFileSync(data.filePath))
|
||||
: null;
|
||||
return {
|
||||
dependencies: undefined,
|
||||
id: undefined,
|
||||
module: undefined,
|
||||
sha1
|
||||
};
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue