@babsey/code-graph 0.8.7 → 0.9.1

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;
+}

package/dist/codeNodeInterfaces/textInput/TextInputInterface.vue.d.ts

@@ -0,0 +1,26 @@
+import { TextInputInterface } from './textInputInterface';
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    intf: {
+        type: () => TextInputInterface;
+        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: () => TextInputInterface;
+        required: true;
+    };
+    modelValue: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,7 @@
+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/textareaInput/textareaInputInterface.d.ts

@@ -0,0 +1,5 @@
+import { ComponentOptions } from 'vue';
+import { BaseStringInterface } from '../baseStringInterface';
+export declare class TextareaInputInterface extends BaseStringInterface {
+    component: ComponentOptions;
+}

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

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

package/dist/components/CodeGraphEditor.vue.d.ts

@@ -0,0 +1,19 @@
+import { ICodeGraphViewModel } from '../viewModel';
+type __VLS_Props = {
+    viewModel: ICodeGraphViewModel;
+};
+declare var __VLS_30: {
+    node: import('baklavajs').AbstractNode;
+};
+type __VLS_Slots = {} & {
+    sidebarCodeEditor?: (props: typeof __VLS_30) => any;
+};
+declare const __VLS_base: 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 __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/dev/CodeGraphInfo.vue.d.ts

@@ -0,0 +1,7 @@
+import { ICodeGraphViewModel } from '../../viewModel';
+type __VLS_Props = {
+    viewModel: ICodeGraphViewModel;
+};
+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/components/editor/CodeEditor.vue.d.ts

@@ -0,0 +1,19 @@
+import { Extension } from '@codemirror/state';
+type __VLS_Props = {
+    locked: boolean;
+    extensions?: Extension[];
+};
+type __VLS_ModelProps = {
+    modelValue: string;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+} & {
+    "update:locked": (v: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:locked"?: ((v: boolean) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/editor/CopyToClipboard.vue.d.ts

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

package/dist/components/index.d.ts

@@ -0,0 +1,11 @@
+export { default as CodeEditor } from './editor/CodeEditor.vue';
+export { default as CodeGraphEditor } from './CodeGraphEditor.vue';
+export { default as CodeGraphInfo } from './dev/CodeGraphInfo.vue';
+export { default as CodeGraphNode } from './node/CodeGraphNode.vue';
+export { default as CodeGraphNodeInterface } from './nodeInterface/CodeGraphNodeInterface.vue';
+export { default as CodeGraphSidebar } from './sidebar/CodeGraphSidebar.vue';
+export { default as CodeNodePalette } from './nodePalette/CodeNodePalette.vue';
+export { default as CopyToClipboard } from './editor/CopyToClipboard.vue';
+export { default as NavBar } from './nav/NavBar.vue';
+export { default as NavItem } from './nav/NavItem.vue';
+export { default as SidebarCheckbox } from './sidebar/SidebarCheckbox.vue';

package/dist/components/nav/NavBar.vue.d.ts

@@ -0,0 +1,29 @@
+import { IEditorState } from 'baklavajs';
+import { ICodeGraphViewModel } from '../../viewModel';
+type __VLS_Props = {
+    viewModel: ICodeGraphViewModel;
+    editorStates: IEditorState[];
+    routes?: {
+        edit: string;
+        new: string;
+    };
+};
+declare var __VLS_1: {}, __VLS_15: {};
+type __VLS_Slots = {} & {
+    prepend?: (props: typeof __VLS_1) => any;
+} & {
+    append?: (props: typeof __VLS_15) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "click:remove": (graphId: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onClick:remove"?: ((graphId: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/nav/NavItem.vue.d.ts

@@ -0,0 +1,17 @@
+declare var __VLS_8: {}, __VLS_10: {}, __VLS_12: {};
+type __VLS_Slots = {} & {
+    prependIcon?: (props: typeof __VLS_8) => any;
+} & {
+    default?: (props: typeof __VLS_10) => any;
+} & {
+    appendIcon?: (props: typeof __VLS_12) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/node/CodeGraphNode.vue.d.ts

@@ -0,0 +1,39 @@
+import { AbstractCodeNode } from '../../codeNode';
+type __VLS_Props = {
+    node: AbstractCodeNode;
+    selected?: boolean;
+    dragging?: boolean;
+};
+declare var __VLS_53: {
+    type: string;
+    node: AbstractCodeNode;
+    intf: import('../..').CodeNodeInterface<unknown>;
+}, __VLS_60: {
+    node: AbstractCodeNode;
+    intf: import('../..').CodeNodeInterface<unknown>;
+    type: string;
+};
+type __VLS_Slots = {} & {
+    nodeInterface?: (props: typeof __VLS_53) => any;
+} & {
+    nodeInterface?: (props: typeof __VLS_60) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    select: () => any;
+    update: () => any;
+    "start-drag": (ev: PointerEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: (() => any) | undefined;
+    onUpdate?: (() => any) | undefined;
+    "onStart-drag"?: ((ev: PointerEvent) => any) | undefined;
+}>, {
+    selected: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/nodeInterface/CodeGraphNodeInterface.vue.d.ts

@@ -0,0 +1,19 @@
+import { NodeInterface } from '@baklavajs/core';
+import { AbstractCodeNode } from '../../codeNode';
+type __VLS_Props = {
+    node: AbstractCodeNode;
+    intf: NodeInterface;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: 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 __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/nodePalette/CodeNodePalette.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;