@tma.js/sdk 1.4.4 → 1.4.6

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

@@ -1,39 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,105 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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/parsing/parsers/array.ts

@@ -1,9 +0,0 @@
-import { ArrayValueParser } from '../ArrayValueParser.js';
-
-/**
- * Parses incoming value as an array.
- * @param type - parser type name.
- */
-export function array(type?: string): ArrayValueParser<unknown, false> {
-  return new ArrayValueParser((value) => value, false, type);
-}

package/src/parsing/parsers/boolean.ts

@@ -1,22 +0,0 @@
-import { createValueParserGenerator } from '../createValueParserGenerator.js';
-import { unexpectedTypeError } from '../unexpectedTypeError.js';
-
-/**
- * Returns parser to parse value as boolean.
- */
-export const boolean = createValueParserGenerator<boolean>((value) => {
-  if (typeof value === 'boolean') {
-    return value;
-  }
-  const asString = String(value);
-
-  if (asString === '1' || asString === 'true') {
-    return true;
-  }
-
-  if (asString === '0' || asString === 'false') {
-    return false;
-  }
-
-  throw unexpectedTypeError();
-}, 'boolean');

package/src/parsing/parsers/date.ts

@@ -1,11 +0,0 @@
-import { number } from './number.js';
-import { createValueParserGenerator } from '../createValueParserGenerator.js';
-
-/**
- * Returns parser to parse value as Date.
- */
-export const date = createValueParserGenerator<Date>((value) => (
-  value instanceof Date
-    ? value
-    : new Date(number().parse(value) * 1000)
-), 'Date');

package/src/parsing/parsers/index.ts

@@ -1,8 +0,0 @@
-export * from './array.js';
-export * from './boolean.js';
-export * from './date.js';
-export * from './json.js';
-export * from './number.js';
-export * from './rgb.js';
-export * from './searchParams.js';
-export * from './string.js';

package/src/parsing/parsers/json.ts

@@ -1,17 +0,0 @@
-import { parseBySchema } from '../parseBySchema.js';
-import { toRecord } from '../toRecord.js';
-import type { Schema } from '../types.js';
-import { ValueParser } from '../ValueParser.js';
-
-/**
- * Creates new Json parser according to passed schema.
- * @param schema - object schema.
- * @param type - parser type name.
- */
-export function json<T>(schema: Schema<T>, type?: string): ValueParser<T, false> {
-  return new ValueParser((value) => {
-    const record = toRecord(value);
-
-    return parseBySchema(schema, (field) => record[field]);
-  }, false, type);
-}

package/src/parsing/parsers/number.ts

@@ -1,21 +0,0 @@
-import { createValueParserGenerator } from '../createValueParserGenerator.js';
-import { unexpectedTypeError } from '../unexpectedTypeError.js';
-
-/**
- * Returns parser to parse value as number.
- */
-export const number = createValueParserGenerator<number>((value) => {
-  if (typeof value === 'number') {
-    return value;
-  }
-
-  if (typeof value === 'string') {
-    const num = Number(value);
-
-    if (!Number.isNaN(num)) {
-      return num;
-    }
-  }
-
-  throw unexpectedTypeError();
-}, 'number');

package/src/parsing/parsers/rgb.ts

@@ -1,10 +0,0 @@
-import { toRGB } from '~/colors/index.js';
-import type { RGB } from '~/colors/index.js';
-
-import { string } from './string.js';
-import { createValueParserGenerator } from '../createValueParserGenerator.js';
-
-/**
- * Returns parser to parse value as RGB color.
- */
-export const rgb = createValueParserGenerator<RGB>((value) => toRGB(string().parse(value)), 'rgb');

package/src/parsing/parsers/searchParams.ts

@@ -1,24 +0,0 @@
-import { parseBySchema } from '../parseBySchema.js';
-import type { Schema } from '../types.js';
-import { unexpectedTypeError } from '../unexpectedTypeError.js';
-import { ValueParser } from '../ValueParser.js';
-
-/**
- * Creates new search params parser according to passed schema.
- * @param schema - object schema.
- * @param type - parser type name.
- */
-export function searchParams<T>(schema: Schema<T>, type?: string): ValueParser<T, false> {
-  return new ValueParser((value) => {
-    if (typeof value !== 'string' && !(value instanceof URLSearchParams)) {
-      throw unexpectedTypeError();
-    }
-
-    const params = typeof value === 'string' ? new URLSearchParams(value) : value;
-
-    return parseBySchema(schema, (field) => {
-      const paramValue = params.get(field);
-      return paramValue === null ? undefined : paramValue;
-    });
-  }, false, type);
-}

package/src/parsing/parsers/string.ts

@@ -1,12 +0,0 @@
-import { createValueParserGenerator } from '../createValueParserGenerator.js';
-import { unexpectedTypeError } from '../unexpectedTypeError.js';
-
-/**
- * Returns parser to parse value as string.
- */
-export const string = createValueParserGenerator<string>((value) => {
-  if (typeof value === 'string' || typeof value === 'number') {
-    return value.toString();
-  }
-  throw unexpectedTypeError();
-}, 'string');

