@babsey/code-graph 0.8.6 → 0.9.0

package/dist/code.d.ts

@@ -0,0 +1,57 @@
+import { UnwrapRef } from 'vue';
+import { AbstractCodeNode } from './codeNode';
+import { CodeGraph } from './codeGraph';
+import { CodeEngine } from './codeEngine';
+import { ICodeGraphViewModel } from './viewModel';
+export interface ICodeState {
+    lockCode: boolean;
+    modules: Record<string, string>;
+    script: string;
+    template: string;
+}
+export declare class Code {
+    private _id;
+    private _state;
+    viewModel: ICodeGraphViewModel | undefined;
+    constructor();
+    get engine(): CodeEngine | undefined;
+    get graph(): CodeGraph | undefined;
+    get id(): string;
+    get lockCode(): boolean;
+    set lockCode(value: boolean);
+    get modules(): string[];
+    get script(): string;
+    set script(value: string);
+    get shortId(): string;
+    get state(): UnwrapRef<ICodeState>;
+    /**
+     * Clear code.
+     */
+    clear(): void;
+    /**
+     * Load template from the file.
+     * @param resolve: default string in promise resolve (from import)
+     */
+    loadTemplate(resolve: Promise<{
+        default: string;
+    }>): Promise<void>;
+    /**
+     * Register code view model instance.
+     * @param viewModel view model
+     */
+    registerViewModel(viewModel: ICodeGraphViewModel): void;
+    /**
+     * Render code script.
+     * @param data data for render template.
+     */
+    renderCode(data?: {
+        nodes: AbstractCodeNode[];
+        modules: string[];
+    }): void;
+}
+export declare class PythonCode extends Code {
+    constructor();
+}
+export declare class JavascriptCode extends Code {
+    constructor();
+}

package/dist/codeEditor.d.ts

@@ -0,0 +1,28 @@
+import { IBaklavaEventEmitter, IBaklavaTapable } from '@baklavajs/events';
+import { IEditorState, Editor } from '@baklavajs/core';
+import { CodeGraph, CodeGraphTemplate } from './codeGraph';
+import { Code } from './code';
+export declare class CodeEditor extends Editor implements IBaklavaEventEmitter, IBaklavaTapable {
+    code: Code;
+    graph: CodeGraph;
+    constructor(code: Code);
+    get graphIds(): string;
+    get graphTemplateIds(): string;
+    /**
+     * Add code graph template.
+     * @param template code graph template
+     */
+    addGraphTemplate(template: CodeGraphTemplate): void;
+    /**
+     * Load a state
+     * @param state State to load
+     * @returns An array of warnings that occured during loading. If the array is empty, the state was successfully loaded.
+     */
+    load(state: IEditorState): string[];
+    /**
+     * Register category module
+     * @param category string
+     * @param module string
+     */
+    registerCategoryModule(category: string, module: string): void;
+}

package/dist/codeEngine/codeEngine.d.ts

@@ -0,0 +1,16 @@
+import { CalculationResult } from '@baklavajs/core';
+import { BaseEngine } from '@baklavajs/engine';
+import { CodeGraph } from '../codeGraph';
+import { CodeEditor } from '../codeEditor';
+import { CodeNodeInterface } from '../codeNodeInterfaces';
+export declare const allowMultipleConnections: <T extends Array<unknown>>(intf: CodeNodeInterface<T>) => void;
+export declare class CodeEngine<CalculationData = unknown> extends BaseEngine<CalculationData, []> {
+    private order;
+    constructor(editor: CodeEditor);
+    start(): void;
+    runGraph(graph: CodeGraph, inputs: Map<string, unknown>, calculationData: CalculationData): Promise<CalculationResult>;
+    protected execute(calculationData: CalculationData): Promise<CalculationResult>;
+    getInputValues(graph: CodeGraph): Map<string, unknown>;
+    protected onChange(recalculateOrder: boolean): void;
+    private getInterfaceValue;
+}

package/dist/codeEngine/index.d.ts

@@ -0,0 +1,3 @@
+export * from './codeEngine';
+export * from './register';
+export * from './runEngine.command';

