warscript 0.0.1-dev.f48f7bb → 0.0.1-dev.f70428f

package/utility/functions.d.ts

@@ -3,3 +3,11 @@ 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;
 };
+export declare const identity: <T>(value: T) => T;
+export declare const firstArgument: <T>(value: T) => T;
+export declare const secondArgument: <T>(_: unknown, value: T) => T;
+export declare const thirdArgument: <T>(_first: unknown, _second: unknown, value: T) => T;
+export declare const increment: (value: number) => number;
+export declare const or: (lhs: boolean, rhs: boolean) => boolean;
+export type Transform<T, R> = (<T, R>(value: T) => R) | KeysOfType<T, R>;
+export declare const transform: <T, R>(object: T, transform: Transform<T, R>) => R;

package/utility/functions.lua

@@ -87,4 +87,17 @@ ____exports.apply = function(object, transform, ...)
     end
     return object
 end
+____exports.identity = function(value) return value end
+____exports.firstArgument = ____exports.identity
+____exports.secondArgument = function(_, value) return value end
+____exports.thirdArgument = function(_first, _second, value) return value end
+____exports.increment = function(value) return value + 1 end
+____exports["or"] = function(lhs, rhs) return lhs or rhs end
+____exports.transform = function(object, transform)
+    if type(transform) == "function" then
+        return transform(object)
+    else
+        return object[transform]
+    end
+end
 return ____exports

package/utility/linked-set.d.ts

@@ -36,6 +36,7 @@ export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet
     copyOf(): LinkedSet<T>;
     first(): T | undefined;
     last(): T | undefined;
+    pop(): T | undefined;
     next(key: T): T | undefined;
     previous(key: T): T | undefined;
     add(key: T): boolean;
@@ -50,6 +51,7 @@ export declare class LinkedSet<T extends AnyNotNil> implements ReadonlyLinkedSet
     protected __pairs(this: LinkedSet<T>): LuaIterator<T | undefined, IteratorState<T>>;
 }
 export declare const emptyLinkedSet: <T extends AnyNotNil>() => ReadonlyLinkedSet<T>;
+export declare const mutableLinkedSet: <T extends AnyNotNil>() => LinkedSet<T>;
 export declare const mutableLinkedSetOf: <T extends AnyNotNil>(...elements: ReadonlyArray<T>) => LinkedSet<T>;
 export declare const mutableLinkedSetOfNotNull: <T extends AnyNotNil>(...elements: readonly (T | undefined | null)[]) => LinkedSet<T>;
 export declare const linkedSetOf: <T extends AnyNotNil>(...elements: ReadonlyArray<T>) => ReadonlyLinkedSet<T>;

package/utility/linked-set.lua

@@ -42,6 +42,23 @@ end
 function LinkedSet.prototype.last(self)
     return self.l
 end
+function LinkedSet.prototype.pop(self)
+    local f = self.f
+    if f == nil then
+        return nil
+    end
+    local n = self.n
+    local next = n[f]
+    n[f] = nil
+    self.f = next
+    if next ~= nil then
+        self.p[next] = nil
+    else
+        self.l = nil
+    end
+    self.s = self.s - 1
+    return f
+end
 function LinkedSet.prototype.next(self, key)
     return self.n[key]
 end
@@ -107,8 +124,9 @@ function LinkedSet.prototype.forEach(self, action, ...)
     local n = self.n
     local c = self.f
     while c ~= nil do
+        local next = n[c]
         action(c, ...)
-        c = n[c]
+        c = next
     end
 end
 function LinkedSet.prototype.toArray(self)
@@ -177,6 +195,9 @@ local EMPTY_LINKED_SET = __TS__New(EmptyLinkedSet)
 ____exports.emptyLinkedSet = function()
     return EMPTY_LINKED_SET
 end
+____exports.mutableLinkedSet = function()
+    return __TS__New(____exports.LinkedSet)
+end
 ____exports.mutableLinkedSetOf = function(...)
     local linkedSet = __TS__New(____exports.LinkedSet)
     for i = 1, select("#", ...) do

package/utility/lua-maps.d.ts

@@ -1,5 +1,18 @@
 /** @noSelfInFile */
 import { Flatten, TupleOf } from "./types";
+export declare const emptyLuaMap: <K extends AnyNotNil, V>() => ReadonlyLuaMap<K, V>;
+export declare const mutableLuaMap: <K extends AnyNotNil, V>() => LuaMap<K, V>;
+export declare const mutableWeakLuaMap: <K extends AnyNotNil, V>() => LuaMap<K, V>;
 export declare const luaMapOf: <K extends AnyNotNil, V>(...pairs: Flatten<TupleOf<[K, V], 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 | 25 | 26 | 27 | 28 | 29 | 30 | 31 | 32 | 33 | 34 | 35 | 36 | 37 | 38 | 39 | 40>>) => LuaMap<K, V>;
