@incodetech/core 2.0.1-rc.0 → 2.1.0-rc.0

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import "./warmup-CEcppFiS.js";
-import { a as reset, i as isConfigured, s as setup, t as SetupOptions } from "./setup-C5AITV8m.js";
+import "./warmup-Dg8Lh-50.js";
+import { a as reset, i as isConfigured, s as setup, t as SetupOptions } from "./setup-BbkprdVv.js";
 export { type SetupOptions, isConfigured, reset, setup };

package/dist/index.esm.js

@@ -1,12 +1,14 @@
-import { a as setup, n as isConfigured, r as reset } from "./setup-DsM8IG7k.esm.js";
-import "./BaseWasmProvider-C_DLEI40.esm.js";
-import "./WasmUtilProvider-j98OJf-S.esm.js";
+import "./WasmUtilProvider-CiEN7Gjn.esm.js";
+import { a as setup, n as isConfigured, r as reset } from "./setup-BqEfrdja.esm.js";
 import "./BrowserTimerProvider-DhNc_x02.esm.js";
 import "./api-CESGtpbH.esm.js";
-import "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import "./session-CGtQJJzB.esm.js";
-import "./IpifyProvider-D7jx52AL.esm.js";
-import "./browserSimulation-gxD8cSpM.esm.js";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./stats-BMNUG1AU.esm.js";
+import "./IpifyProvider-D4LWD15E.esm.js";
+import "./browserSimulation-B1dWiXp7.esm.js";
+import "./sessionInitializer-B8H5MsXM.esm.js";
+import "./platform-SKvEfCBh.esm.js";
+import "./getBrowser-C8DP7oTB.esm.js";
 
 export { isConfigured, reset, setup };

package/dist/{invokeOnCaptureCallback-rc6kBHo5.esm.js → invokeOnCaptureCallback-ygByVdnn.esm.js}

