First commit

Author: ceifa

.gitignore

@@ -0,0 +1 @@
+node_modules/

.npmignore

@@ -0,0 +1,2 @@
+example/
+.vscode/

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "deno.enable": false
+}

README.md

@@ -1 +1,52 @@
-# lunode
+# demoon
+
+You love Lua but the runtime API is very weak and you don't want to handle and learn a lot of different luarock libraries? You came at the right place! This project aims to offer the bests of **Lua** and **NodeJS** together.
+
+## Usage
+
+You don't need `lua` installed to run demoon, but you need `node` and npm as well, firstly, install demoon globally:
+
+```sh
+$: npm i -g demoon
+```
+
+Then run it passing your entry lua file:
+
+```sh
+$: demoon app.lua
+```
+
+## Example
+
+This is a little sample code to demonstrate how demoon is powerful and bridges well with nodeJS:
+```lua
+-- you can require node modules (package.json/node_modules works as well)
+local http = require('http')
+
+-- you can require js modules and lua files
+-- require('./myjsmodule.js')
+-- require('./myluamodule.lua')
+
+local port = os.getenv('PORT') or 8080
+
+function sleep(ms)
+    -- you can use and create promises
+    return Promise.create(function(resolve)
+        setTimeout(resolve, ms)
+    end)
+end
+
+-- top level await works!
+sleep(1000):await()
+
+http.createServer(async(function (req, res)
+    -- you can await inside async bounded functions
+    sleep(1000):await()
+
+    res:write('Hello World!');
+    -- because end is a lua keyword you have to put the '_'
+    res:_end();
+end)):listen(port);
+
+print('Your server is running on port ' .. port .. '!')
+```

bin/demoon

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+const { start } = require('../src/index');
+
+const snippets = process.argv.splice(2);
+const [entryFile] = snippets
+
+start(entryFile)

example/main.lua

@@ -0,0 +1,23 @@
+-- you can require JS module files
+local jssleep = require('./sleep.js')
+-- you can require node modules
+local http = require('http')
+-- you can require Lua files
+local luasleep = require('sleep.lua')
+
+local port = os.getenv('PORT') or 8080
+
+-- yes, we have top level await
+luasleep(1000):await()
+
+-- create a server object:
+http.createServer(async(function (req, res)
+    -- you can await inside async bounded functions
+    jssleep(1000):await()
+
+    res:write('Hello World!'); -- write a response to the client
+    -- because end is a lua keyword you have to put the '_'
+    res:_end(); -- end the response
+end)):listen(port); -- the server object listens on port 8080
+
+print('Your server is running on port ' .. port .. '!')

example/sleep.js

@@ -0,0 +1 @@
+module.exports = ms => new Promise(resolve => setTimeout(resolve, ms))

example/sleep.lua

@@ -0,0 +1,5 @@
+return function(ms)
+    return Promise.create(function(resolve)
+        setTimeout(resolve, ms)
+    end)
+end

package-lock.json

@@ -0,0 +1,18 @@
+{
+  "name": "demoon",
+  "version": "0.0.1",
+  "description": "Lua + Node",
+  "main": "src/index.js",
+  "bin": {
+    "demoon": "bin/demoon"
+  },
+  "author": "ceifa",
+  "repository": "github:ceifa/demoon",
+  "license": "ISC",
+  "keywords": [
+    "lua"
+  ],
+  "dependencies": {
+    "wasmoon": "1.5.0"
+  }
+}

package.json

@@ -0,0 +1,16 @@
+const { resolve } = require('path');
+const { readdir } = require('fs').promises;
+
+async function* walk(dir) {
+    const dirents = await readdir(dir, { withFileTypes: true });
+    for (const dirent of dirents) {
+        const res = resolve(dir, dirent.name);
+        if (dirent.isDirectory()) {
+            yield* walk(res);
+        } else {
+            yield res;
+        }
+    }
+}
+
+module.exports = { walk }

src/file.js

