@adyen/kyc-components 4.0.0-beta.5 → 4.0.0-compact.0

package/dist/types/utils/makeSelectItemForRole.d.ts

@@ -1,4 +1,4 @@
 import type { TFunction } from 'i18next';
 import type { SelectItem } from '../components/ui/atoms/Select/Select.types';
 import { roleMetadata } from './roleMetadata';
-export declare const makeSelectItemForRole: (role: keyof typeof roleMetadata, t: TFunction) => SelectItem;
+export declare const makeSelectItemForRole: (role: keyof typeof roleMetadata, t: TFunction<"common">) => SelectItem;

package/dist/types/utils/mapScriptLocalization.d.ts

@@ -0,0 +1,55 @@
+import type { CamelCase } from 'type-fest';
+import type { ScriptLocalization } from '../core/models/api/scriptLocalization';
+import type { LocalizedScriptSchema } from '../types/localizedScriptSchema';
+/**
+ * Takes a {@link ScriptLocalization} and converts it into a schema with matching field names.
+ *
+ * E.g.
+ * ```ts
+ * const scriptLocalization = {
+ *   script: 'ja-Kana',
+ *   fields: {
+ *     firstName: 'アレキサンダー',
+ *     lastName: 'パトリック',
+ *   },
+ * } as const;
+ *
+ * const schema = mapApiScriptLocalizationToSchemaFields(scriptLocalization);
+ * console.log(schema);
+ * // {
+ * //   jaKanaFirstName: 'アレキサンダー',
+ * //   jaKanaLastName: 'パトリック'
+ * // }
+ * ```
+ *
+ */
+export declare function mapApiScriptLocalizationToSchemaFields<ApiType, Script extends string>(localization: ScriptLocalization<ApiType, Script>): LocalizedScriptSchema<ApiType, RemoveHyphenFromScriptName<Script>>;
+/**
+ * Given a schema and a script, takes the fields prefixed with that script and produces a {@link ScriptLocalization}.
+ *
+ * E.g.
+ * ```ts
+ * const schema = {
+ *   firstName: 'Alex',
+ *   lastName: 'Tompkins',
+ *   jaKanaFirstName: 'アレキサンダー',
+ *   jaKanaLastName: 'パトリック',
+ *   jaHaniFirstName: 'pretend this is hiragana',
+ *   jaHaniLastName: 'this too',
+ * };
+ *
+ * const localization = mapSchemaFieldsToApiScriptLocalization(schema, 'jaKana');
+ * console.log(localization);
+ * // {
+ * //   script: 'ja-Kana',
+ * //   fields: { firstName: 'アレキサンダー', lastName: 'パトリック' },
+ * // };
+ * ```
+ */
+export declare function mapSchemaFieldsToApiScriptLocalization<Schema extends object, Script extends string>(data: Schema, script: Script): ScriptLocalization<PickFieldsStartingWith<Schema, Script>, AddHyphenToScriptName<Script>>;
+type RemoveHyphenFromScriptName<Script extends string> = Script extends `${infer Part1}-${infer Part2}` ? `${Part1}${Part2}` : never;
+type AddHyphenToScriptName<Script extends string> = Script extends `${infer Letter1}${infer Letter2}${infer Rest}` ? `${Letter1}${Letter2}-${Rest}` : never;
+type PickFieldsStartingWith<Schema, Prefix extends string> = {
+    [K in keyof Schema as K extends `${Prefix}${infer FieldName}` ? CamelCase<FieldName> : never]: Schema[K];
+};
+export {};

package/dist/types/utils/masking/masks/businessRegistrationNumberMasks.d.ts

@@ -136,6 +136,11 @@ export declare const businessRegistrationNumberMasks: {
             transformOnType: import("../transformers/types").InputTransformer;
         };
     };
