@abgov/jsonforms-components 2.68.1 → 2.69.0

package/index.esm.js

@@ -6441,7 +6441,6 @@ function collectRequiredPaths(schema, basePath = '') {
   }
   return out;
 }
-// eslint-disable-next-line
 function collectControllerKeys(ifSchema) {
   if (!isObj(ifSchema)) return [];
   const keys = new Set();
@@ -6454,7 +6453,6 @@ function collectControllerKeys(ifSchema) {
   }
   return [...keys];
 }
-// eslint-disable-next-line
 function buildConditionalDeps(rootSchema) {
   const deps = new Map();
   // eslint-disable-next-line
@@ -6489,9 +6487,55 @@ function buildConditionalDeps(rootSchema) {
   return out;
 }
 
+const sinTitle = 'Social insurance number';
+const invalidSin = 'Social insurance number is invalid';
+const DEFAULT_MAX_ITEMS = 50;
+const REQUIRED_PROPERTY_ERROR = 'is a required property';
+const ADDRESS_LOOKUP_LABELS = {
+  addressLine1: 'Address line 1',
+  addressLine2: 'Address line 2',
+  municipality: 'City',
+  postalCode: 'Postal code',
+  subdivisionCode: 'Province',
+  country: 'Country'
+};
+const VALIDATION_KEYWORDS = {
+  REQUIRED: 'required',
+  MIN_LENGTH: 'minLength',
+  MAX_LENGTH: 'maxLength',
+  FORMAT: 'format',
+  MINIMUM: 'minimum',
+  MAXIMUM: 'maximum',
+  TYPE: 'type',
+  ERROR_MESSAGE: 'errorMessage'
+};
+var StepStatus;
+(function (StepStatus) {
+  StepStatus["NOT_STARTED"] = "NotStarted";
+  StepStatus["IN_PROGRESS"] = "InProgress";
+  StepStatus["COMPLETED"] = "Completed";
+})(StepStatus || (StepStatus = {}));
+const getAddressLookupFieldLabel = fieldName => {
+  return ADDRESS_LOOKUP_LABELS[fieldName] || fieldName;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function getValueAtPath(obj, path) {
+  return path.split('.').reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function hasMeaningfulValue(val) {
+  if (val === undefined || val === null) return false;
+  if (typeof val === 'string') return val.trim() !== '';
+  if (Array.isArray(val)) return val.length > 0;
+  if (typeof val === 'object') return Object.keys(val).length > 0;
+  return true;
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function getSubSchema(schema, path) {
   const parts = path.replace(/^#\//, '').split('/').filter(p => p !== 'properties') // remove 'properties' segments
   .slice(0, -1);
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   let current = schema;
   for (const part of parts) {
     if (!current) return undefined;
@@ -6505,6 +6549,28 @@ function getSubSchema(schema, path) {
   }
   return current;
 }
+// Checks whether any of the given normalized scopes (dot-path form, e.g. "a.b.c")
+// resolve to a property name present in the required array. Returns true if at
+// least one scope's property name is required, false otherwise.
+function isScopeRequired(normalizedScopes, required) {
+  if (!(normalizedScopes != null && normalizedScopes.length) || !(required != null && required.length)) return false;
+  return normalizedScopes.some(scope => {
+    const propertyName = scope.split('.').pop();
+    return !!propertyName && required.includes(propertyName);
+  });
+}
+// Aggregates the required property names applicable to a step's scopes: the
+// schema's top-level required array plus the required array of each scope's
+// immediate parent (sub)schema (for nested objects).
+function getRequiredForScopes(scopes, schema) {
+  const topLevelRequired = schema.required || [];
+  const scopeSets = scopes.reduce((acc, scope) => {
+    const subSchema = getSubSchema(schema, scope);
+    return acc.concat((subSchema == null ? void 0 : subSchema.required) || []);
+  }, topLevelRequired);
+  return Array.from(new Set(scopeSets));
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 function anyRequiredFieldEmpty(scopes, data, required, schema) {
   for (const scope of scopes) {
     const path = scope.replace(/^#\//, '').split('/').filter(p => p !== 'properties');
@@ -6528,6 +6594,15 @@ function anyRequiredFieldEmpty(scopes, data, required, schema) {
   }
   return false;
 }
+// Resolve a single schema scope against the provided data and determine whether
+// it already holds a meaningful value. Used to derive the initial "visited"
+// state of a step from populated form data.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function hasValueAtScope(data, scope) {
+  const path = normalizeSchemaPath(scope);
+  if (!path) return false;
+  return hasMeaningfulValue(getValueAtPath(data, path));
+}
 function getStepStatus(opts) {
   const {
     scopes,
@@ -6536,22 +6611,50 @@ function getStepStatus(opts) {
     data,
     visited
   } = opts;
-  if (!visited) {
-    return 'NotStarted';
-  }
   const normalizedScopes = scopes.map(normalizeSchemaPath).filter(Boolean);
+  // A step with no required fields has nothing that must be filled in, so once
+  // the user has visited it (e.g. navigated back to the application overview
+  // page) it is trivially Completed, regardless of whether its optional
+  // fields hold any data.
+  const requiredForScopes = getRequiredForScopes(scopes, schema);
+  const stepHasRequiredFields = isScopeRequired(normalizedScopes, requiredForScopes);
+  // NotStarted is data-driven: if any scoped field has a defined value the step has been started.
+  // For non-standard scopes that cannot be normalised, fall back to the visited flag so those
+  // steps are never stuck in NotStarted when the form is pre-populated or already visited.
+  const stepHasData = normalizedScopes.length > 0 ? normalizedScopes.some(path => hasMeaningfulValue(get$1(data || {}, path))) : visited != null ? visited : false;
+  if (!stepHasRequiredFields && (visited || stepHasData)) {
+    return {
+      status: StepStatus.COMPLETED,
+      hasRequiredFields: stepHasRequiredFields
+    };
+  }
+  if (!stepHasData) {
+    return {
+      status: StepStatus.NOT_STARTED,
+      hasRequiredFields: stepHasRequiredFields
+    };
+  }
   const incompleteInStep = getIncompletePaths(errors, scopes);
   if (incompleteInStep.length > 0) {
-    return 'InProgress';
+    return {
+      status: StepStatus.IN_PROGRESS,
+      hasRequiredFields: stepHasRequiredFields
+    };
   }
   const required = schema.required || [];
   if (anyRequiredFieldEmpty(scopes, data, required, schema)) {
-    return 'InProgress';
+    return {
+      status: StepStatus.IN_PROGRESS,
+      hasRequiredFields: stepHasRequiredFields
+    };
   }
   const deps = buildConditionalDeps(schema);
   const controllersInStep = normalizedScopes.filter(s => deps.has(s));
   if (controllersInStep.length === 0) {
-    return 'Completed';
+    return {
+      status: StepStatus.COMPLETED,
+      hasRequiredFields: stepHasRequiredFields
+    };
   }
   const affected = new Set();
   for (const controller of controllersInStep) {
@@ -6560,27 +6663,38 @@ function getStepStatus(opts) {
     }
   }
   if (affected.size === 0) {
-    return 'Completed';
+    return {
+      status: StepStatus.COMPLETED,
+      hasRequiredFields: stepHasRequiredFields
+    };
   }
   const affectedPaths = [...affected];
   for (const err of errors || []) {
     for (const candidate of collectErrorCandidates(err)) {
       if (affectedPaths.some(path => isUnder(candidate, path))) {
-        return 'InProgress';
+        return {
+          status: StepStatus.IN_PROGRESS,
+          hasRequiredFields: stepHasRequiredFields
+        };
       }
     }
   }
-  return 'Completed';
+  return {
+    status: StepStatus.COMPLETED,
+    hasRequiredFields: stepHasRequiredFields
+  };
 }
 function collectErrorCandidates(e) {
   var _e$params;
   const out = [];
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const missing = (_e$params = e.params) == null ? void 0 : _e$params.missingProperty;
-  if (e.keyword === 'required' && missing) {
+  if (e.keyword === VALIDATION_KEYWORDS.REQUIRED && missing) {
     const base = normalizeInstancePath(e.instancePath || '');
     out.push(base ? `${base}.${missing}` : missing);
   }
   if (e.instancePath) out.push(normalizeInstancePath(e.instancePath));
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   if (e.dataPath) out.push(normalizeInstancePath(e.dataPath));
   return out.filter(Boolean);
 }
@@ -6609,9 +6723,10 @@ function getIncompletePaths(errors, scopePaths) {
   const incomplete = new Set();
   for (const error of errors) {
     var _error$params;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const missingProperty = (_error$params = error.params) == null ? void 0 : _error$params.missingProperty;
     const candidates = [];
-    if (error.keyword === 'required' && missingProperty) {
+    if (error.keyword === VALIDATION_KEYWORDS.REQUIRED && missingProperty) {
       candidates.push(missingProperty);
       if (error.instancePath) {
         const base = normalizeInstancePath(error.instancePath);
@@ -6672,7 +6787,22 @@ const stepperReducer = (state, action) => {
   switch (action.type) {
     case 'update/uischema':
       {
-        return Object.assign({}, action.payload.state);
+        const newState = action.payload.state;
+        // createStepperContextInitData recomputes categories purely from the
+        // current data/schema snapshot, so a category with no data in its scopes
+        // is reported as not visited even if the user already navigated through it
+        // (page/next, page/prev, or setVisited previously marked it visited).
+        // Preserve any previously-tracked isVisited=true so navigation history
+        // isn't lost whenever unrelated form data changes trigger this recompute.
+        const mergedCategories = newState.categories.map(newCategory => {
+          const previousCategory = categories.find(c => c.id === newCategory.id);
+          return Object.assign({}, newCategory, {
+            isVisited: (previousCategory == null ? void 0 : previousCategory.isVisited) || newCategory.isVisited
+          });
+        });
+        return Object.assign({}, newState, {
+          categories: mergedCategories
+        });
       }
     case 'page/next':
       {
@@ -6740,7 +6870,9 @@ const stepperReducer = (state, action) => {
           }
           const filteredErrors = ajv.errors && ajv.errors.filter(error => (error == null ? void 0 : error.data) != null);
           const visited = true;
-          const status = getStepStatus({
+          const {
+            status
+          } = getStepStatus({
             scopes: cat.scopes,
             data,
             errors: filteredErrors != null ? filteredErrors : [],
@@ -6748,9 +6880,9 @@ const stepperReducer = (state, action) => {
             visited
           });
           return Object.assign({}, cat, {
-            isCompleted: status === 'Completed',
-            isValid: status === 'Completed',
-            status
+            isCompleted: status === StepStatus.COMPLETED,
+            isValid: status === StepStatus.COMPLETED,
+            status: status
           });
         });
         return Object.assign({}, state, {
@@ -6810,26 +6942,38 @@ const createStepperContextInitData = props => {
   // run validation once, capture errors
   const valid = ajv.validate(schema, data || {});
   const isPage = (uischema == null || (_uischema$options = uischema.options) == null ? void 0 : _uischema$options.variant) === 'pages';
+  //TODO: Determine if cachedStatus is still being used by anything in the library
+  //      If not, do a proper clean up.
   const isCacheStatus = (_uischema$options2 = uischema.options) == null ? void 0 : _uischema$options2.cacheStatus;
   isCacheStatus && getIsVisitFromLocalStorage() || [];
   const categories = (_categorization$eleme = categorization.elements) == null ? void 0 : _categorization$eleme.map((c, id) => {
     var _deriveLabelForUISche;
     const scopes = pickPropertyValues(c, 'scope', 'ListWithDetail');
-    const visited = false;
-    const status = getStepStatus({
+    // Treat a step as visited when its scoped fields already contain data so
+    // that getStepStatus returns the real data-driven status on initial mount initially.
+    let visited = scopes.some(scope => hasValueAtScope(data, scope));
+    const {
+      status,
+      hasRequiredFields
+    } = getStepStatus({
       scopes,
       data,
       errors: filteredErrors != null ? filteredErrors : [],
       schema,
       visited
     });
+    //If the step has all conditional fields, set visited to true so that the step status will be
+    //completed to enable form to be saved.
+    if (!hasRequiredFields) {
+      visited = true;
+    }
     return {
       id,
       label: (_deriveLabelForUISche = deriveLabelForUISchemaElement(c, t)) != null ? _deriveLabelForUISche : `Step ${id + 1}`,
       scopes,
-      isCompleted: status === 'Completed',
-      isValid: status === 'Completed',
-      isVisited: status === 'Completed',
+      isCompleted: status === StepStatus.COMPLETED || visited && !hasRequiredFields,
+      isValid: status === StepStatus.COMPLETED || visited && !hasRequiredFields,
+      isVisited: [StepStatus.COMPLETED, StepStatus.IN_PROGRESS].includes(status),
       status,
       uischema: c,
       isEnabled: isEnabled(c, data, '', ajv, undefined),
@@ -6999,7 +7143,7 @@ const JsonFormsStepperContextProvider = ({
       }
     }
     //eslint-disable-next-line
-  }, [JSON.stringify(StepperProps.uischema), JSON.stringify(StepperProps.schema)]);
+  }, [JSON.stringify(StepperProps.uischema), JSON.stringify(StepperProps.schema), JSON.stringify(StepperProps.data)]);
   return jsx(JsonFormsStepperContext.Provider, {
     value: context,
     children: children
@@ -7264,32 +7408,6 @@ fixRegExpWellKnownSymbolLogic$1('match', function (MATCH, nativeMatch, maybeCall
   ];
 });
 
-const sinTitle = 'Social insurance number';
-const invalidSin = 'Social insurance number is invalid';
-const DEFAULT_MAX_ITEMS = 50;
-const REQUIRED_PROPERTY_ERROR = 'is a required property';
-const ADDRESS_LOOKUP_LABELS = {
-  addressLine1: 'Address line 1',
-  addressLine2: 'Address line 2',
-  municipality: 'City',
-  postalCode: 'Postal code',
-  subdivisionCode: 'Province',
-  country: 'Country'
-};
-const VALIDATION_KEYWORDS = {
-  REQUIRED: 'required',
-  MIN_LENGTH: 'minLength',
-  MAX_LENGTH: 'maxLength',
-  FORMAT: 'format',
-  MINIMUM: 'minimum',
-  MAXIMUM: 'maximum',
-  TYPE: 'type',
-  ERROR_MESSAGE: 'errorMessage'
-};
-const getAddressLookupFieldLabel = fieldName => {
-  return ADDRESS_LOOKUP_LABELS[fieldName] || fieldName;
-};
-
 //type DebounceValueType = string | boolean | number | Record<string, unknown>;
 /**
  * A helper util to return a value at a certain delay. The delay is reset if the value arg changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abgov/jsonforms-components",
-  "version": "2.68.1",
+  "version": "2.69.0",
   "license": "Apache-2.0",
   "description": "Government of Alberta - React renderers for JSON Forms based on the design system.",
   "repository": "https://github.com/GovAlta/adsp-monorepo",

package/renderer-catalog.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-07-09T20:09:22.767Z",
-  "sourceCommit": "5d8a7ba85bedb14a77786d3941256a92e2074f6b",
+  "generatedAt": "2026-07-22T15:10:21.951Z",
+  "sourceCommit": "813cb678891e28cf6ee0066498302eb66248289f",
   "sourcePath": "libs/jsonforms-components/src/index.ts",
   "rendererCount": 33,
   "renderers": [

package/src/lib/Controls/FormStepper/context/reducer.d.ts

@@ -2,6 +2,7 @@ import { StepperContextDataType } from './types';
 import { ErrorObject } from 'ajv';
 import { Dispatch } from 'react';
 import Ajv from 'ajv';
+import { JsonSchema } from '@jsonforms/core';
 export type JsonFormStepperDispatch = Dispatch<StepperAction>;
 export type StepperAction = {
     type: 'page/next';
@@ -24,7 +25,7 @@ export type StepperAction = {
         errors?: ErrorObject[];
         id: number;
         ajv: Ajv;
-        schema: any;
+        schema: JsonSchema;
         data: any;
     };
 } | {

package/src/lib/Controls/FormStepper/context/types.d.ts

@@ -1,4 +1,5 @@
 import { Categorization, Category } from '@jsonforms/core';
+import { StepStatusType } from '../../../common/Constants';
 export interface CategoryInternalState {
     isCompleted?: boolean;
     isVisited?: boolean;
@@ -16,6 +17,15 @@ export interface CategoryConfig {
 }
 export type CategoryState = CategoryInternalState & CategoryConfig;
 export type CategoriesState = Array<CategoryState>;
+export interface StepConfig {
+    id: string;
+    label: string;
+    scopePaths: string[];
+}
+export interface StepStatusData {
+    status: StepStatusType;
+    hasRequiredFields: boolean;
+}
 export interface StepperContextDataType {
     categories: CategoriesState;
     activeId: number;

package/src/lib/Controls/FormStepper/context/util.d.ts

@@ -1,12 +1,16 @@
+import { JsonSchema } from '@jsonforms/core';
 import type { ErrorObject } from 'ajv';
+import { StepStatusData } from './types';
 export declare function hasMeaningfulValue(val: any): boolean;
+export declare function isScopeRequired(normalizedScopes: string[], required: string[]): boolean;
+export declare function hasValueAtScope(data: any, scope: string): boolean;
 export declare function getStepStatus(opts: {
     scopes: string[];
     data: any;
     errors: AjvError[];
-    schema: any;
-    visited: boolean;
-}): 'Completed' | 'InProgress' | 'NotStarted';
+    schema: JsonSchema;
+    visited?: boolean;
+}): StepStatusData;
 export declare const isErrorPathIncluded: (errorPaths: string[], path: string) => boolean;
 type AjvError = ErrorObject & {
     dataPath?: string;
@@ -14,12 +18,6 @@ type AjvError = ErrorObject & {
 export declare function normalizeSchemaPath(schemaPath: string): string;
 export declare function normalizeInstancePath(instancePath: string): string;
 export declare function getIncompletePaths(errors: AjvError[] | null | undefined, scopePaths: string[]): string[];
-export type StepStatus = 'not-started' | 'in-progress' | 'completed';
-export interface StepConfig {
-    id: string;
-    label: string;
-    scopePaths: string[];
-}
 export declare const subErrorInParent: (error: ErrorObject, paths: string[]) => boolean;
 export declare const getErrorsInScopes: (errors: ErrorObject[] | null | undefined, scopes: string[]) => ErrorObject[];
 export declare const hasDataInScopes: (data: object, scopes: string[]) => boolean;

package/src/lib/Controls/FormStepper/util/conditionalDeps.d.ts

@@ -1 +1,2 @@
-export declare function buildConditionalDeps(rootSchema: any): Map<string, string[]>;
+import { JsonSchema } from '@jsonforms/core';
+export declare function buildConditionalDeps(rootSchema: JsonSchema): Map<string, string[]>;

package/src/lib/common/Constants.d.ts

@@ -20,4 +20,10 @@ export declare const VALIDATION_KEYWORDS: {
     TYPE: string;
     ERROR_MESSAGE: string;
 };
+export declare enum StepStatus {
+    NOT_STARTED = "NotStarted",
+    IN_PROGRESS = "InProgress",
+    COMPLETED = "Completed"
+}
+export type StepStatusType = StepStatus.COMPLETED | StepStatus.NOT_STARTED | StepStatus.IN_PROGRESS;
 export declare const getAddressLookupFieldLabel: (fieldName: string) => string;