@pushwoosh/dumb-components 2.9.11 → 2.9.13

package/WhatsAppPreview/__tests__/attachment.test.js

@@ -1,103 +0,0 @@
-import { formatAttachmentDuration, formatAttachmentSize, getAttachmentExtension, isMessageDrawable, resolveAttachmentKind, toVideoPosterSource } from '../helpers';
-const SOURCE = 'data:image/jpeg;base64,AAAA';
-describe('resolveAttachmentKind', () => {
-  it('reads the MIME type first', () => {
-    expect(resolveAttachmentKind({
-      name: 'a.pdf',
-      source: SOURCE,
-      mimeType: 'image/png'
-    })).toBe('image');
-    expect(resolveAttachmentKind({
-      name: 'a',
-      source: SOURCE,
-      mimeType: 'video/mp4'
-    })).toBe('video');
-  });
-  it('falls back to the extension', () => {
-    expect(resolveAttachmentKind({
-      name: 'store.JPG',
-      source: SOURCE
-    })).toBe('image');
-    expect(resolveAttachmentKind({
-      name: 'tour.mp4',
-      source: SOURCE
-    })).toBe('video');
-    expect(resolveAttachmentKind({
-      name: 'terms.docx',
-      source: SOURCE
-    })).toBe('document');
-  });
-  it('treats an unknown file as a document', () => {
-    expect(resolveAttachmentKind({
-      name: 'notes',
-      source: SOURCE
-    })).toBe('document');
-  });
-  it('obeys an explicit kind', () => {
-    expect(resolveAttachmentKind({
-      name: 'a.png',
-      source: SOURCE,
-      kind: 'document',
-      mimeType: 'image/png'
-    })).toBe('document');
-  });
-});
-describe('attachment meta', () => {
-  it('reads the extension off the name', () => {
-    expect(getAttachmentExtension({
-      name: 'Price list.pdf',
-      source: SOURCE
-    })).toBe('pdf');
-    expect(getAttachmentExtension({
-      name: 'notes',
-      source: SOURCE
-    })).toBe('');
-  });
-  it('falls back to the MIME subtype when the name has no extension', () => {
-    expect(getAttachmentExtension({
-      name: 'Title',
-      source: SOURCE,
-      mimeType: 'application/PDF'
-    })).toBe('pdf');
-    expect(getAttachmentExtension({
-      name: 'Title.docx',
-      source: SOURCE,
-      mimeType: 'application/pdf'
-    })).toBe('docx');
-  });
-  it('writes sizes the way WhatsApp does', () => {
-    expect(formatAttachmentSize(912)).toBe('912 B');
-    expect(formatAttachmentSize(69_632)).toBe('68 kB');
-    expect(formatAttachmentSize(1_468_006)).toBe('1.4 MB');
-  });
-  it('writes video length as m:ss', () => {
-    expect(formatAttachmentDuration(6.2)).toBe('0:06');
-    expect(formatAttachmentDuration(75)).toBe('1:15');
-  });
-  it('asks the video for a poster frame once', () => {
-    expect(toVideoPosterSource('blob:tour')).toBe('blob:tour#t=0.001');
-    expect(toVideoPosterSource('blob:tour#t=2')).toBe('blob:tour#t=2');
-  });
-});
-describe('isMessageDrawable', () => {
-  it('keeps a message that has a body or a file', () => {
-    expect(isMessageDrawable({
-      text: 'hi'
-    })).toBe(true);
-    expect(isMessageDrawable({
-      attachments: [{
-        name: 'a.jpg',
-        source: SOURCE
-      }]
-    })).toBe(true);
-  });
-  it('drops a message with nothing to show', () => {
-    expect(isMessageDrawable({})).toBe(false);
-    expect(isMessageDrawable({
-      attachments: [{
-        name: 'a.jpg',
-        source: ''
-      }]
-    })).toBe(false);
-  });
-});

