lenix 1.3.2 → 1.3.3

package/lint/{tsconfig.json → src/tsconfig.json}

@@ -4,7 +4,7 @@
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "strict": true,
-    "outDir": "dist"
+    "outDir": "../dist"
   },
   "include": ["lint.mts"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lenix",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "The Monorepo for the software engineering community",
   "author": "Lenix",
   "license": "GPL-3.0",
@@ -31,7 +31,7 @@
   },
   "files": [
     "ts/dist",
-    "lua",
+    "lua/dist",
     "lint"
   ],
   "dependencies": {
@@ -51,7 +51,7 @@
     "typescript": "^5.3.3"
   },
   "scripts": {
-    "build": "tsc -p ts/fxmanifest/tsconfig.json && tsc-alias && tsc -p lint/tsconfig.json",
+    "build": "tsc -p ts/src/fxmanifest/tsconfig.json && tsc-alias && tsc -p lint/src/tsconfig.json",
     "bump": "pnpm version patch"
   }
 }

package/ts/dist/fetch/index.js

@@ -11,6 +11,6 @@ export const safeRequest = async (domain, endpoint, request) => {
         throw new Error('An error occurred while making the request.', { cause: error });
     }
     finally {
-        console.log(`End of ${domain}/${endpoint} request`);
+        console.debug(`End of ${domain}/${endpoint} request`);
     }
 };

package/lua/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Lenix
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/lua/_dev/firstAttempt.lua

