luajitos

style.lua (6706B)

---

 -- CSS Style System
 -- Handles CSS parsing, cascading, specificity, and computed styles
 
 local Style = {}
 Style.__index = Style
 
 -- CSS Rule representation
 local CSSRule = {}
 CSSRule.__index = CSSRule
 
 function CSSRule:new(selector, declarations, specificity, important_flags)
     return setmetatable({
         selector = selector,
         declarations = declarations or {},
         specificity = specificity or {0, 0, 0},
         important_flags = important_flags or {}
     }, self)
 end
 
 -- Parse CSS selector and calculate specificity [ids, classes, tags]
 local function calculate_specificity(selector)
     local ids = 0
     local classes = 0
     local tags = 0
 
     -- Count IDs
     for _ in selector:gmatch("#[%w_-]+") do
         ids = ids + 1
     end
 
     -- Count classes and pseudo-classes
     for _ in selector:gmatch("%.[%w_-]+") do
         classes = classes + 1
     end
 
     -- Count tags
     for word in selector:gmatch("[%w]+") do
         -- Skip if it's right after # or .
         local escaped_word = word:gsub("([%^%$%(%)%%%.%[%]%*%+%-%?])", "%%%1")
         local before = selector:match("([#.])" .. escaped_word)
         if not before then
             tags = tags + 1
         end
     end
 
     return {ids, classes, tags}
 end
 
 -- Compare two specificity arrays
 local function compare_specificity(a, b)
     for i = 1, 3 do
         if a[i] > b[i] then
             return 1
         elseif a[i] < b[i] then
             return -1
         end
     end
     return 0
 end
 
 -- Check if a selector matches an element
 local function selector_matches(selector, element)
     -- Remove whitespace
     selector = selector:match("^%s*(.-)%s*$")
 
     -- Handle descendant selectors (simplified - just check the last part)
     local parts = {}
     for part in selector:gmatch("[^%s]+") do
         table.insert(parts, part)
     end
     local simple_selector = parts[#parts] or selector
 
     -- Parse simple selector
     local tag, id, classes = simple_selector:match("^([%w*]*)#?([%w_-]*)%.?(.*)$")
 
     -- Match tag
     if tag and tag ~= "" and tag ~= "*" then
         if tag ~= element.tag then
             return false
         end
     end
 
     -- Match ID
     if id and id ~= "" then
         if element.id ~= id then
             return false
         end
     end
 
     -- Match classes
     if classes and classes ~= "" then
         for class in classes:gmatch("[%w_-]+") do
             if not element:has_class(class) then
                 return false
             end
         end
     end
 
     return true
 end
 
 -- Parse CSS text into rules
 local function parse_css(css_text)
     local rules = {}
 
     -- Remove comments
     css_text = css_text:gsub("/%*.-%*/", "")
 
     -- Match rule blocks
     for selector, declarations_text in css_text:gmatch("([^{}]+)%s*{([^}]*)}") do
         -- Parse declarations
         local declarations = {}
         local important_flags = {}
 
         for declaration in declarations_text:gmatch("[^;]+") do
             local prop, value = declaration:match("^%s*([%w-]+)%s*:%s*(.-)%s*$")
             if prop and value then
                 -- Check for !important
                 local important = false
                 if value:match("!important") then
                     important = true
                     value = value:gsub("%s*!important%s*", "")
                 end
 
                 declarations[prop] = value
                 important_flags[prop] = important
             end
         end
 
         -- Calculate specificity
         local specificity = calculate_specificity(selector)
 
         -- Create rule
         table.insert(rules, CSSRule:new(selector, declarations, specificity, important_flags))
     end
 
     return rules
 end
 
 -- Load default CSS from file
 local function load_default_css()
     local file = io.open("default.css", "r")
     if not file then
         -- Fallback minimal CSS if file doesn't exist
         return [[
 * {
     display: block;
     color: #000000;
     background-color: transparent;
 }
         ]]
     end
 
     local content = file:read("*all")
     file:close()
     return content
 end
 
 -- Style manager
 function Style:new(dom)
     local obj = setmetatable({
         dom = dom,
         rules = {}
     }, self)
 
     -- Load default styles from default.css
     local default_css = load_default_css()
     obj:load(default_css)
 
     return obj
 end
 
 function Style:load(css_text, css_path)
     local new_rules = parse_css(css_text)
     for _, rule in ipairs(new_rules) do
         table.insert(self.rules, rule)
     end
 end
 
 function Style:inline(css_text)
     self:load(css_text)
 end
 
 function Style:get(element)
     local computed = {}
     local important_props = {}
 
     -- Apply rules in order, respecting specificity and !important
     for _, rule in ipairs(self.rules) do
         if selector_matches(rule.selector, element) then
             for prop, value in pairs(rule.declarations) do
                 local is_important = rule.important_flags[prop]
                 local existing_important = important_props[prop]
 
                 -- Only override if:
                 -- 1. No existing value, OR
                 -- 2. New value is !important and old is not, OR
                 -- 3. Both are !important or neither is, and new has higher/equal specificity
                 if not computed[prop] or
                    (is_important and not existing_important) or
                    ((is_important == existing_important) and
                     compare_specificity(rule.specificity,
                                       self:get_rule_specificity(prop, computed[prop])) >= 0) then
                     computed[prop] = value
                     important_props[prop] = is_important
                 end
             end
         end
     end
 
     -- Handle inline styles (highest specificity)
     if element.attributes.style then
         local style_attr = element.attributes.style
 
         if type(style_attr) == "string" then
             -- Parse inline style string like "color: cyan; font-size: 14px"
             for declaration in style_attr:gmatch("[^;]+") do
                 local prop, value = declaration:match("^%s*([%w-]+)%s*:%s*(.-)%s*$")
                 if prop and value then
                     computed[prop] = value
                 end
             end
         elseif type(style_attr) == "table" then
             -- Style set programmatically via script (already a table)
             for prop, value in pairs(style_attr) do
                 computed[prop] = value
             end
         end
     end
 
     return computed
 end
 
 function Style:get_rule_specificity(prop, value)
     -- Find the specificity of the rule that set this property
     -- For simplicity, return a low specificity
     return {0, 0, 0}
 end
 
 return {
     Style = Style
 }