wuira 0.2.1 → 0.2.3

package/CHANGELOG.md

@@ -7,6 +7,29 @@ with the release date and highlight breaking changes explicitly.
 
 ## Unreleased
 
+## 0.2.3 — 2026-10-15
+
+### Added
+
+- Tooltip attachment in Cell decorations, inherited by all visual components.
+  Route hover to native GameTooltip or another native tooltip with custom text,
+  extra lines or a callback using native spell, item, unit, hyperlink and action APIs.
+- Motion-only hover input preserves click-through behavior and existing scripts;
+  owned tooltips close on leave, hide and disposal without changing secure actions.
+
+## 0.2.2 — 2026-10-15
+
+### Added
+
+- Event-driven EditModeLayouts source with native layout metadata, active layout,
+  availability status and disposable change subscriptions. Layout keys use native
+  type, interface style and name; indices are not persistent IDs.
+
+### Fixed
+
+- Keep generated spell files in LF format on Windows checkouts so deterministic
+  generation checks compare identical bytes across operating systems.
+
 ## 0.2.1 — 2026-10-15
 
 ### Changed

package/README.md

@@ -507,6 +507,23 @@ event listener when its owning feature ends. Support is capability-checked;
 actual timing still needs validation in Forever. The adapter follows the
 [Forever swing API definition](https://github.com/Gethe/wow-ui-source/blob/bd2470aed543f72697a044e989285b6c83e63f73/Interface/AddOns/Blizzard_APIDocumentationGenerated/SwingTimerDocumentation.lua).
 
+### Native Edit Mode layouts
+
+```ts
+import { EditModeLayouts } from "wuira/datasources";
+
+const layouts = new EditModeLayouts();
+console.log(layouts.Active?.name);
+const stop = layouts.onChange(snapshot => console.log(snapshot.active?.key));
+// On teardown: stop(); layouts.Dispose();
+```
+
+`Layouts` lists native indices, names, types and derived keys. `Value` is a detached
+snapshot; native events refresh it without polling. Check `Status` for availability.
+Forever exposes an index rather than a persistent UUID: `key` combines type,
+interface style and name, survives index shifts, and changes on rename. These keys
+describe local game layouts, not portable layout exports.
+
 ### Group members
 
 ```ts
@@ -593,6 +610,30 @@ not install event listeners or poll automatically. The current adapter requires
 in-game verification. Unit tokens refer to snapshot time and are not persistent
 caster identities. No Paladin-specific spell catalog or filtering is built in.
 
+### Native tooltips
+
+`Tooltip` attaches to any Cell through decorations. It forwards hover to the
+game's native tooltip API and creates no visual regions or update loop.
+
+```tsx
+import { Cell, Tooltip } from "wuira/ui";
+
+<Cell width={40} height={40} decorations={{
+    tooltip: new Tooltip({ text: "My tooltip", lines: [{ text: "Extra details" }] }),
+}} />;
+
+<Cell width={40} height={40} decorations={{
+    tooltip: new Tooltip({ show: tooltip => tooltip.SetSpellByID(635) }),
+}} />;
+```
+
+The same attachment works on SecureButton. Call SetItemByID, SetUnit, SetHyperlink
+or SetAction inside `show` for other native content. `text` may be a function
+evaluated on hover; `show` may return false to suppress display. Optional `target`
+selects another native tooltip, and `anchor` defaults to ANCHOR_RIGHT.
+Hover preserves click-through and existing scripts. Leave, hide and unmount close
+only a tooltip still owned by that Cell. Use one decoration instance per Cell.
+
 ### Visual styling
 
 <!-- Screenshot: a dark Cell with a thin colored border. -->

package/lib/datasources/EditModeLayouts.d.ts

@@ -0,0 +1,33 @@
+import { DataSource } from "./DataSource";
+export type EditModeLayoutsStatus = "ready" | "unavailable" | "restricted";
+export interface EditModeLayout {
+    /** Native one-based index. Deleting another layout can change this number. */
+    readonly index: number;
+    readonly name: string;
+    readonly type: number;
+    readonly interfaceStyle?: number;
+    /** Derived from native type, interface style and name; changes on rename. */
+    readonly key: string;
+}
+export interface EditModeLayoutSnapshot {
+    readonly layouts: readonly EditModeLayout[];
+    readonly active?: EditModeLayout;
+}
+/** Read-only native Edit Mode layouts, refreshed by events without polling. */
+export declare class EditModeLayouts extends DataSource<EditModeLayoutSnapshot> {
+    private snapshot;
+    private status;
+    private readonly listeners;
+    private readonly frame;
+    private disposed;
+    constructor();
+    get Status(): EditModeLayoutsStatus;
+    get Layouts(): readonly EditModeLayout[];
+    get Active(): EditModeLayout | undefined;
+    protected HasSecretFields(): boolean;
+    protected GetValue(): EditModeLayoutSnapshot;
+    /** No initial emission. Availability changes also notify observers. */
+    onChange(listener: (value: EditModeLayoutSnapshot) => void): () => void;
+    private Refresh;
+    Dispose(): void;
+}

package/lib/datasources/EditModeLayouts.lua

@@ -0,0 +1,689 @@
+--[[ 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 __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__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__ArrayIsArray(value)
+    return type(value) == "table" and (value[1] ~= nil or next(value) == nil)
+end
+
+local function __TS__NumberIsFinite(value)
+    return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
+end
+
+local function __TS__NumberIsInteger(value)
+    return __TS__NumberIsFinite(value) and math.floor(value) == value
+end
+
+local __TS__ArrayFrom
+do
+    local function arrayLikeStep(self, index)
+        index = index + 1
+        if index > self.length then
+            return
+        end
+        return index, self[index]
+    end
+    local function arrayLikeIterator(arr)
+        if type(arr.length) == "number" then
+            return arrayLikeStep, arr, 0
+        end
+        return __TS__Iterator(arr)
+    end
+    function __TS__ArrayFrom(arrayLike, mapFn, thisArg)
+        local result = {}
+        if mapFn == nil then
+            for ____, v in arrayLikeIterator(arrayLike) do
+                result[#result + 1] = v
+            end
+        else
+            local i = 0
+            for ____, v in arrayLikeIterator(arrayLike) do
+                local ____mapFn_3 = mapFn
+                local ____thisArg_1 = thisArg
+                local ____v_2 = v
+                local ____i_0 = i
+                i = ____i_0 + 1
+                result[#result + 1] = ____mapFn_3(____thisArg_1, ____v_2, ____i_0)
+            end
+        end
+        return result
+    end
+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
+--- Read-only native Edit Mode layouts, refreshed by events without polling.
+____exports.EditModeLayouts = __TS__Class()
+local EditModeLayouts = ____exports.EditModeLayouts
+EditModeLayouts.name = "EditModeLayouts"
+__TS__ClassExtends(EditModeLayouts, DataSource)
+function EditModeLayouts.prototype.____constructor(self)
+    DataSource.prototype.____constructor(self, {layouts = {}})
+    self.snapshot = {layouts = {}}
+    self.status = "unavailable"
+    self.listeners = __TS__New(Set)
+    self.disposed = false
+    self.frame = CreateFrame("Frame", nil, UIParent)
+    for ____, event in ipairs({"EDIT_MODE_LAYOUTS_UPDATED", "PLAYER_ENTERING_WORLD", "PLAYER_SPECIALIZATION_CHANGED"}) do
+        self.frame:RegisterEvent(event)
+    end
+    self.frame:SetScript(
+        "OnEvent",
+        function(_frame, event, value)
+            local ____self_Refresh_1 = self.Refresh
+            local ____temp_0
+            if event == "EDIT_MODE_LAYOUTS_UPDATED" then
+                ____temp_0 = value
+            else
+                ____temp_0 = nil
+            end
+            return ____self_Refresh_1(self, ____temp_0)
+        end
+    )
+    self:Refresh()
+end
+function EditModeLayouts.prototype.HasSecretFields(self)
+    return self.status == "restricted"
+end
+function EditModeLayouts.prototype.GetValue(self)
+    local ____TS__ArrayMap_result_3 = __TS__ArrayMap(
+        self.snapshot.layouts,
+        function(____, layout) return __TS__ObjectAssign({}, layout) end
+    )
+    local ____temp_2
+    if self.snapshot.active == nil then
+        ____temp_2 = nil
+    else
+        ____temp_2 = __TS__ObjectAssign({}, self.snapshot.active)
+    end
+    return {layouts = ____TS__ArrayMap_result_3, active = ____temp_2}
+end
+function EditModeLayouts.prototype.onChange(self, listener)
+    if self.disposed then
+        error("EditModeLayouts: source is disposed")
+    end
+    self.listeners:add(listener)
+    return function()
+        self.listeners:delete(listener)
+    end
+end
+function EditModeLayouts.prototype.Refresh(self, value)
+    local function signature()
+        local ____temp_6 = ((self.status .. "|") .. table.concat(
+            __TS__ArrayMap(
+                self.snapshot.layouts,
+                function(____, layout) return (((tostring(layout.index) .. ":") .. tostring(#layout.key)) .. ":") .. layout.key end
+            ),
+            "|"
+        )) .. "|active:"
+        local ____opt_4 = self.snapshot.active
+        return ____temp_6 .. tostring(____opt_4 and ____opt_4.index or "")
+    end
+    local previous = signature(nil)
+    self.snapshot = {layouts = {}}
+    self.status = "unavailable"
+    if value ~= nil or (C_EditMode and C_EditMode.GetLayouts) ~= nil then
+        do
+            local function ____catch()
+                self.status = "unavailable"
+            end
+            local ____try = pcall(function()
+                local ____value_13 = value
+                if ____value_13 == nil then
+                    local ____opt_9 = C_EditMode and C_EditMode.GetLayouts
+                    ____value_13 = ____opt_9 and ____opt_9()
+                end
+                local native = ____value_13
+                if issecretvalue(native) then
+                    self.status = "restricted"
+                elseif native ~= nil then
+                    if issecretvalue(native.layouts) or issecretvalue(native.activeLayout) then
+                        self.status = "restricted"
+                    elseif __TS__ArrayIsArray(native.layouts) and __TS__NumberIsInteger(native.activeLayout) and native.activeLayout > 0 then
+                        local layouts = {}
+                        self.status = "ready"
+                        do
+                            local offset = 0
+                            while offset < #native.layouts do
+                                local layout = native.layouts[offset + 1]
+                                if issecretvalue(layout) or issecretvalue(layout.layoutName) or issecretvalue(layout.layoutType) or issecretvalue(layout.interfaceStyle) then
+                                    self.status = "restricted"
+                                    break
+                                end
+                                if type(layout.layoutName) ~= "string" or not __TS__NumberIsInteger(layout.layoutType) or layout.interfaceStyle ~= nil and not __TS__NumberIsInteger(layout.interfaceStyle) then
+                                    self.status = "unavailable"
+                                    break
+                                end
+                                layouts[#layouts + 1] = {
+                                    index = offset + 1,
+                                    name = layout.layoutName,
+                                    type = layout.layoutType,
+                                    interfaceStyle = layout.interfaceStyle,
+                                    key = (((tostring(layout.layoutType) .. ":") .. tostring(layout.interfaceStyle or "")) .. ":") .. layout.layoutName
+                                }
+                                offset = offset + 1
+                            end
+                        end
+                        if self.status == "ready" then
+                            self.snapshot = {layouts = layouts, active = layouts[native.activeLayout]}
+                        end
+                    end
+                end
+            end)
+            if not ____try then
+                ____catch()
+            end
+        end
+    end
+    if signature(nil) ~= previous and (self.status ~= "ready" or self:CanEmit(self:GetValue())) then
+        for ____, listener in ipairs(__TS__ArrayFrom(self.listeners)) do
+            listener(
+                nil,
+                self:GetValue()
+            )
+        end
+    end
+end
+function EditModeLayouts.prototype.Dispose(self)
+    if self.disposed then
+        return
+    end
+    self.disposed = true
+    self.listeners:clear()
+    self.frame:UnregisterAllEvents()
+    self.frame:SetScript("OnEvent", nil)
+    self.frame:Hide()
+end
+__TS__SetDescriptor(
+    EditModeLayouts.prototype,
+    "Status",
+    {get = function(self)
+        return self.status
+    end},
+    true
+)
+__TS__SetDescriptor(
+    EditModeLayouts.prototype,
+    "Layouts",
+    {get = function(self)
+        return self.Value.layouts
+    end},
+    true
+)
+__TS__SetDescriptor(
+    EditModeLayouts.prototype,
+    "Active",
+    {get = function(self)
+        return self.Value.active
+    end},
+    true
+)
+return ____exports

package/lib/datasources/index.d.ts

@@ -1,5 +1,7 @@
 /// <reference path="../platform/forever.d.ts" />
 export { DataSource } from "./DataSource";
+export { EditModeLayouts } from "./EditModeLayouts";
+export type { EditModeLayout, EditModeLayoutSnapshot, EditModeLayoutsStatus } from "./EditModeLayouts";
 export { ProgressSource } from "./ProgressSource";
 export { HP, Mana, Unit, DataSources, HealthPrediction } from "./Resources";
 export { Aura, AuraSource, Buffs, Debuffs } from "./Auras";

package/lib/datasources/index.lua

@@ -4,6 +4,10 @@ do
     local ____DataSource = require("datasources.DataSource")
     ____exports.DataSource = ____DataSource.DataSource
 end
+do
+    local ____EditModeLayouts = require("datasources.EditModeLayouts")
+    ____exports.EditModeLayouts = ____EditModeLayouts.EditModeLayouts
+end
 do
     local ____ProgressSource = require("datasources.ProgressSource")
     ____exports.ProgressSource = ____ProgressSource.ProgressSource

package/lib/platform/forever.d.ts

@@ -50,9 +50,12 @@ interface wuiraNativeFrame {
     SetFrameLevel(level: number): void;
     CreateFontString(name: undefined, layer: "OVERLAY"): wuiraNativeFontString;
     EnableMouse(enabled: boolean): void;
+    EnableMouseMotion(enabled: boolean): void;
+    IsMouseMotionEnabled(): boolean;
     RegisterEvent(event: string): void;
     UnregisterAllEvents(): void;
     SetScript(script: "OnEvent", handler: ((this: void, frame: wuiraNativeFrame, event: string, unit?: string) => void) | undefined): void;
+    SetScript<TArgs extends unknown[]>(script: "OnEvent", handler: ((this: void, frame: wuiraNativeFrame, event: string, ...args: TArgs) => void) | undefined): void;
     SetScript(script: "OnUpdate", handler: ((this: void, frame: wuiraNativeFrame, elapsed: number) => void) | undefined): void;
     GetWidth(): number;
     GetHeight(): number;

package/lib/rendering/decorations.lua

@@ -38,5 +38,6 @@ function ____exports.renderDecorations(self, item, tree)
     end
     ____attach_16(nil, ____temp_15)
     attach(nil, decorations and decorations.glow)
+    attach(nil, decorations and decorations.tooltip)
 end
 return ____exports

package/lib/ui/decorations/Decorations.d.ts

@@ -1,8 +1,10 @@
 import type { Background } from "./Background";
 import type { Border } from "./Border";
 import type { Glow } from "./Glow";
+import type { Tooltip } from "./Tooltip";
 export interface Decorations {
     background?: Background;
     border?: Border;
     glow?: Glow;
+    tooltip?: Tooltip;
 }

package/lib/ui/decorations/Tooltip.d.ts

@@ -0,0 +1,50 @@
+import type { Color } from "../../types/Color";
+import { Decoration } from "./Decoration";
+export type TooltipAnchor = "ANCHOR_RIGHT" | "ANCHOR_LEFT" | "ANCHOR_TOP" | "ANCHOR_BOTTOM" | "ANCHOR_CURSOR" | "ANCHOR_NONE";
+/** Native GameTooltip surface passed to callbacks; no custom tooltip renderer. */
+export interface NativeTooltip {
+    SetOwner(owner: wuiraNativeFrame, anchor: TooltipAnchor): void;
+    IsOwned(owner: wuiraNativeFrame): boolean;
+    ClearLines(): void;
+    SetText(text: string, r?: number, g?: number, b?: number, alpha?: number, wrap?: boolean): void;
+    AddLine(text: string, r?: number, g?: number, b?: number, wrap?: boolean): void;
+    SetSpellByID(id: number): void;
+    SetItemByID(id: number): void;
+    SetUnit(unit: string): void;
+    SetHyperlink(link: string): void;
+    SetAction(slot: number): void;
+    Show(): void;
+    Hide(): void;
+}
+export interface TooltipLine {
+    text: string;
+    color?: Color;
+    wrap?: boolean;
+}
+interface TooltipOptions {
+    anchor?: TooltipAnchor;
+    /** Defaults to the game's shared GameTooltip; resolved on hover. */
+    target?: NativeTooltip | (() => NativeTooltip | undefined);
+    lines?: readonly TooltipLine[];
+}
+export type TooltipProps = TooltipOptions & ({
+    text: string | (() => string | undefined);
+    color?: Color;
+    wrap?: boolean;
+    show?: never;
+} | {
+    show: (tooltip: NativeTooltip, owner: wuiraNativeFrame) => void | false;
+    text?: never;
+});
+/** Attaches hover routing to a Cell. Creates no frames, textures or update loop. */
+export declare class Tooltip extends Decoration {
+    readonly props: TooltipProps;
+    private binding?;
+    private shown?;
+    constructor(props: TooltipProps);
+    protected draw(frame: wuiraNativeFrame): void;
+    private Show;
+    private Hide;
+    dispose(): void;
+}
+export {};

package/lib/ui/decorations/Tooltip.lua

@@ -0,0 +1,218 @@
+--[[ 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__CountVarargs(...)
+    return select("#", ...)
+end
+
+local function __TS__SparseArrayNew(...)
+    local sparseArray = {...}
+    sparseArray.sparseLength = __TS__CountVarargs(...)
+    return sparseArray
+end
+
+local function __TS__SparseArrayPush(sparseArray, ...)
+    local args = {...}
+    local argsLen = __TS__CountVarargs(...)
+    local listLen = sparseArray.sparseLength
+    for i = 1, argsLen do
+        sparseArray[listLen + i] = args[i]
+    end
+    sparseArray.sparseLength = listLen + argsLen
+end
+
+local function __TS__SparseArraySpread(sparseArray)
+    local _unpack = unpack or table.unpack
+    return _unpack(sparseArray, 1, sparseArray.sparseLength)
+end
+-- End of Lua Library inline imports
+local ____exports = {}
+local ____Decoration = require("ui.decorations.Decoration")
+local Decoration = ____Decoration.Decoration
+--- Attaches hover routing to a Cell. Creates no frames, textures or update loop.
+____exports.Tooltip = __TS__Class()
+local Tooltip = ____exports.Tooltip
+Tooltip.name = "Tooltip"
+__TS__ClassExtends(Tooltip, Decoration)
+function Tooltip.prototype.____constructor(self, props)
+    Decoration.prototype.____constructor(self)
+    self.props = props
+end
+function Tooltip.prototype.draw(self, frame)
+    local binding = {
+        frame = frame,
+        motion = frame:IsMouseMotionEnabled()
+    }
+    self.binding = binding
+    binding.enter = function() return self:Show(frame) end
+    binding.leave = function() return self:Hide() end
+    frame:HookScript(
+        "OnEnter",
+        function()
+            local ____opt_0 = binding.enter
+            return ____opt_0 and ____opt_0(binding)
+        end
+    )
+    frame:HookScript(
+        "OnLeave",
+        function()
+            local ____opt_2 = binding.leave
+            return ____opt_2 and ____opt_2(binding)
+        end
+    )
+    frame:HookScript(
+        "OnHide",
+        function()
+            local ____opt_4 = binding.leave
+            return ____opt_4 and ____opt_4(binding)
+        end
+    )
+    if not binding.motion then
+        frame:EnableMouseMotion(true)
+    end
+end
+function Tooltip.prototype.Show(self, owner)
+    self:Hide()
+    local target = self.props.target
+    local ____temp_6
+    if type(target) == "function" then
+        ____temp_6 = target(nil)
+    else
+        ____temp_6 = target or GameTooltip
+    end
+    local tooltip = ____temp_6
+    if tooltip == nil then
+        return
+    end
+    tooltip:SetOwner(owner, self.props.anchor or "ANCHOR_RIGHT")
+    self.shown = {tooltip = tooltip, owner = owner}
+    do
+        local function ____catch(failure)
+            self:Hide()
+            error(failure, 0)
+        end
+        local ____try, ____hasReturned, ____returnValue = pcall(function()
+            tooltip:ClearLines()
+            if self.props.show ~= nil then
+                if self.props:show(tooltip, owner) == false then
+                    self:Hide()
+                    return true
+                end
+            else
+                local ____temp_7
+                if type(self.props.text) == "function" then
+                    ____temp_7 = self.props:text()
+                else
+                    ____temp_7 = self.props.text
+                end
+                local text = ____temp_7
+                if text == nil then
+                    self:Hide()
+                    return true
+                end
+                local color = self.props.color or ({r = 1, g = 1, b = 1})
+                local ____tooltip_SetText_10 = tooltip.SetText
+                local ____array_9 = __TS__SparseArrayNew(
+                    text,
+                    color.r,
+                    color.g,
+                    color.b,
+                    color.a or 1
+                )
+                local ____self_props_wrap_8 = self.props.wrap
+                if ____self_props_wrap_8 == nil then
+                    ____self_props_wrap_8 = true
+                end
+                __TS__SparseArrayPush(____array_9, ____self_props_wrap_8)
+                ____tooltip_SetText_10(
+                    tooltip,
+                    __TS__SparseArraySpread(____array_9)
+                )
+            end
+            for ____, line in ipairs(self.props.lines or ({})) do
+                local color = line.color or ({r = 1, g = 1, b = 1})
+                local ____tooltip_AddLine_13 = tooltip.AddLine
+                local ____array_12 = __TS__SparseArrayNew(line.text, color.r, color.g, color.b)
+                local ____line_wrap_11 = line.wrap
+                if ____line_wrap_11 == nil then
+                    ____line_wrap_11 = true
+                end
+                __TS__SparseArrayPush(____array_12, ____line_wrap_11)
+                ____tooltip_AddLine_13(
+                    tooltip,
+                    __TS__SparseArraySpread(____array_12)
+                )
+            end
+            tooltip:Show()
+        end)
+        if not ____try then
+            ____hasReturned, ____returnValue = ____catch(____hasReturned)
+        end
+        if ____hasReturned then
+            return ____returnValue
+        end
+    end
+end
+function Tooltip.prototype.Hide(self)
+    local shown = self.shown
+    self.shown = nil
+    if shown ~= nil and shown.tooltip:IsOwned(shown.owner) then
+        shown.tooltip:Hide()
+    end
+end
+function Tooltip.prototype.dispose(self)
+    local binding = self.binding
+    self.binding = nil
+    if binding ~= nil then
+        binding.enter = nil
+        binding.leave = nil
+        local ____temp_17 = not binding.motion
+        if ____temp_17 then
+            local ____InCombatLockdown_result_16 = InCombatLockdown()
+            if ____InCombatLockdown_result_16 then
+                local ____this_15
+                ____this_15 = binding.frame
+                local ____opt_14 = ____this_15.IsProtected
+                ____InCombatLockdown_result_16 = (____opt_14 and ____opt_14(____this_15)) == true
+            end
+            ____temp_17 = not ____InCombatLockdown_result_16
+        end
+        if ____temp_17 then
+            binding.frame:EnableMouseMotion(false)
+        end
+    end
+    self:Hide()
+    Decoration.prototype.dispose(self)
+end
+return ____exports

package/lib/ui/index.d.ts

@@ -24,6 +24,8 @@ export { ProgressBar } from "./ProgressBar";
 export { Background } from "./decorations/Background";
 export { Border } from "./decorations/Border";
 export { Glow } from "./decorations/Glow";
+export { Tooltip } from "./decorations/Tooltip";
+export type { TooltipProps, TooltipAnchor, TooltipLine, NativeTooltip } from "./decorations/Tooltip";
 export { Label } from "./Label";
 export type { LabelProps } from "./Label";
 export { Icon } from "./Icon";

package/lib/ui/index.lua

@@ -68,6 +68,10 @@ do
     local ____Glow = require("ui.decorations.Glow")
     ____exports.Glow = ____Glow.Glow
 end
+do
+    local ____Tooltip = require("ui.decorations.Tooltip")
+    ____exports.Tooltip = ____Tooltip.Tooltip
+end
 do
     local ____Label = require("ui.Label")
     ____exports.Label = ____Label.Label

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wuira",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "author": {
     "name": "Kerim Cetinbas",
     "email": "a.cetinbas@icloud.com"