@luna-park/plugin 1.4.1 → 1.5.0

package/bin/preview.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+
+import { resolve } from "path";
+
+import { startPreviewServer } from "../dist/preview.mjs";
+
+const cwd = process.cwd();
+
+// Parse CLI arguments
+const { values } = parseArgs({
+    options: {
+        dist: {
+            default: "dist",
+            short: "d",
+            type: "string"
+        },
+        help: {
+            default: false,
+            short: "h",
+            type: "boolean"
+        },
+        port: {
+            default: "2084",
+            short: "p",
+            type: "string"
+        }
+    }
+});
+
+if (values.help) {
+    console.log(`
+Usage: luna-preview [options]
+
+Options:
+  -p, --port <port>    Port to run the server on (default: 2084)
+  -d, --dist <dir>     Distribution directory to serve (default: dist)
+  -h, --help           Show this help message
+  `);
+    process.exit(0);
+}
+
+const dist = resolve(cwd, values.dist);
+const port = parseInt(values.port);
+
+startPreviewServer({
+    dist,
+    externals: ["vue", "vue-router", "@luna-park/design"],
+    port
+});

package/dist/{dist-hc-SHkAg.mjs → dist-JzydDdZn.mjs}

@@ -92,99 +92,99 @@ const LogicType = {
 		return {
 			...args,
 			items,
-			type: EVarType.array
+			type: "array"
 		};
 	},
 	boolean: (args = {}) => {
 		return {
 			...args,
-			type: EVarType.boolean
+			type: "boolean"
 		};
 	},
 	exec: (args = {}) => {
 		return {
 			...args,
-			type: EVarType.exec
-		};
-	},
-	function: (inputs = {
-		properties: {},
-		type: EVarType.object
-	}, output = { type: EVarType.void }, args = {}) => {
-		return {
-			...args,
-			inputs,
-			output,
-			type: EVarType.function
+			type: "exec"
 		};
 	},
+	function: createFunction,
 	interface: (interfaceClass, args = {}) => {
 		return {
 			...args,
 			className: typeof interfaceClass === "string" ? interfaceClass : interfaceClass.name,
-			type: EVarType.interface
+			type: "interface"
 		};
 	},
 	number: (args = {}) => {
 		return {
 			...args,
-			type: EVarType.number
+			type: "number"
 		};
 	},
 	object: (properties = {}, args = {}) => {
 		return {
 			...args,
 			properties,
-			type: EVarType.object
+			type: "object"
 		};
 	},
 	record: (key, value, args = {}) => {
 		return {
 			...args,
 			key,
-			type: EVarType.record,
+			type: "record",
 			value
 		};
 	},
 	string: (args = {}) => {
 		return {
 			...args,
-			type: EVarType.string
-		};
-	},
-	type: (target, args = {}) => {
-		return {
-			...args,
-			target,
-			type: EVarType.type
+			type: "string"
 		};
 	},
+	type: createType,
 	undefined: (args = {}) => {
 		return {
 			...args,
-			type: EVarType.undefined
+			type: "undefined"
 		};
 	},
 	union: (elements, args = {}) => {
 		return {
 			...args,
 			elements,
-			type: EVarType.union
+			type: "union"
 		};
 	},
 	unknown: (args = {}) => {
 		return {
 			...args,
-			type: EVarType.unknown
+			type: "unknown"
 		};
 	},
 	void: (args = {}) => {
 		return {
 			...args,
-			type: EVarType.void
+			type: "void"
 		};
 	}
 };
