@babsey/code-graph 0.10.1 → 0.11.0

package/dist/code.d.ts

@@ -21,7 +21,6 @@ export declare class Code {
     set lockCode(value: boolean);
     get modules(): string[];
     get script(): string;
-    set script(value: string);
     get shortId(): string;
     get state(): UnwrapRef<ICodeState>;
     /**

package/dist/codeGraph/codeGraph.d.ts

@@ -23,7 +23,7 @@ export declare class CodeGraph extends Graph implements IBaklavaEventEmitter, IB
     get connections(): Connection[];
     set connections(values: Connection[]);
     get nodeIds(): string[];
-    get nodes(): AbstractCodeNode[];
+    get nodes(): readonly AbstractCodeNode[];
     set nodes(values: AbstractCodeNode[]);
     get scriptedCodeNodes(): AbstractCodeNode[];
     get selectedNodeIds(): string[];
@@ -34,6 +34,7 @@ export declare class CodeGraph extends Graph implements IBaklavaEventEmitter, IB
      * Add code node to graph.
      * @param node code node
      * @param props optional
+     * @returns code node intstance
      */
     addNode(node: AbstractCodeNode, props?: unknown): AbstractCodeNode | undefined;
     /**
@@ -41,15 +42,16 @@ export declare class CodeGraph extends Graph implements IBaklavaEventEmitter, IB
      * @param node code node
      * @param position position
      * @param props optional
-     * @returns code node
+     * @returns code node instance
      */
     addNodeAtCoordinates: (node: AbstractCodeNode, position?: IPosition, props?: unknown) => AbstractCodeNode;
     /**
      * Add connection of code nodes
      * @param from code node interface
      * @param to code node interface
+     * @returns connection intstance
      */
-    addConnection(from: CodeNodeInterface, to: CodeNodeInterface): void;
+    addConnection(from: CodeNodeInterface, to: CodeNodeInterface): Connection | undefined;
     /**
      * Execute calls of nodes before running graph.
      */

package/dist/codeNode/codeNode.d.ts

@@ -1,7 +1,7 @@
 import { AbstractNode, NodeInterface, CalculateFunction, CalculateFunctionReturnType, INodeState, NodeInterfaceDefinition } from '@baklavajs/core';
 import { UnwrapRef } from 'vue';
 import { Code } from '../code';
-import { CodeNodeInputInterface, CodeNodeInterface, CodeNodeOutputInterface } from '../codeNodeInterfaces';
+import { CodeNodeInterface, CodeNodeInputInterface, CodeNodeOutputInterface } from '../codeNodeInterfaces';
 import { CodeGraph } from '../codeGraph';
 export interface IAbstractCodeNodeState {
     codeTemplate: string;
@@ -128,11 +128,6 @@ export declare abstract class CodeNode<I, O> extends AbstractCodeNode {
     calculate?: CalculateFunction<I, O>;
     executeFactory<V, T extends InterfaceFactory<V>>(type: "input" | "output", factory?: T): void;
     load(state: ICodeNodeState<I, O>): void;
+    save(): ICodeNodeState<I, O>;
 }
 export type AbstractCodeNodeConstructor = new () => AbstractCodeNode;
-/**
- * Format inputs for mustache templates.
- * @param intfs code node input interfaces
- * @returns a list of string
- */
-export declare const formatInputs: (intfs: Record<string, CodeNodeInputInterface>, withKeywords?: boolean) => string[];

package/dist/codeNodeInterfaces/checkbox/checkboxInterface.d.ts

@@ -1,5 +1,8 @@
+import { ComponentOptions } from 'vue';
 import { CodeNodeInputInterface } from '../codeNodeInput/codeNodeInputInterface';
 export declare class CheckboxInterface extends CodeNodeInputInterface<boolean> {
+    component: ComponentOptions;
+    componentName: string;
     constructor(name: string, value: boolean);
     getValue: () => string;
 }

package/dist/codeNodeInterfaces/codeNode/codeNodeInterface.d.ts

@@ -1,16 +1,17 @@
 import { NodeInterface, INodeInterfaceState } from '@baklavajs/core';
-import { UnwrapRef } from 'vue';
+import { ComponentOptions, UnwrapRef } from 'vue';
+import { AbstractCodeNode } from '../../codeNode';
 import { Code } from '../../code';
 export interface ICodeNodeInterfaceRefState {
     optional: boolean;
 }
 export declare class CodeNodeInterface<T = unknown> extends NodeInterface<T> {
+    component: ComponentOptions;
     isCodeNode: boolean;
     code: Code | undefined;
     componentName: string;
     state: UnwrapRef<ICodeNodeInterfaceRefState>;
     type: string | null;
-    constructor(name: string, value: T);
     get optional(): boolean;
     get shortId(): string;
     getValue: () => string;
@@ -18,3 +19,4 @@ export declare class CodeNodeInterface<T = unknown> extends NodeInterface<T> {
     save(): INodeInterfaceState<T>;
     setOptional(value: boolean): this;
 }
+export declare const addCodeInterfaces: (codeNode: AbstractCodeNode) => void;

package/dist/codeNodeInterfaces/codeNodeInput/codeNodeInputInterface.d.ts

@@ -1,5 +1,7 @@
+import { ComponentOptions } from 'vue';
 import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
 export declare class CodeNodeInputInterface<T = unknown> extends CodeNodeInterface<T> {
+    component: ComponentOptions;
     constructor(name?: string, value?: T);
     get value(): T;
     set value(value: T);

package/dist/codeNodeInterfaces/codeNodeOutput/codeNodeOutputInterface.d.ts

@@ -1,9 +1,11 @@
+import { ComponentOptions } from 'vue';
 import { AbstractCodeNode } from '../../codeNode';
 import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
-export declare class CodeNodeOutputInterface extends CodeNodeInterface<string> {
+export declare class CodeNodeOutputInterface extends CodeNodeInterface<unknown> {
+    component: ComponentOptions;
     isCodeNodeOutput: boolean;
     suffix: string;
-    constructor(name?: string, value?: string);
+    constructor(name?: string, suffix?: string);
     get codeValue(): string;
     get node(): AbstractCodeNode | undefined;
 }

package/dist/codeNodeInterfaces/createInterface.d.ts

@@ -1,12 +1,13 @@
-import { CheckboxInterface, IntegerInterface, ListInputInterface, NumberInterface, SelectInterface, TextInputInterface, TupleInputInterface } from '.';
+import { SelectInterfaceItem } from '@baklavajs/renderer-vue';
+import { CheckboxInterface, IntegerInterface, ListInputInterface, NumberInterface, SelectInterface, SliderInterface, TextInputInterface, TupleInputInterface } from '.';
 export interface IInterfaceProps {
     forceUpdate?: boolean;
     hidden?: boolean;
     id: string;
-    items?: string[];
+    items?: SelectInterfaceItem<unknown>[];
     max?: number;
     min?: number;
     name?: string;
     value: unknown;
 }
-export declare const createInterface: (name: string, interfaceProps: IInterfaceProps) => CheckboxInterface | IntegerInterface | ListInputInterface | NumberInterface | SelectInterface<number> | TupleInputInterface | TextInputInterface;
+export declare const createInterface: (name: string, interfaceProps: IInterfaceProps) => CheckboxInterface | IntegerInterface | ListInputInterface | NumberInterface | SelectInterface<unknown> | SliderInterface | TupleInputInterface | TextInputInterface;

package/dist/codeNodeInterfaces/formatInputs.d.ts

@@ -0,0 +1,7 @@
+import { CodeNodeInputInterface } from '../main';
+/**
+ * Format inputs for mustache templates.
+ * @param intfs code node input interfaces
+ * @returns a list of string
+ */
+export declare const formatInputs: (intfs: Record<string, CodeNodeInputInterface>, withKeywords?: boolean) => string[];

package/dist/codeNodeInterfaces/index.d.ts

@@ -1,4 +1,5 @@
 export * from './createInterface';
+export * from './formatInputs';
 export * from './checkbox/checkboxInterface';
 export * from './codeNode/codeNodeInterface';
 export * from './codeNodeInput/codeNodeInputInterface';

package/dist/codeNodeInterfaces/integer/integerInterface.d.ts

@@ -1,5 +1,7 @@
+import { ComponentOptions } from 'vue';
 import { BaseNumericInterface } from '../baseNumericInterface';
 export declare class IntegerInterface extends BaseNumericInterface {
-    constructor(name: string, value?: number);
+    component: ComponentOptions;
+    componentName: string;
     validate(v: number): boolean;
 }

package/dist/codeNodeInterfaces/listInput/listInputInterface.d.ts

@@ -1,5 +1,8 @@
+import { ComponentOptions } from 'vue';
 import { CodeNodeInputInterface } from '../codeNodeInput/codeNodeInputInterface';
 export declare class ListInputInterface extends CodeNodeInputInterface {
+    component: ComponentOptions;
+    componentName: string;
     constructor(name: string, value?: string);
     getValue: () => string;
 }

package/dist/codeNodeInterfaces/number/numberInterface.d.ts

@@ -2,4 +2,5 @@ import { ComponentOptions } from 'vue';
 import { BaseNumericInterface } from '../baseNumericInterface';
 export declare class NumberInterface extends BaseNumericInterface {
     component: ComponentOptions;
+    componentName: string;
 }

package/dist/codeNodeInterfaces/select/selectInterface.d.ts

@@ -7,6 +7,7 @@ export interface IAdvancedSelectInterfaceItem<V> {
 export type SelectInterfaceItem<V> = string | IAdvancedSelectInterfaceItem<V>;
 export declare class SelectInterface<V = string> extends BaseStringInterface {
     component: ComponentOptions;
+    componentName: string;
     items: SelectInterfaceItem<V>[];
-    constructor(name: string, value: V, items: SelectInterfaceItem<V>[]);
+    constructor(name: string, value: V, items: SelectInterfaceItem<V>[] | undefined);
 }

package/dist/codeNodeInterfaces/slider/sliderInterface.d.ts

@@ -1,5 +1,9 @@
+import { ComponentOptions } from 'vue';
 import { BaseNumericInterface } from '../baseNumericInterface';
 export declare class SliderInterface extends BaseNumericInterface {
-    constructor(name: string, value: number, min: number, max: number);
+    component: ComponentOptions;
+    componentName: string;
+    min: number;
+    max: number;
     getValue: () => string;
 }

package/dist/codeNodeInterfaces/tupleInput/tupleInputInterface.d.ts

@@ -1,5 +1,8 @@
+import { ComponentOptions } from 'vue';
 import { CodeNodeInputInterface } from '../codeNodeInput/codeNodeInputInterface';
 export declare class TupleInputInterface extends CodeNodeInputInterface {
+    component: ComponentOptions;
+    componentName: string;
     constructor(name: string, value?: string);
     getValue: () => string;
 }

package/dist/index.d.ts

@@ -11,4 +11,5 @@ export * from './codeNodeInterfaces';
 export * from './interfaceTypes';
 export * from './settings';
 export * from './subgraph';
+export * from './utils';
 export * from './viewModel';

package/dist/subgraph/graphInterface.d.ts

@@ -1,5 +1,6 @@
-import { NodeInterface, CalculateFunction, IGraphInterface } from '@baklavajs/core';
+import { CalculateFunction, IGraphInterface } from '@baklavajs/core';
 import { AbstractCodeNode, CodeNode, ICodeNodeState } from '../codeNode';
+import { CodeNodeInterface } from '../codeNodeInterfaces';
 export interface ICodeGraphInterface extends IGraphInterface {
     id: string;
     nodeId: string;
@@ -17,6 +18,11 @@ declare abstract class CodeGraphInterfaceNode<I, O> extends CodeNode<I, O> {
     onPlaced(): void;
     load(state: IGraphInterfaceNodeState<I, O>): void;
     save(): IGraphInterfaceNodeState<I, O>;
+    afterGraphLoaded(): void;
+    afterLoaded(): void;
+    beforeRun(): void;
+    onConnected(): void;
+    onUnconnected(): void;
     update(): void;
 }
 export declare class CodeGraphInputNode extends CodeGraphInterfaceNode<{
@@ -24,13 +30,13 @@ export declare class CodeGraphInputNode extends CodeGraphInterfaceNode<{
 }, {
     placeholder: unknown;
 }> {
-    static isGraphInputNode(v: AbstractCodeNode): v is CodeGraphInputNode;
+    static isGraphInputNode(v: AbstractCodeNode): boolean;
     readonly type = "__baklava_SubgraphInputNode";
     inputs: {
-        name: NodeInterface<string>;
+        name: CodeNodeInterface<string>;
     };
     outputs: {
-        placeholder: NodeInterface<undefined>;
+        placeholder: CodeNodeInterface<undefined>;
     };
 }
 export type CodeGraphInputNodeState = IGraphInterfaceNodeState<{
@@ -44,14 +50,14 @@ export declare class CodeGraphOutputNode extends CodeGraphInterfaceNode<{
 }, {
     output: unknown;
 }> {
-    static isGraphOutputNode(v: AbstractCodeNode): v is CodeGraphOutputNode;
+    static isGraphOutputNode(v: AbstractCodeNode): boolean;
     readonly type = "__baklava_SubgraphOutputNode";
     inputs: {
-        name: NodeInterface<string>;
-        placeholder: NodeInterface<undefined>;
+        name: CodeNodeInterface<string>;
+        placeholder: CodeNodeInterface<undefined>;
     };
     outputs: {
-        output: NodeInterface<undefined>;
+        output: CodeNodeInterface<undefined>;
     };
     calculate: CalculateFunction<{
         placeholder: unknown;

package/dist/subgraph/subgraphInterfaceNodes.d.ts

@@ -1,27 +1,21 @@
-import { NodeInterface } from '@baklavajs/core';
-import { TextInputInterface } from '@baklavajs/renderer-vue';
+import { CodeNodeInterface, TextInputInterface } from '../codeNodeInterfaces';
 import { CodeGraphInputNode, CodeGraphOutputNode } from './graphInterface';
-import { CodeNodeInterface } from '../codeNodeInterfaces';
 export declare class SubgraphInputNode extends CodeGraphInputNode {
     protected _title: string;
     inputs: {
-        _code: CodeNodeInterface<string>;
         name: TextInputInterface;
     };
     outputs: {
-        _code: CodeNodeInterface<string>;
-        placeholder: NodeInterface<undefined>;
+        placeholder: CodeNodeInterface<undefined>;
     };
 }
 export declare class SubgraphOutputNode extends CodeGraphOutputNode {
     protected _title: string;
     inputs: {
-        _code: CodeNodeInterface<string>;
         name: TextInputInterface;
-        placeholder: NodeInterface<undefined>;
+        placeholder: CodeNodeInterface<undefined>;
     };
     outputs: {
-        _code: CodeNodeInterface<string>;
-        output: NodeInterface<undefined>;
+        output: CodeNodeInterface<undefined>;
     };
 }

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './download';
+export * from './object';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babsey/code-graph",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "author": "babsey <spreizer@web.de>",
   "license": "MIT",
   "type": "module",