@incodetech/core 2.2.0 → 2.3.0-rc.0

package/dist/certificateIssuanceManager-Bfvkq7Cy.esm.js

@@ -0,0 +1,69 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
+import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
+import { r as isPasswordValid, t as certificateIssuanceMachine } from "./certificateIssuanceStateMachine-BBD5h8c4.esm.js";
+//#region src/modules/certificate-issuance/certificateIssuanceActor.ts
+/**
+* Creates and starts a certificate issuance actor.
+*/
+function createCertificateIssuanceActor(options) {
+	return createActor(certificateIssuanceMachine, { input: { config: options.config } }).start();
+}
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("password")) return {
+		status: "password",
+		password: context.password,
+		passwordValidations: context.passwordValidations,
+		canSubmit: isPasswordValid(context.passwordValidations)
+	};
+	if (typedSnapshot.matches("processing")) return { status: "processing" };
+	if (typedSnapshot.matches("error")) return { status: "error" };
+	if (typedSnapshot.matches("success")) return {
+		status: "success",
+		blob: context.certificateBlob
+	};
+	if (typedSnapshot.matches("downloaded")) return { status: "downloaded" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setPassword(password) {
+			actor.send({
+				type: "PASSWORD_CHANGED",
+				password
+			});
+		},
+		submitPassword() {
+			actor.send({ type: "SUBMIT_PASSWORD" });
+		},
+		markDownloaded() {
+			actor.send({ type: "DOWNLOADED" });
+		},
+		reportDownloadError() {
+			actor.send({ type: "DOWNLOAD_FAILED" });
+		},
+		finish() {
+			actor.send({ type: "FINISH" });
+		}
+	};
+}
+function createCertificateIssuanceManager(options) {
+	return createCertificateIssuanceManagerFromActor(createCertificateIssuanceActor(options));
+}
+function createCertificateIssuanceManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.certificateIssuance)
+	});
+}
+//#endregion
+export { createCertificateIssuanceManagerFromActor as n, createCertificateIssuanceManager as t };

package/dist/certificateIssuanceManager-DCgEidHz.d.ts

