cluaupp 1.3.0 → 1.4.0

package/examples/game/libs/Display/_impl/init.luau

@@ -1,269 +0,0 @@
---!strict
--- Services
--- Packages
-local Option = require(script.option)
-
--- Types
-
-type Option<V> = Option.Option<V>
-export type DisplayConfig = {
-	sortKeys: boolean,
-	useMetatable: boolean,
-	indentWith: string
-}
-type OverrideCallback = (
-	value: unknown?,
-	baseIndent: number,
-	display: Display,
-	log: { [any]: true? }
-) -> string?
-type Callback = (value: unknown?, baseIndent: number, display: Display, log: { [any]: true? }) -> string
-type DisplayStruct =  {
-	sortKeys: boolean,
-	useMetatable: boolean,
-	indentWith: string,
-	override: OverrideCallback,
-	callback: Callback
-}
-
-type DisplayImpl = {
-	__index: DisplayImpl,
-	display: (self: Display, value: unknown?, baseIndent: number?, log: { [any]: true? }?) -> string,
-	builder: (self: Display) -> DisplayBuilder
-}
-export type Display = typeof(setmetatable({} :: DisplayStruct, {} :: DisplayImpl))
-type DisplayBuilderImpl = {
-	__index: DisplayBuilderImpl,
-	setSortKeys: (self: DisplayBuilder, sortKeys: boolean) -> DisplayBuilder,
-	setIndentWith: (self: DisplayBuilder, character: string) -> DisplayBuilder,
-	setUseMetatable: (self: DisplayBuilder, useMetatable: boolean) -> DisplayBuilder,
-	setCallback: (self: DisplayBuilder, callback: Callback) -> DisplayBuilder,
-	setOverride: (self: DisplayBuilder, callback: OverrideCallback) -> DisplayBuilder,
-	build: (self: DisplayBuilder) -> Display,
-	display: (self: DisplayBuilder, value: unknown?, baseIndent: number?, log: { [any]: true? }?) -> string
-}
-export type DisplayBuilder = typeof(setmetatable({} :: {}, {} :: DisplayBuilderImpl))
--- Constants
--- Variables
--- References
--- Private Functions
-function constructFrom(struct: DisplayStruct, set: (mutStruct: DisplayStruct) -> ()): DisplayStruct
-	local out = table.clone(struct) :: Display
-	set(out)
-	table.freeze(out)
-	return out
-end
--- Class
-local Display = {} :: DisplayImpl
-Display["__index"] = Display
-
-local DisplayBuilder = {} :: DisplayBuilderImpl
-DisplayBuilder["__index"] = DisplayBuilder
-
-function newDisplayBuilder(struct: DisplayStruct): DisplayBuilder
-	local self = table.clone(struct) :: any
-	setmetatable(self, DisplayBuilder)
-	table.freeze(self)
-	return self
-end
-function newDisplay(struct: DisplayStruct): Display
-	local self = table.clone(struct) :: Display
-	setmetatable(self, Display)
-	table.freeze(self)
-	return self
-end
-
-function Display:display(value: unknown?, baseIndent: number?, logs: { [any]: true? }?): string
-	local override = self.override(value, baseIndent or 0, self, logs or {})
-	if override ~= nil then
-		return override
-	end
-	return self.callback(value, baseIndent or 0, self, logs or {})
-end
-
-function Display:builder(): DisplayBuilder
-	return newDisplayBuilder(self :: DisplayStruct)
-end
-
-function DisplayBuilder:build(): Display
-	return newDisplay(self :: DisplayStruct)
-end
-
-function DisplayBuilder:setSortKeys(sortKeys: boolean): DisplayBuilder
-	return newDisplayBuilder(constructFrom(self, function(mutStruct)
-		mutStruct.sortKeys = sortKeys
-	end)) :: DisplayBuilder
-end
-
-function DisplayBuilder:setUseMetatable(useMetatable): DisplayBuilder
-	return newDisplayBuilder(constructFrom(self, function(mutStruct)
-		mutStruct.useMetatable = useMetatable
-	end)) :: DisplayBuilder
-end
-function DisplayBuilder:setIndentWith(text: string): DisplayBuilder
-	return newDisplayBuilder(constructFrom(self, function(mutStruct)
-		mutStruct.indentWith = text
-	end)) :: DisplayBuilder
-end
-
-function DisplayBuilder:setCallback(callback: Callback): DisplayBuilder
-	return newDisplayBuilder(constructFrom(self, function(mutStruct)
-		mutStruct.callback = callback
-	end)) :: DisplayBuilder
-end
-
-function DisplayBuilder:setOverride(callback: OverrideCallback): DisplayBuilder
-	return newDisplayBuilder(constructFrom(self, function(mutStruct)
-		mutStruct.override = callback
-	end)) :: DisplayBuilder
-end
-
-function DisplayBuilder:display(value, baseIndent, logs): string
-	return self:build():display(value, baseIndent, logs)
-end
-
-function newJsonDisplayBuilder(): DisplayBuilder
-	return newDisplayBuilder({
-		sortKeys = false,
-		indentWith = "",
-		useMetatable = false,
-		override = function(
-			value: unknown?,
-			baseIndent: number,
-			display: Display,
-			log: { [any]: true? }
-		): string?
-			return nil
-		end,
-		callback = function(
-			value: unknown?,
-			baseIndent: number,
-			display: Display,
-			log: { [any]: true? }
-		): string
-			local ov = display.override(value, baseIndent, display, log)
-			if ov ~= nil then
-				return ov
-			end
-			if type(value) == "string" then
-				return '"' .. value:gsub('"', '\\"') .. '"'
-			elseif type(value) == "number" then
-				if value ~= value then
-					return '"NaN"'
-				elseif math.abs(value) == math.huge then
-					return '"Inf"'
-				end
-				return tostring(value)
-			elseif type(value) == "boolean" then
-				return tostring(value)
-			elseif type(value) == "table" then
-				if log[value] then
-					return '"<circular>"'
-				end
-				log[value] = true
-				local meta: { [any]: any? }? = nil
-				pcall(function()
-					meta = getmetatable(value :: any)
-				end)
-				if display.useMetatable and meta and rawget(meta, "__tostring") ~= nil then
-					local str: string?
-					local tostringSuccess, _ = pcall(function()
-						str = tostring(value)
-					end)
-					if tostringSuccess then
-						return `"{str}"`
-					end
-				end
-				local out = {}
-				local isArray = true
-				local keyCount = 0
-				for k, v in pairs(value :: any) do
-					keyCount += 1
-					if type(k) ~= "number" then
-						isArray = false
-						break
-					end
-				end
-				if #(value :: any) == keyCount and isArray then
-					for _, v in ipairs(value :: any) do
-						table.insert(out, display:display(v, baseIndent + 1, log))
-					end
-					if display.indentWith:len() ~= 0 then
-						if #out == 0 then
-							return "[]"
-						end
-						local msg = "["
-						for i, row in ipairs(out) do
-							msg ..= "\n" .. string.rep(display.indentWith, baseIndent + 1) .. row
-							if i ~= #out then
-								msg ..= ","
-							end
-						end
-						msg ..= "\n" .. string.rep(display.indentWith, baseIndent) .. "]"
-						return msg
-					else
-						return "[" .. table.concat(out, ",") .. "]"
-					end
-				else
-					local keyList = {}
-					for k, _ in pairs(value :: any) do
-						table.insert(keyList, k)
-					end
-					if display.sortKeys then
-						table.sort(keyList)
-					end
-					for i, k in ipairs(keyList) do
-						local v = (value :: any)[k]
-						if Option.isOption(v) then
-							local vOpt: Option<unknown> = v
-							if vOpt:isSome() then
-								table.insert(
-									out,
-									display:display(tostring(k), baseIndent + 1, log)
-										.. ": "
-										.. display:display(v, baseIndent + 1, log)
-								)
-							else
-								table.insert(
-									out,
-									display:display(tostring(k), baseIndent + 1, log) .. ": null"
-								)
-							end
-							continue
-						end
-						table.insert(
-							out,
-							display:display(tostring(k), baseIndent + 1, log)
-								.. ": "
-								.. display:display(v, baseIndent + 1, log)
-						)
-					end
-					if display.indentWith:len() ~= 0 then
-						if #out == 0 then
-							return "{}"
-						end
-						local msg = "{"
-						for i, row in ipairs(out) do
-							msg ..= "\n" .. string.rep(display.indentWith, baseIndent + 1) .. row
-							if i ~= #out then
-								msg ..= ","
-							end
-						end
-						msg ..= "\n" .. string.rep(display.indentWith, baseIndent + 1) .. "}"
-						return msg
-					else
-						return "{" .. table.concat(out, ",") .. "}"
-					end
-				end
-			else
-				return `"{tostring(value)}"`
-			end
-		end,
-	})
-end
-
-return {
-	JSON = {
-		new = newJsonDisplayBuilder,
-	},
-}

package/examples/game/libs/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/examples/game/libs/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