@luna-park/plugin 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,448 @@
+import { Component as Component_2 } from 'vue';
+import { IconDefinition } from '@fortawesome/fontawesome-svg-core';
+import { PluginOption } from 'vite';
+
+declare type Component = {
+    name: string;
+};
+
+export declare enum ELogicScope {
+    Frontend = "frontend",
+    Backend = "backend",
+    Desktop = "desktop",
+    Shared = "shared"
+}
+
+export declare enum ELogicType {
+    function = "function",
+    macro = "macro",
+    operation = "operation"
+}
+
+export declare enum EVarType {
+    exec = "exec",
+    number = "number",
+    string = "string",
+    boolean = "boolean",
+    object = "object",
+    array = "array",
+    interface = "interface",
+    type = "type",
+    function = "function",
+    union = "union",
+    unknown = "unknown",
+    undefined = "undefined",
+    void = "void"
+}
+
+export declare function getPluginParam<T>(target: TOption<TEnv, T>, env: Partial<TEnv>): Promise<T>;
+
+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>;
+    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;
+    string: <TArgs extends TArguments<string>>(args?: TArgs) => TString & TArgs;
+    undefined: (args?: TArguments) => TUndefined;
+    union: <T extends Array<TSchema>>(elements: T, args?: TArguments) => TUnion<T>;
+    unknown: <TArgs extends TArguments<unknown>>(args?: TArgs) => TUnknown & TArgs;
+    void: (args?: TArguments) => TVoid;
+};
+
+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>;
+
+declare type MethodsFrom<TInterface extends TNodeInterfaceDescriptor> = {
+    [TKey in keyof TInterface]: () => Promise<Static<TInterface[TKey]>> | Static<TInterface[TKey]>;
+};
+
+declare type OptionalKeys<T extends TProperties> = {
+    [K in keyof T]: T[K] extends {
+        optional: true;
+    } ? K : never;
+}[keyof T];
+
+declare type RequiredKeys<T extends TProperties> = Exclude<keyof T, OptionalKeys<T>>;
+
+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 StaticObject<T extends TProperties> = {
+    [K in RequiredKeys<T>]: Static<T[K]>;
+} & {
+    [K in OptionalKeys<T>]?: Static<T[K]>;
+};
+
+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 interface TArguments<TType = any> {
+    name?: string;
+    build?: (arg: unknown) => unknown;
+    customizable?: boolean;
+    default?: 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;
+    optional?: boolean;
+    options?: {
+        format?: (arg: TType) => TType;
+        freeze?: boolean;
+    } & Record<string, unknown>;
+    parse?: (arg: unknown) => unknown;
+    placeholder?: string;
+    priority?: boolean;
+    static?: unknown;
+    sub?: TSchema;
+}
+
+declare interface TArray<T extends TSchema = TSchema> {
+    type: EVarType.array;
+    items: T;
+    static: Array<Static<T>>;
+}
+
+declare interface TBoolean {
+    type: EVarType.boolean;
+    static: boolean;
+}
+
+declare type TComponent = {
+    name: string;
+    attribute?: Record<string, TLogicNode>;
+    component: Component_2;
+    custom?: {
+        slots: (attributes: Record<string, unknown>) => Record<string, false | TSchema>;
+    };
+    import?: Array<{
+        name: string;
+        target: string;
+    }>;
+    slots?: Record<string, false | TSchema>;
+};
+
+declare type TDocumentation = {
+    description?: string;
+    examples?: Array<{
+        inputs: Array<{
+            key: string;
+            value: unknown;
+        }>;
+        outputs: Array<{
+            key: string;
+            value: unknown;
+        }>;
+    }>;
+    parameters?: Array<{
+        name: string;
+        description: string;
+    }>;
+};
+
+declare type TEnum<TEnumType> = Array<TEnumType> | Record<string, TEnumType>;
+
+declare type TEnv<TConfig extends TSchema = TSchema, TInternal = unknown> = {
+    config: Static<TConfig>;
+    internal: TInternal;
+    mode: "build" | "editor";
+};
+
+declare interface TExec {
+    type: EVarType.exec;
+}
+
+declare interface TFunction<TInputs extends TObject = TObject, TOutput extends TSchema = TUnknown> {
+    type: EVarType.function;
+    inputs: TInputs;
+    output: TOutput;
+    static: StaticFunction<TInputs, TOutput>;
+}
+
+declare interface TInterface<T = unknown> {
+    type: EVarType.interface;
+    class?: new (...args: any) => T;
+    className: string;
+    static: T;
+}
+
+declare type TLogicNode = {
+    name: string;
+    type?: ELogicType;
+    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>;
+    outputs: TNodeInterfaceDescriptor;
+};
+
+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> = {
+    internal?: unknown;
+} & {
+    [TKey in keyof TConfig]: Static<TConfig[TKey]>;
+};
+
+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>;
+} & {
+    [TKey in keyof TOnlyVarsOf<TInputs>]: Static<TInputs[TKey]>;
+} & {
+    [TKey in keyof TOnlyVarsOf<TOutputs>]: Static<TOutputs[TKey]>;
+} & Record<`internal_${string}`, unknown> & {
+    arguments: Promise<Array<unknown>>;
+    config: {
+        [TKey in keyof TConfig]: Static<TConfig[TKey]>;
+    };
+    properties: Record<string, {
+        name: string;
+        value: Promise<unknown>;
+    }>;
+    stack: any;
+}>;
+
+declare type TNodeDisplay = {
+    name?: string;
+    altSearch?: string;
+    config?: {
+        back?: string | IconDefinition;
+        data?: {
+            size?: {
+                x: number;
+                y: number;
+            };
+        };
+        dependency?: () => void;
+        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;
+    priority?: number;
+};
+
+declare 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>;
+};
+
+declare type TNodeGenerated<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor, TConfig extends TNodeConfigDescriptor> = {
+    name?: string;
+    type?: ELogicType;
+    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>>;
+    outputs: TOutputs;
+};
+
+declare type TNodeInterfaceDescriptor = Record<string, TSchema>;
+
+declare type TNodeIOSchema<TInterface extends TNodeInterfaceDescriptor> = {
+    [TKey in keyof TOnlyVarsOf<TInterface>]: {
+        linked: boolean;
+        schema: TOnlyVarsOf<TInterface>[TKey];
+        value: Static<TOnlyVarsOf<TInterface>[TKey]>;
+    };
+};
+
+declare type TNodeOptionals<TInputs extends TNodeInterfaceDescriptor, TOutputs extends TNodeInterfaceDescriptor> = {
+    [TKey in keyof (TOnlyVarsOf<TInputs> | TOnlyVarsOf<TOutputs>)]: boolean;
+};
+
+declare interface TNumber {
+    type: EVarType.number;
+    static: number;
+}
+
+declare interface TObject<T extends TProperties = TProperties> {
+    type: EVarType.object;
+    properties: T;
+    static: StaticObject<T>;
+}
+
+declare type TOnlyExecOf<TNodeInterfaceDescriptor> = {
+    [TAnchor in keyof TNodeInterfaceDescriptor as TNodeInterfaceDescriptor[TAnchor] extends TExec ? TAnchor : never]: TNodeInterfaceDescriptor[TAnchor];
+};
+
+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);
+
+export declare type TPlugin<TConfig extends TSchema = TSchema, TInternal = unknown> = {
+    id: string;
+    name: string;
+    build?: {
+        imports?: TOption<TEnv<TConfig, TInternal>, Array<{
+            name: string;
+            version?: string;
+        }>>;
+        plugins?: TOption<TEnv<TConfig, TInternal>, Array<PluginOption>>;
+    };
+    config?: TConfig;
+    dependencies?: Array<{
+        id: string;
+        name: string;
+        target: string;
+    }>;
+    description?: string;
+    editor?: {
+        components?: TOption<TEnv<TConfig, TInternal>, Array<TLogicNode>>;
+        nodes?: TOption<TEnv<TConfig, TInternal>, Array<TComponent>>;
+        wrapper?: TOption<TEnv<TConfig, TInternal>, Component_2>;
+    };
+    icon: string;
+    inject?: {
+        css?: TOption<TEnv<TConfig, TInternal>, string>;
+        js?: TOption<TEnv<TConfig, TInternal>, string>;
+    };
+    interface?: Component_2;
+    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;
+    };
+};
+
+declare type TProperties = Record<string, TSchema>;
+
+declare type TSchema<TLogic extends TAllLogic = TAllLogic> = TArguments & TLogic;
+
+declare interface TString {
+    type: EVarType.string;
+    static: string;
+}
+
+declare interface TType<T extends TSchema = TSchema> {
+    type: EVarType.type;
+    static: T;
+    target: Array<string>;
+}
+
+declare interface TUndefined {
+    type: EVarType.undefined;
+    static: undefined;
+}
+
+declare interface TUnion<T extends Array<TSchema> = Array<TSchema>> {
+    type: EVarType.union;
+    elements: T;
+    static: StaticUnion<T>;
+}
+
+declare interface TUnknown {
+    type: EVarType.unknown;
+    static: unknown;
+}
+
+declare interface TVoid {
+    type: EVarType.void;
+    static: void;
+}
+
+export { }

