@nodish/core 0.1.3 → 0.2.0

package/dist/src/store/model.d.ts

@@ -1,241 +0,0 @@
-import { NodePack } from './registry';
-export type NodeId = string;
-export type PortId = string;
-export type ConnectionId = string;
-export type NodeTypeId = string;
-export type NodeLocation = {
-    x: number;
-    y: number;
-};
-/** Key into the {@link TypeRegistry} (e.g. `"number"`). */
-export type PortTypeId = string;
-export type PortType = PortTypeId;
-/**
- * Serializable widget descriptor for port value editing and display. Lives on the
- * type definition; the Vue viewer resolves it to a concrete component.
- */
-export type TypeWidgetSpec = {
-    kind: "number";
-    min?: number;
-    max?: number;
-    step?: number;
-    /** Port row height in px; defaults to one line (20px). */
-    rowHeight?: number;
-} | {
-    kind: "text";
-    /** Multiline row count; height is `rows × 20px` unless `rowHeight` is set. */
-    rows?: number;
-    /** Port row height in px; overrides `rows`. */
-    rowHeight?: number;
-} | {
-    kind: "custom";
-    /** Id passed to `registerComponentWidget` in a pack's `setup` hook. */
-    componentId: string;
-    /** Port row height in px; defaults to one line (20px). */
-    rowHeight?: number;
-};
-/**
- * A registered data type. Carries validation, connection compatibility, and
- * optional value lifecycle hooks. Registered at startup — only {@link PortTypeId}
- * keys on ports are serialized in documents.
- */
-export interface PortTypeDefinition {
-    id: PortTypeId;
-    label: string;
-    color: string;
-    validate: (value: unknown) => boolean;
-    /**
-     * Whether an output of type `from` may connect into an input of this type.
-     * Decided by the destination type. Omitted means strict identity (`from === id`).
-     */
-    accepts?: (from: PortTypeId) => boolean;
-    /** Fallback when a port of this type omits its own default. */
-    defaultValue?: unknown;
-    /** Display/edit descriptor for the viewer (no functions). */
-    widget?: TypeWidgetSpec;
-    /** Parse a raw string (e.g. from an input field) into a value. */
-    parse?: (raw: string) => unknown;
-    /** Format a value for display in the viewer. */
-    format?: (value: unknown) => string;
-    /** Normalize or clamp a value after edit or connection. */
-    coerce?: (value: unknown) => unknown;
-}
-/** Library of available data types, keyed by id. */
-export type TypeRegistry = Record<PortTypeId, PortTypeDefinition>;
-export type PortDirection = "input" | "output";
-/**
- * Port template declared by a node type ({@link IndefiniteNode}). Has no id and
- * no live value — only describes ports that instances will receive.
- */
-export type PortDefinition = {
-    /** Stable, human-authored key; referenced inside `execute()`. */
-    name: string;
-    type: PortType;
-    /** Used by an input when nothing is connected to it. */
-    defaultValue?: unknown;
-    description?: string;
-    /**
-     * Input-only. Never accepts a connection — no socket, always shows its widget.
-     * Also feeds parameters into {@link IndefiniteNode.resolvePorts}.
-     */
-    userOnly?: boolean;
-    /**
-     * Input-only. Accepts any number of incoming connections; `execute()` receives
-     * values as an unordered array of `type`.
-     */
-    multi?: boolean;
-    /**
-     * Widget-specific configuration merged on top of the type's widget spec.
-     * Recognized keys: `options`, `min`, `max`, `step`, `rows`, `rowHeight`.
-     */
-    customProps?: Record<string, unknown>;
-};
-/**
- * Materialized port on a placed node ({@link DefiniteNode}). Has a unique id so
- * connections and the DOM can reference it directly.
- */
-export type Port = {
-    id: PortId;
-    /** Matches the {@link PortDefinition.name} it came from. */
-    name: string;
-    type: PortType;
-    direction: PortDirection;
-    /** Input: value when disconnected. Output: optional cache of last computed value. */
-    value?: unknown;
-    userOnly?: boolean;
-    multi?: boolean;
-    customProps?: Record<string, unknown>;
-};
-/** Port templates on a definition, keyed by name (authoring-friendly). */
-export type NodeIODefinition = Record<string, PortDefinition>;
-/** Materialized ports on an instance, keyed by id (connection/DOM-friendly). */
-export type NodeIO = Record<PortId, Port>;
-/** Reference to one port on one node. */
-export type PortRef = {
-    node: NodeId;
-    port: PortId;
-};
-/**
- * Node type template that {@link DefiniteNode} instances are created from. Lives
- * in the runtime registry only (never in a saved graph). Authors ship types via
- * {@link NodePack}.
- *
- * - **Primitive:** implements {@link IndefiniteNode.execute}.
- * - **Composite:** supplies a nested {@link IndefiniteNode.graph} instead of `execute`.
- */
-export interface IndefiniteNode {
-    /** Unique node type id (e.g. `"my-pack/add"`). */
-    typeId: NodeTypeId;
-    displayName: string;
-    color: string;
-    description: string;
-    /**
-     * Hierarchical menu category, broadest first, e.g. `["Math", "Basic Operations"]`.
-     * Empty or omitted places the node at the menu root.
-     */
-    group?: string[];
-    inputs: NodeIODefinition;
-    outputs: NodeIODefinition;
-    /**
-     * Runtime evaluation, keyed by port name (not id). Omit for composite types.
-     * @returns Output values keyed by port name.
-     */
-    execute?: (inputs: Record<string, unknown>) => Record<string, unknown>;
-    /** Nested subgraph for composite types (registry-only, not evaluated standalone). */
-    graph?: NodeGraph;
-    /**
-     * Dynamic port count driven by user-only inputs. When present, static
-     * `inputs`/`outputs` are initial defaults; reconciliation re-materializes
-     * ports by name so existing ids and connections survive a recount.
-     */
-    resolvePorts?: (params: Record<string, unknown>) => {
-        inputs: NodeIODefinition;
-        outputs: NodeIODefinition;
-    };
-}
-/**
- * A node placed on the workspace. Serializable data only — behaviour lives on
- * the {@link IndefiniteNode} referenced by {@link DefiniteNode.typeId}.
- */
-export interface DefiniteNode {
-    id: NodeId;
-    /** {@link IndefiniteNode} this instance was created from. */
-    typeId: NodeTypeId;
-    location: NodeLocation;
-    inputs: NodeIO;
-    outputs: NodeIO;
-    label?: string;
-    color?: string;
-    /** Node width in px. Falls back to layout default when undefined. */
-    width?: number;
-    /**
-     * Stacking order — higher paints on top. Stored for save/load. Undefined until
-     * first assigned.
-     */
-    z?: number;
-    /** Nested graph for composite/group instances. Serializable with the node. */
-    composite?: CompositeState;
-}
-/** Serializable nested graph owned by a composite instance. */
-export interface CompositeState {
-    graph: NodeGraph;
-    interface: GraphInterface;
-}
-/**
- * Directed wire from an output port to an input port. Stored centrally on the
- * graph so either endpoint can be looked up uniformly.
- */
-export interface Connection {
-    id: ConnectionId;
-    /** Must reference an output port. */
-    from: PortRef;
-    /** Must reference an input port. */
-    to: PortRef;
-}
-/** Serializable port template for boundary definitions (object key = port name). */
-export type GraphPortSpec = Omit<PortDefinition, "name">;
-/**
- * External signature of a graph. Parameters become the Input node's output ports;
- * returns become the Output node's input ports.
- */
-export interface GraphInterface {
-    /** Graph inputs (function parameters). Key = port name. */
-    parameters?: Record<string, GraphPortSpec>;
-    /** Graph outputs (return values). Key = port name. */
-    returns?: Record<string, GraphPortSpec>;
-}
-export declare const defaultGraphInterface: GraphInterface;
-/**
- * Placed nodes and connections. Every graph must contain exactly one Input node
- * and one Output node.
- */
-export interface NodeGraph {
-    nodes: DefiniteNode[];
-    connections: Connection[];
-}
-/**
- * Serializable graph snapshot. Contains no `execute()` implementations or type
- * definitions — custom nodes are resolved at runtime from loaded {@link NodePack}s.
- */
-export interface GraphDocument {
-    graph: NodeGraph;
-    interface: GraphInterface;
-    /** Pack ids required to interpret this document. See {@link NodeMap.extensions}. */
-    extensions?: string[];
-}
-/** Library of available node types, keyed by {@link NodeTypeId}. */
-export type NodeRegistry = Record<NodeTypeId, IndefiniteNode>;
-/** In-memory workspace: serializable graph plus runtime type and node registries. */
-export interface NodeMap {
-    graph: NodeGraph;
-    types: TypeRegistry;
-    nodeTypes: NodeRegistry;
-    /** Ids of packs loaded via {@link NodeMap.loadPack}. */
-    extensions: string[];
-    graphInterface: GraphInterface;
-    /**
-     * Register types, nodes, and optional widget setup from a pack.
-     * @returns Registration errors (empty array on success).
-     */
-    loadPack(pack: NodePack): string[];
-}

