@claspo/common 7.3.1-dev.2 → 7.3.1-dev.3

package/src/storage/setCookie.test.ts

@@ -1,97 +0,0 @@
-import setCookie from './setCookie';
-
-describe('setCookie', () => {
-  let originalDescriptor: PropertyDescriptor | undefined;
-  let originalLocationHost: string | undefined;
-  let originalLocationHostname: string | undefined;
-
-  beforeEach(() => {
-    originalDescriptor = Object.getOwnPropertyDescriptor(Document.prototype, 'cookie');
-    originalLocationHost = window.location.host;
-    originalLocationHostname = window.location.hostname;
-  });
-
-  afterEach(() => {
-    if (originalDescriptor) {
-      Object.defineProperty(document, 'cookie', originalDescriptor);
-    }
-    window.location.host = originalLocationHost as string;
-    window.location.hostname = originalLocationHostname as string;
-  });
-
-  it('writes cookie once for a single-segment host', () => {
-    const writes: string[] = [];
-
-    window.location.host = 'localhost';
-    window.location.hostname = 'localhost';
-    Object.defineProperty(document, 'cookie', {
-      get: () => '',
-      set: (value: string) => {
-        writes.push(value);
-      },
-      configurable: true,
-    });
-
-    setCookie('foo', 'bar');
-
-    expect(writes).toHaveLength(1);
-    expect(writes[0]).toContain('foo=bar');
-    expect(writes[0]).toContain('path=/');
-    expect(writes[0]).not.toContain('domain=');
-  });
-
-  it('falls back to a full host domain when parent domain write does not stick', () => {
-    const writes: string[] = [];
-
-    window.location.host = 'app.example.com';
-    window.location.hostname = 'app.example.com';
-    Object.defineProperty(document, 'cookie', {
-      get: () => '',
-      set: (value: string) => {
-        writes.push(value);
-      },
-      configurable: true,
-    });
-
-    setCookie('foo', 'bar');
-
-    expect(writes).toHaveLength(2);
-    expect(writes[0]).toContain('domain=.example.com');
-    expect(writes[1]).toContain('domain=.app.example.com');
-  });
-
-  it('does not write the fallback domain when parent domain write is readable', () => {
-    const writes: string[] = [];
-    let cookieValue = '';
-
-    window.location.host = 'app.example.com';
-    window.location.hostname = 'app.example.com';
-    Object.defineProperty(document, 'cookie', {
-      get: () => cookieValue,
-      set: (value: string) => {
-        writes.push(value);
-        cookieValue = 'foo=bar';
-      },
-      configurable: true,
-    });
-
-    setCookie('foo', 'bar');
-
-    expect(writes).toHaveLength(1);
-    expect(writes[0]).toContain('domain=.example.com');
-  });
-
-  it('does not throw when cookie write fails', () => {
-    window.location.host = 'app.example.com';
-    window.location.hostname = 'app.example.com';
-    Object.defineProperty(document, 'cookie', {
-      get: () => '',
-      set: () => {
-        throw new Error('blocked');
-      },
-      configurable: true,
-    });
-
-    expect(() => setCookie('foo', 'bar')).not.toThrow();
-  });
-});

package/src/storage/setCookie.ts

@@ -1,49 +0,0 @@
-import getCookie from './getCookie';
-
-export interface CookieOptionsI {
-  path?: string;
-  expires?: Date | string;
-  [key: string]: string | Date | boolean | undefined;
-}
-
-export default function setCookie(name: string, value: string | null, options: CookieOptionsI = {}): void {
-  const normalizedOptions: CookieOptionsI = {
-    path: '/',
-    expires: new Date(new Date().getFullYear() + 5, 0),
-    ...options,
-  };
-
-  if (normalizedOptions.expires instanceof Date) {
-    normalizedOptions.expires = normalizedOptions.expires.toUTCString();
-  }
-
-  let updatedCookie = encodeURIComponent(name) + '=' + encodeURIComponent(String(value));
-
-  for (const optionKey in normalizedOptions) {
-    updatedCookie += '; ' + optionKey;
-    const optionValue = normalizedOptions[optionKey];
-    if (optionValue !== true) {
-      updatedCookie += '=' + optionValue;
-    }
-  }
-
-  try {
-    const host = location.host ?? 'localhost';
-
-    if (host.split('.').length === 1) {
-      document.cookie = updatedCookie + '; path=/';
-      return;
-    }
-
-    const domainParts = host.split('.');
-    domainParts.shift();
-    let domain = '.' + domainParts.join('.');
-    document.cookie = updatedCookie + '; path=/; domain=' + domain;
-
-    if (getCookie(name) == null || getCookie(name) !== String(value)) {
-      domain = '.' + host;
-      document.cookie = updatedCookie + '; path=/; domain=' + domain;
-    }
-  } catch (e) {
-  }
-}