package/dist/codeEngine/register.d.ts

@@ -0,0 +1,11 @@
+import { INodeState } from '@baklavajs/core';
+import { ICodeGraphViewModel } from '../viewModel';
+export interface IViewNodeState extends INodeState<unknown, unknown> {
+    position: {
+        x: number;
+        y: number;
+    };
+    width: number;
+    twoColumn: boolean;
+}
+export declare function registerCodeEngine(viewModel: ICodeGraphViewModel): void;

package/dist/codeEngine/runEngine.command.d.ts

@@ -0,0 +1,8 @@
+import { ICommandHandler } from '@baklavajs/renderer-vue';
+import { CodeGraph } from '../codeGraph';
+import { CodeEngine } from './codeEngine';
+/**
+ * Reister run engine commands.
+ * @param viewModel view model instance
+ */
+export declare const registerRunEngineCommands: (graph: CodeGraph, engine: CodeEngine, handler: ICommandHandler) => void;

package/dist/codeGraph/codeGraph.d.ts

@@ -0,0 +1,122 @@
+import { Graph, GraphTemplate, Connection, NodeInterface, IGraphState } from '@baklavajs/core';
+import { UnwrapRef } from 'vue';
+import { IBaklavaEventEmitter, IBaklavaTapable } from '@baklavajs/events';
+import { AbstractCodeNode } from '../codeNode';
+import { Code } from '../code';
+import { CodeEditor } from '../codeEditor';
+import { CodeNodeInterface } from '../codeNodeInterfaces';
+export declare const NODE_DEFAULT_WITH = 350;
+interface IPosition {
+    x: number;
+    y: number;
+}
+export interface ICodeGraphState {
+    codeTemplate: string;
+    lockCode: boolean;
+}
+export declare class CodeGraph extends Graph implements IBaklavaEventEmitter, IBaklavaTapable {
+    code: Code | null;
+    editor: CodeEditor;
+    private _state;
+    constructor(editor: CodeEditor, template?: GraphTemplate);
+    get codeNodes(): AbstractCodeNode[];
+    get connections(): Connection[];
+    set connections(values: Connection[]);
+    get nodeIds(): string[];
+    get nodes(): AbstractCodeNode[];
+    set nodes(values: AbstractCodeNode[]);
+    get scriptedCodeNodes(): AbstractCodeNode[];
+    get selectedNodeIds(): string[];
+    get shortId(): string;
+    get state(): UnwrapRef<ICodeGraphState>;
+    get visibleNodes(): AbstractCodeNode[];
+    /**
+     * Add code node to graph.
+     * @param node code node
+     * @param props optional
+     */
+    addNode(node: AbstractCodeNode, props?: unknown): AbstractCodeNode | undefined;
+    /**
+     * Add code node at coordinates.
+     * @param node code node
+     * @param position position
+     * @param props optional
+     * @returns code node
+     */
+    addNodeAtCoordinates: (node: AbstractCodeNode, position?: IPosition, props?: unknown) => AbstractCodeNode;
+    /**
+     * Add connection of code nodes
+     * @param from code node interface
+     * @param to code node interface
+     */
+    addConnection(from: CodeNodeInterface, to: CodeNodeInterface): void;
+    /**
+     * Clear code graph.
+     */
+    clear(): void;
+    /**
+     * Find node by type.
+     * @param nodeType node type
+     * @returns node instance
+     */
+    findNodeByType(nodeType: string): AbstractCodeNode | undefined;
+    /**
+     * Get nodes of the type.
+     * @param type node type
+     * @returns a list of node instances
+     */
+    getNodesByType(type: string): AbstractCodeNode[];
+    /**
+     * Get nodes of the variable name.
+     * @param variableName variable name
+     * @returns a list of node instances
+     */
+    getNodesByVariableName(variableName: string): AbstractCodeNode[];
+    /**
+     * Check whether the graph has this connection.
+     * @param from node interface
+     * @param to node interface
+     * @returns boolean
+     */
+    hasConnection(from: NodeInterface, to: NodeInterface): boolean;
+    /**
+     * Load a state.
+     * @param state State to load
+     * @returns An array of warnings that occured during loading. If the array is empty, the state was successfully loaded.
+     */
+    load(state: IGraphState): string[];
+    /**
+     * Trigger on graph update.
+     */
+    onUpdate(): void;
+    /**
+     * Render code script.
+     */
+    renderCode(data: {
+        nodes: AbstractCodeNode[];
+    }): string;
+    /**
+     * Sort code nodes.
+     */
+    sortNodes(): void;
+}
+/**
+ * Get code nodes of current graph.
+ * @param graph graph / subgraph
+ * @returns list of code nodes
+ */
+export declare const getCodeNodes: (graph: CodeGraph) => AbstractCodeNode[];
+/**
+ * Get position at specific column.
+ * @param col column
+ * @param offset number
+ * @returns position
+ */
+export declare const getPositionAtColumn: (col?: number, offset?: number) => IPosition;
+/**
+ * Get position before target node.
+ * @param node code node
+ * @returns position
+ */
+export declare const getPositionBeforeNode: (node: AbstractCodeNode) => IPosition;
+export {};

