warscript 0.0.1-dev.989e1a3 → 0.0.1-dev.9979c8f

package/patch-lua.lua

@@ -1,5 +1,9 @@
+local error = _G.error
 local getmetatable = _G.getmetatable
 local ipairs = _G.ipairs
+local select = _G.select
+local tostring = _G.tostring
+local tableconcat = table.concat
 
 _G.ipairs = function(t)
     local metatable = getmetatable(t)
@@ -8,3 +12,14 @@ _G.ipairs = function(t)
     end
     return ipairs(t)
 end
+
+_G.assert = function(v, ...)
+    if not v then
+        local args = {}
+        for i = 1, select("#", ...) do
+            args[i] = tostring(select(i, ...))
+        end
+        error(tableconcat(args, " "))
+    end
+    return v, ...
+end

package/utility/linked-map.d.ts

@@ -0,0 +1,34 @@
+/** @noSelfInFile */
+import { ReadonlyLinkedSet } from "./linked-set";
+type IteratorState<K extends AnyNotNil, V> = {
+    n?: K;
+    t: LuaMap<K, K>;
+    v: LuaMap<K, V>;
+};
+type OneSidedTypeGuard = {
+    readonly __oneSidedTypeGuard: unique symbol;
+};
+export interface ReadonlyLinkedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    readonly keys: ReadonlyLinkedSet<K>;
+    get(key: K): V | undefined;
+    contains(key: AnyNotNil): key is K & OneSidedTypeGuard;
+    readonly size: number;
+}
+export interface LinkedMap<K extends AnyNotNil, V> extends LuaPairsIterable<K, V> {
+    readonly __linkedSet: unique symbol;
+}
+export declare class LinkedMap<K extends AnyNotNil, V> implements ReadonlyLinkedMap<K, V> {
+    private k;
+    private v;
+    get keys(): ReadonlyLinkedSet<K>;
+    get(key: K): V | undefined;
+    getOrPut(key: K, defaultValue: (this: void) => V): V;
+    put(key: K, value: V): void;
+    remove(key: K): boolean;
+    contains(key: AnyNotNil): key is K & OneSidedTypeGuard;
+    get size(): number;
+    protected __pairs(this: LinkedMap<K, V>): LuaIterator<LuaMultiReturn<[K | undefined, V | undefined]>, IteratorState<K, V>>;
+}
+export declare const emptyLinkedMap: <K extends AnyNotNil, V>() => ReadonlyLinkedMap<K, V>;
+export declare const mutableLinkedMap: <K extends AnyNotNil, V>() => LinkedMap<K, V>;
+export {};

package/utility/linked-map.lua

