wuira 0.2.3 → 0.2.5

package/lib/datasources/GroupRoster.lua

@@ -0,0 +1,611 @@
+--[[ Generated with https://github.com/TypeScriptToLua/TypeScriptToLua ]]
+-- Lua Library inline imports
+local __TS__StringReplace
+do
+    local sub = string.sub
+    function __TS__StringReplace(source, searchValue, replaceValue)
+        local startPos, endPos = string.find(source, searchValue, nil, true)
+        if not startPos then
+            return source
+        end
+        local before = sub(source, 1, startPos - 1)
+        local replacement = type(replaceValue) == "string" and replaceValue or replaceValue(nil, searchValue, startPos - 1, source)
+        local after = sub(source, endPos + 1)
+        return (before .. replacement) .. after
+    end
+end
+
+local function __TS__Class(self)
+    local c = {prototype = {}}
+    c.prototype.__index = c.prototype
+    c.prototype.constructor = c
+    return c
+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__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+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 Map
+do
+    Map = __TS__Class()
+    Map.name = "Map"
+    function Map.prototype.____constructor(self, entries)
+        self[Symbol.toStringTag] = "Map"
+        self.items = {}
+        self.size = 0
+        self.nextKey = {}
+        self.previousKey = {}
+        if entries == nil then
+            return
+        end
+        local iterable = entries
+        if iterable[Symbol.iterator] then
+            local iterator = iterable[Symbol.iterator](iterable)
+            while true do
+                local result = iterator:next()
+                if result.done then
+                    break
+                end
+                local value = result.value
+                self:set(value[1], value[2])
+            end
+        else
+            local array = entries
+            for ____, kvp in ipairs(array) do
+                self:set(kvp[1], kvp[2])
+            end
+        end
+    end
+    function Map.prototype.clear(self)
+        self.items = {}
+        self.nextKey = {}
+        self.previousKey = {}
+        self.firstKey = nil
+        self.lastKey = nil
+        self.size = 0
+    end
+    function Map.prototype.delete(self, key)
+        local contains = self:has(key)
+        if contains then
+            self.size = self.size - 1
+            local next = self.nextKey[key]
+            local previous = self.previousKey[key]
+            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[key] = nil
+            self.previousKey[key] = nil
+        end
+        self.items[key] = nil
+        return contains
+    end
+    function Map.prototype.forEach(self, callback)
+        for ____, key in __TS__Iterator(self:keys()) do
+            callback(nil, self.items[key], key, self)
+        end
+    end
+    function Map.prototype.get(self, key)
+        return self.items[key]
+    end
+    function Map.prototype.has(self, key)
+        return self.nextKey[key] ~= nil or self.lastKey == key
+    end
+    function Map.prototype.set(self, key, value)
+        local isNewValue = not self:has(key)
+        if isNewValue then
+            self.size = self.size + 1
+        end
+        self.items[key] = value
+        if self.firstKey == nil then
+            self.firstKey = key
+            self.lastKey = key
+        elseif isNewValue then
+            self.nextKey[self.lastKey] = key
+            self.previousKey[key] = self.lastKey
+            self.lastKey = key
+        end
+        return self
+    end
+    Map.prototype[Symbol.iterator] = function(self)
+        return self:entries()
+    end
+    function Map.prototype.entries(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local items = self.items
+        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, items[key]}}
+            end
+        }
+    end
+    function Map.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 Map.prototype.values(self)
+        local function getFirstKey()
+            return self.firstKey
+        end
+        local items = self.items
+        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 = items[key]}
+            end
+        }
+    end
+    Map[Symbol.species] = Map
+end
+
+local __TS__Unpack = table.unpack or unpack
+
+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__Number(value)
+    local valueType = type(value)
+    if valueType == "number" then
+        return value
+    elseif valueType == "string" then
+        local numberValue = tonumber(value)
+        if numberValue then
+            return numberValue
+        end
+        if value == "Infinity" then
+            return math.huge
+        end
+        if value == "-Infinity" then
+            return -math.huge
+        end
+        local stringWithoutSpaces = string.gsub(value, "%s", "")
+        if stringWithoutSpaces == "" then
+            return 0
+        end
+        return 0 / 0
+    elseif valueType == "boolean" then
+        return value and 1 or 0
+    else
+        return 0 / 0
+    end
+end
+
+local function __TS__ArraySort(self, compareFn)
+    if compareFn ~= nil then
+        table.sort(
+            self,
+            function(a, b) return compareFn(nil, a, b) < 0 end
+        )
+    else
+        table.sort(self)
+    end
+    return self
+end
+
+local function __TS__StringStartsWith(self, searchString, position)
+    if position == nil or position < 0 then
+        position = 0
+    end
+    return string.sub(self, position + 1, #searchString + position) == searchString
+end
+
+local function __TS__CloneDescriptor(____bindingPattern0)
+    local value
+    local writable
+    local set
+    local get
+    local configurable
+    local enumerable
+    enumerable = ____bindingPattern0.enumerable
+    configurable = ____bindingPattern0.configurable
+    get = ____bindingPattern0.get
+    set = ____bindingPattern0.set
+    writable = ____bindingPattern0.writable
+    value = ____bindingPattern0.value
+    local descriptor = {enumerable = enumerable == true, configurable = configurable == true}
+    local hasGetterOrSetter = get ~= nil or set ~= nil
+    local hasValueOrWritableAttribute = writable ~= nil or value ~= nil
+    if hasGetterOrSetter and hasValueOrWritableAttribute then
+        error("Invalid property descriptor. Cannot both specify accessors and a value or writable attribute.", 0)
+    end
+    if get or set then
+        descriptor.get = get
+        descriptor.set = set
+    else
+        descriptor.value = value
+        descriptor.writable = writable == true
+    end
+    return descriptor
+end
+
+local __TS__DescriptorGet
+do
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    function __TS__DescriptorGet(self, metatable, key)
+        while metatable do
+            local rawResult = ____rawget(metatable, key)
+            if rawResult ~= nil then
+                return rawResult
+            end
+            local descriptors = ____rawget(metatable, "_descriptors")
+            if descriptors then
+                local descriptor = descriptors[key]
+                if descriptor ~= nil then
+                    if descriptor.get then
+                        return descriptor.get(self)
+                    end
+                    return descriptor.value
+                end
+            end
+            metatable = getmetatable(metatable)
+        end
+    end
+end
+
+local __TS__DescriptorSet
+do
+    local getmetatable = _G.getmetatable
+    local ____rawget = _G.rawget
+    local rawset = _G.rawset
+    function __TS__DescriptorSet(self, metatable, key, value)
+        while metatable do
+            local descriptors = ____rawget(metatable, "_descriptors")
+            if descriptors then
+                local descriptor = descriptors[key]
+                if descriptor ~= nil then
+                    if descriptor.set then
+                        descriptor.set(self, value)
+                    else
+                        if descriptor.writable == false then
+                            error(
+                                ((("Cannot assign to read only property '" .. key) .. "' of object '") .. tostring(self)) .. "'",
+                                0
+                            )
+                        end
+                        descriptor.value = value
+                    end
+                    return
+                end
+            end
+            metatable = getmetatable(metatable)
+        end
+        rawset(self, key, value)
+    end
+end
+
+local __TS__SetDescriptor
+do
+    local getmetatable = _G.getmetatable
+    local function descriptorIndex(self, key)
+        return __TS__DescriptorGet(
+            self,
+            getmetatable(self),
+            key
+        )
+    end
+    local function descriptorNewIndex(self, key, value)
+        return __TS__DescriptorSet(
+            self,
+            getmetatable(self),
+            key,
+            value
+        )
+    end
+    function __TS__SetDescriptor(target, key, desc, isPrototype)
+        if isPrototype == nil then
+            isPrototype = false
+        end
+        local ____isPrototype_0
+        if isPrototype then
+            ____isPrototype_0 = target
+        else
+            ____isPrototype_0 = getmetatable(target)
+        end
+        local metatable = ____isPrototype_0
+        if not metatable then
+            metatable = {}
+            setmetatable(target, metatable)
+        end
+        if not isPrototype and not rawget(metatable, "_isOwnDescriptorMetatable") then
+            local instanceMetatable = {}
+            instanceMetatable._isOwnDescriptorMetatable = true
+            setmetatable(instanceMetatable, metatable)
+            setmetatable(target, instanceMetatable)
+            metatable = instanceMetatable
+        end
+        local value = rawget(target, key)
+        if value ~= nil then
+            rawset(target, key, nil)
+        end
+        if not rawget(metatable, "_descriptors") then
+            metatable._descriptors = {}
+        end
+        metatable._descriptors[key] = __TS__CloneDescriptor(desc)
+        metatable.__index = descriptorIndex
+        metatable.__newindex = descriptorNewIndex
+    end
+end
+-- End of Lua Library inline imports
+local ____exports = {}
+local ____DataSource = require("datasources.DataSource")
+local DataSource = ____DataSource.DataSource
+local ____GroupMembers = require("datasources.GroupMembers")
+local GroupMembers = ____GroupMembers.GroupMembers
+function ____exports.getPetUnitToken(self, unit)
+    if unit == "player" then
+        return "pet"
+    end
+    return __TS__StringReplace(
+        __TS__StringReplace(unit, "party", "partypet"),
+        "raid",
+        "raidpet"
+    )
+end
+--- Small snapshots describe identity/order only; keyed rendering owns widgets and unit sources.
+____exports.GroupRoster = __TS__Class()
+local GroupRoster = ____exports.GroupRoster
+GroupRoster.name = "GroupRoster"
+__TS__ClassExtends(GroupRoster, DataSource)
+function GroupRoster.prototype.____constructor(self, scope, options)
+    if scope == nil then
+        scope = "auto"
+    end
+    if options == nil then
+        options = {}
+    end
+    DataSource.prototype.____constructor(self, {})
+    self.scope = scope
+    self.options = options
+    self.knownNames = __TS__New(Map)
+    self.snapshot = {}
+    self.restricted = false
+    self.roster = __TS__New(GroupMembers, scope)
+end
+function GroupRoster.prototype.GetValue(self)
+    self.restricted = self.roster:IsSecret()
+    if self.restricted then
+        return self.snapshot
+    end
+    local units = {__TS__Unpack(self.roster.Value)}
+    if #units == 0 and self.options.includeSelfWhenSolo then
+        units = {"player"}
+    end
+    local members = __TS__ArrayMap(
+        units,
+        function(____, unit) return self:Read(unit, false) end
+    )
+    if self.scope == "raid" then
+        __TS__ArraySort(
+            members,
+            function(____, a, b) return __TS__Number(a.group) - __TS__Number(b.group) or __TS__Number(string.sub(a.unit, 5)) - __TS__Number(string.sub(b.unit, 5)) end
+        )
+    end
+    if self.options.pets then
+        for ____, unit in ipairs(units) do
+            local pet = ____exports.getPetUnitToken(nil, unit)
+            local exists = UnitExists(pet)
+            if not issecretvalue(exists) and exists then
+                members[#members + 1] = self:Read(pet, true)
+            end
+        end
+    end
+    self.snapshot = members
+    return members
+end
+function GroupRoster.prototype.Read(self, unit, pet)
+    local rawGUID = UnitGUID(unit)
+    local ____issecretvalue_result_0
+    if issecretvalue(rawGUID) then
+        ____issecretvalue_result_0 = nil
+    else
+        ____issecretvalue_result_0 = rawGUID
+    end
+    local guid = ____issecretvalue_result_0
+    local rawName, rawRealm = UnitFullName(unit)
+    local ____temp_1
+    if issecretvalue(rawName) or issecretvalue(rawRealm) or rawName == nil then
+        ____temp_1 = nil
+    else
+        ____temp_1 = (rawName .. "-") .. (rawRealm or "")
+    end
+    local fullName = ____temp_1
+    if pet and fullName ~= nil then
+        local owner = unit == "pet" and "player" or __TS__StringReplace(
+            __TS__StringReplace(unit, "partypet", "party"),
+            "raidpet",
+            "raid"
+        )
+        local name, realm = UnitFullName(owner)
+        fullName = ((not issecretvalue(name) and not issecretvalue(realm) and name ~= nil and (name .. "-") .. (realm or "") or owner) .. "/") .. fullName
+    end
+    if guid ~= nil and fullName ~= nil then
+        self.knownNames:set(fullName, guid)
+    end
+    local ____guid_3 = guid
+    if ____guid_3 == nil then
+        local ____temp_2
+        if fullName == nil then
+            ____temp_2 = nil
+        else
+            ____temp_2 = self.knownNames:get(fullName)
+        end
+        ____guid_3 = ____temp_2
+    end
+    local identity = ____guid_3
+    local group = "1"
+    if __TS__StringStartsWith(unit, "raid") and not pet then
+        local ____, ____, subgroup = GetRaidRosterInfo(__TS__Number(string.sub(unit, 5)))
+        if not issecretvalue(subgroup) and subgroup ~= nil and subgroup >= 1 and subgroup <= 8 then
+            group = tostring(subgroup)
+        end
+    end
+    return {
+        key = identity == nil and "name:" .. (fullName or unit) or "guid:" .. identity,
+        guid = guid,
+        unit = unit,
+        pet = pet,
+        group = group
+    }
+end
+function GroupRoster.prototype.onChange(self, listener)
+    return self.roster:onChange(function() return listener(nil, self.Value) end)
+end
+function GroupRoster.prototype.Dispose(self)
+    self.roster:Dispose()
+    self.knownNames:clear()
+    self.snapshot = {}
+end
+__TS__SetDescriptor(
+    GroupRoster.prototype,
+    "Status",
+    {get = function(self)
+        return self.restricted and "restricted" or "ready"
+    end},
+    true
+)
+return ____exports

package/lib/datasources/MathConverter.d.ts

@@ -0,0 +1,6 @@
+import { SourceConverter } from "./SourceConverter";
+import type { ValueSource } from "./SourceConverter";
+export declare class MathConverter extends SourceConverter<number, number> {
+    constructor(input: ValueSource<number>, expression: string);
+    static Validate(expression: string): void;
+}

package/lib/datasources/MathConverter.lua

@@ -0,0 +1,61 @@
+--[[ 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 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__New(target, ...)
+    local instance = setmetatable({}, target.prototype)
+    instance:____constructor(...)
+    return instance
+end
+-- End of Lua Library inline imports
+local ____exports = {}
+local ____SourceConverter = require("datasources.SourceConverter")
+local SourceConverter = ____SourceConverter.SourceConverter
+local ____MathExpression = require("datasources.MathExpression")
+local MathExpression = ____MathExpression.MathExpression
+____exports.MathConverter = __TS__Class()
+local MathConverter = ____exports.MathConverter
+MathConverter.name = "MathConverter"
+__TS__ClassExtends(MathConverter, SourceConverter)
+function MathConverter.prototype.____constructor(self, input, expression)
+    local formula = __TS__New(MathExpression, expression)
+    SourceConverter.prototype.____constructor(
+        self,
+        input,
+        function(____, value) return formula:Evaluate(value) end
+    )
+end
+function MathConverter.Validate(self, expression)
+    __TS__New(MathExpression, expression)
+end
+return ____exports

package/lib/datasources/MathExpression.d.ts

@@ -0,0 +1,16 @@
+/** Small bounded arithmetic grammar. Expressions cannot call functions or execute Lua. */
+export declare class MathExpression {
+    private readonly text;
+    private offset;
+    private token;
+    private tokens;
+    private readonly tree;
+    constructor(text: string);
+    private Next;
+    private Depth;
+    private Add;
+    private Multiply;
+    private Unary;
+    private Primary;
+    Evaluate(input: number): number;
+}