package/dist/codeGraph/codeGraphNode.d.ts

@@ -0,0 +1,12 @@
+import { GraphTemplate, IGraphNode, INodeState } from '@baklavajs/core';
+import { AbstractCodeNode } from '../codeNode';
+import { CodeGraph, ICodeGraphState } from './codeGraph';
+import { CodeGraphTemplate } from './codeGraphTemplate';
+export interface IGraphCodeNodeState extends INodeState<unknown, unknown> {
+    graphState: ICodeGraphState;
+}
+export interface IGraphCodeNode extends IGraphNode {
+    template: CodeGraphTemplate;
+    subgraph: CodeGraph | undefined;
+}
+export declare function createCodeGraphNodeType(template: GraphTemplate): new () => AbstractCodeNode & IGraphNode;

package/dist/codeGraph/codeGraphTemplate.d.ts

@@ -0,0 +1,16 @@
+import { GraphTemplate, IGraphTemplateState } from '@baklavajs/core';
+import { CodeEditor } from '../codeEditor';
+import { CodeGraph, ICodeGraphState } from './codeGraph';
+type Optional<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
+export declare class CodeGraphTemplate extends GraphTemplate implements ICodeGraphState {
+    /** Create a new GraphTemplate from the nodes and connections inside the graph instance */
+    static fromGraph(graph: CodeGraph, editor: CodeEditor): CodeGraphTemplate;
+    constructor(state: Optional<IGraphTemplateState, "id" | "name">, editor: CodeEditor);
+    get shortId(): string;
+    /**
+     * Create a new graph instance from this template
+     * or load the state into the provided graph instance.
+     */
+    createGraph(graph?: CodeGraph): CodeGraph;
+}
+export {};

package/dist/codeGraph/index.d.ts

@@ -0,0 +1,4 @@
+export * from './codeGraph';
+export * from './codeGraphNode';
+export * from './codeGraphTemplate';
+export * from './switchCodeGraph';

package/dist/codeGraph/switchCodeGraph.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+import { CodeEditor } from '../codeEditor';
+import { CodeGraph } from './codeGraph';
+import { CodeGraphTemplate } from './codeGraphTemplate';
+export type SwitchCodeGraph = (newGraph: CodeGraph | CodeGraphTemplate) => void;
+export declare function useSwitchCodeGraph(editor: Ref<CodeEditor>, displayedGraph: Ref<CodeGraph>): {
+    switchGraph: SwitchCodeGraph;
+};

package/dist/codeNode/codeNode.d.ts

