@tma.js/sdk 1.2.1 → 1.4.0

package/src/misc/__tests__/isRecord.ts

@@ -0,0 +1,21 @@
+import { expect, it } from 'vitest';
+
+import { isRecord } from '../isRecord';
+
+it('should return false for non-object value', () => {
+  [true, 123, 'abc'].forEach((v) => {
+    expect(isRecord(v)).toBe(false);
+  });
+});
+
+it('should return false for null value', () => {
+  expect(isRecord(null)).toBe(false);
+});
+
+it('should return false for array', () => {
+  expect(isRecord([])).toBe(false);
+});
+
+it('should return true for object', () => {
+  expect(isRecord({ a: true })).toBe(true);
+});

package/src/navigation/HashNavigator/__tests__/HashNavigator.ts

@@ -0,0 +1,144 @@
+import { describe, expect, it } from 'vitest';
+
+import { HashNavigator } from '../HashNavigator';
+
+// TODO: Add more tests.
+
+describe('constructor', () => {
+  it('should throw an error if entries list is empty', () => {
+    expect(() => new HashNavigator([], 0)).toThrow('Entries list should not be empty.');
+  });
+
+  it('should throw an error if cursor equals to higher than entries count', () => {
+    expect(() => new HashNavigator([{ pathname: '/' }], 1))
+      .toThrow('Cursor should be less than entries count.');
+    expect(() => new HashNavigator([{ pathname: '/' }], 2))
+      .toThrow('Cursor should be less than entries count.');
+  });
+});
+
+describe('methods', () => {
+  // describe('go', () => {
+  // });
+  //
+  // describe('forward', () => {
+  // });
+  //
+  // describe('back', () => {
+  // });
+
+  describe('getEntries', () => {
+    it('should return deep clone of navigator entries', () => {
+      const initialEntries = [{
+        search: '?b',
+        hash: '#c',
+        pathname: '/a',
+      }];
+      const navigator = new HashNavigator(initialEntries, 0);
+      const entries = navigator.getEntries();
+
+      expect(entries).toStrictEqual(initialEntries);
+      expect(entries).not.toBe(initialEntries);
+
+      expect(entries[0]).toStrictEqual(initialEntries[0]);
+      expect(entries[0]).not.toBe(initialEntries[0]);
+    });
+  });
+
+  // describe('push', () => {
+  // });
+  //
+  describe('replace', () => {
+    it('should replace current entry', () => {
+      const navigator = new HashNavigator([{
+        search: '?b',
+        hash: '#c',
+        pathname: '/a',
+      }], 0);
+      const [prevEntry] = navigator.getEntries();
+
+      expect(navigator.cursor).toBe(0);
+      navigator.replace('/b');
+      const [entry] = navigator.getEntries();
+
+      expect(prevEntry).not.toStrictEqual(entry);
+      expect(navigator.cursor).toBe(0);
+    });
+  });
+});
+
+describe('getters', () => {
+  describe('pathname', () => {
+    it('should return current entry pathname', () => {
+      expect(new HashNavigator([{ pathname: '/abc' }], 0).pathname).toBe('/abc');
+    });
+  });
+
+  describe('search', () => {
+    it('should return current entry search', () => {
+      expect(
+        new HashNavigator([{
+          search: '?a=1',
+          pathname: '/',
+        }], 0).search,
+      ).toBe('?a=1');
+    });
+  });
+
+  describe('hash', () => {
+    it('should return current entry hash', () => {
+      expect(
+        new HashNavigator([{
+          hash: '#abc',
+          pathname: '/',
+        }], 0).hash,
+      ).toBe('#abc');
+    });
+  });
+
+  describe('path', () => {
+    it('should combine current entry pathname, search and hash', () => {
+      expect(
+        new HashNavigator([{
+          search: '?b',
+          hash: '#c',
+          pathname: '/a',
+        }], 0).path,
+      ).toBe('/a?b#c');
+    });
+  });
+
+  describe('canGoBack', () => {
+    it('should return false if cursor === 0', () => {
+      expect(
+        new HashNavigator([{ pathname: '/' }], 0).canGoBack,
+      ).toBe(false);
+    });
+
+    it('should return true if cursor > 0', () => {
+      expect(
+        new HashNavigator([
+          { pathname: '/a' },
+          { pathname: '/b' },
+        ], 1).canGoBack,
+      ).toBe(true);
+    });
+  });
+
+  describe('canGoForward', () => {
+    it('should return false if cursor === entries.length - 1', () => {
+      expect(
+        new HashNavigator([{ pathname: '/' }], 0).canGoForward,
+      ).toBe(false);
+    });
+
+    it('should return true if cursor < entries.length - 1', () => {
+      expect(
+        new HashNavigator([
+          { pathname: '/a' },
+          { pathname: '/b' },
+        ], 0).canGoForward,
+      ).toBe(true);
+    });
+  });
+});

