@lion/ui 0.23.0 → 0.25.0

package/components/input-stepper/test-suites/lion-input-stepper.suite.js

@@ -14,12 +14,10 @@ import { LionInputStepper } from '../src/LionInputStepper.js';
 /**
  * @typedef {import('lit').TemplateResult} TemplateResult
  */
-const fixture = /** @type {(arg: TemplateResult|string) => Promise<LionInputStepper>} */ (_fixture);
-
+const fixture = /** @type {(arg: TemplateResult|string) => Promise<LionInputStepper>} */ _fixture;
 export function runInputStepperSuite(klass = LionInputStepper) {
   const tagString = defineCE(class extends klass {});
   const tag = unsafeStatic(tagString);
-
   const defaultInputStepper = html`
     <${tag} name="year" label="Years"></${tag}>
   `;
@@ -37,129 +35,144 @@ export function runInputStepperSuite(klass = LionInputStepper) {
     value="1"
     readonly
   ></${tag}>`;
-
   describe('InputStepper', async () => {
     describe('Stepper', () => {
       it('has a type text', async () => {
         const el = await fixture(defaultInputStepper);
         expect(el._inputNode.type).to.equal('text');
       });
-
       it('has a default min and max of Infinity', async () => {
         const el = await fixture(defaultInputStepper);
         expect(el.getAttribute('min')).to.equal('Infinity');
         expect(el.getAttribute('max')).to.equal('Infinity');
       });
-
       it('has a default step of 1', async () => {
         const el = await fixture(defaultInputStepper);
         expect(el.getAttribute('step')).to.equal('1');
       });
-
       it('can set a step with which the value increases', async () => {
         const el = await fixture(defaultInputStepper);
         el.step = 10;
         await el.updateComplete;
         expect(el.value).to.equal('');
         expect(el.getAttribute('step')).to.equal('10');
-
         const incrementButton = el.querySelector('[slot=suffix]');
         incrementButton?.dispatchEvent(new Event('click'));
         expect(el.value).to.equal('10');
       });
     });
-
     describe('Formatter', () => {
       it('uses formatNumber for formatting', async () => {
         const el = await fixture(defaultInputStepper);
         expect(el.formatter).to.equal(formatNumber);
       });
-
       it('formatNumber uses locale provided in formatOptions', async () => {
         let el = await fixture(html`
-          <${tag} .formatOptions="${{ locale: 'en-GB' }}" .modelValue="${1234.56}"
+          <${tag} .formatOptions="${{
+            locale: 'en-GB',
+          }}" .modelValue="${1234.56}"
           ></${tag}>
         `);
         expect(el.formattedValue).to.equal('1,234.56');
         el = await fixture(html`
