@decaf-ts/ui-decorators 0.20.4 → 0.20.7

package/lib/esm/graph/nodes/flow-control/break.js

@@ -0,0 +1,54 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/**
+ * @module ui-decorators/graph/nodes/flow-control/break
+ * @summary Break flow-control node declaration (DECAF-32 §22.2.2).
+ * @description Break — breaks out of the enclosing loop (foreach/while/until).
+ * When executed inside a loop body, the loop terminates early and the loop's
+ * `completed`/`state` output carries the results collected so far. The Break
+ * node executor throws a `GraphBreakSignal` that the enclosing loop executor
+ * catches.
+ */
+import { Model, model, required } from "@decaf-ts/decorator-validation";
+import { uielement } from "./../../../ui/decorators.js";
+import { input, node, output } from "./../../decorators.js";
+// Ensure category styles are registered (idempotent).
+import "./../category-styles.js";
+let BreakFlowNode = class BreakFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Value", placeholder: "Value to forward (collected as the last partial result)" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], BreakFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    output({ handle: "broken" }),
+    __metadata("design:type", Object)
+], BreakFlowNode.prototype, "broken", void 0);
+BreakFlowNode = __decorate([
+    node("core.flow.break", {
+        kind: "core.flow.break",
+        category: "Flow Control",
+        color: "#ef4444",
+        icon: "ti-square-arrow-right",
+        width: 96,
+        height: 96,
+        labels: ["flow", "break", "loop", "control"],
+        metadata: {
+            title: "Break",
+            description: "Breaks out of the enclosing loop. The loop terminates early and returns the results collected so far.",
+        },
+    }),
+    model()
+], BreakFlowNode);
+export { BreakFlowNode };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/nodes/flow-control/error-boundary.js