package/src/theme/theme.utils.ts

@@ -1,50 +0,0 @@
-import { ThemeI } from "../document/Document.interface";
-
-export const THEME_CSS_VAR_PREFIX = 'cl-schema-';
-
-export function toCssVarToken(token: string) {
-  return `${THEME_CSS_VAR_PREFIX}${token}`;
-}
-
-export function fromCssVarToSchemaToken(cssVar: string = '') {
-  return cssVar
-    .replace(/var\(\s*(--[^,\s)]+).*\)/, '$1')
-    .replace(`--${THEME_CSS_VAR_PREFIX}`, '');
-}
-
-export function extractRgbFromFallbackValue(value: string) {
-  const rgbMatch = String(value).match(/var\([^,]+,\s*(rgb(?:a)?\([^)]+\))\)/);
-  if (rgbMatch && rgbMatch[1]) {
-    return rgbMatch[1];
-  }
-  return null;
-}
-
-export function extractColor(value: string, theme?: ThemeI | null) {
-  const _value = String(value || '');
-  if (_value.startsWith('var(')) {
-    if (!theme) {
-      return null;
-    }
-
-    const token = fromCssVarToSchemaToken(_value);
-    const themeColor = theme.schema?.[token];
-
-    if (themeColor) {
-      return themeColor;
-    }
-
-    // Fallback to extract RGB from fallback value: var(--name, rgb(255, 0, 0))
-    return extractRgbFromFallbackValue(_value) || null;
-  }
-  
-  return _value;
-}
-
-export function createTheme(schema: Record<string, string> = {}): ThemeI {
-  return {
-    schema: {
-      ...schema,
-    }
-  }
-}

package/src/url/sanitizeUrl.test.ts

