cluaupp 1.0.0 → 1.4.0

package/runtime/Display/_impl/option.luau

@@ -1,237 +0,0 @@
---!strict
--- https://doc.rust-lang.org/std/option/enum.Option.html
--- Services
--- Packages
--- Modules
--- Types
-type State = "S" | "N"
-type OptionStruct<V> = {
-	_state: string, --"N" | "S", --replaced for performance reasons
-	_value: V?,
-}
-type Self = any
-type OptionImpl<V> = {
-	-- __index: OptionImpl<V>,
-	-- __tostring: (self: Self) -> string,
-	-- __eq: (self: Self, other: Option<V>) -> boolean,
-	isSome: (self: Self) -> boolean,
-	isNone: (self: Self) -> boolean,
-	inspect: (self: Self, fn: (value: V) -> ()) -> (),
-	match: (self: Self, some: (some: V) -> V, none: () -> V) -> V,
-	map: (self: Self, fn: (some: V) -> V) -> Option<V>, --type swapping with map stuff is technically okay, but I can't get the type engine to recognize that
-	unwrap: (self: Self) -> V,
-	unwrapOr: (self: Self, alt: V) -> V,
-	unwrapOrElse: (self: Self, fn: () -> V) -> V,
-	asNullable: (self: Self) -> V?,
-	expect: (self: Self, msg: string) -> V,
-}
-
-export type Option<V> = OptionImpl<V> -- keeps type simple
--- typeof(setmetatable(
--- 	{} :: {
--- 		_state: string, --"N" | "S", --replaced for performance reasons
--- 		_value: V?,
--- 	},
--- 	{} :: OptionImpl<V>
--- ))
-
--- Constants
-local STATE_SOME: "S" = "S"
-local STATE_NONE: "N" = "N"
--- Variables
--- References
--- Private Functions
--- Class
-local Option = {} :: OptionImpl<unknown>
-
--- Constructors
-local asNone = function(): Option<any> --ideally would be variadic, but this causes so many snags in reality
-	local self: any = setmetatable({
-		_state = STATE_NONE :: string,
-		_value = nil,
-	}, Option :: OptionImpl<any>)
-	table.freeze(self)
-	return self
-end
-
-local asSome = function<V>(some: V): Option<V>
-	assert(typeof(some) ~= "nil", "some() value cannot be nil")
-	local self: any = setmetatable({
-		_state = STATE_SOME :: string,
-		_value = some,
-	}, Option :: OptionImpl<any>)
-	table.freeze(self)
-	return self
-end
-
--- returns true if the option is some, false if it is none
-function Option:isSome(): boolean
-	return self._state == STATE_SOME
-end
-
--- returns true if the option is none, false if it is some
-function Option:isNone(): boolean
-	return self._state == STATE_NONE
-end
-
--- allows for the reading of the value if it exists
-function Option:inspect(fn: (value: unknown) -> ())
-	if self:isSome() then
-		fn(self._value)
-	end
-	return self
-end
-
--- allows for the safe handling of each state
-function Option:match<O>(some: (some: unknown) -> unknown, none: () -> O): unknown
-	if self:isSome() then
-		return some(self._value)
-	else
-		assert(self:isNone())
-		return none()
-	end
-end
-
--- allows for construction of a new option using the value of the current option
--- it works for type switching, but try explaining that to the type engine
-function Option:map(fn: (some: unknown) -> unknown): Option<unknown>
-	if self:isSome() then
-		return asSome(fn(self._value))
-	end
-	return asNone()
-end
-
--- this assumes that the value is some, erroring if it is
-function Option:unwrap()
-	if self:isSome() then
-		return self._value
-	end
-	error("Option is none")
-end
-
--- new quality of life method for interfacing with non-option based systems
-function Option:asNullable()
-	if self:isSome() then
-		return self._value
-	end
-	return nil
-end
-
--- unwrapOr() allows for swapping in the value if the option is none()
-function Option:unwrapOr(alt: unknown): unknown
-	if self:isSome() then
-		return self._value
-	end
-	return alt
-end
-
--- unpack() but with a custom error message
-function Option:expect(msg: string)
-	if self:isSome() then
-		return self._value
-	end
-	error(msg)
-end
-
-function Option:unwrapOrElse(fn: () -> unknown): unknown
-	if self:isSome() then
-		return self._value
-	end
-	return fn()
-end
-
--- these work fine, but add a lot of complexity to the type system and aren't used much
-local DeprecatedOption = Option :: any
-DeprecatedOption.__index = Option
-
--- used for debug readability
-function DeprecatedOption:__tostring()
-	if self:isSome() then
-		return "Some<" .. tostring(self._value) .. ">"
-	end
-	return "None"
-end
-
--- allows for equality checking between options
-function DeprecatedOption:__eq(other: Option<unknown>): boolean
-	if self:isSome() and other:isSome() then
-		local ot: any = other
-		return self._value == ot._value
-	end
-	return self:isNone() and other:isNone()
-end
-
-function DeprecatedOption:mapOr(mapFn: (some: unknown) -> unknown, alt: unknown): Option<unknown>
-	if self:isSome() then
-		return asSome(mapFn(self._value))
-	end
-	return asSome(alt)
-end
-
-function DeprecatedOption:mapOrElse(mapFn: (some: unknown) -> unknown, elseFn: () -> unknown): Option<unknown>
-	if self:isSome() then
-		return asSome(mapFn(self._value))
-	end
-	return asSome(elseFn())
-end
-
--- original name for asNullable, kept for backwards compatibility
-function DeprecatedOption:unpack()
-	return self:asNullable()
-end
-
-return {
-	none = asNone,
-	some = asSome,
-	match = function<VI, VO>(self: Option<VI>, some: (some: VI) -> VO, none: () -> VO): VO
-		if self:isSome() then
-			return some(self:unwrap())
-		else
-			return none()
-		end
-	end,
-	map = function<VI, VO>(self: Option<VI>, fn: (some: VI) -> VO): Option<VO> -- allows support for type swapping
-		if self:isSome() then
-			return asSome(fn(self:unwrap()))
-		else
-			return asNone()
-		end
-	end,
-	isOption = function(value: unknown?): boolean
-		if typeof(value) == "table" then
-			return getmetatable(value :: any) == Option
-		end
-		return false
-	end,
-	-- constructs a runtime type-checker with the same format as osyrisrblx/t
-	type = function<V>(someType: (value: V) -> (boolean, string?)): (value: unknown?) -> (boolean, string?)
-		return function(value: unknown?): (boolean, string?)
-			if typeof(value) == "table" then
-				local mt = getmetatable(value :: any)
-				if mt == Option then
-					local valOpt: Option<V> = value :: Option<V>
-					if valOpt:isSome() then
-						return someType(valOpt:unwrap())
-					end
-					return true, nil
-				end
-			end
-			return false, "Value is not an option"
-		end
-	end,
-	try = function<V>(fn: () -> V | nil): Option<V>
-		local out = fn()
-		if typeof(out) == "nil" then
-			return asNone()
-		else
-			return asSome(out)
-		end
-	end,
-	from = function<V>(v: V | nil): Option<V>
-		if typeof(v) == "nil" then
-			return asNone()
-		else
-			return asSome(v)
-		end
-	end,
-}

