From 7423e3f2837a08d7eccd5c5bf34a68965630f387 Mon Sep 17 00:00:00 2001 From: TopchetoEU <36534413+TopchetoEU@users.noreply.github.com> Date: Fri, 27 Dec 2024 19:16:55 +0200 Subject: [PATCH] feat: more sophisticated stdlib definitions --- src/main/resources/lib/iterator.d.ts | 22 ++++++++ src/main/resources/lib/lib.d.ts | 32 +++++++++--- src/main/resources/lib/typing.d.ts | 9 ++++ src/main/resources/lib/values/array.d.ts | 39 ++++++++++++++ src/main/resources/lib/values/boolean.d.ts | 8 +++ src/main/resources/lib/values/function.d.ts | 25 +++++++++ src/main/resources/lib/values/number.d.ts | 24 +++++++++ src/main/resources/lib/values/object.d.ts | 57 +++++++++++++++++++++ src/main/resources/lib/values/regexp.d.ts | 36 +++++++++++++ src/main/resources/lib/values/string.d.ts | 39 ++++++++++++++ src/main/resources/lib/values/symbol.d.ts | 19 +++++++ 11 files changed, 302 insertions(+), 8 deletions(-) create mode 100644 src/main/resources/lib/iterator.d.ts create mode 100644 src/main/resources/lib/typing.d.ts create mode 100644 src/main/resources/lib/values/array.d.ts create mode 100644 src/main/resources/lib/values/boolean.d.ts create mode 100644 src/main/resources/lib/values/function.d.ts create mode 100644 src/main/resources/lib/values/number.d.ts create mode 100644 src/main/resources/lib/values/object.d.ts create mode 100644 src/main/resources/lib/values/regexp.d.ts create mode 100644 src/main/resources/lib/values/string.d.ts create mode 100644 src/main/resources/lib/values/symbol.d.ts diff --git a/src/main/resources/lib/iterator.d.ts b/src/main/resources/lib/iterator.d.ts new file mode 100644 index 0000000..18749db --- /dev/null +++ b/src/main/resources/lib/iterator.d.ts @@ -0,0 +1,22 @@ +declare interface NormalIterationData { + value: T; + done: true; +} +declare interface DoneIterationData { + value: T; + done?: false; +} +declare type IterationData = NormalIterationData | DoneIterationData; + +declare interface Iterator { + next(): IterationData; + next(val: Next): IterationData; + error?(err: unknown): IterationData; + return?(val: Return): IterationData; +} +declare interface IterableIterator extends Iterator { + [Symbol.iterator](): this; +} +declare interface Iterable { + [Symbol.iterator](): Iterator; +} diff --git a/src/main/resources/lib/lib.d.ts b/src/main/resources/lib/lib.d.ts index fab963c..1cec2d3 100644 --- a/src/main/resources/lib/lib.d.ts +++ b/src/main/resources/lib/lib.d.ts @@ -1,10 +1,26 @@ +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// +/// + declare function print(...args: any[]): void; -declare type Array = {}; -declare type Boolean = {}; -declare type Function = {}; -declare type IArguments = {}; -declare type Number = {}; -declare type Object = {}; -declare type RegExp = {}; -declare type String = {}; +declare type IArguments = Array; + +declare var Array: ArrayConstructor; +declare var Boolean: BooleanConstructor; +declare var Function: FunctionConstructor; +declare var Symbol: SymbolConstructor; +declare var Number: NumberConstructor; +declare var Object: ObjectConstructor; +declare var RegExp: RegExpConstructor; +declare var String: StringConstructor; +declare var Promise: PromiseConstructor; diff --git a/src/main/resources/lib/typing.d.ts b/src/main/resources/lib/typing.d.ts new file mode 100644 index 0000000..4d6e5cd --- /dev/null +++ b/src/main/resources/lib/typing.d.ts @@ -0,0 +1,9 @@ +declare interface Record { + [key: Key]: Val; +} +declare type InstanceType = T extends new (...args: any[]) => infer T ? T : never; +declare type ReturnType = T extends (...args: any[]) => infer T ? T : never; +declare type Arguments = + T extends (...args: infer T) => any ? T : + T extends new (...args: infer T) => any ? T : + never; diff --git a/src/main/resources/lib/values/array.d.ts b/src/main/resources/lib/values/array.d.ts new file mode 100644 index 0000000..61179bd --- /dev/null +++ b/src/main/resources/lib/values/array.d.ts @@ -0,0 +1,39 @@ +declare interface Array { + length: number; + [i: number]: T; + + forEach(this: T[], cb: (val: T, i: number, self: this) => void, self?: any): void; + join(this: T[], delim?: string): void; + + push(this: T[], ...elements: T[]): number; + pop(this: T[]): T | undefined; + + unshift(this: T[], ...elements: T[]): number; + shift(this: T[]): T | undefined; + + concat(this: T[], ...elements: (T | T[])[]): T | undefined; + slice(this: T[], start?: number, end?: number): T | undefined; + splice(this: T[], start?: number, count?: number): T[]; + splice(this: T[], start: number | undefined, count: number | undefined, ...elements: T[]): T[]; + + map(this: T[], cb: (val: T, i: number, self: this) => T2, self?: any): T2[]; + filter(this: T[], cb: (val: T, i: number, self: this) => boolean, self?: any): T[]; + some(this: T[], cb: (val: T, i: number, self: this) => boolean, self?: any): boolean; + find(this: T[], cb: (val: T, i: number, self: this) => boolean, self?: any): T | undefined; + indexOf(this: T[], el: T, start?: number): number; + lastIndexOf(this: T[], el: T, start?: number): number; + + sort(this: T[], cb?: (a: T, b: T) => number): T[]; + + [Symbol.iterator](): IterableIterator; +} +declare interface ArrayConstructor { + new (len: number): T[]; + new (...elements: T[]): T[]; + + (len: number): T[]; + (...elements: T[]): T[]; + + isArray(val: any): val is any[]; + // from(val: any): val is any[]; +} diff --git a/src/main/resources/lib/values/boolean.d.ts b/src/main/resources/lib/values/boolean.d.ts new file mode 100644 index 0000000..4ff75ee --- /dev/null +++ b/src/main/resources/lib/values/boolean.d.ts @@ -0,0 +1,8 @@ +declare interface Boolean { + valueOf(): boolean; + toString(): string; +} +declare interface BooleanConstructor { + new (val?: unknown): Boolean; + (val?: unknown): boolean; +} diff --git a/src/main/resources/lib/values/function.d.ts b/src/main/resources/lib/values/function.d.ts new file mode 100644 index 0000000..e9c69cd --- /dev/null +++ b/src/main/resources/lib/values/function.d.ts @@ -0,0 +1,25 @@ +declare interface Function { + prototype: unknown; + + valueOf(): this; + toString(): string; + + apply(this: (this: Self, ...args: Args) => Ret, self: Self, args: Args): Ret; + call(this: (this: Self, ...args: Args) => Ret, self: Self, ...args: Args): Ret; + bind any>(this: T): T; + bind< + Bound extends readonly any[], + Args extends readonly any[], + Ret, Self + >(this: (this: Self, ...args: [...Bound, ...Args]) => Ret, self: Self, ...bound: Bound): (this: void, ...args: Args) => Ret; +} +declare interface CallableFunction extends Function { + (...args: unknown[]): unknown; +} +declare interface NewableFunction extends Function { + new (...args: unknown[]): unknown; +} +declare interface FunctionConstructor { + new (val?: string): (this: unknown, ...args: unknown[]) => unknown; + (val?: string): (this: unknown, ...args: unknown[]) => unknown; +} diff --git a/src/main/resources/lib/values/number.d.ts b/src/main/resources/lib/values/number.d.ts new file mode 100644 index 0000000..5cd8046 --- /dev/null +++ b/src/main/resources/lib/values/number.d.ts @@ -0,0 +1,24 @@ +declare interface Number { + valueOf(): number; + toString(): string; +} +declare interface NumberConstructor { + (val?: unknown): number; + new (val?: unknown): Number; + + isFinite(value: number): boolean; + isInteger(value: number): boolean; + isNaN(value: number): boolean; + isSafeInteger(value: number): boolean; + parseFloat(value: unknown): number; + parseInt(value: unknown, radix?: number): number; + + readonly EPSILON: number; + readonly MIN_SAFE_INTEGER: number; + readonly MAX_SAFE_INTEGER: number; + readonly POSITIVE_INFINITY: number; + readonly NEGATIVE_INFINITY: number; + readonly NaN: number; + readonly MAX_VALUE: number; + readonly MIN_VALUE: number; +} diff --git a/src/main/resources/lib/values/object.d.ts b/src/main/resources/lib/values/object.d.ts new file mode 100644 index 0000000..434c754 --- /dev/null +++ b/src/main/resources/lib/values/object.d.ts @@ -0,0 +1,57 @@ +type AssignResult = + Arr extends [...infer Rest extends object[], infer B extends object] ? { + [x in keyof B | keyof AssignResult]: + x extends keyof B ? B[x] : + x extends keyof AssignResult ? AssignResult[x] : + never + } : {}; + +declare interface PropertyDescriptor { + configurable?: boolean; + enumerable?: boolean; + value?: any; + writable?: boolean; + get?(): any; + set?(v: any): void; +} +declare interface PropertyDescriptorMap { + [key: PropertyKey]: PropertyDescriptor; +} + +declare interface Object { + valueOf(): number; + toString(): string; +} +declare interface ObjectConstructor { + new (val: string): String; + (val: string): String; + new (val: number): Number; + new (val: number): Number; + (val: number): Number; + new (val: boolean): Boolean; + (val: boolean): Boolean; + new (val: symbol): Symbol; + (val: symbol): Symbol; + new (val: T): T; + (val: T): T; + new (): object; + (): object; + + getOwnPropertyDescriptor(obj: object, key: any): PropertyDescriptor; + defineProperty(obj: T, key: string | symbol, desc: PropertyDescriptor): T; + defineProperties(obj: T, desc: PropertyDescriptorMap): T; + + create(proto: T, desc?: PropertyDescriptorMap): T; + assign(targeT: First, ...arr: T): AssignResult<[First, ...T]>; + + setPrototypeOf(obj: T, proto: object | null): T + getPrototypeOf(obj: object): object | null; + + keys(obj: T): (keyof T)[]; + values(obj: T): T[keyof T][]; + entries(obj: T): [key: keyof T, val: T[keyof T]][]; + + preventExtensions(obj: T): T; + seal(obj: T): T; + freeze(obj: T): T; +} diff --git a/src/main/resources/lib/values/regexp.d.ts b/src/main/resources/lib/values/regexp.d.ts new file mode 100644 index 0000000..f3301a1 --- /dev/null +++ b/src/main/resources/lib/values/regexp.d.ts @@ -0,0 +1,36 @@ +declare interface RegExpMatchArray extends Array { + 0: string; + + index?: number; + input?: string; + + groups?: { [key: string]: string }; + indices?: [start: number, end: number][] & { + [key: string]: [start: number, end: number] + } +} + +declare interface RegExp { + lastIndex: number; + + readonly source: string; + readonly flags: string; + + readonly indices: boolean; + readonly global: boolean; + readonly ignoreCase: boolean; + readonly multiline: boolean; + readonly dotall: boolean; + readonly unicode: boolean; + readonly unicodeSets: boolean; + readonly sticky: boolean; + + exec(target: string): RegExpMatchArray | null; + text(target: string): boolean + [Symbol.split](target: string, limit?: number): string[]; + [Symbol.replace](target: string, replacer: any): string; +} +declare interface RegExpConstructor { + new (val: string, flags?: string): String; + (val: string, flags?: string): String; +} diff --git a/src/main/resources/lib/values/string.d.ts b/src/main/resources/lib/values/string.d.ts new file mode 100644 index 0000000..93a087d --- /dev/null +++ b/src/main/resources/lib/values/string.d.ts @@ -0,0 +1,39 @@ +declare interface String { + readonly length: number; + [key: number]: string; + + toString(): string; + valueOf(): string; + + at(index: number): string | undefined; + charAt(i: number): string | undefined; + charCodeAt(i: number): string; + codePointAt(i: number): string; + + includes(search: string, offset?: number): number; + indexOf(search: string, offset?: number): number; + lastIndexOf(search: string, offset?: number): number; + + trim(): string; + trimStart(): string; + trimEnd(): string; + toLowerCase(): string; + toUpperCase(): string; + + split(val?: any, limit?: number): string[]; + replace(val: any, replacer: any): string; + replaceAll(val: any, replacer: any): string; + + slice(start?: number, end?: number): string; + substring(start?: number, end?: number): string; + substr(start?: number, count?: number): string; + + [Symbol.iterator](): IterableIterator; +} +declare interface StringConstructor { + new (val: unknown): String; + (val: unknown): string; + + fromCharCode(...chars: readonly number[]): string; + fromCodePoint(...points: readonly number[]): string; +} diff --git a/src/main/resources/lib/values/symbol.d.ts b/src/main/resources/lib/values/symbol.d.ts new file mode 100644 index 0000000..9f857d6 --- /dev/null +++ b/src/main/resources/lib/values/symbol.d.ts @@ -0,0 +1,19 @@ +declare interface Symbol { + readonly description: string | undefined; + + valueOf(): symbol; + toString(): string; +} +declare interface SymbolConstructor { + (val?: string): symbol; + for(val: string): symbol; + + readonly asyncIterator: unique symbol; + readonly iterator: unique symbol; + readonly match: unique symbol; + readonly matchAll: unique symbol; + readonly replace: unique symbol; + readonly search: unique symbol; + readonly split: unique symbol; + readonly toStringTag: unique symbol; +}