warscript 0.0.1-dev.404878c

package/utility/arrays.lua

@@ -0,0 +1,369 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____exception = require("exception")
+local IllegalArgumentException = ____exception.IllegalArgumentException
+local mathMax = math.max
+local mathMin = math.min
+local select = _G.select
+local tableConcat = table.concat
+local tableSort = table.sort
+____exports.EMPTY_ARRAY = {}
+____exports.joinToString = function(array, separator, transform)
+    if transform == nil then
+        transform = tostring
+    end
+    return tableConcat(
+        ____exports.map(array, transform),
+        separator
+    )
+end
+____exports.arrayOfNotNull = function(...)
+    local array = {}
+    local j = 1
+    for i = 1, select("#", ...) do
+        local value = select(i, ...)
+        if value ~= nil then
+            array[j] = value
+            j = j + 1
+        end
+    end
+    return array
+end
+____exports.array = function(length, initialize)
+    local result = {}
+    for i = 1, length do
+        result[i] = initialize(i - 1)
+    end
+    return result
+end
+____exports.toLuaSet = function(array)
+    local result = {}
+    for i = 1, #array do
+        result[array[i]] = true
+    end
+    return result
+end
+____exports.forEach = function(array, consumerOrKey, ...)
+    if type(consumerOrKey) == "function" then
+        for i = 1, #array do
+            consumerOrKey(array[i], ...)
+        end
+    else
+        for i = 1, #array do
+            local ____self_0 = array[i]
+            ____self_0[consumerOrKey](____self_0, ...)
+        end
+    end
+end
+____exports.all = function(array, transform)
+    local result = true
+    if type(transform) == "function" then
+        for i = 1, #array do
+            result = result and transform(array[i])
+        end
+    else
+        for i = 1, #array do
+            result = result and array[i][transform]
+        end
+    end
+    return result
+end
+____exports.map = function(array, transform)
+    local result = {}
+    if type(transform) == "function" then
+        for i = 1, #array do
+            result[i] = transform(array[i])
+        end
+    else
+        for i = 1, #array do
+            result[i] = array[i][transform]
+        end
+    end
+    return result
+end
+____exports.mapNotNull = function(array, transform)
+    local result = {}
+    local j = 1
+    if type(transform) == "function" then
+        for i = 1, #array do
+            local value = transform(array[i])
+            if value ~= nil then
+                result[j] = value
+                j = j + 1
+            end
+        end
+    else
+        for i = 1, #array do
+            local value = array[i][transform]
+            if value ~= nil then
+                result[j] = value
+                j = j + 1
+            end
+        end
+    end
+    return result
+end
+____exports.mapToLuaSet = function(array, transform)
+    local result = {}
+    if type(transform) == "function" then
+        for i = 1, #array do
+            result[transform(array[i])] = true
+        end
+    else
+        for i = 1, #array do
+            result[array[i][transform]] = true
+        end
+    end
+    return result
+end
+____exports.flatMap = function(array, transform)
+    local result = {}
+    local k = 1
+    if type(transform) == "function" then
+        for i = 1, #array do
+            local values = transform(array[i])
+            for j = 1, #values do
+                result[k] = values[j]
+                k = k + 1
+            end
+        end
+    else
+        for i = 1, #array do
+            local values = array[i][transform]
+            for j = 1, #values do
+                result[k] = values[j]
+                k = k + 1
+            end
+        end
+    end
+    return result
+end
+____exports.flatMapToLuaSet = function(array, transform)
+    local result = {}
+    if type(transform) == "function" then
+        for i = 1, #array do
+            local values = transform(array[i])
+            for j = 1, #values do
+                result[values[j]] = true
+            end
+        end
+    else
+        for i = 1, #array do
+            local values = array[i][transform]
+            for j = 1, #values do
+                result[values[j]] = true
+            end
+        end
+    end
+    return result
+end
+____exports.mapIndexed = function(array, transform)
+    local result = {}
+    for i = 1, #array do
+        result[i] = transform(i - 1, array[i])
+    end
+    return result
+end
+____exports.associate = function(array, keySelector, valueSelector)
+    local result = {}
+    for i = 1, #array do
+        local element = array[i]
+        result[keySelector(element)] = valueSelector(element)
+    end
+    return result
+end
+____exports.associateBy = function(array, keySelector)
+    local result = {}
+    for i = 1, #array do
+        local value = array[i]
+        result[keySelector(value)] = value
+    end
+    return result
+end
+____exports.associateByIndexed = function(array, keySelector)
+    local result = {}
+    for i = 1, #array do
+        local value = array[i]
+        result[keySelector(i - 1, value)] = value
+    end
+    return result
+end
+____exports.associateWith = function(array, valueSelector)
+    local result = {}
+    for i = 1, #array do
+        local value = array[i]
+        result[value] = valueSelector(value)
+    end
+    return result
+end
+____exports.associateWithIndexed = function(array, valueSelector)
+    local result = {}
+    for i = 1, #array do
+        local value = array[i]
+        result[value] = valueSelector(i - 1, value)
+    end
+    return result
+end
+____exports.filter = function(array, predicate)
+    local result = {}
+    local j = 1
+    for i = 1, #array do
+        local value = array[i]
+        if predicate(value) then
+            result[j] = value
+            j = j + 1
+        end
+    end
+    return result
+end
+____exports.average = function(array)
+    local sum = 0
+    local count = #array
+    for i = 1, count do
+        sum = sum + array[i]
+    end
+    return count == 0 and 0 / 0 or sum / count
+end
+____exports.sum = function(array)
+    local sum = 0
+    for i = 1, #array do
+        sum = sum + array[i]
+    end
+    return sum
+end
+____exports.product = function(array)
+    local product = 1
+    for i = 1, #array do
+        product = product * array[i]
+    end
+    return product
+end
+____exports.max = function(array)
+    if #array == 0 then
+        error(
+            __TS__New(IllegalArgumentException),
+            0
+        )
+    end
+    return mathMax(table.unpack(array))
+end
+____exports.intersperse = function(array, delimiter)
+    local result = {}
+    local length = #array
+    for i = 1, length - 1 do
+        result[i + i - 1] = array[i]
+        result[i + i] = delimiter
+    end
+    result[length + length - 1] = array[length]
+    return result
+end
+____exports.zip = function(array, otherArray, transform)
+    local result = {}
+    for i = 1, mathMin(#array, #otherArray) do
+        result[i] = transform(array[i], otherArray[i])
+    end
+    return result
+end
+____exports.chunked = function(array, size)
+    if size <= 0 then
+        error(
+            __TS__New(
+                IllegalArgumentException,
+                ("Size " .. tostring(size)) .. " must be greater than zero."
+            ),
+            0
+        )
+    end
+    local chunks = {}
+    local chunkCount = 0
+    local chunk = {}
+    local chunkSize = 0
+    for i = 1, #array do
+        chunkSize = chunkSize + 1
+        chunk[chunkSize] = array[i]
+        if chunkSize >= size then
+            chunkCount = chunkCount + 1
+            chunks[chunkCount] = chunk
+            chunk = {}
+            chunkSize = 0
+        end
+    end
+    if chunkSize ~= 0 then
+        chunks[chunkCount + 1] = chunk
+    end
+    return chunks
+end
+local comparePropertyKey
+local function compareByProperty(a, b)
+    return a[comparePropertyKey] < b[comparePropertyKey]
+end
+local compareSelector
+local function compareBySelector(a, b)
+    return compareSelector(a) < compareSelector(b)
+end
+____exports.sortBy = function(array, selector)
+    if type(selector) == "function" then
+        compareSelector = selector
+        tableSort(array, compareBySelector)
+    else
+        comparePropertyKey = selector
+        tableSort(array, compareByProperty)
+    end
+end
+____exports.sortedBy = function(array, selector)
+    local sortedArray = {table.unpack(array)}
+    if type(selector) == "function" then
+        compareSelector = selector
+        tableSort(sortedArray, compareBySelector)
+    else
+        comparePropertyKey = selector
+        tableSort(sortedArray, compareByProperty)
+    end
+    return sortedArray
+end
+____exports.partition = function(array, predicate)
+    local first = {}
+    local firstLength = 0
+    local second = {}
+    local secondLength = 0
+    if type(predicate) == "function" then
+        for i = 1, #array do
+            local value = array[i]
+            if predicate(value) then
+                firstLength = firstLength + 1
+                first[firstLength] = value
+            else
+                secondLength = secondLength + 1
+                second[secondLength] = value
+            end
+        end
+    else
+        for i = 1, #array do
+            local value = array[i]
+            if value[predicate] then
+                firstLength = firstLength + 1
+                first[firstLength] = value
+            else
+                secondLength = secondLength + 1
+                second[secondLength] = value
+            end
+        end
+    end
+    return first, second
+end
+____exports.distinct = function(array)
+    local result = {}
+    local j = 1
+    local luaSet = {}
+    for i = 1, #array do
+        local element = array[i]
+        if not (luaSet[element] ~= nil) then
+            luaSet[element] = true
+            result[j] = element
+            j = j + 1
+        end
+    end
+    return result
+end
+return ____exports

package/utility/base64.d.ts

@@ -0,0 +1,23 @@
+interface Base64Encoder {
+    readonly __base64Encoder: unique symbol
+}
+
+interface Base64Decoder {
+    readonly __base64Decoder: unique symbol
+}
+
+export function makeencoder(this: void, s62: string, s63: string, padding: string): Base64Encoder
+export function makedecoder(this: void, s62: string, s63: string, padding: string): Base64Decoder
+
+export function encode(
+    this: void,
+    raw: string,
+    encoder?: Base64Encoder,
+    useCaching?: boolean
+): string
+export function decode(
+    this: void,
+    encoded: string,
+    decoder?: Base64Decoder,
+    useCaching?: boolean
+): string

package/utility/base64.lua

@@ -0,0 +1,177 @@
+--[[
+
+ base64 -- v1.5.1 public domain Lua base64 encoder/decoder
+ no warranty implied; use at your own risk
+
+ Needs bit32.extract function. If not present it's implemented using BitOp
+ or Lua 5.3 native bit operators. For Lua 5.1 fallbacks to pure Lua
+ implementation inspired by Rici Lake's post:
+   http://ricilake.blogspot.co.uk/2007/10/iterating-bits-in-lua.html
+
+ author: Ilya Kolbin (iskolbin@gmail.com)
+ url: github.com/iskolbin/lbase64
+
+ COMPATIBILITY
+
+ Lua 5.1, 5.2, 5.3, LuaJIT
+
+ LICENSE
+
+ See end of file for license information.
+
+--]]
+
+
+local base64 = {}
+
+local function extract( v, from, width )
+    return ( v >> from ) & ((1 << width) - 1)
+end
+
+function base64.makeencoder( s62, s63, spad )
+    local encoder = {}
+    for b64code, char in pairs{[0]='A','B','C','D','E','F','G','H','I','J',
+        'K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y',
+        'Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n',
+        'o','p','q','r','s','t','u','v','w','x','y','z','0','1','2',
+        '3','4','5','6','7','8','9',s62 or '+',s63 or'/',spad or'='} do
+        encoder[b64code] = char:byte()
+    end
+    return encoder
+end
+
+function base64.makedecoder( s62, s63, spad )
+    local decoder = {}
+    for b64code, charcode in pairs( base64.makeencoder( s62, s63, spad )) do
+        decoder[charcode] = b64code
+    end
+    return decoder
+end
+
+local DEFAULT_ENCODER = base64.makeencoder()
+local DEFAULT_DECODER = base64.makedecoder()
+
+local char, concat = string.char, table.concat
+
+function base64.encode( str, encoder, usecaching )
+    encoder = encoder or DEFAULT_ENCODER
+    local t, k, n = {}, 1, #str
+    local lastn = n % 3
+    local cache = {}
+    for i = 1, n-lastn, 3 do
+        local a, b, c = str:byte( i, i+2 )
+        local v = a*0x10000 + b*0x100 + c
+        local s
+        if usecaching then
+            s = cache[v]
+            if not s then
+                s = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[extract(v,0,6)])
+                cache[v] = s
+            end
+        else
+            s = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[extract(v,0,6)])
+        end
+        t[k] = s
+        k = k + 1
+    end
+    if lastn == 2 then
+        local a, b = str:byte( n-1, n )
+        local v = a*0x10000 + b*0x100
+        t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[64])
+    elseif lastn == 1 then
+        local v = str:byte( n )*0x10000
+        t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[64], encoder[64])
+    end
+    return concat( t )
+end
+
+function base64.decode( b64, decoder, usecaching )
+    decoder = decoder or DEFAULT_DECODER
+    local pattern = '[^%w%+%/%=]'
+    if decoder then
+        local s62, s63
+        for charcode, b64code in pairs( decoder ) do
+            if b64code == 62 then s62 = charcode
+            elseif b64code == 63 then s63 = charcode
+            end
+        end
+        pattern = ('[^%%w%%%s%%%s%%=]'):format( char(s62), char(s63) )
+    end
+    b64 = b64:gsub( pattern, '' )
+    local cache = usecaching and {}
+    local t, k = {}, 1
+    local n = #b64
+    local padding = b64:sub(-2) == '==' and 2 or b64:sub(-1) == '=' and 1 or 0
+    for i = 1, padding > 0 and n-4 or n, 4 do
+        local a, b, c, d = b64:byte( i, i+3 )
+        local s
+        if usecaching then
+            local v0 = a*0x1000000 + b*0x10000 + c*0x100 + d
+            s = cache[v0]
+            if not s then
+                local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40 + decoder[d]
+                s = char( extract(v,16,8), extract(v,8,8), extract(v,0,8))
+                cache[v0] = s
+            end
+        else
+            local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40 + decoder[d]
+            s = char( extract(v,16,8), extract(v,8,8), extract(v,0,8))
+        end
+        t[k] = s
+        k = k + 1
+    end
+    if padding == 1 then
+        local a, b, c = b64:byte( n-3, n-1 )
+        local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40
+        t[k] = char( extract(v,16,8), extract(v,8,8))
+    elseif padding == 2 then
+        local a, b = b64:byte( n-3, n-2 )
+    local v = decoder[a]*0x40000 + decoder[b]*0x1000
+        t[k] = char( extract(v,16,8))
+    end
+    return concat( t )
+end
+
+return base64
+
+--[[
+------------------------------------------------------------------------------
+This software is available under 2 licenses -- choose whichever you prefer.
+------------------------------------------------------------------------------
+ALTERNATIVE A - MIT License
+Copyright (c) 2018 Ilya Kolbin
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+------------------------------------------------------------------------------
+ALTERNATIVE B - Public Domain (www.unlicense.org)
+This is free and unencumbered software released into the public domain.
+Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
+software, either in source code form or as a compiled binary, for any purpose,
+commercial or non-commercial, and by any means.
+In jurisdictions that recognize copyright laws, the author or authors of this
+software dedicate any and all copyright interest in the software to the public
+domain. We make this dedication for the benefit of the public at large and to
+the detriment of our heirs and successors. We intend this dedication to be an
+overt act of relinquishment in perpetuity of all present and future rights to
+this software under copyright law.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------------------------------
+--]]

