@asgardeo/javascript 0.9.1 → 0.10.0

package/dist/models/v2/embedded-flow-v2.d.ts

@@ -40,6 +40,8 @@ export declare enum EmbeddedFlowComponentType {
     Action = "ACTION",
     /** Container block component that groups other components */
     Block = "BLOCK",
+    /** Consent component for displaying consent purposes and attributes */
+    Consent = "CONSENT",
     /** Divider component for visual separation of content */
     Divider = "DIVIDER",
     /** Email input field with validation for email addresses. */
@@ -63,7 +65,9 @@ export declare enum EmbeddedFlowComponentType {
     /** Text display component for labels, headings, and messages */
     Text = "TEXT",
     /** Standard text input field for user data entry */
-    TextInput = "TEXT_INPUT"
+    TextInput = "TEXT_INPUT",
+    /** Timer component for displaying a countdown */
+    Timer = "TIMER"
 }
 /**
  * Action variant types for buttons and interactive elements.
@@ -380,6 +384,65 @@ export interface EmbeddedFlowResponseData {
      */
     redirectURL?: string;
 }
+/**
+ * Individual consent attribute/element decision.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ConsentAttributeElement {
+    /** Whether the user approved collection of this attribute */
+    approved: boolean;
+    /** The name of the attribute being consented */
+    name: string;
+}
+/**
+ * Consent decision for a single purpose.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ConsentPurposeDecision {
+    /** Whether the user approved this purpose */
+    approved: boolean;
+    /** Per-attribute decisions for this purpose */
+    elements: ConsentAttributeElement[];
+    /** The name of the consent purpose */
+    purpose_name: string;
+}
+/**
+ * Full consent decisions structure sent to the backend when user submits the consent form.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ConsentDecisions {
+    /** Array of per-purpose decisions */
+    purposes: ConsentPurposeDecision[];
+}
+/**
+ * Single consent purpose data returned by the backend in additionalData.consent_prompt.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ConsentPurposeData {
+    /** Optional human-readable description of the purpose */
+    description?: string;
+    /** Attributes that are always required and cannot be declined */
+    essential: string[];
+    /** Attributes that the user can optionally decline */
+    optional: string[];
+    /** Unique identifier for the purpose */
+    purpose_id: string;
+    /** Human-readable purpose name */
+    purpose_name: string;
+}
+/**
+ * Consent prompt data structure stored in additionalData.consent_prompt.
+ *
+ * @experimental This interface may change in future versions
+ */
+export interface ConsentPromptData {
+    /** Array of consent purposes requiring user review */
+    purposes: ConsentPurposeData[];
+}
 /**
  * Extended request configuration for Asgardeo V2 embedded flow operations.
  *

package/dist/models/v2/vars.d.ts

@@ -18,12 +18,12 @@
 import { FlowMetadataResponse } from './flow-meta-v2';
 import { TranslationFn } from './translation';
 /**
- * Options for the resolveVars function.
+ * Options for the resolveFlowTemplateLiterals function.
  *
  * @template TFn - The concrete translation function type.
  *   Defaults to the SDK-native {@link TranslationFn} signature.
  */
