@incodetech/core 2.1.0-rc.2 → 2.1.0-rc.4

package/dist/geolocationManager-B3lahU1a.d.ts

@@ -0,0 +1,156 @@
+import { t as Manager } from "./Manager-BfBOhrjh.js";
+import { t as ActorRefFrom } from "./Actor-DYjXVMQm.js";
+
+//#region ../infra/src/capabilities/IGeolocationCapability.d.ts
+type GeolocationCoords = {
+  latitude: number;
+  longitude: number;
+};
+type IGeolocationCapability = {
+  getCurrentPosition(): Promise<GeolocationCoords>;
+};
+//#endregion
+//#region src/modules/geolocation/types.d.ts
+/**
+ * Configuration options for the Geolocation module.
+ *
+ * @example
+ * ```typescript
+ * const config: GeolocationConfig = {
+ *   allowUserToSkipGeolocation: true,
+ * };
+ * ```
+ */
+type GeolocationConfig = {
+  /**
+   * Whether the user is allowed to skip geolocation capture.
+   * When true, a skip button is shown on the permission-denied screen.
+   * Backend field name from flow/workflow configuration.
+   * @default false
+   */
+  allowUserToSkipGeolocation?: boolean;
+};
+//#endregion
+//#region src/modules/geolocation/geolocationStateMachine.d.ts
+type GeolocationDeviceType = 'ios' | 'android' | 'desktop';
+declare const geolocationMachine: any;
+type GeolocationMachine = typeof geolocationMachine;
+//#endregion
+//#region src/modules/geolocation/geolocationActor.d.ts
+type CreateGeolocationActorOptions = {
+  config: GeolocationConfig;
+  geolocation?: IGeolocationCapability;
+};
+type GeolocationActor = ActorRefFrom<GeolocationMachine>;
+//#endregion
+//#region src/modules/geolocation/geolocationManager.d.ts
+
+/** Geolocation manager is in initial state, waiting for `request()` to be called */
+type GeolocationIdleState = {
+  status: 'idle';
+};
+/** Browser geolocation permission prompt is active */
+type GeolocationRequestingState = {
+  status: 'requestingLocation';
+};
+/** Coordinates are being submitted to the backend */
+type GeolocationSubmittingState = {
+  status: 'submitting';
+};
+/**
+ * Location successfully acquired — call `continue()` to proceed
+ * @property location - Location name returned from backend, or null
+ */
+type GeolocationAcquiredState = {
+  status: 'locationAcquired';
+  location: string | null;
+};
+/**
+ * User denied geolocation permission — shows device-specific instructions
+ * @property deviceType - Used by UI to render the correct instruction panel
+ * @property canSkip - Whether the skip button should be shown
+ */
+type GeolocationPermissionDeniedState = {
+  status: 'permissionDenied';
+  deviceType: GeolocationDeviceType;
+  canSkip: boolean;
+};
+/** Geolocation flow completed successfully */
+type GeolocationFinishedState = {
+  status: 'finished';
+};
+/**
+ * Union of all possible geolocation manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = geolocationManager.getState();
+ * if (state.status === 'locationAcquired') {
+ *   console.log(state.location);
+ * }
+ * if (state.status === 'permissionDenied') {
+ *   console.log(state.deviceType); // 'ios' | 'android' | 'desktop'
+ * }
+ * ```
+ */
+type GeolocationState = GeolocationIdleState | GeolocationRequestingState | GeolocationSubmittingState | GeolocationAcquiredState | GeolocationPermissionDeniedState | GeolocationFinishedState;
+/**
+ * Creates a geolocation manager for headless or UI-driven usage.
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createGeolocationManager({ config: { allowUserToSkipGeolocation: true } });
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.request();
+ * ```
+ */
+declare function createGeolocationManager(options: CreateGeolocationActorOptions): Manager<GeolocationState> & {
+  /**
+   * Initiates the browser geolocation permission request.
+   * Transitions from 'idle' to 'requestingLocation'.
+   */
+  request(): void;
+  /**
+   * Confirms the acquired location and completes the module.
+   * Should be called when state is 'locationAcquired'.
+   */
+  continue(): void;
+  /**
+   * Skips geolocation when the user has denied permission.
+   * Only works when `config.allowUserToSkipGeolocation` is true.
+   */
+  skip(): void;
+  /**
+   * Resets the manager back to initial state.
+   */
+  reset(): void;
+};
+/**
+ * Creates a geolocation manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or for story-isolation testing.
+ */
+declare function createGeolocationManagerFromActor(actor: GeolocationActor): Manager<GeolocationState> & {
+  /**
+   * Initiates the browser geolocation permission request.
+   * Transitions from 'idle' to 'requestingLocation'.
+   */
+  request(): void;
+  /**
+   * Confirms the acquired location and completes the module.
+   * Should be called when state is 'locationAcquired'.
+   */
+  continue(): void;
+  /**
+   * Skips geolocation when the user has denied permission.
+   * Only works when `config.allowUserToSkipGeolocation` is true.
+   */
+  skip(): void;
+  /**
+   * Resets the manager back to initial state.
+   */
+  reset(): void;
+};
+type GeolocationManager = ReturnType<typeof createGeolocationManager>;
+//#endregion
+export { GeolocationActor as a, createGeolocationManagerFromActor as i, GeolocationState as n, geolocationMachine as o, createGeolocationManager as r, GeolocationConfig as s, GeolocationManager as t };

