warscript 0.0.1-dev.404878c

package/utility/lzw.lua

@@ -0,0 +1,161 @@
+--[[
+MIT License
+Copyright (c) 2016 Rochet2
+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.
+]]
+
+local char = string.char
+local type = type
+local select = select
+local sub = string.sub
+local tconcat = table.concat
+
+local basedictcompress = {}
+local basedictdecompress = {}
+for i = 0, 255 do
+    local ic, iic = char(i), char(i, 0)
+    basedictcompress[ic] = iic
+    basedictdecompress[iic] = ic
+end
+
+local function dictAddA(str, dict, a, b)
+    if a >= 256 then
+        a, b = 0, b+1
+        if b >= 256 then
+            dict = {}
+            b = 1
+        end
+    end
+    dict[str] = char(a,b)
+    a = a+1
+    return dict, a, b
+end
+
+local function compress(input)
+    if type(input) ~= "string" then
+        return nil, "string expected, got "..type(input)
+    end
+    local len = #input
+    if len <= 1 then
+        return "u"..input
+    end
+
+    local dict = {}
+    local a, b = 0, 1
+
+    local result = {"c"}
+    local resultlen = 1
+    local n = 2
+    local word = ""
+    for i = 1, len do
+        local c = sub(input, i, i)
+        local wc = word..c
+        if not (basedictcompress[wc] or dict[wc]) then
+            local write = basedictcompress[word] or dict[word]
+            if not write then
+                return nil, "algorithm error, could not fetch word"
+            end
+            result[n] = write
+            resultlen = resultlen + #write
+            n = n+1
+            if  len <= resultlen then
+                return "u"..input
+            end
+            dict, a, b = dictAddA(wc, dict, a, b)
+            word = c
+        else
+            word = wc
+        end
+    end
+    result[n] = basedictcompress[word] or dict[word]
+    resultlen = resultlen+#result[n]
+    n = n+1
+    if  len <= resultlen then
+        return "u"..input
+    end
+    return tconcat(result)
+end
+
+local function dictAddB(str, dict, a, b)
+    if a >= 256 then
+        a, b = 0, b+1
+        if b >= 256 then
+            dict = {}
+            b = 1
+        end
+    end
+    dict[char(a,b)] = str
+    a = a+1
+    return dict, a, b
+end
+
+local function decompress(input)
+    if type(input) ~= "string" then
+        return nil, "string expected, got "..type(input)
+    end
+
+    if #input < 1 then
+        return nil, "invalid input - not a compressed string"
+    end
+
+    local control = sub(input, 1, 1)
+    if control == "u" then
+        return sub(input, 2)
+    elseif control ~= "c" then
+        return nil, "invalid input - not a compressed string"
+    end
+    input = sub(input, 2)
+    local len = #input
+
+    if len < 2 then
+        return nil, "invalid input - not a compressed string"
+    end
+
+    local dict = {}
+    local a, b = 0, 1
+
+    local result = {}
+    local n = 1
+    local last = sub(input, 1, 2)
+    result[n] = basedictdecompress[last] or dict[last]
+    n = n+1
+    for i = 3, len, 2 do
+        local code = sub(input, i, i+1)
+        local lastStr = basedictdecompress[last] or dict[last]
+        if not lastStr then
+            return nil, "could not find last from dict. Invalid input?"
+        end
+        local toAdd = basedictdecompress[code] or dict[code]
+        if toAdd then
+            result[n] = toAdd
+            n = n+1
+            dict, a, b = dictAddB(lastStr..sub(toAdd, 1, 1), dict, a, b)
+        else
+            local tmp = lastStr..sub(lastStr, 1, 1)
+            result[n] = tmp
+            n = n+1
+            dict, a, b = dictAddB(tmp, dict, a, b)
+        end
+        last = code
+    end
+    return tconcat(result)
+end
+
+return {
+    compress = compress,
+    decompress = decompress,
+}

package/utility/observable-array.d.ts

