@mtcute/core 0.18.0-rc.5 → 0.18.0

package/utils/linked-list.d.cts

@@ -0,0 +1,21 @@
+interface LinkedListItem<T> {
+    v: T;
+    n?: LinkedListItem<T>;
+    p?: LinkedListItem<T>;
+}
+/**
+ * A sorted linked list.
+ */
+export declare class SortedLinkedList<T> {
+    private comparator;
+    _first?: LinkedListItem<T>;
+    _last?: LinkedListItem<T>;
+    _size: number;
+    constructor(comparator: (a: T, b: T) => number);
+    get length(): number;
+    _remove(item: LinkedListItem<T>): void;
+    popFront(): T | undefined;
+    add(item: T): void;
+    clear(): void;
+}
+export {};

package/utils/linked-list.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/links/bots.d.cts

@@ -0,0 +1,72 @@
+import { tl } from '@mtcute/tl';
+import { Deeplink } from './common.js';
+/**
+ * Bot deeplinks
+ *
+ * Used to link to bots with a start parameter
+ */
+export declare const botStart: Deeplink<{
+    /** Bot username */
+    username: string;
+    /** Start parameter */
+    parameter: string;
+}>;
+type BotAdminRight = Exclude<keyof tl.RawChatAdminRights, '_'>;
+/**
+ * Bot add to group links
+ *
+ * Used to ask the user to add a bot to a group, optionally asking for admin rights.
+ * Note that the user is still free to choose which rights to grant, and
+ * whether to grant them at all.
+ */
+export declare const botAddToGroup: Deeplink<{
+    /** Bot username */
+    bot: string;
+    /** If specified, the client will call `/start parameter` on the bot once the bot has been added */
+    parameter?: string;
+    /** Admin rights to request */
+    admin?: BotAdminRight[];
+}>;
+/**
+ * Bot add to channel links
+ *
+ * Used to ask the user to add a bot to a channel, optionally with admin rights.
+ * Note that the user is still free to choose which rights to grant, and
+ * whether to grant them at all.
+ */
+export declare const botAddToChannel: Deeplink<{
+    /** Bot username */
+    bot: string;
+    /** Admin rights to request */
+    admin?: BotAdminRight[];
+}>;
+/**
+ * Game links
+ *
+ * Used to share games.
+ */
+export declare const botGame: Deeplink<{
+    /** Bot username */
+    bot: string;
+    /** Game short name */
+    game: string;
+}>;
+/**
+ * Named bot web app links
+ *
+ * Used to share named bot web apps.
+ *
+ * These links are different from bot attachment menu deep links,
+ * because they don't require the user to install an attachment menu,
+ * and a single bot can offer multiple named web apps, distinguished by
+ * their `short_name`.
+ */
+export declare const botWebApp: Deeplink<{
+    /** Bot username */
+    bot: string;
+    /** App short name */
+    app: string;
+    /** Parameter to be passed by the client to messages.requestAppWebView as `start_param` */
+    parameter?: string;
+}>;
+export {};

package/utils/links/bots.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/links/bundle.d.cts

@@ -0,0 +1,7 @@
+export * from './bots.js';
+export * from './calls.js';
+export * from './chat.js';
+export * from './misc.js';
+export * from './proxy.js';
+export * from './stickers.js';
+export * from './user.js';

package/utils/links/calls.d.cts

@@ -0,0 +1,17 @@
+import { Deeplink } from './common.js';
+/**
+ * Video chat/Livestream links
+ *
+ * Used to join video/voice chats in groups, and livestreams in channels.
+ * Such links are generated using phone.exportGroupCallInvite.
+ */
+export declare const videoChat: Deeplink<{
+    username: string;
+    /**
+     * Invite hash exported if the `can_self_unmute` flag is set when calling `phone.exportGroupCallInvite`:
+     * should be passed to `phone.joinGroupCall`, allows the user to speak in livestreams
+     * or muted group chats.
+     */
+    inviteHash?: string;
+    isLivestream?: boolean;
+}>;

package/utils/links/chat.d.cts

