@incodetech/core 2.0.1 → 2.1.0-rc.0

package/dist/phone.esm.js

@@ -1,9 +1,10 @@
 import "./BrowserTimerProvider-DhNc_x02.esm.js";
 import "./api-CESGtpbH.esm.js";
-import "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import "./xstate.esm-B70JrNqo.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-CuPARRaT.esm.js";
-import { t as createPhoneManager } from "./phoneManager-DAJbGhlY.esm.js";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./xstate.esm-C9wncMQa.esm.js";
+import "./otp-CGMdUzBC.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-BiV0yoEx.esm.js";
+import { t as createPhoneManager } from "./phoneManager-BmF-0Ez4.esm.js";
 
 export { createPhoneManager, phoneMachine };

package/dist/{phoneManager-DAJbGhlY.esm.js → phoneManager-BmF-0Ez4.esm.js}

@@ -1,6 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-CuPARRaT.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-Dvvriq9l.esm.js";
+import { c as createManager, s as createActor } from "./xstate.esm-C9wncMQa.esm.js";
+import { t as OTP_CODE_LENGTH } from "./otp-CGMdUzBC.esm.js";
+import { t as phoneMachine } from "./phoneStateMachine-BiV0yoEx.esm.js";
 
 //#region src/modules/phone/phoneActor.ts
 function createPhoneActor(options) {
@@ -114,29 +115,45 @@ function mapState(snapshot) {
 		phonePrefix: context.phonePrefix,
 		prefilledPhone: context.prefilledPhone,
 		phoneError: context.phoneError,
+		validationErrors: context.validationErrors,
+		isValid: Object.keys(context.validationErrors ?? {}).length === 0,
 		otpVerification: context.config.otpVerification,
 		optinEnabled: context.config.optinEnabled ?? false
 	};
 	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
-	if (typedSnapshot.matches("resendingOtp")) return { status: "resendingOtp" };
+	if (typedSnapshot.matches("resendingOtp")) return {
+		status: "resendingOtp",
+		otpCode: context.otpCode,
+		otpLength: OTP_CODE_LENGTH
+	};
 	if (typedSnapshot.matches("sendingInitialOtp")) return { status: "sendingInitialOtp" };
 	if (typedSnapshot.matches("awaitingOtp")) return {
 		status: "awaitingOtp",
 		resendTimer: context.resendTimer,
 		canResend: !context.resendTimerActive,
-		attemptsRemaining: context.attemptsRemaining
+		attemptsRemaining: context.attemptsRemaining,
+		otpCode: context.otpCode,
+		otpLength: OTP_CODE_LENGTH,
+		otpValidationErrors: context.otpValidationErrors,
+		isOtpValid: Object.keys(context.otpValidationErrors ?? {}).length === 0
 	};
 	if (typedSnapshot.matches("verifyingOtp")) return {
 		status: "verifyingOtp",
 		resendTimer: context.resendTimer,
-		canResend: !context.resendTimerActive
+		canResend: !context.resendTimerActive,
+		otpCode: context.otpCode,
+		otpLength: OTP_CODE_LENGTH
 	};
 	if (typedSnapshot.matches("otpError")) return {
 		status: "otpError",
 		otpError: context.otpError ?? "otp.errorv2",
 		attemptsRemaining: context.attemptsRemaining,
 		resendTimer: context.resendTimer,
-		canResend: !context.resendTimerActive
+		canResend: !context.resendTimerActive,
+		otpCode: context.otpCode,
+		otpLength: OTP_CODE_LENGTH,
+		otpValidationErrors: context.otpValidationErrors,
+		isOtpValid: Object.keys(context.otpValidationErrors ?? {}).length === 0
 	};
 	if (typedSnapshot.matches("finished")) return { status: "finished" };
 	if (typedSnapshot.matches("error")) return {
@@ -157,6 +174,9 @@ function createApi({ actor, trackElementClicked }) {
 				isValid
 			});
 		},
