@babsey/code-graph 0.0.0 → 0.0.1

package/.vscode/extensions.json

@@ -0,0 +1,3 @@
+{
+  "recommendations": ["Vue.volar"]
+}

package/dist/code-graph.umd.cjs

@@ -1,5 +1,5 @@
 (function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("baklavajs"), require("mustache"), require("vue"), require("toposort"), require("uuid"), require("@vueuse/core")) : typeof define === "function" && define.amd ? define(["exports", "baklavajs", "mustache", "vue", "toposort", "uuid", "@vueuse/core"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["code-graph"] = {}, global.baklavajs, global.mustache, global.Vue, global.toposort, global.uuid, global["@vueuse/core"]));
+  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("baklavajs"), require("mustache"), require("vue"), require("toposort"), require("uuid"), require("@vueuse/core")) : typeof define === "function" && define.amd ? define(["exports", "baklavajs", "mustache", "vue", "toposort", "uuid", "@vueuse/core"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global["@code-graph"] = {}, global.baklavajs, global.mustache, global.Vue, global.toposort, global.uuid, global["@vueuse/core"]));
 })(this, (function(exports2, baklavajs, mustache, vue, toposort, uuid, core) {
   "use strict";
   class AbstractCodeNode extends baklavajs.AbstractNode {

package/dist/lib/code.d.ts

@@ -0,0 +1,128 @@
+import { Connection, Graph, IEditorState, INodeState, NodeInterface } from 'baklavajs';
+import { UnwrapRef } from 'vue';
+import { AbstractCodeNode } from './codeNode';
+import { CodeNodeInterface } from './codeNodeInterfaces';
+import { ICodeGraphViewModel } from './viewModel';
+interface IPosition {
+    x: number;
+    y: number;
+}
+interface ICodeState {
+    autosort: boolean;
+    modules: Record<string, string>;
+    script: string;
+    template: string;
+    token: symbol | null;
+}
+export declare class Code {
+    private _id;
+    private _viewModel;
+    private _state;
+    constructor(viewModel: ICodeGraphViewModel);
+    get codeNodes(): AbstractCodeNode[];
+    get connections(): Connection[];
+    get graph(): Graph;
+    get id(): string;
+    get modules(): string[];
+    get nodeIds(): string[];
+    get nodes(): AbstractCodeNode[];
+    get scriptedCodeNodes(): AbstractCodeNode[];
+    get shortId(): string;
+    get state(): UnwrapRef<ICodeState>;
+    get viewModel(): ICodeGraphViewModel;
+    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 | NodeInterface, to: CodeNodeInterface | NodeInterface): void;
+    /**
+     * Clear code graph.
+     */
+    clear(): void;
+    findNodeById(id: string): AbstractCodeNode | undefined;
+    findNodeByType(nodeType: string): AbstractCodeNode | undefined;
+    getNodesBySameType(type: string): AbstractCodeNode[];
+    getNodesBySameVariableNames(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 template from the file.
+     */
+    loadTemplate(resolve: Promise<any>): void;
+    onCodeUpdate(): void;
+    /**
+     * Remove connection from the graph
+     * @param connection connection between code nodes
+     */
+    removeConnection(connection: Connection): void;
+    /**
+     * Remove node from the graph.
+     * @param codeNode code node
+     */
+    removeNode(codeNode: AbstractCodeNode): void;
+    /**
+     * Render node codes.
+     */
+    renderNodeCodes(): void;
+    /**
+     * Render code.
+     */
+    renderCode(): void;
+    /**
+     * Save code graph.
+     * @returns graph state
+     */
+    save(): IEditorState;
+    /**
+     * Save node states.
+     * @param nodeStates a list of node state.
+     */
+    saveNodeStates(nodeStates: INodeState<unknown, unknown>[]): void;
+    /**
+     * Sort code nodes.
+     */
+    sortNodes(): void;
+    updateOutputVariableNames(): void;
+}
+/**
+ * Get nodes of current graph.
+ * @param graph graph / subgraph
+ * @returns list of code nodes
+ */
+export declare const getCodeNodes: (graph: Graph) => 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 declare const transferCodeScript: (graph: Graph) => void;
+export {};

package/dist/lib/codeNode/codeNode.d.ts

@@ -0,0 +1,70 @@
+import { AbstractNode, Graph, NodeInterface, CalculateFunction, INodeState, NodeInterfaceDefinition } from 'baklavajs';
+import { UnwrapRef } from 'vue';
+import { Code } from '../code';
+interface IAbstractCodeNodeState {
+    codeTemplate: string;
+    hidden: boolean;
+    integrated: boolean;
+    modules: string[];
+    props?: unknown;
+    script: string;
+    variableName: string;
+}
+export declare abstract class AbstractCodeNode extends AbstractNode {
+    state: UnwrapRef<IAbstractCodeNodeState>;
+    code: Code | undefined;
+    isCodeNode: boolean;
+    inputs: Record<string, NodeInterface<unknown>>;
+    outputs: Record<string, NodeInterface<unknown>>;
+    constructor();
+    get codeTemplate(): string;
+    get idx(): number;
+    get idxByVariableNames(): number;
+    get script(): string;
+    get shortId(): string;
+    get variableName(): string;
+    abstract onCodeUpdate(): void;
+    /**
+     * Get connected nodes to the node.
+     * @param type inputs or outputs
+     * @returns code node instances
+     */
+    getConnectedNodes(type?: 'inputs' | 'outputs'): AbstractCodeNode[];
+    registerCode(code: Code): void;
+    /**
+     * Render code of this node.
+     */
+    renderCode(): void;
+    updateOutputVariableName(): void;
+}
+export interface ICodeNodeState<I, O> extends INodeState<I, O>, IAbstractCodeNodeState {
+}
+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>;
+    load(state: ICodeNodeState<I, O>): void;
+    save(): ICodeNodeState<I, O>;
+    updateModules(modules?: string[]): void;
+}
+export type AbstractCodeNodeConstructor = new () => AbstractCodeNode;
+/**
+ * Load node state.
+ * @param graph code graph
+ * @param nodeState node state
+ */
+export declare const loadNodeState: (graph: Graph | undefined, nodeState: ICodeNodeState<unknown, unknown>) => void;
+/**
+ * Save state of node.
+ * @param graph code graph
+ * @param nodeState node state
+ */
+export declare const saveNodeState: (graph: Graph | undefined, nodeState: ICodeNodeState<unknown, unknown>) => void;
+export {};

package/dist/lib/codeNode/defineCodeNode.d.ts

@@ -0,0 +1,15 @@
+import { Node, NodeInterface, INodeDefinition } from 'baklavajs';
+import { AbstractCodeNode, CodeNode } 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 type NodeInterfaceFactory<T> = () => NodeInterface<T>;
+export type InterfaceFactory<T> = {
+    [K in keyof T]: NodeInterfaceFactory<T[K]>;
+};
+export interface ICodeNodeDefinition<I, O> extends INodeDefinition<I, O> {
+    codeTemplate?: (node?: AbstractCodeNode) => string;
+    modules?: string[];
+    onCodeUpdate?: (node?: AbstractCodeNode) => void;
+    variableName?: string;
+}
+export declare function defineCodeNode<I, O>(definition: ICodeNodeDefinition<I, O>): new () => CodeNode<I, O>;

package/dist/lib/codeNode/dynamicCodeNode.d.ts

@@ -0,0 +1,35 @@
+import { CalculateFunction, IDynamicNodeDefinition, INodeState, NodeInterface, NodeInterfaceDefinition } from 'baklavajs';
+import { AbstractCodeNode, CodeNode } 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: INodeState<Dynamic<I>, Dynamic<O>>): void;
+    /**
+     * 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<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> {
+    codeTemplate?: (node?: AbstractCodeNode) => string;
+    modules?: string[];
+    onCodeUpdate?: (node?: AbstractCodeNode) => void;
+    variableName?: string;
+}
+export declare function defineDynamicCodeNode<I, O>(definition: IDynamicCodeNodeDefinition<I, O>): new () => DynamicCodeNode<I, O>;
+export {};

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

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

package/dist/lib/codeNodeInterfaces/baseNumericInterface.d.ts

@@ -0,0 +1,23 @@
+import { Ref } from 'vue';
+import { NodeInterface } from 'baklavajs';
+import { CodeNodeInterface } from './codeNode/codeNodeInterface';
+export interface IValidator {
+    validate: (v: number) => boolean;
+}
+export declare class BaseNumericInterface extends CodeNodeInterface<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/lib/codeNodeInterfaces/button/buttonInterface.d.ts

@@ -0,0 +1,9 @@
+import { ComponentOptions } from 'vue';
+import { ButtonInterfaceComponent } from 'baklavajs';
+import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
+export declare class ButtonInterface extends CodeNodeInterface<undefined> {
+    component: ComponentOptions;
+    callback?: () => void;
+    constructor(name: string, callback: () => void);
+}
+export { ButtonInterfaceComponent };

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

@@ -0,0 +1,7 @@
+import { ComponentOptions } from 'vue';
+import { CheckboxInterfaceComponent } from 'baklavajs';
+import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
+export declare class CheckboxInterface extends CodeNodeInterface<boolean> {
+    component: ComponentOptions;
+}
+export { CheckboxInterfaceComponent };

package/dist/lib/codeNodeInterfaces/codeInput/codeInputInterface.d.ts

@@ -0,0 +1,5 @@
+import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
+export declare class CodeInputInterface<T = unknown> extends CodeNodeInterface<T> {
+    isCodeInput: boolean;
+    constructor(name?: string, value?: T);
+}

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

@@ -0,0 +1,14 @@
+import { UnwrapRef } from 'vue';
+import { NodeInterface } from 'baklavajs';
+import { Code } from '../../code';
+interface ICodeNodeInterfaceState {
+    script: string;
+}
+export declare class CodeNodeInterface<T = unknown> extends NodeInterface<T> {
+    optional: boolean;
+    code: Code | undefined;
+    state: UnwrapRef<ICodeNodeInterfaceState>;
+    constructor(name: string, value: T);
+    get shortId(): string;
+}
+export {};

package/dist/lib/codeNodeInterfaces/codeOutput/codeOutputInterface.d.ts

@@ -0,0 +1,8 @@
+import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
+export declare class CodeOutputInterface extends CodeNodeInterface<unknown> {
+    isCodeOutput: boolean;
+    constructor(name?: string, value?: string);
+    get script(): string;
+    get value(): unknown;
+    set value(value: unknown);
+}

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

@@ -0,0 +1,12 @@
+export * from './button/buttonInterface';
+export * from './checkbox/checkboxInterface';
+export * from './codeNode/codeNodeInterface';
+export * from './integer/integerInterface';
+export * from './codeInput/codeInputInterface';
+export * from './codeOutput/codeOutputInterface';
+export * from './number/numberInterface';
+export * from './select/selectInterface';
+export * from './slider/sliderInterface';
+export * from './text/textInterface';
+export * from './textInput/textInputInterface';
+export * from './textareaInput/textareaInputInterface';

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

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

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

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

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

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

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

@@ -0,0 +1,10 @@
+import { ComponentOptions } from 'vue';
+import { SliderInterfaceComponent } from 'baklavajs';
+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);
+}
+export { SliderInterfaceComponent };

package/dist/lib/codeNodeInterfaces/text/textInterface.d.ts

@@ -0,0 +1,6 @@
+import { ComponentOptions } from 'vue';
+import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
+export declare class TextInterface extends CodeNodeInterface<string> {
+    component: ComponentOptions;
+    constructor(name: string, value: string);
+}

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

@@ -0,0 +1,8 @@
+import { ComponentOptions } from 'vue';
+import { TextInputInterfaceComponent } from 'baklavajs';
+import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
+export declare class TextInputInterface extends CodeNodeInterface<string> {
+    isString: boolean;
+    component: ComponentOptions;
+}
+export { TextInputInterfaceComponent };

package/dist/lib/codeNodeInterfaces/textareaInput/textareaInputInterface.d.ts

@@ -0,0 +1,7 @@
+import { ComponentOptions } from 'vue';
+import { TextareaInputInterfaceComponent } from 'baklavajs';
+import { CodeNodeInterface } from '../codeNode/codeNodeInterface';
+export declare class TextareaInputInterface extends CodeNodeInterface<string> {
+    component: ComponentOptions;
+}
+export { TextareaInputInterfaceComponent };

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

@@ -0,0 +1 @@
+export { default as CodeGraphEditor } from './CodeGraphEditor.vue';

package/dist/lib/icons/index.d.ts

@@ -0,0 +1,9 @@
+export { default as LayoutSidebarLeftCollapse } from './LayoutSidebarLeftCollapse.vue';
+export { default as LayoutSidebarLeftExpand } from './LayoutSidebarLeftExpand.vue';
+export { default as LayoutSidebarRight } from './LayoutSidebarRight.vue';
+export { default as LayoutSidebarRightCollapse } from './LayoutSidebarRightCollapse.vue';
+export { default as LayoutSidebarRightExpand } from './LayoutSidebarRightExpand.vue';
+export { default as Schema } from './Schema.vue';
+export { default as SchemaOff } from './SchemaOff.vue';
+export { default as TrashOff } from './TrashOff.vue';
+export { default as VerticalDots } from './VerticalDots.vue';

package/dist/lib/index.d.ts

@@ -0,0 +1,7 @@
+export * from './codeNode';
+export * from './codeNodeInterfaces';
+export * from './code';
+export * from './components';
+export * from './viewModel';
+export * from './settings';
+export * from './style.scss';

package/dist/lib/settings.d.ts

@@ -0,0 +1,10 @@
+import { IViewSettings } from 'baklavajs';
+import { ICodeGraphViewModel } from './viewModel';
+interface ICodeViewSettings extends Partial<IViewSettings> {
+    toolbar?: Partial<IViewSettings['toolbar']>;
+    nodes?: Partial<IViewSettings['nodes']>;
+    sidebar?: Partial<IViewSettings['sidebar']>;
+}
+export declare const addToolbarCommands: (viewModel: ICodeGraphViewModel) => void;
+export declare const DEFAULT_SETTINGS: ICodeViewSettings;
+export {};

package/dist/lib/viewModel.d.ts

@@ -0,0 +1,14 @@
+import { DependencyEngine, Editor, IBaklavaViewModel } from 'baklavajs';
+import { UnwrapRef } from 'vue';
+import { Code } from './code';
+export interface ICodeGraphViewModel extends IBaklavaViewModel {
+    code: Code;
+    engine: DependencyEngine;
+    state: UnwrapRef<{
+        modules: Record<string, string>;
+        token: symbol | null;
+    }>;
+    subscribe: () => void;
+    unsubscribe: () => void;
+}
+export declare function useCodeGraph(existingEditor?: Editor): ICodeGraphViewModel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@babsey/code-graph",
-  "version": "0.0.0",
+  "version": "0.0.1",
   "author": "babsey <spreizer@web.de>",
   "license": "MIT",
   "type": "module",
@@ -57,6 +57,7 @@
     "rimraf": "~6.0",
     "sass-embedded": "~1.93",
     "typescript": "~5.9",
+    "unplugin-dts": "^1.0.0-beta.6",
     "vite": "~7.1",
     "vite-plugin-dts": "~4.5",
     "vite-plugin-vue-devtools": "~8.0",