package/dist/src/store/nodes/index.d.ts

@@ -1,2 +0,0 @@
-import { NodeSpecRegistry } from '../registry/defineNode';
-export declare const defaultNodes: NodeSpecRegistry;

package/dist/src/store/nodes/io.d.ts

@@ -1,46 +0,0 @@
-import { NodeSpec } from '../registry/defineNode';
-import { DefiniteNode, GraphInterface, NodeMap } from '../model';
-/** {@link IndefiniteNode.typeId} for the graph Input (Group Input) boundary node. */
-export declare const INPUT_TYPE = "io/input";
-/** {@link IndefiniteNode.typeId} for the graph Output (Group Output) boundary node. */
-export declare const OUTPUT_TYPE = "io/output";
-export declare const DEFAULT_BOUNDARY_LAYOUT: {
-    input: {
-        x: number;
-        y: number;
-    };
-    output: {
-        x: number;
-        y: number;
-    };
-};
-export type { GraphInterface } from '../model';
-export { defaultGraphInterface as defaultInterface } from '../model';
-export declare function createIONodes(iface?: GraphInterface): {
-    input: NodeSpec;
-    output: NodeSpec;
-};
-export declare function applyGraphInterface(map: NodeMap, iface: GraphInterface): void;
-/**
- * Return the single Input and Output nodes on the graph.
- * @throws When the graph does not contain exactly one of each.
- */
-export declare function boundaryNodes(map: NodeMap): {
-    input: DefiniteNode;
-    output: DefiniteNode;
-};
-export declare function ensureBoundaryNodes(map: NodeMap, layout?: {
-    input: {
-        x: number;
-        y: number;
-    };
-    output: {
-        x: number;
-        y: number;
-    };
-}): {
-    input: DefiniteNode;
-    output: DefiniteNode;
-};
-export declare function updateGraphInterface(map: NodeMap, iface: GraphInterface): string[];
-export declare function validateBoundary(map: NodeMap): string[];

