@memberjunction/ng-task-graph-editor 0.0.0 → 6.1.0-edge.1

package/dist/lib/task-graph-editor-events.js

@@ -0,0 +1,180 @@
+/**
+ * Base for every cancelable graph event.
+ *
+ * A listener flips `Cancel = true` to halt the default behavior; the matching `After*` event will
+ * then **not** fire. That is a contract hosts rely on, not a suggestion.
+ */
+export class CancellableTaskGraphEventArgs {
+    Cancel = false;
+    CancelReason;
+}
+// ── Node lifecycle ───────────────────────────────────────────────────────────
+/** Fired BEFORE a task is added. Cancel to block it (e.g. the host caps graph size). */
+export class BeforeTaskAddedEventArgs extends CancellableTaskGraphEventArgs {
+    Task;
+    constructor(Task) {
+        super();
+        this.Task = Task;
+    }
+}
+/** Fired AFTER a task was added. NOT fired when the Before was canceled. */
+export class AfterTaskAddedEventArgs {
+    Task;
+    Spec;
+    constructor(Task, Spec) {
+        this.Task = Task;
+        this.Spec = Spec;
+    }
+}
+/**
+ * Fired BEFORE a task is removed. Cancel to block it.
+ *
+ * `DependentTempIds` is supplied because removing a node also severs every edge into it, and a host
+ * deciding whether to veto needs to know the blast radius — not just which node was clicked.
+ */
+export class BeforeTaskRemovedEventArgs extends CancellableTaskGraphEventArgs {
+    Task;
+    DependentTempIds;
+    constructor(Task, DependentTempIds) {
+        super();
+        this.Task = Task;
+        this.DependentTempIds = DependentTempIds;
+    }
+}
+/** Fired AFTER a task was removed. NOT fired when the Before was canceled. */
+export class AfterTaskRemovedEventArgs {
+    Task;
+    Spec;
+    constructor(Task, Spec) {
+        this.Task = Task;
+        this.Spec = Spec;
+    }
+}
+/** Fired BEFORE a task's properties change. Cancel to block the edit. */
+export class BeforeTaskUpdatedEventArgs extends CancellableTaskGraphEventArgs {
+    Previous;
+    Next;
+    constructor(Previous, Next) {
+        super();
+        this.Previous = Previous;
+        this.Next = Next;
+    }
+}
+/** Fired AFTER a task's properties changed. NOT fired when the Before was canceled. */
+export class AfterTaskUpdatedEventArgs {
+    Task;
+    Spec;
+    constructor(Task, Spec) {
+        this.Task = Task;
+        this.Spec = Spec;
+    }
+}
+// ── Edge lifecycle ───────────────────────────────────────────────────────────
+/**
+ * Fired BEFORE a dependency edge is created. Cancel to block it.
+ *
+ * `WouldCreateCycle` is computed before emitting so a host can veto on that alone without
+ * re-deriving it. The component refuses a cycle regardless — the flag exists so the host can
+ * explain *why* rather than watch an edge silently fail to appear.
+ */
+export class BeforeDependencyAddedEventArgs extends CancellableTaskGraphEventArgs {
+    FromTempId;
+    ToTempId;
+    WouldCreateCycle;
+    constructor(FromTempId, ToTempId, WouldCreateCycle) {
+        super();
+        this.FromTempId = FromTempId;
+        this.ToTempId = ToTempId;
+        this.WouldCreateCycle = WouldCreateCycle;
+    }
+}
+/** Fired AFTER a dependency edge was created. NOT fired when the Before was canceled. */
+export class AfterDependencyAddedEventArgs {
+    FromTempId;
+    ToTempId;
+    Spec;
+    constructor(FromTempId, ToTempId, Spec) {
+        this.FromTempId = FromTempId;
+        this.ToTempId = ToTempId;
+        this.Spec = Spec;
+    }
+}
+/** Fired BEFORE a dependency edge is removed. Cancel to block it. */
+export class BeforeDependencyRemovedEventArgs extends CancellableTaskGraphEventArgs {
+    FromTempId;
+    ToTempId;
+    constructor(FromTempId, ToTempId) {
+        super();
+        this.FromTempId = FromTempId;
+        this.ToTempId = ToTempId;
+    }
+}
+/** Fired AFTER a dependency edge was removed. NOT fired when the Before was canceled. */
+export class AfterDependencyRemovedEventArgs {
+    FromTempId;
+    ToTempId;
+    Spec;
+    constructor(FromTempId, ToTempId, Spec) {
+        this.FromTempId = FromTempId;
+        this.ToTempId = ToTempId;
+        this.Spec = Spec;
+    }
+}
+// ── Informational ────────────────────────────────────────────────────────────
+//
+// Single emitters, no Before pair. Per the layering guide: don't invent a veto for something that
+// cannot be vetoed. A selection that already happened and a validation that already ran are facts,
+// not requests.
+/** The spec changed for any reason. Hosts persist from here. */
+export class TaskGraphSpecChangedEventArgs {
+    Spec;
+    Reason;
+    constructor(Spec, Reason) {
+        this.Spec = Spec;
+        this.Reason = Reason;
+    }
+}
+/** Selection changed. `Task` is null when the selection was cleared. */
+export class TaskGraphSelectionChangedEventArgs {
+    Task;
+    constructor(Task) {
+        this.Task = Task;
+    }
+}
+/**
+ * Validation ran.
+ *
+ * Errors come from the engine's own `ValidateTaskGraphSpec`, not from a second implementation here —
+ * so a graph that looks valid on the canvas cannot fail a different check at submission.
+ */
+export class TaskGraphValidationChangedEventArgs {
+    Valid;
+    Errors;
+    constructor(Valid, Errors) {
+        this.Valid = Valid;
+        this.Errors = Errors;
+    }
+}
+// ── Intent-only (navigation the HOST performs) ───────────────────────────────
+//
+// A widget at this layer must not navigate: it has no Router, and it cannot know whether it is
+// inside Explorer, a downstream app, or an embedded panel. It reports the intent; the host decides.
+/** The user asked to open the agent behind a task. The host navigates. */
+export class AgentOpenRequestedEventArgs {
+    AgentName;
+    Task;
+    constructor(AgentName, Task) {
+        this.AgentName = AgentName;
+        this.Task = Task;
+    }
+}
+/** The user asked to open a record referenced by the graph. The host navigates. */
+export class RecordOpenRequestedEventArgs {
+    EntityName;
+    RecordID;
+    constructor(EntityName, RecordID) {
+        this.EntityName = EntityName;
+        this.RecordID = RecordID;
+    }
+}
+//# sourceMappingURL=task-graph-editor-events.js.map

