@tma.js/sdk 1.4.4 → 1.4.6

package/src/navigation/Navigator/Navigator.ts

@@ -1,282 +0,0 @@
-import { Logger } from '~/logger/index.js';
-
-import type {
-  AnyEntry,
-  NavigationEntry,
-  NavigatorConEntry,
-  NavigatorOptions,
-  PerformGoOptions,
-  PerformPushOptions,
-  PerformReplaceOptions,
-} from './types.js';
-import { ensurePrefix } from '../ensurePrefix.js';
-
-/**
- * Represents basic navigator implementation which uses only memory to store and control
- * navigation state.
- */
-export abstract class Navigator<T> {
-  protected logger: Logger;
-
-  protected readonly entries: NavigationEntry[];
-
-  constructor(
-    entries: NavigatorConEntry[],
-    protected entriesCursor: number,
-    {
-      debug = false,
-      loggerPrefix = 'Navigator',
-    }: NavigatorOptions,
-  ) {
-    if (entries.length === 0) {
-      throw new Error('Entries list should not be empty.');
-    }
-
-    if (entriesCursor >= entries.length) {
-      throw new Error('Cursor should be less than entries count.');
-    }
-
-    this.entries = entries.map(({ pathname = '', search, hash }) => {
-      if (!pathname.startsWith('/') && pathname.length > 0) {
-        throw new Error('Pathname should start with "/"');
-      }
-
-      return {
-        pathname: ensurePrefix(pathname, '/'),
-        search: search ? ensurePrefix(search, '?') : '',
-        hash: hash ? ensurePrefix(hash, '#') : '',
-      };
-    });
-    this.logger = new Logger(`[${loggerPrefix}]`, debug);
-  }
-
-  protected abstract performGo(options: PerformGoOptions): T;
-
-  protected abstract performPush(options: PerformPushOptions): T;
-
-  protected abstract performReplace(options: PerformReplaceOptions): T;
-
-  /**
-   * Converts entry to the navigation entry.
-   * @param entry - entry data
-   */
-  private formatEntry(entry: AnyEntry): NavigationEntry {
-    let path: string;
-
-    if (typeof entry === 'string') {
-      path = entry;
-    } else {
-      const {
-        pathname = '',
-        search,
-        hash,
-      } = entry;
-
-      path = pathname
-        + (search ? ensurePrefix(search, '?') : '')
-        + (hash ? ensurePrefix(hash, '#') : '');
-    }
-
-    const {
-      pathname,
-      search,
-      hash,
-    } = new URL(path, `https://localhost${this.path}`);
-    return {
-      pathname,
-      search,
-      hash,
-    };
-  }
-
-  /**
-   * Current entry.
-   */
-  protected get entry(): NavigationEntry {
-    return this.entries[this.entriesCursor];
-  }
-
-  /**
-   * Goes back in history.
-   */
-  back(): T {
-    return this.go(-1);
-  }
-
-  /**
-   * Current entries cursor.
-   */
-  get cursor(): number {
-    return this.entriesCursor;
-  }
-
-  /**
-   * True if navigator can go back.
-   */
-  get canGoBack(): boolean {
-    return this.entriesCursor > 0;
-  }
-
-  /**
-   * True if navigator can go forward.
-   */
-  get canGoForward(): boolean {
-    return this.entriesCursor !== this.entries.length - 1;
-  }
-
-  /**
-   * Goes forward in history.
-   */
-  forward(): T {
-    return this.go(1);
-  }
-
-  /**
-   * Moves entries cursor by specified delta.
-   * @param delta - cursor delta.
-   */
-  go(delta: number): T {
-    this.logger.log(`called go(${delta})`);
-
-    // Cursor should be in bounds: [0, this.entries).
-    const cursor = Math.min(
-      this.entries.length - 1,
-      Math.max(this.entriesCursor + delta, 0),
-    );
-
-    if (this.entriesCursor === cursor) {
-      return this.performGo({
-        updated: false,
-        delta,
-      });
-    }
-
-    const before = this.entry;
-    this.entriesCursor = cursor;
-    const after = this.entry;
-
-    this.logger.log('State changed', { before, after });
-
-    return this.performGo({
-      updated: true,
-      delta,
-      before,
-      after,
-    });
-  }
-
-  /**
-   * Returns copy of navigator entries.
-   */
-  getEntries(): NavigationEntry[] {
-    return this.entries.map((entry) => ({ ...entry }));
-  }
-
-  /**
-   * Current hash.
-   * @example
-   * "", "#", "#hash"
-   */
-  get hash(): string {
-    return this.entry.hash;
-  }
-
-  /**
-   * Pushes new entry. Method replaces all entries after the current one with the inserted.
-   * @param entry - entry data.
-   *
-   * @example Pushing absolute pathname.
-   * push("/absolute-path"); // "/absolute-path"
-   *
-   * @example Pushing relative pathname.
-   * // Pushing relative path replaces N last path parts, where N is pushed pathname parts count.
-   * // Pushing empty path is recognized as relative, but not replacing the last pathname part.
-   * push("relative"); // "/home/root" -> "/home/relative"
-   *
-   * @example Pushing query parameters.
-   * push("/absolute?my-param=1"); // "/home" -> "/absolute?my-param=1"
-   * push("relative?my-param=1"); // "/home/root" -> "/home/relative?my-param=1"
-   * push("?my-param=1"); // "/home" -> "/home?my-param=1"
-   *
-   * @example Pushing hash.
-   * push("#my-hash"); // "/home" -> "/home#my-hash"
-   * push("johny#my-hash"); // "/home/root" -> "/home/johny#my-hash"
-   */
-  push(entry: AnyEntry): T {
-    // In case, current cursor refers not to the last one element in the history, we should
-    // remove everything after the cursor.
-    if (this.entriesCursor !== this.entries.length - 1) {
-      this.entries.splice(this.entriesCursor + 1);
-    }
-
-    const formatted = this.formatEntry(entry);
-    const before = this.entry;
-    this.entriesCursor += 1;
-    this.entries[this.entriesCursor] = formatted;
-    const after = this.entry;
-
-    this.logger.log('State changed', { before, after });
-
-    return this.performPush({
-      before,
-      after,
-    });
-  }
-
-  /**
-   * Current full path including pathname, query parameters and hash.
-   */
-  get path(): string {
-    return `${this.pathname}${this.search}${this.hash}`;
-  }
-
-  /**
-   * Current pathname.
-   * @example
-   * "/", "/abc"
-   */
-  get pathname(): string {
-    return this.entry.pathname;
-  }
-
-  /**
-   * Replaces current entry. Has the same logic as `push` method.
-   * @param entry - entry data.
-   * @see push
-   * @returns True if changes were done.
-   */
-  replace(entry: AnyEntry): T {
-    const formattedEntry = this.formatEntry(entry);
-    if (
-      this.search === formattedEntry.search
-      && this.pathname === formattedEntry.pathname
-      && this.hash === formattedEntry.hash
-    ) {
-      return this.performReplace({
-        updated: false,
-        entry: formattedEntry,
-      });
-    }
-
-    const before = this.entry;
-    this.entries[this.entriesCursor] = formattedEntry;
-    const after = this.entry;
-
-    this.logger.log('State changed', { before, after });
-
-    return this.performReplace({
-      updated: true,
-      before,
-      after,
-    });
-  }
-
-  /**
-   * Current query parameters.
-   * @example
-   * "", "?", "?a=1"
-   */
-  get search(): string {
-    return this.entry.search;
-  }
-}

