@luna-park/plugin 1.8.0 → 2.0.0

package/dist/eslint.d.mts

@@ -1,10 +1,10 @@
-//#region src/eslint/index.d.ts
 export declare const objectKeysOptions: {
   orderedKeys: string[];
   selectors: {
     target: {
       name: string;
       type: "function" | "property";
+      argument?: number | undefined;
     };
     mode: "direct" | "recursive";
     orderedKeys?: Array<string>;
@@ -17,5 +17,4 @@ declare const _default: {
     "sort-keys-custom-order/object-keys": ["error", typeof objectKeysOptions];
   };
 };
-//#endregion
 export { _default as default };

package/dist/eslint.mjs

@@ -1,9 +1,11 @@
-//#region src/eslint/index.ts
+// src/eslint/index.ts
 function selector(name, type, options) {
+	const { argument, ...sorting } = options;
 	return {
 		mode: "direct",
-		...options,
+		...sorting,
 		target: {
+			...argument !== void 0 && { argument },
 			name,
 			type
 		}
@@ -62,12 +64,17 @@ const objectKeysOptions = {
 		] }),
 		selector("inputs", "property", { sorting: "none" }),
 		selector("outputs", "property", { sorting: "none" }),
-		selector("methods", "property", { sorting: "none" })
+		selector("config", "property", { sorting: "none" }),
+		selector("methods", "property", { sorting: "none" }),
+		selector("LogicType.object", "function", {
+			argument: 0,
+			sorting: "none"
+		}),
+		selector("enum", "property", { sorting: "none" })
 	]
 };
 var eslint_default = {
 	name: "@luna-park/plugin/eslint",
 	rules: { "sort-keys-custom-order/object-keys": ["error", objectKeysOptions] }
 };
-//#endregion
 export { eslint_default as default, objectKeysOptions };

package/dist/extractor.d.mts