package/src/navigation/HashNavigator/__tests__/drop.ts

@@ -0,0 +1,42 @@
+import { afterEach, expect, it, vi } from 'vitest';
+
+import { drop } from '../drop';
+
+// TODO: Add more tests.
+
+function mockHistoryLength(length: number) {
+  vi
+    .spyOn(window.history, 'length', 'get')
+    .mockImplementation(() => length);
+}
+
+function mockPushState(impl?: History['pushState']) {
+  const spy = vi.spyOn(window.history, 'pushState');
+
+  if (impl) {
+    spy.mockImplementation(impl);
+  }
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+it('should do nothing in case, history contains only 1 element', () => {
+  const pushStateSpy = vi.fn();
+  mockHistoryLength(1);
+  mockPushState(pushStateSpy);
+
+  expect(pushStateSpy).not.toHaveBeenCalled();
+});
+
+it('should push empty state', () => {
+  const pushStateSpy = vi.fn();
+  mockHistoryLength(2);
+  mockPushState(pushStateSpy);
+
+  drop();
+
+  expect(pushStateSpy).toHaveBeenCalledOnce();
+  expect(pushStateSpy).toHaveBeenCalledWith(null, '');
+});

package/src/navigation/HashNavigator/__tests__/go.ts

@@ -0,0 +1,9 @@
+import { expect, it } from 'vitest';
+
+import { go } from '../go';
+
+// TODO: Add more tests.
+
+it('should return true if delta is 0', () => {
+  expect(go(0)).resolves.toBe(true);
+});

package/src/parsing/__tests__/ArrayValueParser.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from 'vitest';
+
+import { ArrayValueParser } from '../ArrayValueParser';
+import { string } from '../parsers';
+
+describe('constructor', () => {
+  it('should apply parser value directly if it is function', () => {
+    const parser = new ArrayValueParser(() => 'Hello!', false);
+
+    expect(parser.parse(['abc'])).toStrictEqual(['Hello!']);
+  });
+
+  it('should apply parser "parse" method directly if it is ValueParser', () => {
+    const parser = new ArrayValueParser(string(), false);
+
+    expect(parser.parse(['abc'])).toStrictEqual(['abc']);
+  });
+});

package/src/parsing/__tests__/toRecord.ts

@@ -0,0 +1,10 @@
+import { expect, it } from 'vitest';
+
+import { toRecord } from '../index';
+
+it('should throw an error in case, passed value is not JSON object or not JSON object converted to string', () => {
+  expect(() => toRecord('')).toThrow();
+  expect(() => toRecord(true)).toThrow();
+  expect(() => toRecord('{}')).not.toThrow();
+  expect(() => toRecord({})).not.toThrow();
+});

package/src/parsing/parsers/__tests__/array.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest';
+
+import { array } from '../array';
+import { string } from '../string';
+
+it('should return value in case, it is array', () => {
+  expect(array().parse(['abc'])).toStrictEqual(['abc']);
+});
+
+it('should correctly parse JSON Array presented as string', () => {
+  expect(array().parse('["abc"]')).toStrictEqual(['abc']);
+});
+
+it('should throw an error in case, passed value is not array', () => {
+  expect(() => array().parse(true)).toThrow();
+  expect(() => array().parse(1)).toThrow();
+  expect(() => array().parse('okay')).toThrow();
+  expect(() => array().parse({})).toThrow();
+});
+
+describe('of', () => {
+  it('should correctly apply item parser to each array item', () => {
+    expect(array().of(string()).parse(['abc'])).toStrictEqual(['abc']);
+  });
+
+  it('should throw an error in case, item parser was unable to parse value', () => {
+    expect(() => array().of(string()).parse(['abc', {}])).toThrow();
+  });
+
+  it('should use parsing function directly if it is not ValueParser', () => {
+    expect(array().of(() => 'Hello!').parse(['abc'])).toStrictEqual(['Hello!']);
+  });
+});
+
+describe('optional', () => {
+  it('should return undefined if value is undefined', () => {
+    expect(array().optional().parse(undefined)).toBe(undefined);
+  });
+});

package/src/parsing/parsers/__tests__/boolean.ts

@@ -0,0 +1,31 @@
+import { describe, expect, it } from 'vitest';
+
+import { boolean } from '../boolean';
+
+it('should return value in case, it has type boolean', () => {
+  expect(boolean().parse(true)).toBe(true);
+  expect(boolean().parse(false)).toBe(false);
+});
+
+it('should return true in case, value string representation equals "1" or "true"', () => {
+  expect(boolean().parse(1)).toBe(true);
+  expect(boolean().parse('1')).toBe(true);
+  expect(boolean().parse('true')).toBe(true);
+});
+
+it('should return false in case, value string representation equals "0" or "false"', () => {
+  expect(boolean().parse(0)).toBe(false);
+  expect(boolean().parse('0')).toBe(false);
+  expect(boolean().parse('false')).toBe(false);
+});
+
+it('should throw an error in case, passed value is not of type boolean and its string representation is not "0", "1", "true" or "false"', () => {
+  expect(() => boolean().parse('true!')).toThrow();
+  expect(() => boolean().parse({})).toThrow();
+});
+
+describe('optional', () => {
+  it('should return undefined if value is undefined', () => {
+    expect(boolean().optional().parse(undefined)).toBe(undefined);
+  });
+});

package/src/parsing/parsers/__tests__/date.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+
+import { date } from '../date';
+
+it('should return value in case, it is instance of Date', () => {
+  const d = new Date();
+  expect(date().parse(d)).toBe(d);
+});
+
+it('should throw an error in case, passed value cannot be converted to number', () => {
+  expect(() => date().parse('true')).toThrow();
+  expect(() => date().parse({})).toThrow();
+});
+
+it('should create date multiplying value by 1000 in case this value can be converted to number', () => {
+  const a = new Date(1000);
+  expect(date().parse('1')).toStrictEqual(a);
+  expect(date().parse(1)).toStrictEqual(a);
+});
+
+describe('optional', () => {
+  it('should return undefined if value is undefined', () => {
+    expect(date().optional().parse(undefined)).toBe(undefined);
+  });
+});

package/src/parsing/parsers/__tests__/json.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest';
+
+import { boolean } from '../boolean';
+import { json } from '../json';
+import { number } from '../number';
+import { string } from '../string';
+
+it('should throw an error in case, passed value is not JSON object or not JSON object converted to string', () => {
+  const parser = json({});
+  expect(() => parser.parse('')).toThrow();
+  expect(() => parser.parse(true)).toThrow();
+  expect(() => parser.parse('{}')).not.toThrow();
+  expect(() => parser.parse({})).not.toThrow();
+});
+
+it('should throw an error in case, passed value does not contain required field presented in schema', () => {
+  const parser = json({ prop: string() });
+  expect(() => parser.parse({})).toThrow();
+});
+
+it('should ignore field in case its value is undefined', () => {
+  const parser = json<{ prop?: string }>({ prop: undefined });
+  expect(parser.parse({})).toStrictEqual({});
+});
+
+describe('field definition as object', () => {
+  it('should extract field value from the specified property "from"', () => {
+    const parser = json({
+      a: {
+        type: (value) => value,
+        from: 'b',
+      },
+    });
+    expect(parser.parse({ b: 'Hello there!' })).toStrictEqual({ a: 'Hello there!' });
+  });
+
+  it('should extract field value from schema field name, if "from" was not specified', () => {
+    const parser = json({
+      a: {
+        type: (value) => value,
+      },
+    });
+    expect(parser.parse({ a: 'Hello there!' })).toStrictEqual({ a: 'Hello there!' });
+  });
+
+  it('should apply parser passed as ValueParser', () => {
+    const parser = json({
+      a: {
+        type: string(),
+      },
+    });
+    expect(parser.parse({ a: 'Hello there!' })).toStrictEqual({ a: 'Hello there!' });
+  });
+});
+
+it('should also apply parser presented as function', () => {
+  const parser = json({
+    prop: () => 'static value',
+  });
+  expect(parser.parse({ prop: 999 })).toStrictEqual({ prop: 'static value' });
+});
+
+it('should throw an error in case, passed value contains field of different type presented in schema', () => {
+  const parser = json({ prop: string() });
+  expect(() => parser.parse({ prop: {} })).toThrow();
+});
+
+it('should correctly parse built-in types', () => {
+  const parser = json({
+    bool: boolean(),
+    string: string(),
+    number: number(),
+  });
+  const obj = {
+    bool: true,
+    string: '123',
+    number: 999,
+  };
+  expect(parser.parse(obj)).toStrictEqual(obj);
+});

package/src/parsing/parsers/__tests__/number.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+
+import { number } from '../number';
+
+it('should return value in case, it has type number', () => {
+  expect(number().parse(9992)).toBe(9992);
+});
+
+it('should return value converted to number in case, it is number converted to string', () => {
+  expect(number().parse('9992')).toBe(9992);
+});
+
+it('should throw an error in case, passed value is not of type number or does not represent number converted to string', () => {
+  expect(() => number().parse(true)).toThrow();
+  expect(() => number().parse('vvv')).toThrow();
+  expect(() => number().parse({})).toThrow();
+});
+
+describe('optional', () => {
+  it('should return undefined if value is undefined', () => {
+    expect(number().optional().parse(undefined)).toBe(undefined);
+  });
+});

package/src/parsing/parsers/__tests__/rgb.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+
+import { rgb } from '../rgb';
+
+it('should return value in case, it represents RGB color', () => {
+  expect(rgb().parse('#fff')).toBe('#ffffff');
+});
+
+it('should throw an error in case, passed value is not of type string', () => {
+  expect(() => rgb().parse(true)).toThrow();
+  expect(() => rgb().parse({})).toThrow();
+});
+
+it('should throw an error in case, passed value does not represent RGB string', () => {
+  expect(() => rgb().parse('my custom string')).toThrow();
+});
+
+describe('optional', () => {
+  it('should return undefined if value is undefined', () => {
+    expect(rgb().optional().parse(undefined)).toBe(undefined);
+  });
+});

package/src/parsing/parsers/__tests__/searchParams.ts

@@ -0,0 +1,105 @@
+import { expect, it } from 'vitest';
+
+import { date } from '../date';
+import { searchParams } from '../searchParams';
+import { string } from '../string';
+
+it('should throw an error in case, passed value is not of type string or URLSearchParams', () => {
+  const parser = searchParams({});
+  expect(() => parser.parse(true)).toThrow();
+  expect(() => parser.parse({})).toThrow();
+  expect(() => parser.parse('true')).not.toThrow();
+  expect(() => parser.parse(new URLSearchParams())).not.toThrow();
+});
+
+it('should throw an error in case, passed value does not contain required field presented in schema', () => {
+  const parser = searchParams({ prop: string() });
+
+  try {
+    parser.parse('abc=123');
+  } catch (e) {
+    expect(e).toMatchObject({
+      message: 'Unable to parse value',
+      cause: {
+        message: 'Unable to parse field "prop" as string',
+        cause: {
+          message: 'Unable to parse value as string',
+          cause: {
+            message: 'Value has unexpected type',
+          },
+        },
+      },
+    });
+  }
+  expect.assertions(1);
+});
+
+it('should not throw an error in case, passed value does not contain optional field presented in schema', () => {
+  const parser = searchParams<{ prop?: string }>({
+    prop: string().optional(),
+  });
+  expect(parser.parse('')).toEqual({});
+  expect(parser.parse('prop=abc')).toEqual({ prop: 'abc' });
+});
+
+it('should use parser with unspecified type', () => {
+  const parser = searchParams<{ prop: unknown }>({
+    prop: () => {
+      throw new Error('Just an error');
+    },
+  });
+
+  try {
+    parser.parse('prop=');
+  } catch (e) {
+    expect(e).toMatchObject({
+      message: 'Unable to parse value',
+      cause: {
+        message: 'Unable to parse field "prop"',
+        cause: {
+          message: 'Just an error',
+        },
+      },
+    });
+  }
+  expect.assertions(1);
+});
+
+it('should throw an error in case, passed value contains field of different type presented in schema', () => {
+  const parser = searchParams({ prop: date() });
+
+  try {
+    parser.parse('prop=abc');
+  } catch (e) {
+    expect(e).toMatchObject({
+      message: 'Unable to parse value',
+      cause: {
+        message: 'Unable to parse field "prop" as Date',
+        cause: {
+          message: 'Unable to parse value as Date',
+          cause: {
+            message: 'Unable to parse value as number',
+            cause: {
+              message: 'Value has unexpected type',
+            },
+          },
+        },
+      },
+    });
+  }
+  expect.assertions(1);
+});
+
+it('should correctly parse built-in types', () => {
+  const parser = searchParams({
+    date: date(),
+    string: string(),
+  });
+  const params = new URLSearchParams();
+  params.set('date', '66653332');
+  params.set('string', 'some string');
+  expect(parser.parse(params)).toEqual({
+    date: new Date(66653332000),
+    string: 'some string',
+  });
+});

package/src/parsing/parsers/__tests__/string.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it } from 'vitest';
+
+import { string } from '../string';
+
+it('should return value in case, it has type string', () => {
+  expect(string().parse('abc')).toBe('abc');
+});
+
+it('should convert value to string in case, it has type number', () => {
+  expect(string().parse(1)).toBe('1');
+});
+
+it('should throw an error in case, passed value is not string or number', () => {
+  expect(() => string().parse({})).toThrow();
+  expect(() => string().parse([])).toThrow();
+  expect(() => string().parse(false)).toThrow();
+  expect(() => string().parse(null)).toThrow();
+  expect(() => string().parse(undefined)).toThrow();
+});
+
+describe('optional', () => {
+  it('should return undefined if value is undefined', () => {
+    expect(string().optional().parse(undefined)).toBe(undefined);
+  });
+});