@@ -0,0 +1,138 @@
+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 { CodeGraph } from '../codeGraph';
+export interface IAbstractCodeNodeState {
+    codeTemplate: string;
+    hidden: boolean;
+    integrated: boolean;
+    lockCode: boolean;
+    modules: string[];
+    position?: {
+        x: number;
+        y: number;
+    };
+    props?: unknown | null;
+    script: string;
+    variableName: string;
+}
+export declare abstract class AbstractCodeNode extends AbstractNode {
+    private _variableName;
+    codeTemplate: () => string;
+    readonly isCodeNode = true;
+    mask: unknown;
+    name: string;
+    state: UnwrapRef<IAbstractCodeNodeState>;
+    inputs: Record<string, CodeNodeInterface<unknown>>;
+    outputs: Record<string, CodeNodeInterface<unknown>>;
+    constructor();
+    get code(): Code | null;
+    get codeNodeInputs(): Record<string, CodeNodeInputInterface>;
+    get codeNodeOutputs(): Record<string, CodeNodeOutputInterface>;
+    get graph(): CodeGraph;
+    get hasConnectedOutputNodes(): boolean;
+    get idx(): number;
+    get idxByType(): number;
+    get idxByVariableNames(): number;
+    get isSelected(): boolean;
+    get lockCode(): boolean;
+    set lockCode(value: boolean);
+    get optionalInputs(): Record<string, CodeNodeInputInterface>;
+    get requiredInputs(): Record<string, CodeNodeInputInterface>;
+    get script(): string;
+    set script(value: string);
+    get shortId(): string;
+    get subgraph(): CodeGraph | undefined;
+    get variableName(): string;
+    set variableName(value: string);
+    abstract afterGraphLoaded(): void;
+    abstract afterLoaded(): void;
+    abstract onConnected(): void;
+    abstract onGraphUpdate(): void;
+    abstract onUnconnected(): void;
+    abstract update(): void;
+    /**
+     * Get connected node to the node interface.
+     * @param nodeInterface string
+     * @returns code node instance or null
+     */
+    getConnectedNodeByInterface(nodeInterface: string, type?: "inputs" | "outputs"): AbstractCodeNode | null;
+    /**
+     * Get connected nodes to the node.
+     * @param type inputs or outputs
+     * @returns code node instances
+     */
+    getConnectedNodes(type?: "inputs" | "outputs"): AbstractCodeNode[];
+    /**
+     * Get connected nodes to the node interface.
+     * @param nodeInterface string
+     * @returns code node instances
+     */
+    getConnectedNodesByInterface(nodeInterface: string, type?: "inputs" | "outputs"): AbstractCodeNode[];
+    /**
+     * Remove this node from the graph.
+     */
+    remove(): void;
+    /**
+     * Render code of this node.
+     */
+    renderCode(data: {
+        inputs: Record<string, unknown>;
+    }): string;
+    /**
+     * Update code templates.
+     */
+    updateCodeTemplate(): void;
+    /**
+     * Update modules.
+     * @param modules a list of modules
+     */
+    updateModules(modules?: string[]): void;
+    /**
+     * Update output names.
+     */
+    updateOutputNames(): void;
+    /**
+     * Update output values.
+     * @param output return data of calculate function
+     */
+    updateOutputValues(outputs: CalculateFunctionReturnType<unknown>): void;
+    /**
+     * Update state props.
+     * @param props
+     */
+    updateProps(props: unknown): void;
+    /**
+     * Update input values
+     * @param inputs input values
+     */
+    updateInputValues(inputs: Record<string, unknown>): void;
+}
+export interface ICodeNodeState<I, O> extends INodeState<I, O>, IAbstractCodeNodeState {
+}
+export type NodeInterfaceFactory<T> = () => NodeInterface<T>;
+export type InterfaceFactory<T> = {
+    [K in keyof T]: NodeInterfaceFactory<T[K]>;
+};
+export declare abstract class CodeNode<I, O> extends AbstractCodeNode {
+    abstract inputs: NodeInterfaceDefinition<I>;
+    abstract outputs: NodeInterfaceDefinition<O>;
+    /**
+     * The default implementation does nothing.
+     * Overwrite this method to do calculation.
+     * @param inputs Values of all input interfaces
+     * @param globalValues Set of values passed to every node by the engine plugin
+     * @return Values for output interfaces
+     */
+    calculate?: CalculateFunction<I, O>;
+    executeFactory<V, T extends InterfaceFactory<V>>(type: "input" | "output", factory?: T): void;
+    load(state: ICodeNodeState<I, O>): void;
+}
+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/codeNode/defineCodeNode.d.ts