package/WhatsAppPreview/__tests__/parseWhatsAppMarkup.test.d.ts

@@ -1 +0,0 @@
-export {};

package/WhatsAppPreview/__tests__/parseWhatsAppMarkup.test.js

@@ -1,59 +0,0 @@
-import { parseWhatsAppMarkup } from '../helpers';
-describe('parseWhatsAppMarkup', () => {
-  it('keeps plain text as a single node', () => {
-    expect(parseWhatsAppMarkup('Hi there')).toEqual([{
-      text: 'Hi there'
-    }]);
-  });
-  it('marks bold, italic and strikethrough runs', () => {
-    expect(parseWhatsAppMarkup('*a* _b_ ~c~')).toEqual([{
-      style: 'bold',
-      children: [{
-        text: 'a'
-      }]
-    }, {
-      text: ' '
-    }, {
-      style: 'italic',
-      children: [{
-        text: 'b'
-      }]
-    }, {
-      text: ' '
-    }, {
-      style: 'strike',
-      children: [{
-        text: 'c'
-      }]
-    }]);
-  });
-  it('nests styles', () => {
-    expect(parseWhatsAppMarkup('*bold _both_*')).toEqual([{
-      style: 'bold',
-      children: [{
-        text: 'bold '
-      }, {
-        style: 'italic',
-        children: [{
-          text: 'both'
-        }]
-      }]
-    }]);
-  });
-  it('keeps monospace content literal', () => {
-    expect(parseWhatsAppMarkup('```*raw*```')).toEqual([{
-      style: 'mono',
-      children: [{
-        text: '*raw*'
-      }]
-    }]);
-  });
-  it('leaves unpaired and empty markers as text', () => {
-    expect(parseWhatsAppMarkup('2 * 3 = 6')).toEqual([{
-      text: '2 * 3 = 6'
-    }]);
-    expect(parseWhatsAppMarkup('**')).toEqual([{
-      text: '**'
-    }]);
-  });
-});

package/helpers/__tests__/barcodeUrl.test.d.ts

@@ -1 +0,0 @@
-export {};

package/helpers/__tests__/barcodeUrl.test.js

@@ -1,43 +0,0 @@
-import { buildBarcodeUrl, barcodePlaceholderSafeEscape, isBarcodePlaceholder } from '../barcodeUrl';
-const BASE = 'https://rag-mcp.svc-nue.pushwoosh.com';
-describe('buildBarcodeUrl', () => {
-  it('omits every empty parameter', () => {
-    expect(buildBarcodeUrl({
-      value: '1234567890123456'
-    }, `${BASE}/`)).toBe(`${BASE}/barcode/v1/code.png?sym=code128&v=1234567890123456`);
-  });
-  // A percent-encoded brace never matches the substituter, on the server or on
-  // the device, so the barcode would encode the placeholder text itself.
-  it.each(['{{voucher}}', '{Coupon|String|}', 'BR-{{voucher}}'])('keeps the placeholder %s literal', value => {
-    expect(buildBarcodeUrl({
-      value
-    }, BASE).endsWith(`&v=${value}`)).toBe(true);
-  });
-  it('escapes what is not a placeholder', () => {
-    expect(barcodePlaceholderSafeEscape('a b&c={{v}}')).toBe('a+b%26c%3D{{v}}');
-  });
-  it('carries every set parameter', () => {
-    const url = buildBarcodeUrl({
-      value: '{Coupon|String|}',
-      symbology: 'qr',
-      showText: true,
-      width: 420,
-      height: 460,
-      quietModules: 6,
-      foregroundColor: '#101010',
-      backgroundColor: '#ffffff',
-      ecLevel: 'H'
-    }, BASE);
-    ['sym=qr', 'hri=1', 'w=420', 'h=460', 'q=6', 'fg=101010', 'bg=ffffff', 'ec=H'].forEach(part => expect(url).toContain(part));
-  });
-  it('drops the error-correction level outside QR', () => {
-    expect(buildBarcodeUrl({
-      value: '1',
-      ecLevel: 'H'
-    }, BASE)).not.toContain('ec=');
-  });
-  it('recognizes a value that still needs substituting', () => {
-    expect(isBarcodePlaceholder('{Coupon|String|}')).toBe(true);
-    expect(isBarcodePlaceholder('4012345678901')).toBe(false);
-  });
-});

