@luna-park/plugin 1.4.1 → 1.5.0

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 };