@faststore/core 3.99.1 → 4.0.0-dev.1

package/test/sdk/localization/bindingSelector.test.ts

@@ -0,0 +1,246 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  buildLanguageOptions,
+  getCurrenciesForLocale,
+  isValidUrl,
+  resolveBinding,
+} from '../../../src/sdk/localization/bindingSelector'
+import type { Binding, Locale } from '../../../src/sdk/localization/types'
+
+// Helper to create a mock locale
+function createLocale(overrides: Partial<Locale> = {}): Locale {
+  return {
+    code: 'en-US',
+    name: 'English',
+    languageCode: 'en',
+    languageName: 'English',
+    script: 'Latn',
+    textDirection: 'ltr',
+    regionCode: 'US',
+    bindings: [],
+    ...overrides,
+  }
+}
+
+// Helper to create a mock binding
+function createBinding(overrides: Partial<Binding> = {}): Binding {
+  return {
+    currencyCode: 'USD',
+    url: 'https://store.example.com/en-US',
+    salesChannel: '1',
+    isDefault: false,
+    ...overrides,
+  }
+}
+
+// Helper to create a locale with simplified parameters (name is used for display)
+function makeLocale(code: string, name: string): Locale {
+  const [languageCode, regionCode] = code.split('-')
+  return createLocale({
+    code,
+    name,
+    languageCode,
+    regionCode,
+  })
+}
+
+describe('buildLanguageOptions', () => {
+  it('displays native name (capitalized) when unique', () => {
+    const locales: Record<string, Locale> = {
+      'fr-FR': makeLocale('fr-FR', 'Français'),
+      'en-US': makeLocale('en-US', 'English'),
+    }
+
+    const options = buildLanguageOptions(locales)
+
+    expect(options['fr-FR']).toBe('Français')
+    expect(options['en-US']).toBe('English')
+  })
+
+  it('adds regionCode when name is duplicated', () => {
+    const locales: Record<string, Locale> = {
+      'pt-BR': makeLocale('pt-BR', 'Português'),
+      'pt-PT': makeLocale('pt-PT', 'Português'),
+    }
+
+    const options = buildLanguageOptions(locales)
+
+    expect(options['pt-BR']).toBe('Português (BR)')
+    expect(options['pt-PT']).toBe('Português (PT)')
+  })
+
+  it('handles mixed unique and duplicated languageNames', () => {
+    const locales: Record<string, Locale> = {
+      'en-US': makeLocale('en-US', 'English'),
+      'pt-BR': makeLocale('pt-BR', 'Português'),
+      'pt-PT': makeLocale('pt-PT', 'Português'),
+      'fr-FR': makeLocale('fr-FR', 'Français'),
+    }
+
+    const options = buildLanguageOptions(locales)
+
+    expect(options['en-US']).toBe('English')
+    expect(options['pt-BR']).toBe('Português (BR)')
+    expect(options['pt-PT']).toBe('Português (PT)')
+    expect(options['fr-FR']).toBe('Français')
+  })
+
+  it('returns empty object for empty locales', () => {
+    const options = buildLanguageOptions({})
+    expect(options).toEqual({})
+  })
+})
+
+describe('getCurrenciesForLocale', () => {
+  const testCases = [
+    {
+      name: 'returns unique currencies from bindings',
+      bindings: [
+        createBinding({ currencyCode: 'BRL' }),
+        createBinding({ currencyCode: 'USD' }),
+        createBinding({ currencyCode: 'BRL' }), // duplicate
+      ],
+      expected: ['BRL', 'USD'],
+    },
+    {
+      name: 'returns single currency when only one binding',
+      bindings: [createBinding({ currencyCode: 'EUR' })],
+      expected: ['EUR'],
+    },
+    {
+      name: 'returns empty array when no bindings',
+      bindings: [],
+      expected: [],
+    },
+    {
+      name: 'preserves order of first occurrence',
+      bindings: [
+        createBinding({ currencyCode: 'USD' }),
+        createBinding({ currencyCode: 'EUR' }),
+        createBinding({ currencyCode: 'BRL' }),
+        createBinding({ currencyCode: 'USD' }), // duplicate
+      ],
+      expected: ['USD', 'EUR', 'BRL'],
+    },
+  ]
+
+  testCases.forEach(({ name, bindings, expected }) => {
+    it(name, () => {
+      const locale = createLocale({ bindings })
+      const currencies = getCurrenciesForLocale(locale)
+      expect(currencies).toEqual(expected)
+    })
+  })
+})
+
+describe('resolveBinding', () => {
+  const mockBindings = {
+    usd: () =>
+      createBinding({ currencyCode: 'USD', url: 'https://usd.example.com' }),
+    eur: () =>
+      createBinding({ currencyCode: 'EUR', url: 'https://eur.example.com' }),
+    brl: (isDefault: boolean, salesChannel: string) =>
+      createBinding({
+        currencyCode: 'BRL',
+        isDefault,
+        url: `https://brl${salesChannel}.example.com`,
+        salesChannel,
+      }),
+  }
+
+  it('returns null when no bindings match currency', () => {
+    const bindings = [mockBindings.usd(), mockBindings.eur()]
+
+    const result = resolveBinding(bindings, 'BRL')
+
+    expect(result).toBeNull()
+  })
+
+  it('returns single match when only one binding matches', () => {
+    const bindings = [mockBindings.usd(), mockBindings.eur()]
+
+    const result = resolveBinding(bindings, 'USD')
+
+    expect(result?.url).toBe('https://usd.example.com')
+  })
+
+  it('applies isDefault tie-breaker when multiple bindings match', () => {
+    const bindings = [mockBindings.brl(false, '1'), mockBindings.brl(true, '2')]
+
+    const result = resolveBinding(bindings, 'BRL')
+
+    expect(result?.url).toBe('https://brl2.example.com')
+    expect(result?.salesChannel).toBe('2')
+  })
+
+  it('falls back to first match when no isDefault exists', () => {
+    const bindings = [
+      mockBindings.brl(false, '1'),
+      mockBindings.brl(false, '2'),
+    ]
+
+    const result = resolveBinding(bindings, 'BRL')
+
+    expect(result?.url).toBe('https://brl1.example.com')
+    expect(result?.salesChannel).toBe('1')
+  })
+
+  it('returns null for empty bindings array', () => {
+    const result = resolveBinding([], 'USD')
+
+    expect(result).toBeNull()
+  })
+
+  it('handles multiple currencies with isDefault correctly', () => {
+    const bindings = [
+      createBinding({
+        currencyCode: 'USD',
+        isDefault: true,
+        url: 'https://usd-default.example.com',
+      }),
+      createBinding({
+        currencyCode: 'USD',
+        isDefault: false,
+        url: 'https://usd-secondary.example.com',
+      }),
+      createBinding({
+        currencyCode: 'EUR',
+        isDefault: true,
+        url: 'https://eur-default.example.com',
+      }),
+    ]
+
+    const usdResult = resolveBinding(bindings, 'USD')
+    const eurResult = resolveBinding(bindings, 'EUR')
+
+    expect(usdResult?.url).toBe('https://usd-default.example.com')
+    expect(eurResult?.url).toBe('https://eur-default.example.com')
+  })
+})
+
+describe('isValidUrl', () => {
+  it('returns true for valid absolute URLs', () => {
+    expect(isValidUrl('https://store.example.com')).toBe(true)
+    expect(isValidUrl('https://store.example.com/pt-BR')).toBe(true)
+    expect(isValidUrl('http://localhost:3000')).toBe(true)
+    expect(isValidUrl('https://sub.domain.example.com/path?query=1')).toBe(true)
+  })
+
+  it('returns false for empty or whitespace URLs', () => {
+    expect(isValidUrl('')).toBe(false)
+    expect(isValidUrl('   ')).toBe(false)
+  })
+
+  it('returns false for invalid URLs', () => {
+    expect(isValidUrl('not-a-url')).toBe(false)
+    expect(isValidUrl('store.example.com')).toBe(false) // missing protocol
+    expect(isValidUrl('/relative/path')).toBe(false)
+  })
+
+  it('returns false for null-like values', () => {
+    // TypeScript should prevent this, but test runtime behavior
+    expect(isValidUrl(null as unknown as string)).toBe(false)
+    expect(isValidUrl(undefined as unknown as string)).toBe(false)
+  })
+})

