5335 lines
146 KiB
JavaScript
5335 lines
146 KiB
JavaScript
import { createRequire as __prettierCreateRequire } from 'module';
|
|
import { fileURLToPath as __prettierFileUrlToPath } from 'url';
|
|
import { dirname as __prettierDirname } from 'path';
|
|
const require = __prettierCreateRequire(import.meta.url);
|
|
const __filename = __prettierFileUrlToPath(import.meta.url);
|
|
const __dirname = __prettierDirname(__filename);
|
|
|
|
var __create = Object.create;
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
var __getProtoOf = Object.getPrototypeOf;
|
|
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
|
var __typeError = (msg) => {
|
|
throw TypeError(msg);
|
|
};
|
|
var __require = /* @__PURE__ */ ((x) =>
|
|
typeof require !== 'undefined' ? require
|
|
: typeof Proxy !== 'undefined' ?
|
|
new Proxy(x, {
|
|
get: (a, b) => (typeof require !== 'undefined' ? require : a)[b],
|
|
})
|
|
: x)(function (x) {
|
|
if (typeof require !== 'undefined') return require.apply(this, arguments);
|
|
throw Error('Dynamic require of "' + x + '" is not supported');
|
|
});
|
|
var __commonJS = (cb, mod) =>
|
|
function __require2() {
|
|
return (
|
|
mod ||
|
|
(0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod),
|
|
mod.exports
|
|
);
|
|
};
|
|
var __copyProps = (to, from, except, desc) => {
|
|
if ((from && typeof from === 'object') || typeof from === 'function') {
|
|
for (let key of __getOwnPropNames(from))
|
|
if (!__hasOwnProp.call(to, key) && key !== except)
|
|
__defProp(to, key, {
|
|
get: () => from[key],
|
|
enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
|
|
});
|
|
}
|
|
return to;
|
|
};
|
|
var __toESM = (mod, isNodeMode, target) => (
|
|
(target = mod != null ? __create(__getProtoOf(mod)) : {}),
|
|
__copyProps(
|
|
// If the importer is in node compatibility mode or this is not an ESM
|
|
// file that has been converted to a CommonJS file using a Babel-
|
|
// compatible transform (i.e. "__esModule" has not been set), then set
|
|
// "default" to the CommonJS "module.exports" for node compatibility.
|
|
isNodeMode || !mod || !mod.__esModule ?
|
|
__defProp(target, 'default', { value: mod, enumerable: true })
|
|
: target,
|
|
mod
|
|
)
|
|
);
|
|
var __accessCheck = (obj, member, msg) =>
|
|
member.has(obj) || __typeError('Cannot ' + msg);
|
|
var __privateGet = (obj, member, getter) => (
|
|
__accessCheck(obj, member, 'read from private field'),
|
|
getter ? getter.call(obj) : member.get(obj)
|
|
);
|
|
var __privateAdd = (obj, member, value) =>
|
|
member.has(obj) ?
|
|
__typeError('Cannot add the same private member more than once')
|
|
: member instanceof WeakSet ? member.add(obj)
|
|
: member.set(obj, value);
|
|
var __privateSet = (obj, member, value, setter) => (
|
|
__accessCheck(obj, member, 'write to private field'),
|
|
setter ? setter.call(obj, value) : member.set(obj, value),
|
|
value
|
|
);
|
|
|
|
// node_modules/dashify/index.js
|
|
var require_dashify = __commonJS({
|
|
'node_modules/dashify/index.js'(exports, module) {
|
|
'use strict';
|
|
module.exports = (str, options) => {
|
|
if (typeof str !== 'string') throw new TypeError('expected a string');
|
|
return str
|
|
.trim()
|
|
.replace(/([a-z])([A-Z])/g, '$1-$2')
|
|
.replace(/\W/g, (m) => (/[À-ž]/.test(m) ? m : '-'))
|
|
.replace(/^-+|-+$/g, '')
|
|
.replace(/-{2,}/g, (m) => (options && options.condense ? '-' : m))
|
|
.toLowerCase();
|
|
};
|
|
},
|
|
});
|
|
|
|
// node_modules/minimist/index.js
|
|
var require_minimist = __commonJS({
|
|
'node_modules/minimist/index.js'(exports, module) {
|
|
'use strict';
|
|
function hasKey(obj, keys2) {
|
|
var o = obj;
|
|
keys2.slice(0, -1).forEach(function (key2) {
|
|
o = o[key2] || {};
|
|
});
|
|
var key = keys2[keys2.length - 1];
|
|
return key in o;
|
|
}
|
|
function isNumber(x) {
|
|
if (typeof x === 'number') {
|
|
return true;
|
|
}
|
|
if (/^0x[0-9a-f]+$/i.test(x)) {
|
|
return true;
|
|
}
|
|
return /^[-+]?(?:\d+(?:\.\d*)?|\.\d+)(e[-+]?\d+)?$/.test(x);
|
|
}
|
|
function isConstructorOrProto(obj, key) {
|
|
return (
|
|
(key === 'constructor' && typeof obj[key] === 'function') ||
|
|
key === '__proto__'
|
|
);
|
|
}
|
|
module.exports = function (args, opts) {
|
|
if (!opts) {
|
|
opts = {};
|
|
}
|
|
var flags = {
|
|
bools: {},
|
|
strings: {},
|
|
unknownFn: null,
|
|
};
|
|
if (typeof opts.unknown === 'function') {
|
|
flags.unknownFn = opts.unknown;
|
|
}
|
|
if (typeof opts.boolean === 'boolean' && opts.boolean) {
|
|
flags.allBools = true;
|
|
} else {
|
|
[]
|
|
.concat(opts.boolean)
|
|
.filter(Boolean)
|
|
.forEach(function (key2) {
|
|
flags.bools[key2] = true;
|
|
});
|
|
}
|
|
var aliases = {};
|
|
function aliasIsBoolean(key2) {
|
|
return aliases[key2].some(function (x) {
|
|
return flags.bools[x];
|
|
});
|
|
}
|
|
Object.keys(opts.alias || {}).forEach(function (key2) {
|
|
aliases[key2] = [].concat(opts.alias[key2]);
|
|
aliases[key2].forEach(function (x) {
|
|
aliases[x] = [key2].concat(
|
|
aliases[key2].filter(function (y) {
|
|
return x !== y;
|
|
})
|
|
);
|
|
});
|
|
});
|
|
[]
|
|
.concat(opts.string)
|
|
.filter(Boolean)
|
|
.forEach(function (key2) {
|
|
flags.strings[key2] = true;
|
|
if (aliases[key2]) {
|
|
[].concat(aliases[key2]).forEach(function (k) {
|
|
flags.strings[k] = true;
|
|
});
|
|
}
|
|
});
|
|
var defaults = opts.default || {};
|
|
var argv = { _: [] };
|
|
function argDefined(key2, arg2) {
|
|
return (
|
|
(flags.allBools && /^--[^=]+$/.test(arg2)) ||
|
|
flags.strings[key2] ||
|
|
flags.bools[key2] ||
|
|
aliases[key2]
|
|
);
|
|
}
|
|
function setKey(obj, keys2, value2) {
|
|
var o = obj;
|
|
for (var i2 = 0; i2 < keys2.length - 1; i2++) {
|
|
var key2 = keys2[i2];
|
|
if (isConstructorOrProto(o, key2)) {
|
|
return;
|
|
}
|
|
if (o[key2] === void 0) {
|
|
o[key2] = {};
|
|
}
|
|
if (
|
|
o[key2] === Object.prototype ||
|
|
o[key2] === Number.prototype ||
|
|
o[key2] === String.prototype
|
|
) {
|
|
o[key2] = {};
|
|
}
|
|
if (o[key2] === Array.prototype) {
|
|
o[key2] = [];
|
|
}
|
|
o = o[key2];
|
|
}
|
|
var lastKey = keys2[keys2.length - 1];
|
|
if (isConstructorOrProto(o, lastKey)) {
|
|
return;
|
|
}
|
|
if (
|
|
o === Object.prototype ||
|
|
o === Number.prototype ||
|
|
o === String.prototype
|
|
) {
|
|
o = {};
|
|
}
|
|
if (o === Array.prototype) {
|
|
o = [];
|
|
}
|
|
if (
|
|
o[lastKey] === void 0 ||
|
|
flags.bools[lastKey] ||
|
|
typeof o[lastKey] === 'boolean'
|
|
) {
|
|
o[lastKey] = value2;
|
|
} else if (Array.isArray(o[lastKey])) {
|
|
o[lastKey].push(value2);
|
|
} else {
|
|
o[lastKey] = [o[lastKey], value2];
|
|
}
|
|
}
|
|
function setArg(key2, val, arg2) {
|
|
if (arg2 && flags.unknownFn && !argDefined(key2, arg2)) {
|
|
if (flags.unknownFn(arg2) === false) {
|
|
return;
|
|
}
|
|
}
|
|
var value2 = !flags.strings[key2] && isNumber(val) ? Number(val) : val;
|
|
setKey(argv, key2.split('.'), value2);
|
|
(aliases[key2] || []).forEach(function (x) {
|
|
setKey(argv, x.split('.'), value2);
|
|
});
|
|
}
|
|
Object.keys(flags.bools).forEach(function (key2) {
|
|
setArg(key2, defaults[key2] === void 0 ? false : defaults[key2]);
|
|
});
|
|
var notFlags = [];
|
|
if (args.indexOf('--') !== -1) {
|
|
notFlags = args.slice(args.indexOf('--') + 1);
|
|
args = args.slice(0, args.indexOf('--'));
|
|
}
|
|
for (var i = 0; i < args.length; i++) {
|
|
var arg = args[i];
|
|
var key;
|
|
var next;
|
|
if (/^--.+=/.test(arg)) {
|
|
var m = arg.match(/^--([^=]+)=([\s\S]*)$/);
|
|
key = m[1];
|
|
var value = m[2];
|
|
if (flags.bools[key]) {
|
|
value = value !== 'false';
|
|
}
|
|
setArg(key, value, arg);
|
|
} else if (/^--no-.+/.test(arg)) {
|
|
key = arg.match(/^--no-(.+)/)[1];
|
|
setArg(key, false, arg);
|
|
} else if (/^--.+/.test(arg)) {
|
|
key = arg.match(/^--(.+)/)[1];
|
|
next = args[i + 1];
|
|
if (
|
|
next !== void 0 &&
|
|
!/^(-|--)[^-]/.test(next) &&
|
|
!flags.bools[key] &&
|
|
!flags.allBools &&
|
|
(aliases[key] ? !aliasIsBoolean(key) : true)
|
|
) {
|
|
setArg(key, next, arg);
|
|
i += 1;
|
|
} else if (/^(true|false)$/.test(next)) {
|
|
setArg(key, next === 'true', arg);
|
|
i += 1;
|
|
} else {
|
|
setArg(key, flags.strings[key] ? '' : true, arg);
|
|
}
|
|
} else if (/^-[^-]+/.test(arg)) {
|
|
var letters = arg.slice(1, -1).split('');
|
|
var broken = false;
|
|
for (var j = 0; j < letters.length; j++) {
|
|
next = arg.slice(j + 2);
|
|
if (next === '-') {
|
|
setArg(letters[j], next, arg);
|
|
continue;
|
|
}
|
|
if (/[A-Za-z]/.test(letters[j]) && next[0] === '=') {
|
|
setArg(letters[j], next.slice(1), arg);
|
|
broken = true;
|
|
break;
|
|
}
|
|
if (
|
|
/[A-Za-z]/.test(letters[j]) &&
|
|
/-?\d+(\.\d*)?(e-?\d+)?$/.test(next)
|
|
) {
|
|
setArg(letters[j], next, arg);
|
|
broken = true;
|
|
break;
|
|
}
|
|
if (letters[j + 1] && letters[j + 1].match(/\W/)) {
|
|
setArg(letters[j], arg.slice(j + 2), arg);
|
|
broken = true;
|
|
break;
|
|
} else {
|
|
setArg(letters[j], flags.strings[letters[j]] ? '' : true, arg);
|
|
}
|
|
}
|
|
key = arg.slice(-1)[0];
|
|
if (!broken && key !== '-') {
|
|
if (
|
|
args[i + 1] &&
|
|
!/^(-|--)[^-]/.test(args[i + 1]) &&
|
|
!flags.bools[key] &&
|
|
(aliases[key] ? !aliasIsBoolean(key) : true)
|
|
) {
|
|
setArg(key, args[i + 1], arg);
|
|
i += 1;
|
|
} else if (args[i + 1] && /^(true|false)$/.test(args[i + 1])) {
|
|
setArg(key, args[i + 1] === 'true', arg);
|
|
i += 1;
|
|
} else {
|
|
setArg(key, flags.strings[key] ? '' : true, arg);
|
|
}
|
|
}
|
|
} else {
|
|
if (!flags.unknownFn || flags.unknownFn(arg) !== false) {
|
|
argv._.push(flags.strings._ || !isNumber(arg) ? arg : Number(arg));
|
|
}
|
|
if (opts.stopEarly) {
|
|
argv._.push.apply(argv._, args.slice(i + 1));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
Object.keys(defaults).forEach(function (k) {
|
|
if (!hasKey(argv, k.split('.'))) {
|
|
setKey(argv, k.split('.'), defaults[k]);
|
|
(aliases[k] || []).forEach(function (x) {
|
|
setKey(argv, x.split('.'), defaults[k]);
|
|
});
|
|
}
|
|
});
|
|
if (opts['--']) {
|
|
argv['--'] = notFlags.slice();
|
|
} else {
|
|
notFlags.forEach(function (k) {
|
|
argv._.push(k);
|
|
});
|
|
}
|
|
return argv;
|
|
};
|
|
},
|
|
});
|
|
|
|
// node_modules/fast-json-stable-stringify/index.js
|
|
var require_fast_json_stable_stringify = __commonJS({
|
|
'node_modules/fast-json-stable-stringify/index.js'(exports, module) {
|
|
'use strict';
|
|
module.exports = function (data, opts) {
|
|
if (!opts) opts = {};
|
|
if (typeof opts === 'function') opts = { cmp: opts };
|
|
var cycles = typeof opts.cycles === 'boolean' ? opts.cycles : false;
|
|
var cmp =
|
|
opts.cmp &&
|
|
/* @__PURE__ */ (function (f) {
|
|
return function (node) {
|
|
return function (a, b) {
|
|
var aobj = { key: a, value: node[a] };
|
|
var bobj = { key: b, value: node[b] };
|
|
return f(aobj, bobj);
|
|
};
|
|
};
|
|
})(opts.cmp);
|
|
var seen = [];
|
|
return (function stringify5(node) {
|
|
if (node && node.toJSON && typeof node.toJSON === 'function') {
|
|
node = node.toJSON();
|
|
}
|
|
if (node === void 0) return;
|
|
if (typeof node == 'number') return isFinite(node) ? '' + node : 'null';
|
|
if (typeof node !== 'object') return JSON.stringify(node);
|
|
var i, out;
|
|
if (Array.isArray(node)) {
|
|
out = '[';
|
|
for (i = 0; i < node.length; i++) {
|
|
if (i) out += ',';
|
|
out += stringify5(node[i]) || 'null';
|
|
}
|
|
return out + ']';
|
|
}
|
|
if (node === null) return 'null';
|
|
if (seen.indexOf(node) !== -1) {
|
|
if (cycles) return JSON.stringify('__cycle__');
|
|
throw new TypeError('Converting circular structure to JSON');
|
|
}
|
|
var seenIndex = seen.push(node) - 1;
|
|
var keys2 = Object.keys(node).sort(cmp && cmp(node));
|
|
out = '';
|
|
for (i = 0; i < keys2.length; i++) {
|
|
var key = keys2[i];
|
|
var value = stringify5(node[key]);
|
|
if (!value) continue;
|
|
if (out) out += ',';
|
|
out += JSON.stringify(key) + ':' + value;
|
|
}
|
|
seen.splice(seenIndex, 1);
|
|
return '{' + out + '}';
|
|
})(data);
|
|
};
|
|
},
|
|
});
|
|
|
|
// node_modules/common-path-prefix/index.js
|
|
var require_common_path_prefix = __commonJS({
|
|
'node_modules/common-path-prefix/index.js'(exports, module) {
|
|
'use strict';
|
|
var { sep: DEFAULT_SEPARATOR } = __require('path');
|
|
var determineSeparator = (paths) => {
|
|
for (const path12 of paths) {
|
|
const match = /(\/|\\)/.exec(path12);
|
|
if (match !== null) return match[0];
|
|
}
|
|
return DEFAULT_SEPARATOR;
|
|
};
|
|
module.exports = function commonPathPrefix2(
|
|
paths,
|
|
sep = determineSeparator(paths)
|
|
) {
|
|
const [first = '', ...remaining] = paths;
|
|
if (first === '' || remaining.length === 0) return '';
|
|
const parts = first.split(sep);
|
|
let endOfPrefix = parts.length;
|
|
for (const path12 of remaining) {
|
|
const compare = path12.split(sep);
|
|
for (let i = 0; i < endOfPrefix; i++) {
|
|
if (compare[i] !== parts[i]) {
|
|
endOfPrefix = i;
|
|
}
|
|
}
|
|
if (endOfPrefix === 0) return '';
|
|
}
|
|
const prefix = parts.slice(0, endOfPrefix).join(sep);
|
|
return prefix.endsWith(sep) ? prefix : prefix + sep;
|
|
};
|
|
},
|
|
});
|
|
|
|
// src/cli/index.js
|
|
import * as prettier2 from '../index.mjs';
|
|
|
|
// scripts/build/shims/at.js
|
|
var at = (isOptionalObject, object2, index) => {
|
|
if (isOptionalObject && (object2 === void 0 || object2 === null)) {
|
|
return;
|
|
}
|
|
if (Array.isArray(object2) || typeof object2 === 'string') {
|
|
return object2[index < 0 ? object2.length + index : index];
|
|
}
|
|
return object2.at(index);
|
|
};
|
|
var at_default = at;
|
|
|
|
// src/cli/options/get-context-options.js
|
|
var import_dashify = __toESM(require_dashify(), 1);
|
|
import { getSupportInfo } from '../index.mjs';
|
|
|
|
// src/cli/cli-options.evaluate.js
|
|
var cli_options_evaluate_default = {
|
|
cache: {
|
|
default: false,
|
|
description: 'Only format changed files. Cannot use with --stdin-filepath.',
|
|
type: 'boolean',
|
|
},
|
|
cacheLocation: {
|
|
description: 'Path to the cache file.',
|
|
type: 'path',
|
|
},
|
|
cacheStrategy: {
|
|
choices: [
|
|
{
|
|
description: 'Use the file metadata such as timestamps as cache keys',
|
|
value: 'metadata',
|
|
},
|
|
{
|
|
description: 'Use the file content as cache keys',
|
|
value: 'content',
|
|
},
|
|
],
|
|
description: 'Strategy for the cache to use for detecting changed files.',
|
|
type: 'choice',
|
|
},
|
|
check: {
|
|
alias: 'c',
|
|
category: 'Output',
|
|
description:
|
|
'Check if the given files are formatted, print a human-friendly summary\nmessage and paths to unformatted files (see also --list-different).',
|
|
type: 'boolean',
|
|
},
|
|
color: {
|
|
default: true,
|
|
description: 'Colorize error messages.',
|
|
oppositeDescription: 'Do not colorize error messages.',
|
|
type: 'boolean',
|
|
},
|
|
config: {
|
|
category: 'Config',
|
|
description:
|
|
'Path to a Prettier configuration file (.prettierrc, package.json, prettier.config.js).',
|
|
exception: (value) => value === false,
|
|
oppositeDescription: 'Do not look for a configuration file.',
|
|
type: 'path',
|
|
},
|
|
configPrecedence: {
|
|
category: 'Config',
|
|
choices: [
|
|
{
|
|
description: 'CLI options take precedence over config file',
|
|
value: 'cli-override',
|
|
},
|
|
{
|
|
description: 'Config file take precedence over CLI options',
|
|
value: 'file-override',
|
|
},
|
|
{
|
|
description:
|
|
'If a config file is found will evaluate it and ignore other CLI options.\nIf no config file is found CLI options will evaluate as normal.',
|
|
value: 'prefer-file',
|
|
},
|
|
],
|
|
default: 'cli-override',
|
|
description:
|
|
'Define in which order config files and CLI options should be evaluated.',
|
|
type: 'choice',
|
|
},
|
|
debugBenchmark: {
|
|
type: 'boolean',
|
|
},
|
|
debugCheck: {
|
|
type: 'boolean',
|
|
},
|
|
debugPrintAst: {
|
|
type: 'boolean',
|
|
},
|
|
debugPrintComments: {
|
|
type: 'boolean',
|
|
},
|
|
debugPrintDoc: {
|
|
type: 'boolean',
|
|
},
|
|
debugRepeat: {
|
|
default: 0,
|
|
type: 'int',
|
|
},
|
|
editorconfig: {
|
|
category: 'Config',
|
|
default: true,
|
|
description: 'Take .editorconfig into account when parsing configuration.',
|
|
oppositeDescription:
|
|
"Don't take .editorconfig into account when parsing configuration.",
|
|
type: 'boolean',
|
|
},
|
|
errorOnUnmatchedPattern: {
|
|
oppositeDescription: 'Prevent errors when pattern is unmatched.',
|
|
type: 'boolean',
|
|
},
|
|
fileInfo: {
|
|
description:
|
|
'Extract the following info (as JSON) for a given file path. Reported fields:\n* ignored (boolean) - true if file path is filtered by --ignore-path\n* inferredParser (string | null) - name of parser inferred from file path',
|
|
type: 'path',
|
|
},
|
|
findConfigPath: {
|
|
category: 'Config',
|
|
description:
|
|
'Find and print the path to a configuration file for the given input file.',
|
|
type: 'path',
|
|
},
|
|
help: {
|
|
alias: 'h',
|
|
description:
|
|
'Show CLI usage, or details about the given flag.\nExample: --help write',
|
|
exception: (value) => value === '',
|
|
type: 'flag',
|
|
},
|
|
ignorePath: {
|
|
array: true,
|
|
category: 'Config',
|
|
default: [
|
|
{
|
|
value: ['.gitignore', '.prettierignore'],
|
|
},
|
|
],
|
|
description:
|
|
'Path to a file with patterns describing files to ignore.\nMultiple values are accepted.',
|
|
type: 'path',
|
|
},
|
|
ignoreUnknown: {
|
|
alias: 'u',
|
|
description: 'Ignore unknown files.',
|
|
type: 'boolean',
|
|
},
|
|
listDifferent: {
|
|
alias: 'l',
|
|
category: 'Output',
|
|
description:
|
|
"Print the names of files that are different from Prettier's formatting (see also --check).",
|
|
type: 'boolean',
|
|
},
|
|
logLevel: {
|
|
choices: ['silent', 'error', 'warn', 'log', 'debug'],
|
|
default: 'log',
|
|
description: 'What level of logs to report.',
|
|
type: 'choice',
|
|
},
|
|
supportInfo: {
|
|
description: 'Print support information as JSON.',
|
|
type: 'boolean',
|
|
},
|
|
version: {
|
|
alias: 'v',
|
|
description: 'Print Prettier version.',
|
|
type: 'boolean',
|
|
},
|
|
withNodeModules: {
|
|
category: 'Config',
|
|
description: "Process files inside 'node_modules' directory.",
|
|
type: 'boolean',
|
|
},
|
|
write: {
|
|
alias: 'w',
|
|
category: 'Output',
|
|
description: 'Edit files in-place. (Beware!)',
|
|
type: 'boolean',
|
|
},
|
|
};
|
|
|
|
// src/cli/prettier-internal.js
|
|
import { __internal as sharedWithCli } from '../index.mjs';
|
|
var {
|
|
errors,
|
|
optionCategories,
|
|
createIsIgnoredFunction,
|
|
formatOptionsHiddenDefaults,
|
|
normalizeOptions,
|
|
getSupportInfoWithoutPlugins,
|
|
normalizeOptionSettings,
|
|
vnopts,
|
|
fastGlob,
|
|
createTwoFilesPatch,
|
|
mockable,
|
|
} = sharedWithCli;
|
|
|
|
// src/cli/options/get-context-options.js
|
|
var detailedCliOptions = normalizeOptionSettings(
|
|
cli_options_evaluate_default
|
|
).map((option) => normalizeDetailedOption(option));
|
|
function apiOptionToCliOption(apiOption) {
|
|
const cliOption = {
|
|
...apiOption,
|
|
description: apiOption.cliDescription ?? apiOption.description,
|
|
category: apiOption.cliCategory ?? optionCategories.CATEGORY_FORMAT,
|
|
forwardToApi: apiOption.name,
|
|
};
|
|
if (apiOption.deprecated) {
|
|
delete cliOption.forwardToApi;
|
|
delete cliOption.description;
|
|
delete cliOption.oppositeDescription;
|
|
cliOption.deprecated = true;
|
|
}
|
|
return normalizeDetailedOption(cliOption);
|
|
}
|
|
function normalizeDetailedOption(option) {
|
|
var _a;
|
|
return {
|
|
category: optionCategories.CATEGORY_OTHER,
|
|
...option,
|
|
name: option.cliName ?? (0, import_dashify.default)(option.name),
|
|
choices:
|
|
(_a = option.choices) == null ?
|
|
void 0
|
|
: _a.map((choice) => {
|
|
const newChoice = {
|
|
description: '',
|
|
deprecated: false,
|
|
...(typeof choice === 'object' ? choice : { value: choice }),
|
|
};
|
|
if (newChoice.value === true) {
|
|
newChoice.value = '';
|
|
}
|
|
return newChoice;
|
|
}),
|
|
};
|
|
}
|
|
function supportInfoToContextOptions({ options: supportOptions, languages }) {
|
|
const detailedOptions = [
|
|
...detailedCliOptions,
|
|
...supportOptions.map((apiOption) => apiOptionToCliOption(apiOption)),
|
|
];
|
|
return {
|
|
supportOptions,
|
|
languages,
|
|
detailedOptions,
|
|
};
|
|
}
|
|
async function getContextOptions(plugins) {
|
|
const supportInfo = await getSupportInfo({
|
|
showDeprecated: true,
|
|
plugins,
|
|
});
|
|
return supportInfoToContextOptions(supportInfo);
|
|
}
|
|
function getContextOptionsWithoutPlugins() {
|
|
const supportInfo = getSupportInfoWithoutPlugins();
|
|
return supportInfoToContextOptions(supportInfo);
|
|
}
|
|
|
|
// scripts/build/shims/string-replace-all.js
|
|
var stringReplaceAll = (isOptionalObject, original, pattern, replacement) => {
|
|
if (isOptionalObject && (original === void 0 || original === null)) {
|
|
return;
|
|
}
|
|
if (original.replaceAll) {
|
|
return original.replaceAll(pattern, replacement);
|
|
}
|
|
if (pattern.global) {
|
|
return original.replace(pattern, replacement);
|
|
}
|
|
return original.split(pattern).join(replacement);
|
|
};
|
|
var string_replace_all_default = stringReplaceAll;
|
|
|
|
// node_modules/camelcase/index.js
|
|
var UPPERCASE = /[\p{Lu}]/u;
|
|
var LOWERCASE = /[\p{Ll}]/u;
|
|
var LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
|
|
var IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
|
|
var SEPARATORS = /[_.\- ]+/;
|
|
var LEADING_SEPARATORS = new RegExp('^' + SEPARATORS.source);
|
|
var SEPARATORS_AND_IDENTIFIER = new RegExp(
|
|
SEPARATORS.source + IDENTIFIER.source,
|
|
'gu'
|
|
);
|
|
var NUMBERS_AND_IDENTIFIER = new RegExp('\\d+' + IDENTIFIER.source, 'gu');
|
|
var preserveCamelCase = (
|
|
string,
|
|
toLowerCase,
|
|
toUpperCase,
|
|
preserveConsecutiveUppercase2
|
|
) => {
|
|
let isLastCharLower = false;
|
|
let isLastCharUpper = false;
|
|
let isLastLastCharUpper = false;
|
|
let isLastLastCharPreserved = false;
|
|
for (let index = 0; index < string.length; index++) {
|
|
const character = string[index];
|
|
isLastLastCharPreserved = index > 2 ? string[index - 3] === '-' : true;
|
|
if (isLastCharLower && UPPERCASE.test(character)) {
|
|
string = string.slice(0, index) + '-' + string.slice(index);
|
|
isLastCharLower = false;
|
|
isLastLastCharUpper = isLastCharUpper;
|
|
isLastCharUpper = true;
|
|
index++;
|
|
} else if (
|
|
isLastCharUpper &&
|
|
isLastLastCharUpper &&
|
|
LOWERCASE.test(character) &&
|
|
(!isLastLastCharPreserved || preserveConsecutiveUppercase2)
|
|
) {
|
|
string = string.slice(0, index - 1) + '-' + string.slice(index - 1);
|
|
isLastLastCharUpper = isLastCharUpper;
|
|
isLastCharUpper = false;
|
|
isLastCharLower = true;
|
|
} else {
|
|
isLastCharLower =
|
|
toLowerCase(character) === character &&
|
|
toUpperCase(character) !== character;
|
|
isLastLastCharUpper = isLastCharUpper;
|
|
isLastCharUpper =
|
|
toUpperCase(character) === character &&
|
|
toLowerCase(character) !== character;
|
|
}
|
|
}
|
|
return string;
|
|
};
|
|
var preserveConsecutiveUppercase = (input, toLowerCase) => {
|
|
LEADING_CAPITAL.lastIndex = 0;
|
|
return string_replace_all_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
input,
|
|
LEADING_CAPITAL,
|
|
(match) => toLowerCase(match)
|
|
);
|
|
};
|
|
var postProcess = (input, toUpperCase) => {
|
|
SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
|
|
NUMBERS_AND_IDENTIFIER.lastIndex = 0;
|
|
return string_replace_all_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
string_replace_all_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
input,
|
|
NUMBERS_AND_IDENTIFIER,
|
|
(match, pattern, offset) =>
|
|
['_', '-'].includes(input.charAt(offset + match.length)) ? match : (
|
|
toUpperCase(match)
|
|
)
|
|
),
|
|
SEPARATORS_AND_IDENTIFIER,
|
|
(_2, identifier) => toUpperCase(identifier)
|
|
);
|
|
};
|
|
function camelCase(input, options) {
|
|
if (!(typeof input === 'string' || Array.isArray(input))) {
|
|
throw new TypeError('Expected the input to be `string | string[]`');
|
|
}
|
|
options = {
|
|
pascalCase: false,
|
|
preserveConsecutiveUppercase: false,
|
|
...options,
|
|
};
|
|
if (Array.isArray(input)) {
|
|
input = input
|
|
.map((x) => x.trim())
|
|
.filter((x) => x.length)
|
|
.join('-');
|
|
} else {
|
|
input = input.trim();
|
|
}
|
|
if (input.length === 0) {
|
|
return '';
|
|
}
|
|
const toLowerCase =
|
|
options.locale === false ?
|
|
(string) => string.toLowerCase()
|
|
: (string) => string.toLocaleLowerCase(options.locale);
|
|
const toUpperCase =
|
|
options.locale === false ?
|
|
(string) => string.toUpperCase()
|
|
: (string) => string.toLocaleUpperCase(options.locale);
|
|
if (input.length === 1) {
|
|
if (SEPARATORS.test(input)) {
|
|
return '';
|
|
}
|
|
return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
|
|
}
|
|
const hasUpperCase = input !== toLowerCase(input);
|
|
if (hasUpperCase) {
|
|
input = preserveCamelCase(
|
|
input,
|
|
toLowerCase,
|
|
toUpperCase,
|
|
options.preserveConsecutiveUppercase
|
|
);
|
|
}
|
|
input = input.replace(LEADING_SEPARATORS, '');
|
|
input =
|
|
options.preserveConsecutiveUppercase ?
|
|
preserveConsecutiveUppercase(input, toLowerCase)
|
|
: toLowerCase(input);
|
|
if (options.pascalCase) {
|
|
input = toUpperCase(input.charAt(0)) + input.slice(1);
|
|
}
|
|
return postProcess(input, toUpperCase);
|
|
}
|
|
|
|
// src/cli/utils.js
|
|
import fs from 'fs/promises';
|
|
import path from 'path';
|
|
|
|
// node_modules/sdbm/index.js
|
|
function sdbm(string) {
|
|
let hash2 = 0;
|
|
for (let i = 0; i < string.length; i++) {
|
|
hash2 = string.charCodeAt(i) + (hash2 << 6) + (hash2 << 16) - hash2;
|
|
}
|
|
return hash2 >>> 0;
|
|
}
|
|
|
|
// src/cli/utils.js
|
|
import { __internal as sharedWithCli2 } from '../index.mjs';
|
|
var printToScreen = console.log.bind(console);
|
|
function groupBy(array2, iteratee) {
|
|
const result = /* @__PURE__ */ Object.create(null);
|
|
for (const value of array2) {
|
|
const key = iteratee(value);
|
|
if (Array.isArray(result[key])) {
|
|
result[key].push(value);
|
|
} else {
|
|
result[key] = [value];
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
function pick(object2, keys2) {
|
|
const entries = keys2.map((key) => [key, object2[key]]);
|
|
return Object.fromEntries(entries);
|
|
}
|
|
function createHash(source) {
|
|
return String(sdbm(source));
|
|
}
|
|
async function statSafe(filePath) {
|
|
try {
|
|
return await fs.stat(filePath);
|
|
} catch (error) {
|
|
if (error.code !== 'ENOENT') {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
async function lstatSafe(filePath) {
|
|
try {
|
|
return await fs.lstat(filePath);
|
|
} catch (error) {
|
|
if (error.code !== 'ENOENT') {
|
|
throw error;
|
|
}
|
|
}
|
|
}
|
|
function isJson(value) {
|
|
try {
|
|
JSON.parse(value);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
var normalizeToPosix =
|
|
path.sep === '\\' ?
|
|
(filepath) =>
|
|
string_replace_all_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
filepath,
|
|
'\\',
|
|
'/'
|
|
)
|
|
: (filepath) => filepath;
|
|
var { omit } = sharedWithCli2.utils;
|
|
|
|
// src/cli/options/create-minimist-options.js
|
|
function createMinimistOptions(detailedOptions) {
|
|
const booleanNames = [];
|
|
const stringNames = [];
|
|
const defaultValues = {};
|
|
for (const option of detailedOptions) {
|
|
const { name, alias, type } = option;
|
|
const names = type === 'boolean' ? booleanNames : stringNames;
|
|
names.push(name);
|
|
if (alias) {
|
|
names.push(alias);
|
|
}
|
|
if (
|
|
!option.deprecated &&
|
|
(!option.forwardToApi || name === 'plugin') &&
|
|
option.default !== void 0
|
|
) {
|
|
defaultValues[option.name] = option.default;
|
|
}
|
|
}
|
|
return {
|
|
// we use vnopts' AliasSchema to handle aliases for better error messages
|
|
alias: {},
|
|
boolean: booleanNames,
|
|
string: stringNames,
|
|
default: defaultValues,
|
|
};
|
|
}
|
|
|
|
// src/cli/options/minimist.js
|
|
var import_minimist = __toESM(require_minimist(), 1);
|
|
var PLACEHOLDER = null;
|
|
function minimistParse(args, options) {
|
|
const boolean = options.boolean ?? [];
|
|
const defaults = options.default ?? {};
|
|
const booleanWithoutDefault = boolean.filter((key) => !(key in defaults));
|
|
const newDefaults = {
|
|
...defaults,
|
|
...Object.fromEntries(
|
|
booleanWithoutDefault.map((key) => [key, PLACEHOLDER])
|
|
),
|
|
};
|
|
const parsed = (0, import_minimist.default)(args, {
|
|
...options,
|
|
default: newDefaults,
|
|
});
|
|
return Object.fromEntries(
|
|
Object.entries(parsed).filter(([, value]) => value !== PLACEHOLDER)
|
|
);
|
|
}
|
|
|
|
// node_modules/chalk/source/vendor/ansi-styles/index.js
|
|
var ANSI_BACKGROUND_OFFSET = 10;
|
|
var wrapAnsi16 =
|
|
(offset = 0) =>
|
|
(code) =>
|
|
`\x1B[${code + offset}m`;
|
|
var wrapAnsi256 =
|
|
(offset = 0) =>
|
|
(code) =>
|
|
`\x1B[${38 + offset};5;${code}m`;
|
|
var wrapAnsi16m =
|
|
(offset = 0) =>
|
|
(red, green, blue) =>
|
|
`\x1B[${38 + offset};2;${red};${green};${blue}m`;
|
|
var styles = {
|
|
modifier: {
|
|
reset: [0, 0],
|
|
// 21 isn't widely supported and 22 does the same thing
|
|
bold: [1, 22],
|
|
dim: [2, 22],
|
|
italic: [3, 23],
|
|
underline: [4, 24],
|
|
overline: [53, 55],
|
|
inverse: [7, 27],
|
|
hidden: [8, 28],
|
|
strikethrough: [9, 29],
|
|
},
|
|
color: {
|
|
black: [30, 39],
|
|
red: [31, 39],
|
|
green: [32, 39],
|
|
yellow: [33, 39],
|
|
blue: [34, 39],
|
|
magenta: [35, 39],
|
|
cyan: [36, 39],
|
|
white: [37, 39],
|
|
// Bright color
|
|
blackBright: [90, 39],
|
|
gray: [90, 39],
|
|
// Alias of `blackBright`
|
|
grey: [90, 39],
|
|
// Alias of `blackBright`
|
|
redBright: [91, 39],
|
|
greenBright: [92, 39],
|
|
yellowBright: [93, 39],
|
|
blueBright: [94, 39],
|
|
magentaBright: [95, 39],
|
|
cyanBright: [96, 39],
|
|
whiteBright: [97, 39],
|
|
},
|
|
bgColor: {
|
|
bgBlack: [40, 49],
|
|
bgRed: [41, 49],
|
|
bgGreen: [42, 49],
|
|
bgYellow: [43, 49],
|
|
bgBlue: [44, 49],
|
|
bgMagenta: [45, 49],
|
|
bgCyan: [46, 49],
|
|
bgWhite: [47, 49],
|
|
// Bright color
|
|
bgBlackBright: [100, 49],
|
|
bgGray: [100, 49],
|
|
// Alias of `bgBlackBright`
|
|
bgGrey: [100, 49],
|
|
// Alias of `bgBlackBright`
|
|
bgRedBright: [101, 49],
|
|
bgGreenBright: [102, 49],
|
|
bgYellowBright: [103, 49],
|
|
bgBlueBright: [104, 49],
|
|
bgMagentaBright: [105, 49],
|
|
bgCyanBright: [106, 49],
|
|
bgWhiteBright: [107, 49],
|
|
},
|
|
};
|
|
var modifierNames = Object.keys(styles.modifier);
|
|
var foregroundColorNames = Object.keys(styles.color);
|
|
var backgroundColorNames = Object.keys(styles.bgColor);
|
|
var colorNames = [...foregroundColorNames, ...backgroundColorNames];
|
|
function assembleStyles() {
|
|
const codes = /* @__PURE__ */ new Map();
|
|
for (const [groupName, group] of Object.entries(styles)) {
|
|
for (const [styleName, style] of Object.entries(group)) {
|
|
styles[styleName] = {
|
|
open: `\x1B[${style[0]}m`,
|
|
close: `\x1B[${style[1]}m`,
|
|
};
|
|
group[styleName] = styles[styleName];
|
|
codes.set(style[0], style[1]);
|
|
}
|
|
Object.defineProperty(styles, groupName, {
|
|
value: group,
|
|
enumerable: false,
|
|
});
|
|
}
|
|
Object.defineProperty(styles, 'codes', {
|
|
value: codes,
|
|
enumerable: false,
|
|
});
|
|
styles.color.close = '\x1B[39m';
|
|
styles.bgColor.close = '\x1B[49m';
|
|
styles.color.ansi = wrapAnsi16();
|
|
styles.color.ansi256 = wrapAnsi256();
|
|
styles.color.ansi16m = wrapAnsi16m();
|
|
styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
|
|
styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
|
|
styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
|
|
Object.defineProperties(styles, {
|
|
rgbToAnsi256: {
|
|
value(red, green, blue) {
|
|
if (red === green && green === blue) {
|
|
if (red < 8) {
|
|
return 16;
|
|
}
|
|
if (red > 248) {
|
|
return 231;
|
|
}
|
|
return Math.round(((red - 8) / 247) * 24) + 232;
|
|
}
|
|
return (
|
|
16 +
|
|
36 * Math.round((red / 255) * 5) +
|
|
6 * Math.round((green / 255) * 5) +
|
|
Math.round((blue / 255) * 5)
|
|
);
|
|
},
|
|
enumerable: false,
|
|
},
|
|
hexToRgb: {
|
|
value(hex) {
|
|
const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
|
|
if (!matches) {
|
|
return [0, 0, 0];
|
|
}
|
|
let [colorString] = matches;
|
|
if (colorString.length === 3) {
|
|
colorString = [...colorString]
|
|
.map((character) => character + character)
|
|
.join('');
|
|
}
|
|
const integer = Number.parseInt(colorString, 16);
|
|
return [
|
|
/* eslint-disable no-bitwise */
|
|
(integer >> 16) & 255,
|
|
(integer >> 8) & 255,
|
|
integer & 255,
|
|
/* eslint-enable no-bitwise */
|
|
];
|
|
},
|
|
enumerable: false,
|
|
},
|
|
hexToAnsi256: {
|
|
value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
|
|
enumerable: false,
|
|
},
|
|
ansi256ToAnsi: {
|
|
value(code) {
|
|
if (code < 8) {
|
|
return 30 + code;
|
|
}
|
|
if (code < 16) {
|
|
return 90 + (code - 8);
|
|
}
|
|
let red;
|
|
let green;
|
|
let blue;
|
|
if (code >= 232) {
|
|
red = ((code - 232) * 10 + 8) / 255;
|
|
green = red;
|
|
blue = red;
|
|
} else {
|
|
code -= 16;
|
|
const remainder = code % 36;
|
|
red = Math.floor(code / 36) / 5;
|
|
green = Math.floor(remainder / 6) / 5;
|
|
blue = (remainder % 6) / 5;
|
|
}
|
|
const value = Math.max(red, green, blue) * 2;
|
|
if (value === 0) {
|
|
return 30;
|
|
}
|
|
let result =
|
|
30 +
|
|
((Math.round(blue) << 2) |
|
|
(Math.round(green) << 1) |
|
|
Math.round(red));
|
|
if (value === 2) {
|
|
result += 60;
|
|
}
|
|
return result;
|
|
},
|
|
enumerable: false,
|
|
},
|
|
rgbToAnsi: {
|
|
value: (red, green, blue) =>
|
|
styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
|
|
enumerable: false,
|
|
},
|
|
hexToAnsi: {
|
|
value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
|
|
enumerable: false,
|
|
},
|
|
});
|
|
return styles;
|
|
}
|
|
var ansiStyles = assembleStyles();
|
|
var ansi_styles_default = ansiStyles;
|
|
|
|
// node_modules/chalk/source/vendor/supports-color/index.js
|
|
import process2 from 'process';
|
|
import os from 'os';
|
|
import tty from 'tty';
|
|
function hasFlag(
|
|
flag,
|
|
argv = globalThis.Deno ? globalThis.Deno.args : process2.argv
|
|
) {
|
|
const prefix =
|
|
flag.startsWith('-') ? ''
|
|
: flag.length === 1 ? '-'
|
|
: '--';
|
|
const position = argv.indexOf(prefix + flag);
|
|
const terminatorPosition = argv.indexOf('--');
|
|
return (
|
|
position !== -1 &&
|
|
(terminatorPosition === -1 || position < terminatorPosition)
|
|
);
|
|
}
|
|
var { env } = process2;
|
|
var flagForceColor;
|
|
if (
|
|
hasFlag('no-color') ||
|
|
hasFlag('no-colors') ||
|
|
hasFlag('color=false') ||
|
|
hasFlag('color=never')
|
|
) {
|
|
flagForceColor = 0;
|
|
} else if (
|
|
hasFlag('color') ||
|
|
hasFlag('colors') ||
|
|
hasFlag('color=true') ||
|
|
hasFlag('color=always')
|
|
) {
|
|
flagForceColor = 1;
|
|
}
|
|
function envForceColor() {
|
|
if ('FORCE_COLOR' in env) {
|
|
if (env.FORCE_COLOR === 'true') {
|
|
return 1;
|
|
}
|
|
if (env.FORCE_COLOR === 'false') {
|
|
return 0;
|
|
}
|
|
return env.FORCE_COLOR.length === 0 ?
|
|
1
|
|
: Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
|
|
}
|
|
}
|
|
function translateLevel(level) {
|
|
if (level === 0) {
|
|
return false;
|
|
}
|
|
return {
|
|
level,
|
|
hasBasic: true,
|
|
has256: level >= 2,
|
|
has16m: level >= 3,
|
|
};
|
|
}
|
|
function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
|
|
const noFlagForceColor = envForceColor();
|
|
if (noFlagForceColor !== void 0) {
|
|
flagForceColor = noFlagForceColor;
|
|
}
|
|
const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
|
|
if (forceColor === 0) {
|
|
return 0;
|
|
}
|
|
if (sniffFlags) {
|
|
if (
|
|
hasFlag('color=16m') ||
|
|
hasFlag('color=full') ||
|
|
hasFlag('color=truecolor')
|
|
) {
|
|
return 3;
|
|
}
|
|
if (hasFlag('color=256')) {
|
|
return 2;
|
|
}
|
|
}
|
|
if ('TF_BUILD' in env && 'AGENT_NAME' in env) {
|
|
return 1;
|
|
}
|
|
if (haveStream && !streamIsTTY && forceColor === void 0) {
|
|
return 0;
|
|
}
|
|
const min = forceColor || 0;
|
|
if (env.TERM === 'dumb') {
|
|
return min;
|
|
}
|
|
if (process2.platform === 'win32') {
|
|
const osRelease = os.release().split('.');
|
|
if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
|
|
return Number(osRelease[2]) >= 14931 ? 3 : 2;
|
|
}
|
|
return 1;
|
|
}
|
|
if ('CI' in env) {
|
|
if (
|
|
['GITHUB_ACTIONS', 'GITEA_ACTIONS', 'CIRCLECI'].some((key) => key in env)
|
|
) {
|
|
return 3;
|
|
}
|
|
if (
|
|
['TRAVIS', 'APPVEYOR', 'GITLAB_CI', 'BUILDKITE', 'DRONE'].some(
|
|
(sign) => sign in env
|
|
) ||
|
|
env.CI_NAME === 'codeship'
|
|
) {
|
|
return 1;
|
|
}
|
|
return min;
|
|
}
|
|
if ('TEAMCITY_VERSION' in env) {
|
|
return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
|
|
}
|
|
if (env.COLORTERM === 'truecolor') {
|
|
return 3;
|
|
}
|
|
if (env.TERM === 'xterm-kitty') {
|
|
return 3;
|
|
}
|
|
if ('TERM_PROGRAM' in env) {
|
|
const version2 = Number.parseInt(
|
|
(env.TERM_PROGRAM_VERSION || '').split('.')[0],
|
|
10
|
|
);
|
|
switch (env.TERM_PROGRAM) {
|
|
case 'iTerm.app': {
|
|
return version2 >= 3 ? 3 : 2;
|
|
}
|
|
case 'Apple_Terminal': {
|
|
return 2;
|
|
}
|
|
}
|
|
}
|
|
if (/-256(color)?$/i.test(env.TERM)) {
|
|
return 2;
|
|
}
|
|
if (
|
|
/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)
|
|
) {
|
|
return 1;
|
|
}
|
|
if ('COLORTERM' in env) {
|
|
return 1;
|
|
}
|
|
return min;
|
|
}
|
|
function createSupportsColor(stream, options = {}) {
|
|
const level = _supportsColor(stream, {
|
|
streamIsTTY: stream && stream.isTTY,
|
|
...options,
|
|
});
|
|
return translateLevel(level);
|
|
}
|
|
var supportsColor = {
|
|
stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
|
|
stderr: createSupportsColor({ isTTY: tty.isatty(2) }),
|
|
};
|
|
var supports_color_default = supportsColor;
|
|
|
|
// node_modules/chalk/source/utilities.js
|
|
function stringReplaceAll2(string, substring, replacer) {
|
|
let index = string.indexOf(substring);
|
|
if (index === -1) {
|
|
return string;
|
|
}
|
|
const substringLength = substring.length;
|
|
let endIndex = 0;
|
|
let returnValue = '';
|
|
do {
|
|
returnValue += string.slice(endIndex, index) + substring + replacer;
|
|
endIndex = index + substringLength;
|
|
index = string.indexOf(substring, endIndex);
|
|
} while (index !== -1);
|
|
returnValue += string.slice(endIndex);
|
|
return returnValue;
|
|
}
|
|
function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
|
|
let endIndex = 0;
|
|
let returnValue = '';
|
|
do {
|
|
const gotCR = string[index - 1] === '\r';
|
|
returnValue +=
|
|
string.slice(endIndex, gotCR ? index - 1 : index) +
|
|
prefix +
|
|
(gotCR ? '\r\n' : '\n') +
|
|
postfix;
|
|
endIndex = index + 1;
|
|
index = string.indexOf('\n', endIndex);
|
|
} while (index !== -1);
|
|
returnValue += string.slice(endIndex);
|
|
return returnValue;
|
|
}
|
|
|
|
// node_modules/chalk/source/index.js
|
|
var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
|
|
var GENERATOR = Symbol('GENERATOR');
|
|
var STYLER = Symbol('STYLER');
|
|
var IS_EMPTY = Symbol('IS_EMPTY');
|
|
var levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
|
|
var styles2 = /* @__PURE__ */ Object.create(null);
|
|
var applyOptions = (object2, options = {}) => {
|
|
if (
|
|
options.level &&
|
|
!(
|
|
Number.isInteger(options.level) &&
|
|
options.level >= 0 &&
|
|
options.level <= 3
|
|
)
|
|
) {
|
|
throw new Error('The `level` option should be an integer from 0 to 3');
|
|
}
|
|
const colorLevel = stdoutColor ? stdoutColor.level : 0;
|
|
object2.level = options.level === void 0 ? colorLevel : options.level;
|
|
};
|
|
var chalkFactory = (options) => {
|
|
const chalk2 = (...strings) => strings.join(' ');
|
|
applyOptions(chalk2, options);
|
|
Object.setPrototypeOf(chalk2, createChalk.prototype);
|
|
return chalk2;
|
|
};
|
|
function createChalk(options) {
|
|
return chalkFactory(options);
|
|
}
|
|
Object.setPrototypeOf(createChalk.prototype, Function.prototype);
|
|
for (const [styleName, style] of Object.entries(ansi_styles_default)) {
|
|
styles2[styleName] = {
|
|
get() {
|
|
const builder = createBuilder(
|
|
this,
|
|
createStyler(style.open, style.close, this[STYLER]),
|
|
this[IS_EMPTY]
|
|
);
|
|
Object.defineProperty(this, styleName, { value: builder });
|
|
return builder;
|
|
},
|
|
};
|
|
}
|
|
styles2.visible = {
|
|
get() {
|
|
const builder = createBuilder(this, this[STYLER], true);
|
|
Object.defineProperty(this, 'visible', { value: builder });
|
|
return builder;
|
|
},
|
|
};
|
|
var getModelAnsi = (model, level, type, ...arguments_) => {
|
|
if (model === 'rgb') {
|
|
if (level === 'ansi16m') {
|
|
return ansi_styles_default[type].ansi16m(...arguments_);
|
|
}
|
|
if (level === 'ansi256') {
|
|
return ansi_styles_default[type].ansi256(
|
|
ansi_styles_default.rgbToAnsi256(...arguments_)
|
|
);
|
|
}
|
|
return ansi_styles_default[type].ansi(
|
|
ansi_styles_default.rgbToAnsi(...arguments_)
|
|
);
|
|
}
|
|
if (model === 'hex') {
|
|
return getModelAnsi(
|
|
'rgb',
|
|
level,
|
|
type,
|
|
...ansi_styles_default.hexToRgb(...arguments_)
|
|
);
|
|
}
|
|
return ansi_styles_default[type][model](...arguments_);
|
|
};
|
|
var usedModels = ['rgb', 'hex', 'ansi256'];
|
|
for (const model of usedModels) {
|
|
styles2[model] = {
|
|
get() {
|
|
const { level } = this;
|
|
return function (...arguments_) {
|
|
const styler = createStyler(
|
|
getModelAnsi(model, levelMapping[level], 'color', ...arguments_),
|
|
ansi_styles_default.color.close,
|
|
this[STYLER]
|
|
);
|
|
return createBuilder(this, styler, this[IS_EMPTY]);
|
|
};
|
|
},
|
|
};
|
|
const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
|
|
styles2[bgModel] = {
|
|
get() {
|
|
const { level } = this;
|
|
return function (...arguments_) {
|
|
const styler = createStyler(
|
|
getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_),
|
|
ansi_styles_default.bgColor.close,
|
|
this[STYLER]
|
|
);
|
|
return createBuilder(this, styler, this[IS_EMPTY]);
|
|
};
|
|
},
|
|
};
|
|
}
|
|
var proto = Object.defineProperties(() => {}, {
|
|
...styles2,
|
|
level: {
|
|
enumerable: true,
|
|
get() {
|
|
return this[GENERATOR].level;
|
|
},
|
|
set(level) {
|
|
this[GENERATOR].level = level;
|
|
},
|
|
},
|
|
});
|
|
var createStyler = (open, close, parent) => {
|
|
let openAll;
|
|
let closeAll;
|
|
if (parent === void 0) {
|
|
openAll = open;
|
|
closeAll = close;
|
|
} else {
|
|
openAll = parent.openAll + open;
|
|
closeAll = close + parent.closeAll;
|
|
}
|
|
return {
|
|
open,
|
|
close,
|
|
openAll,
|
|
closeAll,
|
|
parent,
|
|
};
|
|
};
|
|
var createBuilder = (self, _styler, _isEmpty) => {
|
|
const builder = (...arguments_) =>
|
|
applyStyle(
|
|
builder,
|
|
arguments_.length === 1 ? '' + arguments_[0] : arguments_.join(' ')
|
|
);
|
|
Object.setPrototypeOf(builder, proto);
|
|
builder[GENERATOR] = self;
|
|
builder[STYLER] = _styler;
|
|
builder[IS_EMPTY] = _isEmpty;
|
|
return builder;
|
|
};
|
|
var applyStyle = (self, string) => {
|
|
if (self.level <= 0 || !string) {
|
|
return self[IS_EMPTY] ? '' : string;
|
|
}
|
|
let styler = self[STYLER];
|
|
if (styler === void 0) {
|
|
return string;
|
|
}
|
|
const { openAll, closeAll } = styler;
|
|
if (string.includes('\x1B')) {
|
|
while (styler !== void 0) {
|
|
string = stringReplaceAll2(string, styler.close, styler.open);
|
|
styler = styler.parent;
|
|
}
|
|
}
|
|
const lfIndex = string.indexOf('\n');
|
|
if (lfIndex !== -1) {
|
|
string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
|
|
}
|
|
return openAll + string + closeAll;
|
|
};
|
|
Object.defineProperties(createChalk.prototype, styles2);
|
|
var chalk = createChalk();
|
|
var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
|
|
var source_default = chalk;
|
|
|
|
// node_modules/leven/index.js
|
|
var array = [];
|
|
var characterCodeCache = [];
|
|
function leven(first, second) {
|
|
if (first === second) {
|
|
return 0;
|
|
}
|
|
const swap = first;
|
|
if (first.length > second.length) {
|
|
first = second;
|
|
second = swap;
|
|
}
|
|
let firstLength = first.length;
|
|
let secondLength = second.length;
|
|
while (
|
|
firstLength > 0 &&
|
|
first.charCodeAt(~-firstLength) === second.charCodeAt(~-secondLength)
|
|
) {
|
|
firstLength--;
|
|
secondLength--;
|
|
}
|
|
let start = 0;
|
|
while (
|
|
start < firstLength &&
|
|
first.charCodeAt(start) === second.charCodeAt(start)
|
|
) {
|
|
start++;
|
|
}
|
|
firstLength -= start;
|
|
secondLength -= start;
|
|
if (firstLength === 0) {
|
|
return secondLength;
|
|
}
|
|
let bCharacterCode;
|
|
let result;
|
|
let temporary;
|
|
let temporary2;
|
|
let index = 0;
|
|
let index2 = 0;
|
|
while (index < firstLength) {
|
|
characterCodeCache[index] = first.charCodeAt(start + index);
|
|
array[index] = ++index;
|
|
}
|
|
while (index2 < secondLength) {
|
|
bCharacterCode = second.charCodeAt(start + index2);
|
|
temporary = index2++;
|
|
result = index2;
|
|
for (index = 0; index < firstLength; index++) {
|
|
temporary2 =
|
|
bCharacterCode === characterCodeCache[index] ?
|
|
temporary
|
|
: temporary + 1;
|
|
temporary = array[index];
|
|
result = array[index] =
|
|
temporary > result ?
|
|
temporary2 > result ?
|
|
result + 1
|
|
: temporary2
|
|
: temporary2 > temporary ? temporary + 1
|
|
: temporary2;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// src/cli/options/normalize-cli-options.js
|
|
var descriptor = {
|
|
key: (key) => (key.length === 1 ? `-${key}` : `--${key}`),
|
|
value: (value) => vnopts.apiDescriptor.value(value),
|
|
pair: ({ key, value }) =>
|
|
value === false ? `--no-${key}`
|
|
: value === true ? descriptor.key(key)
|
|
: value === '' ? `${descriptor.key(key)} without an argument`
|
|
: `${descriptor.key(key)}=${value}`,
|
|
};
|
|
var _flags;
|
|
var FlagSchema = class extends vnopts.ChoiceSchema {
|
|
constructor({ name, flags }) {
|
|
super({ name, choices: flags });
|
|
__privateAdd(this, _flags, []);
|
|
__privateSet(this, _flags, [...flags].sort());
|
|
}
|
|
preprocess(value, utils) {
|
|
if (
|
|
typeof value === 'string' &&
|
|
value.length > 0 &&
|
|
!__privateGet(this, _flags).includes(value)
|
|
) {
|
|
const suggestion = __privateGet(this, _flags).find(
|
|
(flag) => leven(flag, value) < 3
|
|
);
|
|
if (suggestion) {
|
|
utils.logger.warn(
|
|
[
|
|
`Unknown flag ${source_default.yellow(utils.descriptor.value(value))},`,
|
|
`did you mean ${source_default.blue(utils.descriptor.value(suggestion))}?`,
|
|
].join(' ')
|
|
);
|
|
return suggestion;
|
|
}
|
|
}
|
|
return value;
|
|
}
|
|
expected() {
|
|
return 'a flag';
|
|
}
|
|
};
|
|
_flags = new WeakMap();
|
|
function normalizeCliOptions(options, optionInfos, opts) {
|
|
return normalizeOptions(options, optionInfos, {
|
|
...opts,
|
|
isCLI: true,
|
|
FlagSchema,
|
|
descriptor,
|
|
});
|
|
}
|
|
var normalize_cli_options_default = normalizeCliOptions;
|
|
|
|
// src/cli/options/parse-cli-arguments.js
|
|
function parseArgv(rawArguments, detailedOptions, logger, keys2) {
|
|
var _a;
|
|
const minimistOptions = createMinimistOptions(detailedOptions);
|
|
let argv = minimistParse(rawArguments, minimistOptions);
|
|
if (keys2) {
|
|
detailedOptions = detailedOptions.filter((option) =>
|
|
keys2.includes(option.name)
|
|
);
|
|
argv = pick(argv, keys2);
|
|
}
|
|
const normalized = normalize_cli_options_default(argv, detailedOptions, {
|
|
logger,
|
|
});
|
|
return {
|
|
...Object.fromEntries(
|
|
Object.entries(normalized).map(([key, value]) => {
|
|
const option = detailedOptions.find(({ name }) => name === key) || {};
|
|
return [option.forwardToApi || camelCase(key), value];
|
|
})
|
|
),
|
|
_: (_a = normalized._) == null ? void 0 : _a.map(String),
|
|
get __raw() {
|
|
return argv;
|
|
},
|
|
};
|
|
}
|
|
var { detailedOptions: detailedOptionsWithoutPlugins } =
|
|
getContextOptionsWithoutPlugins();
|
|
function parseArgvWithoutPlugins(rawArguments, logger, keys2) {
|
|
return parseArgv(
|
|
rawArguments,
|
|
detailedOptionsWithoutPlugins,
|
|
logger,
|
|
typeof keys2 === 'string' ? [keys2] : keys2
|
|
);
|
|
}
|
|
|
|
// src/cli/context.js
|
|
var _stack;
|
|
var Context = class {
|
|
constructor({ rawArguments, logger }) {
|
|
__privateAdd(this, _stack, []);
|
|
this.rawArguments = rawArguments;
|
|
this.logger = logger;
|
|
}
|
|
async init() {
|
|
const { rawArguments, logger } = this;
|
|
const { plugins } = parseArgvWithoutPlugins(rawArguments, logger, [
|
|
'plugin',
|
|
]);
|
|
await this.pushContextPlugins(plugins);
|
|
const argv = parseArgv(rawArguments, this.detailedOptions, logger);
|
|
this.argv = argv;
|
|
this.filePatterns = argv._;
|
|
}
|
|
/**
|
|
* @param {string[]} plugins
|
|
*/
|
|
async pushContextPlugins(plugins) {
|
|
const options = await getContextOptions(plugins);
|
|
__privateGet(this, _stack).push(options);
|
|
Object.assign(this, options);
|
|
}
|
|
popContextPlugins() {
|
|
__privateGet(this, _stack).pop();
|
|
Object.assign(
|
|
this,
|
|
at_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
__privateGet(this, _stack),
|
|
-1
|
|
)
|
|
);
|
|
}
|
|
// eslint-disable-next-line getter-return
|
|
get performanceTestFlag() {
|
|
const { debugBenchmark, debugRepeat } = this.argv;
|
|
if (debugBenchmark) {
|
|
return {
|
|
name: '--debug-benchmark',
|
|
debugBenchmark: true,
|
|
};
|
|
}
|
|
if (debugRepeat > 0) {
|
|
return {
|
|
name: '--debug-repeat',
|
|
debugRepeat,
|
|
};
|
|
}
|
|
const { PRETTIER_PERF_REPEAT } = process.env;
|
|
if (PRETTIER_PERF_REPEAT && /^\d+$/u.test(PRETTIER_PERF_REPEAT)) {
|
|
return {
|
|
name: 'PRETTIER_PERF_REPEAT (environment variable)',
|
|
debugRepeat: Number(PRETTIER_PERF_REPEAT),
|
|
};
|
|
}
|
|
}
|
|
};
|
|
_stack = new WeakMap();
|
|
var context_default = Context;
|
|
|
|
// src/cli/file-info.js
|
|
var import_fast_json_stable_stringify = __toESM(
|
|
require_fast_json_stable_stringify(),
|
|
1
|
|
);
|
|
import { format, getFileInfo } from '../index.mjs';
|
|
async function logFileInfoOrDie(context) {
|
|
const {
|
|
fileInfo: file,
|
|
ignorePath,
|
|
withNodeModules,
|
|
plugins,
|
|
config,
|
|
} = context.argv;
|
|
const fileInfo = await getFileInfo(file, {
|
|
ignorePath,
|
|
withNodeModules,
|
|
plugins,
|
|
resolveConfig: config !== false,
|
|
});
|
|
printToScreen(
|
|
await format((0, import_fast_json_stable_stringify.default)(fileInfo), {
|
|
parser: 'json',
|
|
})
|
|
);
|
|
}
|
|
var file_info_default = logFileInfoOrDie;
|
|
|
|
// src/cli/find-config-path.js
|
|
import path2 from 'path';
|
|
import { resolveConfigFile } from '../index.mjs';
|
|
async function logResolvedConfigPathOrDie(context) {
|
|
const file = context.argv.findConfigPath;
|
|
const configFile = await resolveConfigFile(file);
|
|
if (configFile) {
|
|
printToScreen(normalizeToPosix(path2.relative(process.cwd(), configFile)));
|
|
} else {
|
|
throw new Error(`Can not find configure file for "${file}".`);
|
|
}
|
|
}
|
|
var find_config_path_default = logResolvedConfigPathOrDie;
|
|
|
|
// src/cli/format.js
|
|
import fs8 from 'fs/promises';
|
|
import path11 from 'path';
|
|
import * as prettier from '../index.mjs';
|
|
|
|
// src/cli/expand-patterns.js
|
|
import path3 from 'path';
|
|
async function* expandPatterns(context) {
|
|
const seen = /* @__PURE__ */ new Set();
|
|
let noResults = true;
|
|
for await (const { filePath, ignoreUnknown, error } of expandPatternsInternal(
|
|
context
|
|
)) {
|
|
noResults = false;
|
|
if (error) {
|
|
yield { error };
|
|
continue;
|
|
}
|
|
const filename = path3.resolve(filePath);
|
|
if (seen.has(filename)) {
|
|
continue;
|
|
}
|
|
seen.add(filename);
|
|
yield { filename, ignoreUnknown };
|
|
}
|
|
if (noResults && context.argv.errorOnUnmatchedPattern !== false) {
|
|
yield {
|
|
error: `No matching files. Patterns: ${context.filePatterns.join(' ')}`,
|
|
};
|
|
}
|
|
}
|
|
async function* expandPatternsInternal(context) {
|
|
const silentlyIgnoredDirs = ['.git', '.sl', '.svn', '.hg', '.jj'];
|
|
if (context.argv.withNodeModules !== true) {
|
|
silentlyIgnoredDirs.push('node_modules');
|
|
}
|
|
const globOptions = {
|
|
dot: true,
|
|
ignore: silentlyIgnoredDirs.map((dir) => '**/' + dir),
|
|
followSymbolicLinks: false,
|
|
};
|
|
const cwd2 = process.cwd();
|
|
const entries = [];
|
|
for (const pattern of context.filePatterns) {
|
|
const absolutePath = path3.resolve(cwd2, pattern);
|
|
if (containsIgnoredPathSegment(absolutePath, cwd2, silentlyIgnoredDirs)) {
|
|
continue;
|
|
}
|
|
const stat = await lstatSafe(absolutePath);
|
|
if (stat) {
|
|
if (stat.isSymbolicLink()) {
|
|
if (context.argv.errorOnUnmatchedPattern !== false) {
|
|
yield {
|
|
error: `Explicitly specified pattern "${pattern}" is a symbolic link.`,
|
|
};
|
|
} else {
|
|
context.logger.debug(
|
|
`Skipping pattern "${pattern}", as it is a symbolic link.`
|
|
);
|
|
}
|
|
} else if (stat.isFile()) {
|
|
entries.push({
|
|
type: 'file',
|
|
glob: escapePathForGlob(fixWindowsSlashes(pattern)),
|
|
input: pattern,
|
|
});
|
|
} else if (stat.isDirectory()) {
|
|
const relativePath = path3.relative(cwd2, absolutePath) || '.';
|
|
const prefix = escapePathForGlob(fixWindowsSlashes(relativePath));
|
|
entries.push({
|
|
type: 'dir',
|
|
glob: `${prefix}/**/*`,
|
|
input: pattern,
|
|
ignoreUnknown: true,
|
|
});
|
|
}
|
|
} else if (pattern[0] === '!') {
|
|
globOptions.ignore.push(fixWindowsSlashes(pattern.slice(1)));
|
|
} else {
|
|
entries.push({
|
|
type: 'glob',
|
|
glob: fixWindowsSlashes(pattern),
|
|
input: pattern,
|
|
});
|
|
}
|
|
}
|
|
for (const { type, glob, input, ignoreUnknown } of entries) {
|
|
let result;
|
|
try {
|
|
result = await fastGlob(glob, globOptions);
|
|
} catch ({ message }) {
|
|
yield {
|
|
error: `${errorMessages.globError[type]}: "${input}".
|
|
${message}`,
|
|
};
|
|
continue;
|
|
}
|
|
if (result.length === 0) {
|
|
if (context.argv.errorOnUnmatchedPattern !== false) {
|
|
yield { error: `${errorMessages.emptyResults[type]}: "${input}".` };
|
|
}
|
|
} else {
|
|
yield* sortPaths(result).map((filePath) => ({ filePath, ignoreUnknown }));
|
|
}
|
|
}
|
|
}
|
|
var errorMessages = {
|
|
globError: {
|
|
file: 'Unable to resolve file',
|
|
dir: 'Unable to expand directory',
|
|
glob: 'Unable to expand glob pattern',
|
|
},
|
|
emptyResults: {
|
|
file: 'Explicitly specified file was ignored due to negative glob patterns',
|
|
dir: 'No supported files were found in the directory',
|
|
glob: 'No files matching the pattern were found',
|
|
},
|
|
};
|
|
function containsIgnoredPathSegment(absolutePath, cwd2, ignoredDirectories) {
|
|
return path3
|
|
.relative(cwd2, absolutePath)
|
|
.split(path3.sep)
|
|
.some((dir) => ignoredDirectories.includes(dir));
|
|
}
|
|
function sortPaths(paths) {
|
|
return paths.sort((a, b) => a.localeCompare(b));
|
|
}
|
|
function escapePathForGlob(path12) {
|
|
return string_replace_all_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
string_replace_all_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
fastGlob.escapePath(
|
|
string_replace_all_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
path12,
|
|
'\\',
|
|
'\0'
|
|
)
|
|
// Workaround for fast-glob#262 (part 1)
|
|
),
|
|
String.raw`\!`,
|
|
'@(!)'
|
|
),
|
|
'\0',
|
|
String.raw`@(\\)`
|
|
);
|
|
}
|
|
var fixWindowsSlashes = normalizeToPosix;
|
|
|
|
// src/cli/find-cache-file.js
|
|
import fs4 from 'fs/promises';
|
|
import os2 from 'os';
|
|
import path8 from 'path';
|
|
|
|
// node_modules/find-cache-dir/index.js
|
|
var import_common_path_prefix = __toESM(require_common_path_prefix(), 1);
|
|
import process4 from 'process';
|
|
import path7 from 'path';
|
|
import fs3 from 'fs';
|
|
|
|
// node_modules/pkg-dir/index.js
|
|
import path6 from 'path';
|
|
|
|
// node_modules/pkg-dir/node_modules/find-up/index.js
|
|
import path5 from 'path';
|
|
import { fileURLToPath as fileURLToPath2 } from 'url';
|
|
|
|
// node_modules/locate-path/index.js
|
|
import process3 from 'process';
|
|
import path4 from 'path';
|
|
import fs2, { promises as fsPromises } from 'fs';
|
|
import { fileURLToPath } from 'url';
|
|
var typeMappings = {
|
|
directory: 'isDirectory',
|
|
file: 'isFile',
|
|
};
|
|
function checkType(type) {
|
|
if (Object.hasOwnProperty.call(typeMappings, type)) {
|
|
return;
|
|
}
|
|
throw new Error(`Invalid type specified: ${type}`);
|
|
}
|
|
var matchType = (type, stat) => stat[typeMappings[type]]();
|
|
var toPath = (urlOrPath) =>
|
|
urlOrPath instanceof URL ? fileURLToPath(urlOrPath) : urlOrPath;
|
|
function locatePathSync(
|
|
paths,
|
|
{ cwd: cwd2 = process3.cwd(), type = 'file', allowSymlinks = true } = {}
|
|
) {
|
|
checkType(type);
|
|
cwd2 = toPath(cwd2);
|
|
const statFunction = allowSymlinks ? fs2.statSync : fs2.lstatSync;
|
|
for (const path_ of paths) {
|
|
try {
|
|
const stat = statFunction(path4.resolve(cwd2, path_), {
|
|
throwIfNoEntry: false,
|
|
});
|
|
if (!stat) {
|
|
continue;
|
|
}
|
|
if (matchType(type, stat)) {
|
|
return path_;
|
|
}
|
|
} catch {}
|
|
}
|
|
}
|
|
|
|
// node_modules/pkg-dir/node_modules/find-up/index.js
|
|
var toPath2 = (urlOrPath) =>
|
|
urlOrPath instanceof URL ? fileURLToPath2(urlOrPath) : urlOrPath;
|
|
var findUpStop = Symbol('findUpStop');
|
|
function findUpMultipleSync(name, options = {}) {
|
|
let directory = path5.resolve(toPath2(options.cwd) || '');
|
|
const { root } = path5.parse(directory);
|
|
const stopAt = options.stopAt || root;
|
|
const limit = options.limit || Number.POSITIVE_INFINITY;
|
|
const paths = [name].flat();
|
|
const runMatcher = (locateOptions) => {
|
|
if (typeof name !== 'function') {
|
|
return locatePathSync(paths, locateOptions);
|
|
}
|
|
const foundPath = name(locateOptions.cwd);
|
|
if (typeof foundPath === 'string') {
|
|
return locatePathSync([foundPath], locateOptions);
|
|
}
|
|
return foundPath;
|
|
};
|
|
const matches = [];
|
|
while (true) {
|
|
const foundPath = runMatcher({ ...options, cwd: directory });
|
|
if (foundPath === findUpStop) {
|
|
break;
|
|
}
|
|
if (foundPath) {
|
|
matches.push(path5.resolve(directory, foundPath));
|
|
}
|
|
if (directory === stopAt || matches.length >= limit) {
|
|
break;
|
|
}
|
|
directory = path5.dirname(directory);
|
|
}
|
|
return matches;
|
|
}
|
|
function findUpSync(name, options = {}) {
|
|
const matches = findUpMultipleSync(name, { ...options, limit: 1 });
|
|
return matches[0];
|
|
}
|
|
|
|
// node_modules/pkg-dir/index.js
|
|
function packageDirectorySync({ cwd: cwd2 } = {}) {
|
|
const filePath = findUpSync('package.json', { cwd: cwd2 });
|
|
return filePath && path6.dirname(filePath);
|
|
}
|
|
|
|
// node_modules/find-cache-dir/index.js
|
|
var { env: env2, cwd } = process4;
|
|
var isWritable = (path12) => {
|
|
try {
|
|
fs3.accessSync(path12, fs3.constants.W_OK);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
};
|
|
function useDirectory(directory, options) {
|
|
if (options.create) {
|
|
fs3.mkdirSync(directory, { recursive: true });
|
|
}
|
|
return directory;
|
|
}
|
|
function getNodeModuleDirectory(directory) {
|
|
const nodeModules = path7.join(directory, 'node_modules');
|
|
if (
|
|
!isWritable(nodeModules) &&
|
|
(fs3.existsSync(nodeModules) || !isWritable(path7.join(directory)))
|
|
) {
|
|
return;
|
|
}
|
|
return nodeModules;
|
|
}
|
|
function findCacheDirectory(options = {}) {
|
|
if (env2.CACHE_DIR && !['true', 'false', '1', '0'].includes(env2.CACHE_DIR)) {
|
|
return useDirectory(path7.join(env2.CACHE_DIR, options.name), options);
|
|
}
|
|
let { cwd: directory = cwd(), files } = options;
|
|
if (files) {
|
|
if (!Array.isArray(files)) {
|
|
throw new TypeError(
|
|
`Expected \`files\` option to be an array, got \`${typeof files}\`.`
|
|
);
|
|
}
|
|
directory = (0, import_common_path_prefix.default)(
|
|
files.map((file) => path7.resolve(directory, file))
|
|
);
|
|
}
|
|
directory = packageDirectorySync({ cwd: directory });
|
|
if (!directory) {
|
|
return;
|
|
}
|
|
const nodeModules = getNodeModuleDirectory(directory);
|
|
if (!nodeModules) {
|
|
return;
|
|
}
|
|
return useDirectory(
|
|
path7.join(directory, 'node_modules', '.cache', options.name),
|
|
options
|
|
);
|
|
}
|
|
|
|
// src/cli/find-cache-file.js
|
|
function findDefaultCacheFile() {
|
|
const cacheDir =
|
|
findCacheDirectory({ name: 'prettier', create: true }) || os2.tmpdir();
|
|
const cacheFilePath = path8.join(cacheDir, '.prettier-cache');
|
|
return cacheFilePath;
|
|
}
|
|
async function findCacheFileFromOption(cacheLocation) {
|
|
const cacheFile = path8.resolve(cacheLocation);
|
|
const stat = await statSafe(cacheFile);
|
|
if (stat) {
|
|
if (stat.isDirectory()) {
|
|
throw new Error(
|
|
`Resolved --cache-location '${cacheFile}' is a directory`
|
|
);
|
|
}
|
|
const data = await fs4.readFile(cacheFile, 'utf8');
|
|
if (!isJson(data)) {
|
|
throw new Error(`'${cacheFile}' isn't a valid JSON file`);
|
|
}
|
|
}
|
|
return cacheFile;
|
|
}
|
|
async function findCacheFile(cacheLocation) {
|
|
if (!cacheLocation) {
|
|
return findDefaultCacheFile();
|
|
}
|
|
const cacheFile = await findCacheFileFromOption(cacheLocation);
|
|
return cacheFile;
|
|
}
|
|
var find_cache_file_default = findCacheFile;
|
|
|
|
// src/cli/format-results-cache.js
|
|
var import_fast_json_stable_stringify2 = __toESM(
|
|
require_fast_json_stable_stringify(),
|
|
1
|
|
);
|
|
import fs7 from 'fs';
|
|
|
|
// node_modules/file-entry-cache/dist/index.js
|
|
import crypto2 from 'crypto';
|
|
import fs6 from 'fs';
|
|
import path10 from 'path';
|
|
|
|
// node_modules/file-entry-cache/node_modules/flat-cache/dist/index.js
|
|
import path9 from 'path';
|
|
import fs5 from 'fs';
|
|
|
|
// node_modules/hookified/dist/node/index.js
|
|
var Eventified = class {
|
|
_eventListeners;
|
|
_maxListeners;
|
|
constructor() {
|
|
this._eventListeners = /* @__PURE__ */ new Map();
|
|
this._maxListeners = 100;
|
|
}
|
|
/**
|
|
* Adds a handler function for a specific event that will run only once
|
|
* @param {string | symbol} eventName
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
once(eventName, listener) {
|
|
const onceListener = (...arguments_) => {
|
|
this.off(eventName, onceListener);
|
|
listener(...arguments_);
|
|
};
|
|
this.on(eventName, onceListener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Gets the number of listeners for a specific event. If no event is provided, it returns the total number of listeners
|
|
* @param {string} eventName The event name. Not required
|
|
* @returns {number} The number of listeners
|
|
*/
|
|
listenerCount(eventName) {
|
|
if (!eventName) {
|
|
return this.getAllListeners().length;
|
|
}
|
|
const listeners = this._eventListeners.get(eventName);
|
|
return listeners ? listeners.length : 0;
|
|
}
|
|
/**
|
|
* Gets an array of event names
|
|
* @returns {Array<string | symbol>} An array of event names
|
|
*/
|
|
eventNames() {
|
|
return Array.from(this._eventListeners.keys());
|
|
}
|
|
/**
|
|
* Gets an array of listeners for a specific event. If no event is provided, it returns all listeners
|
|
* @param {string} [event] (Optional) The event name
|
|
* @returns {EventListener[]} An array of listeners
|
|
*/
|
|
rawListeners(event) {
|
|
if (!event) {
|
|
return this.getAllListeners();
|
|
}
|
|
return this._eventListeners.get(event) ?? [];
|
|
}
|
|
/**
|
|
* Prepends a listener to the beginning of the listeners array for the specified event
|
|
* @param {string | symbol} eventName
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
prependListener(eventName, listener) {
|
|
const listeners = this._eventListeners.get(eventName) ?? [];
|
|
listeners.unshift(listener);
|
|
this._eventListeners.set(eventName, listeners);
|
|
return this;
|
|
}
|
|
/**
|
|
* Prepends a one-time listener to the beginning of the listeners array for the specified event
|
|
* @param {string | symbol} eventName
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
prependOnceListener(eventName, listener) {
|
|
const onceListener = (...arguments_) => {
|
|
this.off(eventName, onceListener);
|
|
listener(...arguments_);
|
|
};
|
|
this.prependListener(eventName, onceListener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Gets the maximum number of listeners that can be added for a single event
|
|
* @returns {number} The maximum number of listeners
|
|
*/
|
|
maxListeners() {
|
|
return this._maxListeners;
|
|
}
|
|
/**
|
|
* Adds a listener for a specific event. It is an alias for the on() method
|
|
* @param {string | symbol} event
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
addListener(event, listener) {
|
|
this.on(event, listener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Adds a listener for a specific event
|
|
* @param {string | symbol} event
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
on(event, listener) {
|
|
if (!this._eventListeners.has(event)) {
|
|
this._eventListeners.set(event, []);
|
|
}
|
|
const listeners = this._eventListeners.get(event);
|
|
if (listeners) {
|
|
if (listeners.length >= this._maxListeners) {
|
|
console.warn(
|
|
`MaxListenersExceededWarning: Possible event memory leak detected. ${listeners.length + 1} ${event} listeners added. Use setMaxListeners() to increase limit.`
|
|
);
|
|
}
|
|
listeners.push(listener);
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Removes a listener for a specific event. It is an alias for the off() method
|
|
* @param {string | symbol} event
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
removeListener(event, listener) {
|
|
this.off(event, listener);
|
|
return this;
|
|
}
|
|
/**
|
|
* Removes a listener for a specific event
|
|
* @param {string | symbol} event
|
|
* @param {EventListener} listener
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
off(event, listener) {
|
|
const listeners = this._eventListeners.get(event) ?? [];
|
|
const index = listeners.indexOf(listener);
|
|
if (index !== -1) {
|
|
listeners.splice(index, 1);
|
|
}
|
|
if (listeners.length === 0) {
|
|
this._eventListeners.delete(event);
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Calls all listeners for a specific event
|
|
* @param {string | symbol} event
|
|
* @param arguments_ The arguments to pass to the listeners
|
|
* @returns {boolean} Returns true if the event had listeners, false otherwise
|
|
*/
|
|
emit(event, ...arguments_) {
|
|
let result = false;
|
|
const listeners = this._eventListeners.get(event);
|
|
if (listeners && listeners.length > 0) {
|
|
for (const listener of listeners) {
|
|
listener(...arguments_);
|
|
result = true;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Gets all listeners for a specific event. If no event is provided, it returns all listeners
|
|
* @param {string} [event] (Optional) The event name
|
|
* @returns {EventListener[]} An array of listeners
|
|
*/
|
|
listeners(event) {
|
|
return this._eventListeners.get(event) ?? [];
|
|
}
|
|
/**
|
|
* Removes all listeners for a specific event. If no event is provided, it removes all listeners
|
|
* @param {string} [event] (Optional) The event name
|
|
* @returns {IEventEmitter} returns the instance of the class for chaining
|
|
*/
|
|
removeAllListeners(event) {
|
|
if (event) {
|
|
this._eventListeners.delete(event);
|
|
} else {
|
|
this._eventListeners.clear();
|
|
}
|
|
return this;
|
|
}
|
|
/**
|
|
* Sets the maximum number of listeners that can be added for a single event
|
|
* @param {number} n The maximum number of listeners
|
|
* @returns {void}
|
|
*/
|
|
setMaxListeners(n) {
|
|
this._maxListeners = n;
|
|
for (const listeners of this._eventListeners.values()) {
|
|
if (listeners.length > n) {
|
|
listeners.splice(n);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Gets all listeners
|
|
* @returns {EventListener[]} An array of listeners
|
|
*/
|
|
getAllListeners() {
|
|
let result = new Array();
|
|
for (const listeners of this._eventListeners.values()) {
|
|
result = result.concat(listeners);
|
|
}
|
|
return result;
|
|
}
|
|
};
|
|
var Hookified = class extends Eventified {
|
|
_hooks;
|
|
_throwHookErrors = false;
|
|
constructor(options) {
|
|
super();
|
|
this._hooks = /* @__PURE__ */ new Map();
|
|
if ((options == null ? void 0 : options.throwHookErrors) !== void 0) {
|
|
this._throwHookErrors = options.throwHookErrors;
|
|
}
|
|
}
|
|
/**
|
|
* Gets all hooks
|
|
* @returns {Map<string, Hook[]>}
|
|
*/
|
|
get hooks() {
|
|
return this._hooks;
|
|
}
|
|
/**
|
|
* Gets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
|
|
* @returns {boolean}
|
|
*/
|
|
get throwHookErrors() {
|
|
return this._throwHookErrors;
|
|
}
|
|
/**
|
|
* Sets whether an error should be thrown when a hook throws an error. Default is false and only emits an error event.
|
|
* @param {boolean} value
|
|
*/
|
|
set throwHookErrors(value) {
|
|
this._throwHookErrors = value;
|
|
}
|
|
/**
|
|
* Adds a handler function for a specific event
|
|
* @param {string} event
|
|
* @param {Hook} handler - this can be async or sync
|
|
* @returns {void}
|
|
*/
|
|
onHook(event, handler) {
|
|
const eventHandlers = this._hooks.get(event);
|
|
if (eventHandlers) {
|
|
eventHandlers.push(handler);
|
|
} else {
|
|
this._hooks.set(event, [handler]);
|
|
}
|
|
}
|
|
/**
|
|
* Adds a handler function for a specific event that runs before all other handlers
|
|
* @param {string} event
|
|
* @param {Hook} handler - this can be async or sync
|
|
* @returns {void}
|
|
*/
|
|
prependHook(event, handler) {
|
|
const eventHandlers = this._hooks.get(event);
|
|
if (eventHandlers) {
|
|
eventHandlers.unshift(handler);
|
|
} else {
|
|
this._hooks.set(event, [handler]);
|
|
}
|
|
}
|
|
/**
|
|
* Adds a handler that only executes once for a specific event before all other handlers
|
|
* @param event
|
|
* @param handler
|
|
*/
|
|
prependOnceHook(event, handler) {
|
|
const hook = async (...arguments_) => {
|
|
this.removeHook(event, hook);
|
|
return handler(...arguments_);
|
|
};
|
|
this.prependHook(event, hook);
|
|
}
|
|
/**
|
|
* Adds a handler that only executes once for a specific event
|
|
* @param event
|
|
* @param handler
|
|
*/
|
|
onceHook(event, handler) {
|
|
const hook = async (...arguments_) => {
|
|
this.removeHook(event, hook);
|
|
return handler(...arguments_);
|
|
};
|
|
this.onHook(event, hook);
|
|
}
|
|
/**
|
|
* Removes a handler function for a specific event
|
|
* @param {string} event
|
|
* @param {Hook} handler
|
|
* @returns {void}
|
|
*/
|
|
removeHook(event, handler) {
|
|
const eventHandlers = this._hooks.get(event);
|
|
if (eventHandlers) {
|
|
const index = eventHandlers.indexOf(handler);
|
|
if (index !== -1) {
|
|
eventHandlers.splice(index, 1);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Calls all handlers for a specific event
|
|
* @param {string} event
|
|
* @param {T[]} arguments_
|
|
* @returns {Promise<void>}
|
|
*/
|
|
async hook(event, ...arguments_) {
|
|
const eventHandlers = this._hooks.get(event);
|
|
if (eventHandlers) {
|
|
for (const handler of eventHandlers) {
|
|
try {
|
|
await handler(...arguments_);
|
|
} catch (error) {
|
|
const message = `${event}: ${error.message}`;
|
|
this.emit('error', new Error(message));
|
|
if (this._throwHookErrors) {
|
|
throw new Error(message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Gets all hooks for a specific event
|
|
* @param {string} event
|
|
* @returns {Hook[]}
|
|
*/
|
|
getHooks(event) {
|
|
return this._hooks.get(event);
|
|
}
|
|
/**
|
|
* Removes all hooks
|
|
* @returns {void}
|
|
*/
|
|
clearHooks() {
|
|
this._hooks.clear();
|
|
}
|
|
};
|
|
|
|
// node_modules/cacheable/dist/index.js
|
|
import * as crypto from 'crypto';
|
|
var structuredClone =
|
|
globalThis.structuredClone ?? ((value) => JSON.parse(JSON.stringify(value)));
|
|
var shorthandToMilliseconds = (shorthand) => {
|
|
let milliseconds;
|
|
if (shorthand === void 0) {
|
|
return void 0;
|
|
}
|
|
if (typeof shorthand === 'number') {
|
|
milliseconds = shorthand;
|
|
} else if (typeof shorthand === 'string') {
|
|
shorthand = shorthand.trim();
|
|
if (Number.isNaN(Number(shorthand))) {
|
|
const match = /^([\d.]+)\s*(ms|s|m|h|hr|d)$/i.exec(shorthand);
|
|
if (!match) {
|
|
throw new Error(
|
|
`Unsupported time format: "${shorthand}". Use 'ms', 's', 'm', 'h', 'hr', or 'd'.`
|
|
);
|
|
}
|
|
const [, value, unit] = match;
|
|
const numericValue = Number.parseFloat(value);
|
|
const unitLower = unit.toLowerCase();
|
|
switch (unitLower) {
|
|
case 'ms': {
|
|
milliseconds = numericValue;
|
|
break;
|
|
}
|
|
case 's': {
|
|
milliseconds = numericValue * 1e3;
|
|
break;
|
|
}
|
|
case 'm': {
|
|
milliseconds = numericValue * 1e3 * 60;
|
|
break;
|
|
}
|
|
case 'h': {
|
|
milliseconds = numericValue * 1e3 * 60 * 60;
|
|
break;
|
|
}
|
|
case 'hr': {
|
|
milliseconds = numericValue * 1e3 * 60 * 60;
|
|
break;
|
|
}
|
|
case 'd': {
|
|
milliseconds = numericValue * 1e3 * 60 * 60 * 24;
|
|
break;
|
|
}
|
|
/* c8 ignore next 3 */
|
|
default: {
|
|
milliseconds = Number(shorthand);
|
|
}
|
|
}
|
|
} else {
|
|
milliseconds = Number(shorthand);
|
|
}
|
|
} else {
|
|
throw new TypeError('Time must be a string or a number.');
|
|
}
|
|
return milliseconds;
|
|
};
|
|
var shorthandToTime = (shorthand, fromDate) => {
|
|
fromDate || (fromDate = /* @__PURE__ */ new Date());
|
|
const milliseconds = shorthandToMilliseconds(shorthand);
|
|
if (milliseconds === void 0) {
|
|
return fromDate.getTime();
|
|
}
|
|
return fromDate.getTime() + milliseconds;
|
|
};
|
|
function hash(object2, algorithm = 'sha256') {
|
|
const objectString = JSON.stringify(object2);
|
|
if (!crypto.getHashes().includes(algorithm)) {
|
|
throw new Error(`Unsupported hash algorithm: '${algorithm}'`);
|
|
}
|
|
const hasher = crypto.createHash(algorithm);
|
|
hasher.update(objectString);
|
|
return hasher.digest('hex');
|
|
}
|
|
function wrapSync(function_, options) {
|
|
const { ttl, keyPrefix, cache } = options;
|
|
return function (...arguments_) {
|
|
const cacheKey = createWrapKey(function_, arguments_, keyPrefix);
|
|
let value = cache.get(cacheKey);
|
|
if (value === void 0) {
|
|
try {
|
|
value = function_(...arguments_);
|
|
cache.set(cacheKey, value, ttl);
|
|
} catch (error) {
|
|
cache.emit('error', error);
|
|
if (options.cacheErrors) {
|
|
cache.set(cacheKey, error, ttl);
|
|
}
|
|
}
|
|
}
|
|
return value;
|
|
};
|
|
}
|
|
function createWrapKey(function_, arguments_, keyPrefix) {
|
|
if (!keyPrefix) {
|
|
return `${function_.name}::${hash(arguments_)}`;
|
|
}
|
|
return `${keyPrefix}::${function_.name}::${hash(arguments_)}`;
|
|
}
|
|
var ListNode = class {
|
|
// eslint-disable-next-line @typescript-eslint/parameter-properties
|
|
value;
|
|
prev = void 0;
|
|
next = void 0;
|
|
constructor(value) {
|
|
this.value = value;
|
|
}
|
|
};
|
|
var DoublyLinkedList = class {
|
|
head = void 0;
|
|
tail = void 0;
|
|
nodesMap = /* @__PURE__ */ new Map();
|
|
// Add a new node to the front (most recently used)
|
|
addToFront(value) {
|
|
const newNode = new ListNode(value);
|
|
if (this.head) {
|
|
newNode.next = this.head;
|
|
this.head.prev = newNode;
|
|
this.head = newNode;
|
|
} else {
|
|
this.head = this.tail = newNode;
|
|
}
|
|
this.nodesMap.set(value, newNode);
|
|
}
|
|
// Move an existing node to the front (most recently used)
|
|
moveToFront(value) {
|
|
const node = this.nodesMap.get(value);
|
|
if (!node || this.head === node) {
|
|
return;
|
|
}
|
|
if (node.prev) {
|
|
node.prev.next = node.next;
|
|
}
|
|
if (node.next) {
|
|
node.next.prev = node.prev;
|
|
}
|
|
if (node === this.tail) {
|
|
this.tail = node.prev;
|
|
}
|
|
node.prev = void 0;
|
|
node.next = this.head;
|
|
if (this.head) {
|
|
this.head.prev = node;
|
|
}
|
|
this.head = node;
|
|
this.tail || (this.tail = node);
|
|
}
|
|
// Get the oldest node (tail)
|
|
getOldest() {
|
|
return this.tail ? this.tail.value : void 0;
|
|
}
|
|
// Remove the oldest node (tail)
|
|
removeOldest() {
|
|
if (!this.tail) {
|
|
return void 0;
|
|
}
|
|
const oldValue = this.tail.value;
|
|
if (this.tail.prev) {
|
|
this.tail = this.tail.prev;
|
|
this.tail.next = void 0;
|
|
} else {
|
|
this.head = this.tail = void 0;
|
|
}
|
|
this.nodesMap.delete(oldValue);
|
|
return oldValue;
|
|
}
|
|
get size() {
|
|
return this.nodesMap.size;
|
|
}
|
|
};
|
|
var CacheableMemory = class extends Hookified {
|
|
_lru = new DoublyLinkedList();
|
|
_hashCache = /* @__PURE__ */ new Map();
|
|
_hash0 = /* @__PURE__ */ new Map();
|
|
_hash1 = /* @__PURE__ */ new Map();
|
|
_hash2 = /* @__PURE__ */ new Map();
|
|
_hash3 = /* @__PURE__ */ new Map();
|
|
_hash4 = /* @__PURE__ */ new Map();
|
|
_hash5 = /* @__PURE__ */ new Map();
|
|
_hash6 = /* @__PURE__ */ new Map();
|
|
_hash7 = /* @__PURE__ */ new Map();
|
|
_hash8 = /* @__PURE__ */ new Map();
|
|
_hash9 = /* @__PURE__ */ new Map();
|
|
_ttl;
|
|
// Turned off by default
|
|
_useClone = true;
|
|
// Turned on by default
|
|
_lruSize = 0;
|
|
// Turned off by default
|
|
_checkInterval = 0;
|
|
// Turned off by default
|
|
_interval = 0;
|
|
// Turned off by default
|
|
/**
|
|
* @constructor
|
|
* @param {CacheableMemoryOptions} [options] - The options for the CacheableMemory
|
|
*/
|
|
constructor(options) {
|
|
super();
|
|
if (options == null ? void 0 : options.ttl) {
|
|
this.setTtl(options.ttl);
|
|
}
|
|
if ((options == null ? void 0 : options.useClone) !== void 0) {
|
|
this._useClone = options.useClone;
|
|
}
|
|
if (options == null ? void 0 : options.lruSize) {
|
|
this._lruSize = options.lruSize;
|
|
}
|
|
if (options == null ? void 0 : options.checkInterval) {
|
|
this._checkInterval = options.checkInterval;
|
|
}
|
|
this.startIntervalCheck();
|
|
}
|
|
/**
|
|
* Gets the time-to-live
|
|
* @returns {number|string|undefined} - The time-to-live in miliseconds or a human-readable format. If undefined, it will not have a time-to-live.
|
|
*/
|
|
get ttl() {
|
|
return this._ttl;
|
|
}
|
|
/**
|
|
* Sets the time-to-live
|
|
* @param {number|string|undefined} value - The time-to-live in miliseconds or a human-readable format (example '1s' = 1 second, '1h' = 1 hour). If undefined, it will not have a time-to-live.
|
|
*/
|
|
set ttl(value) {
|
|
this.setTtl(value);
|
|
}
|
|
/**
|
|
* Gets whether to use clone
|
|
* @returns {boolean} - If true, it will clone the value before returning it. If false, it will return the value directly. Default is true.
|
|
*/
|
|
get useClone() {
|
|
return this._useClone;
|
|
}
|
|
/**
|
|
* Sets whether to use clone
|
|
* @param {boolean} value - If true, it will clone the value before returning it. If false, it will return the value directly. Default is true.
|
|
*/
|
|
set useClone(value) {
|
|
this._useClone = value;
|
|
}
|
|
/**
|
|
* Gets the size of the LRU cache
|
|
* @returns {number} - The size of the LRU cache. If set to 0, it will not use LRU cache. Default is 0.
|
|
*/
|
|
get lruSize() {
|
|
return this._lruSize;
|
|
}
|
|
/**
|
|
* Sets the size of the LRU cache
|
|
* @param {number} value - The size of the LRU cache. If set to 0, it will not use LRU cache. Default is 0.
|
|
*/
|
|
set lruSize(value) {
|
|
this._lruSize = value;
|
|
this.lruResize();
|
|
}
|
|
/**
|
|
* Gets the check interval
|
|
* @returns {number} - The interval to check for expired items. If set to 0, it will not check for expired items. Default is 0.
|
|
*/
|
|
get checkInterval() {
|
|
return this._checkInterval;
|
|
}
|
|
/**
|
|
* Sets the check interval
|
|
* @param {number} value - The interval to check for expired items. If set to 0, it will not check for expired items. Default is 0.
|
|
*/
|
|
set checkInterval(value) {
|
|
this._checkInterval = value;
|
|
}
|
|
/**
|
|
* Gets the size of the cache
|
|
* @returns {number} - The size of the cache
|
|
*/
|
|
get size() {
|
|
return (
|
|
this._hash0.size +
|
|
this._hash1.size +
|
|
this._hash2.size +
|
|
this._hash3.size +
|
|
this._hash4.size +
|
|
this._hash5.size +
|
|
this._hash6.size +
|
|
this._hash7.size +
|
|
this._hash8.size +
|
|
this._hash9.size
|
|
);
|
|
}
|
|
/**
|
|
* Gets the keys
|
|
* @returns {IterableIterator<string>} - The keys
|
|
*/
|
|
get keys() {
|
|
return this.concatStores().keys();
|
|
}
|
|
/**
|
|
* Gets the items
|
|
* @returns {IterableIterator<CacheableStoreItem>} - The items
|
|
*/
|
|
get items() {
|
|
return this.concatStores().values();
|
|
}
|
|
/**
|
|
* Gets the value of the key
|
|
* @param {string} key - The key to get the value
|
|
* @returns {T | undefined} - The value of the key
|
|
*/
|
|
get(key) {
|
|
const store = this.getStore(key);
|
|
const item = store.get(key);
|
|
if (!item) {
|
|
return void 0;
|
|
}
|
|
if (item.expires && item.expires && Date.now() > item.expires) {
|
|
store.delete(key);
|
|
return void 0;
|
|
}
|
|
this.lruMoveToFront(key);
|
|
if (!this._useClone) {
|
|
return item.value;
|
|
}
|
|
return this.clone(item.value);
|
|
}
|
|
/**
|
|
* Gets the values of the keys
|
|
* @param {string[]} keys - The keys to get the values
|
|
* @returns {T[]} - The values of the keys
|
|
*/
|
|
getMany(keys2) {
|
|
const result = new Array();
|
|
for (const key of keys2) {
|
|
result.push(this.get(key));
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Gets the raw value of the key
|
|
* @param {string} key - The key to get the value
|
|
* @returns {CacheableStoreItem | undefined} - The raw value of the key
|
|
*/
|
|
getRaw(key) {
|
|
const store = this.getStore(key);
|
|
const item = store.get(key);
|
|
if (!item) {
|
|
return void 0;
|
|
}
|
|
if (item.expires && item.expires && Date.now() > item.expires) {
|
|
store.delete(key);
|
|
return void 0;
|
|
}
|
|
this.lruMoveToFront(key);
|
|
return item;
|
|
}
|
|
/**
|
|
* Gets the raw values of the keys
|
|
* @param {string[]} keys - The keys to get the values
|
|
* @returns {CacheableStoreItem[]} - The raw values of the keys
|
|
*/
|
|
getManyRaw(keys2) {
|
|
const result = new Array();
|
|
for (const key of keys2) {
|
|
result.push(this.getRaw(key));
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Sets the value of the key
|
|
* @param {string} key - The key to set the value
|
|
* @param {any} value - The value to set
|
|
* @param {number|string|SetOptions} [ttl] - Time to Live - If you set a number it is miliseconds, if you set a string it is a human-readable.
|
|
* If you want to set expire directly you can do that by setting the expire property in the SetOptions.
|
|
* If you set undefined, it will use the default time-to-live. If both are undefined then it will not have a time-to-live.
|
|
* @returns {void}
|
|
*/
|
|
set(key, value, ttl) {
|
|
const store = this.getStore(key);
|
|
let expires;
|
|
if (ttl !== void 0 || this._ttl !== void 0) {
|
|
if (typeof ttl === 'object') {
|
|
if (ttl.expire) {
|
|
expires =
|
|
typeof ttl.expire === 'number' ? ttl.expire : ttl.expire.getTime();
|
|
}
|
|
if (ttl.ttl) {
|
|
const finalTtl = shorthandToTime(ttl.ttl);
|
|
if (finalTtl !== void 0) {
|
|
expires = finalTtl;
|
|
}
|
|
}
|
|
} else {
|
|
const finalTtl = shorthandToTime(ttl ?? this._ttl);
|
|
if (finalTtl !== void 0) {
|
|
expires = finalTtl;
|
|
}
|
|
}
|
|
}
|
|
if (this._lruSize > 0) {
|
|
if (store.has(key)) {
|
|
this.lruMoveToFront(key);
|
|
} else {
|
|
this.lruAddToFront(key);
|
|
if (this._lru.size > this._lruSize) {
|
|
const oldestKey = this._lru.getOldest();
|
|
if (oldestKey) {
|
|
this._lru.removeOldest();
|
|
this.delete(oldestKey);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
const item = { key, value, expires };
|
|
store.set(key, item);
|
|
}
|
|
/**
|
|
* Sets the values of the keys
|
|
* @param {CacheableItem[]} items - The items to set
|
|
* @returns {void}
|
|
*/
|
|
setMany(items) {
|
|
for (const item of items) {
|
|
this.set(item.key, item.value, item.ttl);
|
|
}
|
|
}
|
|
/**
|
|
* Checks if the key exists
|
|
* @param {string} key - The key to check
|
|
* @returns {boolean} - If true, the key exists. If false, the key does not exist.
|
|
*/
|
|
has(key) {
|
|
const item = this.get(key);
|
|
return Boolean(item);
|
|
}
|
|
/**
|
|
* @function hasMany
|
|
* @param {string[]} keys - The keys to check
|
|
* @returns {boolean[]} - If true, the key exists. If false, the key does not exist.
|
|
*/
|
|
hasMany(keys2) {
|
|
const result = new Array();
|
|
for (const key of keys2) {
|
|
const item = this.get(key);
|
|
result.push(Boolean(item));
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Take will get the key and delete the entry from cache
|
|
* @param {string} key - The key to take
|
|
* @returns {T | undefined} - The value of the key
|
|
*/
|
|
take(key) {
|
|
const item = this.get(key);
|
|
if (!item) {
|
|
return void 0;
|
|
}
|
|
this.delete(key);
|
|
return item;
|
|
}
|
|
/**
|
|
* TakeMany will get the keys and delete the entries from cache
|
|
* @param {string[]} keys - The keys to take
|
|
* @returns {T[]} - The values of the keys
|
|
*/
|
|
takeMany(keys2) {
|
|
const result = new Array();
|
|
for (const key of keys2) {
|
|
result.push(this.take(key));
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Delete the key
|
|
* @param {string} key - The key to delete
|
|
* @returns {void}
|
|
*/
|
|
delete(key) {
|
|
const store = this.getStore(key);
|
|
store.delete(key);
|
|
}
|
|
/**
|
|
* Delete the keys
|
|
* @param {string[]} keys - The keys to delete
|
|
* @returns {void}
|
|
*/
|
|
deleteMany(keys2) {
|
|
for (const key of keys2) {
|
|
this.delete(key);
|
|
}
|
|
}
|
|
/**
|
|
* Clear the cache
|
|
* @returns {void}
|
|
*/
|
|
clear() {
|
|
this._hash0.clear();
|
|
this._hash1.clear();
|
|
this._hash2.clear();
|
|
this._hash3.clear();
|
|
this._hash4.clear();
|
|
this._hash5.clear();
|
|
this._hash6.clear();
|
|
this._hash7.clear();
|
|
this._hash8.clear();
|
|
this._hash9.clear();
|
|
this._hashCache.clear();
|
|
this._lru = new DoublyLinkedList();
|
|
}
|
|
/**
|
|
* Get the store based on the key (internal use)
|
|
* @param {string} key - The key to get the store
|
|
* @returns {CacheableHashStore} - The store
|
|
*/
|
|
getStore(key) {
|
|
const hash2 = this.hashKey(key);
|
|
return this.getStoreFromHash(hash2);
|
|
}
|
|
/**
|
|
* Get the store based on the hash (internal use)
|
|
* @param {number} hash
|
|
* @returns {Map<string, CacheableStoreItem>}
|
|
*/
|
|
getStoreFromHash(hash2) {
|
|
switch (hash2) {
|
|
case 1: {
|
|
return this._hash1;
|
|
}
|
|
case 2: {
|
|
return this._hash2;
|
|
}
|
|
case 3: {
|
|
return this._hash3;
|
|
}
|
|
case 4: {
|
|
return this._hash4;
|
|
}
|
|
case 5: {
|
|
return this._hash5;
|
|
}
|
|
case 6: {
|
|
return this._hash6;
|
|
}
|
|
case 7: {
|
|
return this._hash7;
|
|
}
|
|
case 8: {
|
|
return this._hash8;
|
|
}
|
|
case 9: {
|
|
return this._hash9;
|
|
}
|
|
default: {
|
|
return this._hash0;
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Hash the key (internal use)
|
|
* @param key
|
|
* @returns {number} from 0 to 9
|
|
*/
|
|
hashKey(key) {
|
|
const cacheHashNumber = this._hashCache.get(key);
|
|
if (cacheHashNumber) {
|
|
return cacheHashNumber;
|
|
}
|
|
let hash2 = 0;
|
|
const primeMultiplier = 31;
|
|
for (let i = 0; i < key.length; i++) {
|
|
hash2 = hash2 * primeMultiplier + key.charCodeAt(i);
|
|
}
|
|
const result = Math.abs(hash2) % 10;
|
|
this._hashCache.set(key, result);
|
|
return result;
|
|
}
|
|
/**
|
|
* Clone the value. This is for internal use
|
|
* @param {any} value - The value to clone
|
|
* @returns {any} - The cloned value
|
|
*/
|
|
clone(value) {
|
|
if (this.isPrimitive(value)) {
|
|
return value;
|
|
}
|
|
return structuredClone(value);
|
|
}
|
|
/**
|
|
* Add to the front of the LRU cache. This is for internal use
|
|
* @param {string} key - The key to add to the front
|
|
* @returns {void}
|
|
*/
|
|
lruAddToFront(key) {
|
|
if (this._lruSize === 0) {
|
|
return;
|
|
}
|
|
this._lru.addToFront(key);
|
|
}
|
|
/**
|
|
* Move to the front of the LRU cache. This is for internal use
|
|
* @param {string} key - The key to move to the front
|
|
* @returns {void}
|
|
*/
|
|
lruMoveToFront(key) {
|
|
if (this._lruSize === 0) {
|
|
return;
|
|
}
|
|
this._lru.moveToFront(key);
|
|
}
|
|
/**
|
|
* Resize the LRU cache. This is for internal use
|
|
* @returns {void}
|
|
*/
|
|
lruResize() {
|
|
if (this._lruSize === 0) {
|
|
return;
|
|
}
|
|
while (this._lru.size > this._lruSize) {
|
|
const oldestKey = this._lru.getOldest();
|
|
if (oldestKey) {
|
|
this._lru.removeOldest();
|
|
this.delete(oldestKey);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Check for expiration. This is for internal use
|
|
* @returns {void}
|
|
*/
|
|
checkExpiration() {
|
|
const stores = this.concatStores();
|
|
for (const item of stores.values()) {
|
|
if (item.expires && Date.now() > item.expires) {
|
|
this.delete(item.key);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Start the interval check. This is for internal use
|
|
* @returns {void}
|
|
*/
|
|
startIntervalCheck() {
|
|
if (this._checkInterval > 0) {
|
|
if (this._interval) {
|
|
clearInterval(this._interval);
|
|
}
|
|
this._interval = setInterval(() => {
|
|
this.checkExpiration();
|
|
}, this._checkInterval).unref();
|
|
}
|
|
}
|
|
/**
|
|
* Stop the interval check. This is for internal use
|
|
* @returns {void}
|
|
*/
|
|
stopIntervalCheck() {
|
|
if (this._interval) {
|
|
clearInterval(this._interval);
|
|
}
|
|
this._interval = 0;
|
|
this._checkInterval = 0;
|
|
}
|
|
/**
|
|
* Hash the object. This is for internal use
|
|
* @param {any} object - The object to hash
|
|
* @param {string} [algorithm='sha256'] - The algorithm to hash
|
|
* @returns {string} - The hashed string
|
|
*/
|
|
hash(object2, algorithm = 'sha256') {
|
|
return hash(object2, algorithm);
|
|
}
|
|
/**
|
|
* Wrap the function for caching
|
|
* @param {Function} function_ - The function to wrap
|
|
* @param {Object} [options] - The options to wrap
|
|
* @returns {Function} - The wrapped function
|
|
*/
|
|
wrap(function_, options) {
|
|
const wrapOptions = {
|
|
ttl: (options == null ? void 0 : options.ttl) ?? this._ttl,
|
|
keyPrefix: options == null ? void 0 : options.keyPrefix,
|
|
cache: this,
|
|
};
|
|
return wrapSync(function_, wrapOptions);
|
|
}
|
|
isPrimitive(value) {
|
|
const result = false;
|
|
if (value === null || value === void 0) {
|
|
return true;
|
|
}
|
|
if (
|
|
typeof value === 'string' ||
|
|
typeof value === 'number' ||
|
|
typeof value === 'boolean'
|
|
) {
|
|
return true;
|
|
}
|
|
return result;
|
|
}
|
|
concatStores() {
|
|
return new Map([
|
|
...this._hash0,
|
|
...this._hash1,
|
|
...this._hash2,
|
|
...this._hash3,
|
|
...this._hash4,
|
|
...this._hash5,
|
|
...this._hash6,
|
|
...this._hash7,
|
|
...this._hash8,
|
|
...this._hash9,
|
|
]);
|
|
}
|
|
setTtl(ttl) {
|
|
if (typeof ttl === 'string' || ttl === void 0) {
|
|
this._ttl = ttl;
|
|
} else if (ttl > 0) {
|
|
this._ttl = ttl;
|
|
} else {
|
|
this._ttl = void 0;
|
|
}
|
|
}
|
|
};
|
|
|
|
// node_modules/flatted/esm/index.js
|
|
var { parse: $parse, stringify: $stringify } = JSON;
|
|
var { keys } = Object;
|
|
var Primitive = String;
|
|
var primitive = 'string';
|
|
var ignore = {};
|
|
var object = 'object';
|
|
var noop = (_2, value) => value;
|
|
var primitives = (value) =>
|
|
value instanceof Primitive ? Primitive(value) : value;
|
|
var Primitives = (_2, value) =>
|
|
typeof value === primitive ? new Primitive(value) : value;
|
|
var revive = (input, parsed, output, $) => {
|
|
const lazy = [];
|
|
for (let ke = keys(output), { length } = ke, y = 0; y < length; y++) {
|
|
const k = ke[y];
|
|
const value = output[k];
|
|
if (value instanceof Primitive) {
|
|
const tmp = input[value];
|
|
if (typeof tmp === object && !parsed.has(tmp)) {
|
|
parsed.add(tmp);
|
|
output[k] = ignore;
|
|
lazy.push({ k, a: [input, parsed, tmp, $] });
|
|
} else output[k] = $.call(output, k, tmp);
|
|
} else if (output[k] !== ignore) output[k] = $.call(output, k, value);
|
|
}
|
|
for (let { length } = lazy, i = 0; i < length; i++) {
|
|
const { k, a } = lazy[i];
|
|
output[k] = $.call(output, k, revive.apply(null, a));
|
|
}
|
|
return output;
|
|
};
|
|
var set = (known, input, value) => {
|
|
const index = Primitive(input.push(value) - 1);
|
|
known.set(value, index);
|
|
return index;
|
|
};
|
|
var parse = (text, reviver) => {
|
|
const input = $parse(text, Primitives).map(primitives);
|
|
const value = input[0];
|
|
const $ = reviver || noop;
|
|
const tmp =
|
|
typeof value === object && value ?
|
|
revive(input, /* @__PURE__ */ new Set(), value, $)
|
|
: value;
|
|
return $.call({ '': tmp }, '', tmp);
|
|
};
|
|
var stringify2 = (value, replacer, space) => {
|
|
const $ =
|
|
replacer && typeof replacer === object ?
|
|
(k, v) => (k === '' || -1 < replacer.indexOf(k) ? v : void 0)
|
|
: replacer || noop;
|
|
const known = /* @__PURE__ */ new Map();
|
|
const input = [];
|
|
const output = [];
|
|
let i = +set(known, input, $.call({ '': value }, '', value));
|
|
let firstRun = !i;
|
|
while (i < input.length) {
|
|
firstRun = true;
|
|
output[i] = $stringify(input[i++], replace, space);
|
|
}
|
|
return '[' + output.join(',') + ']';
|
|
function replace(key, value2) {
|
|
if (firstRun) {
|
|
firstRun = !firstRun;
|
|
return value2;
|
|
}
|
|
const after = $.call(this, key, value2);
|
|
switch (typeof after) {
|
|
case object:
|
|
if (after === null) return after;
|
|
case primitive:
|
|
return known.get(after) || set(known, input, after);
|
|
}
|
|
return after;
|
|
}
|
|
};
|
|
|
|
// node_modules/file-entry-cache/node_modules/flat-cache/dist/index.js
|
|
var FlatCache = class extends Hookified {
|
|
_cache = new CacheableMemory();
|
|
_cacheDir = '.cache';
|
|
_cacheId = 'cache1';
|
|
_persistInterval = 0;
|
|
_persistTimer;
|
|
_changesSinceLastSave = false;
|
|
_parse = parse;
|
|
_stringify = stringify2;
|
|
constructor(options) {
|
|
super();
|
|
if (options) {
|
|
this._cache = new CacheableMemory({
|
|
ttl: options.ttl,
|
|
useClone: options.useClone,
|
|
lruSize: options.lruSize,
|
|
checkInterval: options.expirationInterval,
|
|
});
|
|
}
|
|
if (options == null ? void 0 : options.cacheDir) {
|
|
this._cacheDir = options.cacheDir;
|
|
}
|
|
if (options == null ? void 0 : options.cacheId) {
|
|
this._cacheId = options.cacheId;
|
|
}
|
|
if (options == null ? void 0 : options.persistInterval) {
|
|
this._persistInterval = options.persistInterval;
|
|
this.startAutoPersist();
|
|
}
|
|
if (options == null ? void 0 : options.deserialize) {
|
|
this._parse = options.deserialize;
|
|
}
|
|
if (options == null ? void 0 : options.serialize) {
|
|
this._stringify = options.serialize;
|
|
}
|
|
}
|
|
/**
|
|
* The cache object
|
|
* @property cache
|
|
* @type {CacheableMemory}
|
|
*/
|
|
get cache() {
|
|
return this._cache;
|
|
}
|
|
/**
|
|
* The cache directory
|
|
* @property cacheDir
|
|
* @type {String}
|
|
* @default '.cache'
|
|
*/
|
|
get cacheDir() {
|
|
return this._cacheDir;
|
|
}
|
|
/**
|
|
* Set the cache directory
|
|
* @property cacheDir
|
|
* @type {String}
|
|
* @default '.cache'
|
|
*/
|
|
set cacheDir(value) {
|
|
this._cacheDir = value;
|
|
}
|
|
/**
|
|
* The cache id
|
|
* @property cacheId
|
|
* @type {String}
|
|
* @default 'cache1'
|
|
*/
|
|
get cacheId() {
|
|
return this._cacheId;
|
|
}
|
|
/**
|
|
* Set the cache id
|
|
* @property cacheId
|
|
* @type {String}
|
|
* @default 'cache1'
|
|
*/
|
|
set cacheId(value) {
|
|
this._cacheId = value;
|
|
}
|
|
/**
|
|
* The flag to indicate if there are changes since the last save
|
|
* @property changesSinceLastSave
|
|
* @type {Boolean}
|
|
* @default false
|
|
*/
|
|
get changesSinceLastSave() {
|
|
return this._changesSinceLastSave;
|
|
}
|
|
/**
|
|
* The interval to persist the cache to disk. 0 means no timed persistence
|
|
* @property persistInterval
|
|
* @type {Number}
|
|
* @default 0
|
|
*/
|
|
get persistInterval() {
|
|
return this._persistInterval;
|
|
}
|
|
/**
|
|
* Set the interval to persist the cache to disk. 0 means no timed persistence
|
|
* @property persistInterval
|
|
* @type {Number}
|
|
* @default 0
|
|
*/
|
|
set persistInterval(value) {
|
|
this._persistInterval = value;
|
|
}
|
|
/**
|
|
* Load a cache identified by the given Id. If the element does not exists, then initialize an empty
|
|
* cache storage. If specified `cacheDir` will be used as the directory to persist the data to. If omitted
|
|
* then the cache module directory `.cacheDir` will be used instead
|
|
*
|
|
* @method load
|
|
* @param cacheId {String} the id of the cache, would also be used as the name of the file cache
|
|
* @param cacheDir {String} directory for the cache entry
|
|
*/
|
|
// eslint-disable-next-line unicorn/prevent-abbreviations
|
|
load(cacheId, cacheDir) {
|
|
try {
|
|
const filePath = path9.resolve(
|
|
`${cacheDir ?? this._cacheDir}/${cacheId ?? this._cacheId}`
|
|
);
|
|
this.loadFile(filePath);
|
|
this.emit(
|
|
'load'
|
|
/* LOAD */
|
|
);
|
|
} catch (error) {
|
|
this.emit('error', error);
|
|
}
|
|
}
|
|
/**
|
|
* Load the cache from the provided file
|
|
* @method loadFile
|
|
* @param {String} pathToFile the path to the file containing the info for the cache
|
|
*/
|
|
loadFile(pathToFile) {
|
|
if (fs5.existsSync(pathToFile)) {
|
|
const data = fs5.readFileSync(pathToFile, 'utf8');
|
|
const items = this._parse(data);
|
|
for (const key of Object.keys(items)) {
|
|
this._cache.set(items[key].key, items[key].value, {
|
|
expire: items[key].expires,
|
|
});
|
|
}
|
|
this._changesSinceLastSave = true;
|
|
}
|
|
}
|
|
/**
|
|
* Returns the entire persisted object
|
|
* @method all
|
|
* @returns {*}
|
|
*/
|
|
all() {
|
|
const result = {};
|
|
const items = Array.from(this._cache.items);
|
|
for (const item of items) {
|
|
result[item.key] = item.value;
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Returns an array with all the items in the cache { key, value, ttl }
|
|
* @method items
|
|
* @returns {Array}
|
|
*/
|
|
get items() {
|
|
return Array.from(this._cache.items);
|
|
}
|
|
/**
|
|
* Returns the path to the file where the cache is persisted
|
|
* @method cacheFilePath
|
|
* @returns {String}
|
|
*/
|
|
get cacheFilePath() {
|
|
return path9.resolve(`${this._cacheDir}/${this._cacheId}`);
|
|
}
|
|
/**
|
|
* Returns the path to the cache directory
|
|
* @method cacheDirPath
|
|
* @returns {String}
|
|
*/
|
|
get cacheDirPath() {
|
|
return path9.resolve(this._cacheDir);
|
|
}
|
|
/**
|
|
* Returns an array with all the keys in the cache
|
|
* @method keys
|
|
* @returns {Array}
|
|
*/
|
|
keys() {
|
|
return Array.from(this._cache.keys);
|
|
}
|
|
/**
|
|
* (Legacy) set key method. This method will be deprecated in the future
|
|
* @method setKey
|
|
* @param key {string} the key to set
|
|
* @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
|
|
*/
|
|
setKey(key, value, ttl) {
|
|
this.set(key, value, ttl);
|
|
}
|
|
/**
|
|
* Sets a key to a given value
|
|
* @method set
|
|
* @param key {string} the key to set
|
|
* @param value {object} the value of the key. Could be any object that can be serialized with JSON.stringify
|
|
* @param [ttl] {number} the time to live in milliseconds
|
|
*/
|
|
set(key, value, ttl) {
|
|
this._cache.set(key, value, ttl);
|
|
this._changesSinceLastSave = true;
|
|
}
|
|
/**
|
|
* (Legacy) Remove a given key from the cache. This method will be deprecated in the future
|
|
* @method removeKey
|
|
* @param key {String} the key to remove from the object
|
|
*/
|
|
removeKey(key) {
|
|
this.delete(key);
|
|
}
|
|
/**
|
|
* Remove a given key from the cache
|
|
* @method delete
|
|
* @param key {String} the key to remove from the object
|
|
*/
|
|
delete(key) {
|
|
this._cache.delete(key);
|
|
this._changesSinceLastSave = true;
|
|
this.emit('delete', key);
|
|
}
|
|
/**
|
|
* (Legacy) Return the value of the provided key. This method will be deprecated in the future
|
|
* @method getKey<T>
|
|
* @param key {String} the name of the key to retrieve
|
|
* @returns {*} at T the value from the key
|
|
*/
|
|
getKey(key) {
|
|
return this.get(key);
|
|
}
|
|
/**
|
|
* Return the value of the provided key
|
|
* @method get<T>
|
|
* @param key {String} the name of the key to retrieve
|
|
* @returns {*} at T the value from the key
|
|
*/
|
|
get(key) {
|
|
return this._cache.get(key);
|
|
}
|
|
/**
|
|
* Clear the cache and save the state to disk
|
|
* @method clear
|
|
*/
|
|
clear() {
|
|
try {
|
|
this._cache.clear();
|
|
this._changesSinceLastSave = true;
|
|
this.save();
|
|
this.emit(
|
|
'clear'
|
|
/* CLEAR */
|
|
);
|
|
} catch (error) {
|
|
this.emit('error', error);
|
|
}
|
|
}
|
|
/**
|
|
* Save the state of the cache identified by the docId to disk
|
|
* as a JSON structure
|
|
* @method save
|
|
*/
|
|
save(force = false) {
|
|
try {
|
|
if (this._changesSinceLastSave || force) {
|
|
const filePath = this.cacheFilePath;
|
|
const items = Array.from(this._cache.items);
|
|
const data = this._stringify(items);
|
|
if (!fs5.existsSync(this._cacheDir)) {
|
|
fs5.mkdirSync(this._cacheDir, { recursive: true });
|
|
}
|
|
fs5.writeFileSync(filePath, data);
|
|
this._changesSinceLastSave = false;
|
|
this.emit(
|
|
'save'
|
|
/* SAVE */
|
|
);
|
|
}
|
|
} catch (error) {
|
|
this.emit('error', error);
|
|
}
|
|
}
|
|
/**
|
|
* Remove the file where the cache is persisted
|
|
* @method removeCacheFile
|
|
* @return {Boolean} true or false if the file was successfully deleted
|
|
*/
|
|
removeCacheFile() {
|
|
try {
|
|
if (fs5.existsSync(this.cacheFilePath)) {
|
|
fs5.rmSync(this.cacheFilePath);
|
|
return true;
|
|
}
|
|
} catch (error) {
|
|
this.emit('error', error);
|
|
}
|
|
return false;
|
|
}
|
|
/**
|
|
* Destroy the cache. This will remove the directory, file, and memory cache
|
|
* @method destroy
|
|
* @param [includeCacheDir=false] {Boolean} if true, the cache directory will be removed
|
|
* @return {undefined}
|
|
*/
|
|
destroy(includeCacheDirectory = false) {
|
|
try {
|
|
this._cache.clear();
|
|
this.stopAutoPersist();
|
|
if (includeCacheDirectory) {
|
|
fs5.rmSync(this.cacheDirPath, { recursive: true, force: true });
|
|
} else {
|
|
fs5.rmSync(this.cacheFilePath, { recursive: true, force: true });
|
|
}
|
|
this._changesSinceLastSave = false;
|
|
this.emit(
|
|
'destroy'
|
|
/* DESTROY */
|
|
);
|
|
} catch (error) {
|
|
this.emit('error', error);
|
|
}
|
|
}
|
|
/**
|
|
* Start the auto persist interval
|
|
* @method startAutoPersist
|
|
*/
|
|
startAutoPersist() {
|
|
if (this._persistInterval > 0) {
|
|
if (this._persistTimer) {
|
|
clearInterval(this._persistTimer);
|
|
this._persistTimer = void 0;
|
|
}
|
|
this._persistTimer = setInterval(() => {
|
|
this.save();
|
|
}, this._persistInterval);
|
|
}
|
|
}
|
|
/**
|
|
* Stop the auto persist interval
|
|
* @method stopAutoPersist
|
|
*/
|
|
stopAutoPersist() {
|
|
if (this._persistTimer) {
|
|
clearInterval(this._persistTimer);
|
|
this._persistTimer = void 0;
|
|
}
|
|
}
|
|
};
|
|
function createFromFile(filePath, options) {
|
|
const cache = new FlatCache(options);
|
|
cache.loadFile(filePath);
|
|
return cache;
|
|
}
|
|
|
|
// node_modules/file-entry-cache/dist/index.js
|
|
function createFromFile2(filePath, useCheckSum, currentWorkingDirectory) {
|
|
const fname = path10.basename(filePath);
|
|
const directory = path10.dirname(filePath);
|
|
return create(fname, directory, useCheckSum, currentWorkingDirectory);
|
|
}
|
|
function create(cacheId, cacheDirectory, useCheckSum, currentWorkingDirectory) {
|
|
const options = {
|
|
currentWorkingDirectory,
|
|
useCheckSum,
|
|
cache: {
|
|
cacheId,
|
|
cacheDir: cacheDirectory,
|
|
},
|
|
};
|
|
const fileEntryCache = new FileEntryCache(options);
|
|
if (cacheDirectory) {
|
|
const cachePath = `${cacheDirectory}/${cacheId}`;
|
|
if (fs6.existsSync(cachePath)) {
|
|
fileEntryCache.cache = createFromFile(cachePath, options.cache);
|
|
}
|
|
}
|
|
return fileEntryCache;
|
|
}
|
|
var FileEntryDefault = class {
|
|
static create = create;
|
|
static createFromFile = createFromFile2;
|
|
};
|
|
var FileEntryCache = class {
|
|
_cache = new FlatCache({ useClone: false });
|
|
_useCheckSum = false;
|
|
_currentWorkingDirectory;
|
|
_hashAlgorithm = 'md5';
|
|
constructor(options) {
|
|
if (options == null ? void 0 : options.cache) {
|
|
this._cache = new FlatCache(options.cache);
|
|
}
|
|
if (options == null ? void 0 : options.useCheckSum) {
|
|
this._useCheckSum = options.useCheckSum;
|
|
}
|
|
if (options == null ? void 0 : options.currentWorkingDirectory) {
|
|
this._currentWorkingDirectory = options.currentWorkingDirectory;
|
|
}
|
|
if (options == null ? void 0 : options.hashAlgorithm) {
|
|
this._hashAlgorithm = options.hashAlgorithm;
|
|
}
|
|
}
|
|
get cache() {
|
|
return this._cache;
|
|
}
|
|
set cache(cache) {
|
|
this._cache = cache;
|
|
}
|
|
get useCheckSum() {
|
|
return this._useCheckSum;
|
|
}
|
|
set useCheckSum(value) {
|
|
this._useCheckSum = value;
|
|
}
|
|
get hashAlgorithm() {
|
|
return this._hashAlgorithm;
|
|
}
|
|
set hashAlgorithm(value) {
|
|
this._hashAlgorithm = value;
|
|
}
|
|
get currentWorkingDirectory() {
|
|
return this._currentWorkingDirectory;
|
|
}
|
|
set currentWorkingDirectory(value) {
|
|
this._currentWorkingDirectory = value;
|
|
}
|
|
/**
|
|
* Given a buffer, calculate md5 hash of its content.
|
|
* @method getHash
|
|
* @param {Buffer} buffer buffer to calculate hash on
|
|
* @return {String} content hash digest
|
|
*/
|
|
// eslint-disable-next-line @typescript-eslint/ban-types
|
|
getHash(buffer) {
|
|
return crypto2.createHash(this._hashAlgorithm).update(buffer).digest('hex');
|
|
}
|
|
/**
|
|
* Create the key for the file path used for caching.
|
|
* @method createFileKey
|
|
* @param {String} filePath
|
|
* @return {String}
|
|
*/
|
|
createFileKey(filePath, options) {
|
|
let result = filePath;
|
|
const currentWorkingDirectory =
|
|
(options == null ? void 0 : options.currentWorkingDirectory) ??
|
|
this._currentWorkingDirectory;
|
|
if (
|
|
currentWorkingDirectory &&
|
|
filePath.startsWith(currentWorkingDirectory)
|
|
) {
|
|
const splitPath = filePath.split(currentWorkingDirectory).pop();
|
|
if (splitPath) {
|
|
result = splitPath;
|
|
if (result.startsWith('/')) {
|
|
result = result.slice(1);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Check if the file path is a relative path
|
|
* @method isRelativePath
|
|
* @param filePath - The file path to check
|
|
* @returns {boolean} if the file path is a relative path, false otherwise
|
|
*/
|
|
isRelativePath(filePath) {
|
|
return !path10.isAbsolute(filePath);
|
|
}
|
|
/**
|
|
* Delete the cache file from the disk
|
|
* @method deleteCacheFile
|
|
* @return {boolean} true if the file was deleted, false otherwise
|
|
*/
|
|
deleteCacheFile() {
|
|
return this._cache.removeCacheFile();
|
|
}
|
|
/**
|
|
* Remove the cache from the file and clear the memory cache
|
|
* @method destroy
|
|
*/
|
|
destroy() {
|
|
this._cache.destroy();
|
|
}
|
|
/**
|
|
* Remove and Entry From the Cache
|
|
* @method removeEntry
|
|
* @param filePath - The file path to remove from the cache
|
|
*/
|
|
removeEntry(filePath, options) {
|
|
if (this.isRelativePath(filePath)) {
|
|
filePath = this.getAbsolutePath(filePath, {
|
|
currentWorkingDirectory:
|
|
options == null ? void 0 : options.currentWorkingDirectory,
|
|
});
|
|
this._cache.removeKey(this.createFileKey(filePath));
|
|
}
|
|
const key = this.createFileKey(filePath, {
|
|
currentWorkingDirectory:
|
|
options == null ? void 0 : options.currentWorkingDirectory,
|
|
});
|
|
this._cache.removeKey(key);
|
|
}
|
|
/**
|
|
* Reconcile the cache
|
|
* @method reconcile
|
|
*/
|
|
reconcile() {
|
|
const items = this._cache.items;
|
|
for (const item of items) {
|
|
const fileDescriptor = this.getFileDescriptor(item.key);
|
|
if (fileDescriptor.notFound) {
|
|
this._cache.removeKey(item.key);
|
|
}
|
|
}
|
|
this._cache.save();
|
|
}
|
|
/**
|
|
* Check if the file has changed
|
|
* @method hasFileChanged
|
|
* @param filePath - The file path to check
|
|
* @returns {boolean} if the file has changed, false otherwise
|
|
*/
|
|
hasFileChanged(filePath) {
|
|
let result = false;
|
|
const fileDescriptor = this.getFileDescriptor(filePath);
|
|
if (
|
|
(!fileDescriptor.err || !fileDescriptor.notFound) &&
|
|
fileDescriptor.changed
|
|
) {
|
|
result = true;
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Get the file descriptor for the file path
|
|
* @method getFileDescriptor
|
|
* @param filePath - The file path to get the file descriptor for
|
|
* @param options - The options for getting the file descriptor
|
|
* @returns The file descriptor
|
|
*/
|
|
getFileDescriptor(filePath, options) {
|
|
var _a, _b, _c;
|
|
let fstat;
|
|
const result = {
|
|
key: this.createFileKey(filePath),
|
|
changed: false,
|
|
meta: {},
|
|
};
|
|
result.meta = this._cache.getKey(result.key) ?? {};
|
|
filePath = this.getAbsolutePath(filePath, {
|
|
currentWorkingDirectory:
|
|
options == null ? void 0 : options.currentWorkingDirectory,
|
|
});
|
|
const useCheckSumValue =
|
|
(options == null ? void 0 : options.useCheckSum) ?? this._useCheckSum;
|
|
try {
|
|
fstat = fs6.statSync(filePath);
|
|
result.meta = {
|
|
size: fstat.size,
|
|
};
|
|
result.meta.mtime = fstat.mtime.getTime();
|
|
if (useCheckSumValue) {
|
|
const buffer = fs6.readFileSync(filePath);
|
|
result.meta.hash = this.getHash(buffer);
|
|
}
|
|
} catch (error) {
|
|
this.removeEntry(filePath);
|
|
let notFound = false;
|
|
if (error.message.includes('ENOENT')) {
|
|
notFound = true;
|
|
}
|
|
return {
|
|
key: result.key,
|
|
err: error,
|
|
notFound,
|
|
meta: {},
|
|
};
|
|
}
|
|
const metaCache = this._cache.getKey(result.key);
|
|
if (!metaCache) {
|
|
result.changed = true;
|
|
this._cache.setKey(result.key, result.meta);
|
|
return result;
|
|
}
|
|
if (result.meta.data === void 0) {
|
|
result.meta.data = metaCache.data;
|
|
}
|
|
if (
|
|
(metaCache == null ? void 0 : metaCache.mtime) !==
|
|
((_a = result.meta) == null ? void 0 : _a.mtime) ||
|
|
(metaCache == null ? void 0 : metaCache.size) !==
|
|
((_b = result.meta) == null ? void 0 : _b.size)
|
|
) {
|
|
result.changed = true;
|
|
}
|
|
if (
|
|
useCheckSumValue &&
|
|
(metaCache == null ? void 0 : metaCache.hash) !==
|
|
((_c = result.meta) == null ? void 0 : _c.hash)
|
|
) {
|
|
result.changed = true;
|
|
}
|
|
this._cache.setKey(result.key, result.meta);
|
|
return result;
|
|
}
|
|
/**
|
|
* Get the file descriptors for the files
|
|
* @method normalizeEntries
|
|
* @param files?: string[] - The files to get the file descriptors for
|
|
* @returns The file descriptors
|
|
*/
|
|
normalizeEntries(files) {
|
|
const result = new Array();
|
|
if (files) {
|
|
for (const file of files) {
|
|
const fileDescriptor = this.getFileDescriptor(file);
|
|
result.push(fileDescriptor);
|
|
}
|
|
return result;
|
|
}
|
|
const keys2 = this.cache.keys();
|
|
for (const key of keys2) {
|
|
const fileDescriptor = this.getFileDescriptor(key);
|
|
if (!fileDescriptor.notFound && !fileDescriptor.err) {
|
|
result.push(fileDescriptor);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Analyze the files
|
|
* @method analyzeFiles
|
|
* @param files - The files to analyze
|
|
* @returns {AnalyzedFiles} The analysis of the files
|
|
*/
|
|
analyzeFiles(files) {
|
|
const result = {
|
|
changedFiles: [],
|
|
notFoundFiles: [],
|
|
notChangedFiles: [],
|
|
};
|
|
const fileDescriptors = this.normalizeEntries(files);
|
|
for (const fileDescriptor of fileDescriptors) {
|
|
if (fileDescriptor.notFound) {
|
|
result.notFoundFiles.push(fileDescriptor.key);
|
|
} else if (fileDescriptor.changed) {
|
|
result.changedFiles.push(fileDescriptor.key);
|
|
} else {
|
|
result.notChangedFiles.push(fileDescriptor.key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Get the updated files
|
|
* @method getUpdatedFiles
|
|
* @param files - The files to get the updated files for
|
|
* @returns {string[]} The updated files
|
|
*/
|
|
getUpdatedFiles(files) {
|
|
const result = new Array();
|
|
const fileDescriptors = this.normalizeEntries(files);
|
|
for (const fileDescriptor of fileDescriptors) {
|
|
if (fileDescriptor.changed) {
|
|
result.push(fileDescriptor.key);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Get the not found files
|
|
* @method getFileDescriptorsByPath
|
|
* @param filePath - the files that you want to get from a path
|
|
* @returns {FileDescriptor[]} The not found files
|
|
*/
|
|
getFileDescriptorsByPath(filePath) {
|
|
const result = new Array();
|
|
const keys2 = this._cache.keys();
|
|
for (const key of keys2) {
|
|
const absolutePath = this.getAbsolutePath(filePath);
|
|
if (absolutePath.startsWith(filePath)) {
|
|
const fileDescriptor = this.getFileDescriptor(key);
|
|
result.push(fileDescriptor);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
/**
|
|
* Get the Absolute Path. If it is already absolute it will return the path as is.
|
|
* @method getAbsolutePath
|
|
* @param filePath - The file path to get the absolute path for
|
|
* @param options - The options for getting the absolute path. The current working directory is used if not provided.
|
|
* @returns {string}
|
|
*/
|
|
getAbsolutePath(filePath, options) {
|
|
if (this.isRelativePath(filePath)) {
|
|
const currentWorkingDirectory =
|
|
(options == null ? void 0 : options.currentWorkingDirectory) ??
|
|
this._currentWorkingDirectory ??
|
|
process.cwd();
|
|
filePath = path10.resolve(currentWorkingDirectory, filePath);
|
|
}
|
|
return filePath;
|
|
}
|
|
/**
|
|
* Rename the absolute path keys. This is used when a directory is changed or renamed.
|
|
* @method renameAbsolutePathKeys
|
|
* @param oldPath - The old path to rename
|
|
* @param newPath - The new path to rename to
|
|
*/
|
|
renameAbsolutePathKeys(oldPath, newPath) {
|
|
const keys2 = this._cache.keys();
|
|
for (const key of keys2) {
|
|
if (key.startsWith(oldPath)) {
|
|
const newKey = key.replace(oldPath, newPath);
|
|
const meta = this._cache.getKey(key);
|
|
this._cache.removeKey(key);
|
|
this._cache.setKey(newKey, meta);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// src/cli/format-results-cache.js
|
|
import { version as prettierVersion } from '../index.mjs';
|
|
var optionsHashCache = /* @__PURE__ */ new WeakMap();
|
|
var nodeVersion = process.version;
|
|
function getHashOfOptions(options) {
|
|
if (optionsHashCache.has(options)) {
|
|
return optionsHashCache.get(options);
|
|
}
|
|
const hash2 = createHash(
|
|
`${prettierVersion}_${nodeVersion}_${(0, import_fast_json_stable_stringify2.default)(options)}`
|
|
);
|
|
optionsHashCache.set(options, hash2);
|
|
return hash2;
|
|
}
|
|
function getMetadataFromFileDescriptor(fileDescriptor) {
|
|
return fileDescriptor.meta;
|
|
}
|
|
var _fileEntryCache;
|
|
var FormatResultsCache = class {
|
|
/**
|
|
* @param {string} cacheFileLocation The path of cache file location. (default: `node_modules/.cache/prettier/.prettier-cache`)
|
|
* @param {string} cacheStrategy
|
|
*/
|
|
constructor(cacheFileLocation, cacheStrategy) {
|
|
__privateAdd(this, _fileEntryCache);
|
|
const useChecksum = cacheStrategy === 'content';
|
|
try {
|
|
__privateSet(
|
|
this,
|
|
_fileEntryCache,
|
|
FileEntryDefault.createFromFile(
|
|
/* filePath */
|
|
cacheFileLocation,
|
|
useChecksum
|
|
)
|
|
);
|
|
} catch {
|
|
if (fs7.existsSync(cacheFileLocation)) {
|
|
fs7.unlinkSync(cacheFileLocation);
|
|
__privateSet(
|
|
this,
|
|
_fileEntryCache,
|
|
FileEntryDefault.createFromFile(
|
|
/* filePath */
|
|
cacheFileLocation,
|
|
useChecksum
|
|
)
|
|
);
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* @param {string} filePath
|
|
* @param {any} options
|
|
*/
|
|
existsAvailableFormatResultsCache(filePath, options) {
|
|
var _a;
|
|
const fileDescriptor = __privateGet(
|
|
this,
|
|
_fileEntryCache
|
|
).getFileDescriptor(filePath);
|
|
if (fileDescriptor.notFound || fileDescriptor.changed) {
|
|
return false;
|
|
}
|
|
const hashOfOptions =
|
|
(_a = getMetadataFromFileDescriptor(fileDescriptor).data) == null ?
|
|
void 0
|
|
: _a.hashOfOptions;
|
|
return hashOfOptions && hashOfOptions === getHashOfOptions(options);
|
|
}
|
|
/**
|
|
* @param {string} filePath
|
|
* @param {any} options
|
|
*/
|
|
setFormatResultsCache(filePath, options) {
|
|
const fileDescriptor = __privateGet(
|
|
this,
|
|
_fileEntryCache
|
|
).getFileDescriptor(filePath);
|
|
if (!fileDescriptor.notFound) {
|
|
const meta = getMetadataFromFileDescriptor(fileDescriptor);
|
|
meta.data = { ...meta.data, hashOfOptions: getHashOfOptions(options) };
|
|
}
|
|
}
|
|
/**
|
|
* @param {string} filePath
|
|
*/
|
|
removeFormatResultsCache(filePath) {
|
|
__privateGet(this, _fileEntryCache).removeEntry(filePath);
|
|
}
|
|
reconcile() {
|
|
__privateGet(this, _fileEntryCache).reconcile();
|
|
}
|
|
};
|
|
_fileEntryCache = new WeakMap();
|
|
var format_results_cache_default = FormatResultsCache;
|
|
|
|
// src/cli/is-tty.js
|
|
function isTTY() {
|
|
return process.stdout.isTTY && !mockable.isCI();
|
|
}
|
|
|
|
// src/cli/options/get-options-for-file.js
|
|
var import_dashify2 = __toESM(require_dashify(), 1);
|
|
import { resolveConfig } from '../index.mjs';
|
|
function getOptions(argv, detailedOptions) {
|
|
return Object.fromEntries(
|
|
detailedOptions
|
|
.filter(({ forwardToApi }) => forwardToApi)
|
|
.map(({ forwardToApi, name }) => [forwardToApi, argv[name]])
|
|
);
|
|
}
|
|
function cliifyOptions(object2, apiDetailedOptionMap) {
|
|
return Object.fromEntries(
|
|
Object.entries(object2 || {}).map(([key, value]) => {
|
|
const apiOption = apiDetailedOptionMap[key];
|
|
const cliKey = apiOption ? apiOption.name : key;
|
|
return [(0, import_dashify2.default)(cliKey), value];
|
|
})
|
|
);
|
|
}
|
|
function createApiDetailedOptionMap(detailedOptions) {
|
|
return Object.fromEntries(
|
|
detailedOptions
|
|
.filter(
|
|
(option) => option.forwardToApi && option.forwardToApi !== option.name
|
|
)
|
|
.map((option) => [option.forwardToApi, option])
|
|
);
|
|
}
|
|
function parseArgsToOptions(context, overrideDefaults) {
|
|
const minimistOptions = createMinimistOptions(context.detailedOptions);
|
|
const apiDetailedOptionMap = createApiDetailedOptionMap(
|
|
context.detailedOptions
|
|
);
|
|
return getOptions(
|
|
normalize_cli_options_default(
|
|
minimistParse(context.rawArguments, {
|
|
string: minimistOptions.string,
|
|
boolean: minimistOptions.boolean,
|
|
default: cliifyOptions(overrideDefaults, apiDetailedOptionMap),
|
|
}),
|
|
context.detailedOptions,
|
|
{ logger: false }
|
|
),
|
|
context.detailedOptions
|
|
);
|
|
}
|
|
async function getOptionsOrDie(context, filePath) {
|
|
try {
|
|
if (context.argv.config === false) {
|
|
context.logger.debug(
|
|
"'--no-config' option found, skip loading config file."
|
|
);
|
|
return null;
|
|
}
|
|
context.logger.debug(
|
|
context.argv.config ?
|
|
`load config file from '${context.argv.config}'`
|
|
: `resolve config from '${filePath}'`
|
|
);
|
|
const options = await resolveConfig(filePath, {
|
|
editorconfig: context.argv.editorconfig,
|
|
config: context.argv.config,
|
|
});
|
|
context.logger.debug('loaded options `' + JSON.stringify(options) + '`');
|
|
return options;
|
|
} catch (error) {
|
|
context.logger.error(
|
|
`Invalid configuration${filePath ? ` for file "${filePath}"` : ''}:
|
|
` + error.message
|
|
);
|
|
process.exit(2);
|
|
}
|
|
}
|
|
function applyConfigPrecedence(context, options) {
|
|
try {
|
|
switch (context.argv.configPrecedence) {
|
|
case 'cli-override':
|
|
return parseArgsToOptions(context, options);
|
|
case 'file-override':
|
|
return { ...parseArgsToOptions(context), ...options };
|
|
case 'prefer-file':
|
|
return options || parseArgsToOptions(context);
|
|
}
|
|
} catch (error) {
|
|
context.logger.error(error.toString());
|
|
process.exit(2);
|
|
}
|
|
}
|
|
async function getOptionsForFile(context, filepath) {
|
|
const options = await getOptionsOrDie(context, filepath);
|
|
const hasPlugins = options == null ? void 0 : options.plugins;
|
|
if (hasPlugins) {
|
|
await context.pushContextPlugins(options.plugins);
|
|
}
|
|
const appliedOptions = {
|
|
filepath,
|
|
...applyConfigPrecedence(
|
|
context,
|
|
options &&
|
|
normalizeOptions(options, context.supportOptions, {
|
|
logger: context.logger,
|
|
})
|
|
),
|
|
};
|
|
context.logger.debug(
|
|
`applied config-precedence (${context.argv.configPrecedence}): ${JSON.stringify(appliedOptions)}`
|
|
);
|
|
if (hasPlugins) {
|
|
context.popContextPlugins();
|
|
}
|
|
return appliedOptions;
|
|
}
|
|
var get_options_for_file_default = getOptionsForFile;
|
|
|
|
// src/cli/format.js
|
|
var { getStdin, writeFormattedFile } = mockable;
|
|
function diff(a, b) {
|
|
return createTwoFilesPatch('', '', a, b, '', '', { context: 2 });
|
|
}
|
|
var DebugError = class extends Error {
|
|
name = 'DebugError';
|
|
};
|
|
function handleError(context, filename, error, printedFilename, ignoreUnknown) {
|
|
ignoreUnknown || (ignoreUnknown = context.argv.ignoreUnknown);
|
|
const errorIsUndefinedParseError =
|
|
error instanceof errors.UndefinedParserError;
|
|
if (printedFilename) {
|
|
if ((context.argv.write || ignoreUnknown) && errorIsUndefinedParseError) {
|
|
printedFilename.clear();
|
|
} else {
|
|
process.stdout.write('\n');
|
|
}
|
|
}
|
|
if (errorIsUndefinedParseError) {
|
|
if (ignoreUnknown) {
|
|
return;
|
|
}
|
|
if (!context.argv.check && !context.argv.listDifferent) {
|
|
process.exitCode = 2;
|
|
}
|
|
context.logger.error(error.message);
|
|
return;
|
|
}
|
|
const isParseError = Boolean(error == null ? void 0 : error.loc);
|
|
const isValidationError = /^Invalid \S+ value\./u.test(
|
|
error == null ? void 0 : error.message
|
|
);
|
|
if (isParseError) {
|
|
context.logger.error(`${filename}: ${String(error)}`);
|
|
} else if (isValidationError || error instanceof errors.ConfigError) {
|
|
context.logger.error(error.message);
|
|
process.exit(1);
|
|
} else if (error instanceof DebugError) {
|
|
context.logger.error(`${filename}: ${error.message}`);
|
|
} else {
|
|
context.logger.error(filename + ': ' + (error.stack || error));
|
|
}
|
|
process.exitCode = 2;
|
|
}
|
|
function writeOutput(context, result, options) {
|
|
process.stdout.write(
|
|
context.argv.debugCheck ? result.filepath : result.formatted
|
|
);
|
|
if (options && options.cursorOffset >= 0) {
|
|
process.stderr.write(result.cursorOffset + '\n');
|
|
}
|
|
}
|
|
async function listDifferent(context, input, options, filename) {
|
|
if (!context.argv.check && !context.argv.listDifferent) {
|
|
return;
|
|
}
|
|
try {
|
|
if (!(await prettier.check(input, options)) && !context.argv.write) {
|
|
context.logger.log(filename);
|
|
process.exitCode = 1;
|
|
}
|
|
} catch (error) {
|
|
context.logger.error(error.message);
|
|
}
|
|
return true;
|
|
}
|
|
async function format3(context, input, opt) {
|
|
if (context.argv.debugPrintDoc) {
|
|
const doc = await prettier.__debug.printToDoc(input, opt);
|
|
return { formatted: (await prettier.__debug.formatDoc(doc)) + '\n' };
|
|
}
|
|
if (context.argv.debugPrintComments) {
|
|
return {
|
|
formatted: await prettier.format(
|
|
JSON.stringify(
|
|
(await prettier.formatWithCursor(input, opt)).comments || []
|
|
),
|
|
{ parser: 'json' }
|
|
),
|
|
};
|
|
}
|
|
if (context.argv.debugPrintAst) {
|
|
const { ast } = await prettier.__debug.parse(input, opt);
|
|
return {
|
|
formatted: JSON.stringify(ast),
|
|
};
|
|
}
|
|
if (context.argv.debugCheck) {
|
|
const pp = await prettier.format(input, opt);
|
|
const pppp = await prettier.format(pp, opt);
|
|
if (pp !== pppp) {
|
|
throw new DebugError(
|
|
'prettier(input) !== prettier(prettier(input))\n' + diff(pp, pppp)
|
|
);
|
|
} else {
|
|
const stringify5 = (obj) => JSON.stringify(obj, null, 2);
|
|
const ast = stringify5(
|
|
(await prettier.__debug.parse(input, opt, { massage: true })).ast
|
|
);
|
|
const past = stringify5(
|
|
(await prettier.__debug.parse(pp, opt, { massage: true })).ast
|
|
);
|
|
if (ast !== past) {
|
|
const MAX_AST_SIZE = 2097152;
|
|
const astDiff =
|
|
ast.length > MAX_AST_SIZE || past.length > MAX_AST_SIZE ?
|
|
'AST diff too large to render'
|
|
: diff(ast, past);
|
|
throw new DebugError(
|
|
'ast(input) !== ast(prettier(input))\n' +
|
|
astDiff +
|
|
'\n' +
|
|
diff(input, pp)
|
|
);
|
|
}
|
|
}
|
|
return { formatted: pp, filepath: opt.filepath || '(stdin)\n' };
|
|
}
|
|
const { performanceTestFlag } = context;
|
|
if (
|
|
performanceTestFlag == null ? void 0 : performanceTestFlag.debugBenchmark
|
|
) {
|
|
let benchmark;
|
|
try {
|
|
({ default: benchmark } = await import('benchmark'));
|
|
} catch {
|
|
context.logger.debug(
|
|
"'--debug-benchmark' requires the 'benchmark' package to be installed."
|
|
);
|
|
process.exit(2);
|
|
}
|
|
context.logger.debug(
|
|
"'--debug-benchmark' option found, measuring formatWithCursor with 'benchmark' module."
|
|
);
|
|
const suite = new benchmark.Suite();
|
|
suite.add('format', {
|
|
defer: true,
|
|
async fn(deferred) {
|
|
await prettier.formatWithCursor(input, opt);
|
|
deferred.resolve();
|
|
},
|
|
});
|
|
const result = await new Promise((resolve) => {
|
|
suite
|
|
.on('complete', (event) => {
|
|
resolve({
|
|
benchmark: String(event.target),
|
|
hz: event.target.hz,
|
|
ms: event.target.times.cycle * 1e3,
|
|
});
|
|
})
|
|
.run({ async: false });
|
|
});
|
|
context.logger.debug(
|
|
"'--debug-benchmark' measurements for formatWithCursor: " +
|
|
JSON.stringify(result, null, 2)
|
|
);
|
|
} else if (
|
|
performanceTestFlag == null ? void 0 : performanceTestFlag.debugRepeat
|
|
) {
|
|
const repeat = performanceTestFlag.debugRepeat;
|
|
context.logger.debug(
|
|
`'${performanceTestFlag.name}' found, running formatWithCursor ${repeat} times.`
|
|
);
|
|
let totalMs = 0;
|
|
for (let i = 0; i < repeat; ++i) {
|
|
const startMs = Date.now();
|
|
await prettier.formatWithCursor(input, opt);
|
|
totalMs += Date.now() - startMs;
|
|
}
|
|
const averageMs = totalMs / repeat;
|
|
const results = {
|
|
repeat,
|
|
hz: 1e3 / averageMs,
|
|
ms: averageMs,
|
|
};
|
|
context.logger.debug(
|
|
`'${performanceTestFlag.name}' measurements for formatWithCursor: ${JSON.stringify(
|
|
results,
|
|
null,
|
|
2
|
|
)}`
|
|
);
|
|
}
|
|
return prettier.formatWithCursor(input, opt);
|
|
}
|
|
async function createIsIgnoredFromContextOrDie(context) {
|
|
try {
|
|
return await createIsIgnoredFunction(
|
|
context.argv.ignorePath,
|
|
context.argv.withNodeModules
|
|
);
|
|
} catch (e) {
|
|
context.logger.error(e.message);
|
|
process.exit(2);
|
|
}
|
|
}
|
|
async function formatStdin(context) {
|
|
const { filepath } = context.argv;
|
|
try {
|
|
const input = await getStdin();
|
|
let isFileIgnored = false;
|
|
if (filepath) {
|
|
const isIgnored = await createIsIgnoredFromContextOrDie(context);
|
|
isFileIgnored = isIgnored(filepath);
|
|
}
|
|
if (isFileIgnored) {
|
|
writeOutput(context, { formatted: input });
|
|
return;
|
|
}
|
|
const options = await get_options_for_file_default(
|
|
context,
|
|
filepath ? path11.resolve(filepath) : void 0
|
|
);
|
|
if (await listDifferent(context, input, options, '(stdin)')) {
|
|
return;
|
|
}
|
|
const formatted = await format3(context, input, options);
|
|
const { performanceTestFlag } = context;
|
|
if (performanceTestFlag) {
|
|
context.logger.log(
|
|
`'${performanceTestFlag.name}' option found, skipped print code to screen.`
|
|
);
|
|
return;
|
|
}
|
|
writeOutput(context, formatted, options);
|
|
} catch (error) {
|
|
handleError(context, filepath || 'stdin', error);
|
|
}
|
|
}
|
|
async function formatFiles(context) {
|
|
const isIgnored = await createIsIgnoredFromContextOrDie(context);
|
|
const cwd2 = process.cwd();
|
|
let numberOfUnformattedFilesFound = 0;
|
|
const { performanceTestFlag } = context;
|
|
if (context.argv.check && !performanceTestFlag) {
|
|
context.logger.log('Checking formatting...');
|
|
}
|
|
let formatResultsCache;
|
|
const cacheFilePath = await find_cache_file_default(
|
|
context.argv.cacheLocation
|
|
);
|
|
if (context.argv.cache) {
|
|
formatResultsCache = new format_results_cache_default(
|
|
cacheFilePath,
|
|
context.argv.cacheStrategy || 'content'
|
|
);
|
|
} else if (!context.argv.cacheLocation) {
|
|
const stat = await statSafe(cacheFilePath);
|
|
if (stat) {
|
|
await fs8.unlink(cacheFilePath);
|
|
}
|
|
}
|
|
for await (const { error, filename, ignoreUnknown } of expandPatterns(
|
|
context
|
|
)) {
|
|
if (error) {
|
|
context.logger.error(error);
|
|
process.exitCode = 2;
|
|
continue;
|
|
}
|
|
const isFileIgnored = isIgnored(filename);
|
|
if (
|
|
isFileIgnored &&
|
|
(context.argv.debugCheck ||
|
|
context.argv.write ||
|
|
context.argv.check ||
|
|
context.argv.listDifferent)
|
|
) {
|
|
continue;
|
|
}
|
|
const options = {
|
|
...(await get_options_for_file_default(context, filename)),
|
|
filepath: filename,
|
|
};
|
|
const fileNameToDisplay = normalizeToPosix(path11.relative(cwd2, filename));
|
|
let printedFilename;
|
|
if (isTTY()) {
|
|
printedFilename = context.logger.log(fileNameToDisplay, {
|
|
newline: false,
|
|
clearable: true,
|
|
});
|
|
}
|
|
let input;
|
|
try {
|
|
input = await fs8.readFile(filename, 'utf8');
|
|
} catch (error2) {
|
|
context.logger.log('');
|
|
context.logger.error(
|
|
`Unable to read file "${fileNameToDisplay}":
|
|
${error2.message}`
|
|
);
|
|
process.exitCode = 2;
|
|
continue;
|
|
}
|
|
if (isFileIgnored) {
|
|
printedFilename == null ? void 0 : printedFilename.clear();
|
|
writeOutput(context, { formatted: input }, options);
|
|
continue;
|
|
}
|
|
const start = Date.now();
|
|
const isCacheExists =
|
|
formatResultsCache == null ? void 0 : (
|
|
formatResultsCache.existsAvailableFormatResultsCache(filename, options)
|
|
);
|
|
let result;
|
|
let output;
|
|
try {
|
|
if (isCacheExists) {
|
|
result = { formatted: input };
|
|
} else {
|
|
result = await format3(context, input, options);
|
|
}
|
|
output = result.formatted;
|
|
} catch (error2) {
|
|
handleError(
|
|
context,
|
|
fileNameToDisplay,
|
|
error2,
|
|
printedFilename,
|
|
ignoreUnknown
|
|
);
|
|
continue;
|
|
}
|
|
const isDifferent = output !== input;
|
|
let shouldSetCache = !isDifferent;
|
|
printedFilename == null ? void 0 : printedFilename.clear();
|
|
if (performanceTestFlag) {
|
|
context.logger.log(
|
|
`'${performanceTestFlag.name}' option found, skipped print code or write files.`
|
|
);
|
|
return;
|
|
}
|
|
if (context.argv.write) {
|
|
if (isDifferent) {
|
|
if (!context.argv.check && !context.argv.listDifferent) {
|
|
context.logger.log(`${fileNameToDisplay} ${Date.now() - start}ms`);
|
|
}
|
|
try {
|
|
await writeFormattedFile(filename, output);
|
|
shouldSetCache = true;
|
|
} catch (error2) {
|
|
context.logger.error(
|
|
`Unable to write file "${fileNameToDisplay}":
|
|
${error2.message}`
|
|
);
|
|
process.exitCode = 2;
|
|
}
|
|
} else if (!context.argv.check && !context.argv.listDifferent) {
|
|
const message = `${source_default.grey(fileNameToDisplay)} ${Date.now() - start}ms (unchanged)`;
|
|
if (isCacheExists) {
|
|
context.logger.log(`${message} (cached)`);
|
|
} else {
|
|
context.logger.log(message);
|
|
}
|
|
}
|
|
} else if (context.argv.debugCheck) {
|
|
if (result.filepath) {
|
|
context.logger.log(fileNameToDisplay);
|
|
} else {
|
|
process.exitCode = 2;
|
|
}
|
|
} else if (!context.argv.check && !context.argv.listDifferent) {
|
|
writeOutput(context, result, options);
|
|
}
|
|
if (shouldSetCache) {
|
|
formatResultsCache == null ? void 0 : (
|
|
formatResultsCache.setFormatResultsCache(filename, options)
|
|
);
|
|
} else {
|
|
formatResultsCache == null ? void 0 : (
|
|
formatResultsCache.removeFormatResultsCache(filename)
|
|
);
|
|
}
|
|
if (isDifferent) {
|
|
if (context.argv.check) {
|
|
context.logger.warn(fileNameToDisplay);
|
|
} else if (context.argv.listDifferent) {
|
|
context.logger.log(fileNameToDisplay);
|
|
}
|
|
numberOfUnformattedFilesFound += 1;
|
|
}
|
|
}
|
|
formatResultsCache == null ? void 0 : formatResultsCache.reconcile();
|
|
if (context.argv.check) {
|
|
if (numberOfUnformattedFilesFound === 0) {
|
|
context.logger.log('All matched files use Prettier code style!');
|
|
} else {
|
|
const files =
|
|
numberOfUnformattedFilesFound === 1 ? 'the above file' : (
|
|
`${numberOfUnformattedFilesFound} files`
|
|
);
|
|
context.logger.warn(
|
|
context.argv.write ?
|
|
`Code style issues fixed in ${files}.`
|
|
: `Code style issues found in ${files}. Run Prettier with --write to fix.`
|
|
);
|
|
}
|
|
}
|
|
if (
|
|
(context.argv.check || context.argv.listDifferent) &&
|
|
numberOfUnformattedFilesFound > 0 &&
|
|
!process.exitCode &&
|
|
!context.argv.write
|
|
) {
|
|
process.exitCode = 1;
|
|
}
|
|
}
|
|
|
|
// src/cli/logger.js
|
|
import readline from 'readline';
|
|
|
|
// node_modules/strip-ansi/node_modules/ansi-regex/index.js
|
|
function ansiRegex({ onlyFirst = false } = {}) {
|
|
const ST = '(?:\\u0007|\\u001B\\u005C|\\u009C)';
|
|
const pattern = [
|
|
`[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?${ST})`,
|
|
'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))',
|
|
].join('|');
|
|
return new RegExp(pattern, onlyFirst ? void 0 : 'g');
|
|
}
|
|
|
|
// node_modules/strip-ansi/index.js
|
|
var regex = ansiRegex();
|
|
function stripAnsi(string) {
|
|
if (typeof string !== 'string') {
|
|
throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
|
|
}
|
|
return string.replace(regex, '');
|
|
}
|
|
|
|
// node_modules/wcwidth.js/combining.js
|
|
var combining_default = [
|
|
[768, 879],
|
|
[1155, 1158],
|
|
[1160, 1161],
|
|
[1425, 1469],
|
|
[1471, 1471],
|
|
[1473, 1474],
|
|
[1476, 1477],
|
|
[1479, 1479],
|
|
[1536, 1539],
|
|
[1552, 1557],
|
|
[1611, 1630],
|
|
[1648, 1648],
|
|
[1750, 1764],
|
|
[1767, 1768],
|
|
[1770, 1773],
|
|
[1807, 1807],
|
|
[1809, 1809],
|
|
[1840, 1866],
|
|
[1958, 1968],
|
|
[2027, 2035],
|
|
[2305, 2306],
|
|
[2364, 2364],
|
|
[2369, 2376],
|
|
[2381, 2381],
|
|
[2385, 2388],
|
|
[2402, 2403],
|
|
[2433, 2433],
|
|
[2492, 2492],
|
|
[2497, 2500],
|
|
[2509, 2509],
|
|
[2530, 2531],
|
|
[2561, 2562],
|
|
[2620, 2620],
|
|
[2625, 2626],
|
|
[2631, 2632],
|
|
[2635, 2637],
|
|
[2672, 2673],
|
|
[2689, 2690],
|
|
[2748, 2748],
|
|
[2753, 2757],
|
|
[2759, 2760],
|
|
[2765, 2765],
|
|
[2786, 2787],
|
|
[2817, 2817],
|
|
[2876, 2876],
|
|
[2879, 2879],
|
|
[2881, 2883],
|
|
[2893, 2893],
|
|
[2902, 2902],
|
|
[2946, 2946],
|
|
[3008, 3008],
|
|
[3021, 3021],
|
|
[3134, 3136],
|
|
[3142, 3144],
|
|
[3146, 3149],
|
|
[3157, 3158],
|
|
[3260, 3260],
|
|
[3263, 3263],
|
|
[3270, 3270],
|
|
[3276, 3277],
|
|
[3298, 3299],
|
|
[3393, 3395],
|
|
[3405, 3405],
|
|
[3530, 3530],
|
|
[3538, 3540],
|
|
[3542, 3542],
|
|
[3633, 3633],
|
|
[3636, 3642],
|
|
[3655, 3662],
|
|
[3761, 3761],
|
|
[3764, 3769],
|
|
[3771, 3772],
|
|
[3784, 3789],
|
|
[3864, 3865],
|
|
[3893, 3893],
|
|
[3895, 3895],
|
|
[3897, 3897],
|
|
[3953, 3966],
|
|
[3968, 3972],
|
|
[3974, 3975],
|
|
[3984, 3991],
|
|
[3993, 4028],
|
|
[4038, 4038],
|
|
[4141, 4144],
|
|
[4146, 4146],
|
|
[4150, 4151],
|
|
[4153, 4153],
|
|
[4184, 4185],
|
|
[4448, 4607],
|
|
[4959, 4959],
|
|
[5906, 5908],
|
|
[5938, 5940],
|
|
[5970, 5971],
|
|
[6002, 6003],
|
|
[6068, 6069],
|
|
[6071, 6077],
|
|
[6086, 6086],
|
|
[6089, 6099],
|
|
[6109, 6109],
|
|
[6155, 6157],
|
|
[6313, 6313],
|
|
[6432, 6434],
|
|
[6439, 6440],
|
|
[6450, 6450],
|
|
[6457, 6459],
|
|
[6679, 6680],
|
|
[6912, 6915],
|
|
[6964, 6964],
|
|
[6966, 6970],
|
|
[6972, 6972],
|
|
[6978, 6978],
|
|
[7019, 7027],
|
|
[7616, 7626],
|
|
[7678, 7679],
|
|
[8203, 8207],
|
|
[8234, 8238],
|
|
[8288, 8291],
|
|
[8298, 8303],
|
|
[8400, 8431],
|
|
[12330, 12335],
|
|
[12441, 12442],
|
|
[43014, 43014],
|
|
[43019, 43019],
|
|
[43045, 43046],
|
|
[64286, 64286],
|
|
[65024, 65039],
|
|
[65056, 65059],
|
|
[65279, 65279],
|
|
[65529, 65531],
|
|
[68097, 68099],
|
|
[68101, 68102],
|
|
[68108, 68111],
|
|
[68152, 68154],
|
|
[68159, 68159],
|
|
[119143, 119145],
|
|
[119155, 119170],
|
|
[119173, 119179],
|
|
[119210, 119213],
|
|
[119362, 119364],
|
|
[917505, 917505],
|
|
[917536, 917631],
|
|
[917760, 917999],
|
|
];
|
|
|
|
// node_modules/wcwidth.js/index.js
|
|
var DEFAULTS = {
|
|
nul: 0,
|
|
control: 0,
|
|
};
|
|
function bisearch(ucs) {
|
|
let min = 0;
|
|
let max = combining_default.length - 1;
|
|
let mid;
|
|
if (ucs < combining_default[0][0] || ucs > combining_default[max][1])
|
|
return false;
|
|
while (max >= min) {
|
|
mid = Math.floor((min + max) / 2);
|
|
if (ucs > combining_default[mid][1]) min = mid + 1;
|
|
else if (ucs < combining_default[mid][0]) max = mid - 1;
|
|
else return true;
|
|
}
|
|
return false;
|
|
}
|
|
function wcwidth(ucs, opts) {
|
|
if (ucs === 0) return opts.nul;
|
|
if (ucs < 32 || (ucs >= 127 && ucs < 160)) return opts.control;
|
|
if (bisearch(ucs)) return 0;
|
|
return (
|
|
1 +
|
|
(ucs >= 4352 &&
|
|
(ucs <= 4447 || // Hangul Jamo init. consonants
|
|
ucs == 9001 ||
|
|
ucs == 9002 ||
|
|
(ucs >= 11904 && ucs <= 42191 && ucs != 12351) || // CJK ... Yi
|
|
(ucs >= 44032 && ucs <= 55203) || // Hangul Syllables
|
|
(ucs >= 63744 && ucs <= 64255) || // CJK Compatibility Ideographs
|
|
(ucs >= 65040 && ucs <= 65049) || // Vertical forms
|
|
(ucs >= 65072 && ucs <= 65135) || // CJK Compatibility Forms
|
|
(ucs >= 65280 && ucs <= 65376) || // Fullwidth Forms
|
|
(ucs >= 65504 && ucs <= 65510) ||
|
|
(ucs >= 131072 && ucs <= 196605) ||
|
|
(ucs >= 196608 && ucs <= 262141)))
|
|
);
|
|
}
|
|
function wcswidth(str, opts) {
|
|
let h;
|
|
let l;
|
|
let s = 0;
|
|
let n;
|
|
if (typeof str !== 'string') return wcwidth(str, opts);
|
|
for (let i = 0; i < str.length; i++) {
|
|
h = str.charCodeAt(i);
|
|
if (h >= 55296 && h <= 56319) {
|
|
l = str.charCodeAt(++i);
|
|
if (l >= 56320 && l <= 57343) {
|
|
h = (h - 55296) * 1024 + (l - 56320) + 65536;
|
|
} else {
|
|
i--;
|
|
}
|
|
}
|
|
n = wcwidth(h, opts);
|
|
if (n < 0) return -1;
|
|
s += n;
|
|
}
|
|
return s;
|
|
}
|
|
var _ = (str) => wcswidth(str, DEFAULTS);
|
|
_.config = (opts = {}) => {
|
|
opts = {
|
|
...DEFAULTS,
|
|
...opts,
|
|
};
|
|
return (str) => wcswidth(str, opts);
|
|
};
|
|
var wcwidth_default = _;
|
|
|
|
// src/cli/logger.js
|
|
var countLines = (stream, text) => {
|
|
const columns = stream.columns || 80;
|
|
let lineCount = 0;
|
|
for (const line of stripAnsi(text).split('\n')) {
|
|
lineCount += Math.max(1, Math.ceil(wcwidth_default(line) / columns));
|
|
}
|
|
return lineCount;
|
|
};
|
|
var clear = (stream, text) => () => {
|
|
const lineCount = countLines(stream, text);
|
|
for (let line = 0; line < lineCount; line++) {
|
|
if (line > 0) {
|
|
readline.moveCursor(stream, 0, -1);
|
|
}
|
|
readline.clearLine(stream, 0);
|
|
readline.cursorTo(stream, 0);
|
|
}
|
|
};
|
|
var emptyLogResult = { clear() {} };
|
|
function createLogger(logLevel = 'log') {
|
|
return {
|
|
logLevel,
|
|
warn: createLogFunc('warn', 'yellow'),
|
|
error: createLogFunc('error', 'red'),
|
|
debug: createLogFunc('debug', 'blue'),
|
|
log: createLogFunc('log'),
|
|
};
|
|
function createLogFunc(loggerName, color) {
|
|
if (!shouldLog(loggerName)) {
|
|
return () => emptyLogResult;
|
|
}
|
|
const stream = process[loggerName === 'log' ? 'stdout' : 'stderr'];
|
|
const chalkInstance = loggerName === 'log' ? source_default : chalkStderr;
|
|
const prefix = color ? `[${chalkInstance[color](loggerName)}] ` : '';
|
|
return (message, options) => {
|
|
options = {
|
|
newline: true,
|
|
clearable: false,
|
|
...options,
|
|
};
|
|
message =
|
|
string_replace_all_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
message,
|
|
/^/gmu,
|
|
prefix
|
|
) + (options.newline ? '\n' : '');
|
|
stream.write(message);
|
|
if (options.clearable) {
|
|
return {
|
|
clear: clear(stream, message),
|
|
};
|
|
}
|
|
};
|
|
}
|
|
function shouldLog(loggerName) {
|
|
switch (logLevel) {
|
|
case 'silent':
|
|
return false;
|
|
case 'debug':
|
|
if (loggerName === 'debug') {
|
|
return true;
|
|
}
|
|
// fall through
|
|
case 'log':
|
|
if (loggerName === 'log') {
|
|
return true;
|
|
}
|
|
// fall through
|
|
case 'warn':
|
|
if (loggerName === 'warn') {
|
|
return true;
|
|
}
|
|
// fall through
|
|
case 'error':
|
|
return loggerName === 'error';
|
|
}
|
|
}
|
|
}
|
|
var logger_default = createLogger;
|
|
|
|
// src/cli/print-support-info.js
|
|
var import_fast_json_stable_stringify3 = __toESM(
|
|
require_fast_json_stable_stringify(),
|
|
1
|
|
);
|
|
import {
|
|
format as format4,
|
|
getSupportInfo as getSupportInfo2,
|
|
} from '../index.mjs';
|
|
var sortByName = (array2) =>
|
|
array2.sort((a, b) => a.name.localeCompare(b.name));
|
|
async function printSupportInfo() {
|
|
const { languages, options } = await getSupportInfo2();
|
|
const supportInfo = {
|
|
languages: sortByName(languages),
|
|
options: sortByName(options).map((option) =>
|
|
omit(option, ['cliName', 'cliCategory', 'cliDescription'])
|
|
),
|
|
};
|
|
printToScreen(
|
|
await format4(
|
|
(0, import_fast_json_stable_stringify3.default)(supportInfo),
|
|
{ parser: 'json' }
|
|
)
|
|
);
|
|
}
|
|
var print_support_info_default = printSupportInfo;
|
|
|
|
// src/cli/constants.evaluate.js
|
|
var categoryOrder = ['Output', 'Format', 'Config', 'Editor', 'Other'];
|
|
var usageSummary =
|
|
'Usage: prettier [options] [file/dir/glob ...]\n\nBy default, output is written to stdout.\nStdin is read if it is piped to Prettier and no files are given.';
|
|
|
|
// src/cli/usage.js
|
|
var OPTION_USAGE_THRESHOLD = 25;
|
|
var CHOICE_USAGE_MARGIN = 3;
|
|
var CHOICE_USAGE_INDENTATION = 2;
|
|
function indent(str, spaces) {
|
|
return string_replace_all_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
str,
|
|
/^/gmu,
|
|
' '.repeat(spaces)
|
|
);
|
|
}
|
|
function createDefaultValueDisplay(value) {
|
|
return Array.isArray(value) ?
|
|
`[${value.map(createDefaultValueDisplay).join(', ')}]`
|
|
: value;
|
|
}
|
|
function getOptionDefaultValue(context, optionName) {
|
|
var _a;
|
|
const option = context.detailedOptions.find(
|
|
({ name }) => name === optionName
|
|
);
|
|
if ((option == null ? void 0 : option.default) !== void 0) {
|
|
return option.default;
|
|
}
|
|
const optionCamelName = camelCase(optionName);
|
|
return (
|
|
formatOptionsHiddenDefaults[optionCamelName] ??
|
|
((
|
|
(_a = context.supportOptions.find(
|
|
(option2) => !option2.deprecated && option2.name === optionCamelName
|
|
)) == null
|
|
) ?
|
|
void 0
|
|
: _a.default)
|
|
);
|
|
}
|
|
function createOptionUsageHeader(option) {
|
|
const name = `--${option.name}`;
|
|
const alias = option.alias ? `-${option.alias},` : null;
|
|
const type = createOptionUsageType(option);
|
|
return [alias, name, type].filter(Boolean).join(' ');
|
|
}
|
|
function createOptionUsageRow(header, content, threshold) {
|
|
const separator =
|
|
header.length >= threshold ?
|
|
`
|
|
${' '.repeat(threshold)}`
|
|
: ' '.repeat(threshold - header.length);
|
|
const description = string_replace_all_default(
|
|
/* isOptionalObject */
|
|
false,
|
|
content,
|
|
'\n',
|
|
`
|
|
${' '.repeat(threshold)}`
|
|
);
|
|
return `${header}${separator}${description}`;
|
|
}
|
|
function createOptionUsageType(option) {
|
|
switch (option.type) {
|
|
case 'boolean':
|
|
return null;
|
|
case 'choice':
|
|
return `<${option.choices
|
|
.filter((choice) => !choice.deprecated)
|
|
.map((choice) => choice.value)
|
|
.join('|')}>`;
|
|
default:
|
|
return `<${option.type}>`;
|
|
}
|
|
}
|
|
function createChoiceUsages(choices, margin, indentation) {
|
|
const activeChoices = choices.filter((choice) => !choice.deprecated);
|
|
const threshold =
|
|
Math.max(0, ...activeChoices.map((choice) => choice.value.length)) + margin;
|
|
return activeChoices.map((choice) =>
|
|
indent(
|
|
createOptionUsageRow(choice.value, choice.description, threshold),
|
|
indentation
|
|
)
|
|
);
|
|
}
|
|
function createOptionUsage(context, option, threshold) {
|
|
const header = createOptionUsageHeader(option);
|
|
const optionDefaultValue = getOptionDefaultValue(context, option.name);
|
|
return createOptionUsageRow(
|
|
header,
|
|
`${option.description}${
|
|
optionDefaultValue === void 0 ? '' : (
|
|
`
|
|
Defaults to ${createDefaultValueDisplay(optionDefaultValue)}.`
|
|
)
|
|
}`,
|
|
threshold
|
|
);
|
|
}
|
|
function getOptionsWithOpposites(options) {
|
|
const optionsWithOpposites = options.map((option) => [
|
|
option.description ? option : null,
|
|
option.oppositeDescription ?
|
|
{
|
|
...option,
|
|
name: `no-${option.name}`,
|
|
type: 'boolean',
|
|
description: option.oppositeDescription,
|
|
}
|
|
: null,
|
|
]);
|
|
return optionsWithOpposites.flat().filter(Boolean);
|
|
}
|
|
function createUsage(context) {
|
|
const sortedOptions = context.detailedOptions.sort((optionA, optionB) =>
|
|
optionA.name.localeCompare(optionB.name)
|
|
);
|
|
const options = getOptionsWithOpposites(sortedOptions).filter(
|
|
// remove unnecessary option (e.g. `semi`, `color`, etc.), which is only used for --help <flag>
|
|
(option) =>
|
|
!(
|
|
option.type === 'boolean' &&
|
|
option.oppositeDescription &&
|
|
!option.name.startsWith('no-')
|
|
)
|
|
);
|
|
const groupedOptions = groupBy(options, (option) => option.category);
|
|
const firstCategories = categoryOrder.slice(0, -1);
|
|
const lastCategories = categoryOrder.slice(-1);
|
|
const restCategories = Object.keys(groupedOptions).filter(
|
|
(category) => !categoryOrder.includes(category)
|
|
);
|
|
const allCategories = [
|
|
...firstCategories,
|
|
...restCategories,
|
|
...lastCategories,
|
|
];
|
|
const optionsUsage = allCategories.map((category) => {
|
|
const categoryOptions = groupedOptions[category]
|
|
.map((option) =>
|
|
createOptionUsage(context, option, OPTION_USAGE_THRESHOLD)
|
|
)
|
|
.join('\n');
|
|
return `${category} options:
|
|
|
|
${indent(categoryOptions, 2)}`;
|
|
});
|
|
return [usageSummary, ...optionsUsage, ''].join('\n\n');
|
|
}
|
|
function createPluginDefaults(pluginDefaults) {
|
|
if (!pluginDefaults || Object.keys(pluginDefaults).length === 0) {
|
|
return '';
|
|
}
|
|
const defaults = Object.entries(pluginDefaults)
|
|
.sort(([pluginNameA], [pluginNameB]) =>
|
|
pluginNameA.localeCompare(pluginNameB)
|
|
)
|
|
.map(
|
|
([plugin, value]) => `* ${plugin}: ${createDefaultValueDisplay(value)}`
|
|
)
|
|
.join('\n');
|
|
return `
|
|
Plugin defaults:
|
|
${defaults}`;
|
|
}
|
|
function createDetailedUsage(context, flag) {
|
|
const option = getOptionsWithOpposites(context.detailedOptions).find(
|
|
(option2) => option2.name === flag || option2.alias === flag
|
|
);
|
|
const header = createOptionUsageHeader(option);
|
|
const description = `
|
|
|
|
${indent(option.description, 2)}`;
|
|
const choices =
|
|
option.type !== 'choice' ?
|
|
''
|
|
: `
|
|
|
|
Valid options:
|
|
|
|
${createChoiceUsages(
|
|
option.choices,
|
|
CHOICE_USAGE_MARGIN,
|
|
CHOICE_USAGE_INDENTATION
|
|
).join('\n')}`;
|
|
const optionDefaultValue = getOptionDefaultValue(context, option.name);
|
|
const defaults =
|
|
optionDefaultValue !== void 0 ?
|
|
`
|
|
|
|
Default: ${createDefaultValueDisplay(optionDefaultValue)}`
|
|
: '';
|
|
const pluginDefaults = createPluginDefaults(option.pluginDefaults);
|
|
return `${header}${description}${choices}${defaults}${pluginDefaults}`;
|
|
}
|
|
|
|
// src/cli/index.js
|
|
async function run(rawArguments = process.argv.slice(2)) {
|
|
let logger = logger_default();
|
|
try {
|
|
const { logLevel } = parseArgvWithoutPlugins(
|
|
rawArguments,
|
|
logger,
|
|
'log-level'
|
|
);
|
|
if (logLevel !== logger.logLevel) {
|
|
logger = logger_default(logLevel);
|
|
}
|
|
const context = new context_default({ rawArguments, logger });
|
|
await context.init();
|
|
if (logger.logLevel !== 'debug' && context.performanceTestFlag) {
|
|
context.logger = logger_default('debug');
|
|
}
|
|
await main(context);
|
|
} catch (error) {
|
|
logger.error(error.message);
|
|
process.exitCode = 1;
|
|
}
|
|
}
|
|
async function main(context) {
|
|
context.logger.debug(`normalized argv: ${JSON.stringify(context.argv)}`);
|
|
if (context.argv.check && context.argv.listDifferent) {
|
|
throw new Error('Cannot use --check and --list-different together.');
|
|
}
|
|
if (context.argv.write && context.argv.debugCheck) {
|
|
throw new Error('Cannot use --write and --debug-check together.');
|
|
}
|
|
if (context.argv.findConfigPath && context.filePatterns.length > 0) {
|
|
throw new Error('Cannot use --find-config-path with multiple files');
|
|
}
|
|
if (context.argv.fileInfo && context.filePatterns.length > 0) {
|
|
throw new Error('Cannot use --file-info with multiple files');
|
|
}
|
|
if (!context.argv.cache && context.argv.cacheStrategy) {
|
|
throw new Error('`--cache-strategy` cannot be used without `--cache`.');
|
|
}
|
|
if (context.argv.version) {
|
|
printToScreen(prettier2.version);
|
|
return;
|
|
}
|
|
if (context.argv.help !== void 0) {
|
|
printToScreen(
|
|
typeof context.argv.help === 'string' && context.argv.help !== '' ?
|
|
createDetailedUsage(context, context.argv.help)
|
|
: createUsage(context)
|
|
);
|
|
return;
|
|
}
|
|
if (context.argv.supportInfo) {
|
|
return print_support_info_default();
|
|
}
|
|
if (context.argv.findConfigPath) {
|
|
await find_config_path_default(context);
|
|
return;
|
|
}
|
|
if (context.argv.fileInfo) {
|
|
await file_info_default(context);
|
|
return;
|
|
}
|
|
const hasFilePatterns = context.filePatterns.length > 0;
|
|
const useStdin =
|
|
!hasFilePatterns && (!process.stdin.isTTY || context.argv.filepath);
|
|
if (useStdin) {
|
|
if (context.argv.cache) {
|
|
throw new Error('`--cache` cannot be used when formatting stdin.');
|
|
}
|
|
await formatStdin(context);
|
|
return;
|
|
}
|
|
if (hasFilePatterns) {
|
|
await formatFiles(context);
|
|
return;
|
|
}
|
|
process.exitCode = 1;
|
|
printToScreen(createUsage(context));
|
|
}
|
|
export { run };
|