@tma.js/sdk 1.3.0 → 1.4.0

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);
+  });
+});

package/src/popup/__tests__/Popup.ts

@@ -0,0 +1,130 @@
+import { describe, expect, it } from 'vitest';
+
+// import {emitDesktopEvent, mockDesktop} from '../../../tests';
+// import { Popup } from './Popup';
+// import {Bridge} from '@tma.js/bridge';
+// import {PopupParams} from './types';
+// import {preparePopupParams} from './utils';
+
+// beforeAll(mockDesktop);
+
+describe('components', () => {
+  describe('Popup', () => {
+    it('should be fine', () => {
+      expect(true).toBe(true);
+    });
+    // it('isOpened', () => {
+    //  it('should emit event "openChange" with specified value in setter', () => {
+    //     const popup = new Popup('7');
+    //     const spy = vi.spyOn((popup as any).ee, 'emit');
+    //     (popup as any).isOpened = true;
+    //     expect(spy).lastCalledWith('openChange', true);
+    //
+    //     (popup as any).isOpened = false;
+    //     expect(spy).lastCalledWith('openChange', false);
+    //   });
+    // });
+    //
+    // it('show', () => {
+    //  it('should throw an error in case, current version is less than 6.2', () => {
+    //     expect(() => new Popup('6.1').show({message: 'Hey!'})).toThrow();
+    //     expect(() => new Popup('6.2').show({message: 'Hey!'})).not.toThrow();
+    //   });
+    //
+    //  it('should call bridge event "web_app_open_popup" with prepared parameters', () => {
+    //     const bridge = new Bridge();
+    //     const spy = vi.spyOn(bridge, 'postEvent');
+    //     const popup = new Popup('7', {bridge});
+    //     const params: PopupParams = {message: 'Message'};
+    //     const prepared = preparePopupParams(params);
+    //     popup.show(params);
+    //     expect(spy).toHaveBeenCalledWith('web_app_open_popup', prepared);
+    //   });
+    //
+    //  it('should emit event "open" with prepared params', () => {
+    //     const popup = new Popup('7');
+    //     const spy = vi.spyOn((popup as any).ee, 'emit');
+    //     const params: PopupParams = {message: 'Message'};
+    //     const prepared = preparePopupParams(params);
+    //     popup.show(params);
+    //     expect(spy).toHaveBeenCalledWith('open', prepared);
+    //   });
+    //
+    //  it('should set "isOpened" property to true', () => {
+    //     const popup = new Popup('7');
+    //     expect(popup.isOpened).toBe(false);
+    //     popup.show({message: 'Message'});
+    //     expect(popup.isOpened).toBe(true);
+    //   });
+    //
+    //  it('should set "isOpened" property to false when promise is resolved', async () => {
+    //     const popup = new Popup('7');
+    //     const promise = popup.show({message: 'Message'});
+    //
+    //     emitDesktopEvent('popup_closed', {button_id: null});
+    //     await promise;
+    //     expect(popup.isOpened).toBe(false);
+    //   });
+    //
+    //  it('should set "isOpened" property to true', () => {
+    //     const popup = new Popup('7');
+    //     popup.show({message: 'Message'});
+    //     expect(popup.isOpened).toBe(true);
+    //   });
+    //
+    //  it('should emit close event with specified button_id when promise is resolved',
+    //   async () => {
+    //     const popup = new Popup('7');
+    //     const spy = vi.spyOn((popup as any).ee, 'emit');
+    //     const promise = popup.show({message: 'Message'});
+    //     emitDesktopEvent('popup_closed', {button_id: 'Hey!'});
+    //     await promise;
+    //     expect(spy).lastCalledWith('close', 'Hey!');
+    //   });
+    // });
+    //
+    // it('showAlert', () => {
+    //  it('should call "show" with passed message and buttons = [{type: "close"}]', () => {
+    //     const popup = new Popup('7');
+    //     const spy = vi.spyOn(popup, 'show');
+    //
+    //     popup.showAlert('Message');
+    //
+    //     expect(spy).toHaveBeenCalledWith({
+    //       message: 'Message',
+    //       buttons: [{type: 'close'}],
+    //     });
+    //   });
+    // });
+    //
+    // it('showConfirm', () => {
+    //  test(
+    //     'should call "show" with passed message and ' +
+    //     'buttons = [{type: "ok", id: "ok"}, {id: "cancel", type: "cancel"}]',
+    //     () => {
+    //       const popup = new Popup('7');
+    //       const spy = vi.spyOn(popup, 'show');
+    //
+    //       popup.showConfirm('Message');
+    //
+    //       expect(spy).toHaveBeenCalledWith({
+    //         message: 'Message',
+    //         buttons: [{type: 'ok', id: 'ok'}, {id: 'cancel', type: 'cancel'}],
+    //       });
+    //     },
+    //   );
+    //
+    //  it('should resolve true in case, user pressed button with id "ok"', async () => {
+    //     const promise = new Popup('7').showConfirm('Message');
+    //     emitDesktopEvent('popup_closed', {button_id: 'ok'});
+    //     expect(await promise).toBe(true);
+    //   });
+    //
+    //  it('should resolve false in case, user pressed any other button', async () => {
+    //     const promise = new Popup('7').showConfirm('Message');
+    //     emitDesktopEvent('popup_closed', {button_id: 'cancel'});
+    //     await expect(promise).resolves.toBe(false);
+    //   });
+    // });
+  });
+});

