@pushwoosh/dumb-components 2.9.12 → 2.9.14

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 {};

package/polyglot/__tests__/helpers.test.js

@@ -1,176 +0,0 @@
-import { smartSplit, smartSplitAtFirstDelimiter, ensureNumber, ensureString, parseScalarOrVariable, addSpaceAroundOperators, unpackScalarOrValue, decodeHtmlEntities } from '../liquid/helpers';
-describe('smartSplit', () => {
-  test('splits simple string by delimiter', () => {
-    expect(smartSplit('a,b,c', ',')).toEqual(['a', 'b', 'c']);
-  });
-  test('preserves quoted strings', () => {
-    expect(smartSplit('"a,b",c', ',')).toEqual(['"a,b"', 'c']);
-  });
-  test('handles escaped quotes in strings', () => {
-    expect(smartSplit('"a\\"b",c', ',')).toEqual(['"a\\"b"', 'c']);
-  });
-  test('handles empty string', () => {
-    expect(smartSplit('', ',')).toEqual([]);
-  });
-  test('handles single element', () => {
-    expect(smartSplit('abc', ',')).toEqual(['abc']);
-  });
-});
-describe('smartSplitAtFirstDelimiter', () => {
-  test('splits at first delimiter', () => {
-    expect(smartSplitAtFirstDelimiter('a:b:c', ':')).toEqual(['a', 'b:c']);
-  });
-  test('returns original string when no delimiter', () => {
-    expect(smartSplitAtFirstDelimiter('abc', ':')).toEqual(['abc']);
-  });
-  test('preserves quoted strings before delimiter', () => {
-    expect(smartSplitAtFirstDelimiter('"a:b":c', ':')).toEqual(['"a:b"', 'c']);
-  });
-});
-describe('ensureNumber', () => {
-  test('returns number as is', () => {
-    expect(ensureNumber(42)).toBe(42);
-  });
-  test('parses string number', () => {
-    expect(ensureNumber('42')).toBe(42);
-  });
-  test('parses float', () => {
-    expect(ensureNumber('3.14')).toBe(3.14);
-  });
-  test('returns 0 for NaN', () => {
-    expect(ensureNumber('not a number')).toBe(0);
-  });
-  test('returns 0 for undefined', () => {
-    expect(ensureNumber(undefined)).toBe(0);
-  });
-});
-describe('ensureString', () => {
-  test('returns string as is', () => {
-    expect(ensureString('hello')).toBe('hello');
-  });
-  test('converts number to string', () => {
-    expect(ensureString(42)).toBe('42');
-  });
-  test('returns empty string for null', () => {
-    expect(ensureString(null)).toBe('');
-  });
-  test('returns empty string for undefined', () => {
-    expect(ensureString(undefined)).toBe('');
-  });
-});
-describe('parseScalarOrVariable', () => {
-  test('parses quoted string as scalar', () => {
-    expect(parseScalarOrVariable('"hello"')).toEqual({
-      type: 'Scalar',
-      value: 'hello'
-    });
-  });
-  test('parses boolean true', () => {
-    expect(parseScalarOrVariable('true')).toEqual({
-      type: 'Scalar',
-      value: true
-    });
-  });
-  test('parses boolean false', () => {
-    expect(parseScalarOrVariable('false')).toEqual({
-      type: 'Scalar',
-      value: false
-    });
-  });
-  test('parses integer as scalar', () => {
-    expect(parseScalarOrVariable('42')).toEqual({
-      type: 'Scalar',
-      value: 42
-    });
-  });
-  test('parses float as scalar', () => {
-    expect(parseScalarOrVariable('3.14')).toEqual({
-      type: 'Scalar',
-      value: 3.14
-    });
-  });
-  test('parses identifier as variable', () => {
-    expect(parseScalarOrVariable('name')).toEqual({
-      type: 'Variable',
-      name: 'name'
-    });
-  });
-});
-describe('addSpaceAroundOperators', () => {
-  test('adds spaces around ==', () => {
-    expect(addSpaceAroundOperators('a==b')).toBe('a == b');
-  });
-  test('adds spaces around !=', () => {
-    expect(addSpaceAroundOperators('a!=b')).toBe('a != b');
-  });
-  test('adds spaces around >=', () => {
-    expect(addSpaceAroundOperators('a>=b')).toBe('a >= b');
-  });
-});
-describe('unpackScalarOrValue', () => {
-  const context = {
-    values: {
-      name: 'John'
-    },
-    language: 'en',
-    timezone: 'UTC'
-  };
-  test('returns scalar value directly', () => {
-    expect(unpackScalarOrValue({
-      type: 'Scalar',
-      value: 'hello'
-    }, context)).toBe('hello');
-  });
-  test('returns variable value from context', () => {
-    expect(unpackScalarOrValue({
-      type: 'Variable',
-      name: 'name'
-    }, context)).toBe('John');
-  });
-});
-describe('decodeHtmlEntities', () => {
-  describe('named entities', () => {
-    test('decodes   to non-breaking space', () => {
-      expect(decodeHtmlEntities('Hello World')).toBe('Hello\u00A0World');
-    });
-    test('decodes & to ampersand', () => {
-      expect(decodeHtmlEntities('A&B')).toBe('A&B');
-    });
-    test('decodes < and >', () => {
-      expect(decodeHtmlEntities('&lt;div&gt;')).toBe('<div>');
-    });
-    test('decodes &quot; and &apos;', () => {
-      expect(decodeHtmlEntities('&quot;hello&apos;')).toBe('"hello\'');
-    });
-    test('leaves unknown named entities as is', () => {
-      expect(decodeHtmlEntities('&unknown;')).toBe('&unknown;');
-    });
-  });
-  describe('decimal numeric entities', () => {
-    test('decodes &#160; to non-breaking space', () => {
-      expect(decodeHtmlEntities('Hello&#160;World')).toBe('Hello\u00A0World');
-    });
-    test('decodes &#60; and &#62;', () => {
-      expect(decodeHtmlEntities('&#60;div&#62;')).toBe('<div>');
-    });
-  });
-  describe('hex numeric entities', () => {
-    test('decodes &#x00A0; to non-breaking space', () => {
-      expect(decodeHtmlEntities('Hello&#x00A0;World')).toBe('Hello\u00A0World');
-    });
-    test('decodes &#xA0; (short form)', () => {
-      expect(decodeHtmlEntities('Hello&#xA0;World')).toBe('Hello\u00A0World');
-    });
-    test('decodes &#x3C; and &#x3E;', () => {
-      expect(decodeHtmlEntities('&#x3C;div&#x3E;')).toBe('<div>');
-    });
-  });
-  describe('mixed entities', () => {
-    test('decodes multiple different entity types', () => {
-      expect(decodeHtmlEntities('&lt;div&gt;&nbsp;&#60;span&#62;&#x00A0;')).toBe('<div>\u00A0<span>\u00A0');
-    });
-    test('returns text without entities unchanged', () => {
-      expect(decodeHtmlEntities('Hello World')).toBe('Hello World');
-    });
-  });
-});

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

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