+    JP: {
+        default: {
+            mask: import("../maskTypes").Mask;
+        };
+    };
     JE: {
         default: {
             mask: import("../maskTypes").Mask;

package/dist/types/utils/translation.d.ts

@@ -38,3 +38,9 @@ interface TransSelectorProps<Key, Ns extends Namespace = _DefaultNamespace, KPre
     t?: TFunction<Ns, KPrefix>;
 }
 export declare const Trans: _EnableSelector extends true | "optimize" ? TransSelector : TransLegacy;
+export declare const addResourceBundles: (i18n: i18n, language: string, resourceDetails: {
+    ns: Namespace;
+    importFn: () => Promise<{
+        default: Record<string, string>;
+    }>;
+}[]) => void;

package/dist/types-CAznNNSI.js

@@ -0,0 +1,160 @@
+;
+{
+  try {
+    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "79adf98d-ded8-4cb5-af20-515331a52736", e._sentryDebugIdIdentifier = "sentry-dbid-79adf98d-ded8-4cb5-af20-515331a52736");
+  } catch (e) {
+  }
+}
+;
+const ExperimentNames = {
+  // Features
+  AllowMoreRolesForMainRootTrustee: "AllowMoreRolesForMainRootTrustee",
+  /**
+   *
+   */
+  ShowUnsupportedEntityType: "ShowUnsupportedEntityType",
+  /**
+   *
+   */
+  ShowExtraTaxExemptionReasons: "ShowExtraTaxExemptionReasons",
+  /**
+   *
+   */
+  EnableEInvoicingCodeField: "EnableEInvoicingCodeField",
+  /**
+   * Allows users to specify a 'Country of Governing Law' for UK companies
+   * within Business Details Task
+   */
+  EnableCountryOfGoverningLawForUKCompanies: "EnableCountryOfGoverningLawForUKCompanies",
+  /**
+   *
+   */
+  HidePayoutAccountTask: "HidePayoutAccountTask",
+  /**
+   *
+   */
+  HidePciTask: "HidePciTask",
+  /**
+   *
+   */
+  EnableAgeVerification: "EnableAgeVerification",
+  /**
+   *
+   */
+  EnableNationalitySGHK: "EnableNationalitySGHK",
+  /**
+   *
+   */
+  EnableFinancialInformationComponentV4: "EnableFinancialInformationComponentV4",
+  /**
+   *
+   */
+  StrictNameAndAddressValidationV4: "StrictNameAndAddressValidationV4",
+  /**
+   *
+   */
+  EnableDoingBusinessAsNameV4: "EnableDoingBusinessAsNameV4",
+  /**
+   *
+   */
+  EnablePhoneFieldScenario: "EnablePhoneFieldScenario",
+  /**
+   *
+   */
+  ShowCustomerSupportV4: "ShowCustomerSupportV4",
+  /**
+   *
+   */
+  EnableRegistrationAndTaxAbsentStatesV4: "EnableRegistrationAndTaxAbsentStatesV4",
+  /**
+   *
+   */
+  EnableAutofillFlowForPureIndividualsInKeyMarkets: "EnableAutofillFlowForPureIndividualsInKeyMarkets",
+  /**
+   *
+   */
+  EnableAutofillFlowForPureIndividualsInAdditionalMarkets: "EnableAutofillFlowForPureIndividualsInAdditionalMarkets",
+  /**
+   *
+   */
+  EnableAutofillFlowForDecisionMakersInKeyMarkets: "EnableAutofillFlowForDecisionMakersInKeyMarkets",
+  /**
+   *
+   */
+  EnableAutofillFlowForDecisionMakersInAdditionalMarkets: "EnableAutofillFlowForDecisionMakersInAdditionalMarkets",
+  /**
+   * SOE-5373: Do not show all countries for business accounts customer
+   */
+  EnableLimitCountryBusinessAccountCustomers: "EnableLimitCountryBusinessAccountCustomers",
+  /**
+   * Enables Unincorporated Partnerships to be selected within Business Type Selection Task to be onboarded in HO
+   */
+  EnableUnincorporatedPartnershipInHO: "EnableUnincorporatedPartnershipInHO",
+  /**
+   *
+   */
+  UseOnboardingComponentsForSingpass: "UseOnboardingComponentsForSingpass",
+  /**
+   *
+   */
+  EnableCheckOnCreateBankAccount: "EnableCheckOnCreateBankAccount",
+  /**
+   * SOE-5342: Make TaxID mandatory when onboarding companies for business accounts
+   */
+  EnableTaxIdRequiredForBusinessAccountsScenarios: "EnableTaxIdRequiredForBusinessAccountsScenarios",
+  /**
+   * Enables ja-JP locale for HO
+   */
+  EnableJaJPLocale: "EnableJaJPLocale",
+  /**
+   * Enable guided decision makers workflow with questionnaire
+   */
+  EnableGuidedDecisionMakersFlow: "EnableGuidedDecisionMakersFlow",
+  /**
+   * OXP-6238 Disable guided decision makers workflow for requested scopes
+   */
+  DisableGuidedDecisionMakersFlow: "DisableGuidedDecisionMakersFlow",
+  /**
+   * SOE-5806 Enable task status service usage for `BUSINESS_DETAILS` task
+   */
+  EnableBusinessDetailsTaskStatusService: "EnableBusinessDetailsTaskStatusService",
+  /**
+   * Use the status calculated on the backend for the payout task.
+   * If false, instead compute the status from capabilities and problems on the root LE.
+   */
+  UseTaskStatusApiForPayout: "UseTaskStatusApiForPayout",
+  /**
+   * OXP-6031 Make users sign PCI questionnaire before ToS if it is present
+   */
+  EnableSignPCIBeforeTOS: "EnableSignPCIBeforeTOS",
+  /**
+   * OXP-6357 Show revamped decision-maker task page
+   */
+  EnableRevampedDecisionMakersTaskPage: "EnableRevampedDecisionMakersTaskPage",
+  /**
+   * OXP-5078 Show task to add business lines
+   */
+  EnableBusinessLinesTask: "EnableBusinessLinesTask",
+  /**
+   * SOE-5391: Enable useMultiForm for Business Details task
+   */
+  EnableBusinessDetailsMultiForm: "EnableBusinessDetailsMultiForm",
+  // Experiments
+  /**
+   * SOE-5561: A/B New CaaS flow vs Standard bank account flow
+   */
+  BankVerificationFlowOptimization_CAASIntegration: "BankVerificationFlowOptimization_CAASIntegration",
+  /**
+   * SOE-5889: Create experiment flag for guided decision-maker flow
+   */
+  DecisionMakersFlowOptimization_GuidedDecisionMakersFlow: "DecisionMakersFlowOptimization_GuidedDecisionMakersFlow",
+  /**
+   * OXP-5888: A/B testing: With & without pre-selection for verification method in Banking flow
+   */
+  BankVerificationMethodAutonomy_UnbiasedSelection: "BankVerificationMethodAutonomy_UnbiasedSelection",
+  EnableIncorporationDateBasedFinancialValidationForHO: "EnableIncorporationDateBasedFinancialValidationForHO"
+};
+export {
+  ExperimentNames as E
+};

