wuira 0.2.5 → 0.2.6

package/CHANGELOG.md

@@ -7,6 +7,19 @@ with the release date and highlight breaking changes explicitly.
 
 ## Unreleased
 
+## 0.2.6 — 2026-10-16
+
+### Changed
+
+- Keep wuira source conversion callback-based. Case mappings and arithmetic
+  formula factories now belong to LumaUI's builder layer.
+
+### Removed
+
+- **Breaking:** Remove the `CaseConverter` and `MathConverter` APIs introduced in
+  0.2.5, including the expression parser. Use `new SourceConverter(source,
+  value => ...)` in wuira code; LumaUI owns its editable case/math definitions.
+
 ## 0.2.5 — 2026-10-16
 
 ### Added

package/README.md

@@ -30,7 +30,7 @@ wuira.Mount(App);
 - **Native widgets** — Cells mount to WoW frames; progress bars use the native StatusBar widget.
 - **Layout primitives** — Arrange children with `flow` and `grid`.
 - **Data sources** — HP, Mana, auras, cooldowns, casts, swings, group members, class/spec, spellbook.
-- **Source converters** — Compose checked value transformations, case mappings and arithmetic expressions. See [source converters](docs/source-converters.md).
+- **Source converters** — Transform checked values with typed callbacks. See [source converters](docs/source-converters.md).
 - **Slash commands** — Register commands with quoting and escaping support.
 - **Windows and settings** — `Window`, `AddonSettings`, `FrameMover`, `KeybindCapture`.
 - **Secure buttons** — Spell, item, macro, action, and target actions with `SecureButton`.

package/docs/source-converters.md

@@ -1,34 +1,27 @@
 # Source converters
 
-`SourceConverter` transforms a readable source value. It consumes the input's change notifications, shares one upstream subscription across its observers, and does not create a timer or dispose the shared input. Sources without notifications remain available as checked one-time reads.
+`SourceConverter` transforms a readable source with a typed callback. It consumes change notifications, shares one upstream subscription across observers, and does not create a timer or dispose the shared input. Sources without notifications remain available as checked one-time reads.
 
 ```ts
-import { ClassSource, SourceConverter, CaseConverter, HP, MathConverter, Unit } from "wuira/datasources";
+import { SourceConverter, HP, ClassSource, Unit } from "wuira/datasources";
 
+const hp = new HP(Unit.Player);
+const doubled = new SourceConverter(hp, value => value * 2);
 const characterClass = new ClassSource(Unit.Player);
 const token = new SourceConverter(characterClass, info => info?.token);
-const color = new CaseConverter(token, [
-    { equals: "PALADIN", value: { r: 1, g: 0.5, b: 0.7, a: 1 } },
-    { equals: "MAGE", value: { r: 0.4, g: 0.8, b: 1, a: 1 } },
-], { r: 0.35, g: 0.4, b: 0.45, a: 1 });
-
-const hp = new HP(Unit.Player);
-const doubled = new MathConverter(hp, "2 * input");
 const stop = doubled.BindTo(value => console.log(value));
+
 // On removal:
 stop();
 doubled.Dispose();
-color.Dispose();
 token.Dispose();
 characterClass.Dispose();
 ```
 
-`Value` and `Compute()` are checked reads. `TryCompute()` performs one checked read and returns `{ readable: false }` for restricted data, without invoking the callback. Converter chains use it to avoid repeated leaf reads. `onChange()` observes future readable output changes; `BindTo()` also applies the current readable value immediately. Scalar outputs with the same value do not emit again. `When()` filters emissions without changing the checked `Value` getter. Call `Dispose()` when the converter is no longer owned by a component.
-
-Cases compare strings, finite numbers and booleans with strict equality; `1` and `"1"` are different keys. Duplicate keys are rejected. Unmatched values return the supplied default, or `undefined` when none was provided. Case outputs can be colors, texture IDs, text or other data.
+`Value` and `Compute()` are checked reads. `TryCompute()` performs one checked read and returns `{ readable: false }` for restricted data without invoking the callback. Converter chains use it to read their leaf once, including when the data is restricted.
 