@@ -0,0 +1,58 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/**
+ * @module ui-decorators/graph/nodes/flow-control/error-boundary
+ * @summary Error-boundary flow-control node declaration (DECAF-32 §22.2.2).
+ * @description Error boundary — try/catch/finally workflow behaviour.
+ */
+import { Model, model, required } from "@decaf-ts/decorator-validation";
+import { uielement } from "./../../../ui/decorators.js";
+import { input, node, output } from "./../../decorators.js";
+// Ensure category styles are registered (idempotent).
+import "./../category-styles.js";
+let ErrorBoundaryFlowNode = class ErrorBoundaryFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to guard" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Result", placeholder: "Output on success" }),
+    output({ handle: "result" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "result", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Error", placeholder: "Output on failure" }),
+    output({ handle: "error" }),
+    __metadata("design:type", Object)
+], ErrorBoundaryFlowNode.prototype, "error", void 0);
+ErrorBoundaryFlowNode = __decorate([
+    node("core.flow.errorBoundary", {
+        kind: "core.flow.errorBoundary",
+        category: "Flow Control",
+        color: "#ef4444",
+        icon: "ti-shield-check",
+        width: 96,
+        height: 96,
+        labels: ["flow", "error", "try-catch"],
+        metadata: {
+            title: "Error boundary",
+            description: "Wraps the input in a try/catch/finally. Emits the result on success, or the error on failure.",
+            finally: false,
+        },
+    }),
+    model()
+], ErrorBoundaryFlowNode);
+export { ErrorBoundaryFlowNode };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3ItYm91bmRhcnkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ3JhcGgvbm9kZXMvZmxvdy1jb250cm9sL2Vycm9yLWJvdW5kYXJ5LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7OztBQUFBOzs7O0dBSUc7QUFDSCxPQUFPLEVBQUUsS0FBSyxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQztBQUN4RSxPQUFPLEVBQUUsU0FBUyxFQUFFLG9DQUErQjtBQUNuRCxPQUFPLEVBQUUsS0FBSyxFQUFFLElBQUksRUFBRSxNQUFNLEVBQUUsOEJBQXlCO0FBRXZELHNEQUFzRDtBQUN0RCxpQ0FBNEI7QUFpQnJCLElBQU0scUJBQXFCLEdBQTNCLE1BQU0scUJBQXNCLFNBQVEsS0FBSztDQWUvQyxDQUFBO0FBWEM7SUFIQyxRQUFRLEVBQUU7SUFDVixTQUFTLENBQUMsVUFBVSxFQUFFLEVBQUUsS0FBSyxFQUFFLGFBQWEsRUFBRSxXQUFXLEVBQUUsZ0JBQWdCLEVBQUUsQ0FBQztJQUM5RSxLQUFLLENBQUMsRUFBRSxNQUFNLEVBQUUsT0FBTyxFQUFFLENBQUM7O29EQUNYO0FBS2hCO0lBSEMsUUFBUSxFQUFFO0lBQ1YsU0FBUyxDQUFDLE9BQU8sRUFBRSxFQUFFLEtBQUssRUFBRSxRQUFRLEVBQUUsV0FBVyxFQUFFLG1CQUFtQixFQUFFLENBQUM7SUFDekUsTUFBTSxDQUFDLEVBQUUsTUFBTSxFQUFFLFFBQVEsRUFBRSxDQUFDOztxREFDWjtBQUtqQjtJQUhDLFFBQVEsRUFBRTtJQUNWLFNBQVMsQ0FBQyxPQUFPLEVBQUUsRUFBRSxLQUFLLEVBQUUsT0FBTyxFQUFFLFdBQVcsRUFBRSxtQkFBbUIsRUFBRSxDQUFDO0lBQ3hFLE1BQU0sQ0FBQyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsQ0FBQzs7b0RBQ1o7QUFkTCxxQkFBcUI7SUFmakMsSUFBSSxDQUFDLHlCQUF5QixFQUFFO1FBQy9CLElBQUksRUFBRSx5QkFBeUI7UUFDL0IsUUFBUSxFQUFFLGNBQWM7UUFDeEIsS0FBSyxFQUFFLFNBQVM7UUFDaEIsSUFBSSxFQUFFLGlCQUFpQjtRQUN2QixLQUFLLEVBQUUsRUFBRTtRQUNULE1BQU0sRUFBRSxFQUFFO1FBQ1YsTUFBTSxFQUFFLENBQUMsTUFBTSxFQUFFLE9BQU8sRUFBRSxXQUFXLENBQUM7UUFDdEMsUUFBUSxFQUFFO1lBQ1IsS0FBSyxFQUFFLGdCQUFnQjtZQUN2QixXQUFXLEVBQUUsK0ZBQStGO1lBQzVHLE9BQU8sRUFBRSxLQUFLO1NBQ2Y7S0FDRixDQUFDO0lBQ0QsS0FBSyxFQUFFO0dBQ0sscUJBQXFCLENBZWpDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBAbW9kdWxlIHVpLWRlY29yYXRvcnMvZ3JhcGgvbm9kZXMvZmxvdy1jb250cm9sL2Vycm9yLWJvdW5kYXJ5XG4gKiBAc3VtbWFyeSBFcnJvci1ib3VuZGFyeSBmbG93LWNvbnRyb2wgbm9kZSBkZWNsYXJhdGlvbiAoREVDQUYtMzIgwqcyMi4yLjIpLlxuICogQGRlc2NyaXB0aW9uIEVycm9yIGJvdW5kYXJ5IOKAlCB0cnkvY2F0Y2gvZmluYWxseSB3b3JrZmxvdyBiZWhhdmlvdXIuXG4gKi9cbmltcG9ydCB7IE1vZGVsLCBtb2RlbCwgcmVxdWlyZWQgfSBmcm9tIFwiQGRlY2FmLXRzL2RlY29yYXRvci12YWxpZGF0aW9uXCI7XG5pbXBvcnQgeyB1aWVsZW1lbnQgfSBmcm9tIFwiLi4vLi4vLi4vdWkvZGVjb3JhdG9yc1wiO1xuaW1wb3J0IHsgaW5wdXQsIG5vZGUsIG91dHB1dCB9IGZyb20gXCIuLi8uLi9kZWNvcmF0b3JzXCI7XG5cbi8vIEVuc3VyZSBjYXRlZ29yeSBzdHlsZXMgYXJlIHJlZ2lzdGVyZWQgKGlkZW1wb3RlbnQpLlxuaW1wb3J0IFwiLi4vY2F0ZWdvcnktc3R5bGVzXCI7XG5cbkBub2RlKFwiY29yZS5mbG93LmVycm9yQm91bmRhcnlcIiwge1xuICBraW5kOiBcImNvcmUuZmxvdy5lcnJvckJvdW5kYXJ5XCIsXG4gIGNhdGVnb3J5OiBcIkZsb3cgQ29udHJvbFwiLFxuICBjb2xvcjogXCIjZWY0NDQ0XCIsXG4gIGljb246IFwidGktc2hpZWxkLWNoZWNrXCIsXG4gIHdpZHRoOiA5NixcbiAgaGVpZ2h0OiA5NixcbiAgbGFiZWxzOiBbXCJmbG93XCIsIFwiZXJyb3JcIiwgXCJ0cnktY2F0Y2hcIl0sXG4gIG1ldGFkYXRhOiB7XG4gICAgdGl0bGU6IFwiRXJyb3IgYm91bmRhcnlcIixcbiAgICBkZXNjcmlwdGlvbjogXCJXcmFwcyB0aGUgaW5wdXQgaW4gYSB0cnkvY2F0Y2gvZmluYWxseS4gRW1pdHMgdGhlIHJlc3VsdCBvbiBzdWNjZXNzLCBvciB0aGUgZXJyb3Igb24gZmFpbHVyZS5cIixcbiAgICBmaW5hbGx5OiBmYWxzZSxcbiAgfSxcbn0pXG5AbW9kZWwoKVxuZXhwb3J0IGNsYXNzIEVycm9yQm91bmRhcnlGbG93Tm9kZSBleHRlbmRzIE1vZGVsIHtcbiAgQHJlcXVpcmVkKClcbiAgQHVpZWxlbWVudChcInRleHRhcmVhXCIsIHsgbGFiZWw6IFwiSW5wdXQgdmFsdWVcIiwgcGxhY2Vob2xkZXI6IFwiVmFsdWUgdG8gZ3VhcmRcIiB9KVxuICBAaW5wdXQoeyBoYW5kbGU6IFwidmFsdWVcIiB9KVxuICB2YWx1ZSE6IHVua25vd247XG5cbiAgQHJlcXVpcmVkKClcbiAgQHVpZWxlbWVudChcImlucHV0XCIsIHsgbGFiZWw6IFwiUmVzdWx0XCIsIHBsYWNlaG9sZGVyOiBcIk91dHB1dCBvbiBzdWNjZXNzXCIgfSlcbiAgQG91dHB1dCh7IGhhbmRsZTogXCJyZXN1bHRcIiB9KVxuICByZXN1bHQhOiB1bmtub3duO1xuXG4gIEByZXF1aXJlZCgpXG4gIEB1aWVsZW1lbnQoXCJpbnB1dFwiLCB7IGxhYmVsOiBcIkVycm9yXCIsIHBsYWNlaG9sZGVyOiBcIk91dHB1dCBvbiBmYWlsdXJlXCIgfSlcbiAgQG91dHB1dCh7IGhhbmRsZTogXCJlcnJvclwiIH0pXG4gIGVycm9yITogdW5rbm93bjtcbn1cbiJdfQ==