package/utility/bit-set.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="@warscript/language-extensions" />
+/// <reference types="@typescript-to-lua/language-extensions" />
+/** @noSelfInFile */
+interface IBitSet<T extends number> {
+    readonly has: LuaBitwiseAndEqualsRightMethod<T>;
+    readonly hasAny: LuaBitwiseAndUnequalsZeroMethod<this>;
+    readonly intersect: LuaBitwiseAndMethod<this, this>;
+    readonly union: LuaBitwiseOrMethod<this, this>;
+    readonly with: LuaBitwiseOrMethod<T, this>;
+    readonly without: LuaBitwiseAndNotMethod<T, this>;
+}
+/**
+ * Typically, T should be a const enum, with each value being a power of two.
+ */
+export type BitSet<T extends number> = number & IBitSet<T>;
+export declare const emptyBitSet: <T extends number>() => BitSet<T>;
+export declare const bitSetOf: <T extends number>(...elements: T[]) => BitSet<T>;
+export {};

package/utility/bit-set.lua

@@ -0,0 +1,12 @@
+local ____exports = {}
+____exports.emptyBitSet = function()
+    return 0
+end
+____exports.bitSetOf = function(...)
+    local bitSet = 0
+    for i = 1, select("#", ...) do
+        bitSet = bitSet | (select(i, ...))
+    end
+    return bitSet
+end
+return ____exports