-Math expressions support `input`, finite numeric literals, parentheses, unary signs, `+`, `-`, `*`, `/`, `%`, and exponentiation (`^` or `**`). Exponents associate to the right; `-input^2` means `-(input^2)`. The bounded parser runs once at construction. It does not evaluate JavaScript or Lua, access globals, or call functions. Invalid syntax, division by zero and non-finite results throw errors. `MathConverter.Validate(expression)` checks syntax without reading the input.
+`onChange()` observes future readable output changes; `BindTo()` also applies the current readable value immediately. Identical scalar outputs do not emit again. `When()` filters emissions without changing the checked getter. `Dispose()` releases observers while leaving the input available to other consumers.
 
-Restricted values, including nested secret fields, never reach a conversion callback. Restrictions are checked when values are consumed; combat alone does not mark a value secret. ClassSource subscriptions follow unit identity changes and relevant native events, and release those listeners when the last consumer unsubscribes.
+Restricted values, including nested secret fields, never reach a conversion callback. Restrictions are checked when consumed; combat alone does not mark a value secret. ClassSource subscriptions follow unit identity changes and native events, releasing listeners when the last consumer unsubscribes.
 
-Converters produce data. They do not grant permission to change protected buttons or their actions during combat.
+The SDK accepts TypeScript callbacks. Editable case rules and math formulas are LumaUI builder factories, implemented using this generic source. Converters produce data; protected button actions remain subject to native combat restrictions.

package/lib/datasources/SourceConverter.d.ts

@@ -28,12 +28,3 @@ export declare class SourceConverter<TInput, TOutput> extends DataSource<TOutput
     BindTo(apply: (value: TOutput) => void): () => void;
     Dispose(): void;
 }
-export type CaseKey = string | number | boolean;
-export interface SourceCase<T> {
-    readonly equals: CaseKey;
-    readonly value: T;
-}
-/** Strict equality, first matching case, then the optional default value. */
-export declare class CaseConverter<TInput, TOutput> extends SourceConverter<TInput, TOutput | undefined> {
-    constructor(input: ValueSource<TInput>, cases: readonly SourceCase<TOutput>[], fallback?: TOutput);
-}

package/lib/datasources/SourceConverter.lua

@@ -319,62 +319,6 @@ local function __TS__ClassExtends(target, base)
         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")
@@ -528,41 +472,4 @@ function SourceConverter.prototype.Dispose(self)
     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/index.d.ts

@@ -1,9 +1,8 @@
 /// <reference path="../platform/forever.d.ts" />
 export { DataSource } from "./DataSource";
 export type { ReadResult } from "./DataSource";
-export { SourceConverter, CaseConverter } from "./SourceConverter";
-export type { ValueSource, CaseKey, SourceCase } from "./SourceConverter";
-export { MathConverter } from "./MathConverter";
+export { SourceConverter } from "./SourceConverter";
+export type { ValueSource } from "./SourceConverter";
 export { EditModeLayouts } from "./EditModeLayouts";
 export type { EditModeLayout, EditModeLayoutSnapshot, EditModeLayoutsStatus } from "./EditModeLayouts";
 export { ProgressSource } from "./ProgressSource";

package/lib/datasources/index.lua

@@ -7,11 +7,6 @@ end
 do
     local ____SourceConverter = require("datasources.SourceConverter")
     ____exports.SourceConverter = ____SourceConverter.SourceConverter
-    ____exports.CaseConverter = ____SourceConverter.CaseConverter
-end
-do
-    local ____MathConverter = require("datasources.MathConverter")
-    ____exports.MathConverter = ____MathConverter.MathConverter
 end
 do
     local ____EditModeLayouts = require("datasources.EditModeLayouts")

package/package.json

@@ -4,7 +4,7 @@
     "type": "git",
     "url": "git+https://github.com/KerimCETINBAS/wuira.git"
   },