@@ -1,62 +0,0 @@
-import sanitizeUrl from './sanitizeUrl';
-
-describe('sanitizeUrl', () => {
-  it('should sanitize URLs correctly', () => {
-    // Safe URLs - должны проходить без изменений
-    expect(sanitizeUrl('http://example.com')).toBe('http://example.com');
-    expect(sanitizeUrl('https://example.com')).toBe('https://example.com');
-    expect(sanitizeUrl('mailto:user@example.com')).toBe('mailto:user@example.com');
-    expect(sanitizeUrl('tel:+1234567890')).toBe('tel:+1234567890');
-    expect(sanitizeUrl('sms:+1234567890')).toBe('sms:+1234567890');
-    expect(sanitizeUrl('whatsapp://send?text=Hello')).toBe('whatsapp://send?text=Hello');
-    expect(sanitizeUrl('tg://resolve?domain=username')).toBe('tg://resolve?domain=username');
-    expect(sanitizeUrl('fb://profile/123456')).toBe('fb://profile/123456');
-    expect(sanitizeUrl('twitter://user?screen_name=username')).toBe('twitter://user?screen_name=username');
-    expect(sanitizeUrl('instagram://user?username=test')).toBe('instagram://user?username=test');
-    expect(sanitizeUrl('myapp://action/123')).toBe('myapp://action/123');
-    expect(sanitizeUrl('customscheme://open/page')).toBe('customscheme://open/page');
-    expect(sanitizeUrl('app-name://deep/link/path')).toBe('app-name://deep/link/path');
-    expect(sanitizeUrl('spotify:track:123456')).toBe('spotify:track:123456');
-    expect(sanitizeUrl('maps://maps.google.com/maps?q=location')).toBe('maps://maps.google.com/maps?q=location');
-    expect(sanitizeUrl('comgooglemaps://maps?q=location')).toBe('comgooglemaps://maps?q=location');
-    expect(sanitizeUrl('zoommtg://zoom.us/join?confno=123456')).toBe('zoommtg://zoom.us/join?confno=123456');
-    expect(sanitizeUrl('zoom://meeting/123456')).toBe('zoom://meeting/123456');
-    expect(sanitizeUrl('slack://channel?team=T123&id=C456')).toBe('slack://channel?team=T123&id=C456');
-    expect(sanitizeUrl('msteams://teams.microsoft.com/l/chat')).toBe('msteams://teams.microsoft.com/l/chat');
-    expect(sanitizeUrl('itms-apps://itunes.apple.com/app/id123456')).toBe('itms-apps://itunes.apple.com/app/id123456');
-    expect(sanitizeUrl('market://details?id=com.example.app')).toBe('market://details?id=com.example.app');
-
-    // Опасные протоколы - должны блокироваться
-    expect(sanitizeUrl('javascript:alert("XSS")')).toBe('about:blank');
-    expect(sanitizeUrl('JavaScript:alert("XSS")')).toBe('about:blank');
-    expect(sanitizeUrl('jAvAsCrIpT:alert("XSS")')).toBe('about:blank');
-    expect(sanitizeUrl('data:text/html,<script>alert("XSS")</script>')).toBe('about:blank');
-    expect(sanitizeUrl('data:text/html;base64,PHNjcmlwdD5hbGVydCgiWFNTIik8L3NjcmlwdD4=')).toBe('about:blank');
-    expect(sanitizeUrl('vbscript:alert("XSS")')).toBe('about:blank');
-    expect(sanitizeUrl('chrome://settings')).toBe('about:blank');
-    expect(sanitizeUrl('chrome-extension://abc/page.html')).toBe('about:blank');
-    expect(sanitizeUrl('chrome-untrusted://abc')).toBe('about:blank');
-    expect(sanitizeUrl('about:config')).toBe('about:blank');
-    expect(sanitizeUrl('about:chrome')).toBe('about:blank');
-
-    // XSS паттерны - должны блокироваться
-    expect(sanitizeUrl('http://example.com/<script>alert("XSS")</script>')).toBe('about:blank');
-    expect(sanitizeUrl('http://example.com/<iframe src="evil.com"></iframe>')).toBe('about:blank');
-    expect(sanitizeUrl('http://example.com/<img onerror="alert(\'XSS\')">')).toBe('about:blank');
-    expect(sanitizeUrl('data:image/svg+xml,<svg onload=alert("XSS")>')).toBe('about:blank');
-    expect(sanitizeUrl('http://example.com/<embed src="evil.swf">')).toBe('about:blank');
-    expect(sanitizeUrl('http://example.com/<object data="evil">')).toBe('about:blank');
-    expect(sanitizeUrl('http://example.com/<applet code="Evil.class">')).toBe('about:blank');
-    expect(sanitizeUrl('http://example.com/<meta http-equiv="refresh">')).toBe('about:blank');
-    expect(sanitizeUrl('http://example.com/<link rel="import">')).toBe('about:blank');
-    expect(sanitizeUrl('http://example.com/<style>body{background:url("javascript:alert()")}</style>')).toBe('about:blank');
-
-    // Edge cases
-    expect(sanitizeUrl('')).toBe('about:blank');
-    expect(sanitizeUrl(null)).toBe('about:blank');
-    expect(sanitizeUrl(undefined)).toBe('about:blank');
-    expect(sanitizeUrl('about:blank')).toBe('about:blank');
-    expect(sanitizeUrl('  https://example.com  ')).toBe('https://example.com');
-    expect(sanitizeUrl('\t\nhttps://example.com\n\t')).toBe('https://example.com');
-  });
-});

package/src/url/sanitizeUrl.ts

