@incodetech/core 2.0.1 → 2.1.0-rc.0

package/dist/consent.esm.js

@@ -1,79 +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 consentMachine } from "./consentStateMachine-CCT-B60O.esm.js";
+import "./events-Dvvriq9l.esm.js";
+import "./endpoints-BeTK0Mlt.esm.js";
+import "./xstate.esm-C9wncMQa.esm.js";
+import { t as consentMachine } from "./consentStateMachine-BG3yL8aC.esm.js";
+import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-BYo9Nu1r.esm.js";
 
-//#region src/modules/consent/consentActor.ts
-function createConsentActor(options) {
-	return createActor(consentMachine, { input: { config: options.config } }).start();
-}
-
-//#endregion
-//#region src/modules/consent/consentManager.ts
-function getCanSubmit(checkboxes) {
-	return checkboxes.filter((checkbox) => checkbox.required).every((checkbox) => checkbox.checked);
-}
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	const { context } = typedSnapshot;
-	const canSubmit = getCanSubmit(context.checkboxes);
-	if (typedSnapshot.matches("idle")) return { status: "idle" };
-	if (typedSnapshot.matches("loading")) return { status: "loading" };
-	if (typedSnapshot.matches("display")) return {
-		status: "display",
-		title: context.title,
-		richText: context.richText,
-		checkboxes: context.checkboxes,
-		canSubmit,
-		error: context.error
-	};
-	if (typedSnapshot.matches("submitting")) return {
-		status: "submitting",
-		title: context.title,
-		richText: context.richText,
-		checkboxes: context.checkboxes,
-		canSubmit: false
-	};
-	if (typedSnapshot.matches("finished")) return { status: "finished" };
-	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" });
-		},
-		toggleCheckbox(checkboxId) {
-			actor.send({
-				type: "TOGGLE_CHECKBOX",
-				checkboxId
-			});
-		},
-		submit() {
-			trackElementClicked?.("submit");
-			actor.send({ type: "SUBMIT" });
-		},
-		retry() {
-			trackElementClicked?.("retry");
-			actor.send({ type: "RETRY" });
-		},
-		reset() {
-			actor.send({ type: "RESET" });
-		}
-	};
-}
-function createConsentManager(options) {
-	return createManager({
-		actor: createConsentActor(options),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.combinedConsent)
-	});
-}
-
-//#endregion
-export { consentMachine, createConsentManager };
+export { consentMachine, createConsentManager, createConsentManagerFromActor };

package/dist/consentManager-BLd51QiW.d.ts

