iureiure 1.0.0

package/packages/analytics-js/src/components/configManager/ConfigManager.ts

@@ -0,0 +1,218 @@
+/* eslint-disable class-methods-use-this */
+import type {
+  IHttpClient,
+  ResponseDetails,
+} from '@rudderstack/analytics-js-common/types/HttpClient';
+import { batch, effect } from '@preact/signals-core';
+import { isFunction, isString } from '@rudderstack/analytics-js-common/utilities/checks';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { Destination } from '@rudderstack/analytics-js-common/types/Destination';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import { CONFIG_MANAGER } from '@rudderstack/analytics-js-common/constants/loggerContexts';
+import { isValidSourceConfig, validateLoadArgs } from './util/validate';
+import {
+  DATA_PLANE_URL_ERROR,
+  SOURCE_CONFIG_FETCH_ERROR,
+  SOURCE_CONFIG_OPTION_ERROR,
+  SOURCE_CONFIG_RESOLUTION_ERROR,
+} from '../../constants/logMessages';
+import { getSourceConfigURL } from '../utilities/loadOptions';
+import { filterEnabledDestination } from '../utilities/destinations';
+import { removeTrailingSlashes } from '../utilities/url';
+import { APP_VERSION } from '../../constants/app';
+import { state } from '../../state';
+import { resolveDataPlaneUrl } from './util/dataPlaneResolver';
+import { getIntegrationsCDNPath, getPluginsCDNPath } from './util/cdnPaths';
+import type { IConfigManager, SourceConfigResponse } from './types';
+import {
+  updateConsentsState,
+  updateConsentsStateFromLoadOptions,
+  updateReportingState,
+  updateStorageStateFromLoadOptions,
+} from './util/commonUtil';
+
+class ConfigManager implements IConfigManager {
+  httpClient: IHttpClient;
+  errorHandler?: IErrorHandler;
+  logger?: ILogger;
+  hasErrorHandler = false;
+
+  constructor(httpClient: IHttpClient, errorHandler?: IErrorHandler, logger?: ILogger) {
+    this.errorHandler = errorHandler;
+    this.logger = logger;
+    this.httpClient = httpClient;
+    this.hasErrorHandler = Boolean(this.errorHandler);
+
+    this.onError = this.onError.bind(this);
+    this.processConfig = this.processConfig.bind(this);
+  }
+
+  attachEffects() {
+    effect(() => {
+      this.logger?.setMinLogLevel(state.lifecycle.logLevel.value);
+    });
+  }
+
+  /**
+   * A function to validate, construct and store loadOption, lifecycle, source and destination
+   * config related information in global state
+   */
+  init() {
+    this.attachEffects();
+
+    validateLoadArgs(state.lifecycle.writeKey.value, state.lifecycle.dataPlaneUrl.value);
+
+    const lockIntegrationsVersion = state.loadOptions.value.lockIntegrationsVersion as boolean;
+
+    // determine the path to fetch integration SDK from
+    const intgCdnUrl = getIntegrationsCDNPath(
+      APP_VERSION,
+      lockIntegrationsVersion,
+      state.loadOptions.value.destSDKBaseURL,
+    );
+    // determine the path to fetch remote plugins from
+    const pluginsCDNPath = getPluginsCDNPath(state.loadOptions.value.pluginsSDKBaseURL);
+
+    updateStorageStateFromLoadOptions(this.logger);
+    updateConsentsStateFromLoadOptions(this.logger);
+
+    // set application lifecycle state in global state
+    batch(() => {
+      state.lifecycle.integrationsCDNPath.value = intgCdnUrl;
+      state.lifecycle.pluginsCDNPath.value = pluginsCDNPath;
+
+      if (state.loadOptions.value.logLevel) {
+        state.lifecycle.logLevel.value = state.loadOptions.value.logLevel;
+      }
+
+      state.lifecycle.sourceConfigUrl.value = getSourceConfigURL(
+        state.loadOptions.value.configUrl,
+        state.lifecycle.writeKey.value as string,
+        lockIntegrationsVersion,
+        this.logger,
+      );
+    });
+
+    this.getConfig();
+  }
+
+  /**
+   * Handle errors
+   */
+  onError(error: unknown, customMessage?: string, shouldAlwaysThrow?: boolean) {
+    if (this.hasErrorHandler) {
+      this.errorHandler?.onError(error, CONFIG_MANAGER, customMessage, shouldAlwaysThrow);
+    } else {
+      throw error;
+    }
+  }
+
+  /**
+   * A callback function that is executed once we fetch the source config response.
+   * Use to construct and store information that are dependent on the sourceConfig.
+   */
+  processConfig(response?: SourceConfigResponse | string, details?: ResponseDetails) {
+    // TODO: add retry logic with backoff based on rejectionDetails.xhr.status
+    // We can use isErrRetryable utility method
+    if (!response) {
+      this.onError(SOURCE_CONFIG_FETCH_ERROR(details?.error));
+      return;
+    }
+
+    let res: SourceConfigResponse;
+    try {
+      if (isString(response)) {
+        res = JSON.parse(response);
+      } else {
+        res = response;
+      }
+    } catch (err) {
+      this.onError(err, SOURCE_CONFIG_RESOLUTION_ERROR, true);
+      return;
+    }
+
+    if (!isValidSourceConfig(res)) {
+      this.onError(new Error(SOURCE_CONFIG_RESOLUTION_ERROR), undefined, true);
+      return;
+    }
+
+    // set the values in state for reporting slice
+    updateReportingState(res, this.logger);
+
+    // determine the dataPlane url
+    const dataPlaneUrl = resolveDataPlaneUrl(
+      res.source.dataplanes,
+      state.lifecycle.dataPlaneUrl.value,
+      state.loadOptions.value.residencyServer,
+      this.logger,
+    );
+
+    if (!dataPlaneUrl) {
+      this.onError(new Error(DATA_PLANE_URL_ERROR), undefined, true);
+      return;
+    }
+    const nativeDestinations: Destination[] =
+      res.source.destinations.length > 0 ? filterEnabledDestination(res.source.destinations) : [];
+
+    // set in the state --> source, destination, lifecycle, reporting
+    batch(() => {
+      // set source related information in state
+      state.source.value = {
+        config: res.source.config,
+        id: res.source.id,
+      };
+
+      // set device mode destination related information in state
+      state.nativeDestinations.configuredDestinations.value = nativeDestinations;
+
+      // set the desired optional plugins
+      state.plugins.pluginsToLoadFromConfig.value = state.loadOptions.value.plugins ?? [];
+
+      updateConsentsState(res);
+
+      // set application lifecycle state
+      // Cast to string as we are sure that the value is not undefined
+      state.lifecycle.activeDataplaneUrl.value = removeTrailingSlashes(dataPlaneUrl) as string;
+      state.lifecycle.status.value = 'configured';
+    });
+  }
+
+  /**
+   * A function to fetch source config either from /sourceConfig endpoint
+   * or from getSourceConfig load option
+   * @returns
+   */
+  getConfig() {
+    const sourceConfigFunc = state.loadOptions.value.getSourceConfig;
+    if (sourceConfigFunc) {
+      if (!isFunction(sourceConfigFunc)) {
+        throw new Error(SOURCE_CONFIG_OPTION_ERROR);
+      }
+      // fetch source config from the function
+      const res = sourceConfigFunc();
+
+      if (res instanceof Promise) {
+        res
+          .then(pRes => this.processConfig(pRes as SourceConfigResponse))
+          .catch(err => {
+            this.onError(err, 'SourceConfig');
+          });
+      } else {
+        this.processConfig(res as SourceConfigResponse);
+      }
+    } else {
+      // fetch source config from config url API
+      this.httpClient.getAsyncData({
+        url: state.lifecycle.sourceConfigUrl.value as string,
+        options: {
+          headers: {
+            'Content-Type': undefined,
+          },
+        },
+        callback: this.processConfig,
+      });
+    }
+  }
+}
+
+export { ConfigManager };