@@ -0,0 +1,17 @@
+/** @noSelfInFile */
+import { Event } from "../event";
+export interface ObservableArray<T> extends Array<T> {
+}
+export declare class ObservableArray<T> {
+    /**
+     * The backing array.
+     * @private
+     */
+    private readonly a;
+    readonly onChange: Event<[]>;
+    protected __newindex(index: number, value: T): void;
+    protected __index(index: number): T;
+    protected __len(): number;
+    protected __ipairs(): ReturnType<typeof ipairs<T>>;
+    protected __pairs(): ReturnType<typeof pairs>;
+}

package/utility/observable-array.lua

@@ -0,0 +1,30 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____event = require("event")
+local Event = ____event.Event
+____exports.ObservableArray = __TS__Class()
+local ObservableArray = ____exports.ObservableArray
+ObservableArray.name = "ObservableArray"
+function ObservableArray.prototype.____constructor(self)
+    self.a = {}
+    self.onChange = __TS__New(Event)
+end
+function ObservableArray.prototype.__newindex(self, index, value)
+    self.a[index] = value
+    Event.invoke(self.onChange)
+end
+function ObservableArray.prototype.__index(self, index)
+    return self.a[index]
+end
+function ObservableArray.prototype.__len(self)
+    return #self.a
+end
+function ObservableArray.prototype.__ipairs(self)
+    return ipairs(self.a)
+end
+function ObservableArray.prototype.__pairs(self)
+    return pairs(self.a)
+end
+return ____exports

package/utility/preconditions.d.ts

@@ -0,0 +1,23 @@
+/** @noSelfInFile */
+/**
+ * Throws an {@link IllegalArgumentException} if the `value` is false.
+ */
+export declare const require: (value: boolean, message?: string) => asserts value is true;
+/**
+ * Throws an {@link IllegalArgumentException} if the `value` is null.
+ * Otherwise, returns the not null value.
+ */
+export declare const requireNotNull: <T>(value: T, message?: string) => NonNullable<T>;
+/**
+ * Throws an {@link IllegalStateException} if the `value` is false.
+ */
+export declare const check: (value: boolean, message?: string) => asserts value is true;
+/**
+ * Throws an {@link IllegalStateException} if the `value` is null.
+ * Otherwise, returns the not null value.
+ */
+export declare const checkNotNull: <T>(value: T, message?: string) => NonNullable<T>;
+/**
+ * Throws an {@link IllegalStateException} with the given `message`.
+ */
+export declare const error: (message: unknown) => never;

package/utility/preconditions.lua

@@ -0,0 +1,58 @@
+local ____lualib = require("lualib_bundle")
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local ____exception = require("exception")
+local IllegalArgumentException = ____exception.IllegalArgumentException
+local IllegalStateException = ____exception.IllegalStateException
+local toString = _G.tostring
+--- Throws an {@link IllegalArgumentException} if the `value` is false.
+____exports.require = function(value, message)
+    if not value then
+        error(
+            __TS__New(IllegalArgumentException, message or "Failed requirement."),
+            0
+        )
+    end
+end
+--- Throws an {@link IllegalArgumentException} if the `value` is null.
+-- Otherwise, returns the not null value.
+____exports.requireNotNull = function(value, message)
+    if value == nil then
+        error(
+            __TS__New(IllegalArgumentException, message or "Required value was null."),
+            0
+        )
+    end
+    return value
+end
+--- Throws an {@link IllegalStateException} if the `value` is false.
+____exports.check = function(value, message)
+    if not value then
+        error(
+            __TS__New(IllegalStateException, message or "Check failed."),
+            0
+        )
+    end
+end
+--- Throws an {@link IllegalStateException} if the `value` is null.
+-- Otherwise, returns the not null value.
+____exports.checkNotNull = function(value, message)
+    if value == nil then
+        error(
+            __TS__New(IllegalStateException, message or "Required value was null."),
+            0
+        )
+    end
+    return value
+end
+--- Throws an {@link IllegalStateException} with the given `message`.
+____exports.error = function(message)
+    error(
+        __TS__New(
+            IllegalStateException,
+            toString(message)
+        ),
+        0
+    )
+end
+return ____exports

package/utility/records.d.ts

