@trezor/connect 10.0.0-alpha.1 → 10.0.0-beta.1

package/libESM/data/firmwareInfo.mjs

@@ -1,411 +0,0 @@
-import { DeviceModelInternal, FirmwareType, getBootloaderVersionArray, getFirmwareOrBootloaderVersionArray, getFirmwareVersionArray } from "@trezor/device-utils";
-import { getIntegerInRangeFromString, removeTrailingSlashes, versionUtils } from "@trezor/utils";
-import * as firmwareReleaseStore from "./firmwareReleaseStore.mjs";
-import * as localFirmwareStore from "./localFirmwareStore.mjs";
-import * as settingsStore from "./settingsStore.mjs";
-import { getReleaseAsset, getReleasesAssetByDeviceModelAndFirmwareType } from "../utils/assetUtils.mjs";
-import { httpRequest } from "../utils/assets.mjs";
-import { getOnlineFirmwareBaseUrl } from "../utils/firmwareReleaseConfigUtils.mjs";
-import { buildIntermediaryFirmwareFileName, buildLocalFirmwareFileName, buildLocalReleaseName, findBestCompatibleRelease, isFirmwareCacheUsedForSelectedSource, isStrictFeatures } from "../utils/firmwareUtils.mjs";
-const getBundledFirmwareVersion = (deviceModel, firmwareType) => {
-  const localFirmwareReleaseConfig = firmwareReleaseStore.getLocal();
-  const modelReleases = localFirmwareReleaseConfig.releases[deviceModel];
-  const bundledRelease = modelReleases?.[firmwareType];
-  if (!bundledRelease) {
-    return;
-  }
-  const bundledVersion = bundledRelease.releasePath.match(/(\d+\.\d+\.\d+)/);
-  if (!bundledVersion) {
-    throw new Error('Fimrware bundled version was not found.');
-  }
-  return bundledVersion[0];
-};
-export const getBundledRelease = (deviceModel, firmwareType) => {
-  const version = getBundledFirmwareVersion(deviceModel, firmwareType);
-  if (!version) {
-    return;
-  }
-  const versionArray = versionUtils.tryParse(version);
-  if (!versionArray) {
-    throw new Error('There was error parsing bundled release.');
-  }
-  return getReleaseAsset(deviceModel, versionArray, firmwareType);
-};
-const getOnlineReleaseByPath = async releasePath => {
-  const onlineFirmwareBaseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
-  const url = `${onlineFirmwareBaseUrl.BASE_URL}/${releasePath}`;
-  const response = await httpRequest(url, 'json', {
-    signal: AbortSignal.timeout(10000),
-    skipLocalForceDownload: true
-  });
-  return response;
-};
-const getOnlineReleasePath = (deviceModel, firmwareVersion, firmwareType) => {
-  const onlineFirmwareBaseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
-  const firmwareTypeFileString = firmwareType === FirmwareType.BitcoinOnly ? 'bitcoinonly' : 'universal';
-  const relaseJsonFilename = `${deviceModel.toLowerCase()}-${firmwareVersion.join('.')}-${firmwareTypeFileString}.json`;
-  const origin = `${onlineFirmwareBaseUrl.MIDDLE_PATH}/${deviceModel.toLowerCase()}/${firmwareTypeFileString}`;
-  const releasePath = `${origin}/${relaseJsonFilename}`;
-  return releasePath;
-};
-export const getOnlineReleaseByVersion = async (deviceModel, firmwareVersion, firmwareType) => {
-  const releasePath = getOnlineReleasePath(deviceModel, firmwareVersion, firmwareType);
-  const onlineRelease = await getOnlineReleaseByPath(releasePath);
-  if (!onlineRelease || !versionUtils.isEqual(onlineRelease.version, firmwareVersion)) {
-    return;
-  }
-  return onlineRelease;
-};
-export const getReleaseConfig = (features, firmwareType) => {
-  const {
-    internal_model
-  } = features;
-  if (internal_model === DeviceModelInternal.UNKNOWN) {
-    return undefined;
-  }
-  const firmwareReleaseConfig = firmwareReleaseStore.getReleases();
-  if (!firmwareReleaseConfig) {
-    throw new Error('Firmware release config not loaded.');
-  }
-  const deviceMessageRelease = firmwareReleaseConfig[internal_model];
-  if (!deviceMessageRelease) {
-    return;
-  }
-  return deviceMessageRelease[firmwareType];
-};
-export const getReleaseByVersion = async (features, firmwareVersion, firmwareType) => {
-  const deviceModel = features.internal_model;
-  const tryGetRelease = async getter => {
-    try {
-      return await getter();
-    } catch {
-      return;
-    }
-  };
-  const releaseFromConfig = getReleaseConfig(features, firmwareType)?.release;
-  if (releaseFromConfig && versionUtils.isEqual(firmwareVersion, releaseFromConfig.version)) {
-    return releaseFromConfig;
-  }
-  const releaseName = buildLocalReleaseName(firmwareType, deviceModel, firmwareVersion);
-  const {
-    firmwareDir,
-    firmwareList
-  } = localFirmwareStore.get();
-  if (isFirmwareCacheUsedForSelectedSource(settingsStore.get('firmwareChannel')) && firmwareList.includes(releaseName)) {
-    const localReleasePath = `${firmwareDir}${releaseName}`;
-    const localReleaseBuffer = await httpRequest(localReleasePath, 'json');
-    return JSON.parse(localReleaseBuffer.toString());
-  }
-  const release = (await tryGetRelease(() => getReleaseAsset(deviceModel, firmwareVersion, firmwareType))) || (await tryGetRelease(() => getOnlineReleaseByVersion(deviceModel, firmwareVersion, firmwareType)));
-  if (release && versionUtils.isEqual(release.version, firmwareVersion)) {
-    return release;
-  }
-  return;
-};
-export const createLocalFirmwareConfig = baseConfig => {
-  const releaseEntries = Object.entries(baseConfig.releases).map(([deviceModel, modelReleases]) => {
-    const modelKey = deviceModel;
-    if (modelKey === DeviceModelInternal.UNKNOWN) return null;
-    const {
-      'bitcoin-only': bitcoinOnlyConfig,
-      universal: universalConfig
-    } = modelReleases ?? {};
-    if (!bitcoinOnlyConfig?.releasePath || !universalConfig?.releasePath) return null;
-    const btcOnlyRelease = getBundledRelease(modelKey, FirmwareType.BitcoinOnly);
-    const universalRelease = getBundledRelease(modelKey, FirmwareType.Universal);
-    if (!btcOnlyRelease || !universalRelease) return null;
-    const releases = {
-      [FirmwareType.BitcoinOnly]: {
-        ...bitcoinOnlyConfig,
-        release: btcOnlyRelease
-      },
-      [FirmwareType.Universal]: {
-        ...universalConfig,
-        release: universalRelease
-      }
-    };
-    return [modelKey, releases];
-  }).filter(entry => entry !== null);
-  return Object.fromEntries(releaseEntries);
-};
-export const createRemoteFirmwareConfig = async config => {
-  const releaseEntryPromises = Object.entries(config.releases).map(async ([deviceModel, modelReleases]) => {
-    const modelKey = deviceModel;
-    if (modelKey === DeviceModelInternal.UNKNOWN) return null;
-    const {
-      'bitcoin-only': bitcoinOnlyConfig,
-      universal: universalConfig
-    } = modelReleases ?? {};
-    if (!bitcoinOnlyConfig?.releasePath || !universalConfig?.releasePath) return null;
-    const [bitcoinOnlyRelease, universalRelease] = await Promise.all([getOnlineReleaseByPath(bitcoinOnlyConfig.releasePath), getOnlineReleaseByPath(universalConfig.releasePath)]);
-    if (!universalRelease || !bitcoinOnlyRelease) return null;
-    const releases = {
-      [FirmwareType.BitcoinOnly]: {
-        ...bitcoinOnlyConfig,
-        release: bitcoinOnlyRelease
-      },
-      [FirmwareType.Universal]: {
-        ...universalConfig,
-        release: universalRelease
-      }
-    };
-    return [modelKey, releases];
-  });
-  const validEntries = (await Promise.all(releaseEntryPromises)).filter(entry => entry !== null);
-  return Object.fromEntries(validEntries);
-};
-export const initializeFirmwareConfig = async (config, isRemote) => {
-  if (isRemote) {
-    try {
-      const remoteReleases = await createRemoteFirmwareConfig(config);
-      return {
-        releases: remoteReleases,
-        intermediaries: config.intermediaries
-      };
-    } catch {}
-  }
-  const localFirmwareReleaseConfig = firmwareReleaseStore.getLocal();
-  const localReleases = createLocalFirmwareConfig(localFirmwareReleaseConfig);
-  return {
-    releases: localReleases,
-    intermediaries: localFirmwareReleaseConfig.intermediaries
-  };
-};
-export const getLanguage = languageBinPath => {
-  const baseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
-  const url = `${baseUrl.BASE_URL}/${languageBinPath}`;
-  return httpRequest(url, 'binary');
-};
-const getCurrentVersion = features => {
-  if (!isStrictFeatures(features)) {
-    throw new Error('Features of unexpected shape provided.');
-  }
-  const bootloaderVersion = getBootloaderVersionArray({
-    features
-  });
-  const firmwareVersion = getFirmwareVersionArray({
-    features
-  });
-  return {
-    bootloaderVersion,
-    firmwareVersion
-  };
-};
-const getIntermediaryMessageRelease = features => {
-  const config = firmwareReleaseStore.getIntermediary();
-  if (!config) {
-    throw new Error('Firmware release config not loaded.');
-  }
-  const deviceIntermediaryReleases = config[features.internal_model];
-  if (!deviceIntermediaryReleases || deviceIntermediaryReleases.length === 0) {
-    return;
-  }
-  const {
-    bootloaderVersion,
-    firmwareVersion
-  } = getCurrentVersion(features);
-  const currentVersion = features.bootloader_mode ? bootloaderVersion : firmwareVersion;
-  const minVersionKey = features.bootloader_mode ? 'min_bootloader_version' : 'min_firmware_version';
-  if (!currentVersion) {
-    return undefined;
-  }
-  return deviceIntermediaryReleases.find(release => versionUtils.isNewer(release[minVersionKey], currentVersion));
-};
-const getIsBitcoinOnlyAvailable = features => {
-  const {
-    internal_model
-  } = features;
-  if (internal_model === DeviceModelInternal.UNKNOWN) {
-    return false;
-  }
-  const firmwareReleaseConfig = firmwareReleaseStore.getReleases();
-  if (!firmwareReleaseConfig) {
-    throw new Error('Firmware release config not loaded.');
-  }
-  const deviceMessageRelease = firmwareReleaseConfig[internal_model];
-  return !!deviceMessageRelease && !!deviceMessageRelease[FirmwareType.BitcoinOnly];
-};
-const isValidConditionalRelease = release => !!(release.version && release.min_firmware_version && release.min_bootloader_version);
-const calculateShouldOfferRelease = (rolloutProbability, deviceId) => {
-  if (rolloutProbability < 0 || rolloutProbability > 100) {
-    throw new Error('Probability must be between 0 and 100.');
-  }
-  if (deviceId === null) {
-    return rolloutProbability > 0;
-  } else {
-    const deterministicValueToCompare = getIntegerInRangeFromString(deviceId, 101);
-    return deterministicValueToCompare < rolloutProbability;
-  }
-};
-const getChangelog = (releases, features) => {
-  if (features.bootloader_mode) {
-    if (features.firmware_present && features.major_version === 1) {
-      return null;
-    }
-    if (features.firmware_present && features.major_version === 2) {
-      return releases.filter(r => versionUtils.isNewer(r.version, [features.fw_major, features.fw_minor, features.fw_patch]));
-    }
-    return releases;
-  }
-  return releases.filter(r => versionUtils.isNewer(r.version, getFirmwareOrBootloaderVersionArray(features)));
-};
-const isRequired = changelog => {
-  if (!changelog || !changelog.length) return null;
-  return changelog.some(item => item.required);
-};
-export const getReleaseInfo = ({
-  features,
-  release,
-  conditions,
-  intermediary,
-  firmwareType,
-  isBitcoinOnlyAvailable,
-  releasesOfDevice
-}) => {
-  if (!isStrictFeatures(features)) {
-    throw new Error('Features of unexpected shape provided.');
-  }
-  if (!isValidConditionalRelease(release)) {
-    throw new Error(`Release object in unexpected shape.`);
-  }
-  const {
-    min_firmware_version,
-    min_bootloader_version
-  } = release;
-  const changelog = getChangelog(releasesOfDevice, features);
-  let isNewer = false;
-  let requiresIntermediary = false;
-  if (features.bootloader_mode && release.bootloader_version) {
-    const {
-      bootloaderVersion,
-      firmwareVersion
-    } = getCurrentVersion(features);
-    if (versionUtils.isVersionArray(firmwareVersion)) {
-      isNewer = versionUtils.isNewer(release.version, firmwareVersion);
-      requiresIntermediary = versionUtils.isNewer(min_firmware_version, firmwareVersion);
-    } else if (versionUtils.isVersionArray(bootloaderVersion)) {
-      isNewer = versionUtils.isNewer(release.bootloader_version, bootloaderVersion);
-      requiresIntermediary = versionUtils.isNewer(min_bootloader_version, bootloaderVersion);
-    } else {
-      throw new Error('Version is not version array.');
-    }
-  } else {
-    const {
-      firmwareVersion
-    } = getCurrentVersion(features);
-    if (!versionUtils.isVersionArray(firmwareVersion)) {
-      throw new Error('Firmware version is not version array.');
-    }
-    isNewer = versionUtils.isNewer(release.version, firmwareVersion);
-    requiresIntermediary = versionUtils.isNewer(min_firmware_version, firmwareVersion);
-  }
-  const {
-    rollout_probability
-  } = conditions;
-  const shouldBeOffered = calculateShouldOfferRelease(rollout_probability, features.device_id);
-  if (requiresIntermediary && intermediary) {
-    isNewer = true;
-  }
-  return {
-    firmwareType,
-    isBitcoinOnlyAvailable,
-    releaseConditions: {
-      ...conditions,
-      shouldBeOffered
-    },
-    release,
-    intermediary: requiresIntermediary ? intermediary : undefined,
-    isRequired: isRequired(changelog),
-    isNewer,
-    translations: release.translations
-  };
-};
-export const getFirmwareReleaseConfigInfo = (features, firmwareType) => {
-  const deviceMessageRelease = getReleaseConfig(features, firmwareType);
-  if (!deviceMessageRelease?.release) {
-    return;
-  }
-  const {
-    release,
-    conditions,
-    firmware_type
-  } = deviceMessageRelease;
-  const currentVersion = getCurrentVersion(features);
-  const inBootloaderMode = features.bootloader_mode && !!currentVersion.bootloaderVersion;
-  const versionContext = inBootloaderMode ? {
-    version: currentVersion.bootloaderVersion,
-    minVersionKey: 'min_bootloader_version'
-  } : {
-    version: currentVersion.firmwareVersion,
-    minVersionKey: 'min_firmware_version'
-  };
-  const isCompatible = versionContext.version && versionUtils.isNewerOrEqual(versionContext.version, release[versionContext.minVersionKey]);
-  const releasesOfDevice = getReleasesAssetByDeviceModelAndFirmwareType(features.internal_model, firmwareType);
-  let suitableRelease = release;
-  if (!isCompatible) {
-    const alternativeRelease = findBestCompatibleRelease(releasesOfDevice, currentVersion, versionContext.minVersionKey);
-    if (alternativeRelease) {
-      suitableRelease = alternativeRelease;
-    }
-  }
-  const intermediary = getIntermediaryMessageRelease(features);
-  const finalTargetRelease = intermediary ? release : suitableRelease;
-  return getReleaseInfo({
-    isBitcoinOnlyAvailable: getIsBitcoinOnlyAvailable(features),
-    features,
-    release: finalTargetRelease,
-    conditions,
-    intermediary,
-    firmwareType: firmware_type,
-    releasesOfDevice
-  });
-};
-export const getFirmwareStatus = (features, firmwareType) => {
-  if (features.firmware_present === false) {
-    return 'none';
-  }
-  if (features.major_version === 1 && features.bootloader_mode) {
-    return 'unknown';
-  }
-  const releaseInfo = getFirmwareReleaseConfigInfo(features, firmwareType);
-  if (!releaseInfo) return 'custom';
-  if (releaseInfo.isRequired) return 'required';
-  if (releaseInfo.isNewer) return 'outdated';
-  return 'valid';
-};
-export const getFirmwareLocation = ({
-  firmwareVersion,
-  remotePath,
-  deviceModel,
-  firmwareType,
-  intermediaryVersion
-}) => {
-  const firmwareName = intermediaryVersion ? buildIntermediaryFirmwareFileName(deviceModel, intermediaryVersion) : buildLocalFirmwareFileName(firmwareType, deviceModel, firmwareVersion);
-  const versionString = firmwareVersion.join('.');
-  const bundledBaseUrl = removeTrailingSlashes(settingsStore.get('binFilesBaseUrl'));
-  const isRealBundled = !bundledBaseUrl.includes('data.trezor.io');
-  const bundledVersion = getBundledFirmwareVersion(deviceModel, firmwareType);
-  const isIntermediary = bundledBaseUrl && intermediaryVersion;
-  const isMatchingBundledVersion = bundledBaseUrl && isRealBundled && bundledVersion === versionString;
-  if (isIntermediary || isMatchingBundledVersion) {
-    return {
-      baseUrl: bundledBaseUrl,
-      path: `firmware/${deviceModel.toLowerCase()}/${firmwareName}`
-    };
-  }
-  const {
-    firmwareDir,
-    firmwareList
-  } = localFirmwareStore.get();
-  if (isFirmwareCacheUsedForSelectedSource(settingsStore.get('firmwareChannel')) && firmwareList.includes(firmwareName)) {
-    return {
-      baseUrl: firmwareDir,
-      path: firmwareName
-    };
-  }
-  const onlineBaseUrl = getOnlineFirmwareBaseUrl(settingsStore.get('firmwareChannel'));
-  return {
-    baseUrl: onlineBaseUrl.BASE_URL,
-    path: remotePath
-  };
-};