package/src/navigation/Navigator/index.ts

@@ -1,2 +0,0 @@
-export * from './Navigator.js';
-export * from './types.js';

package/src/navigation/Navigator/types.ts

@@ -1,55 +0,0 @@
-export interface NavigationEntry {
-  pathname: string;
-  search: string;
-  hash: string;
-}
-
-export type NavigatorConEntry = Partial<NavigationEntry>;
-
-/**
- * Entry information is allowed to be used in `push` and `replace` Navigator methods.
- * Should be either path or object partially describing it.
- */
-export type AnyEntry = string | Partial<NavigationEntry>;
-
-export type PerformGoOptions =
-  | {
-    updated: false;
-    delta: number;
-  }
-  | {
-    updated: true;
-    delta: number;
-    before: NavigationEntry;
-    after: NavigationEntry;
-  };
-
-export interface PerformPushOptions {
-  before: NavigationEntry;
-  after: NavigationEntry;
-}
-
-export type PerformReplaceOptions =
-  | {
-    updated: false;
-    entry: NavigationEntry;
-  }
-  | {
-    updated: true;
-    before: NavigationEntry;
-    after: NavigationEntry;
-  };
-
-export interface NavigatorOptions {
-  /**
-   * Should navigator display debug messages.
-   * @default false
-   */
-  debug?: boolean;
-
-  /**
-   * Prefix used for logger.
-   * @default 'Navigator'
-   */
-  loggerPrefix?: string;
-}