@@ -1,202 +0,0 @@
-local class<const> = function (fields)
-  local defined<const> = {}
-  local private<const> = fields.private or {}
-  local getter<const> = fields.get or {}
-  local setter<const> = fields.set or {}
-  local accessor<const> = fields.accessor or {}
-  local privates<const> = { static = {}, instance = {} }
-  local setProperties<const> = { static = {}, instance = {} }
-  local getProperties<const> = { static = {}, instance = {} }
-
-  local isVariableEligible<const> = function (variable, valueType, value)
-    if defined[variable] then
-      print(("`%s` is already defined"):format(variable))
-      return
-    elseif type(value) ~= valueType and valueType ~= "any" then
-      print(("type mismatch for `%s`, expected `%s`, got `%s`"):format(variable, valueType, type(value)))
-      return
-    end
-    defined[variable] = true
-    if valueType == "any" then
-      print(("variable `%s` implicitly has type `%s`"):format(variable, valueType, type(value)))
-    end
-    return true
-  end
-
-  local fieldPairs<const> = {
-    {private, privates},
-    {getter, getProperties},
-    {setter, setProperties},
-    {accessor, nil}
-  }
-
-  for _, pair in ipairs(fieldPairs) do
-    local source, target = pair[1], pair[2]
-    for variable, values in pairs(source) do
-      -- getPropertyValue
-      local value<const> = type(values) == "table" and values[1]
-      -- getPropertyType
-      local valueType<const> = type(values) == "table" and values[2] or "any"
-      local staticValue<const> = values and values[3] or false
-      if isVariableEligible(variable, valueType, value) then
-        -- fill table with keys and values
-        if target then
-          if staticValue then
-            target["static"][variable] = value
-          else
-            target["instance"][variable] = value
-          end
-        else
-          if staticValue then
-            getProperties["static"][variable] = value
-            setProperties["static"][variable] = value
-          else
-            getProperties["instance"][variable] = value
-            setProperties["instance"][variable] = value
-          end
-        end
-      end
-    end
-  end
-
-  return setmetatable({
-    new = function (self, ...)
-      local newInstanceArgs = {...}
-      print(self)
-      local constructor<const> = fields.constructor
-      constructor(self, nil, ...)
-      return setmetatable({}, {
-        __index = function (_, variableKey)
-          if getter["instance"][variableKey] then
-            return getProperties["instance"][variableKey]
-          elseif accessor["instance"][variableKey] then
-            return getProperties["instance"][variableKey]
-          end
-        end,
-      })
-    end
-  }, {
-    __index = function(_, variableKey)
-      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
-      -- isPropertyExist
-      if getter[variableKey] ~= nil then
-        if isStatic(getter, variableKey, "get") then
-          -- returnPropertyValue
-          return getProperties["static"][variableKey]
-        end
-      elseif accessor[variableKey] ~= nil then
-        if isStatic(accessor, variableKey, "accessor") then
-          return getProperties["static"][variableKey]
-        end
-      elseif private[variableKey] ~= nil then
-        print(("cannot read the private property `%s`"):format(variableKey))
-      elseif setter[variableKey] ~= nil then
-        print(("the setter only property `%s` can not be accessed"):format(variableKey))
-      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
-    end,
-    __newindex = function (_, variableKey, variableValue)
-      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
-      if setter[variableKey] ~= nil then
-        if not isStatic(setter, variableKey, "set") then
-          local valueType = setter[variableKey][2] or "any"
-          if type(variableValue) ~= valueType and valueType ~= "any" then
-            print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
-            return
-          end
-        end
-        getProperties["static"][variableKey] = variableValue
-      elseif accessor[variableKey] ~= nil then
-        if not isStatic(accessor, variableKey, "accessor") then
-          local valueType = accessor[variableKey][2] or "any"
-          if type(variableValue) ~= valueType and valueType ~= "any" then
-            print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
-            return
-          end
-        end
-        getProperties["static"][variableKey] = variableValue
-      elseif getter[variableKey] ~= nil then
-        print(("the getter only property `%s `can not be set"):format(variableKey))
-      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
-    end
-  })
-end
-
-myClass = class({
-  private = {
-    height = {197, "number"},
-  },
-  get = {
-    blood = {"O+", "any"},
-  },
-  set = {
-    date = {2005, "number"},
-  },
-  accessor = {
-    age = {20, "number"},
-    name = {"Lenix", "string"},
-    getBlood = {function(self) return self end, "function"}
-  },
-  constructor = function(self, super, name, age)
-    self.name = name
-    self.age = age
-  end
-})
-
-
-local Person = myClass:new("Dev", 21)
-print(Person.name, Person.age)
--- Person.date = 2005
--- print(Person.date)
--- print(Person.age)
--- Person.age = 21
-
--- print(myClass.height)
--- print(myClass.blood)
--- myClass.date = 2026
--- print(myClass.age)
--- myClass.age = 21
--- print(myClass.age)
--- print(myClass.name)
--- myClass.name = "Dev"
--- print(myClass.name)
--- print(myClass.getBlood())
--- myClass.getBlood = function() return true end
--- print(myClass.getBlood())
-
-
-
-
-__index = function(_, variableKey)
-      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
-      -- isPropertyExist
-      if getter[variableKey] ~= nil then
-        -- returnPropertyValue
-        return getProperties[variableKey]
-      elseif accessor[variableKey] ~= nil then
-        return getProperties[variableKey]
-      elseif private[variableKey] ~= nil then
-        print(("cannot read the private property `%s`"):format(variableKey))
-      elseif setter[variableKey] ~= nil then
-        print(("the setter only property `%s` are forbidden to be accessed"):format(variableKey))
-      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
-    end,
-    __newindex = function (_, variableKey, variableValue)
-      assert(defined[variableKey], ("property `%s` not found"):format(variableKey))
-      if setter[variableKey] ~= nil then
-        local valueType = setter[variableKey][2] or "any"
-        if type(variableValue) ~= valueType and valueType ~= "any" then
-          print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
-          return
-        end
-        getProperties[variableKey] = variableValue
-      elseif accessor[variableKey] ~= nil then
-        local valueType = accessor[variableKey][2] or "any"
-        if type(variableValue) ~= valueType and valueType ~= "any" then
-          print(("cannot assign `%s` to `%s` on `%s`"):format(type(variableValue), valueType, variableKey))
-          return
-        end
-        getProperties[variableKey] = variableValue
-      elseif getter[variableKey] ~= nil then
-        print(("the getter only property `%s `can not be set"):format(variableKey))
-      else print(("something went wrong when trying to access `%s`"):format(variableKey)) end
-    end

package/lua/_dev/secondAttempt.lua