@@ -0,0 +1,47 @@
+import { Deeplink } from './common.js';
+/**
+ * Chat invite links
+ *
+ * Used to invite users to private groups and channels
+ */
+export declare const chatInvite: Deeplink<{
+    hash: string;
+}>;
+/**
+ * Chat folder links
+ */
+export declare const chatFolder: Deeplink<{
+    slug: string;
+}>;
+/**
+ * Message links
+ *
+ * Used to link to specific messages in public or private groups and channels.
+ *
+ * Note: `channelId` is a non-marked channel ID
+ */
+export declare const message: Deeplink<({
+    username: string;
+} | {
+    channelId: number;
+}) & {
+    /** Message ID */
+    id: number;
+    /** Thread ID */
+    threadId?: number;
+    /**
+     * For comments, `id` will contain the message ID of the channel message that started
+     * the comment section and this field will contain the message ID of the comment in
+     * the discussion group.
+     */
+    commentId?: number;
+    /**
+     * Timestamp at which to start playing the media file present
+     * in the body or in the webpage preview of the message
+     */
+    mediaTimestamp?: number;
+    /**
+     * Whether this is a link to a specific message in the album or to the entire album
+     */
+    single?: boolean;
+}>;

package/utils/links/chat.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/links/common.d.cts

@@ -0,0 +1,31 @@
+export interface CommonDeeplinkOptions {
+    /**
+     * Protocol to use for deeplink
+     * - `tg` - use `tg://` protocol links (default)
+     * - `http` - use `http://` protocol
+     * - `https` - use `https://` protocol
+     * - `none` - don't use any protocol
+     *
+     * @default  'https'
+     */
+    protocol?: 'tg' | 'http' | 'https' | 'none';
+    /**
+     * For protocols except `tg://`, domain to use
+     *
+     * @default  't.me'
+     */
+    domain?: string;
+}
+type InputQuery = Record<string, string | number | true | undefined> | null;
+interface BuildDeeplinkOptions<T> {
+    internalBuild?: (options: T) => [string, InputQuery];
+    internalParse?: (path: string, query: URLSearchParams) => T | null;
+    externalBuild?: (options: T) => [string, InputQuery];
+    externalParse?: (path: string, query: URLSearchParams) => T | null;
+}
+export interface Deeplink<T> {
+    (options: T & CommonDeeplinkOptions): string;
+    parse: (url: string) => T | null;
+}
+export declare function deeplinkBuilder<T>(params: BuildDeeplinkOptions<T>): Deeplink<T>;
+export {};

package/utils/links/index.d.cts

@@ -0,0 +1,2 @@
+import * as links from './bundle.js';
+export { links };

package/utils/links/misc.d.cts

@@ -0,0 +1,26 @@
+import { Deeplink } from './common.js';
+/**
+ * Share links
+ *
+ * Used to share a prepared message and URL into a chosen chat's text field.
+ */
+export declare const share: Deeplink<{
+    url: string;
+    text?: string;
+}>;
+/**
+ * Boost links
+ *
+ * Used by users to boost channels, granting them the ability to post stories.
+ */
+export declare const boost: Deeplink<{
+    username: string;
+} | {
+    channelId: number;
+}>;
+/**
+ * Link to a shared folder (chat list)
+ */
+export declare const folder: Deeplink<{
+    slug: string;
+}>;

package/utils/links/misc.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/links/proxy.d.cts

@@ -0,0 +1,18 @@
+import { Deeplink } from './common.js';
+/**
+ * MTProxy links
+ */
+export declare const mtproxy: Deeplink<{
+    server: string;
+    port: number;
+    secret: string;
+}>;
+/**
+ * Socks5 proxy links
+ */
+export declare const socks5: Deeplink<{
+    server: string;
+    port: number;
+    user?: string;
+    pass?: string;
+}>;

package/utils/links/proxy.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/links/stickers.d.cts

@@ -0,0 +1,10 @@
+import { Deeplink } from './common.js';
+/**
+ * Sticker set links
+ *
+ * Used to import stickersets or custom emoji stickersets
+ */
+export declare const stickerset: Deeplink<{
+    slug: string;
+    emoji?: boolean;
+}>;

package/utils/links/user.d.cts

@@ -0,0 +1,28 @@
+import { Deeplink } from './common.js';
+/**
+ * Public username links
+ *
+ * Used to link to public users, groups and channels
+ */
+export declare const publicUsername: Deeplink<{
+    username: string;
+}>;
+/**
+ * Temporary profile links
+ *
+ * Used to link to user profiles, generated using contacts.exportContactToken.
+ * These links can be generated even for profiles that don't have a username,
+ * and they have an expiration date, specified by the expires field of the exportedContactToken
+ * constructor returned by contacts.exportContactToken.
+ */
+export declare const temporaryProfile: Deeplink<{
+    token: string;
+}>;
+/**
+ * Phone number links
+ *
+ * Used to link to public and private users by their phone number.
+ */
+export declare const phoneNumber: Deeplink<{
+    phone: string;
+}>;

package/utils/links/user.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/logger.d.cts