package/test/sdk/localization/store-url.browser.test.ts

@@ -0,0 +1,140 @@
+import { afterAll, describe, expect, it, vi } from 'vitest'
+import { getStoreURL } from '../../../src/sdk/localization/useLocalizationConfig.js'
+
+vi.mock(import('../../../discovery.config.js'), async (original) => ({
+  default: {
+    ...((await original()).default ?? (await original())),
+    localization: {
+      enabled: true,
+      defaultLocale: 'pt-BR',
+      regions: {
+        US: {
+          code: 'US',
+          name: 'United States',
+          dateFormat: 'MM/DD/YYYY',
+          timeFormat: '12h',
+          timeFormatMask: 'hh:mm a',
+          unitSystem: 'imperial',
+          defaultTimezone: 'GMT-5',
+        },
+        BR: {
+          code: 'BR',
+          name: 'Brazil',
+          dateFormat: 'DD/MM/YYYY',
+          timeFormat: '24h',
+          timeFormatMask: 'HH:mm',
+          unitSystem: 'metric',
+          defaultTimezone: 'GMT-3',
+        },
+      },
+      locales: {
+        'pt-BR': {
+          code: 'pt-BR',
+          name: 'português',
+          languageCode: 'pt',
+          languageName: 'Portuguese',
+          script: 'Latn',
+          textDirection: 'ltr',
+          regionCode: 'BR',
+          bindings: [
+            {
+              currencyCode: 'BRL',
+              url: 'https://brandless.myvtex.com',
+              salesChannel: '1',
+              isDefault: true,
+            },
+            {
+              currencyCode: 'BRL',
+              url: 'https://brandless.fast.store/pt-BR',
+              salesChannel: '1',
+              isDefault: false,
+            },
+          ],
+        },
+        'en-US': {
+          code: 'en-US',
+          name: 'English',
+          languageCode: 'en',
+          languageName: 'English',
+          script: 'Latn',
+          textDirection: 'ltr',
+          regionCode: 'US',
+          bindings: [
+            {
+              currencyCode: 'USD',
+              url: 'https://brandless.fast.store/en-US',
+              salesChannel: '2',
+              isDefault: false,
+            },
+          ],
+        },
+      },
+      currencies: {
+        BRL: {
+          code: 'BRL',
+          name: 'Brazilian Real',
+          symbol: 'R$',
+        },
+        USD: {
+          code: 'USD',
+          name: 'US Dollar',
+          symbol: '$',
+        },
+      },
+    },
+  },
+}))
+
+import config from '../../../discovery.config'
+
+const oldWindowLocation = window.location
+
+afterAll(() => {
+  // restore `window.location` to the `jsdom` `Location` object
+  window.location = oldWindowLocation
+})
+
+describe('localization store url with custom location on browser', () => {
+  it('should return correct binding', () => {
+    expect(getStoreURL()).toEqual(
+      config.localization.locales['pt-BR'].bindings[0].url
+    )
+  })
+
+  it('should return the correct binding when window.location.href is defined', () => {
+    delete window.location
+    window.location = Object.defineProperties(
+      {},
+      {
+        ...Object.getOwnPropertyDescriptors(oldWindowLocation),
+        href: {
+          configurable: true,
+          value: config.localization.locales['en-US'].bindings[0].url,
+        },
+      }
+    )
+
+    expect(getStoreURL()).toEqual(
+      config.localization.locales['en-US'].bindings[0].url
+    )
+  })
+
+  it('should return the correct binding based on window.location.href', () => {
+    delete window.location
+    window.location = Object.defineProperties(
+      {},
+      {
+        ...Object.getOwnPropertyDescriptors(oldWindowLocation),
+        href: {
+          configurable: true,
+          value: `${config.localization.locales['pt-BR'].bindings[1].url}/p?query=test`,
+        },
+      }
+    )
+
+    // simulates a running environment on the browser with different window.location
+    expect(getStoreURL()).toEqual(
+      config.localization.locales['pt-BR'].bindings[1].url
+    )
+  })
+})

