@luna-park/plugin 1.1.0 → 1.2.1

package/dist/index.d.ts

@@ -1,11 +1,220 @@
+import { CDatabase } from './modules/database/lib/Database';
 import { Component } from 'vue';
+import { ComputedRef } from 'vue';
+import { Cron } from 'lite-cron';
 import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
-import { PluginOption } from 'vite';
+import { default as LSettingsStoryWrapper } from './components/LSettingsStoryWrapper.vue';
+
+declare namespace Anchor {
+    export {
+        EAnchorDirection,
+        ANCHOR_PADDING,
+        IAnchor,
+        CAnchor,
+        ISingleAnchor,
+        CSingleAnchor,
+        INodeAnchor,
+        CNodeAnchor
+    }
+}
+
+declare const ANCHOR_PADDING = 43;
+
+declare abstract class CAnchor implements IAnchor {
+    connections: Array<Wire.CWire>;
+    dbAnchor: TDBAnchor;
+    padding?: number;
+    protected constructor(anchor: IAnchor);
+    abstract getLocation(): TVector;
+    abstract getPadding(): number;
+    get schema(): TSchema;
+    get schemaRaw(): TSchema;
+    get toSchema(): TSchema;
+}
+
+declare class CDynamicVariable {
+    _dynamic: boolean;
+    type: EDynamicVariableType;
+    value: unknown;
+    token: string;
+    access: Array<string>;
+    target?: {
+        invert: boolean;
+        operation: EDynamicVariableOperation;
+        variable?: CDynamicVariable;
+    };
+    constructor({ type, access, target, token, value }?: Partial<TDynamicVariable>);
+    getComputed(component: TFileComponent, options?: {
+        context?: TLayoutContext;
+        stackId?: string;
+    }): ComputedRef<CLayoutValue | TReturnValue>;
+    getValue(component: TFileComponent, options?: {
+        base?: boolean;
+        context?: TLayoutContext;
+        stackId?: string;
+    }): TReturnValue;
+    getRawValue(): unknown;
+    toJSON(): unknown;
+}
+
+declare class CLayoutValue {
+    id: string;
+    child: Array<string>;
+    component: TFileComponent;
+    type?: ELayoutValueType;
+    baseType?: ELayoutValueType;
+    stackId: string;
+    context: TLayoutContext;
+    constructor(access: Array<string>, component: TFileComponent, options?: {
+        context?: TLayoutContext;
+        stackId?: string;
+    });
+    get value(): unknown;
+    set value(value: unknown);
+    get schema(): TSchema;
+    get baseSchema(): TSchema;
+}
+
+declare class CNode {
+    id: string;
+    dbNode: TGeneratedNode;
+    element?: HTMLElement;
+    invert: boolean;
+    parent?: TAnyLogic;
+    config: {
+        animate: boolean;
+        processing: boolean;
+    };
+    inputs: Record<string, Anchor.CNodeAnchor>;
+    outputs: Record<string, Anchor.CNodeAnchor>;
+    private cache;
+    private _location;
+    _data: TNodeData;
+    constructor(node: TNode_2);
+    get orderedInputs(): Anchor.CNodeAnchor[];
+    get orderedOutputs(): Anchor.CNodeAnchor[];
+    set location(location: TVector);
+    get location(): TVector;
+    getSafeInputs(): Record<string, CNodeAnchor>;
+    getSafeOutputs(): Record<string, CNodeAnchor>;
+    set data(data: Record<string, unknown>);
+    get data(): TNodeData;
+    reset(): void;
+    setLocation(location: TVector): CNode;
+    getAnchorLocation(anchor: Anchor.CNodeAnchor): CVector;
+    getRelativeAnchorLocation(anchor: Anchor.CNodeAnchor): CVector;
+    getRelativeAnchorLocation_internal(anchor: Anchor.CNodeAnchor): CVector;
+    getLocation(): CVector;
+    private getLocation_internal;
+    getSize(): CVector;
+    private getSize_internal;
+    execute(outputKey: string, stack?: TStack): MaybePromise<void>;
+    getInput(inputKey: string, stack?: TStack): unknown;
+    setOutput(outputKey: string, value: unknown, stack?: TStack): void;
+}
+
+declare class CNodeAnchor extends CAnchor implements INodeAnchor {
+    key: string;
+    index: number;
+    node: Node_2.CNode;
+    direction: EAnchorDirection;
+    value: unknown;
+    element?: HTMLElement;
+    cache: {
+        preview?: unknown;
+        relativeLocation?: CVector;
+    };
+    constructor(anchor: INodeAnchor);
+    get schema(): TSchema;
+    get toSchema(): TSchema;
+    get schemaRaw(): TSchema;
+    getLocation(): CVector;
+    getRelativeLocation(): CVector;
+    resetCache(): void;
+    getPadding(): number;
+    isDisabled(): boolean;
+    errorMessage(): string | undefined;
+    setValue(value: string | number | boolean): void;
+    resetValue(): void;
+}
 
 declare type Component_2 = {
     name: string;
 };
 
