@incodetech/core 2.1.1 → 2.2.0-rc.0

package/dist/watchlistManager-CjSMmbyq.esm.js

@@ -0,0 +1,83 @@
+import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-CxfNJVZW.esm.js";
+import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
+import { c as createManager, o as createActor } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { t as watchlistMachine } from "./watchlistStateMachine-Bl7Wy9Cm.esm.js";
+//#region src/modules/watchlist/watchlistActor.ts
+function createWatchlistActor() {
+	return createActor(watchlistMachine).start();
+}
+//#endregion
+//#region src/modules/watchlist/watchlistManager.ts
+/**
+* Maps a Watchlist state-machine snapshot to the exact Figma "Tracked
+* Events" screen name. Source: Watchlist | Custom Watchlist Figma file
+* (`https://www.figma.com/design/Xm4BgXotNwdi5iRdHTIX0N/Watchlist-%7C-Custom-Watchlist----Latest-Design?node-id=3031-82920`).
+* Family is `watchlist.*` — shared across global watchlist, custom
+* watchlist, and watchlist-for-business (distinct module tokens per
+* AdSign/QSign precedent).
+*
+* `idle` and `finished` are intentionally unmapped — the Figma canvas does
+* not define screens for the entry / terminal moments. `finished` collapses
+* into `moduleClosed`.
+*/
+function getWatchlistScreenName(snapshot) {
+	const stateName = topLevelStateName(snapshot.value);
+	if (stateName === void 0) return void 0;
+	switch (stateName) {
+		case "processing": return "watchlist.processing";
+		case "success": return "watchlist.success";
+		default: return;
+	}
+}
+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 { 
+	/**
+	* Kicks off the global watchlist check.
+	* Transitions from 'idle' to 'processing'.
+	*/
+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, { getEventScreenName: getWatchlistScreenName })
+	});
+}
+/**
+* Creates a watchlist manager from a pre-built actor.
+* Use this when overriding the machine via `.provide()` for custom backends or testing.
+*/
+function createWatchlistManagerFromActor(actor) {
+	return createManager({
+		actor,
+		mapState,
+		createApi,
+		instrumentation: createManagerInstrumentation(eventModuleNames.watchlist, { getEventScreenName: getWatchlistScreenName })
+	});
+}
+//#endregion
+export { createWatchlistManagerFromActor as n, createWatchlistManager as t };

package/dist/watchlistManager-DLXef90v.d.ts

@@ -0,0 +1,68 @@
+import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+//#region src/modules/watchlist/watchlistStateMachine.d.ts
+type WatchlistResult = 'success' | 'skipped';
+declare const watchlistMachine: any;
+type WatchlistMachine = typeof watchlistMachine;
+//#endregion
+//#region src/modules/watchlist/watchlistActor.d.ts
+type WatchlistActor = ActorRefFrom<WatchlistMachine>;
+//#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;
+};
+/**
+ * Creates a watchlist manager from a pre-built actor.
+ * Use this when overriding the machine via `.provide()` for custom backends or testing.
+ */
+declare function createWatchlistManagerFromActor(actor: WatchlistActor): Manager<WatchlistState> & {
+  /**
+   * Kicks off the global watchlist check.
+   * Transitions from 'idle' to 'processing'.
+   */
+  load(): void;
+};
+type WatchlistManager = ReturnType<typeof createWatchlistManager>;
+//#endregion
+export { WatchlistActor as a, createWatchlistManagerFromActor as i, WatchlistState as n, watchlistMachine as o, createWatchlistManager as r, WatchlistManager as t };

package/dist/{watchlistStateMachine-D07UVq1m.esm.js → watchlistStateMachine-Bl7Wy9Cm.esm.js}

@@ -1,14 +1,13 @@
-import { t as api } from "./api-DsbUi7TO.esm.js";
-import { t as endpoints } from "./endpoints-CwrFQfW7.esm.js";
-import { a as fromPromise, r as assign, t as setup } from "./xstate.esm-nY3M5UYm.esm.js";
-
+import { t as api } from "./api-Bx3gKW_y.esm.js";
+import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
+import { r as assign, t as setup } from "./xstate.esm-Cf4e0Cfd.esm.js";
+import { n as fromPromise } from "./xstate-actors.esm-CtI5S0f4.esm.js";
 //#region src/modules/watchlist/watchlistServices.ts
 async function processWatchlist(signal) {
 	const res = await api.post(endpoints.processGlobalWatchlist, {}, { signal });
 	if (!res.ok) throw new Error(`POST ${endpoints.processGlobalWatchlist} failed: ${res.status} ${res.statusText}`);
 	return res.data;
 }
-
 //#endregion
 //#region src/modules/watchlist/watchlistStateMachine.ts
 const watchlistMachine = setup({
@@ -45,6 +44,5 @@ const watchlistMachine = setup({
 		finished: { type: "final" }
 	}
 });
-
 //#endregion
-export { watchlistMachine as t };
+export { watchlistMachine as t };