package/test/sdk/localization/store-url.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it, vi } from 'vitest'
+import { getStoreURL } from '../../../src/sdk/localization/useLocalizationConfig.js'
+
+vi.mock(import('../../../discovery.config.js'), async (original) => ({
+  default: {
+    ...((await original()).default ?? {}),
+    localization: {
+      enabled: true,
+      defaultLocale: 'pt-BR',
+      regions: {
+        US: {
+          code: 'US',
+          name: 'United States',
+          dateFormat: 'MM/DD/YYYY',
+          timeFormat: '12h',
+          timeFormatMask: 'hh:mm a',
+          unitSystem: 'imperial',
+          defaultTimezone: 'GMT-5',
+        },
+        BR: {
+          code: 'BR',
+          name: 'Brazil',
+          dateFormat: 'DD/MM/YYYY',
+          timeFormat: '24h',
+          timeFormatMask: 'HH:mm',
+          unitSystem: 'metric',
+          defaultTimezone: 'GMT-3',
+        },
+      },
+      locales: {
+        'pt-BR': {
+          code: 'pt-BR',
+          name: 'português',
+          languageCode: 'pt',
+          languageName: 'Portuguese',
+          script: 'Latn',
+          textDirection: 'ltr',
+          regionCode: 'BR',
+          bindings: [
+            {
+              currencyCode: 'BRL',
+              url: 'https://brandless.myvtex.com',
+              salesChannel: '1',
+              isDefault: true,
+            },
+            {
+              currencyCode: 'BRL',
+              url: 'https://brandless.fast.store/pt-BR',
+              salesChannel: '1',
+              isDefault: false,
+            },
+          ],
+        },
+        'en-US': {
+          code: 'en-US',
+          name: 'English',
+          languageCode: 'en',
+          languageName: 'English',
+          script: 'Latn',
+          textDirection: 'ltr',
+          regionCode: 'US',
+          bindings: [
+            {
+              currencyCode: 'USD',
+              url: 'https://brandless.fast.store/en-US',
+              salesChannel: '2',
+              isDefault: false,
+            },
+          ],
+        },
+      },
+      currencies: {
+        BRL: {
+          code: 'BRL',
+          name: 'Brazilian Real',
+          symbol: 'R$',
+        },
+        USD: {
+          code: 'USD',
+          name: 'US Dollar',
+          symbol: '$',
+        },
+      },
+    },
+  },
+}))
+
+import config from '../../../discovery.config'
+
+describe('localization store url', () => {
+  it('should return correct binding', () => {
+    expect(getStoreURL()).toEqual(
+      config.localization.locales['pt-BR'].bindings[0].url
+    )
+  })
+})