-  "version": "0.2.5",
+  "version": "0.2.6",
   "author": {
     "name": "Kerim Cetinbas",
     "email": "a.cetinbas@icloud.com"

package/lib/datasources/MathConverter.d.ts

@@ -1,6 +0,0 @@
-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

@@ -1,61 +0,0 @@
---[[ 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

@@ -1,16 +0,0 @@
-/** 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;
-}

package/lib/datasources/MathExpression.lua

@@ -1,281 +0,0 @@
---[[ 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__StringAccess(self, index)
-    if index >= 0 and index < #self then
-        return string.sub(self, index + 1, index + 1)
-    end
-end
-
-local function __TS__StringIncludes(self, searchString, position)
-    if not position then
-        position = 1
-    else
-        position = position + 1
-    end
-    local index = string.find(self, searchString, position, true)
-    return index ~= nil
-end
-
-local function __TS__StringSlice(self, start, ____end)
-    if start == nil or start ~= start then
-        start = 0
-    end
-    if ____end ~= ____end then
-        ____end = 0
-    end
-    if start >= 0 then
-        start = start + 1
-    end
-    if ____end ~= nil and ____end < 0 then
-        ____end = ____end - 1
-    end
-    return string.sub(self, start, ____end)
-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__NumberIsFinite(value)
-    return type(value) == "number" and value == value and value ~= math.huge and value ~= -math.huge
-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
--- End of Lua Library inline imports
-local ____exports = {}
---- Small bounded arithmetic grammar. Expressions cannot call functions or execute Lua.
-____exports.MathExpression = __TS__Class()
-local MathExpression = ____exports.MathExpression
-MathExpression.name = "MathExpression"
-function MathExpression.prototype.____constructor(self, text)
-    self.text = text
-    self.offset = 0
-    self.token = ""
-    self.tokens = 0
-    if issecretvalue(text) or type(text) ~= "string" or #text == 0 or #text > 256 then
-        error("MathConverter: expression must contain 1–256 characters")
-    end
-    self:Next()
-    self.tree = self:Add(0)
-    if self.token ~= "" then
-        error("MathConverter: unexpected token " .. self.token)
-    end
-end
-function MathExpression.prototype.Next(self)
-    local ____self_0, ____tokens_1 = self, "tokens"
-    local ____self_tokens_2 = ____self_0[____tokens_1] + 1
-    ____self_0[____tokens_1] = ____self_tokens_2
-    if ____self_tokens_2 > 128 then
-        error("MathConverter: expression is too complex")
-    end
-    while __TS__StringIncludes(
-        " \t\r\n",
-        __TS__StringAccess(self.text, self.offset) or "\0"
-    ) do
-        self.offset = self.offset + 1
-    end
-    local char = __TS__StringAccess(self.text, self.offset)
-    if char == nil then
-        self.token = ""
-        return
-    end
-    if __TS__StringSlice(self.text, self.offset, self.offset + 5) == "input" then
-        self.offset = self.offset + 5
-        self.token = "input"
-        return
-    end
-    if __TS__StringIncludes("0123456789.", char) then
-        local ____self_3, ____offset_4 = self, "offset"
-        local ____self_offset_5 = ____self_3[____offset_4]
-        ____self_3[____offset_4] = ____self_offset_5 + 1
-        local start = ____self_offset_5
-        while __TS__StringIncludes(
-            "0123456789.",
-            __TS__StringAccess(self.text, self.offset) or "\0"
-        ) do
-            self.offset = self.offset + 1
-        end
-        if __TS__StringAccess(self.text, self.offset) == "e" or __TS__StringAccess(self.text, self.offset) == "E" then
-            self.offset = self.offset + 1
-            if __TS__StringAccess(self.text, self.offset) == "+" or __TS__StringAccess(self.text, self.offset) == "-" then
-                self.offset = self.offset + 1
-            end
-            while __TS__StringIncludes(
-                "0123456789",
-                __TS__StringAccess(self.text, self.offset) or "\0"
-            ) do
-                self.offset = self.offset + 1
-            end
-        end
-        self.token = __TS__StringSlice(self.text, start, self.offset)
-        if not __TS__NumberIsFinite(__TS__Number(self.token)) then
-            error("MathConverter: invalid number")
-        end
-        return
-    end
-    if __TS__StringIncludes("+-*/%^()", char) then
-        self.offset = self.offset + 1
-        self.token = char
-        if char == "*" and __TS__StringAccess(self.text, self.offset) == "*" then
-            self.offset = self.offset + 1
-            self.token = "^"
-        end
-        return
-    end
-    error("MathConverter: only input, numbers and arithmetic operators are allowed")
-end
-function MathExpression.prototype.Depth(self, depth)
-    if depth > 32 then
-        error("MathConverter: expression nesting is too deep")
-    end
-end
-function MathExpression.prototype.Add(self, depth)
-    local left = self:Multiply(depth)
-    while self.token == "+" or self.token == "-" do
-        local operator = self.token
-        self:Next()
-        left = {
-            kind = "binary",
-            operator = operator,
-            left = left,
-            right = self:Multiply(depth)
-        }
-    end
-    return left
-end
-function MathExpression.prototype.Multiply(self, depth)
-    local left = self:Unary(depth)
-    while __TS__ArrayIncludes({"*", "/", "%"}, self.token) do
-        local operator = self.token
-        self:Next()
-        left = {
-            kind = "binary",
-            operator = operator,
-            left = left,
-            right = self:Unary(depth)
-        }
-    end
-    return left
-end
-function MathExpression.prototype.Unary(self, depth)
-    self:Depth(depth)
-    if self.token == "+" or self.token == "-" then
-        local sign = self.token == "-" and -1 or 1
-        self:Next()
-        return {
-            kind = "unary",
-            sign = sign,
-            child = self:Unary(depth + 1)
-        }
-    end
-    local left = self:Primary(depth)
-    if self.token == "^" then
-        self:Next()
-        left = {
-            kind = "binary",
-            operator = "^",
-            left = left,
-            right = self:Unary(depth + 1)
-        }
-    end
-    return left
-end
-function MathExpression.prototype.Primary(self, depth)
-    self:Depth(depth)
-    if self.token == "input" then
-        self:Next()
-        return {kind = "input"}
-    end
-    if self.token == "(" then
-        self:Next()
-        local value = self:Add(depth + 1)
-        if self.token ~= ")" then
-            error("MathConverter: missing closing parenthesis")
-        end
-        self:Next()
-        return value
-    end
-    if self.token ~= "" and __TS__NumberIsFinite(__TS__Number(self.token)) then
-        local value = __TS__Number(self.token)
-        self:Next()
-        return {kind = "number", value = value}
-    end
-    error("MathConverter: expected input, a number or parentheses")
-end
-function MathExpression.prototype.Evaluate(self, input)
-    if issecretvalue(input) or type(input) ~= "number" or not __TS__NumberIsFinite(input) then
-        error("MathConverter: input must be a readable finite number")
-    end
-    local read
-    read = function(____, node)
-        if node.kind == "input" then
-            return input
-        end
-        if node.kind == "number" then
-            return node.value
-        end
-        if node.kind == "unary" then
-            return node.sign * read(nil, node.child)
-        end
-        local left = read(nil, node.left)
-        local right = read(nil, node.right)
-        if (node.operator == "/" or node.operator == "%") and right == 0 then
-            error("MathConverter: division by zero")
-        end
-        local result = node.operator == "+" and left + right or (node.operator == "-" and left - right or (node.operator == "*" and left * right or (node.operator == "/" and left / right or (node.operator == "%" and left % right or left ^ right))))
-        if not __TS__NumberIsFinite(result) then
-            error("MathConverter: result must be finite")
-        end
-        return result
-    end
-    return read(nil, self.tree)
-end
-return ____exports