@@ -0,0 +1,17 @@
+import { INodeDefinition, Node } from '@baklavajs/core';
+import { CodeNode, AbstractCodeNode } from './codeNode';
+export type NodeConstructor<I, O> = new () => Node<I, O>;
+export type NodeInstanceOf<T> = T extends new () => Node<infer A, infer B> ? Node<A, B> : never;
+export interface ICodeNodeDefinition<I, O> extends INodeDefinition<I, O> {
+    afterGraphLoaded?: () => void;
+    afterLoaded?: () => void;
+    codeTemplate?: (node?: AbstractCodeNode) => string;
+    modules?: string[];
+    name?: string;
+    onConnected?: () => void;
+    onGraphUpdate?: () => void;
+    onUnconnected?: () => void;
+    update?: (node?: AbstractCodeNode) => void;
+    variableName?: string;
+}
+export declare function defineCodeNode<I, O>(definition: ICodeNodeDefinition<I, O>): new () => CodeNode<I, O>;

package/dist/codeNode/dynamicCodeNode.d.ts

@@ -0,0 +1,34 @@
+import { IDynamicNodeDefinition, NodeInterface, NodeInterfaceDefinition } from '@baklavajs/core';
+import { CodeNode, AbstractCodeNode, ICodeNodeState } from './codeNode';
+type Dynamic<T> = T & Record<string, unknown>;
+/**
+ * @internal
+ * Abstract base class for every dynamic node
+ */
+export declare abstract class DynamicCodeNode<I, O> extends CodeNode<Dynamic<I>, Dynamic<O>> {
+    abstract inputs: NodeInterfaceDefinition<Dynamic<I>>;
+    abstract outputs: NodeInterfaceDefinition<Dynamic<O>>;
+    abstract load(state: ICodeNodeState<Dynamic<I>, Dynamic<O>>): void;
+    abstract save(): ICodeNodeState<Dynamic<I>, Dynamic<O>>;
+}
+export type DynamicNodeDefinition = Record<string, (() => NodeInterface<unknown>) | undefined>;
+export interface DynamicNodeUpdateResult {
+    inputs?: DynamicNodeDefinition;
+    outputs?: DynamicNodeDefinition;
+    forceUpdateInputs?: string[];
+    forceUpdateOutputs?: string[];
+}
+export interface IDynamicCodeNodeDefinition<I, O> extends IDynamicNodeDefinition<I, O> {
+    afterGraphLoaded?: () => void;
+    afterLoaded?: () => void;
+    codeTemplate?: (node?: AbstractCodeNode) => string;
+    name?: string;
+    modules?: string[];
+    onConnected?: () => void;
+    onGraphUpdate?: () => void;
+    onUnconnected?: () => void;
+    update?: (node?: AbstractCodeNode) => void;
+    variableName?: string;
+}
+export declare function defineDynamicCodeNode<I, O>(definition: IDynamicCodeNodeDefinition<I, O>): new () => DynamicCodeNode<I, O>;
+export {};

package/dist/codeNode/index.d.ts

@@ -0,0 +1,3 @@
+export * from './codeNode';
+export * from './defineCodeNode';
+export * from './dynamicCodeNode';

package/dist/codeNodeInterfaces/baseNumericInterface.d.ts

@@ -0,0 +1,23 @@
+import { Ref } from 'vue';
+import { NodeInterface } from '@baklavajs/core';
+import { CodeNodeInputInterface } from './codeNodeInput/codeNodeInputInterface';
+export interface IValidator {
+    validate: (v: number) => boolean;
+}
+export declare class BaseNumericInterface extends CodeNodeInputInterface<number> implements IValidator {
+    min?: number;
+    max?: number;
+    constructor(name: string, value: number, min?: number, max?: number);
+    validate(v: number): boolean;
+}
+export declare const useBaseNumericInterface: (intf: Ref<NodeInterface<number>>, precision?: number) => {
+    editMode: Ref<boolean, boolean>;
+    invalid: Ref<boolean, boolean>;
+    tempValue: Ref<string, string>;
+    inputEl: Ref<HTMLInputElement | null, HTMLInputElement | null>;
+    stringRepresentation: import('vue').ComputedRef<string>;
+    validate: (v: number) => boolean;
+    setValue: (newValue: number) => void;
+    enterEditMode: () => Promise<void>;
+    leaveEditMode: () => void;
+};

