@luna-park/plugin 1.3.0 → 1.4.0

package/dist/index-X3hhfmWd.d.mts

@@ -0,0 +1,368 @@
+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 MaybePromise<T> = T | Promise<T>;
+//#endregion
+//#region src/vector.d.ts
+type TVector = {
+  x: number;
+  y: number;
+};
+declare class CVector {
+  x: number;
+  y: number;
+  constructor(vector: TVector);
+  setX(x: number): CVector;
+  setY(y: number): CVector;
+  clone(): CVector;
+  add(vector: TVector): CVector;
+  sub(vector: TVector): CVector;
+  mul(number: number): CVector;
+  div(number: number): CVector;
+  round(): CVector;
+  addX(x: number): CVector;
+  addY(y: number): CVector;
+  normalize(): CVector;
+  isNearlyEqual(vector: TVector): boolean;
+  getPointString(): string;
+  getMagnitude(): number;
+} //#endregion
+//#endregion
+//#region ../logicnodes/dist/index.d.mts
+//#region src/logic/type.d.ts
+declare enum EVarType {
+  exec = "exec",
+  number = "number",
+  string = "string",
+  boolean = "boolean",
+  object = "object",
+  record = "record",
+  array = "array",
+  interface = "interface",
+  type = "type",
+  function = "function",
+  union = "union",
+  unknown = "unknown",
+  undefined = "undefined",
+  void = "void"
+}
+type TProperties = Record<string, TSchema>;
+interface TArguments<TType = unknown> {
+  build?: (arg: unknown) => unknown;
+  customizable?: boolean;
+  default?: TType | (() => TType);
+  defaultType?: TSchema;
+  description?: string;
+  dynamic?: ((arg: {
+    config: Record<string, unknown>;
+    inputs: Record<string, TSchema>;
+    outputs: Record<string, TSchema>;
+  }) => TSchema);
+  enum?: TEnum<TType>;
+  example?: unknown;
+  format?: "date-time" | "email" | "color";
+  multiple?: boolean;
+  name?: string;
+  optional?: boolean;
+  options?: {
+    access?: TSchema<TObject>;
+    format?: (arg: TType) => TType;
+    freeze?: boolean;
+    readonly?: boolean;
+  } & Record<string, unknown>;
+  parse?: (arg: unknown) => unknown;
+  placeholder?: string;
+  priority?: boolean;
+  promise?: boolean;
+  required?: boolean;
+  static?: unknown;
+  sub?: TSchema;
+}
+type TEnum<TEnumType> = Array<TEnumType> | Record<string, TEnumType>;
+interface TExec {
+  type: EVarType.exec;
+}
+interface TNumber {
+  static: number;
+  type: EVarType.number;
+}
+interface TString {
+  static: string;
+  type: EVarType.string;
+}
+interface TBoolean {
+  static: boolean;
+  type: EVarType.boolean;
+}
+interface TUnknown {
+  static: unknown;
+  type: EVarType.unknown;
+}
+interface TUndefined {
+  static: undefined;
+  type: EVarType.undefined;
+}
+interface TVoid {
+  static: void;
+  type: EVarType.void;
+}
+interface TObject<T extends TProperties = TProperties> {
+  properties: T;
+  static: StaticObject<T>;
+  type: EVarType.object;
+}
+interface TRecord<TKey extends TString | TNumber = TString, TValue extends TSchema = TSchema> {
+  key: TKey;
+  static: StaticRecord<TKey, TValue>;
+  type: EVarType.record;
+  value: TValue;
+}
+interface TInterface<T = unknown> {
+  class?: new (...args: Array<unknown>) => T;
+  className: string;
+  static: T;
+  type: EVarType.interface;
+}
+interface TType<T extends TSchema = TSchema> {
+  static: T;
+  target: Array<string>;
+  type: EVarType.type;
+}
+interface TArray<T extends TSchema = TSchema> {
+  items: T;
+  static: Array<Static<T>>;
+  type: EVarType.array;
+}
+interface TUnion<T extends ReadonlyArray<TSchema> = ReadonlyArray<TSchema>> {
+  elements: T;
+  static: StaticUnion<T>;
+  type: EVarType.union;
+}
+interface TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TSchema, TPromise extends boolean = false> {
+  inputs: TInputs;
+  output: TOutput;
+  static: StaticFunction<TInputs, 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>>;
+declare const LogicType: {
+  array: <T extends TSchema, TArgs extends TArguments<Array<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>;
+  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>;
+  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>;
+  unknown: <TArgs extends TArguments>(args?: TArgs) => TUnknown & TArgs;
+  void: (args?: TArguments) => TVoid;
+};
+type OptionalKeys<T extends TProperties> = { [K in keyof T]: T[K] extends {
+  optional: true;
+} ? 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 {
+  optional: true;
+} ? (T["static"] | undefined) : T["static"];
+declare const LogicUtil: {
+  omit(target: TObject, keys: Array<string>): TObject;
+  partial(target: TObject, force?: boolean): TObject;
+  pick(target: TObject, keys: Array<string>): TObject;
+  promise(target: TSchema): TSchema;
+  required(target: TObject): TObject;
+}; //#endregion
+//#region src/logic/node.d.ts
+type Component = {
+  name: string;
+};
+type TNodeInterfaceDescriptor = Record<string, TSchema>;
+declare enum ELogicType {
+  function = "function",
+  macro = "macro",
+  operation = "operation"
+}
+declare enum ELogicScope {
+  Frontend = "frontend",
+  Backend = "backend",
+  Desktop = "desktop",
+  Shared = "shared"
+}
+type TNodeDisplay = {
+  altSearch?: string;
+  config?: {
+    back?: string | IconDefinition;
+    data?: {
+      size?: {
+        x: number;
+        y: number;
+      };
+    };
+    fixed?: boolean;
+    headerless?: boolean;
+    hoverable?: boolean;
+    icon?: string | IconDefinition;
+    inspector?: string;
+    noDelete?: boolean;
+    noSelection?: boolean;
+    notFound?: boolean;
+    once?: boolean;
+    priority?: number;
+    scope?: ELogicScope;
+    transparent?: boolean;
+  };
+  custom?: Component | string;
+  data?: Record<string, unknown>;
+  inspector?: string;
+  interface?: Component | string;
+  name?: string;
+  priority?: number;
+};
+type TNodeConfigDescriptor = Record<string, TSchema>;
+type TNodeIOSchema<TInterface extends TNodeInterfaceDescriptor> = { [TKey in keyof TOnlyVarsOf<TInterface>]: {
+  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 TNodeConfigSchema<TConfig extends TNodeConfigDescriptor> = {
+  internal?: unknown;
+} & { [TKey in keyof TConfig]: Static<TConfig[TKey]> };
+type TNodeDynamics<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = {
+  inputs?: (ioSchema: {
+    config: TNodeConfigSchema<TConfig>;
+    inputs: TNodeIOSchema<TInputs>;
+    optionals: TNodeOptionals<TInputs, TOutputs>;
+    outputs: TNodeIOSchema<TOutputs>;
+  }) => Partial<TNodeInterfaceDescriptor>;
+  outputs?: (ioSchema: {
+    config: TNodeConfigSchema<TConfig>;
+    inputs: TNodeIOSchema<TInputs>;
+    optionals: TNodeOptionals<TInputs, TOutputs>;
+    outputs: TNodeIOSchema<TOutputs>;
+  }) => Partial<TNodeInterfaceDescriptor>;
+};
+type TDocumentation = {
+  description?: string;
+  examples?: Array<{
+    inputs: Array<{
+      key: string;
+      value: unknown;
+    }>;
+    outputs: Array<{
+      key: string;
+      value: unknown;
+    }>;
+  }>;
+  parameters?: Array<{
+    description: string;
+    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 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>>;
+  cache: Record<string, unknown>;
+  config: { [TKey in keyof TConfig]: Static<TConfig[TKey]> };
+  properties: Record<string, {
+    name: string;
+    value: Promise<unknown>;
+  }>;
+  stack: any;
+}>;
+type TNodeGenerated<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = {
+  build?: {
+    define?: Array<{
+      id: (data: {
+        input?: TOnlyVarsOf<TInputs>;
+      }) => string;
+      values: (data: {
+        input?: TOnlyVarsOf<TInputs>;
+      }) => string;
+    }>;
+    entry?: boolean;
+    generate?: (data: {
+      config?: { [TKey in keyof TConfig]: Static<TConfig[TKey]> };
+      inputKeys: Array<string>;
+      key?: string;
+    }) => string;
+    imports?: Array<{
+      name: string;
+      target: string;
+    }>;
+  };
+  config?: TConfig;
+  display?: TNodeDisplay;
+  documentation?: TDocumentation;
+  dynamics?: TNodeDynamics<TInputs, TOutputs, TConfig>;
+  inputs: TInputs;
+  methods: Partial<TMethodsOf<TInputs, TOutputs>>;
+  name?: string;
+  outputs: TOutputs;
+  type?: ELogicType;
+};
+type TLogicNode = {
+  build?: {
+    define?: Array<{
+      id: (data: {
+        input?: Record<string, unknown>;
+      }) => string;
+      values: (data: {
+        input?: Record<string, unknown>;
+      }) => string;
+    }>;
+    entry?: boolean;
+    generate?: (options: {
+      config: Record<string, unknown>;
+      inputKeys: Array<string>;
+      key: string;
+    }) => string;
+    imports?: Array<{
+      name: string;
+      target: string;
+    }>;
+  };
+  config?: TNodeConfigDescriptor;
+  display?: TNodeDisplay;
+  documentation?: TDocumentation;
+  dynamics?: {
+    inputs?: (ioSchema: {
+      config: Record<string, unknown>;
+      inputs: Record<string, unknown>;
+      optionals: Record<string, boolean>;
+      outputs: Record<string, unknown>;
+    }) => TNodeInterfaceDescriptor;
+    outputs?: (ioSchema: {
+      config: Record<string, unknown>;
+      inputs: Record<string, unknown>;
+      optionals: Record<string, boolean>;
+      outputs: Record<string, unknown>;
+    }) => TNodeInterfaceDescriptor;
+  };
+  inputs: TNodeInterfaceDescriptor;
+  methods: Record<string, () => unknown>;
+  name: string;
+  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
+//#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 };