@luna-park/plugin 1.3.1 → 1.4.0

package/dist/dist-hc-SHkAg.mjs

@@ -0,0 +1,600 @@
+//#region ../utils/dist/index.mjs
+function cloneDeep(object) {
+	if (typeof object !== "object") return object;
+	const strategies = [
+		() => JSON.parse(JSON.stringify(object)),
+		() => structuredClone(object),
+		() => safeClone(object)
+	];
+	let lastError;
+	for (const strategy of strategies) try {
+		return strategy();
+	} catch (error) {
+		lastError = error;
+		continue;
+	}
+	console.error("Failed to deep clone object:", object);
+	throw new Error(lastError);
+}
+function safeClone(object) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	return recursiveClone(object);
+	function recursiveClone(object) {
+		if (typeof object !== "object") return object;
+		if (seen.has(object)) return { recursive: true };
+		seen.add(object);
+		if (Array.isArray(object)) return object.map((element) => recursiveClone(element));
+		const descriptors = Object.getOwnPropertyDescriptors(object);
+		const clone = {};
+		for (const [key, descriptor] of Object.entries(descriptors)) clone[key] = recursiveClone(descriptor.value);
+		return clone;
+	}
+}
+function cloneWithFunctions(object) {
+	if (Array.isArray(object)) return object.map(cloneWithFunctions);
+	if (typeof object !== "object") return object;
+	const clone = {};
+	for (const [key, value] of Object.entries(object)) {
+		if (typeof value === "function") {
+			clone[key] = value;
+			continue;
+		}
+		clone[key] = cloneWithFunctions(value);
+	}
+	return clone;
+}
+function objectMap(source, func) {
+	if (!source) return {};
+	return Object.fromEntries(Object.entries(source).map(([key, value]) => [key, func({
+		key,
+		value
+	})]));
+}
+function objectFilter(source, func) {
+	if (!source) return {};
+	return Object.fromEntries(Object.entries(source).filter(([key, value]) => func({
+		key,
+		value
+	})));
+}
+function cleanObject(target) {
+	target = cloneDeep(target);
+	for (const key in target) cleanDeep(target, key);
+	function cleanDeep(value, key) {
+		if (typeof value[key] === "object") {
+			for (const childKey in value[key]) cleanDeep(value[key], childKey);
+			if (Object.keys(value[key]).length === 0) delete value[key];
+		}
+	}
+	return target;
+}
+//#endregion
+//#region ../logicnodes/dist/index.mjs
+let EVarType = /* @__PURE__ */ function(EVarType) {
+	EVarType["exec"] = "exec";
+	EVarType["number"] = "number";
+	EVarType["string"] = "string";
+	EVarType["boolean"] = "boolean";
+	EVarType["object"] = "object";
+	EVarType["record"] = "record";
+	EVarType["array"] = "array";
+	EVarType["interface"] = "interface";
+	EVarType["type"] = "type";
+	EVarType["function"] = "function";
+	EVarType["union"] = "union";
+	EVarType["unknown"] = "unknown";
+	EVarType["undefined"] = "undefined";
+	EVarType["void"] = "void";
+	return EVarType;
+}({});
+const LogicType = {
+	array: (items, args = {}) => {
+		return {
+			...args,
+			items,
+			type: EVarType.array
+		};
+	},
+	boolean: (args = {}) => {
+		return {
+			...args,
+			type: EVarType.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
+		};
+	},
+	interface: (interfaceClass, args = {}) => {
+		return {
+			...args,
+			className: typeof interfaceClass === "string" ? interfaceClass : interfaceClass.name,
+			type: EVarType.interface
+		};
+	},
+	number: (args = {}) => {
+		return {
+			...args,
+			type: EVarType.number
+		};
+	},
+	object: (properties = {}, args = {}) => {
+		return {
+			...args,
+			properties,
+			type: EVarType.object
+		};
+	},
+	record: (key, value, args = {}) => {
+		return {
+			...args,
+			key,
+			type: EVarType.record,
+			value
+		};
+	},
+	string: (args = {}) => {
+		return {
+			...args,
+			type: EVarType.string
+		};
+	},
+	type: (target, args = {}) => {
+		return {
+			...args,
+			target,
+			type: EVarType.type
+		};
+	},
+	undefined: (args = {}) => {
+		return {
+			...args,
+			type: EVarType.undefined
+		};
+	},
+	union: (elements, args = {}) => {
+		return {
+			...args,
+			elements,
+			type: EVarType.union
+		};
+	},
+	unknown: (args = {}) => {
+		return {
+			...args,
+			type: EVarType.unknown
+		};
+	},
+	void: (args = {}) => {
+		return {
+			...args,
+			type: EVarType.void
+		};
+	}
+};
+const LogicUtil = {
+	omit(target, keys) {
+		return {
+			...target,
+			properties: objectFilter(target.properties, ({ key }) => !keys.includes(key))
+		};
+	},
+	partial(target, force = false) {
+		return {
+			...target,
+			properties: objectMap(target.properties, ({ value }) => ({
+				...value,
+				optional: !force || !value.required
+			}))
+		};
+	},
+	pick(target, keys) {
+		return {
+			...target,
+			properties: objectFilter(target.properties, ({ key }) => keys.includes(key))
+		};
+	},
+	promise(target) {
+		return {
+			...target,
+			promise: true
+		};
+	},
+	required(target) {
+		return {
+			...target,
+			properties: objectMap(target.properties, ({ value }) => ({
+				...value,
+				optional: false
+			}))
+		};
+	}
+};
+let ELogicType = /* @__PURE__ */ function(ELogicType) {
+	ELogicType["function"] = "function";
+	ELogicType["macro"] = "macro";
+	ELogicType["operation"] = "operation";
+	return ELogicType;
+}({});
+let ELogicScope = /* @__PURE__ */ function(ELogicScope) {
+	ELogicScope["Frontend"] = "frontend";
+	ELogicScope["Backend"] = "backend";
+	ELogicScope["Desktop"] = "desktop";
+	ELogicScope["Shared"] = "shared";
+	return 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 = [
+	["(", ")"],
+	["[", "]"],
+	["{", "}"],
+	["<", ">"],
+	["'", "'"],
+	["\"", "\""]
+];
+function lexer(scan) {
+	return cleanArray(splitUntil(scan, ";"));
+}
+function getUntil(scan, until, depth = 1) {
+	const result = [];
+	const opening = wrappers.find((wrapper) => wrapper[1] === until)?.[0];
+	while (scan.length) {
+		if (scan[0] === opening) {}
+		if (scan[0] === until) {
+			depth--;
+			if (depth <= 0) break;
+		}
+		const element = getFirstElement(scan);
+		result.push(element);
+		if (depth === 0 && typeof element === "object" && element.type === "wrap" && element.style.endsWith(until)) break;
+	}
+	scan.shift();
+	return result;
+}
+function eraseUntil(scan, until) {
+	while (scan.length) {
+		if (scan[0] === until) {
+			scan.shift();
+			break;
+		}
+		scan.shift();
+	}
+}
+function splitUntil(scan, until) {
+	const result = [[]];
+	while (scan.length) {
+		if (scan[0] === until) {
+			result.push([]);
+			scan.shift();
+			continue;
+		}
+		result.at(-1).push(getFirstElement(scan));
+	}
+	return result.filter((chunk) => chunk.length);
+}
+function getFirstElement(scan) {
+	let element = scan.shift();
+	let exportFlag = false;
+	if (element === "export") {
+		exportFlag = true;
+		element = scan.shift();
+		if (element === "=") return {
+			type: "export",
+			content: scan.shift()
+		};
+		if (element === "as") {
+			eraseUntil(scan, ";");
+			return getFirstElement(scan);
+		}
+	}
+	if (element === "declare") element = scan.shift();
+	if (element === "namespace") {
+		const name = scan.shift();
+		scan.shift();
+		const content = splitUntil(getUntil(scan, "}", 0), ";");
+		scan.unshift(";");
+		return {
+			name,
+			type: element,
+			content,
+			export: exportFlag
+		};
+	}
+	if (element === "function") {
+		const name = scan.shift();
+		const then = scan.shift();
+		const result = {
+			name,
+			type: element
+		};
+		if (then === "<") {
+			result.template = getUntil(scan, ">");
+			scan.shift();
+		}
+		const params = splitUntil(getUntil(scan, ")", 0), ",");
+		result.export = exportFlag;
+		result.params = params;
+		if (scan[0] === ":") {
+			scan.shift();
+			result.returns = getUntil(scan, ";");
+		}
+		scan.unshift(";");
+		return result;
+	}
+	if (element === "interface") {
+		const name = scan.shift();
+		scan.shift();
+		const content = splitUntil(getUntil(scan, "}", 0), ";");
+		scan.unshift(";");
+		return {
+			name,
+			type: "interface",
+			content
+		};
+	}
+	if (element === "type" && /^[A-Za-z0-9]*$/.test(scan[0])) {
+		const name = scan.shift();
+		const then = scan.shift();
+		const result = {
+			name,
+			type: element
+		};
+		if (then === "<") {
+			result.template = getUntil(scan, ">");
+			scan.shift();
+		}
+		result.content = getUntil(scan, ";");
+		scan.unshift(";");
+		return result;
+	}
+	if (element === "enum") {
+		const name = scan.shift();
+		scan.shift();
+		const content = getUntil(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];
+			}))
+		};
+	}
+	if (typeof element === "string" && element.startsWith("/*")) return {
+		type: "comment",
+		content: cleanComment(element)
+	};
+	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("")
+	};
+	return element;
+}
+function cleanArray(input) {
+	if (Array.isArray(input)) {
+		if (input.length === 1) return cleanArray(input[0]);
+		return input.map((element) => cleanArray(element));
+	}
+	if (typeof input === "object" && input !== null) return objectMap(input, ({ value }) => cleanArray(value));
+	return input;
+}
+function cleanComment(comment) {
+	comment = comment.trim();
+	if (!(comment.startsWith("/**") && comment.endsWith("*/"))) return comment;
+	comment = comment.slice(3, -2).split("\n").map((line) => {
+		const trim = line.trim();
+		if (trim.startsWith("* ")) return trim.slice(2);
+		return trim;
+	}).join("\n").trim();
+	return comment.trim();
+}
+function cleanUnion(schema) {
+	if (schema.elements.find((element) => [EVarType.undefined, EVarType.void].includes(element.type))) {
+		schema.optional = true;
+		schema.elements = schema.elements.filter((element) => ![EVarType.undefined, EVarType.void].includes(element.type));
+	}
+	const childUnions = schema.elements.filter((element) => element.type === EVarType.union);
+	if (childUnions.length > 0) {
+		schema.elements = schema.elements.filter((element) => element.type !== EVarType.union);
+		for (const childUnion of childUnions) schema.elements.push(...childUnion.elements);
+	}
+	const stringElements = schema.elements.filter((element) => element.type === EVarType.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);
+		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);
+	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);
+		if (anyFlag) schema.elements.push(LogicType.number());
+		else schema.elements.push(LogicType.number({ enum: enumValues }));
+	}
+	if (schema.elements.length === 1) {
+		const simpleSchema = schema.elements[0];
+		simpleSchema.optional = schema.optional;
+		return simpleSchema;
+	}
+	if (schema.elements.length === 0) return LogicType.void();
+	return schema;
+}
+function cleanInterface(schema) {
+	if (schema.className === "Array") return LogicType.array(schema.options.template[0]);
+	if (schema.className === "keyof") return LogicType.string();
+	if (schema.className === "Record") return LogicType.object({});
+	if (schema.className === "PropertyKey") return LogicType.union([LogicType.string(), LogicType.number()]);
+	if ([
+		"Promise",
+		"Partial",
+		"Required"
+	].includes(schema.className)) return LogicUtil[schema.className.toLocaleLowerCase()](schema.options.template[0]);
+	if (["Omit", "Pick"].includes(schema.className)) return LogicUtil[schema.className.toLocaleLowerCase()](schema.options.template[0], schema.options.template[1]?.enum);
+	return schema;
+}
+function parser(element, options = {}) {
+	if (typeof element === "string") {
+		if (element === "string") return LogicType.string(options);
+		if (element === "number") return LogicType.number(options);
+		if (element === "boolean") return LogicType.boolean(options);
+		if (element === "undefined") return LogicType.void(options);
+		if (["unknown", "any"].includes(element)) return LogicType.unknown(options);
+		if (["undefined", "null"].includes(element)) return LogicType.undefined(options);
+		return cleanInterface(LogicType.interface(element, options));
+	}
+	if (Array.isArray(element)) {
+		if (element[0] === "readonly") element.shift();
+		if (element.length === 1) return parser(element[0], options);
+		if (element.includes("|")) return cleanUnion(LogicType.union(separate(element, (element) => element === "|").map((element) => parser(element)), options));
+		if (element.includes("&")) return cleanUnion(LogicType.union(separate(element, (element) => element === "&").map((element) => parser(element)), options));
+		if (element.at(-1)?.type === "wrap" && element.at(-1).style === "[]") return LogicType.array(parser(element.slice(0, -1)), options);
+		if (element[0] === "import" && element[2] === ".") return parser(element.slice(3), options);
+		if (element.length === 2) {
+			if (element[1].type === "wrap") {
+				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]);
+					template = template.map((element) => parser(element));
+					return cleanInterface(LogicType.interface(element[0], {
+						...options,
+						options: { template }
+					}));
+				}
+			}
+		}
+		if (element.length === 3) {
+			if (element[1] === "=>") {
+				const parameters = !element[0].content.length || Array.isArray(element[0].content[0]) ? element[0].content : [element[0].content];
+				return LogicType.function(LogicType.object(Object.fromEntries(parameters.map((parameter) => {
+					return [parameter[0], parser(parameter.slice(2))];
+				}))), parser(element[2]));
+			}
+		}
+		return parser(element[0], options);
+	}
+	if (typeof element === "object" && element !== null) {
+		if (element.type === "wrap") {
+			if (["''", "\"\""].includes(element.style)) return LogicType.string({
+				...options,
+				enum: [element.content]
+			});
+			if (element.style === "{}") {
+				const content = !element.content.length || Array.isArray(element.content[0]) ? element.content : [element.content];
+				return LogicType.object(Object.fromEntries(content.filter((element) => typeof element[0] === "string").map((element) => [element[0], element[1] === "?" ? parser(element.slice(3), { optional: true }) : parser(element.slice(2))])), options);
+			}
+			if (element.style === "[]") {
+				if (element.content[1] === ":") return LogicType.array(parser(element.content.slice(2)), options);
+				return LogicType.array(parser(element.content), options);
+			}
+			if (element.style === "()") return parser(element.content, options);
+		}
+	}
+	console.log("Unknown element");
+	console.log(element);
+	return LogicType.unknown();
+}
+function separate(result, separator) {
+	const output = [[]];
+	for (const element of result) if (separator(element)) output.push([]);
+	else output[output.length - 1].push(element);
+	return output;
+}
+function typeToSchema(type) {
+	try {
+		if (/^[A-Za-z]+\??:/.test(type)) {
+			const [, name, optional, rest] = type.match(/([A-Za-z]+)(\??):(.*)/);
+			const schema = parser(lexer(scanner(rest)));
+			schema.name = name;
+			if (optional === "?") schema.optional = true;
+			return schema;
+		}
+		return parser(lexer(scanner(type)));
+	} catch (error) {
+		console.error("Failed to parse type", type);
+		console.error(error);
+		return LogicType.unknown();
+	}
+}
+function schemaLoop(schema, func, key) {
+	schema = func({
+		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) {
+		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);
+	return schema;
+}
+//#endregion
+export { LogicUtil as a, typeToSchema as c, objectMap as d, LogicType as i, cleanObject as l, ELogicType as n, makeLogicNode as o, EVarType as r, schemaLoop as s, ELogicScope as t, cloneWithFunctions as u };

package/dist/extractor.d.mts

@@ -0,0 +1,85 @@
+import { l as TSchema } from "./index-X3hhfmWd.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>>;
+  models?: Record<string, TExportType>;
+  properties?: Record<string, TExportType>;
+  slots?: Record<string, TExportType>;
+};
+type TExportFunction = {
+  description?: string;
+  parameters?: Array<{
+    default?: string;
+    description?: string;
+    name: string;
+    optional?: boolean;
+    type: string;
+  }>;
+  return: {
+    description?: string;
+    type: string;
+  };
+  type: string;
+};
+type TExportType = {
+  default?: string;
+  description?: string;
+  optional?: boolean;
+  properties?: Record<string, TExportType>;
+  type: string | Record<string, TExportType>;
+};
+//#endregion
+//#region src/extractor/export/index.d.ts
+declare class CTypeExport {
+  program: ts.Program;
+  checker: ts.TypeChecker;
+  index?: ts.SourceFile;
+  private cache;
+  private result?;
+  constructor(program: ts.Program);
+  get(target: string): TExportResult;
+  exportModule(module: ts.Symbol): void;
+  exportComponent(name: string, type: ts.Type): void;
+  exportFunction(name: string, signature: ts.Signature): void;
+  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;
+  parameters?: Array<TSchema>;
+  return?: TSchema;
+};
+type TExportLogicComponent = {
+  emits: Record<string, TSchema>;
+  models: Record<string, TSchema>;
+  properties: Record<string, TSchema>;
+  slots: Record<string, TSchema>;
+};
+type TExportLogicResult = {
+  components: Record<string, TExportLogicComponent>;
+  functions: Record<string, TExportNodeFunction>;
+  types: Record<string, TSchema>;
+};
+declare function generateNodes(exportResult: TExportResult, packageName?: string): TExportLogicResult;
+//#endregion
+//#region src/extractor/source.d.ts
+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 };