-export interface ResolveVarsOptions<TFn extends TranslationFn = TranslationFn> {
+export interface ResolveFlowTemplateLiteralsOptions<TFn extends TranslationFn = TranslationFn> {
     /**
      * Optional flow metadata for resolving `{{ meta(path) }}` expressions.
      */

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

@@ -0,0 +1,56 @@
+/**
+ * Copyright (c) 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
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Check whether a string contains a `{{ meta(key) }}` flow template literal anywhere within it.
+ *
+ * Unlike {@link isMetaFlowTemplateLiteral}, which requires the **entire** string to be the
+ * template, this function detects the pattern embedded inside a larger string such as an
+ * HTML label or sentence.
+ *
+ * Whitespace around `{{` / `}}` is allowed, e.g. `{{ meta(application.signUpUrl) }}`.
+ *
+ * @param str - The string to search (may be a plain value or an HTML fragment).
+ * @param key - The meta path to look for, e.g. `"application.signUpUrl"`.
+ * @returns `true` if the pattern is found anywhere in `str`, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * containsMetaFlowTemplateLiteral('<a href="{{meta(application.signUpUrl)}}">Sign up</a>', 'application.signUpUrl')
+ * // true
+ *
+ * containsMetaFlowTemplateLiteral('<a href="https://example.com">Sign up</a>', 'application.signUpUrl')
+ * // false
+ * ```
+ */
+export default function containsMetaFlowTemplateLiteral(str: string, key: string): boolean;
+/**
+ * Replace all occurrences of `{{ meta(key) }}` (with optional whitespace) in `str`
+ * with `replacement`.
+ *
+ * @param str - The source string.
+ * @param key - The meta path to replace, e.g. `"application.signUpUrl"`.
+ * @param replacement - The value to substitute for each match.
+ * @returns A new string with all occurrences replaced.
+ *
+ * @example
+ * ```typescript
+ * replaceMetaFlowTemplateLiteral('Sign up at {{ meta(application.signUpUrl) }}', 'application.signUpUrl', 'https://example.com')
+ * // 'Sign up at https://example.com'
+ * ```
+ */
+export declare function replaceMetaFlowTemplateLiteral(str: string, key: string, replacement: string): string;

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

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) 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
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Extracts the emoji character from an `emoji:` URI.
+ *
+ * @param uri - A URI string in the form `"emoji:<emoji>"`.
+ * @returns The emoji character, or an empty string if the URI is not a valid emoji URI.
+ *
+ * @example
+ * ```typescript
+ * extractEmojiFromUri("emoji:🐯"); // "🐯"
+ * extractEmojiFromUri("https://example.com"); // ""
+ * ```
+ */
+declare const extractEmojiFromUri: (uri: string) => string;
+export default extractEmojiFromUri;

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

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 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
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+export declare const EMOJI_URI_SCHEME: string;
+/**
+ * Checks whether a given URI uses the `emoji:` scheme (e.g. `"emoji:🐯"`).
+ *
+ * @param uri - The URI string to check.
+ * @returns `true` if the URI starts with `"emoji:"`, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * isEmojiUri("emoji:🐯");          // true
+ * isEmojiUri("https://example.com/logo.png"); // false
+ * isEmojiUri("");                  // false
+ * ```
+ */
+declare const isEmojiUri: (uri: string) => boolean;
+export default isEmojiUri;

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

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 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
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Regular expression to match a meta flow template literal `{{meta(key)}}` (exact, full-string match).
+ * Optional whitespace around `{{` / `}}` is allowed.
+ */
+export declare const META_FLOW_TEMPLATE_LITERAL_PATTERN: RegExp;
+/**
+ * Regular expression to extract the path from a meta flow template literal `{{meta(path)}}`.
+ */
+export declare const META_FLOW_TEMPLATE_LITERAL_KEY_PATTERN: RegExp;
+/**
+ * Check if a string is exactly a meta flow template literal (`{{ meta(path) }}`).
+ *
+ * This checks that the **entire** string is the template pattern. Use
+ * {@link FLOW_TEMPLATE_LITERAL_REGEX} from `parseFlowTemplateLiteral` to detect
+ * templates embedded inside a larger string.
+ *
+ * @param value - The string to test.
+ * @returns `true` if the trimmed value matches the pattern, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * isMetaFlowTemplateLiteral('{{ meta(application.name) }}') // true
+ * isMetaFlowTemplateLiteral('hello world')                  // false
+ * isMetaFlowTemplateLiteral('Login to {{ meta(app.name) }}') // false — embedded, not exact
+ * ```
+ */
+export default function isMetaFlowTemplateLiteral(value: string): boolean;

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

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 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
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Regular expression to match a translation flow template literal `{{t(key)}}` (exact, full-string match).
+ * Optional whitespace around `{{` / `}}` is allowed.
+ */
+export declare const TRANSLATION_FLOW_TEMPLATE_LITERAL_PATTERN: RegExp;
+/**
+ * Regular expression to extract the key from a translation flow template literal `{{t(key)}}`.
+ */
+export declare const TRANSLATION_FLOW_TEMPLATE_LITERAL_KEY_PATTERN: RegExp;
+/**
+ * Check if a string is exactly a translation flow template literal (`{{ t(key) }}`).
+ *
+ * This checks that the **entire** string is the template pattern. Use
+ * {@link FLOW_TEMPLATE_LITERAL_REGEX} from `parseFlowTemplateLiteral` to detect
+ * templates embedded inside a larger string.
+ *
+ * @param value - The string to test.
+ * @returns `true` if the trimmed value matches the pattern, `false` otherwise.
+ *
+ * @example
+ * ```typescript
+ * isTranslationFlowTemplateLiteral('{{ t(signin:heading) }}') // true
+ * isTranslationFlowTemplateLiteral('hello world')            // false
+ * isTranslationFlowTemplateLiteral('Login via {{ t(key) }}') // false — embedded, not exact
+ * ```
+ */
+export default function isTranslationFlowTemplateLiteral(value: string): boolean;

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

@@ -0,0 +1,95 @@
+/**
+ * Copyright (c) 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
+ * in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+/**
+ * Regular expression to detect a flow template literal wrapped in double braces.
+ * Matches patterns like `{{ t(key) }}`, `{{ meta(key) }}`, etc.
+ *
+ * Note: this regex has no `g` flag — use `new RegExp(FLOW_TEMPLATE_LITERAL_REGEX.source, 'g')`
+ * when global replacement is needed (e.g. in resolveFlowTemplateLiterals).
+ */
+export declare const FLOW_TEMPLATE_LITERAL_REGEX: RegExp;
+/**
+ * Regular expression to parse a function-call expression inside flow template braces.
+ * Matches `funcName(arg)` and captures the function name and argument.
+ */
+export declare const FLOW_TEMPLATE_FUNCTION_REGEX: RegExp;
+/**
+ * Flow template literal types supported by the SDK.
+ *
+ * Values correspond to the function name used in the template expression,
+ * so that a `{ t }` object from `useTranslation()` can be passed directly
+ * as a handler map.
+ */
+export declare enum FlowTemplateLiteralType {
+    /** Meta template literal — `{{ meta(path) }}` — resolves against flow/page metadata */
+    META = "meta",
+    /** Translation template literal — `{{ t(key) }}` */
+    TRANSLATION = "t",
+    /** Unknown or unsupported template literal format */
+    UNKNOWN = "unknown"
+}
+/**
+ * Result of parsing a flow template literal.
+ */
+export interface FlowTemplateLiteralResult {
+    /**
+     * The extracted key or path from the template literal.
+     * e.g. `"signin:heading"` from `"{{ t(signin:heading) }}"`.
+     */
+    key?: string;
+    /** The original template literal content before parsing */
+    originalValue: string;
+    /** The type of flow template literal that was detected */
+    type: FlowTemplateLiteralType;
+}
+/**
+ * Map of handler functions keyed by {@link FlowTemplateLiteralType}.
+ *
+ * When provided to a resolver, the matching handler is called with the extracted key.
+ * Because `FlowTemplateLiteralType.TRANSLATION === 't'`, you can pass the `{ t }` object
+ * from `useTranslation()` directly.
+ *
+ * @example
+ * ```typescript
+ * const { t } = useTranslation();
+ * // handler map: { t: (key) => string }
+ * ```
+ */
+export type FlowTemplateLiteralHandlers = Partial<Record<FlowTemplateLiteralType, (key: string) => string>>;
+/**
+ * Parse a flow template literal content string and extract its type and key.
+ *
+ * Supports function-call expressions like:
+ * - `t(signin:heading)`  → type `TRANSLATION`, key `"signin:heading"`
+ * - `meta(application.name)` → type `META`, key `"application.name"`
+ *
+ * Surrounding quotes on the key argument are stripped automatically.
+ *
+ * @param content - The content inside the template literal braces (without `{{ }}`).
+ * @returns Parsed flow template literal information.
+ *
+ * @example
+ * ```typescript
+ * parseFlowTemplateLiteral('t(signin:heading)')
+ * // { type: FlowTemplateLiteralType.TRANSLATION, key: 'signin:heading', originalValue: 't(signin:heading)' }
+ *
+ * parseFlowTemplateLiteral('meta(application.name)')
+ * // { type: FlowTemplateLiteralType.META, key: 'application.name', originalValue: 'meta(application.name)' }
+ * ```
+ */
+export default function parseFlowTemplateLiteral(content: string): FlowTemplateLiteralResult;

package/dist/utils/v2/{resolveVars.d.ts → resolveFlowTemplateLiterals.d.ts}

@@ -16,9 +16,9 @@
  * under the License.
  */
 import { TranslationFn } from '../../models/v2/translation';
-import { ResolveVarsOptions } from '../../models/v2/vars';
+import { ResolveFlowTemplateLiteralsOptions } from '../../models/v2/vars';
 /**
- * Resolves all template expressions in a string.
+ * Resolves all flow template literal expressions in a string.
  *
  * Supported patterns:
  *   - `{{ t(key) }}`       — resolved via the i18n translation function.
@@ -27,15 +27,15 @@ import { ResolveVarsOptions } from '../../models/v2/vars';
  *   - `{{ meta(path) }}`   — resolved via a dot-path lookup on FlowMetadataResponse.
  *                            `{{ meta(application.name) }}` → `meta.application?.name`
  *
- * Template expressions can be embedded inside larger strings:
+ * Flow template literals can be embedded inside larger strings:
  *   `"Login using {{ meta(application.name) }}"` → `"Login using My App"`
  *
- * Unrecognised expressions are left unchanged.
+ * Unrecognized expressions are left unchanged.
  *
  * @template TFn - The concrete translation function type.
  *
- * @param text - The string to resolve (may contain zero or more template expressions)
+ * @param text - The string to resolve (may contain zero or more flow template literals)
  * @param options - Resolution context: translation function and optional flow metadata
  * @returns The resolved string
  */
-export default function resolveVars<TFn extends TranslationFn = TranslationFn>(text: string | undefined, { t, meta }: ResolveVarsOptions<TFn>): string;
+export default function resolveFlowTemplateLiterals<TFn extends TranslationFn = TranslationFn>(text: string | undefined, { t, meta }: ResolveFlowTemplateLiteralsOptions<TFn>): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asgardeo/javascript",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Framework agnostic JavaScript SDK for Asgardeo.",
   "keywords": [
     "asgardeo",
@@ -47,7 +47,7 @@
   "dependencies": {
     "tslib": "2.8.1",
     "jose": "^5.2.0",
-    "@asgardeo/i18n": "0.4.3"
+    "@asgardeo/i18n": "0.4.4"
   },
   "publishConfig": {
     "access": "public"