@incodetech/core 2.0.0-rc.0 → 2.0.0

package/dist/mandatory-consent.d.ts

@@ -1,412 +0,0 @@
-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 xstate16 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: xstate16.StateMachine<MandatoryConsentContext, {
-  type: "LOAD";
-} | {
-  type: "TOGGLE";
-} | {
-  type: "SUBMIT";
-} | {
-  type: "CANCEL";
-} | {
-  type: "RETRY";
-} | {
-  type: "RESET";
-}, {
-  [x: string]: xstate16.ActorRefFromLogic<xstate16.PromiseActorLogic<FetchMandatoryConsentResponse, {
-    config: MandatoryConsentConfig;
-  }, xstate16.EventObject>> | xstate16.ActorRefFromLogic<xstate16.PromiseActorLogic<void, {
-    consentId: string;
-    isSigned: boolean;
-  }, xstate16.EventObject>> | undefined;
-}, xstate16.Values<{
-  fetchConsent: {
-    src: "fetchConsent";
-    logic: xstate16.PromiseActorLogic<FetchMandatoryConsentResponse, {
-      config: MandatoryConsentConfig;
-    }, xstate16.EventObject>;
-    id: string | undefined;
-  };
-  submitConsent: {
-    src: "submitConsent";
-    logic: xstate16.PromiseActorLogic<void, {
-      consentId: string;
-      isSigned: boolean;
-    }, xstate16.EventObject>;
-    id: string | undefined;
-  };
-}>, xstate16.Values<{
-  setConsent: {
-    type: "setConsent";
-    params: xstate16.NonReducibleUnknown;
-  };
-  toggleSigned: {
-    type: "toggleSigned";
-    params: xstate16.NonReducibleUnknown;
-  };
-  setError: {
-    type: "setError";
-    params: xstate16.NonReducibleUnknown;
-  };
-  clearError: {
-    type: "clearError";
-    params: xstate16.NonReducibleUnknown;
-  };
-  resetContext: {
-    type: "resetContext";
-    params: xstate16.NonReducibleUnknown;
-  };
-}>, {
-  type: "canSubmit";
-  params: unknown;
-}, never, "error" | "idle" | "closed" | "finished" | "loading" | "display" | "submitting", string, MandatoryConsentInput, xstate16.NonReducibleUnknown, xstate16.EventObject, xstate16.MetaObject, {
-  readonly id: "mandatoryConsent";
-  readonly initial: "idle";
-  readonly context: ({
-    input
-  }: {
-    spawn: {
-      <TSrc extends "fetchConsent" | "submitConsent">(logic: TSrc, ...[options]: ({
-        src: "fetchConsent";
-        logic: xstate16.PromiseActorLogic<FetchMandatoryConsentResponse, {
-          config: MandatoryConsentConfig;
-        }, xstate16.EventObject>;
-        id: string | undefined;
-      } extends infer T ? T extends {
-        src: "fetchConsent";
-        logic: xstate16.PromiseActorLogic<FetchMandatoryConsentResponse, {
-          config: MandatoryConsentConfig;
-        }, xstate16.EventObject>;
-        id: string | undefined;
-      } ? T extends {
-        src: TSrc;
-      } ? xstate16.ConditionalRequired<[options?: ({
-        id?: T["id"] | undefined;
-        systemId?: string;
-        input?: xstate16.InputFrom<T["logic"]> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K in xstate16.RequiredActorOptions<T>]: unknown }) | undefined], xstate16.IsNotNever<xstate16.RequiredActorOptions<T>>> : never : never : never) | ({
-        src: "submitConsent";
-        logic: xstate16.PromiseActorLogic<void, {
-          consentId: string;
-          isSigned: boolean;
-        }, xstate16.EventObject>;
-        id: string | undefined;
-      } extends infer T_1 ? T_1 extends {
-        src: "submitConsent";
-        logic: xstate16.PromiseActorLogic<void, {
-          consentId: string;
-          isSigned: boolean;
-        }, xstate16.EventObject>;
-        id: string | undefined;
-      } ? T_1 extends {
-        src: TSrc;
-      } ? xstate16.ConditionalRequired<[options?: ({
-        id?: T_1["id"] | undefined;
-        systemId?: string;
-        input?: xstate16.InputFrom<T_1["logic"]> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K_1 in xstate16.RequiredActorOptions<T_1>]: unknown }) | undefined], xstate16.IsNotNever<xstate16.RequiredActorOptions<T_1>>> : never : never : never)): xstate16.ActorRefFromLogic<xstate16.GetConcreteByKey<xstate16.Values<{
-        fetchConsent: {
-          src: "fetchConsent";
-          logic: xstate16.PromiseActorLogic<FetchMandatoryConsentResponse, {
-            config: MandatoryConsentConfig;
-          }, xstate16.EventObject>;
-          id: string | undefined;
-        };
-        submitConsent: {
-          src: "submitConsent";
-          logic: xstate16.PromiseActorLogic<void, {
-            consentId: string;
-            isSigned: boolean;
-          }, xstate16.EventObject>;
-          id: string | undefined;
-        };
-      }>, "src", TSrc>["logic"]>;
-      <TLogic extends xstate16.AnyActorLogic>(src: TLogic, ...[options]: xstate16.ConditionalRequired<[options?: ({
-        id?: never;
-        systemId?: string;
-        input?: xstate16.InputFrom<TLogic> | undefined;
-        syncSnapshot?: boolean;
-      } & { [K in xstate16.RequiredLogicInput<TLogic>]: unknown }) | undefined], xstate16.IsNotNever<xstate16.RequiredLogicInput<TLogic>>>): xstate16.ActorRefFromLogic<TLogic>;
-    };
-    input: MandatoryConsentInput;
-    self: xstate16.ActorRef<xstate16.MachineSnapshot<MandatoryConsentContext, {
-      type: "LOAD";
-    } | {
-      type: "TOGGLE";
-    } | {
-      type: "SUBMIT";
-    } | {
-      type: "CANCEL";
-    } | {
-      type: "RETRY";
-    } | {
-      type: "RESET";
-    }, Record<string, xstate16.AnyActorRef | undefined>, xstate16.StateValue, string, unknown, any, any>, {
-      type: "LOAD";
-    } | {
-      type: "TOGGLE";
-    } | {
-      type: "SUBMIT";
-    } | {
-      type: "CANCEL";
-    } | {
-      type: "RETRY";
-    } | {
-      type: "RESET";
-    }, xstate16.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: xstate16.ActorRef<xstate16.MachineSnapshot<MandatoryConsentContext, {
-            type: "LOAD";
-          } | {
-            type: "TOGGLE";
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "CANCEL";
-          } | {
-            type: "RETRY";
-          } | {
-            type: "RESET";
-          }, Record<string, xstate16.AnyActorRef>, xstate16.StateValue, string, unknown, any, any>, {
-            type: "LOAD";
-          } | {
-            type: "TOGGLE";
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "CANCEL";
-          } | {
-            type: "RETRY";
-          } | {
-            type: "RESET";
-          }, xstate16.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: xstate16.ActorRef<xstate16.MachineSnapshot<MandatoryConsentContext, {
-            type: "LOAD";
-          } | {
-            type: "TOGGLE";
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "CANCEL";
-          } | {
-            type: "RETRY";
-          } | {
-            type: "RESET";
-          }, Record<string, xstate16.AnyActorRef>, xstate16.StateValue, string, unknown, any, any>, {
-            type: "LOAD";
-          } | {
-            type: "TOGGLE";
-          } | {
-            type: "SUBMIT";
-          } | {
-            type: "CANCEL";
-          } | {
-            type: "RETRY";
-          } | {
-            type: "RESET";
-          }, xstate16.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 };