+function createFunction(inputs = [], output = LogicType.void(), args = {}) {
+	if (Array.isArray(inputs)) return createFunction(LogicType.object(Object.fromEntries(inputs)), output, args);
+	return {
+		...args,
+		inputs,
+		output,
+		type: "function"
+	};
+}
+function createType(target, args = {}) {
+	return {
+		...args,
+		target,
+		type: "type"
+	};
+}
 const LogicUtil = {
 	omit(target, keys) {
 		return {
@@ -239,44 +239,6 @@ let ELogicScope = /* @__PURE__ */ function(ELogicScope) {
 function makeLogicNode(node) {
 	return node;
 }
-function scanner(input) {
-	const elements = [];
-	input = input.replaceAll(/ +/g, " ");
-	input = input.replaceAll(/\s*\n\s*/g, "\n");
-	while (input.length) {
-		if ([" ", "\n"].includes(input[0])) {
-			input = input.slice(1);
-			continue;
-		}
-		if (input.startsWith("/*")) {
-			const commentEnd = input.indexOf("*/");
-			elements.push(input.slice(0, commentEnd + 2));
-			input = input.slice(commentEnd + 2);
-			continue;
-		}
-		const startingWord = input.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)/)?.[0];
-		if (startingWord) {
-			input = input.slice(startingWord.length);
-			elements.push(startingWord);
-			continue;
-		}
-		const startingNumber = input.match(/^([0-9]+)/)?.[0];
-		if (startingNumber) {
-			input = input.slice(startingNumber.length);
-			elements.push(startingNumber);
-			continue;
-		}
-		if (input[0] === ">" && elements.at(-1) === "=") {
-			elements.pop();
-			elements.push("=>");
-			input = input.slice(1);
-			continue;
-		}
-		elements.push(input[0]);
-		input = input.slice(1);
-	}
-	return elements;
-}
 const wrappers = [
 	["(", ")"],
 	["[", "]"],
@@ -332,8 +294,8 @@ function getFirstElement(scan) {
 		exportFlag = true;
 		element = scan.shift();
 		if (element === "=") return {
-			type: "export",
-			content: scan.shift()
+			content: scan.shift(),
+			type: "export"
 		};
 		if (element === "as") {
 			eraseUntil(scan, ";");
@@ -347,10 +309,10 @@ function getFirstElement(scan) {
 		const content = splitUntil(getUntil(scan, "}", 0), ";");
 		scan.unshift(";");
 		return {
-			name,
-			type: element,
 			content,
-			export: exportFlag
+			export: exportFlag,
+			name,
+			type: element
 		};
 	}
 	if (element === "function") {
@@ -380,9 +342,9 @@ function getFirstElement(scan) {
 		const content = splitUntil(getUntil(scan, "}", 0), ";");
 		scan.unshift(";");
 		return {
+			content,
 			name,
-			type: "interface",
-			content
+			type: "interface"
 		};
 	}
 	if (element === "type" && /^[A-Za-z0-9]*$/.test(scan[0])) {
@@ -407,24 +369,24 @@ function getFirstElement(scan) {
 		scan.unshift(";");
 		return {
 			name,
-			type: "enum",
 			options: Object.fromEntries(content.join("").split(",").filter((item) => item.trim()).map((item) => {
 				if (item.includes("=")) {
 					const [name, value] = item.split("=");
 					return [JSON.parse(value), name];
 				}
 				return [name, name];
-			}))
+			})),
+			type: "enum"
 		};
 	}
 	if (typeof element === "string" && element.startsWith("/*")) return {
-		type: "comment",
-		content: cleanComment(element)
+		content: cleanComment(element),
+		type: "comment"
 	};
 	for (const wrapper of wrappers) if (element === wrapper[0]) return {
-		type: "wrap",
 		content: splitUntil(getUntil(scan, wrapper[1]), ";").map((item) => splitUntil(item, ",")).map((item) => splitUntil(item, "|")),
-		style: wrapper.join("")
+		style: wrapper.join(""),
+		type: "wrap"
 	};
 	return element;
 }
@@ -447,32 +409,32 @@ function cleanComment(comment) {
 	return comment.trim();
 }
 function cleanUnion(schema) {
-	if (schema.elements.find((element) => [EVarType.undefined, EVarType.void].includes(element.type))) {
+	if (schema.elements.find((element) => ["undefined", "void"].includes(element.type))) {
 		schema.optional = true;
-		schema.elements = schema.elements.filter((element) => ![EVarType.undefined, EVarType.void].includes(element.type));
+		schema.elements = schema.elements.filter((element) => !["undefined", "void"].includes(element.type));
 	}
-	const childUnions = schema.elements.filter((element) => element.type === EVarType.union);
+	const childUnions = schema.elements.filter((element) => element.type === "union");
 	if (childUnions.length > 0) {
-		schema.elements = schema.elements.filter((element) => element.type !== EVarType.union);
+		schema.elements = schema.elements.filter((element) => element.type !== "union");
 		for (const childUnion of childUnions) schema.elements.push(...childUnion.elements);
 	}
-	const stringElements = schema.elements.filter((element) => element.type === EVarType.string);
+	const stringElements = schema.elements.filter((element) => element.type === "string");
 	if (stringElements.length > 1) {
 		const enumValues = [];
 		let anyFlag = false;
 		for (const element of stringElements) if (element.enum) enumValues.push(...element.enum);
 		else anyFlag = true;
-		schema.elements = schema.elements.filter((element) => element.type !== EVarType.string);
+		schema.elements = schema.elements.filter((element) => element.type !== "string");
 		if (anyFlag) schema.elements.push(LogicType.string());
 		else schema.elements.push(LogicType.string({ enum: enumValues }));
 	}
-	const numberElements = schema.elements.filter((element) => element.type === EVarType.number);
+	const numberElements = schema.elements.filter((element) => element.type === "number");
 	if (numberElements.length > 1) {
 		const enumValues = [];
 		let anyFlag = false;
 		for (const element of numberElements) if (element.enum) enumValues.push(...element.enum);
 		else anyFlag = true;
-		schema.elements = schema.elements.filter((element) => element.type !== EVarType.number);
+		schema.elements = schema.elements.filter((element) => element.type !== "number");
 		if (anyFlag) schema.elements.push(LogicType.number());
 		else schema.elements.push(LogicType.number({ enum: enumValues }));
 	}
@@ -497,6 +459,44 @@ function cleanInterface(schema) {
 	if (["Omit", "Pick"].includes(schema.className)) return LogicUtil[schema.className.toLocaleLowerCase()](schema.options.template[0], schema.options.template[1]?.enum);
 	return schema;
 }
+function scanner(input) {
+	const elements = [];
+	input = input.replaceAll(/ +/g, " ");
+	input = input.replaceAll(/\s*\n\s*/g, "\n");
+	while (input.length) {
+		if ([" ", "\n"].includes(input[0])) {
+			input = input.slice(1);
+			continue;
+		}
+		if (input.startsWith("/*")) {
+			const commentEnd = input.indexOf("*/");
+			elements.push(input.slice(0, commentEnd + 2));
+			input = input.slice(commentEnd + 2);
+			continue;
+		}
+		const startingWord = input.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)/)?.[0];
+		if (startingWord) {
+			input = input.slice(startingWord.length);
+			elements.push(startingWord);
+			continue;
+		}
+		const startingNumber = input.match(/^([0-9]+)/)?.[0];
+		if (startingNumber) {
+			input = input.slice(startingNumber.length);
+			elements.push(startingNumber);
+			continue;
+		}
+		if (input[0] === ">" && elements.at(-1) === "=") {
+			elements.pop();
+			elements.push("=>");
+			input = input.slice(1);
+			continue;
+		}
+		elements.push(input[0]);
+		input = input.slice(1);
+	}
+	return elements;
+}
 function parser(element, options = {}) {
 	if (typeof element === "string") {
 		if (element === "string") return LogicType.string(options);
@@ -519,8 +519,10 @@ function parser(element, options = {}) {
 				if (element[1].style === "<>") {
 					let template = element[1].content;
 					if (!Array.isArray(template)) template = [template];
-					if (!Array.isArray(template[0])) if (template.some((element) => element.type === "wrap" && element.style === "[]") || template.some((element) => element.type === "wrap" && element.style === "<>") || template.includes("&") || template.includes("|")) template = [template];
-					else template = template.map((element) => [element]);
+					if (!Array.isArray(template[0])) {
+						if (template.some((element) => element.type === "wrap" && element.style === "[]") || template.some((element) => element.type === "wrap" && element.style === "<>") || template.includes("&") || template.includes("|")) template = [template];
+						else template = template.map((element) => [element]);
+					}
 					template = template.map((element) => parser(element));
 					return cleanInterface(LogicType.interface(element[0], {
 						...options,
@@ -587,13 +589,13 @@ function schemaLoop(schema, func, key) {
 		key,
 		schema
 	}) || schema;
-	if (schema.type === EVarType.object) for (const key in schema.properties) schema.properties[key] = schemaLoop(schema.properties[key], func, key);
-	if (schema.type === EVarType.array) schema.items = schemaLoop(schema.items, func);
-	if (schema.type === EVarType.function) {
+	if (schema.type === "object") for (const key in schema.properties) schema.properties[key] = schemaLoop(schema.properties[key], func, key);
+	if (schema.type === "array") schema.items = schemaLoop(schema.items, func);
+	if (schema.type === "function") {
 		schema.inputs = schemaLoop(schema.inputs, func);
 		schema.output = schemaLoop(schema.output, func);
 	}
-	if (schema.type === EVarType.union) for (const key in schema.elements) schema.elements[key] = schemaLoop(schema.elements[key], func);
+	if (schema.type === "union") for (const key in schema.elements) schema.elements[key] = schemaLoop(schema.elements[key], func);
 	return schema;
 }
 //#endregion

package/dist/extractor.d.mts

@@ -1,7 +1,6 @@
-import { l as TSchema } from "./index-X3hhfmWd.mjs";
+import { l as TSchema } from "./index-DwEOlEBY.mjs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
-
 //#region src/extractor/export/type.d.ts
 type TExportResult = {
   components: Record<string, TExportComponent>;
@@ -38,7 +37,7 @@ type TExportType = {
 };
 //#endregion
 //#region src/extractor/export/index.d.ts
-declare class CTypeExport {
+export declare class CTypeExport {
   program: ts.Program;
   checker: ts.TypeChecker;
   index?: ts.SourceFile;
@@ -71,15 +70,14 @@ type TExportLogicResult = {
   functions: Record<string, TExportNodeFunction>;
   types: Record<string, TSchema>;
 };
-declare function generateNodes(exportResult: TExportResult, packageName?: string): TExportLogicResult;
+export declare function generateNodes(exportResult: TExportResult, packageName?: string): TExportLogicResult;
 //#endregion
 //#region src/extractor/source.d.ts
-declare function getSourceFile(moduleName: string): {
+export declare function getSourceFile(moduleName: string): {
   program: ts$1.Program;
   sourceFile: ts$1.SourceFile;
 };
 //#endregion
 //#region src/extractor/index.d.ts
-declare function extractFile(filePath: string, target: string): Promise<void>;
-//#endregion
-export { CTypeExport, extractFile, generateNodes, getSourceFile };
+export declare function extractFile(filePath: string, target: string): Promise<void>;
+//#endregion

package/dist/extractor.mjs

@@ -1,4 +1,4 @@
-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 { c as typeToSchema, d as objectMap, i as LogicType, l as cleanObject, r as EVarType, s as schemaLoop } from "./dist-JzydDdZn.mjs";
 import fs from "node:fs";
 import * as ts$1 from "typescript";
 import ts from "typescript";
@@ -233,6 +233,7 @@ function isUserType(type) {
 //#region src/extractor/export/index.ts
 const FLAGS = ts.TypeFormatFlags.WriteArrowStyleSignature | ts.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope | ts.TypeFormatFlags.NoTruncation | ts.TypeFormatFlags.UseFullyQualifiedType;
 var CTypeExport = class {
+	program;
 	checker;
 	index;
 	cache = /* @__PURE__ */ new Set();
@@ -493,9 +494,7 @@ function generateNodes(exportResult, packageName = "unknown") {
 				case EVarType.number:
 					schema.default = Number(type.default);
 					break;
-				case EVarType.string:
-					schema.default = type.default;
-					break;
+				case EVarType.string: schema.default = type.default;
 			}
 			if (schema.type === EVarType.object && !Object.keys(schema.properties).length) schema.customizable = true;
 			return schema;