@kubb/core
Version:
Core functionality for Kubb's plugin-based code generation system, providing the foundation for transforming OpenAPI specifications.
943 lines (928 loc) • 28.9 kB
JavaScript
;
var chunkBHSTNFNQ_cjs = require('./chunk-BHSTNFNQ.cjs');
var chunkE4XLCCPK_cjs = require('./chunk-E4XLCCPK.cjs');
var path = require('path');
var hash = require('object-hash');
var remeda = require('remeda');
var pLimit = require('p-limit');
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
var path__default = /*#__PURE__*/_interopDefault(path);
var hash__default = /*#__PURE__*/_interopDefault(hash);
var pLimit__default = /*#__PURE__*/_interopDefault(pLimit);
// src/utils/FunctionParams.ts
var FunctionParams = class _FunctionParams {
#items = [];
constructor() {
return this;
}
get items() {
return this.#items.flat();
}
add(item) {
if (!item) {
return this;
}
if (Array.isArray(item)) {
item.filter(Boolean).forEach((it) => this.#items.push(it));
return this;
}
this.#items.push(item);
return this;
}
static #orderItems(items) {
return chunkBHSTNFNQ_cjs.orderBy(
items.filter(Boolean),
[
(v) => {
if (Array.isArray(v)) {
return void 0;
}
return !v.default;
},
(v) => {
if (Array.isArray(v)) {
return void 0;
}
return v.required ?? true;
}
],
["desc", "desc"]
);
}
static #addParams(acc, item) {
const { enabled = true, name, type, required = true, ...rest } = item;
if (!enabled) {
return acc;
}
if (!name) {
acc.push(`${type}${rest.default ? ` = ${rest.default}` : ""}`);
return acc;
}
const parameterName = name.startsWith("{") ? name : chunkBHSTNFNQ_cjs.camelCase(name);
if (type) {
if (required) {
acc.push(`${parameterName}: ${type}${rest.default ? ` = ${rest.default}` : ""}`);
} else {
acc.push(`${parameterName}?: ${type}`);
}
} else {
acc.push(`${parameterName}`);
}
return acc;
}
static toObject(items) {
let type = [];
let name = [];
const enabled = items.every((item) => item.enabled) ? items.at(0)?.enabled : true;
const required = items.every((item) => item.required) ?? true;
items.forEach((item) => {
name = _FunctionParams.#addParams(name, { ...item, type: void 0 });
if (items.some((item2) => item2.type)) {
type = _FunctionParams.#addParams(type, item);
}
});
return {
name: `{ ${name.join(", ")} }`,
type: type.length ? `{ ${type.join("; ")} }` : void 0,
enabled,
required
};
}
static toString(items) {
const sortedData = _FunctionParams.#orderItems(items);
return sortedData.reduce((acc, item) => {
if (Array.isArray(item)) {
if (item.length <= 0) {
return acc;
}
const subItems = _FunctionParams.#orderItems(item);
const objectItem = _FunctionParams.toObject(subItems);
return _FunctionParams.#addParams(acc, objectItem);
}
return _FunctionParams.#addParams(acc, item);
}, []).join(", ");
}
toObject() {
const items = _FunctionParams.#orderItems(this.#items).flat();
return _FunctionParams.toObject(items);
}
toString() {
const items = _FunctionParams.#orderItems(this.#items);
return _FunctionParams.toString(items);
}
};
// src/utils/promise.ts
function isPromise(result) {
return !!result && typeof result?.then === "function";
}
function isPromiseFulfilledResult(result) {
return result.status === "fulfilled";
}
function isPromiseRejectedResult(result) {
return result.status === "rejected";
}
// src/utils/renderTemplate.ts
function renderTemplate(template, data = void 0) {
if (!data || !Object.keys(data).length) {
return template.replace(/{{(.*?)}}/g, "");
}
const matches = template.match(/{{(.*?)}}/g);
return matches?.reduce((prev, curr) => {
const index = curr.split(/{{|}}/).filter(Boolean)[0]?.trim();
if (index === void 0) {
return prev;
}
const value = data[index];
if (value === void 0) {
return prev;
}
return prev.replace(curr, () => {
if (typeof value === "boolean") {
return `${value.toString()}` || "false";
}
return value || "";
}).trim();
}, template) || "";
}
// src/utils/timeout.ts
async function timeout(ms) {
return new Promise((resolve) => {
setTimeout(() => {
resolve(true);
}, ms);
});
}
// src/utils/uniqueName.ts
function getUniqueName(originalName, data) {
let used = data[originalName] || 0;
if (used) {
data[originalName] = ++used;
originalName += used;
}
data[originalName] = 1;
return originalName;
}
function setUniqueName(originalName, data) {
let used = data[originalName] || 0;
if (used) {
data[originalName] = ++used;
return originalName;
}
data[originalName] = 1;
return originalName;
}
// src/utils/URLPath.ts
var URLPath = class {
path;
#options;
constructor(path2, options = {}) {
this.path = path2;
this.#options = options;
return this;
}
/**
* Convert Swagger path to URLPath(syntax of Express)
* @example /pet/{petId} => /pet/:petId
*/
get URL() {
return this.toURLPath();
}
get isURL() {
try {
const url = new URL(this.path);
if (url?.href) {
return true;
}
} catch (_error) {
return false;
}
return false;
}
/**
* Convert Swagger path to template literals/ template strings(camelcase)
* @example /pet/{petId} => `/pet/${petId}`
* @example /account/monetary-accountID => `/account/${monetaryAccountId}`
* @example /account/userID => `/account/${userId}`
*/
get template() {
return this.toTemplateString();
}
get object() {
return this.toObject();
}
get params() {
return this.getParams();
}
toObject({ type = "path", replacer, stringify } = {}) {
const object = {
url: type === "path" ? this.toURLPath() : this.toTemplateString({ replacer }),
params: this.getParams()
};
if (stringify) {
if (type === "template") {
return JSON.stringify(object).replaceAll("'", "").replaceAll(`"`, "");
}
if (object.params) {
return `{ url: '${object.url}', params: ${JSON.stringify(object.params).replaceAll("'", "").replaceAll(`"`, "")} }`;
}
return `{ url: '${object.url}' }`;
}
return object;
}
/**
* Convert Swagger path to template literals/ template strings(camelcase)
* @example /pet/{petId} => `/pet/${petId}`
* @example /account/monetary-accountID => `/account/${monetaryAccountId}`
* @example /account/userID => `/account/${userId}`
*/
toTemplateString({ prefix = "", replacer } = {}) {
const regex = /{(\w|-)*}/g;
const found = this.path.match(regex);
let newPath = this.path.replaceAll("{", "${");
if (found) {
newPath = found.reduce((prev, path2) => {
const pathWithoutBrackets = path2.replaceAll("{", "").replaceAll("}", "");
let param = chunkBHSTNFNQ_cjs.isValidVarName(pathWithoutBrackets) ? pathWithoutBrackets : chunkBHSTNFNQ_cjs.camelCase(pathWithoutBrackets);
if (this.#options.casing === "camelcase") {
param = chunkBHSTNFNQ_cjs.camelCase(param);
}
return prev.replace(path2, `\${${replacer ? replacer(param) : param}}`);
}, this.path);
}
return `\`${prefix}${newPath}\``;
}
getParams(replacer) {
const regex = /{(\w|-)*}/g;
const found = this.path.match(regex);
if (!found) {
return void 0;
}
const params = {};
found.forEach((item) => {
item = item.replaceAll("{", "").replaceAll("}", "");
let param = chunkBHSTNFNQ_cjs.isValidVarName(item) ? item : chunkBHSTNFNQ_cjs.camelCase(item);
if (this.#options.casing === "camelcase") {
param = chunkBHSTNFNQ_cjs.camelCase(param);
}
const key = replacer ? replacer(param) : param;
params[key] = key;
}, this.path);
return params;
}
/**
* Convert Swagger path to URLPath(syntax of Express)
* @example /pet/{petId} => /pet/:petId
*/
toURLPath() {
return this.path.replaceAll("{", ":").replaceAll("}", "");
}
};
// src/utils/TreeNode.ts
var TreeNode = class _TreeNode {
data;
parent;
children = [];
#cachedLeaves = void 0;
constructor(data, parent) {
this.data = data;
this.parent = parent;
return this;
}
addChild(data) {
const child = new _TreeNode(data, this);
if (!this.children) {
this.children = [];
}
this.children.push(child);
return child;
}
get root() {
if (!this.parent) {
return this;
}
return this.parent.root;
}
get leaves() {
if (!this.children || this.children.length === 0) {
return [this];
}
if (this.#cachedLeaves) {
return this.#cachedLeaves;
}
const leaves = [];
if (this.children) {
for (let i = 0, { length } = this.children; i < length; i++) {
leaves.push.apply(leaves, this.children[i].leaves);
}
}
this.#cachedLeaves = leaves;
return leaves;
}
forEach(callback) {
if (typeof callback !== "function") {
throw new TypeError("forEach() callback must be a function");
}
callback(this);
if (this.children) {
for (let i = 0, { length } = this.children; i < length; i++) {
this.children[i]?.forEach(callback);
}
}
return this;
}
findDeep(predicate) {
if (typeof predicate !== "function") {
throw new TypeError("find() predicate must be a function");
}
return this.leaves.find(predicate);
}
forEachDeep(callback) {
if (typeof callback !== "function") {
throw new TypeError("forEach() callback must be a function");
}
this.leaves.forEach(callback);
}
filterDeep(callback) {
if (typeof callback !== "function") {
throw new TypeError("filter() callback must be a function");
}
return this.leaves.filter(callback);
}
mapDeep(callback) {
if (typeof callback !== "function") {
throw new TypeError("map() callback must be a function");
}
return this.leaves.map(callback);
}
static build(files, root) {
try {
const filteredTree = buildDirectoryTree(files, root);
if (!filteredTree) {
return null;
}
const treeNode = new _TreeNode({
name: filteredTree.name,
path: filteredTree.path,
file: filteredTree.file,
type: FileManager.getMode(filteredTree.path)
});
const recurse = (node, item) => {
const subNode = node.addChild({
name: item.name,
path: item.path,
file: item.file,
type: FileManager.getMode(item.path)
});
if (item.children?.length) {
item.children?.forEach((child) => {
recurse(subNode, child);
});
}
};
filteredTree.children?.forEach((child) => recurse(treeNode, child));
return treeNode;
} catch (e) {
throw new Error("Something went wrong with creating barrel files with the TreeNode class", { cause: e });
}
}
};
var normalizePath = (p) => p.replace(/\\/g, "/");
function buildDirectoryTree(files, rootFolder = "") {
const normalizedRootFolder = normalizePath(rootFolder);
const rootPrefix = normalizedRootFolder.endsWith("/") ? normalizedRootFolder : `${normalizedRootFolder}/`;
const filteredFiles = files.filter((file) => {
const normalizedFilePath = normalizePath(file.path);
return rootFolder ? normalizedFilePath.startsWith(rootPrefix) && !normalizedFilePath.endsWith(".json") : !normalizedFilePath.endsWith(".json");
});
if (filteredFiles.length === 0) {
return null;
}
const root = {
name: rootFolder || "",
path: rootFolder || "",
children: []
};
filteredFiles.forEach((file) => {
const path2 = file.path.slice(rootFolder.length);
const parts = path2.split("/");
let currentLevel = root.children;
let currentPath = rootFolder;
parts.forEach((part, index) => {
if (index !== 0) {
currentPath += `/${part}`;
} else {
currentPath += `${part}`;
}
let existingNode = currentLevel.find((node) => node.name === part);
if (!existingNode) {
if (index === parts.length - 1) {
existingNode = {
name: part,
file,
path: currentPath
};
} else {
existingNode = {
name: part,
path: currentPath,
children: []
};
}
currentLevel.push(existingNode);
}
if (!existingNode.file) {
currentLevel = existingNode.children;
}
});
});
return root;
}
// src/BarrelManager.ts
var BarrelManager = class {
#options;
constructor(options = {}) {
this.#options = options;
return this;
}
getFiles({ files: generatedFiles, root }) {
const { logger } = this.#options;
const cachedFiles = /* @__PURE__ */ new Map();
TreeNode.build(generatedFiles, root)?.forEach((treeNode) => {
if (!treeNode || !treeNode.children || !treeNode.parent?.data.path) {
return void 0;
}
const barrelFile = {
path: path.join(treeNode.parent?.data.path, "index.ts"),
baseName: "index.ts",
exports: [],
sources: []
};
const previousBarrelFile = cachedFiles.get(barrelFile.path);
const leaves = treeNode.leaves;
leaves.forEach((item) => {
if (!item.data.name) {
return void 0;
}
const sources = item.data.file?.sources || [];
if (!sources.some((source) => source.isIndexable)) {
logger?.emit(
"warning",
`No isIndexable source found(source should have a name and isIndexable):
File: ${JSON.stringify(item.data.file, void 0, 2)}`
);
}
sources.forEach((source) => {
if (!item.data.file?.path || !source.isIndexable || !source.name) {
return void 0;
}
const alreadyContainInPreviousBarrelFile = previousBarrelFile?.sources.some(
(item2) => item2.name === source.name && item2.isTypeOnly === source.isTypeOnly
);
if (alreadyContainInPreviousBarrelFile) {
return void 0;
}
if (!barrelFile.exports) {
barrelFile.exports = [];
}
const isSubExport = !!treeNode.parent?.data.path?.split?.("/")?.length;
if (isSubExport) {
barrelFile.exports.push({
name: [source.name],
path: chunkE4XLCCPK_cjs.getRelativePath(treeNode.parent?.data.path, item.data.path),
isTypeOnly: source.isTypeOnly
});
} else {
barrelFile.exports.push({
name: [source.name],
path: `./${item.data.file.baseName}`,
isTypeOnly: source.isTypeOnly
});
}
barrelFile.sources.push({
name: source.name,
isTypeOnly: source.isTypeOnly,
//TODO use parser to generate import
value: "",
isExportable: false,
isIndexable: false
});
});
});
if (previousBarrelFile) {
previousBarrelFile.sources.push(...barrelFile.sources);
previousBarrelFile.exports?.push(...barrelFile.exports || []);
} else {
cachedFiles.set(barrelFile.path, barrelFile);
}
});
return [...cachedFiles.values()];
}
};
// src/utils/Cache.ts
var Cache = class {
#buffer = /* @__PURE__ */ new Map();
async get(key) {
return this.#buffer.get(key) ?? null;
}
async set(key, value) {
this.#buffer.set(key, value);
}
async delete(key) {
this.#buffer.delete(key);
}
async clear() {
this.#buffer.clear();
}
async keys() {
return [...this.#buffer.keys()];
}
async values() {
return [...this.#buffer.values()];
}
async flush() {
}
};
// src/FileManager.ts
var FileManager = class {
#cache = new Cache();
#limit = pLimit__default.default(100);
constructor() {
return this;
}
async add(...files) {
const resolvedFiles = [];
const mergedFiles = /* @__PURE__ */ new Map();
files.forEach((file) => {
const existing = mergedFiles.get(file.path);
if (existing) {
mergedFiles.set(file.path, mergeFile(existing, file));
} else {
mergedFiles.set(file.path, file);
}
});
for (const file of mergedFiles.values()) {
const existing = await this.#cache.get(file.path);
const merged = existing ? mergeFile(existing, file) : file;
const resolvedFile = createFile(merged);
await this.#cache.set(resolvedFile.path, resolvedFile);
await this.#cache.flush();
resolvedFiles.push(resolvedFile);
}
if (files.length > 1) {
return resolvedFiles;
}
return resolvedFiles[0];
}
async getByPath(path2) {
return this.#cache.get(path2);
}
async deleteByPath(path2) {
await this.#cache.delete(path2);
}
async clear() {
await this.#cache.clear();
}
async getFiles() {
const cachedKeys = await this.#cache.keys();
const keys = chunkBHSTNFNQ_cjs.orderBy(cachedKeys, [(v) => v.length, (v) => chunkE4XLCCPK_cjs.trimExtName(v).endsWith("index")]);
const filesTasks = keys.map(
(key) => this.#limit(async () => {
const file = await this.#cache.get(key);
return file;
})
);
const files = await Promise.all(filesTasks);
return files.filter(Boolean);
}
async processFiles({ dryRun, root, extension, logger }) {
const files = await this.getFiles();
logger?.emit("progress_start", { id: "files", size: files.length, message: "Writing files ..." });
const promises = files.map((file) => {
return this.#limit(async () => {
const message = file ? `Writing ${path.relative(root, file.path)}` : "";
const extname2 = extension?.[file.extname] || void 0;
if (!dryRun) {
const source = await getSource(file, { logger, extname: extname2 });
await chunkE4XLCCPK_cjs.write(file.path, source, { sanity: false });
}
logger?.emit("progressed", { id: "files", message });
});
});
await Promise.all(promises);
logger?.emit("progress_stop", { id: "files" });
return files;
}
async getBarrelFiles({ type, meta = {}, root, output, logger }) {
if (!type || type === "propagate") {
return [];
}
const barrelManager = new BarrelManager({ logger });
const files = await this.getFiles();
const pathToBuildFrom = path.join(root, output.path);
if (chunkE4XLCCPK_cjs.trimExtName(pathToBuildFrom).endsWith("index")) {
logger?.emit("warning", "Output has the same fileName as the barrelFiles, please disable barrel generation");
return [];
}
const barrelFiles = barrelManager.getFiles({ files, root: pathToBuildFrom, meta });
if (type === "all") {
return barrelFiles.map((file) => {
return {
...file,
exports: file.exports?.map((exportItem) => {
return {
...exportItem,
name: void 0
};
})
};
});
}
return barrelFiles.map((indexFile) => {
return {
...indexFile,
meta
};
});
}
// statics
static getMode(path2) {
if (!path2) {
return "split";
}
return path.extname(path2) ? "single" : "split";
}
};
async function getSource(file, { logger, extname: extname2 } = {}) {
const parser = await getFileParser(file.extname);
const source = await parser.print(file, { logger, extname: extname2 });
return parser.format(source).catch((err) => {
console.warn(err);
return source;
});
}
function mergeFile(a, b) {
return {
...a,
sources: [...a.sources || [], ...b.sources || []],
imports: [...a.imports || [], ...b.imports || []],
exports: [...a.exports || [], ...b.exports || []]
};
}
function combineSources(sources) {
return remeda.uniqueBy(sources, (obj) => [obj.name, obj.isExportable, obj.isTypeOnly]);
}
function combineExports(exports) {
return chunkBHSTNFNQ_cjs.orderBy(exports, [
(v) => !!Array.isArray(v.name),
(v) => !v.isTypeOnly,
(v) => v.path,
(v) => !!v.name,
(v) => Array.isArray(v.name) ? chunkBHSTNFNQ_cjs.orderBy(v.name) : v.name
]).reduce(
(prev, curr) => {
const name = curr.name;
const prevByPath = prev.findLast((imp) => imp.path === curr.path);
const prevByPathAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && remeda.isDeepEqual(imp.name, name) && imp.isTypeOnly);
if (prevByPathAndIsTypeOnly) {
return prev;
}
const uniquePrev = prev.findLast(
(imp) => imp.path === curr.path && remeda.isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly && imp.asAlias === curr.asAlias
);
if (uniquePrev || Array.isArray(name) && !name.length || prevByPath?.asAlias && !curr.asAlias) {
return prev;
}
if (!prevByPath) {
return [
...prev,
{
...curr,
name: Array.isArray(name) ? [...new Set(name)] : name
}
];
}
if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(curr.name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
prevByPath.name = [.../* @__PURE__ */ new Set([...prevByPath.name, ...curr.name])];
return prev;
}
return [...prev, curr];
},
[]
);
}
function combineImports(imports, exports, source) {
return chunkBHSTNFNQ_cjs.orderBy(imports, [
(v) => !!Array.isArray(v.name),
(v) => !v.isTypeOnly,
(v) => v.path,
(v) => !!v.name,
(v) => Array.isArray(v.name) ? chunkBHSTNFNQ_cjs.orderBy(v.name) : v.name
]).reduce(
(prev, curr) => {
let name = Array.isArray(curr.name) ? [...new Set(curr.name)] : curr.name;
const hasImportInSource = (importName) => {
if (!source) {
return true;
}
const checker = (name2) => {
return name2 && source.includes(name2);
};
return checker(importName) || exports.some(({ name: name2 }) => Array.isArray(name2) ? name2.some(checker) : checker(name2));
};
if (curr.path === curr.root) {
return prev;
}
if (Array.isArray(name)) {
name = name.filter((item) => typeof item === "string" ? hasImportInSource(item) : hasImportInSource(item.propertyName));
}
const prevByPath = prev.findLast((imp) => imp.path === curr.path && imp.isTypeOnly === curr.isTypeOnly);
const uniquePrev = prev.findLast((imp) => imp.path === curr.path && remeda.isDeepEqual(imp.name, name) && imp.isTypeOnly === curr.isTypeOnly);
const prevByPathNameAndIsTypeOnly = prev.findLast((imp) => imp.path === curr.path && remeda.isDeepEqual(imp.name, name) && imp.isTypeOnly);
if (prevByPathNameAndIsTypeOnly) {
return prev;
}
if (uniquePrev || Array.isArray(name) && !name.length) {
return prev;
}
if (!prevByPath) {
return [
...prev,
{
...curr,
name
}
];
}
if (prevByPath && Array.isArray(prevByPath.name) && Array.isArray(name) && prevByPath.isTypeOnly === curr.isTypeOnly) {
prevByPath.name = [.../* @__PURE__ */ new Set([...prevByPath.name, ...name])];
return prev;
}
if (!Array.isArray(name) && name && !hasImportInSource(name)) {
return prev;
}
return [...prev, curr];
},
[]
);
}
// src/utils/parser.ts
function getDefaultBanner({ title, description, version, config }) {
try {
let source = "";
if ("path" in config.input) {
source = path__default.default.basename(config.input.path);
} else if ("data" in config.input) {
source = "text content";
}
let banner = "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n";
if (config.output.defaultBanner === "simple") {
banner += "*/\n";
return banner;
}
if (source) {
banner += `* Source: ${source}
`;
}
if (title) {
banner += `* Title: ${title}
`;
}
if (description) {
const formattedDescription = description.replace(/\n/gm, "\n* ");
banner += `* Description: ${formattedDescription}
`;
}
if (version) {
banner += `* OpenAPI spec version: ${version}
`;
}
banner += "*/\n";
return banner;
} catch (_error) {
return "/**\n* Generated by Kubb (https://kubb.dev/).\n* Do not edit manually.\n*/";
}
}
function createFile(file) {
const extname2 = path__default.default.extname(file.baseName);
if (!extname2) {
throw new Error(`No extname found for ${file.baseName}`);
}
const source = file.sources.map((item) => item.value).join("\n\n");
const exports = file.exports?.length ? combineExports(file.exports) : [];
const imports = file.imports?.length && source ? combineImports(file.imports, exports, source) : [];
const sources = file.sources?.length ? combineSources(file.sources) : [];
return {
...file,
id: hash__default.default({ path: file.path }),
name: trimExtName2(file.baseName),
extname: extname2,
imports: imports.map(createFileImport),
exports: exports.map(createFileExport),
sources: sources.map(createFileSource),
meta: file.meta || {}
};
}
function createFileSource(source) {
return source;
}
function createFileImport(imp) {
return {
...imp
};
}
function createFileExport(exp) {
return {
...exp
};
}
function createFileParser(parser) {
return parser;
}
var typeScriptParser = createFileParser({
async format(source) {
const module = await import('@kubb/parser-ts');
return module.format(source);
},
async print(file, options = { extname: ".ts" }) {
const module = await import('@kubb/parser-ts');
const source = file.sources.map((item) => item.value).join("\n\n");
const importNodes = file.imports.map((item) => {
const importPath = item.root ? chunkE4XLCCPK_cjs.getRelativePath(item.root, item.path) : item.path;
const hasExtname = !!path__default.default.extname(importPath);
return module.factory.createImportDeclaration({
name: item.name,
path: options.extname && hasExtname ? `${trimExtName2(importPath)}${options.extname}` : item.root ? trimExtName2(importPath) : importPath,
isTypeOnly: item.isTypeOnly
});
}).filter(Boolean);
const exportNodes = file.exports.map((item) => {
const exportPath = item.path;
const hasExtname = !!path__default.default.extname(exportPath);
return module.factory.createExportDeclaration({
name: item.name,
path: options.extname && hasExtname ? `${trimExtName2(item.path)}${options.extname}` : trimExtName2(item.path),
isTypeOnly: item.isTypeOnly,
asAlias: item.asAlias
});
}).filter(Boolean);
return [file.banner, module.print([...importNodes, ...exportNodes]), source, file.footer].join("\n");
}
});
var tsxParser = createFileParser({
async format(source) {
const module = await import('@kubb/parser-ts');
return module.format(source);
},
async print(file, options = { extname: ".tsx" }) {
return typeScriptParser.print(file, options);
}
});
var defaultParser = createFileParser({
async format(source) {
return source;
},
async print(file) {
return file.sources.map((item) => item.value).join("\n\n");
}
});
var parsers = {
".ts": typeScriptParser,
".js": typeScriptParser,
".jsx": tsxParser,
".tsx": tsxParser,
".json": defaultParser
};
async function getFileParser(extname2) {
if (!extname2) {
return defaultParser;
}
const parser = parsers[extname2];
if (!parser) {
console.warn(`[parser] No parser found for ${extname2}, default parser will be used`);
}
return parser || defaultParser;
}
function trimExtName2(text) {
const extname2 = text.split(".").pop();
return text.replace(`.${extname2}`, "");
}
exports.Cache = Cache;
exports.FileManager = FileManager;
exports.FunctionParams = FunctionParams;
exports.URLPath = URLPath;
exports.createFile = createFile;
exports.createFileExport = createFileExport;
exports.createFileImport = createFileImport;
exports.createFileParser = createFileParser;
exports.getDefaultBanner = getDefaultBanner;
exports.getFileParser = getFileParser;
exports.getSource = getSource;
exports.getUniqueName = getUniqueName;
exports.isPromise = isPromise;
exports.isPromiseFulfilledResult = isPromiseFulfilledResult;
exports.isPromiseRejectedResult = isPromiseRejectedResult;
exports.renderTemplate = renderTemplate;
exports.setUniqueName = setUniqueName;
exports.timeout = timeout;
//# sourceMappingURL=chunk-QR7CQIA3.cjs.map
//# sourceMappingURL=chunk-QR7CQIA3.cjs.map