@incodetech/core 0.0.0-dev-20260320-c9bdba0 → 0.0.0-dev-20260320-e46eb90

package/dist/{addressSearch-B446UZn4.esm.js → addressSearch-O-LFYClt.esm.js}

@@ -1,7 +1,7 @@
-import { g as BrowserTimerProvider } from "./src-D0bFtylT.esm.js";
-import { r as fromCallback } from "./xstate.esm-CcoTezCZ.esm.js";
-import { t as api } from "./api-C2uzxrpN.esm.js";
-import { t as endpoints } from "./endpoints-IAlXA1zN.esm.js";
+import { g as BrowserTimerProvider } from "./src-LjezYyPe.esm.js";
+import { r as fromCallback } from "./xstate.esm-nEixMy7s.esm.js";
+import { t as api } from "./api-G4JA8CXK.esm.js";
+import { t as endpoints } from "./endpoints-BGaT9ldX.esm.js";
 
 //#region src/shared/usStates.ts
 const usStates = {

package/dist/authentication.d.ts

@@ -1,11 +1,11 @@
-import "./deepsightService-CP5OM4Fc.js";
-import { g as AuthenticationConfig, h as createAuthenticationActor, m as CreateAuthenticationActorOptions, p as AuthenticationActor, y as authenticationMachine } from "./faceCaptureManagerFactory-COWObGBr.js";
-import "./warmup-4e5k___O.js";
-import "./Manager-DsNvecSe.js";
-import "./camera-Bzi6CMAW.js";
-import "./Actor-D3GOC38V.js";
-import "./StateMachine-BFurBmbZ.js";
-import "./types-BHnsBsl_.js";
-import "./types-BZcBRlI8.js";
-import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-CsDKpKla.js";
+import "./deepsightService-B4HcyNDh.js";
+import { g as AuthenticationConfig, h as createAuthenticationActor, m as CreateAuthenticationActorOptions, p as AuthenticationActor, y as authenticationMachine } from "./faceCaptureManagerFactory-CULlsJHa.js";
+import "./warmup-LifmFv5i.js";
+import "./Manager-DKHVvCA1.js";
+import "./camera-pEBK1r31.js";
+import "./Actor-Bd72Yikw.js";
+import "./StateMachine-D-N4dLZo.js";
+import "./types-CSgWWTDb.js";
+import "./types-S1nlDDGB.js";
+import { n as AuthenticationState, r as createAuthenticationManager, t as AuthenticationManager } from "./authenticationManager-BH1ZY_16.js";
 export { type AuthenticationActor, type AuthenticationConfig, type AuthenticationManager, type AuthenticationState, type CreateAuthenticationActorOptions, authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/authentication.esm.js

@@ -1,13 +1,13 @@
-import "./events-3HzCcoEy.esm.js";
-import "./backCameraStream-DDzfvhxo.esm.js";
-import "./src-D0bFtylT.esm.js";
-import "./xstate.esm-CcoTezCZ.esm.js";
-import "./streamingEvents-BjxVqrJP.esm.js";
-import "./deepsightService-Ca85OHZ-.esm.js";
-import "./api-C2uzxrpN.esm.js";
-import "./endpoints-IAlXA1zN.esm.js";
-import "./stats-kLtQIgsA.esm.js";
-import "./faceCaptureSetup-I9wFuT1d.esm.js";
-import { i as authenticationMachine, r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-IChdnUM9.esm.js";
+import "./events-CcXL3VWp.esm.js";
+import "./backCameraStream-D-_dxon_.esm.js";
+import "./src-LjezYyPe.esm.js";
+import "./xstate.esm-nEixMy7s.esm.js";
+import "./streamingEvents-JeLmnOFf.esm.js";
+import "./deepsightService-B4jCQAh8.esm.js";
+import "./api-G4JA8CXK.esm.js";
+import "./endpoints-BGaT9ldX.esm.js";
+import "./stats-DJ3CICeP.esm.js";
+import "./faceCaptureSetup-ePWTb1VF.esm.js";
+import { i as authenticationMachine, r as createAuthenticationActor, t as createAuthenticationManager } from "./authenticationManager-BDCN6xbG.esm.js";
 
 export { authenticationMachine, createAuthenticationActor, createAuthenticationManager };

package/dist/{authenticationManager-IChdnUM9.esm.js → authenticationManager-BDCN6xbG.esm.js}

@@ -1,10 +1,10 @@
-import { d as addEvent, n as eventModuleNames } from "./events-3HzCcoEy.esm.js";
-import { _ as BrowserStorageProvider, a as WasmUtilProvider } from "./src-D0bFtylT.esm.js";
-import { a as createActor, i as fromPromise, n as assign } from "./xstate.esm-CcoTezCZ.esm.js";
-import { l as getDeviceClass } from "./streamingEvents-BjxVqrJP.esm.js";
-import { t as api } from "./api-C2uzxrpN.esm.js";
-import { t as endpoints } from "./endpoints-IAlXA1zN.esm.js";
-import { a as FACE_ERROR_CODES, n as faceCaptureMachine, o as createFaceCaptureManagerFromActor, t as FACE_CAPTURE_EVENT_CODES } from "./faceCaptureSetup-I9wFuT1d.esm.js";
+import { d as addEvent, n as eventModuleNames } from "./events-CcXL3VWp.esm.js";
+import { _ as BrowserStorageProvider, a as WasmUtilProvider } from "./src-LjezYyPe.esm.js";
+import { a as createActor, i as fromPromise, n as assign } from "./xstate.esm-nEixMy7s.esm.js";
+import { l as getDeviceClass } from "./streamingEvents-JeLmnOFf.esm.js";
+import { t as api } from "./api-G4JA8CXK.esm.js";
+import { t as endpoints } from "./endpoints-BGaT9ldX.esm.js";
+import { a as FACE_ERROR_CODES, n as faceCaptureMachine, o as createFaceCaptureManagerFromActor, t as FACE_CAPTURE_EVENT_CODES } from "./faceCaptureSetup-ePWTb1VF.esm.js";
 
 //#region src/modules/authentication/authenticationErrorUtils.ts
 const AUTH_ERROR_MAP = {

package/dist/{authenticationManager-CsDKpKla.d.ts → authenticationManager-BH1ZY_16.d.ts}

@@ -1,5 +1,5 @@
-import { m as CreateAuthenticationActorOptions, n as FaceCaptureManagerState, p as AuthenticationActor, t as FaceCaptureManager } from "./faceCaptureManagerFactory-COWObGBr.js";
-import { t as Manager } from "./Manager-DsNvecSe.js";
+import { m as CreateAuthenticationActorOptions, n as FaceCaptureManagerState, p as AuthenticationActor, t as FaceCaptureManager } from "./faceCaptureManagerFactory-CULlsJHa.js";
+import { t as Manager } from "./Manager-DKHVvCA1.js";
 
 //#region src/modules/authentication/authenticationManager.d.ts
 type AuthenticationState = FaceCaptureManagerState;

package/dist/{backCameraStream-DDzfvhxo.esm.js → backCameraStream-D-_dxon_.esm.js}

@@ -1,4 +1,4 @@
-import { B as isSafari, D as enumerateVideoDevices, E as applyTrackConstraints, F as isAndroid, L as isIOS, O as requestCameraAccess, k as stopCameraStream, z as isIPhone14OrHigher } from "./src-D0bFtylT.esm.js";
+import { B as isSafari, D as enumerateVideoDevices, E as applyTrackConstraints, F as isAndroid, L as isIOS, O as requestCameraAccess, k as stopCameraStream, z as isIPhone14OrHigher } from "./src-LjezYyPe.esm.js";
 
 //#region ../infra/src/capabilities/ITimerCapability.ts
 function sleep(ms) {

package/dist/consent.d.ts

@@ -0,0 +1,402 @@
+import { t as Manager } from "./Manager-DKHVvCA1.js";
+import * as xstate63 from "xstate";
+
+//#region src/modules/consent/types.d.ts
+type ConsentConfig = {
+  combinedConsents?: string;
+  consentId?: string;
+};
+type ConsentCheckbox = {
+  id: string;
+  label: string;
+  required: boolean;
+  checked: boolean;
+};
+type FetchCombinedConsentResponse = {
+  languageConsentId: string;
+  terms: string;
+  title: string;
+  consents: Array<{
+    checkboxId: string;
+    consentText: string;
+    optional: boolean;
+  }>;
+};
+//#endregion
+//#region src/modules/consent/consentStateMachine.d.ts
+type ConsentContext = {
+  config: ConsentConfig;
+  title: string;
+  richText: string;
+  languageConsentId: string;
+  checkboxes: ConsentCheckbox[];
+  error: string | undefined;
+};
+type ConsentInput = {
+  config: ConsentConfig;
+};
+declare const consentMachine: xstate63.StateMachine<ConsentContext, {
+  type: "LOAD";
+} | {
+  type: "TOGGLE_CHECKBOX";
+  checkboxId: string;
+} | {
+  type: "SUBMIT";
+} | {
+  type: "RETRY";
+} | {
+  type: "RESET";
+}, {
+  [x: string]: xstate63.ActorRefFromLogic<xstate63.PromiseActorLogic<FetchCombinedConsentResponse, {
+    consentId: string;
+  }, xstate63.EventObject>> | xstate63.ActorRefFromLogic<xstate63.PromiseActorLogic<void, {
+    languageConsentId: string;
+    checkboxes: ConsentCheckbox[];
+  }, xstate63.EventObject>> | undefined;
+}, xstate63.Values<{
+  fetchConsent: {
+    src: "fetchConsent";
+    logic: xstate63.PromiseActorLogic<FetchCombinedConsentResponse, {
+      consentId: string;
+    }, xstate63.EventObject>;
+    id: string | undefined;
+  };
+  submitConsent: {
+    src: "submitConsent";
+    logic: xstate63.PromiseActorLogic<void, {
+      languageConsentId: string;
+      checkboxes: ConsentCheckbox[];
+    }, xstate63.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate63.Values<{
+  setError: {
+    type: "setError";
+    params: unknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: unknown;
+  };
+  setConsentData: {
+    type: "setConsentData";
+    params: unknown;
+  };
+  toggleCheckbox: {
+    type: "toggleCheckbox";
+    params: unknown;
+  };
+  resetContext: {
+    type: "resetContext";
+    params: unknown;
+  };
+  trackConsentGiven: {
+    type: "trackConsentGiven";
+    params: unknown;
+  };
+}>, {
+  type: "canSubmit";
+  params: unknown;
+}, never, "error" | "idle" | "finished" | "loading" | "display" | "submitting", string, ConsentInput, xstate63.NonReducibleUnknown, xstate63.EventObject, xstate63.MetaObject, {
+  readonly id: "consent";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "fetchConsent" | "submitConsent">(logic: TSrc, ...[options]: ({
+        src: "fetchConsent";
+        logic: xstate63.PromiseActorLogic<FetchCombinedConsentResponse, {
+          consentId: string;
+        }, xstate63.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "fetchConsent";
+        logic: xstate63.PromiseActorLogic<FetchCombinedConsentResponse, {
+          consentId: string;
+        }, xstate63.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate63.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate63.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate63.RequiredActorOptions<T>]: unknown }) | undefined], xstate63.IsNotNever<xstate63.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "submitConsent";
+        logic: xstate63.PromiseActorLogic<void, {
+          languageConsentId: string;
+          checkboxes: ConsentCheckbox[];
+        }, xstate63.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "submitConsent";
+        logic: xstate63.PromiseActorLogic<void, {
+          languageConsentId: string;
+          checkboxes: ConsentCheckbox[];
+        }, xstate63.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate63.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate63.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate63.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate63.IsNotNever<xstate63.RequiredActorOptions<T_1>>> : never : never : never)): xstate63.ActorRefFromLogic<xstate63.GetConcreteByKey<xstate63.Values<{
+        fetchConsent: {
+          src: "fetchConsent";
+          logic: xstate63.PromiseActorLogic<FetchCombinedConsentResponse, {
+            consentId: string;
+          }, xstate63.EventObject>;
+          id: string | undefined;
+        };
+        submitConsent: {
+          src: "submitConsent";
+          logic: xstate63.PromiseActorLogic<void, {
+            languageConsentId: string;
+            checkboxes: ConsentCheckbox[];
+          }, xstate63.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate63.AnyActorLogic>(src: TLogic, ...[options]: xstate63.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate63.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate63.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate63.IsNotNever<xstate63.RequiredLogicInput<TLogic>>>): xstate63.ActorRefFromLogic<TLogic>;
+    };
+    input: ConsentInput;
+    self: xstate63.ActorRef<xstate63.MachineSnapshot<ConsentContext, {
+      type: "LOAD";
+    } | {
+      type: "TOGGLE_CHECKBOX";
+      checkboxId: string;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "RESET";
+    }, Record<string, xstate63.AnyActorRef | undefined>, xstate63.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "TOGGLE_CHECKBOX";
+      checkboxId: string;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "RESET";
+    }, xstate63.AnyEventObject>;
+  }) => {
+    config: ConsentConfig;
+    title: string;
+    richText: string;
+    languageConsentId: string;
+    checkboxes: never[];
+    error: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+      };
+    };
+    readonly loading: {
+      readonly invoke: {
+        readonly id: "fetchConsent";
+        readonly src: "fetchConsent";
+        readonly input: ({
+          context
+        }: {
+          context: ConsentContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          };
+          self: xstate63.ActorRef<xstate63.MachineSnapshot<ConsentContext, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, Record<string, xstate63.AnyActorRef>, xstate63.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, xstate63.AnyEventObject>;
+        }) => {
+          consentId: string;
+        };
+        readonly onDone: {
+          readonly target: "display";
+          readonly actions: "setConsentData";
+        };
+        readonly onError: {
+          readonly target: "error";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly display: {
+      readonly on: {
+        readonly TOGGLE_CHECKBOX: {
+          readonly actions: "toggleCheckbox";
+        };
+        readonly SUBMIT: {
+          readonly target: "submitting";
+          readonly guard: "canSubmit";
+        };
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+      };
+    };
+    readonly submitting: {
+      readonly invoke: {
+        readonly id: "submitConsent";
+        readonly src: "submitConsent";
+        readonly input: ({
+          context
+        }: {
+          context: ConsentContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          };
+          self: xstate63.ActorRef<xstate63.MachineSnapshot<ConsentContext, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, Record<string, xstate63.AnyActorRef>, xstate63.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, xstate63.AnyEventObject>;
+        }) => {
+          languageConsentId: string;
+          checkboxes: ConsentCheckbox[];
+        };
+        readonly onDone: {
+          readonly target: "finished";
+          readonly actions: "trackConsentGiven";
+        };
+        readonly onError: {
+          readonly target: "display";
+          readonly actions: "setError";
+        };
+      };
+    };
+    readonly error: {
+      readonly on: {
+        readonly RETRY: {
+          readonly target: "loading";
+          readonly actions: "clearError";
+        };
+        readonly RESET: {
+          readonly target: "idle";
+          readonly actions: "resetContext";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+//#endregion
+//#region src/modules/consent/consentActor.d.ts
+type CreateConsentActorOptions = {
+  config: ConsentConfig;
+};
+//#endregion
+//#region src/modules/consent/consentManager.d.ts
+type ConsentIdleState = {
+  status: 'idle';
+};
+type ConsentLoadingState = {
+  status: 'loading';
+};
+type ConsentDisplayState = {
+  status: 'display';
+  title: string;
+  richText: string;
+  checkboxes: ConsentCheckbox[];
+  canSubmit: boolean;
+  error?: string;
+};
+type ConsentSubmittingState = {
+  status: 'submitting';
+  title: string;
+  richText: string;
+  checkboxes: ConsentCheckbox[];
+  canSubmit: false;
+};
+type ConsentFinishedState = {
+  status: 'finished';
+};
+type ConsentErrorState = {
+  status: 'error';
+  error: string;
+};
+type ConsentState = ConsentIdleState | ConsentLoadingState | ConsentDisplayState | ConsentSubmittingState | ConsentFinishedState | ConsentErrorState;
+declare function createConsentManager(options: CreateConsentActorOptions): Manager<ConsentState> & {
+  load(): void;
+  toggleCheckbox(checkboxId: string): void;
+  submit(): void;
+  retry(): void;
+  reset(): void;
+};
+type ConsentManager = ReturnType<typeof createConsentManager>;
+//#endregion
+export { type ConsentCheckbox, type ConsentConfig, type ConsentManager, type ConsentState, consentMachine, createConsentManager };