- Fixed a container bug

- Added onDone to Program

Author: NoryiE

src/elements/Container.lua

@@ -102,6 +102,14 @@ end
 function Container:init(props, basalt)
     VisualElement.init(self, props, basalt)
     self.set("type", "Container")
+    self:observe("width", function()
+        self.set("childrenSorted", false)
+        self.set("childrenEventsSorted", false)
+    end)
+    self:observe("height", function()
+        self.set("childrenSorted", false)
+        self.set("childrenEventsSorted", false)
+    end)
 end
 
 --- Returns whether a child is visible
@@ -339,11 +347,13 @@ end
 
 local function convertMousePosition(self, event, ...)
     local args = {...}
-    if event:find("mouse_") then
-        local button, absX, absY = ...
-        local xOffset, yOffset = self.get("offsetX"), self.get("offsetY")
-        local relX, relY = self:getRelativePosition(absX + xOffset, absY + yOffset)
-        args = {button, relX, relY}
+    if event then
+        if event:find("mouse_") then
+            local button, absX, absY = ...
+            local xOffset, yOffset = self.get("offsetX"), self.get("offsetY")
+            local relX, relY = self:getRelativePosition(absX + xOffset, absY + yOffset)
+            args = {button, relX, relY}
+        end
     end
     return args
 end
@@ -680,6 +690,9 @@ end
 --- @private
 function Container:destroy()
     if not self:isType("BaseFrame") then
+        for _, child in ipairs(self.get("children")) do
+            child:destroy()
+        end
         self.set("childrenSorted", false)
         VisualElement.destroy(self)
         return self

src/elements/Flexbox.lua

@@ -787,6 +787,7 @@ function Flexbox:addChild(element)
     return self
 end
 
+--- Removes a child element from the flexbox
 --- @shortDescription Removes a child element from the flexbox
 --- @param element Element The child element to remove
 --- @return Flexbox self The flexbox instance

src/elements/Program.lua

@@ -17,6 +17,8 @@ Program.defineProperty(Program, "path", {default = "", type = "string"})
 Program.defineProperty(Program, "running", {default = false, type = "boolean"})
 --- @property errorCallback function nil The error callback function
 Program.defineProperty(Program, "errorCallback", {default = nil, type = "function"})
+--- @property doneCallback function nil The done callback function
+Program.defineProperty(Program, "doneCallback", {default = nil, type = "function"})
 
 Program.defineEvent(Program, "*")
 
@@ -82,6 +84,10 @@ function BasaltProgram:run(path, width, height)
             local ok, result = coroutine.resume(self.coroutine)
             term.redirect(current)
             if not ok then
+                local doneCallback = self.program.get("doneCallback")
+                if doneCallback then
+                    doneCallback(self.program, ok, result)
+                end
                 local errorCallback = self.program.get("errorCallback")
                 if errorCallback then
                     local trace = debug.traceback(self.coroutine, result)
@@ -94,6 +100,14 @@ function BasaltProgram:run(path, width, height)
                 errorManager.header = "Basalt Program Error ".. path
                 errorManager.error(result)
             end
+            if coroutine.status(self.coroutine)=="dead" then
+                self.program.set("running", false)
+                self.program.set("program", nil)
+                local doneCallback = self.program.get("doneCallback")
+                if doneCallback then
+                    doneCallback(self.program, ok, result)
+                end
+            end
         else
             errorManager.header = "Basalt Program Error ".. path
             errorManager.error("File not found")
@@ -128,10 +142,23 @@ function BasaltProgram:resume(event, ...)
 
     if ok then
         self.filter = result
+        if coroutine.status(self.coroutine)=="dead" then
+            self.program.set("running", false)
+            self.program.set("program", nil)
+            local doneCallback = self.program.get("doneCallback")
+            if doneCallback then
+                doneCallback(self.program, ok, result)
+            end
+        end
     else
+        local doneCallback = self.program.get("doneCallback")
+        if doneCallback then
+            doneCallback(self.program, ok, result)
+        end
         local errorCallback = self.program.get("errorCallback")
         if errorCallback then
             local trace = debug.traceback(self.coroutine, result)
+            trace = trace == nil and "" or trace
             local _result = errorCallback(self.program, result, trace:gsub(result, ""))
             if(_result==false)then
                 self.filter = nil
@@ -235,6 +262,15 @@ function Program:onError(fn)
     return self
 end
 
+--- Registers a callback for the program's done event
+--- @shortDescription Registers a callback for the program's done event
+--- @param fn function The callback function to register
+--- @return Program self The Program instance
+function Program:onDone(fn)
+    self.set("doneCallback", fn)
+    return self
+end
+
 --- @shortDescription Handles all incomming events
 --- @param event string The event to handle
 --- @param ... any The event arguments

tools/BasaltDoc/Button.lua

@@ -0,0 +1,48 @@
+local elementManager = require("elementManager")
+local VisualElement = elementManager.getElement("VisualElement")
+local getCenteredPosition = require("libraries/utils").getCenteredPosition
+---@cofnigDescription The Button is a standard button element with click handling and state management.
+
+--- The Button is a standard button element with click handling and state management.
+---@class Button : VisualElement
+local Button = setmetatable({}, VisualElement)
+Button.__index = Button
+
+---@property text string Button Button text
+Button.defineProperty(Button, "text", {default = "Button", type = "string", canTriggerRender = true})
+
+Button.defineEvent(Button, "mouse_click")
+Button.defineEvent(Button, "mouse_up")
+
+--- @shortDescription Creates a new Button instance
+--- @return table self The created instance
+--- @private
+function Button.new()
+    local self = setmetatable({}, Button):__init()
+    self.class = Button
+    self.set("width", 10)
+    self.set("height", 3)
+    self.set("z", 5)
+    return self
+end
+
+--- @shortDescription Initializes the Button instance
+--- @param props table The properties to initialize the element with
+--- @param basalt table The basalt instance
+--- @protected
+function Button:init(props, basalt)
+    VisualElement.init(self, props, basalt)
+    self.set("type", "Button")
+end
+
+--- @shortDescription Renders the Button
+--- @protected
+function Button:render()
+    VisualElement.render(self)
+    local text = self.get("text")
+    text = text:sub(1, self.get("width"))
+    local xO, yO = getCenteredPosition(text, self.get("width"), self.get("height"))
+    self:textFg(xO, yO, text, self.get("foreground"))
+end
+
+return Button

