@tilua-types/roblox 3.0.0 → 4.1.0

package/index.d.tilua

@@ -21,187 +21,189 @@
 -- ...), copied from scripts/luau.d.tilua — Luau is Roblox's, so they ship
 -- together. The Lua 5.1 standard library underneath is `@tilua-types/lua`.
 
--- What Luau adds to Lua 5.1.
---
--- This file is hand-written and is copied verbatim into the head of
--- packages/roblox/index.d.tilua by generate-roblox.mjs: Luau is Roblox's, so
--- the two ship as one library rather than two. `@tilua-types/lua` underneath has the
--- standard library this builds on, and a name declared in both keeps what Lua
--- gave it — declarations merge, overloads accumulate — so `table` here is
--- Lua's `table` plus these members.
---
--- Edit this file, then regenerate the Roblox definitions.
-
--- ============================================================
--- `typeof()`
--- ------------------------------------------------------------
--- Luau's own: `type()`'s answers plus the Roblox data types further down this
--- file, which it reports by name rather than as `userdata`. Narrowing works
--- exactly as it does for `type()` — see `@tilua-types/lua` for how the overloads
--- drive it.
--- ============================================================
-
-declare function typeof(value: nil): "nil"
-declare function typeof(value: boolean): "boolean"
-declare function typeof(value: number): "number"
-declare function typeof(value: string): "string"
-declare function typeof(value: thread): "thread"
-declare function typeof(value: buffer): "buffer"
-declare function typeof(value: (...args: unknown[]) => unknown): "function"
-declare function typeof(value: { [unknown]: unknown }): "table"
-declare function typeof<T>(value: T): string
-
--- Luau's `type()` knows one answer Lua's does not.
-declare function type(value: buffer): "buffer"
-
--- ============================================================
--- Base library
--- ============================================================
-
--- Not Lua's, but every Luau host provides it.
-declare function warn(...args: unknown[]): nil
-declare function rawlen(t: unknown): number
-
-declare debug: {
-    info: (...args: unknown[]) => unknown,
-    profilebegin: (label: string) => nil,
-    profileend: () => nil,
-    setmemorycategory: (tag: string) => nil,
-    resetmemorycategory: () => nil,
-    dumpcodesize: () => nil,
-}
-
-declare string: {
-    split: (s: string, separator?: string) => string[],
-    -- Binary packing, from Lua 5.3. `unpack` answers the values it read and
-    -- then the position it stopped at, as one array.
-    pack: (format: string, ...args: unknown[]) => string,
-    packsize: (format: string) => number,
-    unpack: (format: string, data: string, pos?: number) => [...unknown[]],
-}
-
--- And a string answers to it: `text:split(",")`. The rest of the methods a
--- string has are in `@tilua-types/lua`.
-type StringMethods = {
-    split: (self: string, separator?: string) => string[],
-}
-
-declare math: {
-    clamp: (x: number, min: number, max: number) => number,
-    round: (x: number) => number,
-    sign: (x: number) => number,
-    -- Perlin noise; the unwritten coordinates are 0.
-    noise: (x: number, y?: number, z?: number) => number,
-    lerp: (a: number, b: number, t: number) => number,
-    map: (x: number, inmin: number, inmax: number, outmin: number, outmax: number) => number,
-    isnan: (n: number) => boolean,
-    isinf: (n: number) => boolean,
-    isfinite: (n: number) => boolean,
-}
-
-declare table: {
-    find: <T>(t: T[], value: T, init?: number) => number | nil,
-    clear: (t: unknown) => nil,
-    clone: <T>(t: T) => T,
-    freeze: <T>(t: T) => T,
-    isfrozen: (t: unknown) => boolean,
-    -- `create(n)` with no value fills with nil, and `T` is whatever the
-    -- annotation on the left says.
-    create: <T>(count: number, value?: T) => T[],
-    pack: (...args: unknown[]) => { n: number, [number]: unknown },
-    unpack: <T>(list: T[], i?: number, j?: number) => [...T[]],
-    move: <T>(src: T[], a: number, b: number, t: number, dst?: T[]) => T[],
-}
-
-declare coroutine: {
-    isyieldable: () => boolean,
-    -- Closes a suspended coroutine: `[true]`, or `[false, error]`.
-    close: (co: thread) => [boolean, unknown],
-}
-
-declare utf8: {
-    char: (...args: number[]) => string,
-    codepoint: (s: string, i?: number, j?: number) => [...number[]],
-    len: (s: string, i?: number, j?: number) => number | nil,
-    offset: (s: string, n: number, i?: number) => number | nil,
-    nfdnormalize: (s: string) => string,
-    nfcnormalize: (s: string) => string,
-    -- `for (const [position, code] in utf8.codes(s))`.
-    codes: (s: string) => Iteration<string, [number, number]>,
-    -- `for (const [first, last] in utf8.graphemes(s))`: where each grapheme
-    -- cluster starts and ends, as byte positions.
-    graphemes: (s: string, i?: number, j?: number) => () => [number, number] | nil,
-    charpattern: string,
-}
-
-declare bit32: {
-    band: (...args: number[]) => number,
-    bor: (...args: number[]) => number,
-    bxor: (...args: number[]) => number,
-    bnot: (x: number) => number,
-    -- True when the bitwise AND of its arguments is not zero.
-    btest: (...args: number[]) => boolean,
-    lshift: (x: number, disp: number) => number,
-    rshift: (x: number, disp: number) => number,
-    arshift: (x: number, disp: number) => number,
-    extract: (n: number, field: number, width?: number) => number,
-    replace: (n: number, v: number, field: number, width?: number) => number,
-    countlz: (n: number) => number,
-    countrz: (n: number) => number,
-    lrotate: (x: number, disp: number) => number,
-    rrotate: (x: number, disp: number) => number,
-    byteswap: (n: number) => number,
-}
-
-declare buffer: {
-    create: (size: number) => buffer,
-    fromstring: (s: string) => buffer,
-    tostring: (b: buffer) => string,
-    len: (b: buffer) => number,
-    readi8: (b: buffer, offset: number) => number,
-    readu8: (b: buffer, offset: number) => number,
-    readi16: (b: buffer, offset: number) => number,
-    readu16: (b: buffer, offset: number) => number,
-    readi32: (b: buffer, offset: number) => number,
-    readu32: (b: buffer, offset: number) => number,
-    readf32: (b: buffer, offset: number) => number,
-    readf64: (b: buffer, offset: number) => number,
-    readbits: (b: buffer, bitOffset: number, bitCount: number) => number,
-    readstring: (b: buffer, offset: number, count: number) => string,
-    writei8: (b: buffer, offset: number, value: number) => nil,
-    writeu8: (b: buffer, offset: number, value: number) => nil,
-    writei16: (b: buffer, offset: number, value: number) => nil,
-    writeu16: (b: buffer, offset: number, value: number) => nil,
-    writei32: (b: buffer, offset: number, value: number) => nil,
-    writeu32: (b: buffer, offset: number, value: number) => nil,
-    writef32: (b: buffer, offset: number, value: number) => nil,
-    writef64: (b: buffer, offset: number, value: number) => nil,
-    writebits: (b: buffer, bitOffset: number, bitCount: number, value: number) => nil,
-    writestring: (b: buffer, offset: number, value: string, count?: number) => nil,
-    copy: (dst: buffer, dstOffset: number, src: buffer, srcOffset?: number, count?: number) => nil,
-    fill: (b: buffer, offset: number, value: number, count?: number) => nil,
-}
-
--- Luau's own vector library. In Roblox a vector *is* a `Vector3` — the same
--- value, and what every engine API that takes one expects — so that is what
--- these are typed as, rather than an opaque type nothing else would accept.
-declare vector: {
-    create: (x: number, y: number, z: number) => Vector3,
-    magnitude: (vec: Vector3) => number,
-    normalize: (vec: Vector3) => Vector3,
-    cross: (vec1: Vector3, vec2: Vector3) => Vector3,
-    dot: (vec1: Vector3, vec2: Vector3) => number,
-    angle: (vec1: Vector3, vec2: Vector3, axis?: Vector3) => number,
-    floor: (vec: Vector3) => Vector3,
-    ceil: (vec: Vector3) => Vector3,
-    abs: (vec: Vector3) => Vector3,
-    sign: (vec: Vector3) => Vector3,
-    clamp: (vec: Vector3, min: Vector3, max: Vector3) => Vector3,
-    lerp: (vec1: Vector3, vec2: Vector3, alpha: number) => Vector3,
-    max: (...args: Vector3[]) => Vector3,
-    min: (...args: Vector3[]) => Vector3,
-    zero: Vector3,
-    one: Vector3,
+-- What Luau adds to Lua 5.1.
+--
+-- This file is hand-written and is copied verbatim into the head of
+-- packages/roblox/index.d.tilua by generate-roblox.mjs: Luau is Roblox's, so
+-- the two ship as one library rather than two. `@tilua-types/lua` underneath has the
+-- standard library this builds on, and a name declared in both keeps what Lua
+-- gave it — declarations merge, overloads accumulate — so `table` here is
+-- Lua's `table` plus these members.
+--
+-- Edit this file, then regenerate the Roblox definitions.
+
+-- ============================================================
+-- `typeof()`
+-- ------------------------------------------------------------
+-- Luau's own: `type()`'s answers plus the Roblox data types further down this
+-- file, which it reports by name rather than as `userdata`. Narrowing works
+-- exactly as it does for `type()` — see `@tilua-types/lua` for how the overloads
+-- drive it.
+-- ============================================================
+
+declare function typeof(value: nil): "nil"
+declare function typeof(value: boolean): "boolean"
+declare function typeof(value: number): "number"
+declare function typeof(value: string): "string"
+declare function typeof(value: thread): "thread"
+declare function typeof(value: buffer): "buffer"
+declare function typeof(value: (...args: unknown[]) => unknown): "function"
+declare function typeof(value: { [unknown]: unknown }): "table"
+declare function typeof<T>(value: T): string
+
+-- Luau's `type()` knows one answer Lua's does not.
+declare function type(value: buffer): "buffer"
+
+-- ============================================================
+-- Base library
+-- ============================================================
+
+-- Not Lua's, but every Luau host provides it.
+declare function warn(...args: unknown[]): nil
+declare function rawlen(t: unknown): number
+
+declare debug: {
+    info: (...args: unknown[]) => unknown,
+    profilebegin: (label: string) => nil,
+    profileend: () => nil,
+    setmemorycategory: (tag: string) => nil,
+    resetmemorycategory: () => nil,
+    dumpcodesize: () => nil,
+}
+
+declare string: {
+    split: (s: string, separator?: string) => string[],
+    -- Binary packing, from Lua 5.3. `unpack` answers the values it read and
+    -- then the position it stopped at, as one array.
+    pack: (format: string, ...args: unknown[]) => string,
+    packsize: (format: string) => number,
+    unpack: (format: string, data: string, pos?: number) => [...unknown[]],
+}
+
+-- And a string answers to it: `text:split(",")`. Luau's string metatable
+-- has it, so it is added to the language's, and stays a plain method call.
+declare metatable string: {
+    __index: {
+        split: (self: string, separator?: string) => string[],
+    },
+}
+
+declare math: {
+    clamp: (x: number, min: number, max: number) => number,
+    round: (x: number) => number,
+    sign: (x: number) => number,
+    -- Perlin noise; the unwritten coordinates are 0.
+    noise: (x: number, y?: number, z?: number) => number,
+    lerp: (a: number, b: number, t: number) => number,
+    map: (x: number, inmin: number, inmax: number, outmin: number, outmax: number) => number,
+    isnan: (n: number) => boolean,
+    isinf: (n: number) => boolean,
+    isfinite: (n: number) => boolean,
+}
+
+declare table: {
+    find: <T>(t: T[], value: T, init?: number) => number | nil,
+    clear: (t: unknown) => nil,
+    clone: <T>(t: T) => T,
+    freeze: <T>(t: T) => T,
+    isfrozen: (t: unknown) => boolean,
+    -- `create(n)` with no value fills with nil, and `T` is whatever the
+    -- annotation on the left says.
+    create: <T>(count: number, value?: T) => T[],
+    pack: (...args: unknown[]) => { n: number, [number]: unknown },
+    unpack: <T>(list: T[], i?: number, j?: number) => [...T[]],
+    move: <T>(src: T[], a: number, b: number, t: number, dst?: T[]) => T[],
+}
+
+declare coroutine: {
+    isyieldable: () => boolean,
+    -- Closes a suspended coroutine: `[true]`, or `[false, error]`.
+    close: (co: thread) => [boolean, unknown],
+}
+
+declare utf8: {
+    char: (...args: number[]) => string,
+    codepoint: (s: string, i?: number, j?: number) => [...number[]],
+    len: (s: string, i?: number, j?: number) => number | nil,
+    offset: (s: string, n: number, i?: number) => number | nil,
+    nfdnormalize: (s: string) => string,
+    nfcnormalize: (s: string) => string,
+    -- `for (const [position, code] in utf8.codes(s))`.
+    codes: (s: string) => Iteration<string, [number, number]>,
+    -- `for (const [first, last] in utf8.graphemes(s))`: where each grapheme
+    -- cluster starts and ends, as byte positions.
+    graphemes: (s: string, i?: number, j?: number) => () => [number, number] | nil,
+    charpattern: string,
+}
+
+declare bit32: {
+    band: (...args: number[]) => number,
+    bor: (...args: number[]) => number,
+    bxor: (...args: number[]) => number,
+    bnot: (x: number) => number,
+    -- True when the bitwise AND of its arguments is not zero.
+    btest: (...args: number[]) => boolean,
+    lshift: (x: number, disp: number) => number,
+    rshift: (x: number, disp: number) => number,
+    arshift: (x: number, disp: number) => number,
+    extract: (n: number, field: number, width?: number) => number,
+    replace: (n: number, v: number, field: number, width?: number) => number,
+    countlz: (n: number) => number,
+    countrz: (n: number) => number,
+    lrotate: (x: number, disp: number) => number,
+    rrotate: (x: number, disp: number) => number,
+    byteswap: (n: number) => number,
+}
+
+declare buffer: {
+    create: (size: number) => buffer,
+    fromstring: (s: string) => buffer,
+    tostring: (b: buffer) => string,
+    len: (b: buffer) => number,
+    readi8: (b: buffer, offset: number) => number,
+    readu8: (b: buffer, offset: number) => number,
+    readi16: (b: buffer, offset: number) => number,
+    readu16: (b: buffer, offset: number) => number,
+    readi32: (b: buffer, offset: number) => number,
+    readu32: (b: buffer, offset: number) => number,
+    readf32: (b: buffer, offset: number) => number,
+    readf64: (b: buffer, offset: number) => number,
+    readbits: (b: buffer, bitOffset: number, bitCount: number) => number,
+    readstring: (b: buffer, offset: number, count: number) => string,
+    writei8: (b: buffer, offset: number, value: number) => nil,
+    writeu8: (b: buffer, offset: number, value: number) => nil,
+    writei16: (b: buffer, offset: number, value: number) => nil,
+    writeu16: (b: buffer, offset: number, value: number) => nil,
+    writei32: (b: buffer, offset: number, value: number) => nil,
+    writeu32: (b: buffer, offset: number, value: number) => nil,
+    writef32: (b: buffer, offset: number, value: number) => nil,
+    writef64: (b: buffer, offset: number, value: number) => nil,
+    writebits: (b: buffer, bitOffset: number, bitCount: number, value: number) => nil,
+    writestring: (b: buffer, offset: number, value: string, count?: number) => nil,
+    copy: (dst: buffer, dstOffset: number, src: buffer, srcOffset?: number, count?: number) => nil,
+    fill: (b: buffer, offset: number, value: number, count?: number) => nil,
+}
+
+-- Luau's own vector library. In Roblox a vector *is* a `Vector3` — the same
+-- value, and what every engine API that takes one expects — so that is what
+-- these are typed as, rather than an opaque type nothing else would accept.
+declare vector: {
+    create: (x: number, y: number, z: number) => Vector3,
+    magnitude: (vec: Vector3) => number,
+    normalize: (vec: Vector3) => Vector3,
+    cross: (vec1: Vector3, vec2: Vector3) => Vector3,
+    dot: (vec1: Vector3, vec2: Vector3) => number,
+    angle: (vec1: Vector3, vec2: Vector3, axis?: Vector3) => number,
+    floor: (vec: Vector3) => Vector3,
+    ceil: (vec: Vector3) => Vector3,
+    abs: (vec: Vector3) => Vector3,
+    sign: (vec: Vector3) => Vector3,
+    clamp: (vec: Vector3, min: Vector3, max: Vector3) => Vector3,
+    lerp: (vec1: Vector3, vec2: Vector3, alpha: number) => Vector3,
+    max: (...args: Vector3[]) => Vector3,
+    min: (...args: Vector3[]) => Vector3,
+    zero: Vector3,
+    one: Vector3,
 }
 
 type ContentId = string

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua-types/roblox",
-  "version": "3.0.0",
+  "version": "4.1.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": "^3.0.0"
+    "@tilua-types/lua": "^4.0.0"
   },
   "keywords": [
     "tilua",