package/dist/mandatory-consent.esm.js

@@ -1,78 +0,0 @@
-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";
-
-//#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 };

package/dist/mandatoryConsentStateMachine-Cnco1jvn.esm.js

@@ -1,126 +0,0 @@
-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";
-
-//#region src/modules/mandatory-consent/mandatoryConsentServices.ts
-async function fetchMandatoryConsent(regulationType, signal) {
-	const res = await api.get(endpoints.getConsents, {
-		signal,
-		query: {
-			type: "MANDATORY",
-			language: "en",
-			regulationType
-		}
-	});
-	if (!res.ok) throw new Error(`GET ${endpoints.getConsents} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-async function submitMandatoryConsent(params, signal) {
-	const res = await api.post(endpoints.submitMlConsent, params, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.submitMlConsent} failed: ${res.status} ${res.statusText}`);
-}
-
-//#endregion
-//#region src/modules/mandatory-consent/mandatoryConsentStateMachine.ts
-const mandatoryConsentMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: {
-		fetchConsent: fromPromise(async ({ input, signal }) => fetchMandatoryConsent(input.config.consentType, signal)),
-		submitConsent: fromPromise(async ({ input, signal }) => submitMandatoryConsent({ consents: [{
-			id: input.consentId,
-			isSigned: input.isSigned
-		}] }, signal))
-	},
-	actions: {
-		setConsent: assign(({ event }) => {
-			return {
-				consent: event.output.consents[0],
-				isSigned: false,
-				error: void 0
-			};
-		}),
-		toggleSigned: assign(({ context }) => ({ isSigned: !context.isSigned })),
-		setError: assign(({ event }) => ({ error: String(event.error) })),
-		clearError: assign({ error: () => void 0 }),
-		resetContext: assign(({ context }) => ({
-			config: context.config,
-			consent: void 0,
-			isSigned: false,
-			error: void 0
-		}))
-	},
-	guards: { canSubmit: ({ context }) => Boolean(context.consent?.id) && context.isSigned }
-}).createMachine({
-	id: "mandatoryConsent",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		consent: void 0,
-		isSigned: false,
-		error: void 0
-	}),
-	states: {
-		idle: { on: { LOAD: {
-			target: "loading",
-			actions: "clearError"
-		} } },
-		loading: { invoke: {
-			id: "fetchConsent",
-			src: "fetchConsent",
-			input: ({ context }) => ({ config: context.config }),
-			onDone: {
-				target: "display",
-				actions: "setConsent"
-			},
-			onError: {
-				target: "error",
-				actions: "setError"
-			}
-		} },
-		display: { on: {
-			TOGGLE: { actions: "toggleSigned" },
-			SUBMIT: {
-				target: "submitting",
-				guard: "canSubmit"
-			},
-			CANCEL: { target: "closed" },
-			RETRY: {
-				target: "loading",
-				actions: "clearError"
-			}
-		} },
-		submitting: { invoke: {
-			id: "submitConsent",
-			src: "submitConsent",
-			input: ({ context }) => ({
-				consentId: context.consent?.id ?? "",
-				isSigned: context.isSigned
-			}),
-			onDone: { target: "finished" },
-			onError: {
-				target: "display",
-				actions: "setError"
-			}
-		} },
-		error: { on: {
-			RETRY: {
-				target: "loading",
-				actions: "clearError"
-			},
-			CANCEL: { target: "closed" },
-			RESET: {
-				target: "idle",
-				actions: "resetContext"
-			}
-		} },
-		finished: { type: "final" },
-		closed: { type: "final" }
-	}
-});
-
-//#endregion
-export { mandatoryConsentMachine as t };

