@luna-park/plugin 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -1,11 +1,90 @@
-import { Component as Component_2 } from 'vue';
+import { Component } from 'vue';
 import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
 import { PluginOption } from 'vite';
 
-declare type Component = {
+declare type Component_2 = {
     name: string;
 };
 
+declare enum EComponentPreview {
+    Compact = "compact",
+    Stretch = "stretch",
+    Full = "full"
+}
+
+declare enum EComponentType {
+    Component = "component",
+    Page = "page"
+}
+
+declare enum EConfigDisplay {
+    Smart = "smart",
+    Performance = "performance"
+}
+
+declare enum EDynamicVariableOperation {
+    Equal = "equal",
+    Greater = "greater",
+    Less = "less",
+    StartsWith = "starts-with",
+    EndsWith = "ends-with",
+    Contains = "contains"
+}
+
+declare enum EDynamicVariableType {
+    Constant = "constant",
+    Dynamic = "dynamic",
+    Token = "token"
+}
+
+declare enum EElementType {
+    Script = "script",
+    Standalone = "standalone",
+    Folder = "folder",
+    MainLogic = "main",
+    Logic = "logic",
+    Config = "config",
+    Text = "text",
+    Store = "store",
+    Database = "database",
+    Component = "component",
+    Route = "route",
+    Type = "type",
+    Cron = "cron",
+    Media = "media"
+}
+
+declare enum EFileSortStrategy {
+    Name = "name",
+    Type = "type"
+}
+
+declare enum EHistoryMode {
+    Hash = "hash",
+    Web = "web",
+    Memory = "memory"
+}
+
+declare enum ELayoutElement {
+    input = "input",
+    div = "div",
+    media = "media",
+    customText = "customText",
+    component = "component",
+    package = "package",
+    customHtml = "customHtml",
+    slot = "slot",
+    template = "template",
+    variable = "variable",
+    widget = "widget"
+}
+
+declare enum ELogicMode {
+    Pure = "pure",
+    Macro = "macro",
+    Code = "code"
+}
+
 export declare enum ELogicScope {
     Frontend = "frontend",
     Backend = "backend",
@@ -19,12 +98,46 @@ export declare enum ELogicType {
     operation = "operation"
 }
 
+declare enum EResponsiveStrategy {
+    DesktopFirst = "desktop-first",
+    MobileFirst = "mobile-first"
+}
+
+declare enum ERouteMethod {
+    Get = "get",
+    Post = "post",
+    Put = "put",
+    Delete = "delete"
+}
+
+declare enum EStoreType {
+    Memory = "memory",
+    Session = "session",
+    Local = "local"
+}
+
+declare enum EThemeMode {
+    Dark = "dark",
+    Light = "light",
+    Auto = "auto"
+}
+
+declare enum ETokenType {
+    Color = "color",
+    FontSize = "font-size",
+    FontWeight = "font-weight",
+    FontFamily = "font-family",
+    Length = "length",
+    Time = "time"
+}
+
 export declare enum EVarType {
     exec = "exec",
     number = "number",
     string = "string",
     boolean = "boolean",
     object = "object",
+    record = "record",
     array = "array",
     interface = "interface",
     type = "type",
@@ -42,10 +155,11 @@ export 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>(inputs: TInputs, output?: TOutput, args?: TArguments) => TFunction<TInputs, TOutput>;
+    function: <TInputs extends TObject, TOutput extends TSchema = TUndefined>(inputs?: TInputs, output?: TOutput, args?: TArguments) => TFunction<TInputs, TOutput>;
     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>;
     string: <TArgs extends TArguments<string>>(args?: TArgs) => TString & TArgs;
     undefined: (args?: TArguments) => TUndefined;
     union: <T extends Array<TSchema>>(elements: T, args?: TArguments) => TUnion<T>;
@@ -53,6 +167,14 @@ export declare const LogicType: {
     void: (args?: TArguments) => TVoid;
 };
 
+export 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;
+};
+
 export declare function makeLogicNode<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor>(node: TNodeDescriptor<TInputs, TOutputs, TConfig>): TLogicNode;
 
 export declare function makePlugin<TConfig extends TSchema, TInternal>(plugin: TPlugin<TConfig, TInternal>): TPlugin<TConfig, TInternal>;
@@ -81,11 +203,98 @@ declare type StaticObject<T extends TProperties> = {
     [K in OptionalKeys<T>]?: Static<T[K]>;
 };
 
+declare type StaticRecord<TKey extends TSchema, TValue extends TSchema> = Record<Static<TKey>, Static<TValue>>;
+
 declare type StaticUnion<T extends Array<TSchema>> = {
     [K in keyof T]: Static<T[K]>;
 }[number];
 
-declare type TAllLogic = TExec | TObject | TInterface | TType | TArray<any> | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion<any> | TFunction<any, any> | TVoid;
+declare type TAnchorExport = TSchema;
+
+declare type TAnyLogic = TExec | TObject | TRecord<any, any> | TInterface | TType | TArray<any> | TString | TNumber | TBoolean | TUnknown | TUndefined | TUnion<any> | TFunction<any, any> | TVoid;
+
+declare type TApplicationConfig = {
+    backend: {
+        proxy: string;
+        salt: string;
+    };
+    database: {
+        type: string;
+    };
+    description?: string;
+    desktop: {
+        fullscreen: boolean;
+        height: number;
+        resizable: boolean;
+        version: string;
+        width: number;
+    };
+    libraries: Record<string, boolean>;
+    packages: Record<string, {
+        name: string;
+        components: TExportNodeResult["components"];
+        description?: string;
+        functions: TExportNodeResult["functions"];
+        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;
+                name: string;
+                value: string;
+            }>;
+            fonts: Array<{
+                id: string;
+                name: string;
+                value: string;
+            }>;
+            lengths: Array<{
+                id: string;
+                name: string;
+                value: string;
+            }>;
+        };
+    };
+    plugins: Record<string, {
+        config?: unknown;
+        internal?: unknown;
+        target: string;
+    }>;
+    state: {
+        currentTab: string;
+        explorerSort: EFileSortStrategy;
+        tabs: Array<string>;
+    };
+    style: {
+        strategy: EResponsiveStrategy;
+    };
+    web: {
+        history: EHistoryMode;
+        pwa: boolean;
+    };
+};
+
+declare type TApplicationExport = {
+    name: string;
+    config: TApplicationConfig;
+    tree: TFileExport;
+};
 
 declare interface TArguments<TType = any> {
     name?: string;
@@ -111,6 +320,8 @@ declare interface TArguments<TType = any> {
     parse?: (arg: unknown) => unknown;
     placeholder?: string;
     priority?: boolean;
+    promise?: boolean;
+    required?: boolean;
     static?: unknown;
     sub?: TSchema;
 }
@@ -126,18 +337,77 @@ declare interface TBoolean {
     static: boolean;
 }
 
-declare type TComponent = {
-    name: string;
-    attribute?: Record<string, TLogicNode>;
-    component: Component_2;
+declare type TCanvasExport = {
+    location: TVector;
+    zoom: number;
+};
+
+export declare type TComponent = {
+    component: Component;
     custom?: {
         slots: (attributes: Record<string, unknown>) => Record<string, false | TSchema>;
     };
+    emits?: Record<string, TSchema>;
     import?: Array<{
         name: string;
         target: string;
     }>;
-    slots?: Record<string, false | TSchema>;
+    models?: Record<string, TSchema>;
+    name: string;
+    properties?: Record<string, TSchema>;
+    slots?: Record<string, TSchema<TObject> | TSchema<TVoid>>;
+};
+
+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>;
+    };
+};
+
+declare type TComponentOptions = {
+    type: EComponentType;
+    path: string;
+    preview: EComponentPreview;
+    previewSize: string;
+};
+
+declare type TConfigExport = {
+    name: string;
+    type: EElementType.Config;
+    content: unknown;
+    display: EConfigDisplay;
+    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 = {
@@ -158,9 +428,22 @@ declare type TDocumentation = {
     }>;
 };
 
+declare type TDynamicVariable = {
+    type: EDynamicVariableType;
+    access: Array<string>;
+    target: {
+        invert?: boolean;
+        operation: EDynamicVariableOperation;
+        variable?: TDynamicVariable;
+    };
+    token: string;
+    value: unknown;
+};
+
 declare type TEnum<TEnumType> = Array<TEnumType> | Record<string, TEnumType>;
 
 declare type TEnv<TConfig extends TSchema = TSchema, TInternal = unknown> = {
+    app: TApplicationExport;
     config: Static<TConfig>;
     internal: TInternal;
     mode: "build" | "editor";
@@ -170,6 +453,33 @@ declare interface TExec {
     type: EVarType.exec;
 }
 
+declare type TExportNodeFunction = {
+    name?: string;
+    description?: string;
+    parameters?: Array<TSchema>;
+    return?: TSchema;
+};
+
+declare type TExportNodeResult = {
+    components: Record<string, {
+        properties: Record<string, TSchema>;
+        slots: Record<string, TSchema>;
+    }>;
+    functions: Record<string, TExportNodeFunction>;
+    types: Record<string, TSchema>;
+};
+
+declare type TFileExport = (TFolderExport | TComponentExport | TConfigExport | TCronExport | TDatabaseExport | TRouteExport | TScriptExport | TStoreExport | TTextExport | TTypeExport | TMediaExport) & {
+    isEditing?: boolean;
+};
+
+declare type TFolderExport = {
+    name: string;
+    type: EElementType.Folder;
+    children: Record<string, TFileExport>;
+    color?: string;
+};
+
 declare interface TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TUnknown> {
     type: EVarType.function;
     inputs: TInputs;
@@ -177,6 +487,12 @@ declare interface TFunction<TInputs extends TObject = TObject, TOutput extends T
     static: StaticFunction<TInputs, TOutput>;
 }
 
+declare type TGraphExport = {
+    canvas: TCanvasExport;
+    nodes: Record<string, TNodeExport>;
+    wires: Record<string, TWireExport>;
+};
+
 declare interface TInterface<T = unknown> {
     type: EVarType.interface;
     class?: new (...args: any) => T;
@@ -184,7 +500,38 @@ declare interface TInterface<T = unknown> {
     static: T;
 }
 
-declare type TLogicNode = {
+declare type TLayoutSchemaExport = {
+    id: string;
+    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;
+    type: EElementType.Logic | EElementType.Standalone;
+    code?: string;
+    export: boolean;
+    graph: TGraphExport;
+    inputs: Record<string, TAnchorExport>;
+    mode: ELogicMode;
+    outputs: Record<string, TAnchorExport>;
+    packages?: Array<string>;
+    values: {
+        variables: Record<string, TValueExport>;
+    };
+};
+
+export declare type TLogicNode = {
     name: string;
     type?: ELogicType;
     build?: {
@@ -229,6 +576,22 @@ declare type TLogicNode = {
     outputs: TNodeInterfaceDescriptor;
 };
 
+declare type TMainLogicExport = {
+    name: "Main";
+    type: EElementType.MainLogic;
+    graph: TGraphExport;
+    values: {
+        variables: Record<string, TValueExport>;
+    };
+};
+
+declare type TMediaExport = {
+    name: string;
+    type: EElementType.Media;
+    mimeType: string;
+    target: string;
+};
+
 declare type TMethodsOf<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = MethodsFrom<TOnlyExecOf<TInputs>> & MethodsFrom<TOnlyVarsOf<TOutputs>>;
 
 declare type TNodeConfigDescriptor = Record<string, TSchema>;
@@ -282,10 +645,10 @@ declare type TNodeDisplay = {
         scope?: ELogicScope;
         transparent?: boolean;
     };
-    custom?: Component | string;
+    custom?: Component_2 | string;
     data?: Record<string, unknown>;
     inspector?: string;
-    interface?: Component | string;
+    interface?: Component_2 | string;
     priority?: number;
 };
 
@@ -304,6 +667,16 @@ 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;
@@ -374,8 +747,6 @@ declare type TOnlyVarsOf<TNodeInterfaceDescriptor> = {
 declare type TOption<TParams = unknown, TResult = unknown> = TResult | ((env: TParams) => Promise<TResult> | TResult | undefined);
 
 export declare type TPlugin<TConfig extends TSchema = TSchema, TInternal = unknown> = {
-    id: string;
-    name: string;
     build?: {
         imports?: TOption<TEnv<TConfig, TInternal>, Array<{
             name: string;
@@ -391,39 +762,114 @@ export declare type TPlugin<TConfig extends TSchema = TSchema, TInternal = unkno
     }>;
     description?: string;
     editor?: {
-        components?: TOption<TEnv<TConfig, TInternal>, Array<TLogicNode>>;
-        nodes?: TOption<TEnv<TConfig, TInternal>, Array<TComponent>>;
-        wrapper?: TOption<TEnv<TConfig, TInternal>, Component_2>;
+        components?: TOption<TEnv<TConfig, TInternal>, Array<TComponent>>;
+        nodes?: TOption<TEnv<TConfig, TInternal>, Array<TLogicNode>>;
+        tokens?: TOption<TEnv<TConfig, TInternal>, Record<ETokenType, Record<string, TToken>>>;
+        wrapper?: TOption<TEnv<TConfig, TInternal>, Component>;
     };
     icon: string;
+    id: string;
     inject?: {
         css?: TOption<TEnv<TConfig, TInternal>, string>;
         js?: TOption<TEnv<TConfig, TInternal>, string>;
     };
-    interface?: Component_2;
+    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>;
 
-declare type TSchema<TLogic extends TAllLogic = TAllLogic> = TArguments & TLogic;
+declare interface TRecord<TKey extends TString | TNumber = TString, TValue extends TSchema = TSchema> {
+    type: EVarType.record;
+    key: TKey;
+    static: StaticRecord<TKey, TValue>;
+    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;
+};
+
+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 TStateExport = 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 TStoreOptions = {
+    type: EStoreType;
+};
 
 declare interface TString {
     type: EVarType.string;
     static: string;
 }
 
+declare type TTextExport = {
+    name: string;
+    type: EElementType.Text;
+    blocks: Array<{
+        content: string;
+        key: string;
+    }>;
+    state: TStateExport;
+};
+
+declare type TToken = {
+    name?: string;
+    value: string;
+};
+
 declare interface TType<T extends TSchema = TSchema> {
     type: EVarType.type;
     static: T;
     target: Array<string>;
 }
 
+declare type TTypeExport = {
+    name: string;
+    type: EElementType.Type;
+    schemas: Record<string, TSchema>;
+    state: TStateExport;
+};
+
 declare interface TUndefined {
     type: EVarType.undefined;
     static: undefined;
@@ -440,9 +886,27 @@ declare interface TUnknown {
     static: unknown;
 }
 
+declare type TValueExport = TSchema;
+
+declare type TVector = {
+    x: number;
+    y: number;
+};
+
 declare interface TVoid {
     type: EVarType.void;
     static: void;
 }
 
+declare type TWireExport = {
+    from: {
+        key: string;
+        node: string;
+    };
+    to: {
+        key: string;
+        node: string;
+    };
+};
+
 export { }