111 lines
2.9 KiB
TypeScript
111 lines
2.9 KiB
TypeScript
/**
|
|
* Represents a type that may or may not be a promise
|
|
*/
|
|
type Awaitable<T> = PromiseLike<T> | T;
|
|
|
|
/**
|
|
* Lazy is a wrapper around a value that is computed lazily. It is useful for
|
|
* cases where the value is expensive to compute and the computation may not
|
|
* be needed at all.
|
|
*
|
|
* @param cb - The callback to lazily evaluate
|
|
* @typeParam T - The type of the value
|
|
* @example
|
|
* ```ts
|
|
* const value = lazy(() => computeExpensiveValue());
|
|
* ```
|
|
*/
|
|
declare function lazy<T>(cb: () => T): () => T;
|
|
|
|
/**
|
|
* Options for creating a range
|
|
*/
|
|
interface RangeOptions {
|
|
/**
|
|
* The end of the range (exclusive)
|
|
*/
|
|
end: number;
|
|
/**
|
|
* The start of the range (inclusive)
|
|
*/
|
|
start: number;
|
|
/**
|
|
* The amount to increment by
|
|
*
|
|
* @defaultValue `1`
|
|
*/
|
|
step?: number;
|
|
}
|
|
/**
|
|
* A generator to yield numbers in a given range
|
|
*
|
|
* @remarks
|
|
* This method is end-exclusive, for example the last number yielded by `range(5)` is 4. If you
|
|
* prefer for the end to be included add 1 to the range or `end` option.
|
|
* @param range - A number representing the the range to yield (exclusive) or an object with start, end and step
|
|
* @example
|
|
* Basic range
|
|
* ```ts
|
|
* for (const number of range(5)) {
|
|
* console.log(number);
|
|
* }
|
|
* // Prints 0, 1, 2, 3, 4
|
|
* ```
|
|
* @example
|
|
* Range with a step
|
|
* ```ts
|
|
* for (const number of range({ start: 3, end: 10, step: 2 })) {
|
|
* console.log(number);
|
|
* }
|
|
* // Prints 3, 5, 7, 9
|
|
* ```
|
|
*/
|
|
declare function range(range: RangeOptions | number): Generator<number, void, unknown>;
|
|
|
|
/**
|
|
* Calculates the shard id for a given guild id.
|
|
*
|
|
* @param guildId - The guild id to calculate the shard id for
|
|
* @param shardCount - The total number of shards
|
|
*/
|
|
declare function calculateShardId(guildId: string, shardCount: number): number;
|
|
|
|
/**
|
|
* Represents an object capable of representing itself as a JSON object
|
|
*
|
|
* @typeParam T - The JSON type corresponding to {@link JSONEncodable.toJSON} outputs.
|
|
*/
|
|
interface JSONEncodable<T> {
|
|
/**
|
|
* Transforms this object to its JSON format
|
|
*/
|
|
toJSON(): T;
|
|
}
|
|
/**
|
|
* Indicates if an object is encodable or not.
|
|
*
|
|
* @param maybeEncodable - The object to check against
|
|
*/
|
|
declare function isJSONEncodable(maybeEncodable: unknown): maybeEncodable is JSONEncodable<unknown>;
|
|
|
|
/**
|
|
* Represents a structure that can be checked against another
|
|
* given structure for equality
|
|
*
|
|
* @typeParam T - The type of object to compare the current object to
|
|
*/
|
|
interface Equatable<T> {
|
|
/**
|
|
* Whether or not this is equal to another structure
|
|
*/
|
|
equals(other: T): boolean;
|
|
}
|
|
/**
|
|
* Indicates if an object is equatable or not.
|
|
*
|
|
* @param maybeEquatable - The object to check against
|
|
*/
|
|
declare function isEquatable(maybeEquatable: unknown): maybeEquatable is Equatable<unknown>;
|
|
|
|
export { Awaitable, Equatable, JSONEncodable, RangeOptions, calculateShardId, isEquatable, isJSONEncodable, lazy, range };
|