package/libESM/data/firmwareReleaseStore.d.mts

@@ -1,10 +0,0 @@
-import type { FirmwareChannel } from '@trezor/connect-common/libESM/types/firmware';
-import type { ConditionalRelease, DeviceModelInternal, FirmwareReleaseConfig, FirmwareType, IntermediaryReleaseConfig, ReleasesConfig } from '@trezor/device-utils';
-export type InitializeFirmwareConfig = (config: FirmwareReleaseConfig, isRemote: boolean) => Promise<{
-    releases: ReleasesConfig;
-    intermediaries: Record<DeviceModelInternal, IntermediaryReleaseConfig[]>;
-}>;
-export declare const init: (firmwareChannel: FirmwareChannel | undefined, onlyLocal: boolean, initializeFirmwareConfig: InitializeFirmwareConfig) => Promise<void>;
-export declare const getLocal: () => FirmwareReleaseConfig;
-export declare const getReleases: () => Partial<Record<"T1B1" | "T2T1" | "T3T1" | "T2B1" | "T3B1" | "T3W1" | "UNKNOWN", Record<FirmwareType, ConditionalRelease>>> | undefined;
-export declare const getIntermediary: () => Record<"T1B1" | "T2T1" | "T3T1" | "T2B1" | "T3B1" | "T3W1" | "UNKNOWN", IntermediaryReleaseConfig[]> | undefined;