@@ -0,0 +1,419 @@
+import { t as Manager } from "./Manager-BHn8wH8K.js";
+import { t as ActorRefFrom } from "./Actor-Y0_Fj-KL.js";
+import * as xstate1044 from "xstate";
+
+//#region src/modules/consent/types.d.ts
+type ConsentConfig = {
+  combinedConsents?: string;
+  consentId?: string;
+  language?: 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: xstate1044.StateMachine<ConsentContext, {
+  type: "LOAD";
+} | {
+  type: "TOGGLE_CHECKBOX";
+  checkboxId: string;
+} | {
+  type: "SUBMIT";
+} | {
+  type: "RETRY";
+} | {
+  type: "RESET";
+}, {
+  [x: string]: xstate1044.ActorRefFromLogic<xstate1044.PromiseActorLogic<FetchCombinedConsentResponse, {
+    consentId: string;
+    language?: string;
+  }, xstate1044.EventObject>> | xstate1044.ActorRefFromLogic<xstate1044.PromiseActorLogic<void, {
+    languageConsentId: string;
+    checkboxes: ConsentCheckbox[];
+  }, xstate1044.EventObject>> | undefined;
+}, xstate1044.Values<{
+  fetchConsent: {
+    src: "fetchConsent";
+    logic: xstate1044.PromiseActorLogic<FetchCombinedConsentResponse, {
+      consentId: string;
+      language?: string;
+    }, xstate1044.EventObject>;
+    id: string | undefined;
+  };
+  submitConsent: {
+    src: "submitConsent";
+    logic: xstate1044.PromiseActorLogic<void, {
+      languageConsentId: string;
+      checkboxes: ConsentCheckbox[];
+    }, xstate1044.EventObject>;
+    id: string | undefined;
+  };
+}>, xstate1044.Values<{
+  setError: {
+    type: "setError";
+    params: xstate1044.NonReducibleUnknown;
+  };
+  clearError: {
+    type: "clearError";
+    params: xstate1044.NonReducibleUnknown;
+  };
+  resetContext: {
+    type: "resetContext";
+    params: xstate1044.NonReducibleUnknown;
+  };
+  setConsentData: {
+    type: "setConsentData";
+    params: xstate1044.NonReducibleUnknown;
+  };
+  toggleCheckbox: {
+    type: "toggleCheckbox";
+    params: xstate1044.NonReducibleUnknown;
+  };
+}>, {
+  type: "canSubmit";
+  params: unknown;
+}, never, "error" | "idle" | "finished" | "loading" | "submitting" | "display", string, ConsentInput, xstate1044.NonReducibleUnknown, xstate1044.EventObject, xstate1044.MetaObject, {
+  readonly id: "consent";
+  readonly initial: "idle";
+  readonly context: ({
+    input
+  }: {
+    spawn: {
+      <TSrc extends "fetchConsent" | "submitConsent">(logic: TSrc, ...[options]: ({
+        src: "fetchConsent";
+        logic: xstate1044.PromiseActorLogic<FetchCombinedConsentResponse, {
+          consentId: string;
+          language?: string;
+        }, xstate1044.EventObject>;
+        id: string | undefined;
+      } extends infer T ? T extends {
+        src: "fetchConsent";
+        logic: xstate1044.PromiseActorLogic<FetchCombinedConsentResponse, {
+          consentId: string;
+          language?: string;
+        }, xstate1044.EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? xstate1044.ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: xstate1044.InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate1044.RequiredActorOptions<T>]: unknown }) | undefined], xstate1044.IsNotNever<xstate1044.RequiredActorOptions<T>>> : never : never : never) | ({
+        src: "submitConsent";
+        logic: xstate1044.PromiseActorLogic<void, {
+          languageConsentId: string;
+          checkboxes: ConsentCheckbox[];
+        }, xstate1044.EventObject>;
+        id: string | undefined;
+      } extends infer T_1 ? T_1 extends {
+        src: "submitConsent";
+        logic: xstate1044.PromiseActorLogic<void, {
+          languageConsentId: string;
+          checkboxes: ConsentCheckbox[];
+        }, xstate1044.EventObject>;
+        id: string | undefined;
+      } ? T_1 extends {
+        src: TSrc;
+      } ? xstate1044.ConditionalRequired<[options?: ({
+        id?: T_1["id"] | undefined;
+        systemId?: string;
+        input?: xstate1044.InputFrom<T_1["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K_1 in xstate1044.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate1044.IsNotNever<xstate1044.RequiredActorOptions<T_1>>> : never : never : never)): xstate1044.ActorRefFromLogic<xstate1044.GetConcreteByKey<xstate1044.Values<{
+        fetchConsent: {
+          src: "fetchConsent";
+          logic: xstate1044.PromiseActorLogic<FetchCombinedConsentResponse, {
+            consentId: string;
+            language?: string;
+          }, xstate1044.EventObject>;
+          id: string | undefined;
+        };
+        submitConsent: {
+          src: "submitConsent";
+          logic: xstate1044.PromiseActorLogic<void, {
+            languageConsentId: string;
+            checkboxes: ConsentCheckbox[];
+          }, xstate1044.EventObject>;
+          id: string | undefined;
+        };
+      }>, "src", TSrc>["logic"]>;
+      <TLogic extends xstate1044.AnyActorLogic>(src: TLogic, ...[options]: xstate1044.ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: xstate1044.InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in xstate1044.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate1044.IsNotNever<xstate1044.RequiredLogicInput<TLogic>>>): xstate1044.ActorRefFromLogic<TLogic>;
+    };
+    input: ConsentInput;
+    self: xstate1044.ActorRef<xstate1044.MachineSnapshot<ConsentContext, {
+      type: "LOAD";
+    } | {
+      type: "TOGGLE_CHECKBOX";
+      checkboxId: string;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "RESET";
+    }, Record<string, xstate1044.AnyActorRef | undefined>, xstate1044.StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "TOGGLE_CHECKBOX";
+      checkboxId: string;
+    } | {
+      type: "SUBMIT";
+    } | {
+      type: "RETRY";
+    } | {
+      type: "RESET";
+    }, xstate1044.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: xstate1044.ActorRef<xstate1044.MachineSnapshot<ConsentContext, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, Record<string, xstate1044.AnyActorRef>, xstate1044.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, xstate1044.AnyEventObject>;
+        }) => {
+          consentId: string;
+          language: string | undefined;
+        };
+        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: xstate1044.ActorRef<xstate1044.MachineSnapshot<ConsentContext, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, Record<string, xstate1044.AnyActorRef>, xstate1044.StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "TOGGLE_CHECKBOX";
+            checkboxId: string;
+          } | {
+            type: "SUBMIT";
+          } | {
+            type: "RETRY";
+          } | {
+            type: "RESET";
+          }, xstate1044.AnyEventObject>;
+        }) => {
+          languageConsentId: string;
+          checkboxes: ConsentCheckbox[];
+        };
+        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 RESET: {
+          readonly target: "idle";
+          readonly actions: "resetContext";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+type ConsentMachine = typeof consentMachine;
+//#endregion
+//#region src/modules/consent/consentActor.d.ts
+type CreateConsentActorOptions = {
+  config: ConsentConfig;
+};
+type ConsentActor = ActorRefFrom<ConsentMachine>;
+//#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;
+};
+/**
+ * Creates a consent manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends
+ * or for story-isolation testing.
+ */
+declare function createConsentManagerFromActor(actor: ConsentActor): Manager<ConsentState> & {
+  load(): void;
+  toggleCheckbox(checkboxId: string): void;
+  submit(): void;
+  retry(): void;
+  reset(): void;
+};
+type ConsentManager = ReturnType<typeof createConsentManager>;
+//#endregion
+export { ConsentActor as a, ConsentConfig as c, createConsentManagerFromActor as i, ConsentState as n, consentMachine as o, createConsentManager as r, ConsentCheckbox as s, ConsentManager as t };

