@incodetech/core 2.2.0 → 2.3.0-rc.1

package/dist/custom-fields.esm.js

@@ -1,232 +1,2 @@
-import { t as api } from "./api-Bx3gKW_y.esm.js";
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.esm.js";
-import { t as topLevelStateName } from "./topLevelStateName-B5i2avbh.esm.js";
-import { t as endpoints } from "./endpoints-CCzL3XD_.esm.js";
-import { i as assign, s as createActor, t as setup, u as createManager } from "./xstate.esm-BuFLFuzz.esm.js";
-import { n as fromPromise } from "./xstate-actors.esm-BXeQ-Ucz.esm.js";
-import { t as isoDateToMs } from "./dateUtils-CvG0FvK8.esm.js";
-//#region src/modules/custom-fields/customFieldsServices.ts
-async function submitCustomFields(params, signal) {
-	const res = await api.post(endpoints.addCustomFields, params.fields, { signal });
-	if (!res.ok) throw new Error(`POST ${endpoints.addCustomFields} failed: ${res.status} ${res.statusText}`);
-	return res.data;
-}
-//#endregion
-//#region src/modules/custom-fields/customFieldsStateMachine.ts
-function transformFields(fields, customFields) {
-	const result = {};
-	for (const [key, value] of Object.entries(fields)) if (customFields.find((f) => f.name === key)?.type === "DATE" && typeof value === "string" && value !== "") result[key] = isoDateToMs(value);
-	else result[key] = value;
-	return result;
-}
-const customFieldsMachine = setup({
-	types: {
-		context: {},
-		events: {},
-		input: {}
-	},
-	actors: { submitFields: fromPromise(async ({ input, signal }) => {
-		return submitCustomFields({ fields: transformFields(input.fields, input.customFields) }, signal);
-	}) },
-	actions: {
-		setField: assign(({ context, event }) => {
-			const e = event;
-			return { fields: {
-				...context.fields,
-				[e.name]: e.value
-			} };
-		}),
-		markSuccess: assign({ result: "success" }),
-		markFailed: assign({ result: "failed" })
-	},
-	guards: { apiSucceeded: ({ event }) => event.output.success }
-}).createMachine({
-	id: "customFields",
-	initial: "idle",
-	context: ({ input }) => ({
-		config: input.config,
-		fields: {},
-		result: null
-	}),
-	states: {
-		idle: { on: { LOAD: { target: "inputting" } } },
-		inputting: { on: {
-			FIELD_CHANGED: { actions: "setField" },
-			SUBMIT: { target: "submitting" }
-		} },
-		submitting: { invoke: {
-			id: "submitFields",
-			src: "submitFields",
-			input: ({ context }) => ({
-				fields: context.fields,
-				customFields: context.config.customFields
-			}),
-			onDone: [{
-				target: "success",
-				guard: "apiSucceeded"
-			}, {
-				target: "finished",
-				actions: "markFailed"
-			}],
-			onError: {
-				target: "finished",
-				actions: "markFailed"
-			}
-		} },
-		success: { after: { 3e3: {
-			target: "finished",
-			actions: "markSuccess"
-		} } },
-		finished: { type: "final" }
-	}
-});
-//#endregion
-//#region src/modules/custom-fields/customFieldsActor.ts
-function createCustomFieldsActor(options) {
-	return createActor(customFieldsMachine, { input: { config: options.config } }).start();
-}
-//#endregion
-//#region src/modules/custom-fields/customFieldsManager.ts
-/**
-* Maps a custom-fields state-machine snapshot to the exact Figma "Tracked
-* Events" screen name. Returned strings are the Figma-verbatim absolute
-* analytics path emitted as-is on `event.screen` by
-* `createManagerInstrumentation`'s `getEventScreenName` path. See
-* `docs/patterns/INSTRUMENTATION.md`.
-*
-* Source of truth: Custom Fields Figma file → Tracked Events canvas
-* (`https://www.figma.com/design/Fb4Jp6kal8clAD05Kh6l4e/Custom-fields---Latest-Design?node-id=2026-30075`).
-* The canvas mixes two casings — sections name the input surfaces
-* `Customfield.{empty,filled}` (capital `C`) and the post-input surfaces
-* `customfield.{processing,complete}` (lowercase `c`). Both spellings are
-* preserved verbatim as Figma is the source of truth.
-*
-* State → screen mapping rationale:
-*
-* - `idle`/`inputting` collapse to `Customfield.empty` — the SM stays in
-*   `inputting` throughout typing (field-level `FIELD_CHANGED` events are
-*   context-only and don't fire a new `screenOpened`). The Figma
-*   `Customfield.filled` surface is therefore a UI sub-state of `inputting`
-*   (computed in `mapState` as `canSubmit`), not a discrete SM state, and
-*   collapses onto the section's primary `Customfield.empty` screen.
-* - `submitting` → `customfield.processing` — submit in-flight.
-* - `success` → `customfield.complete` — happy-path success surface (auto-
-*   advances to `finished` after 3 s).
-* - `finished` is intentionally unmapped: it is dual-outcome (success or
-*   failed — failures route here with `result: 'failed'` since the machine
-*   has no `error` state) and Figma defines no failure screen. Mapping
-*   `finished` onto `customfield.complete` would mis-report failures, so the
-*   adapter falls back to the generic `<module>.finished` default.
-*/
-function getCustomFieldsScreenName(snapshot) {
-	const stateName = topLevelStateName(snapshot.value);
-	if (stateName === void 0) return void 0;
-	switch (stateName) {
-		case "idle":
-		case "inputting": return "Customfield.empty";
-		case "submitting": return "customfield.processing";
-		case "success": return "customfield.complete";
-		default: return;
-	}
-}
-function toDisplayLabel(field) {
-	if (field.alias) return field.alias;
-	return field.name.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase());
-}
-function isFormComplete(fields, customFields) {
-	return customFields.every((f) => {
-		if (f.type === "BOOLEAN") return true;
-		const value = fields[f.name];
-		return value !== void 0 && value !== "";
-	});
-}
-function mapState(snapshot) {
-	const typedSnapshot = snapshot;
-	const { context } = typedSnapshot;
-	if (typedSnapshot.matches("idle")) return { status: "idle" };
-	if (typedSnapshot.matches("inputting")) return {
-		status: "inputting",
-		title: context.config.title,
-		customFields: context.config.customFields.map((f) => ({
-			...f,
-			label: toDisplayLabel(f)
-		})),
-		canSubmit: isFormComplete(context.fields, context.config.customFields)
-	};
-	if (typedSnapshot.matches("submitting")) return {
-		status: "submitting",
-		title: context.config.title
-	};
-	if (typedSnapshot.matches("success")) return { status: "success" };
-	return {
-		status: "finished",
-		result: typedSnapshot.context.result
-	};
-}
-function createApi({ actor }) {
-	return {
-		/**
-		* Initializes the custom fields flow.
-		* Transitions from 'idle' to 'inputting'.
-		* Must be called before any other method.
-		*/
-		load() {
-			actor.send({ type: "LOAD" });
-		},
-		/**
-		* Updates the value of a single field.
-		* Should be called when state is 'inputting'.
-		*
-		* @param name - The field name (matches CustomField.name)
-		* @param value - The field value (string, number, or boolean)
-		*/
-		setField(name, value) {
-			actor.send({
-				type: "FIELD_CHANGED",
-				name,
-				value
-			});
-		},
-		/**
-		* Submits all custom field values to the backend.
-		* Transitions to 'submitting', then 'finished' regardless of outcome.
-		*/
-		submit() {
-			actor.send({ type: "SUBMIT" });
-		}
-	};
-}
-/**
-* Creates a custom fields manager for headless or UI-driven usage.
-*
-* @param options - Configuration options
-* @param options.config - Custom fields configuration (title + field definitions)
-*
-* @returns Custom fields manager with state, API methods, and subscription
-*
-* @example Headless usage
-* ```typescript
-* const manager = createCustomFieldsManager({
-*   config: {
-*     title: 'Additional Information',
-*     customFields: [{ name: 'company', alias: 'Company', type: 'STRING' }],
-*   },
-* });
-*
-* manager.subscribe((state) => console.log(state.status));
-* manager.load();
-* manager.setField('company', 'Incode');
-* manager.submit();
-* manager.stop();
-* ```
-*/
-function createCustomFieldsManager(options) {
-	return createManager({
-		actor: createCustomFieldsActor(options),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.customFields, { getEventScreenName: getCustomFieldsScreenName })
-	});
-}
-//#endregion
-export { createCustomFieldsManager, customFieldsMachine };
+import { n as createCustomFieldsManagerFromActor, r as customFieldsMachine, t as createCustomFieldsManager } from "./customFieldsManager-CzWZTkW-.esm.js";
+export { createCustomFieldsManager, createCustomFieldsManagerFromActor, customFieldsMachine };

