cluaupp 0.1.0

package/runtime/Display/option.luau

@@ -0,0 +1,237 @@
+--!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

@@ -0,0 +1,148 @@
+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);