treege 3.0.0-beta.9 → 3.0.0-beta.90

package/dist/editor/utils/cleanEmptyData.d.ts

@@ -0,0 +1,18 @@
+import { Flow } from '../../shared/types/node';
+/**
+ * Returns a copy of `data` keeping only the entries that carry information:
+ * everything that is neither empty (see `isEmptyValue`) nor a redundant field
+ * default (see `DEFAULT_DATA_VALUES`). Meaningful falsy values like `false` and
+ * `0` are kept. Used before persisting an input node's form so toggling a single
+ * field doesn't flood the node — and the exported JSON — with empty defaults.
+ */
+export declare const cleanEmptyData: (data: Record<string, unknown>) => Record<string, unknown>;
+/**
+ * Returns a copy of the flow trimmed for export: every node's `data` is cleaned
+ * of empty values and field defaults (see `cleanEmptyData`), and transient
+ * editor UI state is dropped — nodes lose `selected`/`dragging`/`measured` and
+ * edges lose `selected`, all of which xyflow recomputes on mount. The input flow
+ * is never mutated, so the live editor canvas keeps its values — only the
+ * exported/saved artifact is trimmed, mirroring `stripSensitiveHeadersFromFlow`.
+ */
+export declare const cleanFlowData: (flow: Flow) => Flow;

package/dist/editor/utils/cleanNodeConfig.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Returns a copy of `data` keeping only the config blocks that belong to
+ * `subType` (non-config keys are always kept).
+ */
+export declare const cleanConfigForSubType: (data: Record<string, unknown>, subType: string) => Record<string, unknown>;

package/dist/editor/utils/dagreLayout.d.ts

@@ -0,0 +1,8 @@
+import { Edge, Node } from '@xyflow/react';
+export type LayoutDirection = "TB" | "LR";
+export interface LayoutOptions {
+    direction?: LayoutDirection;
+    horizontalSpacing?: number;
+    verticalSpacing?: number;
+}
+export declare const getLayoutedElements: (nodes: Node[], edges: Edge[], options?: LayoutOptions) => Node[];

package/dist/editor/utils/edge.d.ts

@@ -0,0 +1,50 @@
+import { Edge, Node } from '@xyflow/react';
+/**
+ * Whether an edge from `source` to `target` already exists in the set.
+ * Used to reject duplicate connections.
+ */
+export declare const edgeExists: (edges: Edge[], source: string, target: string) => boolean;
+type LeafNode = Pick<Node, "id" | "position" | "parentId">;
+interface BuildConvergenceOptions {
+    /** ID for the new common node. */
+    commonNodeId: string;
+    /** Base node template the common node is spread from (e.g. DEFAULT_NODE). */
+    baseNode: Partial<Node>;
+    /** Measured node height, used to place the common node below both leaves. */
+    nodeHeight: number;
+    /** Vertical gap between the leaves and the common node. */
+    verticalSpacing: number;
+}
+/**
+ * Build the common node that converges two leaves, plus the two edges wiring
+ * each leaf to it (`source → common`, `target → common`). The node is centered
+ * horizontally between the leaves and placed one row below the lower one. It
+ * inherits the group only when both leaves share the same `parentId`.
+ *
+ * Pure and deterministic — the caller supplies the new node id, base template
+ * and measured dimensions — so it can be unit-tested without React Flow.
+ */
+export declare const buildConvergence: (sourceNode: LeafNode, targetNode: LeafNode, { commonNodeId, baseNode, nodeHeight, verticalSpacing }: BuildConvergenceOptions) => {
+    node: Node;
+    edges: Edge[];
+};
+/**
+ * Whether adding an edge `source` → `target` would introduce a cycle, i.e.
+ * `target` can already reach `source` by following outgoing edges. BFS from
+ * `target` over the existing edges; returns true as soon as `source` is found.
+ */
+export declare const wouldCreateCycle: (edges: Edge[], source: string, target: string) => boolean;
+/**
+ * Re-normalize outgoing edges from a set of affected parent nodes: if a parent
+ * now has a single remaining child, convert its outgoing edge back to a
+ * "default" type and drop condition-specific data fields.
+ *
+ * Used after edge or node deletions to keep conditional edges in sync with the
+ * presence of siblings.
+ *
+ * @param edges - The edges remaining after deletion
+ * @param affectedParents - Source node IDs whose children changed
+ * @returns A new edges array with affected edges normalized
+ */
+export declare const normalizeConditionalEdges: (edges: Edge[], affectedParents: Set<string>) => Edge[];
+export {};

package/dist/editor/utils/groupColor.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Deterministic color for a group, derived from its id.
+ *
+ * Why HSL + inline style (rather than a Tailwind class):
+ * Tailwind purges classes at build time and can't synthesize `bg-{color}`
+ * from a runtime hash. Picking from a fixed palette would cap the number of
+ * distinguishable groups; HSL with a hashed hue gives effectively unlimited
+ * distinct, stable colors with no Tailwind-side configuration.
+ *
+ * Saturation/lightness are fixed (65% / 45%) so every group lands in the
+ * same readable, mid-contrast band on both light and dark themes — only the
+ * hue varies between groups.
+ */
+export declare const getGroupColor: (groupId?: string) => string;

package/dist/editor/utils/image.d.ts

@@ -0,0 +1,7 @@
+export declare const MAX_IMAGE_INPUT_BYTES: number;
+/**
+ * Converts an image file to a resized JPEG base64 data URL.
+ * Rejects files that are not images or exceed MAX_IMAGE_INPUT_BYTES.
+ * Dimensions are capped at MAX_DIMENSION × MAX_DIMENSION to keep the JSON small.
+ */
+export declare const imageFileToOptimizedDataUrl: (file: File) => Promise<string>;