package/dist/codeNodeInterfaces/baseStringInterface.d.ts

@@ -0,0 +1,5 @@
+import { CodeNodeInputInterface } from './codeNodeInput/codeNodeInputInterface';
+export declare class BaseStringInterface extends CodeNodeInputInterface<string> {
+    constructor(name: string, value: string);
+    getValue: () => string;
+}

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

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

package/dist/codeNodeInterfaces/codeNode/CodeNodeInterface.vue.d.ts

@@ -0,0 +1,7 @@
+import { CodeNodeInterface } from './codeNodeInterface';
+type __VLS_Props = {
+    intf: CodeNodeInterface;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,21 @@
+import { NodeInterface, INodeInterfaceState } from '@baklavajs/core';
+import { UnwrapRef } from 'vue';
+import { default as CodeNodeInterfaceComponent } from './CodeNodeInterface.vue';
+import { Code } from '../../code';
+export interface ICodeNodeInterfaceRefState {
+    optional: boolean;
+}
+export declare class CodeNodeInterface<T = unknown> extends NodeInterface<T> {
+    isCodeNode: boolean;
+    code: Code | undefined;
+    state: UnwrapRef<ICodeNodeInterfaceRefState>;
+    type: string | null;
+    constructor(name: string, value: T);
+    get optional(): boolean;
+    get shortId(): string;
+    getValue: () => string;
+    load(state: INodeInterfaceState<T>): void;
+    save(): INodeInterfaceState<T>;
+    setOptional(value: boolean): this;
+}
+export { CodeNodeInterfaceComponent };

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

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

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

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

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

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

package/dist/codeNodeInterfaces/createInterface.d.ts

@@ -0,0 +1,12 @@
+import { CodeNodeInputInterface } from '.';
+export interface IInterfaceProps {
+    forceUpdate?: boolean;
+    hidden?: boolean;
+    id: string;
+    items?: string[];
+    max?: number;
+    min?: number;
+    name?: string;
+    value: unknown;
+}
+export declare const createInterface: (name: string, interfaceProps: IInterfaceProps) => CodeNodeInputInterface;

package/dist/codeNodeInterfaces/index.d.ts

@@ -0,0 +1,13 @@
+export * from './createInterface';
+export * from './checkbox/checkboxInterface';
+export * from './codeNode/codeNodeInterface';
+export * from './codeNodeInput/codeNodeInputInterface';
+export * from './codeNodeOutput/codeNodeOutputInterface';
+export * from './integer/integerInterface';
+export * from './listInput/listInputInterface';
+export * from './number/numberInterface';
+export * from './select/selectInterface';
+export * from './slider/sliderInterface';
+export * from './textInput/textInputInterface';
+export * from './textareaInput/textareaInputInterface';
+export * from './tupleInput/tupleInputInterface';

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

@@ -0,0 +1,6 @@
+import { ComponentOptions } from 'vue';
+import { BaseNumericInterface } from '../baseNumericInterface';
+export declare class IntegerInterface extends BaseNumericInterface {
+    component: ComponentOptions;
+    validate(v: number): boolean;
+}

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

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

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

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

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

@@ -0,0 +1,12 @@
+import { ComponentOptions } from 'vue';
+import { BaseStringInterface } from '../baseStringInterface';
+export interface IAdvancedSelectInterfaceItem<V> {
+    text: string;
+    value: V;
+}
+export type SelectInterfaceItem<V> = string | IAdvancedSelectInterfaceItem<V>;
+export declare class SelectInterface<V = string> extends BaseStringInterface {
+    component: ComponentOptions;
+    items: SelectInterfaceItem<V>[];
+    constructor(name: string, value: V, items: SelectInterfaceItem<V>[]);
+}

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

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