@@ -0,0 +1,3 @@
+/** @noSelfInFile */
+import { InvertRecordType } from "./types";
+export declare const invertRecord: <T extends Record<PropertyKey, PropertyKey | null | undefined>>(record: T) => InvertRecordType<T>;

package/utility/records.lua

@@ -0,0 +1,9 @@
+local ____exports = {}
+____exports.invertRecord = function(record)
+    local invertRecord = {}
+    for key, value in pairs(record) do
+        invertRecord[value] = key
+    end
+    return invertRecord
+end
+return ____exports

package/utility/reflection.d.ts

@@ -0,0 +1,4 @@
+/** @noSelfInFile */
+import { AbstractConstructor, Constructor } from "./types";
+export declare const getClass: <T extends object>(object: T) => Constructor<T> | undefined;
+export declare const getSuperclass: <T extends object>(clazz: AbstractConstructor<T>) => AbstractConstructor<T> | undefined;

package/utility/reflection.lua

@@ -0,0 +1,31 @@
+local ____exports = {}
+local ____preconditions = require("utility.preconditions")
+local checkNotNull = ____preconditions.checkNotNull
+---
+-- @internal For use by internal systems only.
+____exports.implementReadonlyNumberIndexSupplier = function(clazz, supplier)
+    local metatable = checkNotNull(getmetatable(clazz))
+    local originalIndex = checkNotNull(metatable.__index)
+    local memoizedValueByKey = {}
+    metatable.__index = setmetatable(
+        memoizedValueByKey,
+        {__index = function(self, key)
+            if type(key) == "number" then
+                local value = supplier(key)
+                memoizedValueByKey[key] = value
+                return value
+            end
+            if type(originalIndex) == "function" then
+                return originalIndex(self, key)
+            end
+            return originalIndex[key]
+        end}
+    )
+end
+____exports.getClass = function(object)
+    return object.constructor
+end
+____exports.getSuperclass = function(clazz)
+    return clazz.____super
+end
+return ____exports

package/utility/strings.d.ts

@@ -0,0 +1,2 @@
+/** @noSelfInFile */
+export declare const filterUtf8: (str: string) => string;

package/utility/strings.lua