package/helpers/__tests__/timezones.test.d.ts

@@ -1 +0,0 @@
-export {};

package/helpers/__tests__/timezones.test.js

@@ -1,188 +0,0 @@
-import { canonicalizeTimezone, findTimezoneOption, formatTimezoneLabel, formatTimezoneOffset, formatTimezoneAbbreviation, formatTimezoneBadge, formatTimezoneShort, getTimezoneOffsetSafe, listTimezones, resolveTimezoneOption } from '../timezones';
-const winter = new Date('2026-01-15T12:00:00Z');
-const melbourneDst = new Date('2026-10-10T12:00:00Z');
-const melbourneStandard = new Date('2026-06-15T12:00:00Z');
-describe('formatTimezoneOffset', () => {
-  it('renders sign, hours and minutes', () => {
-    expect(formatTimezoneOffset(300)).toBe('UTC+05:00');
-    expect(formatTimezoneOffset(330)).toBe('UTC+05:30');
-    expect(formatTimezoneOffset(-210)).toBe('UTC-03:30');
-    expect(formatTimezoneOffset(0)).toBe('UTC+00:00');
-  });
-});
-describe('formatTimezoneShort', () => {
-  it('renders the bare offset the calendar badge shows', () => {
-    expect(formatTimezoneShort('Asia/Almaty', winter)).toBe('UTC+05:00');
-    expect(formatTimezoneShort('Asia/Kolkata', winter)).toBe('UTC+05:30');
-    expect(formatTimezoneShort('UTC', winter)).toBe('UTC+00:00');
-  });
-  it('follows DST at the given instant', () => {
-    expect(formatTimezoneShort('Australia/Melbourne', melbourneStandard)).toBe('UTC+10:00');
-    expect(formatTimezoneShort('Australia/Melbourne', melbourneDst)).toBe('UTC+11:00');
-  });
-  it('keeps an unknown zone readable', () => {
-    expect(formatTimezoneShort('Not/AZone', winter)).toBe('Not/AZone');
-  });
-});
-describe('formatTimezoneAbbreviation', () => {
-  it('returns the letter abbreviation where the engine has one', () => {
-    expect(formatTimezoneAbbreviation('America/New_York', winter)).toBe('EST');
-    expect(formatTimezoneAbbreviation('America/Los_Angeles', winter)).toBe('PST');
-  });
-  it('returns null where the engine only offers a GMT-style name', () => {
-    expect(formatTimezoneAbbreviation('Asia/Karachi', winter)).toBeNull();
-    expect(formatTimezoneAbbreviation('Asia/Kolkata', winter)).toBeNull();
-    expect(formatTimezoneAbbreviation('Europe/Moscow', winter)).toBeNull();
-  });
-  it('returns null for UTC and for a zone it does not know', () => {
-    expect(formatTimezoneAbbreviation('UTC', winter)).toBeNull();
-    expect(formatTimezoneAbbreviation('Not/AZone', winter)).toBeNull();
-  });
-  it('follows DST at the given instant', () => {
-    expect(formatTimezoneAbbreviation('America/New_York', new Date('2026-07-01T12:00:00Z'))).toBe('EDT');
-  });
-});
-describe('formatTimezoneBadge', () => {
-  it('pairs the abbreviation with the offset', () => {
-    expect(formatTimezoneBadge('America/New_York', winter)).toBe('EST (UTC-05:00)');
-  });
-  it('falls back to the bare offset for a zone without an abbreviation', () => {
-    expect(formatTimezoneBadge('Asia/Karachi', winter)).toBe('UTC+05:00');
-    expect(formatTimezoneBadge('Asia/Kolkata', winter)).toBe('UTC+05:30');
-    expect(formatTimezoneBadge('UTC', winter)).toBe('UTC+00:00');
-  });
-  it('follows DST at the given instant', () => {
-    expect(formatTimezoneBadge('Australia/Melbourne', melbourneStandard)).toBe('UTC+10:00');
-    expect(formatTimezoneBadge('Australia/Melbourne', melbourneDst)).toBe('UTC+11:00');
-  });
-  it('keeps an unknown zone readable', () => {
-    expect(formatTimezoneBadge('Not/AZone', winter)).toBe('Not/AZone');
-  });
-});
-describe('formatTimezoneLabel', () => {
-  it('uses the current tzdata: Kazakhstan is UTC+5 since 2024', () => {
-    expect(formatTimezoneLabel('Asia/Almaty', winter)).toBe('(UTC+05:00) Asia/Almaty');
-    expect(formatTimezoneLabel('Asia/Qostanay', winter)).toBe('(UTC+05:00) Asia/Qostanay');
-  });
-  it('keeps half-hour zones east of UTC exact', () => {
-    expect(formatTimezoneLabel('Asia/Kolkata', winter)).toBe('(UTC+05:30) Asia/Kolkata');
-    expect(formatTimezoneLabel('Asia/Kathmandu', winter)).toBe('(UTC+05:45) Asia/Kathmandu');
-    expect(formatTimezoneLabel('America/St_Johns', winter)).toBe('(UTC-03:30) America/St_Johns');
-  });
-  it('resolves the offset at the given instant, not today', () => {
-    expect(getTimezoneOffsetSafe('Australia/Melbourne', winter)).toBe(660);
-    expect(getTimezoneOffsetSafe('Australia/Melbourne', new Date('2026-07-01T00:00:00Z'))).toBe(600);
-    expect(getTimezoneOffsetSafe('Australia/Melbourne', melbourneDst)).toBe(660);
-  });
-  it('labels Etc and POSIX names the backend accepts but the picker does not list', () => {
-    expect(formatTimezoneLabel('Etc/GMT+3', winter)).toBe('(UTC-03:00) Etc/GMT+3');
-    expect(formatTimezoneLabel('Etc/GMT-0', winter)).toBe('(UTC+00:00) Etc/GMT-0');
-    expect(formatTimezoneLabel('EST', winter)).toBe('(UTC-05:00) EST');
-  });
-  it('falls back to the bare name for a zone the engine does not know', () => {
-    expect(getTimezoneOffsetSafe('Not/A_Zone')).toBeNull();
-    expect(formatTimezoneLabel('Not/A_Zone')).toBe('Not/A_Zone');
-  });
-});
-describe('canonicalizeTimezone', () => {
-  it('maps aliases onto one engine name and rejects unknown zones', () => {
-    expect(canonicalizeTimezone('Europe/Kiev')).toBe(canonicalizeTimezone('Europe/Kyiv'));
-    expect(canonicalizeTimezone('Asia/Calcutta')).toBe(canonicalizeTimezone('Asia/Kolkata'));
-    expect(canonicalizeTimezone('Etc/UTC')).toBe('UTC');
-    expect(canonicalizeTimezone('Not/A_Zone')).toBeNull();
-  });
-});
-describe('listTimezones', () => {
-  const options = listTimezones(winter);
-  it('contains UTC exactly once and no duplicates', () => {
-    expect(options.filter(option => option.value === 'UTC')).toHaveLength(1);
-    expect(new Set(options.map(option => option.value)).size).toBe(options.length);
-  });
-  it('covers every zone the engine reports', () => {
-    const supported = Intl.supportedValuesOf('timeZone');
-    expect(options.length).toBeGreaterThanOrEqual(supported.length);
-    supported.forEach(name => {
-      expect(options.some(option => option.value === name)).toBe(true);
-    });
-  });
-  it('is sorted by offset, UTC first among the zero-offset zones, then by name', () => {
-    const offsets = options.map(option => getTimezoneOffsetSafe(option.value, winter) ?? Infinity);
-    expect([...offsets].sort((a, b) => a - b)).toEqual(offsets);
-    const zeroOffset = options.filter(option => getTimezoneOffsetSafe(option.value, winter) === 0);
-    expect(zeroOffset[0].value).toBe('UTC');
-  });
-  it('labels every option in the shared format', () => {
-    options.forEach(option => {
-      expect(option.label).toBe(formatTimezoneLabel(option.value, winter));
-    });
-  });
-  it('keeps stored values selectable verbatim, skipping blanks', () => {
-    const withStored = listTimezones(winter, ['Asia/Calcutta', 'Etc/GMT-0', 'EST', 'Not/A_Zone', '', null, undefined]);
-    ['Asia/Calcutta', 'Etc/GMT-0', 'EST', 'Not/A_Zone'].forEach(name => {
-      expect(withStored.filter(option => option.value === name)).toHaveLength(1);
-    });
-    expect(withStored.some(option => option.value === '')).toBe(false);
-    expect(withStored[withStored.length - 1].value).toBe('Not/A_Zone');
-  });
-  it('answers an equal but fresh list when called again for the same minute', () => {
-    const again = listTimezones(winter);
-    expect(again).toEqual(options);
-    expect(again).not.toBe(options);
-    again.length = 0;
-    expect(listTimezones(winter)).toEqual(options);
-  });
-  it('re-resolves offsets when the instant moves across a DST boundary', () => {
-    const standard = listTimezones(melbourneStandard).find(option => option.value === 'Australia/Melbourne');
-    const dst = listTimezones(melbourneDst).find(option => option.value === 'Australia/Melbourne');
-    expect(standard?.label).toBe('(UTC+10:00) Australia/Melbourne');
-    expect(dst?.label).toBe('(UTC+11:00) Australia/Melbourne');
-  });
-  it('falls back to the browser zone and UTC when the engine has no zone list', () => {
-    const original = Intl.supportedValuesOf;
-    Object.defineProperty(Intl, 'supportedValuesOf', {
-      value: undefined,
-      configurable: true
-    });
-    try {
-      const fallback = listTimezones(winter).map(option => option.value);
-      expect(fallback).toContain('UTC');
-      expect(fallback).toContain(Intl.DateTimeFormat().resolvedOptions().timeZone);
-      expect(fallback.length).toBeLessThanOrEqual(2);
-    } finally {
-      Object.defineProperty(Intl, 'supportedValuesOf', {
-        value: original,
-        configurable: true
-      });
-    }
-  });
-});
-describe('findTimezoneOption', () => {
-  const options = listTimezones(winter, ['Asia/Calcutta']);
-  it('matches a stored name exactly, aliases included', () => {
-    expect(findTimezoneOption(options, 'Asia/Almaty', winter)?.value).toBe('Asia/Almaty');
-    expect(findTimezoneOption(options, 'Asia/Calcutta', winter)?.value).toBe('Asia/Calcutta');
-    expect(findTimezoneOption(options, 'Not/Stored', winter)).toBeNull();
-  });
-  it('maps a legacy numeric offset onto a zone with that offset at the instant', () => {
-    expect(getTimezoneOffsetSafe(findTimezoneOption(options, 330, winter).value, winter)).toBe(330);
-    expect(getTimezoneOffsetSafe(findTimezoneOption(options, '-210', winter).value, winter)).toBe(-210);
-    expect(findTimezoneOption(options, 7, winter)).toBeNull();
-  });
-  it('returns null for an empty value', () => {
-    expect(findTimezoneOption(options, '', winter)).toBeNull();
-    expect(findTimezoneOption(options, null, winter)).toBeNull();
-    expect(findTimezoneOption(options, undefined, winter)).toBeNull();
-  });
-});
-describe('resolveTimezoneOption', () => {
-  it('never rewrites the stored value', () => {
-    expect(resolveTimezoneOption('Europe/Kiev', winter)).toEqual({
-      value: 'Europe/Kiev',
-      label: '(UTC+02:00) Europe/Kiev'
-    });
-    expect(resolveTimezoneOption('Not/A_Zone', winter)).toEqual({
-      value: 'Not/A_Zone',
-      label: 'Not/A_Zone'
-    });
-  });
-});