package/runtime/Display/init.luau

@@ -1,10 +0,0 @@
---!strict
--- Cluaupp Display — typed border over nightcycle/display (_impl).
-
-local Impl = require(script._impl)
-
-export type DisplayConfig = Impl.DisplayConfig
-export type Display = Impl.Display
-export type DisplayBuilder = Impl.DisplayBuilder
-
-return Impl

package/runtime/Display/option.luau

@@ -1,237 +0,0 @@
---!strict
--- https://doc.rust-lang.org/std/option/enum.Option.html
--- Services
--- Packages
--- Modules
--- Types
-type State = "S" | "N"
-type OptionStruct<V> = {
-	_state: string, --"N" | "S", --replaced for performance reasons
-	_value: V?,
-}
-type Self = any
-type OptionImpl<V> = {
-	-- __index: OptionImpl<V>,
-	-- __tostring: (self: Self) -> string,
-	-- __eq: (self: Self, other: Option<V>) -> boolean,
-	isSome: (self: Self) -> boolean,
-	isNone: (self: Self) -> boolean,
-	inspect: (self: Self, fn: (value: V) -> ()) -> (),
-	match: (self: Self, some: (some: V) -> V, none: () -> V) -> V,
-	map: (self: Self, fn: (some: V) -> V) -> Option<V>, --type swapping with map stuff is technically okay, but I can't get the type engine to recognize that
-	unwrap: (self: Self) -> V,
-	unwrapOr: (self: Self, alt: V) -> V,
-	unwrapOrElse: (self: Self, fn: () -> V) -> V,
-	asNullable: (self: Self) -> V?,
-	expect: (self: Self, msg: string) -> V,
-}
-
-export type Option<V> = OptionImpl<V> -- keeps type simple
--- typeof(setmetatable(
--- 	{} :: {
--- 		_state: string, --"N" | "S", --replaced for performance reasons
--- 		_value: V?,
--- 	},
--- 	{} :: OptionImpl<V>
--- ))
-
--- Constants
-local STATE_SOME: "S" = "S"
-local STATE_NONE: "N" = "N"
--- Variables
--- References
--- Private Functions
--- Class
-local Option = {} :: OptionImpl<unknown>
-
--- Constructors
-local asNone = function(): Option<any> --ideally would be variadic, but this causes so many snags in reality
-	local self: any = setmetatable({
-		_state = STATE_NONE :: string,
-		_value = nil,
-	}, Option :: OptionImpl<any>)
-	table.freeze(self)
-	return self
-end
-
-local asSome = function<V>(some: V): Option<V>
-	assert(typeof(some) ~= "nil", "some() value cannot be nil")
-	local self: any = setmetatable({
-		_state = STATE_SOME :: string,
-		_value = some,
-	}, Option :: OptionImpl<any>)
-	table.freeze(self)
-	return self
-end
-
--- returns true if the option is some, false if it is none
-function Option:isSome(): boolean
-	return self._state == STATE_SOME
-end
-
--- returns true if the option is none, false if it is some
-function Option:isNone(): boolean
-	return self._state == STATE_NONE
-end
-
--- allows for the reading of the value if it exists
-function Option:inspect(fn: (value: unknown) -> ())
-	if self:isSome() then
-		fn(self._value)
-	end
-	return self
-end
-
--- allows for the safe handling of each state
-function Option:match<O>(some: (some: unknown) -> unknown, none: () -> O): unknown
-	if self:isSome() then
-		return some(self._value)
-	else
-		assert(self:isNone())
-		return none()
-	end
-end
-
--- allows for construction of a new option using the value of the current option
--- it works for type switching, but try explaining that to the type engine
-function Option:map(fn: (some: unknown) -> unknown): Option<unknown>
-	if self:isSome() then
-		return asSome(fn(self._value))
-	end
-	return asNone()
-end
-
--- this assumes that the value is some, erroring if it is
-function Option:unwrap()
-	if self:isSome() then
-		return self._value
-	end
-	error("Option is none")
-end
-
--- new quality of life method for interfacing with non-option based systems
-function Option:asNullable()
-	if self:isSome() then
-		return self._value
-	end
-	return nil
-end
-
--- unwrapOr() allows for swapping in the value if the option is none()
-function Option:unwrapOr(alt: unknown): unknown
-	if self:isSome() then
-		return self._value
-	end
-	return alt
-end
-
--- unpack() but with a custom error message
-function Option:expect(msg: string)
-	if self:isSome() then
-		return self._value
-	end
-	error(msg)
-end
-
-function Option:unwrapOrElse(fn: () -> unknown): unknown
-	if self:isSome() then
-		return self._value
-	end
-	return fn()
-end
-
--- these work fine, but add a lot of complexity to the type system and aren't used much
-local DeprecatedOption = Option :: any
-DeprecatedOption.__index = Option
-
--- used for debug readability
-function DeprecatedOption:__tostring()
-	if self:isSome() then
-		return "Some<" .. tostring(self._value) .. ">"
-	end
-	return "None"
-end
-
--- allows for equality checking between options
-function DeprecatedOption:__eq(other: Option<unknown>): boolean
-	if self:isSome() and other:isSome() then
-		local ot: any = other
-		return self._value == ot._value
-	end
-	return self:isNone() and other:isNone()
-end
-
-function DeprecatedOption:mapOr(mapFn: (some: unknown) -> unknown, alt: unknown): Option<unknown>
-	if self:isSome() then
-		return asSome(mapFn(self._value))
-	end
-	return asSome(alt)
-end
-
-function DeprecatedOption:mapOrElse(mapFn: (some: unknown) -> unknown, elseFn: () -> unknown): Option<unknown>
-	if self:isSome() then
-		return asSome(mapFn(self._value))
-	end
-	return asSome(elseFn())
-end
-
--- original name for asNullable, kept for backwards compatibility
-function DeprecatedOption:unpack()
-	return self:asNullable()
-end
-
-return {
-	none = asNone,
-	some = asSome,
-	match = function<VI, VO>(self: Option<VI>, some: (some: VI) -> VO, none: () -> VO): VO
-		if self:isSome() then
-			return some(self:unwrap())
-		else
-			return none()
-		end
-	end,
-	map = function<VI, VO>(self: Option<VI>, fn: (some: VI) -> VO): Option<VO> -- allows support for type swapping
-		if self:isSome() then
-			return asSome(fn(self:unwrap()))
-		else
-			return asNone()
-		end
-	end,
-	isOption = function(value: unknown?): boolean
-		if typeof(value) == "table" then
-			return getmetatable(value :: any) == Option
-		end
-		return false
-	end,
-	-- constructs a runtime type-checker with the same format as osyrisrblx/t
-	type = function<V>(someType: (value: V) -> (boolean, string?)): (value: unknown?) -> (boolean, string?)
-		return function(value: unknown?): (boolean, string?)
-			if typeof(value) == "table" then
-				local mt = getmetatable(value :: any)
-				if mt == Option then
-					local valOpt: Option<V> = value :: Option<V>
-					if valOpt:isSome() then
-						return someType(valOpt:unwrap())
-					end
-					return true, nil
-				end
-			end
-			return false, "Value is not an option"
-		end
-	end,
-	try = function<V>(fn: () -> V | nil): Option<V>
-		local out = fn()
-		if typeof(out) == "nil" then
-			return asNone()
-		else
-			return asSome(out)
-		end
-	end,
-	from = function<V>(v: V | nil): Option<V>
-		if typeof(v) == "nil" then
-			return asNone()
-		else
-			return asSome(v)
-		end
-	end,
-}