package/dist/lib/task-graph-editor-events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-editor-events.js","sourceRoot":"","sources":["../../src/lib/task-graph-editor-events.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @fileoverview The component's upward contract.\n *\n * Follows MJ's `Before*` / `After*` cancelable pattern (see `guides/UI_LAYERING_GUIDE.md` §6),\n * already used by `ng-base-forms`, `ng-trees`, `ng-entity-viewer` and `ng-conversations`.\n *\n * **Why the args are classes and not payload interfaces.** `Cancel` has to travel *back*. Angular's\n * `EventEmitter` is synchronous for synchronous listeners, so the emitting component reads the\n * mutated object after `.emit()` returns — that is the entire veto mechanism. A frozen payload\n * cannot carry a veto, and a class additionally gives one place for defaults and future fields.\n *\n * **A `Before*` handler must not be `async`.** An `await` inside it returns control to the emitter\n * before the handler sets `Cancel`, so the veto silently does nothing. Where a host genuinely needs\n * to await — a confirmation dialog — the component exposes the action as a public method the host\n * calls *after* its own await, rather than pretending the veto is asynchronous.\n *\n * @module @memberjunction/ng-task-graph-editor\n */\nimport type { TaskGraphSpec, TaskGraphSpecNode, TaskGraphValidationError } from '@memberjunction/ai-core-plus';\n\n/**\n * Base for every cancelable graph event.\n *\n * A listener flips `Cancel = true` to halt the default behavior; the matching `After*` event will\n * then **not** fire. That is a contract hosts rely on, not a suggestion.\n */\nexport class CancellableTaskGraphEventArgs {\n    public Cancel: boolean = false;\n    public CancelReason?: string;\n}\n\n// ── Node lifecycle ───────────────────────────────────────────────────────────\n\n/** Fired BEFORE a task is added. Cancel to block it (e.g. the host caps graph size). */\nexport class BeforeTaskAddedEventArgs extends CancellableTaskGraphEventArgs {\n    constructor(public readonly Task: TaskGraphSpecNode) { super(); }\n}\n\n/** Fired AFTER a task was added. NOT fired when the Before was canceled. */\nexport class AfterTaskAddedEventArgs {\n    constructor(\n        public readonly Task: TaskGraphSpecNode,\n        public readonly Spec: TaskGraphSpec,\n    ) {}\n}\n\n/**\n * Fired BEFORE a task is removed. Cancel to block it.\n *\n * `DependentTempIds` is supplied because removing a node also severs every edge into it, and a host\n * deciding whether to veto needs to know the blast radius — not just which node was clicked.\n */\nexport class BeforeTaskRemovedEventArgs extends CancellableTaskGraphEventArgs {\n    constructor(\n        public readonly Task: TaskGraphSpecNode,\n        public readonly DependentTempIds: readonly string[],\n    ) { super(); }\n}\n\n/** Fired AFTER a task was removed. NOT fired when the Before was canceled. */\nexport class AfterTaskRemovedEventArgs {\n    constructor(\n        public readonly Task: TaskGraphSpecNode,\n        public readonly Spec: TaskGraphSpec,\n    ) {}\n}\n\n/** Fired BEFORE a task's properties change. Cancel to block the edit. */\nexport class BeforeTaskUpdatedEventArgs extends CancellableTaskGraphEventArgs {\n    constructor(\n        public readonly Previous: TaskGraphSpecNode,\n        public readonly Next: TaskGraphSpecNode,\n    ) { super(); }\n}\n\n/** Fired AFTER a task's properties changed. NOT fired when the Before was canceled. */\nexport class AfterTaskUpdatedEventArgs {\n    constructor(\n        public readonly Task: TaskGraphSpecNode,\n        public readonly Spec: TaskGraphSpec,\n    ) {}\n}\n\n// ── Edge lifecycle ───────────────────────────────────────────────────────────\n\n/**\n * Fired BEFORE a dependency edge is created. Cancel to block it.\n *\n * `WouldCreateCycle` is computed before emitting so a host can veto on that alone without\n * re-deriving it. The component refuses a cycle regardless — the flag exists so the host can\n * explain *why* rather than watch an edge silently fail to appear.\n */\nexport class BeforeDependencyAddedEventArgs extends CancellableTaskGraphEventArgs {\n    constructor(\n        public readonly FromTempId: string,\n        public readonly ToTempId: string,\n        public readonly WouldCreateCycle: boolean,\n    ) { super(); }\n}\n\n/** Fired AFTER a dependency edge was created. NOT fired when the Before was canceled. */\nexport class AfterDependencyAddedEventArgs {\n    constructor(\n        public readonly FromTempId: string,\n        public readonly ToTempId: string,\n        public readonly Spec: TaskGraphSpec,\n    ) {}\n}\n\n/** Fired BEFORE a dependency edge is removed. Cancel to block it. */\nexport class BeforeDependencyRemovedEventArgs extends CancellableTaskGraphEventArgs {\n    constructor(\n        public readonly FromTempId: string,\n        public readonly ToTempId: string,\n    ) { super(); }\n}\n\n/** Fired AFTER a dependency edge was removed. NOT fired when the Before was canceled. */\nexport class AfterDependencyRemovedEventArgs {\n    constructor(\n        public readonly FromTempId: string,\n        public readonly ToTempId: string,\n        public readonly Spec: TaskGraphSpec,\n    ) {}\n}\n\n// ── Informational ────────────────────────────────────────────────────────────\n//\n// Single emitters, no Before pair. Per the layering guide: don't invent a veto for something that\n// cannot be vetoed. A selection that already happened and a validation that already ran are facts,\n// not requests.\n\n/** The spec changed for any reason. Hosts persist from here. */\nexport class TaskGraphSpecChangedEventArgs {\n    constructor(\n        public readonly Spec: TaskGraphSpec,\n        public readonly Reason: 'TaskAdded' | 'TaskRemoved' | 'TaskUpdated' | 'DependencyAdded' | 'DependencyRemoved' | 'LayoutApplied',\n    ) {}\n}\n\n/** Selection changed. `Task` is null when the selection was cleared. */\nexport class TaskGraphSelectionChangedEventArgs {\n    constructor(public readonly Task: TaskGraphSpecNode | null) {}\n}\n\n/**\n * Validation ran.\n *\n * Errors come from the engine's own `ValidateTaskGraphSpec`, not from a second implementation here —\n * so a graph that looks valid on the canvas cannot fail a different check at submission.\n */\nexport class TaskGraphValidationChangedEventArgs {\n    constructor(\n        public readonly Valid: boolean,\n        public readonly Errors: readonly TaskGraphValidationError[],\n    ) {}\n}\n\n// ── Intent-only (navigation the HOST performs) ───────────────────────────────\n//\n// A widget at this layer must not navigate: it has no Router, and it cannot know whether it is\n// inside Explorer, a downstream app, or an embedded panel. It reports the intent; the host decides.\n\n/** The user asked to open the agent behind a task. The host navigates. */\nexport class AgentOpenRequestedEventArgs {\n    constructor(\n        public readonly AgentName: string,\n        public readonly Task: TaskGraphSpecNode,\n    ) {}\n}\n\n/** The user asked to open a record referenced by the graph. The host navigates. */\nexport class RecordOpenRequestedEventArgs {\n    constructor(\n        public readonly EntityName: string,\n        public readonly RecordID: string,\n    ) {}\n}\n"]}

