@abgov/jsonforms-components 2.70.3 → 2.71.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abgov/jsonforms-components",
-  "version": "2.70.3",
+  "version": "2.71.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-28T15:31:21.353Z",
-  "sourceCommit": "7656ec403e45371b12001c0a2f44a8ade8632339",
+  "generatedAt": "2026-08-04T16:45:42.802Z",
+  "sourceCommit": "a30b2d185c20480fc9d22daa6bcd39656cb4085e",
   "sourcePath": "libs/jsonforms-components/src/index.ts",
   "rendererCount": 33,
   "renderers": [

package/src/lib/Context/ContextProvider.d.ts

@@ -24,6 +24,10 @@ interface SubmitManagement {
     submitForm?: (any: any) => void;
     saveForm?: (any: any) => void;
 }
+export interface AutoPopulatedValue {
+    path: string;
+    value: unknown;
+}
 type Props = {
     children?: React.ReactNode;
     fileManagement?: FileManagement;
@@ -31,6 +35,8 @@ type Props = {
     isFormSubmitted?: boolean;
     data?: any;
     formUrl?: string | null | undefined;
+    autoPopulatedData?: AutoPopulatedValue[];
+    formId?: string;
 };
 export declare class ContextProviderClass {
     selfProps: Props | undefined;
@@ -48,6 +54,8 @@ export declare class ContextProviderClass {
         getAllFormContextData: () => AllData;
         isFormSubmitted?: boolean;
         formUrl: string | null | undefined;
+        autoPopulatedData?: AutoPopulatedValue[];
+        formId?: string;
     };
     addFormContextData: (key: string, data: Record<string, unknown> | unknown[]) => void;
     addDataByUrl(key: string, url: string, processDataFunction: (data: object) => string[], token?: string): Promise<void>;

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

@@ -4,6 +4,10 @@ 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 interface AutoPopulatedPathValue {
+    path: string;
+    value: unknown;
+}
 export declare function getStepStatus(opts: {
     scopes: string[];
     data: any;
@@ -11,6 +15,7 @@ export declare function getStepStatus(opts: {
     schema: JsonSchema;
     visited?: boolean;
     autoPopulatedScopes?: string[];
+    autoPopulatedValues?: AutoPopulatedPathValue[];
 }): StepStatusData;
 export declare const isErrorPathIncluded: (errorPaths: string[], path: string) => boolean;
 type AjvError = ErrorObject & {
@@ -22,6 +27,8 @@ export declare function getIncompletePaths(errors: AjvError[] | null | undefined
 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;
+export declare const saveVisitedSteps: (formId: string | undefined, ids: number[]) => void;
+export declare const getVisitedSteps: (formId: string | undefined) => number[] | undefined;
 export declare function isJson(str: string): boolean;
 export declare const saveIsVisitFromLocalStorage: (status: boolean[]) => void;
 export declare const getIsVisitFromLocalStorage: () => boolean[] | undefined;

package/src/lib/Controls/FullName/FullNameInputs.d.ts

@@ -9,6 +9,8 @@ interface NameInputsProps {
     requiredFields?: string[];
     errors?: Record<string, string>;
     onFieldBlur?: (name: string) => void;
+    /** Called whenever a field loses focus, so the owner can push pending edits without waiting out the debounce. */
+    onFieldCommit?: () => void;
     handleInputChange: (field: string, value: string) => void;
 }
 export declare const NameInputs: React.FC<NameInputsProps>;

package/src/lib/util/useDebouncedCommit.d.ts

@@ -0,0 +1,37 @@
+export declare const COMMIT_DELAY = 300;
+export interface SetValueOptions {
+    /**
+     * Whether the edit should be pushed upstream once typing stops. Pass false for a field whose
+     * owner commits on its own schedule; the value is still mirrored and still protected from
+     * incoming data until something calls flush.
+     */
+    autoCommit?: boolean;
+}
+export interface DebouncedCommit<T> {
+    /** The live value to bind to the input; updated on every keystroke. */
+    value: T;
+    /** Records a keystroke and, unless told otherwise, schedules the commit. */
+    setValue: (next: T, options?: SetValueOptions) => void;
+    /** Commits straight away, for events that are not typing (blur, selecting a suggestion, unmount). */
+    flush: () => void;
+}
+/**
+ * Keeps a live, per-keystroke mirror of a control's value and pushes it into the form data only
+ * once the user pauses typing.
+ *
+ * The GoA web components keep the value in their own DOM and report changes back a macrotask
+ * late, while their update path writes an incoming `value` prop straight back into the field
+ * whenever it differs from what is in the box. So a render that commits a value older than what
+ * has been typed since wipes out the characters in between. Committing on every keystroke
+ * re-renders and revalidates the whole form, which makes that window wide enough to swallow
+ * characters; debouncing the commit keeps it to a single local render.
+ *
+ * The echo of our own commit is ignored while further edits are outstanding, so data arriving
+ * back from the form can never overwrite what the user has typed in the meantime.
+ *
+ * @param externalValue the value held in the form data; must be referentially stable between
+ *   renders (memoize it when it is an object), otherwise the sync effect runs on every render
+ * @param commit pushes a settled value into the form data
+ * @param delay how long to wait for typing to stop before committing
+ */
+export declare function useDebouncedCommit<T>(externalValue: T, commit: (value: T) => void, delay?: number): DebouncedCommit<T>;