@@ -1,51 +0,0 @@
-const DANGEROUS_PROTOCOLS: readonly string[] = [
-  'javascript:',
-  'data:',
-  'vbscript:',
-  'about:',
-  'chrome:',
-  'chrome-extension:',
-  'chrome-untrusted:',
-];
-
-const DANGEROUS_PATTERNS: readonly RegExp[] = [
-  /^data:[^,]*;base64,.*<script/i,
-  /^data:image\/svg\+xml[^,]*,.*<script/i,
-  /<script|<iframe|<embed|<object|<applet|<meta|<link|<style|<img.*on\w+=/i,
-];
-
-export default function sanitizeUrl(url: string | null | undefined): string {
-  if (!url) {
-    return 'about:blank';
-  }
-
-  const cleanUrl = String(url).trim();
-  
-  if (!cleanUrl) {
-    return 'about:blank';
-  }
-
-  if (cleanUrl === 'about:blank') {
-    return 'about:blank';
-  }
-
-  const lowerUrl = cleanUrl.toLowerCase();
-
-  const hasUnsafeProtocol = DANGEROUS_PROTOCOLS.some(protocol => 
-    lowerUrl.startsWith(protocol)
-  );
-  
-  if (hasUnsafeProtocol) {
-    return 'about:blank';
-  }
-
-  const hasUnsafePattern = DANGEROUS_PATTERNS.some(pattern => 
-    pattern.test(cleanUrl)
-  );
-  
-  if (hasUnsafePattern) {
-    return 'about:blank';
-  }
-
-  return cleanUrl;
-}

package/src/utils/CaseTransformer.test.ts

@@ -1,16 +0,0 @@
-import {CaseTransformer} from "./CaseTransformer";
-
-describe('CaseTransformer', () => {
-  it('should modify camelCase to the dash-case', () => {
-    expect(CaseTransformer.camelCaseToDashCase('someCamelCaseValue')).toEqual('some-camel-case-value');
-  });
-  it('should modify camelCase to the dash-case (case 2)', () => {
-    expect(CaseTransformer.camelCaseToDashCase('testABC')).toEqual('test-a-b-c');
-  });
-  it('should modify camelCase to the UPPER_SNAKE_CASE', () => {
-    expect(CaseTransformer.camelCaseToUpperSnakeCase('someCamelCaseValue')).toEqual('SOME_CAMEL_CASE_VALUE');
-  });
-  it('should modify camelCase to the UPPER_SNAKE_CASE (case 2)', () => {
-    expect(CaseTransformer.camelCaseToUpperSnakeCase('testABC')).toEqual('TEST_A_B_C');
-  });
-});

package/src/utils/CaseTransformer.ts

@@ -1,10 +0,0 @@
-export class CaseTransformer {
-
-  static camelCaseToDashCase(string: string): string {
-    return string.replace(/[A-Z]/g, match => "-" + match.toLowerCase());
-  }
-
-  static camelCaseToUpperSnakeCase(string: string): string {
-    return string.replace(/[A-Z]/g, match => "_" + match).toUpperCase();
-  }
-}

package/src/utils/NullishCoalescingOperator.ts

@@ -1,3 +0,0 @@
-export default function nullishCoalescingOperator<T>(a: T | null | undefined, b: T): T {
-  return (a !== null && a !== undefined) ? a : b;
-}

package/src/utils/NumericDecline.ts

@@ -1,25 +0,0 @@
-/**
- * Returns the correct grammatical form based on a numeric value.
- * Handles pluralization rules for different languages (English, Russian, etc.).
- * @param itemsCount - The number to determine the form for
- * @param translateKeys - Array of translation keys [singular, plural, genitive plural]
- * @param language - The language code (e.g., 'en', 'ru')
- * @returns The appropriate translation key for the given count
- * @example
- * getNumericDecline(1, ['item', 'items', 'items'], 'en');  // 'item'
- * getNumericDecline(5, ['item', 'items', 'items'], 'en');  // 'items'
- * getNumericDecline(21, ['товар', 'товара', 'товаров'], 'ru'); // 'товар'
- */
-export default function getNumericDecline(itemsCount: number, translateKeys: string[], language: string): string {
-  if (language === 'en' && itemsCount > 1) {
-    // for russian it's okay to use single item translation for 21, 31 and similar itemsCount
-    // but for english it doesn't fit
-    return translateKeys[1];
-  }
-
-  const number = Math.abs(itemsCount);
-
-  const cases = [2, 0, 1, 1, 1, 2];
-  return translateKeys[ (number % 100 > 4 &&
-    number % 100 < 20) ? 2 : cases[(number % 10 < 5) ? number % 10 : 5] ];
-}

