warscript/utility/arrays.d.ts

A typescript library for Warcraft III using Warpack.

/// <reference types="@typescript-to-lua/language-extensions" />
/** @noSelfInFile */
import { TupleOf } from "./types";
export declare const EMPTY_ARRAY: readonly any[];
export declare const joinToString: <T>(array: readonly T[], separator: string, transform?: (element: T) => string) => string;
export declare const arrayOfNotNull: <T>(...elements: readonly (T | null | undefined)[]) => T[];
export declare const array: <T, N extends number>(length: N, initialize: (index: number) => T) => TupleOf<T, N>;
export declare const toLuaSet: <T extends AnyNotNil>(array: readonly T[]) => LuaSet<T>;
export declare const forEach: <T, Args extends any[]>(array: readonly T[], consumerOrKey: KeysOfType<T, (this: T, ...args: Args) => void> | ((value: T, ...args: Args) => void), ...args: Args) => void;
export declare const all: {
    <T>(array: readonly T[], transform: (value: T) => boolean): boolean;
    <T>(array: readonly T[], key: KeysOfType<T, boolean>): boolean;
};
export declare const map: {
    <T, R>(array: readonly T[], transform: (value: T) => R): R[];
    <T, K extends keyof T>(array: readonly T[], key: K): T[K][];
};
export declare const mapNotNull: {
    <T, R>(array: readonly T[], transform: (value: T) => R | null | undefined): NonNullable<R>[];
    <T, K extends keyof T>(array: readonly T[], key: K): NonNullable<T[K]>[];
};
export declare const mapToLuaSet: {
    <T, R extends AnyNotNil>(array: readonly T[], transform: (value: T) => R): LuaSet<R>;
    <T, K extends KeysOfType<T, AnyNotNil>>(array: readonly T[], key: K): LuaSet<T[K] extends AnyNotNil ? T[K] : never>;
};
export declare const flatMap: {
    <T, R>(array: readonly T[], transform: (value: T) => readonly R[]): R[];
    <T, K extends KeysOfType<T, readonly any[]>>(array: readonly T[], key: K): (T[K] extends readonly (infer R)[] ? R : never)[];
};
export declare const flatMapToLuaSet: {
    <T, R extends AnyNotNil>(array: readonly T[], transform: (value: T) => readonly R[]): LuaSet<R>;
    <T, K extends KeysOfType<T, readonly AnyNotNil[]>>(array: readonly T[], key: K): LuaSet<T[K] extends readonly (infer R extends AnyNotNil)[] ? R : never>;
};
export declare const mapIndexed: <T, R>(array: readonly T[], transform: (index: number, value: T) => R) => R[];
export declare const associate: <T, K extends AnyNotNil, V>(array: readonly T[], keySelector: (value: T) => K, valueSelector: (value: T) => V) => LuaMap<K, V>;
export declare const associateBy: <K extends AnyNotNil, V>(array: readonly V[], keySelector: (value: V) => K) => LuaMap<K, V>;
export declare const associateByIndexed: <K extends AnyNotNil, V>(array: readonly V[], keySelector: (index: number, value: V) => K) => LuaMap<K, V>;
export declare const associateWith: <K extends AnyNotNil, V>(array: readonly K[], valueSelector: (value: K) => V) => LuaMap<K, V>;
export declare const associateWithIndexed: <K extends AnyNotNil, V>(array: readonly K[], valueSelector: (index: number, value: K) => V) => LuaMap<K, V>;
export declare const filter: <T>(array: readonly T[], predicate: (value: T) => boolean) => T[];
export declare const average: (array: readonly number[]) => number;
export declare const sum: (array: readonly number[]) => number;
export declare const product: (array: readonly number[]) => number;
export declare const max: (array: readonly number[]) => number;
export declare const intersperse: <T>(array: readonly T[], delimiter: T) => T[];
export declare const zip: <T, R, V>(array: readonly T[], otherArray: readonly R[], transform: (value: T, otherValue: R) => V) => V[];
export declare const chunked: <T>(array: readonly T[], size: number) => T[][];
export declare const sortBy: <T, R>(array: T[], selector: KeysOfType<T, R> | ((value: T) => R)) => void;
export declare const sortedBy: {
    <T, R>(array: readonly T[], selector: (value: T) => R): T[];
    <T, K extends keyof T>(array: readonly T[], key: K): T[];
};
export declare const partition: {
    <T>(array: readonly T[], predicate: (value: T) => boolean): LuaMultiReturn<[T[], T[]]>;
    <T, K extends KeysOfType<T, boolean>>(array: readonly T[], key: K): LuaMultiReturn<[T[], T[]]>;
};
export declare const distinct: <T extends AnyNotNil>(array: readonly T[]) => T[];