package/dist/src/store/nodes/math.d.ts

@@ -1,4 +0,0 @@
-import { NodeSpec } from '../registry/defineNode';
-export declare const addNode: NodeSpec;
-export declare const multiplyNode: NodeSpec;
-export declare const divideNode: NodeSpec;

package/dist/src/store/packs/core.d.ts

@@ -1,3 +0,0 @@
-import { NodePack } from '../registry';
-export declare const CORE_PACK_ID = "@local/core";
-export declare const corePack: NodePack;

package/dist/src/store/packs/installPack.d.ts

@@ -1,4 +0,0 @@
-import { NodeMap } from '../model';
-import { NodePack, PackSetupContext } from '../registry';
-export type { NodePack, PackSetupContext } from '../registry';
-export declare function installPack(map: NodeMap, pack: NodePack, setupCtx?: PackSetupContext): string[];

package/dist/src/store/registry/defineNode.d.ts

@@ -1,50 +0,0 @@
-import { GraphPortSpec, IndefiniteNode, NodeGraph, NodeTypeId } from '../model';
-/**
- * Port in a node spec — same as {@link GraphPortSpec}; the name comes from the
- * object key so authors do not repeat it.
- */
-export type PortSpec = GraphPortSpec;
-/** Input or output port templates keyed by port name. */
-export type IOSpec = Record<string, PortSpec>;
-/**
- * Authoring form of {@link IndefiniteNode.resolvePorts}. Returns ports in
- * {@link IOSpec} shape; normalized when registered via {@link registerNodeTypes}.
- */
-export type DynamicPortsSpec = (params: Record<string, unknown>) => {
-    inputs?: IOSpec;
-    outputs?: IOSpec;
-};
-/**
- * Authoring format for a node type. Normalized into a full {@link IndefiniteNode}
- * when registered on a {@link NodeMap} (via {@link NodePack} or
- * {@link registerNodeTypes}).
- */
-export interface NodeSpec {
-    /** Unique node type id (e.g. `"my-pack/add"`). */
-    typeId: NodeTypeId;
-    displayName: string;
-    color?: string;
-    description?: string;
-    /**
-     * Hierarchical menu category, broadest first. See {@link IndefiniteNode.group}.
-     */
-    group?: string[];
-    inputs?: IOSpec;
-    outputs?: IOSpec;
-    /**
-     * Runtime evaluation, keyed by port name. Omit for composite node packs.
-     * @returns Output values keyed by port name.
-     */
-    execute?: (inputs: Record<string, unknown>) => Record<string, unknown>;
-    /** Nested subgraph for composite types in a published pack. Not evaluated yet. */
-    graph?: NodeGraph;
-    /**
-     * Dynamic port count driven by user-only inputs. Static `inputs`/`outputs`
-     * act as initial defaults when present.
-     */
-    resolvePorts?: DynamicPortsSpec;
-}
-/** Node types in authoring form, keyed by {@link NodeTypeId}. */
-export type NodeSpecRegistry = Record<NodeTypeId, NodeSpec>;
-/** Expand a {@link NodeSpec} into a runtime {@link IndefiniteNode}. */
-export declare function normalizeNode(spec: NodeSpec): IndefiniteNode;

