@thigasdevelopment/luam 0.1.1

package/lua/async.lua

@@ -0,0 +1,119 @@
+---@class Async
+---@field tasks Threads
+---@field interval number
+---@field map fun(self: Async, array: table, func: fun(value: any, index: number): any, callback?: fun(elapsed: number): any): number
+---@field iterate fun(self: Async, from: number, to: number, increment: number, func: fun(i: number): any, callback?: fun(elapsed: number): any): number
+---@field foreach fun(self: Async, object: table<any, any>, func: fun(value: any, key: any): any, callback?: fun(elapsed: number): any): number
+---@field getInterval fun(self: Async): number
+---@field setInterval fun(self: Async, interval: number): boolean
+Async = {
+	---@param interval number
+	---@return Async
+	new = function (interval)
+		---@type Async
+		local self = setmetatable({ }, { __index = Async });
+		self.tasks = Threads.new ('concurrent', 'normal');
+
+		self.interval = 100;
+		self:setInterval (interval);
+		return self;
+	end,
+
+	---@param self Async
+	---@param array table
+	---@param func fun(value: any, index: number): any
+	---@param callback? fun(elapsed: number): any
+	---@return number
+	map = function (self, array, func, callback)
+		return self.tasks:add (
+			function (self)
+				local tick = getTickCount ();
+				for index, value in ipairs (array) do
+					func (value, index);
+
+					sleep (self.interval);
+				end
+
+				local callbackType = type (callback);
+				if (callbackType == 'function') then
+					local elapsed = (getTickCount () - tick);
+					callback (elapsed);
+				end
+			end
+		);
+	end,
+
+	---@param self Async
+	---@param from number
+	---@param to number
+	---@param increment number
+	---@param func fun(i: number): any
+	---@param callback? fun(elapsed: number): any
+	---@return number
+	iterate = function (self, from, to, increment, func, callback)
+		return self.tasks:add (
+			function (self)
+				local tick = getTickCount ();
+				for i = from, to, increment do
+					func (i);
+
+					sleep (self.interval);
+				end
+
+				local callbackType = type (callback);
+				if (callbackType == 'function') then
+					local elapsed = (getTickCount () - tick);
+					callback (elapsed);
+				end
+				return true;
+			end, { }, from, to, increment, func, callback
+		);
+	end,
+
+	---@param self Async
+	---@param object table<any, any>
+	---@param func fun(value: any, key: any): any
+	---@param callback? fun(elapsed: number): any
+	---@return number
+	foreach = function (self, object, func, callback)
+		return self.tasks:add (
+			function (self)
+				local tick = getTickCount ();
+				for key, value in pairs (object) do
+					func (value, key);
+
+					sleep (self.interval);
+				end
+
+				local callbackType = type (callback);
+				if (callbackType == 'function') then
+					local elapsed = (getTickCount () - tick);
+					callback (elapsed);
+				end
+			end, { }, object, func, callback
+		);
+	end,
+
+	---@param self Async
+	---@return number
+	getInterval = function (self)
+		return self.interval;
+	end,
+
+	---@param self Async
+	---@param interval number
+	---@return boolean
+	setInterval = function (self, interval)
+		interval = tonumber (interval);
+		if (not interval) then
+			return false;
+		end
+
+		if (interval < 1) or (interval == self:getInterval ()) then
+			return false;
+		end
+
+		self.interval = interval;
+		return true;
+	end,
+};

package/lua/class.lua