package/dist/custom-watchlist.d.ts

@@ -1,53 +1,4 @@
-import { t as Manager } from "./Manager-CQQ99QOI.js";
-//#region src/modules/custom-watchlist/customWatchlistStateMachine.d.ts
-type CustomWatchlistResult = 'success' | 'skipped';
-declare const customWatchlistMachine: any;
-//#endregion
-//#region src/modules/custom-watchlist/customWatchlistManager.d.ts
-type CustomWatchlistIdleState = {
-  status: 'idle';
-};
-type CustomWatchlistProcessingState = {
-  status: 'processing';
-};
-type CustomWatchlistSuccessState = {
-  status: 'success';
-};
-type CustomWatchlistFinishedState = {
-  status: 'finished';
-  result: CustomWatchlistResult;
-};
-/**
- * Union of all possible custom watchlist manager states.
- *
- * @example
- * ```typescript
- * const state = customWatchlistManager.getState();
- * if (state.status === 'finished') {
- *   console.log('Custom watchlist check complete');
- * }
- * ```
- */
-type CustomWatchlistState = CustomWatchlistIdleState | CustomWatchlistProcessingState | CustomWatchlistSuccessState | CustomWatchlistFinishedState;
-/**
- * Creates a custom watchlist manager for headless or UI-driven usage.
- *
- * @example Headless usage
- * ```typescript
- * const manager = createCustomWatchlistManager();
- * manager.subscribe((state) => console.log(state.status));
- * manager.load();
- * ```
- */
-declare function createCustomWatchlistManager(): Manager<CustomWatchlistState> & {
-  /**
-   * Kicks off the custom watchlist check.
-   * Transitions from 'idle' to 'processing'.
-   */
-  load(): void;
-};
-type CustomWatchlistManager = ReturnType<typeof createCustomWatchlistManager>;
-//#endregion
+import { a as CustomWatchlistActor, i as createCustomWatchlistManagerFromActor, n as CustomWatchlistState, o as customWatchlistMachine, r as createCustomWatchlistManager, t as CustomWatchlistManager } from "./customWatchlistManager-PBWHr_oM.js";
 //#region src/modules/custom-watchlist/types.d.ts
 /**
  * Configuration for the custom watchlist module (INCODE_WATCHLIST flow key).
@@ -62,4 +13,4 @@ type CustomWatchlistConfig = {
   autoExecution: boolean;
 };
 //#endregion
-export { type CustomWatchlistConfig, type CustomWatchlistManager, type CustomWatchlistState, createCustomWatchlistManager, customWatchlistMachine };
+export { type CustomWatchlistActor, type CustomWatchlistConfig, type CustomWatchlistManager, type CustomWatchlistState, createCustomWatchlistManager, createCustomWatchlistManagerFromActor, customWatchlistMachine };

package/dist/custom-watchlist.esm.js

@@ -1,70 +1,3 @@
-import { n as eventModuleNames, o as createManagerInstrumentation } from "./events-DYiyoSlx.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 customWatchlistMachine } from "./customWatchlistStateMachine-YWSgKLbF.esm.js";
-//#region src/modules/custom-watchlist/customWatchlistActor.ts
-function createCustomWatchlistActor() {
-	return createActor(customWatchlistMachine).start();
-}
-//#endregion
-//#region src/modules/custom-watchlist/customWatchlistManager.ts
-/**
-* Maps a Custom 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 with the global watchlist manager — both
-* keep their own module token (`watchlist` vs `customWatchlist`) per the
-* AdSign/QSign precedent.
-*
-* `idle` and `finished` are intentionally unmapped — the Figma canvas does
-* not define screens for them; `finished` collapses into `moduleClosed`.
-*/
-function getCustomWatchlistScreenName(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 custom watchlist check.
-	* Transitions from 'idle' to 'processing'.
-	*/
-load() {
-		actor.send({ type: "LOAD" });
-	} };
-}
-/**
-* Creates a custom watchlist manager for headless or UI-driven usage.
-*
-* @example Headless usage
-* ```typescript
-* const manager = createCustomWatchlistManager();
-* manager.subscribe((state) => console.log(state.status));
-* manager.load();
-* ```
-*/
-function createCustomWatchlistManager() {
-	return createManager({
-		actor: createCustomWatchlistActor(),
-		mapState,
-		createApi,
-		instrumentation: createManagerInstrumentation(eventModuleNames.customWatchList, { getEventScreenName: getCustomWatchlistScreenName })
-	});
-}
-//#endregion
-export { createCustomWatchlistManager, customWatchlistMachine };
+import { t as customWatchlistMachine } from "./customWatchlistStateMachine-DOQou6TW.esm.js";
+import { n as createCustomWatchlistManagerFromActor, t as createCustomWatchlistManager } from "./customWatchlistManager-DWTED5Ur.esm.js";
+export { createCustomWatchlistManager, createCustomWatchlistManagerFromActor, customWatchlistMachine };

