Update wasmoon and change api

Author: ceifa

README.md

@@ -2,6 +2,8 @@
 
 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.
 
+> Don't use this in production!
+
 ## Usage
 
 You don't need `lua` installed to run demoon, but you need `node` and npm as well, firstly, install demoon globally:

bin/demoon

@@ -1,8 +1,14 @@
 #!/usr/bin/env node
 
-const { start } = require('../src/index');
+const Demoon = require('../src/index');
 
 const snippets = process.argv.splice(2);
 const [entryFile, ...arg] = snippets
 
-start(entryFile, arg)
+const demoon = new Demoon();
+demoon.getLuaEngine()
+    .then(engine => {
+        engine.global.set('arg', arg)
+    }).then(async () => {
+        await demoon.runFile(entryFile)
+    })

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "demoon",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Lua + Node",
   "main": "src/index.js",
   "bin": {
@@ -13,6 +13,6 @@
     "lua"
   ],
   "dependencies": {
-    "wasmoon": "1.12.1"
+    "wasmoon": "1.15.0"
   }
 }

package.json

@@ -1,48 +1,80 @@
-const { LuaFactory, LuaMultiReturn } = require('wasmoon')
+const { LuaFactory, LuaEngine } = require('wasmoon')
 const path = require('path')
 const FunctionClassTypeExtension = require('./legacyclasses')
 const fs = require('fs/promises')
 
-const start = async (entryFile, arg) => {
-    const factory = new LuaFactory(undefined, process.env)
+module.exports = class {
+    /** @returns {Promise<LuaEngine>} */
+    async getLuaEngine() {
+        await this.#setupIfNeeded()
+        return this.#engine
+    }
 
-    const fullEntryFile = path.resolve(process.cwd(), entryFile)
-    const fullStdFile = path.resolve(__dirname, "std.lua")
+    /**
+     *  @param {string} file
+     *  @returns {Promise<void>}
+    */
+    async runFile(file) {
+        await this.#setupIfNeeded()
 
-    await factory.mountFile(fullEntryFile, await fs.readFile(fullEntryFile))
-    await factory.mountFile(fullStdFile, await fs.readFile(fullStdFile))
+        this.#factory.mountFileSync(await this.#factory.getLuaModule(), file, await fs.readFile(file))
 
-    const engine = await factory.createEngine({ injectObjects: true })
+        try {
+            const thread = this.#engine.global.newThread()
+            thread.loadFile(file)
 
-    engine.global.registerTypeExtension(10, new FunctionClassTypeExtension)
-    engine.global.set('arg', arg)
-    engine.global.set('typeof', value => typeof value)
-    engine.global.set('instanceof', (value, type) => value instanceof type)
-    engine.global.set('new', (constructor, ...args) => new constructor(...args))
-    engine.global.set('global', global)
-    engine.global.set('mountFile', factory.mountFileSync.bind(factory))
-    engine.global.set('jsRequire', (modulename, metaDirectory) => {
-        if (metaDirectory) {
-            if (modulename.startsWith('.')) {
-                modulename = path.resolve(metaDirectory, '..', modulename)
-            }
+            this.#engine.global.set('jsRequire', (modulename, metaDirectory) => {
+                if (metaDirectory) {
+                    if (modulename.startsWith('.')) {
+                        modulename = path.resolve(metaDirectory, '..', modulename)
+                    }
 
-            modulename = require.resolve(modulename, { paths: [fullEntryFile] })
-        }
+                    modulename = require.resolve(modulename, { paths: [file] })
+                }
+
+                return module.require(modulename)
+            })
 
-        return module.require(modulename)
-    })
-
-    try {
-        engine.doFileSync(fullStdFile)
-    
-        const thread = engine.global.newThread()
-        thread.loadFile(fullEntryFile)
-    
-        await thread.run(0)
-    } catch (e) {
-        console.error(e)
+            await thread.run(0)
+        } catch (e) {
+            console.error(e)
+        }
     }
-}
 
-module.exports = { start }
+    /** @type {LuaEngine | undefined} */
+    #engine
+
+    /** @type {LuaFactory | undefined} */
+    #factory
+
+    async #setupIfNeeded() {
+        if (this.#factory) return
+
+        this.#factory = new LuaFactory(undefined, process.env)
+        const luamodule = await this.#factory.getLuaModule()
+
+        const fullStdFile = path.resolve(__dirname, "std.lua")
+        this.#factory.mountFileSync(luamodule, fullStdFile, await fs.readFile(fullStdFile))
+
+        this.#engine = await this.#factory.createEngine({ injectObjects: true })
+
+        this.#engine.global.registerTypeExtension(10, new FunctionClassTypeExtension)
+        this.#engine.global.set('typeof', value => typeof value)
+        this.#engine.global.set('instanceof', (value, type) => value instanceof type)
+        this.#engine.global.set('new', (constructor, ...args) => new constructor(...args))
+        this.#engine.global.set('global', global)
+        this.#engine.global.set('mountFile', (path, content) => this.#factory.mountFileSync(luamodule, path, content))
+        this.#engine.global.set('jsRequire', (modulename, metaDirectory) => {
+            if (metaDirectory) {
+                if (modulename.startsWith('.')) {
+                    modulename = path.resolve(metaDirectory, '..', modulename)
+                }
+
+                modulename = require.resolve(modulename)
+            }
+
+            return module.require(modulename)
+        })
+        this.#engine.doFileSync(fullStdFile)
+    }
+}