package/lib/esm/graph/nodes/flow-control/human-approval.js

@@ -0,0 +1,60 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/**
+ * @module ui-decorators/graph/nodes/flow-control/human-approval
+ * @summary Human-approval flow-control node declaration (DECAF-32 §22.2.2).
+ * @description Human approval — suspends execution until a human approves
+ * or rejects.
+ */
+import { Model, model, required } from "@decaf-ts/decorator-validation";
+import { uielement } from "./../../../ui/decorators.js";
+import { input, node, output } from "./../../decorators.js";
+// Ensure category styles are registered (idempotent).
+import "./../category-styles.js";
+let HumanApprovalFlowNode = class HumanApprovalFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value pending approval" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], HumanApprovalFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Approved", placeholder: "Output when approved" }),
+    output({ handle: "approved" }),
+    __metadata("design:type", Object)
+], HumanApprovalFlowNode.prototype, "approved", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Rejected", placeholder: "Output when rejected" }),
+    output({ handle: "rejected" }),
+    __metadata("design:type", Object)
+], HumanApprovalFlowNode.prototype, "rejected", void 0);
+HumanApprovalFlowNode = __decorate([
+    node("core.flow.humanApproval", {
+        kind: "core.flow.humanApproval",
+        category: "Flow Control",
+        color: "#d946ef",
+        icon: "ti-user-check",
+        width: 96,
+        height: 96,
+        labels: ["flow", "approval", "suspend"],
+        metadata: {
+            title: "Human approval",
+            description: "Suspends execution until a human approves or rejects. Emits the approved value or a rejection.",
+            approvers: [],
+            timeoutMs: 86400000,
+        },
+    }),
+    model()
+], HumanApprovalFlowNode);
+export { HumanApprovalFlowNode };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/nodes/flow-control/if.js