package/src/navigation/ensurePrefix.ts

@@ -1,9 +0,0 @@
-/**
- * Ensures, that specified value starts with the specified prefix. If it doesn't, function appends
- * prefix.
- * @param value - value to check.
- * @param prefix - prefix to add.
- */
-export function ensurePrefix(value: string, prefix: string): string {
-  return value.startsWith(prefix) ? value : `${prefix}${value}`;
-}

package/src/navigation/getHash.ts

@@ -1,17 +0,0 @@
-/**
- * Returns string after first met "#" symbol.
- * @param value - string to take hash part from.
- *
- * @example No hash.
- * getHash('/path'); // null
- *
- * @example Has hash.
- * getHash('/path#abc'); // 'abc'
- *
- * @example Has double hash.
- * getHash('/path#abc#another'); // 'abc#another'
- */
-export function getHash(value: string): string | null {
-  const match = value.match(/#(.+)/);
-  return match ? match[1] : null;
-}

package/src/navigation/index.ts

@@ -1,4 +0,0 @@
-export * from './ensurePrefix.js';
-export * from './getHash.js';
-export * from './HashNavigator/index.js';
-export * from './Navigator/index.js';

package/src/parsing/ArrayValueParser.ts

@@ -1,79 +0,0 @@
-import type { AnyParser, Parser } from './types.js';
-import { unexpectedTypeError } from './unexpectedTypeError.js';
-import type { ParseResult, ValueParserOverrides } from './ValueParser.js';
-import { ValueParser } from './ValueParser.js';
-
-export type OfResult<BaseClass, ItemType, IsOptional extends boolean> = ArrayParserType<
-BaseClass,
-ItemType,
-IsOptional
->;
-
-export interface ArrayParserOverrides<
-  BaseClass,
-  ItemType,
-  IsOptional extends boolean,
-> extends ValueParserOverrides<BaseClass, ItemType[], IsOptional> {
-  /**
-   * Specifies parser for each array item.
-   * @param parser - item parser.
-   */
-  of<Item>(parser: AnyParser<Item>): OfResult<BaseClass, Item, IsOptional>;
-}
-
-export type ArrayParserType<BaseClass, ItemType, IsOptional extends boolean> =
-  Omit<BaseClass, keyof ArrayParserOverrides<any, any, any>>
-  & ArrayParserOverrides<BaseClass, ItemType, IsOptional>;
-
-/**
- * Parses incoming value as array.
- * @param value - value to parse.
- */
-function parseArray(value: unknown): unknown[] {
-  if (Array.isArray(value)) {
-    return value;
-  }
-
-  if (typeof value === 'string') {
-    try {
-      const json = JSON.parse(value);
-
-      if (Array.isArray(json)) {
-        return json;
-      }
-      // eslint-disable-next-line no-empty
-    } catch (e) {
-    }
-  }
-  throw unexpectedTypeError();
-}
-
-export class ArrayValueParser<ItemType, IsOptional extends boolean>
-  extends ValueParser<unknown[], IsOptional> {
-  private itemParser: Parser<any>;
-
-  constructor(
-    itemParser: AnyParser<ItemType>,
-    isOptional: IsOptional,
-    type?: string,
-  ) {
-    super(parseArray, isOptional, type);
-
-    this.itemParser = typeof itemParser === 'function'
-      ? itemParser
-      : itemParser.parse.bind(itemParser);
-  }
-
-  override parse(value: unknown): ParseResult<ItemType[], IsOptional> {
-    const arr = super.parse(value);
-    return arr === undefined ? arr : arr.map(this.itemParser);
-  }
-
-  of<Item>(itemParser: AnyParser<Item>): OfResult<this, Item, IsOptional> {
-    this.itemParser = typeof itemParser === 'function'
-      ? itemParser
-      : itemParser.parse.bind(itemParser);
-
-    return this as OfResult<this, Item, IsOptional>;
-  }
-}

package/src/parsing/ParseError.ts

@@ -1,27 +0,0 @@
-interface Options {
-  /**
-   * Type name.
-   */
-  type?: string;
-
-  /**
-   * Original occurred error.
-   */
-  cause?: unknown;
-}
-
-/**
- * Error thrown in case, there was an error during parsing.
- */
-export class ParseError extends Error {
-  /**
-   * Parser name.
-   */
-  public readonly type?: string;
-
-  constructor(public readonly value: unknown, { cause, type }: Options = {}) {
-    super(`Unable to parse value${type ? ` as ${type}` : ''}`, { cause });
-    Object.setPrototypeOf(this, ParseError.prototype);
-    this.type = type;
-  }
-}

package/src/parsing/ParseSchemaFieldError.ts

@@ -1,21 +0,0 @@
-interface Options {
-  /**
-   * Type name.
-   */
-  type?: string;
-
-  /**
-   * Original occurred error.
-   */
-  cause?: unknown;
-}
-
-/**
- * Error thrown in case, there was an error during parse.
- */
-export class ParseSchemaFieldError extends Error {
-  constructor(field: string, { cause, type }: Options = {}) {
-    super(`Unable to parse field "${field}"${type ? ` as ${type}` : ''}`, { cause });
-    Object.setPrototypeOf(this, ParseSchemaFieldError.prototype);
-  }
-}

package/src/parsing/ValueParser.ts

@@ -1,71 +0,0 @@
-import type { If } from '~/types/index.js';
-
-import { ParseError } from './ParseError.js';
-import type { Parser } from './types.js';
-
-/**
- * Result of "parse" function.
- */
-export type ParseResult<ResultType, IsOptional extends boolean> =
-  | ResultType
-  | If<IsOptional, undefined, never>;
-
-/**
- * Result of "optional" function in ValueParser.
- */
-export type OptionalResult<BaseClass, ResultType> = ValueParserType<
-BaseClass,
-ResultType,
-true
->;
-
-export interface ValueParserOverrides<BaseClass, ResultType, IsOptional extends boolean> {
-  /**
-   * Parses incoming value applying parsing function passed via constructor.
-   * @param value - value to parse.
-   */
-  parse(value: unknown): ParseResult<ResultType, IsOptional>;
-
-  /**
-   * Marks this parser result as optional. This makes the parser to check if passed value
-   * is empty. If so, parser will return undefined value instead of passing it to the actual
-   * parser.
-   */
-  optional(): OptionalResult<BaseClass, ResultType>;
-}
-
-/**
- * Describes generated ValueParser interface. Shortly saying, this type overrides BaseClass
- * properties defined in ValueParser.
- */
-export type ValueParserType<BaseClass, ResultType, IsOptional extends boolean> =
-  Omit<BaseClass, keyof ValueParserOverrides<any, any, any>>
-  & ValueParserOverrides<BaseClass, ResultType, IsOptional>;
-
-export class ValueParser<ResultType, IsOptional extends boolean> {
-  constructor(
-    protected parser: Parser<ResultType>,
-    protected isOptional: IsOptional,
-    protected type?: string,
-  ) {
-  }
-
-  parse(value: unknown): ParseResult<ResultType, IsOptional> {
-    // In case, parsing result is specified as optional, and passed value is considered as empty,
-    // we can return undefined. Otherwise, pass to parser.
-    if (this.isOptional && value === undefined) {
-      return undefined as ParseResult<ResultType, IsOptional>;
-    }
-
-    try {
-      return this.parser(value) as ParseResult<ResultType, IsOptional>;
-    } catch (cause) {
-      throw new ParseError(value, { type: this.type, cause });
-    }
-  }
-
-  optional(): OptionalResult<this, ResultType> {
-    this.isOptional = true as IsOptional;
-    return this as OptionalResult<this, ResultType>;
-  }
-}

package/src/parsing/__tests__/ArrayValueParser.ts

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

@@ -1,10 +0,0 @@
-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/createValueParserGenerator.ts

@@ -1,16 +0,0 @@
-import type { Parser } from './types.js';
-import { ValueParser } from './ValueParser.js';
-
-export type ValueParserGenerator<T> = () => ValueParser<T, false>;
-
-/**
- * Creates function which generates new scalar value parser based on the specified one.
- * @param parser - parser to use as basic.
- * @param type - type name.
- */
-export function createValueParserGenerator<T>(
-  parser: Parser<T>,
-  type?: string,
-): ValueParserGenerator<T> {
-  return () => new ValueParser(parser, false, type);
-}

package/src/parsing/index.ts

@@ -1,10 +0,0 @@
-export * from './ArrayValueParser.js';
-export * from './createValueParserGenerator.js';
-export * from './parseBySchema.js';
-export * from './ParseError.js';
-export * from './parsers/index.js';
-export * from './ParseSchemaFieldError.js';
-export * from './toRecord.js';
-export * from './types.js';
-export * from './unexpectedTypeError.js';
-export * from './ValueParser.js';

package/src/parsing/parseBySchema.ts

@@ -1,65 +0,0 @@
-import { ParseError } from './ParseError.js';
-import { ParseSchemaFieldError } from './ParseSchemaFieldError.js';
-import type { Parser, Schema } from './types.js';
-
-/**
- * Parses external value by specified schema. Functions iterates over each schema field
- * and uses getField function to get its value from the external source.
- * @param schema - object schema.
- * @param getField - function which gets external value by its field name.
- */
-export function parseBySchema<T>(
-  schema: Schema<T>,
-  getField: (field: string) => unknown,
-): T {
-  const result = {} as T;
-
-  // eslint-disable-next-line guard-for-in,no-restricted-syntax
-  for (const field in schema) {
-    const definition = schema[field];
-    if (!definition) {
-      continue;
-    }
-
-    let from: string;
-    let parser: Parser<any>;
-
-    // In case, definition has "type" property, then SchemaFieldDetailed was passed.
-    if (typeof definition === 'function' || 'parse' in definition) {
-      // Otherwise we are working with either parser function or instance.
-      from = field;
-      parser = typeof definition === 'function' ? definition : definition.parse.bind(definition);
-    } else {
-      const { type } = definition;
-
-      from = definition.from || field;
-      parser = typeof type === 'function' ? type : type.parse.bind(type);
-    }
-
-    let parsedValue: unknown;
-    const originalValue = getField(from);
-
-    try {
-      parsedValue = parser(originalValue);
-    } catch (error) {
-      // If error is not instance of ParseError, we have nothing additional to do with the error.
-      if (!(error instanceof ParseError)) {
-        throw new ParseSchemaFieldError(from, { cause: error });
-      }
-
-      // Otherwise, we are going to rethrow the error with extended data.
-      throw new ParseSchemaFieldError(from, {
-        type: error.type,
-        cause: error,
-      });
-    }
-
-    if (parsedValue === undefined) {
-      continue;
-    }
-
-    (result as any)[field] = parsedValue;
-  }
-
-  return result;
-}