Add node modules and new code for release (#57)
Co-authored-by: taakleton <taakleton@users.noreply.github.com>
This commit is contained in:
committed by
GitHub
parent
da63a48ad7
commit
a517f2ff65
21
node_modules/jest-snapshot/LICENSE
generated
vendored
Normal file
21
node_modules/jest-snapshot/LICENSE
generated
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) Facebook, Inc. and its affiliates.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
13
node_modules/jest-snapshot/build/InlineSnapshots.d.ts
generated
vendored
Normal file
13
node_modules/jest-snapshot/build/InlineSnapshots.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 { Frame } from 'jest-message-util';
|
||||
import type { BabelTraverse, Prettier } from './types';
|
||||
export declare type InlineSnapshot = {
|
||||
snapshot: string;
|
||||
frame: Frame;
|
||||
};
|
||||
export declare function saveInlineSnapshots(snapshots: Array<InlineSnapshot>, prettier: Prettier | null, babelTraverse: BabelTraverse): void;
|
354
node_modules/jest-snapshot/build/InlineSnapshots.js
generated
vendored
Normal file
354
node_modules/jest-snapshot/build/InlineSnapshots.js
generated
vendored
Normal file
@ -0,0 +1,354 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.saveInlineSnapshots = saveInlineSnapshots;
|
||||
|
||||
var path = _interopRequireWildcard(require('path'));
|
||||
|
||||
var _types = require('@babel/types');
|
||||
|
||||
var fs = _interopRequireWildcard(require('graceful-fs'));
|
||||
|
||||
var _semver = _interopRequireDefault(require('semver'));
|
||||
|
||||
var _utils = require('./utils');
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var jestWriteFile =
|
||||
global[Symbol.for('jest-native-write-file')] || fs.writeFileSync;
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var jestReadFile =
|
||||
global[Symbol.for('jest-native-read-file')] || fs.readFileSync;
|
||||
|
||||
function saveInlineSnapshots(snapshots, prettier, babelTraverse) {
|
||||
if (!prettier) {
|
||||
throw new Error(
|
||||
`Jest: Inline Snapshots requires Prettier.\n` +
|
||||
`Please ensure "prettier" is installed in your project.`
|
||||
);
|
||||
} // Custom parser API was added in 1.5.0
|
||||
|
||||
if (_semver.default.lt(prettier.version, '1.5.0')) {
|
||||
throw new Error(
|
||||
`Jest: Inline Snapshots require prettier>=1.5.0.\n` +
|
||||
`Please upgrade "prettier".`
|
||||
);
|
||||
}
|
||||
|
||||
const snapshotsByFile = groupSnapshotsByFile(snapshots);
|
||||
|
||||
for (const sourceFilePath of Object.keys(snapshotsByFile)) {
|
||||
saveSnapshotsForFile(
|
||||
snapshotsByFile[sourceFilePath],
|
||||
sourceFilePath,
|
||||
prettier,
|
||||
babelTraverse
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
const saveSnapshotsForFile = (
|
||||
snapshots,
|
||||
sourceFilePath,
|
||||
prettier,
|
||||
babelTraverse
|
||||
) => {
|
||||
const sourceFile = jestReadFile(sourceFilePath, 'utf8'); // Resolve project configuration.
|
||||
// For older versions of Prettier, do not load configuration.
|
||||
|
||||
const config = prettier.resolveConfig
|
||||
? prettier.resolveConfig.sync(sourceFilePath, {
|
||||
editorconfig: true
|
||||
})
|
||||
: null; // Detect the parser for the test file.
|
||||
// For older versions of Prettier, fallback to a simple parser detection.
|
||||
// @ts-expect-error
|
||||
|
||||
const inferredParser = prettier.getFileInfo
|
||||
? prettier.getFileInfo.sync(sourceFilePath).inferredParser
|
||||
: (config && config.parser) || simpleDetectParser(sourceFilePath); // Record the matcher names seen in insertion parser and pass them down one
|
||||
// by one to formatting parser.
|
||||
|
||||
const snapshotMatcherNames = []; // Insert snapshots using the custom parser API. After insertion, the code is
|
||||
// formatted, except snapshot indentation. Snapshots cannot be formatted until
|
||||
// after the initial format because we don't know where the call expression
|
||||
// will be placed (specifically its indentation).
|
||||
|
||||
const newSourceFile = prettier.format(sourceFile, {
|
||||
...config,
|
||||
filepath: sourceFilePath,
|
||||
parser: createInsertionParser(
|
||||
snapshots,
|
||||
snapshotMatcherNames,
|
||||
inferredParser,
|
||||
babelTraverse
|
||||
)
|
||||
}); // Format the snapshots using the custom parser API.
|
||||
|
||||
const formattedNewSourceFile = prettier.format(newSourceFile, {
|
||||
...config,
|
||||
filepath: sourceFilePath,
|
||||
parser: createFormattingParser(
|
||||
snapshotMatcherNames,
|
||||
inferredParser,
|
||||
babelTraverse
|
||||
)
|
||||
});
|
||||
|
||||
if (formattedNewSourceFile !== sourceFile) {
|
||||
jestWriteFile(sourceFilePath, formattedNewSourceFile);
|
||||
}
|
||||
};
|
||||
|
||||
const groupSnapshotsBy = createKey => snapshots =>
|
||||
snapshots.reduce((object, inlineSnapshot) => {
|
||||
const key = createKey(inlineSnapshot);
|
||||
return {...object, [key]: (object[key] || []).concat(inlineSnapshot)};
|
||||
}, {});
|
||||
|
||||
const groupSnapshotsByFrame = groupSnapshotsBy(({frame: {line, column}}) =>
|
||||
typeof line === 'number' && typeof column === 'number'
|
||||
? `${line}:${column - 1}`
|
||||
: ''
|
||||
);
|
||||
const groupSnapshotsByFile = groupSnapshotsBy(({frame: {file}}) => file);
|
||||
|
||||
const indent = (snapshot, numIndents, indentation) => {
|
||||
const lines = snapshot.split('\n'); // Prevent re-indentation of inline snapshots.
|
||||
|
||||
if (
|
||||
lines.length >= 2 &&
|
||||
lines[1].startsWith(indentation.repeat(numIndents + 1))
|
||||
) {
|
||||
return snapshot;
|
||||
}
|
||||
|
||||
return lines
|
||||
.map((line, index) => {
|
||||
if (index === 0) {
|
||||
// First line is either a 1-line snapshot or a blank line.
|
||||
return line;
|
||||
} else if (index !== lines.length - 1) {
|
||||
// Do not indent empty lines.
|
||||
if (line === '') {
|
||||
return line;
|
||||
} // Not last line, indent one level deeper than expect call.
|
||||
|
||||
return indentation.repeat(numIndents + 1) + line;
|
||||
} else {
|
||||
// The last line should be placed on the same level as the expect call.
|
||||
return indentation.repeat(numIndents) + line;
|
||||
}
|
||||
})
|
||||
.join('\n');
|
||||
};
|
||||
|
||||
const getAst = (parsers, inferredParser, text) => {
|
||||
// Flow uses a 'Program' parent node, babel expects a 'File'.
|
||||
let ast = parsers[inferredParser](text);
|
||||
|
||||
if (ast.type !== 'File') {
|
||||
ast = (0, _types.file)(ast, ast.comments, ast.tokens);
|
||||
delete ast.program.comments;
|
||||
}
|
||||
|
||||
return ast;
|
||||
}; // This parser inserts snapshots into the AST.
|
||||
|
||||
const createInsertionParser = (
|
||||
snapshots,
|
||||
snapshotMatcherNames,
|
||||
inferredParser,
|
||||
babelTraverse
|
||||
) => (text, parsers, options) => {
|
||||
// Workaround for https://github.com/prettier/prettier/issues/3150
|
||||
options.parser = inferredParser;
|
||||
const groupedSnapshots = groupSnapshotsByFrame(snapshots);
|
||||
const remainingSnapshots = new Set(snapshots.map(({snapshot}) => snapshot));
|
||||
const ast = getAst(parsers, inferredParser, text);
|
||||
babelTraverse(ast, {
|
||||
CallExpression({node: {arguments: args, callee}}) {
|
||||
if (
|
||||
callee.type !== 'MemberExpression' ||
|
||||
callee.property.type !== 'Identifier' ||
|
||||
callee.property.loc == null
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
const {line, column} = callee.property.loc.start;
|
||||
const snapshotsForFrame = groupedSnapshots[`${line}:${column}`];
|
||||
|
||||
if (!snapshotsForFrame) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (snapshotsForFrame.length > 1) {
|
||||
throw new Error(
|
||||
'Jest: Multiple inline snapshots for the same call are not supported.'
|
||||
);
|
||||
}
|
||||
|
||||
snapshotMatcherNames.push(callee.property.name);
|
||||
const snapshotIndex = args.findIndex(
|
||||
({type}) => type === 'TemplateLiteral'
|
||||
);
|
||||
const values = snapshotsForFrame.map(({snapshot}) => {
|
||||
remainingSnapshots.delete(snapshot);
|
||||
return (0, _types.templateLiteral)(
|
||||
[
|
||||
(0, _types.templateElement)({
|
||||
raw: (0, _utils.escapeBacktickString)(snapshot)
|
||||
})
|
||||
],
|
||||
[]
|
||||
);
|
||||
});
|
||||
const replacementNode = values[0];
|
||||
|
||||
if (snapshotIndex > -1) {
|
||||
args[snapshotIndex] = replacementNode;
|
||||
} else {
|
||||
args.push(replacementNode);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
if (remainingSnapshots.size) {
|
||||
throw new Error(`Jest: Couldn't locate all inline snapshots.`);
|
||||
}
|
||||
|
||||
return ast;
|
||||
}; // This parser formats snapshots to the correct indentation.
|
||||
|
||||
const createFormattingParser = (
|
||||
snapshotMatcherNames,
|
||||
inferredParser,
|
||||
babelTraverse
|
||||
) => (text, parsers, options) => {
|
||||
// Workaround for https://github.com/prettier/prettier/issues/3150
|
||||
options.parser = inferredParser;
|
||||
const ast = getAst(parsers, inferredParser, text);
|
||||
babelTraverse(ast, {
|
||||
CallExpression({node: {arguments: args, callee}}) {
|
||||
var _options$tabWidth, _options$tabWidth2;
|
||||
|
||||
if (
|
||||
callee.type !== 'MemberExpression' ||
|
||||
callee.property.type !== 'Identifier' ||
|
||||
!snapshotMatcherNames.includes(callee.property.name) ||
|
||||
!callee.loc ||
|
||||
callee.computed
|
||||
) {
|
||||
return;
|
||||
}
|
||||
|
||||
let snapshotIndex;
|
||||
let snapshot;
|
||||
|
||||
for (let i = 0; i < args.length; i++) {
|
||||
const node = args[i];
|
||||
|
||||
if (node.type === 'TemplateLiteral') {
|
||||
snapshotIndex = i;
|
||||
snapshot = node.quasis[0].value.raw;
|
||||
}
|
||||
}
|
||||
|
||||
if (snapshot === undefined || snapshotIndex === undefined) {
|
||||
return;
|
||||
}
|
||||
|
||||
const useSpaces = !options.useTabs;
|
||||
snapshot = indent(
|
||||
snapshot,
|
||||
Math.ceil(
|
||||
useSpaces
|
||||
? callee.loc.start.column /
|
||||
((_options$tabWidth = options.tabWidth) !== null &&
|
||||
_options$tabWidth !== void 0
|
||||
? _options$tabWidth
|
||||
: 1)
|
||||
: callee.loc.start.column / 2 // Each tab is 2 characters.
|
||||
),
|
||||
useSpaces
|
||||
? ' '.repeat(
|
||||
(_options$tabWidth2 = options.tabWidth) !== null &&
|
||||
_options$tabWidth2 !== void 0
|
||||
? _options$tabWidth2
|
||||
: 1
|
||||
)
|
||||
: '\t'
|
||||
);
|
||||
const replacementNode = (0, _types.templateLiteral)(
|
||||
[
|
||||
(0, _types.templateElement)({
|
||||
raw: snapshot
|
||||
})
|
||||
],
|
||||
[]
|
||||
);
|
||||
args[snapshotIndex] = replacementNode;
|
||||
}
|
||||
});
|
||||
return ast;
|
||||
};
|
||||
|
||||
const simpleDetectParser = filePath => {
|
||||
const extname = path.extname(filePath);
|
||||
|
||||
if (/tsx?$/.test(extname)) {
|
||||
return 'typescript';
|
||||
}
|
||||
|
||||
return 'babel';
|
||||
};
|
16
node_modules/jest-snapshot/build/SnapshotResolver.d.ts
generated
vendored
Normal file
16
node_modules/jest-snapshot/build/SnapshotResolver.d.ts
generated
vendored
Normal file
@ -0,0 +1,16 @@
|
||||
/**
|
||||
* 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';
|
||||
export declare type SnapshotResolver = {
|
||||
testPathForConsistencyCheck: string;
|
||||
resolveSnapshotPath(testPath: Config.Path, extension?: string): Config.Path;
|
||||
resolveTestPath(snapshotPath: Config.Path, extension?: string): Config.Path;
|
||||
};
|
||||
export declare const EXTENSION = "snap";
|
||||
export declare const DOT_EXTENSION: string;
|
||||
export declare const isSnapshotPath: (path: string) => boolean;
|
||||
export declare const buildSnapshotResolver: (config: Config.ProjectConfig) => SnapshotResolver;
|
159
node_modules/jest-snapshot/build/SnapshotResolver.js
generated
vendored
Normal file
159
node_modules/jest-snapshot/build/SnapshotResolver.js
generated
vendored
Normal file
@ -0,0 +1,159 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.buildSnapshotResolver = exports.isSnapshotPath = exports.DOT_EXTENSION = exports.EXTENSION = void 0;
|
||||
|
||||
var path = _interopRequireWildcard(require('path'));
|
||||
|
||||
var _chalk = _interopRequireDefault(require('chalk'));
|
||||
|
||||
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 EXTENSION = 'snap';
|
||||
exports.EXTENSION = EXTENSION;
|
||||
const DOT_EXTENSION = '.' + EXTENSION;
|
||||
exports.DOT_EXTENSION = DOT_EXTENSION;
|
||||
|
||||
const isSnapshotPath = path => path.endsWith(DOT_EXTENSION);
|
||||
|
||||
exports.isSnapshotPath = isSnapshotPath;
|
||||
const cache = new Map();
|
||||
|
||||
const buildSnapshotResolver = config => {
|
||||
const key = config.rootDir;
|
||||
|
||||
if (!cache.has(key)) {
|
||||
cache.set(key, createSnapshotResolver(config.snapshotResolver));
|
||||
}
|
||||
|
||||
return cache.get(key);
|
||||
};
|
||||
|
||||
exports.buildSnapshotResolver = buildSnapshotResolver;
|
||||
|
||||
function createSnapshotResolver(snapshotResolverPath) {
|
||||
return typeof snapshotResolverPath === 'string'
|
||||
? createCustomSnapshotResolver(snapshotResolverPath)
|
||||
: createDefaultSnapshotResolver();
|
||||
}
|
||||
|
||||
function createDefaultSnapshotResolver() {
|
||||
return {
|
||||
resolveSnapshotPath: testPath =>
|
||||
path.join(
|
||||
path.join(path.dirname(testPath), '__snapshots__'),
|
||||
path.basename(testPath) + DOT_EXTENSION
|
||||
),
|
||||
resolveTestPath: snapshotPath =>
|
||||
path.resolve(
|
||||
path.dirname(snapshotPath),
|
||||
'..',
|
||||
path.basename(snapshotPath, DOT_EXTENSION)
|
||||
),
|
||||
testPathForConsistencyCheck: path.posix.join(
|
||||
'consistency_check',
|
||||
'__tests__',
|
||||
'example.test.js'
|
||||
)
|
||||
};
|
||||
}
|
||||
|
||||
function createCustomSnapshotResolver(snapshotResolverPath) {
|
||||
const custom = require(snapshotResolverPath);
|
||||
|
||||
const keys = [
|
||||
['resolveSnapshotPath', 'function'],
|
||||
['resolveTestPath', 'function'],
|
||||
['testPathForConsistencyCheck', 'string']
|
||||
];
|
||||
keys.forEach(([propName, requiredType]) => {
|
||||
if (typeof custom[propName] !== requiredType) {
|
||||
throw new TypeError(mustImplement(propName, requiredType));
|
||||
}
|
||||
});
|
||||
const customResolver = {
|
||||
resolveSnapshotPath: testPath =>
|
||||
custom.resolveSnapshotPath(testPath, DOT_EXTENSION),
|
||||
resolveTestPath: snapshotPath =>
|
||||
custom.resolveTestPath(snapshotPath, DOT_EXTENSION),
|
||||
testPathForConsistencyCheck: custom.testPathForConsistencyCheck
|
||||
};
|
||||
verifyConsistentTransformations(customResolver);
|
||||
return customResolver;
|
||||
}
|
||||
|
||||
function mustImplement(propName, requiredType) {
|
||||
return (
|
||||
_chalk.default.bold(
|
||||
`Custom snapshot resolver must implement a \`${propName}\` as a ${requiredType}.`
|
||||
) +
|
||||
'\nDocumentation: https://facebook.github.io/jest/docs/en/configuration.html#snapshotResolver'
|
||||
);
|
||||
}
|
||||
|
||||
function verifyConsistentTransformations(custom) {
|
||||
const resolvedSnapshotPath = custom.resolveSnapshotPath(
|
||||
custom.testPathForConsistencyCheck
|
||||
);
|
||||
const resolvedTestPath = custom.resolveTestPath(resolvedSnapshotPath);
|
||||
|
||||
if (resolvedTestPath !== custom.testPathForConsistencyCheck) {
|
||||
throw new Error(
|
||||
_chalk.default.bold(
|
||||
`Custom snapshot resolver functions must transform paths consistently, i.e. expects resolveTestPath(resolveSnapshotPath('${custom.testPathForConsistencyCheck}')) === ${resolvedTestPath}`
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
62
node_modules/jest-snapshot/build/State.d.ts
generated
vendored
Normal file
62
node_modules/jest-snapshot/build/State.d.ts
generated
vendored
Normal file
@ -0,0 +1,62 @@
|
||||
/**
|
||||
* 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 { BabelTraverse, Prettier } from './types';
|
||||
export declare type SnapshotStateOptions = {
|
||||
updateSnapshot: Config.SnapshotUpdateState;
|
||||
getPrettier: () => null | Prettier;
|
||||
getBabelTraverse: () => BabelTraverse;
|
||||
expand?: boolean;
|
||||
};
|
||||
export declare type SnapshotMatchOptions = {
|
||||
testName: string;
|
||||
received: unknown;
|
||||
key?: string;
|
||||
inlineSnapshot?: string;
|
||||
isInline: boolean;
|
||||
error?: Error;
|
||||
};
|
||||
declare type SnapshotReturnOptions = {
|
||||
actual: string;
|
||||
count: number;
|
||||
expected?: string;
|
||||
key: string;
|
||||
pass: boolean;
|
||||
};
|
||||
declare type SaveStatus = {
|
||||
deleted: boolean;
|
||||
saved: boolean;
|
||||
};
|
||||
export default class SnapshotState {
|
||||
private _counters;
|
||||
private _dirty;
|
||||
private _index;
|
||||
private _updateSnapshot;
|
||||
private _snapshotData;
|
||||
private _initialData;
|
||||
private _snapshotPath;
|
||||
private _inlineSnapshots;
|
||||
private _uncheckedKeys;
|
||||
private _getBabelTraverse;
|
||||
private _getPrettier;
|
||||
added: number;
|
||||
expand: boolean;
|
||||
matched: number;
|
||||
unmatched: number;
|
||||
updated: number;
|
||||
constructor(snapshotPath: Config.Path, options: SnapshotStateOptions);
|
||||
markSnapshotsAsCheckedForTest(testName: string): void;
|
||||
private _addSnapshot;
|
||||
clear(): void;
|
||||
save(): SaveStatus;
|
||||
getUncheckedCount(): number;
|
||||
getUncheckedKeys(): Array<string>;
|
||||
removeUncheckedKeys(): void;
|
||||
match({ testName, received, key, inlineSnapshot, isInline, error, }: SnapshotMatchOptions): SnapshotReturnOptions;
|
||||
fail(testName: string, _received: unknown, key?: string): string;
|
||||
}
|
||||
export {};
|
351
node_modules/jest-snapshot/build/State.js
generated
vendored
Normal file
351
node_modules/jest-snapshot/build/State.js
generated
vendored
Normal file
@ -0,0 +1,351 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var fs = _interopRequireWildcard(require('graceful-fs'));
|
||||
|
||||
var _jestMessageUtil = require('jest-message-util');
|
||||
|
||||
var _InlineSnapshots = require('./InlineSnapshots');
|
||||
|
||||
var _utils = require('./utils');
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var jestExistsFile =
|
||||
global[Symbol.for('jest-native-exists-file')] || fs.existsSync;
|
||||
|
||||
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 SnapshotState {
|
||||
// @ts-expect-error
|
||||
constructor(snapshotPath, options) {
|
||||
_defineProperty(this, '_counters', void 0);
|
||||
|
||||
_defineProperty(this, '_dirty', void 0);
|
||||
|
||||
_defineProperty(this, '_index', void 0);
|
||||
|
||||
_defineProperty(this, '_updateSnapshot', void 0);
|
||||
|
||||
_defineProperty(this, '_snapshotData', void 0);
|
||||
|
||||
_defineProperty(this, '_initialData', void 0);
|
||||
|
||||
_defineProperty(this, '_snapshotPath', void 0);
|
||||
|
||||
_defineProperty(this, '_inlineSnapshots', void 0);
|
||||
|
||||
_defineProperty(this, '_uncheckedKeys', void 0);
|
||||
|
||||
_defineProperty(this, '_getBabelTraverse', void 0);
|
||||
|
||||
_defineProperty(this, '_getPrettier', void 0);
|
||||
|
||||
_defineProperty(this, 'added', void 0);
|
||||
|
||||
_defineProperty(this, 'expand', void 0);
|
||||
|
||||
_defineProperty(this, 'matched', void 0);
|
||||
|
||||
_defineProperty(this, 'unmatched', void 0);
|
||||
|
||||
_defineProperty(this, 'updated', void 0);
|
||||
|
||||
this._snapshotPath = snapshotPath;
|
||||
const {data, dirty} = (0, _utils.getSnapshotData)(
|
||||
this._snapshotPath,
|
||||
options.updateSnapshot
|
||||
);
|
||||
this._initialData = data;
|
||||
this._snapshotData = data;
|
||||
this._dirty = dirty;
|
||||
this._getBabelTraverse = options.getBabelTraverse;
|
||||
this._getPrettier = options.getPrettier;
|
||||
this._inlineSnapshots = [];
|
||||
this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
|
||||
this._counters = new Map();
|
||||
this._index = 0;
|
||||
this.expand = options.expand || false;
|
||||
this.added = 0;
|
||||
this.matched = 0;
|
||||
this.unmatched = 0;
|
||||
this._updateSnapshot = options.updateSnapshot;
|
||||
this.updated = 0;
|
||||
}
|
||||
|
||||
markSnapshotsAsCheckedForTest(testName) {
|
||||
this._uncheckedKeys.forEach(uncheckedKey => {
|
||||
if ((0, _utils.keyToTestName)(uncheckedKey) === testName) {
|
||||
this._uncheckedKeys.delete(uncheckedKey);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
_addSnapshot(key, receivedSerialized, options) {
|
||||
this._dirty = true;
|
||||
|
||||
if (options.isInline) {
|
||||
const error = options.error || new Error();
|
||||
const lines = (0, _jestMessageUtil.getStackTraceLines)(
|
||||
(0, _utils.removeLinesBeforeExternalMatcherTrap)(error.stack || '')
|
||||
);
|
||||
const frame = (0, _jestMessageUtil.getTopFrame)(lines);
|
||||
|
||||
if (!frame) {
|
||||
throw new Error(
|
||||
"Jest: Couldn't infer stack frame for inline snapshot."
|
||||
);
|
||||
}
|
||||
|
||||
this._inlineSnapshots.push({
|
||||
frame,
|
||||
snapshot: receivedSerialized
|
||||
});
|
||||
} else {
|
||||
this._snapshotData[key] = receivedSerialized;
|
||||
}
|
||||
}
|
||||
|
||||
clear() {
|
||||
this._snapshotData = this._initialData;
|
||||
this._inlineSnapshots = [];
|
||||
this._counters = new Map();
|
||||
this._index = 0;
|
||||
this.added = 0;
|
||||
this.matched = 0;
|
||||
this.unmatched = 0;
|
||||
this.updated = 0;
|
||||
}
|
||||
|
||||
save() {
|
||||
const hasExternalSnapshots = Object.keys(this._snapshotData).length;
|
||||
const hasInlineSnapshots = this._inlineSnapshots.length;
|
||||
const isEmpty = !hasExternalSnapshots && !hasInlineSnapshots;
|
||||
const status = {
|
||||
deleted: false,
|
||||
saved: false
|
||||
};
|
||||
|
||||
if ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {
|
||||
if (hasExternalSnapshots) {
|
||||
(0, _utils.saveSnapshotFile)(this._snapshotData, this._snapshotPath);
|
||||
}
|
||||
|
||||
if (hasInlineSnapshots) {
|
||||
const prettier = this._getPrettier(); // Load lazily
|
||||
|
||||
const babelTraverse = this._getBabelTraverse(); // Load lazily
|
||||
|
||||
(0, _InlineSnapshots.saveInlineSnapshots)(
|
||||
this._inlineSnapshots,
|
||||
prettier,
|
||||
babelTraverse
|
||||
);
|
||||
}
|
||||
|
||||
status.saved = true;
|
||||
} else if (!hasExternalSnapshots && jestExistsFile(this._snapshotPath)) {
|
||||
if (this._updateSnapshot === 'all') {
|
||||
fs.unlinkSync(this._snapshotPath);
|
||||
}
|
||||
|
||||
status.deleted = true;
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
getUncheckedCount() {
|
||||
return this._uncheckedKeys.size || 0;
|
||||
}
|
||||
|
||||
getUncheckedKeys() {
|
||||
return Array.from(this._uncheckedKeys);
|
||||
}
|
||||
|
||||
removeUncheckedKeys() {
|
||||
if (this._updateSnapshot === 'all' && this._uncheckedKeys.size) {
|
||||
this._dirty = true;
|
||||
|
||||
this._uncheckedKeys.forEach(key => delete this._snapshotData[key]);
|
||||
|
||||
this._uncheckedKeys.clear();
|
||||
}
|
||||
}
|
||||
|
||||
match({testName, received, key, inlineSnapshot, isInline, error}) {
|
||||
this._counters.set(testName, (this._counters.get(testName) || 0) + 1);
|
||||
|
||||
const count = Number(this._counters.get(testName));
|
||||
|
||||
if (!key) {
|
||||
key = (0, _utils.testNameToKey)(testName, count);
|
||||
} // Do not mark the snapshot as "checked" if the snapshot is inline and
|
||||
// there's an external snapshot. This way the external snapshot can be
|
||||
// removed with `--updateSnapshot`.
|
||||
|
||||
if (!(isInline && this._snapshotData[key] !== undefined)) {
|
||||
this._uncheckedKeys.delete(key);
|
||||
}
|
||||
|
||||
const receivedSerialized = (0, _utils.addExtraLineBreaks)(
|
||||
(0, _utils.serialize)(received)
|
||||
);
|
||||
const expected = isInline ? inlineSnapshot : this._snapshotData[key];
|
||||
const pass = expected === receivedSerialized;
|
||||
const hasSnapshot = expected !== undefined;
|
||||
const snapshotIsPersisted = isInline || fs.existsSync(this._snapshotPath);
|
||||
|
||||
if (pass && !isInline) {
|
||||
// Executing a snapshot file as JavaScript and writing the strings back
|
||||
// when other snapshots have changed loses the proper escaping for some
|
||||
// characters. Since we check every snapshot in every test, use the newly
|
||||
// generated formatted string.
|
||||
// Note that this is only relevant when a snapshot is added and the dirty
|
||||
// flag is set.
|
||||
this._snapshotData[key] = receivedSerialized;
|
||||
} // These are the conditions on when to write snapshots:
|
||||
// * There's no snapshot file in a non-CI environment.
|
||||
// * There is a snapshot file and we decided to update the snapshot.
|
||||
// * There is a snapshot file, but it doesn't have this snaphsot.
|
||||
// These are the conditions on when not to write snapshots:
|
||||
// * The update flag is set to 'none'.
|
||||
// * There's no snapshot file or a file without this snapshot on a CI environment.
|
||||
|
||||
if (
|
||||
(hasSnapshot && this._updateSnapshot === 'all') ||
|
||||
((!hasSnapshot || !snapshotIsPersisted) &&
|
||||
(this._updateSnapshot === 'new' || this._updateSnapshot === 'all'))
|
||||
) {
|
||||
if (this._updateSnapshot === 'all') {
|
||||
if (!pass) {
|
||||
if (hasSnapshot) {
|
||||
this.updated++;
|
||||
} else {
|
||||
this.added++;
|
||||
}
|
||||
|
||||
this._addSnapshot(key, receivedSerialized, {
|
||||
error,
|
||||
isInline
|
||||
});
|
||||
} else {
|
||||
this.matched++;
|
||||
}
|
||||
} else {
|
||||
this._addSnapshot(key, receivedSerialized, {
|
||||
error,
|
||||
isInline
|
||||
});
|
||||
|
||||
this.added++;
|
||||
}
|
||||
|
||||
return {
|
||||
actual: '',
|
||||
count,
|
||||
expected: '',
|
||||
key,
|
||||
pass: true
|
||||
};
|
||||
} else {
|
||||
if (!pass) {
|
||||
this.unmatched++;
|
||||
return {
|
||||
actual: (0, _utils.removeExtraLineBreaks)(receivedSerialized),
|
||||
count,
|
||||
expected:
|
||||
expected !== undefined
|
||||
? (0, _utils.removeExtraLineBreaks)(expected)
|
||||
: undefined,
|
||||
key,
|
||||
pass: false
|
||||
};
|
||||
} else {
|
||||
this.matched++;
|
||||
return {
|
||||
actual: '',
|
||||
count,
|
||||
expected: '',
|
||||
key,
|
||||
pass: true
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fail(testName, _received, key) {
|
||||
this._counters.set(testName, (this._counters.get(testName) || 0) + 1);
|
||||
|
||||
const count = Number(this._counters.get(testName));
|
||||
|
||||
if (!key) {
|
||||
key = (0, _utils.testNameToKey)(testName, count);
|
||||
}
|
||||
|
||||
this._uncheckedKeys.delete(key);
|
||||
|
||||
this.unmatched++;
|
||||
return key;
|
||||
}
|
||||
}
|
||||
|
||||
exports.default = SnapshotState;
|
15
node_modules/jest-snapshot/build/colors.d.ts
generated
vendored
Normal file
15
node_modules/jest-snapshot/build/colors.d.ts
generated
vendored
Normal file
@ -0,0 +1,15 @@
|
||||
/**
|
||||
* 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 const aForeground2 = 90;
|
||||
export declare const aBackground2 = 225;
|
||||
export declare const bForeground2 = 23;
|
||||
export declare const bBackground2 = 195;
|
||||
export declare type RGB = [number, number, number];
|
||||
export declare const aForeground3: RGB;
|
||||
export declare const aBackground3: RGB;
|
||||
export declare const bForeground3: RGB;
|
||||
export declare const bBackground3: RGB;
|
30
node_modules/jest-snapshot/build/colors.js
generated
vendored
Normal file
30
node_modules/jest-snapshot/build/colors.js
generated
vendored
Normal file
@ -0,0 +1,30 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.bBackground3 = exports.bForeground3 = exports.aBackground3 = exports.aForeground3 = exports.bBackground2 = exports.bForeground2 = exports.aBackground2 = exports.aForeground2 = 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.
|
||||
*/
|
||||
// https://jonasjacek.github.io/colors/
|
||||
const aForeground2 = 90;
|
||||
exports.aForeground2 = aForeground2;
|
||||
const aBackground2 = 225;
|
||||
exports.aBackground2 = aBackground2;
|
||||
const bForeground2 = 23;
|
||||
exports.bForeground2 = bForeground2;
|
||||
const bBackground2 = 195;
|
||||
exports.bBackground2 = bBackground2;
|
||||
const aForeground3 = [0x80, 0, 0x80];
|
||||
exports.aForeground3 = aForeground3;
|
||||
const aBackground3 = [0xff, 0xd7, 0xff];
|
||||
exports.aBackground3 = aBackground3;
|
||||
const bForeground3 = [0, 0x5f, 0x5f];
|
||||
exports.bForeground3 = bForeground3;
|
||||
const bBackground3 = [0xd7, 0xff, 0xff];
|
||||
exports.bBackground3 = bBackground3;
|
7
node_modules/jest-snapshot/build/dedentLines.d.ts
generated
vendored
Normal file
7
node_modules/jest-snapshot/build/dedentLines.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 const dedentLines: (input: Array<string>) => Array<string> | null;
|
149
node_modules/jest-snapshot/build/dedentLines.js
generated
vendored
Normal file
149
node_modules/jest-snapshot/build/dedentLines.js
generated
vendored
Normal file
@ -0,0 +1,149 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.dedentLines = 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.
|
||||
*/
|
||||
const getIndentationLength = line => {
|
||||
const result = /^( {2})+/.exec(line);
|
||||
return result === null ? 0 : result[0].length;
|
||||
};
|
||||
|
||||
const dedentLine = line => line.slice(getIndentationLength(line)); // Return true if:
|
||||
// "key": "value has multiple lines\n…
|
||||
// "key has multiple lines\n…
|
||||
|
||||
const hasUnmatchedDoubleQuoteMarks = string => {
|
||||
let n = 0;
|
||||
let i = string.indexOf('"', 0);
|
||||
|
||||
while (i !== -1) {
|
||||
if (i === 0 || string[i - 1] !== '\\') {
|
||||
n += 1;
|
||||
}
|
||||
|
||||
i = string.indexOf('"', i + 1);
|
||||
}
|
||||
|
||||
return n % 2 !== 0;
|
||||
};
|
||||
|
||||
const isFirstLineOfTag = line => /^( {2})*\</.test(line); // The length of the output array is the index of the next input line.
|
||||
// Push dedented lines of start tag onto output and return true;
|
||||
// otherwise return false because:
|
||||
// * props include a multiline string (or text node, if props have markup)
|
||||
// * start tag does not close
|
||||
|
||||
const dedentStartTag = (input, output) => {
|
||||
let line = input[output.length];
|
||||
output.push(dedentLine(line));
|
||||
|
||||
if (line.includes('>')) {
|
||||
return true;
|
||||
}
|
||||
|
||||
while (output.length < input.length) {
|
||||
line = input[output.length];
|
||||
|
||||
if (hasUnmatchedDoubleQuoteMarks(line)) {
|
||||
return false; // because props include a multiline string
|
||||
} else if (isFirstLineOfTag(line)) {
|
||||
// Recursion only if props have markup.
|
||||
if (!dedentMarkup(input, output)) {
|
||||
return false;
|
||||
}
|
||||
} else {
|
||||
output.push(dedentLine(line));
|
||||
|
||||
if (line.includes('>')) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}; // Push dedented lines of markup onto output and return true;
|
||||
// otherwise return false because:
|
||||
// * props include a multiline string
|
||||
// * text has more than one adjacent line
|
||||
// * markup does not close
|
||||
|
||||
const dedentMarkup = (input, output) => {
|
||||
let line = input[output.length];
|
||||
|
||||
if (!dedentStartTag(input, output)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (input[output.length - 1].includes('/>')) {
|
||||
return true;
|
||||
}
|
||||
|
||||
let isText = false;
|
||||
const stack = [];
|
||||
stack.push(getIndentationLength(line));
|
||||
|
||||
while (stack.length > 0 && output.length < input.length) {
|
||||
line = input[output.length];
|
||||
|
||||
if (isFirstLineOfTag(line)) {
|
||||
if (line.includes('</')) {
|
||||
output.push(dedentLine(line));
|
||||
stack.pop();
|
||||
} else {
|
||||
if (!dedentStartTag(input, output)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!input[output.length - 1].includes('/>')) {
|
||||
stack.push(getIndentationLength(line));
|
||||
}
|
||||
}
|
||||
|
||||
isText = false;
|
||||
} else {
|
||||
if (isText) {
|
||||
return false; // because text has more than one adjacent line
|
||||
}
|
||||
|
||||
const indentationLengthOfTag = stack[stack.length - 1];
|
||||
output.push(line.slice(indentationLengthOfTag + 2));
|
||||
isText = true;
|
||||
}
|
||||
}
|
||||
|
||||
return stack.length === 0;
|
||||
}; // Return lines unindented by heuristic;
|
||||
// otherwise return null because:
|
||||
// * props include a multiline string
|
||||
// * text has more than one adjacent line
|
||||
// * markup does not close
|
||||
|
||||
const dedentLines = input => {
|
||||
const output = [];
|
||||
|
||||
while (output.length < input.length) {
|
||||
const line = input[output.length];
|
||||
|
||||
if (hasUnmatchedDoubleQuoteMarks(line)) {
|
||||
return null;
|
||||
} else if (isFirstLineOfTag(line)) {
|
||||
if (!dedentMarkup(input, output)) {
|
||||
return null;
|
||||
}
|
||||
} else {
|
||||
output.push(dedentLine(line));
|
||||
}
|
||||
}
|
||||
|
||||
return output;
|
||||
};
|
||||
|
||||
exports.dedentLines = dedentLines;
|
34
node_modules/jest-snapshot/build/index.d.ts
generated
vendored
Normal file
34
node_modules/jest-snapshot/build/index.d.ts
generated
vendored
Normal file
@ -0,0 +1,34 @@
|
||||
/**
|
||||
* 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 { FS as HasteFS } from 'jest-haste-map';
|
||||
import { SnapshotResolver as JestSnapshotResolver } from './SnapshotResolver';
|
||||
import SnapshotState from './State';
|
||||
import type { Context, ExpectationResult } from './types';
|
||||
import * as utils from './utils';
|
||||
declare const JestSnapshot: {
|
||||
EXTENSION: string;
|
||||
SnapshotState: typeof SnapshotState;
|
||||
addSerializer: (plugin: import("pretty-format/build/types").Plugin) => void;
|
||||
buildSnapshotResolver: (config: Config.ProjectConfig) => JestSnapshotResolver;
|
||||
cleanup: (hasteFS: HasteFS, update: Config.SnapshotUpdateState, snapshotResolver: JestSnapshotResolver, testPathIgnorePatterns?: string[] | undefined) => {
|
||||
filesRemoved: number;
|
||||
filesRemovedList: Array<string>;
|
||||
};
|
||||
getSerializers: () => import("pretty-format/build/types").Plugins;
|
||||
isSnapshotPath: (path: string) => boolean;
|
||||
toMatchInlineSnapshot: (this: Context, received: unknown, propertiesOrSnapshot?: string | object | undefined, inlineSnapshot?: string | undefined) => ExpectationResult;
|
||||
toMatchSnapshot: (this: Context, received: unknown, propertiesOrHint?: string | object | undefined, hint?: string | undefined) => ExpectationResult;
|
||||
toThrowErrorMatchingInlineSnapshot: (this: Context, received: unknown, inlineSnapshot?: string | undefined, fromPromise?: boolean | undefined) => ExpectationResult;
|
||||
toThrowErrorMatchingSnapshot: (this: Context, received: unknown, hint: string | undefined, fromPromise: boolean) => ExpectationResult;
|
||||
utils: typeof utils;
|
||||
};
|
||||
declare namespace JestSnapshot {
|
||||
type SnapshotResolver = JestSnapshotResolver;
|
||||
type SnapshotStateType = SnapshotState;
|
||||
}
|
||||
export = JestSnapshot;
|
612
node_modules/jest-snapshot/build/index.js
generated
vendored
Normal file
612
node_modules/jest-snapshot/build/index.js
generated
vendored
Normal file
@ -0,0 +1,612 @@
|
||||
'use strict';
|
||||
|
||||
var fs = _interopRequireWildcard(require('graceful-fs'));
|
||||
|
||||
var _jestMatcherUtils = require('jest-matcher-utils');
|
||||
|
||||
var _SnapshotResolver = require('./SnapshotResolver');
|
||||
|
||||
var _State = _interopRequireDefault(require('./State'));
|
||||
|
||||
var _plugins = require('./plugins');
|
||||
|
||||
var _printSnapshot = require('./printSnapshot');
|
||||
|
||||
var utils = _interopRequireWildcard(require('./utils'));
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var jestExistsFile =
|
||||
global[Symbol.for('jest-native-exists-file')] || fs.existsSync;
|
||||
const DID_NOT_THROW = 'Received function did not throw'; // same as toThrow
|
||||
|
||||
const NOT_SNAPSHOT_MATCHERS = `Snapshot matchers cannot be used with ${(0,
|
||||
_jestMatcherUtils.BOLD_WEIGHT)('not')}`;
|
||||
const INDENTATION_REGEX = /^([^\S\n]*)\S/m; // Display name in report when matcher fails same as in snapshot file,
|
||||
// but with optional hint argument in bold weight.
|
||||
|
||||
const printSnapshotName = (concatenatedBlockNames = '', hint = '', count) => {
|
||||
const hasNames = concatenatedBlockNames.length !== 0;
|
||||
const hasHint = hint.length !== 0;
|
||||
return (
|
||||
'Snapshot name: `' +
|
||||
(hasNames ? utils.escapeBacktickString(concatenatedBlockNames) : '') +
|
||||
(hasNames && hasHint ? ': ' : '') +
|
||||
(hasHint
|
||||
? (0, _jestMatcherUtils.BOLD_WEIGHT)(utils.escapeBacktickString(hint))
|
||||
: '') +
|
||||
' ' +
|
||||
count +
|
||||
'`'
|
||||
);
|
||||
};
|
||||
|
||||
function stripAddedIndentation(inlineSnapshot) {
|
||||
// Find indentation if exists.
|
||||
const match = inlineSnapshot.match(INDENTATION_REGEX);
|
||||
|
||||
if (!match || !match[1]) {
|
||||
// No indentation.
|
||||
return inlineSnapshot;
|
||||
}
|
||||
|
||||
const indentation = match[1];
|
||||
const lines = inlineSnapshot.split('\n');
|
||||
|
||||
if (lines.length <= 2) {
|
||||
// Must be at least 3 lines.
|
||||
return inlineSnapshot;
|
||||
}
|
||||
|
||||
if (lines[0].trim() !== '' || lines[lines.length - 1].trim() !== '') {
|
||||
// If not blank first and last lines, abort.
|
||||
return inlineSnapshot;
|
||||
}
|
||||
|
||||
for (let i = 1; i < lines.length - 1; i++) {
|
||||
if (lines[i] !== '') {
|
||||
if (lines[i].indexOf(indentation) !== 0) {
|
||||
// All lines except first and last should either be blank or have the same
|
||||
// indent as the first line (or more). If this isn't the case we don't
|
||||
// want to touch the snapshot at all.
|
||||
return inlineSnapshot;
|
||||
}
|
||||
|
||||
lines[i] = lines[i].substr(indentation.length);
|
||||
}
|
||||
} // Last line is a special case because it won't have the same indent as others
|
||||
// but may still have been given some indent to line up.
|
||||
|
||||
lines[lines.length - 1] = ''; // Return inline snapshot, now at indent 0.
|
||||
|
||||
inlineSnapshot = lines.join('\n');
|
||||
return inlineSnapshot;
|
||||
}
|
||||
|
||||
const fileExists = (filePath, hasteFS) =>
|
||||
hasteFS.exists(filePath) || jestExistsFile(filePath);
|
||||
|
||||
const cleanup = (hasteFS, update, snapshotResolver, testPathIgnorePatterns) => {
|
||||
const pattern = '\\.' + _SnapshotResolver.EXTENSION + '$';
|
||||
const files = hasteFS.matchFiles(pattern);
|
||||
let testIgnorePatternsRegex = null;
|
||||
|
||||
if (testPathIgnorePatterns && testPathIgnorePatterns.length > 0) {
|
||||
testIgnorePatternsRegex = new RegExp(testPathIgnorePatterns.join('|'));
|
||||
}
|
||||
|
||||
const list = files.filter(snapshotFile => {
|
||||
const testPath = snapshotResolver.resolveTestPath(snapshotFile); // ignore snapshots of ignored tests
|
||||
|
||||
if (testIgnorePatternsRegex && testIgnorePatternsRegex.test(testPath)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!fileExists(testPath, hasteFS)) {
|
||||
if (update === 'all') {
|
||||
fs.unlinkSync(snapshotFile);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
});
|
||||
return {
|
||||
filesRemoved: list.length,
|
||||
filesRemovedList: list
|
||||
};
|
||||
};
|
||||
|
||||
const toMatchSnapshot = function (received, propertiesOrHint, hint) {
|
||||
const matcherName = 'toMatchSnapshot';
|
||||
let properties;
|
||||
const length = arguments.length;
|
||||
|
||||
if (length === 2 && typeof propertiesOrHint === 'string') {
|
||||
hint = propertiesOrHint;
|
||||
} else if (length >= 2) {
|
||||
if (typeof propertiesOrHint !== 'object' || propertiesOrHint === null) {
|
||||
const options = {
|
||||
isNot: this.isNot,
|
||||
promise: this.promise
|
||||
};
|
||||
let printedWithType = (0, _jestMatcherUtils.printWithType)(
|
||||
'Expected properties',
|
||||
propertiesOrHint,
|
||||
_printSnapshot.printExpected
|
||||
);
|
||||
|
||||
if (length === 3) {
|
||||
options.secondArgument = 'hint';
|
||||
options.secondArgumentColor = _jestMatcherUtils.BOLD_WEIGHT;
|
||||
|
||||
if (propertiesOrHint == null) {
|
||||
printedWithType += `\n\nTo provide a hint without properties: toMatchSnapshot('hint')`;
|
||||
}
|
||||
}
|
||||
|
||||
throw new Error(
|
||||
(0, _jestMatcherUtils.matcherErrorMessage)(
|
||||
(0, _jestMatcherUtils.matcherHint)(
|
||||
matcherName,
|
||||
undefined,
|
||||
_printSnapshot.PROPERTIES_ARG,
|
||||
options
|
||||
),
|
||||
`Expected ${(0, _jestMatcherUtils.EXPECTED_COLOR)(
|
||||
'properties'
|
||||
)} must be an object`,
|
||||
printedWithType
|
||||
)
|
||||
);
|
||||
} // Future breaking change: Snapshot hint must be a string
|
||||
// if (arguments.length === 3 && typeof hint !== 'string') {}
|
||||
|
||||
properties = propertiesOrHint;
|
||||
}
|
||||
|
||||
return _toMatchSnapshot({
|
||||
context: this,
|
||||
hint,
|
||||
isInline: false,
|
||||
matcherName,
|
||||
properties,
|
||||
received
|
||||
});
|
||||
};
|
||||
|
||||
const toMatchInlineSnapshot = function (
|
||||
received,
|
||||
propertiesOrSnapshot,
|
||||
inlineSnapshot
|
||||
) {
|
||||
const matcherName = 'toMatchInlineSnapshot';
|
||||
let properties;
|
||||
const length = arguments.length;
|
||||
|
||||
if (length === 2 && typeof propertiesOrSnapshot === 'string') {
|
||||
inlineSnapshot = propertiesOrSnapshot;
|
||||
} else if (length >= 2) {
|
||||
const options = {
|
||||
isNot: this.isNot,
|
||||
promise: this.promise
|
||||
};
|
||||
|
||||
if (length === 3) {
|
||||
options.secondArgument = _printSnapshot.SNAPSHOT_ARG;
|
||||
options.secondArgumentColor = _printSnapshot.noColor;
|
||||
}
|
||||
|
||||
if (
|
||||
typeof propertiesOrSnapshot !== 'object' ||
|
||||
propertiesOrSnapshot === null
|
||||
) {
|
||||
throw new Error(
|
||||
(0, _jestMatcherUtils.matcherErrorMessage)(
|
||||
(0, _jestMatcherUtils.matcherHint)(
|
||||
matcherName,
|
||||
undefined,
|
||||
_printSnapshot.PROPERTIES_ARG,
|
||||
options
|
||||
),
|
||||
`Expected ${(0, _jestMatcherUtils.EXPECTED_COLOR)(
|
||||
'properties'
|
||||
)} must be an object`,
|
||||
(0, _jestMatcherUtils.printWithType)(
|
||||
'Expected properties',
|
||||
propertiesOrSnapshot,
|
||||
_printSnapshot.printExpected
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
if (length === 3 && typeof inlineSnapshot !== 'string') {
|
||||
throw new Error(
|
||||
(0, _jestMatcherUtils.matcherErrorMessage)(
|
||||
(0, _jestMatcherUtils.matcherHint)(
|
||||
matcherName,
|
||||
undefined,
|
||||
_printSnapshot.PROPERTIES_ARG,
|
||||
options
|
||||
),
|
||||
`Inline snapshot must be a string`,
|
||||
(0, _jestMatcherUtils.printWithType)(
|
||||
'Inline snapshot',
|
||||
inlineSnapshot,
|
||||
utils.serialize
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
properties = propertiesOrSnapshot;
|
||||
}
|
||||
|
||||
return _toMatchSnapshot({
|
||||
context: this,
|
||||
inlineSnapshot:
|
||||
inlineSnapshot !== undefined
|
||||
? stripAddedIndentation(inlineSnapshot)
|
||||
: undefined,
|
||||
isInline: true,
|
||||
matcherName,
|
||||
properties,
|
||||
received
|
||||
});
|
||||
};
|
||||
|
||||
const _toMatchSnapshot = config => {
|
||||
const {
|
||||
context,
|
||||
hint,
|
||||
inlineSnapshot,
|
||||
isInline,
|
||||
matcherName,
|
||||
properties
|
||||
} = config;
|
||||
let {received} = config;
|
||||
context.dontThrow && context.dontThrow();
|
||||
const {currentTestName, isNot, snapshotState} = context;
|
||||
|
||||
if (isNot) {
|
||||
throw new Error(
|
||||
(0, _jestMatcherUtils.matcherErrorMessage)(
|
||||
(0, _printSnapshot.matcherHintFromConfig)(config, false),
|
||||
NOT_SNAPSHOT_MATCHERS
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
if (snapshotState == null) {
|
||||
// Because the state is the problem, this is not a matcher error.
|
||||
// Call generic stringify from jest-matcher-utils package
|
||||
// because uninitialized snapshot state does not need snapshot serializers.
|
||||
throw new Error(
|
||||
(0, _printSnapshot.matcherHintFromConfig)(config, false) +
|
||||
'\n\n' +
|
||||
`Snapshot state must be initialized` +
|
||||
'\n\n' +
|
||||
(0, _jestMatcherUtils.printWithType)(
|
||||
'Snapshot state',
|
||||
snapshotState,
|
||||
_jestMatcherUtils.stringify
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
const fullTestName =
|
||||
currentTestName && hint
|
||||
? `${currentTestName}: ${hint}`
|
||||
: currentTestName || ''; // future BREAKING change: || hint
|
||||
|
||||
if (typeof properties === 'object') {
|
||||
if (typeof received !== 'object' || received === null) {
|
||||
throw new Error(
|
||||
(0, _jestMatcherUtils.matcherErrorMessage)(
|
||||
(0, _printSnapshot.matcherHintFromConfig)(config, false),
|
||||
`${(0, _jestMatcherUtils.RECEIVED_COLOR)(
|
||||
'received'
|
||||
)} value must be an object when the matcher has ${(0,
|
||||
_jestMatcherUtils.EXPECTED_COLOR)('properties')}`,
|
||||
(0, _jestMatcherUtils.printWithType)(
|
||||
'Received',
|
||||
received,
|
||||
_printSnapshot.printReceived
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
const propertyPass = context.equals(received, properties, [
|
||||
context.utils.iterableEquality,
|
||||
context.utils.subsetEquality
|
||||
]);
|
||||
|
||||
if (!propertyPass) {
|
||||
const key = snapshotState.fail(fullTestName, received);
|
||||
const matched = /(\d+)$/.exec(key);
|
||||
const count = matched === null ? 1 : Number(matched[1]);
|
||||
|
||||
const message = () =>
|
||||
(0, _printSnapshot.matcherHintFromConfig)(config, false) +
|
||||
'\n\n' +
|
||||
printSnapshotName(currentTestName, hint, count) +
|
||||
'\n\n' +
|
||||
(0, _printSnapshot.printPropertiesAndReceived)(
|
||||
properties,
|
||||
received,
|
||||
snapshotState.expand
|
||||
);
|
||||
|
||||
return {
|
||||
message,
|
||||
name: matcherName,
|
||||
pass: false
|
||||
};
|
||||
} else {
|
||||
received = utils.deepMerge(received, properties);
|
||||
}
|
||||
}
|
||||
|
||||
const result = snapshotState.match({
|
||||
error: context.error,
|
||||
inlineSnapshot,
|
||||
isInline,
|
||||
received,
|
||||
testName: fullTestName
|
||||
});
|
||||
const {actual, count, expected, pass} = result;
|
||||
|
||||
if (pass) {
|
||||
return {
|
||||
message: () => '',
|
||||
pass: true
|
||||
};
|
||||
}
|
||||
|
||||
const message =
|
||||
expected === undefined
|
||||
? () =>
|
||||
(0, _printSnapshot.matcherHintFromConfig)(config, true) +
|
||||
'\n\n' +
|
||||
printSnapshotName(currentTestName, hint, count) +
|
||||
'\n\n' +
|
||||
`New snapshot was ${(0, _jestMatcherUtils.BOLD_WEIGHT)(
|
||||
'not written'
|
||||
)}. The update flag ` +
|
||||
`must be explicitly passed to write a new snapshot.\n\n` +
|
||||
`This is likely because this test is run in a continuous integration ` +
|
||||
`(CI) environment in which snapshots are not written by default.\n\n` +
|
||||
`Received:${actual.includes('\n') ? '\n' : ' '}${(0,
|
||||
_printSnapshot.bReceivedColor)(actual)}`
|
||||
: () =>
|
||||
(0, _printSnapshot.matcherHintFromConfig)(config, true) +
|
||||
'\n\n' +
|
||||
printSnapshotName(currentTestName, hint, count) +
|
||||
'\n\n' +
|
||||
(0, _printSnapshot.printSnapshotAndReceived)(
|
||||
expected,
|
||||
actual,
|
||||
received,
|
||||
snapshotState.expand
|
||||
); // Passing the actual and expected objects so that a custom reporter
|
||||
// could access them, for example in order to display a custom visual diff,
|
||||
// or create a different error message
|
||||
|
||||
return {
|
||||
actual,
|
||||
expected,
|
||||
message,
|
||||
name: matcherName,
|
||||
pass: false
|
||||
};
|
||||
};
|
||||
|
||||
const toThrowErrorMatchingSnapshot = function (
|
||||
received,
|
||||
hint, // because error TS1016 for hint?: string
|
||||
fromPromise
|
||||
) {
|
||||
const matcherName = 'toThrowErrorMatchingSnapshot'; // Future breaking change: Snapshot hint must be a string
|
||||
// if (hint !== undefined && typeof hint !== string) {}
|
||||
|
||||
return _toThrowErrorMatchingSnapshot(
|
||||
{
|
||||
context: this,
|
||||
hint,
|
||||
isInline: false,
|
||||
matcherName,
|
||||
received
|
||||
},
|
||||
fromPromise
|
||||
);
|
||||
};
|
||||
|
||||
const toThrowErrorMatchingInlineSnapshot = function (
|
||||
received,
|
||||
inlineSnapshot,
|
||||
fromPromise
|
||||
) {
|
||||
const matcherName = 'toThrowErrorMatchingInlineSnapshot';
|
||||
|
||||
if (inlineSnapshot !== undefined && typeof inlineSnapshot !== 'string') {
|
||||
const options = {
|
||||
expectedColor: _printSnapshot.noColor,
|
||||
isNot: this.isNot,
|
||||
promise: this.promise
|
||||
};
|
||||
throw new Error(
|
||||
(0, _jestMatcherUtils.matcherErrorMessage)(
|
||||
(0, _jestMatcherUtils.matcherHint)(
|
||||
matcherName,
|
||||
undefined,
|
||||
_printSnapshot.SNAPSHOT_ARG,
|
||||
options
|
||||
),
|
||||
`Inline snapshot must be a string`,
|
||||
(0, _jestMatcherUtils.printWithType)(
|
||||
'Inline snapshot',
|
||||
inlineSnapshot,
|
||||
utils.serialize
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
return _toThrowErrorMatchingSnapshot(
|
||||
{
|
||||
context: this,
|
||||
inlineSnapshot:
|
||||
inlineSnapshot !== undefined
|
||||
? stripAddedIndentation(inlineSnapshot)
|
||||
: undefined,
|
||||
isInline: true,
|
||||
matcherName,
|
||||
received
|
||||
},
|
||||
fromPromise
|
||||
);
|
||||
};
|
||||
|
||||
const _toThrowErrorMatchingSnapshot = (config, fromPromise) => {
|
||||
const {
|
||||
context,
|
||||
hint,
|
||||
inlineSnapshot,
|
||||
isInline,
|
||||
matcherName,
|
||||
received
|
||||
} = config;
|
||||
context.dontThrow && context.dontThrow();
|
||||
const {isNot, promise} = context;
|
||||
|
||||
if (!fromPromise) {
|
||||
if (typeof received !== 'function') {
|
||||
const options = {
|
||||
isNot,
|
||||
promise
|
||||
};
|
||||
throw new Error(
|
||||
(0, _jestMatcherUtils.matcherErrorMessage)(
|
||||
(0, _jestMatcherUtils.matcherHint)(
|
||||
matcherName,
|
||||
undefined,
|
||||
'',
|
||||
options
|
||||
),
|
||||
`${(0, _jestMatcherUtils.RECEIVED_COLOR)(
|
||||
'received'
|
||||
)} value must be a function`,
|
||||
(0, _jestMatcherUtils.printWithType)(
|
||||
'Received',
|
||||
received,
|
||||
_printSnapshot.printReceived
|
||||
)
|
||||
)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
if (isNot) {
|
||||
throw new Error(
|
||||
(0, _jestMatcherUtils.matcherErrorMessage)(
|
||||
(0, _printSnapshot.matcherHintFromConfig)(config, false),
|
||||
NOT_SNAPSHOT_MATCHERS
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
let error;
|
||||
|
||||
if (fromPromise) {
|
||||
error = received;
|
||||
} else {
|
||||
try {
|
||||
received();
|
||||
} catch (e) {
|
||||
error = e;
|
||||
}
|
||||
}
|
||||
|
||||
if (error === undefined) {
|
||||
// Because the received value is a function, this is not a matcher error.
|
||||
throw new Error(
|
||||
(0, _printSnapshot.matcherHintFromConfig)(config, false) +
|
||||
'\n\n' +
|
||||
DID_NOT_THROW
|
||||
);
|
||||
}
|
||||
|
||||
return _toMatchSnapshot({
|
||||
context,
|
||||
hint,
|
||||
inlineSnapshot,
|
||||
isInline,
|
||||
matcherName,
|
||||
received: error.message
|
||||
});
|
||||
};
|
||||
|
||||
const JestSnapshot = {
|
||||
EXTENSION: _SnapshotResolver.EXTENSION,
|
||||
SnapshotState: _State.default,
|
||||
addSerializer: _plugins.addSerializer,
|
||||
buildSnapshotResolver: _SnapshotResolver.buildSnapshotResolver,
|
||||
cleanup,
|
||||
getSerializers: _plugins.getSerializers,
|
||||
isSnapshotPath: _SnapshotResolver.isSnapshotPath,
|
||||
toMatchInlineSnapshot,
|
||||
toMatchSnapshot,
|
||||
toThrowErrorMatchingInlineSnapshot,
|
||||
toThrowErrorMatchingSnapshot,
|
||||
utils
|
||||
};
|
||||
module.exports = JestSnapshot;
|
11
node_modules/jest-snapshot/build/mockSerializer.d.ts
generated
vendored
Normal file
11
node_modules/jest-snapshot/build/mockSerializer.d.ts
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
/**
|
||||
* 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 { NewPlugin } from 'pretty-format';
|
||||
export declare const serialize: NewPlugin['serialize'];
|
||||
export declare const test: NewPlugin['test'];
|
||||
declare const plugin: NewPlugin;
|
||||
export default plugin;
|
52
node_modules/jest-snapshot/build/mockSerializer.js
generated
vendored
Normal file
52
node_modules/jest-snapshot/build/mockSerializer.js
generated
vendored
Normal file
@ -0,0 +1,52 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = exports.test = exports.serialize = 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.
|
||||
*/
|
||||
const serialize = (val, config, indentation, depth, refs, printer) => {
|
||||
// Serialize a non-default name, even if config.printFunctionName is false.
|
||||
const name = val.getMockName();
|
||||
const nameString = name === 'jest.fn()' ? '' : ' ' + name;
|
||||
let callsString = '';
|
||||
|
||||
if (val.mock.calls.length !== 0) {
|
||||
const indentationNext = indentation + config.indent;
|
||||
callsString =
|
||||
' {' +
|
||||
config.spacingOuter +
|
||||
indentationNext +
|
||||
'"calls": ' +
|
||||
printer(val.mock.calls, config, indentationNext, depth, refs) +
|
||||
(config.min ? ', ' : ',') +
|
||||
config.spacingOuter +
|
||||
indentationNext +
|
||||
'"results": ' +
|
||||
printer(val.mock.results, config, indentationNext, depth, refs) +
|
||||
(config.min ? '' : ',') +
|
||||
config.spacingOuter +
|
||||
indentation +
|
||||
'}';
|
||||
}
|
||||
|
||||
return '[MockFunction' + nameString + ']' + callsString;
|
||||
};
|
||||
|
||||
exports.serialize = serialize;
|
||||
|
||||
const test = val => val && !!val._isMockFunction;
|
||||
|
||||
exports.test = test;
|
||||
const plugin = {
|
||||
serialize,
|
||||
test
|
||||
};
|
||||
var _default = plugin;
|
||||
exports.default = _default;
|
9
node_modules/jest-snapshot/build/plugins.d.ts
generated
vendored
Normal file
9
node_modules/jest-snapshot/build/plugins.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 prettyFormat = require('pretty-format');
|
||||
export declare const addSerializer: (plugin: prettyFormat.Plugin) => void;
|
||||
export declare const getSerializers: () => import("pretty-format/build/types").Plugins;
|
48
node_modules/jest-snapshot/build/plugins.js
generated
vendored
Normal file
48
node_modules/jest-snapshot/build/plugins.js
generated
vendored
Normal file
@ -0,0 +1,48 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.getSerializers = exports.addSerializer = void 0;
|
||||
|
||||
var _prettyFormat = _interopRequireDefault(require('pretty-format'));
|
||||
|
||||
var _mockSerializer = _interopRequireDefault(require('./mockSerializer'));
|
||||
|
||||
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 {
|
||||
DOMCollection,
|
||||
DOMElement,
|
||||
Immutable,
|
||||
ReactElement,
|
||||
ReactTestComponent,
|
||||
AsymmetricMatcher
|
||||
} = _prettyFormat.default.plugins;
|
||||
let PLUGINS = [
|
||||
ReactTestComponent,
|
||||
ReactElement,
|
||||
DOMElement,
|
||||
DOMCollection,
|
||||
Immutable,
|
||||
_mockSerializer.default,
|
||||
AsymmetricMatcher
|
||||
]; // Prepend to list so the last added is the first tested.
|
||||
|
||||
const addSerializer = plugin => {
|
||||
PLUGINS = [plugin].concat(PLUGINS);
|
||||
};
|
||||
|
||||
exports.addSerializer = addSerializer;
|
||||
|
||||
const getSerializers = () => PLUGINS;
|
||||
|
||||
exports.getSerializers = getSerializers;
|
24
node_modules/jest-snapshot/build/printSnapshot.d.ts
generated
vendored
Normal file
24
node_modules/jest-snapshot/build/printSnapshot.d.ts
generated
vendored
Normal file
@ -0,0 +1,24 @@
|
||||
/**
|
||||
* 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 chalk = require('chalk');
|
||||
import { DiffOptionsColor } from 'jest-diff';
|
||||
import type { MatchSnapshotConfig } from './types';
|
||||
declare type Chalk = chalk.Chalk;
|
||||
export declare const getSnapshotColorForChalkInstance: (chalkInstance: Chalk) => DiffOptionsColor;
|
||||
export declare const getReceivedColorForChalkInstance: (chalkInstance: Chalk) => DiffOptionsColor;
|
||||
export declare const aSnapshotColor: DiffOptionsColor;
|
||||
export declare const bReceivedColor: DiffOptionsColor;
|
||||
export declare const noColor: (string: string) => string;
|
||||
export declare const HINT_ARG = "hint";
|
||||
export declare const SNAPSHOT_ARG = "snapshot";
|
||||
export declare const PROPERTIES_ARG = "properties";
|
||||
export declare const matcherHintFromConfig: ({ context: { isNot, promise }, hint, inlineSnapshot, matcherName, properties, }: MatchSnapshotConfig, isUpdatable: boolean) => string;
|
||||
export declare const printExpected: (val: unknown) => string;
|
||||
export declare const printReceived: (val: unknown) => string;
|
||||
export declare const printPropertiesAndReceived: (properties: object, received: object, expand: boolean) => string;
|
||||
export declare const printSnapshotAndReceived: (a: string, b: string, received: unknown, expand: boolean) => string;
|
||||
export {};
|
384
node_modules/jest-snapshot/build/printSnapshot.js
generated
vendored
Normal file
384
node_modules/jest-snapshot/build/printSnapshot.js
generated
vendored
Normal file
@ -0,0 +1,384 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.printSnapshotAndReceived = exports.printPropertiesAndReceived = exports.printReceived = exports.printExpected = exports.matcherHintFromConfig = exports.PROPERTIES_ARG = exports.SNAPSHOT_ARG = exports.HINT_ARG = exports.noColor = exports.bReceivedColor = exports.aSnapshotColor = exports.getReceivedColorForChalkInstance = exports.getSnapshotColorForChalkInstance = void 0;
|
||||
|
||||
var _chalk = _interopRequireDefault(require('chalk'));
|
||||
|
||||
var _utils = require('expect/build/utils');
|
||||
|
||||
var _jestDiff = require('jest-diff');
|
||||
|
||||
var _jestGetType = _interopRequireDefault(require('jest-get-type'));
|
||||
|
||||
var _jestMatcherUtils = require('jest-matcher-utils');
|
||||
|
||||
var _prettyFormat = _interopRequireDefault(require('pretty-format'));
|
||||
|
||||
var _colors = require('./colors');
|
||||
|
||||
var _dedentLines = require('./dedentLines');
|
||||
|
||||
var _utils2 = require('./utils');
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
/* eslint-disable local/ban-types-eventually */
|
||||
// Temporary hack because getObjectSubset has known limitations,
|
||||
// is not in the public interface of the expect package,
|
||||
// and the long-term goal is to use a non-serialization diff.
|
||||
const getSnapshotColorForChalkInstance = chalkInstance => {
|
||||
const level = chalkInstance.level;
|
||||
|
||||
if (level === 3) {
|
||||
return chalkInstance
|
||||
.rgb(
|
||||
_colors.aForeground3[0],
|
||||
_colors.aForeground3[1],
|
||||
_colors.aForeground3[2]
|
||||
)
|
||||
.bgRgb(
|
||||
_colors.aBackground3[0],
|
||||
_colors.aBackground3[1],
|
||||
_colors.aBackground3[2]
|
||||
);
|
||||
}
|
||||
|
||||
if (level === 2) {
|
||||
return chalkInstance
|
||||
.ansi256(_colors.aForeground2)
|
||||
.bgAnsi256(_colors.aBackground2);
|
||||
}
|
||||
|
||||
return chalkInstance.magenta.bgYellowBright;
|
||||
};
|
||||
|
||||
exports.getSnapshotColorForChalkInstance = getSnapshotColorForChalkInstance;
|
||||
|
||||
const getReceivedColorForChalkInstance = chalkInstance => {
|
||||
const level = chalkInstance.level;
|
||||
|
||||
if (level === 3) {
|
||||
return chalkInstance
|
||||
.rgb(
|
||||
_colors.bForeground3[0],
|
||||
_colors.bForeground3[1],
|
||||
_colors.bForeground3[2]
|
||||
)
|
||||
.bgRgb(
|
||||
_colors.bBackground3[0],
|
||||
_colors.bBackground3[1],
|
||||
_colors.bBackground3[2]
|
||||
);
|
||||
}
|
||||
|
||||
if (level === 2) {
|
||||
return chalkInstance
|
||||
.ansi256(_colors.bForeground2)
|
||||
.bgAnsi256(_colors.bBackground2);
|
||||
}
|
||||
|
||||
return chalkInstance.cyan.bgWhiteBright; // also known as teal
|
||||
};
|
||||
|
||||
exports.getReceivedColorForChalkInstance = getReceivedColorForChalkInstance;
|
||||
const aSnapshotColor = getSnapshotColorForChalkInstance(_chalk.default);
|
||||
exports.aSnapshotColor = aSnapshotColor;
|
||||
const bReceivedColor = getReceivedColorForChalkInstance(_chalk.default);
|
||||
exports.bReceivedColor = bReceivedColor;
|
||||
|
||||
const noColor = string => string;
|
||||
|
||||
exports.noColor = noColor;
|
||||
const HINT_ARG = 'hint';
|
||||
exports.HINT_ARG = HINT_ARG;
|
||||
const SNAPSHOT_ARG = 'snapshot';
|
||||
exports.SNAPSHOT_ARG = SNAPSHOT_ARG;
|
||||
const PROPERTIES_ARG = 'properties';
|
||||
exports.PROPERTIES_ARG = PROPERTIES_ARG;
|
||||
|
||||
const matcherHintFromConfig = (
|
||||
{context: {isNot, promise}, hint, inlineSnapshot, matcherName, properties},
|
||||
isUpdatable
|
||||
) => {
|
||||
const options = {
|
||||
isNot,
|
||||
promise
|
||||
};
|
||||
|
||||
if (isUpdatable) {
|
||||
options.receivedColor = bReceivedColor;
|
||||
}
|
||||
|
||||
let expectedArgument = '';
|
||||
|
||||
if (typeof properties === 'object') {
|
||||
expectedArgument = PROPERTIES_ARG;
|
||||
|
||||
if (isUpdatable) {
|
||||
options.expectedColor = noColor;
|
||||
}
|
||||
|
||||
if (typeof hint === 'string' && hint.length !== 0) {
|
||||
options.secondArgument = HINT_ARG;
|
||||
options.secondArgumentColor = _jestMatcherUtils.BOLD_WEIGHT;
|
||||
} else if (typeof inlineSnapshot === 'string') {
|
||||
options.secondArgument = SNAPSHOT_ARG;
|
||||
|
||||
if (isUpdatable) {
|
||||
options.secondArgumentColor = aSnapshotColor;
|
||||
} else {
|
||||
options.secondArgumentColor = noColor;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (typeof hint === 'string' && hint.length !== 0) {
|
||||
expectedArgument = HINT_ARG;
|
||||
options.expectedColor = _jestMatcherUtils.BOLD_WEIGHT;
|
||||
} else if (typeof inlineSnapshot === 'string') {
|
||||
expectedArgument = SNAPSHOT_ARG;
|
||||
|
||||
if (isUpdatable) {
|
||||
options.expectedColor = aSnapshotColor;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return (0, _jestMatcherUtils.matcherHint)(
|
||||
matcherName,
|
||||
undefined,
|
||||
expectedArgument,
|
||||
options
|
||||
);
|
||||
}; // Given array of diffs, return string:
|
||||
// * include common substrings
|
||||
// * exclude change substrings which have opposite op
|
||||
// * include change substrings which have argument op
|
||||
// with change color only if there is a common substring
|
||||
|
||||
exports.matcherHintFromConfig = matcherHintFromConfig;
|
||||
|
||||
const joinDiffs = (diffs, op, hasCommon) =>
|
||||
diffs.reduce(
|
||||
(reduced, diff) =>
|
||||
reduced +
|
||||
(diff[0] === _jestDiff.DIFF_EQUAL
|
||||
? diff[1]
|
||||
: diff[0] !== op
|
||||
? ''
|
||||
: hasCommon
|
||||
? (0, _jestMatcherUtils.INVERTED_COLOR)(diff[1])
|
||||
: diff[1]),
|
||||
''
|
||||
);
|
||||
|
||||
const isLineDiffable = received => {
|
||||
const receivedType = (0, _jestGetType.default)(received);
|
||||
|
||||
if (_jestGetType.default.isPrimitive(received)) {
|
||||
return typeof received === 'string';
|
||||
}
|
||||
|
||||
if (
|
||||
receivedType === 'date' ||
|
||||
receivedType === 'function' ||
|
||||
receivedType === 'regexp'
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (received instanceof Error) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (
|
||||
receivedType === 'object' &&
|
||||
typeof received.asymmetricMatch === 'function'
|
||||
) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
const printExpected = val =>
|
||||
(0, _jestMatcherUtils.EXPECTED_COLOR)((0, _utils2.minify)(val));
|
||||
|
||||
exports.printExpected = printExpected;
|
||||
|
||||
const printReceived = val =>
|
||||
(0, _jestMatcherUtils.RECEIVED_COLOR)((0, _utils2.minify)(val));
|
||||
|
||||
exports.printReceived = printReceived;
|
||||
|
||||
const printPropertiesAndReceived = (properties, received, expand) => {
|
||||
const aAnnotation = 'Expected properties';
|
||||
const bAnnotation = 'Received value';
|
||||
|
||||
if (isLineDiffable(properties) && isLineDiffable(received)) {
|
||||
return (0, _jestDiff.diffLinesUnified)(
|
||||
(0, _utils2.serialize)(properties).split('\n'),
|
||||
(0, _utils2.serialize)(
|
||||
(0, _utils.getObjectSubset)(received, properties)
|
||||
).split('\n'),
|
||||
{
|
||||
aAnnotation,
|
||||
aColor: _jestMatcherUtils.EXPECTED_COLOR,
|
||||
bAnnotation,
|
||||
bColor: _jestMatcherUtils.RECEIVED_COLOR,
|
||||
changeLineTrailingSpaceColor: _chalk.default.bgYellow,
|
||||
commonLineTrailingSpaceColor: _chalk.default.bgYellow,
|
||||
emptyFirstOrLastLinePlaceholder: '↵',
|
||||
// U+21B5
|
||||
expand,
|
||||
includeChangeCounts: true
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
const printLabel = (0, _jestMatcherUtils.getLabelPrinter)(
|
||||
aAnnotation,
|
||||
bAnnotation
|
||||
);
|
||||
return (
|
||||
printLabel(aAnnotation) +
|
||||
printExpected(properties) +
|
||||
'\n' +
|
||||
printLabel(bAnnotation) +
|
||||
printReceived(received)
|
||||
);
|
||||
};
|
||||
|
||||
exports.printPropertiesAndReceived = printPropertiesAndReceived;
|
||||
const MAX_DIFF_STRING_LENGTH = 20000;
|
||||
|
||||
const printSnapshotAndReceived = (a, b, received, expand) => {
|
||||
const aAnnotation = 'Snapshot';
|
||||
const bAnnotation = 'Received';
|
||||
const aColor = aSnapshotColor;
|
||||
const bColor = bReceivedColor;
|
||||
const options = {
|
||||
aAnnotation,
|
||||
aColor,
|
||||
bAnnotation,
|
||||
bColor,
|
||||
changeLineTrailingSpaceColor: noColor,
|
||||
commonLineTrailingSpaceColor: _chalk.default.bgYellow,
|
||||
emptyFirstOrLastLinePlaceholder: '↵',
|
||||
// U+21B5
|
||||
expand,
|
||||
includeChangeCounts: true
|
||||
};
|
||||
|
||||
if (typeof received === 'string') {
|
||||
if (
|
||||
a.length >= 2 &&
|
||||
a.startsWith('"') &&
|
||||
a.endsWith('"') &&
|
||||
b === (0, _prettyFormat.default)(received)
|
||||
) {
|
||||
// If snapshot looks like default serialization of a string
|
||||
// and received is string which has default serialization.
|
||||
if (!a.includes('\n') && !b.includes('\n')) {
|
||||
// If neither string is multiline,
|
||||
// display as labels and quoted strings.
|
||||
let aQuoted = a;
|
||||
let bQuoted = b;
|
||||
|
||||
if (
|
||||
a.length - 2 <= MAX_DIFF_STRING_LENGTH &&
|
||||
b.length - 2 <= MAX_DIFF_STRING_LENGTH
|
||||
) {
|
||||
const diffs = (0, _jestDiff.diffStringsRaw)(
|
||||
a.slice(1, -1),
|
||||
b.slice(1, -1),
|
||||
true
|
||||
);
|
||||
const hasCommon = diffs.some(
|
||||
diff => diff[0] === _jestDiff.DIFF_EQUAL
|
||||
);
|
||||
aQuoted =
|
||||
'"' + joinDiffs(diffs, _jestDiff.DIFF_DELETE, hasCommon) + '"';
|
||||
bQuoted =
|
||||
'"' + joinDiffs(diffs, _jestDiff.DIFF_INSERT, hasCommon) + '"';
|
||||
}
|
||||
|
||||
const printLabel = (0, _jestMatcherUtils.getLabelPrinter)(
|
||||
aAnnotation,
|
||||
bAnnotation
|
||||
);
|
||||
return (
|
||||
printLabel(aAnnotation) +
|
||||
aColor(aQuoted) +
|
||||
'\n' +
|
||||
printLabel(bAnnotation) +
|
||||
bColor(bQuoted)
|
||||
);
|
||||
} // Else either string is multiline, so display as unquoted strings.
|
||||
|
||||
a = (0, _utils2.deserializeString)(a); // hypothetical expected string
|
||||
|
||||
b = received; // not serialized
|
||||
} // Else expected had custom serialization or was not a string
|
||||
// or received has custom serialization.
|
||||
|
||||
return a.length <= MAX_DIFF_STRING_LENGTH &&
|
||||
b.length <= MAX_DIFF_STRING_LENGTH
|
||||
? (0, _jestDiff.diffStringsUnified)(a, b, options)
|
||||
: (0, _jestDiff.diffLinesUnified)(a.split('\n'), b.split('\n'), options);
|
||||
}
|
||||
|
||||
if (isLineDiffable(received)) {
|
||||
const aLines2 = a.split('\n');
|
||||
const bLines2 = b.split('\n'); // Fall through to fix a regression for custom serializers
|
||||
// like jest-snapshot-serializer-raw that ignore the indent option.
|
||||
|
||||
const b0 = (0, _utils2.serialize)(received, 0);
|
||||
|
||||
if (b0 !== b) {
|
||||
const aLines0 = (0, _dedentLines.dedentLines)(aLines2);
|
||||
|
||||
if (aLines0 !== null) {
|
||||
// Compare lines without indentation.
|
||||
const bLines0 = b0.split('\n');
|
||||
return (0, _jestDiff.diffLinesUnified2)(
|
||||
aLines2,
|
||||
bLines2,
|
||||
aLines0,
|
||||
bLines0,
|
||||
options
|
||||
);
|
||||
}
|
||||
} // Fall back because:
|
||||
// * props include a multiline string
|
||||
// * text has more than one adjacent line
|
||||
// * markup does not close
|
||||
|
||||
return (0, _jestDiff.diffLinesUnified)(aLines2, bLines2, options);
|
||||
}
|
||||
|
||||
const printLabel = (0, _jestMatcherUtils.getLabelPrinter)(
|
||||
aAnnotation,
|
||||
bAnnotation
|
||||
);
|
||||
return (
|
||||
printLabel(aAnnotation) +
|
||||
aColor(a) +
|
||||
'\n' +
|
||||
printLabel(bAnnotation) +
|
||||
bColor(b)
|
||||
);
|
||||
};
|
||||
|
||||
exports.printSnapshotAndReceived = printSnapshotAndReceived;
|
27
node_modules/jest-snapshot/build/types.d.ts
generated
vendored
Normal file
27
node_modules/jest-snapshot/build/types.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 { MatcherState } from 'expect';
|
||||
import type SnapshotState from './State';
|
||||
export declare type Context = MatcherState & {
|
||||
snapshotState: SnapshotState;
|
||||
};
|
||||
export declare type MatchSnapshotConfig = {
|
||||
context: Context;
|
||||
hint?: string;
|
||||
inlineSnapshot?: string;
|
||||
isInline: boolean;
|
||||
matcherName: string;
|
||||
properties?: object;
|
||||
received: any;
|
||||
};
|
||||
export declare type SnapshotData = Record<string, string>;
|
||||
export declare type ExpectationResult = {
|
||||
pass: boolean;
|
||||
message: () => string;
|
||||
};
|
||||
export declare type BabelTraverse = typeof import('@babel/traverse').default;
|
||||
export declare type Prettier = typeof import('prettier');
|
1
node_modules/jest-snapshot/build/types.js
generated
vendored
Normal file
1
node_modules/jest-snapshot/build/types.js
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
'use strict';
|
27
node_modules/jest-snapshot/build/utils.d.ts
generated
vendored
Normal file
27
node_modules/jest-snapshot/build/utils.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 { SnapshotData } from './types';
|
||||
export declare const SNAPSHOT_VERSION = "1";
|
||||
export declare const SNAPSHOT_GUIDE_LINK = "https://goo.gl/fbAQLP";
|
||||
export declare const SNAPSHOT_VERSION_WARNING: string;
|
||||
export declare const testNameToKey: (testName: Config.Path, count: number) => string;
|
||||
export declare const keyToTestName: (key: string) => string;
|
||||
export declare const getSnapshotData: (snapshotPath: Config.Path, update: Config.SnapshotUpdateState) => {
|
||||
data: SnapshotData;
|
||||
dirty: boolean;
|
||||
};
|
||||
export declare const addExtraLineBreaks: (string: string) => string;
|
||||
export declare const removeExtraLineBreaks: (string: string) => string;
|
||||
export declare const removeLinesBeforeExternalMatcherTrap: (stack: string) => string;
|
||||
export declare const serialize: (val: unknown, indent?: number) => string;
|
||||
export declare const minify: (val: unknown) => string;
|
||||
export declare const deserializeString: (stringified: string) => string;
|
||||
export declare const escapeBacktickString: (str: string) => string;
|
||||
export declare const ensureDirectoryExists: (filePath: Config.Path) => void;
|
||||
export declare const saveSnapshotFile: (snapshotData: SnapshotData, snapshotPath: Config.Path) => void;
|
||||
export declare const deepMerge: (target: any, source: any) => any;
|
338
node_modules/jest-snapshot/build/utils.js
generated
vendored
Normal file
338
node_modules/jest-snapshot/build/utils.js
generated
vendored
Normal file
@ -0,0 +1,338 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.deepMerge = exports.saveSnapshotFile = exports.ensureDirectoryExists = exports.escapeBacktickString = exports.deserializeString = exports.minify = exports.serialize = exports.removeLinesBeforeExternalMatcherTrap = exports.removeExtraLineBreaks = exports.addExtraLineBreaks = exports.getSnapshotData = exports.keyToTestName = exports.testNameToKey = exports.SNAPSHOT_VERSION_WARNING = exports.SNAPSHOT_GUIDE_LINK = exports.SNAPSHOT_VERSION = void 0;
|
||||
|
||||
var path = _interopRequireWildcard(require('path'));
|
||||
|
||||
var _chalk = _interopRequireDefault(require('chalk'));
|
||||
|
||||
var fs = _interopRequireWildcard(require('graceful-fs'));
|
||||
|
||||
var _naturalCompare = _interopRequireDefault(require('natural-compare'));
|
||||
|
||||
var _prettyFormat = _interopRequireDefault(require('pretty-format'));
|
||||
|
||||
var _plugins = require('./plugins');
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var jestWriteFile =
|
||||
global[Symbol.for('jest-native-write-file')] || fs.writeFileSync;
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var jestReadFile =
|
||||
global[Symbol.for('jest-native-read-file')] || fs.readFileSync;
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
var jestExistsFile =
|
||||
global[Symbol.for('jest-native-exists-file')] || fs.existsSync;
|
||||
const SNAPSHOT_VERSION = '1';
|
||||
exports.SNAPSHOT_VERSION = SNAPSHOT_VERSION;
|
||||
const SNAPSHOT_VERSION_REGEXP = /^\/\/ Jest Snapshot v(.+),/;
|
||||
const SNAPSHOT_GUIDE_LINK = 'https://goo.gl/fbAQLP';
|
||||
exports.SNAPSHOT_GUIDE_LINK = SNAPSHOT_GUIDE_LINK;
|
||||
|
||||
const SNAPSHOT_VERSION_WARNING = _chalk.default.yellow(
|
||||
`${_chalk.default.bold('Warning')}: Before you upgrade snapshots, ` +
|
||||
`we recommend that you revert any local changes to tests or other code, ` +
|
||||
`to ensure that you do not store invalid state.`
|
||||
);
|
||||
|
||||
exports.SNAPSHOT_VERSION_WARNING = SNAPSHOT_VERSION_WARNING;
|
||||
|
||||
const writeSnapshotVersion = () =>
|
||||
`// Jest Snapshot v${SNAPSHOT_VERSION}, ${SNAPSHOT_GUIDE_LINK}`;
|
||||
|
||||
const validateSnapshotVersion = snapshotContents => {
|
||||
const versionTest = SNAPSHOT_VERSION_REGEXP.exec(snapshotContents);
|
||||
const version = versionTest && versionTest[1];
|
||||
|
||||
if (!version) {
|
||||
return new Error(
|
||||
_chalk.default.red(
|
||||
`${_chalk.default.bold(
|
||||
'Outdated snapshot'
|
||||
)}: No snapshot header found. ` +
|
||||
`Jest 19 introduced versioned snapshots to ensure all developers ` +
|
||||
`on a project are using the same version of Jest. ` +
|
||||
`Please update all snapshots during this upgrade of Jest.\n\n`
|
||||
) + SNAPSHOT_VERSION_WARNING
|
||||
);
|
||||
}
|
||||
|
||||
if (version < SNAPSHOT_VERSION) {
|
||||
return new Error(
|
||||
_chalk.default.red(
|
||||
`${_chalk.default.red.bold(
|
||||
'Outdated snapshot'
|
||||
)}: The version of the snapshot ` +
|
||||
`file associated with this test is outdated. The snapshot file ` +
|
||||
`version ensures that all developers on a project are using ` +
|
||||
`the same version of Jest. ` +
|
||||
`Please update all snapshots during this upgrade of Jest.\n\n`
|
||||
) +
|
||||
`Expected: v${SNAPSHOT_VERSION}\n` +
|
||||
`Received: v${version}\n\n` +
|
||||
SNAPSHOT_VERSION_WARNING
|
||||
);
|
||||
}
|
||||
|
||||
if (version > SNAPSHOT_VERSION) {
|
||||
return new Error(
|
||||
_chalk.default.red(
|
||||
`${_chalk.default.red.bold(
|
||||
'Outdated Jest version'
|
||||
)}: The version of this ` +
|
||||
`snapshot file indicates that this project is meant to be used ` +
|
||||
`with a newer version of Jest. The snapshot file version ensures ` +
|
||||
`that all developers on a project are using the same version of ` +
|
||||
`Jest. Please update your version of Jest and re-run the tests.\n\n`
|
||||
) +
|
||||
`Expected: v${SNAPSHOT_VERSION}\n` +
|
||||
`Received: v${version}`
|
||||
);
|
||||
}
|
||||
|
||||
return null;
|
||||
};
|
||||
|
||||
function isObject(item) {
|
||||
return item && typeof item === 'object' && !Array.isArray(item);
|
||||
}
|
||||
|
||||
const testNameToKey = (testName, count) => testName + ' ' + count;
|
||||
|
||||
exports.testNameToKey = testNameToKey;
|
||||
|
||||
const keyToTestName = key => {
|
||||
if (!/ \d+$/.test(key)) {
|
||||
throw new Error('Snapshot keys must end with a number.');
|
||||
}
|
||||
|
||||
return key.replace(/ \d+$/, '');
|
||||
};
|
||||
|
||||
exports.keyToTestName = keyToTestName;
|
||||
|
||||
const getSnapshotData = (snapshotPath, update) => {
|
||||
const data = Object.create(null);
|
||||
let snapshotContents = '';
|
||||
let dirty = false;
|
||||
|
||||
if (jestExistsFile(snapshotPath)) {
|
||||
try {
|
||||
snapshotContents = jestReadFile(snapshotPath, 'utf8'); // eslint-disable-next-line no-new-func
|
||||
|
||||
const populate = new Function('exports', snapshotContents);
|
||||
populate(data);
|
||||
} catch {}
|
||||
}
|
||||
|
||||
const validationResult = validateSnapshotVersion(snapshotContents);
|
||||
const isInvalid = snapshotContents && validationResult;
|
||||
|
||||
if (update === 'none' && isInvalid) {
|
||||
throw validationResult;
|
||||
}
|
||||
|
||||
if ((update === 'all' || update === 'new') && isInvalid) {
|
||||
dirty = true;
|
||||
}
|
||||
|
||||
return {
|
||||
data,
|
||||
dirty
|
||||
};
|
||||
}; // Add extra line breaks at beginning and end of multiline snapshot
|
||||
// to make the content easier to read.
|
||||
|
||||
exports.getSnapshotData = getSnapshotData;
|
||||
|
||||
const addExtraLineBreaks = string =>
|
||||
string.includes('\n') ? `\n${string}\n` : string; // Remove extra line breaks at beginning and end of multiline snapshot.
|
||||
// Instead of trim, which can remove additional newlines or spaces
|
||||
// at beginning or end of the content from a custom serializer.
|
||||
|
||||
exports.addExtraLineBreaks = addExtraLineBreaks;
|
||||
|
||||
const removeExtraLineBreaks = string =>
|
||||
string.length > 2 && string.startsWith('\n') && string.endsWith('\n')
|
||||
? string.slice(1, -1)
|
||||
: string;
|
||||
|
||||
exports.removeExtraLineBreaks = removeExtraLineBreaks;
|
||||
|
||||
const removeLinesBeforeExternalMatcherTrap = stack => {
|
||||
const lines = stack.split('\n');
|
||||
|
||||
for (let i = 0; i < lines.length; i += 1) {
|
||||
// It's a function name specified in `packages/expect/src/index.ts`
|
||||
// for external custom matchers.
|
||||
if (lines[i].includes('__EXTERNAL_MATCHER_TRAP__')) {
|
||||
return lines.slice(i + 1).join('\n');
|
||||
}
|
||||
}
|
||||
|
||||
return stack;
|
||||
};
|
||||
|
||||
exports.removeLinesBeforeExternalMatcherTrap = removeLinesBeforeExternalMatcherTrap;
|
||||
const escapeRegex = true;
|
||||
const printFunctionName = false;
|
||||
|
||||
const serialize = (val, indent = 2) =>
|
||||
normalizeNewlines(
|
||||
(0, _prettyFormat.default)(val, {
|
||||
escapeRegex,
|
||||
indent,
|
||||
plugins: (0, _plugins.getSerializers)(),
|
||||
printFunctionName
|
||||
})
|
||||
);
|
||||
|
||||
exports.serialize = serialize;
|
||||
|
||||
const minify = val =>
|
||||
(0, _prettyFormat.default)(val, {
|
||||
escapeRegex,
|
||||
min: true,
|
||||
plugins: (0, _plugins.getSerializers)(),
|
||||
printFunctionName
|
||||
}); // Remove double quote marks and unescape double quotes and backslashes.
|
||||
|
||||
exports.minify = minify;
|
||||
|
||||
const deserializeString = stringified =>
|
||||
stringified.slice(1, -1).replace(/\\("|\\)/g, '$1');
|
||||
|
||||
exports.deserializeString = deserializeString;
|
||||
|
||||
const escapeBacktickString = str => str.replace(/`|\\|\${/g, '\\$&');
|
||||
|
||||
exports.escapeBacktickString = escapeBacktickString;
|
||||
|
||||
const printBacktickString = str => '`' + escapeBacktickString(str) + '`';
|
||||
|
||||
const ensureDirectoryExists = filePath => {
|
||||
try {
|
||||
fs.mkdirSync(path.join(path.dirname(filePath)), {
|
||||
recursive: true
|
||||
});
|
||||
} catch {}
|
||||
};
|
||||
|
||||
exports.ensureDirectoryExists = ensureDirectoryExists;
|
||||
|
||||
const normalizeNewlines = string => string.replace(/\r\n|\r/g, '\n');
|
||||
|
||||
const saveSnapshotFile = (snapshotData, snapshotPath) => {
|
||||
const snapshots = Object.keys(snapshotData)
|
||||
.sort(_naturalCompare.default)
|
||||
.map(
|
||||
key =>
|
||||
'exports[' +
|
||||
printBacktickString(key) +
|
||||
'] = ' +
|
||||
printBacktickString(normalizeNewlines(snapshotData[key])) +
|
||||
';'
|
||||
);
|
||||
ensureDirectoryExists(snapshotPath);
|
||||
jestWriteFile(
|
||||
snapshotPath,
|
||||
writeSnapshotVersion() + '\n\n' + snapshots.join('\n\n') + '\n'
|
||||
);
|
||||
};
|
||||
|
||||
exports.saveSnapshotFile = saveSnapshotFile;
|
||||
|
||||
const deepMergeArray = (target, source) => {
|
||||
const mergedOutput = Array.from(target);
|
||||
source.forEach((sourceElement, index) => {
|
||||
const targetElement = mergedOutput[index];
|
||||
|
||||
if (Array.isArray(target[index])) {
|
||||
mergedOutput[index] = deepMergeArray(target[index], sourceElement);
|
||||
} else if (isObject(targetElement)) {
|
||||
mergedOutput[index] = deepMerge(target[index], sourceElement);
|
||||
} else {
|
||||
// Source does not exist in target or target is primitive and cannot be deep merged
|
||||
mergedOutput[index] = sourceElement;
|
||||
}
|
||||
});
|
||||
return mergedOutput;
|
||||
}; // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
|
||||
|
||||
const deepMerge = (target, source) => {
|
||||
if (isObject(target) && isObject(source)) {
|
||||
const mergedOutput = {...target};
|
||||
Object.keys(source).forEach(key => {
|
||||
if (isObject(source[key]) && !source[key].$$typeof) {
|
||||
if (!(key in target))
|
||||
Object.assign(mergedOutput, {
|
||||
[key]: source[key]
|
||||
});
|
||||
else mergedOutput[key] = deepMerge(target[key], source[key]);
|
||||
} else if (Array.isArray(source[key])) {
|
||||
mergedOutput[key] = deepMergeArray(target[key], source[key]);
|
||||
} else {
|
||||
Object.assign(mergedOutput, {
|
||||
[key]: source[key]
|
||||
});
|
||||
}
|
||||
});
|
||||
return mergedOutput;
|
||||
} else if (Array.isArray(target) && Array.isArray(source)) {
|
||||
return deepMergeArray(target, source);
|
||||
}
|
||||
|
||||
return target;
|
||||
};
|
||||
|
||||
exports.deepMerge = deepMerge;
|
21
node_modules/jest-snapshot/node_modules/diff-sequences/LICENSE
generated
vendored
Normal file
21
node_modules/jest-snapshot/node_modules/diff-sequences/LICENSE
generated
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) Facebook, Inc. and its affiliates.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
404
node_modules/jest-snapshot/node_modules/diff-sequences/README.md
generated
vendored
Normal file
404
node_modules/jest-snapshot/node_modules/diff-sequences/README.md
generated
vendored
Normal file
@ -0,0 +1,404 @@
|
||||
# diff-sequences
|
||||
|
||||
Compare items in two sequences to find a **longest common subsequence**.
|
||||
|
||||
The items not in common are the items to delete or insert in a **shortest edit script**.
|
||||
|
||||
To maximize flexibility and minimize memory, you write **callback** functions as configuration:
|
||||
|
||||
**Input** function `isCommon(aIndex, bIndex)` compares items at indexes in the sequences and returns a truthy/falsey value. This package might call your function more than once for some pairs of indexes.
|
||||
|
||||
- Because your function encapsulates **comparison**, this package can compare items according to `===` operator, `Object.is` method, or other criterion.
|
||||
- Because your function encapsulates **sequences**, this package can find differences in arrays, strings, or other data.
|
||||
|
||||
**Output** function `foundSubsequence(nCommon, aCommon, bCommon)` receives the number of adjacent items and starting indexes of each common subsequence. If sequences do not have common items, then this package does not call your function.
|
||||
|
||||
If N is the sum of lengths of sequences and L is length of a longest common subsequence, then D = N – 2L is the number of **differences** in the corresponding shortest edit script.
|
||||
|
||||
[_An O(ND) Difference Algorithm and Its Variations_](http://xmailserver.org/diff2.pdf) by Eugene W. Myers is fast when sequences have **few** differences.
|
||||
|
||||
This package implements the **linear space** variation with optimizations so it is fast even when sequences have **many** differences.
|
||||
|
||||
## Usage
|
||||
|
||||
To add this package as a dependency of a project, do either of the following:
|
||||
|
||||
- `npm install diff-sequences`
|
||||
- `yarn add diff-sequences`
|
||||
|
||||
To use `diff` as the name of the default export from this package, do either of the following:
|
||||
|
||||
- `var diff = require('diff-sequences').default; // CommonJS modules`
|
||||
- `import diff from 'diff-sequences'; // ECMAScript modules`
|
||||
|
||||
Call `diff` with the **lengths** of sequences and your **callback** functions:
|
||||
|
||||
```js
|
||||
const a = ['a', 'b', 'c', 'a', 'b', 'b', 'a'];
|
||||
const b = ['c', 'b', 'a', 'b', 'a', 'c'];
|
||||
|
||||
function isCommon(aIndex, bIndex) {
|
||||
return a[aIndex] === b[bIndex];
|
||||
}
|
||||
function foundSubsequence(nCommon, aCommon, bCommon) {
|
||||
// see examples
|
||||
}
|
||||
|
||||
diff(a.length, b.length, isCommon, foundSubsequence);
|
||||
```
|
||||
|
||||
## Example of longest common subsequence
|
||||
|
||||
Some sequences (for example, `a` and `b` in the example of usage) have more than one longest common subsequence.
|
||||
|
||||
This package finds the following common items:
|
||||
|
||||
| comparisons of common items | values | output arguments |
|
||||
| :------------------------------- | :--------- | --------------------------: |
|
||||
| `a[2] === b[0]` | `'c'` | `foundSubsequence(1, 2, 0)` |
|
||||
| `a[4] === b[1]` | `'b'` | `foundSubsequence(1, 4, 1)` |
|
||||
| `a[5] === b[3] && a[6] === b[4]` | `'b', 'a'` | `foundSubsequence(2, 5, 3)` |
|
||||
|
||||
The “edit graph” analogy in the Myers paper shows the following common items:
|
||||
|
||||
| comparisons of common items | values |
|
||||
| :------------------------------- | :--------- |
|
||||
| `a[2] === b[0]` | `'c'` |
|
||||
| `a[3] === b[2] && a[4] === b[3]` | `'a', 'b'` |
|
||||
| `a[6] === b[4]` | `'a'` |
|
||||
|
||||
Various packages which implement the Myers algorithm will **always agree** on the **length** of a longest common subsequence, but might **sometimes disagree** on which **items** are in it.
|
||||
|
||||
## Example of callback functions to count common items
|
||||
|
||||
```js
|
||||
// Return length of longest common subsequence according to === operator.
|
||||
function countCommonItems(a, b) {
|
||||
let n = 0;
|
||||
function isCommon(aIndex, bIndex) {
|
||||
return a[aIndex] === b[bIndex];
|
||||
}
|
||||
function foundSubsequence(nCommon) {
|
||||
n += nCommon;
|
||||
}
|
||||
|
||||
diff(a.length, b.length, isCommon, foundSubsequence);
|
||||
|
||||
return n;
|
||||
}
|
||||
|
||||
const commonLength = countCommonItems(
|
||||
['a', 'b', 'c', 'a', 'b', 'b', 'a'],
|
||||
['c', 'b', 'a', 'b', 'a', 'c'],
|
||||
);
|
||||
```
|
||||
|
||||
| category of items | expression | value |
|
||||
| :----------------- | ------------------------: | ----: |
|
||||
| in common | `commonLength` | `4` |
|
||||
| to delete from `a` | `a.length - commonLength` | `3` |
|
||||
| to insert from `b` | `b.length - commonLength` | `2` |
|
||||
|
||||
If the length difference `b.length - a.length` is:
|
||||
|
||||
- negative: its absolute value is the minimum number of items to **delete** from `a`
|
||||
- positive: it is the minimum number of items to **insert** from `b`
|
||||
- zero: there is an **equal** number of items to delete from `a` and insert from `b`
|
||||
- non-zero: there is an equal number of **additional** items to delete from `a` and insert from `b`
|
||||
|
||||
In this example, `6 - 7` is:
|
||||
|
||||
- negative: `1` is the minimum number of items to **delete** from `a`
|
||||
- non-zero: `2` is the number of **additional** items to delete from `a` and insert from `b`
|
||||
|
||||
## Example of callback functions to find common items
|
||||
|
||||
```js
|
||||
// Return array of items in longest common subsequence according to Object.is method.
|
||||
const findCommonItems = (a, b) => {
|
||||
const array = [];
|
||||
diff(
|
||||
a.length,
|
||||
b.length,
|
||||
(aIndex, bIndex) => Object.is(a[aIndex], b[bIndex]),
|
||||
(nCommon, aCommon) => {
|
||||
for (; nCommon !== 0; nCommon -= 1, aCommon += 1) {
|
||||
array.push(a[aCommon]);
|
||||
}
|
||||
},
|
||||
);
|
||||
return array;
|
||||
};
|
||||
|
||||
const commonItems = findCommonItems(
|
||||
['a', 'b', 'c', 'a', 'b', 'b', 'a'],
|
||||
['c', 'b', 'a', 'b', 'a', 'c'],
|
||||
);
|
||||
```
|
||||
|
||||
| `i` | `commonItems[i]` | `aIndex` |
|
||||
| --: | :--------------- | -------: |
|
||||
| `0` | `'c'` | `2` |
|
||||
| `1` | `'b'` | `4` |
|
||||
| `2` | `'b'` | `5` |
|
||||
| `3` | `'a'` | `6` |
|
||||
|
||||
## Example of callback functions to diff index intervals
|
||||
|
||||
Instead of slicing array-like objects, you can adjust indexes in your callback functions.
|
||||
|
||||
```js
|
||||
// Diff index intervals that are half open [start, end) like array slice method.
|
||||
const diffIndexIntervals = (a, aStart, aEnd, b, bStart, bEnd) => {
|
||||
// Validate: 0 <= aStart and aStart <= aEnd and aEnd <= a.length
|
||||
// Validate: 0 <= bStart and bStart <= bEnd and bEnd <= b.length
|
||||
|
||||
diff(
|
||||
aEnd - aStart,
|
||||
bEnd - bStart,
|
||||
(aIndex, bIndex) => Object.is(a[aStart + aIndex], b[bStart + bIndex]),
|
||||
(nCommon, aCommon, bCommon) => {
|
||||
// aStart + aCommon, bStart + bCommon
|
||||
},
|
||||
);
|
||||
|
||||
// After the last common subsequence, do any remaining work.
|
||||
};
|
||||
```
|
||||
|
||||
## Example of callback functions to emulate diff command
|
||||
|
||||
Linux or Unix has a `diff` command to compare files line by line. Its output is a **shortest edit script**:
|
||||
|
||||
- **c**hange adjacent lines from the first file to lines from the second file
|
||||
- **d**elete lines from the first file
|
||||
- **a**ppend or insert lines from the second file
|
||||
|
||||
```js
|
||||
// Given zero-based half-open range [start, end) of array indexes,
|
||||
// return one-based closed range [start + 1, end] as string.
|
||||
const getRange = (start, end) =>
|
||||
start + 1 === end ? `${start + 1}` : `${start + 1},${end}`;
|
||||
|
||||
// Given index intervals of lines to delete or insert, or both, or neither,
|
||||
// push formatted diff lines onto array.
|
||||
const pushDelIns = (aLines, aIndex, aEnd, bLines, bIndex, bEnd, array) => {
|
||||
const deleteLines = aIndex !== aEnd;
|
||||
const insertLines = bIndex !== bEnd;
|
||||
const changeLines = deleteLines && insertLines;
|
||||
if (changeLines) {
|
||||
array.push(getRange(aIndex, aEnd) + 'c' + getRange(bIndex, bEnd));
|
||||
} else if (deleteLines) {
|
||||
array.push(getRange(aIndex, aEnd) + 'd' + String(bIndex));
|
||||
} else if (insertLines) {
|
||||
array.push(String(aIndex) + 'a' + getRange(bIndex, bEnd));
|
||||
} else {
|
||||
return;
|
||||
}
|
||||
|
||||
for (; aIndex !== aEnd; aIndex += 1) {
|
||||
array.push('< ' + aLines[aIndex]); // delete is less than
|
||||
}
|
||||
|
||||
if (changeLines) {
|
||||
array.push('---');
|
||||
}
|
||||
|
||||
for (; bIndex !== bEnd; bIndex += 1) {
|
||||
array.push('> ' + bLines[bIndex]); // insert is greater than
|
||||
}
|
||||
};
|
||||
|
||||
// Given content of two files, return emulated output of diff utility.
|
||||
const findShortestEditScript = (a, b) => {
|
||||
const aLines = a.split('\n');
|
||||
const bLines = b.split('\n');
|
||||
const aLength = aLines.length;
|
||||
const bLength = bLines.length;
|
||||
|
||||
const isCommon = (aIndex, bIndex) => aLines[aIndex] === bLines[bIndex];
|
||||
|
||||
let aIndex = 0;
|
||||
let bIndex = 0;
|
||||
const array = [];
|
||||
const foundSubsequence = (nCommon, aCommon, bCommon) => {
|
||||
pushDelIns(aLines, aIndex, aCommon, bLines, bIndex, bCommon, array);
|
||||
aIndex = aCommon + nCommon; // number of lines compared in a
|
||||
bIndex = bCommon + nCommon; // number of lines compared in b
|
||||
};
|
||||
|
||||
diff(aLength, bLength, isCommon, foundSubsequence);
|
||||
|
||||
// After the last common subsequence, push remaining change lines.
|
||||
pushDelIns(aLines, aIndex, aLength, bLines, bIndex, bLength, array);
|
||||
|
||||
return array.length === 0 ? '' : array.join('\n') + '\n';
|
||||
};
|
||||
```
|
||||
|
||||
## Example of callback functions to format diff lines
|
||||
|
||||
Here is simplified code to format **changed and unchanged lines** in expected and received values after a test fails in Jest:
|
||||
|
||||
```js
|
||||
// Format diff with minus or plus for change lines and space for common lines.
|
||||
const formatDiffLines = (a, b) => {
|
||||
// Jest depends on pretty-format package to serialize objects as strings.
|
||||
// Unindented for comparison to avoid distracting differences:
|
||||
const aLinesUn = format(a, {indent: 0 /*, other options*/}).split('\n');
|
||||
const bLinesUn = format(b, {indent: 0 /*, other options*/}).split('\n');
|
||||
// Indented to display changed and unchanged lines:
|
||||
const aLinesIn = format(a, {indent: 2 /*, other options*/}).split('\n');
|
||||
const bLinesIn = format(b, {indent: 2 /*, other options*/}).split('\n');
|
||||
|
||||
const aLength = aLinesIn.length; // Validate: aLinesUn.length === aLength
|
||||
const bLength = bLinesIn.length; // Validate: bLinesUn.length === bLength
|
||||
|
||||
const isCommon = (aIndex, bIndex) => aLinesUn[aIndex] === bLinesUn[bIndex];
|
||||
|
||||
// Only because the GitHub Flavored Markdown doc collapses adjacent spaces,
|
||||
// this example code and the following table represent spaces as middle dots.
|
||||
let aIndex = 0;
|
||||
let bIndex = 0;
|
||||
const array = [];
|
||||
const foundSubsequence = (nCommon, aCommon, bCommon) => {
|
||||
for (; aIndex !== aCommon; aIndex += 1) {
|
||||
array.push('-·' + aLinesIn[aIndex]); // delete is minus
|
||||
}
|
||||
for (; bIndex !== bCommon; bIndex += 1) {
|
||||
array.push('+·' + bLinesIn[bIndex]); // insert is plus
|
||||
}
|
||||
for (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1) {
|
||||
// For common lines, received indentation seems more intuitive.
|
||||
array.push('··' + bLinesIn[bIndex]); // common is space
|
||||
}
|
||||
};
|
||||
|
||||
diff(aLength, bLength, isCommon, foundSubsequence);
|
||||
|
||||
// After the last common subsequence, push remaining change lines.
|
||||
for (; aIndex !== aLength; aIndex += 1) {
|
||||
array.push('-·' + aLinesIn[aIndex]);
|
||||
}
|
||||
for (; bIndex !== bLength; bIndex += 1) {
|
||||
array.push('+·' + bLinesIn[bIndex]);
|
||||
}
|
||||
|
||||
return array;
|
||||
};
|
||||
|
||||
const expected = {
|
||||
searching: '',
|
||||
sorting: {
|
||||
ascending: true,
|
||||
fieldKey: 'what',
|
||||
},
|
||||
};
|
||||
const received = {
|
||||
searching: '',
|
||||
sorting: [
|
||||
{
|
||||
descending: false,
|
||||
fieldKey: 'what',
|
||||
},
|
||||
],
|
||||
};
|
||||
|
||||
const diffLines = formatDiffLines(expected, received);
|
||||
```
|
||||
|
||||
If N is the sum of lengths of sequences and L is length of a longest common subsequence, then N – L is length of an array of diff lines. In this example, N is 7 + 9, L is 5, and N – L is 11.
|
||||
|
||||
| `i` | `diffLines[i]` | `aIndex` | `bIndex` |
|
||||
| ---: | :--------------------------------- | -------: | -------: |
|
||||
| `0` | `'··Object {'` | `0` | `0` |
|
||||
| `1` | `'····"searching": "",'` | `1` | `1` |
|
||||
| `2` | `'-···"sorting": Object {'` | `2` | |
|
||||
| `3` | `'-·····"ascending": true,'` | `3` | |
|
||||
| `4` | `'+·····"sorting": Array ['` | | `2` |
|
||||
| `5` | `'+·······Object {'` | | `3` |
|
||||
| `6` | `'+·········"descending": false,'` | | `4` |
|
||||
| `7` | `'··········"fieldKey": "what",'` | `4` | `5` |
|
||||
| `8` | `'········},'` | `5` | `6` |
|
||||
| `9` | `'+·····],'` | | `7` |
|
||||
| `10` | `'··}'` | `6` | `8` |
|
||||
|
||||
## Example of callback functions to find diff items
|
||||
|
||||
Here is simplified code to find changed and unchanged substrings **within adjacent changed lines** in expected and received values after a test fails in Jest:
|
||||
|
||||
```js
|
||||
// Return diff items for strings (compatible with diff-match-patch package).
|
||||
const findDiffItems = (a, b) => {
|
||||
const isCommon = (aIndex, bIndex) => a[aIndex] === b[bIndex];
|
||||
|
||||
let aIndex = 0;
|
||||
let bIndex = 0;
|
||||
const array = [];
|
||||
const foundSubsequence = (nCommon, aCommon, bCommon) => {
|
||||
if (aIndex !== aCommon) {
|
||||
array.push([-1, a.slice(aIndex, aCommon)]); // delete is -1
|
||||
}
|
||||
if (bIndex !== bCommon) {
|
||||
array.push([1, b.slice(bIndex, bCommon)]); // insert is 1
|
||||
}
|
||||
|
||||
aIndex = aCommon + nCommon; // number of characters compared in a
|
||||
bIndex = bCommon + nCommon; // number of characters compared in b
|
||||
array.push([0, a.slice(aCommon, aIndex)]); // common is 0
|
||||
};
|
||||
|
||||
diff(a.length, b.length, isCommon, foundSubsequence);
|
||||
|
||||
// After the last common subsequence, push remaining change items.
|
||||
if (aIndex !== a.length) {
|
||||
array.push([-1, a.slice(aIndex)]);
|
||||
}
|
||||
if (bIndex !== b.length) {
|
||||
array.push([1, b.slice(bIndex)]);
|
||||
}
|
||||
|
||||
return array;
|
||||
};
|
||||
|
||||
const expectedDeleted = ['"sorting": Object {', '"ascending": true,'].join(
|
||||
'\n',
|
||||
);
|
||||
const receivedInserted = [
|
||||
'"sorting": Array [',
|
||||
'Object {',
|
||||
'"descending": false,',
|
||||
].join('\n');
|
||||
|
||||
const diffItems = findDiffItems(expectedDeleted, receivedInserted);
|
||||
```
|
||||
|
||||
| `i` | `diffItems[i][0]` | `diffItems[i][1]` |
|
||||
| --: | ----------------: | :---------------- |
|
||||
| `0` | `0` | `'"sorting": '` |
|
||||
| `1` | `1` | `'Array [\n'` |
|
||||
| `2` | `0` | `'Object {\n"'` |
|
||||
| `3` | `-1` | `'a'` |
|
||||
| `4` | `1` | `'de'` |
|
||||
| `5` | `0` | `'scending": '` |
|
||||
| `6` | `-1` | `'tru'` |
|
||||
| `7` | `1` | `'fals'` |
|
||||
| `8` | `0` | `'e,'` |
|
||||
|
||||
The length difference `b.length - a.length` is equal to the sum of `diffItems[i][0]` values times `diffItems[i][1]` lengths. In this example, the difference `48 - 38` is equal to the sum `10`.
|
||||
|
||||
| category of diff item | `[0]` | `[1]` lengths | subtotal |
|
||||
| :-------------------- | ----: | -----------------: | -------: |
|
||||
| in common | `0` | `11 + 10 + 11 + 2` | `0` |
|
||||
| to delete from `a` | `–1` | `1 + 3` | `-4` |
|
||||
| to insert from `b` | `1` | `8 + 2 + 4` | `14` |
|
||||
|
||||
Instead of formatting the changed substrings with escape codes for colors in the `foundSubsequence` function to save memory, this example spends memory to **gain flexibility** before formatting, so a separate heuristic algorithm might modify the generic array of diff items to show changes more clearly:
|
||||
|
||||
| `i` | `diffItems[i][0]` | `diffItems[i][1]` |
|
||||
| --: | ----------------: | :---------------- |
|
||||
| `6` | `-1` | `'true'` |
|
||||
| `7` | `1` | `'false'` |
|
||||
| `8` | `0` | `','` |
|
||||
|
||||
For expected and received strings of serialized data, the result of finding changed **lines**, and then finding changed **substrings** within adjacent changed lines (as in the preceding two examples) sometimes displays the changes in a more intuitive way than the result of finding changed substrings, and then splitting them into changed and unchanged lines.
|
18
node_modules/jest-snapshot/node_modules/diff-sequences/build/index.d.ts
generated
vendored
Normal file
18
node_modules/jest-snapshot/node_modules/diff-sequences/build/index.d.ts
generated
vendored
Normal file
@ -0,0 +1,18 @@
|
||||
/**
|
||||
* 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 type IsCommon = (aIndex: number, // caller can assume: 0 <= aIndex && aIndex < aLength
|
||||
bIndex: number) => boolean;
|
||||
declare type FoundSubsequence = (nCommon: number, // caller can assume: 0 < nCommon
|
||||
aCommon: number, // caller can assume: 0 <= aCommon && aCommon < aLength
|
||||
bCommon: number) => void;
|
||||
export declare type Callbacks = {
|
||||
foundSubsequence: FoundSubsequence;
|
||||
isCommon: IsCommon;
|
||||
};
|
||||
declare const _default: (aLength: number, bLength: number, isCommon: IsCommon, foundSubsequence: FoundSubsequence) => void;
|
||||
export default _default;
|
802
node_modules/jest-snapshot/node_modules/diff-sequences/build/index.js
generated
vendored
Normal file
802
node_modules/jest-snapshot/node_modules/diff-sequences/build/index.js
generated
vendored
Normal file
@ -0,0 +1,802 @@
|
||||
'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 diff-sequences package implements the linear space variation in
|
||||
// An O(ND) Difference Algorithm and Its Variations by Eugene W. Myers
|
||||
// Relationship in notation between Myers paper and this package:
|
||||
// A is a
|
||||
// N is aLength, aEnd - aStart, and so on
|
||||
// x is aIndex, aFirst, aLast, and so on
|
||||
// B is b
|
||||
// M is bLength, bEnd - bStart, and so on
|
||||
// y is bIndex, bFirst, bLast, and so on
|
||||
// Δ = N - M is negative of baDeltaLength = bLength - aLength
|
||||
// D is d
|
||||
// k is kF
|
||||
// k + Δ is kF = kR - baDeltaLength
|
||||
// V is aIndexesF or aIndexesR (see comment below about Indexes type)
|
||||
// index intervals [1, N] and [1, M] are [0, aLength) and [0, bLength)
|
||||
// starting point in forward direction (0, 0) is (-1, -1)
|
||||
// starting point in reverse direction (N + 1, M + 1) is (aLength, bLength)
|
||||
// The “edit graph” for sequences a and b corresponds to items:
|
||||
// in a on the horizontal axis
|
||||
// in b on the vertical axis
|
||||
//
|
||||
// Given a-coordinate of a point in a diagonal, you can compute b-coordinate.
|
||||
//
|
||||
// Forward diagonals kF:
|
||||
// zero diagonal intersects top left corner
|
||||
// positive diagonals intersect top edge
|
||||
// negative diagonals insersect left edge
|
||||
//
|
||||
// Reverse diagonals kR:
|
||||
// zero diagonal intersects bottom right corner
|
||||
// positive diagonals intersect right edge
|
||||
// negative diagonals intersect bottom edge
|
||||
// The graph contains a directed acyclic graph of edges:
|
||||
// horizontal: delete an item from a
|
||||
// vertical: insert an item from b
|
||||
// diagonal: common item in a and b
|
||||
//
|
||||
// The algorithm solves dual problems in the graph analogy:
|
||||
// Find longest common subsequence: path with maximum number of diagonal edges
|
||||
// Find shortest edit script: path with minimum number of non-diagonal edges
|
||||
// Input callback function compares items at indexes in the sequences.
|
||||
// Output callback function receives the number of adjacent items
|
||||
// and starting indexes of each common subsequence.
|
||||
// Either original functions or wrapped to swap indexes if graph is transposed.
|
||||
// Indexes in sequence a of last point of forward or reverse paths in graph.
|
||||
// Myers algorithm indexes by diagonal k which for negative is bad deopt in V8.
|
||||
// This package indexes by iF and iR which are greater than or equal to zero.
|
||||
// and also updates the index arrays in place to cut memory in half.
|
||||
// kF = 2 * iF - d
|
||||
// kR = d - 2 * iR
|
||||
// Division of index intervals in sequences a and b at the middle change.
|
||||
// Invariant: intervals do not have common items at the start or end.
|
||||
const pkg = 'diff-sequences'; // for error messages
|
||||
|
||||
const NOT_YET_SET = 0; // small int instead of undefined to avoid deopt in V8
|
||||
// Return the number of common items that follow in forward direction.
|
||||
// The length of what Myers paper calls a “snake” in a forward path.
|
||||
|
||||
const countCommonItemsF = (aIndex, aEnd, bIndex, bEnd, isCommon) => {
|
||||
let nCommon = 0;
|
||||
|
||||
while (aIndex < aEnd && bIndex < bEnd && isCommon(aIndex, bIndex)) {
|
||||
aIndex += 1;
|
||||
bIndex += 1;
|
||||
nCommon += 1;
|
||||
}
|
||||
|
||||
return nCommon;
|
||||
}; // Return the number of common items that precede in reverse direction.
|
||||
// The length of what Myers paper calls a “snake” in a reverse path.
|
||||
|
||||
const countCommonItemsR = (aStart, aIndex, bStart, bIndex, isCommon) => {
|
||||
let nCommon = 0;
|
||||
|
||||
while (aStart <= aIndex && bStart <= bIndex && isCommon(aIndex, bIndex)) {
|
||||
aIndex -= 1;
|
||||
bIndex -= 1;
|
||||
nCommon += 1;
|
||||
}
|
||||
|
||||
return nCommon;
|
||||
}; // A simple function to extend forward paths from (d - 1) to d changes
|
||||
// when forward and reverse paths cannot yet overlap.
|
||||
|
||||
const extendPathsF = (d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF) => {
|
||||
// Unroll the first iteration.
|
||||
let iF = 0;
|
||||
let kF = -d; // kF = 2 * iF - d
|
||||
|
||||
let aFirst = aIndexesF[iF]; // in first iteration always insert
|
||||
|
||||
let aIndexPrev1 = aFirst; // prev value of [iF - 1] in next iteration
|
||||
|
||||
aIndexesF[iF] += countCommonItemsF(
|
||||
aFirst + 1,
|
||||
aEnd,
|
||||
bF + aFirst - kF + 1,
|
||||
bEnd,
|
||||
isCommon
|
||||
); // Optimization: skip diagonals in which paths cannot ever overlap.
|
||||
|
||||
const nF = d < iMaxF ? d : iMaxF; // The diagonals kF are odd when d is odd and even when d is even.
|
||||
|
||||
for (iF += 1, kF += 2; iF <= nF; iF += 1, kF += 2) {
|
||||
// To get first point of path segment, move one change in forward direction
|
||||
// from last point of previous path segment in an adjacent diagonal.
|
||||
// In last possible iteration when iF === d and kF === d always delete.
|
||||
if (iF !== d && aIndexPrev1 < aIndexesF[iF]) {
|
||||
aFirst = aIndexesF[iF]; // vertical to insert from b
|
||||
} else {
|
||||
aFirst = aIndexPrev1 + 1; // horizontal to delete from a
|
||||
|
||||
if (aEnd <= aFirst) {
|
||||
// Optimization: delete moved past right of graph.
|
||||
return iF - 1;
|
||||
}
|
||||
} // To get last point of path segment, move along diagonal of common items.
|
||||
|
||||
aIndexPrev1 = aIndexesF[iF];
|
||||
aIndexesF[iF] =
|
||||
aFirst +
|
||||
countCommonItemsF(aFirst + 1, aEnd, bF + aFirst - kF + 1, bEnd, isCommon);
|
||||
}
|
||||
|
||||
return iMaxF;
|
||||
}; // A simple function to extend reverse paths from (d - 1) to d changes
|
||||
// when reverse and forward paths cannot yet overlap.
|
||||
|
||||
const extendPathsR = (d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR) => {
|
||||
// Unroll the first iteration.
|
||||
let iR = 0;
|
||||
let kR = d; // kR = d - 2 * iR
|
||||
|
||||
let aFirst = aIndexesR[iR]; // in first iteration always insert
|
||||
|
||||
let aIndexPrev1 = aFirst; // prev value of [iR - 1] in next iteration
|
||||
|
||||
aIndexesR[iR] -= countCommonItemsR(
|
||||
aStart,
|
||||
aFirst - 1,
|
||||
bStart,
|
||||
bR + aFirst - kR - 1,
|
||||
isCommon
|
||||
); // Optimization: skip diagonals in which paths cannot ever overlap.
|
||||
|
||||
const nR = d < iMaxR ? d : iMaxR; // The diagonals kR are odd when d is odd and even when d is even.
|
||||
|
||||
for (iR += 1, kR -= 2; iR <= nR; iR += 1, kR -= 2) {
|
||||
// To get first point of path segment, move one change in reverse direction
|
||||
// from last point of previous path segment in an adjacent diagonal.
|
||||
// In last possible iteration when iR === d and kR === -d always delete.
|
||||
if (iR !== d && aIndexesR[iR] < aIndexPrev1) {
|
||||
aFirst = aIndexesR[iR]; // vertical to insert from b
|
||||
} else {
|
||||
aFirst = aIndexPrev1 - 1; // horizontal to delete from a
|
||||
|
||||
if (aFirst < aStart) {
|
||||
// Optimization: delete moved past left of graph.
|
||||
return iR - 1;
|
||||
}
|
||||
} // To get last point of path segment, move along diagonal of common items.
|
||||
|
||||
aIndexPrev1 = aIndexesR[iR];
|
||||
aIndexesR[iR] =
|
||||
aFirst -
|
||||
countCommonItemsR(
|
||||
aStart,
|
||||
aFirst - 1,
|
||||
bStart,
|
||||
bR + aFirst - kR - 1,
|
||||
isCommon
|
||||
);
|
||||
}
|
||||
|
||||
return iMaxR;
|
||||
}; // A complete function to extend forward paths from (d - 1) to d changes.
|
||||
// Return true if a path overlaps reverse path of (d - 1) changes in its diagonal.
|
||||
|
||||
const extendOverlappablePathsF = (
|
||||
d,
|
||||
aStart,
|
||||
aEnd,
|
||||
bStart,
|
||||
bEnd,
|
||||
isCommon,
|
||||
aIndexesF,
|
||||
iMaxF,
|
||||
aIndexesR,
|
||||
iMaxR,
|
||||
division
|
||||
) => {
|
||||
const bF = bStart - aStart; // bIndex = bF + aIndex - kF
|
||||
|
||||
const aLength = aEnd - aStart;
|
||||
const bLength = bEnd - bStart;
|
||||
const baDeltaLength = bLength - aLength; // kF = kR - baDeltaLength
|
||||
// Range of diagonals in which forward and reverse paths might overlap.
|
||||
|
||||
const kMinOverlapF = -baDeltaLength - (d - 1); // -(d - 1) <= kR
|
||||
|
||||
const kMaxOverlapF = -baDeltaLength + (d - 1); // kR <= (d - 1)
|
||||
|
||||
let aIndexPrev1 = NOT_YET_SET; // prev value of [iF - 1] in next iteration
|
||||
// Optimization: skip diagonals in which paths cannot ever overlap.
|
||||
|
||||
const nF = d < iMaxF ? d : iMaxF; // The diagonals kF = 2 * iF - d are odd when d is odd and even when d is even.
|
||||
|
||||
for (let iF = 0, kF = -d; iF <= nF; iF += 1, kF += 2) {
|
||||
// To get first point of path segment, move one change in forward direction
|
||||
// from last point of previous path segment in an adjacent diagonal.
|
||||
// In first iteration when iF === 0 and kF === -d always insert.
|
||||
// In last possible iteration when iF === d and kF === d always delete.
|
||||
const insert = iF === 0 || (iF !== d && aIndexPrev1 < aIndexesF[iF]);
|
||||
const aLastPrev = insert ? aIndexesF[iF] : aIndexPrev1;
|
||||
const aFirst = insert
|
||||
? aLastPrev // vertical to insert from b
|
||||
: aLastPrev + 1; // horizontal to delete from a
|
||||
// To get last point of path segment, move along diagonal of common items.
|
||||
|
||||
const bFirst = bF + aFirst - kF;
|
||||
const nCommonF = countCommonItemsF(
|
||||
aFirst + 1,
|
||||
aEnd,
|
||||
bFirst + 1,
|
||||
bEnd,
|
||||
isCommon
|
||||
);
|
||||
const aLast = aFirst + nCommonF;
|
||||
aIndexPrev1 = aIndexesF[iF];
|
||||
aIndexesF[iF] = aLast;
|
||||
|
||||
if (kMinOverlapF <= kF && kF <= kMaxOverlapF) {
|
||||
// Solve for iR of reverse path with (d - 1) changes in diagonal kF:
|
||||
// kR = kF + baDeltaLength
|
||||
// kR = (d - 1) - 2 * iR
|
||||
const iR = (d - 1 - (kF + baDeltaLength)) / 2; // If this forward path overlaps the reverse path in this diagonal,
|
||||
// then this is the middle change of the index intervals.
|
||||
|
||||
if (iR <= iMaxR && aIndexesR[iR] - 1 <= aLast) {
|
||||
// Unlike the Myers algorithm which finds only the middle “snake”
|
||||
// this package can find two common subsequences per division.
|
||||
// Last point of previous path segment is on an adjacent diagonal.
|
||||
const bLastPrev = bF + aLastPrev - (insert ? kF + 1 : kF - 1); // Because of invariant that intervals preceding the middle change
|
||||
// cannot have common items at the end,
|
||||
// move in reverse direction along a diagonal of common items.
|
||||
|
||||
const nCommonR = countCommonItemsR(
|
||||
aStart,
|
||||
aLastPrev,
|
||||
bStart,
|
||||
bLastPrev,
|
||||
isCommon
|
||||
);
|
||||
const aIndexPrevFirst = aLastPrev - nCommonR;
|
||||
const bIndexPrevFirst = bLastPrev - nCommonR;
|
||||
const aEndPreceding = aIndexPrevFirst + 1;
|
||||
const bEndPreceding = bIndexPrevFirst + 1;
|
||||
division.nChangePreceding = d - 1;
|
||||
|
||||
if (d - 1 === aEndPreceding + bEndPreceding - aStart - bStart) {
|
||||
// Optimization: number of preceding changes in forward direction
|
||||
// is equal to number of items in preceding interval,
|
||||
// therefore it cannot contain any common items.
|
||||
division.aEndPreceding = aStart;
|
||||
division.bEndPreceding = bStart;
|
||||
} else {
|
||||
division.aEndPreceding = aEndPreceding;
|
||||
division.bEndPreceding = bEndPreceding;
|
||||
}
|
||||
|
||||
division.nCommonPreceding = nCommonR;
|
||||
|
||||
if (nCommonR !== 0) {
|
||||
division.aCommonPreceding = aEndPreceding;
|
||||
division.bCommonPreceding = bEndPreceding;
|
||||
}
|
||||
|
||||
division.nCommonFollowing = nCommonF;
|
||||
|
||||
if (nCommonF !== 0) {
|
||||
division.aCommonFollowing = aFirst + 1;
|
||||
division.bCommonFollowing = bFirst + 1;
|
||||
}
|
||||
|
||||
const aStartFollowing = aLast + 1;
|
||||
const bStartFollowing = bFirst + nCommonF + 1;
|
||||
division.nChangeFollowing = d - 1;
|
||||
|
||||
if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
|
||||
// Optimization: number of changes in reverse direction
|
||||
// is equal to number of items in following interval,
|
||||
// therefore it cannot contain any common items.
|
||||
division.aStartFollowing = aEnd;
|
||||
division.bStartFollowing = bEnd;
|
||||
} else {
|
||||
division.aStartFollowing = aStartFollowing;
|
||||
division.bStartFollowing = bStartFollowing;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}; // A complete function to extend reverse paths from (d - 1) to d changes.
|
||||
// Return true if a path overlaps forward path of d changes in its diagonal.
|
||||
|
||||
const extendOverlappablePathsR = (
|
||||
d,
|
||||
aStart,
|
||||
aEnd,
|
||||
bStart,
|
||||
bEnd,
|
||||
isCommon,
|
||||
aIndexesF,
|
||||
iMaxF,
|
||||
aIndexesR,
|
||||
iMaxR,
|
||||
division
|
||||
) => {
|
||||
const bR = bEnd - aEnd; // bIndex = bR + aIndex - kR
|
||||
|
||||
const aLength = aEnd - aStart;
|
||||
const bLength = bEnd - bStart;
|
||||
const baDeltaLength = bLength - aLength; // kR = kF + baDeltaLength
|
||||
// Range of diagonals in which forward and reverse paths might overlap.
|
||||
|
||||
const kMinOverlapR = baDeltaLength - d; // -d <= kF
|
||||
|
||||
const kMaxOverlapR = baDeltaLength + d; // kF <= d
|
||||
|
||||
let aIndexPrev1 = NOT_YET_SET; // prev value of [iR - 1] in next iteration
|
||||
// Optimization: skip diagonals in which paths cannot ever overlap.
|
||||
|
||||
const nR = d < iMaxR ? d : iMaxR; // The diagonals kR = d - 2 * iR are odd when d is odd and even when d is even.
|
||||
|
||||
for (let iR = 0, kR = d; iR <= nR; iR += 1, kR -= 2) {
|
||||
// To get first point of path segment, move one change in reverse direction
|
||||
// from last point of previous path segment in an adjacent diagonal.
|
||||
// In first iteration when iR === 0 and kR === d always insert.
|
||||
// In last possible iteration when iR === d and kR === -d always delete.
|
||||
const insert = iR === 0 || (iR !== d && aIndexesR[iR] < aIndexPrev1);
|
||||
const aLastPrev = insert ? aIndexesR[iR] : aIndexPrev1;
|
||||
const aFirst = insert
|
||||
? aLastPrev // vertical to insert from b
|
||||
: aLastPrev - 1; // horizontal to delete from a
|
||||
// To get last point of path segment, move along diagonal of common items.
|
||||
|
||||
const bFirst = bR + aFirst - kR;
|
||||
const nCommonR = countCommonItemsR(
|
||||
aStart,
|
||||
aFirst - 1,
|
||||
bStart,
|
||||
bFirst - 1,
|
||||
isCommon
|
||||
);
|
||||
const aLast = aFirst - nCommonR;
|
||||
aIndexPrev1 = aIndexesR[iR];
|
||||
aIndexesR[iR] = aLast;
|
||||
|
||||
if (kMinOverlapR <= kR && kR <= kMaxOverlapR) {
|
||||
// Solve for iF of forward path with d changes in diagonal kR:
|
||||
// kF = kR - baDeltaLength
|
||||
// kF = 2 * iF - d
|
||||
const iF = (d + (kR - baDeltaLength)) / 2; // If this reverse path overlaps the forward path in this diagonal,
|
||||
// then this is a middle change of the index intervals.
|
||||
|
||||
if (iF <= iMaxF && aLast - 1 <= aIndexesF[iF]) {
|
||||
const bLast = bFirst - nCommonR;
|
||||
division.nChangePreceding = d;
|
||||
|
||||
if (d === aLast + bLast - aStart - bStart) {
|
||||
// Optimization: number of changes in reverse direction
|
||||
// is equal to number of items in preceding interval,
|
||||
// therefore it cannot contain any common items.
|
||||
division.aEndPreceding = aStart;
|
||||
division.bEndPreceding = bStart;
|
||||
} else {
|
||||
division.aEndPreceding = aLast;
|
||||
division.bEndPreceding = bLast;
|
||||
}
|
||||
|
||||
division.nCommonPreceding = nCommonR;
|
||||
|
||||
if (nCommonR !== 0) {
|
||||
// The last point of reverse path segment is start of common subsequence.
|
||||
division.aCommonPreceding = aLast;
|
||||
division.bCommonPreceding = bLast;
|
||||
}
|
||||
|
||||
division.nChangeFollowing = d - 1;
|
||||
|
||||
if (d === 1) {
|
||||
// There is no previous path segment.
|
||||
division.nCommonFollowing = 0;
|
||||
division.aStartFollowing = aEnd;
|
||||
division.bStartFollowing = bEnd;
|
||||
} else {
|
||||
// Unlike the Myers algorithm which finds only the middle “snake”
|
||||
// this package can find two common subsequences per division.
|
||||
// Last point of previous path segment is on an adjacent diagonal.
|
||||
const bLastPrev = bR + aLastPrev - (insert ? kR - 1 : kR + 1); // Because of invariant that intervals following the middle change
|
||||
// cannot have common items at the start,
|
||||
// move in forward direction along a diagonal of common items.
|
||||
|
||||
const nCommonF = countCommonItemsF(
|
||||
aLastPrev,
|
||||
aEnd,
|
||||
bLastPrev,
|
||||
bEnd,
|
||||
isCommon
|
||||
);
|
||||
division.nCommonFollowing = nCommonF;
|
||||
|
||||
if (nCommonF !== 0) {
|
||||
// The last point of reverse path segment is start of common subsequence.
|
||||
division.aCommonFollowing = aLastPrev;
|
||||
division.bCommonFollowing = bLastPrev;
|
||||
}
|
||||
|
||||
const aStartFollowing = aLastPrev + nCommonF; // aFirstPrev
|
||||
|
||||
const bStartFollowing = bLastPrev + nCommonF; // bFirstPrev
|
||||
|
||||
if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
|
||||
// Optimization: number of changes in forward direction
|
||||
// is equal to number of items in following interval,
|
||||
// therefore it cannot contain any common items.
|
||||
division.aStartFollowing = aEnd;
|
||||
division.bStartFollowing = bEnd;
|
||||
} else {
|
||||
division.aStartFollowing = aStartFollowing;
|
||||
division.bStartFollowing = bStartFollowing;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}; // Given index intervals and input function to compare items at indexes,
|
||||
// divide at the middle change.
|
||||
//
|
||||
// DO NOT CALL if start === end, because interval cannot contain common items
|
||||
// and because this function will throw the “no overlap” error.
|
||||
|
||||
const divide = (
|
||||
nChange,
|
||||
aStart,
|
||||
aEnd,
|
||||
bStart,
|
||||
bEnd,
|
||||
isCommon,
|
||||
aIndexesF,
|
||||
aIndexesR,
|
||||
division // output
|
||||
) => {
|
||||
const bF = bStart - aStart; // bIndex = bF + aIndex - kF
|
||||
|
||||
const bR = bEnd - aEnd; // bIndex = bR + aIndex - kR
|
||||
|
||||
const aLength = aEnd - aStart;
|
||||
const bLength = bEnd - bStart; // Because graph has square or portrait orientation,
|
||||
// length difference is minimum number of items to insert from b.
|
||||
// Corresponding forward and reverse diagonals in graph
|
||||
// depend on length difference of the sequences:
|
||||
// kF = kR - baDeltaLength
|
||||
// kR = kF + baDeltaLength
|
||||
|
||||
const baDeltaLength = bLength - aLength; // Optimization: max diagonal in graph intersects corner of shorter side.
|
||||
|
||||
let iMaxF = aLength;
|
||||
let iMaxR = aLength; // Initialize no changes yet in forward or reverse direction:
|
||||
|
||||
aIndexesF[0] = aStart - 1; // at open start of interval, outside closed start
|
||||
|
||||
aIndexesR[0] = aEnd; // at open end of interval
|
||||
|
||||
if (baDeltaLength % 2 === 0) {
|
||||
// The number of changes in paths is 2 * d if length difference is even.
|
||||
const dMin = (nChange || baDeltaLength) / 2;
|
||||
const dMax = (aLength + bLength) / 2;
|
||||
|
||||
for (let d = 1; d <= dMax; d += 1) {
|
||||
iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
|
||||
|
||||
if (d < dMin) {
|
||||
iMaxR = extendPathsR(d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);
|
||||
} else if (
|
||||
// If a reverse path overlaps a forward path in the same diagonal,
|
||||
// return a division of the index intervals at the middle change.
|
||||
extendOverlappablePathsR(
|
||||
d,
|
||||
aStart,
|
||||
aEnd,
|
||||
bStart,
|
||||
bEnd,
|
||||
isCommon,
|
||||
aIndexesF,
|
||||
iMaxF,
|
||||
aIndexesR,
|
||||
iMaxR,
|
||||
division
|
||||
)
|
||||
) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// The number of changes in paths is 2 * d - 1 if length difference is odd.
|
||||
const dMin = ((nChange || baDeltaLength) + 1) / 2;
|
||||
const dMax = (aLength + bLength + 1) / 2; // Unroll first half iteration so loop extends the relevant pairs of paths.
|
||||
// Because of invariant that intervals have no common items at start or end,
|
||||
// and limitation not to call divide with empty intervals,
|
||||
// therefore it cannot be called if a forward path with one change
|
||||
// would overlap a reverse path with no changes, even if dMin === 1.
|
||||
|
||||
let d = 1;
|
||||
iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
|
||||
|
||||
for (d += 1; d <= dMax; d += 1) {
|
||||
iMaxR = extendPathsR(
|
||||
d - 1,
|
||||
aStart,
|
||||
bStart,
|
||||
bR,
|
||||
isCommon,
|
||||
aIndexesR,
|
||||
iMaxR
|
||||
);
|
||||
|
||||
if (d < dMin) {
|
||||
iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
|
||||
} else if (
|
||||
// If a forward path overlaps a reverse path in the same diagonal,
|
||||
// return a division of the index intervals at the middle change.
|
||||
extendOverlappablePathsF(
|
||||
d,
|
||||
aStart,
|
||||
aEnd,
|
||||
bStart,
|
||||
bEnd,
|
||||
isCommon,
|
||||
aIndexesF,
|
||||
iMaxF,
|
||||
aIndexesR,
|
||||
iMaxR,
|
||||
division
|
||||
)
|
||||
) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
/* istanbul ignore next */
|
||||
|
||||
throw new Error(
|
||||
`${pkg}: no overlap aStart=${aStart} aEnd=${aEnd} bStart=${bStart} bEnd=${bEnd}`
|
||||
);
|
||||
}; // Given index intervals and input function to compare items at indexes,
|
||||
// return by output function the number of adjacent items and starting indexes
|
||||
// of each common subsequence. Divide and conquer with only linear space.
|
||||
//
|
||||
// The index intervals are half open [start, end) like array slice method.
|
||||
// DO NOT CALL if start === end, because interval cannot contain common items
|
||||
// and because divide function will throw the “no overlap” error.
|
||||
|
||||
const findSubsequences = (
|
||||
nChange,
|
||||
aStart,
|
||||
aEnd,
|
||||
bStart,
|
||||
bEnd,
|
||||
transposed,
|
||||
callbacks,
|
||||
aIndexesF,
|
||||
aIndexesR,
|
||||
division // temporary memory, not input nor output
|
||||
) => {
|
||||
if (bEnd - bStart < aEnd - aStart) {
|
||||
// Transpose graph so it has portrait instead of landscape orientation.
|
||||
// Always compare shorter to longer sequence for consistency and optimization.
|
||||
transposed = !transposed;
|
||||
|
||||
if (transposed && callbacks.length === 1) {
|
||||
// Lazily wrap callback functions to swap args if graph is transposed.
|
||||
const {foundSubsequence, isCommon} = callbacks[0];
|
||||
callbacks[1] = {
|
||||
foundSubsequence: (nCommon, bCommon, aCommon) => {
|
||||
foundSubsequence(nCommon, aCommon, bCommon);
|
||||
},
|
||||
isCommon: (bIndex, aIndex) => isCommon(aIndex, bIndex)
|
||||
};
|
||||
}
|
||||
|
||||
const tStart = aStart;
|
||||
const tEnd = aEnd;
|
||||
aStart = bStart;
|
||||
aEnd = bEnd;
|
||||
bStart = tStart;
|
||||
bEnd = tEnd;
|
||||
}
|
||||
|
||||
const {foundSubsequence, isCommon} = callbacks[transposed ? 1 : 0]; // Divide the index intervals at the middle change.
|
||||
|
||||
divide(
|
||||
nChange,
|
||||
aStart,
|
||||
aEnd,
|
||||
bStart,
|
||||
bEnd,
|
||||
isCommon,
|
||||
aIndexesF,
|
||||
aIndexesR,
|
||||
division
|
||||
);
|
||||
const {
|
||||
nChangePreceding,
|
||||
aEndPreceding,
|
||||
bEndPreceding,
|
||||
nCommonPreceding,
|
||||
aCommonPreceding,
|
||||
bCommonPreceding,
|
||||
nCommonFollowing,
|
||||
aCommonFollowing,
|
||||
bCommonFollowing,
|
||||
nChangeFollowing,
|
||||
aStartFollowing,
|
||||
bStartFollowing
|
||||
} = division; // Unless either index interval is empty, they might contain common items.
|
||||
|
||||
if (aStart < aEndPreceding && bStart < bEndPreceding) {
|
||||
// Recursely find and return common subsequences preceding the division.
|
||||
findSubsequences(
|
||||
nChangePreceding,
|
||||
aStart,
|
||||
aEndPreceding,
|
||||
bStart,
|
||||
bEndPreceding,
|
||||
transposed,
|
||||
callbacks,
|
||||
aIndexesF,
|
||||
aIndexesR,
|
||||
division
|
||||
);
|
||||
} // Return common subsequences that are adjacent to the middle change.
|
||||
|
||||
if (nCommonPreceding !== 0) {
|
||||
foundSubsequence(nCommonPreceding, aCommonPreceding, bCommonPreceding);
|
||||
}
|
||||
|
||||
if (nCommonFollowing !== 0) {
|
||||
foundSubsequence(nCommonFollowing, aCommonFollowing, bCommonFollowing);
|
||||
} // Unless either index interval is empty, they might contain common items.
|
||||
|
||||
if (aStartFollowing < aEnd && bStartFollowing < bEnd) {
|
||||
// Recursely find and return common subsequences following the division.
|
||||
findSubsequences(
|
||||
nChangeFollowing,
|
||||
aStartFollowing,
|
||||
aEnd,
|
||||
bStartFollowing,
|
||||
bEnd,
|
||||
transposed,
|
||||
callbacks,
|
||||
aIndexesF,
|
||||
aIndexesR,
|
||||
division
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
const validateLength = (name, arg) => {
|
||||
if (typeof arg !== 'number') {
|
||||
throw new TypeError(`${pkg}: ${name} typeof ${typeof arg} is not a number`);
|
||||
}
|
||||
|
||||
if (!Number.isSafeInteger(arg)) {
|
||||
throw new RangeError(`${pkg}: ${name} value ${arg} is not a safe integer`);
|
||||
}
|
||||
|
||||
if (arg < 0) {
|
||||
throw new RangeError(`${pkg}: ${name} value ${arg} is a negative integer`);
|
||||
}
|
||||
};
|
||||
|
||||
const validateCallback = (name, arg) => {
|
||||
const type = typeof arg;
|
||||
|
||||
if (type !== 'function') {
|
||||
throw new TypeError(`${pkg}: ${name} typeof ${type} is not a function`);
|
||||
}
|
||||
}; // Compare items in two sequences to find a longest common subsequence.
|
||||
// Given lengths of sequences and input function to compare items at indexes,
|
||||
// return by output function the number of adjacent items and starting indexes
|
||||
// of each common subsequence.
|
||||
|
||||
var _default = (aLength, bLength, isCommon, foundSubsequence) => {
|
||||
validateLength('aLength', aLength);
|
||||
validateLength('bLength', bLength);
|
||||
validateCallback('isCommon', isCommon);
|
||||
validateCallback('foundSubsequence', foundSubsequence); // Count common items from the start in the forward direction.
|
||||
|
||||
const nCommonF = countCommonItemsF(0, aLength, 0, bLength, isCommon);
|
||||
|
||||
if (nCommonF !== 0) {
|
||||
foundSubsequence(nCommonF, 0, 0);
|
||||
} // Unless both sequences consist of common items only,
|
||||
// find common items in the half-trimmed index intervals.
|
||||
|
||||
if (aLength !== nCommonF || bLength !== nCommonF) {
|
||||
// Invariant: intervals do not have common items at the start.
|
||||
// The start of an index interval is closed like array slice method.
|
||||
const aStart = nCommonF;
|
||||
const bStart = nCommonF; // Count common items from the end in the reverse direction.
|
||||
|
||||
const nCommonR = countCommonItemsR(
|
||||
aStart,
|
||||
aLength - 1,
|
||||
bStart,
|
||||
bLength - 1,
|
||||
isCommon
|
||||
); // Invariant: intervals do not have common items at the end.
|
||||
// The end of an index interval is open like array slice method.
|
||||
|
||||
const aEnd = aLength - nCommonR;
|
||||
const bEnd = bLength - nCommonR; // Unless one sequence consists of common items only,
|
||||
// therefore the other trimmed index interval consists of changes only,
|
||||
// find common items in the trimmed index intervals.
|
||||
|
||||
const nCommonFR = nCommonF + nCommonR;
|
||||
|
||||
if (aLength !== nCommonFR && bLength !== nCommonFR) {
|
||||
const nChange = 0; // number of change items is not yet known
|
||||
|
||||
const transposed = false; // call the original unwrapped functions
|
||||
|
||||
const callbacks = [
|
||||
{
|
||||
foundSubsequence,
|
||||
isCommon
|
||||
}
|
||||
]; // Indexes in sequence a of last points in furthest reaching paths
|
||||
// from outside the start at top left in the forward direction:
|
||||
|
||||
const aIndexesF = [NOT_YET_SET]; // from the end at bottom right in the reverse direction:
|
||||
|
||||
const aIndexesR = [NOT_YET_SET]; // Initialize one object as output of all calls to divide function.
|
||||
|
||||
const division = {
|
||||
aCommonFollowing: NOT_YET_SET,
|
||||
aCommonPreceding: NOT_YET_SET,
|
||||
aEndPreceding: NOT_YET_SET,
|
||||
aStartFollowing: NOT_YET_SET,
|
||||
bCommonFollowing: NOT_YET_SET,
|
||||
bCommonPreceding: NOT_YET_SET,
|
||||
bEndPreceding: NOT_YET_SET,
|
||||
bStartFollowing: NOT_YET_SET,
|
||||
nChangeFollowing: NOT_YET_SET,
|
||||
nChangePreceding: NOT_YET_SET,
|
||||
nCommonFollowing: NOT_YET_SET,
|
||||
nCommonPreceding: NOT_YET_SET
|
||||
}; // Find and return common subsequences in the trimmed index intervals.
|
||||
|
||||
findSubsequences(
|
||||
nChange,
|
||||
aStart,
|
||||
aEnd,
|
||||
bStart,
|
||||
bEnd,
|
||||
transposed,
|
||||
callbacks,
|
||||
aIndexesF,
|
||||
aIndexesR,
|
||||
division
|
||||
);
|
||||
}
|
||||
|
||||
if (nCommonR !== 0) {
|
||||
foundSubsequence(nCommonR, aEnd, bEnd);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
exports.default = _default;
|
35
node_modules/jest-snapshot/node_modules/diff-sequences/package.json
generated
vendored
Normal file
35
node_modules/jest-snapshot/node_modules/diff-sequences/package.json
generated
vendored
Normal file
@ -0,0 +1,35 @@
|
||||
{
|
||||
"name": "diff-sequences",
|
||||
"version": "26.6.2",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/facebook/jest.git",
|
||||
"directory": "packages/diff-sequences"
|
||||
},
|
||||
"license": "MIT",
|
||||
"description": "Compare items in two sequences to find a longest common subsequence",
|
||||
"keywords": [
|
||||
"fast",
|
||||
"linear",
|
||||
"space",
|
||||
"callback",
|
||||
"diff"
|
||||
],
|
||||
"engines": {
|
||||
"node": ">= 10.14.2"
|
||||
},
|
||||
"main": "build/index.js",
|
||||
"types": "build/index.d.ts",
|
||||
"scripts": {
|
||||
"perf": "node --expose-gc perf/index.js"
|
||||
},
|
||||
"devDependencies": {
|
||||
"benchmark": "^2.1.4",
|
||||
"diff": "^4.0.1",
|
||||
"fast-check": "^2.0.0"
|
||||
},
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"gitHead": "4c46930615602cbf983fb7e8e82884c282a624d5"
|
||||
}
|
48
node_modules/jest-snapshot/node_modules/diff-sequences/perf/example.md
generated
vendored
Normal file
48
node_modules/jest-snapshot/node_modules/diff-sequences/perf/example.md
generated
vendored
Normal file
@ -0,0 +1,48 @@
|
||||
## Benchmark time for `diff-sequences` versus `diff`
|
||||
|
||||
A ratio less than 1.0 means `diff-sequences` is faster.
|
||||
|
||||
### n = 20
|
||||
|
||||
| name | % | ratio | improved | rme | baseline | rme |
|
||||
| :----- | ---: | :----- | :-------- | ----: | :-------- | ----: |
|
||||
| delete | 20% | 0.1824 | 3.0639e-6 | 1.11% | 1.6795e-5 | 0.78% |
|
||||
| insert | 20% | 0.1367 | 2.5786e-6 | 0.75% | 1.8866e-5 | 0.85% |
|
||||
| delete | 40% | 0.1015 | 3.0534e-6 | 1.00% | 3.0090e-5 | 0.70% |
|
||||
| insert | 40% | 0.0791 | 2.6722e-6 | 0.61% | 3.3791e-5 | 0.56% |
|
||||
| delete | 80% | 0.0410 | 2.8870e-6 | 0.93% | 7.0411e-5 | 0.72% |
|
||||
| insert | 80% | 0.0371 | 2.5786e-6 | 0.83% | 6.9431e-5 | 0.62% |
|
||||
| change | 10% | 0.1504 | 2.8703e-6 | 0.71% | 1.9087e-5 | 0.83% |
|
||||
| change | 20% | 0.1706 | 3.2637e-6 | 0.78% | 1.9127e-5 | 0.62% |
|
||||
| change | 50% | 0.0944 | 1.2012e-5 | 0.55% | 1.2724e-4 | 0.76% |
|
||||
| change | 100% | 0.0522 | 1.5422e-5 | 0.61% | 2.9566e-4 | 0.66% |
|
||||
|
||||
### n = 200
|
||||
|
||||
| name | % | ratio | improved | rme | baseline | rme |
|
||||
| :----- | ---: | :----- | :-------- | ----: | :-------- | ----: |
|
||||
| delete | 20% | 0.1524 | 7.2866e-5 | 0.75% | 4.7797e-4 | 0.80% |
|
||||
| insert | 20% | 0.1226 | 6.1561e-5 | 0.58% | 5.0198e-4 | 0.66% |
|
||||
| delete | 40% | 0.1118 | 1.5674e-4 | 0.67% | 1.4020e-3 | 0.58% |
|
||||
| insert | 40% | 0.0894 | 1.2906e-4 | 0.64% | 1.4435e-3 | 0.53% |
|
||||
| delete | 80% | 0.0796 | 3.0119e-4 | 0.58% | 3.7852e-3 | 0.52% |
|
||||
| insert | 80% | 0.0734 | 2.4713e-4 | 0.67% | 3.3653e-3 | 0.54% |
|
||||
| change | 10% | 0.1572 | 7.2965e-5 | 0.48% | 4.6426e-4 | 0.73% |
|
||||
| change | 20% | 0.1446 | 7.0056e-5 | 0.69% | 4.8456e-4 | 0.53% |
|
||||
| change | 50% | 0.0764 | 6.5638e-4 | 0.67% | 8.5946e-3 | 0.70% |
|
||||
| change | 100% | 0.0525 | 1.1160e-3 | 0.51% | 2.1249e-2 | 0.63% |
|
||||
|
||||
### n = 2000
|
||||
|
||||
| name | % | ratio | improved | rme | baseline | rme |
|
||||
| :----- | ---: | :----- | :-------- | ----: | :-------- | ----: |
|
||||
| delete | 20% | 0.0669 | 3.4073e-3 | 0.54% | 5.0922e-2 | 0.54% |
|
||||
| insert | 20% | 0.0588 | 2.8273e-3 | 0.51% | 4.8111e-2 | 0.46% |
|
||||
| delete | 40% | 0.0517 | 1.1048e-2 | 0.52% | 2.1367e-1 | 0.47% |
|
||||
| insert | 40% | 0.0460 | 9.1469e-3 | 0.37% | 1.9878e-1 | 0.26% |
|
||||
| delete | 80% | 0.0563 | 2.7426e-2 | 0.56% | 4.8674e-1 | 0.36% |
|
||||
| insert | 80% | 0.0506 | 2.2208e-2 | 0.35% | 4.3888e-1 | 0.47% |
|
||||
| change | 10% | 0.0716 | 3.1267e-3 | 1.21% | 4.3652e-2 | 0.56% |
|
||||
| change | 20% | 0.0621 | 3.0197e-3 | 0.72% | 4.8652e-2 | 0.45% |
|
||||
| change | 50% | 0.0083 | 5.4250e-2 | 0.62% | 6.5595e+0 | 3.60% |
|
||||
| change | 100% | 0.0493 | 1.0534e-1 | 0.71% | 2.1362e+0 | 0.21% |
|
170
node_modules/jest-snapshot/node_modules/diff-sequences/perf/index.js
generated
vendored
Normal file
170
node_modules/jest-snapshot/node_modules/diff-sequences/perf/index.js
generated
vendored
Normal file
@ -0,0 +1,170 @@
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
// Make sure to run node with --expose-gc option!
|
||||
|
||||
// The times are reliable if about 1% relative mean error if you run it:
|
||||
|
||||
// * immediately after restart
|
||||
// * with 100% battery charge
|
||||
// * not connected to network
|
||||
|
||||
/* eslint import/no-extraneous-dependencies: "off" */
|
||||
|
||||
const Benchmark = require('benchmark');
|
||||
const diffBaseline = require('diff').diffLines;
|
||||
const diffImproved = require('../build/index.js').default;
|
||||
|
||||
const testBaseline = (a, b) => {
|
||||
const benchmark = new Benchmark({
|
||||
fn() {
|
||||
diffBaseline(a, b);
|
||||
},
|
||||
name: 'baseline',
|
||||
onCycle() {
|
||||
global.gc(); // after run cycle
|
||||
},
|
||||
onStart() {
|
||||
global.gc(); // when benchmark starts
|
||||
},
|
||||
});
|
||||
|
||||
benchmark.run({async: false});
|
||||
|
||||
return benchmark.stats;
|
||||
};
|
||||
|
||||
const testImproved = function (a, b) {
|
||||
const benchmark = new Benchmark({
|
||||
fn() {
|
||||
// Split string arguments to make fair comparison with baseline.
|
||||
const aItems = a.split('\n');
|
||||
const bItems = b.split('\n');
|
||||
|
||||
const isCommon = (aIndex, bIndex) => aItems[aIndex] === bItems[bIndex];
|
||||
|
||||
// This callback obviously does less than baseline `diff` package,
|
||||
// but avoiding double work and memory churn is the goal.
|
||||
// For example, `jest-diff` has had to split strings that `diff` joins.
|
||||
const foundSubsequence = () => {};
|
||||
|
||||
diffImproved(aItems.length, bItems.length, isCommon, foundSubsequence);
|
||||
},
|
||||
name: 'improved',
|
||||
onCycle() {
|
||||
global.gc(); // after run cycle
|
||||
},
|
||||
onStart() {
|
||||
global.gc(); // when benchmark starts
|
||||
},
|
||||
});
|
||||
|
||||
benchmark.run({async: false});
|
||||
|
||||
return benchmark.stats;
|
||||
};
|
||||
|
||||
const writeHeading2 = () => {
|
||||
console.log('## Benchmark time for `diff-sequences` versus `diff`\n');
|
||||
console.log('A ratio less than 1.0 means `diff-sequences` is faster.');
|
||||
};
|
||||
|
||||
const writeHeading3 = n => {
|
||||
console.log(`\n### n = ${n}\n`);
|
||||
console.log('| name | % | ratio | improved | rme | baseline | rme |');
|
||||
console.log('| :--- | ---: | :--- | :--- | ---: | :--- | ---: |');
|
||||
};
|
||||
|
||||
const writeRow = (name, percent, statsImproved, statsBaseline) => {
|
||||
const {mean: meanImproved, rme: rmeImproved} = statsImproved;
|
||||
const {mean: meanBaseline, rme: rmeBaseline} = statsBaseline;
|
||||
const ratio = meanImproved / meanBaseline;
|
||||
|
||||
console.log(
|
||||
`| ${name} | ${percent}% | ${ratio.toFixed(
|
||||
4,
|
||||
)} | ${meanImproved.toExponential(4)} | ${rmeImproved.toFixed(
|
||||
2,
|
||||
)}% | ${meanBaseline.toExponential(4)} | ${rmeBaseline.toFixed(2)}% |`,
|
||||
);
|
||||
};
|
||||
|
||||
const testDeleteInsert = (tenths, more, less) => {
|
||||
// For improved `diff-sequences` package, delete is often slower than insert.
|
||||
const statsDeleteImproved = testImproved(more, less);
|
||||
const statsDeleteBaseline = testBaseline(more, less);
|
||||
writeRow('delete', tenths * 10, statsDeleteImproved, statsDeleteBaseline);
|
||||
|
||||
// For baseline `diff` package, many insertions is serious perf problem.
|
||||
// However, the benchmark package cannot accurately measure for large n.
|
||||
const statsInsertBaseline = testBaseline(less, more);
|
||||
const statsInsertImproved = testImproved(less, more);
|
||||
writeRow('insert', tenths * 10, statsInsertImproved, statsInsertBaseline);
|
||||
};
|
||||
|
||||
const testChange = (tenths, expected, received) => {
|
||||
const statsImproved = testImproved(expected, received);
|
||||
const statsBaseline = testBaseline(expected, received);
|
||||
writeRow('change', tenths * 10, statsImproved, statsBaseline);
|
||||
};
|
||||
|
||||
const getItems = (n, callback) => {
|
||||
const items = [];
|
||||
|
||||
for (let i = 0; i !== n; i += 1) {
|
||||
const item = callback(i);
|
||||
if (typeof item === 'string') {
|
||||
items.push(item);
|
||||
}
|
||||
}
|
||||
|
||||
return items.join('\n');
|
||||
};
|
||||
|
||||
// Simulate change of property name which is usually not same line.
|
||||
// Expected: 0 1 2 3 4 5 6 7 8 9 and so on
|
||||
// Received: 1 2 3 4 x0 5 6 7 8 9 and so on
|
||||
const change2 = i => {
|
||||
const j = i % 10;
|
||||
return j === 4 ? `x${i - 4}` : j < 4 ? `${i + 1}` : `${i}`;
|
||||
};
|
||||
|
||||
const testLength = n => {
|
||||
const all = getItems(n, i => `${i}`);
|
||||
|
||||
writeHeading3(n);
|
||||
|
||||
[2, 4, 8].forEach(tenth => {
|
||||
testDeleteInsert(
|
||||
tenth,
|
||||
all,
|
||||
getItems(n, i => i % 10 >= tenth && `${i}`),
|
||||
);
|
||||
});
|
||||
testChange(
|
||||
1,
|
||||
all,
|
||||
getItems(n, i => (i % 10 === 0 ? `x${i}` : `${i}`)),
|
||||
);
|
||||
testChange(2, all, getItems(n, change2));
|
||||
testChange(
|
||||
5,
|
||||
all,
|
||||
getItems(n, i => (i % 2 === 0 ? `x${i}` : `${i}`)),
|
||||
);
|
||||
testChange(
|
||||
10,
|
||||
all,
|
||||
getItems(n, i => `x${i}`),
|
||||
); // simulate TDD
|
||||
};
|
||||
|
||||
writeHeading2();
|
||||
|
||||
testLength(20);
|
||||
testLength(200);
|
||||
testLength(2000);
|
21
node_modules/jest-snapshot/node_modules/jest-diff/LICENSE
generated
vendored
Normal file
21
node_modules/jest-snapshot/node_modules/jest-diff/LICENSE
generated
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) Facebook, Inc. and its affiliates.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
614
node_modules/jest-snapshot/node_modules/jest-diff/README.md
generated
vendored
Normal file
614
node_modules/jest-snapshot/node_modules/jest-diff/README.md
generated
vendored
Normal file
@ -0,0 +1,614 @@
|
||||
# jest-diff
|
||||
|
||||
Display differences clearly so people can review changes confidently.
|
||||
|
||||
The default export serializes JavaScript **values**, compares them line-by-line, and returns a string which includes comparison lines.
|
||||
|
||||
Two named exports compare **strings** character-by-character:
|
||||
|
||||
- `diffStringsUnified` returns a string.
|
||||
- `diffStringsRaw` returns an array of `Diff` objects.
|
||||
|
||||
Three named exports compare **arrays of strings** line-by-line:
|
||||
|
||||
- `diffLinesUnified` and `diffLinesUnified2` return a string.
|
||||
- `diffLinesRaw` returns an array of `Diff` objects.
|
||||
|
||||
## Installation
|
||||
|
||||
To add this package as a dependency of a project, run either of the following commands:
|
||||
|
||||
- `npm install jest-diff`
|
||||
- `yarn add jest-diff`
|
||||
|
||||
## Usage of default export
|
||||
|
||||
Given JavaScript **values**, `diffDefault(a, b, options?)` does the following:
|
||||
|
||||
1. **serialize** the values as strings using the `pretty-format` package
|
||||
2. **compare** the strings line-by-line using the `diff-sequences` package
|
||||
3. **format** the changed or common lines using the `chalk` package
|
||||
|
||||
To use this function, write either of the following:
|
||||
|
||||
- `const diffDefault = require('jest-diff').default;` in CommonJS modules
|
||||
- `import diffDefault from 'jest-diff';` in ECMAScript modules
|
||||
|
||||
### Example of default export
|
||||
|
||||
```js
|
||||
const a = ['delete', 'common', 'changed from'];
|
||||
const b = ['common', 'changed to', 'insert'];
|
||||
|
||||
const difference = diffDefault(a, b);
|
||||
```
|
||||
|
||||
The returned **string** consists of:
|
||||
|
||||
- annotation lines: describe the two change indicators with labels, and a blank line
|
||||
- comparison lines: similar to “unified” view on GitHub, but `Expected` lines are green, `Received` lines are red, and common lines are dim (by default, see Options)
|
||||
|
||||
```diff
|
||||
- Expected
|
||||
+ Received
|
||||
|
||||
Array [
|
||||
- "delete",
|
||||
"common",
|
||||
- "changed from",
|
||||
+ "changed to",
|
||||
+ "insert",
|
||||
]
|
||||
```
|
||||
|
||||
### Edge cases of default export
|
||||
|
||||
Here are edge cases for the return value:
|
||||
|
||||
- `' Comparing two different types of values. …'` if the arguments have **different types** according to the `jest-get-type` package (instances of different classes have the same `'object'` type)
|
||||
- `'Compared values have no visual difference.'` if the arguments have either **referential identity** according to `Object.is` method or **same serialization** according to the `pretty-format` package
|
||||
- `null` if either argument is a so-called **asymmetric matcher** in Jasmine or Jest
|
||||
|
||||
## Usage of diffStringsUnified
|
||||
|
||||
Given **strings**, `diffStringsUnified(a, b, options?)` does the following:
|
||||
|
||||
1. **compare** the strings character-by-character using the `diff-sequences` package
|
||||
2. **clean up** small (often coincidental) common substrings, also known as chaff
|
||||
3. **format** the changed or common lines using the `chalk` package
|
||||
|
||||
Although the function is mainly for **multiline** strings, it compares any strings.
|
||||
|
||||
Write either of the following:
|
||||
|
||||
- `const {diffStringsUnified} = require('jest-diff');` in CommonJS modules
|
||||
- `import {diffStringsUnified} from 'jest-diff';` in ECMAScript modules
|
||||
|
||||
### Example of diffStringsUnified
|
||||
|
||||
```js
|
||||
const a = 'common\nchanged from';
|
||||
const b = 'common\nchanged to';
|
||||
|
||||
const difference = diffStringsUnified(a, b);
|
||||
```
|
||||
|
||||
The returned **string** consists of:
|
||||
|
||||
- annotation lines: describe the two change indicators with labels, and a blank line
|
||||
- comparison lines: similar to “unified” view on GitHub, and **changed substrings** have **inverse** foreground and background colors (that is, `from` has white-on-green and `to` has white-on-red, which the following example does not show)
|
||||
|
||||
```diff
|
||||
- Expected
|
||||
+ Received
|
||||
|
||||
common
|
||||
- changed from
|
||||
+ changed to
|
||||
```
|
||||
|
||||
### Performance of diffStringsUnified
|
||||
|
||||
To get the benefit of **changed substrings** within the comparison lines, a character-by-character comparison has a higher computational cost (in time and space) than a line-by-line comparison.
|
||||
|
||||
If the input strings can have **arbitrary length**, we recommend that the calling code set a limit, beyond which splits the strings, and then calls `diffLinesUnified` instead. For example, Jest falls back to line-by-line comparison if either string has length greater than 20K characters.
|
||||
|
||||
## Usage of diffLinesUnified
|
||||
|
||||
Given **arrays of strings**, `diffLinesUnified(aLines, bLines, options?)` does the following:
|
||||
|
||||
1. **compare** the arrays line-by-line using the `diff-sequences` package
|
||||
2. **format** the changed or common lines using the `chalk` package
|
||||
|
||||
You might call this function when strings have been split into lines and you do not need to see changed substrings within lines.
|
||||
|
||||
### Example of diffLinesUnified
|
||||
|
||||
```js
|
||||
const aLines = ['delete', 'common', 'changed from'];
|
||||
const bLines = ['common', 'changed to', 'insert'];
|
||||
|
||||
const difference = diffLinesUnified(aLines, bLines);
|
||||
```
|
||||
|
||||
```diff
|
||||
- Expected
|
||||
+ Received
|
||||
|
||||
- delete
|
||||
common
|
||||
- changed from
|
||||
+ changed to
|
||||
+ insert
|
||||
```
|
||||
|
||||
### Edge cases of diffLinesUnified or diffStringsUnified
|
||||
|
||||
Here are edge cases for arguments and return values:
|
||||
|
||||
- both `a` and `b` are empty strings: no comparison lines
|
||||
- only `a` is empty string: all comparison lines have `bColor` and `bIndicator` (see Options)
|
||||
- only `b` is empty string: all comparison lines have `aColor` and `aIndicator` (see Options)
|
||||
- `a` and `b` are equal non-empty strings: all comparison lines have `commonColor` and `commonIndicator` (see Options)
|
||||
|
||||
## Usage of diffLinesUnified2
|
||||
|
||||
Given two **pairs** of arrays of strings, `diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCompare, options?)` does the following:
|
||||
|
||||
1. **compare** the pair of `Compare` arrays line-by-line using the `diff-sequences` package
|
||||
2. **format** the corresponding lines in the pair of `Display` arrays using the `chalk` package
|
||||
|
||||
Jest calls this function to consider lines as common instead of changed if the only difference is indentation.
|
||||
|
||||
You might call this function for case insensitive or Unicode equivalence comparison of lines.
|
||||
|
||||
### Example of diffLinesUnified2
|
||||
|
||||
```js
|
||||
import format from 'pretty-format';
|
||||
|
||||
const a = {
|
||||
text: 'Ignore indentation in serialized object',
|
||||
time: '2019-09-19T12:34:56.000Z',
|
||||
type: 'CREATE_ITEM',
|
||||
};
|
||||
const b = {
|
||||
payload: {
|
||||
text: 'Ignore indentation in serialized object',
|
||||
time: '2019-09-19T12:34:56.000Z',
|
||||
},
|
||||
type: 'CREATE_ITEM',
|
||||
};
|
||||
|
||||
const difference = diffLinesUnified2(
|
||||
// serialize with indentation to display lines
|
||||
format(a).split('\n'),
|
||||
format(b).split('\n'),
|
||||
// serialize without indentation to compare lines
|
||||
format(a, {indent: 0}).split('\n'),
|
||||
format(b, {indent: 0}).split('\n'),
|
||||
);
|
||||
```
|
||||
|
||||
The `text` and `time` properties are common, because their only difference is indentation:
|
||||
|
||||
```diff
|
||||
- Expected
|
||||
+ Received
|
||||
|
||||
Object {
|
||||
+ payload: Object {
|
||||
text: 'Ignore indentation in serialized object',
|
||||
time: '2019-09-19T12:34:56.000Z',
|
||||
+ },
|
||||
type: 'CREATE_ITEM',
|
||||
}
|
||||
```
|
||||
|
||||
The preceding example illustrates why (at least for indentation) it seems more intuitive that the function returns the common line from the `bLinesDisplay` array instead of from the `aLinesDisplay` array.
|
||||
|
||||
## Usage of diffStringsRaw
|
||||
|
||||
Given **strings** and a boolean option, `diffStringsRaw(a, b, cleanup)` does the following:
|
||||
|
||||
1. **compare** the strings character-by-character using the `diff-sequences` package
|
||||
2. optionally **clean up** small (often coincidental) common substrings, also known as chaff
|
||||
|
||||
Because `diffStringsRaw` returns the difference as **data** instead of a string, you can format it as your application requires (for example, enclosed in HTML markup for browser instead of escape sequences for console).
|
||||
|
||||
The returned **array** describes substrings as instances of the `Diff` class, which calling code can access like array tuples:
|
||||
|
||||
The value at index `0` is one of the following:
|
||||
|
||||
| value | named export | description |
|
||||
| ----: | :------------ | :-------------------- |
|
||||
| `0` | `DIFF_EQUAL` | in `a` and in `b` |
|
||||
| `-1` | `DIFF_DELETE` | in `a` but not in `b` |
|
||||
| `1` | `DIFF_INSERT` | in `b` but not in `a` |
|
||||
|
||||
The value at index `1` is a substring of `a` or `b` or both.
|
||||
|
||||
### Example of diffStringsRaw with cleanup
|
||||
|
||||
```js
|
||||
const diffs = diffStringsRaw('changed from', 'changed to', true);
|
||||
```
|
||||
|
||||
| `i` | `diffs[i][0]` | `diffs[i][1]` |
|
||||
| --: | ------------: | :------------ |
|
||||
| `0` | `0` | `'changed '` |
|
||||
| `1` | `-1` | `'from'` |
|
||||
| `2` | `1` | `'to'` |
|
||||
|
||||
### Example of diffStringsRaw without cleanup
|
||||
|
||||
```js
|
||||
const diffs = diffStringsRaw('changed from', 'changed to', false);
|
||||
```
|
||||
|
||||
| `i` | `diffs[i][0]` | `diffs[i][1]` |
|
||||
| --: | ------------: | :------------ |
|
||||
| `0` | `0` | `'changed '` |
|
||||
| `1` | `-1` | `'fr'` |
|
||||
| `2` | `1` | `'t'` |
|
||||
| `3` | `0` | `'o'` |
|
||||
| `4` | `-1` | `'m'` |
|
||||
|
||||
### Advanced import for diffStringsRaw
|
||||
|
||||
Here are all the named imports that you might need for the `diffStringsRaw` function:
|
||||
|
||||
- `const {DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, diffStringsRaw} = require('jest-diff');` in CommonJS modules
|
||||
- `import {DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, diffStringsRaw} from 'jest-diff';` in ECMAScript modules
|
||||
|
||||
To write a **formatting** function, you might need the named constants (and `Diff` in TypeScript annotations).
|
||||
|
||||
If you write an application-specific **cleanup** algorithm, then you might need to call the `Diff` constructor:
|
||||
|
||||
```js
|
||||
const diffCommon = new Diff(DIFF_EQUAL, 'changed ');
|
||||
const diffDelete = new Diff(DIFF_DELETE, 'from');
|
||||
const diffInsert = new Diff(DIFF_INSERT, 'to');
|
||||
```
|
||||
|
||||
## Usage of diffLinesRaw
|
||||
|
||||
Given **arrays of strings**, `diffLinesRaw(aLines, bLines)` does the following:
|
||||
|
||||
- **compare** the arrays line-by-line using the `diff-sequences` package
|
||||
|
||||
Because `diffLinesRaw` returns the difference as **data** instead of a string, you can format it as your application requires.
|
||||
|
||||
### Example of diffLinesRaw
|
||||
|
||||
```js
|
||||
const aLines = ['delete', 'common', 'changed from'];
|
||||
const bLines = ['common', 'changed to', 'insert'];
|
||||
|
||||
const diffs = diffLinesRaw(aLines, bLines);
|
||||
```
|
||||
|
||||
| `i` | `diffs[i][0]` | `diffs[i][1]` |
|
||||
| --: | ------------: | :--------------- |
|
||||
| `0` | `-1` | `'delete'` |
|
||||
| `1` | `0` | `'common'` |
|
||||
| `2` | `-1` | `'changed from'` |
|
||||
| `3` | `1` | `'changed to'` |
|
||||
| `4` | `1` | `'insert'` |
|
||||
|
||||
### Edge case of diffLinesRaw
|
||||
|
||||
If you call `string.split('\n')` for an empty string:
|
||||
|
||||
- the result is `['']` an array which contains an empty string
|
||||
- instead of `[]` an empty array
|
||||
|
||||
Depending of your application, you might call `diffLinesRaw` with either array.
|
||||
|
||||
### Example of split method
|
||||
|
||||
```js
|
||||
import {diffLinesRaw} from 'jest-diff';
|
||||
|
||||
const a = 'non-empty string';
|
||||
const b = '';
|
||||
|
||||
const diffs = diffLinesRaw(a.split('\n'), b.split('\n'));
|
||||
```
|
||||
|
||||
| `i` | `diffs[i][0]` | `diffs[i][1]` |
|
||||
| --: | ------------: | :------------------- |
|
||||
| `0` | `-1` | `'non-empty string'` |
|
||||
| `1` | `1` | `''` |
|
||||
|
||||
Which you might format as follows:
|
||||
|
||||
```diff
|
||||
- Expected - 1
|
||||
+ Received + 1
|
||||
|
||||
- non-empty string
|
||||
+
|
||||
```
|
||||
|
||||
### Example of splitLines0 function
|
||||
|
||||
For edge case behavior like the `diffLinesUnified` function, you might define a `splitLines0` function, which given an empty string, returns `[]` an empty array:
|
||||
|
||||
```js
|
||||
export const splitLines0 = string =>
|
||||
string.length === 0 ? [] : string.split('\n');
|
||||
```
|
||||
|
||||
```js
|
||||
import {diffLinesRaw} from 'jest-diff';
|
||||
|
||||
const a = '';
|
||||
const b = 'line 1\nline 2\nline 3';
|
||||
|
||||
const diffs = diffLinesRaw(a.split('\n'), b.split('\n'));
|
||||
```
|
||||
|
||||
| `i` | `diffs[i][0]` | `diffs[i][1]` |
|
||||
| --: | ------------: | :------------ |
|
||||
| `0` | `1` | `'line 1'` |
|
||||
| `1` | `1` | `'line 2'` |
|
||||
| `2` | `1` | `'line 3'` |
|
||||
|
||||
Which you might format as follows:
|
||||
|
||||
```diff
|
||||
- Expected - 0
|
||||
+ Received + 3
|
||||
|
||||
+ line 1
|
||||
+ line 2
|
||||
+ line 3
|
||||
```
|
||||
|
||||
In contrast to the `diffLinesRaw` function, the `diffLinesUnified` and `diffLinesUnified2` functions **automatically** convert array arguments computed by string `split` method, so callers do **not** need a `splitLine0` function.
|
||||
|
||||
## Options
|
||||
|
||||
The default options are for the report when an assertion fails from the `expect` package used by Jest.
|
||||
|
||||
For other applications, you can provide an options object as a third argument:
|
||||
|
||||
- `diffDefault(a, b, options)`
|
||||
- `diffStringsUnified(a, b, options)`
|
||||
- `diffLinesUnified(aLines, bLines, options)`
|
||||
- `diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCompare, options)`
|
||||
|
||||
### Properties of options object
|
||||
|
||||
| name | default |
|
||||
| :-------------------------------- | :----------------- |
|
||||
| `aAnnotation` | `'Expected'` |
|
||||
| `aColor` | `chalk.green` |
|
||||
| `aIndicator` | `'-'` |
|
||||
| `bAnnotation` | `'Received'` |
|
||||
| `bColor` | `chalk.red` |
|
||||
| `bIndicator` | `'+'` |
|
||||
| `changeColor` | `chalk.inverse` |
|
||||
| `changeLineTrailingSpaceColor` | `string => string` |
|
||||
| `commonColor` | `chalk.dim` |
|
||||
| `commonIndicator` | `' '` |
|
||||
| `commonLineTrailingSpaceColor` | `string => string` |
|
||||
| `contextLines` | `5` |
|
||||
| `emptyFirstOrLastLinePlaceholder` | `''` |
|
||||
| `expand` | `true` |
|
||||
| `includeChangeCounts` | `false` |
|
||||
| `omitAnnotationLines` | `false` |
|
||||
| `patchColor` | `chalk.yellow` |
|
||||
|
||||
For more information about the options, see the following examples.
|
||||
|
||||
### Example of options for labels
|
||||
|
||||
If the application is code modification, you might replace the labels:
|
||||
|
||||
```js
|
||||
const options = {
|
||||
aAnnotation: 'Original',
|
||||
bAnnotation: 'Modified',
|
||||
};
|
||||
```
|
||||
|
||||
```diff
|
||||
- Original
|
||||
+ Modified
|
||||
|
||||
common
|
||||
- changed from
|
||||
+ changed to
|
||||
```
|
||||
|
||||
The `jest-diff` package does not assume that the 2 labels have equal length.
|
||||
|
||||
### Example of options for colors of changed lines
|
||||
|
||||
For consistency with most diff tools, you might exchange the colors:
|
||||
|
||||
```ts
|
||||
import chalk = require('chalk');
|
||||
|
||||
const options = {
|
||||
aColor: chalk.red,
|
||||
bColor: chalk.green,
|
||||
};
|
||||
```
|
||||
|
||||
### Example of option for color of changed substrings
|
||||
|
||||
Although the default inverse of foreground and background colors is hard to beat for changed substrings **within lines**, especially because it highlights spaces, if you want bold font weight on yellow background color:
|
||||
|
||||
```ts
|
||||
import chalk = require('chalk');
|
||||
|
||||
const options = {
|
||||
changeColor: chalk.bold.bgYellowBright,
|
||||
};
|
||||
```
|
||||
|
||||
### Example of option to format trailing spaces
|
||||
|
||||
Because the default export does not display substring differences within lines, formatting can help you see when lines differ by the presence or absence of trailing spaces found by `/\s+$/` regular expression.
|
||||
|
||||
- If change lines have a background color, then you can see trailing spaces.
|
||||
- If common lines have default dim color, then you cannot see trailing spaces. You might want yellowish background color to see them.
|
||||
|
||||
```js
|
||||
const options = {
|
||||
aColor: chalk.rgb(128, 0, 128).bgRgb(255, 215, 255), // magenta
|
||||
bColor: chalk.rgb(0, 95, 0).bgRgb(215, 255, 215), // green
|
||||
commonLineTrailingSpaceColor: chalk.bgYellow,
|
||||
};
|
||||
```
|
||||
|
||||
The value of a Color option is a function, which given a string, returns a string.
|
||||
|
||||
If you want to replace trailing spaces with middle dot characters:
|
||||
|
||||
```js
|
||||
const replaceSpacesWithMiddleDot = string => '·'.repeat(string.length);
|
||||
|
||||
const options = {
|
||||
changeLineTrailingSpaceColor: replaceSpacesWithMiddleDot,
|
||||
commonLineTrailingSpaceColor: replaceSpacesWithMiddleDot,
|
||||
};
|
||||
```
|
||||
|
||||
If you need the TypeScript type of a Color option:
|
||||
|
||||
```ts
|
||||
import {DiffOptionsColor} from 'jest-diff';
|
||||
```
|
||||
|
||||
### Example of options for no colors
|
||||
|
||||
To store the difference in a file without escape codes for colors, provide an identity function:
|
||||
|
||||
```js
|
||||
const noColor = string => string;
|
||||
|
||||
const options = {
|
||||
aColor: noColor,
|
||||
bColor: noColor,
|
||||
changeColor: noColor,
|
||||
commonColor: noColor,
|
||||
patchColor: noColor,
|
||||
};
|
||||
```
|
||||
|
||||
### Example of options for indicators
|
||||
|
||||
For consistency with the `diff` command, you might replace the indicators:
|
||||
|
||||
```js
|
||||
const options = {
|
||||
aIndicator: '<',
|
||||
bIndicator: '>',
|
||||
};
|
||||
```
|
||||
|
||||
The `jest-diff` package assumes (but does not enforce) that the 3 indicators have equal length.
|
||||
|
||||
### Example of options to limit common lines
|
||||
|
||||
By default, the output includes all common lines.
|
||||
|
||||
To emphasize the changes, you might limit the number of common “context” lines:
|
||||
|
||||
```js
|
||||
const options = {
|
||||
contextLines: 1,
|
||||
expand: false,
|
||||
};
|
||||
```
|
||||
|
||||
A patch mark like `@@ -12,7 +12,9 @@` accounts for omitted common lines.
|
||||
|
||||
### Example of option for color of patch marks
|
||||
|
||||
If you want patch marks to have the same dim color as common lines:
|
||||
|
||||
```ts
|
||||
import chalk = require('chalk');
|
||||
|
||||
const options = {
|
||||
expand: false,
|
||||
patchColor: chalk.dim,
|
||||
};
|
||||
```
|
||||
|
||||
### Example of option to include change counts
|
||||
|
||||
To display the number of changed lines at the right of annotation lines:
|
||||
|
||||
```js
|
||||
const a = ['common', 'changed from'];
|
||||
const b = ['common', 'changed to', 'insert'];
|
||||
|
||||
const options = {
|
||||
includeChangeCounts: true,
|
||||
};
|
||||
|
||||
const difference = diffDefault(a, b, options);
|
||||
```
|
||||
|
||||
```diff
|
||||
- Expected - 1
|
||||
+ Received + 2
|
||||
|
||||
Array [
|
||||
"common",
|
||||
- "changed from",
|
||||
+ "changed to",
|
||||
+ "insert",
|
||||
]
|
||||
```
|
||||
|
||||
### Example of option to omit annotation lines
|
||||
|
||||
To display only the comparison lines:
|
||||
|
||||
```js
|
||||
const a = 'common\nchanged from';
|
||||
const b = 'common\nchanged to';
|
||||
|
||||
const options = {
|
||||
omitAnnotationLines: true,
|
||||
};
|
||||
|
||||
const difference = diffStringsUnified(a, b, options);
|
||||
```
|
||||
|
||||
```diff
|
||||
common
|
||||
- changed from
|
||||
+ changed to
|
||||
```
|
||||
|
||||
### Example of option for empty first or last lines
|
||||
|
||||
If the **first** or **last** comparison line is **empty**, because the content is empty and the indicator is a space, you might not notice it.
|
||||
|
||||
The replacement option is a string whose default value is `''` empty string.
|
||||
|
||||
Because Jest trims the report when a matcher fails, it deletes an empty last line.
|
||||
|
||||
Therefore, Jest uses as placeholder the downwards arrow with corner leftwards:
|
||||
|
||||
```js
|
||||
const options = {
|
||||
emptyFirstOrLastLinePlaceholder: '↵', // U+21B5
|
||||
};
|
||||
```
|
||||
|
||||
If a content line is empty, then the corresponding comparison line is automatically trimmed to remove the margin space (represented as a middle dot below) for the default indicators:
|
||||
|
||||
| Indicator | untrimmed | trimmed |
|
||||
| ----------------: | :-------- | :------ |
|
||||
| `aIndicator` | `'-·'` | `'-'` |
|
||||
| `bIndicator` | `'+·'` | `'+'` |
|
||||
| `commonIndicator` | `' ·'` | `''` |
|
57
node_modules/jest-snapshot/node_modules/jest-diff/build/cleanupSemantic.d.ts
generated
vendored
Normal file
57
node_modules/jest-snapshot/node_modules/jest-diff/build/cleanupSemantic.d.ts
generated
vendored
Normal file
@ -0,0 +1,57 @@
|
||||
/**
|
||||
* Diff Match and Patch
|
||||
* Copyright 2018 The diff-match-patch Authors.
|
||||
* https://github.com/google/diff-match-patch
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
/**
|
||||
* @fileoverview Computes the difference between two texts to create a patch.
|
||||
* Applies the patch onto another text, allowing for errors.
|
||||
* @author fraser@google.com (Neil Fraser)
|
||||
*/
|
||||
/**
|
||||
* CHANGES by pedrottimark to diff_match_patch_uncompressed.ts file:
|
||||
*
|
||||
* 1. Delete anything not needed to use diff_cleanupSemantic method
|
||||
* 2. Convert from prototype properties to var declarations
|
||||
* 3. Convert Diff to class from constructor and prototype
|
||||
* 4. Add type annotations for arguments and return values
|
||||
* 5. Add exports
|
||||
*/
|
||||
/**
|
||||
* The data structure representing a diff is an array of tuples:
|
||||
* [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
|
||||
* which means: delete 'Hello', add 'Goodbye' and keep ' world.'
|
||||
*/
|
||||
declare var DIFF_DELETE: number;
|
||||
declare var DIFF_INSERT: number;
|
||||
declare var DIFF_EQUAL: number;
|
||||
/**
|
||||
* Class representing one diff tuple.
|
||||
* Attempts to look like a two-element array (which is what this used to be).
|
||||
* @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.
|
||||
* @param {string} text Text to be deleted, inserted, or retained.
|
||||
* @constructor
|
||||
*/
|
||||
declare class Diff {
|
||||
0: number;
|
||||
1: string;
|
||||
constructor(op: number, text: string);
|
||||
}
|
||||
/**
|
||||
* Reduce the number of edits by eliminating semantically trivial equalities.
|
||||
* @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
|
||||
*/
|
||||
declare var diff_cleanupSemantic: (diffs: Array<Diff>) => void;
|
||||
export { Diff, DIFF_EQUAL, DIFF_DELETE, DIFF_INSERT, diff_cleanupSemantic as cleanupSemantic, };
|
651
node_modules/jest-snapshot/node_modules/jest-diff/build/cleanupSemantic.js
generated
vendored
Normal file
651
node_modules/jest-snapshot/node_modules/jest-diff/build/cleanupSemantic.js
generated
vendored
Normal file
@ -0,0 +1,651 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.cleanupSemantic = exports.DIFF_INSERT = exports.DIFF_DELETE = exports.DIFF_EQUAL = exports.Diff = void 0;
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Diff Match and Patch
|
||||
* Copyright 2018 The diff-match-patch Authors.
|
||||
* https://github.com/google/diff-match-patch
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @fileoverview Computes the difference between two texts to create a patch.
|
||||
* Applies the patch onto another text, allowing for errors.
|
||||
* @author fraser@google.com (Neil Fraser)
|
||||
*/
|
||||
|
||||
/**
|
||||
* CHANGES by pedrottimark to diff_match_patch_uncompressed.ts file:
|
||||
*
|
||||
* 1. Delete anything not needed to use diff_cleanupSemantic method
|
||||
* 2. Convert from prototype properties to var declarations
|
||||
* 3. Convert Diff to class from constructor and prototype
|
||||
* 4. Add type annotations for arguments and return values
|
||||
* 5. Add exports
|
||||
*/
|
||||
|
||||
/**
|
||||
* The data structure representing a diff is an array of tuples:
|
||||
* [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
|
||||
* which means: delete 'Hello', add 'Goodbye' and keep ' world.'
|
||||
*/
|
||||
var DIFF_DELETE = -1;
|
||||
exports.DIFF_DELETE = DIFF_DELETE;
|
||||
var DIFF_INSERT = 1;
|
||||
exports.DIFF_INSERT = DIFF_INSERT;
|
||||
var DIFF_EQUAL = 0;
|
||||
/**
|
||||
* Class representing one diff tuple.
|
||||
* Attempts to look like a two-element array (which is what this used to be).
|
||||
* @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.
|
||||
* @param {string} text Text to be deleted, inserted, or retained.
|
||||
* @constructor
|
||||
*/
|
||||
|
||||
exports.DIFF_EQUAL = DIFF_EQUAL;
|
||||
|
||||
class Diff {
|
||||
constructor(op, text) {
|
||||
_defineProperty(this, 0, void 0);
|
||||
|
||||
_defineProperty(this, 1, void 0);
|
||||
|
||||
this[0] = op;
|
||||
this[1] = text;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* Determine the common prefix of two strings.
|
||||
* @param {string} text1 First string.
|
||||
* @param {string} text2 Second string.
|
||||
* @return {number} The number of characters common to the start of each
|
||||
* string.
|
||||
*/
|
||||
|
||||
exports.Diff = Diff;
|
||||
|
||||
var diff_commonPrefix = function (text1, text2) {
|
||||
// Quick check for common null cases.
|
||||
if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {
|
||||
return 0;
|
||||
} // Binary search.
|
||||
// Performance analysis: https://neil.fraser.name/news/2007/10/09/
|
||||
|
||||
var pointermin = 0;
|
||||
var pointermax = Math.min(text1.length, text2.length);
|
||||
var pointermid = pointermax;
|
||||
var pointerstart = 0;
|
||||
|
||||
while (pointermin < pointermid) {
|
||||
if (
|
||||
text1.substring(pointerstart, pointermid) ==
|
||||
text2.substring(pointerstart, pointermid)
|
||||
) {
|
||||
pointermin = pointermid;
|
||||
pointerstart = pointermin;
|
||||
} else {
|
||||
pointermax = pointermid;
|
||||
}
|
||||
|
||||
pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
|
||||
}
|
||||
|
||||
return pointermid;
|
||||
};
|
||||
/**
|
||||
* Determine the common suffix of two strings.
|
||||
* @param {string} text1 First string.
|
||||
* @param {string} text2 Second string.
|
||||
* @return {number} The number of characters common to the end of each string.
|
||||
*/
|
||||
|
||||
var diff_commonSuffix = function (text1, text2) {
|
||||
// Quick check for common null cases.
|
||||
if (
|
||||
!text1 ||
|
||||
!text2 ||
|
||||
text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)
|
||||
) {
|
||||
return 0;
|
||||
} // Binary search.
|
||||
// Performance analysis: https://neil.fraser.name/news/2007/10/09/
|
||||
|
||||
var pointermin = 0;
|
||||
var pointermax = Math.min(text1.length, text2.length);
|
||||
var pointermid = pointermax;
|
||||
var pointerend = 0;
|
||||
|
||||
while (pointermin < pointermid) {
|
||||
if (
|
||||
text1.substring(text1.length - pointermid, text1.length - pointerend) ==
|
||||
text2.substring(text2.length - pointermid, text2.length - pointerend)
|
||||
) {
|
||||
pointermin = pointermid;
|
||||
pointerend = pointermin;
|
||||
} else {
|
||||
pointermax = pointermid;
|
||||
}
|
||||
|
||||
pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
|
||||
}
|
||||
|
||||
return pointermid;
|
||||
};
|
||||
/**
|
||||
* Determine if the suffix of one string is the prefix of another.
|
||||
* @param {string} text1 First string.
|
||||
* @param {string} text2 Second string.
|
||||
* @return {number} The number of characters common to the end of the first
|
||||
* string and the start of the second string.
|
||||
* @private
|
||||
*/
|
||||
|
||||
var diff_commonOverlap_ = function (text1, text2) {
|
||||
// Cache the text lengths to prevent multiple calls.
|
||||
var text1_length = text1.length;
|
||||
var text2_length = text2.length; // Eliminate the null case.
|
||||
|
||||
if (text1_length == 0 || text2_length == 0) {
|
||||
return 0;
|
||||
} // Truncate the longer string.
|
||||
|
||||
if (text1_length > text2_length) {
|
||||
text1 = text1.substring(text1_length - text2_length);
|
||||
} else if (text1_length < text2_length) {
|
||||
text2 = text2.substring(0, text1_length);
|
||||
}
|
||||
|
||||
var text_length = Math.min(text1_length, text2_length); // Quick check for the worst case.
|
||||
|
||||
if (text1 == text2) {
|
||||
return text_length;
|
||||
} // Start by looking for a single character match
|
||||
// and increase length until no match is found.
|
||||
// Performance analysis: https://neil.fraser.name/news/2010/11/04/
|
||||
|
||||
var best = 0;
|
||||
var length = 1;
|
||||
|
||||
while (true) {
|
||||
var pattern = text1.substring(text_length - length);
|
||||
var found = text2.indexOf(pattern);
|
||||
|
||||
if (found == -1) {
|
||||
return best;
|
||||
}
|
||||
|
||||
length += found;
|
||||
|
||||
if (
|
||||
found == 0 ||
|
||||
text1.substring(text_length - length) == text2.substring(0, length)
|
||||
) {
|
||||
best = length;
|
||||
length++;
|
||||
}
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Reduce the number of edits by eliminating semantically trivial equalities.
|
||||
* @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
|
||||
*/
|
||||
|
||||
var diff_cleanupSemantic = function (diffs) {
|
||||
var changes = false;
|
||||
var equalities = []; // Stack of indices where equalities are found.
|
||||
|
||||
var equalitiesLength = 0; // Keeping our own length var is faster in JS.
|
||||
|
||||
/** @type {?string} */
|
||||
|
||||
var lastEquality = null; // Always equal to diffs[equalities[equalitiesLength - 1]][1]
|
||||
|
||||
var pointer = 0; // Index of current position.
|
||||
// Number of characters that changed prior to the equality.
|
||||
|
||||
var length_insertions1 = 0;
|
||||
var length_deletions1 = 0; // Number of characters that changed after the equality.
|
||||
|
||||
var length_insertions2 = 0;
|
||||
var length_deletions2 = 0;
|
||||
|
||||
while (pointer < diffs.length) {
|
||||
if (diffs[pointer][0] == DIFF_EQUAL) {
|
||||
// Equality found.
|
||||
equalities[equalitiesLength++] = pointer;
|
||||
length_insertions1 = length_insertions2;
|
||||
length_deletions1 = length_deletions2;
|
||||
length_insertions2 = 0;
|
||||
length_deletions2 = 0;
|
||||
lastEquality = diffs[pointer][1];
|
||||
} else {
|
||||
// An insertion or deletion.
|
||||
if (diffs[pointer][0] == DIFF_INSERT) {
|
||||
length_insertions2 += diffs[pointer][1].length;
|
||||
} else {
|
||||
length_deletions2 += diffs[pointer][1].length;
|
||||
} // Eliminate an equality that is smaller or equal to the edits on both
|
||||
// sides of it.
|
||||
|
||||
if (
|
||||
lastEquality &&
|
||||
lastEquality.length <=
|
||||
Math.max(length_insertions1, length_deletions1) &&
|
||||
lastEquality.length <= Math.max(length_insertions2, length_deletions2)
|
||||
) {
|
||||
// Duplicate record.
|
||||
diffs.splice(
|
||||
equalities[equalitiesLength - 1],
|
||||
0,
|
||||
new Diff(DIFF_DELETE, lastEquality)
|
||||
); // Change second copy to insert.
|
||||
|
||||
diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT; // Throw away the equality we just deleted.
|
||||
|
||||
equalitiesLength--; // Throw away the previous equality (it needs to be reevaluated).
|
||||
|
||||
equalitiesLength--;
|
||||
pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
|
||||
length_insertions1 = 0; // Reset the counters.
|
||||
|
||||
length_deletions1 = 0;
|
||||
length_insertions2 = 0;
|
||||
length_deletions2 = 0;
|
||||
lastEquality = null;
|
||||
changes = true;
|
||||
}
|
||||
}
|
||||
|
||||
pointer++;
|
||||
} // Normalize the diff.
|
||||
|
||||
if (changes) {
|
||||
diff_cleanupMerge(diffs);
|
||||
}
|
||||
|
||||
diff_cleanupSemanticLossless(diffs); // Find any overlaps between deletions and insertions.
|
||||
// e.g: <del>abcxxx</del><ins>xxxdef</ins>
|
||||
// -> <del>abc</del>xxx<ins>def</ins>
|
||||
// e.g: <del>xxxabc</del><ins>defxxx</ins>
|
||||
// -> <ins>def</ins>xxx<del>abc</del>
|
||||
// Only extract an overlap if it is as big as the edit ahead or behind it.
|
||||
|
||||
pointer = 1;
|
||||
|
||||
while (pointer < diffs.length) {
|
||||
if (
|
||||
diffs[pointer - 1][0] == DIFF_DELETE &&
|
||||
diffs[pointer][0] == DIFF_INSERT
|
||||
) {
|
||||
var deletion = diffs[pointer - 1][1];
|
||||
var insertion = diffs[pointer][1];
|
||||
var overlap_length1 = diff_commonOverlap_(deletion, insertion);
|
||||
var overlap_length2 = diff_commonOverlap_(insertion, deletion);
|
||||
|
||||
if (overlap_length1 >= overlap_length2) {
|
||||
if (
|
||||
overlap_length1 >= deletion.length / 2 ||
|
||||
overlap_length1 >= insertion.length / 2
|
||||
) {
|
||||
// Overlap found. Insert an equality and trim the surrounding edits.
|
||||
diffs.splice(
|
||||
pointer,
|
||||
0,
|
||||
new Diff(DIFF_EQUAL, insertion.substring(0, overlap_length1))
|
||||
);
|
||||
diffs[pointer - 1][1] = deletion.substring(
|
||||
0,
|
||||
deletion.length - overlap_length1
|
||||
);
|
||||
diffs[pointer + 1][1] = insertion.substring(overlap_length1);
|
||||
pointer++;
|
||||
}
|
||||
} else {
|
||||
if (
|
||||
overlap_length2 >= deletion.length / 2 ||
|
||||
overlap_length2 >= insertion.length / 2
|
||||
) {
|
||||
// Reverse overlap found.
|
||||
// Insert an equality and swap and trim the surrounding edits.
|
||||
diffs.splice(
|
||||
pointer,
|
||||
0,
|
||||
new Diff(DIFF_EQUAL, deletion.substring(0, overlap_length2))
|
||||
);
|
||||
diffs[pointer - 1][0] = DIFF_INSERT;
|
||||
diffs[pointer - 1][1] = insertion.substring(
|
||||
0,
|
||||
insertion.length - overlap_length2
|
||||
);
|
||||
diffs[pointer + 1][0] = DIFF_DELETE;
|
||||
diffs[pointer + 1][1] = deletion.substring(overlap_length2);
|
||||
pointer++;
|
||||
}
|
||||
}
|
||||
|
||||
pointer++;
|
||||
}
|
||||
|
||||
pointer++;
|
||||
}
|
||||
};
|
||||
/**
|
||||
* Look for single edits surrounded on both sides by equalities
|
||||
* which can be shifted sideways to align the edit to a word boundary.
|
||||
* e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
|
||||
* @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
|
||||
*/
|
||||
|
||||
exports.cleanupSemantic = diff_cleanupSemantic;
|
||||
|
||||
var diff_cleanupSemanticLossless = function (diffs) {
|
||||
/**
|
||||
* Given two strings, compute a score representing whether the internal
|
||||
* boundary falls on logical boundaries.
|
||||
* Scores range from 6 (best) to 0 (worst).
|
||||
* Closure, but does not reference any external variables.
|
||||
* @param {string} one First string.
|
||||
* @param {string} two Second string.
|
||||
* @return {number} The score.
|
||||
* @private
|
||||
*/
|
||||
function diff_cleanupSemanticScore_(one, two) {
|
||||
if (!one || !two) {
|
||||
// Edges are the best.
|
||||
return 6;
|
||||
} // Each port of this function behaves slightly differently due to
|
||||
// subtle differences in each language's definition of things like
|
||||
// 'whitespace'. Since this function's purpose is largely cosmetic,
|
||||
// the choice has been made to use each language's native features
|
||||
// rather than force total conformity.
|
||||
|
||||
var char1 = one.charAt(one.length - 1);
|
||||
var char2 = two.charAt(0);
|
||||
var nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex_);
|
||||
var nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);
|
||||
var whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex_);
|
||||
var whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex_);
|
||||
var lineBreak1 = whitespace1 && char1.match(linebreakRegex_);
|
||||
var lineBreak2 = whitespace2 && char2.match(linebreakRegex_);
|
||||
var blankLine1 = lineBreak1 && one.match(blanklineEndRegex_);
|
||||
var blankLine2 = lineBreak2 && two.match(blanklineStartRegex_);
|
||||
|
||||
if (blankLine1 || blankLine2) {
|
||||
// Five points for blank lines.
|
||||
return 5;
|
||||
} else if (lineBreak1 || lineBreak2) {
|
||||
// Four points for line breaks.
|
||||
return 4;
|
||||
} else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {
|
||||
// Three points for end of sentences.
|
||||
return 3;
|
||||
} else if (whitespace1 || whitespace2) {
|
||||
// Two points for whitespace.
|
||||
return 2;
|
||||
} else if (nonAlphaNumeric1 || nonAlphaNumeric2) {
|
||||
// One point for non-alphanumeric.
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
var pointer = 1; // Intentionally ignore the first and last element (don't need checking).
|
||||
|
||||
while (pointer < diffs.length - 1) {
|
||||
if (
|
||||
diffs[pointer - 1][0] == DIFF_EQUAL &&
|
||||
diffs[pointer + 1][0] == DIFF_EQUAL
|
||||
) {
|
||||
// This is a single edit surrounded by equalities.
|
||||
var equality1 = diffs[pointer - 1][1];
|
||||
var edit = diffs[pointer][1];
|
||||
var equality2 = diffs[pointer + 1][1]; // First, shift the edit as far left as possible.
|
||||
|
||||
var commonOffset = diff_commonSuffix(equality1, edit);
|
||||
|
||||
if (commonOffset) {
|
||||
var commonString = edit.substring(edit.length - commonOffset);
|
||||
equality1 = equality1.substring(0, equality1.length - commonOffset);
|
||||
edit = commonString + edit.substring(0, edit.length - commonOffset);
|
||||
equality2 = commonString + equality2;
|
||||
} // Second, step character by character right, looking for the best fit.
|
||||
|
||||
var bestEquality1 = equality1;
|
||||
var bestEdit = edit;
|
||||
var bestEquality2 = equality2;
|
||||
var bestScore =
|
||||
diff_cleanupSemanticScore_(equality1, edit) +
|
||||
diff_cleanupSemanticScore_(edit, equality2);
|
||||
|
||||
while (edit.charAt(0) === equality2.charAt(0)) {
|
||||
equality1 += edit.charAt(0);
|
||||
edit = edit.substring(1) + equality2.charAt(0);
|
||||
equality2 = equality2.substring(1);
|
||||
var score =
|
||||
diff_cleanupSemanticScore_(equality1, edit) +
|
||||
diff_cleanupSemanticScore_(edit, equality2); // The >= encourages trailing rather than leading whitespace on edits.
|
||||
|
||||
if (score >= bestScore) {
|
||||
bestScore = score;
|
||||
bestEquality1 = equality1;
|
||||
bestEdit = edit;
|
||||
bestEquality2 = equality2;
|
||||
}
|
||||
}
|
||||
|
||||
if (diffs[pointer - 1][1] != bestEquality1) {
|
||||
// We have an improvement, save it back to the diff.
|
||||
if (bestEquality1) {
|
||||
diffs[pointer - 1][1] = bestEquality1;
|
||||
} else {
|
||||
diffs.splice(pointer - 1, 1);
|
||||
pointer--;
|
||||
}
|
||||
|
||||
diffs[pointer][1] = bestEdit;
|
||||
|
||||
if (bestEquality2) {
|
||||
diffs[pointer + 1][1] = bestEquality2;
|
||||
} else {
|
||||
diffs.splice(pointer + 1, 1);
|
||||
pointer--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pointer++;
|
||||
}
|
||||
}; // Define some regex patterns for matching boundaries.
|
||||
|
||||
var nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
|
||||
var whitespaceRegex_ = /\s/;
|
||||
var linebreakRegex_ = /[\r\n]/;
|
||||
var blanklineEndRegex_ = /\n\r?\n$/;
|
||||
var blanklineStartRegex_ = /^\r?\n\r?\n/;
|
||||
/**
|
||||
* Reorder and merge like edit sections. Merge equalities.
|
||||
* Any edit section can move as long as it doesn't cross an equality.
|
||||
* @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
|
||||
*/
|
||||
|
||||
var diff_cleanupMerge = function (diffs) {
|
||||
// Add a dummy entry at the end.
|
||||
diffs.push(new Diff(DIFF_EQUAL, ''));
|
||||
var pointer = 0;
|
||||
var count_delete = 0;
|
||||
var count_insert = 0;
|
||||
var text_delete = '';
|
||||
var text_insert = '';
|
||||
var commonlength;
|
||||
|
||||
while (pointer < diffs.length) {
|
||||
switch (diffs[pointer][0]) {
|
||||
case DIFF_INSERT:
|
||||
count_insert++;
|
||||
text_insert += diffs[pointer][1];
|
||||
pointer++;
|
||||
break;
|
||||
|
||||
case DIFF_DELETE:
|
||||
count_delete++;
|
||||
text_delete += diffs[pointer][1];
|
||||
pointer++;
|
||||
break;
|
||||
|
||||
case DIFF_EQUAL:
|
||||
// Upon reaching an equality, check for prior redundancies.
|
||||
if (count_delete + count_insert > 1) {
|
||||
if (count_delete !== 0 && count_insert !== 0) {
|
||||
// Factor out any common prefixies.
|
||||
commonlength = diff_commonPrefix(text_insert, text_delete);
|
||||
|
||||
if (commonlength !== 0) {
|
||||
if (
|
||||
pointer - count_delete - count_insert > 0 &&
|
||||
diffs[pointer - count_delete - count_insert - 1][0] ==
|
||||
DIFF_EQUAL
|
||||
) {
|
||||
diffs[
|
||||
pointer - count_delete - count_insert - 1
|
||||
][1] += text_insert.substring(0, commonlength);
|
||||
} else {
|
||||
diffs.splice(
|
||||
0,
|
||||
0,
|
||||
new Diff(DIFF_EQUAL, text_insert.substring(0, commonlength))
|
||||
);
|
||||
pointer++;
|
||||
}
|
||||
|
||||
text_insert = text_insert.substring(commonlength);
|
||||
text_delete = text_delete.substring(commonlength);
|
||||
} // Factor out any common suffixies.
|
||||
|
||||
commonlength = diff_commonSuffix(text_insert, text_delete);
|
||||
|
||||
if (commonlength !== 0) {
|
||||
diffs[pointer][1] =
|
||||
text_insert.substring(text_insert.length - commonlength) +
|
||||
diffs[pointer][1];
|
||||
text_insert = text_insert.substring(
|
||||
0,
|
||||
text_insert.length - commonlength
|
||||
);
|
||||
text_delete = text_delete.substring(
|
||||
0,
|
||||
text_delete.length - commonlength
|
||||
);
|
||||
}
|
||||
} // Delete the offending records and add the merged ones.
|
||||
|
||||
pointer -= count_delete + count_insert;
|
||||
diffs.splice(pointer, count_delete + count_insert);
|
||||
|
||||
if (text_delete.length) {
|
||||
diffs.splice(pointer, 0, new Diff(DIFF_DELETE, text_delete));
|
||||
pointer++;
|
||||
}
|
||||
|
||||
if (text_insert.length) {
|
||||
diffs.splice(pointer, 0, new Diff(DIFF_INSERT, text_insert));
|
||||
pointer++;
|
||||
}
|
||||
|
||||
pointer++;
|
||||
} else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) {
|
||||
// Merge this equality with the previous one.
|
||||
diffs[pointer - 1][1] += diffs[pointer][1];
|
||||
diffs.splice(pointer, 1);
|
||||
} else {
|
||||
pointer++;
|
||||
}
|
||||
|
||||
count_insert = 0;
|
||||
count_delete = 0;
|
||||
text_delete = '';
|
||||
text_insert = '';
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (diffs[diffs.length - 1][1] === '') {
|
||||
diffs.pop(); // Remove the dummy entry at the end.
|
||||
} // Second pass: look for single edits surrounded on both sides by equalities
|
||||
// which can be shifted sideways to eliminate an equality.
|
||||
// e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
|
||||
|
||||
var changes = false;
|
||||
pointer = 1; // Intentionally ignore the first and last element (don't need checking).
|
||||
|
||||
while (pointer < diffs.length - 1) {
|
||||
if (
|
||||
diffs[pointer - 1][0] == DIFF_EQUAL &&
|
||||
diffs[pointer + 1][0] == DIFF_EQUAL
|
||||
) {
|
||||
// This is a single edit surrounded by equalities.
|
||||
if (
|
||||
diffs[pointer][1].substring(
|
||||
diffs[pointer][1].length - diffs[pointer - 1][1].length
|
||||
) == diffs[pointer - 1][1]
|
||||
) {
|
||||
// Shift the edit over the previous equality.
|
||||
diffs[pointer][1] =
|
||||
diffs[pointer - 1][1] +
|
||||
diffs[pointer][1].substring(
|
||||
0,
|
||||
diffs[pointer][1].length - diffs[pointer - 1][1].length
|
||||
);
|
||||
diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
|
||||
diffs.splice(pointer - 1, 1);
|
||||
changes = true;
|
||||
} else if (
|
||||
diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==
|
||||
diffs[pointer + 1][1]
|
||||
) {
|
||||
// Shift the edit over the next equality.
|
||||
diffs[pointer - 1][1] += diffs[pointer + 1][1];
|
||||
diffs[pointer][1] =
|
||||
diffs[pointer][1].substring(diffs[pointer + 1][1].length) +
|
||||
diffs[pointer + 1][1];
|
||||
diffs.splice(pointer + 1, 1);
|
||||
changes = true;
|
||||
}
|
||||
}
|
||||
|
||||
pointer++;
|
||||
} // If shifts were made, the diff needs reordering and another shift sweep.
|
||||
|
||||
if (changes) {
|
||||
diff_cleanupMerge(diffs);
|
||||
}
|
||||
};
|
8
node_modules/jest-snapshot/node_modules/jest-diff/build/constants.d.ts
generated
vendored
Normal file
8
node_modules/jest-snapshot/node_modules/jest-diff/build/constants.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 const NO_DIFF_MESSAGE = "Compared values have no visual difference.";
|
||||
export declare const SIMILAR_MESSAGE: string;
|
19
node_modules/jest-snapshot/node_modules/jest-diff/build/constants.js
generated
vendored
Normal file
19
node_modules/jest-snapshot/node_modules/jest-diff/build/constants.js
generated
vendored
Normal file
@ -0,0 +1,19 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.SIMILAR_MESSAGE = exports.NO_DIFF_MESSAGE = 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.
|
||||
*/
|
||||
const NO_DIFF_MESSAGE = 'Compared values have no visual difference.';
|
||||
exports.NO_DIFF_MESSAGE = NO_DIFF_MESSAGE;
|
||||
const SIMILAR_MESSAGE =
|
||||
'Compared values serialize to the same structure.\n' +
|
||||
'Printing internal object structure without calling `toJSON` instead.';
|
||||
exports.SIMILAR_MESSAGE = SIMILAR_MESSAGE;
|
11
node_modules/jest-snapshot/node_modules/jest-diff/build/diffLines.d.ts
generated
vendored
Normal file
11
node_modules/jest-snapshot/node_modules/jest-diff/build/diffLines.d.ts
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
/**
|
||||
* 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 { Diff } from './cleanupSemantic';
|
||||
import type { DiffOptions } from './types';
|
||||
export declare const diffLinesUnified: (aLines: Array<string>, bLines: Array<string>, options?: DiffOptions | undefined) => string;
|
||||
export declare const diffLinesUnified2: (aLinesDisplay: Array<string>, bLinesDisplay: Array<string>, aLinesCompare: Array<string>, bLinesCompare: Array<string>, options?: DiffOptions | undefined) => string;
|
||||
export declare const diffLinesRaw: (aLines: Array<string>, bLines: Array<string>) => Array<Diff>;
|
143
node_modules/jest-snapshot/node_modules/jest-diff/build/diffLines.js
generated
vendored
Normal file
143
node_modules/jest-snapshot/node_modules/jest-diff/build/diffLines.js
generated
vendored
Normal file
@ -0,0 +1,143 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.diffLinesRaw = exports.diffLinesUnified2 = exports.diffLinesUnified = void 0;
|
||||
|
||||
var _diffSequences = _interopRequireDefault(require('diff-sequences'));
|
||||
|
||||
var _cleanupSemantic = require('./cleanupSemantic');
|
||||
|
||||
var _normalizeDiffOptions = require('./normalizeDiffOptions');
|
||||
|
||||
var _printDiffs = require('./printDiffs');
|
||||
|
||||
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 isEmptyString = lines => lines.length === 1 && lines[0].length === 0; // Compare two arrays of strings line-by-line. Format as comparison lines.
|
||||
|
||||
const diffLinesUnified = (aLines, bLines, options) =>
|
||||
(0, _printDiffs.printDiffLines)(
|
||||
diffLinesRaw(
|
||||
isEmptyString(aLines) ? [] : aLines,
|
||||
isEmptyString(bLines) ? [] : bLines
|
||||
),
|
||||
(0, _normalizeDiffOptions.normalizeDiffOptions)(options)
|
||||
); // Given two pairs of arrays of strings:
|
||||
// Compare the pair of comparison arrays line-by-line.
|
||||
// Format the corresponding lines in the pair of displayable arrays.
|
||||
|
||||
exports.diffLinesUnified = diffLinesUnified;
|
||||
|
||||
const diffLinesUnified2 = (
|
||||
aLinesDisplay,
|
||||
bLinesDisplay,
|
||||
aLinesCompare,
|
||||
bLinesCompare,
|
||||
options
|
||||
) => {
|
||||
if (isEmptyString(aLinesDisplay) && isEmptyString(aLinesCompare)) {
|
||||
aLinesDisplay = [];
|
||||
aLinesCompare = [];
|
||||
}
|
||||
|
||||
if (isEmptyString(bLinesDisplay) && isEmptyString(bLinesCompare)) {
|
||||
bLinesDisplay = [];
|
||||
bLinesCompare = [];
|
||||
}
|
||||
|
||||
if (
|
||||
aLinesDisplay.length !== aLinesCompare.length ||
|
||||
bLinesDisplay.length !== bLinesCompare.length
|
||||
) {
|
||||
// Fall back to diff of display lines.
|
||||
return diffLinesUnified(aLinesDisplay, bLinesDisplay, options);
|
||||
}
|
||||
|
||||
const diffs = diffLinesRaw(aLinesCompare, bLinesCompare); // Replace comparison lines with displayable lines.
|
||||
|
||||
let aIndex = 0;
|
||||
let bIndex = 0;
|
||||
diffs.forEach(diff => {
|
||||
switch (diff[0]) {
|
||||
case _cleanupSemantic.DIFF_DELETE:
|
||||
diff[1] = aLinesDisplay[aIndex];
|
||||
aIndex += 1;
|
||||
break;
|
||||
|
||||
case _cleanupSemantic.DIFF_INSERT:
|
||||
diff[1] = bLinesDisplay[bIndex];
|
||||
bIndex += 1;
|
||||
break;
|
||||
|
||||
default:
|
||||
diff[1] = bLinesDisplay[bIndex];
|
||||
aIndex += 1;
|
||||
bIndex += 1;
|
||||
}
|
||||
});
|
||||
return (0, _printDiffs.printDiffLines)(
|
||||
diffs,
|
||||
(0, _normalizeDiffOptions.normalizeDiffOptions)(options)
|
||||
);
|
||||
}; // Compare two arrays of strings line-by-line.
|
||||
|
||||
exports.diffLinesUnified2 = diffLinesUnified2;
|
||||
|
||||
const diffLinesRaw = (aLines, bLines) => {
|
||||
const aLength = aLines.length;
|
||||
const bLength = bLines.length;
|
||||
|
||||
const isCommon = (aIndex, bIndex) => aLines[aIndex] === bLines[bIndex];
|
||||
|
||||
const diffs = [];
|
||||
let aIndex = 0;
|
||||
let bIndex = 0;
|
||||
|
||||
const foundSubsequence = (nCommon, aCommon, bCommon) => {
|
||||
for (; aIndex !== aCommon; aIndex += 1) {
|
||||
diffs.push(
|
||||
new _cleanupSemantic.Diff(_cleanupSemantic.DIFF_DELETE, aLines[aIndex])
|
||||
);
|
||||
}
|
||||
|
||||
for (; bIndex !== bCommon; bIndex += 1) {
|
||||
diffs.push(
|
||||
new _cleanupSemantic.Diff(_cleanupSemantic.DIFF_INSERT, bLines[bIndex])
|
||||
);
|
||||
}
|
||||
|
||||
for (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1) {
|
||||
diffs.push(
|
||||
new _cleanupSemantic.Diff(_cleanupSemantic.DIFF_EQUAL, bLines[bIndex])
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
(0, _diffSequences.default)(aLength, bLength, isCommon, foundSubsequence); // After the last common subsequence, push remaining change items.
|
||||
|
||||
for (; aIndex !== aLength; aIndex += 1) {
|
||||
diffs.push(
|
||||
new _cleanupSemantic.Diff(_cleanupSemantic.DIFF_DELETE, aLines[aIndex])
|
||||
);
|
||||
}
|
||||
|
||||
for (; bIndex !== bLength; bIndex += 1) {
|
||||
diffs.push(
|
||||
new _cleanupSemantic.Diff(_cleanupSemantic.DIFF_INSERT, bLines[bIndex])
|
||||
);
|
||||
}
|
||||
|
||||
return diffs;
|
||||
};
|
||||
|
||||
exports.diffLinesRaw = diffLinesRaw;
|
9
node_modules/jest-snapshot/node_modules/jest-diff/build/diffStrings.d.ts
generated
vendored
Normal file
9
node_modules/jest-snapshot/node_modules/jest-diff/build/diffStrings.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 { Diff } from './cleanupSemantic';
|
||||
declare const diffStrings: (a: string, b: string) => Array<Diff>;
|
||||
export default diffStrings;
|
78
node_modules/jest-snapshot/node_modules/jest-diff/build/diffStrings.js
generated
vendored
Normal file
78
node_modules/jest-snapshot/node_modules/jest-diff/build/diffStrings.js
generated
vendored
Normal file
@ -0,0 +1,78 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var _diffSequences = _interopRequireDefault(require('diff-sequences'));
|
||||
|
||||
var _cleanupSemantic = require('./cleanupSemantic');
|
||||
|
||||
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 diffStrings = (a, b) => {
|
||||
const isCommon = (aIndex, bIndex) => a[aIndex] === b[bIndex];
|
||||
|
||||
let aIndex = 0;
|
||||
let bIndex = 0;
|
||||
const diffs = [];
|
||||
|
||||
const foundSubsequence = (nCommon, aCommon, bCommon) => {
|
||||
if (aIndex !== aCommon) {
|
||||
diffs.push(
|
||||
new _cleanupSemantic.Diff(
|
||||
_cleanupSemantic.DIFF_DELETE,
|
||||
a.slice(aIndex, aCommon)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
if (bIndex !== bCommon) {
|
||||
diffs.push(
|
||||
new _cleanupSemantic.Diff(
|
||||
_cleanupSemantic.DIFF_INSERT,
|
||||
b.slice(bIndex, bCommon)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
aIndex = aCommon + nCommon; // number of characters compared in a
|
||||
|
||||
bIndex = bCommon + nCommon; // number of characters compared in b
|
||||
|
||||
diffs.push(
|
||||
new _cleanupSemantic.Diff(
|
||||
_cleanupSemantic.DIFF_EQUAL,
|
||||
b.slice(bCommon, bIndex)
|
||||
)
|
||||
);
|
||||
};
|
||||
|
||||
(0, _diffSequences.default)(a.length, b.length, isCommon, foundSubsequence); // After the last common subsequence, push remaining change items.
|
||||
|
||||
if (aIndex !== a.length) {
|
||||
diffs.push(
|
||||
new _cleanupSemantic.Diff(_cleanupSemantic.DIFF_DELETE, a.slice(aIndex))
|
||||
);
|
||||
}
|
||||
|
||||
if (bIndex !== b.length) {
|
||||
diffs.push(
|
||||
new _cleanupSemantic.Diff(_cleanupSemantic.DIFF_INSERT, b.slice(bIndex))
|
||||
);
|
||||
}
|
||||
|
||||
return diffs;
|
||||
};
|
||||
|
||||
var _default = diffStrings;
|
||||
exports.default = _default;
|
10
node_modules/jest-snapshot/node_modules/jest-diff/build/getAlignedDiffs.d.ts
generated
vendored
Normal file
10
node_modules/jest-snapshot/node_modules/jest-diff/build/getAlignedDiffs.d.ts
generated
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
/**
|
||||
* 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 { Diff } from './cleanupSemantic';
|
||||
import type { DiffOptionsColor } from './types';
|
||||
declare const getAlignedDiffs: (diffs: Array<Diff>, changeColor: DiffOptionsColor) => Array<Diff>;
|
||||
export default getAlignedDiffs;
|
244
node_modules/jest-snapshot/node_modules/jest-diff/build/getAlignedDiffs.js
generated
vendored
Normal file
244
node_modules/jest-snapshot/node_modules/jest-diff/build/getAlignedDiffs.js
generated
vendored
Normal file
@ -0,0 +1,244 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var _cleanupSemantic = require('./cleanupSemantic');
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
// Given change op and array of diffs, return concatenated string:
|
||||
// * include common strings
|
||||
// * include change strings which have argument op with changeColor
|
||||
// * exclude change strings which have opposite op
|
||||
const concatenateRelevantDiffs = (op, diffs, changeColor) =>
|
||||
diffs.reduce(
|
||||
(reduced, diff) =>
|
||||
reduced +
|
||||
(diff[0] === _cleanupSemantic.DIFF_EQUAL
|
||||
? diff[1]
|
||||
: diff[0] === op && diff[1].length !== 0 // empty if change is newline
|
||||
? changeColor(diff[1])
|
||||
: ''),
|
||||
''
|
||||
); // Encapsulate change lines until either a common newline or the end.
|
||||
|
||||
class ChangeBuffer {
|
||||
// incomplete line
|
||||
// complete lines
|
||||
constructor(op, changeColor) {
|
||||
_defineProperty(this, 'op', void 0);
|
||||
|
||||
_defineProperty(this, 'line', void 0);
|
||||
|
||||
_defineProperty(this, 'lines', void 0);
|
||||
|
||||
_defineProperty(this, 'changeColor', void 0);
|
||||
|
||||
this.op = op;
|
||||
this.line = [];
|
||||
this.lines = [];
|
||||
this.changeColor = changeColor;
|
||||
}
|
||||
|
||||
pushSubstring(substring) {
|
||||
this.pushDiff(new _cleanupSemantic.Diff(this.op, substring));
|
||||
}
|
||||
|
||||
pushLine() {
|
||||
// Assume call only if line has at least one diff,
|
||||
// therefore an empty line must have a diff which has an empty string.
|
||||
// If line has multiple diffs, then assume it has a common diff,
|
||||
// therefore change diffs have change color;
|
||||
// otherwise then it has line color only.
|
||||
this.lines.push(
|
||||
this.line.length !== 1
|
||||
? new _cleanupSemantic.Diff(
|
||||
this.op,
|
||||
concatenateRelevantDiffs(this.op, this.line, this.changeColor)
|
||||
)
|
||||
: this.line[0][0] === this.op
|
||||
? this.line[0] // can use instance
|
||||
: new _cleanupSemantic.Diff(this.op, this.line[0][1]) // was common diff
|
||||
);
|
||||
this.line.length = 0;
|
||||
}
|
||||
|
||||
isLineEmpty() {
|
||||
return this.line.length === 0;
|
||||
} // Minor input to buffer.
|
||||
|
||||
pushDiff(diff) {
|
||||
this.line.push(diff);
|
||||
} // Main input to buffer.
|
||||
|
||||
align(diff) {
|
||||
const string = diff[1];
|
||||
|
||||
if (string.includes('\n')) {
|
||||
const substrings = string.split('\n');
|
||||
const iLast = substrings.length - 1;
|
||||
substrings.forEach((substring, i) => {
|
||||
if (i < iLast) {
|
||||
// The first substring completes the current change line.
|
||||
// A middle substring is a change line.
|
||||
this.pushSubstring(substring);
|
||||
this.pushLine();
|
||||
} else if (substring.length !== 0) {
|
||||
// The last substring starts a change line, if it is not empty.
|
||||
// Important: This non-empty condition also automatically omits
|
||||
// the newline appended to the end of expected and received strings.
|
||||
this.pushSubstring(substring);
|
||||
}
|
||||
});
|
||||
} else {
|
||||
// Append non-multiline string to current change line.
|
||||
this.pushDiff(diff);
|
||||
}
|
||||
} // Output from buffer.
|
||||
|
||||
moveLinesTo(lines) {
|
||||
if (!this.isLineEmpty()) {
|
||||
this.pushLine();
|
||||
}
|
||||
|
||||
lines.push(...this.lines);
|
||||
this.lines.length = 0;
|
||||
}
|
||||
} // Encapsulate common and change lines.
|
||||
|
||||
class CommonBuffer {
|
||||
constructor(deleteBuffer, insertBuffer) {
|
||||
_defineProperty(this, 'deleteBuffer', void 0);
|
||||
|
||||
_defineProperty(this, 'insertBuffer', void 0);
|
||||
|
||||
_defineProperty(this, 'lines', void 0);
|
||||
|
||||
this.deleteBuffer = deleteBuffer;
|
||||
this.insertBuffer = insertBuffer;
|
||||
this.lines = [];
|
||||
}
|
||||
|
||||
pushDiffCommonLine(diff) {
|
||||
this.lines.push(diff);
|
||||
}
|
||||
|
||||
pushDiffChangeLines(diff) {
|
||||
const isDiffEmpty = diff[1].length === 0; // An empty diff string is redundant, unless a change line is empty.
|
||||
|
||||
if (!isDiffEmpty || this.deleteBuffer.isLineEmpty()) {
|
||||
this.deleteBuffer.pushDiff(diff);
|
||||
}
|
||||
|
||||
if (!isDiffEmpty || this.insertBuffer.isLineEmpty()) {
|
||||
this.insertBuffer.pushDiff(diff);
|
||||
}
|
||||
}
|
||||
|
||||
flushChangeLines() {
|
||||
this.deleteBuffer.moveLinesTo(this.lines);
|
||||
this.insertBuffer.moveLinesTo(this.lines);
|
||||
} // Input to buffer.
|
||||
|
||||
align(diff) {
|
||||
const op = diff[0];
|
||||
const string = diff[1];
|
||||
|
||||
if (string.includes('\n')) {
|
||||
const substrings = string.split('\n');
|
||||
const iLast = substrings.length - 1;
|
||||
substrings.forEach((substring, i) => {
|
||||
if (i === 0) {
|
||||
const subdiff = new _cleanupSemantic.Diff(op, substring);
|
||||
|
||||
if (
|
||||
this.deleteBuffer.isLineEmpty() &&
|
||||
this.insertBuffer.isLineEmpty()
|
||||
) {
|
||||
// If both current change lines are empty,
|
||||
// then the first substring is a common line.
|
||||
this.flushChangeLines();
|
||||
this.pushDiffCommonLine(subdiff);
|
||||
} else {
|
||||
// If either current change line is non-empty,
|
||||
// then the first substring completes the change lines.
|
||||
this.pushDiffChangeLines(subdiff);
|
||||
this.flushChangeLines();
|
||||
}
|
||||
} else if (i < iLast) {
|
||||
// A middle substring is a common line.
|
||||
this.pushDiffCommonLine(new _cleanupSemantic.Diff(op, substring));
|
||||
} else if (substring.length !== 0) {
|
||||
// The last substring starts a change line, if it is not empty.
|
||||
// Important: This non-empty condition also automatically omits
|
||||
// the newline appended to the end of expected and received strings.
|
||||
this.pushDiffChangeLines(new _cleanupSemantic.Diff(op, substring));
|
||||
}
|
||||
});
|
||||
} else {
|
||||
// Append non-multiline string to current change lines.
|
||||
// Important: It cannot be at the end following empty change lines,
|
||||
// because newline appended to the end of expected and received strings.
|
||||
this.pushDiffChangeLines(diff);
|
||||
}
|
||||
} // Output from buffer.
|
||||
|
||||
getLines() {
|
||||
this.flushChangeLines();
|
||||
return this.lines;
|
||||
}
|
||||
} // Given diffs from expected and received strings,
|
||||
// return new array of diffs split or joined into lines.
|
||||
//
|
||||
// To correctly align a change line at the end, the algorithm:
|
||||
// * assumes that a newline was appended to the strings
|
||||
// * omits the last newline from the output array
|
||||
//
|
||||
// Assume the function is not called:
|
||||
// * if either expected or received is empty string
|
||||
// * if neither expected nor received is multiline string
|
||||
|
||||
const getAlignedDiffs = (diffs, changeColor) => {
|
||||
const deleteBuffer = new ChangeBuffer(
|
||||
_cleanupSemantic.DIFF_DELETE,
|
||||
changeColor
|
||||
);
|
||||
const insertBuffer = new ChangeBuffer(
|
||||
_cleanupSemantic.DIFF_INSERT,
|
||||
changeColor
|
||||
);
|
||||
const commonBuffer = new CommonBuffer(deleteBuffer, insertBuffer);
|
||||
diffs.forEach(diff => {
|
||||
switch (diff[0]) {
|
||||
case _cleanupSemantic.DIFF_DELETE:
|
||||
deleteBuffer.align(diff);
|
||||
break;
|
||||
|
||||
case _cleanupSemantic.DIFF_INSERT:
|
||||
insertBuffer.align(diff);
|
||||
break;
|
||||
|
||||
default:
|
||||
commonBuffer.align(diff);
|
||||
}
|
||||
});
|
||||
return commonBuffer.getLines();
|
||||
};
|
||||
|
||||
var _default = getAlignedDiffs;
|
||||
exports.default = _default;
|
16
node_modules/jest-snapshot/node_modules/jest-diff/build/index.d.ts
generated
vendored
Normal file
16
node_modules/jest-snapshot/node_modules/jest-diff/build/index.d.ts
generated
vendored
Normal file
@ -0,0 +1,16 @@
|
||||
/**
|
||||
* 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 { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff } from './cleanupSemantic';
|
||||
import { diffLinesRaw, diffLinesUnified, diffLinesUnified2 } from './diffLines';
|
||||
import { diffStringsRaw, diffStringsUnified } from './printDiffs';
|
||||
import type { DiffOptions } from './types';
|
||||
export type { DiffOptions, DiffOptionsColor } from './types';
|
||||
export { diffLinesRaw, diffLinesUnified, diffLinesUnified2 };
|
||||
export { diffStringsRaw, diffStringsUnified };
|
||||
export { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff };
|
||||
declare function diff(a: any, b: any, options?: DiffOptions): string | null;
|
||||
export default diff;
|
258
node_modules/jest-snapshot/node_modules/jest-diff/build/index.js
generated
vendored
Normal file
258
node_modules/jest-snapshot/node_modules/jest-diff/build/index.js
generated
vendored
Normal file
@ -0,0 +1,258 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
Object.defineProperty(exports, 'DIFF_DELETE', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _cleanupSemantic.DIFF_DELETE;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, 'DIFF_EQUAL', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _cleanupSemantic.DIFF_EQUAL;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, 'DIFF_INSERT', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _cleanupSemantic.DIFF_INSERT;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, 'Diff', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _cleanupSemantic.Diff;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, 'diffLinesRaw', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _diffLines.diffLinesRaw;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, 'diffLinesUnified', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _diffLines.diffLinesUnified;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, 'diffLinesUnified2', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _diffLines.diffLinesUnified2;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, 'diffStringsRaw', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _printDiffs.diffStringsRaw;
|
||||
}
|
||||
});
|
||||
Object.defineProperty(exports, 'diffStringsUnified', {
|
||||
enumerable: true,
|
||||
get: function () {
|
||||
return _printDiffs.diffStringsUnified;
|
||||
}
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var _chalk = _interopRequireDefault(require('chalk'));
|
||||
|
||||
var _jestGetType = _interopRequireDefault(require('jest-get-type'));
|
||||
|
||||
var _prettyFormat = _interopRequireDefault(require('pretty-format'));
|
||||
|
||||
var _cleanupSemantic = require('./cleanupSemantic');
|
||||
|
||||
var _constants = require('./constants');
|
||||
|
||||
var _diffLines = require('./diffLines');
|
||||
|
||||
var _normalizeDiffOptions = require('./normalizeDiffOptions');
|
||||
|
||||
var _printDiffs = require('./printDiffs');
|
||||
|
||||
function _interopRequireDefault(obj) {
|
||||
return obj && obj.__esModule ? obj : {default: obj};
|
||||
}
|
||||
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
|
||||
const getCommonMessage = (message, options) => {
|
||||
const {commonColor} = (0, _normalizeDiffOptions.normalizeDiffOptions)(
|
||||
options
|
||||
);
|
||||
return commonColor(message);
|
||||
};
|
||||
|
||||
const {
|
||||
AsymmetricMatcher,
|
||||
DOMCollection,
|
||||
DOMElement,
|
||||
Immutable,
|
||||
ReactElement,
|
||||
ReactTestComponent
|
||||
} = _prettyFormat.default.plugins;
|
||||
const PLUGINS = [
|
||||
ReactTestComponent,
|
||||
ReactElement,
|
||||
DOMElement,
|
||||
DOMCollection,
|
||||
Immutable,
|
||||
AsymmetricMatcher
|
||||
];
|
||||
const FORMAT_OPTIONS = {
|
||||
plugins: PLUGINS
|
||||
};
|
||||
const FORMAT_OPTIONS_0 = {...FORMAT_OPTIONS, indent: 0};
|
||||
const FALLBACK_FORMAT_OPTIONS = {
|
||||
callToJSON: false,
|
||||
maxDepth: 10,
|
||||
plugins: PLUGINS
|
||||
};
|
||||
const FALLBACK_FORMAT_OPTIONS_0 = {...FALLBACK_FORMAT_OPTIONS, indent: 0}; // Generate a string that will highlight the difference between two values
|
||||
// with green and red. (similar to how github does code diffing)
|
||||
// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
|
||||
|
||||
function diff(a, b, options) {
|
||||
if (Object.is(a, b)) {
|
||||
return getCommonMessage(_constants.NO_DIFF_MESSAGE, options);
|
||||
}
|
||||
|
||||
const aType = (0, _jestGetType.default)(a);
|
||||
let expectedType = aType;
|
||||
let omitDifference = false;
|
||||
|
||||
if (aType === 'object' && typeof a.asymmetricMatch === 'function') {
|
||||
if (a.$$typeof !== Symbol.for('jest.asymmetricMatcher')) {
|
||||
// Do not know expected type of user-defined asymmetric matcher.
|
||||
return null;
|
||||
}
|
||||
|
||||
if (typeof a.getExpectedType !== 'function') {
|
||||
// For example, expect.anything() matches either null or undefined
|
||||
return null;
|
||||
}
|
||||
|
||||
expectedType = a.getExpectedType(); // Primitive types boolean and number omit difference below.
|
||||
// For example, omit difference for expect.stringMatching(regexp)
|
||||
|
||||
omitDifference = expectedType === 'string';
|
||||
}
|
||||
|
||||
if (expectedType !== (0, _jestGetType.default)(b)) {
|
||||
return (
|
||||
' Comparing two different types of values.' +
|
||||
` Expected ${_chalk.default.green(expectedType)} but ` +
|
||||
`received ${_chalk.default.red((0, _jestGetType.default)(b))}.`
|
||||
);
|
||||
}
|
||||
|
||||
if (omitDifference) {
|
||||
return null;
|
||||
}
|
||||
|
||||
switch (aType) {
|
||||
case 'string':
|
||||
return (0, _diffLines.diffLinesUnified)(
|
||||
a.split('\n'),
|
||||
b.split('\n'),
|
||||
options
|
||||
);
|
||||
|
||||
case 'boolean':
|
||||
case 'number':
|
||||
return comparePrimitive(a, b, options);
|
||||
|
||||
case 'map':
|
||||
return compareObjects(sortMap(a), sortMap(b), options);
|
||||
|
||||
case 'set':
|
||||
return compareObjects(sortSet(a), sortSet(b), options);
|
||||
|
||||
default:
|
||||
return compareObjects(a, b, options);
|
||||
}
|
||||
}
|
||||
|
||||
function comparePrimitive(a, b, options) {
|
||||
const aFormat = (0, _prettyFormat.default)(a, FORMAT_OPTIONS);
|
||||
const bFormat = (0, _prettyFormat.default)(b, FORMAT_OPTIONS);
|
||||
return aFormat === bFormat
|
||||
? getCommonMessage(_constants.NO_DIFF_MESSAGE, options)
|
||||
: (0, _diffLines.diffLinesUnified)(
|
||||
aFormat.split('\n'),
|
||||
bFormat.split('\n'),
|
||||
options
|
||||
);
|
||||
}
|
||||
|
||||
function sortMap(map) {
|
||||
return new Map(Array.from(map.entries()).sort());
|
||||
}
|
||||
|
||||
function sortSet(set) {
|
||||
return new Set(Array.from(set.values()).sort());
|
||||
}
|
||||
|
||||
function compareObjects(a, b, options) {
|
||||
let difference;
|
||||
let hasThrown = false;
|
||||
const noDiffMessage = getCommonMessage(_constants.NO_DIFF_MESSAGE, options);
|
||||
|
||||
try {
|
||||
const aCompare = (0, _prettyFormat.default)(a, FORMAT_OPTIONS_0);
|
||||
const bCompare = (0, _prettyFormat.default)(b, FORMAT_OPTIONS_0);
|
||||
|
||||
if (aCompare === bCompare) {
|
||||
difference = noDiffMessage;
|
||||
} else {
|
||||
const aDisplay = (0, _prettyFormat.default)(a, FORMAT_OPTIONS);
|
||||
const bDisplay = (0, _prettyFormat.default)(b, FORMAT_OPTIONS);
|
||||
difference = (0, _diffLines.diffLinesUnified2)(
|
||||
aDisplay.split('\n'),
|
||||
bDisplay.split('\n'),
|
||||
aCompare.split('\n'),
|
||||
bCompare.split('\n'),
|
||||
options
|
||||
);
|
||||
}
|
||||
} catch {
|
||||
hasThrown = true;
|
||||
} // If the comparison yields no results, compare again but this time
|
||||
// without calling `toJSON`. It's also possible that toJSON might throw.
|
||||
|
||||
if (difference === undefined || difference === noDiffMessage) {
|
||||
const aCompare = (0, _prettyFormat.default)(a, FALLBACK_FORMAT_OPTIONS_0);
|
||||
const bCompare = (0, _prettyFormat.default)(b, FALLBACK_FORMAT_OPTIONS_0);
|
||||
|
||||
if (aCompare === bCompare) {
|
||||
difference = noDiffMessage;
|
||||
} else {
|
||||
const aDisplay = (0, _prettyFormat.default)(a, FALLBACK_FORMAT_OPTIONS);
|
||||
const bDisplay = (0, _prettyFormat.default)(b, FALLBACK_FORMAT_OPTIONS);
|
||||
difference = (0, _diffLines.diffLinesUnified2)(
|
||||
aDisplay.split('\n'),
|
||||
bDisplay.split('\n'),
|
||||
aCompare.split('\n'),
|
||||
bCompare.split('\n'),
|
||||
options
|
||||
);
|
||||
}
|
||||
|
||||
if (difference !== noDiffMessage && !hasThrown) {
|
||||
difference =
|
||||
getCommonMessage(_constants.SIMILAR_MESSAGE, options) +
|
||||
'\n\n' +
|
||||
difference;
|
||||
}
|
||||
}
|
||||
|
||||
return difference;
|
||||
}
|
||||
|
||||
var _default = diff;
|
||||
exports.default = _default;
|
10
node_modules/jest-snapshot/node_modules/jest-diff/build/joinAlignedDiffs.d.ts
generated
vendored
Normal file
10
node_modules/jest-snapshot/node_modules/jest-diff/build/joinAlignedDiffs.d.ts
generated
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
/**
|
||||
* 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 { Diff } from './cleanupSemantic';
|
||||
import type { DiffOptionsNormalized } from './types';
|
||||
export declare const joinAlignedDiffsNoExpand: (diffs: Array<Diff>, options: DiffOptionsNormalized) => string;
|
||||
export declare const joinAlignedDiffsExpand: (diffs: Array<Diff>, options: DiffOptionsNormalized) => string;
|
235
node_modules/jest-snapshot/node_modules/jest-diff/build/joinAlignedDiffs.js
generated
vendored
Normal file
235
node_modules/jest-snapshot/node_modules/jest-diff/build/joinAlignedDiffs.js
generated
vendored
Normal file
@ -0,0 +1,235 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.joinAlignedDiffsExpand = exports.joinAlignedDiffsNoExpand = void 0;
|
||||
|
||||
var _cleanupSemantic = require('./cleanupSemantic');
|
||||
|
||||
var _printDiffs = require('./printDiffs');
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
// jest --no-expand
|
||||
//
|
||||
// Given array of aligned strings with inverse highlight formatting,
|
||||
// return joined lines with diff formatting (and patch marks, if needed).
|
||||
const joinAlignedDiffsNoExpand = (diffs, options) => {
|
||||
const iLength = diffs.length;
|
||||
const nContextLines = options.contextLines;
|
||||
const nContextLines2 = nContextLines + nContextLines; // First pass: count output lines and see if it has patches.
|
||||
|
||||
let jLength = iLength;
|
||||
let hasExcessAtStartOrEnd = false;
|
||||
let nExcessesBetweenChanges = 0;
|
||||
let i = 0;
|
||||
|
||||
while (i !== iLength) {
|
||||
const iStart = i;
|
||||
|
||||
while (i !== iLength && diffs[i][0] === _cleanupSemantic.DIFF_EQUAL) {
|
||||
i += 1;
|
||||
}
|
||||
|
||||
if (iStart !== i) {
|
||||
if (iStart === 0) {
|
||||
// at start
|
||||
if (i > nContextLines) {
|
||||
jLength -= i - nContextLines; // subtract excess common lines
|
||||
|
||||
hasExcessAtStartOrEnd = true;
|
||||
}
|
||||
} else if (i === iLength) {
|
||||
// at end
|
||||
const n = i - iStart;
|
||||
|
||||
if (n > nContextLines) {
|
||||
jLength -= n - nContextLines; // subtract excess common lines
|
||||
|
||||
hasExcessAtStartOrEnd = true;
|
||||
}
|
||||
} else {
|
||||
// between changes
|
||||
const n = i - iStart;
|
||||
|
||||
if (n > nContextLines2) {
|
||||
jLength -= n - nContextLines2; // subtract excess common lines
|
||||
|
||||
nExcessesBetweenChanges += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
while (i !== iLength && diffs[i][0] !== _cleanupSemantic.DIFF_EQUAL) {
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
|
||||
const hasPatch = nExcessesBetweenChanges !== 0 || hasExcessAtStartOrEnd;
|
||||
|
||||
if (nExcessesBetweenChanges !== 0) {
|
||||
jLength += nExcessesBetweenChanges + 1; // add patch lines
|
||||
} else if (hasExcessAtStartOrEnd) {
|
||||
jLength += 1; // add patch line
|
||||
}
|
||||
|
||||
const jLast = jLength - 1;
|
||||
const lines = [];
|
||||
let jPatchMark = 0; // index of placeholder line for current patch mark
|
||||
|
||||
if (hasPatch) {
|
||||
lines.push(''); // placeholder line for first patch mark
|
||||
} // Indexes of expected or received lines in current patch:
|
||||
|
||||
let aStart = 0;
|
||||
let bStart = 0;
|
||||
let aEnd = 0;
|
||||
let bEnd = 0;
|
||||
|
||||
const pushCommonLine = line => {
|
||||
const j = lines.length;
|
||||
lines.push(
|
||||
(0, _printDiffs.printCommonLine)(line, j === 0 || j === jLast, options)
|
||||
);
|
||||
aEnd += 1;
|
||||
bEnd += 1;
|
||||
};
|
||||
|
||||
const pushDeleteLine = line => {
|
||||
const j = lines.length;
|
||||
lines.push(
|
||||
(0, _printDiffs.printDeleteLine)(line, j === 0 || j === jLast, options)
|
||||
);
|
||||
aEnd += 1;
|
||||
};
|
||||
|
||||
const pushInsertLine = line => {
|
||||
const j = lines.length;
|
||||
lines.push(
|
||||
(0, _printDiffs.printInsertLine)(line, j === 0 || j === jLast, options)
|
||||
);
|
||||
bEnd += 1;
|
||||
}; // Second pass: push lines with diff formatting (and patch marks, if needed).
|
||||
|
||||
i = 0;
|
||||
|
||||
while (i !== iLength) {
|
||||
let iStart = i;
|
||||
|
||||
while (i !== iLength && diffs[i][0] === _cleanupSemantic.DIFF_EQUAL) {
|
||||
i += 1;
|
||||
}
|
||||
|
||||
if (iStart !== i) {
|
||||
if (iStart === 0) {
|
||||
// at beginning
|
||||
if (i > nContextLines) {
|
||||
iStart = i - nContextLines;
|
||||
aStart = iStart;
|
||||
bStart = iStart;
|
||||
aEnd = aStart;
|
||||
bEnd = bStart;
|
||||
}
|
||||
|
||||
for (let iCommon = iStart; iCommon !== i; iCommon += 1) {
|
||||
pushCommonLine(diffs[iCommon][1]);
|
||||
}
|
||||
} else if (i === iLength) {
|
||||
// at end
|
||||
const iEnd = i - iStart > nContextLines ? iStart + nContextLines : i;
|
||||
|
||||
for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) {
|
||||
pushCommonLine(diffs[iCommon][1]);
|
||||
}
|
||||
} else {
|
||||
// between changes
|
||||
const nCommon = i - iStart;
|
||||
|
||||
if (nCommon > nContextLines2) {
|
||||
const iEnd = iStart + nContextLines;
|
||||
|
||||
for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) {
|
||||
pushCommonLine(diffs[iCommon][1]);
|
||||
}
|
||||
|
||||
lines[jPatchMark] = (0, _printDiffs.createPatchMark)(
|
||||
aStart,
|
||||
aEnd,
|
||||
bStart,
|
||||
bEnd,
|
||||
options
|
||||
);
|
||||
jPatchMark = lines.length;
|
||||
lines.push(''); // placeholder line for next patch mark
|
||||
|
||||
const nOmit = nCommon - nContextLines2;
|
||||
aStart = aEnd + nOmit;
|
||||
bStart = bEnd + nOmit;
|
||||
aEnd = aStart;
|
||||
bEnd = bStart;
|
||||
|
||||
for (let iCommon = i - nContextLines; iCommon !== i; iCommon += 1) {
|
||||
pushCommonLine(diffs[iCommon][1]);
|
||||
}
|
||||
} else {
|
||||
for (let iCommon = iStart; iCommon !== i; iCommon += 1) {
|
||||
pushCommonLine(diffs[iCommon][1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
while (i !== iLength && diffs[i][0] === _cleanupSemantic.DIFF_DELETE) {
|
||||
pushDeleteLine(diffs[i][1]);
|
||||
i += 1;
|
||||
}
|
||||
|
||||
while (i !== iLength && diffs[i][0] === _cleanupSemantic.DIFF_INSERT) {
|
||||
pushInsertLine(diffs[i][1]);
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (hasPatch) {
|
||||
lines[jPatchMark] = (0, _printDiffs.createPatchMark)(
|
||||
aStart,
|
||||
aEnd,
|
||||
bStart,
|
||||
bEnd,
|
||||
options
|
||||
);
|
||||
}
|
||||
|
||||
return lines.join('\n');
|
||||
}; // jest --expand
|
||||
//
|
||||
// Given array of aligned strings with inverse highlight formatting,
|
||||
// return joined lines with diff formatting.
|
||||
|
||||
exports.joinAlignedDiffsNoExpand = joinAlignedDiffsNoExpand;
|
||||
|
||||
const joinAlignedDiffsExpand = (diffs, options) =>
|
||||
diffs
|
||||
.map((diff, i, diffs) => {
|
||||
const line = diff[1];
|
||||
const isFirstOrLast = i === 0 || i === diffs.length - 1;
|
||||
|
||||
switch (diff[0]) {
|
||||
case _cleanupSemantic.DIFF_DELETE:
|
||||
return (0, _printDiffs.printDeleteLine)(line, isFirstOrLast, options);
|
||||
|
||||
case _cleanupSemantic.DIFF_INSERT:
|
||||
return (0, _printDiffs.printInsertLine)(line, isFirstOrLast, options);
|
||||
|
||||
default:
|
||||
return (0, _printDiffs.printCommonLine)(line, isFirstOrLast, options);
|
||||
}
|
||||
})
|
||||
.join('\n');
|
||||
|
||||
exports.joinAlignedDiffsExpand = joinAlignedDiffsExpand;
|
9
node_modules/jest-snapshot/node_modules/jest-diff/build/normalizeDiffOptions.d.ts
generated
vendored
Normal file
9
node_modules/jest-snapshot/node_modules/jest-diff/build/normalizeDiffOptions.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 { DiffOptions, DiffOptionsNormalized } from './types';
|
||||
export declare const noColor: (string: string) => string;
|
||||
export declare const normalizeDiffOptions: (options?: DiffOptions) => DiffOptionsNormalized;
|
57
node_modules/jest-snapshot/node_modules/jest-diff/build/normalizeDiffOptions.js
generated
vendored
Normal file
57
node_modules/jest-snapshot/node_modules/jest-diff/build/normalizeDiffOptions.js
generated
vendored
Normal file
@ -0,0 +1,57 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.normalizeDiffOptions = exports.noColor = void 0;
|
||||
|
||||
var _chalk = _interopRequireDefault(require('chalk'));
|
||||
|
||||
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 noColor = string => string;
|
||||
|
||||
exports.noColor = noColor;
|
||||
const DIFF_CONTEXT_DEFAULT = 5;
|
||||
const OPTIONS_DEFAULT = {
|
||||
aAnnotation: 'Expected',
|
||||
aColor: _chalk.default.green,
|
||||
aIndicator: '-',
|
||||
bAnnotation: 'Received',
|
||||
bColor: _chalk.default.red,
|
||||
bIndicator: '+',
|
||||
changeColor: _chalk.default.inverse,
|
||||
changeLineTrailingSpaceColor: noColor,
|
||||
commonColor: _chalk.default.dim,
|
||||
commonIndicator: ' ',
|
||||
commonLineTrailingSpaceColor: noColor,
|
||||
contextLines: DIFF_CONTEXT_DEFAULT,
|
||||
emptyFirstOrLastLinePlaceholder: '',
|
||||
expand: true,
|
||||
includeChangeCounts: false,
|
||||
omitAnnotationLines: false,
|
||||
patchColor: _chalk.default.yellow
|
||||
};
|
||||
|
||||
const getContextLines = contextLines =>
|
||||
typeof contextLines === 'number' &&
|
||||
Number.isSafeInteger(contextLines) &&
|
||||
contextLines >= 0
|
||||
? contextLines
|
||||
: DIFF_CONTEXT_DEFAULT; // Pure function returns options with all properties.
|
||||
|
||||
const normalizeDiffOptions = (options = {}) => ({
|
||||
...OPTIONS_DEFAULT,
|
||||
...options,
|
||||
contextLines: getContextLines(options.contextLines)
|
||||
});
|
||||
|
||||
exports.normalizeDiffOptions = normalizeDiffOptions;
|
22
node_modules/jest-snapshot/node_modules/jest-diff/build/printDiffs.d.ts
generated
vendored
Normal file
22
node_modules/jest-snapshot/node_modules/jest-diff/build/printDiffs.d.ts
generated
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
/**
|
||||
* 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 { Diff } from './cleanupSemantic';
|
||||
import type { DiffOptions, DiffOptionsNormalized } from './types';
|
||||
export declare const printDeleteLine: (line: string, isFirstOrLast: boolean, { aColor, aIndicator, changeLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder, }: DiffOptionsNormalized) => string;
|
||||
export declare const printInsertLine: (line: string, isFirstOrLast: boolean, { bColor, bIndicator, changeLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder, }: DiffOptionsNormalized) => string;
|
||||
export declare const printCommonLine: (line: string, isFirstOrLast: boolean, { commonColor, commonIndicator, commonLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder, }: DiffOptionsNormalized) => string;
|
||||
export declare const hasCommonDiff: (diffs: Array<Diff>, isMultiline: boolean) => boolean;
|
||||
export declare type ChangeCounts = {
|
||||
a: number;
|
||||
b: number;
|
||||
};
|
||||
export declare const countChanges: (diffs: Array<Diff>) => ChangeCounts;
|
||||
export declare const printAnnotation: ({ aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator, includeChangeCounts, omitAnnotationLines, }: DiffOptionsNormalized, changeCounts: ChangeCounts) => string;
|
||||
export declare const printDiffLines: (diffs: Array<Diff>, options: DiffOptionsNormalized) => string;
|
||||
export declare const createPatchMark: (aStart: number, aEnd: number, bStart: number, bEnd: number, { patchColor }: DiffOptionsNormalized) => string;
|
||||
export declare const diffStringsUnified: (a: string, b: string, options?: DiffOptions | undefined) => string;
|
||||
export declare const diffStringsRaw: (a: string, b: string, cleanup: boolean) => Array<Diff>;
|
257
node_modules/jest-snapshot/node_modules/jest-diff/build/printDiffs.js
generated
vendored
Normal file
257
node_modules/jest-snapshot/node_modules/jest-diff/build/printDiffs.js
generated
vendored
Normal file
@ -0,0 +1,257 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.diffStringsRaw = exports.diffStringsUnified = exports.createPatchMark = exports.printDiffLines = exports.printAnnotation = exports.countChanges = exports.hasCommonDiff = exports.printCommonLine = exports.printInsertLine = exports.printDeleteLine = void 0;
|
||||
|
||||
var _cleanupSemantic = require('./cleanupSemantic');
|
||||
|
||||
var _diffLines = require('./diffLines');
|
||||
|
||||
var _diffStrings = _interopRequireDefault(require('./diffStrings'));
|
||||
|
||||
var _getAlignedDiffs = _interopRequireDefault(require('./getAlignedDiffs'));
|
||||
|
||||
var _joinAlignedDiffs = require('./joinAlignedDiffs');
|
||||
|
||||
var _normalizeDiffOptions = require('./normalizeDiffOptions');
|
||||
|
||||
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 formatTrailingSpaces = (line, trailingSpaceFormatter) =>
|
||||
line.replace(/\s+$/, match => trailingSpaceFormatter(match));
|
||||
|
||||
const printDiffLine = (
|
||||
line,
|
||||
isFirstOrLast,
|
||||
color,
|
||||
indicator,
|
||||
trailingSpaceFormatter,
|
||||
emptyFirstOrLastLinePlaceholder
|
||||
) =>
|
||||
line.length !== 0
|
||||
? color(
|
||||
indicator + ' ' + formatTrailingSpaces(line, trailingSpaceFormatter)
|
||||
)
|
||||
: indicator !== ' '
|
||||
? color(indicator)
|
||||
: isFirstOrLast && emptyFirstOrLastLinePlaceholder.length !== 0
|
||||
? color(indicator + ' ' + emptyFirstOrLastLinePlaceholder)
|
||||
: '';
|
||||
|
||||
const printDeleteLine = (
|
||||
line,
|
||||
isFirstOrLast,
|
||||
{
|
||||
aColor,
|
||||
aIndicator,
|
||||
changeLineTrailingSpaceColor,
|
||||
emptyFirstOrLastLinePlaceholder
|
||||
}
|
||||
) =>
|
||||
printDiffLine(
|
||||
line,
|
||||
isFirstOrLast,
|
||||
aColor,
|
||||
aIndicator,
|
||||
changeLineTrailingSpaceColor,
|
||||
emptyFirstOrLastLinePlaceholder
|
||||
);
|
||||
|
||||
exports.printDeleteLine = printDeleteLine;
|
||||
|
||||
const printInsertLine = (
|
||||
line,
|
||||
isFirstOrLast,
|
||||
{
|
||||
bColor,
|
||||
bIndicator,
|
||||
changeLineTrailingSpaceColor,
|
||||
emptyFirstOrLastLinePlaceholder
|
||||
}
|
||||
) =>
|
||||
printDiffLine(
|
||||
line,
|
||||
isFirstOrLast,
|
||||
bColor,
|
||||
bIndicator,
|
||||
changeLineTrailingSpaceColor,
|
||||
emptyFirstOrLastLinePlaceholder
|
||||
);
|
||||
|
||||
exports.printInsertLine = printInsertLine;
|
||||
|
||||
const printCommonLine = (
|
||||
line,
|
||||
isFirstOrLast,
|
||||
{
|
||||
commonColor,
|
||||
commonIndicator,
|
||||
commonLineTrailingSpaceColor,
|
||||
emptyFirstOrLastLinePlaceholder
|
||||
}
|
||||
) =>
|
||||
printDiffLine(
|
||||
line,
|
||||
isFirstOrLast,
|
||||
commonColor,
|
||||
commonIndicator,
|
||||
commonLineTrailingSpaceColor,
|
||||
emptyFirstOrLastLinePlaceholder
|
||||
);
|
||||
|
||||
exports.printCommonLine = printCommonLine;
|
||||
|
||||
const hasCommonDiff = (diffs, isMultiline) => {
|
||||
if (isMultiline) {
|
||||
// Important: Ignore common newline that was appended to multiline strings!
|
||||
const iLast = diffs.length - 1;
|
||||
return diffs.some(
|
||||
(diff, i) =>
|
||||
diff[0] === _cleanupSemantic.DIFF_EQUAL &&
|
||||
(i !== iLast || diff[1] !== '\n')
|
||||
);
|
||||
}
|
||||
|
||||
return diffs.some(diff => diff[0] === _cleanupSemantic.DIFF_EQUAL);
|
||||
};
|
||||
|
||||
exports.hasCommonDiff = hasCommonDiff;
|
||||
|
||||
const countChanges = diffs => {
|
||||
let a = 0;
|
||||
let b = 0;
|
||||
diffs.forEach(diff => {
|
||||
switch (diff[0]) {
|
||||
case _cleanupSemantic.DIFF_DELETE:
|
||||
a += 1;
|
||||
break;
|
||||
|
||||
case _cleanupSemantic.DIFF_INSERT:
|
||||
b += 1;
|
||||
break;
|
||||
}
|
||||
});
|
||||
return {
|
||||
a,
|
||||
b
|
||||
};
|
||||
};
|
||||
|
||||
exports.countChanges = countChanges;
|
||||
|
||||
const printAnnotation = (
|
||||
{
|
||||
aAnnotation,
|
||||
aColor,
|
||||
aIndicator,
|
||||
bAnnotation,
|
||||
bColor,
|
||||
bIndicator,
|
||||
includeChangeCounts,
|
||||
omitAnnotationLines
|
||||
},
|
||||
changeCounts
|
||||
) => {
|
||||
if (omitAnnotationLines) {
|
||||
return '';
|
||||
}
|
||||
|
||||
let aRest = '';
|
||||
let bRest = '';
|
||||
|
||||
if (includeChangeCounts) {
|
||||
const aCount = String(changeCounts.a);
|
||||
const bCount = String(changeCounts.b); // Padding right aligns the ends of the annotations.
|
||||
|
||||
const baAnnotationLengthDiff = bAnnotation.length - aAnnotation.length;
|
||||
const aAnnotationPadding = ' '.repeat(Math.max(0, baAnnotationLengthDiff));
|
||||
const bAnnotationPadding = ' '.repeat(Math.max(0, -baAnnotationLengthDiff)); // Padding left aligns the ends of the counts.
|
||||
|
||||
const baCountLengthDiff = bCount.length - aCount.length;
|
||||
const aCountPadding = ' '.repeat(Math.max(0, baCountLengthDiff));
|
||||
const bCountPadding = ' '.repeat(Math.max(0, -baCountLengthDiff));
|
||||
aRest =
|
||||
aAnnotationPadding + ' ' + aIndicator + ' ' + aCountPadding + aCount;
|
||||
bRest =
|
||||
bAnnotationPadding + ' ' + bIndicator + ' ' + bCountPadding + bCount;
|
||||
}
|
||||
|
||||
return (
|
||||
aColor(aIndicator + ' ' + aAnnotation + aRest) +
|
||||
'\n' +
|
||||
bColor(bIndicator + ' ' + bAnnotation + bRest) +
|
||||
'\n\n'
|
||||
);
|
||||
};
|
||||
|
||||
exports.printAnnotation = printAnnotation;
|
||||
|
||||
const printDiffLines = (diffs, options) =>
|
||||
printAnnotation(options, countChanges(diffs)) +
|
||||
(options.expand
|
||||
? (0, _joinAlignedDiffs.joinAlignedDiffsExpand)(diffs, options)
|
||||
: (0, _joinAlignedDiffs.joinAlignedDiffsNoExpand)(diffs, options)); // In GNU diff format, indexes are one-based instead of zero-based.
|
||||
|
||||
exports.printDiffLines = printDiffLines;
|
||||
|
||||
const createPatchMark = (aStart, aEnd, bStart, bEnd, {patchColor}) =>
|
||||
patchColor(
|
||||
`@@ -${aStart + 1},${aEnd - aStart} +${bStart + 1},${bEnd - bStart} @@`
|
||||
); // Compare two strings character-by-character.
|
||||
// Format as comparison lines in which changed substrings have inverse colors.
|
||||
|
||||
exports.createPatchMark = createPatchMark;
|
||||
|
||||
const diffStringsUnified = (a, b, options) => {
|
||||
if (a !== b && a.length !== 0 && b.length !== 0) {
|
||||
const isMultiline = a.includes('\n') || b.includes('\n'); // getAlignedDiffs assumes that a newline was appended to the strings.
|
||||
|
||||
const diffs = diffStringsRaw(
|
||||
isMultiline ? a + '\n' : a,
|
||||
isMultiline ? b + '\n' : b,
|
||||
true // cleanupSemantic
|
||||
);
|
||||
|
||||
if (hasCommonDiff(diffs, isMultiline)) {
|
||||
const optionsNormalized = (0, _normalizeDiffOptions.normalizeDiffOptions)(
|
||||
options
|
||||
);
|
||||
const lines = (0, _getAlignedDiffs.default)(
|
||||
diffs,
|
||||
optionsNormalized.changeColor
|
||||
);
|
||||
return printDiffLines(lines, optionsNormalized);
|
||||
}
|
||||
} // Fall back to line-by-line diff.
|
||||
|
||||
return (0, _diffLines.diffLinesUnified)(
|
||||
a.split('\n'),
|
||||
b.split('\n'),
|
||||
options
|
||||
);
|
||||
}; // Compare two strings character-by-character.
|
||||
// Optionally clean up small common substrings, also known as chaff.
|
||||
|
||||
exports.diffStringsUnified = diffStringsUnified;
|
||||
|
||||
const diffStringsRaw = (a, b, cleanup) => {
|
||||
const diffs = (0, _diffStrings.default)(a, b);
|
||||
|
||||
if (cleanup) {
|
||||
(0, _cleanupSemantic.cleanupSemantic)(diffs); // impure function
|
||||
}
|
||||
|
||||
return diffs;
|
||||
};
|
||||
|
||||
exports.diffStringsRaw = diffStringsRaw;
|
45
node_modules/jest-snapshot/node_modules/jest-diff/build/types.d.ts
generated
vendored
Normal file
45
node_modules/jest-snapshot/node_modules/jest-diff/build/types.d.ts
generated
vendored
Normal file
@ -0,0 +1,45 @@
|
||||
/**
|
||||
* 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 type DiffOptionsColor = (arg: string) => string;
|
||||
export declare type DiffOptions = {
|
||||
aAnnotation?: string;
|
||||
aColor?: DiffOptionsColor;
|
||||
aIndicator?: string;
|
||||
bAnnotation?: string;
|
||||
bColor?: DiffOptionsColor;
|
||||
bIndicator?: string;
|
||||
changeColor?: DiffOptionsColor;
|
||||
changeLineTrailingSpaceColor?: DiffOptionsColor;
|
||||
commonColor?: DiffOptionsColor;
|
||||
commonIndicator?: string;
|
||||
commonLineTrailingSpaceColor?: DiffOptionsColor;
|
||||
contextLines?: number;
|
||||
emptyFirstOrLastLinePlaceholder?: string;
|
||||
expand?: boolean;
|
||||
includeChangeCounts?: boolean;
|
||||
omitAnnotationLines?: boolean;
|
||||
patchColor?: DiffOptionsColor;
|
||||
};
|
||||
export declare type DiffOptionsNormalized = {
|
||||
aAnnotation: string;
|
||||
aColor: DiffOptionsColor;
|
||||
aIndicator: string;
|
||||
bAnnotation: string;
|
||||
bColor: DiffOptionsColor;
|
||||
bIndicator: string;
|
||||
changeColor: DiffOptionsColor;
|
||||
changeLineTrailingSpaceColor: DiffOptionsColor;
|
||||
commonColor: DiffOptionsColor;
|
||||
commonIndicator: string;
|
||||
commonLineTrailingSpaceColor: DiffOptionsColor;
|
||||
contextLines: number;
|
||||
emptyFirstOrLastLinePlaceholder: string;
|
||||
expand: boolean;
|
||||
includeChangeCounts: boolean;
|
||||
omitAnnotationLines: boolean;
|
||||
patchColor: DiffOptionsColor;
|
||||
};
|
1
node_modules/jest-snapshot/node_modules/jest-diff/build/types.js
generated
vendored
Normal file
1
node_modules/jest-snapshot/node_modules/jest-diff/build/types.js
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
'use strict';
|
29
node_modules/jest-snapshot/node_modules/jest-diff/package.json
generated
vendored
Normal file
29
node_modules/jest-snapshot/node_modules/jest-diff/package.json
generated
vendored
Normal file
@ -0,0 +1,29 @@
|
||||
{
|
||||
"name": "jest-diff",
|
||||
"version": "26.6.2",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/facebook/jest.git",
|
||||
"directory": "packages/jest-diff"
|
||||
},
|
||||
"license": "MIT",
|
||||
"main": "build/index.js",
|
||||
"types": "build/index.d.ts",
|
||||
"dependencies": {
|
||||
"chalk": "^4.0.0",
|
||||
"diff-sequences": "^26.6.2",
|
||||
"jest-get-type": "^26.3.0",
|
||||
"pretty-format": "^26.6.2"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@jest/test-utils": "^26.6.2",
|
||||
"strip-ansi": "^6.0.0"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 10.14.2"
|
||||
},
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"gitHead": "4c46930615602cbf983fb7e8e82884c282a624d5"
|
||||
}
|
21
node_modules/jest-snapshot/node_modules/pretty-format/LICENSE
generated
vendored
Normal file
21
node_modules/jest-snapshot/node_modules/pretty-format/LICENSE
generated
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) Facebook, Inc. and its affiliates.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
454
node_modules/jest-snapshot/node_modules/pretty-format/README.md
generated
vendored
Executable file
454
node_modules/jest-snapshot/node_modules/pretty-format/README.md
generated
vendored
Executable file
@ -0,0 +1,454 @@
|
||||
# pretty-format
|
||||
|
||||
Stringify any JavaScript value.
|
||||
|
||||
- Serialize built-in JavaScript types.
|
||||
- Serialize application-specific data types with built-in or user-defined plugins.
|
||||
|
||||
## Installation
|
||||
|
||||
```sh
|
||||
$ yarn add pretty-format
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```js
|
||||
const prettyFormat = require('pretty-format'); // CommonJS
|
||||
```
|
||||
|
||||
```js
|
||||
import prettyFormat from 'pretty-format'; // ES2015 modules
|
||||
```
|
||||
|
||||
```js
|
||||
const val = {object: {}};
|
||||
val.circularReference = val;
|
||||
val[Symbol('foo')] = 'foo';
|
||||
val.map = new Map([['prop', 'value']]);
|
||||
val.array = [-0, Infinity, NaN];
|
||||
|
||||
console.log(prettyFormat(val));
|
||||
/*
|
||||
Object {
|
||||
"array": Array [
|
||||
-0,
|
||||
Infinity,
|
||||
NaN,
|
||||
],
|
||||
"circularReference": [Circular],
|
||||
"map": Map {
|
||||
"prop" => "value",
|
||||
},
|
||||
"object": Object {},
|
||||
Symbol(foo): "foo",
|
||||
}
|
||||
*/
|
||||
```
|
||||
|
||||
## Usage with options
|
||||
|
||||
```js
|
||||
function onClick() {}
|
||||
|
||||
console.log(prettyFormat(onClick));
|
||||
/*
|
||||
[Function onClick]
|
||||
*/
|
||||
|
||||
const options = {
|
||||
printFunctionName: false,
|
||||
};
|
||||
console.log(prettyFormat(onClick, options));
|
||||
/*
|
||||
[Function]
|
||||
*/
|
||||
```
|
||||
|
||||
<!-- prettier-ignore -->
|
||||
| key | type | default | description |
|
||||
| :------------------ | :-------- | :--------- | :------------------------------------------------------ |
|
||||
| `callToJSON` | `boolean` | `true` | call `toJSON` method (if it exists) on objects |
|
||||
| `escapeRegex` | `boolean` | `false` | escape special characters in regular expressions |
|
||||
| `escapeString` | `boolean` | `true` | escape special characters in strings |
|
||||
| `highlight` | `boolean` | `false` | highlight syntax with colors in terminal (some plugins) |
|
||||
| `indent` | `number` | `2` | spaces in each level of indentation |
|
||||
| `maxDepth` | `number` | `Infinity` | levels to print in arrays, objects, elements, and so on |
|
||||
| `min` | `boolean` | `false` | minimize added space: no indentation nor line breaks |
|
||||
| `plugins` | `array` | `[]` | plugins to serialize application-specific data types |
|
||||
| `printFunctionName` | `boolean` | `true` | include or omit the name of a function |
|
||||
| `theme` | `object` | | colors to highlight syntax in terminal |
|
||||
|
||||
Property values of `theme` are from [ansi-styles colors](https://github.com/chalk/ansi-styles#colors)
|
||||
|
||||
```js
|
||||
const DEFAULT_THEME = {
|
||||
comment: 'gray',
|
||||
content: 'reset',
|
||||
prop: 'yellow',
|
||||
tag: 'cyan',
|
||||
value: 'green',
|
||||
};
|
||||
```
|
||||
|
||||
## Usage with plugins
|
||||
|
||||
The `pretty-format` package provides some built-in plugins, including:
|
||||
|
||||
- `ReactElement` for elements from `react`
|
||||
- `ReactTestComponent` for test objects from `react-test-renderer`
|
||||
|
||||
```js
|
||||
// CommonJS
|
||||
const React = require('react');
|
||||
const renderer = require('react-test-renderer');
|
||||
const prettyFormat = require('pretty-format');
|
||||
const ReactElement = prettyFormat.plugins.ReactElement;
|
||||
const ReactTestComponent = prettyFormat.plugins.ReactTestComponent;
|
||||
```
|
||||
|
||||
```js
|
||||
import React from 'react';
|
||||
import renderer from 'react-test-renderer';
|
||||
// ES2015 modules and destructuring assignment
|
||||
import prettyFormat from 'pretty-format';
|
||||
const {ReactElement, ReactTestComponent} = prettyFormat.plugins;
|
||||
```
|
||||
|
||||
```js
|
||||
const onClick = () => {};
|
||||
const element = React.createElement('button', {onClick}, 'Hello World');
|
||||
|
||||
const formatted1 = prettyFormat(element, {
|
||||
plugins: [ReactElement],
|
||||
printFunctionName: false,
|
||||
});
|
||||
const formatted2 = prettyFormat(renderer.create(element).toJSON(), {
|
||||
plugins: [ReactTestComponent],
|
||||
printFunctionName: false,
|
||||
});
|
||||
/*
|
||||
<button
|
||||
onClick=[Function]
|
||||
>
|
||||
Hello World
|
||||
</button>
|
||||
*/
|
||||
```
|
||||
|
||||
## Usage in Jest
|
||||
|
||||
For snapshot tests, Jest uses `pretty-format` with options that include some of its built-in plugins. For this purpose, plugins are also known as **snapshot serializers**.
|
||||
|
||||
To serialize application-specific data types, you can add modules to `devDependencies` of a project, and then:
|
||||
|
||||
In an **individual** test file, you can add a module as follows. It precedes any modules from Jest configuration.
|
||||
|
||||
```js
|
||||
import serializer from 'my-serializer-module';
|
||||
expect.addSnapshotSerializer(serializer);
|
||||
|
||||
// tests which have `expect(value).toMatchSnapshot()` assertions
|
||||
```
|
||||
|
||||
For **all** test files, you can specify modules in Jest configuration. They precede built-in plugins for React, HTML, and Immutable.js data types. For example, in a `package.json` file:
|
||||
|
||||
```json
|
||||
{
|
||||
"jest": {
|
||||
"snapshotSerializers": ["my-serializer-module"]
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Writing plugins
|
||||
|
||||
A plugin is a JavaScript object.
|
||||
|
||||
If `options` has a `plugins` array: for the first plugin whose `test(val)` method returns a truthy value, then `prettyFormat(val, options)` returns the result from either:
|
||||
|
||||
- `serialize(val, …)` method of the **improved** interface (available in **version 21** or later)
|
||||
- `print(val, …)` method of the **original** interface (if plugin does not have `serialize` method)
|
||||
|
||||
### test
|
||||
|
||||
Write `test` so it can receive `val` argument of any type. To serialize **objects** which have certain properties, then a guarded expression like `val != null && …` or more concise `val && …` prevents the following errors:
|
||||
|
||||
- `TypeError: Cannot read property 'whatever' of null`
|
||||
- `TypeError: Cannot read property 'whatever' of undefined`
|
||||
|
||||
For example, `test` method of built-in `ReactElement` plugin:
|
||||
|
||||
```js
|
||||
const elementSymbol = Symbol.for('react.element');
|
||||
const test = val => val && val.$$typeof === elementSymbol;
|
||||
```
|
||||
|
||||
Pay attention to efficiency in `test` because `pretty-format` calls it often.
|
||||
|
||||
### serialize
|
||||
|
||||
The **improved** interface is available in **version 21** or later.
|
||||
|
||||
Write `serialize` to return a string, given the arguments:
|
||||
|
||||
- `val` which “passed the test”
|
||||
- unchanging `config` object: derived from `options`
|
||||
- current `indentation` string: concatenate to `indent` from `config`
|
||||
- current `depth` number: compare to `maxDepth` from `config`
|
||||
- current `refs` array: find circular references in objects
|
||||
- `printer` callback function: serialize children
|
||||
|
||||
### config
|
||||
|
||||
<!-- prettier-ignore -->
|
||||
| key | type | description |
|
||||
| :------------------ | :-------- | :------------------------------------------------------ |
|
||||
| `callToJSON` | `boolean` | call `toJSON` method (if it exists) on objects |
|
||||
| `colors` | `Object` | escape codes for colors to highlight syntax |
|
||||
| `escapeRegex` | `boolean` | escape special characters in regular expressions |
|
||||
| `escapeString` | `boolean` | escape special characters in strings |
|
||||
| `indent` | `string` | spaces in each level of indentation |
|
||||
| `maxDepth` | `number` | levels to print in arrays, objects, elements, and so on |
|
||||
| `min` | `boolean` | minimize added space: no indentation nor line breaks |
|
||||
| `plugins` | `array` | plugins to serialize application-specific data types |
|
||||
| `printFunctionName` | `boolean` | include or omit the name of a function |
|
||||
| `spacingInner` | `strong` | spacing to separate items in a list |
|
||||
| `spacingOuter` | `strong` | spacing to enclose a list of items |
|
||||
|
||||
Each property of `colors` in `config` corresponds to a property of `theme` in `options`:
|
||||
|
||||
- the key is the same (for example, `tag`)
|
||||
- the value in `colors` is a object with `open` and `close` properties whose values are escape codes from [ansi-styles](https://github.com/chalk/ansi-styles) for the color value in `theme` (for example, `'cyan'`)
|
||||
|
||||
Some properties in `config` are derived from `min` in `options`:
|
||||
|
||||
- `spacingInner` and `spacingOuter` are **newline** if `min` is `false`
|
||||
- `spacingInner` is **space** and `spacingOuter` is **empty string** if `min` is `true`
|
||||
|
||||
### Example of serialize and test
|
||||
|
||||
This plugin is a pattern you can apply to serialize composite data types. Side note: `pretty-format` does not need a plugin to serialize arrays.
|
||||
|
||||
```js
|
||||
// We reused more code when we factored out a function for child items
|
||||
// that is independent of depth, name, and enclosing punctuation (see below).
|
||||
const SEPARATOR = ',';
|
||||
function serializeItems(items, config, indentation, depth, refs, printer) {
|
||||
if (items.length === 0) {
|
||||
return '';
|
||||
}
|
||||
const indentationItems = indentation + config.indent;
|
||||
return (
|
||||
config.spacingOuter +
|
||||
items
|
||||
.map(
|
||||
item =>
|
||||
indentationItems +
|
||||
printer(item, config, indentationItems, depth, refs), // callback
|
||||
)
|
||||
.join(SEPARATOR + config.spacingInner) +
|
||||
(config.min ? '' : SEPARATOR) + // following the last item
|
||||
config.spacingOuter +
|
||||
indentation
|
||||
);
|
||||
}
|
||||
|
||||
const plugin = {
|
||||
test(val) {
|
||||
return Array.isArray(val);
|
||||
},
|
||||
serialize(array, config, indentation, depth, refs, printer) {
|
||||
const name = array.constructor.name;
|
||||
return ++depth > config.maxDepth
|
||||
? '[' + name + ']'
|
||||
: (config.min ? '' : name + ' ') +
|
||||
'[' +
|
||||
serializeItems(array, config, indentation, depth, refs, printer) +
|
||||
']';
|
||||
},
|
||||
};
|
||||
```
|
||||
|
||||
```js
|
||||
const val = {
|
||||
filter: 'completed',
|
||||
items: [
|
||||
{
|
||||
text: 'Write test',
|
||||
completed: true,
|
||||
},
|
||||
{
|
||||
text: 'Write serialize',
|
||||
completed: true,
|
||||
},
|
||||
],
|
||||
};
|
||||
```
|
||||
|
||||
```js
|
||||
console.log(
|
||||
prettyFormat(val, {
|
||||
plugins: [plugin],
|
||||
}),
|
||||
);
|
||||
/*
|
||||
Object {
|
||||
"filter": "completed",
|
||||
"items": Array [
|
||||
Object {
|
||||
"completed": true,
|
||||
"text": "Write test",
|
||||
},
|
||||
Object {
|
||||
"completed": true,
|
||||
"text": "Write serialize",
|
||||
},
|
||||
],
|
||||
}
|
||||
*/
|
||||
```
|
||||
|
||||
```js
|
||||
console.log(
|
||||
prettyFormat(val, {
|
||||
indent: 4,
|
||||
plugins: [plugin],
|
||||
}),
|
||||
);
|
||||
/*
|
||||
Object {
|
||||
"filter": "completed",
|
||||
"items": Array [
|
||||
Object {
|
||||
"completed": true,
|
||||
"text": "Write test",
|
||||
},
|
||||
Object {
|
||||
"completed": true,
|
||||
"text": "Write serialize",
|
||||
},
|
||||
],
|
||||
}
|
||||
*/
|
||||
```
|
||||
|
||||
```js
|
||||
console.log(
|
||||
prettyFormat(val, {
|
||||
maxDepth: 1,
|
||||
plugins: [plugin],
|
||||
}),
|
||||
);
|
||||
/*
|
||||
Object {
|
||||
"filter": "completed",
|
||||
"items": [Array],
|
||||
}
|
||||
*/
|
||||
```
|
||||
|
||||
```js
|
||||
console.log(
|
||||
prettyFormat(val, {
|
||||
min: true,
|
||||
plugins: [plugin],
|
||||
}),
|
||||
);
|
||||
/*
|
||||
{"filter": "completed", "items": [{"completed": true, "text": "Write test"}, {"completed": true, "text": "Write serialize"}]}
|
||||
*/
|
||||
```
|
||||
|
||||
### print
|
||||
|
||||
The **original** interface is adequate for plugins:
|
||||
|
||||
- that **do not** depend on options other than `highlight` or `min`
|
||||
- that **do not** depend on `depth` or `refs` in recursive traversal, and
|
||||
- if values either
|
||||
- do **not** require indentation, or
|
||||
- do **not** occur as children of JavaScript data structures (for example, array)
|
||||
|
||||
Write `print` to return a string, given the arguments:
|
||||
|
||||
- `val` which “passed the test”
|
||||
- current `printer(valChild)` callback function: serialize children
|
||||
- current `indenter(lines)` callback function: indent lines at the next level
|
||||
- unchanging `config` object: derived from `options`
|
||||
- unchanging `colors` object: derived from `options`
|
||||
|
||||
The 3 properties of `config` are `min` in `options` and:
|
||||
|
||||
- `spacing` and `edgeSpacing` are **newline** if `min` is `false`
|
||||
- `spacing` is **space** and `edgeSpacing` is **empty string** if `min` is `true`
|
||||
|
||||
Each property of `colors` corresponds to a property of `theme` in `options`:
|
||||
|
||||
- the key is the same (for example, `tag`)
|
||||
- the value in `colors` is a object with `open` and `close` properties whose values are escape codes from [ansi-styles](https://github.com/chalk/ansi-styles) for the color value in `theme` (for example, `'cyan'`)
|
||||
|
||||
### Example of print and test
|
||||
|
||||
This plugin prints functions with the **number of named arguments** excluding rest argument.
|
||||
|
||||
```js
|
||||
const plugin = {
|
||||
print(val) {
|
||||
return `[Function ${val.name || 'anonymous'} ${val.length}]`;
|
||||
},
|
||||
test(val) {
|
||||
return typeof val === 'function';
|
||||
},
|
||||
};
|
||||
```
|
||||
|
||||
```js
|
||||
const val = {
|
||||
onClick(event) {},
|
||||
render() {},
|
||||
};
|
||||
|
||||
prettyFormat(val, {
|
||||
plugins: [plugin],
|
||||
});
|
||||
/*
|
||||
Object {
|
||||
"onClick": [Function onClick 1],
|
||||
"render": [Function render 0],
|
||||
}
|
||||
*/
|
||||
|
||||
prettyFormat(val);
|
||||
/*
|
||||
Object {
|
||||
"onClick": [Function onClick],
|
||||
"render": [Function render],
|
||||
}
|
||||
*/
|
||||
```
|
||||
|
||||
This plugin **ignores** the `printFunctionName` option. That limitation of the original `print` interface is a reason to use the improved `serialize` interface, described above.
|
||||
|
||||
```js
|
||||
prettyFormat(val, {
|
||||
plugins: [pluginOld],
|
||||
printFunctionName: false,
|
||||
});
|
||||
/*
|
||||
Object {
|
||||
"onClick": [Function onClick 1],
|
||||
"render": [Function render 0],
|
||||
}
|
||||
*/
|
||||
|
||||
prettyFormat(val, {
|
||||
printFunctionName: false,
|
||||
});
|
||||
/*
|
||||
Object {
|
||||
"onClick": [Function],
|
||||
"render": [Function],
|
||||
}
|
||||
*/
|
||||
```
|
32
node_modules/jest-snapshot/node_modules/pretty-format/build/collections.d.ts
generated
vendored
Normal file
32
node_modules/jest-snapshot/node_modules/pretty-format/build/collections.d.ts
generated
vendored
Normal file
@ -0,0 +1,32 @@
|
||||
/**
|
||||
* 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, Printer, Refs } from './types';
|
||||
/**
|
||||
* Return entries (for example, of a map)
|
||||
* with spacing, indentation, and comma
|
||||
* without surrounding punctuation (for example, braces)
|
||||
*/
|
||||
export declare function printIteratorEntries(iterator: Iterator<[unknown, unknown]>, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer, separator?: string): string;
|
||||
/**
|
||||
* Return values (for example, of a set)
|
||||
* with spacing, indentation, and comma
|
||||
* without surrounding punctuation (braces or brackets)
|
||||
*/
|
||||
export declare function printIteratorValues(iterator: Iterator<unknown>, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer): string;
|
||||
/**
|
||||
* Return items (for example, of an array)
|
||||
* with spacing, indentation, and comma
|
||||
* without surrounding punctuation (for example, brackets)
|
||||
**/
|
||||
export declare function printListItems(list: ArrayLike<unknown>, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer): string;
|
||||
/**
|
||||
* Return properties of an object
|
||||
* with spacing, indentation, and comma
|
||||
* without surrounding punctuation (for example, braces)
|
||||
*/
|
||||
export declare function printObjectProperties(val: Record<string, unknown>, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer): string;
|
185
node_modules/jest-snapshot/node_modules/pretty-format/build/collections.js
generated
vendored
Normal file
185
node_modules/jest-snapshot/node_modules/pretty-format/build/collections.js
generated
vendored
Normal file
@ -0,0 +1,185 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.printIteratorEntries = printIteratorEntries;
|
||||
exports.printIteratorValues = printIteratorValues;
|
||||
exports.printListItems = printListItems;
|
||||
exports.printObjectProperties = printObjectProperties;
|
||||
|
||||
/**
|
||||
* 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 getKeysOfEnumerableProperties = object => {
|
||||
const keys = Object.keys(object).sort();
|
||||
|
||||
if (Object.getOwnPropertySymbols) {
|
||||
Object.getOwnPropertySymbols(object).forEach(symbol => {
|
||||
if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
|
||||
keys.push(symbol);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return keys;
|
||||
};
|
||||
/**
|
||||
* Return entries (for example, of a map)
|
||||
* with spacing, indentation, and comma
|
||||
* without surrounding punctuation (for example, braces)
|
||||
*/
|
||||
|
||||
function printIteratorEntries(
|
||||
iterator,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer, // Too bad, so sad that separator for ECMAScript Map has been ' => '
|
||||
// What a distracting diff if you change a data structure to/from
|
||||
// ECMAScript Object or Immutable.Map/OrderedMap which use the default.
|
||||
separator = ': '
|
||||
) {
|
||||
let result = '';
|
||||
let current = iterator.next();
|
||||
|
||||
if (!current.done) {
|
||||
result += config.spacingOuter;
|
||||
const indentationNext = indentation + config.indent;
|
||||
|
||||
while (!current.done) {
|
||||
const name = printer(
|
||||
current.value[0],
|
||||
config,
|
||||
indentationNext,
|
||||
depth,
|
||||
refs
|
||||
);
|
||||
const value = printer(
|
||||
current.value[1],
|
||||
config,
|
||||
indentationNext,
|
||||
depth,
|
||||
refs
|
||||
);
|
||||
result += indentationNext + name + separator + value;
|
||||
current = iterator.next();
|
||||
|
||||
if (!current.done) {
|
||||
result += ',' + config.spacingInner;
|
||||
} else if (!config.min) {
|
||||
result += ',';
|
||||
}
|
||||
}
|
||||
|
||||
result += config.spacingOuter + indentation;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
/**
|
||||
* Return values (for example, of a set)
|
||||
* with spacing, indentation, and comma
|
||||
* without surrounding punctuation (braces or brackets)
|
||||
*/
|
||||
|
||||
function printIteratorValues(
|
||||
iterator,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) {
|
||||
let result = '';
|
||||
let current = iterator.next();
|
||||
|
||||
if (!current.done) {
|
||||
result += config.spacingOuter;
|
||||
const indentationNext = indentation + config.indent;
|
||||
|
||||
while (!current.done) {
|
||||
result +=
|
||||
indentationNext +
|
||||
printer(current.value, config, indentationNext, depth, refs);
|
||||
current = iterator.next();
|
||||
|
||||
if (!current.done) {
|
||||
result += ',' + config.spacingInner;
|
||||
} else if (!config.min) {
|
||||
result += ',';
|
||||
}
|
||||
}
|
||||
|
||||
result += config.spacingOuter + indentation;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
/**
|
||||
* Return items (for example, of an array)
|
||||
* with spacing, indentation, and comma
|
||||
* without surrounding punctuation (for example, brackets)
|
||||
**/
|
||||
|
||||
function printListItems(list, config, indentation, depth, refs, printer) {
|
||||
let result = '';
|
||||
|
||||
if (list.length) {
|
||||
result += config.spacingOuter;
|
||||
const indentationNext = indentation + config.indent;
|
||||
|
||||
for (let i = 0; i < list.length; i++) {
|
||||
result +=
|
||||
indentationNext +
|
||||
printer(list[i], config, indentationNext, depth, refs);
|
||||
|
||||
if (i < list.length - 1) {
|
||||
result += ',' + config.spacingInner;
|
||||
} else if (!config.min) {
|
||||
result += ',';
|
||||
}
|
||||
}
|
||||
|
||||
result += config.spacingOuter + indentation;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
/**
|
||||
* Return properties of an object
|
||||
* with spacing, indentation, and comma
|
||||
* without surrounding punctuation (for example, braces)
|
||||
*/
|
||||
|
||||
function printObjectProperties(val, config, indentation, depth, refs, printer) {
|
||||
let result = '';
|
||||
const keys = getKeysOfEnumerableProperties(val);
|
||||
|
||||
if (keys.length) {
|
||||
result += config.spacingOuter;
|
||||
const indentationNext = indentation + config.indent;
|
||||
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
const key = keys[i];
|
||||
const name = printer(key, config, indentationNext, depth, refs);
|
||||
const value = printer(val[key], config, indentationNext, depth, refs);
|
||||
result += indentationNext + name + ': ' + value;
|
||||
|
||||
if (i < keys.length - 1) {
|
||||
result += ',' + config.spacingInner;
|
||||
} else if (!config.min) {
|
||||
result += ',';
|
||||
}
|
||||
}
|
||||
|
||||
result += config.spacingOuter + indentation;
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
37
node_modules/jest-snapshot/node_modules/pretty-format/build/index.d.ts
generated
vendored
Normal file
37
node_modules/jest-snapshot/node_modules/pretty-format/build/index.d.ts
generated
vendored
Normal file
@ -0,0 +1,37 @@
|
||||
/**
|
||||
* 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 * as PrettyFormat from './types';
|
||||
/**
|
||||
* Returns a presentation string of your `val` object
|
||||
* @param val any potential JavaScript object
|
||||
* @param options Custom settings
|
||||
*/
|
||||
declare function prettyFormat(val: unknown, options?: PrettyFormat.OptionsReceived): string;
|
||||
declare namespace prettyFormat {
|
||||
var plugins: {
|
||||
AsymmetricMatcher: PrettyFormat.NewPlugin;
|
||||
ConvertAnsi: PrettyFormat.NewPlugin;
|
||||
DOMCollection: PrettyFormat.NewPlugin;
|
||||
DOMElement: PrettyFormat.NewPlugin;
|
||||
Immutable: PrettyFormat.NewPlugin;
|
||||
ReactElement: PrettyFormat.NewPlugin;
|
||||
ReactTestComponent: PrettyFormat.NewPlugin;
|
||||
};
|
||||
}
|
||||
declare namespace prettyFormat {
|
||||
type Colors = PrettyFormat.Colors;
|
||||
type Config = PrettyFormat.Config;
|
||||
type Options = PrettyFormat.Options;
|
||||
type OptionsReceived = PrettyFormat.OptionsReceived;
|
||||
type OldPlugin = PrettyFormat.OldPlugin;
|
||||
type NewPlugin = PrettyFormat.NewPlugin;
|
||||
type Plugin = PrettyFormat.Plugin;
|
||||
type Plugins = PrettyFormat.Plugins;
|
||||
type Refs = PrettyFormat.Refs;
|
||||
type Theme = PrettyFormat.Theme;
|
||||
}
|
||||
export = prettyFormat;
|
560
node_modules/jest-snapshot/node_modules/pretty-format/build/index.js
generated
vendored
Normal file
560
node_modules/jest-snapshot/node_modules/pretty-format/build/index.js
generated
vendored
Normal file
@ -0,0 +1,560 @@
|
||||
'use strict';
|
||||
|
||||
var _ansiStyles = _interopRequireDefault(require('ansi-styles'));
|
||||
|
||||
var _collections = require('./collections');
|
||||
|
||||
var _AsymmetricMatcher = _interopRequireDefault(
|
||||
require('./plugins/AsymmetricMatcher')
|
||||
);
|
||||
|
||||
var _ConvertAnsi = _interopRequireDefault(require('./plugins/ConvertAnsi'));
|
||||
|
||||
var _DOMCollection = _interopRequireDefault(require('./plugins/DOMCollection'));
|
||||
|
||||
var _DOMElement = _interopRequireDefault(require('./plugins/DOMElement'));
|
||||
|
||||
var _Immutable = _interopRequireDefault(require('./plugins/Immutable'));
|
||||
|
||||
var _ReactElement = _interopRequireDefault(require('./plugins/ReactElement'));
|
||||
|
||||
var _ReactTestComponent = _interopRequireDefault(
|
||||
require('./plugins/ReactTestComponent')
|
||||
);
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
/* eslint-disable local/ban-types-eventually */
|
||||
const toString = Object.prototype.toString;
|
||||
const toISOString = Date.prototype.toISOString;
|
||||
const errorToString = Error.prototype.toString;
|
||||
const regExpToString = RegExp.prototype.toString;
|
||||
/**
|
||||
* Explicitly comparing typeof constructor to function avoids undefined as name
|
||||
* when mock identity-obj-proxy returns the key as the value for any key.
|
||||
*/
|
||||
|
||||
const getConstructorName = val =>
|
||||
(typeof val.constructor === 'function' && val.constructor.name) || 'Object';
|
||||
/* global window */
|
||||
|
||||
/** Is val is equal to global window object? Works even if it does not exist :) */
|
||||
|
||||
const isWindow = val => typeof window !== 'undefined' && val === window;
|
||||
|
||||
const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
|
||||
const NEWLINE_REGEXP = /\n/gi;
|
||||
|
||||
class PrettyFormatPluginError extends Error {
|
||||
constructor(message, stack) {
|
||||
super(message);
|
||||
this.stack = stack;
|
||||
this.name = this.constructor.name;
|
||||
}
|
||||
}
|
||||
|
||||
function isToStringedArrayType(toStringed) {
|
||||
return (
|
||||
toStringed === '[object Array]' ||
|
||||
toStringed === '[object ArrayBuffer]' ||
|
||||
toStringed === '[object DataView]' ||
|
||||
toStringed === '[object Float32Array]' ||
|
||||
toStringed === '[object Float64Array]' ||
|
||||
toStringed === '[object Int8Array]' ||
|
||||
toStringed === '[object Int16Array]' ||
|
||||
toStringed === '[object Int32Array]' ||
|
||||
toStringed === '[object Uint8Array]' ||
|
||||
toStringed === '[object Uint8ClampedArray]' ||
|
||||
toStringed === '[object Uint16Array]' ||
|
||||
toStringed === '[object Uint32Array]'
|
||||
);
|
||||
}
|
||||
|
||||
function printNumber(val) {
|
||||
return Object.is(val, -0) ? '-0' : String(val);
|
||||
}
|
||||
|
||||
function printBigInt(val) {
|
||||
return String(`${val}n`);
|
||||
}
|
||||
|
||||
function printFunction(val, printFunctionName) {
|
||||
if (!printFunctionName) {
|
||||
return '[Function]';
|
||||
}
|
||||
|
||||
return '[Function ' + (val.name || 'anonymous') + ']';
|
||||
}
|
||||
|
||||
function printSymbol(val) {
|
||||
return String(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
|
||||
}
|
||||
|
||||
function printError(val) {
|
||||
return '[' + errorToString.call(val) + ']';
|
||||
}
|
||||
/**
|
||||
* The first port of call for printing an object, handles most of the
|
||||
* data-types in JS.
|
||||
*/
|
||||
|
||||
function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
|
||||
if (val === true || val === false) {
|
||||
return '' + val;
|
||||
}
|
||||
|
||||
if (val === undefined) {
|
||||
return 'undefined';
|
||||
}
|
||||
|
||||
if (val === null) {
|
||||
return 'null';
|
||||
}
|
||||
|
||||
const typeOf = typeof val;
|
||||
|
||||
if (typeOf === 'number') {
|
||||
return printNumber(val);
|
||||
}
|
||||
|
||||
if (typeOf === 'bigint') {
|
||||
return printBigInt(val);
|
||||
}
|
||||
|
||||
if (typeOf === 'string') {
|
||||
if (escapeString) {
|
||||
return '"' + val.replace(/"|\\/g, '\\$&') + '"';
|
||||
}
|
||||
|
||||
return '"' + val + '"';
|
||||
}
|
||||
|
||||
if (typeOf === 'function') {
|
||||
return printFunction(val, printFunctionName);
|
||||
}
|
||||
|
||||
if (typeOf === 'symbol') {
|
||||
return printSymbol(val);
|
||||
}
|
||||
|
||||
const toStringed = toString.call(val);
|
||||
|
||||
if (toStringed === '[object WeakMap]') {
|
||||
return 'WeakMap {}';
|
||||
}
|
||||
|
||||
if (toStringed === '[object WeakSet]') {
|
||||
return 'WeakSet {}';
|
||||
}
|
||||
|
||||
if (
|
||||
toStringed === '[object Function]' ||
|
||||
toStringed === '[object GeneratorFunction]'
|
||||
) {
|
||||
return printFunction(val, printFunctionName);
|
||||
}
|
||||
|
||||
if (toStringed === '[object Symbol]') {
|
||||
return printSymbol(val);
|
||||
}
|
||||
|
||||
if (toStringed === '[object Date]') {
|
||||
return isNaN(+val) ? 'Date { NaN }' : toISOString.call(val);
|
||||
}
|
||||
|
||||
if (toStringed === '[object Error]') {
|
||||
return printError(val);
|
||||
}
|
||||
|
||||
if (toStringed === '[object RegExp]') {
|
||||
if (escapeRegex) {
|
||||
// https://github.com/benjamingr/RegExp.escape/blob/master/polyfill.js
|
||||
return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
|
||||
}
|
||||
|
||||
return regExpToString.call(val);
|
||||
}
|
||||
|
||||
if (val instanceof Error) {
|
||||
return printError(val);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
/**
|
||||
* Handles more complex objects ( such as objects with circular references.
|
||||
* maps and sets etc )
|
||||
*/
|
||||
|
||||
function printComplexValue(
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
hasCalledToJSON
|
||||
) {
|
||||
if (refs.indexOf(val) !== -1) {
|
||||
return '[Circular]';
|
||||
}
|
||||
|
||||
refs = refs.slice();
|
||||
refs.push(val);
|
||||
const hitMaxDepth = ++depth > config.maxDepth;
|
||||
const min = config.min;
|
||||
|
||||
if (
|
||||
config.callToJSON &&
|
||||
!hitMaxDepth &&
|
||||
val.toJSON &&
|
||||
typeof val.toJSON === 'function' &&
|
||||
!hasCalledToJSON
|
||||
) {
|
||||
return printer(val.toJSON(), config, indentation, depth, refs, true);
|
||||
}
|
||||
|
||||
const toStringed = toString.call(val);
|
||||
|
||||
if (toStringed === '[object Arguments]') {
|
||||
return hitMaxDepth
|
||||
? '[Arguments]'
|
||||
: (min ? '' : 'Arguments ') +
|
||||
'[' +
|
||||
(0, _collections.printListItems)(
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
']';
|
||||
}
|
||||
|
||||
if (isToStringedArrayType(toStringed)) {
|
||||
return hitMaxDepth
|
||||
? '[' + val.constructor.name + ']'
|
||||
: (min ? '' : val.constructor.name + ' ') +
|
||||
'[' +
|
||||
(0, _collections.printListItems)(
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
']';
|
||||
}
|
||||
|
||||
if (toStringed === '[object Map]') {
|
||||
return hitMaxDepth
|
||||
? '[Map]'
|
||||
: 'Map {' +
|
||||
(0, _collections.printIteratorEntries)(
|
||||
val.entries(),
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer,
|
||||
' => '
|
||||
) +
|
||||
'}';
|
||||
}
|
||||
|
||||
if (toStringed === '[object Set]') {
|
||||
return hitMaxDepth
|
||||
? '[Set]'
|
||||
: 'Set {' +
|
||||
(0, _collections.printIteratorValues)(
|
||||
val.values(),
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
'}';
|
||||
} // Avoid failure to serialize global window object in jsdom test environment.
|
||||
// For example, not even relevant if window is prop of React element.
|
||||
|
||||
return hitMaxDepth || isWindow(val)
|
||||
? '[' + getConstructorName(val) + ']'
|
||||
: (min ? '' : getConstructorName(val) + ' ') +
|
||||
'{' +
|
||||
(0, _collections.printObjectProperties)(
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
'}';
|
||||
}
|
||||
|
||||
function isNewPlugin(plugin) {
|
||||
return plugin.serialize != null;
|
||||
}
|
||||
|
||||
function printPlugin(plugin, val, config, indentation, depth, refs) {
|
||||
let printed;
|
||||
|
||||
try {
|
||||
printed = isNewPlugin(plugin)
|
||||
? plugin.serialize(val, config, indentation, depth, refs, printer)
|
||||
: plugin.print(
|
||||
val,
|
||||
valChild => printer(valChild, config, indentation, depth, refs),
|
||||
str => {
|
||||
const indentationNext = indentation + config.indent;
|
||||
return (
|
||||
indentationNext +
|
||||
str.replace(NEWLINE_REGEXP, '\n' + indentationNext)
|
||||
);
|
||||
},
|
||||
{
|
||||
edgeSpacing: config.spacingOuter,
|
||||
min: config.min,
|
||||
spacing: config.spacingInner
|
||||
},
|
||||
config.colors
|
||||
);
|
||||
} catch (error) {
|
||||
throw new PrettyFormatPluginError(error.message, error.stack);
|
||||
}
|
||||
|
||||
if (typeof printed !== 'string') {
|
||||
throw new Error(
|
||||
`pretty-format: Plugin must return type "string" but instead returned "${typeof printed}".`
|
||||
);
|
||||
}
|
||||
|
||||
return printed;
|
||||
}
|
||||
|
||||
function findPlugin(plugins, val) {
|
||||
for (let p = 0; p < plugins.length; p++) {
|
||||
try {
|
||||
if (plugins[p].test(val)) {
|
||||
return plugins[p];
|
||||
}
|
||||
} catch (error) {
|
||||
throw new PrettyFormatPluginError(error.message, error.stack);
|
||||
}
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
|
||||
const plugin = findPlugin(config.plugins, val);
|
||||
|
||||
if (plugin !== null) {
|
||||
return printPlugin(plugin, val, config, indentation, depth, refs);
|
||||
}
|
||||
|
||||
const basicResult = printBasicValue(
|
||||
val,
|
||||
config.printFunctionName,
|
||||
config.escapeRegex,
|
||||
config.escapeString
|
||||
);
|
||||
|
||||
if (basicResult !== null) {
|
||||
return basicResult;
|
||||
}
|
||||
|
||||
return printComplexValue(
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
hasCalledToJSON
|
||||
);
|
||||
}
|
||||
|
||||
const DEFAULT_THEME = {
|
||||
comment: 'gray',
|
||||
content: 'reset',
|
||||
prop: 'yellow',
|
||||
tag: 'cyan',
|
||||
value: 'green'
|
||||
};
|
||||
const DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
|
||||
const DEFAULT_OPTIONS = {
|
||||
callToJSON: true,
|
||||
escapeRegex: false,
|
||||
escapeString: true,
|
||||
highlight: false,
|
||||
indent: 2,
|
||||
maxDepth: Infinity,
|
||||
min: false,
|
||||
plugins: [],
|
||||
printFunctionName: true,
|
||||
theme: DEFAULT_THEME
|
||||
};
|
||||
|
||||
function validateOptions(options) {
|
||||
Object.keys(options).forEach(key => {
|
||||
if (!DEFAULT_OPTIONS.hasOwnProperty(key)) {
|
||||
throw new Error(`pretty-format: Unknown option "${key}".`);
|
||||
}
|
||||
});
|
||||
|
||||
if (options.min && options.indent !== undefined && options.indent !== 0) {
|
||||
throw new Error(
|
||||
'pretty-format: Options "min" and "indent" cannot be used together.'
|
||||
);
|
||||
}
|
||||
|
||||
if (options.theme !== undefined) {
|
||||
if (options.theme === null) {
|
||||
throw new Error(`pretty-format: Option "theme" must not be null.`);
|
||||
}
|
||||
|
||||
if (typeof options.theme !== 'object') {
|
||||
throw new Error(
|
||||
`pretty-format: Option "theme" must be of type "object" but instead received "${typeof options.theme}".`
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const getColorsHighlight = options =>
|
||||
DEFAULT_THEME_KEYS.reduce((colors, key) => {
|
||||
const value =
|
||||
options.theme && options.theme[key] !== undefined
|
||||
? options.theme[key]
|
||||
: DEFAULT_THEME[key];
|
||||
const color = value && _ansiStyles.default[value];
|
||||
|
||||
if (
|
||||
color &&
|
||||
typeof color.close === 'string' &&
|
||||
typeof color.open === 'string'
|
||||
) {
|
||||
colors[key] = color;
|
||||
} else {
|
||||
throw new Error(
|
||||
`pretty-format: Option "theme" has a key "${key}" whose value "${value}" is undefined in ansi-styles.`
|
||||
);
|
||||
}
|
||||
|
||||
return colors;
|
||||
}, Object.create(null));
|
||||
|
||||
const getColorsEmpty = () =>
|
||||
DEFAULT_THEME_KEYS.reduce((colors, key) => {
|
||||
colors[key] = {
|
||||
close: '',
|
||||
open: ''
|
||||
};
|
||||
return colors;
|
||||
}, Object.create(null));
|
||||
|
||||
const getPrintFunctionName = options =>
|
||||
options && options.printFunctionName !== undefined
|
||||
? options.printFunctionName
|
||||
: DEFAULT_OPTIONS.printFunctionName;
|
||||
|
||||
const getEscapeRegex = options =>
|
||||
options && options.escapeRegex !== undefined
|
||||
? options.escapeRegex
|
||||
: DEFAULT_OPTIONS.escapeRegex;
|
||||
|
||||
const getEscapeString = options =>
|
||||
options && options.escapeString !== undefined
|
||||
? options.escapeString
|
||||
: DEFAULT_OPTIONS.escapeString;
|
||||
|
||||
const getConfig = options => ({
|
||||
callToJSON:
|
||||
options && options.callToJSON !== undefined
|
||||
? options.callToJSON
|
||||
: DEFAULT_OPTIONS.callToJSON,
|
||||
colors:
|
||||
options && options.highlight
|
||||
? getColorsHighlight(options)
|
||||
: getColorsEmpty(),
|
||||
escapeRegex: getEscapeRegex(options),
|
||||
escapeString: getEscapeString(options),
|
||||
indent:
|
||||
options && options.min
|
||||
? ''
|
||||
: createIndent(
|
||||
options && options.indent !== undefined
|
||||
? options.indent
|
||||
: DEFAULT_OPTIONS.indent
|
||||
),
|
||||
maxDepth:
|
||||
options && options.maxDepth !== undefined
|
||||
? options.maxDepth
|
||||
: DEFAULT_OPTIONS.maxDepth,
|
||||
min: options && options.min !== undefined ? options.min : DEFAULT_OPTIONS.min,
|
||||
plugins:
|
||||
options && options.plugins !== undefined
|
||||
? options.plugins
|
||||
: DEFAULT_OPTIONS.plugins,
|
||||
printFunctionName: getPrintFunctionName(options),
|
||||
spacingInner: options && options.min ? ' ' : '\n',
|
||||
spacingOuter: options && options.min ? '' : '\n'
|
||||
});
|
||||
|
||||
function createIndent(indent) {
|
||||
return new Array(indent + 1).join(' ');
|
||||
}
|
||||
/**
|
||||
* Returns a presentation string of your `val` object
|
||||
* @param val any potential JavaScript object
|
||||
* @param options Custom settings
|
||||
*/
|
||||
|
||||
function prettyFormat(val, options) {
|
||||
if (options) {
|
||||
validateOptions(options);
|
||||
|
||||
if (options.plugins) {
|
||||
const plugin = findPlugin(options.plugins, val);
|
||||
|
||||
if (plugin !== null) {
|
||||
return printPlugin(plugin, val, getConfig(options), '', 0, []);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const basicResult = printBasicValue(
|
||||
val,
|
||||
getPrintFunctionName(options),
|
||||
getEscapeRegex(options),
|
||||
getEscapeString(options)
|
||||
);
|
||||
|
||||
if (basicResult !== null) {
|
||||
return basicResult;
|
||||
}
|
||||
|
||||
return printComplexValue(val, getConfig(options), '', 0, []);
|
||||
}
|
||||
|
||||
prettyFormat.plugins = {
|
||||
AsymmetricMatcher: _AsymmetricMatcher.default,
|
||||
ConvertAnsi: _ConvertAnsi.default,
|
||||
DOMCollection: _DOMCollection.default,
|
||||
DOMElement: _DOMElement.default,
|
||||
Immutable: _Immutable.default,
|
||||
ReactElement: _ReactElement.default,
|
||||
ReactTestComponent: _ReactTestComponent.default
|
||||
};
|
||||
module.exports = prettyFormat;
|
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/AsymmetricMatcher.d.ts
generated
vendored
Normal file
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/AsymmetricMatcher.d.ts
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
/**
|
||||
* 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 { NewPlugin } from '../types';
|
||||
export declare const serialize: NewPlugin['serialize'];
|
||||
export declare const test: NewPlugin['test'];
|
||||
declare const plugin: NewPlugin;
|
||||
export default plugin;
|
103
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/AsymmetricMatcher.js
generated
vendored
Normal file
103
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/AsymmetricMatcher.js
generated
vendored
Normal file
@ -0,0 +1,103 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = exports.test = exports.serialize = void 0;
|
||||
|
||||
var _collections = require('../collections');
|
||||
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
const asymmetricMatcher =
|
||||
typeof Symbol === 'function' && Symbol.for
|
||||
? Symbol.for('jest.asymmetricMatcher')
|
||||
: 0x1357a5;
|
||||
const SPACE = ' ';
|
||||
|
||||
const serialize = (val, config, indentation, depth, refs, printer) => {
|
||||
const stringedValue = val.toString();
|
||||
|
||||
if (
|
||||
stringedValue === 'ArrayContaining' ||
|
||||
stringedValue === 'ArrayNotContaining'
|
||||
) {
|
||||
if (++depth > config.maxDepth) {
|
||||
return '[' + stringedValue + ']';
|
||||
}
|
||||
|
||||
return (
|
||||
stringedValue +
|
||||
SPACE +
|
||||
'[' +
|
||||
(0, _collections.printListItems)(
|
||||
val.sample,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
']'
|
||||
);
|
||||
}
|
||||
|
||||
if (
|
||||
stringedValue === 'ObjectContaining' ||
|
||||
stringedValue === 'ObjectNotContaining'
|
||||
) {
|
||||
if (++depth > config.maxDepth) {
|
||||
return '[' + stringedValue + ']';
|
||||
}
|
||||
|
||||
return (
|
||||
stringedValue +
|
||||
SPACE +
|
||||
'{' +
|
||||
(0, _collections.printObjectProperties)(
|
||||
val.sample,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
'}'
|
||||
);
|
||||
}
|
||||
|
||||
if (
|
||||
stringedValue === 'StringMatching' ||
|
||||
stringedValue === 'StringNotMatching'
|
||||
) {
|
||||
return (
|
||||
stringedValue +
|
||||
SPACE +
|
||||
printer(val.sample, config, indentation, depth, refs)
|
||||
);
|
||||
}
|
||||
|
||||
if (
|
||||
stringedValue === 'StringContaining' ||
|
||||
stringedValue === 'StringNotContaining'
|
||||
) {
|
||||
return (
|
||||
stringedValue +
|
||||
SPACE +
|
||||
printer(val.sample, config, indentation, depth, refs)
|
||||
);
|
||||
}
|
||||
|
||||
return val.toAsymmetricMatcher();
|
||||
};
|
||||
|
||||
exports.serialize = serialize;
|
||||
|
||||
const test = val => val && val.$$typeof === asymmetricMatcher;
|
||||
|
||||
exports.test = test;
|
||||
const plugin = {
|
||||
serialize,
|
||||
test
|
||||
};
|
||||
var _default = plugin;
|
||||
exports.default = _default;
|
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ConvertAnsi.d.ts
generated
vendored
Normal file
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ConvertAnsi.d.ts
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
/**
|
||||
* 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 { NewPlugin } from '../types';
|
||||
export declare const test: NewPlugin['test'];
|
||||
export declare const serialize: NewPlugin['serialize'];
|
||||
declare const plugin: NewPlugin;
|
||||
export default plugin;
|
96
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ConvertAnsi.js
generated
vendored
Normal file
96
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ConvertAnsi.js
generated
vendored
Normal file
@ -0,0 +1,96 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = exports.serialize = exports.test = void 0;
|
||||
|
||||
var _ansiRegex = _interopRequireDefault(require('ansi-regex'));
|
||||
|
||||
var _ansiStyles = _interopRequireDefault(require('ansi-styles'));
|
||||
|
||||
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 toHumanReadableAnsi = text =>
|
||||
text.replace((0, _ansiRegex.default)(), match => {
|
||||
switch (match) {
|
||||
case _ansiStyles.default.red.close:
|
||||
case _ansiStyles.default.green.close:
|
||||
case _ansiStyles.default.cyan.close:
|
||||
case _ansiStyles.default.gray.close:
|
||||
case _ansiStyles.default.white.close:
|
||||
case _ansiStyles.default.yellow.close:
|
||||
case _ansiStyles.default.bgRed.close:
|
||||
case _ansiStyles.default.bgGreen.close:
|
||||
case _ansiStyles.default.bgYellow.close:
|
||||
case _ansiStyles.default.inverse.close:
|
||||
case _ansiStyles.default.dim.close:
|
||||
case _ansiStyles.default.bold.close:
|
||||
case _ansiStyles.default.reset.open:
|
||||
case _ansiStyles.default.reset.close:
|
||||
return '</>';
|
||||
|
||||
case _ansiStyles.default.red.open:
|
||||
return '<red>';
|
||||
|
||||
case _ansiStyles.default.green.open:
|
||||
return '<green>';
|
||||
|
||||
case _ansiStyles.default.cyan.open:
|
||||
return '<cyan>';
|
||||
|
||||
case _ansiStyles.default.gray.open:
|
||||
return '<gray>';
|
||||
|
||||
case _ansiStyles.default.white.open:
|
||||
return '<white>';
|
||||
|
||||
case _ansiStyles.default.yellow.open:
|
||||
return '<yellow>';
|
||||
|
||||
case _ansiStyles.default.bgRed.open:
|
||||
return '<bgRed>';
|
||||
|
||||
case _ansiStyles.default.bgGreen.open:
|
||||
return '<bgGreen>';
|
||||
|
||||
case _ansiStyles.default.bgYellow.open:
|
||||
return '<bgYellow>';
|
||||
|
||||
case _ansiStyles.default.inverse.open:
|
||||
return '<inverse>';
|
||||
|
||||
case _ansiStyles.default.dim.open:
|
||||
return '<dim>';
|
||||
|
||||
case _ansiStyles.default.bold.open:
|
||||
return '<bold>';
|
||||
|
||||
default:
|
||||
return '';
|
||||
}
|
||||
});
|
||||
|
||||
const test = val =>
|
||||
typeof val === 'string' && !!val.match((0, _ansiRegex.default)());
|
||||
|
||||
exports.test = test;
|
||||
|
||||
const serialize = (val, config, indentation, depth, refs, printer) =>
|
||||
printer(toHumanReadableAnsi(val), config, indentation, depth, refs);
|
||||
|
||||
exports.serialize = serialize;
|
||||
const plugin = {
|
||||
serialize,
|
||||
test
|
||||
};
|
||||
var _default = plugin;
|
||||
exports.default = _default;
|
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/DOMCollection.d.ts
generated
vendored
Normal file
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/DOMCollection.d.ts
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
/**
|
||||
* 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 { NewPlugin } from '../types';
|
||||
export declare const test: NewPlugin['test'];
|
||||
export declare const serialize: NewPlugin['serialize'];
|
||||
declare const plugin: NewPlugin;
|
||||
export default plugin;
|
80
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/DOMCollection.js
generated
vendored
Normal file
80
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/DOMCollection.js
generated
vendored
Normal file
@ -0,0 +1,80 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = exports.serialize = exports.test = void 0;
|
||||
|
||||
var _collections = require('../collections');
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
|
||||
/* eslint-disable local/ban-types-eventually */
|
||||
const SPACE = ' ';
|
||||
const OBJECT_NAMES = ['DOMStringMap', 'NamedNodeMap'];
|
||||
const ARRAY_REGEXP = /^(HTML\w*Collection|NodeList)$/;
|
||||
|
||||
const testName = name =>
|
||||
OBJECT_NAMES.indexOf(name) !== -1 || ARRAY_REGEXP.test(name);
|
||||
|
||||
const test = val =>
|
||||
val &&
|
||||
val.constructor &&
|
||||
!!val.constructor.name &&
|
||||
testName(val.constructor.name);
|
||||
|
||||
exports.test = test;
|
||||
|
||||
const isNamedNodeMap = collection =>
|
||||
collection.constructor.name === 'NamedNodeMap';
|
||||
|
||||
const serialize = (collection, config, indentation, depth, refs, printer) => {
|
||||
const name = collection.constructor.name;
|
||||
|
||||
if (++depth > config.maxDepth) {
|
||||
return '[' + name + ']';
|
||||
}
|
||||
|
||||
return (
|
||||
(config.min ? '' : name + SPACE) +
|
||||
(OBJECT_NAMES.indexOf(name) !== -1
|
||||
? '{' +
|
||||
(0, _collections.printObjectProperties)(
|
||||
isNamedNodeMap(collection)
|
||||
? Array.from(collection).reduce((props, attribute) => {
|
||||
props[attribute.name] = attribute.value;
|
||||
return props;
|
||||
}, {})
|
||||
: {...collection},
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
'}'
|
||||
: '[' +
|
||||
(0, _collections.printListItems)(
|
||||
Array.from(collection),
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
']')
|
||||
);
|
||||
};
|
||||
|
||||
exports.serialize = serialize;
|
||||
const plugin = {
|
||||
serialize,
|
||||
test
|
||||
};
|
||||
var _default = plugin;
|
||||
exports.default = _default;
|
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/DOMElement.d.ts
generated
vendored
Normal file
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/DOMElement.d.ts
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
/**
|
||||
* 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 { NewPlugin } from '../types';
|
||||
export declare const test: NewPlugin['test'];
|
||||
export declare const serialize: NewPlugin['serialize'];
|
||||
declare const plugin: NewPlugin;
|
||||
export default plugin;
|
125
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/DOMElement.js
generated
vendored
Normal file
125
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/DOMElement.js
generated
vendored
Normal file
@ -0,0 +1,125 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = exports.serialize = exports.test = void 0;
|
||||
|
||||
var _markup = require('./lib/markup');
|
||||
|
||||
/**
|
||||
* 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 ELEMENT_NODE = 1;
|
||||
const TEXT_NODE = 3;
|
||||
const COMMENT_NODE = 8;
|
||||
const FRAGMENT_NODE = 11;
|
||||
const ELEMENT_REGEXP = /^((HTML|SVG)\w*)?Element$/;
|
||||
|
||||
const testNode = val => {
|
||||
var _val$hasAttribute;
|
||||
|
||||
const constructorName = val.constructor.name;
|
||||
const {nodeType, tagName} = val;
|
||||
const isCustomElement =
|
||||
(typeof tagName === 'string' && tagName.includes('-')) ||
|
||||
((_val$hasAttribute = val.hasAttribute) === null ||
|
||||
_val$hasAttribute === void 0
|
||||
? void 0
|
||||
: _val$hasAttribute.call(val, 'is'));
|
||||
return (
|
||||
(nodeType === ELEMENT_NODE &&
|
||||
(ELEMENT_REGEXP.test(constructorName) || isCustomElement)) ||
|
||||
(nodeType === TEXT_NODE && constructorName === 'Text') ||
|
||||
(nodeType === COMMENT_NODE && constructorName === 'Comment') ||
|
||||
(nodeType === FRAGMENT_NODE && constructorName === 'DocumentFragment')
|
||||
);
|
||||
};
|
||||
|
||||
const test = val => {
|
||||
var _val$constructor;
|
||||
|
||||
return (
|
||||
(val === null || val === void 0
|
||||
? void 0
|
||||
: (_val$constructor = val.constructor) === null ||
|
||||
_val$constructor === void 0
|
||||
? void 0
|
||||
: _val$constructor.name) && testNode(val)
|
||||
);
|
||||
};
|
||||
|
||||
exports.test = test;
|
||||
|
||||
function nodeIsText(node) {
|
||||
return node.nodeType === TEXT_NODE;
|
||||
}
|
||||
|
||||
function nodeIsComment(node) {
|
||||
return node.nodeType === COMMENT_NODE;
|
||||
}
|
||||
|
||||
function nodeIsFragment(node) {
|
||||
return node.nodeType === FRAGMENT_NODE;
|
||||
}
|
||||
|
||||
const serialize = (node, config, indentation, depth, refs, printer) => {
|
||||
if (nodeIsText(node)) {
|
||||
return (0, _markup.printText)(node.data, config);
|
||||
}
|
||||
|
||||
if (nodeIsComment(node)) {
|
||||
return (0, _markup.printComment)(node.data, config);
|
||||
}
|
||||
|
||||
const type = nodeIsFragment(node)
|
||||
? `DocumentFragment`
|
||||
: node.tagName.toLowerCase();
|
||||
|
||||
if (++depth > config.maxDepth) {
|
||||
return (0, _markup.printElementAsLeaf)(type, config);
|
||||
}
|
||||
|
||||
return (0, _markup.printElement)(
|
||||
type,
|
||||
(0, _markup.printProps)(
|
||||
nodeIsFragment(node)
|
||||
? []
|
||||
: Array.from(node.attributes)
|
||||
.map(attr => attr.name)
|
||||
.sort(),
|
||||
nodeIsFragment(node)
|
||||
? {}
|
||||
: Array.from(node.attributes).reduce((props, attribute) => {
|
||||
props[attribute.name] = attribute.value;
|
||||
return props;
|
||||
}, {}),
|
||||
config,
|
||||
indentation + config.indent,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
),
|
||||
(0, _markup.printChildren)(
|
||||
Array.prototype.slice.call(node.childNodes || node.children),
|
||||
config,
|
||||
indentation + config.indent,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
),
|
||||
config,
|
||||
indentation
|
||||
);
|
||||
};
|
||||
|
||||
exports.serialize = serialize;
|
||||
const plugin = {
|
||||
serialize,
|
||||
test
|
||||
};
|
||||
var _default = plugin;
|
||||
exports.default = _default;
|
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/Immutable.d.ts
generated
vendored
Normal file
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/Immutable.d.ts
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
/**
|
||||
* 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 { NewPlugin } from '../types';
|
||||
export declare const serialize: NewPlugin['serialize'];
|
||||
export declare const test: NewPlugin['test'];
|
||||
declare const plugin: NewPlugin;
|
||||
export default plugin;
|
247
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/Immutable.js
generated
vendored
Normal file
247
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/Immutable.js
generated
vendored
Normal file
@ -0,0 +1,247 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = exports.test = exports.serialize = void 0;
|
||||
|
||||
var _collections = require('../collections');
|
||||
|
||||
/**
|
||||
* 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.
|
||||
*/
|
||||
// SENTINEL constants are from https://github.com/facebook/immutable-js
|
||||
const IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
|
||||
const IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
|
||||
const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
|
||||
const IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
|
||||
const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
|
||||
const IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@'; // immutable v4
|
||||
|
||||
const IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
|
||||
const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
|
||||
const IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
|
||||
|
||||
const getImmutableName = name => 'Immutable.' + name;
|
||||
|
||||
const printAsLeaf = name => '[' + name + ']';
|
||||
|
||||
const SPACE = ' ';
|
||||
const LAZY = '…'; // Seq is lazy if it calls a method like filter
|
||||
|
||||
const printImmutableEntries = (
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer,
|
||||
type
|
||||
) =>
|
||||
++depth > config.maxDepth
|
||||
? printAsLeaf(getImmutableName(type))
|
||||
: getImmutableName(type) +
|
||||
SPACE +
|
||||
'{' +
|
||||
(0, _collections.printIteratorEntries)(
|
||||
val.entries(),
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
'}'; // Record has an entries method because it is a collection in immutable v3.
|
||||
// Return an iterator for Immutable Record from version v3 or v4.
|
||||
|
||||
function getRecordEntries(val) {
|
||||
let i = 0;
|
||||
return {
|
||||
next() {
|
||||
if (i < val._keys.length) {
|
||||
const key = val._keys[i++];
|
||||
return {
|
||||
done: false,
|
||||
value: [key, val.get(key)]
|
||||
};
|
||||
}
|
||||
|
||||
return {
|
||||
done: true,
|
||||
value: undefined
|
||||
};
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
const printImmutableRecord = (
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) => {
|
||||
// _name property is defined only for an Immutable Record instance
|
||||
// which was constructed with a second optional descriptive name arg
|
||||
const name = getImmutableName(val._name || 'Record');
|
||||
return ++depth > config.maxDepth
|
||||
? printAsLeaf(name)
|
||||
: name +
|
||||
SPACE +
|
||||
'{' +
|
||||
(0, _collections.printIteratorEntries)(
|
||||
getRecordEntries(val),
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
'}';
|
||||
};
|
||||
|
||||
const printImmutableSeq = (val, config, indentation, depth, refs, printer) => {
|
||||
const name = getImmutableName('Seq');
|
||||
|
||||
if (++depth > config.maxDepth) {
|
||||
return printAsLeaf(name);
|
||||
}
|
||||
|
||||
if (val[IS_KEYED_SENTINEL]) {
|
||||
return (
|
||||
name +
|
||||
SPACE +
|
||||
'{' + // from Immutable collection of entries or from ECMAScript object
|
||||
(val._iter || val._object
|
||||
? (0, _collections.printIteratorEntries)(
|
||||
val.entries(),
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
)
|
||||
: LAZY) +
|
||||
'}'
|
||||
);
|
||||
}
|
||||
|
||||
return (
|
||||
name +
|
||||
SPACE +
|
||||
'[' +
|
||||
(val._iter || // from Immutable collection of values
|
||||
val._array || // from ECMAScript array
|
||||
val._collection || // from ECMAScript collection in immutable v4
|
||||
val._iterable // from ECMAScript collection in immutable v3
|
||||
? (0, _collections.printIteratorValues)(
|
||||
val.values(),
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
)
|
||||
: LAZY) +
|
||||
']'
|
||||
);
|
||||
};
|
||||
|
||||
const printImmutableValues = (
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer,
|
||||
type
|
||||
) =>
|
||||
++depth > config.maxDepth
|
||||
? printAsLeaf(getImmutableName(type))
|
||||
: getImmutableName(type) +
|
||||
SPACE +
|
||||
'[' +
|
||||
(0, _collections.printIteratorValues)(
|
||||
val.values(),
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
) +
|
||||
']';
|
||||
|
||||
const serialize = (val, config, indentation, depth, refs, printer) => {
|
||||
if (val[IS_MAP_SENTINEL]) {
|
||||
return printImmutableEntries(
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer,
|
||||
val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map'
|
||||
);
|
||||
}
|
||||
|
||||
if (val[IS_LIST_SENTINEL]) {
|
||||
return printImmutableValues(
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer,
|
||||
'List'
|
||||
);
|
||||
}
|
||||
|
||||
if (val[IS_SET_SENTINEL]) {
|
||||
return printImmutableValues(
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer,
|
||||
val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set'
|
||||
);
|
||||
}
|
||||
|
||||
if (val[IS_STACK_SENTINEL]) {
|
||||
return printImmutableValues(
|
||||
val,
|
||||
config,
|
||||
indentation,
|
||||
depth,
|
||||
refs,
|
||||
printer,
|
||||
'Stack'
|
||||
);
|
||||
}
|
||||
|
||||
if (val[IS_SEQ_SENTINEL]) {
|
||||
return printImmutableSeq(val, config, indentation, depth, refs, printer);
|
||||
} // For compatibility with immutable v3 and v4, let record be the default.
|
||||
|
||||
return printImmutableRecord(val, config, indentation, depth, refs, printer);
|
||||
}; // Explicitly comparing sentinel properties to true avoids false positive
|
||||
// when mock identity-obj-proxy returns the key as the value for any key.
|
||||
|
||||
exports.serialize = serialize;
|
||||
|
||||
const test = val =>
|
||||
val &&
|
||||
(val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
|
||||
|
||||
exports.test = test;
|
||||
const plugin = {
|
||||
serialize,
|
||||
test
|
||||
};
|
||||
var _default = plugin;
|
||||
exports.default = _default;
|
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ReactElement.d.ts
generated
vendored
Normal file
11
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ReactElement.d.ts
generated
vendored
Normal file
@ -0,0 +1,11 @@
|
||||
/**
|
||||
* 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 { NewPlugin } from '../types';
|
||||
export declare const serialize: NewPlugin['serialize'];
|
||||
export declare const test: NewPlugin['test'];
|
||||
declare const plugin: NewPlugin;
|
||||
export default plugin;
|
166
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ReactElement.js
generated
vendored
Normal file
166
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ReactElement.js
generated
vendored
Normal file
@ -0,0 +1,166 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = exports.test = exports.serialize = void 0;
|
||||
|
||||
var ReactIs = _interopRequireWildcard(require('react-is'));
|
||||
|
||||
var _markup = require('./lib/markup');
|
||||
|
||||
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.
|
||||
*/
|
||||
// Given element.props.children, or subtree during recursive traversal,
|
||||
// return flattened array of children.
|
||||
const getChildren = (arg, children = []) => {
|
||||
if (Array.isArray(arg)) {
|
||||
arg.forEach(item => {
|
||||
getChildren(item, children);
|
||||
});
|
||||
} else if (arg != null && arg !== false) {
|
||||
children.push(arg);
|
||||
}
|
||||
|
||||
return children;
|
||||
};
|
||||
|
||||
const getType = element => {
|
||||
const type = element.type;
|
||||
|
||||
if (typeof type === 'string') {
|
||||
return type;
|
||||
}
|
||||
|
||||
if (typeof type === 'function') {
|
||||
return type.displayName || type.name || 'Unknown';
|
||||
}
|
||||
|
||||
if (ReactIs.isFragment(element)) {
|
||||
return 'React.Fragment';
|
||||
}
|
||||
|
||||
if (ReactIs.isSuspense(element)) {
|
||||
return 'React.Suspense';
|
||||
}
|
||||
|
||||
if (typeof type === 'object' && type !== null) {
|
||||
if (ReactIs.isContextProvider(element)) {
|
||||
return 'Context.Provider';
|
||||
}
|
||||
|
||||
if (ReactIs.isContextConsumer(element)) {
|
||||
return 'Context.Consumer';
|
||||
}
|
||||
|
||||
if (ReactIs.isForwardRef(element)) {
|
||||
if (type.displayName) {
|
||||
return type.displayName;
|
||||
}
|
||||
|
||||
const functionName = type.render.displayName || type.render.name || '';
|
||||
return functionName !== ''
|
||||
? 'ForwardRef(' + functionName + ')'
|
||||
: 'ForwardRef';
|
||||
}
|
||||
|
||||
if (ReactIs.isMemo(element)) {
|
||||
const functionName =
|
||||
type.displayName || type.type.displayName || type.type.name || '';
|
||||
return functionName !== '' ? 'Memo(' + functionName + ')' : 'Memo';
|
||||
}
|
||||
}
|
||||
|
||||
return 'UNDEFINED';
|
||||
};
|
||||
|
||||
const getPropKeys = element => {
|
||||
const {props} = element;
|
||||
return Object.keys(props)
|
||||
.filter(key => key !== 'children' && props[key] !== undefined)
|
||||
.sort();
|
||||
};
|
||||
|
||||
const serialize = (element, config, indentation, depth, refs, printer) =>
|
||||
++depth > config.maxDepth
|
||||
? (0, _markup.printElementAsLeaf)(getType(element), config)
|
||||
: (0, _markup.printElement)(
|
||||
getType(element),
|
||||
(0, _markup.printProps)(
|
||||
getPropKeys(element),
|
||||
element.props,
|
||||
config,
|
||||
indentation + config.indent,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
),
|
||||
(0, _markup.printChildren)(
|
||||
getChildren(element.props.children),
|
||||
config,
|
||||
indentation + config.indent,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
),
|
||||
config,
|
||||
indentation
|
||||
);
|
||||
|
||||
exports.serialize = serialize;
|
||||
|
||||
const test = val => val && ReactIs.isElement(val);
|
||||
|
||||
exports.test = test;
|
||||
const plugin = {
|
||||
serialize,
|
||||
test
|
||||
};
|
||||
var _default = plugin;
|
||||
exports.default = _default;
|
18
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ReactTestComponent.d.ts
generated
vendored
Normal file
18
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ReactTestComponent.d.ts
generated
vendored
Normal file
@ -0,0 +1,18 @@
|
||||
/**
|
||||
* 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 { NewPlugin } from '../types';
|
||||
export declare type ReactTestObject = {
|
||||
$$typeof: symbol;
|
||||
type: string;
|
||||
props?: Record<string, unknown>;
|
||||
children?: null | Array<ReactTestChild>;
|
||||
};
|
||||
declare type ReactTestChild = ReactTestObject | string | number;
|
||||
export declare const serialize: NewPlugin['serialize'];
|
||||
export declare const test: NewPlugin['test'];
|
||||
declare const plugin: NewPlugin;
|
||||
export default plugin;
|
65
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ReactTestComponent.js
generated
vendored
Normal file
65
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/ReactTestComponent.js
generated
vendored
Normal file
@ -0,0 +1,65 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = exports.test = exports.serialize = void 0;
|
||||
|
||||
var _markup = require('./lib/markup');
|
||||
|
||||
var Symbol = global['jest-symbol-do-not-touch'] || global.Symbol;
|
||||
const testSymbol =
|
||||
typeof Symbol === 'function' && Symbol.for
|
||||
? Symbol.for('react.test.json')
|
||||
: 0xea71357;
|
||||
|
||||
const getPropKeys = object => {
|
||||
const {props} = object;
|
||||
return props
|
||||
? Object.keys(props)
|
||||
.filter(key => props[key] !== undefined)
|
||||
.sort()
|
||||
: [];
|
||||
};
|
||||
|
||||
const serialize = (object, config, indentation, depth, refs, printer) =>
|
||||
++depth > config.maxDepth
|
||||
? (0, _markup.printElementAsLeaf)(object.type, config)
|
||||
: (0, _markup.printElement)(
|
||||
object.type,
|
||||
object.props
|
||||
? (0, _markup.printProps)(
|
||||
getPropKeys(object),
|
||||
object.props,
|
||||
config,
|
||||
indentation + config.indent,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
)
|
||||
: '',
|
||||
object.children
|
||||
? (0, _markup.printChildren)(
|
||||
object.children,
|
||||
config,
|
||||
indentation + config.indent,
|
||||
depth,
|
||||
refs,
|
||||
printer
|
||||
)
|
||||
: '',
|
||||
config,
|
||||
indentation
|
||||
);
|
||||
|
||||
exports.serialize = serialize;
|
||||
|
||||
const test = val => val && val.$$typeof === testSymbol;
|
||||
|
||||
exports.test = test;
|
||||
const plugin = {
|
||||
serialize,
|
||||
test
|
||||
};
|
||||
var _default = plugin;
|
||||
exports.default = _default;
|
7
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/lib/escapeHTML.d.ts
generated
vendored
Normal file
7
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/lib/escapeHTML.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 escapeHTML(str: string): string;
|
16
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/lib/escapeHTML.js
generated
vendored
Normal file
16
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/lib/escapeHTML.js
generated
vendored
Normal file
@ -0,0 +1,16 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.default = escapeHTML;
|
||||
|
||||
/**
|
||||
* 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 escapeHTML(str) {
|
||||
return str.replace(/</g, '<').replace(/>/g, '>');
|
||||
}
|
13
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/lib/markup.d.ts
generated
vendored
Normal file
13
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/lib/markup.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 { Config, Printer, Refs } from '../../types';
|
||||
export declare const printProps: (keys: Array<string>, props: Record<string, unknown>, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer) => string;
|
||||
export declare const printChildren: (children: Array<unknown>, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer) => string;
|
||||
export declare const printText: (text: string, config: Config) => string;
|
||||
export declare const printComment: (comment: string, config: Config) => string;
|
||||
export declare const printElement: (type: string, printedProps: string, printedChildren: string, config: Config, indentation: string) => string;
|
||||
export declare const printElementAsLeaf: (type: string, config: Config) => string;
|
147
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/lib/markup.js
generated
vendored
Normal file
147
node_modules/jest-snapshot/node_modules/pretty-format/build/plugins/lib/markup.js
generated
vendored
Normal file
@ -0,0 +1,147 @@
|
||||
'use strict';
|
||||
|
||||
Object.defineProperty(exports, '__esModule', {
|
||||
value: true
|
||||
});
|
||||
exports.printElementAsLeaf = exports.printElement = exports.printComment = exports.printText = exports.printChildren = exports.printProps = void 0;
|
||||
|
||||
var _escapeHTML = _interopRequireDefault(require('./escapeHTML'));
|
||||
|
||||
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.
|
||||
*/
|
||||
// Return empty string if keys is empty.
|
||||
const printProps = (keys, props, config, indentation, depth, refs, printer) => {
|
||||
const indentationNext = indentation + config.indent;
|
||||
const colors = config.colors;
|
||||
return keys
|
||||
.map(key => {
|
||||
const value = props[key];
|
||||
let printed = printer(value, config, indentationNext, depth, refs);
|
||||
|
||||
if (typeof value !== 'string') {
|
||||
if (printed.indexOf('\n') !== -1) {
|
||||
printed =
|
||||
config.spacingOuter +
|
||||
indentationNext +
|
||||
printed +
|
||||
config.spacingOuter +
|
||||
indentation;
|
||||
}
|
||||
|
||||
printed = '{' + printed + '}';
|
||||
}
|
||||
|
||||
return (
|
||||
config.spacingInner +
|
||||
indentation +
|
||||
colors.prop.open +
|
||||
key +
|
||||
colors.prop.close +
|
||||
'=' +
|
||||
colors.value.open +
|
||||
printed +
|
||||
colors.value.close
|
||||
);
|
||||
})
|
||||
.join('');
|
||||
}; // Return empty string if children is empty.
|
||||
|
||||
exports.printProps = printProps;
|
||||
|
||||
const printChildren = (children, config, indentation, depth, refs, printer) =>
|
||||
children
|
||||
.map(
|
||||
child =>
|
||||
config.spacingOuter +
|
||||
indentation +
|
||||
(typeof child === 'string'
|
||||
? printText(child, config)
|
||||
: printer(child, config, indentation, depth, refs))
|
||||
)
|
||||
.join('');
|
||||
|
||||
exports.printChildren = printChildren;
|
||||
|
||||
const printText = (text, config) => {
|
||||
const contentColor = config.colors.content;
|
||||
return (
|
||||
contentColor.open + (0, _escapeHTML.default)(text) + contentColor.close
|
||||
);
|
||||
};
|
||||
|
||||
exports.printText = printText;
|
||||
|
||||
const printComment = (comment, config) => {
|
||||
const commentColor = config.colors.comment;
|
||||
return (
|
||||
commentColor.open +
|
||||
'<!--' +
|
||||
(0, _escapeHTML.default)(comment) +
|
||||
'-->' +
|
||||
commentColor.close
|
||||
);
|
||||
}; // Separate the functions to format props, children, and element,
|
||||
// so a plugin could override a particular function, if needed.
|
||||
// Too bad, so sad: the traditional (but unnecessary) space
|
||||
// in a self-closing tagColor requires a second test of printedProps.
|
||||
|
||||
exports.printComment = printComment;
|
||||
|
||||
const printElement = (
|
||||
type,
|
||||
printedProps,
|
||||
printedChildren,
|
||||
config,
|
||||
indentation
|
||||
) => {
|
||||
const tagColor = config.colors.tag;
|
||||
return (
|
||||
tagColor.open +
|
||||
'<' +
|
||||
type +
|
||||
(printedProps &&
|
||||
tagColor.close +
|
||||
printedProps +
|
||||
config.spacingOuter +
|
||||
indentation +
|
||||
tagColor.open) +
|
||||
(printedChildren
|
||||
? '>' +
|
||||
tagColor.close +
|
||||
printedChildren +
|
||||
config.spacingOuter +
|
||||
indentation +
|
||||
tagColor.open +
|
||||
'</' +
|
||||
type
|
||||
: (printedProps && !config.min ? '' : ' ') + '/') +
|
||||
'>' +
|
||||
tagColor.close
|
||||
);
|
||||
};
|
||||
|
||||
exports.printElement = printElement;
|
||||
|
||||
const printElementAsLeaf = (type, config) => {
|
||||
const tagColor = config.colors.tag;
|
||||
return (
|
||||
tagColor.open +
|
||||
'<' +
|
||||
type +
|
||||
tagColor.close +
|
||||
' …' +
|
||||
tagColor.open +
|
||||
' />' +
|
||||
tagColor.close
|
||||
);
|
||||
};
|
||||
|
||||
exports.printElementAsLeaf = printElementAsLeaf;
|
100
node_modules/jest-snapshot/node_modules/pretty-format/build/types.d.ts
generated
vendored
Normal file
100
node_modules/jest-snapshot/node_modules/pretty-format/build/types.d.ts
generated
vendored
Normal file
@ -0,0 +1,100 @@
|
||||
/**
|
||||
* 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 type Colors = {
|
||||
comment: {
|
||||
close: string;
|
||||
open: string;
|
||||
};
|
||||
content: {
|
||||
close: string;
|
||||
open: string;
|
||||
};
|
||||
prop: {
|
||||
close: string;
|
||||
open: string;
|
||||
};
|
||||
tag: {
|
||||
close: string;
|
||||
open: string;
|
||||
};
|
||||
value: {
|
||||
close: string;
|
||||
open: string;
|
||||
};
|
||||
};
|
||||
declare type Indent = (arg0: string) => string;
|
||||
export declare type Refs = Array<unknown>;
|
||||
declare type Print = (arg0: unknown) => string;
|
||||
export declare type Theme = {
|
||||
comment: string;
|
||||
content: string;
|
||||
prop: string;
|
||||
tag: string;
|
||||
value: string;
|
||||
};
|
||||
declare type ThemeReceived = {
|
||||
comment?: string;
|
||||
content?: string;
|
||||
prop?: string;
|
||||
tag?: string;
|
||||
value?: string;
|
||||
};
|
||||
export declare type Options = {
|
||||
callToJSON: boolean;
|
||||
escapeRegex: boolean;
|
||||
escapeString: boolean;
|
||||
highlight: boolean;
|
||||
indent: number;
|
||||
maxDepth: number;
|
||||
min: boolean;
|
||||
plugins: Plugins;
|
||||
printFunctionName: boolean;
|
||||
theme: Theme;
|
||||
};
|
||||
export declare type OptionsReceived = {
|
||||
callToJSON?: boolean;
|
||||
escapeRegex?: boolean;
|
||||
escapeString?: boolean;
|
||||
highlight?: boolean;
|
||||
indent?: number;
|
||||
maxDepth?: number;
|
||||
min?: boolean;
|
||||
plugins?: Plugins;
|
||||
printFunctionName?: boolean;
|
||||
theme?: ThemeReceived;
|
||||
};
|
||||
export declare type Config = {
|
||||
callToJSON: boolean;
|
||||
colors: Colors;
|
||||
escapeRegex: boolean;
|
||||
escapeString: boolean;
|
||||
indent: string;
|
||||
maxDepth: number;
|
||||
min: boolean;
|
||||
plugins: Plugins;
|
||||
printFunctionName: boolean;
|
||||
spacingInner: string;
|
||||
spacingOuter: string;
|
||||
};
|
||||
export declare type Printer = (val: unknown, config: Config, indentation: string, depth: number, refs: Refs, hasCalledToJSON?: boolean) => string;
|
||||
declare type Test = (arg0: any) => boolean;
|
||||
export declare type NewPlugin = {
|
||||
serialize: (val: any, config: Config, indentation: string, depth: number, refs: Refs, printer: Printer) => string;
|
||||
test: Test;
|
||||
};
|
||||
declare type PluginOptions = {
|
||||
edgeSpacing: string;
|
||||
min: boolean;
|
||||
spacing: string;
|
||||
};
|
||||
export declare type OldPlugin = {
|
||||
print: (val: unknown, print: Print, indent: Indent, options: PluginOptions, colors: Colors) => string;
|
||||
test: Test;
|
||||
};
|
||||
export declare type Plugin = NewPlugin | OldPlugin;
|
||||
export declare type Plugins = Array<Plugin>;
|
||||
export {};
|
1
node_modules/jest-snapshot/node_modules/pretty-format/build/types.js
generated
vendored
Normal file
1
node_modules/jest-snapshot/node_modules/pretty-format/build/types.js
generated
vendored
Normal file
@ -0,0 +1 @@
|
||||
'use strict';
|
37
node_modules/jest-snapshot/node_modules/pretty-format/package.json
generated
vendored
Normal file
37
node_modules/jest-snapshot/node_modules/pretty-format/package.json
generated
vendored
Normal file
@ -0,0 +1,37 @@
|
||||
{
|
||||
"name": "pretty-format",
|
||||
"version": "26.6.2",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/facebook/jest.git",
|
||||
"directory": "packages/pretty-format"
|
||||
},
|
||||
"license": "MIT",
|
||||
"description": "Stringify any JavaScript value.",
|
||||
"main": "build/index.js",
|
||||
"types": "build/index.d.ts",
|
||||
"author": "James Kyle <me@thejameskyle.com>",
|
||||
"dependencies": {
|
||||
"@jest/types": "^26.6.2",
|
||||
"ansi-regex": "^5.0.0",
|
||||
"ansi-styles": "^4.0.0",
|
||||
"react-is": "^17.0.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@types/react": "*",
|
||||
"@types/react-is": "^16.7.1",
|
||||
"@types/react-test-renderer": "*",
|
||||
"immutable": "4.0.0-rc.9",
|
||||
"jest-util": "^26.6.2",
|
||||
"react": "*",
|
||||
"react-dom": "*",
|
||||
"react-test-renderer": "*"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 10"
|
||||
},
|
||||
"publishConfig": {
|
||||
"access": "public"
|
||||
},
|
||||
"gitHead": "4c46930615602cbf983fb7e8e82884c282a624d5"
|
||||
}
|
21
node_modules/jest-snapshot/node_modules/react-is/LICENSE
generated
vendored
Normal file
21
node_modules/jest-snapshot/node_modules/react-is/LICENSE
generated
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) Facebook, Inc. and its affiliates.
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
104
node_modules/jest-snapshot/node_modules/react-is/README.md
generated
vendored
Normal file
104
node_modules/jest-snapshot/node_modules/react-is/README.md
generated
vendored
Normal file
@ -0,0 +1,104 @@
|
||||
# `react-is`
|
||||
|
||||
This package allows you to test arbitrary values and see if they're a particular React element type.
|
||||
|
||||
## Installation
|
||||
|
||||
```sh
|
||||
# Yarn
|
||||
yarn add react-is
|
||||
|
||||
# NPM
|
||||
npm install react-is
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
### Determining if a Component is Valid
|
||||
|
||||
```js
|
||||
import React from "react";
|
||||
import * as ReactIs from "react-is";
|
||||
|
||||
class ClassComponent extends React.Component {
|
||||
render() {
|
||||
return React.createElement("div");
|
||||
}
|
||||
}
|
||||
|
||||
const FunctionComponent = () => React.createElement("div");
|
||||
|
||||
const ForwardRefComponent = React.forwardRef((props, ref) =>
|
||||
React.createElement(Component, { forwardedRef: ref, ...props })
|
||||
);
|
||||
|
||||
const Context = React.createContext(false);
|
||||
|
||||
ReactIs.isValidElementType("div"); // true
|
||||
ReactIs.isValidElementType(ClassComponent); // true
|
||||
ReactIs.isValidElementType(FunctionComponent); // true
|
||||
ReactIs.isValidElementType(ForwardRefComponent); // true
|
||||
ReactIs.isValidElementType(Context.Provider); // true
|
||||
ReactIs.isValidElementType(Context.Consumer); // true
|
||||
ReactIs.isValidElementType(React.createFactory("div")); // true
|
||||
```
|
||||
|
||||
### Determining an Element's Type
|
||||
|
||||
#### Context
|
||||
|
||||
```js
|
||||
import React from "react";
|
||||
import * as ReactIs from 'react-is';
|
||||
|
||||
const ThemeContext = React.createContext("blue");
|
||||
|
||||
ReactIs.isContextConsumer(<ThemeContext.Consumer />); // true
|
||||
ReactIs.isContextProvider(<ThemeContext.Provider />); // true
|
||||
ReactIs.typeOf(<ThemeContext.Provider />) === ReactIs.ContextProvider; // true
|
||||
ReactIs.typeOf(<ThemeContext.Consumer />) === ReactIs.ContextConsumer; // true
|
||||
```
|
||||
|
||||
#### Element
|
||||
|
||||
```js
|
||||
import React from "react";
|
||||
import * as ReactIs from 'react-is';
|
||||
|
||||
ReactIs.isElement(<div />); // true
|
||||
ReactIs.typeOf(<div />) === ReactIs.Element; // true
|
||||
```
|
||||
|
||||
#### Fragment
|
||||
|
||||
```js
|
||||
import React from "react";
|
||||
import * as ReactIs from 'react-is';
|
||||
|
||||
ReactIs.isFragment(<></>); // true
|
||||
ReactIs.typeOf(<></>) === ReactIs.Fragment; // true
|
||||
```
|
||||
|
||||
#### Portal
|
||||
|
||||
```js
|
||||
import React from "react";
|
||||
import ReactDOM from "react-dom";
|
||||
import * as ReactIs from 'react-is';
|
||||
|
||||
const div = document.createElement("div");
|
||||
const portal = ReactDOM.createPortal(<div />, div);
|
||||
|
||||
ReactIs.isPortal(portal); // true
|
||||
ReactIs.typeOf(portal) === ReactIs.Portal; // true
|
||||
```
|
||||
|
||||
#### StrictMode
|
||||
|
||||
```js
|
||||
import React from "react";
|
||||
import * as ReactIs from 'react-is';
|
||||
|
||||
ReactIs.isStrictMode(<React.StrictMode />); // true
|
||||
ReactIs.typeOf(<React.StrictMode />) === ReactIs.StrictMode; // true
|
||||
```
|
8
node_modules/jest-snapshot/node_modules/react-is/build-info.json
generated
vendored
Normal file
8
node_modules/jest-snapshot/node_modules/react-is/build-info.json
generated
vendored
Normal file
@ -0,0 +1,8 @@
|
||||
{
|
||||
"branch": "pull/21051",
|
||||
"buildNumber": "287151",
|
||||
"checksum": "94f5c65",
|
||||
"commit": "12adaffef",
|
||||
"environment": "ci",
|
||||
"reactVersion": "17.0.0-12adaffef"
|
||||
}
|
226
node_modules/jest-snapshot/node_modules/react-is/cjs/react-is.development.js
generated
vendored
Normal file
226
node_modules/jest-snapshot/node_modules/react-is/cjs/react-is.development.js
generated
vendored
Normal file
@ -0,0 +1,226 @@
|
||||
/** @license React v17.0.2
|
||||
* react-is.development.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
'use strict';
|
||||
|
||||
if (process.env.NODE_ENV !== "production") {
|
||||
(function() {
|
||||
'use strict';
|
||||
|
||||
// ATTENTION
|
||||
// When adding new symbols to this file,
|
||||
// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
|
||||
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
|
||||
// nor polyfill, then a plain number is used for performance.
|
||||
var REACT_ELEMENT_TYPE = 0xeac7;
|
||||
var REACT_PORTAL_TYPE = 0xeaca;
|
||||
var REACT_FRAGMENT_TYPE = 0xeacb;
|
||||
var REACT_STRICT_MODE_TYPE = 0xeacc;
|
||||
var REACT_PROFILER_TYPE = 0xead2;
|
||||
var REACT_PROVIDER_TYPE = 0xeacd;
|
||||
var REACT_CONTEXT_TYPE = 0xeace;
|
||||
var REACT_FORWARD_REF_TYPE = 0xead0;
|
||||
var REACT_SUSPENSE_TYPE = 0xead1;
|
||||
var REACT_SUSPENSE_LIST_TYPE = 0xead8;
|
||||
var REACT_MEMO_TYPE = 0xead3;
|
||||
var REACT_LAZY_TYPE = 0xead4;
|
||||
var REACT_BLOCK_TYPE = 0xead9;
|
||||
var REACT_SERVER_BLOCK_TYPE = 0xeada;
|
||||
var REACT_FUNDAMENTAL_TYPE = 0xead5;
|
||||
var REACT_SCOPE_TYPE = 0xead7;
|
||||
var REACT_OPAQUE_ID_TYPE = 0xeae0;
|
||||
var REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1;
|
||||
var REACT_OFFSCREEN_TYPE = 0xeae2;
|
||||
var REACT_LEGACY_HIDDEN_TYPE = 0xeae3;
|
||||
|
||||
if (typeof Symbol === 'function' && Symbol.for) {
|
||||
var symbolFor = Symbol.for;
|
||||
REACT_ELEMENT_TYPE = symbolFor('react.element');
|
||||
REACT_PORTAL_TYPE = symbolFor('react.portal');
|
||||
REACT_FRAGMENT_TYPE = symbolFor('react.fragment');
|
||||
REACT_STRICT_MODE_TYPE = symbolFor('react.strict_mode');
|
||||
REACT_PROFILER_TYPE = symbolFor('react.profiler');
|
||||
REACT_PROVIDER_TYPE = symbolFor('react.provider');
|
||||
REACT_CONTEXT_TYPE = symbolFor('react.context');
|
||||
REACT_FORWARD_REF_TYPE = symbolFor('react.forward_ref');
|
||||
REACT_SUSPENSE_TYPE = symbolFor('react.suspense');
|
||||
REACT_SUSPENSE_LIST_TYPE = symbolFor('react.suspense_list');
|
||||
REACT_MEMO_TYPE = symbolFor('react.memo');
|
||||
REACT_LAZY_TYPE = symbolFor('react.lazy');
|
||||
REACT_BLOCK_TYPE = symbolFor('react.block');
|
||||
REACT_SERVER_BLOCK_TYPE = symbolFor('react.server.block');
|
||||
REACT_FUNDAMENTAL_TYPE = symbolFor('react.fundamental');
|
||||
REACT_SCOPE_TYPE = symbolFor('react.scope');
|
||||
REACT_OPAQUE_ID_TYPE = symbolFor('react.opaque.id');
|
||||
REACT_DEBUG_TRACING_MODE_TYPE = symbolFor('react.debug_trace_mode');
|
||||
REACT_OFFSCREEN_TYPE = symbolFor('react.offscreen');
|
||||
REACT_LEGACY_HIDDEN_TYPE = symbolFor('react.legacy_hidden');
|
||||
}
|
||||
|
||||
// Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
|
||||
|
||||
var enableScopeAPI = false; // Experimental Create Event Handle API.
|
||||
|
||||
function isValidElementType(type) {
|
||||
if (typeof type === 'string' || typeof type === 'function') {
|
||||
return true;
|
||||
} // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
|
||||
|
||||
|
||||
if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_DEBUG_TRACING_MODE_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (typeof type === 'object' && type !== null) {
|
||||
if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function typeOf(object) {
|
||||
if (typeof object === 'object' && object !== null) {
|
||||
var $$typeof = object.$$typeof;
|
||||
|
||||
switch ($$typeof) {
|
||||
case REACT_ELEMENT_TYPE:
|
||||
var type = object.type;
|
||||
|
||||
switch (type) {
|
||||
case REACT_FRAGMENT_TYPE:
|
||||
case REACT_PROFILER_TYPE:
|
||||
case REACT_STRICT_MODE_TYPE:
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return type;
|
||||
|
||||
default:
|
||||
var $$typeofType = type && type.$$typeof;
|
||||
|
||||
switch ($$typeofType) {
|
||||
case REACT_CONTEXT_TYPE:
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
case REACT_LAZY_TYPE:
|
||||
case REACT_MEMO_TYPE:
|
||||
case REACT_PROVIDER_TYPE:
|
||||
return $$typeofType;
|
||||
|
||||
default:
|
||||
return $$typeof;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
case REACT_PORTAL_TYPE:
|
||||
return $$typeof;
|
||||
}
|
||||
}
|
||||
|
||||
return undefined;
|
||||
}
|
||||
var ContextConsumer = REACT_CONTEXT_TYPE;
|
||||
var ContextProvider = REACT_PROVIDER_TYPE;
|
||||
var Element = REACT_ELEMENT_TYPE;
|
||||
var ForwardRef = REACT_FORWARD_REF_TYPE;
|
||||
var Fragment = REACT_FRAGMENT_TYPE;
|
||||
var Lazy = REACT_LAZY_TYPE;
|
||||
var Memo = REACT_MEMO_TYPE;
|
||||
var Portal = REACT_PORTAL_TYPE;
|
||||
var Profiler = REACT_PROFILER_TYPE;
|
||||
var StrictMode = REACT_STRICT_MODE_TYPE;
|
||||
var Suspense = REACT_SUSPENSE_TYPE;
|
||||
var hasWarnedAboutDeprecatedIsAsyncMode = false;
|
||||
var hasWarnedAboutDeprecatedIsConcurrentMode = false; // AsyncMode should be deprecated
|
||||
|
||||
function isAsyncMode(object) {
|
||||
{
|
||||
if (!hasWarnedAboutDeprecatedIsAsyncMode) {
|
||||
hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
|
||||
|
||||
console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
function isConcurrentMode(object) {
|
||||
{
|
||||
if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
|
||||
hasWarnedAboutDeprecatedIsConcurrentMode = true; // Using console['warn'] to evade Babel and ESLint
|
||||
|
||||
console['warn']('The ReactIs.isConcurrentMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
function isContextConsumer(object) {
|
||||
return typeOf(object) === REACT_CONTEXT_TYPE;
|
||||
}
|
||||
function isContextProvider(object) {
|
||||
return typeOf(object) === REACT_PROVIDER_TYPE;
|
||||
}
|
||||
function isElement(object) {
|
||||
return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
|
||||
}
|
||||
function isForwardRef(object) {
|
||||
return typeOf(object) === REACT_FORWARD_REF_TYPE;
|
||||
}
|
||||
function isFragment(object) {
|
||||
return typeOf(object) === REACT_FRAGMENT_TYPE;
|
||||
}
|
||||
function isLazy(object) {
|
||||
return typeOf(object) === REACT_LAZY_TYPE;
|
||||
}
|
||||
function isMemo(object) {
|
||||
return typeOf(object) === REACT_MEMO_TYPE;
|
||||
}
|
||||
function isPortal(object) {
|
||||
return typeOf(object) === REACT_PORTAL_TYPE;
|
||||
}
|
||||
function isProfiler(object) {
|
||||
return typeOf(object) === REACT_PROFILER_TYPE;
|
||||
}
|
||||
function isStrictMode(object) {
|
||||
return typeOf(object) === REACT_STRICT_MODE_TYPE;
|
||||
}
|
||||
function isSuspense(object) {
|
||||
return typeOf(object) === REACT_SUSPENSE_TYPE;
|
||||
}
|
||||
|
||||
exports.ContextConsumer = ContextConsumer;
|
||||
exports.ContextProvider = ContextProvider;
|
||||
exports.Element = Element;
|
||||
exports.ForwardRef = ForwardRef;
|
||||
exports.Fragment = Fragment;
|
||||
exports.Lazy = Lazy;
|
||||
exports.Memo = Memo;
|
||||
exports.Portal = Portal;
|
||||
exports.Profiler = Profiler;
|
||||
exports.StrictMode = StrictMode;
|
||||
exports.Suspense = Suspense;
|
||||
exports.isAsyncMode = isAsyncMode;
|
||||
exports.isConcurrentMode = isConcurrentMode;
|
||||
exports.isContextConsumer = isContextConsumer;
|
||||
exports.isContextProvider = isContextProvider;
|
||||
exports.isElement = isElement;
|
||||
exports.isForwardRef = isForwardRef;
|
||||
exports.isFragment = isFragment;
|
||||
exports.isLazy = isLazy;
|
||||
exports.isMemo = isMemo;
|
||||
exports.isPortal = isPortal;
|
||||
exports.isProfiler = isProfiler;
|
||||
exports.isStrictMode = isStrictMode;
|
||||
exports.isSuspense = isSuspense;
|
||||
exports.isValidElementType = isValidElementType;
|
||||
exports.typeOf = typeOf;
|
||||
})();
|
||||
}
|
14
node_modules/jest-snapshot/node_modules/react-is/cjs/react-is.production.min.js
generated
vendored
Normal file
14
node_modules/jest-snapshot/node_modules/react-is/cjs/react-is.production.min.js
generated
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
/** @license React v17.0.2
|
||||
* react-is.production.min.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
'use strict';var b=60103,c=60106,d=60107,e=60108,f=60114,g=60109,h=60110,k=60112,l=60113,m=60120,n=60115,p=60116,q=60121,r=60122,u=60117,v=60129,w=60131;
|
||||
if("function"===typeof Symbol&&Symbol.for){var x=Symbol.for;b=x("react.element");c=x("react.portal");d=x("react.fragment");e=x("react.strict_mode");f=x("react.profiler");g=x("react.provider");h=x("react.context");k=x("react.forward_ref");l=x("react.suspense");m=x("react.suspense_list");n=x("react.memo");p=x("react.lazy");q=x("react.block");r=x("react.server.block");u=x("react.fundamental");v=x("react.debug_trace_mode");w=x("react.legacy_hidden")}
|
||||
function y(a){if("object"===typeof a&&null!==a){var t=a.$$typeof;switch(t){case b:switch(a=a.type,a){case d:case f:case e:case l:case m:return a;default:switch(a=a&&a.$$typeof,a){case h:case k:case p:case n:case g:return a;default:return t}}case c:return t}}}var z=g,A=b,B=k,C=d,D=p,E=n,F=c,G=f,H=e,I=l;exports.ContextConsumer=h;exports.ContextProvider=z;exports.Element=A;exports.ForwardRef=B;exports.Fragment=C;exports.Lazy=D;exports.Memo=E;exports.Portal=F;exports.Profiler=G;exports.StrictMode=H;
|
||||
exports.Suspense=I;exports.isAsyncMode=function(){return!1};exports.isConcurrentMode=function(){return!1};exports.isContextConsumer=function(a){return y(a)===h};exports.isContextProvider=function(a){return y(a)===g};exports.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===b};exports.isForwardRef=function(a){return y(a)===k};exports.isFragment=function(a){return y(a)===d};exports.isLazy=function(a){return y(a)===p};exports.isMemo=function(a){return y(a)===n};
|
||||
exports.isPortal=function(a){return y(a)===c};exports.isProfiler=function(a){return y(a)===f};exports.isStrictMode=function(a){return y(a)===e};exports.isSuspense=function(a){return y(a)===l};exports.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===d||a===f||a===v||a===e||a===l||a===m||a===w||"object"===typeof a&&null!==a&&(a.$$typeof===p||a.$$typeof===n||a.$$typeof===g||a.$$typeof===h||a.$$typeof===k||a.$$typeof===u||a.$$typeof===q||a[0]===r)?!0:!1};
|
||||
exports.typeOf=y;
|
7
node_modules/jest-snapshot/node_modules/react-is/index.js
generated
vendored
Normal file
7
node_modules/jest-snapshot/node_modules/react-is/index.js
generated
vendored
Normal file
@ -0,0 +1,7 @@
|
||||
'use strict';
|
||||
|
||||
if (process.env.NODE_ENV === 'production') {
|
||||
module.exports = require('./cjs/react-is.production.min.js');
|
||||
} else {
|
||||
module.exports = require('./cjs/react-is.development.js');
|
||||
}
|
27
node_modules/jest-snapshot/node_modules/react-is/package.json
generated
vendored
Normal file
27
node_modules/jest-snapshot/node_modules/react-is/package.json
generated
vendored
Normal file
@ -0,0 +1,27 @@
|
||||
{
|
||||
"name": "react-is",
|
||||
"version": "17.0.2",
|
||||
"description": "Brand checking of React Elements.",
|
||||
"main": "index.js",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/facebook/react.git",
|
||||
"directory": "packages/react-is"
|
||||
},
|
||||
"keywords": [
|
||||
"react"
|
||||
],
|
||||
"license": "MIT",
|
||||
"bugs": {
|
||||
"url": "https://github.com/facebook/react/issues"
|
||||
},
|
||||
"homepage": "https://reactjs.org/",
|
||||
"files": [
|
||||
"LICENSE",
|
||||
"README.md",
|
||||
"build-info.json",
|
||||
"index.js",
|
||||
"cjs/",
|
||||
"umd/"
|
||||
]
|
||||
}
|
225
node_modules/jest-snapshot/node_modules/react-is/umd/react-is.development.js
generated
vendored
Normal file
225
node_modules/jest-snapshot/node_modules/react-is/umd/react-is.development.js
generated
vendored
Normal file
@ -0,0 +1,225 @@
|
||||
/** @license React v17.0.2
|
||||
* react-is.development.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
||||
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
||||
(global = global || self, factory(global.ReactIs = {}));
|
||||
}(this, (function (exports) { 'use strict';
|
||||
|
||||
// ATTENTION
|
||||
// When adding new symbols to this file,
|
||||
// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
|
||||
// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
|
||||
// nor polyfill, then a plain number is used for performance.
|
||||
var REACT_ELEMENT_TYPE = 0xeac7;
|
||||
var REACT_PORTAL_TYPE = 0xeaca;
|
||||
var REACT_FRAGMENT_TYPE = 0xeacb;
|
||||
var REACT_STRICT_MODE_TYPE = 0xeacc;
|
||||
var REACT_PROFILER_TYPE = 0xead2;
|
||||
var REACT_PROVIDER_TYPE = 0xeacd;
|
||||
var REACT_CONTEXT_TYPE = 0xeace;
|
||||
var REACT_FORWARD_REF_TYPE = 0xead0;
|
||||
var REACT_SUSPENSE_TYPE = 0xead1;
|
||||
var REACT_SUSPENSE_LIST_TYPE = 0xead8;
|
||||
var REACT_MEMO_TYPE = 0xead3;
|
||||
var REACT_LAZY_TYPE = 0xead4;
|
||||
var REACT_BLOCK_TYPE = 0xead9;
|
||||
var REACT_SERVER_BLOCK_TYPE = 0xeada;
|
||||
var REACT_FUNDAMENTAL_TYPE = 0xead5;
|
||||
var REACT_SCOPE_TYPE = 0xead7;
|
||||
var REACT_OPAQUE_ID_TYPE = 0xeae0;
|
||||
var REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1;
|
||||
var REACT_OFFSCREEN_TYPE = 0xeae2;
|
||||
var REACT_LEGACY_HIDDEN_TYPE = 0xeae3;
|
||||
|
||||
if (typeof Symbol === 'function' && Symbol.for) {
|
||||
var symbolFor = Symbol.for;
|
||||
REACT_ELEMENT_TYPE = symbolFor('react.element');
|
||||
REACT_PORTAL_TYPE = symbolFor('react.portal');
|
||||
REACT_FRAGMENT_TYPE = symbolFor('react.fragment');
|
||||
REACT_STRICT_MODE_TYPE = symbolFor('react.strict_mode');
|
||||
REACT_PROFILER_TYPE = symbolFor('react.profiler');
|
||||
REACT_PROVIDER_TYPE = symbolFor('react.provider');
|
||||
REACT_CONTEXT_TYPE = symbolFor('react.context');
|
||||
REACT_FORWARD_REF_TYPE = symbolFor('react.forward_ref');
|
||||
REACT_SUSPENSE_TYPE = symbolFor('react.suspense');
|
||||
REACT_SUSPENSE_LIST_TYPE = symbolFor('react.suspense_list');
|
||||
REACT_MEMO_TYPE = symbolFor('react.memo');
|
||||
REACT_LAZY_TYPE = symbolFor('react.lazy');
|
||||
REACT_BLOCK_TYPE = symbolFor('react.block');
|
||||
REACT_SERVER_BLOCK_TYPE = symbolFor('react.server.block');
|
||||
REACT_FUNDAMENTAL_TYPE = symbolFor('react.fundamental');
|
||||
REACT_SCOPE_TYPE = symbolFor('react.scope');
|
||||
REACT_OPAQUE_ID_TYPE = symbolFor('react.opaque.id');
|
||||
REACT_DEBUG_TRACING_MODE_TYPE = symbolFor('react.debug_trace_mode');
|
||||
REACT_OFFSCREEN_TYPE = symbolFor('react.offscreen');
|
||||
REACT_LEGACY_HIDDEN_TYPE = symbolFor('react.legacy_hidden');
|
||||
}
|
||||
|
||||
// Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
|
||||
|
||||
var enableScopeAPI = false; // Experimental Create Event Handle API.
|
||||
|
||||
function isValidElementType(type) {
|
||||
if (typeof type === 'string' || typeof type === 'function') {
|
||||
return true;
|
||||
} // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
|
||||
|
||||
|
||||
if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_DEBUG_TRACING_MODE_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI ) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (typeof type === 'object' && type !== null) {
|
||||
if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
function typeOf(object) {
|
||||
if (typeof object === 'object' && object !== null) {
|
||||
var $$typeof = object.$$typeof;
|
||||
|
||||
switch ($$typeof) {
|
||||
case REACT_ELEMENT_TYPE:
|
||||
var type = object.type;
|
||||
|
||||
switch (type) {
|
||||
case REACT_FRAGMENT_TYPE:
|
||||
case REACT_PROFILER_TYPE:
|
||||
case REACT_STRICT_MODE_TYPE:
|
||||
case REACT_SUSPENSE_TYPE:
|
||||
case REACT_SUSPENSE_LIST_TYPE:
|
||||
return type;
|
||||
|
||||
default:
|
||||
var $$typeofType = type && type.$$typeof;
|
||||
|
||||
switch ($$typeofType) {
|
||||
case REACT_CONTEXT_TYPE:
|
||||
case REACT_FORWARD_REF_TYPE:
|
||||
case REACT_LAZY_TYPE:
|
||||
case REACT_MEMO_TYPE:
|
||||
case REACT_PROVIDER_TYPE:
|
||||
return $$typeofType;
|
||||
|
||||
default:
|
||||
return $$typeof;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
case REACT_PORTAL_TYPE:
|
||||
return $$typeof;
|
||||
}
|
||||
}
|
||||
|
||||
return undefined;
|
||||
}
|
||||
var ContextConsumer = REACT_CONTEXT_TYPE;
|
||||
var ContextProvider = REACT_PROVIDER_TYPE;
|
||||
var Element = REACT_ELEMENT_TYPE;
|
||||
var ForwardRef = REACT_FORWARD_REF_TYPE;
|
||||
var Fragment = REACT_FRAGMENT_TYPE;
|
||||
var Lazy = REACT_LAZY_TYPE;
|
||||
var Memo = REACT_MEMO_TYPE;
|
||||
var Portal = REACT_PORTAL_TYPE;
|
||||
var Profiler = REACT_PROFILER_TYPE;
|
||||
var StrictMode = REACT_STRICT_MODE_TYPE;
|
||||
var Suspense = REACT_SUSPENSE_TYPE;
|
||||
var hasWarnedAboutDeprecatedIsAsyncMode = false;
|
||||
var hasWarnedAboutDeprecatedIsConcurrentMode = false; // AsyncMode should be deprecated
|
||||
|
||||
function isAsyncMode(object) {
|
||||
{
|
||||
if (!hasWarnedAboutDeprecatedIsAsyncMode) {
|
||||
hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
|
||||
|
||||
console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
function isConcurrentMode(object) {
|
||||
{
|
||||
if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
|
||||
hasWarnedAboutDeprecatedIsConcurrentMode = true; // Using console['warn'] to evade Babel and ESLint
|
||||
|
||||
console['warn']('The ReactIs.isConcurrentMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
function isContextConsumer(object) {
|
||||
return typeOf(object) === REACT_CONTEXT_TYPE;
|
||||
}
|
||||
function isContextProvider(object) {
|
||||
return typeOf(object) === REACT_PROVIDER_TYPE;
|
||||
}
|
||||
function isElement(object) {
|
||||
return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
|
||||
}
|
||||
function isForwardRef(object) {
|
||||
return typeOf(object) === REACT_FORWARD_REF_TYPE;
|
||||
}
|
||||
function isFragment(object) {
|
||||
return typeOf(object) === REACT_FRAGMENT_TYPE;
|
||||
}
|
||||
function isLazy(object) {
|
||||
return typeOf(object) === REACT_LAZY_TYPE;
|
||||
}
|
||||
function isMemo(object) {
|
||||
return typeOf(object) === REACT_MEMO_TYPE;
|
||||
}
|
||||
function isPortal(object) {
|
||||
return typeOf(object) === REACT_PORTAL_TYPE;
|
||||
}
|
||||
function isProfiler(object) {
|
||||
return typeOf(object) === REACT_PROFILER_TYPE;
|
||||
}
|
||||
function isStrictMode(object) {
|
||||
return typeOf(object) === REACT_STRICT_MODE_TYPE;
|
||||
}
|
||||
function isSuspense(object) {
|
||||
return typeOf(object) === REACT_SUSPENSE_TYPE;
|
||||
}
|
||||
|
||||
exports.ContextConsumer = ContextConsumer;
|
||||
exports.ContextProvider = ContextProvider;
|
||||
exports.Element = Element;
|
||||
exports.ForwardRef = ForwardRef;
|
||||
exports.Fragment = Fragment;
|
||||
exports.Lazy = Lazy;
|
||||
exports.Memo = Memo;
|
||||
exports.Portal = Portal;
|
||||
exports.Profiler = Profiler;
|
||||
exports.StrictMode = StrictMode;
|
||||
exports.Suspense = Suspense;
|
||||
exports.isAsyncMode = isAsyncMode;
|
||||
exports.isConcurrentMode = isConcurrentMode;
|
||||
exports.isContextConsumer = isContextConsumer;
|
||||
exports.isContextProvider = isContextProvider;
|
||||
exports.isElement = isElement;
|
||||
exports.isForwardRef = isForwardRef;
|
||||
exports.isFragment = isFragment;
|
||||
exports.isLazy = isLazy;
|
||||
exports.isMemo = isMemo;
|
||||
exports.isPortal = isPortal;
|
||||
exports.isProfiler = isProfiler;
|
||||
exports.isStrictMode = isStrictMode;
|
||||
exports.isSuspense = isSuspense;
|
||||
exports.isValidElementType = isValidElementType;
|
||||
exports.typeOf = typeOf;
|
||||
|
||||
})));
|
14
node_modules/jest-snapshot/node_modules/react-is/umd/react-is.production.min.js
generated
vendored
Normal file
14
node_modules/jest-snapshot/node_modules/react-is/umd/react-is.production.min.js
generated
vendored
Normal file
@ -0,0 +1,14 @@
|
||||
/** @license React v17.0.2
|
||||
* react-is.production.min.js
|
||||
*
|
||||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
(function(){'use strict';(function(b,d){"object"===typeof exports&&"undefined"!==typeof module?d(exports):"function"===typeof define&&define.amd?define(["exports"],d):(b=b||self,d(b.ReactIs={}))})(this,function(b){function d(a){if("object"===typeof a&&null!==a){var b=a.$$typeof;switch(b){case q:switch(a=a.type,a){case e:case f:case g:case h:case t:return a;default:switch(a=a&&a.$$typeof,a){case k:case l:case m:case n:case p:return a;default:return b}}case r:return b}}}var q=60103,r=60106,e=60107,g=60108,f=60114,
|
||||
p=60109,k=60110,l=60112,h=60113,t=60120,n=60115,m=60116,u=60121,v=60122,w=60117,x=60129,y=60131;if("function"===typeof Symbol&&Symbol.for){var c=Symbol.for;q=c("react.element");r=c("react.portal");e=c("react.fragment");g=c("react.strict_mode");f=c("react.profiler");p=c("react.provider");k=c("react.context");l=c("react.forward_ref");h=c("react.suspense");t=c("react.suspense_list");n=c("react.memo");m=c("react.lazy");u=c("react.block");v=c("react.server.block");w=c("react.fundamental");x=c("react.debug_trace_mode");
|
||||
y=c("react.legacy_hidden")}b.ContextConsumer=k;b.ContextProvider=p;b.Element=q;b.ForwardRef=l;b.Fragment=e;b.Lazy=m;b.Memo=n;b.Portal=r;b.Profiler=f;b.StrictMode=g;b.Suspense=h;b.isAsyncMode=function(a){return!1};b.isConcurrentMode=function(a){return!1};b.isContextConsumer=function(a){return d(a)===k};b.isContextProvider=function(a){return d(a)===p};b.isElement=function(a){return"object"===typeof a&&null!==a&&a.$$typeof===q};b.isForwardRef=function(a){return d(a)===l};b.isFragment=function(a){return d(a)===
|
||||
e};b.isLazy=function(a){return d(a)===m};b.isMemo=function(a){return d(a)===n};b.isPortal=function(a){return d(a)===r};b.isProfiler=function(a){return d(a)===f};b.isStrictMode=function(a){return d(a)===g};b.isSuspense=function(a){return d(a)===h};b.isValidElementType=function(a){return"string"===typeof a||"function"===typeof a||a===e||a===f||a===x||a===g||a===h||a===t||a===y||"object"===typeof a&&null!==a&&(a.$$typeof===m||a.$$typeof===n||a.$$typeof===p||a.$$typeof===k||a.$$typeof===l||a.$$typeof===
|
||||
w||a.$$typeof===u||a[0]===v)?!0:!1};b.typeOf=d});
|
||||
})();
|
111
node_modules/jest-snapshot/node_modules/semver/CHANGELOG.md
generated
vendored
Normal file
111
node_modules/jest-snapshot/node_modules/semver/CHANGELOG.md
generated
vendored
Normal file
@ -0,0 +1,111 @@
|
||||
# changes log
|
||||
|
||||
## 7.3.0
|
||||
|
||||
* Add `subset(r1, r2)` method to determine if `r1` range is entirely
|
||||
contained by `r2` range.
|
||||
|
||||
## 7.2.3
|
||||
|
||||
* Fix handling of `includePrelease` mode where version ranges like `1.0.0 -
|
||||
2.0.0` would include `3.0.0-pre` and not `1.0.0-pre`.
|
||||
|
||||
## 7.2.2
|
||||
|
||||
* Fix bug where `2.0.0-pre` would be included in `^1.0.0` if
|
||||
`includePrerelease` was set to true.
|
||||
|
||||
## 7.2.0
|
||||
|
||||
* Add `simplifyRange` method to attempt to generate a more human-readable
|
||||
range expression that is equivalent to a supplied range, for a given set
|
||||
of versions.
|
||||
|
||||
## 7.1.2
|
||||
|
||||
* Remove fancy lazy-loading logic, as it was causing problems for webpack
|
||||
users.
|
||||
|
||||
## 7.1.0
|
||||
|
||||
* Add `require('semver/preload')` to load the entire module without using
|
||||
lazy getter methods.
|
||||
|
||||
## 7.0.0
|
||||
|
||||
* Refactor module into separate files for better tree-shaking
|
||||
* Drop support for very old node versions, use const/let, `=>` functions,
|
||||
and classes.
|
||||
|
||||
## 6.3.0
|
||||
|
||||
* Expose the token enum on the exports
|
||||
|
||||
## 6.2.0
|
||||
|
||||
* Coerce numbers to strings when passed to semver.coerce()
|
||||
* Add `rtl` option to coerce from right to left
|
||||
|
||||
## 6.1.3
|
||||
|
||||
* Handle X-ranges properly in includePrerelease mode
|
||||
|
||||
## 6.1.2
|
||||
|
||||
* Do not throw when testing invalid version strings
|
||||
|
||||
## 6.1.1
|
||||
|
||||
* Add options support for semver.coerce()
|
||||
* Handle undefined version passed to Range.test
|
||||
|
||||
## 6.1.0
|
||||
|
||||
* Add semver.compareBuild function
|
||||
* Support `*` in semver.intersects
|
||||
|
||||
## 6.0
|
||||
|
||||
* Fix `intersects` logic.
|
||||
|
||||
This is technically a bug fix, but since it is also a change to behavior
|
||||
that may require users updating their code, it is marked as a major
|
||||
version increment.
|
||||
|
||||
## 5.7
|
||||
|
||||
* Add `minVersion` method
|
||||
|
||||
## 5.6
|
||||
|
||||
* Move boolean `loose` param to an options object, with
|
||||
backwards-compatibility protection.
|
||||
* Add ability to opt out of special prerelease version handling with
|
||||
the `includePrerelease` option flag.
|
||||
|
||||
## 5.5
|
||||
|
||||
* Add version coercion capabilities
|
||||
|
||||
## 5.4
|
||||
|
||||
* Add intersection checking
|
||||
|
||||
## 5.3
|
||||
|
||||
* Add `minSatisfying` method
|
||||
|
||||
## 5.2
|
||||
|
||||
* Add `prerelease(v)` that returns prerelease components
|
||||
|
||||
## 5.1
|
||||
|
||||
* Add Backus-Naur for ranges
|
||||
* Remove excessively cute inspection methods
|
||||
|
||||
## 5.0
|
||||
|
||||
* Remove AMD/Browserified build artifacts
|
||||
* Fix ltr and gtr when using the `*` range
|
||||
* Fix for range `*` with a prerelease identifier
|
15
node_modules/jest-snapshot/node_modules/semver/LICENSE
generated
vendored
Normal file
15
node_modules/jest-snapshot/node_modules/semver/LICENSE
generated
vendored
Normal file
@ -0,0 +1,15 @@
|
||||
The ISC License
|
||||
|
||||
Copyright (c) Isaac Z. Schlueter and Contributors
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted, provided that the above
|
||||
copyright notice and this permission notice appear in all copies.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
|
||||
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
566
node_modules/jest-snapshot/node_modules/semver/README.md
generated
vendored
Normal file
566
node_modules/jest-snapshot/node_modules/semver/README.md
generated
vendored
Normal file
@ -0,0 +1,566 @@
|
||||
semver(1) -- The semantic versioner for npm
|
||||
===========================================
|
||||
|
||||
## Install
|
||||
|
||||
```bash
|
||||
npm install semver
|
||||
````
|
||||
|
||||
## Usage
|
||||
|
||||
As a node module:
|
||||
|
||||
```js
|
||||
const semver = require('semver')
|
||||
|
||||
semver.valid('1.2.3') // '1.2.3'
|
||||
semver.valid('a.b.c') // null
|
||||
semver.clean(' =v1.2.3 ') // '1.2.3'
|
||||
semver.satisfies('1.2.3', '1.x || >=2.5.0 || 5.0.0 - 7.2.3') // true
|
||||
semver.gt('1.2.3', '9.8.7') // false
|
||||
semver.lt('1.2.3', '9.8.7') // true
|
||||
semver.minVersion('>=1.0.0') // '1.0.0'
|
||||
semver.valid(semver.coerce('v2')) // '2.0.0'
|
||||
semver.valid(semver.coerce('42.6.7.9.3-alpha')) // '42.6.7'
|
||||
```
|
||||
|
||||
You can also just load the module for the function that you care about, if
|
||||
you'd like to minimize your footprint.
|
||||
|
||||
```js
|
||||
// load the whole API at once in a single object
|
||||
const semver = require('semver')
|
||||
|
||||
// or just load the bits you need
|
||||
// all of them listed here, just pick and choose what you want
|
||||
|
||||
// classes
|
||||
const SemVer = require('semver/classes/semver')
|
||||
const Comparator = require('semver/classes/comparator')
|
||||
const Range = require('semver/classes/range')
|
||||
|
||||
// functions for working with versions
|
||||
const semverParse = require('semver/functions/parse')
|
||||
const semverValid = require('semver/functions/valid')
|
||||
const semverClean = require('semver/functions/clean')
|
||||
const semverInc = require('semver/functions/inc')
|
||||
const semverDiff = require('semver/functions/diff')
|
||||
const semverMajor = require('semver/functions/major')
|
||||
const semverMinor = require('semver/functions/minor')
|
||||
const semverPatch = require('semver/functions/patch')
|
||||
const semverPrerelease = require('semver/functions/prerelease')
|
||||
const semverCompare = require('semver/functions/compare')
|
||||
const semverRcompare = require('semver/functions/rcompare')
|
||||
const semverCompareLoose = require('semver/functions/compare-loose')
|
||||
const semverCompareBuild = require('semver/functions/compare-build')
|
||||
const semverSort = require('semver/functions/sort')
|
||||
const semverRsort = require('semver/functions/rsort')
|
||||
|
||||
// low-level comparators between versions
|
||||
const semverGt = require('semver/functions/gt')
|
||||
const semverLt = require('semver/functions/lt')
|
||||
const semverEq = require('semver/functions/eq')
|
||||
const semverNeq = require('semver/functions/neq')
|
||||
const semverGte = require('semver/functions/gte')
|
||||
const semverLte = require('semver/functions/lte')
|
||||
const semverCmp = require('semver/functions/cmp')
|
||||
const semverCoerce = require('semver/functions/coerce')
|
||||
|
||||
// working with ranges
|
||||
const semverSatisfies = require('semver/functions/satisfies')
|
||||
const semverMaxSatisfying = require('semver/ranges/max-satisfying')
|
||||
const semverMinSatisfying = require('semver/ranges/min-satisfying')
|
||||
const semverToComparators = require('semver/ranges/to-comparators')
|
||||
const semverMinVersion = require('semver/ranges/min-version')
|
||||
const semverValidRange = require('semver/ranges/valid')
|
||||
const semverOutside = require('semver/ranges/outside')
|
||||
const semverGtr = require('semver/ranges/gtr')
|
||||
const semverLtr = require('semver/ranges/ltr')
|
||||
const semverIntersects = require('semver/ranges/intersects')
|
||||
const simplifyRange = require('semver/ranges/simplify')
|
||||
const rangeSubset = require('semver/ranges/subset')
|
||||
```
|
||||
|
||||
As a command-line utility:
|
||||
|
||||
```
|
||||
$ semver -h
|
||||
|
||||
A JavaScript implementation of the https://semver.org/ specification
|
||||
Copyright Isaac Z. Schlueter
|
||||
|
||||
Usage: semver [options] <version> [<version> [...]]
|
||||
Prints valid versions sorted by SemVer precedence
|
||||
|
||||
Options:
|
||||
-r --range <range>
|
||||
Print versions that match the specified range.
|
||||
|
||||
-i --increment [<level>]
|
||||
Increment a version by the specified level. Level can
|
||||
be one of: major, minor, patch, premajor, preminor,
|
||||
prepatch, or prerelease. Default level is 'patch'.
|
||||
Only one version may be specified.
|
||||
|
||||
--preid <identifier>
|
||||
Identifier to be used to prefix premajor, preminor,
|
||||
prepatch or prerelease version increments.
|
||||
|
||||
-l --loose
|
||||
Interpret versions and ranges loosely
|
||||
|
||||
-p --include-prerelease
|
||||
Always include prerelease versions in range matching
|
||||
|
||||
-c --coerce
|
||||
Coerce a string into SemVer if possible
|
||||
(does not imply --loose)
|
||||
|
||||
--rtl
|
||||
Coerce version strings right to left
|
||||
|
||||
--ltr
|
||||
Coerce version strings left to right (default)
|
||||
|
||||
Program exits successfully if any valid version satisfies
|
||||
all supplied ranges, and prints all satisfying versions.
|
||||
|
||||
If no satisfying versions are found, then exits failure.
|
||||
|
||||
Versions are printed in ascending order, so supplying
|
||||
multiple versions to the utility will just sort them.
|
||||
```
|
||||
|
||||
## Versions
|
||||
|
||||
A "version" is described by the `v2.0.0` specification found at
|
||||
<https://semver.org/>.
|
||||
|
||||
A leading `"="` or `"v"` character is stripped off and ignored.
|
||||
|
||||
## Ranges
|
||||
|
||||
A `version range` is a set of `comparators` which specify versions
|
||||
that satisfy the range.
|
||||
|
||||
A `comparator` is composed of an `operator` and a `version`. The set
|
||||
of primitive `operators` is:
|
||||
|
||||
* `<` Less than
|
||||
* `<=` Less than or equal to
|
||||
* `>` Greater than
|
||||
* `>=` Greater than or equal to
|
||||
* `=` Equal. If no operator is specified, then equality is assumed,
|
||||
so this operator is optional, but MAY be included.
|
||||
|
||||
For example, the comparator `>=1.2.7` would match the versions
|
||||
`1.2.7`, `1.2.8`, `2.5.3`, and `1.3.9`, but not the versions `1.2.6`
|
||||
or `1.1.0`.
|
||||
|
||||
Comparators can be joined by whitespace to form a `comparator set`,
|
||||
which is satisfied by the **intersection** of all of the comparators
|
||||
it includes.
|
||||
|
||||
A range is composed of one or more comparator sets, joined by `||`. A
|
||||
version matches a range if and only if every comparator in at least
|
||||
one of the `||`-separated comparator sets is satisfied by the version.
|
||||
|
||||
For example, the range `>=1.2.7 <1.3.0` would match the versions
|
||||
`1.2.7`, `1.2.8`, and `1.2.99`, but not the versions `1.2.6`, `1.3.0`,
|
||||
or `1.1.0`.
|
||||
|
||||
The range `1.2.7 || >=1.2.9 <2.0.0` would match the versions `1.2.7`,
|
||||
`1.2.9`, and `1.4.6`, but not the versions `1.2.8` or `2.0.0`.
|
||||
|
||||
### Prerelease Tags
|
||||
|
||||
If a version has a prerelease tag (for example, `1.2.3-alpha.3`) then
|
||||
it will only be allowed to satisfy comparator sets if at least one
|
||||
comparator with the same `[major, minor, patch]` tuple also has a
|
||||
prerelease tag.
|
||||
|
||||
For example, the range `>1.2.3-alpha.3` would be allowed to match the
|
||||
version `1.2.3-alpha.7`, but it would *not* be satisfied by
|
||||
`3.4.5-alpha.9`, even though `3.4.5-alpha.9` is technically "greater
|
||||
than" `1.2.3-alpha.3` according to the SemVer sort rules. The version
|
||||
range only accepts prerelease tags on the `1.2.3` version. The
|
||||
version `3.4.5` *would* satisfy the range, because it does not have a
|
||||
prerelease flag, and `3.4.5` is greater than `1.2.3-alpha.7`.
|
||||
|
||||
The purpose for this behavior is twofold. First, prerelease versions
|
||||
frequently are updated very quickly, and contain many breaking changes
|
||||
that are (by the author's design) not yet fit for public consumption.
|
||||
Therefore, by default, they are excluded from range matching
|
||||
semantics.
|
||||
|
||||
Second, a user who has opted into using a prerelease version has
|
||||
clearly indicated the intent to use *that specific* set of
|
||||
alpha/beta/rc versions. By including a prerelease tag in the range,
|
||||
the user is indicating that they are aware of the risk. However, it
|
||||
is still not appropriate to assume that they have opted into taking a
|
||||
similar risk on the *next* set of prerelease versions.
|
||||
|
||||
Note that this behavior can be suppressed (treating all prerelease
|
||||
versions as if they were normal versions, for the purpose of range
|
||||
matching) by setting the `includePrerelease` flag on the options
|
||||
object to any
|
||||
[functions](https://github.com/npm/node-semver#functions) that do
|
||||
range matching.
|
||||
|
||||
#### Prerelease Identifiers
|
||||
|
||||
The method `.inc` takes an additional `identifier` string argument that
|
||||
will append the value of the string as a prerelease identifier:
|
||||
|
||||
```javascript
|
||||
semver.inc('1.2.3', 'prerelease', 'beta')
|
||||
// '1.2.4-beta.0'
|
||||
```
|
||||
|
||||
command-line example:
|
||||
|
||||
```bash
|
||||
$ semver 1.2.3 -i prerelease --preid beta
|
||||
1.2.4-beta.0
|
||||
```
|
||||
|
||||
Which then can be used to increment further:
|
||||
|
||||
```bash
|
||||
$ semver 1.2.4-beta.0 -i prerelease
|
||||
1.2.4-beta.1
|
||||
```
|
||||
|
||||
### Advanced Range Syntax
|
||||
|
||||
Advanced range syntax desugars to primitive comparators in
|
||||
deterministic ways.
|
||||
|
||||
Advanced ranges may be combined in the same way as primitive
|
||||
comparators using white space or `||`.
|
||||
|
||||
#### Hyphen Ranges `X.Y.Z - A.B.C`
|
||||
|
||||
Specifies an inclusive set.
|
||||
|
||||
* `1.2.3 - 2.3.4` := `>=1.2.3 <=2.3.4`
|
||||
|
||||
If a partial version is provided as the first version in the inclusive
|
||||
range, then the missing pieces are replaced with zeroes.
|
||||
|
||||
* `1.2 - 2.3.4` := `>=1.2.0 <=2.3.4`
|
||||
|
||||
If a partial version is provided as the second version in the
|
||||
inclusive range, then all versions that start with the supplied parts
|
||||
of the tuple are accepted, but nothing that would be greater than the
|
||||
provided tuple parts.
|
||||
|
||||
* `1.2.3 - 2.3` := `>=1.2.3 <2.4.0-0`
|
||||
* `1.2.3 - 2` := `>=1.2.3 <3.0.0-0`
|
||||
|
||||
#### X-Ranges `1.2.x` `1.X` `1.2.*` `*`
|
||||
|
||||
Any of `X`, `x`, or `*` may be used to "stand in" for one of the
|
||||
numeric values in the `[major, minor, patch]` tuple.
|
||||
|
||||
* `*` := `>=0.0.0` (Any version satisfies)
|
||||
* `1.x` := `>=1.0.0 <2.0.0-0` (Matching major version)
|
||||
* `1.2.x` := `>=1.2.0 <1.3.0-0` (Matching major and minor versions)
|
||||
|
||||
A partial version range is treated as an X-Range, so the special
|
||||
character is in fact optional.
|
||||
|
||||
* `""` (empty string) := `*` := `>=0.0.0`
|
||||
* `1` := `1.x.x` := `>=1.0.0 <2.0.0-0`
|
||||
* `1.2` := `1.2.x` := `>=1.2.0 <1.3.0-0`
|
||||
|
||||
#### Tilde Ranges `~1.2.3` `~1.2` `~1`
|
||||
|
||||
Allows patch-level changes if a minor version is specified on the
|
||||
comparator. Allows minor-level changes if not.
|
||||
|
||||
* `~1.2.3` := `>=1.2.3 <1.(2+1).0` := `>=1.2.3 <1.3.0-0`
|
||||
* `~1.2` := `>=1.2.0 <1.(2+1).0` := `>=1.2.0 <1.3.0-0` (Same as `1.2.x`)
|
||||
* `~1` := `>=1.0.0 <(1+1).0.0` := `>=1.0.0 <2.0.0-0` (Same as `1.x`)
|
||||
* `~0.2.3` := `>=0.2.3 <0.(2+1).0` := `>=0.2.3 <0.3.0-0`
|
||||
* `~0.2` := `>=0.2.0 <0.(2+1).0` := `>=0.2.0 <0.3.0-0` (Same as `0.2.x`)
|
||||
* `~0` := `>=0.0.0 <(0+1).0.0` := `>=0.0.0 <1.0.0-0` (Same as `0.x`)
|
||||
* `~1.2.3-beta.2` := `>=1.2.3-beta.2 <1.3.0-0` Note that prereleases in
|
||||
the `1.2.3` version will be allowed, if they are greater than or
|
||||
equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but
|
||||
`1.2.4-beta.2` would not, because it is a prerelease of a
|
||||
different `[major, minor, patch]` tuple.
|
||||
|
||||
#### Caret Ranges `^1.2.3` `^0.2.5` `^0.0.4`
|
||||
|
||||
Allows changes that do not modify the left-most non-zero element in the
|
||||
`[major, minor, patch]` tuple. In other words, this allows patch and
|
||||
minor updates for versions `1.0.0` and above, patch updates for
|
||||
versions `0.X >=0.1.0`, and *no* updates for versions `0.0.X`.
|
||||
|
||||
Many authors treat a `0.x` version as if the `x` were the major
|
||||
"breaking-change" indicator.
|
||||
|
||||
Caret ranges are ideal when an author may make breaking changes
|
||||
between `0.2.4` and `0.3.0` releases, which is a common practice.
|
||||
However, it presumes that there will *not* be breaking changes between
|
||||
`0.2.4` and `0.2.5`. It allows for changes that are presumed to be
|
||||
additive (but non-breaking), according to commonly observed practices.
|
||||
|
||||
* `^1.2.3` := `>=1.2.3 <2.0.0-0`
|
||||
* `^0.2.3` := `>=0.2.3 <0.3.0-0`
|
||||
* `^0.0.3` := `>=0.0.3 <0.0.4-0`
|
||||
* `^1.2.3-beta.2` := `>=1.2.3-beta.2 <2.0.0-0` Note that prereleases in
|
||||
the `1.2.3` version will be allowed, if they are greater than or
|
||||
equal to `beta.2`. So, `1.2.3-beta.4` would be allowed, but
|
||||
`1.2.4-beta.2` would not, because it is a prerelease of a
|
||||
different `[major, minor, patch]` tuple.
|
||||
* `^0.0.3-beta` := `>=0.0.3-beta <0.0.4-0` Note that prereleases in the
|
||||
`0.0.3` version *only* will be allowed, if they are greater than or
|
||||
equal to `beta`. So, `0.0.3-pr.2` would be allowed.
|
||||
|
||||
When parsing caret ranges, a missing `patch` value desugars to the
|
||||
number `0`, but will allow flexibility within that value, even if the
|
||||
major and minor versions are both `0`.
|
||||
|
||||
* `^1.2.x` := `>=1.2.0 <2.0.0-0`
|
||||
* `^0.0.x` := `>=0.0.0 <0.1.0-0`
|
||||
* `^0.0` := `>=0.0.0 <0.1.0-0`
|
||||
|
||||
A missing `minor` and `patch` values will desugar to zero, but also
|
||||
allow flexibility within those values, even if the major version is
|
||||
zero.
|
||||
|
||||
* `^1.x` := `>=1.0.0 <2.0.0-0`
|
||||
* `^0.x` := `>=0.0.0 <1.0.0-0`
|
||||
|
||||
### Range Grammar
|
||||
|
||||
Putting all this together, here is a Backus-Naur grammar for ranges,
|
||||
for the benefit of parser authors:
|
||||
|
||||
```bnf
|
||||
range-set ::= range ( logical-or range ) *
|
||||
logical-or ::= ( ' ' ) * '||' ( ' ' ) *
|
||||
range ::= hyphen | simple ( ' ' simple ) * | ''
|
||||
hyphen ::= partial ' - ' partial
|
||||
simple ::= primitive | partial | tilde | caret
|
||||
primitive ::= ( '<' | '>' | '>=' | '<=' | '=' ) partial
|
||||
partial ::= xr ( '.' xr ( '.' xr qualifier ? )? )?
|
||||
xr ::= 'x' | 'X' | '*' | nr
|
||||
nr ::= '0' | ['1'-'9'] ( ['0'-'9'] ) *
|
||||
tilde ::= '~' partial
|
||||
caret ::= '^' partial
|
||||
qualifier ::= ( '-' pre )? ( '+' build )?
|
||||
pre ::= parts
|
||||
build ::= parts
|
||||
parts ::= part ( '.' part ) *
|
||||
part ::= nr | [-0-9A-Za-z]+
|
||||
```
|
||||
|
||||
## Functions
|
||||
|
||||
All methods and classes take a final `options` object argument. All
|
||||
options in this object are `false` by default. The options supported
|
||||
are:
|
||||
|
||||
- `loose` Be more forgiving about not-quite-valid semver strings.
|
||||
(Any resulting output will always be 100% strict compliant, of
|
||||
course.) For backwards compatibility reasons, if the `options`
|
||||
argument is a boolean value instead of an object, it is interpreted
|
||||
to be the `loose` param.
|
||||
- `includePrerelease` Set to suppress the [default
|
||||
behavior](https://github.com/npm/node-semver#prerelease-tags) of
|
||||
excluding prerelease tagged versions from ranges unless they are
|
||||
explicitly opted into.
|
||||
|
||||
Strict-mode Comparators and Ranges will be strict about the SemVer
|
||||
strings that they parse.
|
||||
|
||||
* `valid(v)`: Return the parsed version, or null if it's not valid.
|
||||
* `inc(v, release)`: Return the version incremented by the release
|
||||
type (`major`, `premajor`, `minor`, `preminor`, `patch`,
|
||||
`prepatch`, or `prerelease`), or null if it's not valid
|
||||
* `premajor` in one call will bump the version up to the next major
|
||||
version and down to a prerelease of that major version.
|
||||
`preminor`, and `prepatch` work the same way.
|
||||
* If called from a non-prerelease version, the `prerelease` will work the
|
||||
same as `prepatch`. It increments the patch version, then makes a
|
||||
prerelease. If the input version is already a prerelease it simply
|
||||
increments it.
|
||||
* `prerelease(v)`: Returns an array of prerelease components, or null
|
||||
if none exist. Example: `prerelease('1.2.3-alpha.1') -> ['alpha', 1]`
|
||||
* `major(v)`: Return the major version number.
|
||||
* `minor(v)`: Return the minor version number.
|
||||
* `patch(v)`: Return the patch version number.
|
||||
* `intersects(r1, r2, loose)`: Return true if the two supplied ranges
|
||||
or comparators intersect.
|
||||
* `parse(v)`: Attempt to parse a string as a semantic version, returning either
|
||||
a `SemVer` object or `null`.
|
||||
|
||||
### Comparison
|
||||
|
||||
* `gt(v1, v2)`: `v1 > v2`
|
||||
* `gte(v1, v2)`: `v1 >= v2`
|
||||
* `lt(v1, v2)`: `v1 < v2`
|
||||
* `lte(v1, v2)`: `v1 <= v2`
|
||||
* `eq(v1, v2)`: `v1 == v2` This is true if they're logically equivalent,
|
||||
even if they're not the exact same string. You already know how to
|
||||
compare strings.
|
||||
* `neq(v1, v2)`: `v1 != v2` The opposite of `eq`.
|
||||
* `cmp(v1, comparator, v2)`: Pass in a comparison string, and it'll call
|
||||
the corresponding function above. `"==="` and `"!=="` do simple
|
||||
string comparison, but are included for completeness. Throws if an
|
||||
invalid comparison string is provided.
|
||||
* `compare(v1, v2)`: Return `0` if `v1 == v2`, or `1` if `v1` is greater, or `-1` if
|
||||
`v2` is greater. Sorts in ascending order if passed to `Array.sort()`.
|
||||
* `rcompare(v1, v2)`: The reverse of compare. Sorts an array of versions
|
||||
in descending order when passed to `Array.sort()`.
|
||||
* `compareBuild(v1, v2)`: The same as `compare` but considers `build` when two versions
|
||||
are equal. Sorts in ascending order if passed to `Array.sort()`.
|
||||
`v2` is greater. Sorts in ascending order if passed to `Array.sort()`.
|
||||
* `diff(v1, v2)`: Returns difference between two versions by the release type
|
||||
(`major`, `premajor`, `minor`, `preminor`, `patch`, `prepatch`, or `prerelease`),
|
||||
or null if the versions are the same.
|
||||
|
||||
### Comparators
|
||||
|
||||
* `intersects(comparator)`: Return true if the comparators intersect
|
||||
|
||||
### Ranges
|
||||
|
||||
* `validRange(range)`: Return the valid range or null if it's not valid
|
||||
* `satisfies(version, range)`: Return true if the version satisfies the
|
||||
range.
|
||||
* `maxSatisfying(versions, range)`: Return the highest version in the list
|
||||
that satisfies the range, or `null` if none of them do.
|
||||
* `minSatisfying(versions, range)`: Return the lowest version in the list
|
||||
that satisfies the range, or `null` if none of them do.
|
||||
* `minVersion(range)`: Return the lowest version that can possibly match
|
||||
the given range.
|
||||
* `gtr(version, range)`: Return `true` if version is greater than all the
|
||||
versions possible in the range.
|
||||
* `ltr(version, range)`: Return `true` if version is less than all the
|
||||
versions possible in the range.
|
||||
* `outside(version, range, hilo)`: Return true if the version is outside
|
||||
the bounds of the range in either the high or low direction. The
|
||||
`hilo` argument must be either the string `'>'` or `'<'`. (This is
|
||||
the function called by `gtr` and `ltr`.)
|
||||
* `intersects(range)`: Return true if any of the ranges comparators intersect
|
||||
* `simplifyRange(versions, range)`: Return a "simplified" range that
|
||||
matches the same items in `versions` list as the range specified. Note
|
||||
that it does *not* guarantee that it would match the same versions in all
|
||||
cases, only for the set of versions provided. This is useful when
|
||||
generating ranges by joining together multiple versions with `||`
|
||||
programmatically, to provide the user with something a bit more
|
||||
ergonomic. If the provided range is shorter in string-length than the
|
||||
generated range, then that is returned.
|
||||
* `subset(subRange, superRange)`: Return `true` if the `subRange` range is
|
||||
entirely contained by the `superRange` range.
|
||||
|
||||
Note that, since ranges may be non-contiguous, a version might not be
|
||||
greater than a range, less than a range, *or* satisfy a range! For
|
||||
example, the range `1.2 <1.2.9 || >2.0.0` would have a hole from `1.2.9`
|
||||
until `2.0.0`, so the version `1.2.10` would not be greater than the
|
||||
range (because `2.0.1` satisfies, which is higher), nor less than the
|
||||
range (since `1.2.8` satisfies, which is lower), and it also does not
|
||||
satisfy the range.
|
||||
|
||||
If you want to know if a version satisfies or does not satisfy a
|
||||
range, use the `satisfies(version, range)` function.
|
||||
|
||||
### Coercion
|
||||
|
||||
* `coerce(version, options)`: Coerces a string to semver if possible
|
||||
|
||||
This aims to provide a very forgiving translation of a non-semver string to
|
||||
semver. It looks for the first digit in a string, and consumes all
|
||||
remaining characters which satisfy at least a partial semver (e.g., `1`,
|
||||
`1.2`, `1.2.3`) up to the max permitted length (256 characters). Longer
|
||||
versions are simply truncated (`4.6.3.9.2-alpha2` becomes `4.6.3`). All
|
||||
surrounding text is simply ignored (`v3.4 replaces v3.3.1` becomes
|
||||
`3.4.0`). Only text which lacks digits will fail coercion (`version one`
|
||||
is not valid). The maximum length for any semver component considered for
|
||||
coercion is 16 characters; longer components will be ignored
|
||||
(`10000000000000000.4.7.4` becomes `4.7.4`). The maximum value for any
|
||||
semver component is `Number.MAX_SAFE_INTEGER || (2**53 - 1)`; higher value
|
||||
components are invalid (`9999999999999999.4.7.4` is likely invalid).
|
||||
|
||||
If the `options.rtl` flag is set, then `coerce` will return the right-most
|
||||
coercible tuple that does not share an ending index with a longer coercible
|
||||
tuple. For example, `1.2.3.4` will return `2.3.4` in rtl mode, not
|
||||
`4.0.0`. `1.2.3/4` will return `4.0.0`, because the `4` is not a part of
|
||||
any other overlapping SemVer tuple.
|
||||
|
||||
### Clean
|
||||
|
||||
* `clean(version)`: Clean a string to be a valid semver if possible
|
||||
|
||||
This will return a cleaned and trimmed semver version. If the provided
|
||||
version is not valid a null will be returned. This does not work for
|
||||
ranges.
|
||||
|
||||
ex.
|
||||
* `s.clean(' = v 2.1.5foo')`: `null`
|
||||
* `s.clean(' = v 2.1.5foo', { loose: true })`: `'2.1.5-foo'`
|
||||
* `s.clean(' = v 2.1.5-foo')`: `null`
|
||||
* `s.clean(' = v 2.1.5-foo', { loose: true })`: `'2.1.5-foo'`
|
||||
* `s.clean('=v2.1.5')`: `'2.1.5'`
|
||||
* `s.clean(' =v2.1.5')`: `2.1.5`
|
||||
* `s.clean(' 2.1.5 ')`: `'2.1.5'`
|
||||
* `s.clean('~1.0.0')`: `null`
|
||||
|
||||
## Exported Modules
|
||||
|
||||
<!--
|
||||
TODO: Make sure that all of these items are documented (classes aren't,
|
||||
eg), and then pull the module name into the documentation for that specific
|
||||
thing.
|
||||
-->
|
||||
|
||||
You may pull in just the part of this semver utility that you need, if you
|
||||
are sensitive to packing and tree-shaking concerns. The main
|
||||
`require('semver')` export uses getter functions to lazily load the parts
|
||||
of the API that are used.
|
||||
|
||||
The following modules are available:
|
||||
|
||||
* `require('semver')`
|
||||
* `require('semver/classes')`
|
||||
* `require('semver/classes/comparator')`
|
||||
* `require('semver/classes/range')`
|
||||
* `require('semver/classes/semver')`
|
||||
* `require('semver/functions/clean')`
|
||||
* `require('semver/functions/cmp')`
|
||||
* `require('semver/functions/coerce')`
|
||||
* `require('semver/functions/compare')`
|
||||
* `require('semver/functions/compare-build')`
|
||||
* `require('semver/functions/compare-loose')`
|
||||
* `require('semver/functions/diff')`
|
||||
* `require('semver/functions/eq')`
|
||||
* `require('semver/functions/gt')`
|
||||
* `require('semver/functions/gte')`
|
||||
* `require('semver/functions/inc')`
|
||||
* `require('semver/functions/lt')`
|
||||
* `require('semver/functions/lte')`
|
||||
* `require('semver/functions/major')`
|
||||
* `require('semver/functions/minor')`
|
||||
* `require('semver/functions/neq')`
|
||||
* `require('semver/functions/parse')`
|
||||
* `require('semver/functions/patch')`
|
||||
* `require('semver/functions/prerelease')`
|
||||
* `require('semver/functions/rcompare')`
|
||||
* `require('semver/functions/rsort')`
|
||||
* `require('semver/functions/satisfies')`
|
||||
* `require('semver/functions/sort')`
|
||||
* `require('semver/functions/valid')`
|
||||
* `require('semver/ranges/gtr')`
|
||||
* `require('semver/ranges/intersects')`
|
||||
* `require('semver/ranges/ltr')`
|
||||
* `require('semver/ranges/max-satisfying')`
|
||||
* `require('semver/ranges/min-satisfying')`
|
||||
* `require('semver/ranges/min-version')`
|
||||
* `require('semver/ranges/outside')`
|
||||
* `require('semver/ranges/to-comparators')`
|
||||
* `require('semver/ranges/valid')`
|
173
node_modules/jest-snapshot/node_modules/semver/bin/semver.js
generated
vendored
Executable file
173
node_modules/jest-snapshot/node_modules/semver/bin/semver.js
generated
vendored
Executable file
@ -0,0 +1,173 @@
|
||||
#!/usr/bin/env node
|
||||
// Standalone semver comparison program.
|
||||
// Exits successfully and prints matching version(s) if
|
||||
// any supplied version is valid and passes all tests.
|
||||
|
||||
const argv = process.argv.slice(2)
|
||||
|
||||
let versions = []
|
||||
|
||||
const range = []
|
||||
|
||||
let inc = null
|
||||
|
||||
const version = require('../package.json').version
|
||||
|
||||
let loose = false
|
||||
|
||||
let includePrerelease = false
|
||||
|
||||
let coerce = false
|
||||
|
||||
let rtl = false
|
||||
|
||||
let identifier
|
||||
|
||||
const semver = require('../')
|
||||
|
||||
let reverse = false
|
||||
|
||||
const options = {}
|
||||
|
||||
const main = () => {
|
||||
if (!argv.length) return help()
|
||||
while (argv.length) {
|
||||
let a = argv.shift()
|
||||
const indexOfEqualSign = a.indexOf('=')
|
||||
if (indexOfEqualSign !== -1) {
|
||||
a = a.slice(0, indexOfEqualSign)
|
||||
argv.unshift(a.slice(indexOfEqualSign + 1))
|
||||
}
|
||||
switch (a) {
|
||||
case '-rv': case '-rev': case '--rev': case '--reverse':
|
||||
reverse = true
|
||||
break
|
||||
case '-l': case '--loose':
|
||||
loose = true
|
||||
break
|
||||
case '-p': case '--include-prerelease':
|
||||
includePrerelease = true
|
||||
break
|
||||
case '-v': case '--version':
|
||||
versions.push(argv.shift())
|
||||
break
|
||||
case '-i': case '--inc': case '--increment':
|
||||
switch (argv[0]) {
|
||||
case 'major': case 'minor': case 'patch': case 'prerelease':
|
||||
case 'premajor': case 'preminor': case 'prepatch':
|
||||
inc = argv.shift()
|
||||
break
|
||||
default:
|
||||
inc = 'patch'
|
||||
break
|
||||
}
|
||||
break
|
||||
case '--preid':
|
||||
identifier = argv.shift()
|
||||
break
|
||||
case '-r': case '--range':
|
||||
range.push(argv.shift())
|
||||
break
|
||||
case '-c': case '--coerce':
|
||||
coerce = true
|
||||
break
|
||||
case '--rtl':
|
||||
rtl = true
|
||||
break
|
||||
case '--ltr':
|
||||
rtl = false
|
||||
break
|
||||
case '-h': case '--help': case '-?':
|
||||
return help()
|
||||
default:
|
||||
versions.push(a)
|
||||
break
|
||||
}
|
||||
}
|
||||
|
||||
const options = { loose: loose, includePrerelease: includePrerelease, rtl: rtl }
|
||||
|
||||
versions = versions.map((v) => {
|
||||
return coerce ? (semver.coerce(v, options) || { version: v }).version : v
|
||||
}).filter((v) => {
|
||||
return semver.valid(v)
|
||||
})
|
||||
if (!versions.length) return fail()
|
||||
if (inc && (versions.length !== 1 || range.length)) { return failInc() }
|
||||
|
||||
for (let i = 0, l = range.length; i < l; i++) {
|
||||
versions = versions.filter((v) => {
|
||||
return semver.satisfies(v, range[i], options)
|
||||
})
|
||||
if (!versions.length) return fail()
|
||||
}
|
||||
return success(versions)
|
||||
}
|
||||
|
||||
|
||||
const failInc = () => {
|
||||
console.error('--inc can only be used on a single version with no range')
|
||||
fail()
|
||||
}
|
||||
|
||||
const fail = () => process.exit(1)
|
||||
|
||||
const success = () => {
|
||||
const compare = reverse ? 'rcompare' : 'compare'
|
||||
versions.sort((a, b) => {
|
||||
return semver[compare](a, b, options)
|
||||
}).map((v) => {
|
||||
return semver.clean(v, options)
|
||||
}).map((v) => {
|
||||
return inc ? semver.inc(v, inc, options, identifier) : v
|
||||
}).forEach((v, i, _) => { console.log(v) })
|
||||
}
|
||||
|
||||
const help = () => console.log(
|
||||
`SemVer ${version}
|
||||
|
||||
A JavaScript implementation of the https://semver.org/ specification
|
||||
Copyright Isaac Z. Schlueter
|
||||
|
||||
Usage: semver [options] <version> [<version> [...]]
|
||||
Prints valid versions sorted by SemVer precedence
|
||||
|
||||
Options:
|
||||
-r --range <range>
|
||||
Print versions that match the specified range.
|
||||
|
||||
-i --increment [<level>]
|
||||
Increment a version by the specified level. Level can
|
||||
be one of: major, minor, patch, premajor, preminor,
|
||||
prepatch, or prerelease. Default level is 'patch'.
|
||||
Only one version may be specified.
|
||||
|
||||
--preid <identifier>
|
||||
Identifier to be used to prefix premajor, preminor,
|
||||
prepatch or prerelease version increments.
|
||||
|
||||
-l --loose
|
||||
Interpret versions and ranges loosely
|
||||
|
||||
-p --include-prerelease
|
||||
Always include prerelease versions in range matching
|
||||
|
||||
-c --coerce
|
||||
Coerce a string into SemVer if possible
|
||||
(does not imply --loose)
|
||||
|
||||
--rtl
|
||||
Coerce version strings right to left
|
||||
|
||||
--ltr
|
||||
Coerce version strings left to right (default)
|
||||
|
||||
Program exits successfully if any valid version satisfies
|
||||
all supplied ranges, and prints all satisfying versions.
|
||||
|
||||
If no satisfying versions are found, then exits failure.
|
||||
|
||||
Versions are printed in ascending order, so supplying
|
||||
multiple versions to the utility will just sort them.`)
|
||||
|
||||
main()
|
135
node_modules/jest-snapshot/node_modules/semver/classes/comparator.js
generated
vendored
Normal file
135
node_modules/jest-snapshot/node_modules/semver/classes/comparator.js
generated
vendored
Normal file
@ -0,0 +1,135 @@
|
||||
const ANY = Symbol('SemVer ANY')
|
||||
// hoisted class for cyclic dependency
|
||||
class Comparator {
|
||||
static get ANY () {
|
||||
return ANY
|
||||
}
|
||||
constructor (comp, options) {
|
||||
options = parseOptions(options)
|
||||
|
||||
if (comp instanceof Comparator) {
|
||||
if (comp.loose === !!options.loose) {
|
||||
return comp
|
||||
} else {
|
||||
comp = comp.value
|
||||
}
|
||||
}
|
||||
|
||||
debug('comparator', comp, options)
|
||||
this.options = options
|
||||
this.loose = !!options.loose
|
||||
this.parse(comp)
|
||||
|
||||
if (this.semver === ANY) {
|
||||
this.value = ''
|
||||
} else {
|
||||
this.value = this.operator + this.semver.version
|
||||
}
|
||||
|
||||
debug('comp', this)
|
||||
}
|
||||
|
||||
parse (comp) {
|
||||
const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
|
||||
const m = comp.match(r)
|
||||
|
||||
if (!m) {
|
||||
throw new TypeError(`Invalid comparator: ${comp}`)
|
||||
}
|
||||
|
||||
this.operator = m[1] !== undefined ? m[1] : ''
|
||||
if (this.operator === '=') {
|
||||
this.operator = ''
|
||||
}
|
||||
|
||||
// if it literally is just '>' or '' then allow anything.
|
||||
if (!m[2]) {
|
||||
this.semver = ANY
|
||||
} else {
|
||||
this.semver = new SemVer(m[2], this.options.loose)
|
||||
}
|
||||
}
|
||||
|
||||
toString () {
|
||||
return this.value
|
||||
}
|
||||
|
||||
test (version) {
|
||||
debug('Comparator.test', version, this.options.loose)
|
||||
|
||||
if (this.semver === ANY || version === ANY) {
|
||||
return true
|
||||
}
|
||||
|
||||
if (typeof version === 'string') {
|
||||
try {
|
||||
version = new SemVer(version, this.options)
|
||||
} catch (er) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return cmp(version, this.operator, this.semver, this.options)
|
||||
}
|
||||
|
||||
intersects (comp, options) {
|
||||
if (!(comp instanceof Comparator)) {
|
||||
throw new TypeError('a Comparator is required')
|
||||
}
|
||||
|
||||
if (!options || typeof options !== 'object') {
|
||||
options = {
|
||||
loose: !!options,
|
||||
includePrerelease: false
|
||||
}
|
||||
}
|
||||
|
||||
if (this.operator === '') {
|
||||
if (this.value === '') {
|
||||
return true
|
||||
}
|
||||
return new Range(comp.value, options).test(this.value)
|
||||
} else if (comp.operator === '') {
|
||||
if (comp.value === '') {
|
||||
return true
|
||||
}
|
||||
return new Range(this.value, options).test(comp.semver)
|
||||
}
|
||||
|
||||
const sameDirectionIncreasing =
|
||||
(this.operator === '>=' || this.operator === '>') &&
|
||||
(comp.operator === '>=' || comp.operator === '>')
|
||||
const sameDirectionDecreasing =
|
||||
(this.operator === '<=' || this.operator === '<') &&
|
||||
(comp.operator === '<=' || comp.operator === '<')
|
||||
const sameSemVer = this.semver.version === comp.semver.version
|
||||
const differentDirectionsInclusive =
|
||||
(this.operator === '>=' || this.operator === '<=') &&
|
||||
(comp.operator === '>=' || comp.operator === '<=')
|
||||
const oppositeDirectionsLessThan =
|
||||
cmp(this.semver, '<', comp.semver, options) &&
|
||||
(this.operator === '>=' || this.operator === '>') &&
|
||||
(comp.operator === '<=' || comp.operator === '<')
|
||||
const oppositeDirectionsGreaterThan =
|
||||
cmp(this.semver, '>', comp.semver, options) &&
|
||||
(this.operator === '<=' || this.operator === '<') &&
|
||||
(comp.operator === '>=' || comp.operator === '>')
|
||||
|
||||
return (
|
||||
sameDirectionIncreasing ||
|
||||
sameDirectionDecreasing ||
|
||||
(sameSemVer && differentDirectionsInclusive) ||
|
||||
oppositeDirectionsLessThan ||
|
||||
oppositeDirectionsGreaterThan
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = Comparator
|
||||
|
||||
const parseOptions = require('../internal/parse-options')
|
||||
const {re, t} = require('../internal/re')
|
||||
const cmp = require('../functions/cmp')
|
||||
const debug = require('../internal/debug')
|
||||
const SemVer = require('./semver')
|
||||
const Range = require('./range')
|
5
node_modules/jest-snapshot/node_modules/semver/classes/index.js
generated
vendored
Normal file
5
node_modules/jest-snapshot/node_modules/semver/classes/index.js
generated
vendored
Normal file
@ -0,0 +1,5 @@
|
||||
module.exports = {
|
||||
SemVer: require('./semver.js'),
|
||||
Range: require('./range.js'),
|
||||
Comparator: require('./comparator.js')
|
||||
}
|
510
node_modules/jest-snapshot/node_modules/semver/classes/range.js
generated
vendored
Normal file
510
node_modules/jest-snapshot/node_modules/semver/classes/range.js
generated
vendored
Normal file
@ -0,0 +1,510 @@
|
||||
// hoisted class for cyclic dependency
|
||||
class Range {
|
||||
constructor (range, options) {
|
||||
options = parseOptions(options)
|
||||
|
||||
if (range instanceof Range) {
|
||||
if (
|
||||
range.loose === !!options.loose &&
|
||||
range.includePrerelease === !!options.includePrerelease
|
||||
) {
|
||||
return range
|
||||
} else {
|
||||
return new Range(range.raw, options)
|
||||
}
|
||||
}
|
||||
|
||||
if (range instanceof Comparator) {
|
||||
// just put it in the set and return
|
||||
this.raw = range.value
|
||||
this.set = [[range]]
|
||||
this.format()
|
||||
return this
|
||||
}
|
||||
|
||||
this.options = options
|
||||
this.loose = !!options.loose
|
||||
this.includePrerelease = !!options.includePrerelease
|
||||
|
||||
// First, split based on boolean or ||
|
||||
this.raw = range
|
||||
this.set = range
|
||||
.split(/\s*\|\|\s*/)
|
||||
// map the range to a 2d array of comparators
|
||||
.map(range => this.parseRange(range.trim()))
|
||||
// throw out any comparator lists that are empty
|
||||
// this generally means that it was not a valid range, which is allowed
|
||||
// in loose mode, but will still throw if the WHOLE range is invalid.
|
||||
.filter(c => c.length)
|
||||
|
||||
if (!this.set.length) {
|
||||
throw new TypeError(`Invalid SemVer Range: ${range}`)
|
||||
}
|
||||
|
||||
// if we have any that are not the null set, throw out null sets.
|
||||
if (this.set.length > 1) {
|
||||
// keep the first one, in case they're all null sets
|
||||
const first = this.set[0]
|
||||
this.set = this.set.filter(c => !isNullSet(c[0]))
|
||||
if (this.set.length === 0)
|
||||
this.set = [first]
|
||||
else if (this.set.length > 1) {
|
||||
// if we have any that are *, then the range is just *
|
||||
for (const c of this.set) {
|
||||
if (c.length === 1 && isAny(c[0])) {
|
||||
this.set = [c]
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.format()
|
||||
}
|
||||
|
||||
format () {
|
||||
this.range = this.set
|
||||
.map((comps) => {
|
||||
return comps.join(' ').trim()
|
||||
})
|
||||
.join('||')
|
||||
.trim()
|
||||
return this.range
|
||||
}
|
||||
|
||||
toString () {
|
||||
return this.range
|
||||
}
|
||||
|
||||
parseRange (range) {
|
||||
range = range.trim()
|
||||
|
||||
// memoize range parsing for performance.
|
||||
// this is a very hot path, and fully deterministic.
|
||||
const memoOpts = Object.keys(this.options).join(',')
|
||||
const memoKey = `parseRange:${memoOpts}:${range}`
|
||||
const cached = cache.get(memoKey)
|
||||
if (cached)
|
||||
return cached
|
||||
|
||||
const loose = this.options.loose
|
||||
// `1.2.3 - 1.2.4` => `>=1.2.3 <=1.2.4`
|
||||
const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE]
|
||||
range = range.replace(hr, hyphenReplace(this.options.includePrerelease))
|
||||
debug('hyphen replace', range)
|
||||
// `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
|
||||
range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace)
|
||||
debug('comparator trim', range, re[t.COMPARATORTRIM])
|
||||
|
||||
// `~ 1.2.3` => `~1.2.3`
|
||||
range = range.replace(re[t.TILDETRIM], tildeTrimReplace)
|
||||
|
||||
// `^ 1.2.3` => `^1.2.3`
|
||||
range = range.replace(re[t.CARETTRIM], caretTrimReplace)
|
||||
|
||||
// normalize spaces
|
||||
range = range.split(/\s+/).join(' ')
|
||||
|
||||
// At this point, the range is completely trimmed and
|
||||
// ready to be split into comparators.
|
||||
|
||||
const compRe = loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR]
|
||||
const rangeList = range
|
||||
.split(' ')
|
||||
.map(comp => parseComparator(comp, this.options))
|
||||
.join(' ')
|
||||
.split(/\s+/)
|
||||
// >=0.0.0 is equivalent to *
|
||||
.map(comp => replaceGTE0(comp, this.options))
|
||||
// in loose mode, throw out any that are not valid comparators
|
||||
.filter(this.options.loose ? comp => !!comp.match(compRe) : () => true)
|
||||
.map(comp => new Comparator(comp, this.options))
|
||||
|
||||
// if any comparators are the null set, then replace with JUST null set
|
||||
// if more than one comparator, remove any * comparators
|
||||
// also, don't include the same comparator more than once
|
||||
const l = rangeList.length
|
||||
const rangeMap = new Map()
|
||||
for (const comp of rangeList) {
|
||||
if (isNullSet(comp))
|
||||
return [comp]
|
||||
rangeMap.set(comp.value, comp)
|
||||
}
|
||||
if (rangeMap.size > 1 && rangeMap.has(''))
|
||||
rangeMap.delete('')
|
||||
|
||||
const result = [...rangeMap.values()]
|
||||
cache.set(memoKey, result)
|
||||
return result
|
||||
}
|
||||
|
||||
intersects (range, options) {
|
||||
if (!(range instanceof Range)) {
|
||||
throw new TypeError('a Range is required')
|
||||
}
|
||||
|
||||
return this.set.some((thisComparators) => {
|
||||
return (
|
||||
isSatisfiable(thisComparators, options) &&
|
||||
range.set.some((rangeComparators) => {
|
||||
return (
|
||||
isSatisfiable(rangeComparators, options) &&
|
||||
thisComparators.every((thisComparator) => {
|
||||
return rangeComparators.every((rangeComparator) => {
|
||||
return thisComparator.intersects(rangeComparator, options)
|
||||
})
|
||||
})
|
||||
)
|
||||
})
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
// if ANY of the sets match ALL of its comparators, then pass
|
||||
test (version) {
|
||||
if (!version) {
|
||||
return false
|
||||
}
|
||||
|
||||
if (typeof version === 'string') {
|
||||
try {
|
||||
version = new SemVer(version, this.options)
|
||||
} catch (er) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
for (let i = 0; i < this.set.length; i++) {
|
||||
if (testSet(this.set[i], version, this.options)) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
}
|
||||
module.exports = Range
|
||||
|
||||
const LRU = require('lru-cache')
|
||||
const cache = new LRU({ max: 1000 })
|
||||
|
||||
const parseOptions = require('../internal/parse-options')
|
||||
const Comparator = require('./comparator')
|
||||
const debug = require('../internal/debug')
|
||||
const SemVer = require('./semver')
|
||||
const {
|
||||
re,
|
||||
t,
|
||||
comparatorTrimReplace,
|
||||
tildeTrimReplace,
|
||||
caretTrimReplace
|
||||
} = require('../internal/re')
|
||||
|
||||
const isNullSet = c => c.value === '<0.0.0-0'
|
||||
const isAny = c => c.value === ''
|
||||
|
||||
// take a set of comparators and determine whether there
|
||||
// exists a version which can satisfy it
|
||||
const isSatisfiable = (comparators, options) => {
|
||||
let result = true
|
||||
const remainingComparators = comparators.slice()
|
||||
let testComparator = remainingComparators.pop()
|
||||
|
||||
while (result && remainingComparators.length) {
|
||||
result = remainingComparators.every((otherComparator) => {
|
||||
return testComparator.intersects(otherComparator, options)
|
||||
})
|
||||
|
||||
testComparator = remainingComparators.pop()
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
// comprised of xranges, tildes, stars, and gtlt's at this point.
|
||||
// already replaced the hyphen ranges
|
||||
// turn into a set of JUST comparators.
|
||||
const parseComparator = (comp, options) => {
|
||||
debug('comp', comp, options)
|
||||
comp = replaceCarets(comp, options)
|
||||
debug('caret', comp)
|
||||
comp = replaceTildes(comp, options)
|
||||
debug('tildes', comp)
|
||||
comp = replaceXRanges(comp, options)
|
||||
debug('xrange', comp)
|
||||
comp = replaceStars(comp, options)
|
||||
debug('stars', comp)
|
||||
return comp
|
||||
}
|
||||
|
||||
const isX = id => !id || id.toLowerCase() === 'x' || id === '*'
|
||||
|
||||
// ~, ~> --> * (any, kinda silly)
|
||||
// ~2, ~2.x, ~2.x.x, ~>2, ~>2.x ~>2.x.x --> >=2.0.0 <3.0.0-0
|
||||
// ~2.0, ~2.0.x, ~>2.0, ~>2.0.x --> >=2.0.0 <2.1.0-0
|
||||
// ~1.2, ~1.2.x, ~>1.2, ~>1.2.x --> >=1.2.0 <1.3.0-0
|
||||
// ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
|
||||
// ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
|
||||
const replaceTildes = (comp, options) =>
|
||||
comp.trim().split(/\s+/).map((comp) => {
|
||||
return replaceTilde(comp, options)
|
||||
}).join(' ')
|
||||
|
||||
const replaceTilde = (comp, options) => {
|
||||
const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE]
|
||||
return comp.replace(r, (_, M, m, p, pr) => {
|
||||
debug('tilde', comp, _, M, m, p, pr)
|
||||
let ret
|
||||
|
||||
if (isX(M)) {
|
||||
ret = ''
|
||||
} else if (isX(m)) {
|
||||
ret = `>=${M}.0.0 <${+M + 1}.0.0-0`
|
||||
} else if (isX(p)) {
|
||||
// ~1.2 == >=1.2.0 <1.3.0-0
|
||||
ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`
|
||||
} else if (pr) {
|
||||
debug('replaceTilde pr', pr)
|
||||
ret = `>=${M}.${m}.${p}-${pr
|
||||
} <${M}.${+m + 1}.0-0`
|
||||
} else {
|
||||
// ~1.2.3 == >=1.2.3 <1.3.0-0
|
||||
ret = `>=${M}.${m}.${p
|
||||
} <${M}.${+m + 1}.0-0`
|
||||
}
|
||||
|
||||
debug('tilde return', ret)
|
||||
return ret
|
||||
})
|
||||
}
|
||||
|
||||
// ^ --> * (any, kinda silly)
|
||||
// ^2, ^2.x, ^2.x.x --> >=2.0.0 <3.0.0-0
|
||||
// ^2.0, ^2.0.x --> >=2.0.0 <3.0.0-0
|
||||
// ^1.2, ^1.2.x --> >=1.2.0 <2.0.0-0
|
||||
// ^1.2.3 --> >=1.2.3 <2.0.0-0
|
||||
// ^1.2.0 --> >=1.2.0 <2.0.0-0
|
||||
const replaceCarets = (comp, options) =>
|
||||
comp.trim().split(/\s+/).map((comp) => {
|
||||
return replaceCaret(comp, options)
|
||||
}).join(' ')
|
||||
|
||||
const replaceCaret = (comp, options) => {
|
||||
debug('caret', comp, options)
|
||||
const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET]
|
||||
const z = options.includePrerelease ? '-0' : ''
|
||||
return comp.replace(r, (_, M, m, p, pr) => {
|
||||
debug('caret', comp, _, M, m, p, pr)
|
||||
let ret
|
||||
|
||||
if (isX(M)) {
|
||||
ret = ''
|
||||
} else if (isX(m)) {
|
||||
ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`
|
||||
} else if (isX(p)) {
|
||||
if (M === '0') {
|
||||
ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`
|
||||
} else {
|
||||
ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`
|
||||
}
|
||||
} else if (pr) {
|
||||
debug('replaceCaret pr', pr)
|
||||
if (M === '0') {
|
||||
if (m === '0') {
|
||||
ret = `>=${M}.${m}.${p}-${pr
|
||||
} <${M}.${m}.${+p + 1}-0`
|
||||
} else {
|
||||
ret = `>=${M}.${m}.${p}-${pr
|
||||
} <${M}.${+m + 1}.0-0`
|
||||
}
|
||||
} else {
|
||||
ret = `>=${M}.${m}.${p}-${pr
|
||||
} <${+M + 1}.0.0-0`
|
||||
}
|
||||
} else {
|
||||
debug('no pr')
|
||||
if (M === '0') {
|
||||
if (m === '0') {
|
||||
ret = `>=${M}.${m}.${p
|
||||
}${z} <${M}.${m}.${+p + 1}-0`
|
||||
} else {
|
||||
ret = `>=${M}.${m}.${p
|
||||
}${z} <${M}.${+m + 1}.0-0`
|
||||
}
|
||||
} else {
|
||||
ret = `>=${M}.${m}.${p
|
||||
} <${+M + 1}.0.0-0`
|
||||
}
|
||||
}
|
||||
|
||||
debug('caret return', ret)
|
||||
return ret
|
||||
})
|
||||
}
|
||||
|
||||
const replaceXRanges = (comp, options) => {
|
||||
debug('replaceXRanges', comp, options)
|
||||
return comp.split(/\s+/).map((comp) => {
|
||||
return replaceXRange(comp, options)
|
||||
}).join(' ')
|
||||
}
|
||||
|
||||
const replaceXRange = (comp, options) => {
|
||||
comp = comp.trim()
|
||||
const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE]
|
||||
return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
|
||||
debug('xRange', comp, ret, gtlt, M, m, p, pr)
|
||||
const xM = isX(M)
|
||||
const xm = xM || isX(m)
|
||||
const xp = xm || isX(p)
|
||||
const anyX = xp
|
||||
|
||||
if (gtlt === '=' && anyX) {
|
||||
gtlt = ''
|
||||
}
|
||||
|
||||
// if we're including prereleases in the match, then we need
|
||||
// to fix this to -0, the lowest possible prerelease value
|
||||
pr = options.includePrerelease ? '-0' : ''
|
||||
|
||||
if (xM) {
|
||||
if (gtlt === '>' || gtlt === '<') {
|
||||
// nothing is allowed
|
||||
ret = '<0.0.0-0'
|
||||
} else {
|
||||
// nothing is forbidden
|
||||
ret = '*'
|
||||
}
|
||||
} else if (gtlt && anyX) {
|
||||
// we know patch is an x, because we have any x at all.
|
||||
// replace X with 0
|
||||
if (xm) {
|
||||
m = 0
|
||||
}
|
||||
p = 0
|
||||
|
||||
if (gtlt === '>') {
|
||||
// >1 => >=2.0.0
|
||||
// >1.2 => >=1.3.0
|
||||
gtlt = '>='
|
||||
if (xm) {
|
||||
M = +M + 1
|
||||
m = 0
|
||||
p = 0
|
||||
} else {
|
||||
m = +m + 1
|
||||
p = 0
|
||||
}
|
||||
} else if (gtlt === '<=') {
|
||||
// <=0.7.x is actually <0.8.0, since any 0.7.x should
|
||||
// pass. Similarly, <=7.x is actually <8.0.0, etc.
|
||||
gtlt = '<'
|
||||
if (xm) {
|
||||
M = +M + 1
|
||||
} else {
|
||||
m = +m + 1
|
||||
}
|
||||
}
|
||||
|
||||
if (gtlt === '<')
|
||||
pr = '-0'
|
||||
|
||||
ret = `${gtlt + M}.${m}.${p}${pr}`
|
||||
} else if (xm) {
|
||||
ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`
|
||||
} else if (xp) {
|
||||
ret = `>=${M}.${m}.0${pr
|
||||
} <${M}.${+m + 1}.0-0`
|
||||
}
|
||||
|
||||
debug('xRange return', ret)
|
||||
|
||||
return ret
|
||||
})
|
||||
}
|
||||
|
||||
// Because * is AND-ed with everything else in the comparator,
|
||||
// and '' means "any version", just remove the *s entirely.
|
||||
const replaceStars = (comp, options) => {
|
||||
debug('replaceStars', comp, options)
|
||||
// Looseness is ignored here. star is always as loose as it gets!
|
||||
return comp.trim().replace(re[t.STAR], '')
|
||||
}
|
||||
|
||||
const replaceGTE0 = (comp, options) => {
|
||||
debug('replaceGTE0', comp, options)
|
||||
return comp.trim()
|
||||
.replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
|
||||
}
|
||||
|
||||
// This function is passed to string.replace(re[t.HYPHENRANGE])
|
||||
// M, m, patch, prerelease, build
|
||||
// 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
|
||||
// 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
|
||||
// 1.2 - 3.4 => >=1.2.0 <3.5.0-0
|
||||
const hyphenReplace = incPr => ($0,
|
||||
from, fM, fm, fp, fpr, fb,
|
||||
to, tM, tm, tp, tpr, tb) => {
|
||||
if (isX(fM)) {
|
||||
from = ''
|
||||
} else if (isX(fm)) {
|
||||
from = `>=${fM}.0.0${incPr ? '-0' : ''}`
|
||||
} else if (isX(fp)) {
|
||||
from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`
|
||||
} else if (fpr) {
|
||||
from = `>=${from}`
|
||||
} else {
|
||||
from = `>=${from}${incPr ? '-0' : ''}`
|
||||
}
|
||||
|
||||
if (isX(tM)) {
|
||||
to = ''
|
||||
} else if (isX(tm)) {
|
||||
to = `<${+tM + 1}.0.0-0`
|
||||
} else if (isX(tp)) {
|
||||
to = `<${tM}.${+tm + 1}.0-0`
|
||||
} else if (tpr) {
|
||||
to = `<=${tM}.${tm}.${tp}-${tpr}`
|
||||
} else if (incPr) {
|
||||
to = `<${tM}.${tm}.${+tp + 1}-0`
|
||||
} else {
|
||||
to = `<=${to}`
|
||||
}
|
||||
|
||||
return (`${from} ${to}`).trim()
|
||||
}
|
||||
|
||||
const testSet = (set, version, options) => {
|
||||
for (let i = 0; i < set.length; i++) {
|
||||
if (!set[i].test(version)) {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
if (version.prerelease.length && !options.includePrerelease) {
|
||||
// Find the set of versions that are allowed to have prereleases
|
||||
// For example, ^1.2.3-pr.1 desugars to >=1.2.3-pr.1 <2.0.0
|
||||
// That should allow `1.2.3-pr.2` to pass.
|
||||
// However, `1.2.4-alpha.notready` should NOT be allowed,
|
||||
// even though it's within the range set by the comparators.
|
||||
for (let i = 0; i < set.length; i++) {
|
||||
debug(set[i].semver)
|
||||
if (set[i].semver === Comparator.ANY) {
|
||||
continue
|
||||
}
|
||||
|
||||
if (set[i].semver.prerelease.length > 0) {
|
||||
const allowed = set[i].semver
|
||||
if (allowed.major === version.major &&
|
||||
allowed.minor === version.minor &&
|
||||
allowed.patch === version.patch) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Version has a -pre, but it's not one of the ones we like.
|
||||
return false
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
287
node_modules/jest-snapshot/node_modules/semver/classes/semver.js
generated
vendored
Normal file
287
node_modules/jest-snapshot/node_modules/semver/classes/semver.js
generated
vendored
Normal file
@ -0,0 +1,287 @@
|
||||
const debug = require('../internal/debug')
|
||||
const { MAX_LENGTH, MAX_SAFE_INTEGER } = require('../internal/constants')
|
||||
const { re, t } = require('../internal/re')
|
||||
|
||||
const parseOptions = require('../internal/parse-options')
|
||||
const { compareIdentifiers } = require('../internal/identifiers')
|
||||
class SemVer {
|
||||
constructor (version, options) {
|
||||
options = parseOptions(options)
|
||||
|
||||
if (version instanceof SemVer) {
|
||||
if (version.loose === !!options.loose &&
|
||||
version.includePrerelease === !!options.includePrerelease) {
|
||||
return version
|
||||
} else {
|
||||
version = version.version
|
||||
}
|
||||
} else if (typeof version !== 'string') {
|
||||
throw new TypeError(`Invalid Version: ${version}`)
|
||||
}
|
||||
|
||||
if (version.length > MAX_LENGTH) {
|
||||
throw new TypeError(
|
||||
`version is longer than ${MAX_LENGTH} characters`
|
||||
)
|
||||
}
|
||||
|
||||
debug('SemVer', version, options)
|
||||
this.options = options
|
||||
this.loose = !!options.loose
|
||||
// this isn't actually relevant for versions, but keep it so that we
|
||||
// don't run into trouble passing this.options around.
|
||||
this.includePrerelease = !!options.includePrerelease
|
||||
|
||||
const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL])
|
||||
|
||||
if (!m) {
|
||||
throw new TypeError(`Invalid Version: ${version}`)
|
||||
}
|
||||
|
||||
this.raw = version
|
||||
|
||||
// these are actually numbers
|
||||
this.major = +m[1]
|
||||
this.minor = +m[2]
|
||||
this.patch = +m[3]
|
||||
|
||||
if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
|
||||
throw new TypeError('Invalid major version')
|
||||
}
|
||||
|
||||
if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
|
||||
throw new TypeError('Invalid minor version')
|
||||
}
|
||||
|
||||
if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
|
||||
throw new TypeError('Invalid patch version')
|
||||
}
|
||||
|
||||
// numberify any prerelease numeric ids
|
||||
if (!m[4]) {
|
||||
this.prerelease = []
|
||||
} else {
|
||||
this.prerelease = m[4].split('.').map((id) => {
|
||||
if (/^[0-9]+$/.test(id)) {
|
||||
const num = +id
|
||||
if (num >= 0 && num < MAX_SAFE_INTEGER) {
|
||||
return num
|
||||
}
|
||||
}
|
||||
return id
|
||||
})
|
||||
}
|
||||
|
||||
this.build = m[5] ? m[5].split('.') : []
|
||||
this.format()
|
||||
}
|
||||
|
||||
format () {
|
||||
this.version = `${this.major}.${this.minor}.${this.patch}`
|
||||
if (this.prerelease.length) {
|
||||
this.version += `-${this.prerelease.join('.')}`
|
||||
}
|
||||
return this.version
|
||||
}
|
||||
|
||||
toString () {
|
||||
return this.version
|
||||
}
|
||||
|
||||
compare (other) {
|
||||
debug('SemVer.compare', this.version, this.options, other)
|
||||
if (!(other instanceof SemVer)) {
|
||||
if (typeof other === 'string' && other === this.version) {
|
||||
return 0
|
||||
}
|
||||
other = new SemVer(other, this.options)
|
||||
}
|
||||
|
||||
if (other.version === this.version) {
|
||||
return 0
|
||||
}
|
||||
|
||||
return this.compareMain(other) || this.comparePre(other)
|
||||
}
|
||||
|
||||
compareMain (other) {
|
||||
if (!(other instanceof SemVer)) {
|
||||
other = new SemVer(other, this.options)
|
||||
}
|
||||
|
||||
return (
|
||||
compareIdentifiers(this.major, other.major) ||
|
||||
compareIdentifiers(this.minor, other.minor) ||
|
||||
compareIdentifiers(this.patch, other.patch)
|
||||
)
|
||||
}
|
||||
|
||||
comparePre (other) {
|
||||
if (!(other instanceof SemVer)) {
|
||||
other = new SemVer(other, this.options)
|
||||
}
|
||||
|
||||
// NOT having a prerelease is > having one
|
||||
if (this.prerelease.length && !other.prerelease.length) {
|
||||
return -1
|
||||
} else if (!this.prerelease.length && other.prerelease.length) {
|
||||
return 1
|
||||
} else if (!this.prerelease.length && !other.prerelease.length) {
|
||||
return 0
|
||||
}
|
||||
|
||||
let i = 0
|
||||
do {
|
||||
const a = this.prerelease[i]
|
||||
const b = other.prerelease[i]
|
||||
debug('prerelease compare', i, a, b)
|
||||
if (a === undefined && b === undefined) {
|
||||
return 0
|
||||
} else if (b === undefined) {
|
||||
return 1
|
||||
} else if (a === undefined) {
|
||||
return -1
|
||||
} else if (a === b) {
|
||||
continue
|
||||
} else {
|
||||
return compareIdentifiers(a, b)
|
||||
}
|
||||
} while (++i)
|
||||
}
|
||||
|
||||
compareBuild (other) {
|
||||
if (!(other instanceof SemVer)) {
|
||||
other = new SemVer(other, this.options)
|
||||
}
|
||||
|
||||
let i = 0
|
||||
do {
|
||||
const a = this.build[i]
|
||||
const b = other.build[i]
|
||||
debug('prerelease compare', i, a, b)
|
||||
if (a === undefined && b === undefined) {
|
||||
return 0
|
||||
} else if (b === undefined) {
|
||||
return 1
|
||||
} else if (a === undefined) {
|
||||
return -1
|
||||
} else if (a === b) {
|
||||
continue
|
||||
} else {
|
||||
return compareIdentifiers(a, b)
|
||||
}
|
||||
} while (++i)
|
||||
}
|
||||
|
||||
// preminor will bump the version up to the next minor release, and immediately
|
||||
// down to pre-release. premajor and prepatch work the same way.
|
||||
inc (release, identifier) {
|
||||
switch (release) {
|
||||
case 'premajor':
|
||||
this.prerelease.length = 0
|
||||
this.patch = 0
|
||||
this.minor = 0
|
||||
this.major++
|
||||
this.inc('pre', identifier)
|
||||
break
|
||||
case 'preminor':
|
||||
this.prerelease.length = 0
|
||||
this.patch = 0
|
||||
this.minor++
|
||||
this.inc('pre', identifier)
|
||||
break
|
||||
case 'prepatch':
|
||||
// If this is already a prerelease, it will bump to the next version
|
||||
// drop any prereleases that might already exist, since they are not
|
||||
// relevant at this point.
|
||||
this.prerelease.length = 0
|
||||
this.inc('patch', identifier)
|
||||
this.inc('pre', identifier)
|
||||
break
|
||||
// If the input is a non-prerelease version, this acts the same as
|
||||
// prepatch.
|
||||
case 'prerelease':
|
||||
if (this.prerelease.length === 0) {
|
||||
this.inc('patch', identifier)
|
||||
}
|
||||
this.inc('pre', identifier)
|
||||
break
|
||||
|
||||
case 'major':
|
||||
// If this is a pre-major version, bump up to the same major version.
|
||||
// Otherwise increment major.
|
||||
// 1.0.0-5 bumps to 1.0.0
|
||||
// 1.1.0 bumps to 2.0.0
|
||||
if (
|
||||
this.minor !== 0 ||
|
||||
this.patch !== 0 ||
|
||||
this.prerelease.length === 0
|
||||
) {
|
||||
this.major++
|
||||
}
|
||||
this.minor = 0
|
||||
this.patch = 0
|
||||
this.prerelease = []
|
||||
break
|
||||
case 'minor':
|
||||
// If this is a pre-minor version, bump up to the same minor version.
|
||||
// Otherwise increment minor.
|
||||
// 1.2.0-5 bumps to 1.2.0
|
||||
// 1.2.1 bumps to 1.3.0
|
||||
if (this.patch !== 0 || this.prerelease.length === 0) {
|
||||
this.minor++
|
||||
}
|
||||
this.patch = 0
|
||||
this.prerelease = []
|
||||
break
|
||||
case 'patch':
|
||||
// If this is not a pre-release version, it will increment the patch.
|
||||
// If it is a pre-release it will bump up to the same patch version.
|
||||
// 1.2.0-5 patches to 1.2.0
|
||||
// 1.2.0 patches to 1.2.1
|
||||
if (this.prerelease.length === 0) {
|
||||
this.patch++
|
||||
}
|
||||
this.prerelease = []
|
||||
break
|
||||
// This probably shouldn't be used publicly.
|
||||
// 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
|
||||
case 'pre':
|
||||
if (this.prerelease.length === 0) {
|
||||
this.prerelease = [0]
|
||||
} else {
|
||||
let i = this.prerelease.length
|
||||
while (--i >= 0) {
|
||||
if (typeof this.prerelease[i] === 'number') {
|
||||
this.prerelease[i]++
|
||||
i = -2
|
||||
}
|
||||
}
|
||||
if (i === -1) {
|
||||
// didn't increment anything
|
||||
this.prerelease.push(0)
|
||||
}
|
||||
}
|
||||
if (identifier) {
|
||||
// 1.2.0-beta.1 bumps to 1.2.0-beta.2,
|
||||
// 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
|
||||
if (this.prerelease[0] === identifier) {
|
||||
if (isNaN(this.prerelease[1])) {
|
||||
this.prerelease = [identifier, 0]
|
||||
}
|
||||
} else {
|
||||
this.prerelease = [identifier, 0]
|
||||
}
|
||||
}
|
||||
break
|
||||
|
||||
default:
|
||||
throw new Error(`invalid increment argument: ${release}`)
|
||||
}
|
||||
this.format()
|
||||
this.raw = this.version
|
||||
return this
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = SemVer
|
6
node_modules/jest-snapshot/node_modules/semver/functions/clean.js
generated
vendored
Normal file
6
node_modules/jest-snapshot/node_modules/semver/functions/clean.js
generated
vendored
Normal file
@ -0,0 +1,6 @@
|
||||
const parse = require('./parse')
|
||||
const clean = (version, options) => {
|
||||
const s = parse(version.trim().replace(/^[=v]+/, ''), options)
|
||||
return s ? s.version : null
|
||||
}
|
||||
module.exports = clean
|
48
node_modules/jest-snapshot/node_modules/semver/functions/cmp.js
generated
vendored
Normal file
48
node_modules/jest-snapshot/node_modules/semver/functions/cmp.js
generated
vendored
Normal file
@ -0,0 +1,48 @@
|
||||
const eq = require('./eq')
|
||||
const neq = require('./neq')
|
||||
const gt = require('./gt')
|
||||
const gte = require('./gte')
|
||||
const lt = require('./lt')
|
||||
const lte = require('./lte')
|
||||
|
||||
const cmp = (a, op, b, loose) => {
|
||||
switch (op) {
|
||||
case '===':
|
||||
if (typeof a === 'object')
|
||||
a = a.version
|
||||
if (typeof b === 'object')
|
||||
b = b.version
|
||||
return a === b
|
||||
|
||||
case '!==':
|
||||
if (typeof a === 'object')
|
||||
a = a.version
|
||||
if (typeof b === 'object')
|
||||
b = b.version
|
||||
return a !== b
|
||||
|
||||
case '':
|
||||
case '=':
|
||||
case '==':
|
||||
return eq(a, b, loose)
|
||||
|
||||
case '!=':
|
||||
return neq(a, b, loose)
|
||||
|
||||
case '>':
|
||||
return gt(a, b, loose)
|
||||
|
||||
case '>=':
|
||||
return gte(a, b, loose)
|
||||
|
||||
case '<':
|
||||
return lt(a, b, loose)
|
||||
|
||||
case '<=':
|
||||
return lte(a, b, loose)
|
||||
|
||||
default:
|
||||
throw new TypeError(`Invalid operator: ${op}`)
|
||||
}
|
||||
}
|
||||
module.exports = cmp
|
51
node_modules/jest-snapshot/node_modules/semver/functions/coerce.js
generated
vendored
Normal file
51
node_modules/jest-snapshot/node_modules/semver/functions/coerce.js
generated
vendored
Normal file
@ -0,0 +1,51 @@
|
||||
const SemVer = require('../classes/semver')
|
||||
const parse = require('./parse')
|
||||
const {re, t} = require('../internal/re')
|
||||
|
||||
const coerce = (version, options) => {
|
||||
if (version instanceof SemVer) {
|
||||
return version
|
||||
}
|
||||
|
||||
if (typeof version === 'number') {
|
||||
version = String(version)
|
||||
}
|
||||
|
||||
if (typeof version !== 'string') {
|
||||
return null
|
||||
}
|
||||
|
||||
options = options || {}
|
||||
|
||||
let match = null
|
||||
if (!options.rtl) {
|
||||
match = version.match(re[t.COERCE])
|
||||
} else {
|
||||
// Find the right-most coercible string that does not share
|
||||
// a terminus with a more left-ward coercible string.
|
||||
// Eg, '1.2.3.4' wants to coerce '2.3.4', not '3.4' or '4'
|
||||
//
|
||||
// Walk through the string checking with a /g regexp
|
||||
// Manually set the index so as to pick up overlapping matches.
|
||||
// Stop when we get a match that ends at the string end, since no
|
||||
// coercible string can be more right-ward without the same terminus.
|
||||
let next
|
||||
while ((next = re[t.COERCERTL].exec(version)) &&
|
||||
(!match || match.index + match[0].length !== version.length)
|
||||
) {
|
||||
if (!match ||
|
||||
next.index + next[0].length !== match.index + match[0].length) {
|
||||
match = next
|
||||
}
|
||||
re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length
|
||||
}
|
||||
// leave it in a clean state
|
||||
re[t.COERCERTL].lastIndex = -1
|
||||
}
|
||||
|
||||
if (match === null)
|
||||
return null
|
||||
|
||||
return parse(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
|
||||
}
|
||||
module.exports = coerce
|
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user