@@ -0,0 +1,62 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/**
+ * @module ui-decorators/graph/nodes/flow-control/if
+ * @summary If flow-control node declaration (DECAF-32 §22.2.2).
+ * @description If — conditional branch. Evaluates a `ConditionExpression`
+ * (§22.3) and routes the input to the `then` or `else` output. A graph-level
+ * macro: the engine's planner recognises it as an ordinary executable node
+ * (§5.7) but it has no built-in executor — downstream projects register
+ * custom executors or compile it into composition APIs (§22.2.2).
+ */
+import { Model, model, required } from "@decaf-ts/decorator-validation";
+import { uielement } from "./../../../ui/decorators.js";
+import { input, node, output } from "./../../decorators.js";
+// Ensure category styles are registered (idempotent).
+import "./../category-styles.js";
+let IfFlowNode = class IfFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to evaluate" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], IfFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Then", placeholder: "Output when condition is true" }),
+    output({ handle: "then" }),
+    __metadata("design:type", Object)
+], IfFlowNode.prototype, "then", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Else", placeholder: "Output when condition is false" }),
+    output({ handle: "else" }),
+    __metadata("design:type", Object)
+], IfFlowNode.prototype, "else", void 0);
+IfFlowNode = __decorate([
+    node("core.flow.if", {
+        kind: "core.flow.if",
+        category: "Flow Control",
+        color: "#f59e0b",
+        icon: "ti-arrows-split-2",
+        width: 96,
+        height: 96,
+        labels: ["flow", "conditional", "branch"],
+        metadata: {
+            title: "If",
+            description: "Conditional branch. Evaluates the configured condition and routes the input to the matching output.",
+            condition: { op: "eq", left: { const: true }, right: { const: true } },
+        },
+    }),
+    model()
+], IfFlowNode);
+export { IfFlowNode };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/nodes/flow-control/parallel.js

@@ -0,0 +1,52 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/**
+ * @module ui-decorators/graph/nodes/flow-control/parallel
+ * @summary Parallel flow-control node declaration (DECAF-32 §22.2.2).
+ * @description Parallel — splits execution into concurrent branches.
+ */
+import { Model, model, required } from "@decaf-ts/decorator-validation";
+import { uielement } from "./../../../ui/decorators.js";
+import { input, node, output } from "./../../decorators.js";
+// Ensure category styles are registered (idempotent).
+import "./../category-styles.js";
+let ParallelFlowNode = class ParallelFlowNode extends Model {
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to fan out" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], ParallelFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Branches", placeholder: "Collected branch outputs" }),
+    output({ handle: "branches" }),
+    __metadata("design:type", Array)
+], ParallelFlowNode.prototype, "branches", void 0);
+ParallelFlowNode = __decorate([
+    node("core.flow.parallel", {
+        kind: "core.flow.parallel",
+        category: "Flow Control",
+        color: "#06b6d4",
+        icon: "ti-arrows-vertical",
+        width: 96,
+        height: 96,
+        labels: ["flow", "parallel", "concurrent"],
+        metadata: {
+            title: "Parallel",
+            description: "Splits execution into concurrent branches. All branches run in parallel and outputs are collected.",
+            branchCount: 2,
+        },
+    }),
+    model()
+], ParallelFlowNode);
+export { ParallelFlowNode };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/esm/graph/nodes/flow-control/switch.js