package/dist/lib/task-graph-editor.component.d.ts

@@ -0,0 +1,128 @@
+/**
+ * @fileoverview View and edit a `TaskGraphSpec` on a canvas.
+ *
+ * **What makes this reusable is its subject.** It edits `TaskGraphSpec` — the one fully-qualified
+ * graph contract every producer in the program already authors against (D16) — rather than any
+ * particular persistence. A design-time flow, a graph an agent emitted at runtime, a stored workflow
+ * definition and a graph a person is drawing from scratch are all the same type here, so one
+ * component serves the Flow Agent editor, the Agent Run admin view, conversation plan cards, the
+ * Tasks view, and anything downstream.
+ *
+ * The alternative — teaching the existing agent editor a second dialect — is precisely how the two
+ * graph models drifted apart before Phase 4 pulled them onto one traversal engine.
+ *
+ * **Layer: `widgets` (L1/L2).** No `@angular/router`, no `@memberjunction/ng-shared`, no
+ * `NavigationService`. Route-derived state arrives as `@Input()`; navigation *intent* leaves as an
+ * `@Output()` the host acts on, because a widget cannot know whether it is inside Explorer, a
+ * downstream app, or an embedded panel. See `guides/UI_LAYERING_GUIDE.md`.
+ *
+ * **Validation is the engine's.** Cycles, unknown dependency refs and assignment conflicts are
+ * reported by calling `ValidateTaskGraphSpec` from `@memberjunction/ai-core-plus` — the same
+ * function `LoopAgentType` and `TaskGraphService.Submit` call. A second implementation here would be
+ * a second definition of "valid", and the graph that passes on the canvas would be free to fail at
+ * submission.
+ *
+ * @module @memberjunction/ng-task-graph-editor
+ */
+import { EventEmitter } from '@angular/core';
+import { BaseAngularComponent } from '@memberjunction/ng-base-types';
+import { type TaskGraphSpec, type TaskGraphSpecNode, type TaskGraphValidationError } from '@memberjunction/ai-core-plus';
+import type { FlowConnection, FlowConnectionCreatedEvent, FlowLayoutDirection, FlowNode, FlowNodeTypeConfig } from '@memberjunction/ng-flow-editor';
+import { type TaskGraphRuntimeStatus } from './task-graph-canvas-adapter';
+import { AfterDependencyAddedEventArgs, AfterDependencyRemovedEventArgs, AfterTaskAddedEventArgs, AfterTaskRemovedEventArgs, AfterTaskUpdatedEventArgs, AgentOpenRequestedEventArgs, BeforeDependencyAddedEventArgs, BeforeDependencyRemovedEventArgs, BeforeTaskAddedEventArgs, BeforeTaskRemovedEventArgs, BeforeTaskUpdatedEventArgs, RecordOpenRequestedEventArgs, TaskGraphSelectionChangedEventArgs, TaskGraphSpecChangedEventArgs, TaskGraphValidationChangedEventArgs } from './task-graph-editor-events';
+import * as i0 from "@angular/core";
+export declare class TaskGraphEditorComponent extends BaseAngularComponent {
+    /**
+     * The graph to show. Setter-based rather than `ngOnChanges` (repo convention): the reaction is
+     * explicit, runs only when this property changes, and costs nothing on other change-detection
+     * passes.
+     */
+    set Spec(value: TaskGraphSpec | null);
+    get Spec(): TaskGraphSpec | null;
+    /**
+     * Live per-task state, keyed by `tempId`. Supplying it turns the canvas into a runtime view of
+     * the same graph — the convergence point the program was aiming at: one renderer for design time
+     * and run time, rather than an editor and a separate Gantt that can disagree.
+     */
+    set RuntimeStatus(value: TaskGraphRuntimeStatus | null);
+    get RuntimeStatus(): TaskGraphRuntimeStatus | null;
+    /** Read-only mode. The same component is the viewer — there is no second, weaker renderer. */
+    ReadOnly: boolean;
+    ShowToolbar: boolean;
+    ShowPalette: boolean;
+    ShowMinimap: boolean;
+    ShowStatusBar: boolean;
+    AutoLayoutDirection: FlowLayoutDirection;
+    /** Shown when there is nothing to draw yet. */
+    EmptyStateMessage: string;
+    BeforeTaskAdded: EventEmitter<BeforeTaskAddedEventArgs>;
+    AfterTaskAdded: EventEmitter<AfterTaskAddedEventArgs>;
+    BeforeTaskRemoved: EventEmitter<BeforeTaskRemovedEventArgs>;
+    AfterTaskRemoved: EventEmitter<AfterTaskRemovedEventArgs>;
+    BeforeTaskUpdated: EventEmitter<BeforeTaskUpdatedEventArgs>;
+    AfterTaskUpdated: EventEmitter<AfterTaskUpdatedEventArgs>;
+    BeforeDependencyAdded: EventEmitter<BeforeDependencyAddedEventArgs>;
+    AfterDependencyAdded: EventEmitter<AfterDependencyAddedEventArgs>;
+    BeforeDependencyRemoved: EventEmitter<BeforeDependencyRemovedEventArgs>;
+    AfterDependencyRemoved: EventEmitter<AfterDependencyRemovedEventArgs>;
+    /** Informational — no `Before` pair, because these report what already happened. */
+    SpecChanged: EventEmitter<TaskGraphSpecChangedEventArgs>;
+    SelectionChanged: EventEmitter<TaskGraphSelectionChangedEventArgs>;
+    ValidationChanged: EventEmitter<TaskGraphValidationChangedEventArgs>;
+    /** Intent-only — the host navigates; this widget has no Router and must not acquire one. */
+    AgentOpenRequested: EventEmitter<AgentOpenRequestedEventArgs>;
+    RecordOpenRequested: EventEmitter<RecordOpenRequestedEventArgs>;
+    Nodes: FlowNode[];
+    Connections: FlowConnection[];
+    NodeTypes: FlowNodeTypeConfig[];
+    SelectedTask: TaskGraphSpecNode | null;
+    ValidationErrors: readonly TaskGraphValidationError[];
+    IsValid: boolean;
+    private currentSpec;
+    private currentRuntime;
+    get IsEmpty(): boolean;
+    /** Re-runs validation and emits the result. Idempotent. */
+    Validate(): TaskGraphValidationChangedEventArgs;
+    /** Adds a task. Returns the new task, or null when a host vetoed it. */
+    AddTask(partial?: Partial<TaskGraphSpecNode>): TaskGraphSpecNode | null;
+    /** Removes a task and every edge into it. Returns false when a host vetoed it. */
+    RemoveTask(tempId: string): boolean;
+    /** Replaces a task's properties. Returns false when a host vetoed it. */
+    UpdateTask(tempId: string, next: TaskGraphSpecNode): boolean;
+    /**
+     * Adds a dependency edge. Returns false when it was vetoed **or would create a cycle**.
+     *
+     * The cycle is refused unconditionally, not merely reported: a cyclic graph can never execute —
+     * nothing would ever become eligible — so allowing the canvas to draw one would let a user build
+     * something the engine must then reject. Better to refuse the stroke than to accept a graph that
+     * cannot run.
+     */
+    AddDependency(fromTempId: string, toTempId: string, condition?: string): boolean;
+    /** Removes a dependency edge. Returns false when a host vetoed it. */
+    RemoveDependency(fromTempId: string, toTempId: string): boolean;
+    /**
+     * Sets — or with an empty string, clears — a dependency edge's condition.
+     *
+     * Implemented as remove-then-add so it travels the same `Before*`/`After*` path as any other
+     * edge change. A separate silent mutation would be a second write path into the spec, and the
+     * veto contract would then be right in one place and wrong in the other.
+     */
+    SetDependencyCondition(fromTempId: string, toTempId: string, condition: string): boolean;
+    /** Asks the host to open the agent behind a task. */
+    RequestAgentOpen(task: TaskGraphSpecNode): void;
+    /** Asks the host to open a record the graph references. */
+    RequestRecordOpen(entityName: string, recordID: string): void;
+    OnNodeSelected(node: FlowNode | null): void;
+    OnConnectionCreated(event: FlowConnectionCreatedEvent): void;
+    OnConnectionRemoved(connection: FlowConnection): void;
+    OnNodeRemoved(node: FlowNode): void;
+    private findTask;
+    private selectTask;
+    /** Applies a new spec, re-projects, re-validates, and tells the host — in that order. */
+    private commit;
+    /** Re-derives the canvas from the spec. Validation rides along so the two never disagree. */
+    private project;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TaskGraphEditorComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TaskGraphEditorComponent, "mj-task-graph-editor", never, { "Spec": { "alias": "Spec"; "required": false; }; "RuntimeStatus": { "alias": "RuntimeStatus"; "required": false; }; "ReadOnly": { "alias": "ReadOnly"; "required": false; }; "ShowToolbar": { "alias": "ShowToolbar"; "required": false; }; "ShowPalette": { "alias": "ShowPalette"; "required": false; }; "ShowMinimap": { "alias": "ShowMinimap"; "required": false; }; "ShowStatusBar": { "alias": "ShowStatusBar"; "required": false; }; "AutoLayoutDirection": { "alias": "AutoLayoutDirection"; "required": false; }; "EmptyStateMessage": { "alias": "EmptyStateMessage"; "required": false; }; }, { "BeforeTaskAdded": "BeforeTaskAdded"; "AfterTaskAdded": "AfterTaskAdded"; "BeforeTaskRemoved": "BeforeTaskRemoved"; "AfterTaskRemoved": "AfterTaskRemoved"; "BeforeTaskUpdated": "BeforeTaskUpdated"; "AfterTaskUpdated": "AfterTaskUpdated"; "BeforeDependencyAdded": "BeforeDependencyAdded"; "AfterDependencyAdded": "AfterDependencyAdded"; "BeforeDependencyRemoved": "BeforeDependencyRemoved"; "AfterDependencyRemoved": "AfterDependencyRemoved"; "SpecChanged": "SpecChanged"; "SelectionChanged": "SelectionChanged"; "ValidationChanged": "ValidationChanged"; "AgentOpenRequested": "AgentOpenRequested"; "RecordOpenRequested": "RecordOpenRequested"; }, never, never, false, never>;
+}
+//# sourceMappingURL=task-graph-editor.component.d.ts.map

package/dist/lib/task-graph-editor.component.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-graph-editor.component.d.ts","sourceRoot":"","sources":["../../src/lib/task-graph-editor.component.ts"],"names":[],"mappings":"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"}