package/polyglot/__tests__/parser.test.js

@@ -1,108 +0,0 @@
-import { stringToAst } from '../liquid/parser';
-describe('stringToAst', () => {
-  describe('text parsing', () => {
-    test('parses plain text', () => {
-      const ast = stringToAst('Hello World');
-      expect(ast).toHaveLength(1);
-      expect(ast[0].type).toBe('Text');
-      expect(ast[0].content).toBe('Hello World');
-    });
-    test('parses empty string', () => {
-      const ast = stringToAst('');
-      expect(ast).toHaveLength(0);
-    });
-  });
-  describe('variable parsing', () => {
-    test('parses simple variable', () => {
-      const ast = stringToAst('{{ name }}');
-      expect(ast).toHaveLength(1);
-      const node = ast[0];
-      expect(node.type).toBe('Variable');
-      expect(node.value).toEqual({
-        type: 'Variable',
-        name: 'name'
-      });
-    });
-    test('parses variable with filter', () => {
-      const ast = stringToAst('{{ name | capitalize }}');
-      expect(ast).toHaveLength(1);
-      const node = ast[0];
-      expect(node.type).toBe('Variable');
-      expect(node.filters).toHaveLength(1);
-      expect(node.filters[0].name).toBe('capitalize');
-    });
-    test('parses variable with multiple filters', () => {
-      const ast = stringToAst('{{ name | capitalize | upperCase }}');
-      expect(ast).toHaveLength(1);
-      const node = ast[0];
-      expect(node.filters).toHaveLength(2);
-      expect(node.filters[0].name).toBe('capitalize');
-      expect(node.filters[1].name).toBe('upperCase');
-    });
-    test('parses variable mixed with text', () => {
-      const ast = stringToAst('Hello {{ name }}!');
-      expect(ast).toHaveLength(3);
-      expect(ast[0].content).toBe('Hello ');
-      expect(ast[1].type).toBe('Variable');
-      expect(ast[2].content).toBe('!');
-    });
-  });
-  describe('if control parsing', () => {
-    test('parses simple if block', () => {
-      const ast = stringToAst('{% if count == 1 %}one{% endif %}');
-      expect(ast).toHaveLength(1);
-      const node = ast[0];
-      expect(node.type).toBe('Control');
-      expect(node.name).toBe('if');
-      expect(node.condition[1]).toBe('==');
-    });
-    test('parses if-else block', () => {
-      const ast = stringToAst('{% if active == true %}yes{% else %}no{% endif %}');
-      expect(ast).toHaveLength(1);
-      const node = ast[0];
-      expect(node.children).toHaveLength(1);
-      expect(node.elseChildren).toHaveLength(1);
-    });
-  });
-  describe('for control parsing', () => {
-    test('parses for loop', () => {
-      const ast = stringToAst('{% for item in items %}{{ item }}{% endfor %}');
-      expect(ast).toHaveLength(1);
-      const node = ast[0];
-      expect(node.type).toBe('Control');
-      expect(node.name).toBe('for');
-      expect(node.varName).toBe('item');
-    });
-  });
-  describe('HTML tag parsing', () => {
-    test('parses self-closing br tag', () => {
-      const ast = stringToAst('line1<br/>line2');
-      expect(ast).toHaveLength(3);
-      expect(ast[0].content).toBe('line1');
-      expect(ast[1].type).toBe('Tag');
-      expect(ast[1].name).toBe('br');
-      expect(ast[2].content).toBe('line2');
-    });
-    test('parses void hr tag', () => {
-      const ast = stringToAst('before<hr>after');
-      expect(ast).toHaveLength(3);
-      expect(ast[1].name).toBe('hr');
-    });
-    test('parses img tag with attributes', () => {
-      const ast = stringToAst('<img src="test.png" alt="test">');
-      expect(ast).toHaveLength(1);
-      const node = ast[0];
-      expect(node.name).toBe('img');
-      expect(node.params).toHaveProperty('src');
-      expect(node.params).toHaveProperty('alt');
-    });
-    test('parses nested tags', () => {
-      const ast = stringToAst('<strong>bold text</strong>');
-      expect(ast).toHaveLength(1);
-      const node = ast[0];
-      expect(node.name).toBe('strong');
-      expect(node.children).toHaveLength(1);
-      expect(node.children[0].content).toBe('bold text');
-    });
-  });
-});

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

@@ -1 +0,0 @@
-import '@testing-library/jest-dom';