@@ -0,0 +1,178 @@
+local classes = {}
+
+local constructors = {}
+
+local BLOCKED_METAMETHODS = {
+    ['__call'] = true,
+    ['__index'] = true,
+    ['__newindex'] = true,
+}
+
+local function bindSuper(value, inherited)
+    return function(self, ...)
+        local previous = rawget(self, 'super')
+
+        self.super = function(_, ...)
+            return inherited(self, ...)
+        end
+
+        local result = value(self, ...)
+
+        self.super = previous
+
+        return result
+    end
+end
+
+local function create(name, struct, options)
+    if classes[name] then
+        error('Class ' .. tostring(name) .. ' already exists.')
+    end
+
+    local definition = {
+        __name = name,
+        __super = options.super,
+        __metamethods = options.metamethods,
+    }
+
+    for key, value in pairs(struct) do
+        local inherited = definition.__super and definition.__super[key]
+
+        if type(value) == 'function' and type(inherited) == 'function' then
+            definition[key] = bindSuper(value, inherited)
+        else
+            definition[key] = value
+        end
+    end
+
+    if definition.__super then
+        setmetatable(definition, { __index = definition.__super })
+    end
+
+    classes[name] = definition
+
+    return definition
+end
+
+function class(name)
+    local options = { super = nil, metamethods = nil }
+
+    local modifiers = {
+        extends = function(self, super)
+            options.super = classes[super]
+
+            if not options.super then
+                error('Class ' .. tostring(name) .. ' extends ' .. tostring(super) .. ', which is not defined.')
+            end
+
+            return self
+        end,
+
+        metamethods = function(self, metamethods)
+            options.metamethods = metamethods
+
+            return self
+        end,
+    }
+
+    return setmetatable({}, {
+        __index = function(_, key)
+            if modifiers[key] then
+                return modifiers[key]
+            end
+
+            local definition = classes[name]
+
+            if not definition then
+                return nil
+            end
+
+            return definition[key]
+        end,
+
+        __call = function(_, struct)
+            return create(name, struct, options)
+        end,
+    })
+end
+
+local function instanceMetatable(definition)
+    local meta = { __index = definition }
+
+    if not definition.__metamethods then
+        return meta
+    end
+
+    for key, value in pairs(definition.__metamethods) do
+        if BLOCKED_METAMETHODS[key] then
+            error('Cannot override metamethod ' .. tostring(key) .. '.')
+        end
+
+        meta[key] = value
+    end
+
+    return meta
+end
+
+local function createConstructor(definition)
+    local meta = instanceMetatable(definition)
+
+    return function(...)
+        local instance = setmetatable({}, meta)
+
+        if type(instance.constructor) == 'function' then
+            instance:constructor(...)
+        end
+
+        return instance
+    end
+end
+
+function new(name)
+    local definition = classes[name]
+
+    if not definition then
+        error('Class ' .. tostring(name) .. ' is not defined.')
+    end
+
+    local constructor = constructors[definition]
+
+    if not constructor then
+        constructor = createConstructor(definition)
+        constructors[definition] = constructor
+    end
+
+    return constructor
+end
+
+function bind(func, self)
+    if type(func) ~= 'function' then
+        error('Cannot bind a value of type ' .. type(func) .. '.')
+    end
+
+    return function(...)
+        return func(self, ...)
+    end
+end
+
+function enum(names)
+    local values = {}
+
+    if type(names) ~= 'table' then
+        return values
+    end
+
+    for index = 1, #names do
+        values[names[index]] = index - 1
+    end
+
+    return values
+end
+
+function getClasses()
+    return classes
+end
+
+function getClass(name)
+    return classes[name]
+end

package/lua/development-logs-client.lua

@@ -0,0 +1,13 @@
+local luamOriginalOutputDebugString = outputDebugString
+local luamDevelopmentEvent = "luam:development-log"
+local luamMaximumMessageLength = __LUAM_MAX_MESSAGE_LENGTH__
+
+function outputDebugString(message, level, red, green, blue)
+    local result = luamOriginalOutputDebugString(message, level, red, green, blue)
+
+    if type(message) == "string" and #message <= luamMaximumMessageLength and (level == nil or type(level) == "number") then
+        triggerServerEvent(luamDevelopmentEvent, resourceRoot, message, level or 3)
+    end
+
+    return result
+end

package/lua/development-logs-server.lua

