warscript 0.0.1-dev.404878c

package/util/stream.lua

@@ -0,0 +1,453 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local __TS__Class = ____lualib.__TS__Class
+local Set = ____lualib.Set
+local Map = ____lualib.Map
+local __TS__InstanceOf = ____lualib.__TS__InstanceOf
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local StreamImpl, EntryStreamImpl
+local ____exception = require("exception")
+local IllegalStateException = ____exception.IllegalStateException
+local ____tostring = _G.tostring
+local concat = table.concat
+local sort = table.sort
+local DONE = {}
+____exports.Stream = {}
+local Stream = ____exports.Stream
+do
+    function Stream.of(array)
+        local length = #array
+        local i = 0
+        return __TS__New(
+            StreamImpl,
+            function()
+                if i >= length then
+                    return DONE
+                end
+                i = i + 1
+                return array[i]
+            end
+        )
+    end
+    function Stream.ofReversed(array)
+        local i = #array + 1
+        return __TS__New(
+            StreamImpl,
+            function()
+                if i <= 1 then
+                    return DONE
+                end
+                i = i - 1
+                return array[i]
+            end
+        )
+    end
+    function Stream.ofNullable(element)
+        if element then
+            local next = true
+            return __TS__New(
+                StreamImpl,
+                function()
+                    if next then
+                        next = false
+                        return element
+                    end
+                    return DONE
+                end
+            )
+        end
+        return __TS__New(
+            StreamImpl,
+            function() return DONE end
+        )
+    end
+    function Stream.range(startInclusive, endExclusive, step)
+        if step == nil then
+            step = 1
+        end
+        local i = startInclusive
+        return __TS__New(
+            StreamImpl,
+            function()
+                if i >= endExclusive then
+                    return DONE
+                end
+                local element = i
+                i = i + step
+                return element
+            end
+        )
+    end
+    function Stream.rangeClosed(startInclusive, endInclusive, step)
+        if step == nil then
+            step = 1
+        end
+        local i = startInclusive
+        return __TS__New(
+            StreamImpl,
+            function()
+                if i > endInclusive then
+                    return DONE
+                end
+                local element = i
+                i = i + step
+                return element
+            end
+        )
+    end
+end
+StreamImpl = __TS__Class()
+StreamImpl.name = "StreamImpl"
+function StreamImpl.prototype.____constructor(self, next)
+    self.next = next
+end
+function StreamImpl.prototype.toArray(self)
+    local next = self.next
+    local array = {}
+    local i = 1
+    do
+        local element = next()
+        while element ~= DONE do
+            array[i] = element
+            i = i + 1
+            element = next()
+        end
+    end
+    return array
+end
+function StreamImpl.prototype.toSet(self)
+    local next = self.next
+    local set = __TS__New(Set)
+    do
+        local element = next()
+        while element ~= DONE do
+            set:add(element)
+            element = next()
+        end
+    end
+    return set
+end
+function StreamImpl.prototype.groupingBy(self, f)
+    local next = self.next
+    local map = __TS__New(Map)
+    do
+        local element = next()
+        while element ~= DONE do
+            local key = f(element)
+            local array = map:get(key)
+            if array then
+                array[#array + 1] = element
+            else
+                map:set(key, {element})
+            end
+            element = next()
+        end
+    end
+    return map
+end
+function StreamImpl.prototype.joining(self, sep)
+    local next = self.next
+    local array = {}
+    do
+        local element = next()
+        while element ~= DONE do
+            array[#array + 1] = ____tostring(element)
+            element = next()
+        end
+    end
+    return concat(array, sep)
+end
+function StreamImpl.prototype.forEach(self, f)
+    local next = self.next
+    do
+        local element = next()
+        while element ~= DONE do
+            f(element)
+            element = next()
+        end
+    end
+end
+function StreamImpl.prototype.count(self)
+    local next = self.next
+    local i = 0
+    do
+        local element = next()
+        while element ~= DONE do
+            i = i + 1
+            element = next()
+        end
+    end
+    return i
+end
+function StreamImpl.prototype.findFirst(self)
+    local element = self.next()
+    local ____temp_0
+    if element ~= DONE then
+        ____temp_0 = element
+    else
+        ____temp_0 = nil
+    end
+    return ____temp_0
+end
+function StreamImpl.prototype.reduce(self, identity, accumulator)
+    local next = self.next
+    local result = identity
+    do
+        local element = next()
+        while element ~= DONE do
+            result = accumulator(result, element)
+            element = next()
+        end
+    end
+    return result
+end
+function StreamImpl.prototype.peek(self, f)
+    local next = self.next
+    return __TS__New(
+        StreamImpl,
+        function()
+            local element = next()
+            f(element)
+            return element
+        end
+    )
+end
+function StreamImpl.prototype.map(self, f)
+    local next = self.next
+    return __TS__New(
+        StreamImpl,
+        function()
+            local element = next()
+            local ____temp_1
+            if element == DONE then
+                ____temp_1 = DONE
+            else
+                ____temp_1 = f(element)
+            end
+            return ____temp_1
+        end
+    )
+end
+function StreamImpl.prototype.filter(self, predicate)
+    local next = self.next
+    return __TS__New(
+        StreamImpl,
+        function()
+            do
+                local element = next()
+                while element ~= DONE do
+                    if predicate(element) then
+                        return element
+                    end
+                    element = next()
+                end
+            end
+            return DONE
+        end
+    )
+end
+function StreamImpl.prototype.without(self, value)
+    local next = self.next
+    return __TS__New(
+        StreamImpl,
+        function()
+            do
+                local element = next()
+                while element ~= DONE do
+                    if element ~= value then
+                        return element
+                    end
+                    element = next()
+                end
+            end
+            return DONE
+        end
+    )
+end
+function StreamImpl.prototype.nonNull(self)
+    local next = self.next
+    return __TS__New(
+        StreamImpl,
+        function()
+            do
+                local element = next()
+                while element ~= DONE do
+                    if element ~= nil then
+                        return element
+                    end
+                    element = next()
+                end
+            end
+            return DONE
+        end
+    )
+end
+function StreamImpl.prototype.distinct(self)
+    local next = self.next
+    local ____table = {}
+    local hasNull = false
+    return __TS__New(
+        StreamImpl,
+        function()
+            do
+                local element = next()
+                while element ~= DONE do
+                    if element == nil then
+                        if not hasNull then
+                            hasNull = true
+                            return nil
+                        end
+                    else
+                        if not ____table[element] then
+                            ____table[element] = true
+                            return element
+                        end
+                    end
+                    element = next()
+                end
+            end
+            return DONE
+        end
+    )
+end
+function StreamImpl.prototype.sorted(self)
+    local next = self.next
+    local list = {}
+    local length = -1
+    local i = 0
+    return __TS__New(
+        StreamImpl,
+        function()
+            if length == -1 then
+                length = 1
+                do
+                    local element = next()
+                    while element ~= DONE do
+                        list[length] = element
+                        length = length + 1
+                        element = next()
+                    end
+                end
+                length = length - 1
+                sort(list)
+            end
+            if i >= length then
+                return DONE
+            end
+            i = i + 1
+            return list[i]
+        end
+    )
+end
+function StreamImpl.prototype.limit(self, n)
+    local next = self.next
+    return __TS__New(
+        StreamImpl,
+        function()
+            if n > 0 then
+                n = n - 1
+                return next()
+            end
+            return DONE
+        end
+    )
+end
+function StreamImpl.prototype.skip(self, n)
+    local next = self.next
+    return __TS__New(
+        StreamImpl,
+        function()
+            while n > 0 do
+                if next() == DONE then
+                    return DONE
+                end
+                n = n - 1
+            end
+            return next()
+        end
+    )
+end
+function StreamImpl.prototype.flatMap(self, f)
+    local next = self.next
+    local subnext
+    return __TS__New(
+        StreamImpl,
+        function()
+            do
+                while true do
+                    if not subnext then
+                        local element = next()
+                        if element == DONE then
+                            return DONE
+                        end
+                        subnext = f(element).next
+                    end
+                    local element = subnext()
+                    if element ~= DONE then
+                        return element
+                    end
+                    subnext = nil
+                end
+            end
+        end
+    )
+end
+____exports.EntryStream = {}
+local EntryStream = ____exports.EntryStream
+do
+    function EntryStream.of(map)
+        if __TS__InstanceOf(map, Map) then
+            local iterator = map:entries()
+            return __TS__New(
+                EntryStreamImpl,
+                function()
+                    local result = iterator:next()
+                    if result.done then
+                        return DONE
+                    end
+                    return result.value
+                end
+            )
+        end
+        return __TS__New(
+            EntryStreamImpl,
+            pairs(map)
+        )
+    end
+end
+EntryStreamImpl = __TS__Class()
+EntryStreamImpl.name = "EntryStreamImpl"
+__TS__ClassExtends(EntryStreamImpl, StreamImpl)
+function EntryStreamImpl.prototype.____constructor(self, next)
+    StreamImpl.prototype.____constructor(self, next)
+end
+function EntryStreamImpl.prototype.invert(self)
+    local next = self.next
+    return __TS__New(
+        EntryStreamImpl,
+        function()
+            local element = next()
+            return element == DONE and DONE or ({element[2], element[1]})
+        end
+    )
+end
+function EntryStreamImpl.prototype.toMap(self)
+    local next = self.next
+    local map = __TS__New(Map)
+    do
+        local element = next()
+        while element ~= DONE do
+            if map:has(element[1]) then
+                error(
+                    __TS__New(IllegalStateException),
+                    0
+                )
+            end
+            map:set(element[1], element[2])
+            element = next()
+        end
+    end
+    return map
+end
+return ____exports

package/util/stringBuilder.d.ts

@@ -0,0 +1,8 @@
+/** @noSelfInFile */
+export declare class StringBuilder {
+    private readonly s;
+    private i;
+    append<T>(v: T): StringBuilder;
+    clear(): void;
+    toString(): string;
+}

package/util/stringBuilder.lua

@@ -0,0 +1,25 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local ____exports = {}
+local ____tostring = _G.tostring
+local concat = table.concat
+____exports.StringBuilder = __TS__Class()
+local StringBuilder = ____exports.StringBuilder
+StringBuilder.name = "StringBuilder"
+function StringBuilder.prototype.____constructor(self)
+    self.s = {}
+    self.i = 0
+end
+function StringBuilder.prototype.append(self, v)
+    local i = self.i + 1
+    self.s[i] = ____tostring(v)
+    self.i = i
+    return self
+end
+function StringBuilder.prototype.clear(self)
+    self.i = 0
+end
+function StringBuilder.prototype.__tostring(self)
+    return concat(self.s, "", 1, self.i)
+end
+return ____exports

package/utility/arrays.d.ts

@@ -0,0 +1,57 @@
+/// <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[];