package/src/parsing/toRecord.ts

@@ -1,27 +0,0 @@
-import { unexpectedTypeError } from './unexpectedTypeError.js';
-
-/**
- * Converts value to record.
- * @param value - value to convert.
- * @throws {Error} Value passed as a string does not represent JSON object.
- * @throws {Error} Value is not convertable.
- */
-export function toRecord(value: unknown): Record<string, unknown> {
-  let formattedValue: any = value;
-
-  // Convert value to JSON in case, it is string. We expect value to be JSON string.
-  if (typeof formattedValue === 'string') {
-    formattedValue = JSON.parse(formattedValue);
-  }
-
-  // We expect json to be usual object.
-  if (
-    typeof formattedValue !== 'object'
-    || formattedValue === null
-    || Array.isArray(formattedValue)
-  ) {
-    throw unexpectedTypeError();
-  }
-
-  return formattedValue;
-}

package/src/parsing/types.ts

@@ -1,32 +0,0 @@
-/**
- * Represents any known parser.
- */
-export type AnyParser<T> = Parser<T> | { parse: Parser<T> };
-
-/**
- * Detailed schema field options.
- */
-export interface SchemaFieldDetailed<T> {
-  /**
-   * Source property name.
-   * @default Original property name in schema.
-   */
-  from?: string;
-
-  /**
-   * Function which should parse incoming value and return expected type.
-   */
-  type: AnyParser<T>;
-}
-
-/**
- * Function which parses incoming value.
- */
-export type Parser<T> = (value: unknown) => T;
-
-/**
- * Object schema definition.
- */
-export type Schema<T> = {
-  [K in keyof T]: AnyParser<T[K]> | SchemaFieldDetailed<T[K]>;
-};

package/src/parsing/unexpectedTypeError.ts

@@ -1,6 +0,0 @@
-/**
- * Creates instance of TypeError stating, that value has unexpected type.
- */
-export function unexpectedTypeError(): TypeError {
-  return new TypeError('Value has unexpected type');
-}

package/src/popup/Popup.ts

@@ -1,91 +0,0 @@
-import {
-  type PostEvent,
-  postEvent as defaultPostEvent,
-  request,
-} from '~/bridge/index.js';
-import { EventEmitter } from '~/event-emitter/index.js';
-import { State } from '~/state/index.js';
-import {
-  createSupportsFunc,
-  type SupportsFunc,
-} from '~/supports/index.js';
-import type { Version } from '~/version/index.js';
-
-import { preparePopupParams } from './preparePopupParams.js';
-import type { OpenPopupOptions, PopupEvents, PopupState } from './types.js';
-
-/**
- * Controls currently displayed application popup. It allows developers to
- * open new custom popups and detect popup-connected events.
- */
-export class Popup {
-  private readonly ee = new EventEmitter<PopupEvents>();
-
-  private readonly state: State<PopupState>;
-
-  constructor(
-    version: Version,
-    private readonly postEvent: PostEvent = defaultPostEvent,
-  ) {
-    this.state = new State({ isOpened: false }, this.ee);
-    this.supports = createSupportsFunc(version, { open: 'web_app_open_popup' });
-  }
-
-  private set isOpened(value) {
-    this.state.set('isOpened', value);
-  }
-
-  /**
-   * True if popup is currently opened.
-   */
-  get isOpened(): boolean {
-    return this.state.get('isOpened');
-  }
-
-  /**
-   * Adds new event listener.
-   */
-  on = this.ee.on.bind(this.ee);
-
-  /**
-   * Removes event listener.
-   */
-  off = this.ee.off.bind(this.ee);
-
-  /**
-   * A method that shows a native popup described by the `params` argument.
-   * Promise will be resolved when popup is closed. Resolved value will have
-   * an identifier of pressed button.
-   *
-   * In case, user clicked outside the popup or clicked top right popup close
-   * button, null will be returned.
-   *
-   * FIXME: In desktop, this function may work incorrectly.
-   *  Issue: https://github.com/Telegram-Mini-Apps/tma.js/issues/7
-   * @param options - popup parameters.
-   * @throws {Error} Popup is already opened.
-   */
-  open(options: OpenPopupOptions): Promise<string | null> {
-    if (this.isOpened) {
-      throw new Error('Popup is already opened.');
-    }
-
-    this.isOpened = true;
-
-    return request(
-      'web_app_open_popup',
-      preparePopupParams(options),
-      'popup_closed',
-      { postEvent: this.postEvent },
-    )
-      .then(({ button_id = null }) => button_id)
-      .finally(() => {
-        this.isOpened = false;
-      });
-  }
-
-  /**
-   * Checks if specified method is supported by current component.
-   */
-  supports: SupportsFunc<'open'>;
-}