@burdenoff/fluidgrids-fe-sdk 2026.1113.1 → 2026.1113.2

package/dist/assert-rules-CPNrO44K.js

@@ -0,0 +1,318 @@
+"use client";
+import { jI as WorkflowTestAssertionOperator } from "./graphql-types-v6CTGwA0.js";
+
+// src/builder/lib/assert-rules.ts
+/** Every operator, in the order the editors offer them. */
+const ASSERT_OPERATORS = [
+	{
+		wire: "equals",
+		value: "EQUALS",
+		operand: "expected",
+		label: "equals"
+	},
+	{
+		wire: "notEquals",
+		value: "NOT_EQUALS",
+		operand: "expected",
+		label: "does not equal"
+	},
+	{
+		wire: "contains",
+		value: "CONTAINS",
+		operand: "expected",
+		label: "contains"
+	},
+	{
+		wire: "notContains",
+		value: "NOT_CONTAINS",
+		operand: "expected",
+		label: "does not contain"
+	},
+	{
+		wire: "matches",
+		value: "MATCHES",
+		operand: "expected",
+		label: "matches regex"
+	},
+	{
+		wire: "jsonSchema",
+		value: "JSON_SCHEMA",
+		operand: "expected",
+		label: "matches JSON Schema"
+	},
+	{
+		wire: "between",
+		value: "BETWEEN",
+		operand: "range",
+		label: "is between"
+	},
+	{
+		wire: "itemCount",
+		value: "ITEM_COUNT",
+		operand: "range",
+		label: "has item count"
+	},
+	{
+		wire: "exists",
+		value: "EXISTS",
+		operand: "none",
+		label: "exists"
+	},
+	{
+		wire: "notExists",
+		value: "NOT_EXISTS",
+		operand: "none",
+		label: "does not exist"
+	}
+];
+/** The service's cap on a `matches` pattern. */
+const MAX_REGEX_LENGTH = 500;
+/** Rules per node (Assert node or test-case expectation). */
+const MAX_RULES = 50;
+/**
+* The spec of an operator given in either spelling (`itemCount`,
+* `ITEM_COUNT`), or null when it is not one.
+*/
+function operatorSpec(value) {
+	if (typeof value !== "string") return null;
+	return ASSERT_OPERATORS.find((spec) => spec.wire === value || spec.value === value) ?? null;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function optionalNumber(value) {
+	if (value === void 0 || value === null) return void 0;
+	return typeof value === "number" && Number.isFinite(value) ? value : false;
+}
+/**
+* Checks one rule and normalises it to the wire form, or reports the first
+* problem. `index` is the rule's position, for the message.
+*/
+function normaliseAssertRule(raw, index) {
+	if (!isRecord(raw)) return { problem: {
+		code: "notObject",
+		index
+	} };
+	const spec = operatorSpec(raw.operator);
+	if (!spec) return { problem: {
+		code: "unknownOperator",
+		index,
+		operator: String(raw.operator ?? "")
+	} };
+	const rule = { operator: spec.wire };
+	if (raw.path !== void 0 && raw.path !== null && raw.path !== "") {
+		if (typeof raw.path !== "string") return { problem: {
+			code: "pathInvalid",
+			index
+		} };
+		rule.path = raw.path;
+	}
+	if (raw.message !== void 0 && raw.message !== null && raw.message !== "") {
+		if (typeof raw.message !== "string") return { problem: {
+			code: "messageInvalid",
+			index
+		} };
+		rule.message = raw.message;
+	}
+	if (spec.operand === "expected") {
+		if (!("expected" in raw)) return { problem: {
+			code: "expectedRequired",
+			index
+		} };
+		if (spec.wire === "matches") {
+			if (typeof raw.expected !== "string") return { problem: {
+				code: "regexInvalid",
+				index
+			} };
+			if (raw.expected.length > 500) return { problem: {
+				code: "regexTooLong",
+				index
+			} };
+			try {
+				new RegExp(raw.expected);
+			} catch {
+				return { problem: {
+					code: "regexInvalid",
+					index
+				} };
+			}
+		}
+		if (spec.wire === "jsonSchema" && !isRecord(raw.expected)) return { problem: {
+			code: "schemaInvalid",
+			index
+		} };
+		rule.expected = raw.expected;
+	}
+	if (spec.operand === "range") {
+		const min = optionalNumber(raw.min);
+		const max = optionalNumber(raw.max);
+		if (min === false || max === false) return { problem: {
+			code: "rangeInvalid",
+			index
+		} };
+		if (min === void 0 && max === void 0) return { problem: {
+			code: "rangeRequired",
+			index
+		} };
+		if (min !== void 0 && max !== void 0 && min > max) return { problem: {
+			code: "rangeInvalid",
+			index
+		} };
+		if (min !== void 0) rule.min = min;
+		if (max !== void 0) rule.max = max;
+	}
+	return { rule };
+}
+/** Checks a list of rules (1 to {@link MAX_RULES}); the first problem wins. */
+function normaliseAssertRules(raw) {
+	if (raw.length === 0) return { problem: { code: "empty" } };
+	if (raw.length > 50) return { problem: {
+		code: "tooMany",
+		count: raw.length
+	} };
+	const rules = [];
+	for (const [index, item] of raw.entries()) {
+		const result = normaliseAssertRule(item, index);
+		if ("problem" in result) return result;
+		rules.push(result.rule);
+	}
+	return { rules };
+}
+/** An i18n key and its English fallback for a rule problem. */
+function describeAssertRuleProblem(problem) {
+	const at = "index" in problem ? `Rule ${problem.index + 1}: ` : "";
+	switch (problem.code) {
+		case "notObject": return {
+			key: "fluidgrids.builder.assertRules.notObject",
+			fallback: `${at}a rule must be an object.`
+		};
+		case "unknownOperator": return {
+			key: "fluidgrids.builder.assertRules.unknownOperator",
+			fallback: `${at}unknown operator "${problem.operator}". Use ${ASSERT_OPERATORS.map((spec) => spec.wire).join(", ")}.`
+		};
+		case "expectedRequired": return {
+			key: "fluidgrids.builder.assertRules.expectedRequired",
+			fallback: `${at}this operator needs an expected value.`
+		};
+		case "rangeRequired": return {
+			key: "fluidgrids.builder.assertRules.rangeRequired",
+			fallback: `${at}set a minimum, a maximum or both.`
+		};
+		case "rangeInvalid": return {
+			key: "fluidgrids.builder.assertRules.rangeInvalid",
+			fallback: `${at}minimum and maximum must be numbers, with the minimum not above the maximum.`
+		};
+		case "regexInvalid": return {
+			key: "fluidgrids.builder.assertRules.regexInvalid",
+			fallback: `${at}the expected value is not a valid regular expression.`
+		};
+		case "regexTooLong": return {
+			key: "fluidgrids.builder.assertRules.regexTooLong",
+			fallback: `${at}a regular expression may have at most ${500} characters.`
+		};
+		case "schemaInvalid": return {
+			key: "fluidgrids.builder.assertRules.schemaInvalid",
+			fallback: `${at}the expected value must be a JSON Schema object.`
+		};
+		case "pathInvalid": return {
+			key: "fluidgrids.builder.assertRules.pathInvalid",
+			fallback: `${at}the path must be text.`
+		};
+		case "messageInvalid": return {
+			key: "fluidgrids.builder.assertRules.messageInvalid",
+			fallback: `${at}the message must be text.`
+		};
+		case "tooMany": return {
+			key: "fluidgrids.builder.assertRules.tooMany",
+			fallback: `At most ${50} rules (found ${problem.count}).`
+		};
+		case "empty": return {
+			key: "fluidgrids.builder.assertRules.empty",
+			fallback: "Add at least one rule."
+		};
+	}
+}
+/**
+* The rules held in an Assert node's `rules` setting. The manifest declares it
+* as text, so it is usually a JSON string; an array is accepted as well. A
+* value that does not parse yields null, so the editor can fall back to the
+* raw text instead of discarding it.
+*/
+function readAssertRulesSetting(value) {
+	if (value === void 0 || value === null || value === "") return [];
+	if (Array.isArray(value)) return value;
+	if (typeof value !== "string") return null;
+	try {
+		const parsed = JSON.parse(value);
+		return Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+function emptyAssertRuleRow() {
+	return {
+		path: "",
+		operator: "equals",
+		expected: "",
+		min: "",
+		max: "",
+		message: ""
+	};
+}
+function rowNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? String(value) : "";
+}
+function rowExpected(operator, value) {
+	if (value === void 0) return "";
+	if (operator === "matches" && typeof value === "string") return value;
+	return JSON.stringify(value);
+}
+/** The editor rows of stored rules (either operator spelling). */
+function rowsFromRules(rules) {
+	return rules.map((raw) => {
+		const rule = isRecord(raw) ? raw : {};
+		const operator = operatorSpec(rule.operator)?.wire ?? (typeof rule.operator === "string" ? rule.operator : "equals");
+		return {
+			path: typeof rule.path === "string" ? rule.path : "",
+			operator,
+			expected: rowExpected(operator, rule.expected),
+			min: rowNumber(rule.min),
+			max: rowNumber(rule.max),
+			message: typeof rule.message === "string" ? rule.message : ""
+		};
+	});
+}
+function parseExpected(operator, text) {
+	if (operator === "matches") return text;
+	try {
+		return JSON.parse(text);
+	} catch {
+		return text;
+	}
+}
+function parseRowNumber(text) {
+	const trimmed = text.trim();
+	if (trimmed === "") return void 0;
+	const value = Number(trimmed);
+	return Number.isFinite(value) ? value : trimmed;
+}
+/**
+* The stored form of an editor row. Only the operands its operator uses are
+* kept, so switching an operator does not leave a stale `expected` behind.
+*/
+function ruleFromRow(row) {
+	const spec = operatorSpec(row.operator);
+	const rule = { operator: row.operator };
+	if (row.path.trim()) rule.path = row.path.trim();
+	if (spec?.operand === "expected" && (row.expected !== "" || spec.wire === "matches")) rule.expected = parseExpected(spec.wire, row.expected);
+	if (spec?.operand === "range") {
+		const min = parseRowNumber(row.min);
+		const max = parseRowNumber(row.max);
+		if (min !== void 0) rule.min = min;
+		if (max !== void 0) rule.max = max;
+	}
+	if (row.message.trim()) rule.message = row.message.trim();
+	return rule;
+}
+
+export { operatorSpec as a, ruleFromRow as c, normaliseAssertRules as i, describeAssertRuleProblem as n, readAssertRulesSetting as o, emptyAssertRuleRow as r, rowsFromRules as s, ASSERT_OPERATORS as t };

package/dist/attach-node-helpers-CNsYtLOR.js

@@ -0,0 +1,32 @@
+"use client";
+import { w as resolveInputHandles } from "./node-operation-selection-Czeeb2D4.js";
+
+// src/builder/hooks/attach-node-helpers.ts
+/** Horizontal gap between a source node and a node attached via the "+" flow. */
+const ATTACH_GAP_X = 120;
+/** Fallback width when the source node hasn't been measured yet (w-72 card). */
+const DEFAULT_NODE_WIDTH = 288;
+/**
+* Canvas position for a node attached to `source`'s output: immediately to the
+* right of the card, vertically aligned (n8n places the next node the same
+* way). Overlaps with existing nodes are resolved by the canvas auto-adjust
+* pass that runs after the new node is measured.
+*/
+function computeAttachPosition(source) {
+	if (!source) return void 0;
+	const width = source.measured?.width ?? DEFAULT_NODE_WIDTH;
+	return {
+		x: source.position.x + width + 120,
+		y: source.position.y
+	};
+}
+/**
+* The input handle a freshly-attached node should be wired to — the first
+* declared input handle (Merge `input-1`, Compare Datasets `inputA`, …),
+* falling back to the default single `target` handle.
+*/
+function firstInputHandleId(data) {
+	return resolveInputHandles(data)[0]?.id ?? "target";
+}
+
+export { firstInputHandleId as n, computeAttachPosition as t };

package/dist/badge-CXfPhoMH.js

@@ -0,0 +1,26 @@
+"use client";
+import { t as cn } from "./cn-QqidFIgr.js";
+import { jsx } from "react/jsx-runtime";
+import { cva } from "class-variance-authority";
+
+// src/ui/badge.tsx
+const badgeVariants = cva("inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2", {
+	variants: { variant: {
+		default: "border-transparent bg-primary text-primary-foreground hover:bg-primary/80",
+		secondary: "border-transparent bg-secondary text-secondary-foreground hover:bg-secondary/80",
+		destructive: "border-transparent bg-destructive text-destructive-foreground hover:bg-destructive/80",
+		outline: "text-foreground",
+		success: "border-transparent bg-status-success-bg-subtle text-status-success-text",
+		warning: "border-transparent bg-status-warning-bg-subtle text-status-warning-text",
+		info: "border-transparent bg-status-info-bg-subtle text-status-info-text"
+	} },
+	defaultVariants: { variant: "default" }
+});
+function Badge({ className, variant, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		className: cn(badgeVariants({ variant }), className),
+		...props
+	});
+}
+
+export { badgeVariants as n, Badge as t };

package/dist/{canvasNoteTools-C_AN79m0.js → canvasNoteTools-DmfZwtnL.js}

@@ -1,8 +1,8 @@
 "use client";
 import { n as useAgentMarksStore, r as toPlainText } from "./marksStore-DGCXjTmZ.js";
-import { $ as selectedOperationOf, Q as paramsFromOperation, X as nodeTitle } from "./FluidGridsProvider-C4FVNz0n.js";
-import { H as useFlowStore } from "./node-operation-selection-DAbS6jSY.js";
-import { p as notesKeyOf } from "./flow-builder-D3Hl2AFk.js";
+import { F as nodeTitle, L as paramsFromOperation, R as selectedOperationOf } from "./FluidGridsProvider-Dc_Jhtch.js";
+import { M as useFlowStore } from "./node-operation-selection-Czeeb2D4.js";
+import { t as notesKeyOf } from "./notesKey-5EaREBGA.js";
 import { AgentToolError, defineAgentTool } from "@burdenoff/fe-libs/shared/agent-tools";
 import { z } from "zod";
 

package/dist/{channel-CZ70oI81.js → channel-DtF1n_ab.js}

@@ -1,5 +1,5 @@
 "use client";
-import { x as getFluidGridsConfig } from "./client-C9XSzSXr.js";
+import { r as getFluidGridsConfig } from "./config-X97zrIvn.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
 import { useMemo } from "react";
 import { Icon } from "@iconify/react";

package/dist/client-Ctl4jmY3.js

@@ -0,0 +1,127 @@
+"use client";
+import { s as createLiveTokenReader, t as createFluidGridsTokenRefreshLink } from "./token-refresh-link-BjN7H4qA.js";
+import { ApolloClient, InMemoryCache, createHttpLink, split } from "@apollo/client/core";
+import { setContext } from "@apollo/client/link/context";
+import { getMainDefinition } from "@apollo/client/utilities";
+import { GraphQLWsLink } from "@apollo/client/link/subscriptions";
+import { createClient } from "graphql-ws";
+
+// src/graphql/client.ts
+let clientInstance = null;
+/**
+* Create a new Apollo client for FluidGrids SDK.
+*
+* Tokens are read per request: the client starts with `config.authToken` /
+* `config.workspaceToken` and follows any token set later in the SDK config
+* (see `auth.onTokenExpired`). Expired-token responses are refreshed and
+* retried once by `createFluidGridsTokenRefreshLink`; the websocket reads the
+* current token whenever it (re)connects.
+*/
+function createFluidGridsClient(config) {
+	const graphqlUrl = getGraphQLUrl(config.apiGatewayUrl);
+	const wsUrl = graphqlUrl.replace(/^http/, "ws");
+	const readTokens = createLiveTokenReader({
+		authToken: config.authToken,
+		workspaceToken: config.workspaceToken
+	});
+	const httpLink = createHttpLink({ uri: graphqlUrl });
+	const authLink = setContext((_, { headers }) => {
+		const { authToken, workspaceToken } = readTokens();
+		return { headers: {
+			...headers,
+			...authToken && { authorization: `Bearer ${authToken}` },
+			...workspaceToken && { "x-workspace-authorization": `Bearer ${workspaceToken}` },
+			"x-workspace-id": config.workspaceId,
+			...config.tenantId && { "x-tenant-id": config.tenantId },
+			...config.productId && { "x-product-id": config.productId }
+		} };
+	});
+	const wsLink = new GraphQLWsLink(createClient({
+		url: wsUrl,
+		connectionParams: () => {
+			const { authToken, workspaceToken } = readTokens();
+			return {
+				authorization: authToken ? `Bearer ${authToken}` : "",
+				...workspaceToken && { "x-workspace-authorization": `Bearer ${workspaceToken}` },
+				"x-workspace-id": config.workspaceId,
+				...config.tenantId && { "x-tenant-id": config.tenantId },
+				...config.productId && { "x-product-id": config.productId }
+			};
+		}
+	}));
+	const splitLink = split(({ query }) => {
+		const definition = getMainDefinition(query);
+		return definition.kind === "OperationDefinition" && definition.operation === "subscription";
+	}, wsLink, createFluidGridsTokenRefreshLink().concat(authLink).concat(httpLink));
+	return new ApolloClient({
+		link: splitLink,
+		cache: new InMemoryCache(),
+		defaultOptions: {
+			watchQuery: { fetchPolicy: "cache-and-network" },
+			query: { fetchPolicy: "network-only" }
+		}
+	});
+}
+/**
+* Get the GraphQL URL from the API gateway URL
+*/
+function getGraphQLUrl(apiGatewayUrl) {
+	const normalizedBase = apiGatewayUrl.endsWith("/") ? apiGatewayUrl.slice(0, -1) : apiGatewayUrl;
+	if (normalizedBase.endsWith("/graphql")) return normalizedBase;
+	return `${normalizedBase}/workspaces/graphql`;
+}
+/**
+* Set the module-level client (for SDK-managed mode or wrapper injection)
+*/
+function setFluidGridsClient(client) {
+	clientInstance = client;
+}
+/**
+* Get the module-level client
+* @throws Error if client is not initialized
+*/
+function getFluidGridsClient() {
+	if (!clientInstance) throw new Error("FluidGrids client not initialized. Use FluidGridsProvider or call setFluidGridsClient().");
+	return clientInstance;
+}
+/**
+* Get the client if available, or null if not initialized
+*/
+function getFluidGridsClientSafe() {
+	return clientInstance;
+}
+/**
+* Check if the client is ready
+*/
+function isFluidGridsClientReady() {
+	return clientInstance !== null;
+}
+/**
+* Wait for the client to be initialized
+*/
+function waitForFluidGridsClient(timeoutMs = 1e4, intervalMs = 100) {
+	return new Promise((resolve) => {
+		if (clientInstance) {
+			resolve(clientInstance);
+			return;
+		}
+		const start = Date.now();
+		const timer = setInterval(() => {
+			if (clientInstance) {
+				clearInterval(timer);
+				resolve(clientInstance);
+			} else if (Date.now() - start >= timeoutMs) {
+				clearInterval(timer);
+				resolve(null);
+			}
+		}, intervalMs);
+	});
+}
+/**
+* Reset the client reference (for cleanup on unmount)
+*/
+function resetFluidGridsClient() {
+	clientInstance = null;
+}
+
+export { resetFluidGridsClient as a, isFluidGridsClientReady as i, getFluidGridsClient as n, setFluidGridsClient as o, getFluidGridsClientSafe as r, waitForFluidGridsClient as s, createFluidGridsClient as t };

package/dist/code-editor-diagnostics-Zr0cIcx1.js

@@ -0,0 +1,46 @@
+"use client";
+// src/builder/components/ndv/code-editor-diagnostics.ts
+/** Maps the service's severity strings onto CodeMirror's three. */
+function editorSeverity(value) {
+	const lower = value.toLowerCase();
+	if (lower.startsWith("warn")) return "warning";
+	if (lower === "info" || lower === "hint" || lower === "suggestion") return "info";
+	return "error";
+}
+/** Start offsets of each line of `text`. */
+function lineStarts(text) {
+	const starts = [0];
+	for (let i = 0; i < text.length; i += 1) if (text.charCodeAt(i) === 10) starts.push(i + 1);
+	return starts;
+}
+/**
+* Converts line/column diagnostics into CodeMirror ranges over `text`. A
+* position beyond the text is clamped to its end, so a diagnostic computed for
+* an older text never throws. A column marks the token that starts there (up
+* to the next non-word character); no column marks the whole line.
+*/
+function toCodeMirrorDiagnostics(text, diagnostics) {
+	const starts = lineStarts(text);
+	return diagnostics.map((diagnostic) => {
+		const lineIndex = Math.min(Math.max((diagnostic.line ?? 1) - 1, 0), starts.length - 1);
+		const lineStart = starts[lineIndex];
+		const lineEnd = lineIndex + 1 < starts.length ? starts[lineIndex + 1] - 1 : text.length;
+		let from = lineStart;
+		let to = lineEnd;
+		if (diagnostic.column && diagnostic.column > 0) {
+			from = Math.min(lineStart + diagnostic.column - 1, lineEnd);
+			to = from;
+			while (to < lineEnd && /[\w$]/.test(text.charAt(to))) to += 1;
+			if (to === from) to = Math.min(from + 1, lineEnd);
+		}
+		const message = diagnostic.code ? `${diagnostic.code}: ${diagnostic.message}` : diagnostic.message;
+		return {
+			from,
+			to,
+			severity: diagnostic.severity,
+			message
+		};
+	});
+}
+
+export { toCodeMirrorDiagnostics as n, editorSeverity as t };

package/dist/{code-editor-field-Dt6KNWwN.js → code-editor-field-Cv907s3W.js}

@@ -1,7 +1,7 @@
 "use client";
 import { t as __exportAll } from "./rolldown-runtime-hDbaFkMy.js";
-import { g as toCodeMirrorDiagnostics } from "./node-operation-selection-DAbS6jSY.js";
-import { Un as useBuilderReadOnly } from "./FluidGridsProvider-C4FVNz0n.js";
+import { n as toCodeMirrorDiagnostics } from "./code-editor-diagnostics-Zr0cIcx1.js";
+import { n as useBuilderReadOnly } from "./read-only-context-Dt9N9SIG.js";
 import { useEffect, useMemo, useRef, useState } from "react";
 import { cn } from "@burdenoff/fe-libs/utils";
 import { jsx } from "react/jsx-runtime";

package/dist/{codec-client-CJ95Rmqo.js → codec-client-CAYl6j46.js}

@@ -1,5 +1,6 @@
 "use client";
-import { _ as throwIfResultError, n as getFluidGridsClient } from "./client-C9XSzSXr.js";
+import { o as throwIfResultError } from "./errors-xPZ-IbQd.js";
+import { n as getFluidGridsClient } from "./client-Ctl4jmY3.js";
 import { r as useTr } from "./TranslationBridge-Da-TPgQm.js";
 import { useCallback, useEffect, useState } from "react";
 import { cn } from "@burdenoff/fe-libs/utils";