@thunderid/react 0.0.5 → 0.2.0

package/dist/utils/applyThemeToDOM.js

@@ -0,0 +1,15 @@
+//#region src/utils/applyThemeToDOM.ts
+/**
+* Writes all CSS custom properties from a resolved `Theme` onto the document root.
+* Called inside a `useEffect` whenever the active theme changes.
+*/
+const applyThemeToDOM = (theme) => {
+	Object.entries(theme.cssVariables).forEach(([key, value]) => {
+		document.documentElement.style.setProperty(key, value);
+	});
+};
+var applyThemeToDOM_default = applyThemeToDOM;
+
+//#endregion
+export { applyThemeToDOM_default as default };
+//# sourceMappingURL=applyThemeToDOM.js.map

package/dist/utils/applyThemeToDOM.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"applyThemeToDOM.js","names":[],"sources":["../../src/utils/applyThemeToDOM.ts"],"sourcesContent":["/**\n * Copyright (c) 2026, WSO2 LLC. (https://www.wso2.com).\n *\n * WSO2 LLC. licenses this file to you under the Apache License,\n * Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing,\n * software distributed under the License is distributed on an\n * \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n * KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations\n * under the License.\n */\n\nimport {Theme} from '@thunderid/browser';\n\n/**\n * Writes all CSS custom properties from a resolved `Theme` onto the document root.\n * Called inside a `useEffect` whenever the active theme changes.\n */\nconst applyThemeToDOM = (theme: Theme): void => {\n  Object.entries(theme.cssVariables).forEach(([key, value]: [string, string]) => {\n    document.documentElement.style.setProperty(key, value);\n  });\n};\n\nexport default applyThemeToDOM;\n"],"mappings":";;;;;AAwBA,MAAM,mBAAmB,UAAuB;AAC9C,QAAO,QAAQ,MAAM,aAAa,CAAC,SAAS,CAAC,KAAK,WAA6B;AAC7E,WAAS,gBAAgB,MAAM,YAAY,KAAK,MAAM;GACtD;;AAGJ,8BAAe"}