package/dist/src/store/registry/defineType.d.ts

@@ -1,31 +0,0 @@
-import { PortTypeDefinition, PortTypeId, TypeWidgetSpec } from '../model';
-/**
- * Authoring format for a data type. {@link defineType} expands this into a full
- * {@link PortTypeDefinition} (default label, color, and widget lifecycle hooks).
- */
-export interface TypeSpec {
-    /** Unique type id (e.g. `"number"`, `"my-pack/label"`). */
-    id: PortTypeId;
-    label?: string;
-    color?: string;
-    validate: (value: unknown) => boolean;
-    /**
-     * Whether an output of type `from` may connect into ports of this type.
-     * Omitted means strict identity.
-     */
-    accepts?: (from: PortTypeId) => boolean;
-    /** Fallback when a port of this type omits its own default. */
-    defaultValue?: unknown;
-    /** Viewer widget descriptor for ports of this type. */
-    widget?: TypeWidgetSpec;
-    /** Override default parse behaviour for this type's widget. */
-    parse?: (raw: string) => unknown;
-    /** Override default format behaviour for this type's widget. */
-    format?: (value: unknown) => string;
-    /** Override default coerce behaviour for this type's widget. */
-    coerce?: (value: unknown) => unknown;
-}
-/**
- * Turn a {@link TypeSpec} into a complete {@link PortTypeDefinition}.
- */
-export declare function defineType(spec: TypeSpec): PortTypeDefinition;

package/dist/src/store/registry/groups.d.ts

@@ -1,9 +0,0 @@
-import { IndefiniteNode, NodeRegistry } from '../model';
-export interface NodeGroup {
-    name: string;
-    path: string[];
-    subgroups: NodeGroup[];
-    nodes: IndefiniteNode[];
-}
-export declare function buildNodeGroupTree(registry: NodeRegistry, filter?: (node: IndefiniteNode) => boolean): NodeGroup;
-export declare function sortNodeGroupTree(group: NodeGroup): NodeGroup;

package/dist/src/store/registry/index.d.ts