package/utility/functions.d.ts

@@ -0,0 +1,5 @@
+/** @noSelfInFile */
+export declare const apply: {
+    <T, ConsumerParameters extends any[]>(object: T, consumer: (value: T, ...parameters: ConsumerParameters) => void, ...parameters: ConsumerParameters): T;
+    <T, ConsumerParameters extends any[], K extends KeysOfType<T, (...parameters: ConsumerParameters) => void>>(object: T, key: K, ...parameters: ConsumerParameters): T;
+};

package/utility/functions.lua

@@ -0,0 +1,90 @@
+local ____exports = {}
+---
+-- @internal An ugly function for use by internal systems only.
+____exports.forward3 = function(func, that, arg0, arg1, arg2, ...)
+    return func(that, arg0, arg1, arg2)
+end
+---
+-- @internal An ugly function for use by internal systems only.
+____exports.forward4 = function(func, that, arg0, arg1, arg2, arg3, ...)
+    return func(
+        that,
+        arg0,
+        arg1,
+        arg2,
+        arg3
+    )
+end
+---
+-- @internal An ugly function for use by internal systems only.
+____exports.forward5 = function(func, that, arg0, arg1, arg2, arg3, arg4, ...)
+    return func(
+        that,
+        arg0,
+        arg1,
+        arg2,
+        arg3,
+        arg4
+    )
+end
+---
+-- @internal An ugly function for use by internal systems only.
+____exports.forward6 = function(func, that, arg0, arg1, arg2, arg3, arg4, arg5, ...)
+    return func(
+        that,
+        arg0,
+        arg1,
+        arg2,
+        arg3,
+        arg4,
+        arg5
+    )
+end
+---
+-- @internal An ugly function for use by internal systems only.
+____exports.forward7 = function(func, that, arg0, arg1, arg2, arg3, arg4, arg5, arg6, ...)
+    return func(
+        that,
+        arg0,
+        arg1,
+        arg2,
+        arg3,
+        arg4,
+        arg5,
+        arg6
+    )
+end
+---
+-- @internal An ugly function for use by internal systems only.
+____exports.forward8 = function(func, that, arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, ...)
+    return func(
+        that,
+        arg0,
+        arg1,
+        arg2,
+        arg3,
+        arg4,
+        arg5,
+        arg6,
+        arg7
+    )
+end
+---
+-- @internal An ugly thing for use by internal systems only.
+____exports.forwardByN = {
+    [3] = ____exports.forward3,
+    [4] = ____exports.forward4,
+    [5] = ____exports.forward5,
+    [6] = ____exports.forward6,
+    [7] = ____exports.forward7,
+    [8] = ____exports.forward8
+}
+____exports.apply = function(object, transform, ...)
+    if type(transform) == "function" then
+        transform(object, ...)
+    else
+        object[transform](object, ...)
+    end
+    return object
+end
+return ____exports

package/utility/json.d.ts

@@ -0,0 +1,2 @@
+export function encode(this: void, value: any): string
+export function decode(this: void, input: string): any