-          <${tag} .formatOptions="${{ locale: 'nl-NL' }}" .modelValue="${1234.56}"
+          <${tag} .formatOptions="${{
+            locale: 'nl-NL',
+          }}" .modelValue="${1234.56}"
           ></${tag}>
         `);
         expect(el.formattedValue).to.equal('1.234,56');
       });
-
       it('supports overriding decimalSeparator in formatOptions', async () => {
-        const el = await fixture(
-          html`<${tag}
-            .formatOptions="${{ locale: 'nl-NL', decimalSeparator: '.' }}"
+        const el = await fixture(html`<${tag}
+            .formatOptions="${{
+              locale: 'nl-NL',
+              decimalSeparator: '.',
+            }}"
             .modelValue="${12.34}"
             
-          ></${tag}>`,
-        );
+          ></${tag}>`);
         expect(el.formattedValue).to.equal('12.34');
       });
-
       it('supports overriding groupSeparator in formatOptions', async () => {
-        const el = await fixture(
-          html`<${tag}
-            .formatOptions="${{ locale: 'nl-NL', groupSeparator: ',', decimalSeparator: '.' }}"
+        const el = await fixture(html`<${tag}
+            .formatOptions="${{
+              locale: 'nl-NL',
+              groupSeparator: ',',
+              decimalSeparator: '.',
+            }}"
             .modelValue="${1234.56}"
             
-          ></${tag}>`,
-        );
+          ></${tag}>`);
         expect(el.formattedValue).to.equal('1,234.56');
       });
     });
-
     describe('User interaction', () => {
       it('should NOT increment the value to 1 on [ArrowUp] when is readonly', async () => {
         const el = await fixture(inputStepperReadOnly);
         expect(el.value).to.equal('1');
-        el.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowUp' }));
+        el.dispatchEvent(
+          new KeyboardEvent('keydown', {
+            key: 'ArrowUp',
+          }),
+        );
         await el.updateComplete;
         expect(el.value).to.equal('1');
       });
-
       it('should NOT decrement the value to -1 on [ArrowDown] when is readonly', async () => {
         const el = await fixture(inputStepperReadOnly);
         expect(el.value).to.equal('1');
-        el.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown' }));
+        el.dispatchEvent(
+          new KeyboardEvent('keydown', {
+            key: 'ArrowDown',
+          }),
+        );
         await el.updateComplete;
         expect(el.value).to.equal('1');
       });
-
       it('should increment the value to 1 on [ArrowUp]', async () => {
         const el = await fixture(defaultInputStepper);
         expect(el.value).to.equal('');
-        el.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowUp' }));
+        el.dispatchEvent(
+          new KeyboardEvent('keydown', {
+            key: 'ArrowUp',
+          }),
+        );
         await el.updateComplete;
         expect(el.value).to.equal('1');
       });
-
       it('should increment the value to minValue on [ArrowUp] if value is below min', async () => {
         const el = await fixture(inputStepperWithAttrs);
         expect(el.value).to.equal('');
-        el.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowUp' }));
+        el.dispatchEvent(
+          new KeyboardEvent('keydown', {
+            key: 'ArrowUp',
+          }),
+        );
         await el.updateComplete;
         expect(el.value).to.equal('100');
       });
-
       it('should decrement the value to -1 on [ArrowDown]', async () => {
         const el = await fixture(defaultInputStepper);
         expect(el.value).to.equal('');
-        el.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown' }));
+        el.dispatchEvent(
+          new KeyboardEvent('keydown', {
+            key: 'ArrowDown',
+          }),
+        );
         await el.updateComplete;
         expect(el.value).to.equal('−1');
       });
-
       it('should increment the value to minValue on [ArrowDown] if value is below min', async () => {
         const el = await fixture(inputStepperWithAttrs);
         el.modelValue = 600;
-        el.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown' }));
+        el.dispatchEvent(
+          new KeyboardEvent('keydown', {
+            key: 'ArrowDown',
+          }),
+        );
         await el.updateComplete;
         expect(el.value).to.equal('200');
       });
-
       it('should increment the value to 1 on + button click', async () => {
         const el = await fixture(defaultInputStepper);
         expect(el.value).to.equal('');
@@ -167,7 +180,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         incrementButton?.dispatchEvent(new Event('click'));
         expect(el.value).to.equal('1');
       });
-
       it('should decrement the value to -1 on - button click', async () => {
         const el = await fixture(defaultInputStepper);
         expect(el.value).to.equal('');
@@ -175,7 +187,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         decrementButton?.dispatchEvent(new Event('click'));
         expect(el.value).to.equal('−1');
       });
-
       it('fires one "user-input-changed" event on + button click', async () => {
         let counter = 0;
         const el = await fixture(html`
@@ -193,7 +204,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         incrementButton?.dispatchEvent(new Event('click'));
         expect(counter).to.equal(1);
       });