package/dist/customFieldsManager-8-W2KY4n.d.ts

@@ -0,0 +1,141 @@
+import { i as ActorRefFrom } from "./spawn-D9jgw9pW.js";
+import { t as Manager } from "./Manager-CQQ99QOI.js";
+import "./Actor-iTq7YY48.js";
+//#region src/modules/custom-fields/types.d.ts
+type CustomFieldType = 'INTEGER' | 'DOUBLE' | 'BOOLEAN' | 'STRING' | 'DATE';
+type CustomField = {
+  name: string;
+  alias: string;
+  type: CustomFieldType;
+};
+type CustomFieldsConfig = {
+  title: string;
+  customFields: CustomField[];
+};
+//#endregion
+//#region src/modules/custom-fields/customFieldsStateMachine.d.ts
+type CustomFieldsResult = 'success' | 'failed';
+type CustomFieldsValidationErrors = Record<string, string>;
+declare const customFieldsMachine: any;
+type CustomFieldsMachine = typeof customFieldsMachine;
+//#endregion
+//#region src/modules/custom-fields/customFieldsActor.d.ts
+type CreateCustomFieldsActorOptions = {
+  config: CustomFieldsConfig;
+};
+type CustomFieldsActor = ActorRefFrom<CustomFieldsMachine>;
+//#endregion
+//#region src/modules/custom-fields/customFieldsManager.d.ts
+/**
+ * A `CustomField` enriched with a computed `label` for display.
+ * Label is derived from `alias` when present, otherwise auto-formatted from `name`.
+ */
+type MappedCustomField = CustomField & {
+  label: string;
+};
+/** Custom fields manager is in initial state, waiting for `load()` to be called */
+type CustomFieldsIdleState = {
+  status: 'idle';
+};
+/**
+ * Ready for field input — use `setField()` and `submit()`
+ * @property title - Form title from configuration
+ * @property customFields - Field definitions with computed display labels
+ * @property validationErrors - Required-field errors surfaced after a failed submit attempt
+ * @property canSubmit - Optimistically true until validation errors are displayed
+ */
+type CustomFieldsInputtingState = {
+  status: 'inputting';
+  title: string;
+  customFields: MappedCustomField[];
+  validationErrors?: CustomFieldsValidationErrors;
+  canSubmit: boolean;
+};
+/** Fields are being submitted to the backend */
+type CustomFieldsSubmittingState = {
+  status: 'submitting';
+  title: string;
+};
+/** API call succeeded — success page is visible for ~3 s before finishing */
+type CustomFieldsSuccessState = {
+  status: 'success';
+};
+/** Custom fields flow complete. `result` indicates whether the API call succeeded or failed. */
+type CustomFieldsFinishedState = {
+  status: 'finished';
+  result: CustomFieldsResult | null;
+};
+/**
+ * Union of all possible custom fields manager states.
+ */
+type CustomFieldsState = CustomFieldsIdleState | CustomFieldsInputtingState | CustomFieldsSubmittingState | CustomFieldsSuccessState | CustomFieldsFinishedState;
+/**
+ * Creates a custom fields manager for headless or UI-driven usage.
+ *
+ * @param options - Configuration options
+ * @param options.config - Custom fields configuration (title + field definitions)
+ *
+ * @returns Custom fields manager with state, API methods, and subscription
+ *
+ * @example Headless usage
+ * ```typescript
+ * const manager = createCustomFieldsManager({
+ *   config: {
+ *     title: 'Additional Information',
+ *     customFields: [{ name: 'company', alias: 'Company', type: 'STRING' }],
+ *   },
+ * });
+ *
+ * manager.subscribe((state) => console.log(state.status));
+ * manager.load();
+ * manager.setField('company', 'Incode');
+ * manager.submit();
+ * manager.stop();
+ * ```
+ */
+declare function createCustomFieldsManager(options: CreateCustomFieldsActorOptions): Manager<CustomFieldsState> & {
+  /**
+   * Initializes the custom fields flow.
+   * Transitions from 'idle' to 'inputting'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Updates the value of a single field.
+   * Should be called when state is 'inputting'.
+   *
+   * @param name - The field name (matches CustomField.name)
+   * @param value - The field value (string, number, or boolean)
+   */
+  setField(name: string, value: string | number | boolean): void;
+  /**
+   * Submits all custom field values to the backend.
+   * Transitions to 'submitting', then 'finished' regardless of outcome.
+   */
+  submit(): void;
+};
+declare function createCustomFieldsManagerFromActor(actor: CustomFieldsActor): Manager<CustomFieldsState> & {
+  /**
+   * Initializes the custom fields flow.
+   * Transitions from 'idle' to 'inputting'.
+   * Must be called before any other method.
+   */
+  load(): void;
+  /**
+   * Updates the value of a single field.
+   * Should be called when state is 'inputting'.
+   *
+   * @param name - The field name (matches CustomField.name)
+   * @param value - The field value (string, number, or boolean)
+   */
+  setField(name: string, value: string | number | boolean): void;
+  /**
+   * Submits all custom field values to the backend.
+   * Transitions to 'submitting', then 'finished' regardless of outcome.
+   */
+  submit(): void;
+};
+/** Type representing a custom fields manager instance. */
+type CustomFieldsManager = ReturnType<typeof createCustomFieldsManager>;
+//#endregion
+export { createCustomFieldsManagerFromActor as a, customFieldsMachine as c, CustomFieldsConfig as d, createCustomFieldsManager as i, CustomField as l, CustomFieldsState as n, CustomFieldsActor as o, MappedCustomField as r, CustomFieldsValidationErrors as s, CustomFieldsManager as t, CustomFieldType as u };