package/libESM/data/firmwareReleaseStore.mjs

@@ -1,16 +0,0 @@
-import { getFirmwareReleaseConfig, getOnlyLocalFirmwareReleaseConfig } from "../utils/firmwareReleaseConfigUtils.mjs";
-const local = getOnlyLocalFirmwareReleaseConfig().config;
-let releases;
-let intermediary;
-export const init = async (firmwareChannel, onlyLocal, initializeFirmwareConfig) => {
-  const firmwareReleaseConfig = onlyLocal ? {
-    config: local,
-    isRemote: false
-  } : await getFirmwareReleaseConfig(firmwareChannel);
-  const result = await initializeFirmwareConfig(firmwareReleaseConfig.config, firmwareReleaseConfig.isRemote);
-  releases = result.releases;
-  intermediary = result.intermediaries;
-};
-export const getLocal = () => local;
-export const getReleases = () => releases;
-export const getIntermediary = () => intermediary;

package/libESM/data/localFirmwareStore.d.mts

@@ -1,3 +0,0 @@
-import type { LocalFirmwares } from '@trezor/connect-common';
-export declare const set: (next: LocalFirmwares) => void;
-export declare const get: () => LocalFirmwares;

package/libESM/data/protobufLoader.d.mts

@@ -1 +0,0 @@
-export declare const loadProtobufModules: () => Promise<void>;