+declare class CPathPoint {
+    direction: CVector;
+    location: CVector;
+    constructor({ direction, location }: {
+        direction: TVector;
+        location: TVector;
+    });
+    move(offset: TVector, config?: {
+        reverse: boolean;
+    }): CPathPoint;
+}
+
+declare function create({ from, temp, to }: {
+    from: Anchor.CAnchor;
+    temp: boolean;
+    to: Anchor.CAnchor;
+}): CWire;
+
+declare function create_2(dbNode: TLogicNode, { origin }?: {
+    origin?: TNode_2;
+}): CNode;
+
+declare class CSingleAnchor extends CAnchor implements ISingleAnchor {
+    location: TVector;
+    constructor(anchor: ISingleAnchor);
+    getLocation(): TVector;
+    getPadding(): 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;
+}
+
+declare class CWire {
+    id: string;
+    from: Anchor.CAnchor;
+    to: Anchor.CAnchor;
+    animate: boolean;
+    temp: boolean;
+    constructor(wire: TWire);
+    get type(): TSchema | (TUnknown & TArguments<unknown>);
+    get toType(): TSchema;
+    getPoints(): string;
+    registerRibbon(path: Path): void;
+    getBoundingBox(): TRect;
+}
+
+declare 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];
+};
+
+declare enum EAnchorDirection {
+    input = "input",
+    output = "output",
+    none = "none"
+}
+
 declare enum EComponentPreview {
     Compact = "compact",
     Stretch = "stretch",
@@ -37,7 +246,12 @@ declare enum EDynamicVariableType {
     Token = "token"
 }
 
-declare enum EElementType {
+declare enum EElementTemplate {
+    If = "if",
+    For = "for"
+}
+
+export declare enum EElementType {
     Script = "script",
     Standalone = "standalone",
     Folder = "folder",
@@ -65,6 +279,17 @@ declare enum EHistoryMode {
     Memory = "memory"
 }
 
+export declare enum EInjectionKey {
+    ViteImport = "viteImport",
+    VitePlugin = "vitePlugin",
+    AppImport = "appImport",
+    AppBody = "appBody",
+    AppSetup = "appSetup",
+    Style = "style",
+    ServerImport = "serverImport",
+    ServerBody = "serverBody"
+}
+
 declare enum ELayoutElement {
     input = "input",
     div = "div",
@@ -76,7 +301,30 @@ declare enum ELayoutElement {
     slot = "slot",
     template = "template",
     variable = "variable",
-    widget = "widget"
+    link = "link"
+}
+
+declare enum ELayoutEvent {
+    click = "click",
+    keydown = "keydown",
+    mouseenter = "mouseenter",
+    mouseleave = "mouseleave",
+    mousedown = "mousedown",
+    mouseup = "mouseup",
+    mousemove = "mousemove",
+    wheel = "wheel"
+}
+
+declare enum ELayoutValueType {
+    variable = "variable",
+    property = "property",
+    attribute = "attribute",
+    context = "context",
+    computed = "computed",
+    event = "event",
+    file = "file",
+    model = "model",
+    logic = "logic"
 }
 
 declare enum ELogicMode {
@@ -116,12 +364,6 @@ declare enum EStoreType {
     Local = "local"
 }
 
-declare enum EThemeMode {
-    Dark = "dark",
-    Light = "light",
-    Auto = "auto"
-}
-
 export declare enum ETokenType {
     Color = "color",
     FontSize = "font-size",
@@ -148,19 +390,45 @@ export declare enum EVarType {
     void = "void"
 }
 
+declare function from(wire: TWire): CWire;
+
+declare function from_2(node: TNode_2): CNode;
+
 export declare function getPluginParam<T>(target: TOption<TEnv, T>, env: Partial<TEnv>): Promise<T>;
 
+declare interface IAnchor {
+    connections?: Array<Wire.CWire>;
+    dbAnchor: TDBAnchor;
+    padding?: number;
+}
+
+declare interface INodeAnchor extends IAnchor {
+    index: number;
+    direction: EAnchorDirection;
+    element?: HTMLElement;
+    key: string;
+    node: Node_2.CNode;
+}
+
+declare interface ISingleAnchor extends IAnchor {
+    location: TVector;
+}
+
+export declare function loadPlugin<TConfig extends TSchema, TInternal>(plugin: TPlugin<TConfig, TInternal>, env: Partial<TEnv>): Promise<TBasePlugin<TConfig, TInternal>>;
+
 export declare const LogicType: {
-    type: <T extends TSchema>(target: Array<string>, args?: TArguments) => TType<T>;
     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>(inputs?: TInputs, output?: TOutput, args?: TArguments) => TFunction<TInputs, TOutput>;
+    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, TArgs extends TArguments<T> = TArguments<T>>(interfaceClass: (new (...args: any) => 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 = TSchema<TAnyLogic_2>>(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<unknown>>(args?: TArgs) => TUnknown & TArgs;
@@ -175,27 +443,56 @@ export declare const LogicUtil: {
     required(target: TObject): TObject;
 };
 
+export { LSettingsStoryWrapper }
+
+export declare function makeComponent<TProps extends Record<string, TSchema>>(component: TComponent<TProps>): TComponent<TProps>;
+
 export declare function makeLogicNode<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor>(node: TNodeDescriptor<TInputs, TOutputs, TConfig>): TLogicNode;
 
+declare function makePath(start: CPathPoint, end: CPathPoint): Path;
+
 export declare function makePlugin<TConfig extends TSchema, TInternal>(plugin: TPlugin<TConfig, TInternal>): TPlugin<TConfig, TInternal>;
 
+declare type MaybePromise<T> = T | Promise<T>;
+
 declare type MethodsFrom<TInterface extends TNodeInterfaceDescriptor> = {
-    [TKey in keyof TInterface]: () => Promise<Static<TInterface[TKey]>> | Static<TInterface[TKey]>;
+    [TKey in keyof TInterface]: (() => MaybePromise<Static<TInterface[TKey]>>) | {
+        async: () => Promise<Static<TInterface[TKey]>>;
+        sync: () => MaybePromise<Static<TInterface[TKey]>>;
+    };
 };
 
+declare namespace Node_2 {
+    export {
+        from_2 as from,
+        create_2 as create,
+        NODE_WIDTH,
+        TNode_2 as TNode,
+        CNode
+    }
+}
+
+declare const NODE_WIDTH = 10;
+
 declare type OptionalKeys<T extends TProperties> = {
     [K in keyof T]: T[K] extends {
         optional: true;
     } ? K : never;
 }[keyof T];
 
+declare type Path = Array<CPathPoint>;
+
+declare function pathToString(path: Path, config?: {
+    smoothing: boolean;
+}): string;
+
 declare type RequiredKeys<T extends TProperties> = Exclude<keyof T, OptionalKeys<T>>;
 
-declare type Static<T extends TSchema> = T extends {
+export declare type Static<T extends TSchema> = T extends {
     optional: true;
 } ? (T["static"] | undefined) : T["static"];
 
-declare type StaticFunction<TInputs extends TObject, TOutput extends TSchema> = (...args: Array<Static<TInputs>[string]>) => Promise<Static<TOutput>>;
+declare 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>;
 
 declare type StaticObject<T extends TProperties> = {
     [K in RequiredKeys<T>]: Static<T[K]>;
@@ -216,9 +513,22 @@ declare type StaticUnion<T extends Array<TSchema>> = {
     [K in keyof T]: Static<T[K]>;
 }[number];
 
-declare type TAnchorExport = TSchema;
+declare type TAnchor<TExport extends boolean = false> = TExport extends true ? TSchema : {
+    id: string;
+    parent?: TLogic<TExport>;
+    schema: TSchema;
+};
 
-declare type TAnyLogic = TExec | TObject | TRecord<any, any> | TInterface | TType | TArray<any> | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion<any> | TFunction<any, any> | TVoid;
+export declare type TAnyLogic<TExport extends boolean = false> = TLogic<TExport> | TLogicMain<TExport>;
+
+declare type TAnyLogic_2 = TExec | TObject | TRecord<any, any> | TInterface | TType | TArray<any> | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion<any> | TFunction<any, any> | TVoid;
+
+export declare type TApplication<TExport extends boolean = false> = {
+    name: string;
+    config: TApplicationConfig;
+    tree: TFile<TExport>;
+    version: number;
+};
 
 declare type TApplicationConfig = {
     backend: {
@@ -245,21 +555,6 @@ declare type TApplicationConfig = {
         types: TExportNodeResult["types"];
     }>;
     palette: {
-        content: string;
-        forceTheme: boolean;
-        inject: {
-            css: string;
-            head: string;
-            html: string;
-            js: string;
-        };
-        length: {
-            border: number;
-            radius: number;
-        };
-        matchEditor: boolean;
-        primary: string;
-        theme: EThemeMode;
         tokens: {
             colors: Array<{
                 id: string;
@@ -277,10 +572,16 @@ declare type TApplicationConfig = {
                 value: string;
             }>;
         };
+        inject: {
+            html: string;
+            css: string;
+            js: string;
+            head: string;
+        };
     };
     plugins: Record<string, {
         config?: unknown;
-        internal?: unknown;
+        internals?: unknown;
         target: string;
     }>;
     state: {
@@ -297,14 +598,7 @@ declare type TApplicationConfig = {
     };
 };
 
-declare type TApplicationExport = {
-    name: string;
-    config: TApplicationConfig;
-    tree: TFileExport;
-};
-
 declare interface TArguments<TType = any> {
-    name?: string;
     build?: (arg: unknown) => unknown;
     customizable?: boolean;
     default?: TType;
@@ -319,6 +613,7 @@ declare interface TArguments<TType = any> {
     example?: unknown;
     format?: "date-time" | "email" | "color";
     multiple?: boolean;
+    name?: string;
     optional?: boolean;
     options?: {
         format?: (arg: TType) => TType;
@@ -334,26 +629,91 @@ declare interface TArguments<TType = any> {
 }
 
 declare interface TArray<T extends TSchema = TSchema> {
-    type: EVarType.array;
     items: T;
     static: Array<Static<T>>;
+    type: EVarType.array;
 }
 
+declare type TBaseDynamicVariable = {
+    type: EDynamicVariableType;
+    _dynamic: true;
+    access: Array<string>;
+    target: {
+        invert?: boolean;
+        operation: EDynamicVariableOperation;
+        variable?: TDynamicVariable;
+    };
+    token: string;
+    value: unknown;
+};
+
+export declare type TBasePlugin<TConfig extends TSchema = TSchema, TInternals = unknown> = {
+    build?: {
+        backImports?: Array<{
+            name: string;
+            version?: string;
+        }>;
+        frontImports?: Array<{
+            name: string;
+            version?: string;
+        }>;
+        injections?: Partial<Record<EInjectionKey, string>>;
+    };
+    color?: string;
+    config?: TConfig;
+    dependencies?: Array<{
+        id: string;
+        name: string;
+        target: string;
+    }>;
+    description?: string;
+    editor?: {
+        components?: Array<TComponent>;
+        interfaces?: Array<TInterface_2>;
+        nodes?: Array<TLogicNode>;
+        templates?: Array<TTemplate>;
+        tokens?: Array<TToken>;
+        wrapper?: TComponent & {
+            attributes?: Record<string, unknown>;
+        };
+    };
+    icon: string;
+    id: string;
+    inject?: {
+        css?: string;
+        js?: string;
+    };
+    interface?: Component;
+    internals?: TInternals;
+    lifecycle?: {
+        mount?: (env: TEnv<TConfig, TInternals>) => Promise<void> | void;
+        unmount?: (env: TEnv<TConfig, TInternals>) => Promise<void> | void;
+        update?: (env: TEnv<TConfig, TInternals>) => Promise<void> | void;
+    };
+    name: string;
+    settings?: Array<{
+        component: Component;
+        icon?: IconDefinition | string;
+        label: string;
+    }>;
+};
+
 declare interface TBoolean {
-    type: EVarType.boolean;
     static: boolean;
+    type: EVarType.boolean;
 }
 
-declare type TCanvasExport = {
+declare type TCanvas = {
     location: TVector;
     zoom: number;
 };
 
-export declare type TComponent<TProps extends Record<string, TSchema> = Record<string, TSchema>> = {
+export declare type TComponent<TProps extends Record<string, TSchema> = Record<string, TSchema>, TInternals = unknown> = {
     build?: {
-        import?: Array<{
+        imports?: Array<{
+            default?: boolean;
+            from: string;
             name: string;
-            target: string;
         }>;
         name?: string;
     };
@@ -363,27 +723,21 @@ export declare type TComponent<TProps extends Record<string, TSchema> = Record<s
         link?: string;
     };
     emits?: Record<string, TSchema>;
+    icon?: IconDefinition | string;
+    internals?: TInternals;
     models?: Record<string, TSchema>;
     name: string;
-    properties?: TProps;
-    slots?: Record<string, TSlot> | ((attributes: StaticOfProps<TProps>) => Record<string, TSlot>);
-};
-
-declare type TComponentExport = {
-    name: string;
-    type: EElementType.Component;
-    collapsed?: boolean;
-    layout: TLayoutSchemaExport;
-    logics: Record<string, TLogicExport | TMainLogicExport>;
-    options: TComponentOptions;
-    state: TStateExport;
-    values: {
-        computed: Record<string, TValueExport>;
-        events: Record<string, TValueExport>;
-        model?: TSchema;
-        properties: Record<string, TValueExport>;
-        variables: Record<string, TValueExport>;
+    preview?: {
+        properties?: Partial<{
+            [TKey in keyof TProps]: Static<TProps[TKey]>;
+        }>;
+        slots?: Record<string, string>;
+        style?: string;
     };
+    properties?: TProps;
+    slots?: Record<string, TSlot> | ((attributes: StaticOfProps<TProps> & {
+        internals: TInternals;
+    }) => Record<string, TSlot>);
 };
 
 declare type TComponentOptions = {
@@ -393,32 +747,9 @@ declare type TComponentOptions = {
     previewSize: string;
 };
 
-declare type TConfigExport = {
-    name: string;
-    type: EElementType.Config;
-    content: unknown;
-    display: EConfigDisplay;
+declare type TDBAnchor = {
+    id?: string;
     schema: TSchema;
-    scope: ELogicScope;
-    state: TStateExport;
-};
-
-declare type TCronExport = {
-    name: string;
-    type: EElementType.Cron;
-    active: boolean;
-    editorTrigger: boolean;
-    logics: Record<string, TLogicExport | TMainLogicExport>;
-    state: TStateExport;
-    time: string;
-};
-
-declare type TDatabaseExport = {
-    name: string;
-    type: EElementType.Database;
-    data: Array<Record<string, unknown>>;
-    schema: TSchema<TObject>;
-    state: TStateExport;
 };
 
 declare type TDocumentation = {
@@ -434,29 +765,22 @@ declare type TDocumentation = {
         }>;
     }>;
     parameters?: Array<{
-        name: string;
         description: string;
+        name: string;
     }>;
 };
 
-declare type TDynamicVariable = {
-    type: EDynamicVariableType;
-    access: Array<string>;
-    target: {
-        invert?: boolean;
-        operation: EDynamicVariableOperation;
-        variable?: TDynamicVariable;
-    };
-    token: string;
-    value: unknown;
-};
+declare type TDynamicVariable<TExport extends boolean = false> = (TExport extends true ? TBaseDynamicVariable : CDynamicVariable) | unknown;
 
 declare type TEnum<TEnumType> = Array<TEnumType> | Record<string, TEnumType>;
 
-declare type TEnv<TConfig extends TSchema = TSchema, TInternal = unknown> = {
-    app: TApplicationExport;
+declare type TEnv<TConfig extends TSchema = TSchema, TInternals = unknown> = {
+    addFile: (file: DeepPartial<TFile<true>> & {
+        type: EElementType;
+    }, parentId?: string) => TFile;
+    app: TApplication;
     config: Static<TConfig>;
-    internal: TInternal;
+    internals: TInternals;
     mode: "build" | "editor";
 };
 
@@ -480,71 +804,263 @@ declare type TExportNodeResult = {
     types: Record<string, TSchema>;
 };
 
-export declare type TFileExport = (TFolderExport | TComponentExport | TConfigExport | TCronExport | TDatabaseExport | TRouteExport | TScriptExport | TStoreExport | TTextExport | TTypeExport | TMediaExport) & {
+export declare type TFile<TExport extends boolean = false> = (TFolder<TExport> | TFileComponent<TExport> | TFileConfig<TExport> | TFileCron<TExport> | TFileDatabase<TExport> | TFileRoute<TExport> | TFileScript<TExport> | TFileStore<TExport> | TFileText<TExport> | TFileType<TExport> | TFileMedia<TExport>) & {
     isEditing?: boolean;
 };
 
-declare type TFolderExport = {
+declare type TFileBase<TExport extends boolean = false> = {
     name: string;
+    state: TFileState;
+} & (TExport extends false ? {
+    id: string;
+    parent?: TFolder<TExport>;
+} : {});
+
+export declare type TFileComponent<TExport extends boolean = false> = TFileBase<TExport> & {
+    type: EElementType.Component;
+    collapsed?: boolean;
+    layout: TLayoutSchema<ELayoutElement, TExport>;
+    logics: Record<string, TLogic<TExport> | TLogicMain<TExport>>;
+    options: TComponentOptions;
+    values: {
+        computed: Record<string, TValue<TExport>>;
+        events: Record<string, TValue<TExport>>;
+        model?: TSchema;
+        properties: Record<string, TValue<TExport>>;
+        variables: Record<string, TValue<TExport>>;
+    };
+} & (TExport extends false ? {
+    flat: Record<string, TLayoutSchema>;
+} : {});
+
+export declare type TFileConfig<TExport extends boolean = false> = TFileBase<TExport> & {
+    type: EElementType.Config;
+    content: unknown;
+    display: EConfigDisplay;
+    schema: TSchema;
+    scope: ELogicScope;
+};
+
+export declare type TFileCron<TExport extends boolean = false> = TFileBase<TExport> & {
+    type: EElementType.Cron;
+    active: boolean;
+    editorTrigger: boolean;
+    logics: Record<string, TAnyLogic<TExport>>;
+    time: string;
+} & (TExport extends false ? {
+    cron?: Cron;
+    scope: ELogicScope.Backend;
+} : {});
+
+export declare type TFileDatabase<TExport extends boolean = false> = TFileBase<TExport> & {
+    type: EElementType.Database;
+    data: Array<Record<string, unknown>>;
+    schema: TSchema<TObject>;
+} & (TExport extends false ? {
+    db: CDatabase;
+    scope: ELogicScope.Backend;
+} : {});
+
+export declare type TFileMedia<TExport extends boolean = false> = TFileBase<TExport> & {
+    type: EElementType.Media;
+    mimeType: string;
+    target: string;
+};
+
+export declare type TFileRoute<TExport extends boolean = false> = TFileBase<TExport> & {
+    type: EElementType.Route;
+    dev?: boolean;
+    input: {
+        body: TSchema;
+        headers: TSchema;
+        query: TSchema;
+    };
+    logics: Record<string, TAnyLogic<TExport>>;
+    method: ERouteMethod;
+    output: TSchema;
+    path: string;
+} & (TExport extends false ? {
+    scope: ELogicScope.Backend;
+} : {});
+
+export declare type TFileScript<TExport extends boolean = false> = TFileBase<TExport> & {
+    type: EElementType.Script;
+    logics: Record<string, TAnyLogic<TExport>>;
+    options?: {
+        autoReload?: boolean;
+    };
+    scope: ELogicScope;
+};
+
+declare type TFileState = {
+    expand?: boolean;
+    isEditing?: boolean;
+    logic?: {
+        location: TVector;
+        zoom: number;
+    };
+    opened?: boolean;
+    panel?: string;
+};
+
+export declare type TFileStore<TExport extends boolean = false> = TFileBase<TExport> & {
+    type: EElementType.Store;
+    default: unknown;
+    logics: Record<string, TLogic<TExport>>;
+    options: TStoreOptions;
+    schema: TSchema;
+} & (TExport extends false ? {
+    proxy: TSchema;
+    scope: ELogicScope.Frontend;
+} : {});
+
+export declare type TFileText<TExport extends boolean = false> = TFileBase<TExport> & {
+    type: EElementType.Text;
+    blocks: Array<{
+        content: string;
+        key: string;
+    }>;
+} & (TExport extends false ? {
+    scope: ELogicScope.Frontend;
+} : {});
+
+export declare type TFileType<TExport extends boolean = false> = TFileBase<TExport> & {
+    name: string;
+    type: EElementType.Type;
+    schemas: Record<string, TSchema>;
+} & (TExport extends false ? {
+    scope: ELogicScope.Shared;
+} : {});
+
+export declare type TFolder<TExport extends boolean = false> = TFileBase<TExport> & {
     type: EElementType.Folder;
-    children: Record<string, TFileExport>;
+    children: Record<string, TFile<TExport>>;
     color?: string;
 };
 
-declare interface TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TUnknown> {
-    type: EVarType.function;
+declare interface TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TUnknown, TPromise extends boolean = false> {
     inputs: TInputs;
     output: TOutput;
-    static: StaticFunction<TInputs, TOutput>;
+    static: StaticFunction<TInputs, TOutput, TPromise>;
+    type: EVarType.function;
 }
 
-declare type TGraphExport = {
-    canvas: TCanvasExport;
-    nodes: Record<string, TNodeExport>;
-    wires: Record<string, TWireExport>;
+declare type TGeneratedNode<TLogic extends TLogicNode = TLogicNode> = TLogic & {
+    node?: CNode;
+    origin: TLogic;
+    proxy: any;
+};
+
+declare type TGraph<TExport extends boolean = false> = {
+    canvas: TCanvas;
+    nodes: Record<string, TNode<TExport>>;
+    wires: Record<string, TWire_2<TExport>>;
 };
 
 declare interface TInterface<T = unknown> {
-    type: EVarType.interface;
     class?: new (...args: any) => T;
     className: string;
     static: T;
+    type: EVarType.interface;
 }
 
-declare type TLayoutSchemaExport = {
-    id: string;
+declare type TInterface_2 = {
+    arguments?: Array<TSchema>;
+    class?: new (...args: Array<unknown>) => unknown;
+    methods?: Array<{
+        name: string;
+        parameters?: Array<TSchema>;
+        return: TSchema;
+    }>;
     name: string;
-    children: Array<TLayoutSchemaExport>;
-    classes: Array<TDynamicVariable>;
-    content?: Record<string, unknown>;
-    element: ELayoutElement;
-    events: Array<string>;
-    model?: Array<string>;
-    properties: Record<string, TDynamicVariable>;
-    style: Record<"base" | string, Record<"default" | "hover", Record<string, Record<string, TDynamicVariable>> & {
-        collapsed?: boolean;
-    }>>;
-    tag?: string;
 };
 
-declare type TLogicExport = {
-    name: string;
+declare type TLayoutContentType<TElement extends ELayoutElement, TExport extends boolean = false> = TElement extends ELayoutElement.variable ? {
+    var: CDynamicVariable | unknown;
+} : TElement extends ELayoutElement.component ? {
+    id: string;
+    slot: boolean;
+    slots: Record<string, TLayoutSchema<TElement, TExport>>;
+} : TElement extends ELayoutElement.customText ? {
+    text: TTextBlock;
+    variables: Array<string>;
+} : TElement extends ELayoutElement.customHtml ? {
+    html: string;
+    variables: Array<string>;
+} : TElement extends ELayoutElement.template ? {
+    preview: string;
+    template: EElementTemplate;
+    var: CDynamicVariable | unknown;
+} : TElement extends ELayoutElement.package ? {
+    slot: boolean;
+    slots: Record<string, TLayoutSchema<TElement, TExport>>;
+    target: Array<string>;
+} : Record<string, unknown>;
+
+declare type TLayoutContext = Record<string, TLayoutContextVariable>;
+
+declare type TLayoutContextVariable = {
+    schema: TSchema;
+    value: unknown;
+};
+
+declare type TLayoutSchema<TElement extends ELayoutElement = ELayoutElement, TExport extends boolean = false> = {
+    [TInnerElement in TElement]: {
+        id: string;
+        name: string;
+        children: Array<TLayoutSchema<ELayoutElement, TExport>>;
+        classes: Array<TDynamicVariable<TExport>>;
+        collapsed?: boolean;
+        component: TFileComponent<TExport>;
+        content: TLayoutContentType<TInnerElement>;
+        element: TInnerElement;
+        events: Array<ELayoutEvent | string>;
+        model?: Array<string>;
+        properties: Record<string, TDynamicVariable<TExport>>;
+        style: Record<"base" | string, Record<"default" | "hover", Record<string, Record<string, TDynamicVariable<TExport>>> & {
+            collapsed?: boolean;
+        }>>;
+        tag?: string;
+    };
+}[TElement] & (TExport extends false ? {
+    parent?: TLayoutSchema<ELayoutElement, TExport>;
+} : {});
+
+export declare type TLogic<TExport extends boolean = false> = TLogicBase<TExport> & {
     type: EElementType.Logic | EElementType.Standalone;
+    async: boolean;
     code?: string;
     export: boolean;
-    graph: TGraphExport;
-    inputs: Record<string, TAnchorExport>;
+    inputs: Record<string, TAnchor<TExport>>;
     mode: ELogicMode;
-    outputs: Record<string, TAnchorExport>;
+    outputs: Record<string, TAnchor<TExport>>;
     packages?: Array<string>;
+} & (TExport extends false ? {
+    id: string;
+} : {});
+
+declare type TLogicBase<TExport extends boolean = false> = {
+    name: string;
+    type: EElementType;
+    graph: TGraph<TExport>;
     values: {
-        variables: Record<string, TValueExport>;
+        variables: Record<string, TValue<TExport>>;
     };
-};
+} & (TExport extends false ? {
+    id: string;
+    db: Record<string, TLogicNode>;
+    isEditing?: boolean;
+    parent: TFile<TExport>;
+} : {});
+
+export declare type TLogicMain<TExport extends boolean = false> = TLogicBase<TExport> & {
+    name: "Main";
+    type: EElementType.MainLogic;
+} & (TExport extends false ? {
+    id: "main";
+} : {});
 
 export declare type TLogicNode = {
-    name: string;
-    type?: ELogicType;
     build?: {
         define?: Array<{
             id: (data: {
@@ -584,27 +1100,32 @@ export declare type TLogicNode = {
     };
     inputs: TNodeInterfaceDescriptor;
     methods: Record<string, () => unknown>;
+    name: string;
     outputs: TNodeInterfaceDescriptor;
+    type?: ELogicType;
 };
 
-declare type TMainLogicExport = {
-    name: "Main";
-    type: EElementType.MainLogic;
-    graph: TGraphExport;
-    values: {
-        variables: Record<string, TValueExport>;
+declare type TMethodsOf<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = MethodsFrom<TOnlyExecOf<TInputs>> & MethodsFrom<TOnlyVarsOf<TOutputs>>;
+
+declare type TNode<TExport extends boolean = false> = TExport extends true ? {
+    data?: Record<string, unknown>;
+    internal?: {
+        inputs?: Record<string, unknown>;
+        outputs?: Record<string, unknown>;
     };
-};
+    location: TVector;
+    logic: string;
+} : CNode;
 
-declare type TMediaExport = {
-    name: string;
-    type: EElementType.Media;
-    mimeType: string;
-    target: string;
+declare type TNode_2 = {
+    id: string;
+    inputs: Record<string, Anchor.CNodeAnchor>;
+    outputs: Record<string, Anchor.CNodeAnchor>;
+    data?: object;
+    dbNode: TGeneratedNode;
+    location: TVector;
 };
 
-declare type TMethodsOf<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = MethodsFrom<TOnlyExecOf<TInputs>> & MethodsFrom<TOnlyVarsOf<TOutputs>>;
-
 declare type TNodeConfigDescriptor = Record<string, TSchema>;
 
 declare type TNodeConfigSchema<TConfig extends TNodeConfigDescriptor> = {
@@ -613,6 +1134,16 @@ declare type TNodeConfigSchema<TConfig extends TNodeConfigDescriptor> = {
     [TKey in keyof TConfig]: Static<TConfig[TKey]>;
 };
 
+declare type TNodeData = {
+    config?: Record<string, unknown>;
+    multiple?: {
+        isArray?: boolean;
+        number: number;
+    };
+    optionals?: Record<string, boolean>;
+    size?: TVector;
+} & Record<string, unknown>;
+
 declare 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>;
 } & {
@@ -632,7 +1163,6 @@ declare type TNodeDescriptor<TInputs extends TNodeInterfaceDescriptor, TOutputs
 }>;
 
 declare type TNodeDisplay = {
-    name?: string;
     altSearch?: string;
     config?: {
         back?: string | IconDefinition;
@@ -660,6 +1190,7 @@ declare type TNodeDisplay = {
     data?: Record<string, unknown>;
     inspector?: string;
     interface?: Component_2 | string;
+    name?: string;
     priority?: number;
 };
 
@@ -678,19 +1209,7 @@ declare type TNodeDynamics<TInputs extends TNodeInterfaceDescriptor, TOutputs ex
     }) => Partial<TNodeInterfaceDescriptor>;
 };
 
-declare type TNodeExport = {
-    data?: Record<string, unknown>;
-    internal?: {
-        inputs?: Record<string, unknown>;
-        outputs?: Record<string, unknown>;
-    };
-    location: TVector;
-    logic: string;
-};
-
 declare type TNodeGenerated<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = {
-    name?: string;
-    type?: ELogicType;
     build?: {
         define?: Array<{
             id: (data: {
@@ -719,7 +1238,9 @@ declare type TNodeGenerated<TInputs extends TNodeInterfaceDescriptor, TOutputs e
     dynamics?: TNodeDynamics<TInputs, TOutputs, TConfig>;
     inputs: TInputs;
     methods: Partial<TMethodsOf<TInputs, TOutputs>>;
+    name?: string;
     outputs: TOutputs;
+    type?: ELogicType;
 };
 
 declare type TNodeInterfaceDescriptor = Record<string, TSchema>;
@@ -737,14 +1258,14 @@ declare type TNodeOptionals<TInputs extends TNodeInterfaceDescriptor, TOutputs e
 };
 
 declare interface TNumber {
-    type: EVarType.number;
     static: number;
+    type: EVarType.number;
 }
 
 declare interface TObject<T extends TProperties = TProperties> {
-    type: EVarType.object;
     properties: T;
     static: StaticObject<T>;
+    type: EVarType.object;
 }
 
 declare type TOnlyExecOf<TNodeInterfaceDescriptor> = {
@@ -755,96 +1276,57 @@ declare type TOnlyVarsOf<TNodeInterfaceDescriptor> = {
     [TAnchor in keyof TNodeInterfaceDescriptor as TNodeInterfaceDescriptor[TAnchor] extends TExec ? never : TAnchor]: TNodeInterfaceDescriptor[TAnchor];
 };
 
-declare type TOption<TParams = unknown, TResult = unknown> = TResult | ((env: TParams) => Promise<TResult> | TResult | undefined);
+declare type TOption<TParams = unknown, TResult = unknown> = TResult | ((env: TParams) => Promise<TResult> | TResult);
 
-export declare type TPlugin<TConfig extends TSchema = TSchema, TInternal = unknown> = {
-    build?: {
-        imports?: TOption<TEnv<TConfig, TInternal>, Array<{
-            name: string;
-            version?: string;
-        }>>;
-        plugins?: TOption<TEnv<TConfig, TInternal>, Array<PluginOption>>;
+export declare type TPlugin<TConfig extends TSchema = TSchema, TInternal = unknown, TBase extends TBasePlugin<TConfig, TInternal> = TBasePlugin<TConfig, TInternal>> = Omit<TBase, "build" | "editor" | "inject"> & {
+    [TCategory in "build" | "editor" | "inject"]?: {
+        [TKey in keyof NonNullable<TBase[TCategory]>]: TOption<TEnv<TConfig, TInternal>, NonNullable<TBase[TCategory]>[TKey]>;
     };
-    config?: TConfig;
-    dependencies?: Array<{
-        id: string;
-        name: string;
-        target: string;
-    }>;
-    description?: string;
-    editor?: {
-        components?: TOption<TEnv<TConfig, TInternal>, Array<TComponent>>;
-        nodes?: TOption<TEnv<TConfig, TInternal>, Array<TLogicNode>>;
-        templates?: TOption<TEnv<TConfig, TInternal>, Array<TTemplate>>;
-        tokens?: TOption<TEnv<TConfig, TInternal>, Array<TToken>>;
-        wrapper?: TOption<TEnv<TConfig, TInternal>, TComponent>;
-    };
-    icon: string;
-    id: string;
-    inject?: {
-        css?: TOption<TEnv<TConfig, TInternal>, string>;
-        js?: TOption<TEnv<TConfig, TInternal>, string>;
-    };
-    interface?: Component;
-    internal?: TInternal;
-    lifecycle?: {
-        mount?: (env: TEnv<TConfig, TInternal>) => Promise<void> | void;
-        unmount?: (env: TEnv<TConfig, TInternal>) => Promise<void> | void;
-        update?: (env: TEnv<TConfig, TInternal>) => Promise<void> | void;
-    };
-    name: string;
 };
 
 declare type TProperties = Record<string, TSchema>;
 
+export declare type TProxyPlugin<TConfig extends TSchema = TSchema, TInternal = unknown, TBase extends TBasePlugin<TConfig, TInternal> = TBasePlugin<TConfig, TInternal>> = Omit<TBase, "build" | "editor" | "inject"> & {
+    [TCategory in "build" | "editor" | "inject"]?: {
+        [TKey in keyof NonNullable<TBase[TCategory]>]: Promise<NonNullable<TBase[TCategory]>[TKey]>;
+    };
+};
+
 declare interface TRecord<TKey extends TString | TNumber = TString, TValue extends TSchema = TSchema> {
-    type: EVarType.record;
     key: TKey;
     static: StaticRecord<TKey, TValue>;
+    type: EVarType.record;
     value: TValue;
 }
 
-declare type TRouteExport = {
-    name: string;
-    type: EElementType.Route;
-    dev?: boolean;
-    input: {
-        body: TSchema;
-        headers: TSchema;
-        query: TSchema;
-    };
-    logics: Record<string, TLogicExport | TMainLogicExport>;
-    method: ERouteMethod;
-    output: TSchema;
-    path: string;
-    state: TStateExport;
+declare type TRect = {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
 };
 
-export declare type TSchema<TLogic extends TAnyLogic = TAnyLogic> = TArguments & TLogic;
-
-declare type TScriptExport = {
-    name: string;
-    type: EElementType.Script;
-    logics: Record<string, TLogicExport | TMainLogicExport>;
-    options?: {
-        autoReload?: boolean;
-    };
-    scope: ELogicScope;
-    state: TStateExport;
+declare type TReturnValue = {
+    schema: TSchema;
+    value: unknown;
 };
 
+export declare type TSchema<TLogic extends TAnyLogic_2 = TAnyLogic_2> = TArguments & TLogic;
+
 export declare type TSlot = TSchema<TObject> | TSchema<TVoid>;
 
-declare type TStateExport = Record<string, unknown>;
+declare type TStack = {
+    id: string;
+    config?: Record<string, unknown>;
+    context: object;
+    parent?: TStackParent;
+    variables: Record<string, unknown>;
+};
 
-declare type TStoreExport = {
-    name: string;
-    type: EElementType.Store;
-    default: unknown;
-    logics: Record<string, TLogicExport>;
-    options: TStoreOptions;
-    schema: TSchema;
-    state: TStateExport;
+declare type TStackParent = {
+    logic?: TLogic;
+    node?: CNode;
+    stack: TStack;
 };
 
 declare type TStoreOptions = {
@@ -852,24 +1334,19 @@ declare type TStoreOptions = {
 };
 
 declare interface TString {
-    type: EVarType.string;
     static: string;
+    type: EVarType.string;
 }
 
 export declare type TTemplate = {
     name: string;
     preview?: string;
-    template: TFileExport;
+    template: TFile<true>;
 };
 
-declare type TTextExport = {
-    name: string;
-    type: EElementType.Text;
-    blocks: Array<{
-        content: string;
-        key: string;
-    }>;
-    state: TStateExport;
+declare type TTextBlock = {
+    content: string;
+    key: string;
 };
 
 export declare type TToken = {
@@ -880,35 +1357,33 @@ export declare type TToken = {
 };
 
 declare interface TType<T extends TSchema = TSchema> {
-    type: EVarType.type;
     static: T;
     target: Array<string>;
+    type: EVarType.type;
 }
 
-declare type TTypeExport = {
-    name: string;
-    type: EElementType.Type;
-    schemas: Record<string, TSchema>;
-    state: TStateExport;
-};
-
 declare interface TUndefined {
-    type: EVarType.undefined;
     static: undefined;
+    type: EVarType.undefined;
 }
 
 declare interface TUnion<T extends Array<TSchema> = Array<TSchema>> {
-    type: EVarType.union;
     elements: T;
     static: StaticUnion<T>;
+    type: EVarType.union;
 }
 
 declare interface TUnknown {
-    type: EVarType.unknown;
     static: unknown;
+    type: EVarType.unknown;
 }
 
-declare type TValueExport = TSchema;
+declare type TValue<TExport extends boolean = false> = TExport extends false ? {
+    id: string;
+    isEditing?: boolean;
+    parent?: TLogic<TExport>;
+    schema: TSchema;
+} : TSchema;
 
 declare type TVector = {
     x: number;
@@ -916,11 +1391,18 @@ declare type TVector = {
 };
 
 declare interface TVoid {
-    type: EVarType.void;
     static: void;
+    type: EVarType.void;
 }
 
-declare type TWireExport = {
+declare type TWire = {
+    id: string;
+    from: Anchor.CAnchor;
+    temp?: boolean;
+    to: Anchor.CAnchor;
+};
+
+declare type TWire_2<TExport extends boolean = false> = TExport extends true ? {
     from: {
         key: string;
         node: string;
@@ -929,6 +1411,22 @@ declare type TWireExport = {
         key: string;
         node: string;
     };
-};
+} : CWire;
+
+declare namespace Wire {
+    export {
+        from,
+        create,
+        makePath,
+        pathToString,
+        TWire,
+        CPathPoint,
+        Path,
+        WIRE_PADDING,
+        CWire
+    }
+}
+
+declare const WIRE_PADDING = 6;
 
 export { }