@luna-park/plugin 1.4.2 → 1.5.0

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;

package/dist/{index-X3hhfmWd.d.mts → index-DwEOlEBY.d.mts}

@@ -1,7 +1,6 @@
 import { IconDefinition } from "@fortawesome/fontawesome-svg-core";
-
 //#region ../utils/dist/index.d.mts
-type DeepPartial<T> = { [K in keyof T]?: T[K] extends Array<unknown> ? Array<DeepPartial<T[K][number]>> : T[K] extends Record<string, unknown> ? DeepPartial<T[K]> : T[K] };
+type DeepPartial<T> = { [K in keyof T]?: T[K] extends Array<unknown> ? Array<DeepPartial<T[K][number]>> : T[K] extends Record<string, unknown> ? DeepPartial<T[K]> : T[K]; };
 type MaybePromise<T> = T | Promise<T>;
 //#endregion
 //#region src/vector.d.ts
@@ -27,7 +26,8 @@ declare class CVector {
   isNearlyEqual(vector: TVector): boolean;
   getPointString(): string;
   getMagnitude(): number;
-} //#endregion
+}
+//#endregion
 //#endregion
 //#region ../logicnodes/dist/index.d.mts
 //#region src/logic/type.d.ts
@@ -67,7 +67,6 @@ interface TArguments<TType = unknown> {
   optional?: boolean;
   options?: {
     access?: TSchema<TObject>;
-    format?: (arg: TType) => TType;
     freeze?: boolean;
     readonly?: boolean;
   } & Record<string, unknown>;
@@ -124,14 +123,14 @@ interface TInterface<T = unknown> {
   static: T;
   type: EVarType.interface;
 }
-interface TType<T extends TSchema = TSchema> {
+interface TType<T = unknown> {
   static: T;
   target: Array<string>;
   type: EVarType.type;
 }
 interface TArray<T extends TSchema = TSchema> {
   items: T;
-  static: Array<Static<T>>;
+  static: Array<StaticSchema<T>>;
   type: EVarType.array;
 }
 interface TUnion<T extends ReadonlyArray<TSchema> = ReadonlyArray<TSchema>> {
@@ -139,50 +138,80 @@ interface TUnion<T extends ReadonlyArray<TSchema> = ReadonlyArray<TSchema>> {
   static: StaticUnion<T>;
   type: EVarType.union;
 }
-interface TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TSchema, TPromise extends boolean = false> {
+type TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TSchema, TPromise extends boolean = false, TParameters extends ReadonlyArray<TSchema> = ReadonlyArray<TSchema>> = {
   inputs: TInputs;
   output: TOutput;
-  static: StaticFunction<TInputs, TOutput, TPromise>;
+  static: StaticFunction<TParameters, TOutput, TPromise>;
   type: EVarType.function;
-}
-type TAnyLogic = TExec | TObject | TRecord | TInterface | TType | TArray | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion | TFunction | TVoid;
-type TSchema<TLogic extends TAnyLogic = TAnyLogic> = TLogic & TArguments<Static<TLogic>>;
+};
+type TAnyLogic = TExec | TObject | TRecord<TString | TNumber> | TInterface | TType | TArray | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion | TFunction<TObject, TSchema, boolean, ReadonlyArray<never>> | TVoid;
+type TSchema<TLogic extends TAnyLogic = TAnyLogic> = TLogic & TArguments;
 declare const LogicType: {
-  array: <T extends TSchema, TArgs extends TArguments<Array<T>>>(items: T, args?: TArgs) => TArray<T> & TArgs;
+  array: <T extends TSchema, TArgs extends TArguments<Array<StaticSchema<T>>>>(items: T, args?: TArgs) => TArray<T> & TArgs;
   boolean: <TArgs extends TArguments<boolean>>(args?: TArgs) => TBoolean & TArgs;
-  exec: (args?: TArguments) => TExec;
-  function: <TInputs extends TObject, TOutput extends TSchema = TUndefined, TPromise extends boolean = false>(inputs?: TInputs, output?: TOutput, args?: TArguments & {
-    promise?: TPromise;
-  }) => TFunction<TInputs, TOutput, TPromise>;
+  exec: <const TArgs extends TArguments = {}>(args?: TArgs) => TExec & TArgs;
+  function: typeof createFunction;
   interface: <T = unknown, TArgs extends TArguments<T> = TArguments<T>>(interfaceClass: (new (...args: Array<unknown>) => T) | string, args?: TArgs) => TInterface<T> & TArgs;
   number: <TArgs extends TArguments<number>>(args?: TArgs) => TNumber & TArgs;
   object: <T extends TProperties, TArgs extends TArguments<object>>(properties?: T, args?: TArgs) => TObject<T> & TArgs;
-  record: <TKey extends TString | TNumber, TValue extends TSchema = TSchema<TAnyLogic>>(key: TKey, value: TValue, args?: TArguments) => TRecord<TKey, TValue>;
+  record: <TKey extends TString | TNumber, TValue extends TSchema, const TArgs extends TArguments<StaticRecord<TKey, TValue>> = {}>(key: TKey, value: TValue, args?: TArgs) => TRecord<TKey, TValue> & TArgs;
   string: <TArgs extends TArguments<string>>(args?: TArgs) => TString & TArgs;
-  type: <T extends TSchema>(target: Array<string>, args?: TArguments) => TType<T>;
-  undefined: (args?: TArguments) => TUndefined;
-  union: <T extends Array<TSchema>>(elements: T, args?: TArguments) => TUnion<T>;
+  type: typeof createType;
+  undefined: <const TArgs extends TArguments<undefined> = {}>(args?: TArgs) => TUndefined & TArgs;
+  union: <const T extends ReadonlyArray<TSchema>, const TArgs extends TArguments<StaticUnion<T>> = {}>(elements: T, args?: TArgs) => TUnion<T> & TArgs;
   unknown: <TArgs extends TArguments>(args?: TArgs) => TUnknown & TArgs;
-  void: (args?: TArguments) => TVoid;
+  void: <const TArgs extends TArguments<void> = {}>(args?: TArgs) => TVoid & TArgs;
 };
 type OptionalKeys<T extends TProperties> = { [K in keyof T]: T[K] extends {
   optional: true;
-} ? K : never }[keyof T];
+} ? K : never; }[keyof T];
 type RequiredKeys<T extends TProperties> = Exclude<keyof T, OptionalKeys<T>>;
-type StaticObject<T extends TProperties> = { [K in RequiredKeys<T>]: Static<T[K]> } & { [K in OptionalKeys<T>]?: Static<T[K]> };
-type StaticRecord<TKey extends TSchema<TString> | TSchema<TNumber>, TValue extends TSchema> = Record<Static<TKey>, Static<TValue>>;
-type StaticUnion<T extends ReadonlyArray<TSchema>> = { [K in keyof T]: Static<T[K]> }[number];
-type StaticFunction<TInputs extends TObject, TOutput extends TSchema, TPromise extends boolean = false> = TPromise extends true ? (...args: Array<Static<TInputs>[string]>) => Promise<Static<TOutput>> : (...args: Array<Static<TInputs>[string]>) => Static<TOutput>;
-type Static<T extends TSchema> = T extends {
+type StaticSchema<T extends TSchema> = [TSchema] extends [T] ? unknown : T extends {
+  static: unknown;
+} ? Static<T> : unknown;
+type StaticObject<T extends TProperties> = string extends keyof T ? Record<string, unknown> : { [K in RequiredKeys<T>]: StaticSchema<T[K]>; } & { [K in OptionalKeys<T>]?: StaticSchema<T[K]>; };
+type StaticRecord<TKey extends TSchema<TString> | TSchema<TNumber>, TValue extends TSchema> = Record<StaticSchema<TKey> & (string | number), StaticSchema<TValue>>;
+type StaticUnion<T extends ReadonlyArray<TSchema>> = StaticSchema<T[number]>;
+type TStaticParameters<T extends ReadonlyArray<TSchema>> = number extends T["length"] ? Array<StaticSchema<T[number]>> : T extends readonly [...infer TRest extends ReadonlyArray<TSchema>, infer TLast extends TSchema] ? TLast extends {
+  optional: true;
+} ? [...TStaticParameters<TRest>, StaticSchema<TLast>?] : [...TStaticParameters<TRest>, StaticSchema<TLast>] : [];
+type StaticFunction<TParameters extends ReadonlyArray<TSchema>, TOutput extends TSchema, TPromise extends boolean = false> = TPromise extends true ? (...args: TStaticParameters<TParameters>) => Promise<StaticSchema<TOutput>> : (...args: TStaticParameters<TParameters>) => StaticSchema<TOutput>;
+type TFunctionEntries = ReadonlyArray<readonly [string, TSchema]>;
+type TEntryProperties<T extends TFunctionEntries> = { [TEntry in T[number] as TEntry[0]]: TEntry[1]; };
+type TEntryParameters<T extends TFunctionEntries> = { [K in keyof T]: T[K][1]; };
+type TObjectParameters<T extends TObject> = keyof T["properties"] extends never ? ReadonlyArray<TSchema> : ReadonlyArray<T["properties"][keyof T["properties"]]>;
+type TFunctionPromise<T extends TArguments> = "promise" extends keyof T ? Exclude<T["promise"], undefined> : false;
+declare function createFunction<const TEntries extends TFunctionEntries = [], TOutput extends TSchema = TVoid, const TArgs extends TArguments = {}>(inputs?: TEntries, output?: TOutput, args?: TArgs): TFunction<TObject<TEntryProperties<TEntries>>, TOutput, TFunctionPromise<TArgs>, TEntryParameters<TEntries>> & TArgs;
+declare function createFunction<TInputs extends TObject, TOutput extends TSchema = TVoid, const TArgs extends TArguments = {}>(inputs: TInputs, output?: TOutput, args?: TArgs): TFunction<TInputs, TOutput, TFunctionPromise<TArgs>, TObjectParameters<TInputs>> & TArgs;
+declare function createType<T, const TArgs extends TArguments<T> & {
+  optional: true;
+} = TArguments<T> & {
+  optional: true;
+}>(target: Array<string>, args: TArgs): TType<T> & TArgs;
+declare function createType<T, const TArgs extends TArguments<T> = TArguments<T>>(target: Array<string>, args?: TArgs): TType<T> & TArgs;
+type Static<T extends {
+  optional?: boolean;
+  static: unknown;
+}> = T extends {
   optional: true;
 } ? (T["static"] | undefined) : T["static"];
+type TTransformedObject<TTarget extends TObject, T extends TProperties> = Omit<TTarget, "properties" | "static"> & TObject<T>;
+type TWithOptional<T extends TSchema, TOptional extends boolean> = T extends TSchema ? Omit<T, "optional"> & {
+  optional: TOptional;
+} : never;
+type TPartialOptional<T extends TSchema> = T["required"] extends true ? false : true extends T["required"] ? boolean : true;
+type TPartialProperties<T extends TProperties, TForce extends boolean> = TForce extends true ? { [K in keyof T]: TWithOptional<T[K], TPartialOptional<T[K]>>; } : { [K in keyof T]: TWithOptional<T[K], true>; };
+type TRequiredProperties<T extends TProperties> = { [K in keyof T]: TWithOptional<T[K], false>; };
+type TPickedProperties<T extends TProperties, TKeys extends ReadonlyArray<string>> = number extends TKeys["length"] ? TProperties : Pick<T, Extract<TKeys[number], keyof T>>;
+type TOmittedProperties<T extends TProperties, TKeys extends ReadonlyArray<string>> = number extends TKeys["length"] ? TProperties : Omit<T, TKeys[number]>;
 declare const LogicUtil: {
-  omit(target: TObject, keys: Array<string>): TObject;
-  partial(target: TObject, force?: boolean): TObject;
-  pick(target: TObject, keys: Array<string>): TObject;
+  omit<TTarget extends TObject, const TKeys extends ReadonlyArray<string>>(target: TTarget, keys: TKeys): TTransformedObject<TTarget, TOmittedProperties<TTarget["properties"], TKeys>>;
+  partial<TTarget extends TObject, TForce extends boolean = false>(target: TTarget, force?: TForce): TTransformedObject<TTarget, TPartialProperties<TTarget["properties"], TForce>>;
+  pick<TTarget extends TObject, const TKeys extends ReadonlyArray<string>>(target: TTarget, keys: TKeys): TTransformedObject<TTarget, TPickedProperties<TTarget["properties"], TKeys>>;
   promise(target: TSchema): TSchema;
-  required(target: TObject): TObject;
-}; //#endregion
+  required<TTarget extends TObject>(target: TTarget): TTransformedObject<TTarget, TRequiredProperties<TTarget["properties"]>>;
+};
+//#endregion
 //#region src/logic/node.d.ts
 type Component = {
   name: string;
@@ -234,11 +263,11 @@ type TNodeIOSchema<TInterface extends TNodeInterfaceDescriptor> = { [TKey in key
   linked: boolean;
   schema: TOnlyVarsOf<TInterface>[TKey];
   value: Static<TOnlyVarsOf<TInterface>[TKey]>;
-} };
-type TNodeOptionals<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = { [TKey in keyof (TOnlyVarsOf<TInputs> | TOnlyVarsOf<TOutputs>)]: boolean };
+}; };
+type TNodeOptionals<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = { [TKey in keyof (TOnlyVarsOf<TInputs> | TOnlyVarsOf<TOutputs>)]: boolean; };
 type TNodeConfigSchema<TConfig extends TNodeConfigDescriptor> = {
   internal?: unknown;
-} & { [TKey in keyof TConfig]: Static<TConfig[TKey]> };
+} & { [TKey in keyof TConfig]: Static<TConfig[TKey]>; };
 type TNodeDynamics<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = {
   inputs?: (ioSchema: {
     config: TNodeConfigSchema<TConfig>;
@@ -270,17 +299,18 @@ type TDocumentation = {
     name: string;
   }>;
 };
-type TOnlyExecOf<TNodeInterfaceDescriptor> = { [TAnchor in keyof TNodeInterfaceDescriptor as TNodeInterfaceDescriptor[TAnchor] extends TExec ? TAnchor : never]: TNodeInterfaceDescriptor[TAnchor] };
-type TOnlyVarsOf<TNodeInterfaceDescriptor> = { [TAnchor in keyof TNodeInterfaceDescriptor as TNodeInterfaceDescriptor[TAnchor] extends TExec ? never : TAnchor]: TNodeInterfaceDescriptor[TAnchor] };
+type TOnlyExecOf<TNodeInterfaceDescriptor> = { [TAnchor in keyof TNodeInterfaceDescriptor as TNodeInterfaceDescriptor[TAnchor] extends TExec ? TAnchor : never]: TNodeInterfaceDescriptor[TAnchor]; };
+type TOnlyVarsOf<TNodeInterfaceDescriptor> = { [TAnchor in keyof TNodeInterfaceDescriptor as TNodeInterfaceDescriptor[TAnchor] extends TExec ? never : TAnchor]: TNodeInterfaceDescriptor[TAnchor]; };
 type MethodsFrom<TInterface extends TNodeInterfaceDescriptor> = { [TKey in keyof TInterface]: (() => MaybePromise<Static<TInterface[TKey]>>) | {
   async: () => Promise<Static<TInterface[TKey]>>;
   sync: () => MaybePromise<Static<TInterface[TKey]>>;
-} };
+}; };
 type TMethodsOf<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = MethodsFrom<TOnlyExecOf<TInputs>> & MethodsFrom<TOnlyVarsOf<TOutputs>>;
