@incodetech/core 2.4.1-agentic.5 → 2.4.1-agentic.7

package/dist/ekycPrefillManager-DHfC1T9s.d.ts

@@ -0,0 +1,565 @@
+import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, i as ActorRefFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
+import { t as Manager } from "./Manager-C9T5amUN.js";
+import "./Actor-DpTj5PFb.js";
+import { a as EkycFormValues, c as EkycValidationErrors } from "./types-BaDx6utW.js";
+import { a as EkycPrefillFieldDef, c as EkycPrefillModuleConfig, d as EkycPrefillSubmitResponse, i as EkycPrefillErrorKind, o as EkycPrefillInput, r as EkycPrefillContext, t as EkycPrefillConfig, u as EkycPrefillSubmitPlan } from "./types-D9vIGFbl.js";
+//#region src/modules/ekyc-prefill/ekycPrefillStateMachine.d.ts
+type SubmitInput = {
+  submit: EkycPrefillSubmitPlan;
+  values: EkycFormValues;
+};
+declare const ekycPrefillMachine: StateMachine<EkycPrefillContext, {
+  type: "LOAD";
+} | {
+  type: "SET_FIELD";
+  name: string;
+  value: string;
+  isValid?: boolean;
+} | {
+  type: "VALIDATE_FIELD";
+  name: string;
+} | {
+  type: "SUBMIT";
+} | {
+  type: "RETRY";
+} | {
+  type: "CONTINUE";
+} | {
+  type: "CLOSE";
+}, {
+  [x: string]: ActorRefFromLogic<PromiseActorLogic<EkycPrefillSubmitResponse, SubmitInput, EventObject>> | ActorRefFromLogic<PromiseActorLogic<void, {
+    hasPhone: boolean;
+  }, EventObject>> | undefined;
+}, Values<{
+  submit: {
+    src: "submit";
+    logic: PromiseActorLogic<EkycPrefillSubmitResponse, SubmitInput, EventObject>;
+    id: string | undefined;
+  };
+  loadPhoneRules: {
+    src: "loadPhoneRules";
+    logic: PromiseActorLogic<void, {
+      hasPhone: boolean;
+    }, EventObject>;
+    id: string | undefined;
+  };
+}>, Values<{
+  applyForm: {
+    type: "applyForm";
+    params: NonReducibleUnknown;
+  };
+  setPhoneRulesLoaded: {
+    type: "setPhoneRulesLoaded";
+    params: NonReducibleUnknown;
+  };
+  setPhoneRulesFailed: {
+    type: "setPhoneRulesFailed";
+    params: NonReducibleUnknown;
+  };
+  setFieldValue: {
+    type: "setFieldValue";
+    params: NonReducibleUnknown;
+  };
+  validateOneField: {
+    type: "validateOneField";
+    params: NonReducibleUnknown;
+  };
+  validateAll: {
+    type: "validateAll";
+    params: NonReducibleUnknown;
+  };
+  applyRejection: {
+    type: "applyRejection";
+    params: NonReducibleUnknown;
+  };
+  setSubmitError: {
+    type: "setSubmitError";
+    params: NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: NonReducibleUnknown;
+  };
+}>, Values<{
+  isValid: {
+    type: "isValid";
+    params: unknown;
+  };
+  phoneRulesFailed: {
+    type: "phoneRulesFailed";
+    params: unknown;
+  };
+  isAutoExecution: {
+    type: "isAutoExecution";
+    params: unknown;
+  };
+  canRender: {
+    type: "canRender";
+    params: unknown;
+  };
+  isBadRequest: {
+    type: "isBadRequest";
+    params: unknown;
+  };
+  isForbidden: {
+    type: "isForbidden";
+    params: unknown;
+  };
+  isLimitReached: {
+    type: "isLimitReached";
+    params: unknown;
+  };
+}>, never, "error" | "idle" | "closed" | "finished" | "submitting" | "misconfigured" | "limitReached" | {
+  form: "inputting" | "validating";
+}, string, EkycPrefillInput, NonReducibleUnknown, EventObject, MetaObject, {
+  readonly id: "ekycPrefill";
+  readonly initial: "idle";
+  readonly context: ({ input }: {
+    spawn: {
+      <TSrc extends "submit" | "loadPhoneRules">(logic: TSrc, ...[options]: ({
+        src: "submit";
+        logic: PromiseActorLogic<EkycPrefillSubmitResponse, SubmitInput, EventObject>;
+        id: string | undefined;
+      } extends (infer T) ? T extends {
+        src: "submit";
+        logic: PromiseActorLogic<EkycPrefillSubmitResponse, SubmitInput, EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "loadPhoneRules";
+        logic: PromiseActorLogic<void, {
+          hasPhone: boolean;
+        }, EventObject>;
+        id: string | undefined;
+      } extends (infer T_1) ? T_1 extends {
+        src: "loadPhoneRules";
+        logic: PromiseActorLogic<void, {
+          hasPhone: boolean;
+        }, EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in RequiredActorOptions<T_1>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T_1>>> : never : never : never)): ActorRefFromLogic<GetConcreteByKey<Values<{
+        submit: {
+          src: "submit";
+          logic: PromiseActorLogic<EkycPrefillSubmitResponse, SubmitInput, EventObject>;
+          id: string | undefined;
+        };
+        loadPhoneRules: {
+          src: "loadPhoneRules";
+          logic: PromiseActorLogic<void, {
+            hasPhone: boolean;
+          }, EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
+    };
+    input: EkycPrefillInput;
+    self: ActorRef<MachineSnapshot<EkycPrefillContext, {
+      type: "LOAD";
+    } | {
+      type: "SET_FIELD";
+      name: string;
+      value: string;
+      isValid?: boolean;
+    } | {
+      type: "VALIDATE_FIELD";
+      name: string;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CONTINUE";
+    } | {
+      type: "CLOSE";
+    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "SET_FIELD";
+      name: string;
+      value: string;
+      isValid?: boolean;
+    } | {
+      type: "VALIDATE_FIELD";
+      name: string;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "CONTINUE";
+    } | {
+      type: "CLOSE";
+    }, AnyEventObject>;
+  }) => {
+    config: EkycPrefillConfig;
+    prepared: undefined;
+    values: {};
+    errors: {};
+    invalidFormats: {};
+    anyOfError: false;
+    phoneRulesLoaded: false;
+    phoneRulesFailed: false;
+    submitError: undefined;
+    errorKind: undefined;
+    errorMessage: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: readonly [{
+          readonly guard: "isAutoExecution";
+          readonly target: "finished";
+        }, {
+          readonly guard: "canRender";
+          readonly target: "form";
+          readonly actions: "applyForm";
+        }, {
+          readonly target: "misconfigured";
+        }];
+      };
+    };
+    readonly form: {
+      readonly invoke: {
+        readonly id: "loadPhoneRules";
+        readonly src: "loadPhoneRules";
+        readonly input: ({ context }: {
+          context: EkycPrefillContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "SET_FIELD";
+            name: string;
+            value: string;
+            isValid?: boolean;
+          } | {
+            type: "VALIDATE_FIELD";
+            name: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "CLOSE";
+          };
+          self: ActorRef<MachineSnapshot<EkycPrefillContext, {
+            type: "LOAD";
+          } | {
+            type: "SET_FIELD";
+            name: string;
+            value: string;
+            isValid?: boolean;
+          } | {
+            type: "VALIDATE_FIELD";
+            name: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "CLOSE";
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "SET_FIELD";
+            name: string;
+            value: string;
+            isValid?: boolean;
+          } | {
+            type: "VALIDATE_FIELD";
+            name: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "CLOSE";
+          }, AnyEventObject>;
+        }) => {
+          hasPhone: boolean;
+        };
+        readonly onDone: {
+          readonly actions: "setPhoneRulesLoaded";
+        };
+        readonly onError: {
+          readonly target: "#ekycPrefill.error";
+          readonly actions: "setPhoneRulesFailed";
+        };
+      };
+      readonly initial: "inputting";
+      readonly states: {
+        readonly inputting: {
+          readonly on: {
+            readonly SET_FIELD: {
+              readonly actions: "setFieldValue";
+            };
+            readonly VALIDATE_FIELD: {
+              readonly actions: "validateOneField";
+            };
+            readonly SUBMIT: "validating";
+          };
+        };
+        readonly validating: {
+          readonly entry: "validateAll";
+          readonly always: readonly [{
+            readonly guard: "isValid";
+            readonly target: "#ekycPrefill.submitting";
+          }, {
+            readonly target: "inputting";
+          }];
+        };
+      };
+      readonly on: {
+        readonly CLOSE: "closed";
+      };
+    };
+    readonly submitting: {
+      readonly invoke: {
+        readonly id: "submit";
+        readonly src: "submit";
+        readonly input: ({ context }: {
+          context: EkycPrefillContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "SET_FIELD";
+            name: string;
+            value: string;
+            isValid?: boolean;
+          } | {
+            type: "VALIDATE_FIELD";
+            name: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "CLOSE";
+          };
+          self: ActorRef<MachineSnapshot<EkycPrefillContext, {
+            type: "LOAD";
+          } | {
+            type: "SET_FIELD";
+            name: string;
+            value: string;
+            isValid?: boolean;
+          } | {
+            type: "VALIDATE_FIELD";
+            name: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "CLOSE";
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "SET_FIELD";
+            name: string;
+            value: string;
+            isValid?: boolean;
+          } | {
+            type: "VALIDATE_FIELD";
+            name: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "CONTINUE";
+          } | {
+            type: "CLOSE";
+          }, AnyEventObject>;
+        }) => {
+          submit: EkycPrefillSubmitPlan;
+          values: EkycFormValues;
+        };
+        readonly onDone: {
+          readonly target: "finished";
+        };
+        readonly onError: readonly [{
+          readonly guard: "isLimitReached";
+          readonly target: "limitReached";
+        }, {
+          readonly guard: "isBadRequest";
+          readonly target: "form.inputting";
+          readonly actions: "applyRejection";
+        }, {
+          readonly guard: "isForbidden";
+          readonly target: "misconfigured";
+        }, {
+          readonly target: "error";
+          readonly actions: "setSubmitError";
+        }];
+      };
+    };
+    /**
+     * The lookup could not run (409, 503, a network failure), or the phone
+     * rules did not load: offer a retry of whichever failed.
+     */
+    readonly error: {
+      readonly on: {
+        readonly RETRY: readonly [{
+          readonly guard: "phoneRulesFailed";
+          readonly target: "form";
+          readonly actions: "clearError";
+        }, {
+          readonly target: "submitting";
+          readonly actions: "clearError";
+        }];
+        readonly CLOSE: "closed";
+      };
+    };
+    /** The lookup limit is reached; it does not reset within the session, so the flow moves on. */
+    readonly limitReached: {
+      readonly on: {
+        readonly CONTINUE: "finished";
+        readonly CLOSE: "closed";
+      };
+    };
+    /** The configuration can't be rendered, or the session's flow doesn't allow the lookup. */
+    readonly misconfigured: {
+      readonly on: {
+        readonly CLOSE: "closed";
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+    readonly closed: {
+      readonly type: "final";
+    };
+  };
+}>;
+type EkycPrefillMachine = typeof ekycPrefillMachine;
+//#endregion
+//#region src/modules/ekyc-prefill/ekycPrefillActor.d.ts
+type EkycPrefillActor = ActorRefFrom<EkycPrefillMachine>;
+type CreateEkycPrefillActorOptions = {
+  /** The served `EKYC_PREFILL` module configuration, raw or normalized. */
+  config?: EkycPrefillModuleConfig | EkycPrefillConfig;
+};
+//#endregion
+//#region src/modules/ekyc-prefill/ekycPrefillManager.d.ts
+type EkycPrefillIdleState = {
+  status: 'idle';
+};
+/** The "at least one of" rule: its members and the message shown under them. */
+type EkycPrefillAnyOfState = {
+  fields: string[];
+  /** Message key. Its `fields` param lists the members' labels. */
+  message: string;
+  /** Show the message as an error; otherwise as a hint. */
+  showError: boolean;
+};
+type EkycPrefillFormState = {
+  status: 'form';
+  country: string;
+  fields: EkycPrefillFieldDef[];
+  values: EkycFormValues;
+  errors: EkycValidationErrors;
+  anyOf: EkycPrefillAnyOfState | undefined;
+  /** A rejection the form can't pin on one field. Message key. */
+  submitError: string | undefined;
+  /** Every rule passes, so the lookup can be submitted. */
+  canSubmit: boolean;
+};
+type EkycPrefillSubmittingState = {
+  status: 'submitting';
+};
+/** The lookup could not run. `retry()` repeats it. */
+type EkycPrefillErrorState = {
+  status: 'error';
+  /** `busy`: another lookup for the session is running (409). */
+  errorKind: EkycPrefillErrorKind | undefined;
+  errorMessage: string | undefined;
+};
+/** The session's lookup limit is reached. `continue()` moves on. */
+type EkycPrefillLimitReachedState = {
+  status: 'limitReached';
+};
+/** The configuration can't be rendered, or the session's flow doesn't allow the lookup. */
+type EkycPrefillMisconfiguredState = {
+  status: 'misconfigured';
+};
+type EkycPrefillFinishedState = {
+  status: 'finished';
+};
+type EkycPrefillClosedState = {
+  status: 'closed';
+};
+/** Discriminated union of all eKYC Pre-fill manager states. */
+type EkycPrefillState = EkycPrefillIdleState | EkycPrefillFormState | EkycPrefillSubmittingState | EkycPrefillErrorState | EkycPrefillLimitReachedState | EkycPrefillMisconfiguredState | EkycPrefillFinishedState | EkycPrefillClosedState;
+declare function createEkycPrefillManagerFromActor(actor: EkycPrefillActor): Manager<EkycPrefillState> & {
+  /** Builds the form from the configuration, or finishes at once when the backend runs the lookup itself. */
+  load(): void;
+  /**
+   * Sets a field's value, formatted as typed, and clears its error. Pass
+   * `isValid: false` when the input itself knows the value is malformed
+   * (a phone number).
+   */
+  setField(name: string, value: string, isValid?: boolean): void;
+  /** Validates one field, typically when it loses focus. */
+  validateField(name: string): void;
+  /** Validates the form and, when it passes, runs the lookup. */
+  submit(): void;
+  /** Repeats the lookup that could not run. */
+  retry(): void;
+  /** Moves on after the lookup limit is reached. */
+  continue(): void;
+  /** Closes the module. */
+  close(): void;
+};
+/** Creates an eKYC Pre-fill manager for headless or UI-driven usage. */
+declare function createEkycPrefillManager(options?: CreateEkycPrefillActorOptions): Manager<EkycPrefillState> & {
+  /** Builds the form from the configuration, or finishes at once when the backend runs the lookup itself. */
+  load(): void;
+  /**
+   * Sets a field's value, formatted as typed, and clears its error. Pass
+   * `isValid: false` when the input itself knows the value is malformed
+   * (a phone number).
+   */
+  setField(name: string, value: string, isValid?: boolean): void;
+  /** Validates one field, typically when it loses focus. */
+  validateField(name: string): void;
+  /** Validates the form and, when it passes, runs the lookup. */
+  submit(): void;
+  /** Repeats the lookup that could not run. */
+  retry(): void;
+  /** Moves on after the lookup limit is reached. */
+  continue(): void;
+  /** Closes the module. */
+  close(): void;
+};
+type EkycPrefillManager = ReturnType<typeof createEkycPrefillManager>;
+//#endregion
+export { EkycPrefillFormState as a, EkycPrefillManager as c, EkycPrefillSubmittingState as d, createEkycPrefillManager as f, ekycPrefillMachine as h, EkycPrefillFinishedState as i, EkycPrefillMisconfiguredState as l, EkycPrefillActor as m, EkycPrefillClosedState as n, EkycPrefillIdleState as o, createEkycPrefillManagerFromActor as p, EkycPrefillErrorState as r, EkycPrefillLimitReachedState as s, EkycPrefillAnyOfState as t, EkycPrefillState as u };

package/dist/ekycPrefillManager-Pgb16lcO.esm.js

@@ -0,0 +1,102 @@
+import { s as createActor, u as createManager } from "./xstate.esm-DSajW7CJ.esm.js";
+import { n as isAnyOfMissing, r as validateForm, t as ekycPrefillMachine } from "./ekycPrefillStateMachine-j_WwaTPe.esm.js";
+//#region src/modules/ekyc-prefill/ekycPrefillActor.ts
+/** Creates and starts an eKYC Pre-fill actor, idle until `LOAD`. */
+function createEkycPrefillActor(options = {}) {
+	return createActor(ekycPrefillMachine, { input: { config: options.config } }).start();
+}
+//#endregion
+//#region src/modules/ekyc-prefill/ekycPrefillManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("form") && context.prepared) {
+		const { prepared, values, invalidFormats } = context;
+		const canSubmit = Object.keys(validateForm(prepared, values, invalidFormats)).length === 0 && !isAnyOfMissing(prepared, values);
+		return {
+			status: "form",
+			country: prepared.country,
+			fields: prepared.fields,
+			values,
+			errors: context.errors,
+			anyOf: prepared.anyOf && {
+				...prepared.anyOf,
+				showError: context.anyOfError
+			},
+			submitError: context.submitError,
+			canSubmit
+		};
+	}
+	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		errorKind: context.errorKind,
+		errorMessage: context.errorMessage
+	};
+	if (typedSnapshot.matches("limitReached")) return { status: "limitReached" };
+	if (typedSnapshot.matches("misconfigured")) return { status: "misconfigured" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		/** Builds the form from the configuration, or finishes at once when the backend runs the lookup itself. */
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		/**
+		* Sets a field's value, formatted as typed, and clears its error. Pass
+		* `isValid: false` when the input itself knows the value is malformed
+		* (a phone number).
+		*/
+		setField(name, value, isValid) {
+			actor.send({
+				type: "SET_FIELD",
+				name,
+				value,
+				isValid
+			});
+		},
+		/** Validates one field, typically when it loses focus. */
+		validateField(name) {
+			actor.send({
+				type: "VALIDATE_FIELD",
+				name
+			});
+		},
+		/** Validates the form and, when it passes, runs the lookup. */
+		submit() {
+			trackElementClicked?.("submit");
+			actor.send({ type: "SUBMIT" });
+		},
+		/** Repeats the lookup that could not run. */
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		/** Moves on after the lookup limit is reached. */
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		},
+		/** Closes the module. */
+		close() {
+			trackElementClicked?.("close");
+			actor.send({ type: "CLOSE" });
+		}
+	};
+}
+function createEkycPrefillManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi
+	});
+}
+/** Creates an eKYC Pre-fill manager for headless or UI-driven usage. */
+function createEkycPrefillManager(options = {}) {
+	return createEkycPrefillManagerFromActor(createEkycPrefillActor(options));
+}
+//#endregion
+export { createEkycPrefillManagerFromActor as n, createEkycPrefillManager as t };