package/dist/types-CP1NRoE8.js

@@ -0,0 +1,74 @@
+;
+{
+  try {
+    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "fc824383-6ba8-4ca5-87a1-e6590e4f56be", e._sentryDebugIdIdentifier = "sentry-dbid-fc824383-6ba8-4ca5-87a1-e6590e4f56be");
+  } catch (e) {
+  }
+}
+;
+import { a8 as CountryCodes } from "./StoreProvider-BlaJzXSZ.js";
+const ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES = [
+  CountryCodes.Australia,
+  CountryCodes.Belgium,
+  CountryCodes.Canada,
+  CountryCodes.France,
+  CountryCodes.Germany,
+  CountryCodes.HongKong,
+  CountryCodes.Ireland,
+  CountryCodes.Netherlands,
+  CountryCodes.NewZealand,
+  CountryCodes.Poland,
+  CountryCodes.Singapore,
+  CountryCodes.Spain,
+  CountryCodes.Switzerland,
+  CountryCodes.UnitedKingdom,
+  CountryCodes.UnitedStates
+];
+const UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED = [
+  CountryCodes.Belgium,
+  CountryCodes.Netherlands,
+  CountryCodes.NewZealand,
+  CountryCodes.Singapore
+];
+const UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL = [
+  CountryCodes.Australia,
+  CountryCodes.Canada,
+  CountryCodes.China,
+  CountryCodes.France,
+  CountryCodes.Germany,
+  CountryCodes.Iceland,
+  CountryCodes.Slovakia,
+  CountryCodes.Spain,
+  CountryCodes.Switzerland,
+  CountryCodes.UnitedKingdom
+];
+const UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED = [
+  CountryCodes.Australia,
+  CountryCodes.Germany,
+  CountryCodes.HongKong,
+  CountryCodes.Ireland,
+  CountryCodes.Netherlands,
+  CountryCodes.NewZealand,
+  CountryCodes.UnitedKingdom
+];
+const UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL = [
+  CountryCodes.Singapore
+];
+const UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL = [
+  CountryCodes.Belgium,
+  CountryCodes.Germany,
+  CountryCodes.Ireland,
+  CountryCodes.Netherlands,
+  CountryCodes.Poland,
+  CountryCodes.Spain,
+  CountryCodes.UnitedKingdom
+];
+export {
+  ALLOWED_UNINCORPORATED_PARTNERSHIP_COUNTRIES as A,
+  UNINCORPORATED_PARTNERSHIP_COUNTRIES_VAT_NUMBER_OPTIONAL as U,
+  UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_REQUIRED as a,
+  UNINCORPORATED_PARTNERSHIP_COUNTRIES_REGISTRATION_NUMBER_OPTIONAL as b,
+  UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_REQUIRED as c,
+  UNINCORPORATED_PARTNERSHIP_COUNTRIES_TAX_INFORMATION_OPTIONAL as d
+};

