@forgerock/journey-client 0.0.0-beta-20251222204813

package/src/lib/policy/policy.test.ts

@@ -0,0 +1,202 @@
+/*
+ * @forgerock/ping-javascript-sdk
+ *
+ * fr-policy.test.ts
+ *
+ * Copyright (c) 2020 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { PolicyKey } from '@forgerock/sdk-types';
+
+import { Policy, MessageCreator } from './policy.js';
+
+describe('The IDM error handling', () => {
+  const property = 'userName';
+
+  it('returns a human readable error message', () => {
+    const test = {
+      expectedString: `${property} must be unique`,
+      policy: {
+        policyRequirement: 'UNIQUE',
+      },
+    };
+    const message = Policy.parsePolicyRequirement(property, test.policy);
+    expect(message).toBe(test.expectedString);
+  });
+
+  it('returns a human readable error message with param data', () => {
+    const test = {
+      expectedString: `${property} must be at least 6 characters`,
+      policy: {
+        params: {
+          minLength: 6,
+        },
+        policyRequirement: 'MIN_LENGTH',
+      },
+    };
+    const message = Policy.parsePolicyRequirement(property, test.policy);
+    expect(message).toBe(test.expectedString);
+  });
+
+  it('returns a human readable generic message for unknown error', () => {
+    const test = {
+      expectedString: `${property}: Unknown policy requirement "SOME_UNKNOWN_POLICY"`,
+      policy: {
+        params: {
+          unknownParam: 6,
+        },
+        policyRequirement: 'SOME_UNKNOWN_POLICY',
+      },
+    };
+    const message = Policy.parsePolicyRequirement(property, test.policy);
+    expect(message).toBe(test.expectedString);
+  });
+
+  it('error handling is extensible by customer', () => {
+    const test = {
+      customMessage: {
+        CUSTOM_POLICY: (property: string, params?: { [key: string]: unknown }): string =>
+          `this is a custom message for "${params?.policyRequirement}" policy of ${property}`,
+      },
+      expectedString: `this is a custom message for "CUSTOM_POLICY" policy of ${property}`,
+      policy: {
+        policyRequirement: 'CUSTOM_POLICY',
+      },
+    };
+    const message = Policy.parsePolicyRequirement(
+      property,
+      test.policy,
+      test.customMessage as MessageCreator,
+    );
+    expect(message).toBe(test.expectedString);
+  });
+
+  it('error handling is overwritable by customer', () => {
+    const test = {
+      customMessage: {
+        [PolicyKey.Unique]: (property: string): string =>
+          `this is a custom message for "UNIQUE" policy of ${property}`,
+      },
+      expectedString: `this is a custom message for "UNIQUE" policy of ${property}`,
+      policy: {
+        policyRequirement: 'UNIQUE',
+      },
+    };
+    const message = Policy.parsePolicyRequirement(property, test.policy, test.customMessage);
+    expect(message).toBe(test.expectedString);
+  });
+
+  it('groups failed policies for one property', () => {
+    const policy = {
+      policyRequirements: [
+        {
+          policyRequirement: 'UNIQUE',
+        },
+        {
+          params: {
+            minLength: 6,
+          },
+          policyRequirement: 'MIN_LENGTH',
+        },
+      ],
+      property: 'userName',
+    };
+
+    const messageArray = Policy.parseFailedPolicyRequirement(policy);
+    expect(messageArray).toEqual([
+      'userName must be unique',
+      'userName must be at least 6 characters',
+    ]);
+  });
+
+  it('returns an object array with a human readable error and the server error', () => {
+    const errorResponse = {
+      code: 403,
+      reason: 'Forbidden',
+      message: 'Policy validation failed',
+      detail: {
+        failedPolicyRequirements: [
+          {
+            policyRequirements: [
+              {
+                policyRequirement: 'UNIQUE',
+              },
+              {
+                params: {
+                  minLength: 6,
+                },
+                policyRequirement: 'MIN_LENGTH',
+              },
+              {
+                policyRequirement: 'CUSTOM_POLICY',
+              },
+            ],
+            property: 'userName',
+          },
+          {
+            policyRequirements: [
+              {
+                params: {
+                  numCaps: 1,
+                },
+                policyRequirement: 'AT_LEAST_X_CAPITAL_LETTERS',
+              },
+              {
+                params: {
+                  minLength: 6,
+                },
+                policyRequirement: 'MIN_LENGTH',
+              },
+            ],
+            property: 'password',
+          },
+        ],
+        result: false,
+      },
+    };
+    const customMessage: MessageCreator = {
+      [PolicyKey.Unique]: (property: string): string =>
+        `this is a custom message for "UNIQUE" policy of ${property}`,
+      CUSTOM_POLICY: (property: string, params?: { [key: string]: unknown }): string =>
+        `this is a custom message for "${params?.policyRequirement}" policy of ${property}`,
+    };
+    const expected = [
+      {
+        messages: [
+          'this is a custom message for "UNIQUE" policy of userName',
+          'userName must be at least 6 characters',
+          'this is a custom message for "CUSTOM_POLICY" policy of userName',
+        ],
+        detail: {
+          policyRequirements: [
+            { policyRequirement: 'UNIQUE' },
+            { params: { minLength: 6 }, policyRequirement: 'MIN_LENGTH' },
+            { policyRequirement: 'CUSTOM_POLICY' },
+          ],
+          property: 'userName',
+        },
+      },
+      {
+        messages: [
+          'password must contain at least 1 capital letter',
+          'password must be at least 6 characters',
+        ],
+        detail: {
+          policyRequirements: [
+            {
+              params: { numCaps: 1 },
+              policyRequirement: 'AT_LEAST_X_CAPITAL_LETTERS',
+            },
+            { params: { minLength: 6 }, policyRequirement: 'MIN_LENGTH' },
+          ],
+          property: 'password',
+        },
+      },
+    ];
+
+    const errorObjArr = Policy.parseErrors(errorResponse, customMessage);
+    expect(errorObjArr).toEqual(expected);
+  });
+});

package/src/lib/policy/policy.ts

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2020 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { PolicyKey } from '@forgerock/sdk-types';
+
+import type { FailedPolicyRequirement, PolicyRequirement, Step } from '@forgerock/sdk-types';
+
+import { defaultMessageCreator } from './message-creator.js';
+
+import type { MessageCreator, ProcessedPropertyError } from './interfaces.js';
+
+/**
+ * Utility for processing policy failures into human readable messages.
+ *
+ * Example:
+ *
+ * ```js
+ * // Create message overrides and extensions as needed
+ * const messageCreator = {
+ *   [PolicyKey.unique]: (property: string) => (
+ *     `this is a custom message for "UNIQUE" policy of ${property}`
+ *   ),
+ *   CUSTOM_POLICY: (property: string, params: any) => (
+ *     `this is a custom message for "${params.policyRequirement}" policy of ${property}`
+ *   ),
+ * };
+ *
+ * const thisStep = await journeyClient.next(previousStep);
+ *
+ * if (thisStep.type === StepType.LoginFailure) {
+ *   const messagesStepMethod = thisStep.getProcessedMessage(messageCreator);
+ *   const messagesClassMethod = Policy.parseErrors(thisStep, messageCreator)
+ * }
+ */
+export abstract class Policy {
+  /**
+   * Parses policy errors and generates human readable error messages.
+   *
+   * @param {Step} err The step containing the error.
+   * @param {MessageCreator} messageCreator
+   * Extensible and overridable custom error messages for policy failures.
+   * @return {ProcessedPropertyError[]} Array of objects containing all processed policy errors.
+   */
+  public static parseErrors(
+    err: Partial<Step>,
+    messageCreator?: MessageCreator,
+  ): ProcessedPropertyError[] {
+    const errors: ProcessedPropertyError[] = [];
+    if (err.detail && err.detail.failedPolicyRequirements) {
+      err.detail.failedPolicyRequirements.map((x: FailedPolicyRequirement) => {
+        errors.push.apply(errors, [
+          {
+            detail: x,
+            messages: this.parseFailedPolicyRequirement(x, messageCreator),
+          },
+        ]);
+      });
+    }
+    return errors;
+  }
+
+  /**
+   * Parses a failed policy and returns a string array of error messages.
+   *
+   * @param {FailedPolicyRequirement} failedPolicy The detail data of the failed policy.
+   * @param {MessageCreator} customMessage
+   * Extensible and overridable custom error messages for policy failures.
+   * @return {string[]} Array of strings with all processed policy errors.
+   */
+  public static parseFailedPolicyRequirement(
+    failedPolicy: FailedPolicyRequirement,
+    messageCreator?: MessageCreator,
+  ): string[] {
+    const errors: string[] = [];
+    failedPolicy.policyRequirements.map((policyRequirement: PolicyRequirement) => {
+      errors.push(
+        this.parsePolicyRequirement(failedPolicy.property, policyRequirement, messageCreator),
+      );
+    });
+    return errors;
+  }
+
+  /**
+   * Parses a policy error into a human readable error message.
+   *
+   * @param {string} property The property with the policy failure.
+   * @param {PolicyRequirement} policy The policy failure data.
+   * @param {MessageCreator} customMessage
+   * Extensible and overridable custom error messages for policy failures.
+   * @return {string} Human readable error message.
+   */
+  public static parsePolicyRequirement(
+    property: string,
+    policy: PolicyRequirement,
+    messageCreator: MessageCreator = {},
+  ): string {
+    // AM is returning policy requirement failures as JSON strings
+    let policyObject: { policyRequirement: string; params?: Record<string, unknown> };
+    if (typeof policy === 'string') {
+      try {
+        const parsed = JSON.parse(policy);
+        policyObject =
+          typeof parsed === 'string'
+            ? { policyRequirement: parsed }
+            : (parsed as { policyRequirement: string; params?: Record<string, unknown> });
+      } catch {
+        policyObject = { policyRequirement: policy };
+      }
+    } else {
+      policyObject = { ...policy };
+    }
+
+    const policyRequirement = policyObject.policyRequirement;
+
+    // Determine which message creator function to use
+    const effectiveMessageCreator =
+      messageCreator[policyRequirement] ||
+      defaultMessageCreator[policyRequirement] ||
+      defaultMessageCreator[PolicyKey.UnknownPolicy];
+
+    // Flatten the parameters and create the message
+    const params = policyObject.params
+      ? { ...policyObject.params, policyRequirement }
+      : { policyRequirement };
+    const message = effectiveMessageCreator(property, params);
+
+    return message;
+  }
+}
+
+export type { MessageCreator, ProcessedPropertyError };

