@qlik/api 1.30.0 → 1.31.0

package/chunks/{G6QUM5WQ.js → FKDGGR2O.js}

@@ -6,37 +6,79 @@ import {
   isNode
 } from "./2ZQ3ZX7F.js";
 
+// src/auth/internal/host-config-registry.ts
+var registeredHostConfigs = {};
+function registerHostConfigInternal(name, hostConfig) {
+  if (hostConfig?.reference) {
+    throw new InvalidHostConfigError("Cannot register a host config with a reference");
+  }
+  if (registeredHostConfigs[name]) {
+    console.warn(`registerHostConfig: Host config with name "${name}" is already registered. Overwriting.`);
+  }
+  registeredHostConfigs[name] = hostConfig;
+}
+function unregisterHostConfigInternal(name) {
+  if (registeredHostConfigs[name]) {
+    delete registeredHostConfigs[name];
+  } else {
+    console.warn(`unregisterHostConfig: Host config with name "${name}" not found.`);
+  }
+}
+function getRegisteredHostConfigInternal(name) {
+  if (!registeredHostConfigs[name]) {
+    throw new Error(`Host config with name "${name}" not found.`);
+  }
+  return registeredHostConfigs[name];
+}
+
+// src/auth/internal/default-host-config.ts
+var defaultHostConfig = {};
+function setDefaultHostConfigInternal(hostConfig) {
+  defaultHostConfig = hostConfig || {};
+}
+function withResolvedHostConfig(hostConfig) {
+  if (hostConfig?.reference) {
+    return getRegisteredHostConfigInternal(hostConfig.reference);
+  }
+  if (hostConfig && Object.keys(hostConfig).length > 0) {
+    return hostConfig;
+  }
+  return defaultHostConfig;
+}
+
 // src/platform/platform-functions.ts
 var getPlatform = async (options = {}) => {
+  const hc = withResolvedHostConfig(options.hostConfig);
+  const isAnonymous = hc?.authType === "anonymous" || !!hc.accessCode;
   const isNodeEnvironment = typeof window === "undefined";
   if (isNodeEnvironment) {
-    return result({ isNodeEnv: true });
+    return result({ isNodeEnv: true, isAnonymous });
   }
   const { data: productInfo, status } = await getProductInfo(options);
   if (status === 404) {
-    return result({ isUnknown: true });
+    return result({ isUnknown: true, isAnonymous });
   }
   if (!productInfo || status <= 399 && status >= 300) {
-    return result({ isQSE: true, isWindows: true });
+    return result({ isQSE: true, isWindows: true, isAnonymous });
   }
   const deploymentType = (productInfo.composition?.deploymentType || "").toLowerCase();
   const isControlCenter = deploymentType === "controlcenter";
   if (deploymentType === "qliksenseserver") {
-    return result({ isQSE: true, isWindows: true, meta: extractMeta(productInfo) });
+    return result({ isQSE: true, isWindows: true, isAnonymous, meta: extractMeta(productInfo) });
   }
   if (deploymentType === "qliksensedesktop") {
-    return result({ isQSD: true, isWindows: true, meta: extractMeta(productInfo) });
+    return result({ isQSD: true, isWindows: true, isAnonymous, meta: extractMeta(productInfo) });
   }
   if (deploymentType === "qliksensemobile") {
-    return result({ isQSE: true, isWindows: true, meta: extractMeta(productInfo) });
+    return result({ isQSE: true, isWindows: true, isAnonymous, meta: extractMeta(productInfo) });
   }
   if (deploymentType === "cloud-console") {
-    return result({ isCloud: true, isCloudConsole: true, meta: extractMeta(productInfo) });
+    return result({ isCloud: true, isCloudConsole: true, isAnonymous, meta: extractMeta(productInfo) });
   }
   if (productInfo.composition?.provider === "fedramp") {
-    return result({ isCloud: true, isQCG: true, isControlCenter, meta: extractMeta(productInfo) });
+    return result({ isCloud: true, isQCG: true, isControlCenter, isAnonymous, meta: extractMeta(productInfo) });
   }
-  return result({ isCloud: true, isQCS: true, isControlCenter, meta: extractMeta(productInfo) });
+  return result({ isCloud: true, isQCS: true, isControlCenter, isAnonymous, meta: extractMeta(productInfo) });
 };
 var productInfoPromises = {};
 function templateUrl(baseUrl) {
@@ -105,21 +147,10 @@ var result = (data) => ({
   isQSE: false,
   isQSD: false,
   isUnknown: false,
+  isAnonymous: false,
   ...data
 });
 
-// src/auth/internal/default-host-config.ts
-var defaultHostConfig = {};
-function setDefaultHostConfig(hostConfig) {
-  defaultHostConfig = hostConfig || {};
-}
-function withDefaultHostConfig(hostConfig) {
-  if (hostConfig && Object.keys(hostConfig).length > 0) {
-    return hostConfig;
-  }
-  return defaultHostConfig;
-}
-
 // src/auth/internal/auth-module-registry.ts
 var authModules = {};
 var ongoingAuthModuleLoading = Promise.resolve();
@@ -133,7 +164,7 @@ function getRegisteredAuthModule(authType) {
   return authModules[authType.toLowerCase()];
 }
 async function getAuthModule(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(hostConfig);
   const authType = await determineAuthType(hostConfigToUse);
   if (ongoingAuthModuleLoading) {
     await ongoingAuthModuleLoading;
@@ -193,7 +224,7 @@ var InvalidAuthTypeError = class extends Error {
   constructor(authType) {
     const validAuthModules = getRegisteredAuthModules();
     super(
-      `Not a valid auth type: ${authType}, valid auth types are; '${validAuthModules.filter((name) => name !== "QmfeEmbedFramerAuthModule").join("', '")}'`
+      `Not a valid auth type: ${authType}, valid auth types are; '${validAuthModules.filter((name) => name.toLowerCase() !== "qmfeembedframerauthmodule").join("', '")}'`
     );
     this.name = "InvalidAuthTypeError";
   }
@@ -229,7 +260,7 @@ function isHostCrossOrigin(hostConfig) {
   if (!globalThis.location?.origin) {
     return true;
   }
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(hostConfig);
   if (Object.keys(hostConfigToUse).length === 0) {
     return false;
   }
@@ -241,7 +272,10 @@ function isHostCrossOrigin(hostConfig) {
   return false;
 }
 async function isWindows(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(hostConfig);
+  if (typeof hostConfigToUse.forceIsWindows === "boolean") {
+    return hostConfigToUse.forceIsWindows;
+  }
   if (hostConfigToUse.authType === "cookie") {
     return false;
   }
@@ -251,7 +285,7 @@ async function isWindows(hostConfig) {
   return (await getPlatform({ hostConfig })).isWindows;
 }
 function toValidLocationUrl(hostConfig) {
-  const url = withDefaultHostConfig(hostConfig)?.host;
+  const url = withResolvedHostConfig(hostConfig)?.host;
   let locationUrl;
   if (!url) {
     locationUrl = "";
@@ -266,7 +300,7 @@ function toValidLocationUrl(hostConfig) {
   return locationUrl;
 }
 function toValidWebsocketLocationUrl(hostConfig) {
-  const url = withDefaultHostConfig(hostConfig)?.host;
+  const url = withResolvedHostConfig(hostConfig)?.host;
   let locationUrl;
   if (!url) {
     locationUrl = globalThis.location.origin;
@@ -281,7 +315,7 @@ function toValidWebsocketLocationUrl(hostConfig) {
   return locationUrl.replace(leadingHttp, "ws");
 }
 async function getWebSocketAuthParams(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(props.hostConfig);
   try {
     const authModule = await getAuthModule(hostConfigToUse);
     return await authModule.getWebSocketAuthParams({
@@ -294,7 +328,7 @@ async function getWebSocketAuthParams(props) {
   }
 }
 async function getWebResourceAuthParams(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(props.hostConfig);
   try {
     const authModule = await getAuthModule(hostConfigToUse);
     return await authModule.getWebResourceAuthParams?.({
@@ -307,7 +341,7 @@ async function getWebResourceAuthParams(props) {
   }
 }
 async function handleAuthenticationError(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(props.hostConfig);
   const authModule = await getAuthModule(hostConfigToUse);
   const result2 = await authModule.handleAuthenticationError({
     ...props,
@@ -322,7 +356,7 @@ async function handleAuthenticationError(props) {
   return result2;
 }
 async function getRestCallAuthParams(props) {
-  const hostConfigToUse = withDefaultHostConfig(props.hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(props.hostConfig);
   try {
     const authModule = await getAuthModule(hostConfigToUse);
     return await authModule.getRestCallAuthParams({
@@ -345,11 +379,17 @@ async function getAccessToken(props) {
 function registerAuthModule2(name, authModule) {
   registerAuthModule(name, authModule);
 }
-function setDefaultHostConfig2(hostConfig) {
-  setDefaultHostConfig(hostConfig);
+function setDefaultHostConfig(hostConfig) {
+  setDefaultHostConfigInternal(hostConfig);
+}
+function registerHostConfig(name, hostConfig) {
+  registerHostConfigInternal(name, hostConfig);
+}
+function unregisterHostConfig(name) {
+  unregisterHostConfigInternal(name);
 }
 function serializeHostConfig(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(hostConfig);
   return JSON.stringify(hostConfigToUse, hostConfigPropertyIgnorer);
 }
 async function determineAuthType(hostConfig) {
@@ -368,13 +408,16 @@ async function determineAuthType(hostConfig) {
   if (hostConfig.webIntegrationId) {
     return "cookie";
   }
+  if (hostConfig.reference) {
+    return "reference";
+  }
   if (await isWindows(hostConfig)) {
     return "windowscookie";
   }
   return "cookie";
 }
 function checkForCrossDomainRequest(hostConfig) {
-  const hostConfigToUse = withDefaultHostConfig(hostConfig);
+  const hostConfigToUse = withResolvedHostConfig(hostConfig);
   if (isHostCrossOrigin(hostConfigToUse)) {
     if (Object.keys(hostConfigToUse).length === 0) {
       throw new InvalidHostConfigError("a host config must be provided when making a cross domain request");
@@ -467,6 +510,17 @@ function internalValidateHostConfig(hostConfig, options) {
   return true;
 }
 
+// src/utils/expose-internal-test-apis.ts
+var internalApisName = "__QLIK_INTERNAL__DO_NOT_USE_OR_YOU_WILL_BE_FIRED";
+function exposeInternalApiOnWindow(name, fn) {
+  if (globalThis.location?.origin.startsWith("https://localhost:") || globalThis.location?.origin?.endsWith("qlik-stage.com")) {
+    if (globalThis[internalApisName] === void 0) {
+      globalThis[internalApisName] = {};
+    }
+    globalThis[internalApisName][name] = fn;
+  }
+}
+
 // src/auth/internal/default-auth-modules/oauth/storage-helpers.ts
 var storagePrefix = "qlik-qmfe-api";
 function getTopicFromOauthHostConfig(hostConfig) {
@@ -483,6 +537,20 @@ function getTopicFromAnonHostConfig(hostConfig) {
   return `${hostConfig.accessCode}_${hostConfig.clientId}`;
 }
 var cachedTokens = {};
+function clearAllCachedTokens() {
+  for (const key in cachedTokens) {
+    delete cachedTokens[key];
+  }
+}
+exposeInternalApiOnWindow("clearAllAccessTokens", () => {
+  console.log("Clearing tokens", cachedTokens);
+  Object.keys(cachedTokens).forEach((key) => {
+    console.log("Clearing access tokens for", key);
+    deleteFromLocalStorage(key, ["access-token", "refresh-token"]);
+    deleteFromSessionStorage(key, ["access-token", "refresh-token"]);
+  });
+  clearAllCachedTokens();
+});
 function saveInLocalStorage(topic, name, value) {
   localStorage.setItem(`${storagePrefix}-${topic}-${name}`, value);
 }
@@ -551,6 +619,7 @@ async function loadOrAcquireAccessToken(topic, acquireTokens, noCache, accessTok
   const mayUseStorage = isBrowser();
   const storedOauthTokens = cachedTokens[topic] || (mayUseStorage ? loadOauthTokensFromStorage(topic, accessTokenStorage) : void 0);
   if (storedOauthTokens) {
+    cachedTokens[topic] = storedOauthTokens;
     return Promise.resolve(storedOauthTokens);
   }
   const tokensPromise = acquireTokens();
@@ -1415,6 +1484,23 @@ var oauth_default = {
   })
 };
 
+// src/auth/internal/default-auth-modules/reference.ts
+function getRestCallAuthParams7() {
+  throw new Error("getRestCallAuthParams should never be called for reference auth module");
+}
+function getWebSocketAuthParams7() {
+  throw new Error("getWebSocketAuthParams should never be called for reference auth module");
+}
+function handleAuthenticationError7() {
+  throw new Error("handleAuthenticationError should never be called for reference auth module");
+}
+var reference_default = {
+  getRestCallAuthParams: getRestCallAuthParams7,
+  getWebSocketAuthParams: getWebSocketAuthParams7,
+  handleAuthenticationError: handleAuthenticationError7,
+  validateHostConfig: (hostConfig) => internalValidateHostConfig(hostConfig, { requiredProps: ["reference"], optionalProps: [] })
+};
+
 // src/auth/internal/default-auth-modules/windows-cookie/xrf-keys.ts
 var xrfKeys = {};
 function createXrfKey() {
@@ -1438,7 +1524,7 @@ function getXrfKey(hostConfig) {
 }
 
 // src/auth/internal/default-auth-modules/windows-cookie.ts
-async function getRestCallAuthParams7({
+async function getRestCallAuthParams8({
   hostConfig
 }) {
   return {
@@ -1451,7 +1537,7 @@ async function getRestCallAuthParams7({
     credentials: getCredentialsForCookieAuth(hostConfig)
   };
 }
-async function getWebSocketAuthParams7({
+async function getWebSocketAuthParams8({
   hostConfig
 }) {
   return {
@@ -1461,7 +1547,7 @@ async function getWebSocketAuthParams7({
     }
   };
 }
-async function handleAuthenticationError7({
+async function handleAuthenticationError8({
   hostConfig
 }) {
   if (hostConfig.loginUri) {
@@ -1480,9 +1566,9 @@ async function handleAuthenticationError7({
   };
 }
 var windows_cookie_default = {
-  getRestCallAuthParams: getRestCallAuthParams7,
-  getWebSocketAuthParams: getWebSocketAuthParams7,
-  handleAuthenticationError: handleAuthenticationError7,
+  getRestCallAuthParams: getRestCallAuthParams8,
+  getWebSocketAuthParams: getWebSocketAuthParams8,
+  handleAuthenticationError: handleAuthenticationError8,
   validateHostConfig: (hostConfig) => internalValidateHostConfig(hostConfig, {
     requiredProps: [],
     optionalProps: ["loginUri", "crossSiteCookies"]
@@ -1500,6 +1586,7 @@ function registerDefaultAuthModules() {
     registerAuthModule("oauth2", oauth_default);
     registerAuthModule("anonymous", anonymous_default);
     registerAuthModule("windowscookie", windows_cookie_default);
+    registerAuthModule("reference", reference_default);
     authModulesRegistered = true;
   }
 }
@@ -1507,7 +1594,9 @@ registerDefaultAuthModules();
 var auth = {
   logout,
   registerAuthModule,
-  setDefaultHostConfig: setDefaultHostConfig2,
+  setDefaultHostConfig,
+  registerHostConfig,
+  unregisterHostConfig,
   getRestCallAuthParams,
   getWebSocketAuthParams,
   getWebResourceAuthParams,
@@ -2124,9 +2213,9 @@ function cleanStack(stack) {
 // src/invoke-fetch/invoke-fetch-functions.ts
 var defaultUserAgent = "qmfe-api/latest";
 async function invokeFetch(api, props, interceptors) {
-  interceptors = interceptors || getInterceptors();
+  const effectiveInterceptors = interceptors || getInterceptors();
   const invokeFetchFinal = (reqeust) => invokeFetchIntercepted(api, reqeust);
-  const withInterceptors = (interceptors || []).reduce(
+  const withInterceptors = (effectiveInterceptors || []).reduce(
     (proceed, interceptor) => (request) => interceptor(request, proceed),
     invokeFetchFinal
   );
@@ -2236,12 +2325,15 @@ export {
   getRestCallAuthParams,
   getAccessToken,
   registerAuthModule2 as registerAuthModule,
-  setDefaultHostConfig2 as setDefaultHostConfig,
+  setDefaultHostConfig,
+  registerHostConfig,
+  unregisterHostConfig,
   serializeHostConfig,
   determineAuthType,
   checkForCrossDomainRequest,
   logout,
   generateRandomString,
+  exposeInternalApiOnWindow,
   InvokeFetchError,
   EncodingError,
   invokeFetch,

package/chunks/{QK4TMJ64.js → GUU3KZGK.js}

@@ -1,6 +1,6 @@
 import {
   getAuthRuntimeModule
-} from "./TXC5XORK.js";
+} from "./DLKLPD7T.js";
 
 // src/public/auth.ts
 function registerAuthModule(name, authModule) {
@@ -12,12 +12,20 @@ function logout() {
 function setDefaultHostConfig(hostConfig) {
   void getAuthRuntimeModule(hostConfig).then((impl) => impl.setDefaultHostConfig(hostConfig));
 }
+function registerHostConfig(name, hostConfig) {
+  void getAuthRuntimeModule(hostConfig).then((impl) => impl.registerHostConfig(name, hostConfig));
+}
+function unregisterHostConfig(name) {
+  void getAuthRuntimeModule().then((impl) => impl.unregisterHostConfig(name));
+}
 async function getAccessToken({ hostConfig }) {
   return getAuthRuntimeModule(hostConfig).then((impl) => impl.getAccessToken({ hostConfig }));
 }
 var auth_default = {
   registerAuthModule,
   setDefaultHostConfig,
+  registerHostConfig,
+  unregisterHostConfig,
   getAccessToken
 };
 
@@ -25,6 +33,8 @@ export {
   registerAuthModule,
   logout,
   setDefaultHostConfig,
+  registerHostConfig,
+  unregisterHostConfig,
   getAccessToken,
   auth_default
 };

package/chunks/{IQBP2PKS.js → KBSD75QL.js}

@@ -1,6 +1,6 @@
 import {
   getQixRuntimeModule
-} from "./TXC5XORK.js";
+} from "./DLKLPD7T.js";
 
 // src/public/qix.ts
 function openAppSession(appSessionProps) {

package/chunks/{OTTC4QSX.js → LY7RP2HA.js}

@@ -15,11 +15,13 @@ import {
   isWindows,
   logout,
   registerAuthModule,
+  registerHostConfig,
   serializeHostConfig,
   setDefaultHostConfig,
   toValidLocationUrl,
-  toValidWebsocketLocationUrl
-} from "./G6QUM5WQ.js";
+  toValidWebsocketLocationUrl,
+  unregisterHostConfig
+} from "./FKDGGR2O.js";
 import "./3RGGGGAR.js";
 import "./2ZQ3ZX7F.js";
 export {
@@ -39,8 +41,10 @@ export {
   isWindows,
   logout,
   registerAuthModule,
+  registerHostConfig,
   serializeHostConfig,
   setDefaultHostConfig,
   toValidLocationUrl,
-  toValidWebsocketLocationUrl
+  toValidWebsocketLocationUrl,
+  unregisterHostConfig
 };