@@ -0,0 +1,54 @@
+import { ICorePlatform } from '../types/platform.js';
+/**
+ * Logger created by {@link LogManager}
+ */
+export declare class Logger {
+    readonly mgr: LogManager;
+    readonly tag: string;
+    readonly parent: Logger;
+    private color;
+    prefix: string;
+    constructor(mgr: LogManager, tag: string, parent?: Logger);
+    getPrefix(): string;
+    log(level: number, fmt: string, ...args: unknown[]): void;
+    readonly error: (fmt: string, ...args: unknown[]) => void;
+    readonly warn: (fmt: string, ...args: unknown[]) => void;
+    readonly info: (fmt: string, ...args: unknown[]) => void;
+    readonly debug: (fmt: string, ...args: unknown[]) => void;
+    readonly verbose: (fmt: string, ...args: unknown[]) => void;
+    /**
+     * Create a {@link Logger} with the given tag
+     * from the same {@link LogManager} as the current
+     * Logger.
+     *
+     * @param tag  Logger tag
+     */
+    create(tag: string): Logger;
+}
+/**
+ * Log manager. A logger that allows managing child loggers
+ */
+export declare class LogManager extends Logger {
+    static OFF: number;
+    static ERROR: number;
+    static WARN: number;
+    static INFO: number;
+    static DEBUG: number;
+    static VERBOSE: number;
+    level: number;
+    handler: (color: number, level: number, tag: string, fmt: string, args: unknown[]) => void;
+    constructor(tag: string | undefined, platform: ICorePlatform);
+    private _filter;
+    /**
+     * Create a {@link Logger} with the given tag
+     *
+     * @param tag  Logger tag
+     */
+    create(tag: string): Logger;
+    /**
+     * Filter logging by tags.
+     *
+     * @param cb
+     */
+    filter(cb: ((tag: string) => boolean) | null): void;
+}

package/utils/logger.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/long-utils.d.cts

@@ -0,0 +1,67 @@
+import { CustomMap, CustomSet } from '@fuman/utils';
+import { default as Long } from 'long';
+/**
+ * Get a random Long
+ *
+ * @param unsigned  Whether the number should be unsigned
+ */
+export declare function randomLong(unsigned?: boolean): Long;
+/**
+ * Read a Long from a buffer
+ *
+ * @param buf  Buffer to read from
+ * @param unsigned  Whether the number should be unsigned
+ * @param le  Whether the number is little-endian
+ */
+export declare function longFromBuffer(buf: Uint8Array, unsigned?: boolean, le?: boolean): Long;
+/**
+ * Remove a Long from an array
+ *
+ * @param arr  Array to remove from
+ * @param val  Value to remove
+ */
+export declare function removeFromLongArray(arr: Long[], val: Long): boolean;
+/**
+ * Compare two Longs and return -1, 0 or 1,
+ * to be used as a comparator function.
+ */
+export declare function compareLongs(a: Long, b: Long): number;
+/**
+ * Serialize a Long (int64) to its fast string representation:
+ * `$high|$low`.
+ *
+ * This method is about 500* times faster than using `Long.toString()`,
+ * and very useful when the string will only ever be used internally
+ * (e.g. for keying a map)
+ *
+ * _\* benchmark result, YMMV_
+ *
+ * @param val
+ */
+export declare function longToFastString(val: Long): string;
+/**
+ * Parse a Long (int64) from its fast string representation:
+ * `$high|$low`.
+ *
+ * This method is about 2 times faster than using Long.fromString.
+ *
+ * @param val
+ * @param unsigned
+ */
+export declare function longFromFastString(val: string, unsigned?: boolean): Long;
+/**
+ * Map with Longs as key.
+ *
+ * Uses fast string representation internally.
+ */
+export declare class LongMap<V> extends CustomMap<Long, string, V> {
+    constructor();
+}
+/**
+ * Set for Longs.
+ *
+ * Uses fast string representation internally
+ */
+export declare class LongSet extends CustomSet<Long, string> {
+    constructor();
+}

package/utils/long-utils.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/misc-utils.d.cts

@@ -0,0 +1,2 @@
+export declare function sleepWithAbort(ms: number, signal: AbortSignal): Promise<void>;
+export declare function getRandomInt(top: number): number;

package/utils/peer-utils.d.cts

