@mtkruto/node 0.1.119 → 0.1.121

package/esm/deps/deno.land/{std@0.207.0 → std@0.208.0}/assert/assert_not_strict_equals.js

@@ -16,5 +16,5 @@ export function assertNotStrictEquals(actual, expected, msg) {
         return;
     }
     const msgSuffix = msg ? `: ${msg}` : ".";
-    throw new AssertionError(`Expected "actual" to be strictly unequal to: ${format(actual)}${msgSuffix}\n`);
+    throw new AssertionError(`Expected "actual" to not be strictly equal to: ${format(actual)}${msgSuffix}\n`);
 }

package/esm/storage/0_storage.d.ts

@@ -1,5 +1,5 @@
 import { MaybePromise } from "../1_utilities.js";
-import { TLObject, types } from "../2_tl.js";
+import { enums, TLObject, types } from "../2_tl.js";
 import { DC } from "../3_transport.js";
 export type StorageKeyPart = string | number | bigint;
 export declare abstract class Storage {
@@ -21,12 +21,12 @@ export declare abstract class Storage {
     getUsername(username: string): Promise<["channel" | "user", bigint, Date] | null>;
     setTlObject(key: readonly StorageKeyPart[], value: TLObject | null): Promise<void>;
     getTLObject(key: readonly StorageKeyPart[]): Promise<import("../2_tl.js").ReadObject | null>;
-    setState(state: types.UpdatesState): Promise<void>;
-    getState(): Promise<types.UpdatesState | null>;
-    setMessage(chatId: number, messageId: number, message: types.TypeMessage | null): Promise<void>;
+    setState(state: enums.updates.State): Promise<void>;
+    getState(): Promise<import("../tl/2_types.js").updates_State_ | null>;
+    setMessage(chatId: number, messageId: number, message: enums.Message | null): Promise<void>;
     deleteMessages(): Promise<void>;
     getMessageChat(messageId: number): MaybePromise<number | null>;
-    getMessage(chatId: number, messageId: number): Promise<types.TypeMessage | null>;
+    getMessage(chatId: number, messageId: number): Promise<enums.Message | null>;
     setChannelPts(channelId: bigint, pts: number): Promise<void>;
     getChannelPts(channelId: bigint): MaybePromise<number | null>;
     setEntity(peer: types.Channel): Promise<void>;

package/esm/tl/1_tl_object.d.ts

@@ -18,6 +18,7 @@ export declare const paramDesc: unique symbol;
 export declare const length: unique symbol;
 export declare const serialize: unique symbol;
 export declare const as: unique symbol;
+export declare const name: unique symbol;
 export declare function isOptionalParam(ntype: string): boolean;
 export declare function analyzeOptionalParam(ntype: string): {
     flagField: string;
@@ -26,6 +27,8 @@ export declare function analyzeOptionalParam(ntype: string): {
 export declare abstract class TLObject {
     protected abstract get [id](): number;
     protected abstract get [params](): Params;
+    static get [name](): string;
+    get [name](): string;
     protected static get [paramDesc](): ParamDesc;
     get [length](): number;
     [serialize](): Uint8Array;
@@ -33,6 +36,7 @@ export declare abstract class TLObject {
 }
 export interface TLObjectConstructor<T = TLObject> {
     new (params: any): T;
+    [name]: string;
     [paramDesc]: ParamDesc;
 }
 export declare function isTLObjectConstructor(t: unknown): t is typeof TLObject;

package/esm/tl/1_tl_object.js

@@ -7,6 +7,7 @@ export const paramDesc = Symbol("paramDesc");
 export const length = Symbol("length");
 export const serialize = Symbol();
 export const as = Symbol();
+export const name = Symbol();
 export function isOptionalParam(ntype) {
     return ntype.includes("?");
 }
@@ -21,15 +22,17 @@ export function analyzeOptionalParam(ntype) {
     return { flagField, bitIndex };
 }
 function serializeSingleParam(writer, value, type, ntype, debugInfo) {
-    const valueRepr = value == null ? null : value.constructor.name;
+    const valueRepr = value == null ? null : (typeof value === "object" && name in value) ? value[name] : value.constructor.name;
     if (isTLObjectConstructor(type)) {
-        if ((type.name == "TypeX" && value instanceof TLObject) ||
+        if (
+        // TODO: TypeX
+        (type.name == "TypeX" && value instanceof TLObject) ||
             value instanceof type) {
             writer.write(value[serialize]());
             return;
         }
         else {
-            throw new TypeError(`Expected ${type.name} but received ${valueRepr} ${debugInfo}`);
+            throw new TypeError(`Expected ${type[name]} but received ${valueRepr} ${debugInfo}`);
         }
     }
     if (type == Uint8Array) {
@@ -104,6 +107,12 @@ function serializeSingleParam(writer, value, type, ntype, debugInfo) {
     }
 }
 export class TLObject {
+    static get [name]() {
+        throw new Error("Not implemented");
+    }
+    get [name]() {
+        return this.constructor[name];
+    }
     static get [paramDesc]() {
         // unimpl
         return [];
@@ -156,7 +165,7 @@ export class TLObject {
             return this;
         }
         else {
-            throw new TypeError(`Expected ${constructor.name} but received ${this.constructor.name}`);
+            throw new TypeError(`Expected ${constructor[name]} but received ${this[name]}`);
         }
     }
 }