@@ -1,4 +1,4 @@
-import { h as addEvent } from "./events-D6-e4vok.esm.js";
+import { h as addEvent } from "./events-Dvvriq9l.esm.js";
 
 //#region src/internal/captureOnly/invokeOnCaptureCallback.ts
 /**

package/dist/{lib-BB0B_qQX.esm.js → lib-BY67lgbq.esm.js}

@@ -1,4 +1,4 @@
-import { i as __toCommonJS, n as __esm, r as __export, t as __commonJS } from "./chunk-CRF6K_H_.esm.js";
+import { i as __toCommonJS, n as __esm, r as __export, t as __commonJS } from "./chunk-CMUKZ2uL.esm.js";
 
 //#region ../../node_modules/.pnpm/jsnlog@2.30.0/node_modules/jsnlog/jsnlog.js
 var require_jsnlog = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/jsnlog@2.30.0/node_modules/jsnlog/jsnlog.js": ((exports) => {

package/dist/mandatory-consent.d.ts

@@ -1,412 +1,8 @@
-import { t as Manager } from "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.js";
-import "./camera-DBSxa6ML.js";
-import "./types-CFV9G_7j.js";
-import { a as RegulationTypes } from "./types-BP1m8VRw.js";
-import * as xstate381 from "xstate";
-
-//#region src/modules/mandatory-consent/types.d.ts
-type MandatoryConsentConfig = {
-  consentType: RegulationTypes;
-};
-type MandatoryConsent = {
-  id: string;
-  title: string;
-  text: string;
-  description?: string;
-  consentType: string;
-};
-type FetchMandatoryConsentResponse = {
-  consents: MandatoryConsent[];
-};
-//#endregion
-//#region src/modules/mandatory-consent/mandatoryConsentStateMachine.d.ts
-type MandatoryConsentContext = {
-  config: MandatoryConsentConfig;
-  consent: MandatoryConsent | undefined;
-  isSigned: boolean;
-  error: string | undefined;
-};
-type MandatoryConsentInput = {
-  config: MandatoryConsentConfig;
-};
-declare const mandatoryConsentMachine: xstate381.StateMachine<MandatoryConsentContext, {
-  type: "LOAD";
-} | {
-  type: "TOGGLE";
-} | {
-  type: "SUBMIT";
-} | {
-  type: "CANCEL";
-} | {
-  type: "RETRY";
-} | {
-  type: "RESET";
-}, {
-  [x: string]: xstate381.ActorRefFromLogic<xstate381.PromiseActorLogic<FetchMandatoryConsentResponse, {
-    config: MandatoryConsentConfig;
-  }, xstate381.EventObject>> | xstate381.ActorRefFromLogic<xstate381.PromiseActorLogic<void, {
-    consentId: string;
-    isSigned: boolean;
-  }, xstate381.EventObject>> | undefined;
-}, xstate381.Values<{
-  fetchConsent: {
-    src: "fetchConsent";
-    logic: xstate381.PromiseActorLogic<FetchMandatoryConsentResponse, {
-      config: MandatoryConsentConfig;
-    }, xstate381.EventObject>;
-    id: string | undefined;
-  };
-  submitConsent: {
-    src: "submitConsent";
-    logic: xstate381.PromiseActorLogic<void, {
-      consentId: string;
-      isSigned: boolean;
-    }, xstate381.EventObject>;
-    id: string | undefined;
-  };
-}>, xstate381.Values<{
-  setConsent: {
-    type: "setConsent";
-    params: xstate381.NonReducibleUnknown;
-  };
-  setError: {
-    type: "setError";
-    params: xstate381.NonReducibleUnknown;
-  };
-  clearError: {
-    type: "clearError";
-    params: xstate381.NonReducibleUnknown;
-  };
-  resetContext: {
-    type: "resetContext";
-    params: xstate381.NonReducibleUnknown;
-  };
-  toggleSigned: {
-    type: "toggleSigned";
-    params: xstate381.NonReducibleUnknown;
-  };
-}>, {
-  type: "canSubmit";
-  params: unknown;
-}, never, "error" | "idle" | "closed" | "finished" | "loading" | "display" | "submitting", string, MandatoryConsentInput, xstate381.NonReducibleUnknown, xstate381.EventObject, xstate381.MetaObject, {
-  readonly id: "mandatoryConsent";
-  readonly initial: "idle";
-  readonly context: ({
-    input
-  }: {
-    spawn: {
-      <TSrc extends "fetchConsent" | "submitConsent">(logic: TSrc, ...[options]: ({
-        src: "fetchConsent";
-        logic: xstate381.PromiseActorLogic<FetchMandatoryConsentResponse, {
-          config: MandatoryConsentConfig;
-        }, xstate381.EventObject>;
-        id: string | undefined;
-      } extends infer T ? T extends {
-        src: "fetchConsent";
-        logic: xstate381.PromiseActorLogic<FetchMandatoryConsentResponse, {
-          config: MandatoryConsentConfig;
-        }, xstate381.EventObject>;
-        id: string | undefined;
-      } ? T extends {
-        src: TSrc;
-      } ? xstate381.ConditionalRequired<[options?: ({
-        id?: T["id"] | undefined;
-        systemId?: string;
-        input?: xstate381.InputFrom<T["logic"]> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K in xstate381.RequiredActorOptions<T>]: unknown }) | undefined], xstate381.IsNotNever<xstate381.RequiredActorOptions<T>>> : never : never : never) | ({
-        src: "submitConsent";
-        logic: xstate381.PromiseActorLogic<void, {
-          consentId: string;
-          isSigned: boolean;
-        }, xstate381.EventObject>;
-        id: string | undefined;
-      } extends infer T_1 ? T_1 extends {
-        src: "submitConsent";
-        logic: xstate381.PromiseActorLogic<void, {
-          consentId: string;
-          isSigned: boolean;
-        }, xstate381.EventObject>;
-        id: string | undefined;
-      } ? T_1 extends {
-        src: TSrc;
-      } ? xstate381.ConditionalRequired<[options?: ({
-        id?: T_1["id"] | undefined;
-        systemId?: string;
-        input?: xstate381.InputFrom<T_1["logic"]> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K_1 in xstate381.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate381.IsNotNever<xstate381.RequiredActorOptions<T_1>>> : never : never : never)): xstate381.ActorRefFromLogic<xstate381.GetConcreteByKey<xstate381.Values<{
-        fetchConsent: {
-          src: "fetchConsent";
-          logic: xstate381.PromiseActorLogic<FetchMandatoryConsentResponse, {
-            config: MandatoryConsentConfig;
-          }, xstate381.EventObject>;
-          id: string | undefined;
-        };
-        submitConsent: {
-          src: "submitConsent";
-          logic: xstate381.PromiseActorLogic<void, {
-            consentId: string;
-            isSigned: boolean;
-          }, xstate381.EventObject>;
-          id: string | undefined;
-        };
-      }>, "src", TSrc>["logic"]>;
-      <TLogic extends xstate381.AnyActorLogic>(src: TLogic, ...[options]: xstate381.ConditionalRequired<[options?: ({
-        id?: never;
-        systemId?: string;
-        input?: xstate381.InputFrom<TLogic> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K in xstate381.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate381.IsNotNever<xstate381.RequiredLogicInput<TLogic>>>): xstate381.ActorRefFromLogic<TLogic>;
-    };
-    input: MandatoryConsentInput;
-    self: xstate381.ActorRef<xstate381.MachineSnapshot<MandatoryConsentContext, {
-      type: "LOAD";
-    } | {
-      type: "TOGGLE";
-    } | {
-      type: "SUBMIT";
-    } | {
-      type: "CANCEL";
-    } | {
-      type: "RETRY";
-    } | {
-      type: "RESET";
-    }, Record<string, xstate381.AnyActorRef | undefined>, xstate381.StateValue, string, unknown, any, any>, {
-      type: "LOAD";
-    } | {
-      type: "TOGGLE";
-    } | {
-      type: "SUBMIT";
-    } | {
-      type: "CANCEL";
-    } | {
-      type: "RETRY";
-    } | {
-      type: "RESET";
-    }, xstate381.AnyEventObject>;
-  }) => {
-    config: MandatoryConsentConfig;
-    consent: undefined;
-    isSigned: false;
-    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: MandatoryConsentContext;
-          event: {
-            type: "LOAD";
-          } | {
-            type: "TOGGLE";
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "CANCEL";
-          } | {
-            type: "RETRY";
-          } | {
-            type: "RESET";
-          };
-          self: xstate381.ActorRef<xstate381.MachineSnapshot<MandatoryConsentContext, {
-            type: "LOAD";
-          } | {
-            type: "TOGGLE";
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "CANCEL";
-          } | {
-            type: "RETRY";
-          } | {
-            type: "RESET";
-          }, Record<string, xstate381.AnyActorRef>, xstate381.StateValue, string, unknown, any, any>, {
-            type: "LOAD";
-          } | {
-            type: "TOGGLE";
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "CANCEL";
-          } | {
-            type: "RETRY";
-          } | {
-            type: "RESET";
-          }, xstate381.AnyEventObject>;
-        }) => {
-          config: MandatoryConsentConfig;
-        };
-        readonly onDone: {
-          readonly target: "display";
-          readonly actions: "setConsent";
-        };
-        readonly onError: {
-          readonly target: "error";
-          readonly actions: "setError";
-        };
-      };
-    };
-    readonly display: {
-      readonly on: {
-        readonly TOGGLE: {
-          readonly actions: "toggleSigned";
-        };
-        readonly SUBMIT: {
-          readonly target: "submitting";
-          readonly guard: "canSubmit";
-        };
-        readonly CANCEL: {
-          readonly target: "closed";
-        };
-        readonly RETRY: {
-          readonly target: "loading";
-          readonly actions: "clearError";
-        };
-      };
-    };
-    readonly submitting: {
-      readonly invoke: {
-        readonly id: "submitConsent";
-        readonly src: "submitConsent";
-        readonly input: ({
-          context
-        }: {
-          context: MandatoryConsentContext;
-          event: {
-            type: "LOAD";
-          } | {
-            type: "TOGGLE";
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "CANCEL";
-          } | {
-            type: "RETRY";
-          } | {
-            type: "RESET";
-          };
-          self: xstate381.ActorRef<xstate381.MachineSnapshot<MandatoryConsentContext, {
-            type: "LOAD";
-          } | {
-            type: "TOGGLE";
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "CANCEL";
-          } | {
-            type: "RETRY";
-          } | {
-            type: "RESET";
-          }, Record<string, xstate381.AnyActorRef>, xstate381.StateValue, string, unknown, any, any>, {
-            type: "LOAD";
-          } | {
-            type: "TOGGLE";
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "CANCEL";
-          } | {
-            type: "RETRY";
-          } | {
-            type: "RESET";
-          }, xstate381.AnyEventObject>;
-        }) => {
-          consentId: string;
-          isSigned: boolean;
-        };
-        readonly onDone: {
-          readonly target: "finished";
-        };
-        readonly onError: {
-          readonly target: "display";
-          readonly actions: "setError";
-        };
-      };
-    };
-    readonly error: {
-      readonly on: {
-        readonly RETRY: {
-          readonly target: "loading";
-          readonly actions: "clearError";
-        };
-        readonly CANCEL: {
-          readonly target: "closed";
-        };
-        readonly RESET: {
-          readonly target: "idle";
-          readonly actions: "resetContext";
-        };
-      };
-    };
-    readonly finished: {
-      readonly type: "final";
-    };
-    readonly closed: {
-      readonly type: "final";
-    };
-  };
-}>;
-//#endregion
-//#region src/modules/mandatory-consent/mandatoryConsentActor.d.ts
-type CreateMandatoryConsentActorOptions = {
-  config: MandatoryConsentConfig;
-};
-//#endregion
-//#region src/modules/mandatory-consent/mandatoryConsentManager.d.ts
-type MandatoryConsentIdleState = {
-  status: 'idle';
-};
-type MandatoryConsentLoadingState = {
-  status: 'loading';
-};
-type MandatoryConsentDisplayState = {
-  status: 'display';
-  title: string;
-  text: string;
-  isSigned: boolean;
-  canSubmit: boolean;
-  error?: string;
-};
-type MandatoryConsentSubmittingState = {
-  status: 'submitting';
-  title: string;
-  text: string;
-  isSigned: boolean;
-  canSubmit: false;
-};
-type MandatoryConsentFinishedState = {
-  status: 'finished';
-};
-type MandatoryConsentClosedState = {
-  status: 'closed';
-};
-type MandatoryConsentErrorState = {
-  status: 'error';
-  error: string;
-};
-type MandatoryConsentState = MandatoryConsentIdleState | MandatoryConsentLoadingState | MandatoryConsentDisplayState | MandatoryConsentSubmittingState | MandatoryConsentFinishedState | MandatoryConsentClosedState | MandatoryConsentErrorState;
-declare function createMandatoryConsentManager(options: CreateMandatoryConsentActorOptions): Manager<MandatoryConsentState> & {
-  load(): void;
-  toggle(): void;
-  submit(): void;
-  cancel(): void;
-  retry(): void;
-  reset(): void;
-};
-type MandatoryConsentManager = ReturnType<typeof createMandatoryConsentManager>;
-//#endregion
-export { type MandatoryConsentConfig, type MandatoryConsentManager, type MandatoryConsentState, createMandatoryConsentManager, mandatoryConsentMachine };
+import "./Manager-BHn8wH8K.js";
+import "./Actor-Y0_Fj-KL.js";
+import "./camera-SRBpPq2X.js";
+import "./types-Bj9hdFjU.js";
+import "./types-DvGZI7BF.js";
+import "./types-DOUhndhT.js";
+import { a as MandatoryConsentActor, i as createMandatoryConsentManagerFromActor, n as MandatoryConsentState, o as mandatoryConsentMachine, r as createMandatoryConsentManager, s as MandatoryConsentConfig, t as MandatoryConsentManager } from "./mandatoryConsentManager-KfIlURRY.js";
+export { type MandatoryConsentActor, type MandatoryConsentConfig, type MandatoryConsentManager, type MandatoryConsentState, createMandatoryConsentManager, createMandatoryConsentManagerFromActor, mandatoryConsentMachine };

package/dist/mandatory-consent.esm.js

@@ -1,78 +1,8 @@
 import "./api-CESGtpbH.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import { c as createManager, s as createActor } from "./xstate.esm-B70JrNqo.esm.js";
-import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-Cnco1jvn.esm.js";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./xstate.esm-C9wncMQa.esm.js";
+import { t as mandatoryConsentMachine } from "./mandatoryConsentStateMachine-DtQNW1ji.esm.js";
+import { n as createMandatoryConsentManagerFromActor, t as createMandatoryConsentManager } from "./mandatoryConsentManager-H6D18cZB.esm.js";
 
-//#region src/modules/mandatory-consent/mandatoryConsentActor.ts
-function createMandatoryConsentActor(options) {
-	return createActor(mandatoryConsentMachine, { input: { config: options.config } }).start();
-}
-
-//#endregion
-//#region src/modules/mandatory-consent/mandatoryConsentManager.ts
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	const { context } = typedSnapshot;
-	const canSubmit = Boolean(context.isSigned && context.consent?.id);
-	if (typedSnapshot.matches("idle")) return { status: "idle" };
-	if (typedSnapshot.matches("loading")) return { status: "loading" };
-	if (typedSnapshot.matches("display")) return {
-		status: "display",
-		title: context.consent?.title ?? "",
-		text: context.consent?.text ?? "",
-		isSigned: context.isSigned,
-		canSubmit,
-		error: context.error
-	};
-	if (typedSnapshot.matches("submitting")) return {
-		status: "submitting",
-		title: context.consent?.title ?? "",
-		text: context.consent?.text ?? "",
-		isSigned: context.isSigned,
-		canSubmit: false
-	};
-	if (typedSnapshot.matches("finished")) return { status: "finished" };
-	if (typedSnapshot.matches("closed")) return { status: "closed" };
-	if (typedSnapshot.matches("error")) return {
-		status: "error",
-		error: context.error ?? "Unknown error"
-	};
-	return { status: "idle" };
-}
-function createApi({ actor, trackElementClicked }) {
-	return {
-		load() {
-			actor.send({ type: "LOAD" });
-		},
-		toggle() {
-			actor.send({ type: "TOGGLE" });
-		},
-		submit() {
-			trackElementClicked?.("submit");
-			actor.send({ type: "SUBMIT" });
-		},
-		cancel() {
-			trackElementClicked?.("cancel");
-			actor.send({ type: "CANCEL" });
-		},
-		retry() {
-			trackElementClicked?.("retry");
-			actor.send({ type: "RETRY" });
-		},
-		reset() {
-			actor.send({ type: "RESET" });
-		}
-	};
-}
-function createMandatoryConsentManager(options) {
-	return createManager({
-		actor: createMandatoryConsentActor(options),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.mlConsent)
-	});
-}
-
-//#endregion
-export { createMandatoryConsentManager, mandatoryConsentMachine };
+export { createMandatoryConsentManager, createMandatoryConsentManagerFromActor, mandatoryConsentMachine };

package/dist/mandatoryConsentManager-H6D18cZB.esm.js

@@ -0,0 +1,89 @@
+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 mandatoryConsentMachine } from "./mandatoryConsentStateMachine-DtQNW1ji.esm.js";
+
+//#region src/modules/mandatory-consent/mandatoryConsentActor.ts
+function createMandatoryConsentActor(options) {
+	return createActor(mandatoryConsentMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/mandatory-consent/mandatoryConsentManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	const canSubmit = Boolean(context.isSigned && context.consent?.id);
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loading")) return { status: "loading" };
+	if (typedSnapshot.matches("display")) return {
+		status: "display",
+		title: context.consent?.title ?? "",
+		text: context.consent?.text ?? "",
+		isSigned: context.isSigned,
+		canSubmit,
+		error: context.error
+	};
+	if (typedSnapshot.matches("submitting")) return {
+		status: "submitting",
+		title: context.consent?.title ?? "",
+		text: context.consent?.text ?? "",
+		isSigned: context.isSigned,
+		canSubmit: false
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	if (typedSnapshot.matches("closed")) return { status: "closed" };
+	if (typedSnapshot.matches("error")) return {
+		status: "error",
+		error: context.error ?? "Unknown error"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor, trackElementClicked }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		toggle() {
+			actor.send({ type: "TOGGLE" });
+		},
+		submit() {
+			trackElementClicked?.("submit");
+			actor.send({ type: "SUBMIT" });
+		},
+		cancel() {
+			trackElementClicked?.("cancel");
+			actor.send({ type: "CANCEL" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+function createMandatoryConsentManager(options) {
+	return createManager({
+		actor: createMandatoryConsentActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.mlConsent)
+	});
+}
+/**
+* Creates a mandatory-consent manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createMandatoryConsentManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.mlConsent)
+	});
+}
+
+//#endregion
+export { createMandatoryConsentManagerFromActor as n, createMandatoryConsentManager as t };