package/dist/index.js

@@ -0,0 +1,74 @@
+var i = /* @__PURE__ */ ((e) => (e.exec = "exec", e.number = "number", e.string = "string", e.boolean = "boolean", e.object = "object", e.array = "array", e.interface = "interface", e.type = "type", e.function = "function", e.union = "union", e.unknown = "unknown", e.undefined = "undefined", e.void = "void", e))(i || {});
+const t = {
+  type: (e, n = {}) => ({ ...n, type: "type", target: e }),
+  array: (e, n = {}) => ({ ...n, type: "array", items: e }),
+  boolean: (e = {}) => ({
+    ...e,
+    type: "boolean"
+    /* boolean */
+  }),
+  exec: (e = {}) => ({
+    ...e,
+    type: "exec"
+    /* exec */
+  }),
+  function: (e, n = {
+    type: "undefined"
+    /* undefined */
+  }, o = {}) => ({ ...o, type: "function", inputs: e, output: n }),
+  interface: (e, n = {}) => ({
+    ...n,
+    type: "interface",
+    className: typeof e == "string" ? e : e.name
+  }),
+  number: (e = {}) => ({
+    ...e,
+    type: "number"
+    /* number */
+  }),
+  object: (e = {}, n = {}) => ({ ...n, type: "object", properties: e }),
+  string: (e = {}) => ({
+    ...e,
+    type: "string"
+    /* string */
+  }),
+  undefined: (e = {}) => ({
+    ...e,
+    type: "undefined"
+    /* undefined */
+  }),
+  union: (e, n = {}) => ({ ...n, type: "union", elements: e }),
+  unknown: (e = {}) => ({
+    ...e,
+    type: "unknown"
+    /* unknown */
+  }),
+  void: (e = {}) => ({
+    ...e,
+    type: "void"
+    /* void */
+  })
+};
+var r = /* @__PURE__ */ ((e) => (e.function = "function", e.macro = "macro", e.operation = "operation", e))(r || {}), a = /* @__PURE__ */ ((e) => (e.Frontend = "frontend", e.Backend = "backend", e.Desktop = "desktop", e.Shared = "shared", e))(a || {});
+function u(e) {
+  return e;
+}
+function c(e) {
+  return e;
+}
+async function p(e, n) {
+  return typeof e == "function" ? e({
+    config: n.config,
+    internal: n.internal,
+    mode: n.mode || "editor"
+  }) : e;
+}
+export {
+  a as ELogicScope,
+  r as ELogicType,
+  i as EVarType,
+  t as LogicType,
+  p as getPluginParam,
+  u as makeLogicNode,
+  c as makePlugin
+};