@@ -0,0 +1,44 @@
+local ____exports = {}
+local concat = table.concat
+local char = string.char
+local find = string.find
+local sub = string.sub
+local oneCharUtf8CodePointPattern = ((("[%z" .. char(1)) .. "-") .. char(127)) .. "]"
+local twoCharsUtf8CodePointPattern = ((((((("[" .. char(194)) .. "-") .. char(223)) .. "][") .. char(128)) .. "-") .. char(191)) .. "]"
+local threeCharsUtf8CodePointPattern1 = ((((((((char(224) .. "[") .. char(160)) .. "-") .. char(191)) .. "][") .. char(128)) .. "-") .. char(191)) .. "]"
+local threeCharsUtf8CodePointPattern2 = ((((((((((("[" .. char(225)) .. "-") .. char(236)) .. "][") .. char(128)) .. "-") .. char(191)) .. "][") .. char(128)) .. "-") .. char(191)) .. "]"
+local threeCharsUtf8CodePointPattern3 = ((((((((char(237) .. "[") .. char(128)) .. "-") .. char(159)) .. "][") .. char(128)) .. "-") .. char(191)) .. "]"
+local threeCharsUtf8CodePointPattern4 = ((((((((((("[" .. char(238)) .. "-") .. char(239)) .. "][") .. char(128)) .. "-") .. char(191)) .. "][") .. char(128)) .. "-") .. char(191)) .. "]"
+local fourCharsUtf8CodePointPattern1 = ((((((((((((char(240) .. "[") .. char(144)) .. "-") .. char(191)) .. "][") .. char(128)) .. "-") .. char(191)) .. "][") .. char(128)) .. "-") .. char(191)) .. "]"
+local fourCharsUtf8CodePointPattern2 = ((((((((((((((("[" .. char(241)) .. "-") .. char(243)) .. "][") .. char(128)) .. "-") .. char(191)) .. "][") .. char(128)) .. "-") .. char(191)) .. "][") .. char(128)) .. "-") .. char(191)) .. "]"
+local fourCharsUtf8CodePointPattern3 = ((((((((((((char(244) .. "[") .. char(128)) .. "-") .. char(143)) .. "][") .. char(128)) .. "-") .. char(191)) .. "][") .. char(128)) .. "-") .. char(191)) .. "]"
+____exports.filterUtf8 = function(str)
+    local len = #str
+    local validUtf8Substrings = nil
+    local validUtf8SubstringsNextLuaIndex = 1
+    local validUtf8SubstringStartLuaIndex = 1
+    local i = 1
+    while i <= len do
+        if i == (find(str, oneCharUtf8CodePointPattern, i)) then
+            i = i + 1
+        elseif i == (find(str, twoCharsUtf8CodePointPattern, i)) then
+            i = i + 2
+        elseif i == (find(str, threeCharsUtf8CodePointPattern1, i)) or i == (find(str, threeCharsUtf8CodePointPattern2, i)) or i == (find(str, threeCharsUtf8CodePointPattern3, i)) or i == (find(str, threeCharsUtf8CodePointPattern4, i)) then
+            i = i + 3
+        elseif i == (find(str, fourCharsUtf8CodePointPattern1, i)) or i == (find(str, fourCharsUtf8CodePointPattern2, i)) or i == (find(str, fourCharsUtf8CodePointPattern3, i)) then
+            i = i + 4
+        else
+            validUtf8Substrings = validUtf8Substrings or ({})
+            validUtf8Substrings[validUtf8SubstringsNextLuaIndex] = sub(str, validUtf8SubstringStartLuaIndex, i - 1)
+            validUtf8SubstringsNextLuaIndex = validUtf8SubstringsNextLuaIndex + 1
+            i = i + 1
+            validUtf8SubstringStartLuaIndex = i
+        end
+    end
+    if validUtf8Substrings ~= nil then
+        validUtf8Substrings[validUtf8SubstringsNextLuaIndex] = sub(str, validUtf8SubstringStartLuaIndex)
+        return concat(validUtf8Substrings)
+    end
+    return str
+end
+return ____exports

package/utility/types.d.ts

@@ -0,0 +1,39 @@
+/** @noSelfInFile */
+export type AnyNonNullable = {};
+export type IsExactlyAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+export type NonEmptyArray<T> = [T, ...T[]];
+export type InvertRecordType<T extends Record<PropertyKey, PropertyKey | null | undefined>> = {
+    [P in keyof T as NonNullable<T[P]>]: P;
+};
+export type Constructor<T = any> = new (...args: any) => T;
+export type AbstractConstructor<T = any> = abstract new (...args: any) => T;
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export type ValueOf<T> = T[keyof T];
+export type EntryOf<T> = ValueOf<{
+    [K in keyof T]: [K, T[K]];
+}>;
+export type MutableKeys<T extends object> = {
+    [P in keyof T]-?: IfEquals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }, P>;
+}[keyof T];
+export type ReadonlyKeys<T extends object> = {
+    [P in keyof T]-?: IfEquals<{
+        [Q in P]: T[P];
+    }, {
+        -readonly [Q in P]: T[P];
+    }, never, P>;
+}[keyof T];
+type IfEquals<X, Y, A = X, B = never> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? A : B;
+export type TupleOf<T, N extends number> = N extends N ? number extends N ? T[] : _TupleOf<T, N, []> : never;
+type _TupleOf<T, N extends number, R extends unknown[]> = R["length"] extends N ? R : _TupleOf<T, N, [T, ...R]>;
+export type Flatten<T extends readonly any[], A extends readonly any[] = []> = T extends [
+    infer F,
+    ...infer R
+] ? Flatten<R, F extends readonly any[] ? [...A, ...F] : [...A, F]> : A;
+export type Prohibit<T, K extends keyof any> = T & {
+    [P in K]?: never;
+};
+export {};

package/utility/types.lua

@@ -0,0 +1,2 @@
+local ____exports = {}
+return ____exports