package/libESM/data/protobufLoader.mjs

@@ -1,29 +0,0 @@
-import { protobufManager } from "@trezor/protobuf";
-import * as bitcoinProto from "@trezor/protobuf/libESM/definitions/messages-bitcoin_pb.mjs";
-import * as bleProto from "@trezor/protobuf/libESM/definitions/messages-ble_pb.mjs";
-import * as bootloaderProto from "@trezor/protobuf/libESM/definitions/messages-bootloader_pb.mjs";
-import * as cardanoProto from "@trezor/protobuf/libESM/definitions/messages-cardano_pb.mjs";
-import * as commonProto from "@trezor/protobuf/libESM/definitions/messages-common_pb.mjs";
-import * as cryptoProto from "@trezor/protobuf/libESM/definitions/messages-crypto_pb.mjs";
-import * as debugProto from "@trezor/protobuf/libESM/definitions/messages-debug_pb.mjs";
-import * as definitionsProto from "@trezor/protobuf/libESM/definitions/messages-definitions_pb.mjs";
-import * as eosProto from "@trezor/protobuf/libESM/definitions/messages-eos_pb.mjs";
-import * as ethereumEip712Proto from "@trezor/protobuf/libESM/definitions/messages-ethereum-eip712_pb.mjs";
-import * as ethereumProto from "@trezor/protobuf/libESM/definitions/messages-ethereum_pb.mjs";
-import * as evoluProto from "@trezor/protobuf/libESM/definitions/messages-evolu_pb.mjs";
-import * as managementProto from "@trezor/protobuf/libESM/definitions/messages-management_pb.mjs";
-import * as moneroProto from "@trezor/protobuf/libESM/definitions/messages-monero_pb.mjs";
-import * as rippleProto from "@trezor/protobuf/libESM/definitions/messages-ripple_pb.mjs";
-import * as solanaProto from "@trezor/protobuf/libESM/definitions/messages-solana_pb.mjs";
-import * as stellarProto from "@trezor/protobuf/libESM/definitions/messages-stellar_pb.mjs";
-import * as telemetryProto from "@trezor/protobuf/libESM/definitions/messages-telemetry_pb.mjs";
-import * as tezosProto from "@trezor/protobuf/libESM/definitions/messages-tezos_pb.mjs";
-import * as thpProto from "@trezor/protobuf/libESM/definitions/messages-thp_pb.mjs";
-import * as tronProto from "@trezor/protobuf/libESM/definitions/messages-tron_pb.mjs";
-import * as messagesProto from "@trezor/protobuf/libESM/definitions/messages_pb.mjs";
-import * as optionsProto from "@trezor/protobuf/libESM/definitions/options_pb.mjs";
-export const loadProtobufModules = () => {
-  const definitionModules = [bitcoinProto, bleProto, bootloaderProto, cardanoProto, commonProto, cryptoProto, debugProto, definitionsProto, eosProto, ethereumEip712Proto, ethereumProto, evoluProto, managementProto, moneroProto, rippleProto, solanaProto, stellarProto, telemetryProto, tezosProto, thpProto, tronProto, messagesProto, optionsProto];
-  protobufManager.load(definitionModules);
-  return Promise.resolve();
-};

package/libESM/data/settingsStore.d.mts

@@ -1,6 +0,0 @@
-import type { ConnectSettings } from '@trezor/connect-common';
-export declare const set: (next: ConnectSettings) => void;
-export declare const update: (partial: Partial<ConnectSettings>) => void;
-export declare const isLoaded: () => boolean;
-export declare function get(): ConnectSettings;
-export declare function get<T extends keyof ConnectSettings>(key: T): ConnectSettings[T];

package/libESM/data/settingsStore.mjs

@@ -1,21 +0,0 @@
-import { ERRORS } from "@trezor/connect-common/libESM/constants/index.mjs";
-let settings;
-export const set = next => {
-  settings = next;
-};
-export const update = partial => {
-  if (!settings) {
-    throw ERRORS.TypedError('Runtime', 'settingsStore.update called before set()');
-  }
-  settings = {
-    ...settings,
-    ...partial
-  };
-};
-export const isLoaded = () => settings != null;
-export function get(key) {
-  if (!settings) {
-    throw ERRORS.TypedError('Runtime', 'settingsStore.get called before set()');
-  }
-  return key === undefined ? settings : settings[key];
-}