package/src/utils/addEventListener.ts

@@ -1,23 +0,0 @@
-/**
- * Adds an event listener to an element, with fallback to base implementation.
- * Handles cases where addEventListener may have been overridden.
- * @param element - The target element to attach the listener to
- * @param eventType - The event type to listen for (e.g., 'click', 'load')
- * @param callback - The callback function or object to invoke
- * @param options - Optional listener options (capture, passive, etc.)
- * @example
- * addEventListenerToElement(button, 'click', () => console.log('clicked'));
- */
-const addEventListenerToElement = (
-  element: EventTarget,
-  eventType: string,
-  callback: EventListenerOrEventListenerObject,
-  options?: boolean | AddEventListenerOptions
-): void => {
-  const prototype = EventTarget.prototype as any;
-  const { addEventListenerBase, addEventListener } = prototype;
-
-  (addEventListenerBase || addEventListener).call(element, eventType, callback, options);
-};
-
-export default addEventListenerToElement;

package/src/utils/allSettled.ts

@@ -1,6 +0,0 @@
-export function allSettled<T>(promises: Promise<T>[] = []): Promise<PromiseSettledResult<T>[]> {
-  return Promise.all(promises.map(p => Promise.resolve(p).then(
-    value => ({status: 'fulfilled' as const, value}),
-    reason => ({status: 'rejected' as const, reason}),
-  )));
-}

package/src/utils/checkTimeZone.spec.ts

@@ -1,18 +0,0 @@
-import {checkTimeZone} from "./checkTimeZone";
-
-describe('checkTimeZone', () => {
-  test('should return Europe/Kiev when timeZone is Europe/Kyiv', () => {
-    const result = checkTimeZone('Europe/Kyiv');
-    expect(result).toBe('Europe/Kiev');
-  });
-
-  test('should return the same timeZone when it does not match Europe/Kyiv', () => {
-    const result = checkTimeZone('America/New_York');
-    expect(result).toBe('America/New_York');
-  });
-
-  test('should return undefined when timeZone is not provided', () => {
-    const result = checkTimeZone(undefined);
-    expect(result).toBeUndefined();
-  });
-});

package/src/utils/checkTimeZone.ts

@@ -1,6 +0,0 @@
-export function checkTimeZone(timeZone: string | undefined): string | undefined {
-  if (timeZone && timeZone === 'Europe/Kyiv') {
-    return 'Europe/Kiev';
-  }
-  return timeZone;
-}

package/src/utils/deviceUtils.ts

@@ -1,12 +0,0 @@
-export const isIPad = (): boolean => {
-  return /iPad/.test(navigator.userAgent) ||
-      (navigator.platform === 'MacIntel' && navigator['maxTouchPoints'] > 1);
-}
-
-export const isIPhone = (): boolean => {
-  return /iPhone/i.test(navigator.userAgent);
-}
-
-export const isIOS = (): boolean => {
-  return isIPhone() || isIPad();
-}

package/src/utils/flatMap.test.ts

@@ -1,21 +0,0 @@
-import flatMap from './flatMap';
-
-describe('flatMap', () => {
-  it('Should flatten an array of arrays', () => {
-    const input = [[1, 2], [3, 4], [5]];
-    const result = flatMap(input, x => x);
-    expect(result).toEqual([1, 2, 3, 4, 5]);
-  });
-
-  it('Should apply a function to each item and flatten the result', () => {
-    const input = [1, 2, 3];
-    const result = flatMap(input, x => [x, x * 2]);
-    expect(result).toEqual([1, 2, 2, 4, 3, 6]);
-  });
-
-  it('Should return an empty array when given an empty array', () => {
-    const input = [];
-    const result = flatMap(input, x => [x]);
-    expect(result).toEqual([]);
-  });
-});