@@ -1,166 +0,0 @@
-assert(_VERSION == "Lua 5.4", "THIS MODULE REQUIRES Lua 5.4")
-
-local class<const> = function (fields)
-  local definedProperties<const> = {}
-  local promisedToBeConstructed<const> = {}
-  local private<const> = fields.private or {}
-  local getter<const> = fields.get or {}
-  local setter<const> = fields.set or {}
-  local accessor<const> = fields.accessor or {}
-  local privates<const> = {}
-  local setProperties<const> = {}
-  local getProperties<const> = {}
-
-  local isVariableEligible<const> = function (propertyKey, propertyType, propertyValue)
-    if definedProperties[propertyKey] then
-      print(("`%s` is already defined"):format(propertyKey))
-      return
-    elseif type(propertyValue) ~= propertyType and propertyType ~= "any" and propertyValue ~= nil then
-      error(("type mismatch for `%s`, defined `%s`, appointed `%s`"):format(propertyKey, propertyType, type(propertyValue)))
-      return
-    end
-    definedProperties[propertyKey] = true
-    if propertyType == "any" then
-      print(("variable `%s` implicitly has type `%s`"):format(propertyKey, propertyType, type(propertyValue)))
-    end
-    if propertyValue == nil and propertyType ~= "nil" then
-      promisedToBeConstructed[propertyKey] = true
-    end
-    return true
-  end
-
-  local fieldPairs<const> = {
-    {private, privates},
-    {getter, getProperties},
-    {setter, setProperties},
-    {accessor, nil}
-  }
-
-  for _, pair in ipairs(fieldPairs) do
-    local field<const>, properties<const> = pair[1], pair[2]
-    for propertyKey, propertyValues in pairs(field) do
-      -- getPropertyValue
-      local propertyValue<const> = type(propertyValues) == "table" and propertyValues[1]
-      -- getPropertyType
-      assert(type(propertyValues) == 'table', ("syntax error at `%s`, expected `%s`, got `%s`"):format(propertyKey, "table", type(propertyValues)))
-      local propertyType<const> = propertyValues[2]
-      if isVariableEligible(propertyKey, propertyType, propertyValue) then
-        -- fill table with keys and values
-        if properties then
-          properties[propertyKey] = propertyValue
-        else
-          -- for the accessor, filling the get and set permission
-          getProperties[propertyKey], setProperties[propertyKey] = propertyValue, propertyValue
-          setter[propertyKey], getter[propertyKey] = accessor[propertyKey], accessor[propertyKey]
-        end
-      end
-    end
-  end
-
-  local get<const> = function (self, propertyKey)
-    if definedProperties[propertyKey] then
-      if getter[propertyKey] then
-        if type(self[propertyKey]) == 'function' then
-          return function(...) return self[propertyKey](self, ...) end
-        end
-        return self[propertyKey]
-      elseif private[propertyKey] then
-        print(("private property `%s` is not allowed to be accessed"):format(propertyKey))
-      else print(("tried to get the `%s` set-only property"):format(propertyKey)) end
-    else
-      print(("`%s` property does not exist"):format(propertyKey))
-    end
-  end
-  local set<const> = function (self, propertyKey, propertyValue)
-    if definedProperties[propertyKey] then
-      if setter[propertyKey] then
-        if type(propertyValue) == setter[propertyKey][2] or setter[propertyKey][2] == "any" then
-          self[propertyKey] = propertyValue
-        else print(("`%s` is not assignable to `%s`: on `%s`"):format(type(propertyValue), setter[propertyKey][2], propertyKey)) end
-      elseif private[propertyKey] then
-        print(("private property `%s` is not allowed to be assigned"):format(propertyKey))
-      else print(("tried to set the `%s` get-only property"):format(propertyKey)) end
-    else
-      print(("`%s` property does not exist"):format(propertyKey))
-    end
-  end
-
-  return setmetatable({
-    new = function(self, ...)
-      local instance<const> = {}
-
-      for _, pair in pairs(fieldPairs) do
-        for propertyKey, propertyValue in pairs(pair[2] or {}) do
-          instance[propertyKey] = propertyValue
-        end
-      end
-
-      setmetatable(instance, getmetatable(self))
-
-      if fields.constructor then
-        fields.constructor(instance, nil, ...)
-      else error('no constructor was provided') end
-
-      -- Constructor has finished, now validate
-      for propertyKey in pairs(promisedToBeConstructed) do
-        if instance[propertyKey] == nil then
-          error(('the `%s` was not instantiated in constructor as promised'):format(propertyKey))
-        end
-      end
-
-      return setmetatable({}, {
-        __index = function(_, propertyKey)
-          return get(instance, propertyKey)
-        end,
-        __newindex = function(_, propertyKey, varValue)
-          set(instance, propertyKey, varValue)
-        end
-      })
-    end
-  }, { })
-end
-
-local myClass<const> = class({
-  private = {
-    height = {nil, "number"},
-  },
-  get = {
-    blood = {nil, "string"},
-    getHeight = {function(self, new)
-      self.setHeight(self, new)
-      return self.height
-    end, "function"}
-  },
-  set = {
-    setHeight = {
-      function(new)
-        self.height = new
-      end, "function"
-    },
-  },
-  accessor = {
-    name = {nil, "string"},
-    age = {nil, "number"},
-  },
-  constructor = function(self, super, name, age, height, blood)
-    self.name = name
-    self.age = age
-    self.height = height
-    self.blood = blood
-  end
-})
-
-
-local Class<const> = myClass:new("Lenix", 20, 197, "O+")
-Class.setHeight = function(self, new)
-  self.height = new
-end
-
-
-
-print(Class.getHeight(198))
-
-
-
-
-