-
       it('fires one "user-input-changed" event on - button click', async () => {
         let counter = 0;
         const el = await fixture(html`
@@ -211,7 +221,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         decrementButton?.dispatchEvent(new Event('click'));
         expect(counter).to.equal(1);
       });
-
       it('should update min and max attributes when min and max property change', async () => {
         const el = await fixture(inputStepperWithAttrs);
         el.min = 100;
@@ -220,7 +229,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         expect(el._inputNode.min).to.equal(el.min.toString());
         expect(el._inputNode.max).to.equal(el.max.toString());
       });
-
       it('should remove the disabled attribute of the decrement button when the min property changes to below the modelvalue', async () => {
         const el = await fixture(inputStepperWithAttrs);
         const decrementButton = el.querySelector('[slot=prefix]');
@@ -231,7 +239,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         await nextFrame();
         expect(decrementButton?.getAttribute('disabled')).to.equal(null);
       });
-
       it('should add the disabled attribute of the decrement button when the min property changes to the modelvalue', async () => {
         const el = await fixture(inputStepperWithAttrs);
         const decrementButton = el.querySelector('[slot=prefix]');
@@ -242,7 +249,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         await nextFrame();
         expect(decrementButton?.getAttribute('disabled')).to.equal('true');
       });
-
       it('should remove the disabled attribute of the increment button when the max property changes to above the modelvalue', async () => {
         const el = await fixture(inputStepperWithAttrs);
         const incrementButton = el.querySelector('[slot=suffix]');
@@ -253,7 +259,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         await nextFrame();
         expect(incrementButton?.getAttribute('disabled')).to.equal(null);
       });
-
       it('should add the disabled attribute of the increment button when the max property changes to the modelvalue', async () => {
         const el = await fixture(inputStepperWithAttrs);
         const incrementButton = el.querySelector('[slot=suffix]');
@@ -264,7 +269,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         await nextFrame();
         expect(incrementButton?.getAttribute('disabled')).to.equal('true');
       });
-
       it('should react to changes in the modelValue by adjusting the disabled state of the button', async () => {
         const el = await fixture(inputStepperWithAttrs);
         const incrementButton = el.querySelector('[slot=suffix]');
@@ -275,7 +279,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         await nextFrame();
         expect(incrementButton?.getAttribute('disabled')).to.equal('true');
       });
-
       describe('It align to steps', () => {
         it('aligns the value to the nearest step when incrementing', async () => {
           let el = await fixture(html`<${tag} step="10" min="0" max="100" value="55"></${tag}>`);
@@ -312,7 +315,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
           await el.updateComplete;
           expect(el.modelValue).to.equal(-3, 'Fail + : (-23 > 100 by 10; val 55)'); // -23 > -13 > -3 > 7
         });
-
         it('aligns the value to the nearest step when decrementing', async () => {
           let el = await fixture(html`<${tag} step="10" min="0" max="100" value="55"></${tag}>`);
           let decrementButton = el.querySelector('[slot=prefix]');
@@ -348,7 +350,6 @@ export function runInputStepperSuite(klass = LionInputStepper) {
           await el.updateComplete;
           expect(el.modelValue).to.equal(-13, 'Fail - : (-23 > 100 by 10; val 55)'); // -23 > -13 > -3 > 7
         });
-
         it('handles decimal step values correctly', async () => {
           // Test with decimal step 0.1
           let el = await fixture(html`<${tag} step="0.1" min="0" max="9" value="5.55"></${tag}>`);
@@ -385,13 +386,11 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         });
       });
     });
-
     describe('_destroyOutputContent method', () => {
       beforeEach(() => {
         // Ensure clean state for each test
         sinon.restore();
       });
-
       it('should clear existing timer before setting a new one', async () => {
         const el = await fixture(defaultInputStepper);
         const clearTimeoutSpy = sinon.spy(window, 'clearTimeout');
@@ -402,11 +401,9 @@ export function runInputStepperSuite(klass = LionInputStepper) {
 
         // Call _destroyOutputContent
         el._destroyOutputContent();
-
         expect(clearTimeoutSpy.calledWith(initialTimer)).to.be.true;
         clearTimeoutSpy.restore();
       });
-
       it('should set __valueText to nothing and request update after timeout', async () => {
         const el = await fixture(defaultInputStepper);
         const requestUpdateSpy = sinon.spy(el, 'requestUpdate');
@@ -420,32 +417,26 @@ export function runInputStepperSuite(klass = LionInputStepper) {
 
         // Fast forward time by 2000ms (default timeout)
         clock.tick(2000);
-
         await expect(el.__valueText).to.equal(nothing);
         expect(requestUpdateSpy.calledOnce).to.be.true;
-
         clock.restore();
         requestUpdateSpy.restore();
       });
-
       it('should use custom timeout from data-self-destruct attribute', async () => {
         const el = await fixture(html`
           <${tag} name="test" label="Test"> ></${tag}>
         `);
-
         await el.updateComplete;
 
         // Get the output element and set custom self-destruct value
-        const outputElement = /** @type {HTMLElement} */ (
-          el.shadowRoot?.querySelector('.input-stepper__value')
-        );
+        const outputElement =
+          /** @type {HTMLElement} */
+          el.shadowRoot?.querySelector('.input-stepper__value');
         if (outputElement) {
           outputElement.dataset.selfDestruct = '5000';
         }
-
         const clock = sinon.useFakeTimers();
         const requestUpdateSpy = sinon.spy(el, 'requestUpdate');
-
         el.__valueText = 'test value';
         el._destroyOutputContent();
 
@@ -458,29 +449,24 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         clock.tick(3000); // Total 5000ms
         await expect(el.__valueText).to.equal(nothing);
         expect(requestUpdateSpy.calledOnce).to.be.true;
-
         clock.restore();
         requestUpdateSpy.restore();
       });
-
       it('should handle invalid data-self-destruct value by using default timeout', async () => {
         const el = await fixture(html`
           <${tag} name="test" label="Test"> ></${tag}>
         `);
-
         await el.updateComplete;
 
         // Get the output element and set invalid self-destruct value
-        const outputElement = /** @type {HTMLElement} */ (
-          el.shadowRoot?.querySelector('.input-stepper__value')
-        );
+        const outputElement =
+          /** @type {HTMLElement} */
+          el.shadowRoot?.querySelector('.input-stepper__value');
         if (outputElement) {
           outputElement.dataset.selfDestruct = 'invalid';
         }
-
         const clock = sinon.useFakeTimers();
         const requestUpdateSpy = sinon.spy(el, 'requestUpdate');
-
         el.__valueText = 'test value';
         el._destroyOutputContent();
 
@@ -488,11 +474,9 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         clock.tick(2000);
         await expect(el.__valueText).to.equal(nothing);
         expect(requestUpdateSpy.calledOnce).to.be.true;
-
         clock.restore();
         requestUpdateSpy.restore();
       });
-
       it('should not set timeout if output element does not exist', async () => {
         const el = await fixture(defaultInputStepper);
         const setTimeoutSpy = sinon.spy(window, 'setTimeout');
@@ -502,9 +486,7 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         if (el.shadowRoot) {
           el.shadowRoot.querySelector = () => null;
         }
-
         el._destroyOutputContent();
-
         expect(setTimeoutSpy.called).to.be.false;
 
         // Restore original querySelector
@@ -513,12 +495,10 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         }
         setTimeoutSpy.restore();
       });
-
       it('should only execute timeout callback if output element still has parent', async () => {
         const el = await fixture(defaultInputStepper);
         const clock = sinon.useFakeTimers();
         const requestUpdateSpy = sinon.spy(el, 'requestUpdate');
-
         el.__valueText = 'test value';
         el._destroyOutputContent();
 
@@ -534,38 +514,29 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         // Should not have updated since element was removed
         expect(requestUpdateSpy.called).to.be.false;
         expect(el.__valueText).to.equal('test value');
-
         clock.restore();
         requestUpdateSpy.restore();
       });
-
       it('should be called when increment button is clicked', async () => {
         const el = await fixture(defaultInputStepper);
         const destroyOutputSpy = sinon.spy(el, '_destroyOutputContent');
-
         const incrementButton = el.querySelector('[slot=suffix]');
         incrementButton?.dispatchEvent(new Event('click'));
-
         expect(destroyOutputSpy.calledOnce).to.be.true;
         destroyOutputSpy.restore();
       });
-
       it('should be called when decrement button is clicked', async () => {
         const el = await fixture(defaultInputStepper);
         const destroyOutputSpy = sinon.spy(el, '_destroyOutputContent');
-
         const decrementButton = el.querySelector('[slot=prefix]');
         decrementButton?.dispatchEvent(new Event('click'));
-
         expect(destroyOutputSpy.calledOnce).to.be.true;
         destroyOutputSpy.restore();
       });
-
       it('should handle multiple rapid calls by clearing previous timers', async () => {
         const el = await fixture(defaultInputStepper);
         const clock = sinon.useFakeTimers();
         const requestUpdateSpy = sinon.spy(el, 'requestUpdate');
-
         el.__valueText = 'test value';
 
         // Call _destroyOutputContent multiple times rapidly
@@ -578,48 +549,39 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         // Should not have triggered yet since second call reset the timer
         expect(el.__valueText).to.equal('test value');
         expect(requestUpdateSpy.called).to.be.false;
-
         clock.tick(1000); // Total 2 seconds from second call
 
         // Should trigger now
         await expect(el.__valueText).to.equal(nothing);
         expect(requestUpdateSpy.calledOnce).to.be.true;
-
         clock.restore();
         requestUpdateSpy.restore();
       });
     });
-
     describe('Accessibility', () => {
       it('is a11y AXE accessible', async () => {
         const el = await fixture(defaultInputStepper);
         await expect(el).to.be.accessible();
       });
-
       it('is accessible when disabled', async () => {
         const el = await fixture(html`<${tag} label="rsvp" disabled></${tag}>`);
         await expect(el).to.be.accessible();
       });
-
       it('has role="spinbutton"', async () => {
         const el = await fixture(defaultInputStepper);
         expect(el._inputNode.hasAttribute('role')).to.be.true;
         expect(el._inputNode.getAttribute('role')).to.equal('spinbutton');
       });
-
       it('updates aria-valuenow when stepper is changed', async () => {
         const el = await fixture(defaultInputStepper);
         el.modelValue = 1;
-
         await el.updateComplete;
         expect(el._inputNode.hasAttribute('aria-valuenow')).to.be.true;
         expect(el._inputNode.getAttribute('aria-valuenow')).to.equal('1');
-
         el.modelValue = '';
         await el.updateComplete;
         expect(el._inputNode.hasAttribute('aria-valuenow')).to.be.false;
       });
-
       it('updates aria-valuetext when stepper is changed', async () => {
         // VoiceOver announces percentages once the valuemin or valuemax are used.
         // This can be fixed by setting valuetext to the same value as valuenow
@@ -627,15 +589,12 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         const el = await fixture(defaultInputStepper);
         el.modelValue = 1;
         await el.updateComplete;
-
         expect(el._inputNode.hasAttribute('aria-valuetext')).to.be.true;
         expect(el._inputNode.getAttribute('aria-valuetext')).to.equal('1');
-
         el.modelValue = '';
         await el.updateComplete;
         expect(el._inputNode.hasAttribute('aria-valuetext')).to.be.false;
       });
-
       it('can give aria-valuetext to override default value as a human-readable text alternative', async () => {
         const values = {
           1: 'first',
@@ -650,45 +609,37 @@ export function runInputStepperSuite(klass = LionInputStepper) {
         expect(el._inputNode.hasAttribute('aria-valuetext')).to.be.true;
         expect(el._inputNode.getAttribute('aria-valuetext')).to.equal('first');
       });
-
       it('updates aria-valuemin when stepper is changed', async () => {
         const el = await fixture(inputStepperWithAttrs);
         const incrementButton = el.querySelector('[slot=suffix]');
         incrementButton?.dispatchEvent(new Event('click'));
         expect(el._inputNode.hasAttribute('aria-valuemin')).to.be.true;
         expect(el._inputNode.getAttribute('aria-valuemin')).to.equal('100');
-
         el.min = 0;
         await el.updateComplete;
         expect(el._inputNode.hasAttribute('aria-valuemin')).to.be.true;
         expect(el._inputNode.getAttribute('aria-valuemin')).to.equal('0');
       });
-
       it('updates aria-valuemax when stepper is changed', async () => {
         const el = await fixture(inputStepperWithAttrs);
         const incrementButton = el.querySelector('[slot=suffix]');
         incrementButton?.dispatchEvent(new Event('click'));
         expect(el._inputNode.hasAttribute('aria-valuemax')).to.be.true;
         expect(el._inputNode.getAttribute('aria-valuemax')).to.equal('200');
-
         el.max = 1000;
         await el.updateComplete;
         expect(el._inputNode.hasAttribute('aria-valuemax')).to.be.true;
         expect(el._inputNode.getAttribute('aria-valuemax')).to.equal('1000');
       });
-
       it('decrease button should have aria-label with the component label', async () => {
         const el = await fixture(inputStepperWithAttrs);
         const decrementButton = el.querySelector('[slot=prefix]');
-
         expect(decrementButton?.hasAttribute('aria-label')).to.be.true;
         expect(decrementButton?.getAttribute('aria-label')).to.equal('Decrease Label');
       });
-
       it('increase button should have aria-label with the component label', async () => {
         const el = await fixture(inputStepperWithAttrs);
         const incrementButton = el.querySelector('[slot=suffix]');
-
         expect(incrementButton?.hasAttribute('aria-label')).to.be.true;
         expect(incrementButton?.getAttribute('aria-label')).to.equal('Increase Label');
       });

package/components/input-stepper/translations/bg-BG.js

@@ -1,5 +1,4 @@
 import bg from './bg.js';
-
 export default {
   ...bg,
 };

package/components/input-stepper/translations/cs-CZ.js

@@ -1,5 +1,4 @@
 import cs from './cs.js';
-
 export default {
   ...cs,
 };

package/components/input-stepper/translations/de-DE.js

@@ -1,5 +1,4 @@
 import de from './de.js';
-
 export default {
   ...de,
 };

package/components/input-stepper/translations/en-AU.js

@@ -1,5 +1,4 @@
 import en from './en.js';
-
 export default {
   ...en,
 };

package/components/input-stepper/translations/en-GB.js

@@ -1,5 +1,4 @@
 import en from './en.js';
-
 export default {
   ...en,
 };

package/components/input-stepper/translations/en-US.js

@@ -1,5 +1,4 @@
 import en from './en.js';
-
 export default {
   ...en,
 };

package/components/input-stepper/translations/es-ES.js

@@ -1,5 +1,4 @@
 import es from './es.js';
-
 export default {
   ...es,
 };

package/components/input-stepper/translations/fr-BE.js

@@ -1,5 +1,4 @@
 import fr from './fr.js';
-
 export default {
   ...fr,
 };

package/components/input-stepper/translations/fr-FR.js

@@ -1,5 +1,4 @@
 import fr from './fr.js';
-
 export default {
   ...fr,
 };

package/components/input-stepper/translations/hu-HU.js

@@ -1,5 +1,4 @@
 import hu from './hu.js';
-
 export default {
   ...hu,
 };

package/components/input-stepper/translations/it-IT.js

@@ -1,5 +1,4 @@
 import it from './it.js';
-
 export default {
   ...it,
 };

package/components/input-stepper/translations/nl-BE.js

@@ -1,5 +1,4 @@
 import nl from './nl.js';
-
 export default {
   ...nl,
 };

package/components/input-stepper/translations/nl-NL.js

@@ -1,5 +1,4 @@
 import nl from './nl.js';
-
 export default {
   ...nl,
 };

package/components/input-stepper/translations/pl-PL.js

@@ -1,5 +1,4 @@
 import pl from './pl.js';
-
 export default {
   ...pl,
 };

package/components/input-stepper/translations/ro-RO.js

@@ -1,5 +1,4 @@
 import ro from './ro.js';
-
 export default {
   ...ro,
 };

package/components/input-stepper/translations/ru-RU.js

@@ -1,5 +1,4 @@
 import ru from './ru.js';
-
 export default {
   ...ru,
 };