package/src/lib/qr-code/qr-code.mock.data.ts

@@ -0,0 +1,184 @@
+/*
+ * @forgerock/ping-javascript-sdk
+ *
+ * fr-qr-code.mock.data.ts
+ *
+ * Copyright (c) 2024 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { callbackType } from '@forgerock/sdk-types';
+
+export const otpQRCodeStep = {
+  authId: 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9',
+  callbacks: [
+    {
+      type: callbackType.TextOutputCallback,
+      output: [
+        {
+          name: 'message',
+          value:
+            'Scan the QR code image below with the ForgeRock Authenticator app to register your ' +
+            'device with your login.',
+        },
+        {
+          name: 'messageType',
+          value: '0',
+        },
+      ],
+    },
+    {
+      type: callbackType.TextOutputCallback,
+      output: [
+        {
+          name: 'message',
+          value:
+            `window.QRCodeReader.createCode({\n    id: 'callback_0',\n    text: 'otpauth\\x3A\\x` +
+            `2F\\x2Ftotp\\x2FForgeRock\\x3Ajlowery\\x3Fperiod\\x3D30\\x26b\\x3D032b75\\x26` +
+            `digits\\x3D6\\x26secret\\QITSTC234FRIU8DD987DW3VPICFY\\x3D\\x3D\\x3D\\x3D\\x3` +
+            `D\\x',\n  3D\\x26issuer\\x3DForgeRock  version: '20',\n    code: 'L'\n});`,
+        },
+        {
+          name: 'messageType',
+          value: '4',
+        },
+      ],
+    },
+    {
+      type: callbackType.HiddenValueCallback,
+      output: [
+        {
+          name: 'value',
+          value:
+            'otpauth://totp/ForgeRock:jlowery?secret=QITSTC234FRIU8DD987DW3VPICFY======&issue' +
+            'r=ForgeRock&period=30&digits=6&b=032b75',
+        },
+        {
+          name: 'id',
+          value: 'mfaDeviceRegistration',
+        },
+      ],
+      input: [
+        {
+          name: 'IDToken3',
+          value: 'mfaDeviceRegistration',
+        },
+      ],
+    },
+    {
+      type: callbackType.ConfirmationCallback,
+      output: [
+        {
+          name: 'prompt',
+          value: '',
+        },
+        {
+          name: 'messageType',
+          value: 0,
+        },
+        {
+          name: 'options',
+          value: ['Next'],
+        },
+        {
+          name: 'optionType',
+          value: -1,
+        },
+        {
+          name: 'defaultOption',
+          value: 0,
+        },
+      ],
+      input: [
+        {
+          name: 'IDToken4',
+          value: 0,
+        },
+      ],
+    },
+  ],
+};
+
+export const pushQRCodeStep = {
+  authId: 'eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9',
+  callbacks: [
+    {
+      type: callbackType.TextOutputCallback,
+      output: [
+        {
+          name: 'message',
+          value:
+            'Scan the QR code image below with the ForgeRock Authenticator app to register ' +
+            'your device with your login.',
+        },
+        {
+          name: 'messageType',
+          value: '0',
+        },
+      ],
+    },
+    {
+      type: callbackType.TextOutputCallback,
+      output: [
+        {
+          name: 'message',
+          value:
+            `window.QRCodeReader.createCode({\n    id: 'callback_0',\n    text: 'pushauth\\x` +
+            `3A\\x2F\\x2Fpush\\x2Fforgerock\\x3AJustin\\x2520Lowery\\x3Fa\\x3DaHR0cHM6Ly9vc` +
+            `GVuYW0tZm9yZ2Vycm9jay1zZGtzLmZvcmdlYmxvY2tzLmNvbTo0NDMvYW0vanNvbi9hbHBoYS9wdXN` +
+            `oL3Nucy9tZXNzYWdlP19hY3Rpb249YXV0aGVudGljYXRl\\x26r\\x3DaHR0cHM6Ly9vcGVuYW0tZm` +
+            `9yZ2Vycm9jay1zZGtzLmZvcmdlYmxvY2tzLmNvbTo0NDMvYW0vanNvbi9hbHBoYS9wdXNoL3Nucy9t` +
+            `ZXNzYWdlP19hY3Rpb249cmVnaXN0ZXI\\x26b\\x3D032b75\\x26s\\x3DFoxEr5uAzrys1yBmuyg` +
+            `PbxrVjysElmzsmqifi6eO_AI\\x26c\\x3DXD\\x2DMxsK2sRGa7sUw7kinSKoUDf_eNYMZUV2f0z5` +
+            `kjgw\\x26l\\x3DYW1sYmNvb2tpZT0wMQ\\x26m\\x3DREGISTER\\x3A53b85112\\x2D8ba9\\x2` +
+            `D4b7e\\x2D9107\\x2Decbca2d65f7b1695151603616\\x26issuer\\x3DRm9yZ2VSb2Nr',\n  ` +
+            `  version: '20',\n    code: 'L'\n});`,
+        },
+        {
+          name: 'messageType',
+          value: '4',
+        },
+      ],
+    },
+    {
+      type: callbackType.HiddenValueCallback,
+      output: [
+        {
+          name: 'value',
+          value:
+            'pushauth://push/forgerock:Justin%20Lowery?l=YW1sYmNvb2tpZT0wMQ&issuer=Rm9yZ2VSb' +
+            '2Nr&m=REGISTER:53b85112-8ba9-4b7e-9107-ecbca2d65f7b1695151603616&s=FoxEr5uAzrys' +
+            '1yBmuygPbxrVjysElmzsmqifi6eO_AI&c=XD-MxsK2sRGa7sUw7kinSKoUDf_eNYMZUV2f0z5kjgw&r' +
+            '=aHR0cHM6Ly9vcGVuYW0tZm9yZ2Vycm9jay1zZGtzLmZvcmdlYmxvY2tzLmNvbTo0NDMvYW0vanNvbi' +
+            '9hbHBoYS9wdXNoL3Nucy9tZXNzYWdlP19hY3Rpb249cmVnaXN0ZXI&a=aHR0cHM6Ly9vcGVuYW0tZm9' +
+            'yZ2Vycm9jay1zZGtzLmZvcmdlYmxvY2tzLmNvbTo0NDMvYW0vanNvbi9hbHBoYS9wdXNoL3Nucy9tZ' +
+            'XNzYWdlP19hY3Rpb249YXV0aGVudGljYXRl&b=032b75',
+        },
+        {
+          name: 'id',
+          value: 'mfaDeviceRegistration',
+        },
+      ],
+      input: [
+        {
+          name: 'IDToken3',
+          value: 'mfaDeviceRegistration',
+        },
+      ],
+    },
+    {
+      type: callbackType.PollingWaitCallback,
+      output: [
+        {
+          name: 'waitTime',
+          value: '5000',
+        },
+        {
+          name: 'message',
+          value: 'Waiting for response...',
+        },
+      ],
+    },
+  ],
+};

package/src/lib/qr-code/qr-code.test.ts

@@ -0,0 +1,78 @@
+/*
+ * @forgerock/ping-javascript-sdk
+ *
+ * index.test.ts
+ *
+ * Copyright (c) 2024 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { QRCode } from './qr-code.js';
+import { otpQRCodeStep, pushQRCodeStep } from './qr-code.mock.data.js';
+import { createJourneyStep } from '../step.utils.js';
+// import WebAuthn step as it's similar in structure for testing non-QR Code steps
+import { webAuthnRegJSCallback70 } from '../webauthn/webauthn.mock.data.js';
+
+describe('Class for managing QR Codes', () => {
+  it('should return true for step containing OTP QR Code callbacks', () => {
+    const expected = true;
+    const step = createJourneyStep(otpQRCodeStep);
+    const result = QRCode.isQRCodeStep(step);
+
+    expect(result).toBe(expected);
+  });
+
+  it('should return true for step containing Push QR Code callbacks', () => {
+    const expected = true;
+    const step = createJourneyStep(pushQRCodeStep);
+    const result = QRCode.isQRCodeStep(step);
+
+    expect(result).toBe(expected);
+  });
+
+  it('should return false for step containing WebAuthn step', () => {
+    const expected = false;
+    const step = createJourneyStep(webAuthnRegJSCallback70);
+    const result = QRCode.isQRCodeStep(step);
+
+    expect(result).toBe(expected);
+  });
+
+  it('should return an object with OTP QR Code data', () => {
+    const expected = {
+      message:
+        'Scan the QR code image below with the ForgeRock Authenticator app to register your ' +
+        'device with your login.',
+      use: 'otp',
+      uri:
+        'otpauth://totp/ForgeRock:jlowery?secret=QITSTC234FRIU8DD987DW3VPICFY======&issue' +
+        'r=ForgeRock&period=30&digits=6&b=032b75',
+    };
+    const step = createJourneyStep(otpQRCodeStep);
+    const result = QRCode.getQRCodeData(step);
+
+    expect(result).toStrictEqual(expected);
+  });
+
+  it('should return an object with Push QR Code data', () => {
+    const expected = {
+      message:
+        'Scan the QR code image below with the ForgeRock Authenticator app to register ' +
+        'your device with your login.',
+      use: 'push',
+      uri:
+        'pushauth://push/forgerock:Justin%20Lowery?l=YW1sYmNvb2tpZT0wMQ&issuer=Rm9yZ2VSb' +
+        '2Nr&m=REGISTER:53b85112-8ba9-4b7e-9107-ecbca2d65f7b1695151603616&s=FoxEr5uAzrys' +
+        '1yBmuygPbxrVjysElmzsmqifi6eO_AI&c=XD-MxsK2sRGa7sUw7kinSKoUDf_eNYMZUV2f0z5kjgw&r' +
+        '=aHR0cHM6Ly9vcGVuYW0tZm9yZ2Vycm9jay1zZGtzLmZvcmdlYmxvY2tzLmNvbTo0NDMvYW0vanNvbi' +
+        '9hbHBoYS9wdXNoL3Nucy9tZXNzYWdlP19hY3Rpb249cmVnaXN0ZXI&a=aHR0cHM6Ly9vcGVuYW0tZm9' +
+        'yZ2Vycm9jay1zZGtzLmZvcmdlYmxvY2tzLmNvbTo0NDMvYW0vanNvbi9hbHBoYS9wdXNoL3Nucy9tZ' +
+        'XNzYWdlP19hY3Rpb249YXV0aGVudGljYXRl&b=032b75',
+    };
+    const step = createJourneyStep(pushQRCodeStep);
+    const result = QRCode.getQRCodeData(step);
+
+    expect(result).toStrictEqual(expected);
+  });
+});

package/src/lib/qr-code/qr-code.ts

@@ -0,0 +1,96 @@
+/*
+ * @forgerock/ping-javascript-sdk
+ *
+ * index.ts
+ *
+ * Copyright (c) 2024 - 2025 Ping Identity Corporation. All rights reserved.
+ * This software may be modified and distributed under the terms
+ * of the MIT license. See the LICENSE file for details.
+ */
+
+import { callbackType } from '@forgerock/sdk-types';
+
+import { TextOutputCallback } from '../callbacks/text-output-callback.js';
+import { HiddenValueCallback } from '../callbacks/hidden-value-callback.js';
+
+import type { JourneyStep } from '../step.utils.js';
+
+export type QRCodeData = {
+  message: string;
+  use: string;
+  uri: string;
+};
+
+/**
+ * @class QRCode - A utility class for handling QR Code steps
+ *
+ * Example:
+ *
+ * ```js
+ * const isQRCodeStep = QRCode.isQRCodeStep(step);
+ * let qrCodeData;
+ * if (isQRCodeStep) {
+ *   qrCodeData = QRCode.getQRCodeData(step);
+ * }
+ * ```
+ */
+export abstract class QRCode {
+  /**
+   * @method isQRCodeStep - determines if step contains QR Code callbacks
+   * @param {JourneyStep} step - step object from AM response
+   * @returns {boolean}
+   */
+  public static isQRCodeStep(step: JourneyStep): boolean {
+    const hiddenValueCb = step.getCallbacksOfType(callbackType.HiddenValueCallback);
+
+    // QR Codes step should have at least one HiddenValueCallback
+    if (hiddenValueCb.length === 0) {
+      return false;
+    }
+    return !!this.getQRCodeURICb(hiddenValueCb);
+  }
+
+  /**
+   * @method getQRCodeData - gets the necessary information from the QR Code callbacks
+   * @param {JourneyStep} step - step object from AM response
+   * @returns {QRCodeData}
+   */
+  public static getQRCodeData(step: JourneyStep): QRCodeData {
+    const hiddenValueCb = step.getCallbacksOfType(callbackType.HiddenValueCallback);
+
+    // QR Codes step should have at least one HiddenValueCallback
+    if (hiddenValueCb.length === 0) {
+      throw new Error(
+        'QR Code step must contain a HiddenValueCallback. Use `QRCode.isQRCodeStep` to guard.',
+      );
+    }
+    const qrCodeURICb = this.getQRCodeURICb(hiddenValueCb) as HiddenValueCallback;
+    const outputValue = qrCodeURICb ? qrCodeURICb.getOutputValue('value') : '';
+    const qrCodeUse =
+      typeof outputValue === 'string' && outputValue.includes('otpauth://') ? 'otp' : 'push';
+
+    const messageCbs = step.getCallbacksOfType(callbackType.TextOutputCallback);
+    const displayMessageCb = messageCbs.find((cb) => {
+      const textOutputCallback = cb as TextOutputCallback;
+      return textOutputCallback.getMessageType() !== '4';
+    }) as TextOutputCallback | null;
+
+    return {
+      message: displayMessageCb ? displayMessageCb.getMessage() : '',
+      use: qrCodeUse,
+      uri: typeof outputValue === 'string' ? outputValue : '',
+    };
+  }
+
+  private static getQRCodeURICb(hiddenValueCbs: HiddenValueCallback[]) {
+    // Look for a HiddenValueCallback with an OTP URI
+    return hiddenValueCbs.find((cb) => {
+      const outputValue = cb.getOutputValue('value');
+
+      if (typeof outputValue === 'string') {
+        return outputValue?.includes('otpauth://') || outputValue?.includes('pushauth://');
+      }
+      return false;
+    });
+  }
+}