package/packages/analytics-js/src/components/configManager/constants.ts

@@ -0,0 +1,21 @@
+import type { PluginName } from '@rudderstack/analytics-js-common/types/PluginsManager';
+
+const DEFAULT_ERROR_REPORTING_PROVIDER = 'bugsnag';
+const DEFAULT_STORAGE_ENCRYPTION_VERSION = 'v3';
+
+export const ConsentManagersToPluginNameMap: Record<string, PluginName> = {
+  oneTrust: 'OneTrustConsentManager',
+  ketch: 'KetchConsentManager',
+  custom: 'CustomConsentManager',
+};
+
+export const ErrorReportingProvidersToPluginNameMap: Record<string, PluginName> = {
+  [DEFAULT_ERROR_REPORTING_PROVIDER]: 'Bugsnag',
+};
+
+export const StorageEncryptionVersionsToPluginNameMap: Record<string, PluginName> = {
+  [DEFAULT_STORAGE_ENCRYPTION_VERSION]: 'StorageEncryption',
+  legacy: 'StorageEncryptionLegacy',
+};
+
+export { DEFAULT_ERROR_REPORTING_PROVIDER, DEFAULT_STORAGE_ENCRYPTION_VERSION };

package/packages/analytics-js/src/components/configManager/index.ts