package/runtime/EzVisualz/Dropshadow.luau

@@ -1,148 +0,0 @@
-local RunService = game:GetService("RunService");
-local SmartAssert = require(script.Parent.Util);
-
-export type Dropshadow<T...> = {
-	UIInstance: GuiObject,
-	Instance: GuiObject,
-	IsPaused: boolean,
-	Color: Color3,
-	ColorTarget: Color3,
-	ColorAcceleration: number,
-	Transparency: number,
-	TransparencyTarget: number,
-	TransparencyAcceleration: number,
-	Offset: Vector2,
-	OffsetTarget: Vector2,
-	OffsetAcceleration: number,
-	Connection: RBXScriptConnection,
-	IsText: boolean,
-
-	Pause: (self: Dropshadow<T...>) -> nil,
-	Resume: (self: Dropshadow<T...>) -> nil,
-	SetOffset: (self: Dropshadow<T...>, offset: Vector2, acceleration: number) -> nil,
-	SetTransparency: (self: Dropshadow<T...>, transparency: number, acceleration: number) -> nil,
-	SetColor: (self: Dropshadow<T...>, color: Color3, acceleration: number) -> nil,
-	Destroy: (self: Dropshadow<T...>) -> nil,
-};
-
-local Dropshadow = {};
-Dropshadow.__index = Dropshadow;
-
-function Dropshadow.new<T...>(uiInstance: GuiObject | UIStroke, color: Color3?, transparency: number?, offset: Vector2?): Dropshadow<T...>
-	SmartAssert(uiInstance ~= nil, "UIInstance not provided");
-	SmartAssert(uiInstance:IsA("GuiObject") or uiInstance:IsA("UIStroke"), "UIInstance is not a GuiObject or UIStroke");
-	if (color) then
-		SmartAssert(typeof(color) == "Color3", "Color is not a Color3");
-	end;
-	if (transparency) then
-		SmartAssert(typeof(transparency) == "number", "Transparency is not a number");
-	end;
-	if (offset) then
-		SmartAssert(typeof(offset) == "Vector2", "Offset is not a Vector2");
-	end;
-
-	local self = {};
-
-	self.UIInstance = uiInstance;
-	self.Instance = uiInstance:Clone();
-	self.IsPaused = false;
-
-	self.Color = color or Color3.new();
-	self.ColorTarget = color or Color3.new();
-	self.ColorAcceleration = 1;
-	self.Transparency = transparency or 0;
-	self.TransparencyTarget = transparency or 0;
-	self.TransparencyAcceleration = 1;
-	self.Offset = offset or Vector2.new(-4, 4);
-	self.OffsetTarget = offset or Vector2.new();
-	self.OffsetAcceleration = 1;
-	self.Connection = nil;
-	self.IsText = false;
-
-	self.Instance.Size = UDim2.new(1, 0, 1, 0);
-	self.Instance:ClearAllChildren();
-
-	self.Instance.Position = UDim2.new(0, self.Offset.X, 0, self.Offset.Y);
-
-	if (uiInstance:IsA("TextLabel") or uiInstance:IsA("TextBox") or uiInstance:IsA("TextButton")) then
-		self.Instance.TextColor3 = self.Color;
-		self.IsText = true;
-	end;
-
-	self.Instance.Parent = self.UIInstance;
-
-	self.Connection = RunService.Heartbeat:Connect(function(dt)
-		if (self.IsPaused) then
-			return;
-		end;
-
-		if (not self.UIInstance or self.UIInstance.Parent == nil) then
-			self:Destroy();
-			return;
-		end;
-
-		self.Color = self.Color:Lerp(self.ColorTarget, math.min(1, self.ColorAcceleration * dt));
-		self.Offset = self.Offset:Lerp(self.OffsetTarget, math.min(1, self.OffsetAcceleration * dt));
-		self.Transparency = self.Transparency + ((self.TransparencyTarget - self.Transparency) * self.TransparencyAcceleration * dt);
-
-		self.Instance.Position = UDim2.new(0, self.Offset.X, 0, self.Offset.Y);
-
-		if (self.IsText) then
-			self.Instance.Text = self.UIInstance.Text;
-			self.Instance.TextTransparency = self.Transparency;
-			self.Instance.TextColor3 = self.Color;
-		end;
-
-		self.Instance.ZIndex = self.UIInstance.ZIndex - 1;
-	end);
-
-	return setmetatable(self, Dropshadow);
-end
-
-function Dropshadow:SetOffset(offset: Vector2, acceleration: number)
-	-- Accepts a Vector2 as the first argument and a number as the second argument.
-	-- Values below 0 or above 1 for the acceleration argument do not make sense.
-	SmartAssert(typeof(offset) == "Vector2", "Offset isn't a Vector2");
-	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
-
-	self.OffsetTarget = offset;
-	self.OffsetAcceleration = math.clamp(acceleration, 0, 1);
-end
-
-function Dropshadow:SetTransparency(transparency: number, acceleration: number)
-	-- Accepts a number as the first argument and a number as the second argument.
-	-- Values below 0 or above 1 for the acceleration argument do not make sense.
-	SmartAssert(typeof(transparency) == "number", "Transparency isn't a number");
-	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
-
-	self.TransparencyTarget = transparency;
-	self.TransparencyAcceleration = math.clamp(acceleration, 0, 1);
-end
-
-function Dropshadow:SetColor(color: Color3, acceleration: number)
-	-- Accepts a Color3 as the first argument and a number as the second argument.
-	-- Values below 0 or above 1 for the acceleration argument do not make sense.
-	SmartAssert(typeof(color) == "Color3", "Color isn't a Color3");
-	SmartAssert(typeof(acceleration) == "number", "Acceleration isn't a number");
-
-	self.ColorTarget = color;
-	self.ColorAcceleration = math.clamp(acceleration, 0, 1);
-end
-
-function Dropshadow:Pause()
-	self.IsPaused = true;
-end
-
-function Dropshadow:Resume()
-	self.IsPaused = false;
-end
-
-function Dropshadow:Destroy()
-	self.Connection:Disconnect();
-	if (self.Instance) then
-		self.Instance:Destroy();
-		self.Instance = nil;
-	end;
-end
-
-return table.freeze(Dropshadow);