package/src/utils/flatMap.ts

@@ -1,3 +0,0 @@
-export default function flatMap<T, U>(arr: T[], func: (item: T) => U[]): U[] {
-  return arr.reduce((acc: U[], item: T) => acc.concat(func(item)), []);
-}

package/src/utils/fromEntries.ts

@@ -1,6 +0,0 @@
-export function fromEntries<V>(iterable: Iterable<[string, V]>): Record<string, V> {
-    return [...iterable].reduce((obj: Record<string, V>, [key, val]) => {
-        obj[key] = val;
-        return obj;
-    }, {});
-}

package/src/utils/generateRandomNumber.test.ts

@@ -1,23 +0,0 @@
-import generateRandomNumber from "./generateRandomNumber";
-
-describe('generateRandomNumber', () => {
-  it('should calc', () => {
-
-    let vars = {};
-    let length = 1_000_000;
-
-    for (let i = 0; i < length; i++) {
-      let id = generateRandomNumber(1, 3);
-      if (!vars[id]) {
-        vars[id] = 1;
-      } else {
-        vars[id] += 1;
-      }
-
-    }
-    expect(Object.keys(vars).length).toBe(3);
-
-
-  });
-
-});

package/src/utils/generateRandomNumber.ts

@@ -1,3 +0,0 @@
-export default function generateRandomNumber(min: number, max: number): number {
-  return Math.floor(Math.random() * (max + 1- min)) + min;
-}

package/src/utils/objectSort.ts

@@ -1,41 +0,0 @@
-import {fromEntries} from "./fromEntries";
-
-export function comparisonFunction(a: Record<string, any>, b: Record<string, any>, property: string, descending: boolean = false): number {
-  let first = a[property];
-  let second = b[property];
-
-  if (isNaN(first) || isNaN(second)) {
-    if (typeof first !== 'string' || typeof second !== 'string') {
-      return 0;
-
-    } else {
-      first = first.toLowerCase();
-      second = second.toLowerCase();
-
-      if (descending) {
-        return second.localeCompare(first);
-
-      } else {
-        return first.localeCompare(second);
-      }
-    }
-  }
-
-  if (first < second) {
-    return descending ? 1 : -1;
-  }
-  if (first > second) {
-    return descending ? -1 : 1;
-  }
-
-  return 0;
-}
-
-export function sort(object: Record<string, Record<string, any>>, property: string, descending: boolean = false): Record<string, Record<string, any>> {
-  return fromEntries(
-    Object.entries(object)
-    .sort(([_ka, a], [_kb, b]) => {
-      return comparisonFunction(a, b, property, descending);
-    })
-  );
-}

package/src/utils/orientationUtils.ts

@@ -1,18 +0,0 @@
-export const detectOrientation = (): 'PORTRAIT' | 'LANDSCAPE' => {
-  const screen = window.screen as any;
-  const orientation =
-    screen.orientation ||
-    screen.mozOrientation ||
-    screen.msOrientation;
-
-  if (orientation) {
-    return orientation.type.includes('portrait') ? 'PORTRAIT' : 'LANDSCAPE';
-  } else if (typeof (window as any).orientation !== 'undefined') {
-    if ((window as any).orientation === 0 || (window as any).orientation === 180) {
-      return 'PORTRAIT';
-    } else if ((window as any).orientation === 90 || (window as any).orientation === -90) {
-      return 'LANDSCAPE';
-    }
-  }
-  return 'PORTRAIT';
-};

package/src/velocity/SysVelocityContext.spec.ts