@@ -0,0 +1 @@
+export { ConfigManager } from './ConfigManager';

package/packages/analytics-js/src/components/configManager/types.ts

@@ -0,0 +1,90 @@
+import type { DestinationConfig } from '@rudderstack/analytics-js-common/types/Destination';
+import type { Nullable } from '@rudderstack/analytics-js-common/types/Nullable';
+import type { StatsCollection } from '@rudderstack/analytics-js-common/types/Source';
+import type {
+  RegionDetails,
+  ResidencyServerRegion,
+} from '@rudderstack/analytics-js-common/types/DataResidency';
+import type { IHttpClient } from '@rudderstack/analytics-js-common/types/HttpClient';
+import type { IErrorHandler } from '@rudderstack/analytics-js-common/types/ErrorHandler';
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import type { ConsentManagementMetadata } from '@rudderstack/analytics-js-common/types/Consent';
+
+export type DestinationDefinition = {
+  name: string;
+  displayName: string;
+  updatedAt: string;
+};
+
+export type ConfigResponseDestinationItem = {
+  shouldApplyDeviceModeTransformation: boolean;
+  propagateEventsUntransformedOnError: boolean;
+  config: DestinationConfig;
+  updatedAt: string;
+  deleted: boolean;
+  destinationDefinition: DestinationDefinition;
+  enabled: boolean;
+  id: string;
+  name: string;
+};
+
+export type Connection = {
+  createdAt: string;
+  deleted: boolean;
+  destinationId: string;
+  enabled: boolean;
+  id: string;
+  sourceId: string;
+  updatedAt: string;
+};
+
+export type SourceDefinition = {
+  category: Nullable<any>;
+  config: Nullable<any>;
+  configSchema: Nullable<any>;
+  createdAt: string;
+  displayName: string;
+  id: string;
+  name: string;
+  options: Nullable<any>;
+  uiConfig: Nullable<any>;
+  updatedAt: string;
+};
+
+export type SourceConfigResponse = {
+  consentManagementMetadata?: ConsentManagementMetadata;
+  source: {
+    destinations: ConfigResponseDestinationItem[];
+    sourceDefinitionId: string;
+    transient: boolean;
+    updatedAt: string;
+    workspaceId: string;
+    writeKey: string;
+    enabled: boolean;
+    id: string;
+    liveEventsConfig: {
+      eventUpload: boolean;
+      eventUploadTS: number;
+    };
+    name: string;
+    secretVersion: Nullable<string>;
+    sourceDefinition: SourceDefinition;
+    config: {
+      statsCollection: StatsCollection;
+    };
+    connections: Connection[];
+    createdAt: string;
+    createdBy: string;
+    deleted: boolean;
+    dataplanes?: Record<ResidencyServerRegion, RegionDetails[]>;
+  };
+};
+
+export interface IConfigManager {
+  httpClient: IHttpClient;
+  errorHandler?: IErrorHandler;
+  logger?: ILogger;
+  init: () => void;
+  getConfig: () => void;
+  processConfig: () => void;
+}