@@ -0,0 +1,44 @@
+local luamDevelopmentEvent = "luam:development-log"
+local luamDevelopmentMarker = "__LUAM_DEV_LOG__"
+local luamMaximumMessageLength = __LUAM_MAX_MESSAGE_LENGTH__
+local luamRateLimit = __LUAM_RATE_LIMIT__
+local luamRateWindow = __LUAM_RATE_WINDOW_MS__
+local luamRateBuckets = {}
+
+addEvent(luamDevelopmentEvent, true)
+addEventHandler(luamDevelopmentEvent, resourceRoot, function(message, level)
+    if client == nil or source ~= resourceRoot or type(message) ~= "string" or #message > luamMaximumMessageLength then
+        return
+    end
+
+    if type(level) ~= "number" or level < 0 or level > 4 or level ~= math.floor(level) then
+        return
+    end
+
+    local now = getTickCount()
+    local bucket = luamRateBuckets[client]
+
+    if bucket == nil or now < bucket.started or now - bucket.started >= luamRateWindow then
+        bucket = { started = now, count = 0 }
+        luamRateBuckets[client] = bucket
+    end
+
+    if bucket.count >= luamRateLimit then
+        return
+    end
+
+    bucket.count = bucket.count + 1
+
+    local record = {
+        environment = "client",
+        level = level,
+        message = message,
+        resource = getResourceName(getThisResource())
+    }
+
+    outputDebugString(luamDevelopmentMarker .. toJSON(record, true), 4)
+end)
+
+addEventHandler("onPlayerQuit", root, function()
+    luamRateBuckets[source] = nil
+end)

package/lua/dotenv.lua

@@ -0,0 +1,160 @@
+local DEFAULT_FILE = '.env'
+
+local KEYWORDS = {
+    ['true'] = true,
+    ['false'] = false,
+}
+
+local ESCAPES = {
+    ['n'] = '\n',
+    ['r'] = '\r',
+    ['t'] = '\t',
+    ['"'] = '"',
+    ["'"] = "'",
+    ['\\'] = '\\',
+}
+
+local function trim(value)
+    return value:match('^%s*(.-)%s*$') or ''
+end
+
+local function unescape(character)
+    return ESCAPES[character] or ('\\' .. character)
+end
+
+local function cast(raw)
+    local quote = raw:sub(1, 1)
+
+    if quote == '"' or quote == "'" then
+        local quoted = raw:match('^' .. quote .. '(.*)' .. quote)
+
+        if quoted then
+            return (quoted:gsub('\\(.)', unescape))
+        end
+    end
+
+    local value = trim((raw:gsub('%s+#.*$', '')))
+    local keyword = KEYWORDS[value]
+
+    if keyword ~= nil then
+        return keyword
+    end
+
+    return tonumber(value) or value
+end
+
+local function read(path)
+    local file = fileOpen(path, true)
+
+    if not file then
+        return nil
+    end
+
+    local content = fileRead(file, fileGetSize(file))
+
+    fileClose(file)
+
+    return content
+end
+
+local function parse(path, content)
+    local values = {}
+    local number = 0
+
+    for line in (content .. '\n'):gmatch('(.-)\r?\n') do
+        number = number + 1
+
+        local trimmed = trim(line)
+
+        if trimmed ~= '' and trimmed:sub(1, 1) ~= '#' then
+            local key, raw = trimmed:match('^([%a_][%w_]*)%s*=%s*(.*)$')
+
+            if not key then
+                error('Malformed entry in "' .. path .. '" on line ' .. number .. '. Expected "KEY=value".')
+            end
+
+            values[key] = cast(raw)
+        end
+    end
+
+    return values
+end
+
+local function seal(path, values)
+    return setmetatable({}, {
+        __index = function(_, key)
+            local value = values[key]
+
+            if value == nil then
+                error('"' .. tostring(key) .. '" is not declared in "' .. path .. '".', 2)
+            end
+
+            return value
+        end,
+
+        __newindex = function(_, key)
+            error('The environment is read-only and "' .. tostring(key) .. '" cannot be assigned.', 2)
+        end,
+
+        __metatable = false,
+    })
+end
+
+if localPlayer ~= nil then
+    return
+end
+
+Dotenv = {}
+Dotenv.__index = Dotenv
+
+function Dotenv.new(path)
+    path = path or DEFAULT_FILE
+
+    local content = read(path)
+
+    if not content then
+        error('Failed to read the environment file "' .. tostring(path) .. '".', 2)
+    end
+
+    local self = setmetatable({}, Dotenv)
+
+    self.path = path
+    self.values = parse(path, content)
+
+    return self
+end
+
+function Dotenv:get(key, default)
+    local value = self.values[key]
+
+    if value == nil then
+        return default
+    end
+
+    return value
+end
+
+function Dotenv:has(key)
+    return self.values[key] ~= nil
+end
+
+function Dotenv:all()
+    local copy = {}
+
+    for key, value in pairs(self.values) do
+        copy[key] = value
+    end
+
+    return copy
+end
+
+function Dotenv:apply()
+    if type(process) ~= 'table' then
+        process = {}
+    end
+
+    process.env = seal(self.path, self.values)
+    env = process.env
+
+    return process.env
+end