+		validatePhone() {
+			actor.send({ type: "VALIDATE_PHONE" });
+		},
 		setOptInGranted(granted) {
 			actor.send({
 				type: "OPT_IN_CHANGED",
@@ -173,6 +193,9 @@ function createApi({ actor, trackElementClicked }) {
 				code
 			});
 		},
+		validateOtp() {
+			actor.send({ type: "VALIDATE_OTP" });
+		},
 		submitOtp(code) {
 			trackElementClicked?.("submitOtp");
 			actor.send({

package/dist/{phoneManager-B6M30hKE.d.ts → phoneManager-fPmIBYQK.d.ts}

@@ -1,5 +1,6 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import { t as ActorRefFrom } from "./Actor-CI32dTbG.js";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+import { t as OtpValidationErrors } from "./otp-DF5A0sFx.js";
 
 //#region src/modules/phone/types.d.ts
 
@@ -62,6 +63,10 @@ type PhoneConfig = {
    */
   maxOtpAttempts?: number;
 };
+/** Client-side validation errors for the phone input screen, keyed by field. */
+type PhoneValidationErrors = {
+  phone?: string;
+};
 //#endregion
 //#region src/modules/phone/phoneStateMachine.d.ts
 
@@ -107,6 +112,10 @@ type PhoneInputtingState = {
   phonePrefix: string;
   prefilledPhone?: string;
   phoneError?: string;
+  /** Client-side validation errors (e.g. invalid/empty phone). Surfaced on blur and submit. */
+  validationErrors?: PhoneValidationErrors;
+  /** True iff `validationErrors` is empty. Optimistic semantic: starts true on initial render. */
+  isValid: boolean;
   otpVerification?: boolean;
   optinEnabled?: boolean;
 };
@@ -117,6 +126,10 @@ type PhoneSubmittingState = {
 /** OTP is being sent to the phone number on resend */
 type PhoneResendingOtpState = {
   status: 'resendingOtp';
+  /** The OTP code entered so far (controlled-input value, kept visible while disabled) */
+  otpCode: string;
+  /** Expected OTP length (owned by Core) */
+  otpLength: number;
 };
 /** OTP is being initialy sent to the phone number */
 type PhoneSendingInitialOtp = {
@@ -127,22 +140,34 @@ type PhoneSendingInitialOtp = {
  * @property resendTimer - Seconds remaining before resend is allowed
  * @property canResend - Whether the resend button should be enabled
  * @property attemptsRemaining - Number of OTP verification attempts left
+ * @property otpCode - The OTP code entered so far (controlled-input value)
+ * @property otpLength - Expected OTP length (owned by Core; the UI should not hardcode it)
+ * @property otpValidationErrors - Client-side OTP errors (e.g. incomplete code). Surfaced on blur and submit.
+ * @property isOtpValid - True iff `otpValidationErrors` is empty. Optimistic semantic: starts true.
  */
 type PhoneAwaitingOtpState = {
   status: 'awaitingOtp';
   resendTimer: number;
   canResend: boolean;
   attemptsRemaining: number;
+  otpCode: string;
+  otpLength: number;
+  otpValidationErrors?: OtpValidationErrors;
+  isOtpValid: boolean;
 };
 /**
  * OTP code is being verified against the backend
  * @property resendTimer - Seconds remaining on resend cooldown (unchanged while verifying)
  * @property canResend - Whether resend is allowed (cooldown finished)
+ * @property otpCode - The code being verified (controlled-input value, kept visible while disabled)
+ * @property otpLength - Expected OTP length (owned by Core)
  */
 type PhoneVerifyingOtpState = {
   status: 'verifyingOtp';
   resendTimer: number;
   canResend: boolean;
+  otpCode: string;
+  otpLength: number;
 };
 /**
  * OTP verification failed - user can retry with `submitOtp()`
@@ -150,6 +175,10 @@ type PhoneVerifyingOtpState = {
  * @property attemptsRemaining - Number of remaining attempts before lockout
  * @property resendTimer - Seconds remaining on resend cooldown (same as awaiting OTP)
  * @property canResend - Whether resend is allowed (cooldown finished)
+ * @property otpCode - The OTP code entered so far (controlled-input value)
+ * @property otpLength - Expected OTP length (owned by Core)
+ * @property otpValidationErrors - Client-side OTP errors (e.g. incomplete code). Server `otpError` takes precedence in the UI.
+ * @property isOtpValid - True iff `otpValidationErrors` is empty. Optimistic semantic: starts true.
  */
 type PhoneOtpErrorState = {
   status: 'otpError';
@@ -157,6 +186,10 @@ type PhoneOtpErrorState = {
   attemptsRemaining: number;
   resendTimer: number;
   canResend: boolean;
+  otpCode: string;
+  otpLength: number;
+  otpValidationErrors?: OtpValidationErrors;
+  isOtpValid: boolean;
 };
 /** Phone verification completed successfully */
 type PhoneFinishedState = {
@@ -248,6 +281,11 @@ declare function createPhoneManager(options: CreatePhoneActorOptions): Manager<P
    * ```
    */
   setPhoneNumber(phone: string, isValid: boolean): void;
+  /**
+   * Validates the current phone number (e.g., on blur).
+   * Populates or clears `validationErrors.phone` on the 'inputting' state.
+   */
+  validatePhone(): void;
   /**
    * Sets the marketing opt-in preference.
    * Only relevant if `config.optinEnabled` is true.
@@ -257,8 +295,9 @@ declare function createPhoneManager(options: CreatePhoneActorOptions): Manager<P
   setOptInGranted(granted: boolean): void;
   /**
    * Submits the phone number for verification.
-   * Requires a valid phone number to be set via `setPhoneNumber()`.
-   * Transitions to 'submitting', then to 'sendingOtp' or 'success' (if no OTP).
+   * Runs full validation first: if the phone is empty or invalid, populates
+   * `validationErrors` and stays on 'inputting'; otherwise transitions to
+   * 'submitting', then to 'sendingInitialOtp' or 'finished' (if no OTP).
    */
   submit(): void;
   /**
@@ -268,6 +307,12 @@ declare function createPhoneManager(options: CreatePhoneActorOptions): Manager<P
    * @param code - The OTP code entered by the user
    */
   setOtpCode(code: string): void;
+  /**
+   * Validates the current OTP code (e.g. on blur), without submitting.
+   * Populates or clears `otpValidationErrors.otp` on the 'awaitingOtp' /
+   * 'otpError' states (incomplete code → `isOtpValid` becomes false).
+   */
+  validateOtp(): void;
   /**
    * Sets and submits the OTP code in one call.
    * Should be called when state is 'awaitingOtp' or 'otpError'.
@@ -323,6 +368,11 @@ declare function createPhoneManagerFromActor(actor: PhoneActor): Manager<PhoneSt
    * ```
    */
   setPhoneNumber(phone: string, isValid: boolean): void;
+  /**
+   * Validates the current phone number (e.g., on blur).
+   * Populates or clears `validationErrors.phone` on the 'inputting' state.
+   */
+  validatePhone(): void;
   /**
    * Sets the marketing opt-in preference.
    * Only relevant if `config.optinEnabled` is true.
@@ -332,8 +382,9 @@ declare function createPhoneManagerFromActor(actor: PhoneActor): Manager<PhoneSt
   setOptInGranted(granted: boolean): void;
   /**
    * Submits the phone number for verification.
-   * Requires a valid phone number to be set via `setPhoneNumber()`.
-   * Transitions to 'submitting', then to 'sendingOtp' or 'success' (if no OTP).
+   * Runs full validation first: if the phone is empty or invalid, populates
+   * `validationErrors` and stays on 'inputting'; otherwise transitions to
+   * 'submitting', then to 'sendingInitialOtp' or 'finished' (if no OTP).
    */
   submit(): void;
   /**
@@ -343,6 +394,12 @@ declare function createPhoneManagerFromActor(actor: PhoneActor): Manager<PhoneSt
    * @param code - The OTP code entered by the user
    */
   setOtpCode(code: string): void;
+  /**
+   * Validates the current OTP code (e.g. on blur), without submitting.
+   * Populates or clears `otpValidationErrors.otp` on the 'awaitingOtp' /
+   * 'otpError' states (incomplete code → `isOtpValid` becomes false).
+   */
+  validateOtp(): void;
   /**
    * Sets and submits the OTP code in one call.
    * Should be called when state is 'awaitingOtp' or 'otpError'.
@@ -387,6 +444,7 @@ declare function createPhoneManagerFromActor(actor: PhoneActor): Manager<PhoneSt
  * @property setOptInGranted - Sets marketing opt-in preference
  * @property submit - Submits the phone number
  * @property setOtpCode - Sets OTP code without submitting
+ * @property validateOtp - Validates the current OTP (e.g. on blur)
  * @property submitOtp - Sets and submits OTP code
  * @property resendOtp - Requests new OTP code
  * @property back - Returns to phone input from OTP screen
@@ -394,4 +452,4 @@ declare function createPhoneManagerFromActor(actor: PhoneActor): Manager<PhoneSt
  */
 type PhoneManager = ReturnType<typeof createPhoneManager>;
 //#endregion
-export { phoneMachine as a, createPhoneManagerFromActor as i, PhoneState as n, PhoneConfig as o, createPhoneManager as r, PhoneManager as t };
+export { PhoneActor as a, createPhoneManagerFromActor as i, PhoneState as n, phoneMachine as o, createPhoneManager as r, PhoneConfig as s, PhoneManager as t };

package/dist/{phoneStateMachine-CuPARRaT.esm.js → phoneStateMachine-BiV0yoEx.esm.js}

@@ -1,7 +1,8 @@
 import { t as BrowserTimerProvider } from "./BrowserTimerProvider-DhNc_x02.esm.js";
 import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as endpoints } from "./endpoints-BeTK0Mlt.esm.js";
+import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
+import { n as computeOtpValidationErrors, r as isOtpComplete } from "./otp-CGMdUzBC.esm.js";
 
 //#region src/modules/phone/phoneServices.ts
 function getPhoneServerFailureReason(error, invalidStatus) {
@@ -60,6 +61,10 @@ function getErrorMessage(error) {
 	if (error instanceof Error) return error.message;
 	return String(error);
 }
+function computePhoneValidationErrors(context) {
+	if (context.phone.trim().length === 0 || !context.isValid) return { phone: "invalidPhone" };
+	return {};
+}
 const phoneMachine = setup({
 	types: {
 		context: {},
@@ -122,9 +127,18 @@ const phoneMachine = setup({
 			return {
 				phone: e.phone,
 				isValid: e.isValid,
-				phoneError: void 0
+				phoneError: void 0,
+				validationErrors: void 0
 			};
 		}),
+		validatePhoneField: assign(({ context }) => {
+			const errors = computePhoneValidationErrors(context);
+			return { validationErrors: errors.phone ? errors : void 0 };
+		}),
+		computeValidationResult: assign(({ context }) => {
+			const errors = computePhoneValidationErrors(context);
+			return { validationErrors: errors.phone ? errors : void 0 };
+		}),
 		setPhoneError: assign(({ event }) => ({ phoneError: getErrorMessage(event.error) })),
 		setOptInGranted: assign(({ event }) => ({ optInGranted: event.granted })),
 		setError: assign(({ event }) => ({ error: getErrorMessage(event.error) })),
@@ -132,8 +146,13 @@ const phoneMachine = setup({
 		clearPhoneError: assign({ phoneError: () => void 0 }),
 		setOtpCode: assign(({ event }) => ({
 			otpCode: event.code,
-			otpError: void 0
+			otpError: void 0,
+			otpValidationErrors: void 0
 		})),
+		validateOtpField: assign(({ context }) => {
+			const errors = computeOtpValidationErrors(context.otpCode);
+			return { otpValidationErrors: errors.otp ? errors : void 0 };
+		}),
 		setOtpError: assign(({ context, event }) => ({
 			otpError: getErrorMessage(event.error),
 			attemptsRemaining: context.attemptsRemaining - 1
@@ -141,7 +160,8 @@ const phoneMachine = setup({
 		setOtpRequestError: assign(({ event }) => ({ otpError: getErrorMessage(event.error) })),
 		clearOtpError: assign({
 			otpError: () => void 0,
-			otpCode: () => ""
+			otpCode: () => "",
+			otpValidationErrors: () => void 0
 		}),
 		startResendTimer: assign({
 			resendTimer: () => RESEND_TIMER_SECONDS,
@@ -159,6 +179,7 @@ const phoneMachine = setup({
 			phone: "",
 			isValid: false,
 			phoneError: void 0,
+			validationErrors: void 0,
 			countryCode: "",
 			phonePrefix: "",
 			prefilledPhone: void 0,
@@ -167,6 +188,7 @@ const phoneMachine = setup({
 			error: void 0,
 			otpCode: "",
 			otpError: void 0,
+			otpValidationErrors: void 0,
 			attemptsRemaining: context.config.maxOtpAttempts ?? 3,
 			resendTimer: 0,
 			resendTimerActive: false
@@ -175,8 +197,9 @@ const phoneMachine = setup({
 	guards: {
 		hasPrefill: ({ context }) => context.config.prefill,
 		hasOtpVerification: ({ context }) => context.config.otpVerification,
-		isValidPhone: ({ context }) => context.isValid,
+		hasNoValidationErrors: ({ context }) => !context.validationErrors || Object.keys(context.validationErrors).length === 0,
 		hasAttemptsRemaining: ({ context }) => context.attemptsRemaining > 1,
+		hasCompleteOtp: ({ context }) => isOtpComplete(context.otpCode),
 		canResend: ({ context }) => !context.resendTimerActive
 	}
 }).createMachine({
@@ -187,6 +210,7 @@ const phoneMachine = setup({
 		phone: "",
 		isValid: false,
 		phoneError: void 0,
+		validationErrors: void 0,
 		countryCode: "",
 		phonePrefix: "",
 		prefilledPhone: void 0,
@@ -195,6 +219,7 @@ const phoneMachine = setup({
 		error: void 0,
 		otpCode: "",
 		otpError: void 0,
+		otpValidationErrors: void 0,
 		attemptsRemaining: input.config.maxOtpAttempts ?? 3,
 		resendTimer: 0,
 		resendTimerActive: false
@@ -225,12 +250,17 @@ const phoneMachine = setup({
 		inputting: { on: {
 			PHONE_CHANGED: { actions: "setPhone" },
 			OPT_IN_CHANGED: { actions: "setOptInGranted" },
-			SUBMIT: {
+			VALIDATE_PHONE: { actions: "validatePhoneField" },
+			SUBMIT: { target: "validatingSubmit" }
+		} },
+		validatingSubmit: {
+			entry: "computeValidationResult",
+			always: [{
+				guard: "hasNoValidationErrors",
 				target: "submitting",
-				guard: "isValidPhone",
 				actions: "clearPhoneError"
-			}
-		} },
+			}, { target: "inputting" }]
+		},
 		submitting: { invoke: {
 			id: "submitPhone",
 			src: "submitPhone",
@@ -281,7 +311,11 @@ const phoneMachine = setup({
 			on: {
 				TICK: { actions: "tickResendTimer" },
 				OTP_CHANGED: { actions: "setOtpCode" },
-				VERIFY_OTP: { target: "verifyingOtp" },
+				VALIDATE_OTP: { actions: "validateOtpField" },
+				VERIFY_OTP: [{
+					guard: "hasCompleteOtp",
+					target: "verifyingOtp"
+				}, { actions: "validateOtpField" }],
 				RESEND_OTP: {
 					target: "resendingOtp",
 					guard: "canResend"
@@ -332,6 +366,7 @@ const phoneMachine = setup({
 					target: "awaitingOtp",
 					actions: "setOtpCode"
 				},
+				VALIDATE_OTP: { actions: "validateOtpField" },
 				RESEND_OTP: {
 					target: "resendingOtp",
 					guard: "canResend"

package/dist/{qe-signature-DFo_Cc-I.esm.js → qe-signature-CUYPcHVo.esm.js}

@@ -1,4 +1,4 @@
-import { t as createElectronicSignatureManager } from "./electronicSignatureManager-D9OHzTpG.esm.js";
+import { t as createElectronicSignatureManager } from "./electronicSignatureManager-BaECdJ1u.esm.js";
 
 //#region src/modules/qe-signature/index.ts
 function createQeSignatureManager(options) {

package/dist/qe-signature.d.ts

@@ -1,6 +1,6 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.js";
-import { c as ConsentKey, f as QE_CONSENT_KEYS, g as getDefaultConsentChecks, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, s as ConsentChecks, u as ElectronicSignatureDocument } from "./index-ChHWNH48.js";
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
+import { c as ConsentKey, f as QE_CONSENT_KEYS, g as getDefaultConsentChecks, i as electronicSignatureMachine, l as ElectronicSignatureConfig, m as areAllConsented, n as ElectronicSignatureState, s as ConsentChecks, u as ElectronicSignatureDocument } from "./index-B9NysVDB.js";
 
 //#region src/modules/qe-signature/index.d.ts
 

package/dist/qe-signature.esm.js

@@ -1,8 +1,9 @@
 import "./api-CESGtpbH.esm.js";
-import "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import "./xstate.esm-B70JrNqo.esm.js";
-import { a as areAllConsented, i as QE_CONSENT_KEYS, n as electronicSignatureMachine, s as getDefaultConsentChecks } from "./electronicSignatureManager-D9OHzTpG.esm.js";
-import { t as createQeSignatureManager } from "./qe-signature-DFo_Cc-I.esm.js";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./xstate.esm-C9wncMQa.esm.js";
+import "./apiError-B-j-gyDx.esm.js";
+import { a as areAllConsented, i as QE_CONSENT_KEYS, n as electronicSignatureMachine, s as getDefaultConsentChecks } from "./electronicSignatureManager-BaECdJ1u.esm.js";
+import { t as createQeSignatureManager } from "./qe-signature-CUYPcHVo.esm.js";
 
 export { QE_CONSENT_KEYS, areAllConsented, createQeSignatureManager, getDefaultConsentChecks, electronicSignatureMachine as qeSignatureMachine };