wuira 0.2.4 → 0.2.5

package/lib/datasources/SourceConverter.lua

@@ -0,0 +1,568 @@
+--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
+-- Lua Library inline imports
+local function __TS__Class(self)
+    local c = {prototype = {}}
+    c.prototype.__index = c.prototype
+    c.prototype.constructor = c
+    return c
+end
+
+local __TS__Symbol, Symbol
+do
+    local symbolMetatable = {__tostring = function(self)
+        return ("Symbol(" .. (self.description or "")) .. ")"
+    end}
+    function __TS__Symbol(description)
+        return setmetatable({description = description}, symbolMetatable)
+    end
+    Symbol = {
+        asyncDispose = __TS__Symbol("Symbol.asyncDispose"),
+        dispose = __TS__Symbol("Symbol.dispose"),
+        iterator = __TS__Symbol("Symbol.iterator"),
+        hasInstance = __TS__Symbol("Symbol.hasInstance"),
+        species = __TS__Symbol("Symbol.species"),
+        toStringTag = __TS__Symbol("Symbol.toStringTag")
+    }
+end
+
+local __TS__Iterator
+do
+    local function iteratorGeneratorStep(self)
+        local co = self.____coroutine
+        local status, value = coroutine.resume(co)
+        if not status then
+            error(value, 0)
+        end
+        if coroutine.status(co) == "dead" then
+            return
+        end
+        return true, value
+    end
+    local function iteratorIteratorStep(self)
+        local result = self:next()
+        if result.done then
+            return
+        end
+        return true, result.value
+    end
+    local function iteratorStringStep(self, index)
+        index = index + 1
+        if index > #self then
+            return
+        end
+        return index, string.sub(self, index, index)
+    end
+    function __TS__Iterator(iterable)
+        if type(iterable) == "string" then
+            return iteratorStringStep, iterable, 0
+        elseif iterable.____coroutine ~= nil then
+            return iteratorGeneratorStep, iterable
+        elseif iterable[Symbol.iterator] then
+            local iterator = iterable[Symbol.iterator](iterable)
+            return iteratorIteratorStep, iterator
+        else
+            return ipairs(iterable)
+        end
+    end
+end
+
+local function __TS__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+
+local Set
+do
+    Set = __TS__Class()
+    Set.name = "Set"
+    function Set.prototype.____constructor(self, values)
+        self[Symbol.toStringTag] = "Set"
+        self.size = 0
+        self.nextKey = {}
+        self.previousKey = {}
+        if values == nil then
+            return
+        end
+        local iterable = values
+        if iterable[Symbol.iterator] then
+            local iterator = iterable[Symbol.iterator](iterable)
+            while true do
+                local result = iterator:next()
+                if result.done then
+                    break
+                end
+                self:add(result.value)
+            end
+        else
+            local array = values
+            for ____, value in ipairs(array) do
+                self:add(value)
+            end
+        end
+    end
+    function Set.prototype.add(self, value)
+        local isNewValue = not self:has(value)
+        if isNewValue then
+            self.size = self.size + 1
+        end
+        if self.firstKey == nil then
+            self.firstKey = value
+            self.lastKey = value
+        elseif isNewValue then
+            self.nextKey[self.lastKey] = value
+            self.previousKey[value] = self.lastKey
+            self.lastKey = value
+        end
+        return self
+    end
+    function Set.prototype.clear(self)
+        self.nextKey = {}
+        self.previousKey = {}
+        self.firstKey = nil
+        self.lastKey = nil
+        self.size = 0
+    end
+    function Set.prototype.delete(self, value)
+        local contains = self:has(value)
+        if contains then
+            self.size = self.size - 1
+            local next = self.nextKey[value]
+            local previous = self.previousKey[value]
+            if next ~= nil and previous ~= nil then
+                self.nextKey[previous] = next
+                self.previousKey[next] = previous
+            elseif next ~= nil then
+                self.firstKey = next
+                self.previousKey[next] = nil
+            elseif previous ~= nil then
+                self.lastKey = previous
+                self.nextKey[previous] = nil
+            else
+                self.firstKey = nil
+                self.lastKey = nil
+            end
+            self.nextKey[value] = nil
+            self.previousKey[value] = nil
+        end
+        return contains
+    end
+    function Set.prototype.forEach(self, callback)
+        for ____, key in __TS__Iterator(self:keys()) do
+            callback(nil, key, key, self)
+        end
+    end
+    function Set.prototype.has(self, value)
+        return self.nextKey[value] ~= nil or self.lastKey == value
+    end
+    Set.prototype[Symbol.iterator] = function(self)
+        return self:values()
+    end
+    function Set.prototype.entries(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = {key, key}}
+            end
+        }
+    end
+    function Set.prototype.keys(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = key}
+            end
+        }
+    end
+    function Set.prototype.values(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local nextKey = self.nextKey
+        local key
+        local started = false
+        return {
+            [Symbol.iterator] = function(self)
+                return self
+            end,
+            next = function(self)
+                if not started then
+                    started = true
+                    key = getFirstKey(nil)
+                else
+                    key = nextKey[key]
+                end
+                return {done = not key, value = key}
+            end
+        }
+    end
+    function Set.prototype.union(self, other)
+        local result = __TS__New(Set, self)
+        for ____, item in __TS__Iterator(other) do
+            result:add(item)
+        end
+        return result
+    end
+    function Set.prototype.intersection(self, other)
+        local result = __TS__New(Set)
+        for ____, item in __TS__Iterator(self) do
+            if other:has(item) then
+                result:add(item)
+            end
+        end
+        return result
+    end
+    function Set.prototype.difference(self, other)
+        local result = __TS__New(Set, self)
+        for ____, item in __TS__Iterator(other) do
+            result:delete(item)
+        end
+        return result
+    end
+    function Set.prototype.symmetricDifference(self, other)
+        local result = __TS__New(Set, self)
+        for ____, item in __TS__Iterator(other) do
+            if self:has(item) then
+                result:delete(item)
+            else
+                result:add(item)
+            end
+        end
+        return result
+    end
+    function Set.prototype.isSubsetOf(self, other)
+        for ____, item in __TS__Iterator(self) do
+            if not other:has(item) then
+                return false
+            end
+        end
+        return true
+    end
+    function Set.prototype.isSupersetOf(self, other)
+        for ____, item in __TS__Iterator(other) do
+            if not self:has(item) then
+                return false
+            end
+        end
+        return true
+    end
+    function Set.prototype.isDisjointFrom(self, other)
+        for ____, item in __TS__Iterator(self) do
+            if other:has(item) then
+                return false
+            end
+        end
+        return true
+    end
+    Set[Symbol.species] = Set
+end
+
+local function __TS__ObjectValues(obj)
+    local result = {}
+    local len = 0
+    for key in pairs(obj) do
+        len = len + 1
+        result[len] = obj[key]
+    end
+    return result
+end
+
+local function __TS__ClassExtends(target, base)
+    target.____super = base
+    local staticMetatable = setmetatable({__index = base}, base)
+    setmetatable(target, staticMetatable)
+    local baseMetatable = getmetatable(base)
+    if baseMetatable then
+        if type(baseMetatable.__index) == "function" then
+            staticMetatable.__index = baseMetatable.__index
+        end
+        if type(baseMetatable.__newindex) == "function" then
+            staticMetatable.__newindex = baseMetatable.__newindex
+        end
+    end
+    setmetatable(target.prototype, base.prototype)
+    if type(base.prototype.__index) == "function" then
+        target.prototype.__index = base.prototype.__index
+    end
+    if type(base.prototype.__newindex) == "function" then
+        target.prototype.__newindex = base.prototype.__newindex
+    end
+    if type(base.prototype.__tostring) == "function" then
+        target.prototype.__tostring = base.prototype.__tostring
+    end
+end
+
+local function __TS__ObjectAssign(target, ...)
+    local sources = {...}
+    for i = 1, #sources do
+        local source = sources[i]
+        if type(source) == "table" then
+            for key in pairs(source) do
+                target[key] = source[key]
+            end
+        end
+    end
+    return target
+end
+
+local function __TS__ArrayMap(self, callbackfn, thisArg)
+    local result = {}
+    for i = 1, #self do
+        result[i] = callbackfn(thisArg, self[i], i - 1, self)
+    end
+    return result
+end
+
+local function __TS__TypeOf(value)
+    local luaType = type(value)
+    if luaType == "table" then
+        return "object"
+    elseif luaType == "nil" then
+        return "undefined"
+    else
+        return luaType
+    end
+end
+
+local function __TS__ArrayIncludes(self, searchElement, fromIndex)
+    if fromIndex == nil then
+        fromIndex = 0
+    end
+    local len = #self
+    local k = fromIndex
+    if fromIndex < 0 then
+        k = len + fromIndex
+    end
+    if k < 0 then
+        k = 0
+    end
+    for i = k + 1, len do
+        if self[i] == searchElement then
+            return true
+        end
+    end
+    return false
+end
+
+local function __TS__NumberIsFinite(value)
+    return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
+end
+-- End of Lua Library inline imports
+local ____exports = {}
+local ____DataSource = require("datasources.DataSource")
+local DataSource = ____DataSource.DataSource
+local function restricted(self, value, seen, depth)
+    if seen == nil then
+        seen = __TS__New(Set)
+    end
+    if depth == nil then
+        depth = 0
+    end
+    if issecretvalue(value) or depth > 32 then
+        return true
+    end
+    if type(value) ~= "table" or value == nil or seen:has(value) then
+        return false
+    end
+    seen:add(value)
+    for ____, child in ipairs(__TS__ObjectValues(value)) do
+        if restricted(nil, child, seen, depth + 1) then
+            return true
+        end
+    end
+    return false
+end
+--- Checked value transformation. No timers, native widgets or ownership of the input.
+____exports.SourceConverter = __TS__Class()
+local SourceConverter = ____exports.SourceConverter
+SourceConverter.name = "SourceConverter"
+__TS__ClassExtends(SourceConverter, DataSource)
+function SourceConverter.prototype.____constructor(self, input, convert)
+    DataSource.prototype.____constructor(self, nil)
+    self.input = input
+    self.convert = convert
+    self.listeners = __TS__New(Set)
+    self.disposed = false
+    self.blocked = false
+    self.readable = false
+end
+function SourceConverter.prototype.GetValue(self)
+    if self.disposed then
+        error("SourceConverter is disposed")
+    end
+    if self.input.TryCompute ~= nil then
+        local result = self.input:TryCompute(function(____, value) return self:Convert(value) end)
+        if not result.readable then
+            self.blocked = true
+            return nil
+        end
+        return result.value
+    end
+    self.blocked = self.input:IsSecret()
+    if self.blocked then
+        return nil
+    end
+    return self:Convert(self.input.Value)
+end
+function SourceConverter.prototype.Convert(self, value)
+    self.blocked = restricted(nil, value)
+    local ____table_blocked_0
+    if self.blocked then
+        ____table_blocked_0 = nil
+    else
+        ____table_blocked_0 = self:convert(value)
+    end
+    return ____table_blocked_0
+end
+function SourceConverter.prototype.HasSecretFields(self, value)
+    return self.blocked or restricted(nil, value)
+end
+function SourceConverter.prototype.onChange(self, listener)
+    if self.disposed then
+        error("SourceConverter is disposed")
+    end
+    if self.listeners.size == 0 then
+        local value = self:GetValue()
+        self.readable = not self:HasSecretFields(value)
+        local ____table_readable_1
+        if self.readable then
+            ____table_readable_1 = value
+        else
+            ____table_readable_1 = nil
+        end
+        self.previous = ____table_readable_1
+    end
+    self.listeners:add(listener)
+    if self.listeners.size == 1 then
+        do
+            local function ____catch(failure)
+                self.listeners:delete(listener)
+                error(failure, 0)
+            end
+            local ____try, ____hasReturned = pcall(function()
+                local ____this_3
+                ____this_3 = self.input
+                local ____opt_2 = ____this_3.onChange
+                self.stop = ____opt_2 and ____opt_2(
+                    ____this_3,
+                    function() return self:Refresh() end
+                )
+            end)
+            if not ____try then
+                ____catch(____hasReturned)
+            end
+        end
+    end
+    return function()
+        self.listeners:delete(listener)
+        if self.listeners.size == 0 then
+            local ____opt_4 = self.stop
+            if ____opt_4 ~= nil then
+                ____opt_4(self)
+            end
+            self.stop = nil
+        end
+    end
+end
+function SourceConverter.prototype.Refresh(self)
+    local value = self:GetValue()
+    if self:HasSecretFields(value) then
+        self.readable = false
+        return
+    end
+    local same = self.readable and value == self.previous
+    self.previous = value
+    self.readable = true
+    if not same and self:CanEmit(value) then
+        for ____, listener in __TS__Iterator(self.listeners) do
+            listener(nil, value)
+        end
+    end
+end
+function SourceConverter.prototype.BindTo(self, apply)
+    if not self:IsSecret() then
+        local value = self.Value
+        if self:CanEmit(value) then
+            apply(nil, value)
+        end
+    end
+    return self:onChange(apply)
+end
+function SourceConverter.prototype.Dispose(self)
+    if self.disposed then
+        return
+    end
+    self.disposed = true
+    local ____opt_6 = self.stop
+    if ____opt_6 ~= nil then
+        ____opt_6(self)
+    end
+    self.stop = nil
+    self.listeners:clear()
+end
+--- Strict equality, first matching case, then the optional default value.
+____exports.CaseConverter = __TS__Class()
+local CaseConverter = ____exports.CaseConverter
+CaseConverter.name = "CaseConverter"
+__TS__ClassExtends(CaseConverter, ____exports.SourceConverter)
+function CaseConverter.prototype.____constructor(self, input, cases, fallback)
+    local entries = __TS__ArrayMap(
+        cases,
+        function(____, entry) return __TS__ObjectAssign({}, entry) end
+    )
+    local seen = __TS__New(Set)
+    for ____, entry in ipairs(entries) do
+        local key = entry.equals
+        if issecretvalue(key) or not __TS__ArrayIncludes(
+            {"string", "number", "boolean"},
+            __TS__TypeOf(key)
+        ) or type(key) == "number" and not __TS__NumberIsFinite(key) then
+            error("CaseConverter: invalid match value")
+        end
+        if seen:has(key) then
+            error("CaseConverter: duplicate match value")
+        end
+        seen:add(key)
+    end
+    CaseConverter.____super.prototype.____constructor(
+        self,
+        input,
+        function(____, value)
+            for ____, entry in ipairs(entries) do
+                if value == entry.equals then
+                    return entry.value
+                end
+            end
+            return fallback
+        end
+    )
+end
+return ____exports

package/lib/datasources/UnitInfo.d.ts

@@ -8,11 +8,17 @@ export interface ClassInfo {
 }
 export declare class ClassSource extends DataSource<ClassInfo | undefined> {
     private restricted;
+    private readonly listeners;
+    private events?;
+    private stopUnit?;
     readonly target: UnitSource;
     constructor(unit: UnitInput);
     get unit(): string;
     protected HasSecretFields(): boolean;
     protected GetValue(): ClassInfo | undefined;
+    onChange(listener: (value: ClassInfo | undefined) => void): () => void;
+    private StopListening;
+    Dispose(): void;
 }
 export interface SpecializationInfo {
     readonly id: number;