package/dist/consentManager-BYo9Nu1r.esm.js

@@ -0,0 +1,90 @@
+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 consentMachine } from "./consentStateMachine-BG3yL8aC.esm.js";
+
+//#region src/modules/consent/consentActor.ts
+function createConsentActor(options) {
+	return createActor(consentMachine, { input: { config: options.config } }).start();
+}
+
+//#endregion
+//#region src/modules/consent/consentManager.ts
+function getCanSubmit(checkboxes) {
+	return checkboxes.filter((checkbox) => checkbox.required).every((checkbox) => checkbox.checked);
+}
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	const canSubmit = getCanSubmit(context.checkboxes);
+	if (typedSnapshot.matches("idle")) return { status: "idle" };
+	if (typedSnapshot.matches("loading")) return { status: "loading" };
+	if (typedSnapshot.matches("display")) return {
+		status: "display",
+		title: context.title,
+		richText: context.richText,
+		checkboxes: context.checkboxes,
+		canSubmit,
+		error: context.error
+	};
+	if (typedSnapshot.matches("submitting")) return {
+		status: "submitting",
+		title: context.title,
+		richText: context.richText,
+		checkboxes: context.checkboxes,
+		canSubmit: false
+	};
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	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" });
+		},
+		toggleCheckbox(checkboxId) {
+			actor.send({
+				type: "TOGGLE_CHECKBOX",
+				checkboxId
+			});
+		},
+		submit() {
+			trackElementClicked?.("submit");
+			actor.send({ type: "SUBMIT" });
+		},
+		retry() {
+			trackElementClicked?.("retry");
+			actor.send({ type: "RETRY" });
+		},
+		reset() {
+			actor.send({ type: "RESET" });
+		}
+	};
+}
+function createConsentManager(options) {
+	return createManager({
+		actor: createConsentActor(options),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.combinedConsent)
+	});
+}
+/**
+* Creates a consent manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends
+* or for story-isolation testing.
+*/
+function createConsentManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.combinedConsent)
+	});
+}
+
+//#endregion
+export { createConsentManagerFromActor as n, createConsentManager as t };

package/dist/{consentStateMachine-CCT-B60O.esm.js → consentStateMachine-BG3yL8aC.esm.js}

@@ -1,15 +1,15 @@
 import { t as api } from "./api-CESGtpbH.esm.js";
-import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
-import { a as fromPromise, 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, r as assign, t as setup } from "./xstate.esm-C9wncMQa.esm.js";
 
 //#region src/modules/consent/consentServices.ts
-async function fetchCombinedConsent(consentId, signal) {
+async function fetchCombinedConsent(consentId, language, signal) {
 	if (!consentId) throw new Error("Combined consent id is required");
 	const res = await api.get(endpoints.getCombinedConsent, {
 		signal,
 		query: {
 			id: consentId,
-			language: "en"
+			language: language ?? "en"
 		}
 	});
 	if (!res.ok) throw new Error(`GET ${endpoints.getCombinedConsent} failed: ${res.status} ${res.statusText}`);
@@ -36,7 +36,7 @@ const consentMachine = setup({
 	},
 	actors: {
 		fetchConsent: fromPromise(async ({ input, signal }) => {
-			return fetchCombinedConsent(input.consentId, signal);
+			return fetchCombinedConsent(input.consentId, input.language, signal);
 		}),
 		submitConsent: fromPromise(async ({ input, signal }) => {
 			await submitCombinedConsent({
@@ -99,7 +99,10 @@ const consentMachine = setup({
 		loading: { invoke: {
 			id: "fetchConsent",
 			src: "fetchConsent",
-			input: ({ context }) => ({ consentId: String(context.config.combinedConsents ?? context.config.consentId ?? "") }),
+			input: ({ context }) => ({
+				consentId: String(context.config.combinedConsents ?? context.config.consentId ?? ""),
+				language: context.config.language
+			}),
 			onDone: {
 				target: "display",
 				actions: "setConsentData"