@incodetech/core 2.0.0-alpha.8 → 2.0.0-rc.0

package/dist/watchlist-for-business.esm.js

@@ -0,0 +1,148 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+
+//#region src/modules/watchlist-for-business/watchlistForBusinessServices.ts
+async function submitWatchlistForBusiness(data, signal) {
+	const res = await api.post(endpoints.watchlistForBusinessSubmit, data, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.watchlistForBusinessSubmit} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+//#region src/modules/watchlist-for-business/watchlistForBusinessStateMachine.ts
+const DEFAULT_COUNTRY = "US";
+function computeIsValid(businessName) {
+	return businessName.trim().length > 0;
+}
+const watchlistForBusinessMachine = setup({
+	types: {
+		context: {},
+		events: {}
+	},
+	actors: { submitWatchlistForBusiness: fromPromise(async ({ input, signal }) => {
+		await submitWatchlistForBusiness(input, signal);
+	}) },
+	actions: {
+		setCountry: assign(({ event }) => {
+			const { country } = event;
+			return { country };
+		}),
+		setBusinessName: assign(({ event }) => {
+			const { value } = event;
+			return {
+				businessName: value,
+				isValid: computeIsValid(value)
+			};
+		})
+	},
+	guards: { isValid: ({ context }) => context.isValid }
+}).createMachine({
+	id: "watchlist-for-business",
+	initial: "idle",
+	context: {
+		country: DEFAULT_COUNTRY,
+		businessName: "",
+		isValid: false
+	},
+	states: {
+		idle: { on: { LOAD: { target: "form" } } },
+		form: { on: {
+			SET_COUNTRY: { actions: "setCountry" },
+			SET_BUSINESS_NAME: { actions: "setBusinessName" },
+			SUBMIT: {
+				target: "submitting",
+				guard: "isValid"
+			}
+		} },
+		submitting: { invoke: {
+			id: "submitWatchlistForBusiness",
+			src: "submitWatchlistForBusiness",
+			input: ({ context }) => ({
+				countryCodes: [context.country],
+				businessName: context.businessName
+			}),
+			onDone: { target: "success" },
+			onError: { target: "finished" }
+		} },
+		success: { after: { 3e3: { target: "finished" } } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/watchlist-for-business/watchlistForBusinessActor.ts
+function createWatchlistForBusinessActor() {
+	return createActor(watchlistForBusinessMachine).start();
+}
+
+//#endregion
+//#region src/modules/watchlist-for-business/watchlistForBusinessManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	const { context } = typedSnapshot;
+	if (typedSnapshot.matches("form")) return {
+		status: "form",
+		country: context.country,
+		businessName: context.businessName,
+		isValid: context.isValid
+	};
+	if (typedSnapshot.matches("submitting")) return { status: "submitting" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("finished")) return { status: "finished" };
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return {
+		load() {
+			actor.send({ type: "LOAD" });
+		},
+		setCountry(country) {
+			actor.send({
+				type: "SET_COUNTRY",
+				country
+			});
+		},
+		setBusinessName(value) {
+			actor.send({
+				type: "SET_BUSINESS_NAME",
+				value
+			});
+		},
+		submit() {
+			actor.send({ type: "SUBMIT" });
+		}
+	};
+}
+/**
+* Creates a watchlist-for-business manager for headless or UI-driven usage.
+*
+* On API error the module completes silently (fire-and-forget).
+*
+* @example Headless usage
+* ```typescript
+* import { createWatchlistForBusinessManager } from '@incodetech/core/watchlist-for-business';
+*
+* const manager = createWatchlistForBusinessManager();
+* manager.subscribe((state) => {
+*   if (state.status === 'finished') console.log('Done');
+* });
+* manager.load();
+* manager.setCountry('MX');
+* manager.setBusinessName('Acme Corp');
+* manager.submit();
+* manager.stop();
+* ```
+*/
+function createWatchlistForBusinessManager() {
+	return createManager({
+		actor: createWatchlistForBusinessActor(),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.watchlistForBusiness)
+	});
+}
+
+//#endregion
+export { createWatchlistForBusinessManager, watchlistForBusinessMachine };

package/dist/watchlist.d.ts

@@ -0,0 +1,62 @@
+import { t as Manager } from "./Manager-C8PrhBOx.js";
+
+//#region src/modules/watchlist/watchlistStateMachine.d.ts
+type WatchlistResult = 'success' | 'skipped';
+declare const watchlistMachine: any;
+//#endregion
+//#region src/modules/watchlist/watchlistManager.d.ts
+type WatchlistIdleState = {
+  status: 'idle';
+};
+type WatchlistProcessingState = {
+  status: 'processing';
+};
+type WatchlistSuccessState = {
+  status: 'success';
+};
+type WatchlistFinishedState = {
+  status: 'finished';
+  result: WatchlistResult;
+};
+/**
+ * Union of all possible global watchlist manager states.
+ *
+ * @example
+ * ```typescript
+ * const state = watchlistManager.getState();
+ * if (state.status === 'finished') {
+ *   console.log('Global watchlist check complete');
+ * }
+ * ```
+ */
+type WatchlistState = WatchlistIdleState | WatchlistProcessingState | WatchlistSuccessState | WatchlistFinishedState;
+/**
+ * Creates a global watchlist manager for headless or UI-driven usage.
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createWatchlistManager();
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.load();
+ * ```
+ */
+declare function createWatchlistManager(): Manager<WatchlistState> & {
+  /**
+   * Kicks off the global watchlist check.
+   * Transitions from 'idle' to 'processing'.
+   */
+  load(): void;
+};
+type WatchlistManager = ReturnType<typeof createWatchlistManager>;
+//#endregion
+//#region src/modules/watchlist/types.d.ts
+/**
+ * Configuration options for the global watchlist module.
+ *
+ * The global watchlist module requires no configuration — it is a fire-and-forget
+ * process that runs the backend global watchlist check (OFAC, PEP, etc.) and
+ * completes regardless of the API outcome.
+ */
+type WatchlistConfig = Record<string, never>;
+//#endregion
+export { type WatchlistConfig, type WatchlistManager, type WatchlistState, createWatchlistManager, watchlistMachine };

package/dist/watchlist.esm.js

@@ -0,0 +1,86 @@
+import "./api-CESGtpbH.esm.js";
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-D6-e4vok.esm.js";
+import "./endpoints-CnN3SyDa.esm.js";
+import { a as fromPromise, c as createManager, r as assign, s as createActor, t as setup } from "./xstate.esm-B70JrNqo.esm.js";
+import { t as processWatchlist } from "./watchlistServices-DMbUhkBX.esm.js";
+
+//#region src/modules/watchlist/watchlistStateMachine.ts
+const watchlistMachine = setup({
+	types: {
+		context: {},
+		events: {}
+	},
+	actors: { processWatchlist: fromPromise(async ({ signal }) => {
+		await processWatchlist(signal);
+	}) },
+	actions: {
+		markSuccess: assign({ result: "success" }),
+		markSkipped: assign({ result: "skipped" })
+	}
+}).createMachine({
+	id: "watchlist",
+	initial: "idle",
+	context: { result: null },
+	states: {
+		idle: { on: { LOAD: { target: "processing" } } },
+		processing: { invoke: {
+			id: "processWatchlist",
+			src: "processWatchlist",
+			onDone: { target: "success" },
+			onError: {
+				target: "finished",
+				actions: "markSkipped"
+			}
+		} },
+		success: { after: { 3e3: {
+			target: "finished",
+			actions: "markSuccess"
+		} } },
+		finished: { type: "final" }
+	}
+});
+
+//#endregion
+//#region src/modules/watchlist/watchlistActor.ts
+function createWatchlistActor() {
+	return createActor(watchlistMachine).start();
+}
+
+//#endregion
+//#region src/modules/watchlist/watchlistManager.ts
+function mapState(snapshot) {
+	const typedSnapshot = snapshot;
+	if (typedSnapshot.matches("processing")) return { status: "processing" };
+	if (typedSnapshot.matches("success")) return { status: "success" };
+	if (typedSnapshot.matches("finished")) return {
+		status: "finished",
+		result: typedSnapshot.context.result ?? "skipped"
+	};
+	return { status: "idle" };
+}
+function createApi({ actor }) {
+	return { load() {
+		actor.send({ type: "LOAD" });
+	} };
+}
+/**
+* Creates a global watchlist manager for headless or UI-driven usage.
+*
+* @example Headless usage
+* ```typescript
+* const manager = createWatchlistManager();
+* manager.subscribe((state) => console.log(state.status));
+* manager.load();
+* ```
+*/
+function createWatchlistManager() {
+	return createManager({
+		actor: createWatchlistActor(),
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.watchlist)
+	});
+}
+
+//#endregion
+export { createWatchlistManager, watchlistMachine };

package/dist/watchlistServices-DMbUhkBX.esm.js

@@ -0,0 +1,12 @@
+import { t as api } from "./api-CESGtpbH.esm.js";
+import { t as endpoints } from "./endpoints-CnN3SyDa.esm.js";
+
+//#region src/modules/watchlist/watchlistServices.ts
+async function processWatchlist(signal) {
+	const res = await api.post(endpoints.processWatchlist, {}, { signal });
+	if (!res.ok) throw new Error(`POST ${endpoints.processWatchlist} failed: ${res.status} ${res.statusText}`);
+	return res.data;
+}
+
+//#endregion
+export { processWatchlist as t };