@@ -0,0 +1,112 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/**
+ * @module ui-decorators/graph/nodes/flow-control/switch
+ * @summary Switch flow-control node declaration (DECAF-32 §22.2.2).
+ * @description Switch — multi-branch. Routes the input to one of the case
+ * output ports or `default` based on matching conditions. Each case defines
+ * a `SwitchCaseCondition` (graphical or code mode) and a dedicated output
+ * port. Cases are stored in `metadata.switch.cases` and the renderer creates
+ * dynamic output ports from them (DECAF-32 §22.2.2).
+ *
+ * The node grows in height as cases are added. Each case gets its own
+ * output port on the right side, labeled with the case label.
+ */
+import { model, required } from "@decaf-ts/decorator-validation";
+import { uielement } from "./../../../ui/decorators.js";
+import { input, node, output, } from "./../../decorators.js";
+import { PortDirection, } from "./../../constants.js";
+import { graphDefinitionOf } from "./../../reader.js";
+import { GraphNode } from "./../base.js";
+// Ensure category styles are registered (idempotent).
+import "./../category-styles.js";
+let SwitchFlowNode = class SwitchFlowNode extends GraphNode {
+    /**
+     * Computes the node's ports, size, and data patch from the given switch
+     * metadata. Each case gets its own output port on the right side; the
+     * `default` port always renders **last** (DECAF-32 §21 port-ordering rule,
+     * DECAF-34 §6.2). When `hasDefault` is `false`, the `default` output port
+     * is omitted entirely. The node grows in height as cases are added.
+     *
+     * @param meta - The switch metadata patch (`metadata.switch`), carrying
+     *   the cases and the optional default-port configuration.
+     * @returns The computed {@link NodeMetadataChange}: reordered ports
+     *   (case outputs inserted before the optional default), the grown size,
+     *   and the `switchMetadata` data patch.
+     */
+    static applyMetadata(meta) {
+        const definition = graphDefinitionOf(this);
+        const defaultPortName = meta.defaultPort ?? "default";
+        const hasDefault = meta.hasDefault === true;
+        // Base ports excluding any port that collides with a case output port.
+        const basePorts = definition.ports.filter((p) => !meta.cases.some((c) => c.outputPort === p.property));
+        // Separate the default output port so it can be placed last (or omitted).
+        const nonDefaultPorts = basePorts.filter((p) => p.property !== defaultPortName);
+        const defaultPort = basePorts.find((p) => p.property === defaultPortName);
+        const casePorts = meta.cases.map((c) => ({
+            property: c.outputPort,
+            name: c.label,
+            direction: PortDirection.OUTPUT,
+            label: c.label,
+            required: false,
+            hidden: false,
+            path: c.outputPort,
+        }));
+        // Port order: inputs/non-default outputs first, case outputs next, default last.
+        const ports = [...nonDefaultPorts, ...casePorts];
+        if (hasDefault && defaultPort) {
+            ports.push(defaultPort);
+        }
+        const caseCount = meta.cases.length;
+        return {
+            ports,
+            size: {
+                width: definition.width ?? 120,
+                height: caseCount > 0 ? 140 + caseCount * 24 : definition.height ?? 140,
+            },
+            dataPatch: { switchMetadata: meta },
+        };
+    }
+};
+__decorate([
+    required(),
+    uielement("textarea", { label: "Input value", placeholder: "Value to switch on" }),
+    input({ handle: "value" }),
+    __metadata("design:type", Object)
+], SwitchFlowNode.prototype, "value", void 0);
+__decorate([
+    required(),
+    uielement("input", { label: "Default", placeholder: "Default output when no case matches" }),
+    output({ handle: "default" }),
+    __metadata("design:type", Object)
+], SwitchFlowNode.prototype, "default", void 0);
+SwitchFlowNode = __decorate([
+    node("core.flow.switch", {
+        kind: "core.flow.switch",
+        category: "Flow Control",
+        color: "#f97316",
+        icon: "ti-arrows-shuffle",
+        width: 120,
+        height: 140,
+        labels: ["flow", "switch", "multi-branch"],
+        metadata: {
+            title: "Switch",
+            description: "Multi-branch switch. Routes the input to the first matching case output, or the default output.",
+            switch: {
+                cases: [],
+                defaultPort: "default",
+                hasDefault: false,
+            },
+        },
+    }),
+    model()
+], SwitchFlowNode);
+export { SwitchFlowNode };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"switch.js","sourceRoot":"","sources":["../../../../../src/graph/nodes/flow-control/switch.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @module ui-decorators/graph/nodes/flow-control/switch\n * @summary Switch flow-control node declaration (DECAF-32 §22.2.2).\n * @description Switch — multi-branch. Routes the input to one of the case\n * output ports or `default` based on matching conditions. Each case defines\n * a `SwitchCaseCondition` (graphical or code mode) and a dedicated output\n * port. Cases are stored in `metadata.switch.cases` and the renderer creates\n * dynamic output ports from them (DECAF-32 §22.2.2).\n *\n * The node grows in height as cases are added. Each case gets its own\n * output port on the right side, labeled with the case label.\n */\nimport { model, required } from \"@decaf-ts/decorator-validation\";\nimport { uielement } from \"../../../ui/decorators\";\nimport {\n  input,\n  node,\n  output,\n} from \"../../decorators\";\nimport {\n  PortDirection,\n  type GraphPortDefinition,\n} from \"../../constants\";\nimport { graphDefinitionOf } from \"../../reader\";\nimport type { NodeMetadataChange, SwitchNodeMetadata } from \"../../types\";\nimport { GraphNode } from \"../base\";\n\n// Ensure category styles are registered (idempotent).\nimport \"../category-styles\";\n\n@node(\"core.flow.switch\", {\n  kind: \"core.flow.switch\",\n  category: \"Flow Control\",\n  color: \"#f97316\",\n  icon: \"ti-arrows-shuffle\",\n  width: 120,\n  height: 140,\n  labels: [\"flow\", \"switch\", \"multi-branch\"],\n  metadata: {\n    title: \"Switch\",\n    description: \"Multi-branch switch. Routes the input to the first matching case output, or the default output.\",\n    switch: {\n      cases: [],\n      defaultPort: \"default\",\n      hasDefault: false,\n    },\n  },\n})\n@model()\nexport class SwitchFlowNode extends GraphNode {\n  @required()\n  @uielement(\"textarea\", { label: \"Input value\", placeholder: \"Value to switch on\" })\n  @input({ handle: \"value\" })\n  value!: unknown;\n\n  @required()\n  @uielement(\"input\", { label: \"Default\", placeholder: \"Default output when no case matches\" })\n  @output({ handle: \"default\" })\n  default!: unknown;\n\n  /**\n   * Computes the node's ports, size, and data patch from the given switch\n   * metadata. Each case gets its own output port on the right side; the\n   * `default` port always renders **last** (DECAF-32 §21 port-ordering rule,\n   * DECAF-34 §6.2). When `hasDefault` is `false`, the `default` output port\n   * is omitted entirely. The node grows in height as cases are added.\n   *\n   * @param meta - The switch metadata patch (`metadata.switch`), carrying\n   *   the cases and the optional default-port configuration.\n   * @returns The computed {@link NodeMetadataChange}: reordered ports\n   *   (case outputs inserted before the optional default), the grown size,\n   *   and the `switchMetadata` data patch.\n   */\n  static override applyMetadata(meta: SwitchNodeMetadata): NodeMetadataChange {\n    const definition = graphDefinitionOf(this as never);\n    const defaultPortName = meta.defaultPort ?? \"default\";\n    const hasDefault = meta.hasDefault === true;\n\n    // Base ports excluding any port that collides with a case output port.\n    const basePorts = definition.ports.filter(\n      (p) => !meta.cases.some((c) => c.outputPort === p.property)\n    );\n    // Separate the default output port so it can be placed last (or omitted).\n    const nonDefaultPorts = basePorts.filter(\n      (p) => p.property !== defaultPortName\n    );\n    const defaultPort = basePorts.find((p) => p.property === defaultPortName);\n\n    const casePorts: GraphPortDefinition[] = meta.cases.map((c) => ({\n      property: c.outputPort,\n      name: c.label,\n      direction: PortDirection.OUTPUT,\n      label: c.label,\n      required: false,\n      hidden: false,\n      path: c.outputPort,\n    }));\n\n    // Port order: inputs/non-default outputs first, case outputs next, default last.\n    const ports = [...nonDefaultPorts, ...casePorts];\n    if (hasDefault && defaultPort) {\n      ports.push(defaultPort);\n    }\n\n    const caseCount = meta.cases.length;\n    return {\n      ports,\n      size: {\n        width: definition.width ?? 120,\n        height: caseCount > 0 ? 140 + caseCount * 24 : definition.height ?? 140,\n      },\n      dataPatch: { switchMetadata: meta },\n    };\n  }\n}\n"]}