package/dist/types-K58FM7k4.js

@@ -0,0 +1,64 @@
+;
+{
+  try {
+    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "3e018038-179d-43cc-bc9c-aca8b3fab791", e._sentryDebugIdIdentifier = "sentry-dbid-3e018038-179d-43cc-bc9c-aca8b3fab791");
+  } catch (e) {
+  }
+}
+;
+import { a8 as CountryCodes } from "./StoreProvider-BlaJzXSZ.js";
+import { C as Currencies } from "./currency-BGwQyxBo.js";
+const currencyByCountry = {
+  [CountryCodes.Australia]: [Currencies.AUD],
+  [CountryCodes.Austria]: [Currencies.EUR],
+  [CountryCodes.Belgium]: [Currencies.EUR],
+  [CountryCodes.Brazil]: [Currencies.BRL],
+  [CountryCodes.Bulgaria]: [Currencies.BGN, Currencies.EUR],
+  [CountryCodes.Canada]: [Currencies.CAD, Currencies.USD],
+  [CountryCodes.Croatia]: [Currencies.HRK, Currencies.EUR],
+  [CountryCodes.Cyprus]: [Currencies.EUR],
+  [CountryCodes.CzechRepublic]: [Currencies.CZK, Currencies.EUR],
+  [CountryCodes.Denmark]: [Currencies.DKK, Currencies.EUR],
+  [CountryCodes.Estonia]: [Currencies.EUR],
+  [CountryCodes.Finland]: [Currencies.EUR],
+  [CountryCodes.France]: [Currencies.EUR],
+  [CountryCodes.Germany]: [Currencies.EUR],
+  [CountryCodes.Gibraltar]: [Currencies.GBP],
+  [CountryCodes.Greece]: [Currencies.EUR],
+  [CountryCodes.Guernsey]: [Currencies.GBP],
+  [CountryCodes.HongKong]: [Currencies.HKD],
+  [CountryCodes.Hungary]: [Currencies.HUF, Currencies.EUR],
+  [CountryCodes.Ireland]: [Currencies.EUR],
+  [CountryCodes.IsleOfMan]: [Currencies.GBP],
+  [CountryCodes.Italy]: [Currencies.EUR],
+  [CountryCodes.Jersey]: [Currencies.GBP],
+  [CountryCodes.Latvia]: [Currencies.EUR],
+  [CountryCodes.Liechtenstein]: [Currencies.CHF, Currencies.EUR],
+  [CountryCodes.Lithuania]: [Currencies.EUR],
+  [CountryCodes.Luxembourg]: [Currencies.EUR],
+  [CountryCodes.Malaysia]: [Currencies.MYR],
+  [CountryCodes.Malta]: [Currencies.EUR],
+  [CountryCodes.Mexico]: [Currencies.MXN],
+  [CountryCodes.Monaco]: [Currencies.EUR],
+  [CountryCodes.Netherlands]: [Currencies.EUR],
+  [CountryCodes.NewZealand]: [Currencies.NZD],
+  [CountryCodes.Norway]: [Currencies.NOK, Currencies.EUR],
+  [CountryCodes.Poland]: [Currencies.PLN, Currencies.EUR],
+  [CountryCodes.Portugal]: [Currencies.EUR],
+  [CountryCodes.PuertoRico]: [Currencies.USD],
+  // should exactly match CountryCodes.UnitedStates
+  [CountryCodes.Romania]: [Currencies.RON, Currencies.EUR],
+  [CountryCodes.Singapore]: [Currencies.SGD],
+  [CountryCodes.Slovakia]: [Currencies.EUR],
+  [CountryCodes.Slovenia]: [Currencies.EUR],
+  [CountryCodes.Spain]: [Currencies.EUR],
+  [CountryCodes.Sweden]: [Currencies.SEK, Currencies.EUR],
+  [CountryCodes.Switzerland]: [Currencies.CHF, Currencies.EUR],
+  [CountryCodes.UnitedArabEmirates]: [Currencies.AED],
+  [CountryCodes.UnitedKingdom]: [Currencies.GBP, Currencies.EUR],
+  [CountryCodes.UnitedStates]: [Currencies.USD]
+};
+export {
+  currencyByCountry as c
+};

