roblox-opencode 1.0.0

package/vendor/rbxutil/buffer-util/DataTypeBuffer.luau

@@ -0,0 +1,223 @@
+--!native
+
+local Types = require(script.Parent.Types)
+
+type ReadWritePair = {
+	read: <T>(reader: Types.BufferReader) -> T,
+	write: <T>(writer: Types.BufferWriter, value: T) -> (),
+}
+
+local DataTypeBuffer = {}
+
+DataTypeBuffer.DataTypesToString = {
+	[BrickColor] = "BrickColor",
+	[CFrame] = "CFrame",
+	[Color3] = "Color3",
+	[DateTime] = "DateTime",
+	[Ray] = "Ray",
+	[Rect] = "Rect",
+	[Region3] = "Region3",
+	[Region3int16] = "Region3int16",
+	[UDim] = "UDim",
+	[UDim2] = "UDim2",
+	[Vector2] = "Vector2",
+	[Vector3] = "Vector3",
+	[Vector2int16] = "Vector2int16",
+	[Vector3int16] = "Vector3int16",
+}
+
+DataTypeBuffer.ReadWrite = {} :: { [string]: ReadWritePair }
+
+DataTypeBuffer.ReadWrite.BrickColor = {
+	write = function(writer: Types.BufferWriter, brickColor: BrickColor)
+		writer:WriteUInt16(brickColor.Number)
+	end,
+
+	read = function(reader: Types.BufferReader): BrickColor
+		local number = reader:ReadUInt16()
+		return BrickColor.new(number)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.CFrame = {
+	write = function(writer: Types.BufferWriter, cf: CFrame)
+		DataTypeBuffer.ReadWrite.Vector3.write(writer, cf.Position)
+		DataTypeBuffer.ReadWrite.Vector3.write(writer, cf.XVector)
+		DataTypeBuffer.ReadWrite.Vector3.write(writer, cf.YVector)
+		DataTypeBuffer.ReadWrite.Vector3.write(writer, cf.ZVector)
+	end,
+
+	read = function(reader: Types.BufferReader): CFrame
+		local pos = DataTypeBuffer.ReadWrite.Vector3.read(reader)
+		local vx = DataTypeBuffer.ReadWrite.Vector3.read(reader)
+		local vy = DataTypeBuffer.ReadWrite.Vector3.read(reader)
+		local vz = DataTypeBuffer.ReadWrite.Vector3.read(reader)
+		return CFrame.fromMatrix(pos, vx, vy, vz)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.Color3 = {
+	write = function(writer: Types.BufferWriter, c: Color3)
+		writer:WriteFloat32(c.R)
+		writer:WriteFloat32(c.G)
+		writer:WriteFloat32(c.B)
+	end,
+
+	read = function(reader: Types.BufferReader): Color3
+		local r = reader:ReadFloat32()
+		local g = reader:ReadFloat32()
+		local b = reader:ReadFloat32()
+		return Color3.new(r, g, b)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.DateTime = {
+	write = function(writer: Types.BufferWriter, dt: DateTime)
+		writer:WriteFloat64(dt.UnixTimestampMillis)
+	end,
+
+	read = function(reader: Types.BufferReader): DateTime
+		local millis = reader:ReadFloat64()
+		return DateTime.fromUnixTimestampMillis(millis)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.Ray = {
+	write = function(writer: Types.BufferWriter, ray: Ray)
+		DataTypeBuffer.ReadWrite.Vector3.write(writer, ray.Origin)
+		DataTypeBuffer.ReadWrite.Vector3.write(writer, ray.Direction)
+	end,
+
+	read = function(reader: Types.BufferReader): Ray
+		local origin = DataTypeBuffer.ReadWrite.Vector3.read(reader)
+		local direction = DataTypeBuffer.ReadWrite.Vector3.read(reader)
+		return Ray.new(origin, direction)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.Rect = {
+	write = function(writer: Types.BufferWriter, rect: Rect)
+		DataTypeBuffer.ReadWrite.Vector3.write(writer, rect.Min)
+		DataTypeBuffer.ReadWrite.Vector3.write(writer, rect.Max)
+	end,
+
+	read = function(reader: Types.BufferReader): Rect
+		local min = DataTypeBuffer.ReadWrite.Vector3.read(reader)
+		local max = DataTypeBuffer.ReadWrite.Vector3.read(reader)
+		return Rect.new(min, max)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.Region3 = {
+	write = function(writer: Types.BufferWriter, region3: Region3)
+		local pos = region3.CFrame.Position
+		local sizeHalf = region3.Size * 0.5
+		local min = pos - sizeHalf
+		local max = pos + sizeHalf
+		DataTypeBuffer.ReadWrite.Vector3.write(writer, min)
+		DataTypeBuffer.ReadWrite.Vector3.write(writer, max)
+	end,
+
+	read = function(reader: Types.BufferReader): Region3
+		local min = DataTypeBuffer.ReadWrite.Vector3.read(reader)
+		local max = DataTypeBuffer.ReadWrite.Vector3.read(reader)
+		return Region3.new(min, max)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.Region3int16 = {
+	write = function(writer: Types.BufferWriter, region3int16: Region3int16)
+		DataTypeBuffer.ReadWrite.Vector3int16.write(writer, region3int16.Min)
+		DataTypeBuffer.ReadWrite.Vector3int16.write(writer, region3int16.Max)
+	end,
+
+	read = function(reader: Types.BufferReader): Region3int16
+		local min = DataTypeBuffer.ReadWrite.Vector3int16.read(reader)
+		local max = DataTypeBuffer.ReadWrite.Vector3int16.read(reader)
+		return Region3int16.new(min, max)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.UDim = {
+	write = function(writer: Types.BufferWriter, udim: UDim)
+		writer:WriteFloat32(udim.Scale)
+		writer:WriteInt32(udim.Offset)
+	end,
+
+	read = function(reader: Types.BufferReader): UDim
+		local scale = reader:ReadFloat32()
+		local offset = reader:ReadInt32()
+		return UDim.new(scale, offset)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.UDim2 = {
+	write = function(writer: Types.BufferWriter, udim2: UDim2)
+		DataTypeBuffer.ReadWrite.UDim.write(writer, udim2.X)
+		DataTypeBuffer.ReadWrite.UDim.write(writer, udim2.Y)
+	end,
+
+	read = function(reader: Types.BufferReader): UDim2
+		local x = DataTypeBuffer.ReadWrite.UDim.read(reader)
+		local y = DataTypeBuffer.ReadWrite.UDim.read(reader)
+		return UDim2.new(x, y)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.Vector2 = {
+	write = function(writer: Types.BufferWriter, v2: Vector2)
+		writer:WriteFloat32(v2.X)
+		writer:WriteFloat32(v2.Y)
+	end,
+
+	read = function(reader: Types.BufferReader): Vector2
+		local x = reader:ReadFloat32()
+		local y = reader:ReadFloat32()
+		return Vector2.new(x, y)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.Vector3 = {
+	write = function(writer: Types.BufferWriter, v3: Vector3)
+		writer:WriteFloat32(v3.X)
+		writer:WriteFloat32(v3.Y)
+		writer:WriteFloat32(v3.Z)
+	end,
+
+	read = function(reader: Types.BufferReader): Vector3
+		local x = reader:ReadFloat32()
+		local y = reader:ReadFloat32()
+		local z = reader:ReadFloat32()
+		return Vector3.new(x, y, z)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.Vector2int16 = {
+	write = function(writer: Types.BufferWriter, v2: Vector2int16)
+		writer:WriteInt16(v2.X)
+		writer:WriteInt16(v2.Y)
+	end,
+
+	read = function(reader: Types.BufferReader): Vector2int16
+		local x = reader:ReadInt16()
+		local y = reader:ReadInt16()
+		return Vector2int16.new(x, y)
+	end,
+}
+
+DataTypeBuffer.ReadWrite.Vector3int16 = {
+	write = function(writer: Types.BufferWriter, v3: Vector3int16)
+		writer:WriteInt16(v3.X)
+		writer:WriteInt16(v3.Y)
+		writer:WriteInt16(v3.Z)
+	end,
+
+	read = function(reader: Types.BufferReader): Vector3int16
+		local x = reader:ReadInt16()
+		local y = reader:ReadInt16()
+		local z = reader:ReadInt16()
+		return Vector3int16.new(x, y, z)
+	end,
+}
+
+return DataTypeBuffer

package/vendor/rbxutil/buffer-util/Types.luau

@@ -0,0 +1,60 @@
+export type DataTypes =
+	| BrickColor
+	| CFrame
+	| Color3
+	| DateTime
+	| Ray
+	| Rect
+	| Region3
+	| Region3int16
+	| UDim
+	| UDim2
+	| Vector2
+	| Vector3
+	| Vector2int16
+	| Vector3int16
+
+export type BufferReader = {
+	ReadInt8: (self: BufferReader) -> number,
+	ReadUInt8: (self: BufferReader) -> number,
+	ReadInt16: (self: BufferReader) -> number,
+	ReadUInt16: (self: BufferReader) -> number,
+	ReadInt32: (self: BufferReader) -> number,
+	ReadUInt32: (self: BufferReader) -> number,
+	ReadFloat32: (self: BufferReader) -> number,
+	ReadFloat64: (self: BufferReader) -> number,
+	ReadBool: (self: BufferReader) -> boolean,
+	ReadString: (self: BufferReader) -> string,
+	ReadStringRaw: (self: BufferReader, length: number) -> string,
+	ReadDataType: <T>(self: BufferReader, dataType: { new: (...any) -> T }) -> T,
+	GetSize: (self: BufferReader) -> number,
+	ResetCursor: (self: BufferReader) -> (),
+	SetCursor: (self: BufferReader, cursorPosition: number) -> (),
+	GetCursor: (self: BufferReader) -> number,
+	GetBuffer: (self: BufferReader) -> buffer,
+}
+
+export type BufferWriter = {
+	WriteInt8: (self: BufferWriter, int8: number) -> (),
+	WriteUInt8: (self: BufferWriter, uint8: number) -> (),
+	WriteInt16: (self: BufferWriter, int16: number) -> (),
+	WriteUInt16: (self: BufferWriter, uint16: number) -> (),
+	WriteInt32: (self: BufferWriter, int32: number) -> (),
+	WriteUInt32: (self: BufferWriter, uint32: number) -> (),
+	WriteFloat32: (self: BufferWriter, f32: number) -> (),
+	WriteFloat64: (self: BufferWriter, f64: number) -> (),
+	WriteBool: (self: BufferWriter, bool: boolean) -> (),
+	WriteString: (self: BufferWriter, str: string, length: number?) -> (),
+	WriteStringRaw: (self: BufferWriter, str: string, length: number?) -> (),
+	WriteDataType: (self: BufferWriter, data: DataTypes) -> (),
+	GetSize: (self: BufferWriter) -> number,
+	GetCapacity: (self: BufferWriter) -> number,
+	ResetCursor: (self: BufferWriter) -> (),
+	SetCursor: (self: BufferWriter, cursorPosition: number) -> (),
+	GetCursor: (self: BufferWriter) -> number,
+	Shrink: (self: BufferWriter) -> (),
+	GetBuffer: (self: BufferWriter) -> buffer,
+	ToString: (self: BufferWriter) -> string,
+}
+
+return nil

package/vendor/rbxutil/buffer-util/index.d.ts

@@ -0,0 +1,153 @@
+declare namespace BufferUtil {
+	type DataTypes =
+		| BrickColor
+		| CFrame
+		| Color3
+		| DateTime
+		| Ray
+		| Rect
+		| Region3
+		| Region3int16
+		| UDim
+		| UDim2
+		| Vector2
+		| Vector3
+		| Vector2int16
+		| Vector3int16;
+
+	interface Util {
+		/** Create a BufferReader from the given `buffer` or string. */
+		reader: (buf: buffer | string | BufferWriter) => BufferReader;
+
+		/** Create a zero-initialized BufferWriter with an optional initial byte capacity. */
+		writer: (initialCapacity?: number) => BufferWriter;
+	}
+
+	interface BufferReader {
+		/** Read a signed 8-bit integer from the buffer. */
+		ReadInt8(): number;
+
+		/** Read an unsigned 8-bit integer from the buffer. */
+		ReadUInt8(): number;
+
+		/** Read a signed 16-bit integer from the buffer. */
+		ReadInt16(): number;
+
+		/** Read an unsigned 16-bit integer from the buffer. */
+		ReadUInt16(): number;
+
+		/** Read a signed 32-bit integer from the buffer. */
+		ReadInt32(): number;
+
+		/** Read an unsigned 32-bit integer from the buffer. */
+		ReadUInt32(): number;
+
+		/** Read a 32-bit single-precision float from the buffer. */
+		ReadFloat32(): number;
+
+		/** Read a 64-bit double-precision float from the buffer. */
+		ReadFloat64(): number;
+
+		/** Read a bool from the buffer. */
+		ReadBool(): boolean;
+
+		/** Read a string from the buffer. */
+		ReadString(): string;
+
+		/** Read a raw string from the buffer. */
+		ReadStringRaw(length: number): string;
+
+		/** Read a DataType from the buffer. */
+		ReadDataType<T extends DataTypes>(dataType: new (...args: unknown[]) => T): T;
+
+		/** Returns the position of the cursor. */
+		GetCursor(): number;
+
+		/** Sets the position of the cursor. */
+		SetCursor(position: number): void;
+
+		/** Resets the position of the cursor. */
+		ResetCursor(): void;
+
+		/** Returns the size of the buffer. */
+		GetSize(): number;
+
+		/** Returns the `buffer` object. */
+		GetBuffer(): buffer;
+	}
+
+	interface BufferWriter {
+		/** Write a signed 8-bit integer to the buffer. */
+		WriteInt8(int8: number): void;
+
+		/** Write an unsigned 8-bit integer to the buffer. */
+		WriteUInt8(uint8: number): void;
+
+		/** Write a signed 16-bit integer to the buffer. */
+		WriteInt16(int16: number): void;
+
+		/** Write an unsigned 16-bit integer to the buffer. */
+		WriteUInt16(uint16: number): void;
+
+		/** Write a signed 32-bit integer to the buffer. */
+		WriteInt32(int32: number): void;
+
+		/** Write an unsigned 32-bit integer to the buffer. */
+		WriteUInt32(uint32: number): void;
+
+		/** Write a 32-bit single-precision float to the buffer. */
+		WriteFloat32(f32: number): void;
+
+		/** Write a 64-bit double-precision float to the buffer. */
+		WriteFloat64(f64: number): void;
+
+		/** Write a boolean to the buffer. */
+		WriteBool(bool: boolean): void;
+
+		/** Write a string to the buffer, with an optional `length` of bytes taken from the string. */
+		WriteString(str: string, length?: number): void;
+
+		/** Write a raw string to the buffer, with an optional `length` of bytes taken from the string. */
+		WriteStringRaw(str: string, length?: number): void;
+
+		/** Write a DataType to the buffer. */
+		WriteDataType<T extends DataTypes>(data: T): void;
+
+		/** Shrinks the capacity of the buffer to the current data size. */
+		Shrink(): void;
+
+		/**
+		 * 	Returns the current data size of the buffer. This is _not_ necessarily
+		 *  equal to the capacity of the buffer.
+		 */
+		GetSize(): number;
+
+		/**
+		 * Returns the current capacity of the buffer. This is the length of the
+		 * internal buffer, which is usually not the same as the length of the stored
+		 * data.
+		 *
+		 * The buffer capacity automatically grows as data is added.
+		 */
+		GetCapacity(): number;
+
+		/** Returns the `buffer` object. */
+		GetBuffer(): buffer;
+
+		/** Sets the position of the cursor. */
+		SetCursor(position: number): void;
+
+		/** Gets the position of the cursor. */
+		GetCursor(): number;
+
+		/** Resets the position of the cursor. */
+		ResetCursor(): number;
+
+		/** Returns the string version of the internal buffer. */
+		ToString(): string;
+	}
+}
+
+declare const BufferUtil: BufferUtil.Util;
+
+export = BufferUtil;

package/vendor/rbxutil/buffer-util/init.luau

@@ -0,0 +1,41 @@
+--!native
+
+local BufferReader = require(script.BufferReader)
+local BufferWriter = require(script.BufferWriter)
+
+--[=[
+	@class BufferUtil
+]=]
+
+--[=[
+	@within BufferUtil
+	@function reader
+	@param buf buffer | string
+	@return BufferReader
+
+	Creates a BufferReader. The reader can be constructed from either
+	a string or a `buffer` object.
+
+	```lua
+	local reader = BufferUtil.reader()
+	```
+]=]
+
+--[=[
+	@within BufferUtil
+	@function writer
+	@param initialCapacity number?
+	@return BufferWriter
+
+	Creates a zero-initialized BufferWriter. An initial capacity can
+	optionally be set, and is defaulted to `0`.
+
+	```lua
+	local writer = BufferUtil.writer()
+	```
+]=]
+
+return {
+	reader = BufferReader.new,
+	writer = BufferWriter.new,
+}

package/vendor/rbxutil/buffer-util/package.json

@@ -0,0 +1,16 @@
+{
+	"name": "@rbxutil/buffer-util",
+	"version": "0.3.2",
+	"main": "init.luau",
+	"repository": "github:Sleitnick/RbxUtil",
+	"license": "MIT",
+	"types": "index.d.ts",
+	"files": [
+		"./",
+		"!*.toml",
+		"!*.json"
+	],
+	"publishConfig": {
+		"access": "public"
+	}
+}

package/vendor/rbxutil/buffer-util/wally.toml

@@ -0,0 +1,9 @@
+[package]
+name = "sleitnick/buffer-util"
+description = "Buffer utilities"
+version = "0.3.2"
+license = "MIT"
+authors = ["Stephen Leitnick"]
+registry = "https://github.com/UpliftGames/wally-index"
+realm = "shared"
+exclude = ["node_modules", "package.json", "**/*.ts", "**/*.test.luau"]