package/lua/_dev/tests.lua

@@ -1,298 +0,0 @@
---[[ These are the tests that we have tried to get working with Lua-OOP, if you have any suggestions or improvements, please let us know. ]]
-
-local User = class({
-  name = {nil, false},
-  age = {nil, false},
-  constructor = function(self, super, name, age)
-    self.name = name
-    self.age = age
-  end
-})
-local u = User:new("Alice", 25)
-assert(u.name == "Alice" and u.age == 25, "Test 1 failed")
-local User = class({
-  password = {nil, true},  -- private
-  constructor = function(self, super, pwd)
-    self.password = pwd
-  end
-})
-local u = User:new("secret")
-local ok = pcall(function() print(u.password) end)
-assert(not ok, "Test 2 failed: private property accessible")
-
--- Test 3: Private property accessible internally
-local User = class({
-  password = {nil, true},
-  getPassword = {function(self) return self.password end, false},
-  constructor = function(self, super, pwd)
-    self.password = pwd
-  end
-})
-local u = User:new("secret")
-assert(u.getPassword() == "secret", "Test 3 failed")
-local User = class({
-  count = {0, false, true},  -- static
-  name = {nil, false},
-  constructor = function(self, super, name)
-    self.name = name
-  end
-})
-User.count = 5
-local u = User:new("Alice")
-local ok = pcall(function() print(u.count) end)
-assert(not ok, "Test 4 failed: static accessible on instance")
-assert(User.count == 5, "Test 4 failed: static not on class")
-
--- Test 5: Instance properties on instance, not class
-local ok2 = pcall(function() print(User.name) end)
-assert(not ok2, "Test 5 failed: instance accessible on class")
-local User = class({
-  id = {1, false, false, true},  -- immutable
-  constructor = function(self, super, id)
-    self.id = id
-  end
-})
-local u = User:new(100)
-local ok = pcall(function() u.id = 999 end)
-assert(not ok, "Test 6 failed: immutable modified")
-assert(u.id == 100, "Test 6 failed: immutable changed")
-
--- Test 7: Mutable property can be changed
-local User = class({
-  name = {nil, false, false, false},  -- mutable
-  constructor = function(self, super, name)
-    self.name = name
-  end
-})
-local u = User:new("Alice")
-u.name = "Bob"
-assert(u.name == "Bob", "Test 7 failed")
-local User = class({
-  _value = {0, true},
-  get = {
-    value = function(self) return self._value * 2 end
-  },
-  constructor = function(self, super, val)
-    self._value = val
-  end
-})
-local u = User:new(5)
-assert(u.value == 10, "Test 8 failed")
-
--- Test 9: Setter works
-local User = class({
-  _value = {0, true},
-  getValue = {function(self) return self._value end, false},  -- Add getter
-  set = {
-    value = function(self, val) self._value = val * 2 end
-  },
-  constructor = function(self) self._value = 0 end
-})
-local u = User:new()
-u.value = 5
-assert(u.getValue() == 10, "Test 9 failed")
-
--- Test 10: Getter can't be modified (correct version)
-local User = class({
-  _value = {0, true},
-  get = {
-    value = function(self) return self._value end  -- Getter only, no setter
-  },
-  constructor = function(self) self._value = 10 end
-})
-local u = User:new()
-local ok = pcall(function() u.value = 20 end)  -- Try to set getter-only property
-assert(not ok, "Test 10 failed: getter modified")
-
-local Parent = class({
-  id = {1, false},
-  constructor = function(self, super, id)
-    self.id = id
-  end
-})
-local Child = class({
-  name = {nil, false},
-  constructor = function(self, super, name, id)
-    super(id)
-    self.name = name
-  end
-}, Parent)
-local c = Child:new("Alice", 100)
-assert(c.id == 100 and c.name == "Alice", "Test 11 failed")
-
--- Test 12: Child inherits parent getters
-local Parent = class({
-  value = {10, false},
-  get = {
-    getValue = function(self) return self.value end
-  },
-  constructor = function(self, super, val)
-    self.value = val
-  end
-})
-local Child = class({
-  name = {nil, false},
-  constructor = function(self, super, name, val)
-    super(val)
-    self.name = name
-  end
-}, Parent)
-local c = Child:new("Test", 42)
-assert(c.getValue == 42, "Test 12 failed")
-
--- Test 13: Child inherits parent setters
-local Parent = class({
-  _value = {0, true},
-  getValue = {function(self) return self._value end, false},
-  set = {
-    value = function(self, val) self._value = val * 2 end
-  },
-  constructor = function(self)
-    self._value = 0
-  end
-})
-local Child = class({
-  name = {nil, false},
-  constructor = function(self, super, name)
-    super()
-    self.name = name
-  end
-}, Parent)
-local c = Child:new("Test")
-c.value = 5
-assert(c.getValue() == 10, "Test 13 failed")
-local Parent = class({
-  secret = {nil, true},  -- private
-  constructor = function(self, super, sec)
-    self.secret = sec
-  end
-})
-local Child = class({
-  name = {nil, false},
-  constructor = function(self, super, name, sec)
-    super(sec)
-    self.name = name
-  end
-}, Parent)
-local c = Child:new("Alice", "password")
-local ok = pcall(function() print(c.secret) end)
-assert(not ok, "Test 14 failed: parent private accessible")
-
--- Test 15: Parent immutable property blocked in child
-local Parent = class({
-  id = {1, false, false, true},  -- immutable
-  constructor = function(self, super, id)
-    self.id = id
-  end
-})
-local Child = class({
-  constructor = function(self, super, id)
-    super(id)
-  end
-}, Parent)
-local c = Child:new(100)
-local ok = pcall(function() c.id = 999 end)
-assert(not ok, "Test 15 failed: parent immutable modified")
-local Parent = class({
-  greet = {function(self) return "Hello from parent" end, false, false, false, true},
-  constructor = function(self) end
-})
-local Child = class({
-  greet = {function(self) return "Hello from child" end, false, false, true, false, true},
-  constructor = function(self, super) super() end
-}, Parent)
-local c = Child:new()
-print(c.greet())  -- Should print "Hello from child", probably prints "Hello from parent"
-local Grandparent = class({
-  id = {1, false},
-  constructor = function(self, super, id)
-    self.id = id
-  end
-})
-local Parent = class({
-  name = {nil, false},
-  constructor = function(self, super, name, id)
-    super(id)
-    self.name = name
-  end
-}, Grandparent)
-local Child = class({
-  age = {nil, false},
-  constructor = function(self, super, age, name, id)
-    super(name, id)
-    self.age = age
-  end
-}, Parent)
-local c = Child:new(20, "Alice", 100)
-assert(c.id == 100 and c.name == "Alice" and c.age == 20, "Test 17 failed")
-local Parent = class({
-  count = {0, false, true},  -- static
-  constructor = function(self) end
-})
-local Child = class({
-  constructor = function(self, super) super() end
-}, Parent)
-assert(Child.count == 0, "Test 18 failed")
--- This might fail - test it
-
-local User = class({
-  name = {nil, false},
-  greet = {function(self) return "Hello " .. self.name end, false},
-  constructor = function(self, super, name)
-    self.name = name
-  end
-})
-local u = User:new("Alice")
-assert(u.greet() == "Hello Alice", "Test 19 failed")
-
--- Test 20: Static methods work
-local User = class({
-  create = {function(self, name) return "Created " .. name end, false, true}, -- 481
-  constructor = function(self) end
-})
-assert(User.create("Alice") == "Created Alice", "Test 20 failed")
-local User = class({
-  name = {nil, false},
-  constructor = function(self, super, name)
-    self.name = name
-  end
-})
-local u1 = User:new("Alice")
-local u2 = User:new("Bob")
-u1.name = "Charlie"
-assert(u1.name == "Charlie" and u2.name == "Bob", "Test 21 failed")
-
--- Test 22: Metatable protection
-local User = class({
-  constructor = function(self) end
-})
-local u = User:new()
-local mt = getmetatable(u)
-assert(mt == "access denied", "Test 22 failed: metatable exposed")
-
--- Test 23: Constructor validation
-local User = class({
-  name = {nil, false},
-  age = {nil, false},
-  constructor = function(self, super, name)
-    self.name = name
-    -- Forgot to set age
-  end
-})
-local ok = pcall(function() User:new("Alice") end)
-assert(not ok, "Test 23 failed: validation missed unset property")
-
-
-local Parent = class({
-  greet = {function(self) return "Hello from parent" end, false, false, false, true}, 
-  constructor = function(self) end
-})
-
-local Child = class({
-  greet = {function(self) return "Hello from child" end, false, false, false, false, true},
-  constructor = function(self, super) super() end
-}, Parent)
-
-local c = Child:new()
-print(c.greet())  -- Should print "Hello from child"
-

