@luna-park/plugin 1.3.1 → 1.4.1

package/dist/extractor.mjs

@@ -0,0 +1,611 @@
+import { c as typeToSchema, d as objectMap, i as LogicType, l as cleanObject, r as EVarType, s as schemaLoop } from "./dist-hc-SHkAg.mjs";
+import fs from "node:fs";
+import * as ts$1 from "typescript";
+import ts from "typescript";
+import * as path from "path";
+import * as fs$1 from "fs";
+//#region src/extractor/code/lib.ts
+function generateCode(schema, options = {}) {
+	if (typeof schema !== "object" || schema === null) return JSON.stringify(schema);
+	const properties = {};
+	for (const props of [
+		"default",
+		"description",
+		"name",
+		"target",
+		"promise",
+		"optional",
+		"example",
+		"enum"
+	]) if (schema[props]) properties[props] = schema[props];
+	if (schema.type === EVarType.array) return buildFunctionCall(`LogicType.${schema.type}`, [generateCode(schema.items, options), getCodeFromObject(properties)]);
+	if (schema.type === EVarType.interface) return buildFunctionCall(`LogicType.${schema.type}`, [JSON.stringify(schema.className), getCodeFromObject(properties)]);
+	if (schema.type === EVarType.union) return buildFunctionCall(`LogicType.${schema.type}`, [`[${schema.elements.map((element) => generateCode(element, options)).join(", ")}]`, getCodeFromObject(properties)]);
+	if (schema.type === EVarType.function) return buildFunctionCall(`LogicType.${schema.type}`, [
+		generateCode(schema.inputs, options),
+		generateCode(schema.output, options),
+		getCodeFromObject(properties)
+	]);
+	if (schema.type === EVarType.object) return buildFunctionCall(`LogicType.${schema.type}`, [getCodeFromObject(objectMap(schema.properties, ({ value }) => generateCode(value, options)), true), getCodeFromObject(properties)]);
+	if (schema.type === EVarType.type) {
+		const target = schema.target.at(-1);
+		const propertyCode = getCodeFromObject(properties);
+		if (propertyCode !== "{}") return target;
+		else return `{ ...${target}, ${propertyCode.slice(1, -1)} }`;
+	}
+	return buildFunctionCall(`LogicType.${schema.type}`, [getCodeFromObject(properties)]);
+}
+function buildFunctionCall(target, args) {
+	const lastArgIndex = args.findLastIndex((arg) => arg !== "{}");
+	return `${target}(${args.slice(0, lastArgIndex + 1).join(", ")})`;
+}
+function getCodeFromObject(object, raw) {
+	return `{${Object.entries(object).map(([key, value]) => `${getSafeKey(key)}: ${raw ? value : JSON.stringify(value)}`).join(", ")}}`;
+}
+function getSafeKey(key) {
+	return /^[a-zA-Z]+$/.test(key) ? key : JSON.stringify(key);
+}
+//#endregion
+//#region src/extractor/code/component.ts
+function getComponentCode(logicResult, file) {
+	const content = [];
+	const component = logicResult.components["default"];
+	const typeLib = Object.keys(logicResult.types);
+	for (const type of [
+		"properties",
+		"slots",
+		"models",
+		"emits"
+	]) if (component[type] && Object.keys(component[type]).length) content.push({
+		key: type,
+		value: Object.entries(component[type]).map(([key, value]) => `${getSafeKey(key)}: ${generateCode(value, { lib: typeLib })}`).join(",\n        ")
+	});
+	const typesDeclaration = Object.entries(logicResult.types).map(([key, value]) => `const ${key} = ${generateCode(value, { lib: typeLib })};`).join("\n\n");
+	return `import { LogicType, type TComponent } from "@luna-park/plugin";
+import ${file.name} from "${file.path}";
+
+${typesDeclaration}
+
+export const ${file.name.toLocaleLowerCase()}: TComponent = {
+    name: "${file.name}",
+    component: ${file.name},
+    ${content.map(({ key, value }) => `${key}: {\n        ${value}\n    }`).join(",\n    ")}
+}`;
+}
+//#endregion
+//#region src/extractor/documentation.ts
+function getDocumentationFromSymbol(symbol, checker) {
+	const documentation = { description: mergeSymbolDisplayParts(symbol.getDocumentationComment(checker)) || void 0 };
+	for (const tag of symbol.getJsDocTags()) {
+		if (tag.name === "param") {
+			if (!documentation.params) documentation.params = {};
+			let paramDescription = mergeSymbolDisplayParts(tag.text?.slice(1)).trim();
+			if (paramDescription.startsWith("- ")) paramDescription = paramDescription.slice(2);
+			const paramName = tag.text[0]?.text;
+			documentation.params[paramName] = paramDescription;
+			continue;
+		}
+		documentation[tag.name] = mergeSymbolDisplayParts(tag.text);
+	}
+	return cleanObject(documentation);
+}
+function mergeSymbolDisplayParts(symbolDisplayParts = []) {
+	return symbolDisplayParts.map((part) => part.text).join("");
+}
+//#endregion
+//#region src/extractor/export/component.ts
+function getSlots(type, typeExport) {
+	const properties = typeExport.checker.getPropertiesOfType(type);
+	const slots = {};
+	properties.forEach((slot) => {
+		const slotType = getDefinedType(typeExport.checker.getTypeOfSymbol(slot)).type;
+		const firstParameter = typeExport.checker.getSignaturesOfType(slotType, ts$1.SignatureKind.Call)[0]?.parameters?.[0];
+		if (firstParameter) {
+			const firstParameterType = typeExport.checker.getTypeOfSymbol(firstParameter);
+			slots[slot.name] = { type: typeExport.typeToString(firstParameterType) };
+			typeExport.extractType(firstParameterType);
+		} else slots[slot.name] = { type: "{}" };
+	});
+	return slots;
+}
+function getProps(type, typeExport) {
+	const properties = typeExport.checker.getPropertiesOfType(type);
+	const props = {};
+	const emits = {};
+	properties.forEach((prop) => {
+		if (["onVnode", "ref_"].some((name) => prop.name.startsWith(name)) || [
+			"ref",
+			"class",
+			"style",
+			"key"
+		].includes(prop.name)) return;
+		const propType = typeExport.checker.getTypeOfSymbol(prop);
+		typeExport.extractType(propType);
+		if (isEmits(prop.name)) {
+			emits[emitName(prop.name)] = getExportType(propType, prop, typeExport);
+			return;
+		}
+		props[prop.name] = getExportType(propType, prop, typeExport);
+	});
+	return {
+		emits,
+		props
+	};
+}
+function computeModels(component) {
+	component.models = Object.keys(component.properties ?? {}).reduce((models, prop) => {
+		if (component.emits?.[`update:${prop}`]) {
+			models[prop] = component.properties[prop];
+			delete component.properties[prop];
+			delete component.emits[`update:${prop}`];
+		}
+		return models;
+	}, {});
+	return component;
+}
+function getDefinedType(type) {
+	if (type.isUnion()) {
+		const notUndefined = type.types.filter((type) => type.flags !== ts$1.TypeFlags.Undefined);
+		if (notUndefined.length === 1) return {
+			optional: true,
+			type: notUndefined[0]
+		};
+	}
+	return { type };
+}
+function getExportType(type, symbol, typeExport) {
+	const definedType = getDefinedType(type);
+	return cleanObject({
+		description: getDocumentationFromSymbol(symbol, typeExport.checker).description,
+		optional: definedType.optional,
+		type: typeExport.typeToString(definedType.type)
+	});
+}
+function isEmits(name) {
+	return /^on[A-Z]/.test(name);
+}
+function emitName(name) {
+	name = name.slice(2);
+	return name.charAt(0).toLowerCase() + name.slice(1);
+}
+//#endregion
+//#region src/extractor/export/template.ts
+function getTemplateTypeParameters(signature, typeExport) {
+	return Object.fromEntries((signature.getTypeParameters() ?? []).map((typeParameter) => {
+		let type = "unknown";
+		const defaultType = typeParameter.getDefault();
+		if (defaultType) type = typeExport.typeToString(defaultType);
+		const constraintType = typeParameter.getConstraint();
+		if (constraintType) type = typeExport.typeToString(constraintType);
+		return [typeParameter.symbol.name, type];
+	}));
+}
+//#endregion
+//#region src/extractor/export/utils.ts
+function getResolvedExports(checker, module) {
+	const resolvedExports = /* @__PURE__ */ new Map();
+	const exports = checker.getExportsOfModule(module);
+	for (const exp of exports) {
+		let resolvedSymbol = exp;
+		while (resolvedSymbol.flags & ts$1.SymbolFlags.Alias) resolvedSymbol = checker.getAliasedSymbol(resolvedSymbol);
+		resolvedExports.set(exp.name, resolvedSymbol);
+	}
+	return resolvedExports;
+}
+function getFullName(checker, symbol) {
+	let fullName = checker.getFullyQualifiedName(symbol);
+	if (fullName.includes("\".")) fullName = fullName.split("\".").pop();
+	if (fullName.includes(").")) fullName = fullName.split(").").pop();
+	return fullName;
+}
+function swapType(target, template) {
+	for (const [key, value] of Object.entries(template)) target = target.replace(new RegExp(`\\b${key}\\b`, "g"), value);
+	return target;
+}
+function extractEnumDefinition(enumDeclaration) {
+	const members = [];
+	enumDeclaration.members.forEach((member) => {
+		const memberName = member.name.getText();
+		if (member.initializer) {
+			let initializerText;
+			if (ts$1.isStringLiteral(member.initializer)) initializerText = `"${member.initializer.text}"`;
+			else if (ts$1.isNumericLiteral(member.initializer)) initializerText = member.initializer.text;
+			else initializerText = member.initializer.getText();
+			members.push(`${memberName} = ${initializerText}`);
+		} else members.push(memberName);
+	});
+	return `{ ${members.join(", ")} }`;
+}
+//#endregion
+//#region src/extractor/lib.ts
+function isUserType(type) {
+	if (type.getFlags() & (ts.TypeFlags.StringLike | ts.TypeFlags.NumberLike | ts.TypeFlags.BooleanLike | ts.TypeFlags.ESSymbolLike | ts.TypeFlags.Void | ts.TypeFlags.Undefined | ts.TypeFlags.Null | ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never)) return false;
+	const symbol = type.getSymbol();
+	if (!symbol) return true;
+	const declaration = symbol.declarations?.[0];
+	if (!declaration) return true;
+	const srcFile = declaration.getSourceFile();
+	if (/lib\..*\.d\.ts$/.test(srcFile.fileName)) return false;
+	if (srcFile.fileName.startsWith("/@vue/")) return false;
+	return true;
+}
+//#endregion
+//#region src/extractor/export/index.ts
+const FLAGS = ts.TypeFormatFlags.WriteArrowStyleSignature | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseFullyQualifiedType;
+var CTypeExport = class {
+	checker;
+	index;
+	cache = /* @__PURE__ */ new Set();
+	result;
+	constructor(program) {
+		this.program = program;
+		this.checker = program.getTypeChecker();
+	}
+	get(target) {
+		this.index = this.program.getSourceFile(target);
+		if (!this.index) throw new Error(`Cannot find file ${target}`);
+		const moduleSymbol = this.checker.getSymbolAtLocation(this.index);
+		if (!moduleSymbol) throw new Error(`Cannot find module ${target}`);
+		this.result = {
+			components: {},
+			functions: {},
+			types: {}
+		};
+		const exportAssignment = this.index.statements.find((statement) => ts.isExportAssignment(statement));
+		if (exportAssignment) {
+			const callSignature = this.checker.getTypeAtLocation(exportAssignment.expression).getCallSignatures()[0];
+			if (callSignature) this.exportFunction("default", callSignature);
+		}
+		this.exportModule(moduleSymbol);
+		return this.result;
+	}
+	exportModule(module) {
+		const resolvedExports = getResolvedExports(this.checker, module);
+		for (const [name, exportSymbol] of resolvedExports.entries()) {
+			let exportType = this.checker.getTypeOfSymbol(exportSymbol);
+			if (exportType.symbol && exportType.symbol.flags & ts.SymbolFlags.Module) {
+				const defaultExport = exportType.symbol.exports?.get("default");
+				if (defaultExport) exportType = this.checker.getTypeOfSymbol(defaultExport);
+			}
+			const symbol = exportType.symbol || exportType.aliasSymbol;
+			if (symbol?.flags & ts.SymbolFlags.Function) {
+				const functionType = this.checker.getTypeOfSymbol(symbol);
+				const callSignature = this.checker.getSignaturesOfType(functionType, ts.SignatureKind.Call)[0];
+				if (callSignature) {
+					const fullName = getFullName(this.checker, symbol);
+					this.exportFunction(fullName, callSignature);
+				}
+			} else if (this.typeToString(exportType).includes("DefineComponent<")) try {
+				this.exportComponent(name, exportType);
+			} catch (e) {
+				console.error(`Fail to export component ${name}`);
+				console.error(e);
+			}
+		}
+	}
+	exportComponent(name, type) {
+		const constructSignatures = type.getConstructSignatures()[0];
+		if (!constructSignatures) return;
+		const returnType = this.checker.getReturnTypeOfSignature(constructSignatures);
+		const component = {};
+		const propsSymbol = this.checker.getPropertyOfType(returnType, "$props");
+		if (propsSymbol) {
+			const props = getProps(this.checker.getTypeOfSymbol(propsSymbol), this);
+			component.properties = props.props;
+			component.emits = props.emits;
+		}
+		const slotsSymbol = this.checker.getPropertyOfType(returnType, "$slots");
+		if (slotsSymbol) component.slots = getSlots(this.checker.getTypeOfSymbol(slotsSymbol), this);
+		this.result.components[name] = computeModels(component);
+	}
+	exportFunction(name, signature) {
+		const documentation = getDocumentationFromSymbol(signature, this.checker);
+		const typeParameters = getTemplateTypeParameters(signature, this);
+		const parameters = signature.getParameters().map((symbol) => {
+			const pNode = symbol.valueDeclaration ?? this.index;
+			const pType = this.checker.getTypeOfSymbol(symbol);
+			this.extractType(pType, pNode);
+			const defaultValue = symbol.valueDeclaration?.initializer?.getText();
+			return cleanObject({
+				default: defaultValue,
+				description: documentation.params?.[symbol.name],
+				name: symbol.name,
+				optional: !!pNode.questionToken || defaultValue !== void 0 || void 0,
+				type: swapType(this.typeToString(pType), typeParameters)
+			});
+		});
+		if (parameters.some((parameter) => parameter.name?.startsWith("__VLS_"))) {
+			const component = {};
+			const propsIndex = parameters.findIndex((parameter) => parameter.name === "__VLS_props");
+			const propsSymbol = signature.getParameters()[propsIndex];
+			if (propsSymbol) {
+				const props = getProps(this.checker.getTypeOfSymbol(propsSymbol), this);
+				component.properties = props.props;
+				component.emits = props.emits;
+				Object.values(component.properties).forEach((prop) => {
+					prop.type = swapType(prop.type, typeParameters);
+				});
+			}
+			const slotsIndex = parameters.findIndex((parameter) => parameter.name === "__VLS_slots");
+			const slotsSymbol = signature.getParameters()[slotsIndex];
+			if (slotsSymbol) {
+				component.slots = getSlots(this.checker.getTypeOfSymbol(slotsSymbol), this);
+				Object.values(component.slots).forEach((slot) => {
+					slot.type = swapType(slot.type, typeParameters);
+				});
+			}
+			this.result.components[name] = computeModels(component);
+			return;
+		}
+		const returnType = this.checker.getReturnTypeOfSignature(signature);
+		this.extractType(returnType);
+		this.result.functions[name] = cleanObject({
+			description: documentation.description,
+			parameters,
+			return: {
+				description: documentation.returns,
+				type: swapType(this.typeToString(returnType), typeParameters)
+			}
+		});
+	}
+	extractType(type, ctxNode = this.index) {
+		if (this.cache.has(type)) return;
+		this.cache.add(type);
+		const symbol = type.symbol || type.aliasSymbol;
+		if ((type.isUnion() || type.isIntersection()) && !(symbol?.flags & ts.SymbolFlags.Enum)) type.types.forEach((childType) => {
+			this.extractType(childType, ctxNode);
+		});
+		if (symbol) {
+			if (this.checker.getFullyQualifiedName(symbol).includes("/@vue/")) return;
+			const fullName = getFullName(this.checker, symbol);
+			if (symbol.flags & ts.SymbolFlags.Enum) {
+				const enumDeclaration = symbol.valueDeclaration || symbol.declarations?.[0];
+				if (enumDeclaration && ts.isEnumDeclaration(enumDeclaration)) {
+					const fullName = getFullName(this.checker, symbol);
+					this.result.types[fullName] = cleanObject({
+						...getDocumentationFromSymbol(symbol, this.checker),
+						type: extractEnumDefinition(enumDeclaration)
+					});
+				}
+				return;
+			}
+			if (symbol.flags & ts.SymbolFlags.Namespace) {
+				const namespaceSymbol = symbol;
+				this.exportModule(namespaceSymbol);
+			}
+			if (symbol.flags & ts.SymbolFlags.TypeAlias) {
+				const declaration = symbol.valueDeclaration || symbol.declarations?.[0];
+				if (!declaration) return;
+				const typeParameters = Object.fromEntries((declaration?.typeParameters ?? []).map((typeParameter) => {
+					let type = "unknown";
+					const defaultType = typeParameter.default;
+					if (defaultType) {
+						const defaultTypeObj = this.checker.getTypeFromTypeNode(defaultType);
+						type = this.typeToString(defaultTypeObj);
+					}
+					const constraintType = typeParameter.constraint;
+					if (constraintType) {
+						const constraintTypeObj = this.checker.getTypeFromTypeNode(constraintType);
+						type = this.typeToString(constraintTypeObj);
+					}
+					return [typeParameter.symbol.name, type];
+				}));
+				this.result.types[fullName] = {
+					...getDocumentationFromSymbol(symbol, this.checker),
+					type: swapType(this.typeToString(type, FLAGS | ts.TypeFormatFlags.InTypeAlias), typeParameters)
+				};
+			}
+			if (symbol.flags & ts.SymbolFlags.Interface && isUserType(type)) {
+				const declaration = symbol.getDeclarations()[0];
+				if (declaration) {
+					const properties = this.checker.getPropertiesOfType(type);
+					const exportProperties = {};
+					properties.forEach((prop) => {
+						const propType = this.checker.getTypeOfSymbol(prop);
+						this.extractType(propType, declaration);
+						exportProperties[prop.name] = {
+							...getDocumentationFromSymbol(prop, this.checker),
+							optional: !!(prop.flags & ts.SymbolFlags.Optional) || void 0,
+							type: this.typeToString(propType)
+						};
+					});
+					this.result.types[fullName] = {
+						...getDocumentationFromSymbol(symbol, this.checker),
+						type: exportProperties
+					};
+				}
+			}
+			if (symbol.flags & ts.SymbolFlags.TypeLiteral) {
+				const fullName = getFullName(this.checker, type.aliasSymbol || type.symbol);
+				const properties = this.checker.getPropertiesOfType(type);
+				const exportProperties = {};
+				if ([
+					"Promise",
+					"Partial",
+					"Pick",
+					"Omit",
+					"Required"
+				].includes(fullName)) {
+					this.cache.delete(type);
+					this.extractType(type.aliasTypeArguments[0]);
+					return;
+				}
+				if (type.aliasTypeArguments?.some((typeArgument) => !isUserType(typeArgument))) return;
+				properties.forEach((prop) => {
+					const propType = this.checker.getTypeOfSymbol(prop);
+					exportProperties[prop.name] = {
+						...getDocumentationFromSymbol(prop, this.checker),
+						optional: !!(prop.flags & ts.SymbolFlags.Optional),
+						type: this.typeToString(propType)
+					};
+				});
+				if (fullName !== "__type") this.result.types[fullName] = {
+					...getDocumentationFromSymbol(symbol, this.checker),
+					type: exportProperties
+				};
+			}
+		}
+		if (type.flags & ts.TypeFlags.Object) {
+			const object = type;
+			if (isUserType(type)) this.checker.getPropertiesOfType(type).forEach((prop) => {
+				const propType = this.checker.getTypeOfSymbol(prop);
+				this.extractType(propType, ctxNode);
+			});
+			if (object.objectFlags & ts.ObjectFlags.Reference) {
+				const reference = object;
+				this.checker.getTypeArguments(reference).forEach((typeArg) => {
+					this.extractType(typeArg, ctxNode);
+				});
+			}
+		}
+	}
+	typeToString(type, flags = FLAGS) {
+		return this.checker.typeToString(type, void 0, flags);
+	}
+};
+//#endregion
+//#region src/extractor/generator.ts
+function generateNodes(exportResult, packageName = "unknown") {
+	const nodeResult = {
+		components: {},
+		functions: {},
+		types: {}
+	};
+	for (const [name, type] of Object.entries(exportResult.types)) nodeResult.types[name] = getSchemaFromType(type, name);
+	for (const [name, type] of Object.entries(exportResult.functions)) nodeResult.functions[name] = getSchemaFromFunction(type, name);
+	for (const [name, type] of Object.entries(exportResult.components)) nodeResult.components[name] = getSchemaFromComponent(type, name);
+	return nodeResult;
+	function getSchemaFromType(type, name = "") {
+		if (typeof type.type === "string") {
+			if (type.type === "{}") return LogicType.void();
+			const schema = {
+				...linkTypeReferences(typeToSchema(type.type)),
+				...cleanObject({
+					description: type.description,
+					name: name?.split(".").pop() || void 0,
+					optional: type.optional
+				})
+			};
+			if (type.default) switch (schema.type) {
+				case EVarType.boolean:
+					schema.default = type.default === "true";
+					break;
+				case EVarType.number:
+					schema.default = Number(type.default);
+					break;
+				case EVarType.string:
+					schema.default = type.default;
+					break;
+			}
+			if (schema.type === EVarType.object && !Object.keys(schema.properties).length) schema.customizable = true;
+			return schema;
+		} else {
+			const schema = LogicType.object(objectMap(type.type, ({ key, value }) => getSchemaFromType(value, key)), cleanObject({
+				description: type.description,
+				name: name?.split(".").pop(),
+				optional: type.optional
+			}));
+			if (!Object.keys(schema.properties).length) schema.customizable = true;
+			return schema;
+		}
+	}
+	function getSchemaFromFunction(func, name = "") {
+		return {
+			...cleanObject({
+				description: func.description,
+				name: name?.split(".").pop()
+			}),
+			parameters: (func.parameters ?? []).map((param) => getSchemaFromType(param, param.name)),
+			return: getSchemaFromType(func.return, "result")
+		};
+	}
+	function getSchemaFromComponent(component, name = "") {
+		return {
+			...cleanObject({ name: name?.split(".").pop() }),
+			emits: objectMap(component.emits, ({ value }) => getSchemaFromType(value)),
+			models: objectMap(component.models, ({ value }) => getSchemaFromType(value)),
+			properties: objectMap(component.properties, ({ key, value }) => getSchemaFromType(value, key)),
+			slots: objectMap(component.slots, ({ value }) => getSchemaFromType(value))
+		};
+	}
+	function linkTypeReferences(schema, prefix = "") {
+		return schemaLoop(schema, ({ schema }) => {
+			if (schema.type === EVarType.interface) return {
+				...getShadowedType(schema.className, prefix),
+				description: schema.description,
+				name: schema.name,
+				optional: schema.optional
+			};
+		});
+		function getShadowedType(key, prefix = "") {
+			let target = `${prefix}${key}`;
+			while (!exportResult.types[target] && target.indexOf(".") !== -1) target = target.substring(target.indexOf(".") + 1);
+			return exportResult.types[target] ? LogicType.type([
+				"packages",
+				packageName,
+				...target.split(".")
+			]) : LogicType.interface(key);
+		}
+	}
+}
+//#endregion
+//#region src/extractor/config.ts
+function findNearestTsConfig(configPath) {
+	while (true) {
+		const tsconfigPath = path.join(configPath, "tsconfig.json");
+		if (fs$1.existsSync(tsconfigPath)) return tsconfigPath;
+		const parentDir = path.dirname(configPath);
+		if (parentDir === configPath) return;
+		configPath = parentDir;
+	}
+}
+function getTsConfig(configPath) {
+	const configFile = ts$1.readConfigFile(configPath, ts$1.sys.readFile);
+	if (configFile.error) throw new Error(`Failed to read tsconfig.json: ${configFile.error.messageText}`);
+	return ts$1.parseJsonConfigFileContent(configFile.config, ts$1.sys, path.dirname(configPath));
+}
+//#endregion
+//#region src/extractor/source.ts
+function resolveModulePath(moduleName, compilerOptions) {
+	const tempFileName = path.join(process.cwd(), "__temp__.ts");
+	const tempHost = ts$1.createCompilerHost(compilerOptions);
+	const resolved = ts$1.resolveModuleName(moduleName, tempFileName, compilerOptions, tempHost);
+	if (resolved.resolvedModule) return resolved.resolvedModule.resolvedFileName;
+}
+function getSourceFile(moduleName) {
+	const tsconfigPath = findNearestTsConfig(moduleName);
+	if (!tsconfigPath) throw new Error(`Could not find tsconfig.json for: ${moduleName}`);
+	const compilerOptions = getTsConfig(tsconfigPath).options;
+	const resolvedPath = resolveModulePath(moduleName, compilerOptions);
+	if (!resolvedPath) throw new Error(`Could not resolve module: ${moduleName}`);
+	const host = ts$1.createCompilerHost(compilerOptions);
+	const program = ts$1.createProgram({
+		host,
+		options: compilerOptions,
+		rootNames: [resolvedPath]
+	});
+	const sourceFile = program.getSourceFile(resolvedPath);
+	if (!sourceFile) throw new Error(`Could not get source file for: ${resolvedPath}`);
+	return {
+		program,
+		sourceFile
+	};
+}
+//#endregion
+//#region src/extractor/index.ts
+const fsp = fs.promises;
+async function extractFile(filePath, target) {
+	const fileName = filePath.split("/").pop().split(".")[0];
+	const { program, sourceFile } = getSourceFile(filePath);
+	const logicResult = generateNodes(new CTypeExport(program).get(sourceFile.fileName), fileName);
+	if (logicResult.components.default) {
+		const content = getComponentCode(logicResult, {
+			name: fileName,
+			path: filePath
+		});
+		await fsp.mkdir(target.split("/").slice(0, -1).join("/"), { recursive: true });
+		await fsp.writeFile(target, content);
+	}
+}
+//#endregion
+export { CTypeExport, extractFile, generateNodes, getSourceFile };