@@ -1,39 +0,0 @@
-import { Component } from 'vue';
-import { NodeMap, TypeRegistry } from '../model';
-import { NodeSpecRegistry } from './defineNode';
-/**
- * A publishable bundle of custom types and/or node types (npm package contents).
- * Load onto a {@link NodeMap} with {@link NodeMap.loadPack}.
- */
-export interface NodePack {
-    /** Unique pack id (e.g. `"@my-org/my-pack"`). Recorded in {@link GraphDocument.extensions}. */
-    id: string;
-    /** Custom {@link PortTypeDefinition}s to register. */
-    types?: TypeRegistry;
-    /** Custom node definitions to register (authoring form). */
-    nodeTypes?: NodeSpecRegistry;
-    /**
-     * Optional hook to register Vue widgets after types and nodes are merged.
-     * Runs once per pack load.
-     */
-    setup?: (ctx: PackSetupContext) => void;
-}
-/** Context passed to {@link NodePack.setup} for widget registration. */
-export interface PackSetupContext {
-    /**
-     * Bind a Vue component to all editable ports of a type id.
-     * Overrides the generic widget for that type.
-     */
-    registerTypeWidget: (typeId: string, component: Component) => void;
-    /**
-     * Bind a Vue component to a custom widget id
-     * ({@link TypeWidgetSpec} `kind: "custom"`).
-     */
-    registerComponentWidget: (componentId: string, component: Component) => void;
-}
-export declare function registerTypes(map: NodeMap, types: TypeRegistry): void;
-/** Merge node specs into the runtime registry, expanding ports and defaults. */
-export declare function registerNodeTypes(map: NodeMap, nodeTypes: NodeSpecRegistry): void;
-export declare function registerNodePack(map: NodeMap, pack: NodePack): void;
-export declare function unregisterNodePack(map: NodeMap, packId: string): void;
-export type { NodeSpecRegistry } from './defineNode';

package/dist/src/store/types/effectiveWidget.d.ts

@@ -1,4 +0,0 @@
-import { Port, PortTypeDefinition, TypeWidgetSpec } from '../model';
-export declare function effectiveWidget(typeDef: PortTypeDefinition | undefined, port: Port): TypeWidgetSpec | undefined;
-/** Height in px implied by a widget spec (before port.customProps.rowHeight override). */
-export declare function widgetRowHeight(widget: TypeWidgetSpec | undefined, defaultRowH: number): number;

package/dist/src/store/types/index.d.ts

@@ -1,4 +0,0 @@
-import { TypeRegistry } from '../model';
-export declare const numberType: import('../model').PortTypeDefinition;
-export declare const stringType: import('../model').PortTypeDefinition;
-export declare const defaultTypes: TypeRegistry;

package/dist/src/store/utils/clonePlain.d.ts

@@ -1 +0,0 @@
-export declare function clonePlain<T>(value: T): T;

package/dist/src/vue/attachLoadPack.d.ts

@@ -1,2 +0,0 @@
-import { NodeMap } from '../store/model';
-export declare function attachLoadPack(map: NodeMap): void;

package/dist/src/vue/createNodeMap.d.ts

@@ -1,11 +0,0 @@
-import { CreateNodeMapInit } from '../store/graph/createNodeMap';
-import { GraphDocument } from '../store/model';
-export type { CreateNodeMapInit, GraphDocument };
-/**
- * Create an in-memory graph workspace with registries, boundary nodes, and
- * {@link NodeMap.loadPack} wired for widget setup.
- *
- * Loads the built-in core pack by default unless `defaultPack: false`.
- * Registers built-in number/string widgets on first call.
- */
-export declare function createNodeMap(init?: CreateNodeMapInit): import('.').NodeMap;

package/dist/src/vue/index.d.ts

@@ -1,10 +0,0 @@
-export { default as NodeViewer } from '../components/NodeViewer.vue';
-export { createNodeMap } from './createNodeMap';
-export type { CreateNodeMapInit } from './createNodeMap';
-export { applyDocument, exportGraph, importGraph, parseGraphDocument, serializeDocument, validateDocument, } from '../store/graph/document';
-export { runGraph, type GraphRunResult, type Values, } from '../store/graph/evaluate';
-export { instantiate } from '../store/graph/instance';
-export { boundaryNodes, INPUT_TYPE, OUTPUT_TYPE } from '../store/nodes/io';
-export { registerComponentWidget, registerDefaultTypeWidgets, registerTypeWidget, } from '../components/types/registerDefaultTypeWidgets';
-export type { Connection, ConnectionId, DefiniteNode, GraphDocument, GraphInterface, IndefiniteNode, NodeGraph, NodeId, NodeMap, NodeRegistry, Port, PortRef, PortTypeDefinition, PortTypeId, TypeRegistry, } from '../store/model';
-export * from '../pack/index';