package/dist/useAssociatedLegalEntity-G30FPhOX.js

@@ -0,0 +1,33 @@
+;
+{
+  try {
+    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "483b0be3-2eab-4696-b467-a17b3b100994", e._sentryDebugIdIdentifier = "sentry-dbid-483b0be3-2eab-4696-b467-a17b3b100994");
+  } catch (e) {
+  }
+}
+;
+import { useMemo } from "preact/hooks";
+import { N as createLogger, c as useLegalEntity, q as skipToken } from "./StoreProvider-BlaJzXSZ.js";
+const logger = createLogger();
+function useAssociatedLegalEntity(parentLegalEntity, associationType) {
+  const matchingAssociation = useMemo(() => {
+    if (!parentLegalEntity) return void 0;
+    const typesToFind = Array.isArray(associationType) ? associationType : [associationType];
+    const matchingAssociations = parentLegalEntity.entityAssociations?.filter((entity) => typesToFind.includes(entity.type)) ?? [];
+    if (matchingAssociations.length > 1) {
+      logger.warn(
+        `Multiple matching associations found for types: ${typesToFind.join(", ")} - returning the first.
+        ${matchingAssociations.map((ass) => JSON.stringify(ass, null, 2)).join("\n")}`
+      );
+    }
+    return matchingAssociations[0];
+  }, [parentLegalEntity, associationType]);
+  const { data, refetch, isLoading } = useLegalEntity(
+    matchingAssociation?.legalEntityId ?? skipToken
+  );
+  return { data, refetch, isLoading };
+}
+export {
+  useAssociatedLegalEntity as u
+};

package/dist/useDataset-BgvQQEKd.js