package/lib/esm/graph/nodes/index.js

@@ -0,0 +1,105 @@
+/**
+ * @module ui-decorators/graph/nodes
+ * @summary Shared node kind declarations (DECAF-32 §22.2, DECAF-50 Phase A).
+ * @description Canonical `@node`-decorated classes for the ALFRED-5 node kind
+ * taxonomy, laid out one node per file under `nodes/<category>/<node>.ts`:
+ * triggers (§22.2.1), flow-control and utility nodes (§22.2.2–22.2.3), the
+ * Agent node (§21.3), the three loop kinds (`core.loop.foreach/while/until`,
+ * §5.9), and the workflow input-value boundary node. Shared non-node support
+ * (base class, category styles, manifests) lives in sibling files under the
+ * same tree. Consumers (for-angular, ALFRED, etc.) import these declarations
+ * to populate node palettes, registries, and reference snapshots.
+ */
+export * from "./base.js";
+export * from "./category-styles.js";
+export * from "./flow-control/break.js";
+export * from "./flow-control/error-boundary.js";
+export * from "./flow-control/human-approval.js";
+export * from "./flow-control/if.js";
+export * from "./flow-control/parallel.js";
+export * from "./flow-control/switch.js";
+export * from "./utility/code.js";
+export * from "./utility/delay.js";
+export * from "./utility/log.js";
+export * from "./utility/map.js";
+export * from "./utility/merge.js";
+export * from "./utility/return.js";
+export * from "./utility/utility-log.js";
+export * from "./triggers/chat.js";
+export * from "./triggers/event.js";
+export * from "./triggers/form.js";
+export * from "./triggers/manual.js";
+export * from "./triggers/schedule.js";
+export * from "./triggers/webhook.js";
+export * from "./agents/agent.js";
+export * from "./loops/foreach.js";
+export * from "./loops/until.js";
+export * from "./loops/while.js";
+export * from "./boundary/input-value.js";
+export * from "./manifests.js";
+import { BreakFlowNode } from "./flow-control/break.js";
+import { ErrorBoundaryFlowNode } from "./flow-control/error-boundary.js";
+import { HumanApprovalFlowNode } from "./flow-control/human-approval.js";
+import { IfFlowNode } from "./flow-control/if.js";
+import { ParallelFlowNode } from "./flow-control/parallel.js";
+import { SwitchFlowNode } from "./flow-control/switch.js";
+import { CodeFlowNode } from "./utility/code.js";
+import { DelayFlowNode } from "./utility/delay.js";
+import { LogFlowNode } from "./utility/log.js";
+import { MapFlowNode } from "./utility/map.js";
+import { MergeFlowNode } from "./utility/merge.js";
+import { ReturnFlowNode } from "./utility/return.js";
+import { UtilityLogNode } from "./utility/utility-log.js";
+import { ChatTriggerNode } from "./triggers/chat.js";
+import { EventTriggerNode } from "./triggers/event.js";
+import { FormTriggerNode } from "./triggers/form.js";
+import { ManualTriggerNode } from "./triggers/manual.js";
+import { ScheduleTriggerNode } from "./triggers/schedule.js";
+import { WebhookTriggerNode } from "./triggers/webhook.js";
+import { GraphForeachLoopNode } from "./loops/foreach.js";
+import { GraphUntilLoopNode } from "./loops/until.js";
+import { GraphWhileLoopNode } from "./loops/while.js";
+import { GraphInputValueNode } from "./boundary/input-value.js";
+/**
+ * All built-in trigger node constructors.
+ */
+export const GRAPH_TRIGGER_NODES = [
+    ManualTriggerNode,
+    WebhookTriggerNode,
+    ScheduleTriggerNode,
+    EventTriggerNode,
+    FormTriggerNode,
+    ChatTriggerNode,
+];
+/**
+ * All built-in flow-control node constructors.
+ */
+export const GRAPH_FLOW_CONTROL_NODES = [
+    IfFlowNode,
+    SwitchFlowNode,
+    ParallelFlowNode,
+    MergeFlowNode,
+    MapFlowNode,
+    DelayFlowNode,
+    ErrorBoundaryFlowNode,
+    HumanApprovalFlowNode,
+    ReturnFlowNode,
+    CodeFlowNode,
+    LogFlowNode,
+    UtilityLogNode,
+    BreakFlowNode,
+];
+/**
+ * All built-in loop node constructors (shared declarations of the
+ * `core.loop.*` system kinds).
+ */
+export const GRAPH_LOOP_NODES = [
+    GraphForeachLoopNode,
+    GraphWhileLoopNode,
+    GraphUntilLoopNode,
+];
+/**
+ * All built-in boundary node constructors.
+ */
+export const GRAPH_BOUNDARY_NODES = [GraphInputValueNode];
+//# sourceMappingURL=data:application/json;base64,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