package/test/sdk/localization/useBindingSelector.test.tsx

@@ -0,0 +1,219 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  buildLanguageOptions,
+  getCurrenciesForLocale,
+  isValidUrl,
+  resolveBinding,
+} from '../../../src/sdk/localization/bindingSelector'
+import type { Locale } from '../../../src/sdk/localization/types'
+
+// Test data that mirrors what the hook would receive from discovery.config
+const mockLocales: Record<string, Locale> = {
+  'en-US': {
+    code: 'en-US',
+    name: 'English',
+    languageCode: 'en',
+    languageName: 'English',
+    script: 'Latn',
+    textDirection: 'ltr',
+    regionCode: 'US',
+    bindings: [
+      {
+        currencyCode: 'USD',
+        url: 'https://store.example.com/en-US',
+        salesChannel: '1',
+        isDefault: true,
+      },
+    ],
+  },
+  'pt-BR': {
+    code: 'pt-BR',
+    name: 'Português',
+    languageCode: 'pt',
+    languageName: 'Portuguese',
+    script: 'Latn',
+    textDirection: 'ltr',
+    regionCode: 'BR',
+    bindings: [
+      {
+        currencyCode: 'BRL',
+        url: 'https://store.example.com/pt-BR',
+        salesChannel: '2',
+        isDefault: true,
+      },
+      {
+        currencyCode: 'USD',
+        url: 'https://store.example.com/pt-BR-usd',
+        salesChannel: '3',
+        isDefault: false,
+      },
+    ],
+  },
+  'pt-PT': {
+    code: 'pt-PT',
+    name: 'Português',
+    languageCode: 'pt',
+    languageName: 'Portuguese',
+    script: 'Latn',
+    textDirection: 'ltr',
+    regionCode: 'PT',
+    bindings: [
+      {
+        currencyCode: 'EUR',
+        url: 'https://store.example.com/pt-PT',
+        salesChannel: '4',
+        isDefault: true,
+      },
+    ],
+  },
+  'fr-FR': {
+    code: 'fr-FR',
+    name: 'Français',
+    languageCode: 'fr',
+    languageName: 'French',
+    script: 'Latn',
+    textDirection: 'ltr',
+    regionCode: 'FR',
+    bindings: [
+      {
+        currencyCode: 'EUR',
+        url: 'https://store.example.com/fr-FR',
+        salesChannel: '5',
+        isDefault: true,
+      },
+      {
+        currencyCode: 'EUR',
+        url: 'https://store.example.com/fr-FR-alt',
+        salesChannel: '6',
+        isDefault: false,
+      },
+    ],
+  },
+}
+
+describe('useBindingSelector integration scenarios', () => {
+  describe('language options computation', () => {
+    it('disambiguates languages with same name (native name, first letter capitalized)', () => {
+      const languages = buildLanguageOptions(mockLocales)
+
+      // Português appears in both BR and PT → disambiguate with region
+      expect(languages['pt-BR']).toBe('Português (BR)')
+      expect(languages['pt-PT']).toBe('Português (PT)')
+
+      // English and Français are unique
+      expect(languages['en-US']).toBe('English')
+      expect(languages['fr-FR']).toBe('Français')
+    })
+
+    it('returns Record<string, string> format for UISelectField', () => {
+      const languages = buildLanguageOptions(mockLocales)
+
+      // Verify structure matches UISelectField options format
+      expect(typeof languages).toBe('object')
+      Object.entries(languages).forEach(([key, value]) => {
+        expect(typeof key).toBe('string')
+        expect(typeof value).toBe('string')
+      })
+    })
+  })
+
+  describe('currency filtering by locale', () => {
+    it('returns currencies available for pt-BR locale', () => {
+      const currencies = getCurrenciesForLocale(mockLocales['pt-BR'])
+
+      expect(currencies).toEqual(['BRL', 'USD'])
+    })
+
+    it('returns single currency for en-US locale', () => {
+      const currencies = getCurrenciesForLocale(mockLocales['en-US'])
+
+      expect(currencies).toEqual(['USD'])
+    })
+
+    it('returns single currency for pt-PT locale', () => {
+      const currencies = getCurrenciesForLocale(mockLocales['pt-PT'])
+
+      expect(currencies).toEqual(['EUR'])
+    })
+  })
+
+  describe('binding resolution with isDefault tie-breaker', () => {
+    it('selects isDefault binding when multiple exist for same currency', () => {
+      // fr-FR has two EUR bindings
+      const binding = resolveBinding(mockLocales['fr-FR'].bindings, 'EUR')
+
+      expect(binding?.url).toBe('https://store.example.com/fr-FR')
+      expect(binding?.isDefault).toBe(true)
+    })
+
+    it('selects correct binding for pt-BR with BRL', () => {
+      const binding = resolveBinding(mockLocales['pt-BR'].bindings, 'BRL')
+
+      expect(binding?.url).toBe('https://store.example.com/pt-BR')
+      expect(binding?.salesChannel).toBe('2')
+    })
+
+    it('selects correct binding for pt-BR with USD', () => {
+      const binding = resolveBinding(mockLocales['pt-BR'].bindings, 'USD')
+
+      expect(binding?.url).toBe('https://store.example.com/pt-BR-usd')
+      expect(binding?.salesChannel).toBe('3')
+    })
+
+    it('returns null for non-existent currency', () => {
+      const binding = resolveBinding(mockLocales['en-US'].bindings, 'EUR')
+
+      expect(binding).toBeNull()
+    })
+  })
+
+  describe('URL validation', () => {
+    it('validates binding URLs', () => {
+      // All mock URLs should be valid
+      Object.values(mockLocales).forEach((locale) => {
+        locale.bindings.forEach((binding) => {
+          expect(isValidUrl(binding.url)).toBe(true)
+        })
+      })
+    })
+  })
+
+  describe('complete flow simulation', () => {
+    it('simulates user selecting pt-BR then BRL', () => {
+      // Step 1: Build language options (locale code → native name, capitalized)
+      const languages = buildLanguageOptions(mockLocales)
+      expect(languages['pt-BR']).toBe('Português (BR)')
+
+      // Step 2: User selects pt-BR locale, get currencies
+      const currencies = getCurrenciesForLocale(mockLocales['pt-BR'])
+      expect(currencies).toContain('BRL')
+      expect(currencies).toContain('USD')
+
+      // Step 3: User selects BRL currency, resolve binding
+      const binding = resolveBinding(mockLocales['pt-BR'].bindings, 'BRL')
+      expect(binding).not.toBeNull()
+
+      // Step 4: Validate URL before redirect
+      expect(isValidUrl(binding!.url)).toBe(true)
+      expect(binding!.url).toBe('https://store.example.com/pt-BR')
+    })
+
+    it('simulates user changing from en-US to pt-PT', () => {
+      // Initial: en-US locale with USD
+      const initialCurrencies = getCurrenciesForLocale(mockLocales['en-US'])
+      expect(initialCurrencies).toEqual(['USD'])
+
+      // User changes to pt-PT locale
+      const newCurrencies = getCurrenciesForLocale(mockLocales['pt-PT'])
+      expect(newCurrencies).toEqual(['EUR'])
+
+      // USD is not available in pt-PT
+      expect(newCurrencies.includes('USD')).toBe(false)
+
+      // Only EUR is available, so it would be auto-selected
+      expect(newCurrencies.length).toBe(1)
+      expect(newCurrencies[0]).toBe('EUR')
+    })
+  })
+})