Iris UI Loader

-- This code is probably compatible only with Iris
-- So don't append any changes to it
-- (If you want it to work)

--//=====================    LOADER    \\======================--
-- { child: string, parent: string? }
local DIRECTORY: { { string? } } = { 
    {"API.lua", nil},
    {"Internal.lua", nil},
    {"PubTypes.lua", nil},
    {"Types.lua", nil},
    {"WidgetTypes.lua", nil},
    {"config.lua", nil},
    {"demoWindow.lua", nil},
    {"init.lua", nil},

    {"Tab.lua", "widgets"},
    {"Text.lua", "widgets"},
    {"Checkbox.lua", "widgets"},
    {"Root.lua", "widgets"},
    {"Window.lua", "widgets"},
    {"Table.lua", "widgets"},
    {"Input.lua", "widgets"},
    {"Format.lua", "widgets"},
    {"Combo.lua", "widgets"},
    {"Tree.lua", "widgets"},
    {"RadioButton.lua", "widgets"},
    {"init.lua", "widgets"},
    {"Image.lua", "widgets"},
    {"Plot.lua", "widgets"},
    {"Menu.lua", "widgets"},
    {"Button.lua", "widgets"}
}

-- cross-compatibility const
local OWNER: string = "SirMallard"
local REPO: string = "Iris"

local function get_repo_file(owner: string, repo: string, path: string)
    return game:HttpGet(`https://raw.githubusercontent.com/{owner}/{repo}/main/lib/{path}`) -- hella unoptimized
end

local DirectoryContents = getgenv().DirectoryContents
if DirectoryContents == nil then
    warn("Didn't found directory cache, loading..")
    DirectoryContents = {}

    for _, content in ipairs(DIRECTORY) do
        local child = content[1]:gsub("%.lua$", "") -- horrible
        local parent = content[2]
        if parent == nil then
            DirectoryContents[child] = get_repo_file(OWNER, REPO, content[1])
        else
            -- omg bro wth
            -- when did i do this
            if not DirectoryContents[parent] then DirectoryContents[parent] = {} end
            DirectoryContents[parent][child] = get_repo_file(OWNER, REPO, `{parent}/{content[1]}`)
        end
        warn(`// Loaded {child}`)
    end
    getgenv().DirectoryContents = DirectoryContents
    warn("Done loading!")
else
    print("Using cached directory contents:")
    for key, value in pairs(DirectoryContents) do
        print(key, type(value))
    end
end

--//=====================    MOCKED ENV    \\======================--
-- require(script.Parent.Types) -> script.__index("Parent") -> script.Parent.__index("Types") 
-- that's chain with indexing only two times
-- how to treat indexing module functions?
-- let's try checking for it in directory
-- 1. make function for creating mocked objects
local function create_proxy(object: { any }, index)
    return setmetatable(object, {
        __index = index
    })
end

-- 2. make function for mocking instances
-- where rawData is child of DirectoryContents
local create_mock_instance
create_mock_instance = function(name, rawData, parent)
    local instance = {
        Name = name,
        _rawData = rawData,
        _mocked = true
    }

    local children = {}
    if type(rawData) == "table" then
        for childName, childData in pairs(rawData) do
            children[childName] = create_mock_instance(childName, childData, instance)
        end
    end

    function instance:FindFirstChild(childName)
        return children[childName]
    end

    function instance:WaitForChild(childName)
        return children[childName]
    end

    return create_proxy(instance, function(self, key)
        if key == "Parent" then
            return parent
        end
        if key == "Name" then
            return name
        end
        if children[key] then
            return children[key]
        end
        return rawget(self, key)
    end)
end

-- 3. init directory
local root = create_mock_instance("Iris", DirectoryContents, nil) -- idk how it works

-- 4. mock require and script
local mocks_cache = {}

-- terrible code
-- “If it works, don’t touch it”
local function require(target)
    local target_type = type(target)
    if target_type ~= "table" or not target._mocked then
        error(`require: expected mocked object got {target_type}`) -- bruh ok
    end
    if mocks_cache[target] then
        return mocks_cache[target]
    end
    
    local data_type = type(target._rawData)
    local source
    -- some logic
    if data_type == "string" then
        source = target._rawData
    elseif data_type == "table" then
        local initChild = target:FindFirstChild("init")
        if initChild then
            source = initChild._rawData
        else
            error(`Couldn't find source for "{target.Name}"`)
        end
    else
        error(`Couldn't find source for "{target.Name}"`)
    end

    local chunk, err = loadstring(source)
    if not chunk then
        error(`Compilation error: {err}`)
    end

    setfenv(chunk, setmetatable({
        script = target,
        require = require
    }, { __index = getfenv(0) }))
    
    local result = chunk()
    mocks_cache[target] = result
    return result
    --table.foreach(target._rawData, warn)
end

-- 5. init
local Iris = require(root)
return Iris