@asgardeo/javascript 0.8.0 → 0.8.2

package/dist/cjs/index.js

@@ -1,6 +1,8 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
@@ -15,12 +17,21 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  AgentConfig: () => AgentConfig,
   ApplicationNativeAuthenticationConstants: () => ApplicationNativeAuthenticationConstants_default,
   AsgardeoAPIError: () => AsgardeoAPIError,
   AsgardeoAuthClient: () => AsgardeoAuthClient,
@@ -61,6 +72,7 @@ __export(index_exports, {
   base64urlToArrayBuffer: () => base64urlToArrayBuffer_default,
   bem: () => bem_default,
   configureLogger: () => configure,
+  countryCodeToFlagEmoji: () => countryCodeToFlagEmoji,
   createComponentLogger: () => createComponentLogger,
   createLogger: () => createLogger,
   createOrganization: () => createOrganization_default,
@@ -105,6 +117,10 @@ __export(index_exports, {
   removeTrailingSlash: () => removeTrailingSlash_default,
   resolveFieldName: () => resolveFieldName_default,
   resolveFieldType: () => resolveFieldType_default,
+  resolveLocaleDisplayName: () => resolveLocaleDisplayName,
+  resolveLocaleEmoji: () => resolveLocaleEmoji_default,
+  resolveMeta: () => resolveMeta,
+  resolveVars: () => resolveVars,
   set: () => set_default,
   transformBrandingPreferenceToTheme: () => transformBrandingPreferenceToTheme_default,
   updateMeProfile: () => updateMeProfile_default,
@@ -785,8 +801,9 @@ var IsomorphicCrypto = class {
    *
    * @returns - code challenge.
    */
-  getCodeChallenge(verifier) {
-    return this.cryptoUtils.base64URLEncode(this.cryptoUtils.hashSha256(verifier));
+  async getCodeChallenge(verifier) {
+    const hashed = await this.cryptoUtils.hashSha256(verifier);
+    return this.cryptoUtils.base64URLEncode(hashed);
   }
   /**
    * Get JWK used for the id_token
@@ -1006,6 +1023,31 @@ var StorageManager = class _StorageManager {
 };
 var StorageManager_default = StorageManager;
 
+// src/utils/deepMerge.ts
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && Object.prototype.toString.call(value) === "[object Object]";
+var deepMerge = (target, ...sources) => {
+  if (!target || typeof target !== "object") {
+    throw new Error("Target must be an object");
+  }
+  const result = { ...target };
+  sources.forEach((source) => {
+    if (!source || typeof source !== "object") {
+      return;
+    }
+    Object.keys(source).forEach((key) => {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
+        result[key] = deepMerge(targetValue, sourceValue);
+      } else if (sourceValue !== void 0) {
+        result[key] = sourceValue;
+      }
+    });
+  });
+  return result;
+};
+var deepMerge_default = deepMerge;
+
 // src/utils/extractPkceStorageKeyFromState.ts
 var extractPkceStorageKeyFromState = (state) => {
   const index = parseInt(state.split("request_")[1], 10);
@@ -1246,7 +1288,7 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
       let codeChallenge;
       if (configData.enablePKCE) {
         codeVerifier = this.cryptoHelper?.getCodeVerifier();
-        codeChallenge = this.cryptoHelper?.getCodeChallenge(codeVerifier);
+        codeChallenge = await this.cryptoHelper?.getCodeChallenge(codeVerifier);
         await this.storageManager.setTemporaryDataParameter(pkceKey, codeVerifier, userId);
       }
       if (authRequestConfig["client_secret"]) {
@@ -2013,7 +2055,9 @@ var _AsgardeoAuthClient = class _AsgardeoAuthClient {
    * @preserve
    */
   async reInitialize(config) {
-    await this.storageManager.setConfigData(config);
+    const currentConfig = this.storageManager.getConfigData();
+    const newConfig = deepMerge_default(currentConfig, config);
+    await this.storageManager.setConfigData(newConfig);
     await this.loadOpenIDProviderConfiguration(true);
   }
   static async clearSession(userId) {
@@ -3379,10 +3423,14 @@ var EmbeddedFlowComponentType2 = /* @__PURE__ */ ((EmbeddedFlowComponentType3) =
   EmbeddedFlowComponentType3["Block"] = "BLOCK";
   EmbeddedFlowComponentType3["Divider"] = "DIVIDER";
   EmbeddedFlowComponentType3["EmailInput"] = "EMAIL_INPUT";
+  EmbeddedFlowComponentType3["Icon"] = "ICON";
+  EmbeddedFlowComponentType3["Image"] = "IMAGE";
   EmbeddedFlowComponentType3["OtpInput"] = "OTP_INPUT";
   EmbeddedFlowComponentType3["PasswordInput"] = "PASSWORD_INPUT";
   EmbeddedFlowComponentType3["PhoneInput"] = "PHONE_INPUT";
+  EmbeddedFlowComponentType3["RichText"] = "RICH_TEXT";
   EmbeddedFlowComponentType3["Select"] = "SELECT";
+  EmbeddedFlowComponentType3["Stack"] = "STACK";
   EmbeddedFlowComponentType3["Text"] = "TEXT";
   EmbeddedFlowComponentType3["TextInput"] = "TEXT_INPUT";
   return EmbeddedFlowComponentType3;
@@ -3439,6 +3487,12 @@ var FlowMode = /* @__PURE__ */ ((FlowMode2) => {
   return FlowMode2;
 })(FlowMode || {});
 
+// src/models/agent.ts
+var AgentConfig;
+((AgentConfig2) => {
+  AgentConfig2.DEFAULT_AUTHENTICATOR_NAME = "Username & Password";
+})(AgentConfig || (AgentConfig = {}));
+
 // src/models/scim2-schema.ts
 var WellKnownSchemaIds = /* @__PURE__ */ ((WellKnownSchemaIds2) => {
   WellKnownSchemaIds2["Core"] = "urn:ietf:params:scim:schemas:core:2.0";
@@ -3465,8 +3519,225 @@ var FieldType = /* @__PURE__ */ ((FieldType2) => {
   return FieldType2;
 })(FieldType || {});
 
+// src/DefaultCacheStore.ts
+var DefaultCacheStore = class {
+  constructor() {
+    __publicField(this, "cache");
+    this.cache = /* @__PURE__ */ new Map();
+  }
+  get length() {
+    return this.cache.size;
+  }
+  getItem(key) {
+    return this.cache.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.cache.set(key, value);
+  }
+  removeItem(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+  }
+  key(index) {
+    const keys = Array.from(this.cache.keys());
+    return keys[index] ?? null;
+  }
+  async setData(key, value) {
+    this.cache.set(key, value);
+  }
+  async getData(key) {
+    return this.cache.get(key) ?? "{}";
+  }
+  async removeData(key) {
+    this.cache.delete(key);
+  }
+};
+
+// src/DefaultCrypto.ts
+var jose = __toESM(require("jose"), 1);
+var DefaultCrypto = class {
+  // eslint-disable-next-line class-methods-use-this
+  base64URLDecode(value) {
+    const decodedArray = jose.base64url.decode(value);
+    return new TextDecoder().decode(decodedArray);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  base64URLEncode(value) {
+    return jose.base64url.encode(value);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  generateRandomBytes(length) {
+    return crypto.getRandomValues(new Uint8Array(length));
+  }
+  // eslint-disable-next-line class-methods-use-this
+  async hashSha256(data) {
+    const encoder = new TextEncoder();
+    const dataBuffer = encoder.encode(data);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", dataBuffer);
+    return new Uint8Array(hashBuffer);
+  }
+  // eslint-disable-next-line class-methods-use-this
+  async verifyJwt(idToken, jwk, algorithms, clientId, issuer, subject, clockTolerance, validateJwtIssuer = true) {
+    const key = await jose.importJWK(jwk);
+    await jose.jwtVerify(idToken, key, {
+      algorithms,
+      audience: clientId,
+      clockTolerance,
+      issuer: validateJwtIssuer ? issuer : void 0,
+      subject
+    });
+    return true;
+  }
+};
+
 // src/AsgardeoJavaScriptClient.ts
 var AsgardeoJavaScriptClient = class {
+  constructor(config, cacheStore, cryptoUtils) {
+    __publicField(this, "cacheStore");
+    __publicField(this, "cryptoUtils");
+    __publicField(this, "auth");
+    __publicField(this, "storageManager");
+    __publicField(this, "baseURL");
+    this.cacheStore = cacheStore ?? new DefaultCacheStore();
+    this.cryptoUtils = cryptoUtils ?? new DefaultCrypto();
+    this.auth = new AsgardeoAuthClient();
+    if (config) {
+      this.auth.initialize(config, this.cacheStore, this.cryptoUtils);
+      this.storageManager = this.auth.getStorageManager();
+    }
+    this.baseURL = config?.baseUrl ?? "";
+  }
+  /* eslint-disable class-methods-use-this, @typescript-eslint/no-unused-vars */
+  switchOrganization(_organization, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  initialize(_config, _storage) {
+    throw new Error("Method not implemented.");
+  }
+  reInitialize(_config) {
+    throw new Error("Method not implemented.");
+  }
+  getUser(_options) {
+    throw new Error("Method not implemented.");
+  }
+  getAllOrganizations(_options, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  getMyOrganizations(_options, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  getCurrentOrganization(_sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  getUserProfile(_options) {
+    throw new Error("Method not implemented.");
+  }
+  isLoading() {
+    throw new Error("Method not implemented.");
+  }
+  isSignedIn() {
+    throw new Error("Method not implemented.");
+  }
+  updateUserProfile(_payload, _userId) {
+    throw new Error("Method not implemented.");
+  }
+  getConfiguration() {
+    throw new Error("Method not implemented.");
+  }
+  exchangeToken(_config, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  signInSilently(_options) {
+    throw new Error("Method not implemented.");
+  }
+  getAccessToken(_sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  clearSession(_sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  setSession(_sessionData, _sessionId) {
+    throw new Error("Method not implemented.");
+  }
+  decodeJwtToken(_token) {
+    throw new Error("Method not implemented.");
+  }
+  signIn(_options) {
+    throw new Error("Method not implemented.");
+  }
+  signOut(_options, _sessionIdOrAfterSignOut, _afterSignOut) {
+    throw new Error("Method not implemented.");
+  }
+  signUp(_optionsOrPayload) {
+    throw new Error("Method not implemented.");
+  }
+  /* eslint-enable class-methods-use-this, @typescript-eslint/no-unused-vars */
+  async getAgentToken(agentConfig) {
+    const customParam = {
+      response_mode: "direct"
+    };
+    const authorizeURL = new URL(await this.auth.getSignInUrl(customParam));
+    const authorizeResponse = await initializeEmbeddedSignInFlow_default({
+      payload: Object.fromEntries(authorizeURL.searchParams.entries()),
+      url: `${authorizeURL.origin}${authorizeURL.pathname}`
+    });
+    const authenticatorName = agentConfig.authenticatorName ?? AgentConfig.DEFAULT_AUTHENTICATOR_NAME;
+    const targetAuthenticator = authorizeResponse.nextStep.authenticators.find(
+      (auth) => auth.authenticator === authenticatorName
+    );
+    if (!targetAuthenticator) {
+      throw new Error(`Authenticator '${authenticatorName}' not found among authentication steps.`);
+    }
+    const authnRequest = {
+      baseUrl: this.baseURL,
+      payload: {
+        flowId: authorizeResponse.flowId,
+        selectedAuthenticator: {
+          authenticatorId: targetAuthenticator.authenticatorId,
+          params: {
+            password: agentConfig.agentSecret,
+            username: agentConfig.agentID
+          }
+        }
+      }
+    };
+    const authnResponse = await executeEmbeddedSignInFlow_default(authnRequest);
+    if (authnResponse.flowStatus !== "SUCCESS_COMPLETED" /* SuccessCompleted */) {
+      throw new Error("Agent authentication failed.");
+    }
+    return this.auth.requestAccessToken(
+      authnResponse.authData["code"],
+      authnResponse.authData["session_state"],
+      authnResponse.authData["state"]
+    );
+  }
+  async getOBOSignInURL(agentConfig) {
+    const customParam = {
+      requested_actor: agentConfig.agentID
+    };
+    const authURL = await this.auth.getSignInUrl(customParam);
+    if (authURL) {
+      return authURL.toString();
+    }
+    throw new Error("Could not build Authorize URL");
+  }
+  async getOBOToken(agentConfig, authCodeResponse) {
+    const agentToken = await this.getAgentToken(agentConfig);
+    const tokenRequestConfig = {
+      params: {
+        actor_token: agentToken.accessToken
+      }
+    };
+    return this.auth.requestAccessToken(
+      authCodeResponse.code,
+      authCodeResponse.session_state,
+      authCodeResponse.state,
+      void 0,
+      tokenRequestConfig
+    );
+  }
 };
 var AsgardeoJavaScriptClient_default = AsgardeoJavaScriptClient;
 
@@ -4060,9 +4331,9 @@ var arrayBufferToBase64url = (buffer) => {
 var arrayBufferToBase64url_default = arrayBufferToBase64url;
 
 // src/utils/base64urlToArrayBuffer.ts
-var base64urlToArrayBuffer = (base64url) => {
-  const padding = "=".repeat((4 - base64url.length % 4) % 4);
-  const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/") + padding;
+var base64urlToArrayBuffer = (base64url2) => {
+  const padding = "=".repeat((4 - base64url2.length % 4) % 4);
+  const base64 = base64url2.replace(/-/g, "+").replace(/_/g, "/") + padding;
   const binaryString = atob(base64);
   const bytes = new Uint8Array(binaryString.length);
   for (let i = 0; i < binaryString.length; i += 1) {
@@ -4100,31 +4371,6 @@ var formatDate = (dateString) => {
 };
 var formatDate_default = formatDate;
 
-// src/utils/deepMerge.ts
-var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date) && !(value instanceof RegExp) && Object.prototype.toString.call(value) === "[object Object]";
-var deepMerge = (target, ...sources) => {
-  if (!target || typeof target !== "object") {
-    throw new Error("Target must be an object");
-  }
-  const result = { ...target };
-  sources.forEach((source) => {
-    if (!source || typeof source !== "object") {
-      return;
-    }
-    Object.keys(source).forEach((key) => {
-      const sourceValue = source[key];
-      const targetValue = result[key];
-      if (isPlainObject(sourceValue) && isPlainObject(targetValue)) {
-        result[key] = deepMerge(targetValue, sourceValue);
-      } else if (sourceValue !== void 0) {
-        result[key] = sourceValue;
-      }
-    });
-  });
-  return result;
-};
-var deepMerge_default = deepMerge;
-
 // src/utils/logger.ts
 var PREFIX = "\u{1F6E1}\uFE0F Asgardeo";
 var DEFAULT_CONFIG = {
@@ -4756,6 +5002,116 @@ var resolveFieldName = (field) => {
 };
 var resolveFieldName_default = resolveFieldName;
 
+// src/utils/v2/resolveMeta.ts
+function resolveMeta(path, meta) {
+  const value = path.split(".").reduce((current, part) => {
+    if (current == null || typeof current !== "object") {
+      return void 0;
+    }
+    const obj = current;
+    const snakePart = part.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+    return part in obj ? obj[part] : obj[snakePart];
+  }, meta);
+  return value != null ? String(value) : "";
+}
+
+// src/utils/v2/resolveVars.ts
+function resolveVars(text, { t, meta }) {
+  if (!text) {
+    return "";
+  }
+  return text.replace(/\{\{(.+?)\}\}/g, (match, content) => {
+    const trimmed = content.trim();
+    const tMatch = trimmed.match(/^t\((.+)\)$/);
+    if (tMatch) {
+      let key = tMatch[1].trim();
+      if (key.startsWith('"') && key.endsWith('"') || key.startsWith("'") && key.endsWith("'")) {
+        key = key.slice(1, -1);
+      }
+      return t(key.replace(/:/g, "."));
+    }
+    if (meta) {
+      const metaMatch = trimmed.match(/^meta\((.+)\)$/);
+      if (metaMatch) {
+        let path = metaMatch[1].trim();
+        if (path.startsWith('"') && path.endsWith('"') || path.startsWith("'") && path.endsWith("'")) {
+          path = path.slice(1, -1);
+        }
+        return resolveMeta(path, meta);
+      }
+    }
+    return match;
+  });
+}
+
+// src/utils/v2/countryCodeToFlagEmoji.ts
+function countryCodeToFlagEmoji(countryCode) {
+  return countryCode.toUpperCase().split("").map((char) => String.fromCodePoint(127462 - 65 + char.charCodeAt(0))).join("");
+}
+
+// src/utils/v2/resolveLocaleDisplayName.ts
+function resolveLocaleDisplayName(locale, displayLocale) {
+  try {
+    const displayNames = new Intl.DisplayNames([displayLocale], { type: "language" });
+    return displayNames.of(locale) ?? locale;
+  } catch {
+    return locale;
+  }
+}
+
+// src/utils/v2/resolveLocaleEmoji.ts
+var LANGUAGE_TO_COUNTRY = {
+  am: "ET",
+  ar: "SA",
+  bn: "BD",
+  cs: "CZ",
+  da: "DK",
+  de: "DE",
+  el: "GR",
+  en: "GB",
+  es: "ES",
+  fa: "IR",
+  fi: "FI",
+  fr: "FR",
+  he: "IL",
+  hi: "IN",
+  hu: "HU",
+  id: "ID",
+  it: "IT",
+  ja: "JP",
+  ko: "KR",
+  ml: "IN",
+  ms: "MY",
+  nl: "NL",
+  no: "NO",
+  pl: "PL",
+  pt: "PT",
+  ro: "RO",
+  ru: "RU",
+  si: "LK",
+  sk: "SK",
+  sv: "SE",
+  sw: "KE",
+  ta: "IN",
+  th: "TH",
+  tr: "TR",
+  uk: "UA",
+  ur: "PK",
+  vi: "VN",
+  zh: "CN"
+};
+function resolveLocaleEmoji(locale) {
+  const parts = locale.split("-");
+  const languageCode = parts[0].toLowerCase();
+  const countrySubtag = parts.length > 1 ? parts[parts.length - 1].toUpperCase() : void 0;
+  const countryCode = countrySubtag ?? LANGUAGE_TO_COUNTRY[languageCode];
+  if (!countryCode || countryCode.length !== 2) {
+    return "\u{1F310}";
+  }
+  return countryCodeToFlagEmoji(countryCode);
+}
+var resolveLocaleEmoji_default = resolveLocaleEmoji;
+
 // src/utils/withVendorCSSClassPrefix.ts
 var withVendorCSSClassPrefix = (className) => `${VendorConstants_default.VENDOR_PREFIX}-${className}`;
 var withVendorCSSClassPrefix_default = withVendorCSSClassPrefix;
@@ -4899,6 +5255,7 @@ var transformBrandingPreferenceToTheme = (brandingPreference, forceTheme) => {
 var transformBrandingPreferenceToTheme_default = transformBrandingPreferenceToTheme;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  AgentConfig,
   ApplicationNativeAuthenticationConstants,
   AsgardeoAPIError,
   AsgardeoAuthClient,
@@ -4939,6 +5296,7 @@ var transformBrandingPreferenceToTheme_default = transformBrandingPreferenceToTh
   base64urlToArrayBuffer,
   bem,
   configureLogger,
+  countryCodeToFlagEmoji,
   createComponentLogger,
   createLogger,
   createOrganization,
@@ -4983,6 +5341,10 @@ var transformBrandingPreferenceToTheme_default = transformBrandingPreferenceToTh
   removeTrailingSlash,
   resolveFieldName,
   resolveFieldType,
+  resolveLocaleDisplayName,
+  resolveLocaleEmoji,
+  resolveMeta,
+  resolveVars,
   set,
   transformBrandingPreferenceToTheme,
   updateMeProfile,