package/dist/openviduLazy-Cm0XFh_v.esm.js

@@ -1,3 +0,0 @@
-import { t as loadOpenVidu } from "./openviduLazy-Cok70ZSg.esm.js";
-
-export { loadOpenVidu };

package/dist/openviduLazy-Cok70ZSg.esm.js

@@ -1,12 +0,0 @@
-import { a as __toDynamicImportESM } from "./chunk-CRF6K_H_.esm.js";
-
-//#region ../infra/src/providers/browser/openviduLazy.ts
-let openViduImport;
-async function loadOpenVidu() {
-	if (openViduImport) return openViduImport;
-	openViduImport = import("./lib-BB0B_qQX.esm.js").then(__toDynamicImportESM(1));
-	return openViduImport;
-}
-
-//#endregion
-export { loadOpenVidu as t };

package/dist/permissionServices-D_i6nzEw.esm.js

@@ -1,50 +0,0 @@
-import { i as stopCameraStream, r as requestCameraAccess } from "./camera-PA2Ljri3.esm.js";
-import { t as MotionSensorProvider } from "./MotionSensorProvider-4v7xkqAp.esm.js";
-
-//#region ../infra/src/media/permissions.ts
-async function queryPermission(name) {
-	try {
-		if (typeof navigator === "undefined" || !navigator.permissions) return "prompt";
-		return (await navigator.permissions.query({ name })).state;
-	} catch {
-		return "prompt";
-	}
-}
-async function queryCameraPermission() {
-	return queryPermission("camera");
-}
-
-//#endregion
-//#region src/internal/permissions/permissionServices.ts
-async function checkPermission() {
-	const queryResult = await queryCameraPermission();
-	if (queryResult === "granted") return "granted";
-	if (queryResult === "denied") return "denied";
-	return "prompt";
-}
-/**
-* Requests motion sensor permission. Must be called during a user gesture on iOS.
-* Returns the permission result.
-*/
-async function requestMotionPermission() {
-	return new MotionSensorProvider().requestPermission();
-}
-/**
-* Requests camera permission by attempting to access the camera, then immediately
-* stops the obtained stream. Also requests motion sensor permission (required on iOS
-* to be called during a user gesture). This function does not keep or return the stream.
-*/
-async function requestPermission(options = {}) {
-	try {
-		if (options.requestMotion) await requestMotionPermission();
-		stopCameraStream(await requestCameraAccess({ video: true }));
-		return "granted";
-	} catch (error) {
-		const name = error instanceof Error ? error.name : void 0;
-		if (name === "NotAllowedError" || name === "PermissionDeniedError") return "denied";
-		return "prompt";
-	}
-}
-
-//#endregion
-export { requestPermission as n, checkPermission as t };

package/dist/phone.d.ts

@@ -1,4 +0,0 @@
-import "./Manager-C8PrhBOx.js";
-import "./Actor-CI32dTbG.js";
-import { a as phoneMachine, n as PhoneState, o as PhoneConfig, r as createPhoneManager, t as PhoneManager } from "./phoneManager-B6M30hKE.js";
-export { type PhoneConfig, type PhoneManager, type PhoneState, createPhoneManager, phoneMachine };

package/dist/phone.esm.js

@@ -1,9 +0,0 @@
-import "./BrowserTimerProvider-DhNc_x02.esm.js";
-import "./api-CESGtpbH.esm.js";
-import "./events-D6-e4vok.esm.js";
-import "./endpoints-CnN3SyDa.esm.js";
-import "./xstate.esm-B70JrNqo.esm.js";
-import { t as phoneMachine } from "./phoneStateMachine-CuPARRaT.esm.js";
-import { t as createPhoneManager } from "./phoneManager-DAJbGhlY.esm.js";
-
-export { createPhoneManager, phoneMachine };