@@ -1,14 +1,13 @@
-import { d as TSchema } from "./index-76yMHag4.mjs";
+import { d as TSchema } from "./index-B4kxQtaL.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
-//#region src/extractor/export/type.d.ts
 type TExportResult = {
   components: Record<string, TExportComponent>;
   functions: Record<string, TExportFunction>;
   types: Record<string, TExportType>;
 };
 type TExportComponent = {
-  emits?: Record<string, Array<TExportType>>;
+  emits?: Record<string, TExportType>;
   models?: Record<string, TExportType>;
   properties?: Record<string, TExportType>;
   slots?: Record<string, TExportType>;
@@ -26,7 +25,6 @@ type TExportFunction = {
     description?: string;
     type: string;
   };
-  type: string;
 };
 type TExportType = {
   default?: string;
@@ -35,8 +33,6 @@ type TExportType = {
   properties?: Record<string, TExportType>;
   type: string | Record<string, TExportType>;
 };
-//#endregion
-//#region src/extractor/export/index.d.ts
 export declare class CTypeExport {
   program: ts.Program;
   checker: ts.TypeChecker;
@@ -51,8 +47,6 @@ export declare class CTypeExport {
   extractType(type: ts.Type, ctxNode?: ts.Node): void;
   typeToString(type: ts.Type, flags?: number): string;
 }
-//#endregion
-//#region src/extractor/generator.d.ts
 type TExportNodeFunction = {
   description?: string;
   name?: string;
@@ -71,13 +65,9 @@ type TExportLogicResult = {
   types: Record<string, TSchema>;
 };
 export declare function generateNodes(exportResult: TExportResult, packageName?: string): TExportLogicResult;
-//#endregion
-//#region src/extractor/source.d.ts
 export declare function getSourceFile(moduleName: string): {
   program: ts$1.Program;
   sourceFile: ts$1.SourceFile;
 };
-//#endregion
-//#region src/extractor/index.d.ts
 export declare function extractFile(filePath: string, target: string): Promise<void>;
-//#endregion
+export {};

package/dist/extractor.mjs

@@ -1,13 +1,13 @@
-import { c as typeToSchema, d as objectMap, i as LogicType, l as cleanObject, r as EVarType, s as schemaLoop } from "./dist-BoFOku7q.mjs";
+import { d as assertType, f as cleanObject, i as LogicType, l as schemaLoop, m as objectMap, r as EVarType, u as typeToSchema } from "./dist-CZjmIqBC.mjs";
 import fs from "node:fs";
-import * as ts$1 from "typescript";
-import ts from "typescript";
+import ts, * as ts$1 from "typescript";
 import * as path from "path";
 import * as fs$1 from "fs";
-//#region src/extractor/code/lib.ts
+// src/extractor/code/lib.ts
 function generateCode(schema, options = {}) {
 	if (typeof schema !== "object" || schema === null) return JSON.stringify(schema);
 	const properties = {};
+	const values = { ...schema };
 	for (const props of [
 		"default",
 		"description",
@@ -17,10 +17,13 @@ function generateCode(schema, options = {}) {
 		"optional",
 		"example",
 		"enum"
-	]) if (schema[props]) properties[props] = schema[props];
+	]) if (values[props]) properties[props] = values[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 ([EVarType.union, EVarType.intersection].includes(schema.type)) {
+		assertType(schema);
+		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),
@@ -45,8 +48,7 @@ function getCodeFromObject(object, raw) {
 function getSafeKey(key) {
 	return /^[a-zA-Z]+$/.test(key) ? key : JSON.stringify(key);
 }
-//#endregion
-//#region src/extractor/code/component.ts
+// src/extractor/code/component.ts
 function getComponentCode(logicResult, file) {
 	const content = [];
 	const component = logicResult.components["default"];
@@ -72,8 +74,7 @@ export const ${file.name.toLocaleLowerCase()}: TComponent = {
     ${content.map(({ key, value }) => `${key}: {\n        ${value}\n    }`).join(",\n    ")}
 }`;
 }
-//#endregion
-//#region src/extractor/documentation.ts
+// src/extractor/documentation.ts
 function getDocumentationFromSymbol(symbol, checker) {
 	const documentation = { description: mergeSymbolDisplayParts(symbol.getDocumentationComment(checker)) || void 0 };
 	for (const tag of symbol.getJsDocTags()) {
@@ -81,8 +82,8 @@ function getDocumentationFromSymbol(symbol, checker) {
 			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;
+			const paramName = tag.text?.[0]?.text;
+			if (paramName) documentation.params[paramName] = paramDescription;
 			continue;
 		}
 		documentation[tag.name] = mergeSymbolDisplayParts(tag.text);
@@ -92,8 +93,7 @@ function getDocumentationFromSymbol(symbol, checker) {
 function mergeSymbolDisplayParts(symbolDisplayParts = []) {
 	return symbolDisplayParts.map((part) => part.text).join("");
 }
-//#endregion
-//#region src/extractor/export/component.ts
+// src/extractor/export/component.ts
 function getSlots(type, typeExport) {
 	const properties = typeExport.checker.getPropertiesOfType(type);
 	const slots = {};
@@ -168,8 +168,7 @@ function emitName(name) {
 	name = name.slice(2);
 	return name.charAt(0).toLowerCase() + name.slice(1);
 }
-//#endregion
-//#region src/extractor/export/template.ts
+// src/extractor/export/template.ts
 function getTemplateTypeParameters(signature, typeExport) {
 	return Object.fromEntries((signature.getTypeParameters() ?? []).map((typeParameter) => {
 		let type = "unknown";
@@ -180,8 +179,7 @@ function getTemplateTypeParameters(signature, typeExport) {
 		return [typeParameter.symbol.name, type];
 	}));
 }
-//#endregion
-//#region src/extractor/export/utils.ts
+// src/extractor/export/utils.ts
 function getResolvedExports(checker, module) {
 	const resolvedExports = /* @__PURE__ */ new Map();
 	const exports = checker.getExportsOfModule(module);
@@ -216,8 +214,7 @@ function extractEnumDefinition(enumDeclaration) {
 	});
 	return `{ ${members.join(", ")} }`;
 }
-//#endregion
-//#region src/extractor/lib.ts
+// 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();
@@ -229,8 +226,7 @@ function isUserType(type) {
 	if (srcFile.fileName.startsWith("/@vue/")) return false;
 	return true;
 }
-//#endregion
-//#region src/extractor/export/index.ts
+// src/extractor/export/index.ts
 const FLAGS = ts.TypeFormatFlags.WriteArrowStyleSignature | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseFullyQualifiedType;
 var CTypeExport = class {
 	program;
@@ -303,15 +299,15 @@ var CTypeExport = class {
 		const documentation = getDocumentationFromSymbol(signature, this.checker);
 		const typeParameters = getTemplateTypeParameters(signature, this);
 		const parameters = signature.getParameters().map((symbol) => {
-			const pNode = symbol.valueDeclaration ?? this.index;
+			const parameterDeclaration = symbol.valueDeclaration;
 			const pType = this.checker.getTypeOfSymbol(symbol);
-			this.extractType(pType, pNode);
-			const defaultValue = symbol.valueDeclaration?.initializer?.getText();
+			this.extractType(pType, parameterDeclaration ?? this.index);
+			const defaultValue = parameterDeclaration?.initializer?.getText();
 			return cleanObject({
 				default: defaultValue,
 				description: documentation.params?.[symbol.name],
 				name: symbol.name,
-				optional: !!pNode.questionToken || defaultValue !== void 0 || void 0,
+				optional: !!parameterDeclaration?.questionToken || defaultValue !== void 0 || void 0,
 				type: swapType(this.typeToString(pType), typeParameters)
 			});
 		});
@@ -324,7 +320,7 @@ var CTypeExport = class {
 				component.properties = props.props;
 				component.emits = props.emits;
 				Object.values(component.properties).forEach((prop) => {
-					prop.type = swapType(prop.type, typeParameters);
+					if (typeof prop.type === "string") prop.type = swapType(prop.type, typeParameters);
 				});
 			}
 			const slotsIndex = parameters.findIndex((parameter) => parameter.name === "__VLS_slots");
@@ -332,7 +328,7 @@ var CTypeExport = class {
 			if (slotsSymbol) {
 				component.slots = getSlots(this.checker.getTypeOfSymbol(slotsSymbol), this);
 				Object.values(component.slots).forEach((slot) => {
-					slot.type = swapType(slot.type, typeParameters);
+					if (typeof slot.type === "string") slot.type = swapType(slot.type, typeParameters);
 				});
 			}
 			this.result.components[name] = computeModels(component);
@@ -389,7 +385,7 @@ var CTypeExport = class {
 						const constraintTypeObj = this.checker.getTypeFromTypeNode(constraintType);
 						type = this.typeToString(constraintTypeObj);
 					}
-					return [typeParameter.symbol.name, type];
+					return [typeParameter.name.text, type];
 				}));
 				this.result.types[fullName] = {
 					...getDocumentationFromSymbol(symbol, this.checker),
@@ -397,7 +393,7 @@ var CTypeExport = class {
 				};
 			}
 			if (symbol.flags & ts.SymbolFlags.Interface && isUserType(type)) {
-				const declaration = symbol.getDeclarations()[0];
+				const declaration = symbol.getDeclarations()?.[0];
 				if (declaration) {
 					const properties = this.checker.getPropertiesOfType(type);
 					const exportProperties = {};
@@ -428,7 +424,7 @@ var CTypeExport = class {
 					"Required"
 				].includes(fullName)) {
 					this.cache.delete(type);
-					this.extractType(type.aliasTypeArguments[0]);
+					if (type.aliasTypeArguments?.[0]) this.extractType(type.aliasTypeArguments[0]);
 					return;
 				}
 				if (type.aliasTypeArguments?.some((typeArgument) => !isUserType(typeArgument))) return;
@@ -464,8 +460,7 @@ var CTypeExport = class {
 		return this.checker.typeToString(type, void 0, flags);
 	}
 };
-//#endregion
-//#region src/extractor/generator.ts
+// src/extractor/generator.ts
 function generateNodes(exportResult, packageName = "unknown") {
 	const nodeResult = {
 		components: {},
@@ -547,8 +542,7 @@ function generateNodes(exportResult, packageName = "unknown") {
 		}
 	}
 }
-//#endregion
-//#region src/extractor/config.ts
+// src/extractor/config.ts
 function findNearestTsConfig(configPath) {
 	while (true) {
 		const tsconfigPath = path.join(configPath, "tsconfig.json");
@@ -563,8 +557,7 @@ function getTsConfig(configPath) {
 	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
+// src/extractor/source.ts
 function resolveModulePath(moduleName, compilerOptions) {
 	const tempFileName = path.join(process.cwd(), "__temp__.ts");
 	const tempHost = ts$1.createCompilerHost(compilerOptions);
@@ -590,8 +583,7 @@ function getSourceFile(moduleName) {
 		sourceFile
 	};
 }
-//#endregion
-//#region src/extractor/index.ts
+// src/extractor/index.ts
 const fsp = fs.promises;
 async function extractFile(filePath, target) {
 	const fileName = filePath.split("/").pop().split(".")[0];
@@ -606,5 +598,4 @@ async function extractFile(filePath, target) {
 		await fsp.writeFile(target, content);
 	}
 }
-//#endregion
 export { CTypeExport, extractFile, generateNodes, getSourceFile };