package/lua/env.lua

@@ -0,0 +1,18 @@
+local ENVIRONMENT_FILE = '.env'
+
+if localPlayer ~= nil then
+    return
+end
+
+if not fileExists(ENVIRONMENT_FILE) then
+    if type(process) ~= 'table' then
+        process = {}
+    end
+
+    process.env = {}
+    env = process.env
+
+    return
+end
+
+Dotenv.new(ENVIRONMENT_FILE):apply()

package/lua/math.lua

@@ -0,0 +1,24 @@
+function math.clamp(value, minimum, maximum)
+    value = tonumber(value)
+
+    if not value then
+        return 0
+    end
+
+    minimum = tonumber(minimum) or value
+    maximum = tonumber(maximum) or value
+
+    if minimum > maximum then
+        minimum, maximum = maximum, minimum
+    end
+
+    if value < minimum then
+        return minimum
+    end
+
+    if value > maximum then
+        return maximum
+    end
+
+    return value
+end

package/lua/string.lua

@@ -0,0 +1,82 @@
+local function trim(value)
+    if type(value) ~= 'string' then
+        return tostring(value)
+    end
+
+    return value:match('^%s*(.-)%s*$') or ''
+end
+
+local function resolve(context, path)
+    local current = context
+
+    for key in path:gmatch('[^%.]+') do
+        if type(current) ~= 'table' then
+            return nil
+        end
+
+        current = current[key]
+
+        if current == nil then
+            return nil
+        end
+    end
+
+    return current
+end
+
+local function parse(raw)
+    local key, rest = raw:match('^(.-):(.+)$')
+
+    if not key then
+        return raw, nil
+    end
+
+    return key, trim(rest:match('^([^:]+)'))
+end
+
+function string.trim(value)
+    return trim(value)
+end
+
+function string.startsWith(value, prefix)
+    if type(value) ~= 'string' or type(prefix) ~= 'string' then
+        return false
+    end
+
+    return value:sub(1, prefix:len()) == prefix
+end
+
+function string.endsWith(value, suffix)
+    if type(value) ~= 'string' or type(suffix) ~= 'string' then
+        return false
+    end
+
+    if suffix == '' then
+        return true
+    end
+
+    return value:sub(-suffix:len()) == suffix
+end
+
+function string.template(text, context)
+    if type(text) ~= 'string' then
+        return tostring(text)
+    end
+
+    if type(context) ~= 'table' or next(context) == nil then
+        return text
+    end
+
+    return (
+        text:gsub('%${(.-)}', function(raw)
+            local key, default = parse(trim(raw))
+            local value = resolve(context, trim(key))
+
+            if value == nil then
+                return default ~= nil and default or ''
+            end
+
+            return tostring(value)
+        end)
+    )
+end

package/lua/table.lua

@@ -0,0 +1,63 @@
+function table.size(value)
+    local size = 0
+
+    if type(value) ~= 'table' then
+        return size
+    end
+
+    for _ in pairs(value) do
+        size = size + 1
+    end
+
+    return size
+end
+
+function table.isEmpty(value)
+    if type(value) ~= 'table' then
+        return true
+    end
+
+    return next(value) == nil
+end
+
+function table.keys(value)
+    local keys = {}
+
+    if type(value) ~= 'table' then
+        return keys
+    end
+
+    for key in pairs(value) do
+        keys[#keys + 1] = key
+    end
+
+    return keys
+end
+
+function table.values(value)
+    local values = {}
+
+    if type(value) ~= 'table' then
+        return values
+    end
+
+    for _, item in pairs(value) do
+        values[#values + 1] = item
+    end
+
+    return values
+end
+
+function table.includes(value, item)
+    if type(value) ~= 'table' then
+        return false
+    end
+
+    for _, current in pairs(value) do
+        if current == item then
+            return true
+        end
+    end
+
+    return false
+end