@babsey/code-graph 0.10.0 → 0.10.2

package/dist/codeNode/dynamicCodeNode.d.ts

@@ -27,6 +27,7 @@ export interface IDynamicCodeNodeDefinition<I, O> extends IDynamicNodeDefinition
     modules?: string[];
     onConnected?: () => void;
     onUnconnected?: () => void;
+    onUpdate?: (this: DynamicCodeNode<I, O>, inputs: I, outputs: O) => DynamicNodeUpdateResult;
     update?: (node?: AbstractCodeNode) => void;
     variableName?: 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,16 @@
 import { NodeInterface, INodeInterfaceState } from '@baklavajs/core';
-import { UnwrapRef } from 'vue';
-import { default as CodeNodeInterfaceComponent } from './CodeNodeInterface.vue';
+import { ComponentOptions, UnwrapRef } from 'vue';
 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,4 +18,3 @@ export declare class CodeNodeInterface<T = unknown> extends NodeInterface<T> {
     save(): INodeInterfaceState<T>;
     setOptional(value: boolean): this;
 }
-export { CodeNodeInterfaceComponent };

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

@@ -1,5 +1,7 @@
-import { CodeNodeInterface } from '../codeNode';
+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';
-export declare class CodeNodeOutputInterface extends CodeNodeInterface<string> {
+import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
+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/{codeNode → components}/CodeNodeInterface.vue.d.ts

@@ -1,4 +1,4 @@
-import { CodeNodeInterface } from './codeNodeInterface';
+import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
 type __VLS_Props = {
     intf: CodeNodeInterface;
 };

package/dist/codeNodeInterfaces/components/SelectInterface.vue.d.ts

@@ -0,0 +1,22 @@
+import { SelectInterface, SelectInterfaceItem } from '../select/selectInterface';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    intf: {
+        type: () => SelectInterface<unknown>;
+        required: true;
+    };
+}>, {
+    el: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    open: import('vue').Ref<boolean, boolean>;
+    selectedItem: import('vue').ComputedRef<SelectInterfaceItem<unknown> | undefined>;
+    selectedText: import('vue').ComputedRef<string>;
+    setSelected: (item: SelectInterfaceItem<unknown>) => void;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    intf: {
+        type: () => SelectInterface<unknown>;
+        required: true;
+    };
+}>> & Readonly<{}>, {}, {}, {
+    "i-arrow": import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/codeNodeInterfaces/{textInput → components}/TextInputInterface.vue.d.ts

@@ -1,4 +1,4 @@
-import { TextInputInterface } from './textInputInterface';
+import { TextInputInterface } from '../textInput/textInputInterface';
 declare const _default: typeof __VLS_export;
 export default _default;
 declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{

package/dist/codeNodeInterfaces/components/TextareaInputInterface.vue.d.ts

@@ -0,0 +1,26 @@
+import { TextareaInputInterface } from '../textareaInput/textareaInputInterface';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    intf: {
+        type: () => TextareaInputInterface;
+        required: true;
+    };
+    modelValue: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, {
+    v: import('vue').WritableComputedRef<string, string>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    intf: {
+        type: () => TextareaInputInterface;
+        required: true;
+    };
+    modelValue: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

package/dist/codeNodeInterfaces/components/index.d.ts

@@ -0,0 +1,4 @@
+export { default as CodeNodeInterface } from './CodeNodeInterface.vue';
+export { default as TextInputInterface } from './TextInputInterface.vue';
+export { default as SelectInterface } from './SelectInterface.vue';
+export { default as TextareaInputInterface } from './TextareaInputInterface.vue';

package/dist/codeNodeInterfaces/createInterface.d.ts

@@ -1,12 +1,13 @@
-import { CodeNodeInputInterface } 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) => CodeNodeInputInterface;
+export declare const createInterface: (name: string, interfaceProps: IInterfaceProps) => CheckboxInterface | IntegerInterface | ListInputInterface | NumberInterface | SelectInterface<unknown> | SliderInterface | TupleInputInterface | TextInputInterface;

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

@@ -2,5 +2,6 @@ import { ComponentOptions } from 'vue';
 import { BaseNumericInterface } from '../baseNumericInterface';
 export declare class IntegerInterface extends BaseNumericInterface {
     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 {
-    constructor(name?: string, value?: string);
+    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

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

package/dist/codeNodeInterfaces/textInput/textInputInterface.d.ts

@@ -1,7 +1,5 @@
 import { ComponentOptions } from 'vue';
-import { default as TextInputInterfaceComponent } from './TextInputInterface.vue';
 import { BaseStringInterface } from '../baseStringInterface';
 export declare class TextInputInterface extends BaseStringInterface {
     component: ComponentOptions;
 }
-export { TextInputInterfaceComponent };

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

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

package/dist/components.d.ts

@@ -1,2 +1,2 @@
 export * from './components/index';
-export { default as TextInputInterface } from './codeNodeInterfaces/textInput/TextInputInterface.vue';
+export * from './codeNodeInterfaces/components/index';

package/dist/icons/ChevronDown.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/icons/index.d.ts

@@ -1,4 +1,5 @@
 export { default as Check } from './Check.vue';
+export { default as ChevronDown } from './ChevronDown.vue';
 export { default as CodeVariable } from './CodeVariable.vue';
 export { default as Copy } from './Copy.vue';
 export { default as DotsVertical } from './DotsVertical.vue';

package/package.json

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

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

@@ -1,2 +0,0 @@
-export * from './codeNodeInterface';
-export { default as CodeNodeInterfaceComponent } from './CodeNodeInterface.vue';