tools/BasaltDoc/ldoc-markdown-parser/README.md

@@ -0,0 +1,36 @@
+# ldoc-markdown-parser
+
+## Overview
+`ldoc-markdown-parser` is a simple and extensible Lua documentation parser that converts Lua documentation comments into Markdown format. It supports both single-line and multi-line comments, making it easy to document your Lua code in a structured way.
+
+## Features
+- Extracts single-line and multi-line comments from Lua files.
+- Parses custom tags such as `@property`, `@shortDescription`, `@param`, and `@return`.
+- Converts extracted comments and parsed tags into Markdown format.
+- Easy to extend and customize for additional tags or formatting options.
+
+## Installation
+To install the `ldoc-markdown-parser`, clone the repository and navigate to the project directory:
+
+```bash
+git clone <repository-url>
+cd ldoc-markdown-parser
+```
+
+## Usage
+To use the parser, run the `main.lua` file with the Lua interpreter, providing the path to the Lua file you want to parse:
+
+```bash
+lua src/main.lua path/to/your/lua_file.lua
+```
+
+The output will be generated in Markdown format and can be found in the specified output directory.
+
+## Example
+An example Lua file can be found in the `examples/input/example.lua`, and the expected output Markdown file is located in `examples/output/example.md`.
+
+## Contributing
+Contributions are welcome! Please feel free to submit a pull request or open an issue for any enhancements or bug fixes.
+
+## License
+This project is licensed under the MIT License. See the LICENSE file for more details.

tools/BasaltDoc/ldoc-markdown-parser/src/parser/block_parsers/function.lua

@@ -0,0 +1,64 @@
+local FunctionParser = {}
+
+--- Check if a block represents a function
+function FunctionParser.canParse(block)
+    return block.context and block.context.type == "function"
+end
+
+--- Parse a complete function documentation block
+function FunctionParser.parse(block)
+    local functionDoc = {
+        type = "function",
+        name = block.context.name,
+        shortDescription = nil,
+        params = {},
+        returns = {},
+        visibility = "public", -- default
+        context = block.context,
+        content = {}
+    }
+    
+    for _, line in ipairs(block.comments) do
+        -- Parse shortDescription
+        local shortDesc = line:match("^%-*%s*@shortDescription%s+(.*)$")
+        if shortDesc then
+            functionDoc.shortDescription = shortDesc
+        
+        -- Parse param
+        elseif line:match("^%-*%s*@param") then
+            local paramName, paramType, paramDesc = line:match("^%-*%s*@param%s+(%S+)%s+(%S+)%s+(.*)$")
+            if paramName then
+                table.insert(functionDoc.params, {
+                    name = paramName,
+                    type = paramType,
+                    description = paramDesc or ""
+                })
+            end
+        
+        -- Parse return
+        elseif line:match("^%-*%s*@return") then
+            local returnType, returnName, returnDesc = line:match("^%-*%s*@return%s+(%S+)%s+(%S+)%s+(.*)$")
+            if returnType then
+                table.insert(functionDoc.returns, {
+                    type = returnType,
+                    name = returnName or "",
+                    description = returnDesc or ""
+                })
+            end
+        
+        -- Parse visibility
+        elseif line:match("^%-*%s*@private%s*$") then
+            functionDoc.visibility = "private"
+        elseif line:match("^%-*%s*@protected%s*$") then
+            functionDoc.visibility = "protected"
+        
+        -- Regular content
+        else
+            table.insert(functionDoc.content, line)
+        end
+    end
+    
+    return functionDoc
+end
+
+return FunctionParser

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

@@ -0,0 +1,101 @@
+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)
+    local blocks = {}
+    local currentCommentBlock = {}
+    local i = 1
+    
+    while i <= #lines do
+        local line = lines[i]:match("^%s*(.*)") -- Trim leading whitespace
+        
+        -- 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
+            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 = {}
+        end
+        
+        i = i + 1
+    end
+    
+    -- Handle any remaining comments
+    if #currentCommentBlock > 0 then
+        table.insert(blocks, {
+            comments = currentCommentBlock,
+            context = nil
+        })
+    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"
+    end
+end
+
+--- Extracts the name from a code line
+function CommentExtractor.extractName(codeLine)
+    -- Function patterns
+    local funcName = codeLine:match("^function%s+([%w%.%:]+)")
+    if funcName then return funcName end
+    
+    local localFuncName = codeLine:match("^local%s+function%s+([%w%.%:]+)")
+    if localFuncName then return localFuncName end
+    
+    -- Variable/class patterns
+    local varName = codeLine:match("^local%s+([%w_]+)%s*=")
+    if varName then return varName end
+    
+    -- Method patterns
+    local methodName = codeLine:match("^([%w%.%:]+)%s*=")
+    if methodName then return methodName end
+    
+    return "unknown"
+end
+
+return CommentExtractor