@@ -0,0 +1,312 @@
+import { A as StateMachine, C as StateValue, D as PromiseActorLogic, a as ActorRefFromLogic, b as RequiredActorOptions, c as AnyEventObject, g as IsNotNever, h as InputFrom, i as ActorRefFrom, k as MachineSnapshot, m as GetConcreteByKey, o as AnyActorLogic, p as EventObject, r as ActorRef, s as AnyActorRef, u as ConditionalRequired, v as MetaObject, w as Values, x as RequiredLogicInput, y as NonReducibleUnknown } from "./spawn-D9jgw9pW.js";
+import "./StateMachine-EDpYWy0i.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+//#region src/modules/certificate-issuance/certificateIssuanceConstants.d.ts
+declare const MIN_PASSWORD_LENGTH = 8;
+declare const PASSWORD_VALIDATION_KEYS: readonly ["length", "uppercase", "lowercase", "number"];
+declare const REQUIREMENT_I18N_KEYS: Record<PasswordValidationKey, string>;
+//#endregion
+//#region src/modules/certificate-issuance/types.d.ts
+type CertificateIssuanceType = 'ONE_TIME' | 'SHORT_TERM' | 'LONG_TERM';
+/**
+ * Configuration for the certificate issuance module.
+ */
+type CertificateIssuanceConfig = {
+  /** Issuance region (from flow `moduleConfiguration`) */
+  region: string;
+  /** Certificate validity period */
+  type: CertificateIssuanceType;
+};
+type IssueCertificateResponse = {
+  blob: Blob;
+};
+type PasswordValidations = {
+  length: boolean;
+  uppercase: boolean;
+  lowercase: boolean;
+  number: boolean;
+};
+type PasswordValidationKey = (typeof PASSWORD_VALIDATION_KEYS)[number];
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceStateMachine.d.ts
+type CertificateIssuanceContext = {
+  config: CertificateIssuanceConfig;
+  password: string;
+  passwordValidations: PasswordValidations;
+  certificateBlob: Blob | undefined;
+};
+type CertificateIssuanceInput = {
+  config: CertificateIssuanceConfig;
+};
+declare const certificateIssuanceMachine: StateMachine<CertificateIssuanceContext, {
+  type: "LOAD";
+} | {
+  type: "PASSWORD_CHANGED";
+  password: string;
+} | {
+  type: "SUBMIT_PASSWORD";
+} | {
+  type: "DOWNLOADED";
+} | {
+  type: "DOWNLOAD_FAILED";
+} | {
+  type: "FINISH";
+}, {
+  [x: string]: ActorRefFromLogic<PromiseActorLogic<IssueCertificateResponse, {
+    password: string;
+  }, EventObject>> | undefined;
+}, {
+  src: "issueCertificate";
+  logic: PromiseActorLogic<IssueCertificateResponse, {
+    password: string;
+  }, EventObject>;
+  id: string | undefined;
+}, Values<{
+  setPassword: {
+    type: "setPassword";
+    params: NonReducibleUnknown;
+  };
+  setBlob: {
+    type: "setBlob";
+    params: NonReducibleUnknown;
+  };
+}>, {
+  type: "isPasswordValid";
+  params: unknown;
+}, never, "error" | "idle" | "processing" | "success" | "finished" | "password" | "downloaded", string, CertificateIssuanceInput, NonReducibleUnknown, EventObject, MetaObject, {
+  readonly id: "certificateIssuance";
+  readonly initial: "idle";
+  readonly context: ({ input }: {
+    spawn: {
+      <TSrc extends "issueCertificate">(logic: TSrc, ...[options]: {
+        src: "issueCertificate";
+        logic: PromiseActorLogic<IssueCertificateResponse, {
+          password: string;
+        }, EventObject>;
+        id: string | undefined;
+      } extends (infer T) ? T extends {
+        src: "issueCertificate";
+        logic: PromiseActorLogic<IssueCertificateResponse, {
+          password: string;
+        }, EventObject>;
+        id: string | undefined;
+      } ? T extends {
+        src: TSrc;
+      } ? ConditionalRequired<[options?: ({
+        id?: T["id"] | undefined;
+        systemId?: string;
+        input?: InputFrom<T["logic"]> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in RequiredActorOptions<T>]: unknown; }) | undefined], IsNotNever<RequiredActorOptions<T>>> : never : never : never): ActorRefFromLogic<GetConcreteByKey<{
+        src: "issueCertificate";
+        logic: PromiseActorLogic<IssueCertificateResponse, {
+          password: string;
+        }, EventObject>;
+        id: string | undefined;
+      }, "src", TSrc>["logic"]>;
+      <TLogic extends AnyActorLogic>(src: TLogic, ...[options]: ConditionalRequired<[options?: ({
+        id?: never;
+        systemId?: string;
+        input?: InputFrom<TLogic> | undefined;
+        syncSnapshot?: boolean;
+      } & { [K in RequiredLogicInput<TLogic>]: unknown; }) | undefined], IsNotNever<RequiredLogicInput<TLogic>>>): ActorRefFromLogic<TLogic>;
+    };
+    input: CertificateIssuanceInput;
+    self: ActorRef<MachineSnapshot<CertificateIssuanceContext, {
+      type: "LOAD";
+    } | {
+      type: "PASSWORD_CHANGED";
+      password: string;
+    } | {
+      type: "SUBMIT_PASSWORD";
+    } | {
+      type: "DOWNLOADED";
+    } | {
+      type: "DOWNLOAD_FAILED";
+    } | {
+      type: "FINISH";
+    }, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, any, any>, {
+      type: "LOAD";
+    } | {
+      type: "PASSWORD_CHANGED";
+      password: string;
+    } | {
+      type: "SUBMIT_PASSWORD";
+    } | {
+      type: "DOWNLOADED";
+    } | {
+      type: "DOWNLOAD_FAILED";
+    } | {
+      type: "FINISH";
+    }, AnyEventObject>;
+  }) => {
+    config: CertificateIssuanceConfig;
+    password: string;
+    passwordValidations: PasswordValidations;
+    certificateBlob: undefined;
+  };
+  readonly states: {
+    readonly idle: {
+      readonly on: {
+        readonly LOAD: {
+          readonly target: "password";
+        };
+      };
+    };
+    readonly password: {
+      readonly on: {
+        readonly PASSWORD_CHANGED: {
+          readonly actions: "setPassword";
+        };
+        readonly SUBMIT_PASSWORD: {
+          readonly target: "processing";
+          readonly guard: "isPasswordValid";
+        };
+      };
+    };
+    readonly processing: {
+      readonly invoke: {
+        readonly id: "issueCertificate";
+        readonly src: "issueCertificate";
+        readonly input: ({ context }: {
+          context: CertificateIssuanceContext;
+          event: {
+            type: "LOAD";
+          } | {
+            type: "PASSWORD_CHANGED";
+            password: string;
+          } | {
+            type: "SUBMIT_PASSWORD";
+          } | {
+            type: "DOWNLOADED";
+          } | {
+            type: "DOWNLOAD_FAILED";
+          } | {
+            type: "FINISH";
+          };
+          self: ActorRef<MachineSnapshot<CertificateIssuanceContext, {
+            type: "LOAD";
+          } | {
+            type: "PASSWORD_CHANGED";
+            password: string;
+          } | {
+            type: "SUBMIT_PASSWORD";
+          } | {
+            type: "DOWNLOADED";
+          } | {
+            type: "DOWNLOAD_FAILED";
+          } | {
+            type: "FINISH";
+          }, Record<string, AnyActorRef>, StateValue, string, unknown, any, any>, {
+            type: "LOAD";
+          } | {
+            type: "PASSWORD_CHANGED";
+            password: string;
+          } | {
+            type: "SUBMIT_PASSWORD";
+          } | {
+            type: "DOWNLOADED";
+          } | {
+            type: "DOWNLOAD_FAILED";
+          } | {
+            type: "FINISH";
+          }, AnyEventObject>;
+        }) => {
+          password: string;
+        };
+        readonly onDone: {
+          readonly target: "success";
+          readonly actions: "setBlob";
+        };
+        readonly onError: {
+          readonly target: "error";
+        };
+      };
+    };
+    readonly success: {
+      readonly on: {
+        readonly DOWNLOADED: {
+          readonly target: "downloaded";
+        };
+        readonly DOWNLOAD_FAILED: {
+          readonly target: "error";
+        };
+        readonly FINISH: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly downloaded: {
+      readonly on: {
+        readonly FINISH: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly error: {
+      readonly after: {
+        readonly 3000: {
+          readonly target: "finished";
+        };
+      };
+    };
+    readonly finished: {
+      readonly type: "final";
+    };
+  };
+}>;
+type CertificateIssuanceMachine = typeof certificateIssuanceMachine;
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceActor.d.ts
+type CreateCertificateIssuanceActorOptions = {
+  config: CertificateIssuanceConfig;
+};
+type CertificateIssuanceActor = ActorRefFrom<CertificateIssuanceMachine>;
+//#endregion
+//#region src/modules/certificate-issuance/certificateIssuanceManager.d.ts
+type CertificateIssuanceIdleState = {
+  status: 'idle';
+};
+type CertificateIssuancePasswordState = {
+  status: 'password';
+  password: string;
+  passwordValidations: PasswordValidations;
+  canSubmit: boolean;
+};
+type CertificateIssuanceProcessingState = {
+  status: 'processing';
+};
+type CertificateIssuanceErrorState = {
+  status: 'error';
+};
+type CertificateIssuanceSuccessState = {
+  status: 'success';
+  blob: Blob;
+};
+type CertificateIssuanceDownloadedState = {
+  status: 'downloaded';
+};
+type CertificateIssuanceFinishedState = {
+  status: 'finished';
+};
+type CertificateIssuanceState = CertificateIssuanceIdleState | CertificateIssuancePasswordState | CertificateIssuanceProcessingState | CertificateIssuanceSuccessState | CertificateIssuanceDownloadedState | CertificateIssuanceErrorState | CertificateIssuanceFinishedState;
+declare function createCertificateIssuanceManager(options: CreateCertificateIssuanceActorOptions): Manager<CertificateIssuanceState> & {
+  load(): void;
+  setPassword(password: string): void;
+  submitPassword(): void;
+  markDownloaded(): void;
+  reportDownloadError(): void;
+  finish(): void;
+};
+declare function createCertificateIssuanceManagerFromActor(actor: CertificateIssuanceActor): Manager<CertificateIssuanceState> & {
+  load(): void;
+  setPassword(password: string): void;
+  submitPassword(): void;
+  markDownloaded(): void;
+  reportDownloadError(): void;
+  finish(): void;
+};
+type CertificateIssuanceManager = ReturnType<typeof createCertificateIssuanceManager>;
+//#endregion
+export { CertificateIssuanceActor as a, CertificateIssuanceType as c, PasswordValidations as d, MIN_PASSWORD_LENGTH as f, createCertificateIssuanceManagerFromActor as i, IssueCertificateResponse as l, REQUIREMENT_I18N_KEYS as m, CertificateIssuanceState as n, certificateIssuanceMachine as o, PASSWORD_VALIDATION_KEYS as p, createCertificateIssuanceManager as r, CertificateIssuanceConfig as s, CertificateIssuanceManager as t, PasswordValidationKey as u };

package/dist/{certificateIssuanceStateMachine-D_R92TYu.esm.js → certificateIssuanceStateMachine-BBD5h8c4.esm.js}

@@ -1,5 +1,5 @@
 import { n as getApi, r as getToken } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
 import { i as assign, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 import { t as externalFetch } from "./externalFetch-BKBThAUC.esm.js";

package/dist/consent.d.ts

@@ -1,2 +1,2 @@
-import { a as ConsentActor, c as ConsentConfig, i as createConsentManagerFromActor, n as ConsentState, o as consentMachine, r as createConsentManager, s as ConsentCheckbox, t as ConsentManager } from "./consentManager-3Pbtj-RV.js";
+import { a as ConsentActor, c as ConsentConfig, i as createConsentManagerFromActor, n as ConsentState, o as consentMachine, r as createConsentManager, s as ConsentCheckbox, t as ConsentManager } from "./consentManager-uhDPdU6i.js";
 export { type ConsentActor, type ConsentCheckbox, type ConsentConfig, type ConsentManager, type ConsentState, consentMachine, createConsentManager, createConsentManagerFromActor };

package/dist/consent.esm.js

@@ -1,3 +1,3 @@
-import { t as consentMachine } from "./consentStateMachine-D9D4ON8Z.esm.js";
-import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-BxjpLZAG.esm.js";
+import { t as consentMachine } from "./consentStateMachine-DbUmqWgV.esm.js";
+import { n as createConsentManagerFromActor, t as createConsentManager } from "./consentManager-B5Vqdez-.esm.js";
 export { consentMachine, createConsentManager, createConsentManagerFromActor };

package/dist/{consentManager-BxjpLZAG.esm.js → consentManager-B5Vqdez-.esm.js}

@@ -1,7 +1,7 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-ijlbX_Wx.esm.js";
 import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
 import { s as createActor, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { t as consentMachine } from "./consentStateMachine-D9D4ON8Z.esm.js";
+import { t as consentMachine } from "./consentStateMachine-DbUmqWgV.esm.js";
 //#region src/modules/consent/consentActor.ts
 function createConsentActor(options) {
 	return createActor(consentMachine, { input: { config: options.config } }).start();

package/dist/{consentManager-3Pbtj-RV.d.ts → consentManager-uhDPdU6i.d.ts}

@@ -82,6 +82,10 @@ declare const consentMachine: StateMachine<ConsentContext, {
     type: "clearError";
     params: NonReducibleUnknown;
   };
+  resetContext: {
+    type: "resetContext";
+    params: NonReducibleUnknown;
+  };
   setConsentData: {
     type: "setConsentData";
     params: NonReducibleUnknown;
@@ -90,10 +94,6 @@ declare const consentMachine: StateMachine<ConsentContext, {
     type: "toggleCheckbox";
     params: NonReducibleUnknown;
   };
-  resetContext: {
-    type: "resetContext";
-    params: NonReducibleUnknown;
-  };
 }>, {
   type: "canSubmit";
   params: unknown;

package/dist/{consentStateMachine-D9D4ON8Z.esm.js → consentStateMachine-DbUmqWgV.esm.js}

@@ -1,5 +1,5 @@
 import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { t as endpoints } from "./endpoints-D3B9mUHh.esm.js";
 import { i as assign, t as setup } from "./xstate.esm-BuFLFuzz.esm.js";
 import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
 //#region src/modules/consent/consentServices.ts