@@ -1,88 +0,0 @@
-import SysVelocityContext from "./SysVelocityContext";
-
-describe('SysVelocityContext', function () {
-
-  const velocityContext = new SysVelocityContext();
-  const velocityObject = velocityContext.create();
-  const dateTool = velocityObject.dateTool;
-  const numberTool = velocityObject.numberTool;
-  const mathTool = velocityObject.mathTool;
-
-
-
-  it('should be able to add', function () {
-    expect(mathTool.add(2, 2)).toEqual(4);
-    expect(mathTool.add('2', 5)).toEqual(7);
-  });
-
-  it('should be able to subtract', function () {
-    expect(mathTool.sub(5, 2)).toEqual(3);
-    expect(mathTool.sub('15', '2')).toEqual(13);
-  });
-
-  it('should be able to multiply', function () {
-    expect(mathTool.mul(5, 2)).toEqual(10);
-    expect(mathTool.mul('15', '2')).toEqual(30);
-  });
-
-  it('should be able to divide', function () {
-    expect(mathTool.div(6, 2)).toEqual(3);
-    expect(mathTool.div('36', 3)).toEqual(12);
-  });
-
-  it('should be compare string ignore case', function () {
-    expect(velocityObject.stringTool.equalsIgnoreCase('HEllO!', 'Hello!')).toBeTruthy();
-  });
-
-  it('should be displays an integer without rounding', function () {
-    expect(numberTool.integer(25.36)).toEqual(25);
-    expect(numberTool.integer(36)).toEqual(36);
-    expect(numberTool.integer(3.0000000)).toEqual(3);
-    expect(numberTool.integer('56.045000000')).toEqual(56);
-  });
-
-  it('should be formatting number by mask', function () {
-    expect(numberTool.format('#.00', 56.026954)).toEqual('56.03');
-    expect(numberTool.format('#.00', 56)).toBe('56.00');
-    expect(numberTool.format('#.000', 56.026954)).toEqual('56.027');
-    expect(numberTool.format('#.000', '56.026954')).toEqual('56.027');
-    expect(numberTool.format('#.0', 56.026954)).toEqual('56.0');
-    expect(numberTool.format('#.', 56.026954)).toEqual('56');
-    expect(numberTool.format(null, 56.026954)).toEqual('56');
-  });
-
-  it('should be formatting number by ranks', function () {
-    expect(numberTool.number(589362153.0025)).toEqual('589,362,153.003');
-    expect(numberTool.number(589362153.00000000)).toEqual('589,362,153');
-    expect(numberTool.number(589362153.0025, ' ')).toEqual('589 362 153.003');
-    expect(numberTool.number(589362153.0025, ' ', 2)).toEqual('589 362 153');
-    expect(numberTool.number(589362153.025, ' ', 2)).toEqual('589 362 153.02');
-    expect(numberTool.number(589362153.026, ' ', 2)).toEqual('589 362 153.03');
-    expect(numberTool.number(589362153.026, ' ', 5)).toEqual('589 362 153.02600');
-  });
-
-  it('should be formatting current date as timestamp', function () {
-    const now = new Date();
-    expect(dateTool.formatDate('ISO', now)).toEqual(now.toISOString());
-  });
-
-  it('should be formatting current date as ISO string', function () {
-    const now = new Date();
-    expect(dateTool.formatDate(null, now)).toEqual(now.getTime());
-  });
-
-  it('should be formatting date by mask', function () {
-    const now = new Date(1495479520000);
-    const month = now.getMonth() + 1 > 9 ? now.getMonth() + 1 : `0${now.getMonth() + 1}`;
-    const day = now.getDate() > 9 ? now.getDate() : `0${now.getDate()}`;
-    const hours = now.getHours() > 9 ? now.getHours() : `0${now.getHours()}`;
-    const minutes = now.getMinutes() > 9 ? now.getMinutes() : `0${now.getMinutes()}`;
-    const seconds = now.getSeconds() > 9 ? now.getSeconds() : `0${now.getSeconds()}`;
-    expect(dateTool.formatDate('MM-DD', now)).toEqual(`${month}-${day}`);
-    expect(dateTool.formatDate('YYYY-MM-DD', now))
-      .toEqual(`${now.getFullYear()}-${month}-${day}`);
-    expect(dateTool.formatDate('YYYY-MM-DD HH:MM:SS', now))
-      .toEqual(`${now.getFullYear()}-${month}-${day} ${hours}:${minutes}:${seconds}`);
-  });
-
-});