@@ -0,0 +1,120 @@
+;
+{
+  try {
+    let e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "1e37e1dc-d8f7-4e29-b3c8-eae05e6733fa", e._sentryDebugIdIdentifier = "sentry-dbid-1e37e1dc-d8f7-4e29-b3c8-eae05e6733fa");
+  } catch (e) {
+  }
+}
+;
+import { useState, useEffect } from "preact/hooks";
+import { N as createLogger, u as useI18nContext } from "./StoreProvider-BlaJzXSZ.js";
+const normalizedDatasets = {};
+const datasets = {};
+const createDatasetKey = (identifier, locale) => `${identifier}_${locale}`.toLowerCase();
+const getNormalizeDataset = (datasetKey) => {
+  if (!normalizedDatasets[datasetKey]) {
+    normalizedDatasets[datasetKey] = {};
+    datasets[datasetKey].forEach(({ id, name }) => {
+      normalizedDatasets[datasetKey][id] = name;
+    });
+  }
+  return normalizedDatasets[datasetKey];
+};
+const getDataName = (datasetKey, key) => {
+  if (datasets[datasetKey]) {
+    const normalizedDataset = getNormalizeDataset(datasetKey);
+    return normalizedDataset[key];
+  }
+  return null;
+};
+const datasetIdentifier = {
+  country: "countries",
+  state: (countryCode) => `states/${countryCode}`
+};
+function datasetUtilities(locale) {
+  return {
+    getCountryName: (countryCode) => {
+      if (!countryCode) return null;
+      const datasetKey = createDatasetKey(datasetIdentifier.country, locale);
+      return getDataName(datasetKey, countryCode);
+    },
+    getStateName: (stateCode, countryCode) => {
+      const datasetKey = createDatasetKey(datasetIdentifier.state(countryCode), locale);
+      return getDataName(datasetKey, stateCode);
+    },
+    setDataset: (identifier, dataset) => {
+      const datasetKey = createDatasetKey(identifier, locale);
+      datasets[datasetKey] = dataset;
+    },
+    getDataset: (identifier) => {
+      const datasetKey = createDatasetKey(identifier, locale);
+      return datasets[datasetKey];
+    },
+    getDatasetKey: (identifier) => createDatasetKey(identifier, locale)
+  };
+}
+const logger$1 = createLogger();
+const countriesImports = /* @__PURE__ */ Object.assign({ "../countries/de-DE.json": () => import("./de-DE-B3nctkG8.js"), "../countries/el-GR.json": () => import("./el-GR-CdgLZhuO.js"), "../countries/en-US.json": () => import("./en-US-DSoLr6rp.js"), "../countries/es-ES.json": () => import("./es-ES-BRfK6tX7.js"), "../countries/fr-FR.json": () => import("./fr-FR-Dk6Lw2On.js"), "../countries/it-IT.json": () => import("./it-IT-D7G4BaP7.js"), "../countries/ja-JP.json": () => import("./ja-JP-DTW_hY1L.js"), "../countries/nl-NL.json": () => import("./nl-NL-CFzm75Jw.js"), "../countries/pt-PT.json": () => import("./pt-PT-DpDxAynk.js"), "../countries/sv-SE.json": () => import("./sv-SE-rckxD-43.js") });
+const loadCountriesDataset = async (locale) => {
+  const importForLocale = countriesImports[`../countries/${locale}.json`];
+  if (!importForLocale) {
+    logger$1.warn(`No countries dataset for ${locale}, falling back to en-US`);
+    return (await import("./en-US-DSoLr6rp.js")).default;
+  }
+  return (await importForLocale()).default;
+};
+const logger = createLogger();
+const statesImports = /* @__PURE__ */ Object.assign({ "../states/AU/en-US.json": () => import("./en-US-Do3mE4BR.js"), "../states/BR/en-US.json": () => import("./en-US-DWT3bRZC.js"), "../states/BR/pt-BR.json": () => import("./pt-BR-CTXtdAVc.js"), "../states/CA/en-US.json": () => import("./en-US-PLYPmyFJ.js"), "../states/JP/en-US.json": () => import("./en-US-QbdqemZi.js"), "../states/JP/ja-JP.json": () => import("./ja-JP-DU7yCJYq.js"), "../states/NZ/en-US.json": () => import("./en-US-C_9Fc9mP.js"), "../states/US/en-US.json": () => import("./en-US-9KQC6F8-.js") });
+const loadStatesDataset = async (country, locale) => {
+  const importForLocale = statesImports[`../states/${country}/${locale}.json`];
+  if (!importForLocale) {
+    logger.warn(`No ${country} states dataset for ${locale}, falling back to en-US`);
+    const fallbackImport = statesImports[`../states/${country}/en-US.json`];
+    return (await fallbackImport()).default;
+  }
+  return (await importForLocale()).default;
+};
+const loadDataset = async (identifier, locale) => {
+  if (identifier === datasetIdentifier.country) {
+    return loadCountriesDataset(locale);
+  }
+  if (identifier.startsWith("states")) {
+    const country = identifier.slice(identifier.indexOf("/") + 1);
+    return loadStatesDataset(country, locale);
+  }
+  throw new Error(`Unknown dataset: ${identifier}`);
+};
+const getDataset = async (identifier, locale) => {
+  const datasetUtils = datasetUtilities(locale);
+  const dataset = datasetUtils.getDataset(identifier);
+  if (dataset) {
+    return new Promise((resolve) => {
+      resolve(dataset);
+    });
+  }
+  return loadDataset(identifier, locale).then((datasetResponse) => {
+    datasetUtils.setDataset(identifier, datasetResponse);
+    return datasetResponse;
+  });
+};
+function useDataset(datasetIdentifier2, skip) {
+  const { i18n } = useI18nContext();
+  const [dataset, setDataset] = useState([]);
+  const [loaded, setLoaded] = useState(false);
+  useEffect(() => {
+    if (skip) return;
+    getDataset(datasetIdentifier2, i18n.locale).then((response) => {
+      const result = response && response.length ? response : [];
+      setDataset(result);
+    }).catch(() => {
+      setDataset([]);
+    }).finally(() => setLoaded(true));
+  }, [datasetIdentifier2, i18n.locale, skip]);
+  return { dataset, loaded };
+}
+export {
+  datasetUtilities as a,
+  datasetIdentifier as d,
+  useDataset as u
+};