package/packages/analytics-js/src/components/configManager/util/cdnPaths.ts

@@ -0,0 +1,80 @@
+import { isString } from '@rudderstack/analytics-js-common/utilities/checks';
+import { CDN_INT_DIR, CDN_PLUGINS_DIR } from '@rudderstack/analytics-js-common/constants/urls';
+import { CDN_ARCH_VERSION_DIR, DEST_SDK_BASE_URL, PLUGINS_BASE_URL } from '../../../constants/urls';
+import {
+  INTG_CDN_BASE_URL_ERROR,
+  PLUGINS_CDN_BASE_URL_ERROR,
+} from '../../../constants/logMessages';
+import { isValidUrl, removeTrailingSlashes } from '../../utilities/url';
+import { getSDKUrl } from './commonUtil';
+
+/**
+ * A function that determines integration SDK loading path
+ * @param requiredVersion
+ * @param lockIntegrationsVersion
+ * @param customIntegrationsCDNPath
+ * @returns
+ */
+const getIntegrationsCDNPath = (
+  requiredVersion: string,
+  lockIntegrationsVersion: boolean,
+  customIntegrationsCDNPath?: string,
+): string => {
+  let integrationsCDNPath = '';
+
+  // Get the CDN base URL from the user provided URL if any
+  if (customIntegrationsCDNPath) {
+    integrationsCDNPath = removeTrailingSlashes(customIntegrationsCDNPath) as string;
+
+    if (!integrationsCDNPath || (integrationsCDNPath && !isValidUrl(integrationsCDNPath))) {
+      throw new Error(INTG_CDN_BASE_URL_ERROR);
+    }
+
+    return integrationsCDNPath;
+  }
+
+  // Get the base path from the SDK script tag src attribute or use the default path
+  const sdkURL = getSDKUrl();
+  integrationsCDNPath =
+    sdkURL && isString(sdkURL)
+      ? sdkURL.split('/').slice(0, -1).concat(CDN_INT_DIR).join('/')
+      : DEST_SDK_BASE_URL;
+
+  // If version is not locked it will always get the latest version of the integrations
+  if (lockIntegrationsVersion) {
+    integrationsCDNPath = integrationsCDNPath.replace(CDN_ARCH_VERSION_DIR, requiredVersion);
+  }
+
+  return integrationsCDNPath;
+};
+
+/**
+ * A function that determines plugins SDK loading path
+ * @param customPluginsCDNPath
+ * @returns
+ */
+const getPluginsCDNPath = (customPluginsCDNPath?: string): string => {
+  let pluginsCDNPath = '';
+
+  // Get the CDN base URL from the user provided URL if any
+  if (customPluginsCDNPath) {
+    pluginsCDNPath = removeTrailingSlashes(customPluginsCDNPath) as string;
+
+    if (!pluginsCDNPath || (pluginsCDNPath && !isValidUrl(pluginsCDNPath))) {
+      throw new Error(PLUGINS_CDN_BASE_URL_ERROR);
+    }
+
+    return pluginsCDNPath;
+  }
+
+  // Get the base path from the SDK script tag src attribute or use the default path
+  const sdkURL = getSDKUrl();
+  pluginsCDNPath =
+    sdkURL && isString(sdkURL)
+      ? sdkURL.split('/').slice(0, -1).concat(CDN_PLUGINS_DIR).join('/')
+      : PLUGINS_BASE_URL;
+
+  return pluginsCDNPath;
+};
+
+export { getIntegrationsCDNPath, getPluginsCDNPath };