@@ -0,0 +1,101 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local __TS__ClassExtends = ____lualib.__TS__ClassExtends
+local ____exports = {}
+local ____linked_2Dset = require("utility.linked-set")
+local LinkedSet = ____linked_2Dset.LinkedSet
+local ____exception = require("exception")
+local UnsupportedOperationException = ____exception.UnsupportedOperationException
+local function linkedMapNext(state)
+    local n = state.n
+    state.n = state.t[n]
+    return n, state.v[n]
+end
+____exports.LinkedMap = __TS__Class()
+local LinkedMap = ____exports.LinkedMap
+LinkedMap.name = "LinkedMap"
+function LinkedMap.prototype.____constructor(self)
+    self.k = __TS__New(LinkedSet)
+    self.v = {}
+end
+function LinkedMap.prototype.get(self, key)
+    return self.v[key]
+end
+function LinkedMap.prototype.getOrPut(self, key, defaultValue)
+    local value = self.v[key]
+    if value ~= nil then
+        return value
+    end
+    value = defaultValue()
+    self.k:add(key)
+    self.v[key] = value
+    return value
+end
+function LinkedMap.prototype.put(self, key, value)
+    self.k:add(key)
+    self.v[key] = value
+end
+function LinkedMap.prototype.remove(self, key)
+    if self.k:remove(key) then
+        self.v[key] = nil
+        return true
+    end
+    return false
+end
+function LinkedMap.prototype.contains(self, key)
+    return self.keys:contains(key)
+end
+function LinkedMap.prototype.__pairs(self)
+    return linkedMapNext, {n = self.k.f, t = self.k.n, v = self.v}, nil
+end
+__TS__SetDescriptor(
+    LinkedMap.prototype,
+    "keys",
+    {get = function(self)
+        return self.k
+    end},
+    true
+)
+__TS__SetDescriptor(
+    LinkedMap.prototype,
+    "size",
+    {get = function(self)
+        return self.keys.size
+    end},
+    true
+)
+local emptyIteratorState = {t = {}, v = {}}
+local EmptyLinkedMap = __TS__Class()
+EmptyLinkedMap.name = "EmptyLinkedMap"
+__TS__ClassExtends(EmptyLinkedMap, ____exports.LinkedMap)
+function EmptyLinkedMap.prototype.getOrPut(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyLinkedMap.prototype.put(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyLinkedMap.prototype.remove(self)
+    error(
+        __TS__New(UnsupportedOperationException),
+        0
+    )
+end
+function EmptyLinkedMap.prototype.__pairs(self)
+    return linkedMapNext, emptyIteratorState, nil
+end
+local EMPTY_LINKED_MAP = __TS__New(EmptyLinkedMap)
+____exports.emptyLinkedMap = function()
+    return EMPTY_LINKED_MAP
+end
+____exports.mutableLinkedMap = function()
+    return __TS__New(____exports.LinkedMap)
+end
+return ____exports

package/utility/linked-set.d.ts

@@ -14,7 +14,7 @@ export interface ReadonlyLinkedSet<T extends AnyNotNil> extends LuaPairsKeyItera
     next(key: T): T | undefined;
     previous(key: T): T | undefined;
     contains(key: AnyNotNil): key is T & OneSidedTypeGuard;
-    size: number;
+    readonly size: number;
     forEach<Args extends any[]>(action: (value: T, ...args: Args) => void, ...args: Args): void;
     toArray(): T[];
     sumOf(selector: ((value: T) => number) | KeysOfType<T, number>): number;
@@ -40,6 +40,7 @@ export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet
     next(key: T): T | undefined;
     previous(key: T): T | undefined;
     add(key: T): boolean;
+    protected addBefore(value: T, key: T): boolean;
     remove(key: T): boolean;
     contains(key: AnyNotNil): key is T & OneSidedTypeGuard;
     clear(): void;

package/utility/linked-set.lua

@@ -85,6 +85,23 @@ function LinkedSet.prototype.add(self, key)
     end
     return true
 end
+function LinkedSet.prototype.addBefore(self, value, key)
+    local n = self.n
+    local p = self.p
+    local previous = p[value]
+    if previous ~= nil then
+        n[previous] = key
+        p[key] = previous
+    elseif value == self.f then
+        self.f = key
+    else
+        return false
+    end
+    n[key] = value
+    p[value] = key
+    self.s = self.s + 1
+    return true
+end
 function LinkedSet.prototype.remove(self, key)
     local n = self.n
     local next = n[key]
@@ -182,6 +199,7 @@ __TS__SetDescriptor(
     end},
     true
 )
+local emptyIteratorState = {t = {}}
 local EmptyLinkedSet = __TS__Class()
 EmptyLinkedSet.name = "EmptyLinkedSet"
 __TS__ClassExtends(EmptyLinkedSet, ____exports.LinkedSet)
@@ -191,6 +209,9 @@ function EmptyLinkedSet.prototype.add(self)
         0
     )
 end
+function EmptyLinkedSet.prototype.__pairs(self)
+    return linkedSetNext, emptyIteratorState, nil
+end
 local EMPTY_LINKED_SET = __TS__New(EmptyLinkedSet)
 ____exports.emptyLinkedSet = function()
     return EMPTY_LINKED_SET

package/utility/records.lua

@@ -1,9 +1,28 @@
 local ____exports = {}
+local ____pairs = _G.pairs
+local tableSort = table.sort
 ____exports.invertRecord = function(record)
     local invertRecord = {}
-    for key, value in pairs(record) do
+    for key, value in ____pairs(record) do
         invertRecord[value] = key
     end
     return invertRecord
 end
+local sortedKeysInternal = {}
+local lastSortedKeysLength = 0
+---
+-- @internal For use by internal systems only.
+____exports.sortedKeysUnnested = function(record)
+    local length = 0
+    for key in ____pairs(record) do
+        length = length + 1
+        sortedKeysInternal[length] = key
+    end
+    for i = length + 1, lastSortedKeysLength do
+        sortedKeysInternal[i] = nil
+    end
+    lastSortedKeysLength = length
+    tableSort(sortedKeysInternal)
+    return sortedKeysInternal
+end
 return ____exports