-type TNodeDescriptor<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = TNodeGenerated<TInputs, TOutputs, TConfig> & ThisType<{ [TKey in keyof TOnlyExecOf<TOutputs>]: (stack?: unknown) => Promise<void> } & { [TKey in keyof TOnlyVarsOf<TInputs>]: Static<TInputs[TKey]> } & { [TKey in keyof TOnlyVarsOf<TOutputs>]: Static<TOutputs[TKey]> } & Record<`internal_${string}`, unknown> & {
-  arguments: Promise<Array<unknown>>;
+type TNodeDescriptor<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = TNodeGenerated<TInputs, TOutputs, TConfig> & ThisType<{ [TKey in keyof TOnlyExecOf<TOutputs>]: (stack?: unknown) => Promise<void>; } & { [TKey in keyof TOnlyVarsOf<TInputs>]: Static<TInputs[TKey]>; } & { [TKey in keyof TOnlyVarsOf<TOutputs>]: Static<TOutputs[TKey]>; } & Record<`internal_${string}`, unknown> & {
+  arguments: Array<unknown>;
   cache: Record<string, unknown>;
-  config: { [TKey in keyof TConfig]: Static<TConfig[TKey]> };
+  config: { [TKey in keyof TConfig]: Static<TConfig[TKey]>; };
+  instance: <TValue>(deps: Array<unknown>, factory: () => TValue, key?: string) => TValue;
   properties: Record<string, {
     name: string;
     value: Promise<unknown>;
@@ -299,7 +329,8 @@ type TNodeGenerated<TInputs extends TNodeInterfaceDescriptor, TOutputs extends T
     }>;
     entry?: boolean;
     generate?: (data: {
-      config?: { [TKey in keyof TConfig]: Static<TConfig[TKey]> };
+      config?: { [TKey in keyof TConfig]: Static<TConfig[TKey]>; };
+      id?: string;
       inputKeys: Array<string>;
       key?: string;
     }) => string;
@@ -331,6 +362,7 @@ type TLogicNode = {
     entry?: boolean;
     generate?: (options: {
       config: Record<string, unknown>;
+      id?: string;
       inputKeys: Array<string>;
       key: string;
     }) => string;
@@ -362,7 +394,6 @@ type TLogicNode = {
   outputs: TNodeInterfaceDescriptor;
   type?: ELogicType;
 };
-declare function makeLogicNode<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor>(node: TNodeDescriptor<TInputs, TOutputs, TConfig>): TLogicNode; //#endregion
-//#region src/logic/lib.d.ts
+declare function makeLogicNode<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor>(node: TNodeDescriptor<TInputs, TOutputs, TConfig>): TLogicNode;
 //#endregion
 export { LogicUtil as a, TObject as c, makeLogicNode as d, CVector as f, TVector as h, LogicType as i, TSchema as l, MaybePromise as m, ELogicType as n, Static as o, DeepPartial as p, EVarType as r, TLogicNode as s, ELogicScope as t, TVoid as u };