package/lua/index.lua

@@ -1,322 +0,0 @@
-assert(_VERSION == "Lua 5.4", "THIS MODULE REQUIRES Lua 5.4")
-
-
----@alias MemberKey string | "get" | "set" | "constructor"
----@alias Member ShorthandedMemberValue | MemberEntries | Getter | Setter | Constructor
----@alias ShorthandedMemberValue number | string | boolean | fun(self: unknown, ...: unknown): unknown?
----@alias MemberEntries {[1]: MemberValue, [2]?: MemberFlag, [3]?: MemberFlag, [4]?: MemberFlag, [5]?: MemberFlag, [6]?: MemberFlag}
----@alias MemberValue number | string | boolean | table | nil | fun(self: unknown, ...: unknown): unknown
----@alias MemberFlag boolean | nil
----@alias Getter fun(self: unknown): unknown
----@alias Setter fun(self: unknown, value: unknown): nil
----@alias Constructor fun(self: unknown, super: fun(...: any): unknown, ...: unknown): unknown
----@alias Members table<string, PropertyFlags>
----@alias MembersValues table<string, MemberValue>
----@alias RawMembers table<MemberKey, Member>
-
----@class PropertyFlags
----@field private MemberFlag
----@field static MemberFlag
----@field final MemberFlag
----@field virtual MemberFlag
----@field override MemberFlag
-
----@param Members RawMembers
----@param Parent? unknown
-local class<const> = function (Members, Parent)
-  ---@type Members
-  local members<const> = {}
-  ---@type MembersValues
-  local membersValues<const> = {}
-  local default<const> = function(existingValue, defaultValue)
-    if existingValue ~= nil then
-      return existingValue
-    else return defaultValue end
-  end
-  ---@type table<string, Getter>
-  local getters<const> = {}
-  ---@type table<string, Setter>
-  local setters<const> = {}
-
-  for memberKey, member in pairs(Members) do
-    assert(member ~= nil, ("syntax error: expected member, got `%s`"):format(type(member)))
-    if memberKey == "constructor" then
-      if type(member) ~= "function" then error(("syntax error: constructor expected `function`, got `%s`"):format(type(member))) end
-    elseif memberKey == "get" then
-      if type(member) ~= "table" then error(("syntax error: get expected `table`, got `%s`"):format(type(member))) end
-      ---@cast member table<string, Getter>
-      for getterKey, getter in pairs(member) do
-        if type(getter) ~= "function" then error(("syntax error: the getters(`%s`) can be only a `function`, got `%s`"):format(getterKey, type(getter))) end
-        local getterInfo<const> = debug.getinfo(getter, "u")
-        if getterInfo.nparams ~= 1 then error(("syntax error: the getters(`%s`) can not have parameters (excluding `self`)"):format(getterKey)) end
-        getters[getterKey] = getter
-      end
-    elseif memberKey == "set" then
-      if type(member) ~= "table" then error(("syntax error: set expected `table`, got `%s`"):format(type(member))) end
-      ---@cast member table<string, Setter>
-      for setterKey, setter in pairs(member) do
-        if type(setter) ~= "function" then error(("syntax error: the setters(`%s`) can be only a `function`, got `%s`"):format(setterKey, type(setter))) end
-        local getterInfo<const> = debug.getinfo(setter, "u")
-        if getterInfo.nparams ~= 2 then error(("syntax error: the setters(`%s`) must have exactly one parameter (excluding `self`)"):format(setterKey)) end
-        setters[setterKey] = setter
-      end
-    else
-      members[memberKey] = {}
-      if type(member) == "table" then
-        membersValues[memberKey] = member[1]
-        members[memberKey] = {
-          private = default(member[2], true),
-          static = default(member[3], false),
-          final = default(member[4], false),
-          virtual = default(member[5], false),
-          override = default(member[6], true),
-        }
-      else
-        membersValues[memberKey] = member
-        members[memberKey] = {
-          private = true,
-          static = false,
-          final = true,
-          virtual = false,
-          override = false,
-        }
-      end
-    end
-  end
-
-  for memberKey, member in pairs(members) do
-    if member.override then
-      if not Parent or not Parent.__extended then
-        error(("cannot override `%s`: no parent class was derived"):format(memberKey))
-      end
-
-      local parentMember<const> = Parent.__extended.members[memberKey]
-      if not parentMember then
-        error(("override failed: no such `%s` parent method"):format(memberKey))
-      end
-
-      if not parentMember.virtual then
-        error(("override denied: the parent method `%s` is not virtual"):format(memberKey))
-      end
-    end
-  end
-
-  if Parent and Parent.__extended then
-    for memberKey, member in pairs(Parent.__extended.members) do
-      if not members[memberKey] then
-        members[memberKey] = member
-        membersValues[memberKey] = Parent.__extended.membersValues[memberKey]
-      else
-        if not members[memberKey].override then
-          error(("method `%s` already exists in parent, did you mean to use the override flag"):format(memberKey))
-        end
-      end
-    end
-
-    for getterKey, getter in pairs(Parent.__extended.getters) do
-      if not getters[getterKey] then
-        getters[getterKey] = getter
-      end
-    end
-
-    for setterKey, setter in pairs(Parent.__extended.setters) do
-      if not setters[setterKey] then
-        setters[setterKey] = setter
-      end
-    end
-  end
-
-  return setmetatable({
-    __extended = {
-      members = members,
-      membersValues = membersValues,
-      getters = getters,
-      setters = setters
-    },
-    new = function(self, ...)
-      ---@type MembersValues
-      local instance<const> = {}
-      for memberKey, member in pairs(members) do
-        if not member.static then
-          instance[memberKey] = membersValues[memberKey]
-        end
-      end
-
-      if Members.constructor and not Parent then
-        Members.constructor(instance, nil, ...)
-      elseif Members.constructor and Parent then
-        local super<const> = function(...)
-          local parentInstance<const> = Parent:new(...)
-
-          local parentMetatable<const> = debug.getmetatable(parentInstance)
-          if parentMetatable and parentMetatable.__instance then
-            for memberKey, memberValue in pairs(parentMetatable.__instance) do
-              local parentMember<const> = Parent.__extended.members[memberKey]
-              if members[memberKey] and members[memberKey].override then
-              elseif parentMember and not parentMember.private then
-                instance[memberKey] = memberValue
-              end
-            end
-          end
-
-          return parentInstance
-        end
-        Members.constructor(instance, super, ...)
-      else error("no constructor was provided") end
-
-      for memberKey, member in pairs(members) do
-        if not instance[memberKey] and not member.static and not member.private then
-          error(("the `%s` was not instantiated in constructor"):format(memberKey))
-        end
-      end
-
-      if Parent and Parent.__extended then
-        for memberKey, member in pairs(Parent.__extended.members) do
-          if not instance[memberKey] and not member.static and not member.private then
-            error(("derived member `%s` was not instantiated"):format(memberKey))
-          end
-        end
-      end
-
-      return setmetatable({}, {
-        __metatable = "access denied",
-        __instance = instance,
-        __index = function(_, memberKey)
-          local member<const> = members[memberKey]
-          if not member then 
-            if getters[memberKey] then
-              return getters[memberKey](instance)
-            elseif Parent and Parent.__extended then
-              local parentMember<const> = Parent.__extended.members[memberKey]
-              if parentMember then
-                if parentMember.private then
-                  error(("`%s` is not a public member"):format(memberKey))
-                end
-                return instance[memberKey]
-              end
-            elseif setters[memberKey] then
-              error(("`%s` setter can not be accessed"):format(memberKey))
-            end
-            error(("`%s` does not exist"):format(memberKey))  
-          end
-          assert(not member.private, ("`%s` is not a public member"):format(memberKey))
-          assert(not member.static, ("`%s` is a static member"):format(memberKey))
-
-          local value<const> = instance[memberKey]
-          if type(value) == "function" then
-            return function(_, ...)
-              return value(instance, ...)
-            end
-          end
-
-          return value
-        end,
-        __newindex = function(_, memberKey, memberValue)
-          if setters[memberKey] then
-            setters[memberKey](instance, memberValue)
-            return
-          end
-
-          local member = members[memberKey]
-
-          if not member and Parent and Parent.__extended then
-            member = Parent.__extended.members[memberKey]
-          end
-
-          if not member then 
-            if getters[memberKey] then
-              error(("getters can not be modified: at `%s`"):format(memberKey))
-            end
-            error(("`%s` does not exist"):format(memberKey))
-          end
-
-          assert(not member.private, ("`%s` is not a public member"):format(memberKey))
-          assert(not member.static, ("`%s` is a static member"):format(memberKey))
-          assert(not member.final, ("`%s` is a readonly member"):format(memberKey))
-
-          instance[memberKey] = memberValue
-        end
-      })
-    end
-  }, {
-    __metatable = "access denied",
-    __index = function(self, memberKey)
-      local member<const> = members[memberKey]
-      if not member then
-        if getters[memberKey] then
-          return getters[memberKey](membersValues)
-        elseif Parent then
-          return Parent[memberKey]
-        elseif setters[memberKey] then
-          error(("setters can not be accessed: at `%s`"):format(memberKey))
-        end
-        error(("`%s` does not exist"):format(memberKey))
-      end
-      assert(not member.private, ("`%s` is not a public member"):format(memberKey))
-      assert(member.static, ("`%s` is not a static member"):format(memberKey))
-      local value<const> = membersValues[memberKey]
-
-      if type(value) == "function" then
-        return function(...)
-          return value(membersValues, ...)
-        end
-      end
-
-      return value
-    end,
-    __newindex = function(self, memberKey, memberValue)
-      local member<const> = members[memberKey]
-      if not member then
-        if setters[memberKey] then
-          setters[memberKey](membersValues, memberValue)
-          return
-        elseif Parent then
-          Parent[memberKey] = memberValue
-          return
-        elseif getters[memberKey] then
-          error(("getters can not be modified: at `%s`"):format(memberKey))
-        end
-        error(("`%s` does not exist"):format(memberKey))
-      end
-      assert(not member.private, ("`%s` is not a public member"):format(memberKey))
-      assert(member.static, ("`%s` is not a static member"):format(memberKey))
-      assert(not member.final, ("`%s` is a readonly member"):format(memberKey))
-      membersValues[memberKey] = memberValue
-    end
-  })
-end
-
-
--- annotation tests section
-local private<const>, static<const>, final<const>, virtual<const>, override<const> = true, true, true, true, true
-class({
-  property1 = 10,
-  property4 = {10},
-  property7 = {10, private, false, final, false, override},
-  property2 = "hello",
-  property5 = {"hello"},
-  property8 = {"hello", false, static, false, virtual, false},
-  property3 = true,
-  property6 = {true},
-  property9 = {true, private, false, final, false, override},
-  property10 = nil, -- SYNTAX ERROR
-  property11 = {nil},
-  property12 = {nil, false, static, false, virtual, false},
-  method1 = function(self) end,
-  method2 = {function(self) end},
-  method3 = {function(self) end, private, false, final, false, override},
-  get = {
-    getter1 = function(self)
-      return self.property1
-    end,
-  },
-  set = {
-    setter1 = function(self, value)
-      self.property1 = value
-    end,
-  },
-  constructor = function(self, super, value)
-    super(value)
-    self.property1 = value
-  end
-})

package/lua/lenix-0.1.0-1.rockspec

@@ -1,25 +0,0 @@
-package = "lenix"
-version = "0.1.0-1"
-
-source = {
-   url = "git+https://github.com/lenixdev/lenix.git",
-   tag = "v0.1.0"
-}
-
-description = {
-   summary = "Lua OOP class module similar to TypeScript/JavaScript/Java/C++ classes",
-   detailed = "Lua object oriented programming class module with support for constructors, getters, setters, inheritance, static members, private members, final members, and virtual/override methods.",
-   homepage = "https://github.com/lenixdev/lenix/lua",
-   license = "MIT"
-}
-
-dependencies = {
-   "lua == 5.4"
-}
-
-build = {
-   type = "builtin",
-   modules = {
-      lenix = "index.lua"
-   }
-}