package/hooks/__tests__/useLayer.test.d.ts

@@ -1 +0,0 @@
-export {};

package/hooks/__tests__/useLayer.test.js

@@ -1,71 +0,0 @@
-import { render } from '@testing-library/react';
-import { createElement, Fragment } from 'react';
-import { useLayer } from '../useLayer';
-const GLOBAL_KEY = '__pushwoosh_dumb_components_layer_state__';
-function resetLayerState() {
-  delete window[GLOBAL_KEY];
-}
-function Layer({
-  index,
-  zIndex
-}) {
-  const resolved = useLayer({
-    isOpen: true,
-    zIndex
-  });
-  return createElement('div', {
-    'data-testid': `layer-${index}`,
-    'data-z': resolved.zIndex
-  });
-}
-function layersTree(zIndexes) {
-  const children = zIndexes.map((zIndex, index) => createElement(Layer, {
-    // eslint-disable-next-line react/no-array-index-key
-    key: index,
-    index,
-    zIndex
-  }));
-  return createElement(Fragment, null, ...children);
-}
-function readZIndexes(getByTestId, count) {
-  return Array.from({
-    length: count
-  }, (_, index) => Number(getByTestId(`layer-${index}`).getAttribute('data-z')));
-}
-function renderZIndexes(zIndexes) {
-  const {
-    getByTestId
-  } = render(layersTree(zIndexes));
-  return readZIndexes(getByTestId, zIndexes.length);
-}
-describe('useLayer z-index resolution', () => {
-  beforeEach(resetLayerState);
-  afterEach(resetLayerState);
-  it('puts a lone layer at the base z-index', () => {
-    expect(renderZIndexes([undefined])).toEqual([10000]);
-  });
-  it('stacks plain layers in registration order', () => {
-    expect(renderZIndexes([undefined, undefined])).toEqual([10000, 10100]);
-  });
-  it('keeps a layer opened on top of an explicit base above it', () => {
-    expect(renderZIndexes([100000, undefined])).toEqual([100000, 100100]);
-  });
-  it('propagates the base to every layer stacked above it', () => {
-    expect(renderZIndexes([100000, undefined, undefined])).toEqual([100000, 100100, 100200]);
-  });
-  it('renders a lone explicit base exactly at its value', () => {
-    expect(renderZIndexes([100000])).toEqual([100000]);
-  });
-  it('honors a higher base set by a layer above', () => {
-    expect(renderZIndexes([undefined, 999999])).toEqual([10000, 999999]);
-  });
-  it('re-resolves stacked layers when an open layer changes its base', () => {
-    const {
-      rerender,
-      getByTestId
-    } = render(layersTree([100000, undefined]));
-    expect(readZIndexes(getByTestId, 2)).toEqual([100000, 100100]);
-    rerender(layersTree([200000, undefined]));
-    expect(readZIndexes(getByTestId, 2)).toEqual([200000, 200100]);
-  });
-});