package/dist/geolocationManager-CVKUo6a4.esm.js

@@ -0,0 +1,122 @@
+import { n as eventModuleNames, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
+import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
+import { t as geolocationMachine } from "./geolocationStateMachine-CdYh-pwi.esm.js";
+
+//#region ../infra/src/providers/browser/BrowserGeolocationProvider.ts
+var BrowserGeolocationProvider = class {
+	getCurrentPosition() {
+		return new Promise((resolve, reject) => {
+			navigator.geolocation.getCurrentPosition((pos) => resolve({
+				latitude: pos.coords.latitude,
+				longitude: pos.coords.longitude
+			}), reject);
+		});
+	}
+};
+
+//#endregion
+//#region src/modules/geolocation/geolocationActor.ts
+function createGeolocationActor(options) {
+	const geolocation = options.geolocation ?? new BrowserGeolocationProvider();
+	return createActor(geolocationMachine, { input: {
+		config: options.config,
+		geolocation
+	} }).start();
+}
+
+//#endregion
+//#region src/modules/geolocation/geolocationManager.ts
+/**
+* Maps a Geolocation state-machine snapshot to the exact Figma "Tracked
+* Events" screen name. Returned strings are the absolute analytics screen
+* (module prefix included) and are emitted verbatim by
+* `createManagerInstrumentation`'s `getEventScreenName` short-circuit.
+*
+* Source of truth: Geolocation Figma file → Tracked Events canvas
+* (`https://www.figma.com/design/xg1t3GnUS95A4bLrM3lyOG/Geolocation---Latest-Design?node-id=2652-17008`).
+*
+* Deferred Figma screens that have no state-machine counterpart yet:
+* `Geolocation.error.locationUnavailable` and `Geolocation.error.noNetwork`.
+* Both kinds of failure currently collapse into `permissionDenied`
+* (`requestPosition` `onError`) or `locationAcquired` with `location: null`
+* (`submitPosition` `onError`), so the machine cannot distinguish them today.
+*/
+function getGeolocationScreenName(snapshot) {
+	const { value } = snapshot;
+	if (typeof value !== "string") return void 0;
+	switch (value) {
+		case "idle": return "Geolocation.default";
+		case "requestingLocation":
+		case "submitting": return "Geolocation.permission";
+		case "locationAcquired":
+		case "finished": return "Geolocation.continue";
+		case "permissionDenied": return "Geolocation.allowLocation";
+		default: return;
+	}
+}
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("requestingLocation")) return { status: "requestingLocation" };
+	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
+	if (typedSnapshot.matches("locationAcquired")) return {
+		status: "locationAcquired",
+		location: context.location ?? null
+	};
+	if (typedSnapshot.matches("permissionDenied")) return {
+		status: "permissionDenied",
+		deviceType: context.deviceType,
+		canSkip: context.config.allowUserToSkipGeolocation === true
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		request() {
+			trackElementClicked?.("request");
+			actor.send({ type: "REQUEST" });
+		},
+		continue() {
+			trackElementClicked?.("continue");
+			actor.send({ type: "CONTINUE" });
+		},
+		skip() {
+			trackElementClicked?.("skip");
+			actor.send({ type: "SKIP" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+/**
+* Creates a geolocation manager for headless or UI-driven usage.
+*
+* @example Headless usage
+* ```typescript
+* const manager = createGeolocationManager({ config: { allowUserToSkipGeolocation: true } });
+* manager.subscribe((state) => console.log(state.status));
+* manager.request();
+* ```
+*/
+function createGeolocationManager(options) {
+	return createGeolocationManagerFromActor(createGeolocationActor(options));
+}
+/**
+* Creates a geolocation manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createGeolocationManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.geolocation, { getEventScreenName: getGeolocationScreenName })
+	});
+}
+
+//#endregion
+export { createGeolocationManagerFromActor as n, createGeolocationManager as t };

package/dist/{geolocationStateMachine-BWjrMGS_.esm.js → geolocationStateMachine-CdYh-pwi.esm.js}

@@ -1,7 +1,7 @@
-import { t as api } from "./api-DUZwyz0o.esm.js";
-import { t as endpoints } from "./endpoints-BM2_j_IE.esm.js";
-import { r as isIOS, t as isAndroid } from "./platform-BfoqeM61.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-Dkm1jy5u.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
+import { r as isIOS, t as isAndroid } from "./platform-BoeUeUrV.esm.js";
+import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
 
 //#region src/modules/geolocation/geolocationServices.ts
 async function addGeolocation(params, signal) {

package/dist/{getDeviceClass-rXKlXywy.esm.js → getDeviceClass-QxbJwsOO.esm.js}

@@ -1,4 +1,4 @@
-import { t as getDeviceInfo } from "./getDeviceClass-C0zrM97a.esm.js";
+import { t as getDeviceInfo } from "./getDeviceClass-BdgmyOOu.esm.js";
 
 //#region src/internal/device/getDeviceClass.ts
 function getDeviceClass() {

package/dist/government-validation.d.ts

@@ -1,6 +1,7 @@
-import { t as Manager } from "./Manager-B2OEDYqf.js";
-import "./Actor-fIPLXfoi.js";
-import { t as OtpValidationErrors } from "./otp-BHJnjEEc.js";
+import "./StateMachine-20ahmASR.js";
+import { t as Manager } from "./Manager-BfBOhrjh.js";
+import "./Actor-DYjXVMQm.js";
+import { t as OtpValidationErrors } from "./otp-CETbFjXH.js";
 
 //#region src/modules/government-validation/types.d.ts
 type GovernmentValidationConfig = {

package/dist/government-validation.esm.js

@@ -1,10 +1,10 @@
-import "./BrowserTimerProvider-BVgutW_b.esm.js";
-import "./api-DUZwyz0o.esm.js";
-import { n as eventModuleNames, o as topLevelStateName, s as createManagerInstrumentation } from "./events-DN-u67gb.esm.js";
-import "./endpoints-BM2_j_IE.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-Dkm1jy5u.esm.js";
-import { t as OTP_CODE_LENGTH } from "./otp-D87RTwrx.esm.js";
-import { t as governmentValidationMachine } from "./governmentValidationStateMachine-BoF7U1of.esm.js";
+import "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import { n as eventModuleNames, o as topLevelStateName, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
+import "./endpoints-CwrFQfW7.esm.js";
+import { l as createManager, s as createActor } from "./xstate.esm-nY3M5UYm.esm.js";
+import { t as OTP_CODE_LENGTH } from "./otp-DepQPUIA.esm.js";
+import { t as governmentValidationMachine } from "./governmentValidationStateMachine-CjCs0_fG.esm.js";
 
 //#region src/modules/government-validation/governmentValidationActor.ts
 function createGovernmentValidationActor(options) {

package/dist/{governmentValidationStateMachine-BoF7U1of.esm.js → governmentValidationStateMachine-CjCs0_fG.esm.js}

@@ -1,8 +1,8 @@
-import { t as BrowserTimerProvider } from "./BrowserTimerProvider-BVgutW_b.esm.js";
-import { t as api } from "./api-DUZwyz0o.esm.js";
-import { t as endpoints } from "./endpoints-BM2_j_IE.esm.js";
-import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-Dkm1jy5u.esm.js";
-import { n as computeOtpValidationErrors, r as isOtpComplete } from "./otp-D87RTwrx.esm.js";
+import { t as BrowserTimerProvider } from "./BrowserTimerProvider-CHloo0eQ.esm.js";
+import { t as api } from "./api-DsbUi7TO.esm.js";
+import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
+import { a as fromPromise, i as fromCallback, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
+import { n as computeOtpValidationErrors, r as isOtpComplete } from "./otp-DepQPUIA.esm.js";
 
 //#region src/modules/government-validation/governmentValidationServices.ts
 async function processGovernmentValidation(signal) {

package/dist/home.d.ts

@@ -1,9 +1,12 @@
-import { t as Manager } from "./Manager-B2OEDYqf.js";
-import "./camera-biGPWlmx.js";
-import "./types-Z9wv19v2.js";
-import "./types-DYZja-k9.js";
-import { t as EmptyConfig } from "./types-Dv-9WPJX.js";
-import * as xstate783 from "xstate";
+import "./StateMachine-20ahmASR.js";
+import { t as Manager } from "./Manager-BfBOhrjh.js";
+import "./camera-CWO06Lu5.js";
+import "./types-B_YCuHZx.js";
+import "./types-CTnn7kUK.js";
+import "./canvas-pLrXU1id.js";
+import "./createFaceAvatar-DNMSIcRb.js";
+import { t as EmptyConfig } from "./types-Cyi3gwPK.js";
+import * as xstate188 from "xstate";
 
 //#region src/modules/home/types.d.ts
 type HomeConfig = EmptyConfig;
@@ -35,41 +38,41 @@ type HomeContext = {
 type HomeInput = {
   config: EmptyConfig;
 };
-declare const homeMachine: xstate783.StateMachine<HomeContext, {
+declare const homeMachine: xstate188.StateMachine<HomeContext, {
   type: "LOAD";
 } | {
   type: "COMPLETE";
 } | {
   type: "RESET";
-}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate783.NonReducibleUnknown, xstate783.EventObject, xstate783.MetaObject, {
+}, {}, never, never, never, never, "idle" | "finished" | "main", string, HomeInput, xstate188.NonReducibleUnknown, xstate188.EventObject, xstate188.MetaObject, {
   readonly id: "home";
   readonly initial: "idle";
   readonly context: ({
     input
   }: {
     spawn: {
-      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate783.ActorRefFromLogic<never>;
-      <TLogic extends xstate783.AnyActorLogic>(src: TLogic, ...[options]: xstate783.ConditionalRequired<[options?: ({
+      <TSrc extends never>(logic: TSrc, ...[options]: never): xstate188.ActorRefFromLogic<never>;
+      <TLogic extends xstate188.AnyActorLogic>(src: TLogic, ...[options]: xstate188.ConditionalRequired<[options?: ({
         id?: never;
         systemId?: string;
-        input?: xstate783.InputFrom<TLogic> | undefined;
+        input?: xstate188.InputFrom<TLogic> | undefined;
         syncSnapshot?: boolean;
-      } & { [K in xstate783.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate783.IsNotNever<xstate783.RequiredLogicInput<TLogic>>>): xstate783.ActorRefFromLogic<TLogic>;
+      } & { [K in xstate188.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate188.IsNotNever<xstate188.RequiredLogicInput<TLogic>>>): xstate188.ActorRefFromLogic<TLogic>;
     };
     input: HomeInput;
-    self: xstate783.ActorRef<xstate783.MachineSnapshot<HomeContext, {
+    self: xstate188.ActorRef<xstate188.MachineSnapshot<HomeContext, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, Record<string, xstate783.AnyActorRef | undefined>, xstate783.StateValue, string, unknown, any, any>, {
+    }, Record<string, xstate188.AnyActorRef | undefined>, xstate188.StateValue, string, unknown, any, any>, {
       type: "LOAD";
     } | {
       type: "COMPLETE";
     } | {
       type: "RESET";
-    }, xstate783.AnyEventObject>;
+    }, xstate188.AnyEventObject>;
   }) => {
     config: EmptyConfig;
   };

package/dist/home.esm.js

@@ -1,6 +1,6 @@
-import "./api-DUZwyz0o.esm.js";
-import { n as eventModuleNames, s as createManagerInstrumentation } from "./events-DN-u67gb.esm.js";
-import { c as createManager, s as createActor, t as setup } from "./xstate.esm-Dkm1jy5u.esm.js";
+import "./api-DsbUi7TO.esm.js";
+import { n as eventModuleNames, s as createManagerInstrumentation } from "./events-1wxZ97yf.esm.js";
+import { l as createManager, s as createActor, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
 
 //#region src/modules/home/homeStateMachine.ts
 const homeMachine = setup({ types: {

package/dist/http.esm.js

@@ -1,4 +1,4 @@
-import { n as getApi, t as api } from "./api-DUZwyz0o.esm.js";
-import "./http-CfVTgMfU.esm.js";
+import { n as getApi, t as api } from "./api-DsbUi7TO.esm.js";
+import "./http-CBbBcnBa.esm.js";
 
 export { api, getApi };