package/packages/analytics-js/src/components/configManager/util/commonUtil.ts

@@ -0,0 +1,262 @@
+import type { ILogger } from '@rudderstack/analytics-js-common/types/Logger';
+import { CONFIG_MANAGER } from '@rudderstack/analytics-js-common/constants/loggerContexts';
+import { batch } from '@preact/signals-core';
+import { isDefined, isUndefined } from '@rudderstack/analytics-js-common/utilities/checks';
+import { isSDKRunningInChromeExtension } from '@rudderstack/analytics-js-common/utilities/detect';
+import { DEFAULT_STORAGE_TYPE } from '@rudderstack/analytics-js-common/types/Storage';
+import type {
+  DeliveryType,
+  StorageStrategy,
+} from '@rudderstack/analytics-js-common/types/LoadOptions';
+import {
+  DEFAULT_PRE_CONSENT_EVENTS_DELIVERY_TYPE,
+  DEFAULT_PRE_CONSENT_STORAGE_STRATEGY,
+} from '@rudderstack/analytics-js-common/constants/consent';
+import { isObjectLiteralAndNotNull } from '@rudderstack/analytics-js-common/utilities/object';
+import type {
+  ConsentManagementMetadata,
+  ConsentResolutionStrategy,
+} from '@rudderstack/analytics-js-common/types/Consent';
+import { clone } from 'ramda';
+import { state } from '../../../state';
+import {
+  STORAGE_DATA_MIGRATION_OVERRIDE_WARNING,
+  STORAGE_TYPE_VALIDATION_WARNING,
+  UNSUPPORTED_ERROR_REPORTING_PROVIDER_WARNING,
+  UNSUPPORTED_PRE_CONSENT_EVENTS_DELIVERY_TYPE,
+  UNSUPPORTED_PRE_CONSENT_STORAGE_STRATEGY,
+  UNSUPPORTED_STORAGE_ENCRYPTION_VERSION_WARNING,
+} from '../../../constants/logMessages';
+import {
+  isErrorReportingEnabled,
+  isMetricsReportingEnabled,
+  getErrorReportingProviderNameFromConfig,
+} from '../../utilities/statsCollection';
+import { removeTrailingSlashes } from '../../utilities/url';
+import type { SourceConfigResponse } from '../types';
+import {
+  DEFAULT_ERROR_REPORTING_PROVIDER,
+  DEFAULT_STORAGE_ENCRYPTION_VERSION,
+  ErrorReportingProvidersToPluginNameMap,
+  StorageEncryptionVersionsToPluginNameMap,
+} from '../constants';
+import { isValidStorageType } from './validate';
+import { getConsentManagementData } from '../../utilities/consent';
+
+/**
+ * Determines the SDK url
+ * @returns sdkURL
+ */
+const getSDKUrl = (): string | undefined => {
+  const scripts = document.getElementsByTagName('script');
+  let sdkURL: string | undefined;
+  const scriptList = Array.prototype.slice.call(scripts);
+
+  scriptList.some(script => {
+    const curScriptSrc = removeTrailingSlashes(script.getAttribute('src'));
+    if (curScriptSrc) {
+      const urlMatches = curScriptSrc.match(/^.*rsa?(\.min)?\.js$/);
+      if (urlMatches) {
+        sdkURL = curScriptSrc;
+        return true;
+      }
+    }
+    return false;
+  });
+
+  return sdkURL;
+};
+
+/**
+ * Updates the reporting state variables from the source config data
+ * @param res Source config
+ * @param logger Logger instance
+ */
+const updateReportingState = (res: SourceConfigResponse, logger?: ILogger): void => {
+  state.reporting.isErrorReportingEnabled.value =
+    isErrorReportingEnabled(res.source.config) && !isSDKRunningInChromeExtension();
+  state.reporting.isMetricsReportingEnabled.value = isMetricsReportingEnabled(res.source.config);
+
+  if (state.reporting.isErrorReportingEnabled.value) {
+    const errReportingProvider = getErrorReportingProviderNameFromConfig(res.source.config);
+
+    // Get the corresponding plugin name of the selected error reporting provider from the supported error reporting providers
+    const errReportingProviderPlugin = errReportingProvider
+      ? ErrorReportingProvidersToPluginNameMap[errReportingProvider]
+      : undefined;
+
+    if (!isUndefined(errReportingProvider) && !errReportingProviderPlugin) {
+      // set the default error reporting provider
+      logger?.warn(
+        UNSUPPORTED_ERROR_REPORTING_PROVIDER_WARNING(
+          CONFIG_MANAGER,
+          errReportingProvider,
+          ErrorReportingProvidersToPluginNameMap,
+          DEFAULT_ERROR_REPORTING_PROVIDER,
+        ),
+      );
+    }
+
+    state.reporting.errorReportingProviderPluginName.value =
+      errReportingProviderPlugin ??
+      ErrorReportingProvidersToPluginNameMap[DEFAULT_ERROR_REPORTING_PROVIDER];
+  }
+};
+
+const updateStorageStateFromLoadOptions = (logger?: ILogger): void => {
+  const storageOptsFromLoad = state.loadOptions.value.storage;
+  let storageType = storageOptsFromLoad?.type;
+  if (isDefined(storageType) && !isValidStorageType(storageType)) {
+    logger?.warn(
+      STORAGE_TYPE_VALIDATION_WARNING(CONFIG_MANAGER, storageType, DEFAULT_STORAGE_TYPE),
+    );
+    storageType = DEFAULT_STORAGE_TYPE;
+  }
+
+  let storageEncryptionVersion = storageOptsFromLoad?.encryption?.version;
+  const encryptionPluginName =
+    storageEncryptionVersion && StorageEncryptionVersionsToPluginNameMap[storageEncryptionVersion];
+
+  if (!isUndefined(storageEncryptionVersion) && isUndefined(encryptionPluginName)) {
+    // set the default encryption plugin
+    logger?.warn(
+      UNSUPPORTED_STORAGE_ENCRYPTION_VERSION_WARNING(
+        CONFIG_MANAGER,
+        storageEncryptionVersion,
+        StorageEncryptionVersionsToPluginNameMap,
+        DEFAULT_STORAGE_ENCRYPTION_VERSION,
+      ),
+    );
+    storageEncryptionVersion = DEFAULT_STORAGE_ENCRYPTION_VERSION;
+  } else if (isUndefined(storageEncryptionVersion)) {
+    storageEncryptionVersion = DEFAULT_STORAGE_ENCRYPTION_VERSION;
+  }
+
+  // Allow migration only if the configured encryption version is the default encryption version
+  const configuredMigrationValue = storageOptsFromLoad?.migrate;
+  const finalMigrationVal =
+    (configuredMigrationValue as boolean) &&
+    storageEncryptionVersion === DEFAULT_STORAGE_ENCRYPTION_VERSION;
+
+  if (configuredMigrationValue === true && finalMigrationVal !== configuredMigrationValue) {
+    logger?.warn(
+      STORAGE_DATA_MIGRATION_OVERRIDE_WARNING(
+        CONFIG_MANAGER,
+        storageEncryptionVersion,
+        DEFAULT_STORAGE_ENCRYPTION_VERSION,
+      ),
+    );
+  }
+
+  batch(() => {
+    state.storage.type.value = storageType;
+    state.storage.cookie.value = storageOptsFromLoad?.cookie;
+
+    state.storage.encryptionPluginName.value =
+      StorageEncryptionVersionsToPluginNameMap[storageEncryptionVersion as string];
+
+    state.storage.migrate.value = finalMigrationVal;
+  });
+};
+
+const updateConsentsStateFromLoadOptions = (logger?: ILogger): void => {
+  const { provider, consentManagerPluginName, initialized, enabled, consentsData } =
+    getConsentManagementData(state.loadOptions.value.consentManagement, logger);
+
+  // Pre-consent
+  const preConsentOpts = state.loadOptions.value.preConsent;
+
+  let storageStrategy: StorageStrategy =
+    preConsentOpts?.storage?.strategy ?? DEFAULT_PRE_CONSENT_STORAGE_STRATEGY;
+  const StorageStrategies = ['none', 'session', 'anonymousId'];
+  if (isDefined(storageStrategy) && !StorageStrategies.includes(storageStrategy)) {
+    storageStrategy = DEFAULT_PRE_CONSENT_STORAGE_STRATEGY;
+
+    logger?.warn(
+      UNSUPPORTED_PRE_CONSENT_STORAGE_STRATEGY(
+        CONFIG_MANAGER,
+        preConsentOpts?.storage?.strategy,
+        DEFAULT_PRE_CONSENT_STORAGE_STRATEGY,
+      ),
+    );
+  }
+
+  let eventsDeliveryType: DeliveryType =
+    preConsentOpts?.events?.delivery ?? DEFAULT_PRE_CONSENT_EVENTS_DELIVERY_TYPE;
+  const deliveryTypes = ['immediate', 'buffer'];
+  if (isDefined(eventsDeliveryType) && !deliveryTypes.includes(eventsDeliveryType)) {
+    eventsDeliveryType = DEFAULT_PRE_CONSENT_EVENTS_DELIVERY_TYPE;
+
+    logger?.warn(
+      UNSUPPORTED_PRE_CONSENT_EVENTS_DELIVERY_TYPE(
+        CONFIG_MANAGER,
+        preConsentOpts?.events?.delivery,
+        DEFAULT_PRE_CONSENT_EVENTS_DELIVERY_TYPE,
+      ),
+    );
+  }
+
+  batch(() => {
+    state.consents.activeConsentManagerPluginName.value = consentManagerPluginName;
+    state.consents.initialized.value = initialized;
+    state.consents.enabled.value = enabled;
+    state.consents.data.value = consentsData;
+    state.consents.provider.value = provider;
+
+    state.consents.preConsent.value = {
+      // Only enable pre-consent if it is explicitly enabled and
+      // if it is not already initialized and
+      // if consent management is enabled
+      enabled:
+        state.loadOptions.value.preConsent?.enabled === true &&
+        initialized === false &&
+        enabled === true,
+      storage: {
+        strategy: storageStrategy,
+      },
+      events: {
+        delivery: eventsDeliveryType,
+      },
+    };
+  });
+};
+
+/**
+ * Determines the consent management state variables from the source config data
+ * @param resp Source config response
+ * @param logger Logger instance
+ */
+const updateConsentsState = (resp: SourceConfigResponse): void => {
+  let resolutionStrategy: ConsentResolutionStrategy | undefined =
+    state.consents.resolutionStrategy.value;
+
+  let cmpMetadata: ConsentManagementMetadata | undefined;
+  if (isObjectLiteralAndNotNull(resp.consentManagementMetadata)) {
+    if (state.consents.provider.value) {
+      resolutionStrategy =
+        resp.consentManagementMetadata.providers.find(
+          p => p.provider === state.consents.provider.value,
+        )?.resolutionStrategy ?? state.consents.resolutionStrategy.value;
+    }
+
+    cmpMetadata = resp.consentManagementMetadata;
+  }
+
+  // If the provider is custom, then the resolution strategy is not applicable
+  if (state.consents.provider.value === 'custom') {
+    resolutionStrategy = undefined;
+  }
+
+  batch(() => {
+    state.consents.metadata.value = clone(cmpMetadata);
+    state.consents.resolutionStrategy.value = resolutionStrategy;
+  });
+};
+
+export {
+  getSDKUrl,
+  updateReportingState,
+  updateStorageStateFromLoadOptions,
+  updateConsentsStateFromLoadOptions,
+  updateConsentsState,
+};