@@ -0,0 +1,29 @@
+import { tl } from '@mtcute/tl';
+import { BasicPeerType } from '../types/peers.js';
+/**
+ * Add or remove channel marker from ID
+ */
+export declare function toggleChannelIdMark(id: number): number;
+/**
+ * Get the bare (non-marked) ID from a {@link tl.TypePeer}
+ */
+export declare function getBarePeerId(peer: tl.TypePeer): number;
+/**
+ * Get the marked (non-bare) ID from a {@link tl.TypePeer}
+ *
+ * Mark* is bot API compatible, which is:
+ * - ID stays the same for users
+ * - ID is negated for chats
+ * - ID is negated and `-1e12` is subtracted for channels
+ */
+export declare function getMarkedPeerId(peerId: number, peerType: BasicPeerType): number;
+export declare function getMarkedPeerId(peer: tl.TypePeer | tl.TypeInputPeer | tl.TypeInputUser | tl.TypeInputChannel): number;
+/**
+ * Parse a marked ID into a {@link BasicPeerType} and a bare ID
+ */
+export declare function parseMarkedPeerId(id: number): [BasicPeerType, number];
+/**
+ * Extracts all (cacheable) entities from a TlObject or a list of them.
+ * Only checks `.user`, `.chat`, `.channel`, `.users` and `.chats` properties
+ */
+export declare function getAllPeersFrom(obj: tl.TlObject | tl.TlObject[]): Iterable<tl.TypeUser | tl.TypeChat>;

package/utils/peer-utils.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/sorted-array.d.cts

@@ -0,0 +1,17 @@
+/**
+ * Array that adds elements in sorted order.
+ *
+ * Comparator is always called like: comparator(itemFromSortedArray, yourItem)
+ */
+export declare class SortedArray<T> {
+    readonly comparator: (a: T, b: T) => number;
+    readonly raw: T[];
+    constructor(array: T[] | undefined, comparator: (a: T, b: T) => number);
+    get length(): number;
+    insert(item: T | T[]): number;
+    index(item: T, closest?: boolean): number;
+    remove(item: T): void;
+    includes(item: T): boolean;
+    find(item: T): T | null;
+    clear(): void;
+}

package/utils/sorted-array.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/timers.d.cts

@@ -0,0 +1 @@
+export { timers } from '@fuman/utils';

package/utils/tl-json.d.cts

@@ -0,0 +1,13 @@
+import { tl } from '@mtcute/tl';
+/**
+ * Convert a JS object to TL JSON
+ *
+ * @param obj  Object to be converted
+ */
+export declare function jsonToTlJson(obj: unknown): tl.TypeJSONValue;
+/**
+ * Convert TL JSON object to plain JS object
+ *
+ * @param obj  TL JSON object to convert
+ */
+export declare function tlJsonToJson(obj: tl.TypeJSONValue): unknown;

package/utils/tl-json.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils/type-assertions.d.cts

@@ -0,0 +1,29 @@
+import { mtp, tl } from '@mtcute/tl';
+export declare function isPresent<T>(t: T | undefined | null | void): t is T;
+/**
+ * Returns a function that can be used to filter down objects
+ * to the ones that have a specific value V under a key `k`.
+ *
+ * @example
+ * ```ts
+ * type File = { type: "image", imageUrl: string } | { type: "pdf", pdfUrl: string };
+ * const files: File[] = [];
+ *
+ * const imageFiles = files.filter(file => file.type === "image");
+ * files[0].type // In this case, TS will still treat it  as `"image" | "pdf"`
+ *
+ * const filesWithUrl = files.filter(hasValueKey("type", "image" as const));
+ * files[0].type // TS will now know that this is "image"
+ * files[0].imageUrl // TS will know this is present, because already it excluded the other union members.
+ * ```
+ */
+export declare function hasValueAtKey<const K extends string | number | symbol, const V>(k: K, v: V): <T>(a: T & {
+    [k in K]: unknown;
+}) => a is T & {
+    [k in K]: V;
+};
+export declare function assertTypeIs<T extends tl.TlObject, K extends T['_']>(context: string, obj: T, expected: K): asserts obj is tl.FindByName<T, K>;
+export declare function assertTypeIsNot<T extends tl.TlObject, K extends T['_']>(context: string, obj: T, expectedNot: K): asserts obj is Exclude<T, tl.FindByName<T, K>>;
+export declare function mtpAssertTypeIs<T extends mtp.TlObject, K extends T['_']>(context: string, obj: T, expected: K): asserts obj is mtp.FindByName<T, K>;
+export declare function assertTrue(context: string, cond: boolean): asserts cond;
+export declare function isTlRpcError(obj: unknown): obj is mtp.RawMt_rpc_error;

package/utils/type-assertions.test.d.cts

@@ -0,0 +1 @@
+export {};

package/utils.d.cts

@@ -0,0 +1 @@
+export * from "./utils/index.js"

package/worker.d.cts

@@ -0,0 +1 @@
+export * from "./highlevel/worker/index.js"