@tilua-types/roblox 2.1.0 → 3.0.0

package/lowering.mjs

@@ -12,9 +12,13 @@
  *     task.spawn(work, 1)               ->  tilua_roblox.task.spawn(work, 1)
  *
  * Only where Roblox starts a thread. A callback run synchronously — a
- * `table.sort` comparator, `names:map(f)` — has its caller's `xpcall` already,
- * and `coroutine` is left alone: `coroutine.resume` answering `false, err` is
- * part of what it promises.
+ * `table.sort` comparator, `names:map(f)` — has its caller's `xpcall` already.
+ *
+ * And where Luau answers several values, tilua has one — an array. A method
+ * whose type returns a tuple (`workspace:FindPartOnRay(ray)`, `signal:Wait()`)
+ * is called through the runtime's `values`, which gathers them, and so are the
+ * Luau globals that answer several (`string.unpack`, `utf8.codepoint`,
+ * `coroutine.close`).
  *
  * `print`, `error` and the console come from `@tilua-types/lua`, which this
  * package depends on.
@@ -57,6 +61,23 @@ function isSignal(type) {
         m.kind === "object" && m.properties.has("Connect") && m.properties.has("Once") && m.properties.has("Wait"))
 }
 
+/** Luau globals answering several values, which the runtime gathers. */
+const GATHERED_GLOBALS = new Set(["string.unpack", "coroutine.close", "utf8.codepoint", "utf8.codes", "utf8.graphemes"])
+
+/** Does every signature of `receiver`'s `method` return a tuple — several
+ *  values, as tilua has them in one array?
+ *  @type {(receiver: Type | undefined, method: string) => boolean} */
+function returnsSeveral(receiver, method) {
+    const members = parts(receiver)
+    if (!members.length) return false
+    return members.every(m => {
+        if (m.kind !== "object") return false
+        const found = m.properties.get(method)?.type
+        const signatures = !found ? [] : found.kind === "intersection" ? found.types : [found]
+        return signatures.length > 0 && signatures.every(f => f.kind === "function" && f.returns.kind === "tuple")
+    })
+}
+
 /** @type {(type: Type | undefined, className: string) => boolean} */
 function isInstanceOf(type, className) {
     const members = parts(type)
@@ -72,11 +93,20 @@ const plugin = {
         if (SIGNAL_METHODS.has(method) && isSignal(receiver)) return { callee: `${use("roblox")}.${method}` }
         const service = SERVICE_METHODS.get(method)
         if (service !== undefined && isInstanceOf(receiver, service)) return { callee: `${use("roblox")}.${method}` }
+        if (returnsSeveral(receiver, method)) {
+            return { callee: `${use("roblox")}.values`, prepend: [JSON.stringify(method)] }
+        }
+        return undefined
+    },
+
+    globalCall({ name, use }) {
+        if (GATHERED_GLOBALS.has(name)) return { callee: `${use("roblox")}.globals.${name.replace(".", "_")}` }
         return undefined
     },
 
     globalValue({ name, use }) {
         if (name === "task") return `${use("roblox")}.task`
+        if (GATHERED_GLOBALS.has(name)) return `${use("roblox")}.globals.${name.replace(".", "_")}`
         return undefined
     },
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua-types/roblox",
-  "version": "2.1.0",
+  "version": "3.0.0",
   "description": "Luau and the whole Roblox API as tilua types: every class, enum, data type, service and global",
   "license": "ISC",
   "files": [
@@ -15,7 +15,7 @@
     "lowering": "lowering.mjs"
   },
   "dependencies": {
-    "@tilua-types/lua": "^2.1.0"
+    "@tilua-types/lua": "^3.0.0"
   },
   "keywords": [
     "tilua",

package/runtime/roblox.luau

@@ -75,3 +75,50 @@ __NAME__.task = setmetatable({
 		return task.delay(duration, guard(target), ...)
 	end,
 }, { __index = task })
+
+-- Where Luau answers several values, tilua has one: an array. A Roblox method
+-- whose type says it returns several — `workspace:FindPartOnRay(ray)`,
+-- `signal:Wait()`, `cf:ToOrientation()` — is called through this, which
+-- hands its values back as that array.
+function __NAME__.values(name, receiver, ...)
+	return { receiver[name](receiver, ...) }
+end
+
+-- The same for Luau's own globals that answer several values.
+__NAME__.globals = {
+	string_unpack = function(...)
+		return { string.unpack(...) }
+	end,
+	coroutine_close = function(co)
+		return { coroutine.close(co) }
+	end,
+	utf8_codepoint = function(...)
+		return { utf8.codepoint(...) }
+	end,
+	-- An iteration — `{ step, state, first }` — whose steps answer one
+	-- `{ position, code }` each, as a loop walks them.
+	utf8_codes = function(s)
+		local step, state, first = utf8.codes(s)
+		return {
+			function(_, previous)
+				local position, code = step(state, previous ~= nil and previous[1] or first)
+				if position == nil then
+					return nil
+				end
+				return { position, code }
+			end,
+			s,
+			nil,
+		}
+	end,
+	utf8_graphemes = function(s, i, j)
+		local step = utf8.graphemes(s, i, j)
+		return function()
+			local first, last = step()
+			if first == nil then
+				return nil
+			end
+			return { first, last }
+		end
+	end,
+}