removed scrollbar from tables

added enabled property

Author: NoryiE

.gitignore

@@ -9,3 +9,4 @@ testWorkflows
 todo.txt
 Flexbox2.lua
 markdown2.lua
+BasaltDoc

src/elements/BaseElement.lua

@@ -31,6 +31,9 @@ BaseElement.defineProperty(BaseElement, "name", {default = "", type = "string"})
 --- @property eventCallbacks table BaseElement The event callbacks for the element
 BaseElement.defineProperty(BaseElement, "eventCallbacks", {default = {}, type = "table"})
 
+--- @property enabled boolean BaseElement Whether the element is enabled or not
+BaseElement.defineProperty(BaseElement, "enabled", {default = true, type = "boolean" })
+
 --- Registers a new event listener for the element (on class level)
 --- @shortDescription Registers a new event listener for the element (on class level)
 --- @param class table The class to register
@@ -215,6 +218,9 @@ end
 --- @return boolean? handled Whether the event was handled
 --- @protected
 function BaseElement:dispatchEvent(event, ...)
+    if self.get("enabled") == false then
+        return false
+    end
     if self[event] then
         return self[event](self, ...)
     end

src/elements/Table.lua

@@ -216,7 +216,7 @@ function Table:render()
                 local finalText = string.sub(paddedText, 1, col.width)
                 local finalForeground = string.rep(tHex[self.get("foreground")], #finalText)
                 local finalBackground = string.rep(tHex[bg], #finalText)
-                
+
                 self:blit(currentX, y, finalText, finalForeground, finalBackground)
                 currentX = currentX + col.width
             end
@@ -226,27 +226,6 @@ function Table:render()
                 string.rep(tHex[self.get("background")], self.get("width")))
         end
     end
-
-    if #data > height - 2 then
-        local scrollbarHeight = height - 2
-        local thumbSize = math.max(1, math.floor(scrollbarHeight * (height - 2) / #data))
-
-        local maxScroll = #data - (height - 2) + 1
-        local scrollPercent = scrollOffset / maxScroll
-        local thumbPos = 2 + math.floor(scrollPercent * (scrollbarHeight - thumbSize))
-
-        if scrollOffset >= maxScroll then
-            thumbPos = height - thumbSize
-        end
-
-        for y = 2, height do
-            self:blit(self.get("width"), y, "\127", tHex[colors.gray], tHex[colors.gray])
-        end
-
-        for y = thumbPos, math.min(height, thumbPos + thumbSize - 1) do
-            self:blit(self.get("width"), y, "\127", tHex[colors.white], tHex[colors.white])
-        end
-    end
 end
 
 return Table

src/elements/VisualElement.lua

@@ -99,7 +99,7 @@ VisualElement.registerEventCallback(VisualElement, "ClickUp", "mouse_up", "mouse
 VisualElement.registerEventCallback(VisualElement, "Drag", "mouse_drag", "mouse_click", "mouse_up")
 VisualElement.registerEventCallback(VisualElement, "Scroll", "mouse_scroll")
 VisualElement.registerEventCallback(VisualElement, "Enter", "mouse_enter", "mouse_move")
-VisualElement.registerEventCallback(VisualElement, "LeEave", "mouse_leave", "mouse_move")
+VisualElement.registerEventCallback(VisualElement, "Leave", "mouse_leave", "mouse_move")
 VisualElement.registerEventCallback(VisualElement, "Focus", "focus", "blur")
 VisualElement.registerEventCallback(VisualElement, "Blur", "blur", "focus")
 VisualElement.registerEventCallback(VisualElement, "Key", "key", "key_up")

tools/BasaltDoc/Button.lua

@@ -26,6 +26,7 @@ function Button.new()
     return self
 end
 
+--- Initializes the Button instance
 --- @shortDescription Initializes the Button instance
 --- @param props table The properties to initialize the element with
 --- @param basalt table The basalt instance

tools/BasaltDoc/ldoc-markdown-parser/src/parser/comment_extractor.lua

@@ -1,101 +1,81 @@
 local CommentExtractor = {}
 
---- Extracts comments with their associated code context
--- @param lines table The lines of the Lua file as a table of strings.
--- @return table A table containing comment blocks with context.
-function CommentExtractor.extractComments(lines)
+--- Extracts comment blocks that belong together
+function CommentExtractor.extractBlocks(lines)
     local blocks = {}
-    local currentCommentBlock = {}
-    local i = 1
+    local currentBlock = {
+        comments = {},
+        codeContext = nil
+    }
 
+    local i = 1
     while i <= #lines do
-        local line = lines[i]:match("^%s*(.*)") -- Trim leading whitespace
+        local line = lines[i]
+        local trimmed = line:match("^%s*(.-)%s*$")
 
         -- Check if this is a comment line
-        if line:find("^%-%-%-") or line:find("^%-%-") then
-            table.insert(currentCommentBlock, line)
-        elseif #currentCommentBlock > 0 then
-            -- We have accumulated comments, check if next non-empty line is code
-            local codeContext = nil
-            local j = i
-            
-            -- Skip empty lines to find the actual code
-            while j <= #lines and lines[j]:match("^%s*$") do
-                j = j + 1
+        if trimmed:match("^%-%-%-") or trimmed:match("^%-%-") then
+            table.insert(currentBlock.comments, trimmed)
+        elseif #currentBlock.comments > 0 then
+            -- We have comments, now look for the code that follows
+            local codeLineIndex = CommentExtractor.findNextCodeLine(lines, i)
+            if codeLineIndex then
+                local codeLine = lines[codeLineIndex]:match("^%s*(.-)%s*$")
+                currentBlock.codeContext = CommentExtractor.analyzeCode(codeLine, codeLineIndex)
             end
 
-            if j <= #lines then
-                local codeLine = lines[j]:match("^%s*(.*)")
-                -- Check if it's a function, class, property, etc.
-                if codeLine:find("^function") or 
-                   codeLine:find("^local function") or
-                   codeLine:find("^local%s+%w+%s*=") or
-                   codeLine:find("^%w+%.%w+") then
-                    codeContext = {
-                        type = CommentExtractor.getCodeType(codeLine),
-                        name = CommentExtractor.extractName(codeLine),
-                        line = codeLine,
-                        lineNumber = j
-                    }
-                end
-            end
-            
-            -- Add the comment block with its context
-            table.insert(blocks, {
-                comments = currentCommentBlock,
-                context = codeContext
-            })
-            
-            currentCommentBlock = {}
+            -- Save this block and start a new one
+            table.insert(blocks, currentBlock)
+            currentBlock = {comments = {}, codeContext = nil}
         end
 
         i = i + 1
     end
 
-    -- Handle any remaining comments
-    if #currentCommentBlock > 0 then
-        table.insert(blocks, {
-            comments = currentCommentBlock,
-            context = nil
-        })
+    -- Handle remaining comments
+    if #currentBlock.comments > 0 then
+        table.insert(blocks, currentBlock)
     end
 
     return blocks
 end
 
---- Determines the type of code (function, class, property, etc.)
-function CommentExtractor.getCodeType(codeLine)
-    if codeLine:find("^function") or codeLine:find("^local function") then
-        return "function"
-    elseif codeLine:find("^local%s+%w+%s*=%s*setmetatable") then
-        return "class"
-    elseif codeLine:find("^local%s+%w+%s*=") then
-        return "variable"
-    elseif codeLine:find("^%w+%.defineProperty") then
-        return "property_definition"
-    else
-        return "unknown"
+--- Find the next non-empty code line
+function CommentExtractor.findNextCodeLine(lines, startIndex)
+    for i = startIndex, #lines do
+        local trimmed = lines[i]:match("^%s*(.-)%s*$")
+        if trimmed ~= "" and not trimmed:match("^%-%-") then
+            return i
+        end
     end
+    return nil
 end
 
---- Extracts the name from a code line
-function CommentExtractor.extractName(codeLine)
+--- Analyze what kind of code this is
+function CommentExtractor.analyzeCode(codeLine, lineNumber)
     -- Function patterns
-    local funcName = codeLine:match("^function%s+([%w%.%:]+)")
-    if funcName then return funcName end
+    if codeLine:match("^function%s+([%w%.%:]+)") then
+        local name = codeLine:match("^function%s+([%w%.%:]+)")
+        return {type = "function", name = name, line = codeLine, lineNumber = lineNumber}
+    end
 
-    local localFuncName = codeLine:match("^local%s+function%s+([%w%.%:]+)")
-    if localFuncName then return localFuncName end
+    if codeLine:match("^local%s+function%s+([%w%.%:]+)") then
+        local name = codeLine:match("^local%s+function%s+([%w%.%:]+)")
+        return {type = "function", name = name, line = codeLine, lineNumber = lineNumber}
+    end
 
-    -- Variable/class patterns
-    local varName = codeLine:match("^local%s+([%w_]+)%s*=")
-    if varName then return varName end
+    -- Class/variable patterns
+    if codeLine:match("^local%s+([%w_]+)%s*=%s*setmetatable") then
+        local name = codeLine:match("^local%s+([%w_]+)%s*=")
+        return {type = "class", name = name, line = codeLine, lineNumber = lineNumber}
+    end
 
-    -- Method patterns
-    local methodName = codeLine:match("^([%w%.%:]+)%s*=")
-    if methodName then return methodName end
+    if codeLine:match("^local%s+([%w_]+)%s*=") then
+        local name = codeLine:match("^local%s+([%w_]+)%s*=")
+        return {type = "variable", name = name, line = codeLine, lineNumber = lineNumber}
+    end
 
-    return "unknown"
+    return {type = "unknown", name = "unknown", line = codeLine, lineNumber = lineNumber}
 end
 
 return CommentExtractor

tools/BasaltDoc/ldoc-markdown-parser/src/parser/init.lua

@@ -1,4 +1,5 @@
 local CommentExtractor = require("parser.comment_extractor")
+local TagParser = require("parser.tag_parser")
 local MarkdownGenerator = require("parser.markdown_generator")
 
 local Parser = {}
@@ -9,21 +10,23 @@ function Parser.extractComments(content)
     for line in content:gmatch("[^\r\n]+") do
         table.insert(lines, line)
     end
-    return CommentExtractor.extractComments(lines)
+    return CommentExtractor.extractBlocks(lines)
 end
 
 --- Generate markdown from comment blocks
 function Parser.generateMarkdown(commentBlocks)
-    local parsedBlocks = {}
+    local markdown = {}
 
-    -- Parse each block using the appropriate parser
+    -- Parse each block and generate markdown
     for _, block in ipairs(commentBlocks) do
-        local parsedBlock = MarkdownGenerator.parseBlock(block)
-        table.insert(parsedBlocks, parsedBlock)
+        local tags = TagParser.parseAllTags(block.comments)
+        local blockMarkdown = MarkdownGenerator.generateBlock(block, tags)
+        if blockMarkdown and blockMarkdown ~= "" then
+            table.insert(markdown, blockMarkdown)
+        end
     end
 
-    -- Generate markdown from parsed blocks
-    return MarkdownGenerator.generateMarkdown(parsedBlocks)
+    return table.concat(markdown, "\n\n")
 end
 
 return Parser