-export declare const luaMapInvert: <K extends AnyNotNil, V extends AnyNotNil>(luaMap: LuaMap<K, V>) => LuaMap<V, K>;
-export declare const mapValues: <K extends AnyNotNil, V1, V2>(luaMap: LuaMap<K, V1>, transform: (value: V1) => V2) => LuaMap<K, V2>;
+export declare const luaMapInvert: <K extends AnyNotNil, V extends AnyNotNil>(luaMap: ReadonlyLuaMap<K, V | undefined | null>) => LuaMap<V, K>;
+export declare const toLuaMap: <K extends PropertyKey, V>(record: Record<K, V>) => LuaMap<K, V>;
+export declare const flattenKeys: <K extends AnyNotNil, V>(luaMap: ReadonlyLuaMap<readonly K[], V> | ReadonlyLuaMap<K[], V>) => LuaMap<K, V>;
+export declare const mapKeys: {
+    <K1 extends AnyNotNil, K2 extends AnyNotNil, V>(luaMap: ReadonlyLuaMap<K1, V>, transform: (value: K1) => K2): LuaMap<K2, V>;
+    <K1 extends AnyNotNil, K2 extends keyof K1, V>(luaMap: ReadonlyLuaMap<K1, V>, key: K2): K1[K2] extends AnyNotNil ? LuaMap<K1[K2], V> : never;
+};
+export declare const mapValues: {
+    <K extends AnyNotNil, V1, V2>(luaMap: ReadonlyLuaMap<K, V1>, transform: (value: V1) => V2): LuaMap<K, V2>;
+    <K extends AnyNotNil, V1, V2 extends keyof V1>(luaMap: ReadonlyLuaMap<K, V1>, key: V2): LuaMap<K, V1[V2]>;
+};
+export declare const getOrPut: <K extends AnyNotNil, V>(luaMap: LuaMap<K, V>, key: K, defaultValue: () => V) => V;

package/utility/lua-maps.lua

@@ -1,5 +1,17 @@
 local ____exports = {}
 local select = _G.select
+local setmetatable = _G.setmetatable
+local weakKeysMetatable = {__mode = "k"}
+local EMPTY_LUA_MAP = {}
+____exports.emptyLuaMap = function()
+    return EMPTY_LUA_MAP
+end
+____exports.mutableLuaMap = function()
+    return {}
+end
+____exports.mutableWeakLuaMap = function()
+    return setmetatable({}, weakKeysMetatable)
+end
 ____exports.luaMapOf = function(...)
     local luaMap = {}
     for i = 1, select("#", ...), 2 do
@@ -15,11 +27,50 @@ ____exports.luaMapInvert = function(luaMap)
     end
     return invertLuaMap
 end
+____exports.toLuaMap = function(record)
+    return record
+end
+____exports.flattenKeys = function(luaMap)
+    local result = {}
+    for keys, value in pairs(luaMap) do
+        for ____, key in ipairs(keys) do
+            result[key] = value
+        end
+    end
+    return result
+end
+____exports.mapKeys = function(luaMap, transform)
+    local result = {}
+    if type(transform) == "function" then
+        for key, value in pairs(luaMap) do
+            result[transform(key)] = value
+        end
+    else
+        for key, value in pairs(luaMap) do
+            result[key[transform]] = value
+        end
+    end
+    return result
+end
 ____exports.mapValues = function(luaMap, transform)
     local result = {}
-    for key, value in pairs(luaMap) do
-        result[key] = transform(value)
+    if type(transform) == "function" then
+        for key, value in pairs(luaMap) do
+            result[key] = transform(value)
+        end
+    else
+        for key, value in pairs(luaMap) do
+            result[key] = value[transform]
+        end
     end
     return result
 end
+____exports.getOrPut = function(luaMap, key, defaultValue)
+    local value = luaMap[key]
+    if value == nil then
+        value = defaultValue()
+        luaMap[key] = value
+    end
+    return value
+end
 return ____exports

package/utility/lua-sets.d.ts

@@ -1,4 +1,6 @@
 /** @noSelfInFile */
+export declare const emptyLuaSet: <T extends AnyNotNil>() => ReadonlyLuaSet<T>;
+export declare const mutableLuaSet: <T extends AnyNotNil>() => LuaSet<T>;
 export declare const luaSetOf: <T extends AnyNotNil>(...elements: readonly T[]) => LuaSet<T>;
 export declare const luaSetOfNotNull: <T extends AnyNotNil>(...elements: readonly (T | undefined | null)[]) => LuaSet<T>;
 export declare const luaSetIntersection: <T extends AnyNotNil>(firstLuaSet: ReadonlyLuaSet<T>, secondLuaSet: ReadonlyLuaSet<T>) => LuaSet<T>;