package/dist/index.umd.cjs

@@ -0,0 +1 @@
+(function(i,o){typeof exports=="object"&&typeof module<"u"?o(exports):typeof define=="function"&&define.amd?define(["exports"],o):(i=typeof globalThis<"u"?globalThis:i||self,o(i["@luna-park/plugin"]={}))})(this,(function(i){"use strict";var o=(e=>(e.exec="exec",e.number="number",e.string="string",e.boolean="boolean",e.object="object",e.array="array",e.interface="interface",e.type="type",e.function="function",e.union="union",e.unknown="unknown",e.undefined="undefined",e.void="void",e))(o||{});const r={type:(e,n={})=>({...n,type:"type",target:e}),array:(e,n={})=>({...n,type:"array",items:e}),boolean:(e={})=>({...e,type:"boolean"}),exec:(e={})=>({...e,type:"exec"}),function:(e,n={type:"undefined"},d={})=>({...d,type:"function",inputs:e,output:n}),interface:(e,n={})=>({...n,type:"interface",className:typeof e=="string"?e:e.name}),number:(e={})=>({...e,type:"number"}),object:(e={},n={})=>({...n,type:"object",properties:e}),string:(e={})=>({...e,type:"string"}),undefined:(e={})=>({...e,type:"undefined"}),union:(e,n={})=>({...n,type:"union",elements:e}),unknown:(e={})=>({...e,type:"unknown"}),void:(e={})=>({...e,type:"void"})};var t=(e=>(e.function="function",e.macro="macro",e.operation="operation",e))(t||{}),u=(e=>(e.Frontend="frontend",e.Backend="backend",e.Desktop="desktop",e.Shared="shared",e))(u||{});function a(e){return e}function c(e){return e}async function f(e,n){return typeof e=="function"?e({config:n.config,internal:n.internal,mode:n.mode||"editor"}):e}i.ELogicScope=u,i.ELogicType=t,i.EVarType=o,i.LogicType=r,i.getPluginParam=f,i.makeLogicNode=a,i.makePlugin=c,Object.defineProperty(i,Symbol.toStringTag,{value:"Module"})}));

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@luna-park/plugin",
+  "version": "1.0.0",
+  "private": false,
+  "description": "Plugin helper for Luna Park.",
+  "homepage": "https://luna-park.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lunapark"
+  },
+  "author": {
+    "name": "Luna Park",
+    "url": "https://luna-park.app"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.umd.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.umd.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**"
+  ],
+  "dependencies": {
+    "vue": "^3.5.23",
+    "@luna-park/logicnodes": "^2.0.0"
+  },
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.39.1",
+    "@microsoft/api-extractor": "^7.54.0",
+    "@vitest/ui": "^4.0.7",
+    "eslint": "^9.39.1",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import-x": "^4.16.1",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-sort-keys-custom-order": "^2.2.1",
+    "rimraf": "^6.1.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.3",
+    "unplugin-dts": "1.0.0-beta.6",
+    "vite": "^7.2.1",
+    "vite-plugin-dts": "4.5.4",
+    "vitest": "^4.0.7"
+  },
+  "peerDependencies": {
+    "vue": "^3.5.23"
+  },
+  "scripts": {
+    "build": "rimraf dist && vite build",
+    "dev": "vite build --watch",
+    "dev:test": "vitest --ui",
+    "test": "vitest"
+  }
+}