@parallelworks/ui 0.20.0 → 0.21.0

package/dist/form/Wizard/WizardStepIndicator.js

@@ -1,46 +1,36 @@
 import cx from "classnames";
-import { useMemo } from "react";
 import { jsx, jsxs } from "react/jsx-runtime";
 //#region src/form/Wizard/WizardStepIndicator.tsx
 function WizardStepIndicator({ stepOrder, currentStep, steps, visitedSteps, invalidSteps, onStepClick, allowJump = false, hideStepNumbers = false }) {
-	const currentIndex = useMemo(() => stepOrder.indexOf(currentStep), [stepOrder, currentStep]);
+	const currentIndex = stepOrder.indexOf(currentStep);
 	const getStepStatus = (stepKey, index) => {
 		if (stepKey === currentStep) return "active";
 		if (index < currentIndex) return "completed";
 		return "upcoming";
 	};
-	const handleStepClick = (stepKey) => {
-		if (!allowJump || !visitedSteps.has(stepKey)) return;
-		onStepClick?.(stepKey);
-	};
-	const isClickable = (stepKey) => {
-		return allowJump && visitedSteps.has(stepKey) && stepKey !== currentStep;
-	};
 	return /* @__PURE__ */ jsx("div", {
 		className: "flex items-start justify-between w-full mb-2 gap-4 py-2",
 		children: stepOrder.map((stepKey, index) => {
 			const stepConfig = steps[stepKey];
 			const status = getStepStatus(stepKey, index);
 			const isInvalid = invalidSteps.has(stepKey);
-			const isClickable_ = isClickable(stepKey);
+			const isClickable = allowJump && visitedSteps.has(stepKey) && stepKey !== currentStep;
 			const isDotActive = status === "active";
 			const isDotCompleted = status === "completed";
-			const isDotUpcoming = status === "upcoming";
 			return /* @__PURE__ */ jsxs("div", {
 				className: "flex flex-col items-center flex-1 relative",
 				children: [
 					/* @__PURE__ */ jsxs("button", {
 						type: "button",
-						onClick: () => handleStepClick(stepKey),
-						disabled: !isClickable_,
+						onClick: () => onStepClick(stepKey),
+						disabled: !isClickable,
 						className: cx("w-12 h-12 rounded-full border-3 flex items-center justify-center font-bold text-base transition-all duration-300 flex-shrink-0 relative", {
-							"cursor-pointer": isClickable_,
-							"cursor-not-allowed": !isClickable_
+							"cursor-pointer": isClickable,
+							"cursor-not-allowed": !isClickable
 						}, {
 							"text-white": isDotActive,
 							"bg-green-500 border-green-600 text-white shadow-md": isDotCompleted && !isInvalid,
-							"bg-(--theme-border) theme-border theme-muted-text shadow-sm": isDotUpcoming && !isInvalid,
-							"bg-(--theme-muted-panel-bg) theme-border theme-muted-text shadow-sm": !isDotActive && !isDotCompleted && !isDotUpcoming && !isInvalid,
+							"bg-(--theme-border) theme-border theme-muted-text shadow-sm": status === "upcoming" && !isInvalid,
 							"bg-red-50 border-red-500 text-red-600 shadow-sm": isInvalid && status !== "active"
 						}),
 						style: isDotActive ? {

package/dist/form/Wizard/types.d.ts

@@ -17,8 +17,6 @@ export interface WizardConfig {
     navigation?: WizardNavigation;
     /** Label for the final submit button */
     submitLabel?: string;
-    /** Use URL-based routing instead of component state */
-    urlBased?: boolean;
     /** Flatten step fields into top-level inputs (default: true). Set false to preserve step keys as nested objects. */
     flatten?: boolean;
 }
@@ -33,39 +31,10 @@ export interface StepFieldConfig {
     options: DynamicFormSchema;
     /** Validate current step before proceeding to next (default: true) */
     validateOnNext?: boolean;
-    /** Allow skipping this step without validation */
-    canSkip?: boolean;
     /** Custom label for next button on this step */
     nextLabel?: string;
     /** Custom label for previous button on this step */
     prevLabel?: string;
-    /** Optional tooltip text */
-    tooltip?: string | string[];
-    /** Hidden field support */
-    hidden?: boolean;
-    /** Disable this step */
-    disabled?: boolean;
-}
-/**
- * Internal wizard state managed by useWizardState hook
- */
-export interface WizardState {
-    /** Current step ID/key */
-    currentStep: string;
-    /** Set of step IDs that have been visited */
-    visitedSteps: Set<string>;
-    /** Set of step IDs that have validation errors */
-    invalidSteps: Set<string>;
-    /** List of all step keys in order */
-    stepOrder: string[];
-    /** Total number of steps */
-    totalSteps: number;
-    /** Whether the wizard is on the last step */
-    isLastStep: boolean;
-    /** Whether the wizard can proceed to next step */
-    canProceedToNext: boolean;
-    /** Whether user can go back */
-    canGoBack: boolean;
 }
 /**
  * Extracted wizard configuration and step information
@@ -77,12 +46,7 @@ export interface ParsedWizardConfig {
     steps: Record<string, StepFieldConfig>;
     /** Ordered list of step keys */
     stepOrder: string[];
-    /** Schema for non-step fields (should be none in pure wizard) */
-    otherFields: Record<string, unknown>;
 }
-/**
- * Wizard navigation parameters
- */
 /**
  * Props for WizardContainer component
  */
@@ -120,8 +84,8 @@ export interface WizardStepIndicatorProps {
     visitedSteps: Set<string>;
     /** Set of invalid step keys */
     invalidSteps: Set<string>;
-    /** Callback when step is clicked */
-    onStepClick?: (stepKey: string) => boolean;
+    /** Callback when a step the user may jump to is clicked */
+    onStepClick: (stepKey: string) => boolean;
     /** Whether clicking completed steps is allowed */
     allowJump?: boolean | undefined;
     /** Hide step numbers */
@@ -131,12 +95,8 @@ export interface WizardStepIndicatorProps {
  * Props for WizardNavigation component
  */
 export interface WizardNavigationProps {
-    /** Current step key */
-    currentStep: string;
-    /** List of step keys in order */
-    stepOrder: string[];
-    /** Whether user can go to next step */
-    canGoToNext: boolean;
+    /** Whether the wizard is on its last step, which submits instead of going next */
+    isLastStep: boolean;
     /** Whether user can go back */
     canGoBack: boolean;
     /** Whether current step is valid */
@@ -164,8 +124,6 @@ export interface WizardStepContentProps {
     stepConfig: StepFieldConfig;
     /** Form values */
     values: Record<string, unknown>;
-    /** Update form values */
-    onValuesChange?: ((values: Record<string, unknown>) => void) | undefined;
     /** Label position for fields */
     labelPosition?: LabelPosition | undefined;
     /** Missing fields list */

package/dist/form/Wizard/useWizardState.d.ts

@@ -1,4 +1,4 @@
-import type { StepFieldConfig, WizardState } from './types.js';
+import type { StepFieldConfig } from './types.js';
 interface UseWizardStateProps {
     /** Ordered list of step keys */
     stepOrder: string[];
@@ -6,23 +6,15 @@ interface UseWizardStateProps {
     steps: Record<string, StepFieldConfig>;
     /** Function to validate current step */
     validateStep: (stepKey: string) => Promise<boolean>;
-    /** Initial step to start with (default: first step) */
-    initialStep?: string;
 }
-export declare function useWizardState({ stepOrder, steps, validateStep, initialStep, }: UseWizardStateProps): {
+export declare function useWizardState({ stepOrder, steps, validateStep }: UseWizardStateProps): {
     currentStep: string;
     visitedSteps: Set<string>;
     invalidSteps: Set<string>;
     isLastStep: boolean;
     canGoBack: boolean;
-    currentStepIndex: number;
-    totalSteps: number;
     goToNext: () => Promise<boolean>;
     goToPrevious: () => void;
     jumpToStep: (stepKey: string) => boolean;
-    reset: () => void;
-    markStepVisited: (stepKey: string) => void;
-    markStepInvalid: (stepKey: string, invalid: boolean) => void;
-    getState: () => WizardState;
 };
 export {};

package/dist/form/Wizard/useWizardState.js

@@ -1,22 +1,13 @@
 import { useCallback, useState } from "react";
 //#region src/form/Wizard/useWizardState.ts
-function useWizardState({ stepOrder, steps, validateStep, initialStep }) {
-	const firstStep = initialStep || stepOrder[0] || "";
+function useWizardState({ stepOrder, steps, validateStep }) {
+	const firstStep = stepOrder[0] ?? "";
 	const [currentStep, setCurrentStep] = useState(firstStep);
 	const [visitedSteps, setVisitedSteps] = useState(/* @__PURE__ */ new Set([firstStep]));
 	const [invalidSteps, setInvalidSteps] = useState(/* @__PURE__ */ new Set());
 	const currentStepIndex = stepOrder.indexOf(currentStep);
 	const isLastStep = currentStepIndex === stepOrder.length - 1;
 	const canGoBack = currentStepIndex > 0;
-	/**
-	* Mark step as visited
-	*/
-	const markStepVisited = useCallback((stepKey) => {
-		setVisitedSteps((prev) => /* @__PURE__ */ new Set([...prev, stepKey]));
-	}, []);
-	/**
-	* Mark step as invalid
-	*/
 	const markStepInvalid = useCallback((stepKey, invalid) => {
 		setInvalidSteps((prev) => {
 			const next = new Set(prev);
@@ -25,93 +16,52 @@ function useWizardState({ stepOrder, steps, validateStep, initialStep }) {
 			return next;
 		});
 	}, []);
-	const goToNext = useCallback(async () => {
-		if (isLastStep) return false;
-		if (steps[currentStep]?.validateOnNext !== false) {
-			if (!await validateStep(currentStep)) {
-				markStepInvalid(currentStep, true);
-				return false;
-			}
-		}
-		markStepInvalid(currentStep, false);
-		const nextStepKey = stepOrder[currentStepIndex + 1];
-		setCurrentStep(nextStepKey ?? "");
-		markStepVisited(nextStepKey ?? "");
-		return true;
-	}, [
-		currentStep,
-		currentStepIndex,
-		isLastStep,
-		steps,
-		stepOrder,
-		validateStep,
-		markStepInvalid,
-		markStepVisited
-	]);
-	const goToPrevious = useCallback(() => {
-		if (!canGoBack) return;
-		const prevStepKey = stepOrder[currentStepIndex - 1];
-		setCurrentStep(prevStepKey ?? "");
-	}, [
-		canGoBack,
-		currentStepIndex,
-		stepOrder
-	]);
-	const jumpToStep = useCallback((stepKey) => {
-		if (!stepOrder.includes(stepKey)) return false;
-		if (!visitedSteps.has(stepKey) && stepKey !== currentStep) return false;
-		setCurrentStep(stepKey);
-		return true;
-	}, [
-		stepOrder,
-		visitedSteps,
-		currentStep
-	]);
-	/**
-	* Reset wizard to initial state
-	*/
-	const reset = useCallback(() => {
-		setCurrentStep(firstStep);
-		setVisitedSteps(/* @__PURE__ */ new Set([firstStep]));
-		setInvalidSteps(/* @__PURE__ */ new Set());
-	}, [firstStep]);
-	/**
-	* Get current wizard state
-	*/
-	const getState = useCallback(() => {
-		return {
-			currentStep,
-			visitedSteps,
-			invalidSteps,
-			stepOrder,
-			totalSteps: stepOrder.length,
-			isLastStep,
-			canProceedToNext: !isLastStep,
-			canGoBack
-		};
-	}, [
-		currentStep,
-		visitedSteps,
-		invalidSteps,
-		stepOrder,
-		isLastStep,
-		canGoBack
-	]);
 	return {
 		currentStep,
 		visitedSteps,
 		invalidSteps,
 		isLastStep,
 		canGoBack,
-		currentStepIndex,
-		totalSteps: stepOrder.length,
-		goToNext,
-		goToPrevious,
-		jumpToStep,
-		reset,
-		markStepVisited,
-		markStepInvalid,
-		getState
+		goToNext: useCallback(async () => {
+			if (isLastStep) return false;
+			if (steps[currentStep]?.validateOnNext !== false) {
+				if (!await validateStep(currentStep)) {
+					markStepInvalid(currentStep, true);
+					return false;
+				}
+			}
+			markStepInvalid(currentStep, false);
+			const nextStepKey = stepOrder[currentStepIndex + 1] ?? "";
+			setCurrentStep(nextStepKey);
+			setVisitedSteps((prev) => /* @__PURE__ */ new Set([...prev, nextStepKey]));
+			return true;
+		}, [
+			currentStep,
+			currentStepIndex,
+			isLastStep,
+			steps,
+			stepOrder,
+			validateStep,
+			markStepInvalid
+		]),
+		goToPrevious: useCallback(() => {
+			if (!canGoBack) return;
+			setCurrentStep(stepOrder[currentStepIndex - 1] ?? "");
+		}, [
+			canGoBack,
+			currentStepIndex,
+			stepOrder
+		]),
+		jumpToStep: useCallback((stepKey) => {
+			if (!stepOrder.includes(stepKey)) return false;
+			if (!visitedSteps.has(stepKey) && stepKey !== currentStep) return false;
+			setCurrentStep(stepKey);
+			return true;
+		}, [
+			stepOrder,
+			visitedSteps,
+			currentStep
+		])
 	};
 }
 //#endregion

package/dist/form/Wizard/utils.js

@@ -8,17 +8,13 @@ function isStepField(field) {
 function parseWizardConfig(options) {
 	const meta = options["$meta"];
 	const wizardConfig = isWizardMeta(meta) ? meta.wizard : void 0;
-	if (!wizardConfig || wizardConfig.mode !== "wizard") return null;
+	if (wizardConfig?.mode !== "wizard") return null;
 	const steps = {};
 	const stepOrder = [];
-	const otherFields = {};
-	Object.entries(options).forEach(([key, field]) => {
-		if (key === "$meta") return;
-		if (isStepField(field)) {
-			steps[key] = field;
-			stepOrder.push(key);
-		} else otherFields[key] = field;
-	});
+	for (const [key, field] of Object.entries(options)) if (key !== "$meta" && isStepField(field)) {
+		steps[key] = field;
+		stepOrder.push(key);
+	}
 	if (stepOrder.length === 0) {
 		console.warn("Wizard mode enabled but no steps found");
 		return null;
@@ -26,8 +22,7 @@ function parseWizardConfig(options) {
 	return {
 		config: wizardConfig,
 		steps,
-		stepOrder,
-		otherFields
+		stepOrder
 	};
 }
 //#endregion

package/dist/form/lib.js

@@ -23,56 +23,44 @@ function enforceOneMustBeTrue(items, options, promoteIndex) {
 		const fieldSchema = options[fieldKey];
 		const opts = typeof fieldSchema === "object" && fieldSchema && "options" in fieldSchema ? fieldSchema.options : void 0;
 		const trueOption = typeof opts === "object" && opts && !Array.isArray(opts) && "onOption" in opts ? opts.onOption || true : true;
-		if (!items.some((item) => item[fieldKey] === trueOption)) items[clampedIndex][fieldKey] = trueOption;
+		const hasTrue = items.some((item) => item[fieldKey] === trueOption);
+		const promoted = items[clampedIndex];
+		if (!hasTrue && promoted) promoted[fieldKey] = trueOption;
 	}
 	return items;
 }
 function flattenGroups(schema) {
 	if (!schema || typeof schema !== "object") return {};
-	const fields = schema;
-	let flattenedFields = {};
-	Object.keys(fields).forEach((key) => {
-		const entry = fields[key];
-		if (entry?.type === "group") {
-			const flattenedGroup = flattenGroups(entry.options);
-			flattenedFields = {
-				...flattenedFields,
-				...flattenedGroup
-			};
-		} else if (entry?.type === "object") {
-			const flattenedGroup = flattenGroups(entry.options);
-			flattenedFields = {
-				...flattenedFields,
-				[key]: flattenedGroup
-			};
-		} else flattenedFields[key] = entry;
-	});
-	return flattenedFields;
+	const flattened = {};
+	for (const [key, entry] of Object.entries(schema)) if (entry?.type === "group") Object.assign(flattened, flattenGroups(entry.options));
+	else if (entry?.type === "object") flattened[key] = flattenGroups(entry.options);
+	else flattened[key] = entry;
+	return flattened;
 }
 /**Not a pure function. Edits 'obj' passed into function */
 function impureSetValueFromPath(obj, path, value) {
-	const pathArray = path.split(".");
-	if (pathArray.length === 1) {
-		obj[pathArray[0]] = value;
-		return;
-	}
+	const parents = path.split(".");
+	const leaf = parents.pop() ?? "";
 	let current = obj;
-	for (let i = 0; i < pathArray.length - 1; i++) {
-		const segment = pathArray[i];
+	for (const segment of parents) {
 		const arrayMatch = segment.match(/^(.+)\[(\d+)\]$/);
 		if (arrayMatch) {
-			const key = arrayMatch[1];
-			const index = Number(arrayMatch[2]);
+			const [, key = "", indexText] = arrayMatch;
+			const index = Number(indexText);
 			if (!current[key]) current[key] = [];
 			const list = current[key];
-			if (!list[index]) list[index] = {};
-			current = list[index];
+			let item = list[index];
+			if (!item) {
+				item = {};
+				list[index] = item;
+			}
+			current = item;
 		} else {
 			if (!current[segment]) current[segment] = {};
 			current = current[segment];
 		}
 	}
-	current[pathArray[pathArray.length - 1]] = value;
+	current[leaf] = value;
 }
 function initializeValues(options, srcData = {}, blankDefault) {
 	if (!options || typeof options !== "object") return;
@@ -82,25 +70,13 @@ function initializeValues(options, srcData = {}, blankDefault) {
 	return Object.keys(schema).reduce((acc, field) => {
 		if (field.startsWith("$")) return acc;
 		const fieldSchema = schema[field] ?? EMPTY_ENTRY;
-		if (fieldSchema.type === "group") {
+		const flattenStep = fieldSchema.type === "step" && schema["$meta"]?.wizard?.flatten !== false;
+		if (fieldSchema.type === "group" || flattenStep) {
 			const values = initializeValues(fieldSchema.options, data);
-			if (!values) return acc;
-			Object.keys(values).forEach((key) => {
-				acc[key] = data[key] ?? values[key];
-			});
-			return acc;
-		}
-		if (fieldSchema.type === "step") {
-			if (schema["$meta"]?.wizard?.flatten !== false) {
-				const values = initializeValues(fieldSchema.options, data);
-				if (!values) return acc;
-				Object.keys(values).forEach((key) => {
-					acc[key] = data[key] ?? values[key];
-				});
-			} else acc[field] = initializeValues(fieldSchema.options, asRecord(data[field]));
+			for (const key of Object.keys(values ?? {})) acc[key] = data[key] ?? values?.[key];
 			return acc;
 		}
-		if (fieldSchema.type === "object") {
+		if (fieldSchema.type === "step" || fieldSchema.type === "object") {
 			acc[field] = initializeValues(fieldSchema.options, asRecord(data[field]));
 			return acc;
 		}
@@ -110,14 +86,12 @@ function initializeValues(options, srcData = {}, blankDefault) {
 				acc[field] = Array.isArray(listData) ? [...listData] : [];
 				return acc;
 			}
-			const arr = [];
-			if (Array.isArray(listData)) for (let i = 0; i < listData.length; i++) arr.push(initializeValues(fieldSchema.options, asRecord(listData[i])));
-			acc[field] = arr;
+			acc[field] = Array.isArray(listData) ? listData.map((item) => initializeValues(fieldSchema.options, asRecord(item))) : [];
 			return acc;
 		}
 		if (data[field] !== void 0) {
 			acc[field] = data[field];
-			if ((fieldSchema.type === "dropdown" || fieldSchema.type === "storage") && fieldSchema.secondaryField && fieldSchema.options && Array.isArray(fieldSchema.options)) {
+			if ((fieldSchema.type === "dropdown" || fieldSchema.type === "storage") && fieldSchema.secondaryField && Array.isArray(fieldSchema.options)) {
 				const option = findSecondaryOption(fieldSchema.options, data[field]);
 				applySecondaryField(fieldSchema.secondaryField, option?.secondaryValue, (secondaryField, secondaryValue) => {
 					if (!(fieldSchema.type === "storage" && Object.hasOwn(options, secondaryField) && source[secondaryField] !== void 0)) impureSetValueFromPath(acc, secondaryField, secondaryValue);
@@ -135,8 +109,8 @@ function initializeValues(options, srcData = {}, blankDefault) {
 			else acc[field] = false;
 		}
 		if (fieldSchema.type === "dropdown") {
-			if (fieldSchema.options && Array.isArray(fieldSchema.options) && fieldSchema.options.length > 0) acc[field] = fieldSchema.options[0].value;
-			if (fieldSchema.type === "dropdown" && fieldSchema.secondaryField && fieldSchema.options && Array.isArray(fieldSchema.options)) {
+			if (Array.isArray(fieldSchema.options) && fieldSchema.options.length > 0) acc[field] = fieldSchema.options[0].value;
+			if (fieldSchema.secondaryField && Array.isArray(fieldSchema.options)) {
 				const option = fieldSchema.options.find((option) => option.value === data[field]);
 				const secondaryField = Array.isArray(fieldSchema.secondaryField) ? fieldSchema.secondaryField : [fieldSchema.secondaryField];
 				const secondaryValue = Array.isArray(option?.secondaryValue) ? option?.secondaryValue : [option?.secondaryValue];

package/dist/form/types/fieldTypes.d.ts

@@ -15,7 +15,8 @@ export interface RuntimeFieldExtensions {
     one_must_be_true?: boolean;
     computeOn?: boolean;
     labelPosition?: LabelPosition;
-    resetOnChange?: boolean;
+    /** Path of another field; when its value changes, this field's value is cleared. */
+    resetOnChange?: string;
     options?: unknown;
 }
 export interface BaseField extends RuntimeFieldExtensions {
@@ -36,14 +37,13 @@ interface WizardConfig {
     /** Navigation UI options */
     navigation?: {
         showSteps?: boolean;
-        showProgress?: boolean;
         allowJump?: boolean;
         hideStepNumbers?: boolean;
     };
     /** Label for the final submit button */
     submitLabel?: string;
-    /** Use URL-based routing instead of component state */
-    urlBased?: boolean;
+    /** Flatten step fields into top-level inputs (default: true). Set false to keep each step's fields under its key. */
+    flatten?: boolean;
 }
 interface StepField extends BaseField {
     type: 'step';
@@ -51,7 +51,6 @@ interface StepField extends BaseField {
     description?: string;
     options: Record<string, AnyField>;
     validateOnNext?: boolean;
-    canSkip?: boolean;
     nextLabel?: string;
     prevLabel?: string;
 }

package/dist/form/utils/dependentOptions.d.ts

@@ -0,0 +1,6 @@
+/** Options for a field whose list is keyed by another field's value: with
+ * depends_on, the list follows whatever is currently chosen at that path. */
+export declare function dependentOptions<T>(options: T[] | Record<string, T[]>, dependsOn: string | undefined, values: Record<string, unknown>): {
+    options: T[];
+    parentValue: unknown;
+};

package/dist/form/utils/dependentOptions.js

@@ -0,0 +1,21 @@
+import { getValueUsingPath } from "./getValueUsingPath.js";
+//#region src/form/utils/dependentOptions.ts
+/** Options for a field whose list is keyed by another field's value: with
+* depends_on, the list follows whatever is currently chosen at that path. */
+function dependentOptions(options, dependsOn, values) {
+	if (Array.isArray(options)) return {
+		options,
+		parentValue: void 0
+	};
+	const parentValue = dependsOn ? getValueUsingPath(values, dependsOn) : void 0;
+	if (parentValue === void 0 || parentValue === null) return {
+		options: [],
+		parentValue
+	};
+	return {
+		options: options[String(parentValue)] ?? [],
+		parentValue
+	};
+}
+//#endregion
+export { dependentOptions };

package/dist/form/utils/getParentValue.d.ts

@@ -1,3 +1,4 @@
-export declare function getParentValue(index: number | undefined, targetField: unknown, values: object, dependentPath: string, field: {
+/** `index` replaces a path's `[index]` placeholder when the field sits in a list row. */
+export declare function getParentValue(index: number | undefined, targetField: unknown, values: object, field: {
     depends_on?: string | undefined;
 }): unknown;

package/dist/form/utils/getParentValue.js

@@ -1,23 +1,18 @@
 import { getValueUsingPath } from "./getValueUsingPath.js";
 import { checkShowIfObject } from "./checkShowIfObject.js";
 //#region src/form/utils/getParentValue.ts
-function getParentValue(index, targetField, values, dependentPath, field) {
-	let parentValue;
-	if (typeof targetField === "object" && targetField !== null && !Array.isArray(targetField)) parentValue = !checkShowIfObject(targetField, values, index).includes(false);
-	else if (field.depends_on) {
-		dependentPath = field.depends_on;
-		if (index !== void 0) dependentPath = field.depends_on.replace("[index]", `[${index}]`);
-		const dependsOnValue = getValueUsingPath(values, dependentPath);
+/** `index` replaces a path's `[index]` placeholder when the field sits in a list row. */
+function getParentValue(index, targetField, values, field) {
+	const atIndex = (path) => index === void 0 ? path : path.replace("[index]", `[${index}]`);
+	if (typeof targetField === "object" && targetField !== null && !Array.isArray(targetField)) return !checkShowIfObject(targetField, values, index).includes(false);
+	if (field.depends_on) {
+		const dependsOnValue = getValueUsingPath(values, atIndex(field.depends_on));
 		const dependsOnText = dependsOnValue === null || dependsOnValue === void 0 ? void 0 : String(dependsOnValue);
-		if (Array.isArray(targetField)) parentValue = targetField.includes(dependsOnValue) || targetField.includes(dependsOnText);
-		else if (typeof targetField === "string") parentValue = dependsOnText !== void 0 && targetField.includes(dependsOnText);
-		else parentValue = targetField === dependsOnValue;
-	} else {
-		dependentPath = typeof targetField === "string" ? targetField : "";
-		if (index !== void 0 && typeof targetField === "string") dependentPath = targetField.replace("[index]", `[${index}]`);
-		parentValue = getValueUsingPath(values, dependentPath);
+		if (Array.isArray(targetField)) return targetField.includes(dependsOnValue) || targetField.includes(dependsOnText);
+		if (typeof targetField === "string") return dependsOnText !== void 0 && targetField.includes(dependsOnText);
+		return targetField === dependsOnValue;
 	}
-	return parentValue;
+	return getValueUsingPath(values, typeof targetField === "string" ? atIndex(targetField) : "");
 }
 //#endregion
 export { getParentValue };

package/dist/form/utils/getValueUsingPath.js

@@ -10,7 +10,7 @@ function getValueUsingPath(obj, path) {
 			const [arrayKey = "", indexStr = ""] = key.split("[");
 			const index = parseInt(indexStr.slice(0, -1), 10);
 			const list = container[arrayKey];
-			if (!Array.isArray(list) || isNaN(index)) return;
+			if (!Array.isArray(list) || Number.isNaN(index)) return;
 			current = list[index];
 		} else {
 			if (!(key in container)) return;

package/dist/graph/AnnotationBanner.d.ts

@@ -1,6 +1,6 @@
 import type { WorkflowJob } from './types.js';
 interface AnnotationBannerProps {
-    executedJobs: Record<string, WorkflowJob> | null | undefined;
+    executedJobs: Record<string, WorkflowJob>;
 }
 export declare function AnnotationBanner({ executedJobs }: AnnotationBannerProps): import("react").JSX.Element | null;
 export {};

package/dist/graph/AnnotationBanner.js

@@ -48,6 +48,7 @@ function collectAnnotations(executedJobs, parentPath) {
 					title: annotation.title,
 					file: annotation.file,
 					line: annotation.line,
+					id: annotation.id,
 					jobName: fullJobName,
 					stepName: step?.name,
 					stepIndex
@@ -62,7 +63,6 @@ function collectAnnotations(executedJobs, parentPath) {
 }
 function AnnotationBanner({ executedJobs }) {
 	const [expanded, setExpanded] = useState(false);
-	if (!executedJobs) return null;
 	const annotations = collectAnnotations(executedJobs);
 	if (annotations.length === 0) return null;
 	const counts = {

package/dist/graph/Collapse.d.ts

@@ -1,6 +1,6 @@
-import { type ReactNode } from 'react';
-export declare function Collapse({ expanded, children, releaseOverflow, }: {
+import type { ReactNode } from 'react';
+export declare function Collapse({ expanded, id, children, }: {
     expanded: boolean;
+    id?: string;
     children: ReactNode;
-    releaseOverflow?: boolean;
 }): import("react").JSX.Element;