@kubb/core
Version:
Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.
701 lines (685 loc) • 21.4 kB
JavaScript
;
var remeda = require('remeda');
// ../../node_modules/.pnpm/natural-orderby@5.0.0/node_modules/natural-orderby/dist/index.js
var compareNumbers = function compareNumbers2(numberA, numberB) {
if (numberA < numberB) {
return -1;
}
if (numberA > numberB) {
return 1;
}
return 0;
};
var compareUnicode = function compareUnicode2(stringA, stringB, locale) {
var result = stringA.localeCompare(stringB, locale);
return result ? result / Math.abs(result) : 0;
};
var RE_NUMBERS = /(^0x[\da-fA-F]+$|^([+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?(?!\.\d+)(?=\D|\s|$))|\d+)/g;
var RE_LEADING_OR_TRAILING_WHITESPACES = /^\s+|\s+$/g;
var RE_WHITESPACES = /\s+/g;
var RE_INT_OR_FLOAT = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/;
var RE_DATE = /(^([\w ]+,?[\w ]+)?[\w ]+,?[\w ]+\d+:\d+(:\d+)?[\w ]?|^\d{1,4}[/-]\d{1,4}[/-]\d{1,4}|^\w+, \w+ \d+, \d{4})/;
var RE_LEADING_ZERO = /^0+[1-9]{1}[0-9]*$/;
var RE_UNICODE_CHARACTERS = /[^\x00-\x80]/;
var stringCompare = function stringCompare2(stringA, stringB) {
if (stringA < stringB) {
return -1;
}
if (stringA > stringB) {
return 1;
}
return 0;
};
var compareChunks = function compareChunks2(chunksA, chunksB, locale) {
var lengthA = chunksA.length;
var lengthB = chunksB.length;
var size = Math.min(lengthA, lengthB);
for (var i = 0; i < size; i++) {
var chunkA = chunksA[i];
var chunkB = chunksB[i];
if (chunkA.normalizedString !== chunkB.normalizedString) {
if (chunkA.normalizedString === "" !== (chunkB.normalizedString === "")) {
return chunkA.normalizedString === "" ? -1 : 1;
}
if (chunkA.parsedNumber !== void 0 && chunkB.parsedNumber !== void 0) {
var result = compareNumbers(chunkA.parsedNumber, chunkB.parsedNumber);
if (result === 0) {
return stringCompare(chunkA.normalizedString, chunkB.normalizedString);
}
return result;
} else if (chunkA.parsedNumber !== void 0 || chunkB.parsedNumber !== void 0) {
return chunkA.parsedNumber !== void 0 ? -1 : 1;
} else if (RE_UNICODE_CHARACTERS.test(chunkA.normalizedString + chunkB.normalizedString)) {
return compareUnicode(chunkA.normalizedString, chunkB.normalizedString, locale);
} else {
return stringCompare(chunkA.normalizedString, chunkB.normalizedString);
}
}
}
if (lengthA > size || lengthB > size) {
return lengthA <= size ? -1 : 1;
}
return 0;
};
var compareOtherTypes = function compareOtherTypes2(valueA, valueB) {
if (!valueA.chunks ? valueB.chunks : !valueB.chunks) {
return !valueA.chunks ? 1 : -1;
}
if (valueA.isNaN ? !valueB.isNaN : valueB.isNaN) {
return valueA.isNaN ? -1 : 1;
}
if (valueA.isSymbol ? !valueB.isSymbol : valueB.isSymbol) {
return valueA.isSymbol ? -1 : 1;
}
if (valueA.isObject ? !valueB.isObject : valueB.isObject) {
return valueA.isObject ? -1 : 1;
}
if (valueA.isArray ? !valueB.isArray : valueB.isArray) {
return valueA.isArray ? -1 : 1;
}
if (valueA.isFunction ? !valueB.isFunction : valueB.isFunction) {
return valueA.isFunction ? -1 : 1;
}
if (valueA.isNull ? !valueB.isNull : valueB.isNull) {
return valueA.isNull ? -1 : 1;
}
return 0;
};
var compareValues = function compareValues2(valueA, valueB, locale) {
if (valueA.value === valueB.value) {
return 0;
}
if (valueA.parsedNumber !== void 0 && valueB.parsedNumber !== void 0) {
return compareNumbers(valueA.parsedNumber, valueB.parsedNumber);
}
if (valueA.chunks && valueB.chunks) {
return compareChunks(valueA.chunks, valueB.chunks, locale);
}
return compareOtherTypes(valueA, valueB);
};
var normalizeAlphaChunk = function normalizeAlphaChunk2(chunk) {
return chunk.replace(RE_WHITESPACES, " ").replace(RE_LEADING_OR_TRAILING_WHITESPACES, "");
};
var parseNumber = function parseNumber2(value) {
if (value.length !== 0) {
var parsedNumber = Number(value.replace(/_/g, ""));
if (!Number.isNaN(parsedNumber)) {
return parsedNumber;
}
}
return void 0;
};
var normalizeNumericChunk = function normalizeNumericChunk2(chunk, index, chunks) {
if (RE_INT_OR_FLOAT.test(chunk)) {
if (!RE_LEADING_ZERO.test(chunk) || index === 0 || chunks[index - 1] !== ".") {
return parseNumber(chunk) || 0;
}
}
return void 0;
};
var createChunkMap = function createChunkMap2(chunk, index, chunks) {
return {
parsedNumber: normalizeNumericChunk(chunk, index, chunks),
normalizedString: normalizeAlphaChunk(chunk)
};
};
var createChunks = function createChunks2(value) {
return value.replace(RE_NUMBERS, "\0$1\0").replace(/\0$/, "").replace(/^\0/, "").split("\0");
};
var createChunkMaps = function createChunkMaps2(value) {
var chunksMaps = createChunks(value).map(createChunkMap);
return chunksMaps;
};
var isFunction = function isFunction2(value) {
return typeof value === "function";
};
var isNaN = function isNaN2(value) {
return Number.isNaN(value) || value instanceof Number && Number.isNaN(value.valueOf());
};
var isNull = function isNull2(value) {
return value === null;
};
var isObject = function isObject2(value) {
return value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof Number) && !(value instanceof String) && !(value instanceof Boolean) && !(value instanceof Date);
};
var isSymbol = function isSymbol2(value) {
return typeof value === "symbol";
};
var isUndefined = function isUndefined2(value) {
return value === void 0;
};
var parseDate = function parseDate2(value) {
try {
var parsedDate = Date.parse(value);
if (!Number.isNaN(parsedDate)) {
if (RE_DATE.test(value)) {
return parsedDate;
}
}
return void 0;
} catch (_unused) {
return void 0;
}
};
var numberify = function numberify2(value) {
var parsedNumber = parseNumber(value);
if (parsedNumber !== void 0) {
return parsedNumber;
}
return parseDate(value);
};
var stringify = function stringify2(value) {
if (typeof value === "boolean" || value instanceof Boolean) {
return Number(value).toString();
}
if (typeof value === "number" || value instanceof Number) {
return value.toString();
}
if (value instanceof Date) {
return value.getTime().toString();
}
if (typeof value === "string" || value instanceof String) {
return value.toLowerCase().replace(RE_LEADING_OR_TRAILING_WHITESPACES, "");
}
return "";
};
var getMappedValueRecord = function getMappedValueRecord2(value) {
if (typeof value === "string" || value instanceof String || (typeof value === "number" || value instanceof Number) && !isNaN(value) || typeof value === "boolean" || value instanceof Boolean || value instanceof Date) {
var stringValue = stringify(value);
var parsedNumber = numberify(stringValue);
var chunks = createChunkMaps(parsedNumber ? "" + parsedNumber : stringValue);
return {
parsedNumber,
chunks,
value
};
}
return {
isArray: Array.isArray(value),
isFunction: isFunction(value),
isNaN: isNaN(value),
isNull: isNull(value),
isObject: isObject(value),
isSymbol: isSymbol(value),
isUndefined: isUndefined(value),
value
};
};
var compareMultiple = function compareMultiple2(recordA, recordB, orders, locale) {
var indexA = recordA.index, valuesA = recordA.values;
var indexB = recordB.index, valuesB = recordB.values;
var length = valuesA.length;
var ordersLength = orders.length;
for (var i = 0; i < length; i++) {
var order = i < ordersLength ? orders[i] : null;
if (order && typeof order === "function") {
var result = order(valuesA[i].value, valuesB[i].value);
if (result) {
return result;
}
} else {
var _result = compareValues(valuesA[i], valuesB[i], locale);
if (_result) {
return _result * (order === "desc" ? -1 : 1);
}
}
}
return indexA - indexB;
};
var createIdentifierFn = function createIdentifierFn2(identifier) {
if (typeof identifier === "function") {
return identifier;
}
return function(value) {
if (Array.isArray(value)) {
var index = Number(identifier);
if (Number.isInteger(index)) {
return value[index];
}
} else if (value && typeof value === "object") {
var result = Object.getOwnPropertyDescriptor(value, identifier);
return result == null ? void 0 : result.value;
}
return value;
};
};
var getElementByIndex = function getElementByIndex2(collection, index) {
return collection[index];
};
var getValueByIdentifier = function getValueByIdentifier2(value, getValue) {
return getValue(value);
};
var baseOrderBy = function baseOrderBy2(collection, identifiers, orders, locale) {
var identifierFns = identifiers.length ? identifiers.map(createIdentifierFn) : [function(value) {
return value;
}];
var mappedCollection = collection.map(function(element, index) {
var values = identifierFns.map(function(identifier) {
return getValueByIdentifier(element, identifier);
}).map(getMappedValueRecord);
return {
index,
values
};
});
mappedCollection.sort(function(recordA, recordB) {
return compareMultiple(recordA, recordB, orders, locale);
});
return mappedCollection.map(function(element) {
return getElementByIndex(collection, element.index);
});
};
var getIdentifiers = function getIdentifiers2(identifiers) {
if (!identifiers) {
return [];
}
var identifierList = !Array.isArray(identifiers) ? [identifiers] : [].concat(identifiers);
if (identifierList.some(function(identifier) {
return typeof identifier !== "string" && typeof identifier !== "number" && typeof identifier !== "function";
})) {
return [];
}
return identifierList;
};
var getOrders = function getOrders2(orders) {
if (!orders) {
return [];
}
var orderList = !Array.isArray(orders) ? [orders] : [].concat(orders);
if (orderList.some(function(order) {
return order !== "asc" && order !== "desc" && typeof order !== "function";
})) {
return [];
}
return orderList;
};
function orderBy(collection, identifiers, orders, locale) {
if (!collection || !Array.isArray(collection)) {
return [];
}
var validatedIdentifiers = getIdentifiers(identifiers);
var validatedOrders = getOrders(orders);
return baseOrderBy(collection, validatedIdentifiers, validatedOrders, locale);
}
// ../../node_modules/.pnpm/camelcase@8.0.0/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 input.replaceAll(LEADING_CAPITAL, (match) => toLowerCase(match));
};
var postProcess = (input, toUpperCase) => {
SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
NUMBERS_AND_IDENTIFIER.lastIndex = 0;
return input.replaceAll(NUMBERS_AND_IDENTIFIER, (match, pattern, offset) => ["_", "-"].includes(input.charAt(offset + match.length)) ? match : toUpperCase(match)).replaceAll(SEPARATORS_AND_IDENTIFIER, (_, 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/transformers/casing.ts
function camelCase2(text, { isFile, prefix = "", suffix = "" } = {}) {
if (isFile) {
const splitArray = text.split(".");
return splitArray.map((item, i) => i === splitArray.length - 1 ? camelCase2(item, { prefix, suffix }) : camelCase2(item)).join("/");
}
return camelCase(`${prefix} ${text} ${suffix}`, { pascalCase: false, preserveConsecutiveUppercase: true }).replace(/[^a-zA-Z0-9]/g, "");
}
function pascalCase(text, { isFile, prefix = "", suffix = "" } = {}) {
if (isFile) {
const splitArray = text.split(".");
return splitArray.map((item, i) => i === splitArray.length - 1 ? pascalCase(item, { prefix, suffix }) : camelCase2(item)).join("/");
}
return camelCase(`${prefix} ${text} ${suffix}`, { pascalCase: true, preserveConsecutiveUppercase: true }).replace(/[^a-zA-Z0-9]/g, "");
}
// src/transformers/combineCodes.ts
function combineCodes(codes) {
return codes.join("\n");
}
// src/transformers/createJSDocBlockText.ts
function createJSDocBlockText({ comments }) {
const filteredComments = comments.filter(Boolean);
if (!filteredComments.length) {
return "";
}
return `/**
* ${filteredComments.join("\n * ")}
*/`;
}
// src/transformers/escape.ts
function escape(text) {
return text ? text.replaceAll("`", "\\`") : "";
}
function jsStringEscape(input) {
return `${input}`.replace(/["'\\\n\r\u2028\u2029]/g, (character) => {
switch (character) {
case '"':
case "'":
case "\\":
return `\\${character}`;
// Four possible LineTerminator characters need to be escaped:
case "\n":
return "\\n";
case "\r":
return "\\r";
case "\u2028":
return "\\u2028";
case "\u2029":
return "\\u2029";
default:
return "";
}
});
}
// src/transformers/indent.ts
function createIndent(size) {
return Array.from({ length: size + 1 }).join(" ");
}
// src/transformers/nameSorter.ts
function nameSorter(a, b) {
if (a.name < b.name) {
return -1;
}
if (a.name > b.name) {
return 1;
}
return 0;
}
// src/transformers/searchAndReplace.ts
function searchAndReplace(options) {
const { text, replaceBy, prefix = "", key } = options;
const searchValues = options.searchValues?.(prefix, key) || [
`${prefix}["${key}"]`,
`${prefix}['${key}']`,
`${prefix}[\`${key}\`]`,
`${prefix}"${key}"`,
`${prefix}'${key}'`,
`${prefix}\`${key}\``,
new RegExp(`${prefix}${key}`, "g")
];
return searchValues.reduce((prev, searchValue) => {
return prev.toString().replaceAll(searchValue, replaceBy);
}, text);
}
// src/transformers/trim.ts
function trim(text) {
return text.replaceAll(/\n/g, "").trim();
}
function trimQuotes(text) {
if (text.match(/^"(.*)"$/)) {
return text.replace(/^"(.*)"$/, "$1");
}
if (text.match(/^'(.*)'$/)) {
return text.replace(/^'(.*)'$/, "$1");
}
if (text.match(/^`(.*)`$/)) {
return text.replace(/^`(.*)`$/, "$1");
}
return text;
}
// src/transformers/stringify.ts
function stringify3(value) {
if (value === void 0 || value === null) {
return '""';
}
return JSON.stringify(trimQuotes(value.toString()));
}
function stringifyObject(value) {
const items = Object.entries(value).map(([key, value2]) => {
if (typeof value2 === "object") {
return `${key}: {
${stringifyObject(value2)}
}`;
}
return `${key}: ${value2}`;
}).filter(Boolean);
return items.join(",\n");
}
// src/transformers/toRegExp.ts
function stringToRegex(text) {
const isStartWithSlash = text.startsWith("/");
const isEndWithSlash = text.endsWith("/");
return new RegExp(text.slice(isStartWithSlash ? 1 : 0, isEndWithSlash ? -1 : void 0));
}
function toRegExp(text) {
if (typeof text === "string") {
const source = trimQuotes(text);
return stringToRegex(source);
}
return stringToRegex(text.toString());
}
function toRegExpString(text, func = "RegExp") {
const isStartWithSlash = text.startsWith("/");
const isEndWithSlash = text.endsWith("/");
if (func === null) {
return `/${text.slice(isStartWithSlash ? 1 : 0, isEndWithSlash ? -1 : void 0).replaceAll("/", "\\/")}/`;
}
const regexp = `new ${func}('${jsStringEscape(text.slice(isStartWithSlash ? 1 : 0, isEndWithSlash ? -1 : void 0))}')`;
return regexp;
}
// src/transformers/transformReservedWord.ts
var reservedWords = [
"abstract",
"arguments",
"boolean",
"break",
"byte",
"case",
"catch",
"char",
"class",
"const",
"continue",
"debugger",
"default",
"delete",
"do",
"double",
"else",
"enum",
"eval",
"export",
"extends",
"false",
"final",
"finally",
"float",
"for",
"function",
"goto",
"if",
"implements",
"import",
"in",
"instanceof",
"int",
"interface",
"let",
"long",
"native",
"new",
"null",
"package",
"private",
"protected",
"public",
"return",
"short",
"static",
"super",
"switch",
"synchronized",
"this",
"throw",
"throws",
"transient",
"true",
"try",
"typeof",
"var",
"void",
"volatile",
"while",
"with",
"yield",
"Array",
"Date",
"eval",
"function",
"hasOwnProperty",
"Infinity",
"isFinite",
"isNaN",
"isPrototypeOf",
"length",
"Math",
"name",
"NaN",
"Number",
"Object",
"prototype",
"String",
"toString",
"undefined",
"valueOf"
];
function transformReservedWord(word) {
if (word && reservedWords.includes(word) || word?.match(/^\d/)) {
return `_${word}`;
}
return word;
}
function isValidVarName(name) {
try {
Function(`var ${name}`);
} catch (_e) {
return false;
}
return true;
}
var transformers_default = {
combineCodes,
escape,
jsStringEscape,
createIndent,
transformReservedWord,
isValidVarName,
nameSorter,
searchAndReplace,
stringify: stringify3,
stringifyObject,
toRegExp,
toRegExpString,
trim,
trimQuotes,
JSDoc: {
createJSDocBlockText
},
orderBy,
merge: remeda.merge,
camelCase: camelCase2,
pascalCase
};
/*! Bundled license information:
natural-orderby/dist/index.js:
(**
* natural-orderby v5.0.0
*
* Copyright (c) Olaf Ennen
*
* This source code is licensed under the MIT license found in the
* LICENSE.md file in the root directory of this source tree.
*
* @license MIT
*)
*/
Object.defineProperty(exports, "merge", {
enumerable: true,
get: function () { return remeda.merge; }
});
exports.camelCase = camelCase2;
exports.combineCodes = combineCodes;
exports.createIndent = createIndent;
exports.createJSDocBlockText = createJSDocBlockText;
exports.escape = escape;
exports.isValidVarName = isValidVarName;
exports.jsStringEscape = jsStringEscape;
exports.nameSorter = nameSorter;
exports.orderBy = orderBy;
exports.pascalCase = pascalCase;
exports.searchAndReplace = searchAndReplace;
exports.stringify = stringify3;
exports.stringifyObject = stringifyObject;
exports.toRegExp = toRegExp;
exports.toRegExpString = toRegExpString;
exports.transformReservedWord = transformReservedWord;
exports.transformers_default = transformers_default;
exports.trim = trim;
exports.trimQuotes = trimQuotes;
//# sourceMappingURL=chunk-BHSTNFNQ.cjs.map
//# sourceMappingURL=chunk-BHSTNFNQ.cjs.map