package/src/popup/__tests__/preparePopupParams.ts

@@ -0,0 +1,85 @@
+import { expect, it } from 'vitest';
+
+import { preparePopupParams } from '../preparePopupParams';
+
+/**
+ * Creates test text.
+ * @param length - text length.
+ */
+function createText(length: number): string {
+  return new Array(length).fill('a').join('');
+}
+
+it('should throw an error in case, title length is more than 64 symbols', () => {
+  expect(() => preparePopupParams({
+    title: createText(65),
+    message: 'Hey!',
+  })).toThrow(/^Title has incorrect size/);
+
+  expect(() => preparePopupParams({
+    title: createText(64),
+    message: 'Hey!',
+  })).not.toThrow();
+});
+
+it('should throw an error in case, message length is zero or more than 256 symbols', () => {
+  expect(() => preparePopupParams({
+    message: '',
+  })).toThrow(/^Message has incorrect size/);
+
+  expect(() => preparePopupParams({
+    message: createText(257),
+  })).toThrow(/^Message has incorrect size/);
+
+  expect(() => preparePopupParams({
+    message: createText(256),
+  })).not.toThrow();
+});
+
+it('should throw an error in case, buttons count is more than 3', () => {
+  expect(() => preparePopupParams({
+    message: 'a',
+    buttons: new Array(4).fill({ type: 'close' }),
+  })).toThrow(/^Buttons have incorrect size/);
+
+  expect(() => preparePopupParams({
+    message: 'a',
+    buttons: new Array(3).fill({ type: 'close' }),
+  })).not.toThrow();
+});
+
+it('should append button type "close" in case, buttons array is empty', () => {
+  expect(preparePopupParams({ message: 'a' }).buttons).toStrictEqual([{
+    type: 'close',
+    id: '',
+  }]);
+});
+
+it('should throw an error in case, some button text length size is zero or more than 64 symbols', () => {
+  expect(() => preparePopupParams({
+    message: 'A',
+    buttons: [{ type: 'default', text: createText(65) }],
+  })).toThrowError(/^Button text with type/);
+
+  expect(() => preparePopupParams({
+    message: 'A',
+    buttons: [{ type: 'default', text: '' }],
+  })).toThrowError(/^Button text with type/);
+
+  expect(() => preparePopupParams({
+    message: 'A',
+    buttons: [{ type: 'default', text: createText(64) }],
+  })).not.toThrow();
+});
+
+it('should fulfill all optional popup parameters', () => {
+  expect(preparePopupParams({
+    message: 'Message',
+    buttons: [{ type: 'default', text: 'Wow!' }, { type: 'close' }],
+  }))
+    .toStrictEqual({
+      title: '',
+      message: 'Message',
+      buttons: [{ id: '', type: 'default', text: 'Wow!' }, { type: 'close', id: '' }],
+    });
+});