@@ -0,0 +1,45 @@
+const { LuaFactory, decorate } = require('wasmoon')
+const path = require('path')
+const { walk } = require('./file')
+const fs = require('fs').promises
+const proxy = require('./proxy')
+
+const registerDirectory = async (factory, dir) => {
+    for await (const file of walk(dir)) {
+        await factory.mountFile(file, await fs.readFile(file))
+    }
+}
+
+const start = async (entryFile) => {
+    const factory = new LuaFactory()
+
+    await factory.mountFile(path.resolve(process.cwd(), entryFile), await fs.readFile(entryFile))
+    await registerDirectory(factory, path.resolve(__dirname, "std"))
+
+    const lua = await factory.createEngine({ injectObjects: true })
+
+    lua.global.set('new', constructor => new constructor)
+    lua.global.set('global', decorate(global, {
+        reference: true,
+        metatable: proxy
+    }))
+    lua.global.set('mountFile', factory.mountFileSync.bind(factory))
+    lua.global.set('jsRequire', (modulename, metaDirectory) => {
+        if (modulename.startsWith('.')) {
+            modulename = path.resolve(metaDirectory, '..', modulename)
+        }
+
+        return decorate(require(modulename), {
+            reference: true,
+            metatable: proxy
+        })
+    })
+
+    const module = await factory.getModule()
+    module.module.FS.chdir(process.cwd())
+
+    await lua.doFile(path.resolve(__dirname, "std/main.lua"))
+    await lua.doFile(entryFile)
+}
+
+module.exports = { start }

src/index.js

@@ -0,0 +1,105 @@
+const { decorate } = require('wasmoon')
+
+const keywords = [
+    "and", "break", "do", "else", "elseif",
+    "end", "false", "for", "function", "goto", "if",
+    "in", "local", "nil", "not", "or", "repeat",
+    "return", "then", "true", "until", "while"
+]
+
+const proxy = {
+    __index: (t, k) => {
+        let value = t[k]
+
+        if (value === undefined && typeof k === 'string') {
+            const possibleExpectedKey = k.substring(1)
+            if (keywords.includes(possibleExpectedKey) && t[possibleExpectedKey]) {
+                value = t[possibleExpectedKey]
+            }
+        }
+
+        if (['object', 'function'].includes(typeof value)) {
+            if (typeof value === 'function') {
+                value.__lua_self = t
+            }
+
+            return decorate(value, { reference: true, metatable: proxy })
+        }
+
+        return value
+    },
+    __newindex: (t, k, v) => {
+        t[k] = v
+    },
+    __call: (t, ...args) => {
+        // Called with the : syntax, let's bind this
+        if (args[0] === t.__lua_self) {
+            t = t.bind(t.__lua_self)
+            delete args[0]
+            args = args.slice(1)
+        }
+
+        args = args.map(arg => {
+            if (typeof arg === 'function') {
+                return (...luaFunctionArgs) => {
+                    const fixedLuaFunctionArgs = luaFunctionArgs.map(luaFunctionArg => {
+                        if (['object', 'function'].includes(typeof luaFunctionArg)) {
+                            return decorate(luaFunctionArg, { reference: true, metatable: proxy })
+                        }
+
+                        return luaFunctionArg
+                    })
+
+                    return arg(...fixedLuaFunctionArgs)
+                }
+            }
+
+            return arg
+        })
+
+        delete t.__lua_self
+
+        const value = t(...args)
+
+        if (['object', 'function'].includes(typeof value) && value !== Promise.resolve(value)) {
+            return decorate(value, { reference: true, metatable: proxy })
+        }
+
+        return value
+    },
+    __tostring: (t) => {
+        const value = t
+        return value.toString?.() ?? typeof value
+    },
+    __len: (t) => {
+        return t.lenght ?? 0
+    },
+    __pairs: (t) => {
+        const value = t
+        const keys = Object.getOwnPropertyNames(value)
+        let i = 0
+        return new MultiReturn((ob, last) => {
+            const k = keys[i]
+            i = i + 1
+            return k, ob[k]
+        }, t, undefined)
+    },
+    __ipairs: (t) => {
+        const value = t
+
+        const js_inext = (t, i) => {
+            i = i + 1
+            if (i >= value.length) {
+                return undefined
+            }
+            return i, value[i]
+        }
+
+        return js_inext, value, -1
+    },
+    __eq: (t1, t2) => {
+        return t1 === t2
+    },
+}
+
+module.exports = proxy