package/utility/lua-sets.lua

@@ -1,5 +1,12 @@
 local ____exports = {}
 local select = _G.select
+local EMPTY_LUA_SET = {}
+____exports.emptyLuaSet = function()
+    return EMPTY_LUA_SET
+end
+____exports.mutableLuaSet = function()
+    return {}
+end
 ____exports.luaSetOf = function(...)
     local luaSet = {}
     for i = 1, select("#", ...) do

package/utility/reflection.lua

@@ -5,21 +5,25 @@ 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 originalIndex = checkNotNull(rawget(metatable, "__index"))
     local memoizedValueByKey = {}
-    metatable.__index = setmetatable(
-        memoizedValueByKey,
-        {__index = function(self, key)
+    rawset(
+        metatable,
+        "__index",
+        function(self, key)
             if type(key) == "number" then
-                local value = supplier(key)
-                memoizedValueByKey[key] = value
+                local value = memoizedValueByKey[key]
+                if value == nil then
+                    value = supplier(key)
+                    memoizedValueByKey[key] = value
+                end
                 return value
             end
             if type(originalIndex) == "function" then
                 return originalIndex(self, key)
             end
             return originalIndex[key]
-        end}
+        end
     )
 end
 ____exports.getClass = function(object)

package/utility/types.d.ts

@@ -37,4 +37,7 @@ export type Flatten<T extends readonly any[], A extends readonly any[] = []> = T
 export type Prohibit<T, K extends keyof any> = T & {
     [P in K]?: never;
 };
+type TupleSplit<T, N extends number, O extends readonly any[] = readonly []> = O["length"] extends N ? [O, T] : T extends readonly [infer F, ...infer R] ? TupleSplit<readonly [...R], N, readonly [...O, F]> : [O, T];
+export type TakeFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[0];
+export type SkipFirst<T extends readonly any[], N extends number> = TupleSplit<T, N>[1];
 export {};

package/core/types/order.d.ts

@@ -1,25 +0,0 @@
-/** @noSelfInFile */
-import { Unit } from "./unit";
-import { Item } from "./item";
-import { Destructable } from "./destructable";
-export type Order = {
-    id: number;
-    startX: number;
-    startY: number;
-} & ({
-    type: "immediate";
-} | {
-    type: "point";
-    targetX: number;
-    targetY: number;
-} | {
-    type: "target";
-    target: Unit | Item | Destructable;
-});
-declare module "../../engine/internal/unit" {
-    interface Unit {
-        readonly currentOrder: Order;
-        readonly lastOrder: Order;
-        issueOrder(order: Order): void;
-    }
-}

package/core/types/order.lua

@@ -1,55 +0,0 @@
-local ____lualib = require("lualib_bundle")
-local __TS__ObjectDefineProperty = ____lualib.__TS__ObjectDefineProperty
-local ____exports = {}
-local ____unit = require("core.types.unit")
-local Unit = ____unit.Unit
-local getUnitCurrentOrder = GetUnitCurrentOrder
-local orders = setmetatable({}, {__mode = "k"})
-Unit.onImmediateOrder:addListener(function(unit, orderId)
-    orders[unit] = {id = orderId, startX = unit.x, startY = unit.y, type = "immediate"}
-end)
-Unit.onPointOrder:addListener(function(unit, orderId, x, y)
-    orders[unit] = {
-        id = orderId,
-        startX = unit.x,
-        startY = unit.y,
-        type = "point",
-        targetX = x,
-        targetY = y
-    }
-end)
-Unit.onTargetOrder:addListener(function(unit, orderId, target)
-    orders[unit] = {
-        id = orderId,
-        startX = unit.x,
-        startY = unit.y,
-        type = "target",
-        target = target
-    }
-end)
-__TS__ObjectDefineProperty(
-    Unit.prototype,
-    "currentOrder",
-    {get = function(self)
-        local currentOrderId = getUnitCurrentOrder(self.handle)
-        local lastOrder = orders[self]
-        return lastOrder and (lastOrder.id == currentOrderId or currentOrderId == orderId("patrolAI") and lastOrder.id == orderId("patrol")) and lastOrder or ({id = 0, type = "immediate"})
-    end}
-)
-__TS__ObjectDefineProperty(
-    Unit.prototype,
-    "lastOrder",
-    {get = function(self)
-        return orders[self] or ({id = 0, type = "immediate"})
-    end}
-)
-Unit.prototype.issueOrder = function(self, order)
-    if order.type == "immediate" then
-        IssueImmediateOrderById(self.handle, order.id)
-    elseif order.type == "point" then
-        IssuePointOrderById(self.handle, order.id, order.targetX, order.targetY)
-    else
-        IssueTargetOrderById(self.handle, order.id, order.target.handle)
-    end
-end
-return ____exports