package/polyglot/__tests__/filters.test.d.ts

@@ -1 +0,0 @@
-export {};

package/polyglot/__tests__/filters.test.js

@@ -1,152 +0,0 @@
-import { filters } from '../liquid/filters';
-const createContext = (language = 'en', timezone = 'UTC') => ({
-  values: {},
-  language,
-  timezone
-});
-const scalar = value => ({
-  type: 'Scalar',
-  value
-});
-describe('filters', () => {
-  describe('capitalize', () => {
-    test('capitalizes first letter', () => {
-      expect(filters.capitalize('hello', [], createContext())).toBe('Hello');
-    });
-    test('handles empty string', () => {
-      expect(filters.capitalize('', [], createContext())).toBe('');
-    });
-    test('returns non-string as is', () => {
-      expect(filters.capitalize(42, [], createContext())).toBe(42);
-    });
-  });
-  describe('upperCase', () => {
-    test('converts to uppercase', () => {
-      expect(filters.upperCase('hello', [], createContext())).toBe('HELLO');
-    });
-    test('returns non-string as is', () => {
-      expect(filters.upperCase(42, [], createContext())).toBe(42);
-    });
-  });
-  describe('lowerCase', () => {
-    test('converts to lowercase', () => {
-      expect(filters.lowerCase('HELLO', [], createContext())).toBe('hello');
-    });
-    test('returns non-string as is', () => {
-      expect(filters.lowerCase(42, [], createContext())).toBe(42);
-    });
-  });
-  describe('pluralize', () => {
-    describe('English', () => {
-      const ctx = createContext('en');
-      test('returns singular for 1', () => {
-        expect(filters.pluralize(1, [scalar('item'), scalar('items')], ctx)).toBe('item');
-      });
-      test('returns plural for 0', () => {
-        expect(filters.pluralize(0, [scalar('item'), scalar('items')], ctx)).toBe('items');
-      });
-      test('returns plural for 2+', () => {
-        expect(filters.pluralize(5, [scalar('item'), scalar('items')], ctx)).toBe('items');
-      });
-    });
-    describe('Russian', () => {
-      const ctx = createContext('ru');
-      test('returns first form for 1', () => {
-        expect(filters.pluralize(1, [scalar('яблоко'), scalar('яблока'), scalar('яблок')], ctx)).toBe('яблоко');
-      });
-      test('returns second form for 2-4', () => {
-        expect(filters.pluralize(2, [scalar('яблоко'), scalar('яблока'), scalar('яблок')], ctx)).toBe('яблока');
-        expect(filters.pluralize(3, [scalar('яблоко'), scalar('яблока'), scalar('яблок')], ctx)).toBe('яблока');
-        expect(filters.pluralize(4, [scalar('яблоко'), scalar('яблока'), scalar('яблок')], ctx)).toBe('яблока');
-      });
-      test('returns third form for 5-20', () => {
-        expect(filters.pluralize(5, [scalar('яблоко'), scalar('яблока'), scalar('яблок')], ctx)).toBe('яблок');
-        expect(filters.pluralize(11, [scalar('яблоко'), scalar('яблока'), scalar('яблок')], ctx)).toBe('яблок');
-        expect(filters.pluralize(20, [scalar('яблоко'), scalar('яблока'), scalar('яблок')], ctx)).toBe('яблок');
-      });
-      test('returns first form for 21', () => {
-        expect(filters.pluralize(21, [scalar('яблоко'), scalar('яблока'), scalar('яблок')], ctx)).toBe('яблоко');
-      });
-    });
-    test('returns value as is for non-number', () => {
-      expect(filters.pluralize('not a number', [scalar('a'), scalar('b')], createContext())).toBe('not a number');
-    });
-  });
-  describe('pluralize with CLDR forms', () => {
-    const arabic = ['صفر', 'صف', 'صفان', 'صفوف', 'صفًا', 'صف*'].map(scalar);
-    test('picks each of the six Arabic forms', () => {
-      const ctx = createContext('ar');
-      expect(filters.pluralize(0, arabic, ctx)).toBe('صفر');
-      expect(filters.pluralize(1, arabic, ctx)).toBe('صف');
-      expect(filters.pluralize(2, arabic, ctx)).toBe('صفان');
-      expect(filters.pluralize(3, arabic, ctx)).toBe('صفوف');
-      expect(filters.pluralize(10, arabic, ctx)).toBe('صفوف');
-      expect(filters.pluralize(11, arabic, ctx)).toBe('صفًا');
-      expect(filters.pluralize(99, arabic, ctx)).toBe('صفًا');
-      expect(filters.pluralize(100, arabic, ctx)).toBe('صف*');
-      expect(filters.pluralize(103, arabic, ctx)).toBe('صفوف');
-    });
-    test('keeps the legacy one/other split when fewer forms are given', () => {
-      const ctx = createContext('ar');
-      expect(filters.pluralize(1, [scalar('صف'), scalar('صفوف')], ctx)).toBe('صف');
-      expect(filters.pluralize(0, [scalar('صف'), scalar('صفوف')], ctx)).toBe('صفوف');
-      expect(filters.pluralize(2, [scalar('صف'), scalar('صفوف')], ctx)).toBe('صفوف');
-    });
-    test('Russian three-form rule matches CLDR one/few/many for integers', () => {
-      const ctx = createContext('ru');
-      const forms = [scalar('one'), scalar('few'), scalar('many')];
-      const rules = new Intl.PluralRules('ru');
-      for (let n = 0; n <= 1000; n += 1) {
-        expect(filters.pluralize(n, forms, ctx)).toBe(rules.select(n));
-      }
-    });
-  });
-  describe('formatNumber', () => {
-    test('formats integer with spaces', () => {
-      expect(filters.formatNumber('1000000', [], createContext())).toBe('1 000 000');
-    });
-    test('formats with decimal places', () => {
-      expect(filters.formatNumber('1234.5', [scalar(2)], createContext())).toBe('1 234,50');
-    });
-    test('truncates excess decimal places', () => {
-      expect(filters.formatNumber('1234.5678', [scalar(2)], createContext())).toBe('1 234,56');
-    });
-    test('handles integer without decimal', () => {
-      expect(filters.formatNumber('1234', [], createContext())).toBe('1 234');
-    });
-  });
-  describe('formatDate', () => {
-    const testDate = '2024-06-15T12:30:00Z';
-    test('formats date with context timezone', () => {
-      const result = filters.formatDate(testDate, [], createContext('en', 'UTC'));
-      expect(result).toBe('Jun 15, 2024');
-    });
-    test('formats date with short format', () => {
-      const result = filters.formatDate(testDate, [scalar('short')], createContext('en', 'UTC'));
-      expect(result).toMatch(/\d{1,2}\/\d{1,2}\/\d{2,4}/);
-    });
-    test('formats date with long format', () => {
-      const result = filters.formatDate(testDate, [scalar('long')], createContext('en', 'UTC'));
-      expect(result).toContain('June');
-      expect(result).toContain('2024');
-    });
-    test('formats date with different locale', () => {
-      const result = filters.formatDate(testDate, [], createContext('ru', 'UTC'));
-      expect(result).toContain('2024');
-    });
-  });
-  describe('formatDateTime', () => {
-    const testDate = '2024-06-15T12:30:00Z';
-    test('formats date and time with context timezone', () => {
-      const result = filters.formatDateTime(testDate, [], createContext('en', 'UTC'));
-      expect(result).toContain('Jun');
-      expect(result).toContain('2024');
-      expect(result).toContain('12:30');
-    });
-    test('formats date and time with short format', () => {
-      const result = filters.formatDateTime(testDate, [scalar('short')], createContext('en', 'UTC'));
-      expect(result).toMatch(/\d{1,2}\/\d{1,2}\/\d{2,4}/);
-      expect(result).toContain(':');
-    });
-  });
-});

package/polyglot/__tests__/helpers.test.d.ts

@@ -1 +0,0 @@
-export {};