package/dist/editor/utils/inputTypeIcon.d.ts

@@ -0,0 +1,6 @@
+import { LucideIcon } from 'lucide-react';
+/**
+ * Returns the Lucide icon associated with an input or UI type.
+ * Falls back to DEFAULT_INPUT_TYPE_ICON when no match is found.
+ */
+export declare const getInputTypeIcon: (type?: string) => LucideIcon;

package/dist/editor/utils/jsonBindTarget.d.ts

@@ -0,0 +1,15 @@
+import { EditorState } from '@codemirror/state';
+export interface JsonBindTarget {
+    /** Start offset of the key/value node to replace. */
+    from: number;
+    /** End offset of the key/value node to replace. */
+    to: number;
+    /** Whether the node is already a `{{token}}` (so the menu can offer "unbind"). */
+    isToken: boolean;
+}
+/**
+ * Find the JSON key or value node under `pos`, so a click there can bind a
+ * field. Returns the range to replace and whether it is already a token, or
+ * `null` when `pos` is not on a key/value (e.g. on punctuation/whitespace).
+ */
+export declare const findJsonBindTargetAt: (state: EditorState, pos: number) => JsonBindTarget | null;

package/dist/editor/utils/openApiPayload.d.ts

@@ -0,0 +1,12 @@
+import { ApiRouteMethod, OpenApiDocument, OpenApiSchema } from '../types/openapi';
+/**
+ * Find the JSON request-body schema for the route matching `url` + `method`,
+ * or `undefined` when the route has no JSON request body.
+ */
+export declare const findRouteRequestSchema: (doc: OpenApiDocument, url: string, method: ApiRouteMethod) => OpenApiSchema | undefined;
+/**
+ * Build a JSON skeleton from a schema: uses `example`/`default`/`enum` when
+ * present, otherwise a typed placeholder (`""`, `0`, `false`, `{}`, `[…]`).
+ * `$ref`s are resolved against `components.schemas`; cyclic refs are cut off.
+ */
+export declare const buildPayloadSkeleton: (doc: OpenApiDocument, schema: OpenApiSchema | undefined, seenRefs?: Set<string>) => unknown;

package/dist/editor/utils/openapi.d.ts

@@ -0,0 +1,35 @@
+import { ApiRoute, OpenApiDocument, OpenApiSecurityScheme } from '../types/openapi';
+/**
+ * Type guard validating that `value` is a usable OpenAPI 3.x document.
+ * Rejects 2.0 (Swagger) since we don't support it.
+ */
+export declare const isOpenApi3Document: (value: unknown) => value is OpenApiDocument;
+/**
+ * Load an OpenAPI document from either a remote URL or a raw JSON string.
+ * Throws when the input is empty, unreachable, malformed JSON, or not an
+ * OpenAPI 3.x document.
+ */
+export declare const loadOpenApiDocument: (input: string) => Promise<OpenApiDocument>;
+/**
+ * Flatten every (method, path) tuple defined in the document, preserving
+ * the path declaration order.
+ */
+export declare const extractApiRoutes: (doc: OpenApiDocument) => ApiRoute[];
+/** Returns the first declared server URL (with any trailing slash trimmed). */
+export declare const getBaseUrl: (doc: OpenApiDocument) => string;
+/** Resolve a path to a full URL using the document's first server. */
+export declare const resolveRouteUrl: (doc: OpenApiDocument, path: string) => string;
+/**
+ * Extract every supported security scheme from the document. Schemes other
+ * than `http+bearer` and `apiKey-in-header` are silently dropped — they're
+ * out of MVP scope.
+ */
+export declare const extractSecuritySchemes: (doc: OpenApiDocument) => Array<{
+    name: string;
+    scheme: OpenApiSecurityScheme;
+}>;
+/**
+ * Resolve a `tokenUrl` (which the OpenAPI spec sometimes leaves relative)
+ * against the document's first declared server URL.
+ */
+export declare const resolveTokenUrl: (tokenUrl: string, doc: OpenApiDocument) => string;

package/dist/editor/utils/sensitiveHeaders.d.ts

@@ -0,0 +1,20 @@
+import { Flow } from '../../shared/types/node';
+import { KeyValueEntry } from '../../shared/utils/httpRecord';
+/** True when a header key is known to carry credentials/secrets. */
+export declare const isSensitiveHeaderKey: (key: string) => boolean;
+/**
+ * True when the editor rows contain a sensitive header with a non-empty value.
+ * Operates on the form's working rows (which may still hold empty keys) rather
+ * than the serialized record, so the warning shows as soon as the user types.
+ */
+export declare const hasSensitiveHeader: (headers?: KeyValueEntry[]) => boolean;
+/**
+ * Returns a copy of the flow with all credential-bearing field-level headers
+ * removed from every node's httpConfig/optionsSource/submitConfig, plus the
+ * number of headers stripped. The input flow is never mutated, so the live
+ * editor canvas keeps its values — only the exported/saved artifact is cleaned.
+ */
+export declare const stripSensitiveHeadersFromFlow: (flow: Flow) => {
+    flow: Flow;
+    strippedCount: number;
+};

package/dist/editor/utils/stackPositionIndex.d.ts

@@ -0,0 +1,9 @@
+import { Edge } from '@xyflow/react';
+export type StackPosition = "single" | "first" | "middle" | "last";
+/**
+ * Memoizes the positions map keyed by the edges array reference. React Flow
+ * keeps that reference stable between unrelated updates (drag, selection, …),
+ * so selectors that read from this map effectively perform a Map lookup
+ * outside of edge mutations.
+ */
+export declare const getPositions: (edges: Edge[]) => Map<string, StackPosition>;