package/dist/utils/getDisplayName.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDisplayName.d.ts","sourceRoot":"","sources":["../../src/utils/getDisplayName.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAC,IAAI,EAAC,MAAM,oBAAoB,CAAC;AAGxC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,QAAA,MAAM,cAAc,GAClB,gBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,EAC7D,MAAM,IAAI,EACV,oBAAoB,MAAM,EAAE,KAC3B,MA8BF,CAAC;AAEF,eAAe,cAAc,CAAC"}
+{"version":3,"file":"getDisplayName.d.ts","sourceRoot":"","sources":["../../src/utils/getDisplayName.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAC,IAAI,EAAC,MAAM,oBAAoB,CAAC;AAGxC;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,QAAA,MAAM,cAAc,GAClB,gBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,SAAS,CAAC,EAC7D,MAAM,IAAI,EACV,oBAAoB,MAAM,EAAE,KAC3B,MA+BF,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/utils/getDisplayName.js

@@ -0,0 +1,50 @@
+import getMappedUserProfileValue_default from "./getMappedUserProfileValue.js";
+
+//#region src/utils/getDisplayName.ts
+/**
+* Get the display name of a user by mapping their profile attributes.
+*
+* @param mergedMappings - The merged attribute mappings.
+* @param user - The user object containing profile information.
+* @param displayAttributes - Optional array of attribute keys or paths to try first.
+*   Each entry is resolved via `getMappedUserProfileValue`. The first non-empty
+*   value found is returned. If none resolve, the default fallback chain is used.
+*
+* @example
+* ```ts
+* // Default behavior — tries firstName+lastName, then username, email, name
+* const displayName = getDisplayName(mergedMappings, user);
+*
+* // Custom attributes — try 'nickname' first, then fall back to defaults
+* const displayName = getDisplayName(mergedMappings, user, ['nickname']);
+*
+* // Multiple custom attributes
+* const displayName = getDisplayName(mergedMappings, user, ['preferred_username', 'nickname']);
+* ```
+*
+* @returns The display name of the user.
+*/
+const getDisplayName = (mergedMappings, user, displayAttributes) => {
+	const mappings = mergedMappings;
+	if (displayAttributes && displayAttributes.length > 0) {
+		let foundValue;
+		displayAttributes.some((attr) => {
+			const value = getMappedUserProfileValue_default(attr, mappings, user);
+			if (value !== void 0 && value !== null && value !== "") {
+				foundValue = String(value);
+				return true;
+			}
+			return false;
+		});
+		if (foundValue !== void 0) return foundValue;
+	}
+	const firstName = getMappedUserProfileValue_default("firstName", mappings, user);
+	const lastName = getMappedUserProfileValue_default("lastName", mappings, user);
+	if (firstName && lastName) return `${firstName} ${lastName}`;
+	return getMappedUserProfileValue_default("username", mappings, user) || getMappedUserProfileValue_default("email", mappings, user) || getMappedUserProfileValue_default("name", mappings, user) || "User";
+};
+var getDisplayName_default = getDisplayName;
+
+//#endregion
+export { getDisplayName_default as default };
+//# sourceMappingURL=getDisplayName.js.map

package/dist/utils/getDisplayName.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDisplayName.js","names":["mappings: Record<string, string | string[]>","foundValue: string | undefined","value: any","getMappedUserProfileValue","firstName: any","lastName: any"],"sources":["../../src/utils/getDisplayName.ts"],"sourcesContent":["/**\n * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).\n *\n * WSO2 LLC. licenses this file to you under the Apache License,\n * Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing,\n * software distributed under the License is distributed on an\n * \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n * KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations\n * under the License.\n */\n\nimport {User} from '@thunderid/browser';\nimport getMappedUserProfileValue from './getMappedUserProfileValue';\n\n/**\n * Get the display name of a user by mapping their profile attributes.\n *\n * @param mergedMappings - The merged attribute mappings.\n * @param user - The user object containing profile information.\n * @param displayAttributes - Optional array of attribute keys or paths to try first.\n *   Each entry is resolved via `getMappedUserProfileValue`. The first non-empty\n *   value found is returned. If none resolve, the default fallback chain is used.\n *\n * @example\n * ```ts\n * // Default behavior — tries firstName+lastName, then username, email, name\n * const displayName = getDisplayName(mergedMappings, user);\n *\n * // Custom attributes — try 'nickname' first, then fall back to defaults\n * const displayName = getDisplayName(mergedMappings, user, ['nickname']);\n *\n * // Multiple custom attributes\n * const displayName = getDisplayName(mergedMappings, user, ['preferred_username', 'nickname']);\n * ```\n *\n * @returns The display name of the user.\n */\nconst getDisplayName = (\n  mergedMappings: Record<string, string | string[] | undefined>,\n  user: User,\n  displayAttributes?: string[],\n): string => {\n  const mappings: Record<string, string | string[]> = mergedMappings as Record<string, string | string[]>;\n  if (displayAttributes && displayAttributes.length > 0) {\n    let foundValue: string | undefined;\n    displayAttributes.some((attr: string) => {\n      const value: any = getMappedUserProfileValue(attr, mappings, user);\n\n      if (value !== undefined && value !== null && value !== '') {\n        foundValue = String(value);\n        return true;\n      }\n      return false;\n    });\n    if (foundValue !== undefined) {\n      return foundValue;\n    }\n  }\n\n  const firstName: any = getMappedUserProfileValue('firstName', mappings, user);\n  const lastName: any = getMappedUserProfileValue('lastName', mappings, user);\n\n  if (firstName && lastName) {\n    return `${firstName} ${lastName}`;\n  }\n\n  return (\n    getMappedUserProfileValue('username', mappings, user) ||\n    getMappedUserProfileValue('email', mappings, user) ||\n    getMappedUserProfileValue('name', mappings, user) ||\n    'User'\n  );\n};\n\nexport default getDisplayName;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA4CA,MAAM,kBACJ,gBACA,MACA,sBACW;CACX,MAAMA,WAA8C;AACpD,KAAI,qBAAqB,kBAAkB,SAAS,GAAG;EACrD,IAAIC;AACJ,oBAAkB,MAAM,SAAiB;GACvC,MAAMC,QAAaC,kCAA0B,MAAM,UAAU,KAAK;AAElE,OAAI,UAAU,UAAa,UAAU,QAAQ,UAAU,IAAI;AACzD,iBAAa,OAAO,MAAM;AAC1B,WAAO;;AAET,UAAO;IACP;AACF,MAAI,eAAe,OACjB,QAAO;;CAIX,MAAMC,YAAiBD,kCAA0B,aAAa,UAAU,KAAK;CAC7E,MAAME,WAAgBF,kCAA0B,YAAY,UAAU,KAAK;AAE3E,KAAI,aAAa,SACf,QAAO,GAAG,UAAU,GAAG;AAGzB,QACEA,kCAA0B,YAAY,UAAU,KAAK,IACrDA,kCAA0B,SAAS,UAAU,KAAK,IAClDA,kCAA0B,QAAQ,UAAU,KAAK,IACjD;;AAIJ,6BAAe"}

package/dist/utils/getMappedUserProfileValue.js

@@ -0,0 +1,59 @@
+import { get } from "@thunderid/browser";
+
+//#region src/utils/getMappedUserProfileValue.ts
+/**
+* Retrieves a user profile value based on attribute mapping configuration.
+*
+* This function allows flexible mapping of component attribute names to actual
+* user profile field paths. It supports both simple string mappings and arrays
+* of potential field paths for fallback scenarios.
+*
+* @param key - The logical attribute name to retrieve (e.g., 'firstName', 'email')
+* @param mappings - Object mapping logical names to user profile field paths
+* @param user - The user object to extract values from
+* @returns The mapped value from the user profile, or undefined if not found
+*
+* @example
+* ```typescript
+* const mappings = {
+*   firstName: 'name.givenName',
+*   email: 'emails[0]',
+*   picture: ['profileUrl', 'profile', 'avatar'] // fallback options
+* };
+*
+* const user = {
+*   name: { givenName: 'John' },
+*   emails: ['john@example.com'],
+*   profileUrl: 'https://example.com/avatar.jpg'
+* };
+*
+* getMappedUserProfileValue('firstName', mappings, user); // 'John'
+* getMappedUserProfileValue('email', mappings, user); // 'john@example.com'
+* getMappedUserProfileValue('picture', mappings, user); // 'https://example.com/avatar.jpg'
+* ```
+*/
+const getMappedUserProfileValue = (key, mappings, user) => {
+	if (!key || !mappings || !user) return;
+	const mapping = mappings[key];
+	if (!mapping) return get(user, key);
+	if (Array.isArray(mapping)) {
+		let foundValue;
+		let found = false;
+		mapping.some((path) => {
+			const value = get(user, path);
+			if (value !== void 0 && value !== null && value !== "") {
+				foundValue = value;
+				found = true;
+				return true;
+			}
+			return false;
+		});
+		return found ? foundValue : void 0;
+	}
+	return get(user, mapping);
+};
+var getMappedUserProfileValue_default = getMappedUserProfileValue;
+
+//#endregion
+export { getMappedUserProfileValue_default as default };
+//# sourceMappingURL=getMappedUserProfileValue.js.map

package/dist/utils/getMappedUserProfileValue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMappedUserProfileValue.js","names":["mapping: string | string[]","foundValue: any","value: any"],"sources":["../../src/utils/getMappedUserProfileValue.ts"],"sourcesContent":["/**\n * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).\n *\n * WSO2 LLC. licenses this file to you under the Apache License,\n * Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing,\n * software distributed under the License is distributed on an\n * \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n * KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations\n * under the License.\n */\n\nimport {User, get} from '@thunderid/browser';\n\n/**\n * Retrieves a user profile value based on attribute mapping configuration.\n *\n * This function allows flexible mapping of component attribute names to actual\n * user profile field paths. It supports both simple string mappings and arrays\n * of potential field paths for fallback scenarios.\n *\n * @param key - The logical attribute name to retrieve (e.g., 'firstName', 'email')\n * @param mappings - Object mapping logical names to user profile field paths\n * @param user - The user object to extract values from\n * @returns The mapped value from the user profile, or undefined if not found\n *\n * @example\n * ```typescript\n * const mappings = {\n *   firstName: 'name.givenName',\n *   email: 'emails[0]',\n *   picture: ['profileUrl', 'profile', 'avatar'] // fallback options\n * };\n *\n * const user = {\n *   name: { givenName: 'John' },\n *   emails: ['john@example.com'],\n *   profileUrl: 'https://example.com/avatar.jpg'\n * };\n *\n * getMappedUserProfileValue('firstName', mappings, user); // 'John'\n * getMappedUserProfileValue('email', mappings, user); // 'john@example.com'\n * getMappedUserProfileValue('picture', mappings, user); // 'https://example.com/avatar.jpg'\n * ```\n */\nconst getMappedUserProfileValue = (key: string, mappings: Record<string, string | string[]>, user: User): any => {\n  if (!key || !mappings || !user) {\n    return undefined;\n  }\n\n  const mapping: string | string[] = mappings[key];\n\n  if (!mapping) {\n    // If no mapping defined, try to get the value directly from the user object\n    return get(user, key);\n  }\n\n  // If mapping is an array, try each path until we find a value\n  if (Array.isArray(mapping)) {\n    let foundValue: any;\n    let found = false;\n    mapping.some((path: string) => {\n      const value: any = get(user, path);\n      if (value !== undefined && value !== null && value !== '') {\n        foundValue = value;\n        found = true;\n        return true;\n      }\n      return false;\n    });\n    return found ? foundValue : undefined;\n  }\n\n  // For single string mapping, get the value directly\n  return get(user, mapping);\n};\n\nexport default getMappedUserProfileValue;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmDA,MAAM,6BAA6B,KAAa,UAA6C,SAAoB;AAC/G,KAAI,CAAC,OAAO,CAAC,YAAY,CAAC,KACxB;CAGF,MAAMA,UAA6B,SAAS;AAE5C,KAAI,CAAC,QAEH,QAAO,IAAI,MAAM,IAAI;AAIvB,KAAI,MAAM,QAAQ,QAAQ,EAAE;EAC1B,IAAIC;EACJ,IAAI,QAAQ;AACZ,UAAQ,MAAM,SAAiB;GAC7B,MAAMC,QAAa,IAAI,MAAM,KAAK;AAClC,OAAI,UAAU,UAAa,UAAU,QAAQ,UAAU,IAAI;AACzD,iBAAa;AACb,YAAQ;AACR,WAAO;;AAET,UAAO;IACP;AACF,SAAO,QAAQ,aAAa;;AAI9B,QAAO,IAAI,MAAM,QAAQ;;AAG3B,wCAAe"}

package/dist/utils/normalizeThemeConfig.js

@@ -0,0 +1,42 @@
+//#region src/utils/normalizeThemeConfig.ts
+/**
+* Normalizes a single color value that may have been supplied as a shorthand
+* CSS color string (`'#2563eb'`) instead of the expected object form
+* (`{ main: '#2563eb' }`).
+*
+* This makes the `preferences.theme.overrides.colors.*` API forgiving for
+* JavaScript callers who don't have TypeScript's type-checker to catch the
+* mismatch at compile time.
+*/
+const normalizeColorValue = (color) => typeof color === "string" ? { main: color } : color;
+/**
+* Normalizes a `RecursivePartial<ThemeConfig>` so that color fields which are
+* supplied as plain CSS color strings are coerced into `{ main: string }`
+* objects before being handed to `createTheme`.
+*
+* Only the color groups that `toCssVariables` in `createTheme` actually reads
+* individual sub-keys from are normalized here (`primary`, `secondary`,
+* `error`, `success`, `warning`, `info`).  `border` is left alone because it
+* IS a plain string in `ThemeConfig`.
+*/
+const normalizeThemeConfig = (config) => {
+	if (!config?.colors) return config;
+	const { primary, secondary, error, success, warning, info,...restColors } = config.colors;
+	return {
+		...config,
+		colors: {
+			...restColors,
+			...primary !== void 0 ? { primary: normalizeColorValue(primary) } : {},
+			...secondary !== void 0 ? { secondary: normalizeColorValue(secondary) } : {},
+			...error !== void 0 ? { error: normalizeColorValue(error) } : {},
+			...success !== void 0 ? { success: normalizeColorValue(success) } : {},
+			...warning !== void 0 ? { warning: normalizeColorValue(warning) } : {},
+			...info !== void 0 ? { info: normalizeColorValue(info) } : {}
+		}
+	};
+};
+var normalizeThemeConfig_default = normalizeThemeConfig;
+
+//#endregion
+export { normalizeThemeConfig_default as default };
+//# sourceMappingURL=normalizeThemeConfig.js.map

package/dist/utils/normalizeThemeConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalizeThemeConfig.js","names":[],"sources":["../../src/utils/normalizeThemeConfig.ts"],"sourcesContent":["/**\n * Copyright (c) 2026, WSO2 LLC. (https://www.wso2.com).\n *\n * WSO2 LLC. licenses this file to you under the Apache License,\n * Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing,\n * software distributed under the License is distributed on an\n * \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n * KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations\n * under the License.\n */\n\nimport {RecursivePartial, ThemeConfig} from '@thunderid/browser';\n\ninterface ColorWithMain {\n  [key: string]: unknown;\n  main: string;\n}\n\n/**\n * Normalizes a single color value that may have been supplied as a shorthand\n * CSS color string (`'#2563eb'`) instead of the expected object form\n * (`{ main: '#2563eb' }`).\n *\n * This makes the `preferences.theme.overrides.colors.*` API forgiving for\n * JavaScript callers who don't have TypeScript's type-checker to catch the\n * mismatch at compile time.\n */\nconst normalizeColorValue = (color: string | ColorWithMain): ColorWithMain =>\n  typeof color === 'string' ? {main: color} : color;\n\n/**\n * Normalizes a `RecursivePartial<ThemeConfig>` so that color fields which are\n * supplied as plain CSS color strings are coerced into `{ main: string }`\n * objects before being handed to `createTheme`.\n *\n * Only the color groups that `toCssVariables` in `createTheme` actually reads\n * individual sub-keys from are normalized here (`primary`, `secondary`,\n * `error`, `success`, `warning`, `info`).  `border` is left alone because it\n * IS a plain string in `ThemeConfig`.\n */\nconst normalizeThemeConfig = (\n  config: RecursivePartial<ThemeConfig> | undefined,\n): RecursivePartial<ThemeConfig> | undefined => {\n  if (!config?.colors) {\n    return config;\n  }\n\n  const {primary, secondary, error, success, warning, info, ...restColors} = config.colors as any;\n\n  return {\n    ...config,\n    colors: {\n      ...restColors,\n      ...(primary !== undefined ? {primary: normalizeColorValue(primary)} : {}),\n      ...(secondary !== undefined ? {secondary: normalizeColorValue(secondary)} : {}),\n      ...(error !== undefined ? {error: normalizeColorValue(error)} : {}),\n      ...(success !== undefined ? {success: normalizeColorValue(success)} : {}),\n      ...(warning !== undefined ? {warning: normalizeColorValue(warning)} : {}),\n      ...(info !== undefined ? {info: normalizeColorValue(info)} : {}),\n    },\n  };\n};\n\nexport default normalizeThemeConfig;\n"],"mappings":";;;;;;;;;;AAkCA,MAAM,uBAAuB,UAC3B,OAAO,UAAU,WAAW,EAAC,MAAM,OAAM,GAAG;;;;;;;;;;;AAY9C,MAAM,wBACJ,WAC8C;AAC9C,KAAI,CAAC,QAAQ,OACX,QAAO;CAGT,MAAM,EAAC,SAAS,WAAW,OAAO,SAAS,SAAS,KAAM,GAAG,eAAc,OAAO;AAElF,QAAO;EACL,GAAG;EACH,QAAQ;GACN,GAAG;GACH,GAAI,YAAY,SAAY,EAAC,SAAS,oBAAoB,QAAQ,EAAC,GAAG,EAAE;GACxE,GAAI,cAAc,SAAY,EAAC,WAAW,oBAAoB,UAAU,EAAC,GAAG,EAAE;GAC9E,GAAI,UAAU,SAAY,EAAC,OAAO,oBAAoB,MAAM,EAAC,GAAG,EAAE;GAClE,GAAI,YAAY,SAAY,EAAC,SAAS,oBAAoB,QAAQ,EAAC,GAAG,EAAE;GACxE,GAAI,YAAY,SAAY,EAAC,SAAS,oBAAoB,QAAQ,EAAC,GAAG,EAAE;GACxE,GAAI,SAAS,SAAY,EAAC,MAAM,oBAAoB,KAAK,EAAC,GAAG,EAAE;GAChE;EACF;;AAGH,mCAAe"}

package/dist/utils/oauth.js

@@ -0,0 +1,26 @@
+import { navigate } from "@thunderid/browser";
+
+//#region src/utils/oauth.ts
+/**
+* Initiates OAuth redirect with CSRF protection.
+* Generates random state, stores return path in sessionStorage, and redirects to OAuth provider.
+*
+* @param redirectURL - OAuth authorization URL from the server
+*/
+function initiateOAuthRedirect(redirectURL) {
+	const basePath = document.querySelector("base")?.getAttribute("href") || "";
+	let returnPath = window.location.pathname;
+	if (basePath && returnPath.startsWith(basePath)) returnPath = returnPath.slice(basePath.length) || "/";
+	const state = crypto.randomUUID();
+	sessionStorage.setItem(`thunderid_oauth_${state}`, JSON.stringify({
+		path: returnPath,
+		timestamp: Date.now()
+	}));
+	const redirectUrlObj = new URL(redirectURL);
+	redirectUrlObj.searchParams.set("state", state);
+	navigate(redirectUrlObj.toString());
+}
+
+//#endregion
+export { initiateOAuthRedirect };
+//# sourceMappingURL=oauth.js.map

package/dist/utils/oauth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oauth.js","names":["basePath: string","returnPath: string","state: string","redirectUrlObj: URL"],"sources":["../../src/utils/oauth.ts"],"sourcesContent":["/**\n * Copyright (c) 2026, WSO2 LLC. (https://www.wso2.com).\n *\n * WSO2 LLC. licenses this file to you under the Apache License,\n * Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing,\n * software distributed under the License is distributed on an\n * \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n * KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations\n * under the License.\n */\n\nimport {navigate} from '@thunderid/browser';\n\n/**\n * Initiates OAuth redirect with CSRF protection.\n * Generates random state, stores return path in sessionStorage, and redirects to OAuth provider.\n *\n * @param redirectURL - OAuth authorization URL from the server\n */\nexport function initiateOAuthRedirect(redirectURL: string): void {\n  const basePath: string = document.querySelector('base')?.getAttribute('href') || '';\n  let returnPath: string = window.location.pathname;\n\n  if (basePath && returnPath.startsWith(basePath)) {\n    returnPath = returnPath.slice(basePath.length) || '/';\n  }\n\n  const state: string = crypto.randomUUID();\n\n  sessionStorage.setItem(\n    `thunderid_oauth_${state}`,\n    JSON.stringify({\n      path: returnPath,\n      timestamp: Date.now(),\n    }),\n  );\n\n  const redirectUrlObj: URL = new URL(redirectURL);\n  redirectUrlObj.searchParams.set('state', state);\n\n  navigate(redirectUrlObj.toString());\n}\n"],"mappings":";;;;;;;;;AA0BA,SAAgB,sBAAsB,aAA2B;CAC/D,MAAMA,WAAmB,SAAS,cAAc,OAAO,EAAE,aAAa,OAAO,IAAI;CACjF,IAAIC,aAAqB,OAAO,SAAS;AAEzC,KAAI,YAAY,WAAW,WAAW,SAAS,CAC7C,cAAa,WAAW,MAAM,SAAS,OAAO,IAAI;CAGpD,MAAMC,QAAgB,OAAO,YAAY;AAEzC,gBAAe,QACb,mBAAmB,SACnB,KAAK,UAAU;EACb,MAAM;EACN,WAAW,KAAK,KAAK;EACtB,CAAC,CACH;CAED,MAAMC,iBAAsB,IAAI,IAAI,YAAY;AAChD,gBAAe,aAAa,IAAI,SAAS,MAAM;AAE/C,UAAS,eAAe,UAAU,CAAC"}

package/dist/utils/v2/buildThemeConfigFromFlowMeta.js

@@ -0,0 +1,47 @@
+//#region src/utils/v2/buildThemeConfigFromFlowMeta.ts
+/**
+* Converts a v2 `FlowMetaTheme` into a `RecursivePartial<ThemeConfig>` that
+* `createTheme` can consume.
+*
+* Only fields explicitly present in the FlowMeta response are included so that
+* `createTheme` can deep-merge them onto its base (light/dark) defaults without
+* accidentally dropping sibling keys that were not returned by the server.
+*
+* For example, when FlowMeta returns only `background.default` and
+* `background.paper`, only `body.main` and `surface` are set — the base
+* theme's `background.disabled` and `background.dark` are **not** overridden
+* and therefore keep their default CSS variable values.
+*/
+const buildThemeConfigFromFlowMeta = (flowMetaTheme, colorScheme) => {
+	const scheme = flowMetaTheme.colorSchemes?.[colorScheme];
+	const borderRadius = flowMetaTheme.shape?.borderRadius;
+	const borderRadiusStr = borderRadius !== void 0 ? `${borderRadius}px` : void 0;
+	let colors;
+	if (scheme?.palette) {
+		colors = {};
+		if (scheme.palette.primary) colors.primary = scheme.palette.primary;
+		if (scheme.palette.secondary) colors.secondary = scheme.palette.secondary;
+		if (scheme.palette.text) colors.text = scheme.palette.text;
+		if (scheme.palette.background) {
+			const bg = {};
+			if (scheme.palette.background.default) bg.body = { main: scheme.palette.background.default };
+			if (scheme.palette.background.paper) bg.surface = scheme.palette.background.paper;
+			if (Object.keys(bg).length > 0) colors.background = bg;
+		}
+	}
+	return {
+		...flowMetaTheme.direction ? { direction: flowMetaTheme.direction } : {},
+		...borderRadiusStr ? { borderRadius: {
+			large: borderRadiusStr,
+			medium: borderRadiusStr,
+			small: borderRadiusStr
+		} } : {},
+		...colors && Object.keys(colors).length > 0 ? { colors } : {},
+		...flowMetaTheme.typography?.fontFamily ? { typography: { fontFamily: flowMetaTheme.typography.fontFamily } } : {}
+	};
+};
+var buildThemeConfigFromFlowMeta_default = buildThemeConfigFromFlowMeta;
+
+//#endregion
+export { buildThemeConfigFromFlowMeta_default as default };
+//# sourceMappingURL=buildThemeConfigFromFlowMeta.js.map

package/dist/utils/v2/buildThemeConfigFromFlowMeta.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildThemeConfigFromFlowMeta.js","names":["scheme: FlowMetaThemeColorScheme | undefined","borderRadius: number | undefined","borderRadiusStr: string | undefined","colors: RecursivePartial<ThemeConfig['colors']> | undefined","bg: RecursivePartial<ThemeConfig['colors']['background']>"],"sources":["../../../src/utils/v2/buildThemeConfigFromFlowMeta.ts"],"sourcesContent":["/**\n * Copyright (c) 2026, WSO2 LLC. (https://www.wso2.com).\n *\n * WSO2 LLC. licenses this file to you under the Apache License,\n * Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing,\n * software distributed under the License is distributed on an\n * \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n * KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations\n * under the License.\n */\n\nimport {FlowMetaTheme, FlowMetaThemeColorScheme, RecursivePartial, ThemeConfig} from '@thunderid/browser';\n\n/**\n * Converts a v2 `FlowMetaTheme` into a `RecursivePartial<ThemeConfig>` that\n * `createTheme` can consume.\n *\n * Only fields explicitly present in the FlowMeta response are included so that\n * `createTheme` can deep-merge them onto its base (light/dark) defaults without\n * accidentally dropping sibling keys that were not returned by the server.\n *\n * For example, when FlowMeta returns only `background.default` and\n * `background.paper`, only `body.main` and `surface` are set — the base\n * theme's `background.disabled` and `background.dark` are **not** overridden\n * and therefore keep their default CSS variable values.\n */\nconst buildThemeConfigFromFlowMeta = (\n  flowMetaTheme: FlowMetaTheme,\n  colorScheme: 'light' | 'dark',\n): RecursivePartial<ThemeConfig> => {\n  const scheme: FlowMetaThemeColorScheme | undefined = flowMetaTheme.colorSchemes?.[colorScheme];\n  const borderRadius: number | undefined = flowMetaTheme.shape?.borderRadius;\n  const borderRadiusStr: string | undefined = borderRadius !== undefined ? `${borderRadius}px` : undefined;\n\n  // Build only the colors that the server actually provided.\n  // Each nested object is constructed incrementally so that absent fields are\n  // simply omitted rather than set to `undefined`, which would shadow the\n  // base-theme defaults inside `createTheme`.\n  let colors: RecursivePartial<ThemeConfig['colors']> | undefined;\n\n  if (scheme?.palette) {\n    colors = {};\n\n    if (scheme.palette.primary) {\n      colors.primary = scheme.palette.primary;\n    }\n    if (scheme.palette.secondary) {\n      colors.secondary = scheme.palette.secondary;\n    }\n    if (scheme.palette.text) {\n      colors.text = scheme.palette.text;\n    }\n\n    // Build background incrementally to avoid replacing the full base object.\n    if (scheme.palette.background) {\n      const bg: RecursivePartial<ThemeConfig['colors']['background']> = {};\n\n      if (scheme.palette.background.default) {\n        bg.body = {main: scheme.palette.background.default};\n      }\n      if (scheme.palette.background.paper) {\n        bg.surface = scheme.palette.background.paper;\n      }\n\n      if (Object.keys(bg).length > 0) {\n        colors.background = bg;\n      }\n    }\n  }\n\n  return {\n    ...(flowMetaTheme.direction ? {direction: flowMetaTheme.direction} : {}),\n    ...(borderRadiusStr\n      ? {\n          borderRadius: {\n            large: borderRadiusStr,\n            medium: borderRadiusStr,\n            small: borderRadiusStr,\n          },\n        }\n      : {}),\n    ...(colors && Object.keys(colors).length > 0 ? {colors} : {}),\n    ...(flowMetaTheme.typography?.fontFamily ? {typography: {fontFamily: flowMetaTheme.typography.fontFamily}} : {}),\n  };\n};\n\nexport default buildThemeConfigFromFlowMeta;\n"],"mappings":";;;;;;;;;;;;;;AAiCA,MAAM,gCACJ,eACA,gBACkC;CAClC,MAAMA,SAA+C,cAAc,eAAe;CAClF,MAAMC,eAAmC,cAAc,OAAO;CAC9D,MAAMC,kBAAsC,iBAAiB,SAAY,GAAG,aAAa,MAAM;CAM/F,IAAIC;AAEJ,KAAI,QAAQ,SAAS;AACnB,WAAS,EAAE;AAEX,MAAI,OAAO,QAAQ,QACjB,QAAO,UAAU,OAAO,QAAQ;AAElC,MAAI,OAAO,QAAQ,UACjB,QAAO,YAAY,OAAO,QAAQ;AAEpC,MAAI,OAAO,QAAQ,KACjB,QAAO,OAAO,OAAO,QAAQ;AAI/B,MAAI,OAAO,QAAQ,YAAY;GAC7B,MAAMC,KAA4D,EAAE;AAEpE,OAAI,OAAO,QAAQ,WAAW,QAC5B,IAAG,OAAO,EAAC,MAAM,OAAO,QAAQ,WAAW,SAAQ;AAErD,OAAI,OAAO,QAAQ,WAAW,MAC5B,IAAG,UAAU,OAAO,QAAQ,WAAW;AAGzC,OAAI,OAAO,KAAK,GAAG,CAAC,SAAS,EAC3B,QAAO,aAAa;;;AAK1B,QAAO;EACL,GAAI,cAAc,YAAY,EAAC,WAAW,cAAc,WAAU,GAAG,EAAE;EACvE,GAAI,kBACA,EACE,cAAc;GACZ,OAAO;GACP,QAAQ;GACR,OAAO;GACR,EACF,GACD,EAAE;EACN,GAAI,UAAU,OAAO,KAAK,OAAO,CAAC,SAAS,IAAI,EAAC,QAAO,GAAG,EAAE;EAC5D,GAAI,cAAc,YAAY,aAAa,EAAC,YAAY,EAAC,YAAY,cAAc,WAAW,YAAW,EAAC,GAAG,EAAE;EAChH;;AAGH,2CAAe"}

package/dist/utils/v2/flowTransformer.d.ts

@@ -1,5 +1,5 @@
 /**
- * Copyright (c) 2025, WSO2 LLC. (https://www.wso2.com).
+ * Copyright (c) 2025-2026, WSO2 LLC. (https://www.wso2.com).
  *
  * WSO2 LLC. licenses this file to you under the Apache License,
  * Version 2.0 (the "License"); you may not use this file except
@@ -46,8 +46,18 @@ import { UseTranslation } from '../../hooks/useTranslation';
  * Generic flow error response interface that covers common error structure
  */
 export interface FlowErrorResponse {
+    error?: {
+        code: string;
+        description: {
+            key: string;
+            defaultValue?: string;
+        };
+        message: {
+            key: string;
+            defaultValue?: string;
+        };
+    };
     executionId: string;
-    failureReason?: string;
     flowStatus: 'ERROR';
 }
 /**
@@ -84,13 +94,12 @@ export interface FlowTransformOptions {
 export declare const transformComponents: (response: any, t: UseTranslation["t"], resolveTranslations?: boolean, meta?: FlowMetadataResponse | null) => EmbeddedFlowComponent[];
 /**
  * Extract error message from flow error response.
- * Supports any flow error response that follows the standard structure.
- * Prioritizes failureReason if present, otherwise falls back to translated generic message.
  *
- * @param error - The error response object
- * @param t - Translation function for fallback messages
- * @param defaultErrorKey - Default translation key for generic errors
- * @returns Extracted error message or fallback
+ * Resolution order:
+ * 1. Structured `error` object: try i18n lookup via `t(error.message.key)`.
+ * 2. Fallback to `defaultValue` from `message`, then `description`.
+ * 3. Standard `Error.message`.
+ * 4. Generic translated fallback via `defaultErrorKey`.
  */
 export declare const extractErrorMessage: (error: FlowErrorResponse | any, t: UseTranslation["t"], defaultErrorKey?: string) => string;
 /**

package/dist/utils/v2/flowTransformer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flowTransformer.d.ts","sourceRoot":"","sources":["../../../src/utils/v2/flowTransformer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAC,uBAAuB,IAAI,qBAAqB,EAAE,oBAAoB,EAAC,MAAM,oBAAoB,CAAC;AAE1G,OAAO,EAAC,cAAc,EAAC,MAAM,4BAA4B,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAmHD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAC9B,UAAU,GAAG,EACb,GAAG,cAAc,CAAC,GAAG,CAAC,EACtB,6BAA0B,EAC1B,OAAO,oBAAoB,GAAG,IAAI,KACjC,qBAAqB,EAsBvB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,iBAAiB,GAAG,GAAG,EAC9B,GAAG,cAAc,CAAC,GAAG,CAAC,EACtB,wBAAuC,KACtC,MAaF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAChC,UAAU,GAAG,EACb,GAAG,cAAc,CAAC,GAAG,CAAC,EACtB,wBAAuC,KACtC,MAAM,GAAG,IAMX,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GAChC,UAAU,GAAG,EACb,GAAG,cAAc,CAAC,GAAG,CAAC,EACtB,UAAS,oBAAyB,EAClC,OAAO,oBAAoB,GAAG,IAAI,KACjC;IACD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACpC,UAAU,EAAE,qBAAqB,EAAE,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;CA8BrB,CAAC"}
+{"version":3,"file":"flowTransformer.d.ts","sourceRoot":"","sources":["../../../src/utils/v2/flowTransformer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAC,uBAAuB,IAAI,qBAAqB,EAAE,oBAAoB,EAAC,MAAM,oBAAoB,CAAC;AAE1G,OAAO,EAAC,cAAc,EAAC,MAAM,4BAA4B,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE;YAAC,GAAG,EAAE,MAAM,CAAC;YAAC,YAAY,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;QAClD,OAAO,EAAE;YAAC,GAAG,EAAE,MAAM,CAAC;YAAC,YAAY,CAAC,EAAE,MAAM,CAAA;SAAC,CAAC;KAC/C,CAAC;IACF,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;OAGG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB;AAmHD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAC9B,UAAU,GAAG,EACb,GAAG,cAAc,CAAC,GAAG,CAAC,EACtB,6BAA0B,EAC1B,OAAO,oBAAoB,GAAG,IAAI,KACjC,qBAAqB,EAsBvB,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAC9B,OAAO,iBAAiB,GAAG,GAAG,EAC9B,GAAG,cAAc,CAAC,GAAG,CAAC,EACtB,wBAAuC,KACtC,MAoCF,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB,GAChC,UAAU,GAAG,EACb,GAAG,cAAc,CAAC,GAAG,CAAC,EACtB,wBAAuC,KACtC,MAAM,GAAG,IAMX,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GAChC,UAAU,GAAG,EACb,GAAG,cAAc,CAAC,GAAG,CAAC,EACtB,UAAS,oBAAyB,EAClC,OAAO,oBAAoB,GAAG,IAAI,KACjC;IACD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACpC,UAAU,EAAE,qBAAqB,EAAE,CAAC;IACpC,WAAW,EAAE,MAAM,CAAC;CA8BrB,CAAC"}

package/dist/utils/v2/flowTransformer.js

@@ -0,0 +1,152 @@
+import resolveTranslationsInArray_default from "./resolveTranslationsInArray.js";
+
+//#region src/utils/v2/flowTransformer.ts
+/**
+* Create a mapping from ref to identifier based on data.inputs array.
+* This handles cases where meta.components use 'ref' to reference inputs,
+* and data.inputs contain the actual 'identifier' field.
+*
+* @param response - The flow response object
+* @returns Map of ref to identifier
+*/
+const createInputRefMapping = (response) => {
+	const mapping = /* @__PURE__ */ new Map();
+	if (response?.data?.inputs && Array.isArray(response.data.inputs)) response.data.inputs.forEach((input) => {
+		if (input.ref && input.identifier) mapping.set(input.ref, input.identifier);
+	});
+	return mapping;
+};
+/**
+* Create a mapping from action ref to nextNode based on data.actions array.
+* This handles cases where meta.components reference actions by ref,
+* and data.actions contain the actual nextNode field for routing.
+*
+* @param response - The flow response object
+* @returns Map of action ref to nextNode
+*/
+const createActionRefMapping = (response) => {
+	const mapping = /* @__PURE__ */ new Map();
+	if (response?.data?.actions && Array.isArray(response.data.actions)) response.data.actions.forEach((action) => {
+		if (action.ref && action.nextNode) mapping.set(action.ref, action.nextNode);
+	});
+	return mapping;
+};
+/**
+* Apply input ref mapping to components recursively.
+* This ensures that component.ref values are mapped to the correct identifier
+* from data.inputs, enabling proper form submission.
+*
+* @param components - Array of components to transform
+* @param refMapping - Map of ref to identifier
+* @param actionMapping - Map of action ref to nextNode
+* @param inputsData - Array of input data for resolving SELECT options
+* @returns Transformed components with correct identifiers and action references
+*/
+const applyInputRefMapping = (components, refMapping, actionMapping, inputsData = []) => components.map((component) => {
+	const transformedComponent = { ...component };
+	if (transformedComponent.ref && refMapping.has(transformedComponent.ref)) transformedComponent.ref = refMapping.get(transformedComponent.ref);
+	if (transformedComponent.type === "SELECT" && component.id) {
+		const inputData = inputsData.find((input) => input.ref === component.id);
+		if (inputData?.options) transformedComponent.options = inputData.options.map((opt) => {
+			if (typeof opt === "string") return {
+				label: opt,
+				value: opt
+			};
+			const value = typeof opt.value === "object" ? JSON.stringify(opt.value) : String(opt.value || "");
+			return {
+				label: typeof opt.label === "object" ? JSON.stringify(opt.label) : String(opt.label || value),
+				value
+			};
+		});
+	}
+	if (transformedComponent.type === "ACTION" && transformedComponent.id && actionMapping.has(transformedComponent.id)) transformedComponent.actionRef = actionMapping.get(transformedComponent.id);
+	if (transformedComponent.components && Array.isArray(transformedComponent.components)) transformedComponent.components = applyInputRefMapping(transformedComponent.components, refMapping, actionMapping, inputsData);
+	return transformedComponent;
+});
+/**
+* Transform and resolve translations in components from flow response.
+* This function extracts components from the response meta structure and optionally resolves
+* any translation strings within them. It also handles mapping of input refs to identifiers
+* and action refs to nextNode values.
+*
+* @param response - The flow response object containing components in meta structure
+* @param t - Translation function from useTranslation hook
+* @param resolveTranslations - Whether to resolve translation strings or keep them as i18n keys (default: true)
+* @returns Array of flow components with resolved or unresolved translations
+*/
+const transformComponents = (response, t, resolveTranslations = true, meta) => {
+	if (!response?.data?.meta?.components) return [];
+	let { components } = response.data.meta;
+	const refMapping = createInputRefMapping(response);
+	const actionMapping = createActionRefMapping(response);
+	const inputsData = response?.data?.inputs || [];
+	if (refMapping.size > 0 || actionMapping.size > 0 || inputsData.length > 0) components = applyInputRefMapping(components, refMapping, actionMapping, inputsData);
+	return resolveTranslations ? resolveTranslationsInArray_default(components, t, void 0, meta) : components;
+};
+/**
+* Extract error message from flow error response.
+*
+* Resolution order:
+* 1. Structured `error` object: try i18n lookup via `t(error.message.key)`.
+* 2. Fallback to `defaultValue` from `message`, then `description`.
+* 3. Standard `Error.message`.
+* 4. Generic translated fallback via `defaultErrorKey`.
+*/
+const extractErrorMessage = (error, t, defaultErrorKey = "errors.flow.generic") => {
+	if (error && typeof error === "object" && error.error) {
+		const flowError = error.error;
+		if (flowError?.message?.key) {
+			const translated = t(flowError.message.key);
+			if (translated && translated !== flowError.message.key) return translated;
+			const systemKey = `system.${flowError.message.key}`;
+			const systemTranslated = t(systemKey);
+			if (systemTranslated && systemTranslated !== systemKey) return systemTranslated;
+		}
+		const fallback = flowError?.message?.defaultValue ?? flowError?.description?.defaultValue;
+		if (fallback) return fallback;
+	}
+	if (error && typeof error === "object" && error.failureReason) return error.failureReason;
+	if (error instanceof Error && error.message) return error.message;
+	return t(defaultErrorKey);
+};
+/**
+* Check if a response is an error response and extract the error message.
+* This function identifies error responses by checking for ERROR status and failure reasons.
+*
+* @param response - The flow response to check
+* @param t - Translation function for error messages
+* @param defaultErrorKey - Default translation key for generic errors
+* @returns Error message string if response is an error, null otherwise
+*/
+const checkForErrorResponse = (response, t, defaultErrorKey = "errors.flow.generic") => {
+	if (response?.flowStatus === "ERROR") return extractErrorMessage(response, t, defaultErrorKey);
+	return null;
+};
+/**
+* Generic flow response normalizer that handles both success and error responses.
+* This is the main transformer function that should be used by all flow components.
+*
+* @param response - The raw flow response from the API
+* @param t - Translation function from useTranslation hook
+* @param options - Configuration options for transformation behavior
+* @returns Normalized flow response with executionId and transformed components
+* @throws {any} The original response if it's an error and throwOnError is true
+*/
+const normalizeFlowResponse = (response, t, options = {}, meta) => {
+	const { throwOnError = true, defaultErrorKey = "errors.flow.generic", resolveTranslations = true } = options;
+	if (checkForErrorResponse(response, t, defaultErrorKey) && throwOnError) throw response;
+	const additionalData = response?.data?.additionalData ?? {};
+	if (typeof additionalData["consentPrompt"] === "string") try {
+		const parsed = JSON.parse(additionalData["consentPrompt"]);
+		additionalData["consentPrompt"] = { purposes: Array.isArray(parsed) ? parsed : [] };
+	} catch {}
+	return {
+		additionalData,
+		components: transformComponents(response, t, resolveTranslations, meta),
+		executionId: response.executionId
+	};
+};
+
+//#endregion
+export { extractErrorMessage, normalizeFlowResponse };
+//# sourceMappingURL=flowTransformer.js.map

package/dist/utils/v2/flowTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowTransformer.js","names":["mapping: Map<string, string>","transformedComponent: any","inputData: any","value: string","refMapping: Map<string, string>","actionMapping: Map<string, string>","inputsData: any[]","resolveTranslationsInArray","flowError: FlowErrorResponse['error']","translated: string","systemTranslated: string","fallback: string | undefined","additionalData: Record<string, any>","parsed: any"],"sources":["../../../src/utils/v2/flowTransformer.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-2026, WSO2 LLC. (https://www.wso2.com).\n *\n * WSO2 LLC. licenses this file to you under the Apache License,\n * Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing,\n * software distributed under the License is distributed on an\n * \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n * KIND, either express or implied. See the License for the\n * specific language governing permissions and limitations\n * under the License.\n */\n\n/**\n * @fileoverview Shared flow response transformer utilities for v2 embedded flows.\n *\n * This module provides reusable transformation functions for normalizing embedded flow\n * responses from ThunderID APIs. It handles both successful responses with component\n * extraction and error responses with proper error message extraction.\n *\n * Key features:\n * - Component extraction from flow meta structure\n * - Translation string resolution in components\n * - Error response detection and message extraction\n * - Configurable error handling (throw vs return errors)\n *\n * Usage:\n * ```typescript\n * import { normalizeFlowResponse } from '../../../utils/v2/flowTransformer';\n *\n * const { executionId, components } = normalizeFlowResponse(apiResponse, t, {\n *   defaultErrorKey: 'components.signIn.errors.generic'\n * });\n * ```\n *\n * This transformer is used by both SignIn and SignUp v2 components to ensure\n * consistent response handling across all embedded flows.\n */\n\nimport {EmbeddedFlowComponentV2 as EmbeddedFlowComponent, FlowMetadataResponse} from '@thunderid/browser';\nimport resolveTranslationsInArray from './resolveTranslationsInArray';\nimport {UseTranslation} from '../../hooks/useTranslation';\n\n/**\n * Generic flow error response interface that covers common error structure\n */\nexport interface FlowErrorResponse {\n  error?: {\n    code: string;\n    description: {key: string; defaultValue?: string};\n    message: {key: string; defaultValue?: string};\n  };\n  executionId: string;\n  flowStatus: 'ERROR';\n}\n\n/**\n * Configuration options for flow transformation\n */\nexport interface FlowTransformOptions {\n  /**\n   * Default error message key for translation fallback\n   * @default 'errors.flow.generic'\n   */\n  defaultErrorKey?: string;\n  /**\n   * Whether to resolve translation strings or keep them as i18n keys\n   * @default true\n   */\n  resolveTranslations?: boolean;\n  /**\n   * Whether to throw errors or return them as normalized response\n   * @default true\n   */\n  throwOnError?: boolean;\n}\n\n/**\n * Create a mapping from ref to identifier based on data.inputs array.\n * This handles cases where meta.components use 'ref' to reference inputs,\n * and data.inputs contain the actual 'identifier' field.\n *\n * @param response - The flow response object\n * @returns Map of ref to identifier\n */\nconst createInputRefMapping = (response: any): Map<string, string> => {\n  const mapping: Map<string, string> = new Map<string, string>();\n\n  if (response?.data?.inputs && Array.isArray(response.data.inputs)) {\n    response.data.inputs.forEach((input: any) => {\n      if (input.ref && input.identifier) {\n        mapping.set(input.ref, input.identifier);\n      }\n    });\n  }\n\n  return mapping;\n};\n\n/**\n * Create a mapping from action ref to nextNode based on data.actions array.\n * This handles cases where meta.components reference actions by ref,\n * and data.actions contain the actual nextNode field for routing.\n *\n * @param response - The flow response object\n * @returns Map of action ref to nextNode\n */\nconst createActionRefMapping = (response: any): Map<string, string> => {\n  const mapping: Map<string, string> = new Map<string, string>();\n\n  if (response?.data?.actions && Array.isArray(response.data.actions)) {\n    response.data.actions.forEach((action: any) => {\n      if (action.ref && action.nextNode) {\n        mapping.set(action.ref, action.nextNode);\n      }\n    });\n  }\n\n  return mapping;\n};\n\n/**\n * Apply input ref mapping to components recursively.\n * This ensures that component.ref values are mapped to the correct identifier\n * from data.inputs, enabling proper form submission.\n *\n * @param components - Array of components to transform\n * @param refMapping - Map of ref to identifier\n * @param actionMapping - Map of action ref to nextNode\n * @param inputsData - Array of input data for resolving SELECT options\n * @returns Transformed components with correct identifiers and action references\n */\nconst applyInputRefMapping = (\n  components: EmbeddedFlowComponent[],\n  refMapping: Map<string, string>,\n  actionMapping: Map<string, string>,\n  inputsData: any[] = [],\n): EmbeddedFlowComponent[] =>\n  components.map((component: EmbeddedFlowComponent) => {\n    const transformedComponent: any = {...component} as EmbeddedFlowComponent & {\n      actionRef?: string;\n      options?: {label: string; value: string}[];\n    };\n\n    // If this component has a ref that maps to an identifier, update it\n    if (transformedComponent.ref && refMapping.has(transformedComponent.ref)) {\n      transformedComponent.ref = refMapping.get(transformedComponent.ref);\n    }\n\n    // For SELECT components, copy options from data.inputs\n    // The component.id matches the input.ref in the data structure\n    if (transformedComponent.type === 'SELECT' && component.id) {\n      const inputData: any = inputsData.find((input: any) => input.ref === component.id);\n      if (inputData?.options) {\n        transformedComponent.options = inputData.options.map((opt: any) => {\n          if (typeof opt === 'string') {\n            return {label: opt, value: opt};\n          }\n          // Safely handle non-string values to prevent React key crashes\n          const value: string = typeof opt.value === 'object' ? JSON.stringify(opt.value) : String(opt.value || '');\n          const label: string = typeof opt.label === 'object' ? JSON.stringify(opt.label) : String(opt.label || value);\n\n          return {label, value};\n        });\n      }\n    }\n\n    // If this is an action component, map its id to the nextNode\n    // Store the nextNode reference as actionRef property for later use\n    if (\n      transformedComponent.type === 'ACTION' &&\n      transformedComponent.id &&\n      actionMapping.has(transformedComponent.id)\n    ) {\n      transformedComponent.actionRef = actionMapping.get(transformedComponent.id);\n    }\n\n    // Recursively apply to nested components\n    if (transformedComponent.components && Array.isArray(transformedComponent.components)) {\n      transformedComponent.components = applyInputRefMapping(\n        transformedComponent.components,\n        refMapping,\n        actionMapping,\n        inputsData,\n      );\n    }\n\n    return transformedComponent;\n  });\n\n/**\n * Transform and resolve translations in components from flow response.\n * This function extracts components from the response meta structure and optionally resolves\n * any translation strings within them. It also handles mapping of input refs to identifiers\n * and action refs to nextNode values.\n *\n * @param response - The flow response object containing components in meta structure\n * @param t - Translation function from useTranslation hook\n * @param resolveTranslations - Whether to resolve translation strings or keep them as i18n keys (default: true)\n * @returns Array of flow components with resolved or unresolved translations\n */\nexport const transformComponents = (\n  response: any,\n  t: UseTranslation['t'],\n  resolveTranslations = true,\n  meta?: FlowMetadataResponse | null,\n): EmbeddedFlowComponent[] => {\n  if (!response?.data?.meta?.components) {\n    return [];\n  }\n\n  let {components} = response.data.meta;\n\n  // Create mapping from ref to identifier based on data.inputs\n  const refMapping: Map<string, string> = createInputRefMapping(response);\n\n  // Create mapping from action ref to nextNode based on data.actions\n  const actionMapping: Map<string, string> = createActionRefMapping(response);\n\n  // Get inputs data for SELECT option resolution\n  const inputsData: any[] = response?.data?.inputs || [];\n\n  // Apply ref and action mapping if there are any mappings\n  if (refMapping.size > 0 || actionMapping.size > 0 || inputsData.length > 0) {\n    components = applyInputRefMapping(components, refMapping, actionMapping, inputsData);\n  }\n\n  return resolveTranslations ? resolveTranslationsInArray(components, t, undefined, meta) : components;\n};\n\n/**\n * Extract error message from flow error response.\n *\n * Resolution order:\n * 1. Structured `error` object: try i18n lookup via `t(error.message.key)`.\n * 2. Fallback to `defaultValue` from `message`, then `description`.\n * 3. Standard `Error.message`.\n * 4. Generic translated fallback via `defaultErrorKey`.\n */\nexport const extractErrorMessage = (\n  error: FlowErrorResponse | any,\n  t: UseTranslation['t'],\n  defaultErrorKey = 'errors.flow.generic',\n): string => {\n  if (error && typeof error === 'object' && error.error) {\n    const flowError: FlowErrorResponse['error'] = error.error;\n\n    // 1. Try i18n lookup on message.key first (preferred for user-facing errors)\n    if (flowError?.message?.key) {\n      const translated: string = t(flowError.message.key);\n      if (translated && translated !== flowError.message.key) {\n        return translated;\n      }\n\n      // If the key resolved to itself, retry under the 'system:' namespace\n      const systemKey = `system.${flowError.message.key}`;\n      const systemTranslated: string = t(systemKey);\n      if (systemTranslated && systemTranslated !== systemKey) {\n        return systemTranslated;\n      }\n    }\n\n    // 2. Fall back to defaultValue from message, then description\n    const fallback: string | undefined = flowError?.message?.defaultValue ?? flowError?.description?.defaultValue;\n    if (fallback) {\n      return fallback;\n    }\n  }\n\n  // Legacy backward compatibility\n  if (error && typeof error === 'object' && error.failureReason) {\n    return error.failureReason;\n  }\n\n  if (error instanceof Error && error.message) {\n    return error.message;\n  }\n\n  return t(defaultErrorKey);\n};\n\n/**\n * Check if a response is an error response and extract the error message.\n * This function identifies error responses by checking for ERROR status and failure reasons.\n *\n * @param response - The flow response to check\n * @param t - Translation function for error messages\n * @param defaultErrorKey - Default translation key for generic errors\n * @returns Error message string if response is an error, null otherwise\n */\nexport const checkForErrorResponse = (\n  response: any,\n  t: UseTranslation['t'],\n  defaultErrorKey = 'errors.flow.generic',\n): string | null => {\n  if (response?.flowStatus === 'ERROR') {\n    return extractErrorMessage(response, t, defaultErrorKey);\n  }\n\n  return null;\n};\n\n/**\n * Generic flow response normalizer that handles both success and error responses.\n * This is the main transformer function that should be used by all flow components.\n *\n * @param response - The raw flow response from the API\n * @param t - Translation function from useTranslation hook\n * @param options - Configuration options for transformation behavior\n * @returns Normalized flow response with executionId and transformed components\n * @throws {any} The original response if it's an error and throwOnError is true\n */\nexport const normalizeFlowResponse = (\n  response: any,\n  t: UseTranslation['t'],\n  options: FlowTransformOptions = {},\n  meta?: FlowMetadataResponse | null,\n): {\n  additionalData: Record<string, any>;\n  components: EmbeddedFlowComponent[];\n  executionId: string;\n} => {\n  const {throwOnError = true, defaultErrorKey = 'errors.flow.generic', resolveTranslations = true} = options;\n\n  // Check if this is an error response\n  const errorMessage: string | null = checkForErrorResponse(response, t, defaultErrorKey);\n\n  if (errorMessage && throwOnError) {\n    // Throw the original response so it can be caught by error handling\n    throw response;\n  }\n\n  const additionalData: Record<string, any> = (response?.data?.additionalData as Record<string, any>) ?? {};\n\n  // The consent prompt is serialized as a JSON string (array) by the backend.\n  // Parse it and wrap in the expected {purposes: [...]} structure.\n  if (typeof additionalData['consentPrompt'] === 'string') {\n    try {\n      const parsed: any = JSON.parse(additionalData['consentPrompt']);\n      additionalData['consentPrompt'] = {purposes: Array.isArray(parsed) ? parsed : []};\n    } catch {\n      // Leave unparseable value as-is\n    }\n  }\n\n  return {\n    additionalData,\n    components: transformComponents(response, t, resolveTranslations, meta),\n    executionId: response.executionId,\n  };\n};\n"],"mappings":"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"}

package/dist/utils/v2/getAuthComponentHeadings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getAuthComponentHeadings.d.ts","sourceRoot":"","sources":["../../../src/utils/v2/getAuthComponentHeadings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAC,uBAAuB,IAAI,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AAEpF;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACtC,UAAU,EAAE,qBAAqB,GAAG,IAAI,CAAC;CAC1C;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,yBAAyB,EAAE,qBAAqB,EAAE,CAAC;IACnD,iBAAiB,EAAE,uBAAuB,CAAC;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,QAAA,MAAM,wBAAwB,GAC5B,YAAY,qBAAqB,EAAE,EACnC,YAAY,MAAM,EAClB,eAAe,MAAM,EACrB,eAAe,MAAM,EACrB,kBAAkB,MAAM,KACvB,2BAkFF,CAAC;AAEF,eAAe,wBAAwB,CAAC"}
+{"version":3,"file":"getAuthComponentHeadings.d.ts","sourceRoot":"","sources":["../../../src/utils/v2/getAuthComponentHeadings.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAC,uBAAuB,IAAI,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AAEpF;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,OAAO,EAAE,qBAAqB,GAAG,IAAI,CAAC;IACtC,UAAU,EAAE,qBAAqB,GAAG,IAAI,CAAC;CAC1C;AAED;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,yBAAyB,EAAE,qBAAqB,EAAE,CAAC;IACnD,iBAAiB,EAAE,uBAAuB,CAAC;IAC3C,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,QAAA,MAAM,wBAAwB,GAC5B,YAAY,qBAAqB,EAAE,EACnC,YAAY,MAAM,EAClB,eAAe,MAAM,EACrB,eAAe,MAAM,EACrB,kBAAkB,MAAM,KACvB,2BA6EF,CAAC;AAEF,eAAe,wBAAwB,CAAC"}