@rbxts/react-clean-ui 1.0.5

package/out/Contexts/navigation.context.d.ts

@@ -0,0 +1,5 @@
+import React from "@rbxts/react";
+export interface NavigationContextValue {
+    collapsed: boolean;
+}
+export declare const NavigationContext: React.Context<NavigationContextValue>;

package/out/Contexts/navigation.context.luau

@@ -0,0 +1,9 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local React = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local NavigationContext = React.createContext({
+	collapsed = false,
+})
+return {
+	NavigationContext = NavigationContext,
+}

package/out/Contexts/overlay.context.d.ts

@@ -0,0 +1,13 @@
+import React from "@rbxts/react";
+export interface OverlayContextValue {
+    overlay?: Frame;
+}
+export declare const OverlayContext: React.Context<OverlayContextValue>;
+export interface OverlayProviderProps {
+    children?: React.ReactNode;
+}
+interface OverlayConsumerProps {
+    render: (overlay: Frame | undefined) => React.ReactNode;
+}
+export declare function OverlayConsumer(props: OverlayConsumerProps): React.ReactNode;
+export {};

package/out/Contexts/overlay.context.luau

@@ -0,0 +1,17 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local React = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local OverlayContext = React.createContext({})
+local function OverlayConsumer(props)
+	local overlayContext = React.useContext(OverlayContext)
+	local _props = props
+	local _result = overlayContext
+	if _result ~= nil then
+		_result = _result.overlay
+	end
+	return _props.render(_result)
+end
+return {
+	OverlayConsumer = OverlayConsumer,
+	OverlayContext = OverlayContext,
+}

package/out/Contexts/row.context.d.ts

@@ -0,0 +1,9 @@
+import React from "@rbxts/react";
+import { Breakpoint } from "../Interfaces/clean.element.props";
+export interface RowContextValue {
+    width: number;
+    breakpoint: Breakpoint;
+    padding: UDim;
+    children: number;
+}
+export declare const RowContext: React.Context<RowContextValue>;

package/out/Contexts/row.context.luau

@@ -0,0 +1,12 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local React = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local RowContext = React.createContext({
+	width = 0,
+	padding = UDim.new(0, 0),
+	breakpoint = "xl",
+	children = 0,
+})
+return {
+	RowContext = RowContext,
+}

package/out/Contexts/theme.context.d.ts

@@ -0,0 +1,3 @@
+import React from "@rbxts/react";
+import { CleanTheme } from "../Theme/CleanTheme";
+export declare const CleanThemeContext: React.Context<CleanTheme>;

package/out/Contexts/theme.context.luau

@@ -0,0 +1,8 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local React = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local DefaultTheme = TS.import(script, script.Parent.Parent, "Theme", "themes", "default.theme").DefaultTheme
+local CleanThemeContext = React.createContext(DefaultTheme)
+return {
+	CleanThemeContext = CleanThemeContext,
+}

package/out/Helpers/breakpoint.helper.d.ts

@@ -0,0 +1,7 @@
+import { Breakpoint, BreakpointValue } from "../Interfaces/";
+export declare class BreakpointHelper {
+    private static readonly breakpointOrder;
+    static getValue<T>(breakpoint: Breakpoint, value?: BreakpointValue<T>): T | undefined;
+    static compare(left: Breakpoint, operator: ">" | ">=" | "<" | "<=" | "==" | "!=", right: Breakpoint): boolean;
+    static getBreakpoint(width: number, breakpoints: BreakpointValue<number>): Breakpoint;
+}

package/out/Helpers/breakpoint.helper.luau

@@ -0,0 +1,124 @@
+-- Compiled with roblox-ts v3.0.0
+local BreakpointHelper
+do
+	BreakpointHelper = setmetatable({}, {
+		__tostring = function()
+			return "BreakpointHelper"
+		end,
+	})
+	BreakpointHelper.__index = BreakpointHelper
+	function BreakpointHelper.new(...)
+		local self = setmetatable({}, BreakpointHelper)
+		return self:constructor(...) or self
+	end
+	function BreakpointHelper:constructor()
+	end
+	function BreakpointHelper:getValue(breakpoint, value)
+		if value == nil then
+			return nil
+		end
+		repeat
+			local _fallthrough = false
+			if breakpoint == "xl" then
+				local _condition = value.xl
+				if _condition == nil then
+					_condition = value.lg
+					if _condition == nil then
+						_condition = value.md
+						if _condition == nil then
+							_condition = value.sm
+							if _condition == nil then
+								_condition = value.xs
+							end
+						end
+					end
+				end
+				return _condition
+			end
+			if breakpoint == "lg" then
+				local _condition = value.lg
+				if _condition == nil then
+					_condition = value.md
+					if _condition == nil then
+						_condition = value.sm
+						if _condition == nil then
+							_condition = value.xs
+						end
+					end
+				end
+				return _condition
+			end
+			if breakpoint == "md" then
+				local _condition = value.md
+				if _condition == nil then
+					_condition = value.sm
+					if _condition == nil then
+						_condition = value.xs
+					end
+				end
+				return _condition
+			end
+			if breakpoint == "sm" then
+				local _condition = value.sm
+				if _condition == nil then
+					_condition = value.xs
+				end
+				return _condition
+			end
+			if breakpoint == "xs" then
+			end
+			return value.xs
+		until true
+	end
+	function BreakpointHelper:compare(left, operator, right)
+		local a = BreakpointHelper.breakpointOrder[left]
+		local b = BreakpointHelper.breakpointOrder[right]
+		repeat
+			local _fallthrough = false
+			if operator == ">" then
+				return a > b
+			end
+			if operator == ">=" then
+				return a >= b
+			end
+			if operator == "<" then
+				return a < b
+			end
+			if operator == "<=" then
+				return a <= b
+			end
+			if operator == "!=" then
+				return a ~= b
+			end
+			if operator == "==" then
+			end
+			return a == b
+		until true
+	end
+	function BreakpointHelper:getBreakpoint(width, breakpoints)
+		local active = "xs"
+		if breakpoints.sm ~= nil and width >= breakpoints.sm then
+			active = "sm"
+		end
+		if breakpoints.md ~= nil and width >= breakpoints.md then
+			active = "md"
+		end
+		if breakpoints.lg ~= nil and width >= breakpoints.lg then
+			active = "lg"
+		end
+		if breakpoints.xl ~= nil and width >= breakpoints.xl then
+			active = "xl"
+		end
+		return active
+	end
+	BreakpointHelper.breakpointOrder = {
+		xs = 0,
+		sm = 1,
+		md = 2,
+		lg = 3,
+		xl = 4,
+	}
+end
+return {
+	BreakpointHelper = BreakpointHelper,
+}

package/out/Helpers/color.helper.d.ts

@@ -0,0 +1,5 @@
+import { CleanTheme, InlineIntentColors, IntentScheme } from "../Theme";
+import { ButtonFlag, Intent } from "../Interfaces";
+export declare class ColorHelper {
+    static getIntentColors(theme: CleanTheme, intent: Intent | undefined, state?: ButtonFlag, componentColors?: Partial<Record<Intent, InlineIntentColors>>): IntentScheme;
+}

package/out/Helpers/color.helper.luau

@@ -0,0 +1,101 @@
+-- Compiled with roblox-ts v3.0.0
+local ColorHelper
+do
+	ColorHelper = setmetatable({}, {
+		__tostring = function()
+			return "ColorHelper"
+		end,
+	})
+	ColorHelper.__index = ColorHelper
+	function ColorHelper.new(...)
+		local self = setmetatable({}, ColorHelper)
+		return self:constructor(...) or self
+	end
+	function ColorHelper:constructor()
+	end
+	function ColorHelper:getIntentColors(theme, intent, state, componentColors)
+		if state == nil then
+			state = "default"
+		end
+		local selectedIntent = intent or "primary"
+		local defaultPrimary = theme.colors.intents.primary
+		local defaultMatching = theme.colors.intents[selectedIntent]
+		local _componentPrimary = componentColors
+		if _componentPrimary ~= nil then
+			_componentPrimary = _componentPrimary.primary
+		end
+		local componentPrimary = _componentPrimary
+		local _componentMatching = componentColors
+		if _componentMatching ~= nil then
+			_componentMatching = _componentMatching[selectedIntent]
+		end
+		local componentMatching = _componentMatching
+		local _object = table.clone(defaultPrimary.default)
+		setmetatable(_object, nil)
+		local _condition = defaultPrimary[state]
+		if _condition == nil then
+			_condition = {}
+		end
+		for _k, _v in _condition do
+			_object[_k] = _v
+		end
+		for _k, _v in defaultMatching.default do
+			_object[_k] = _v
+		end
+		local _condition_1 = defaultMatching[state]
+		if _condition_1 == nil then
+			_condition_1 = {}
+		end
+		for _k, _v in _condition_1 do
+			_object[_k] = _v
+		end
+		local _result = componentPrimary
+		if _result ~= nil then
+			_result = _result.default
+		end
+		local _condition_2 = _result
+		if _condition_2 == nil then
+			_condition_2 = {}
+		end
+		for _k, _v in _condition_2 do
+			_object[_k] = _v
+		end
+		local _result_1 = componentPrimary
+		if _result_1 ~= nil then
+			_result_1 = _result_1[state]
+		end
+		local _condition_3 = _result_1
+		if _condition_3 == nil then
+			_condition_3 = {}
+		end
+		for _k, _v in _condition_3 do
+			_object[_k] = _v
+		end
+		local _result_2 = componentMatching
+		if _result_2 ~= nil then
+			_result_2 = _result_2.default
+		end
+		local _condition_4 = _result_2
+		if _condition_4 == nil then
+			_condition_4 = {}
+		end
+		for _k, _v in _condition_4 do
+			_object[_k] = _v
+		end
+		local _result_3 = componentMatching
+		if _result_3 ~= nil then
+			_result_3 = _result_3[state]
+		end
+		local _condition_5 = _result_3
+		if _condition_5 == nil then
+			_condition_5 = {}
+		end
+		for _k, _v in _condition_5 do
+			_object[_k] = _v
+		end
+		return _object
+	end
+end
+return {
+	ColorHelper = ColorHelper,
+}

package/out/Helpers/create-ui-story.d.ts

@@ -0,0 +1,16 @@
+import React from "@rbxts/react";
+import ReactRoblox from "@rbxts/react-roblox";
+import { InferProps } from "@rbxts/ui-labs";
+declare const controls: {
+    Theme: import("@rbxts/ui-labs/src/ControlTypings/Advanced").AdvancedTypes.Choose<"Default" | "Dark" | "Sandstone">;
+};
+type StoryProps = InferProps<typeof controls>;
+export declare function createStory(render: (props: StoryProps) => React.ReactNode): {
+    react: typeof React;
+    reactRoblox: typeof ReactRoblox;
+    controls: {
+        Theme: import("@rbxts/ui-labs/src/ControlTypings/Advanced").AdvancedTypes.Choose<"Default" | "Dark" | "Sandstone">;
+    };
+    story: (props: StoryProps) => React.JSX.Element;
+};
+export {};

package/out/Helpers/create-ui-story.luau

@@ -0,0 +1,38 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local React = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local ReactRoblox = TS.import(script, TS.getModule(script, "@rbxts", "react-roblox"))
+local _Theme = TS.import(script, script.Parent.Parent, "Theme")
+local DarkTheme = _Theme.DarkTheme
+local DefaultTheme = _Theme.DefaultTheme
+local SandstoneTheme = _Theme.SandstoneTheme
+local Choose = TS.import(script, TS.getModule(script, "@rbxts", "ui-labs").src).Choose
+local _ = TS.import(script, script.Parent.Parent, "Providers")
+local OverlayProvider = _.OverlayProvider
+local ThemeProvider = _.ThemeProvider
+local RegistryProvider = TS.import(script, script.Parent.Parent, "Providers", "registry.provider").RegistryProvider
+local controls = {
+	Theme = Choose({ "Default", "Dark", "Sandstone" }),
+}
+local function createStory(render)
+	return {
+		react = React,
+		reactRoblox = ReactRoblox,
+		controls = controls,
+		story = function(props)
+			local theme = DefaultTheme
+			if props.controls.Theme == "Dark" then
+				theme = DarkTheme
+			end
+			if props.controls.Theme == "Sandstone" then
+				theme = SandstoneTheme
+			end
+			return React.createElement(RegistryProvider, nil, React.createElement(ThemeProvider, {
+				theme = theme,
+			}, React.createElement(OverlayProvider, nil, render(props))))
+		end,
+	}
+end
+return {
+	createStory = createStory,
+}

package/out/Helpers/css.helper.d.ts

@@ -0,0 +1,12 @@
+import { CssShadow, CssSize } from "../Interfaces/clean.element.props";
+interface ParsedShadow {
+    offset: UDim2;
+    blurRadius: UDim;
+    spread: UDim2;
+}
+export declare class CssHelper {
+    static parseCssShadow(value: CssShadow): ParsedShadow | undefined;
+    private static isZero;
+    static parseCssSize(value: CssSize): UDim;
+}
+export {};

package/out/Helpers/css.helper.luau

@@ -0,0 +1,114 @@
+-- Compiled with roblox-ts v3.0.0
+local CssHelper
+do
+	CssHelper = setmetatable({}, {
+		__tostring = function()
+			return "CssHelper"
+		end,
+	})
+	CssHelper.__index = CssHelper
+	function CssHelper.new(...)
+		local self = setmetatable({}, CssHelper)
+		return self:constructor(...) or self
+	end
+	function CssHelper:constructor()
+	end
+	function CssHelper:parseCssShadow(value)
+		local _value = value
+		if type(_value) == "number" then
+			if value == 0 then
+				return nil
+			end
+			local size = self:parseCssSize(value)
+			return {
+				offset = UDim2.new(size, size),
+				blurRadius = UDim.new(0, 0),
+				spread = UDim2.new(),
+			}
+		end
+		local _exp = string.split(value, " ")
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _callback = function(part)
+			return #part > 0
+		end
+		local _length = 0
+		for _k, _v in _exp do
+			if _callback(_v, _k - 1, _exp) == true then
+				_length += 1
+				_newValue[_length] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		local parts = _newValue
+		local _self = self
+		local _condition = parts[1]
+		if _condition == nil then
+			_condition = "0"
+		end
+		local x = _self:parseCssSize(_condition)
+		local _self_1 = self
+		local _condition_1 = parts[2]
+		if _condition_1 == nil then
+			_condition_1 = parts[1]
+			if _condition_1 == nil then
+				_condition_1 = "0"
+			end
+		end
+		local y = _self_1:parseCssSize(_condition_1)
+		local _self_2 = self
+		local _condition_2 = parts[3]
+		if _condition_2 == nil then
+			_condition_2 = "0"
+		end
+		local blur = _self_2:parseCssSize(_condition_2)
+		local _self_3 = self
+		local _condition_3 = parts[4]
+		if _condition_3 == nil then
+			_condition_3 = "0"
+		end
+		local spread = _self_3:parseCssSize(_condition_3)
+		local isZero = self:isZero(x) and self:isZero(y) and self:isZero(blur) and self:isZero(spread)
+		if isZero then
+			return nil
+		end
+		return {
+			offset = UDim2.new(x, y),
+			blurRadius = blur,
+			spread = UDim2.new(spread, spread),
+		}
+	end
+	function CssHelper:isZero(value)
+		return value.Scale == 0 and value.Offset == 0
+	end
+	function CssHelper:parseCssSize(value)
+		local _value = value
+		if type(_value) == "number" then
+			return UDim.new(0, value)
+		end
+		if string.sub(value, -1) == "%" then
+			local _condition = tonumber(string.sub(value, 1, -2))
+			if _condition == nil then
+				_condition = 0
+			end
+			local amount = _condition
+			return UDim.new(amount / 100, 0)
+		end
+		if string.sub(value, -2) == "px" then
+			local _condition = tonumber(string.sub(value, 1, -3))
+			if _condition == nil then
+				_condition = 0
+			end
+			local amount = _condition
+			return UDim.new(0, amount)
+		end
+		local _condition = tonumber(value)
+		if _condition == nil then
+			_condition = 0
+		end
+		return UDim.new(0, _condition)
+	end
+end
+return {
+	CssHelper = CssHelper,
+}

package/out/Helpers/gui.helper.d.ts

@@ -0,0 +1,10 @@
+export declare class GuiHelper {
+    static findHighestAncestorOfClass<T extends Instance>(instance: Instance, className: string): T | undefined;
+    static printParentTree(instance: Instance): void;
+    static isPointInsideGuiObject(guiObject: GuiObject, point: Vector2): boolean;
+    static getGuiObjectsAtPosition(instance: Instance, point: Vector2): GuiObject[];
+    static getGuiRenderOrder(instance: Instance): GuiObject[];
+    private static getGuiRoot;
+    private static getRenderSurfaces;
+    private static appendGuiObjects;
+}

package/out/Helpers/gui.helper.luau

@@ -0,0 +1,134 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
+local Players = _services.Players
+local RunService = _services.RunService
+local GuiHelper
+do
+	GuiHelper = setmetatable({}, {
+		__tostring = function()
+			return "GuiHelper"
+		end,
+	})
+	GuiHelper.__index = GuiHelper
+	function GuiHelper.new(...)
+		local self = setmetatable({}, GuiHelper)
+		return self:constructor(...) or self
+	end
+	function GuiHelper:constructor()
+	end
+	function GuiHelper:findHighestAncestorOfClass(instance, className)
+		local current = instance
+		local highest
+		while current do
+			if current:IsA(className) then
+				highest = current
+			end
+			current = current.Parent
+		end
+		return highest
+	end
+	function GuiHelper:printParentTree(instance)
+		local current = instance
+		while current ~= nil do
+			print(`{current.ClassName}: {current.Name}`)
+			current = current.Parent
+		end
+	end
+	function GuiHelper:isPointInsideGuiObject(guiObject, point)
+		local position = guiObject.AbsolutePosition
+		local size = guiObject.AbsoluteSize
+		return point.X >= position.X and point.X <= position.X + size.X and point.Y >= position.Y and point.Y <= position.Y + size.Y
+	end
+	function GuiHelper:getGuiObjectsAtPosition(instance, point)
+		local root = self:findHighestAncestorOfClass(instance, "Frame")
+		if root == nil then
+			return {}
+		end
+		local results = {}
+		for _, descendant in root:GetDescendants() do
+			if descendant:IsA("GuiObject") and descendant.Visible and self:isPointInsideGuiObject(descendant, point) then
+				table.insert(results, descendant)
+			end
+		end
+		table.sort(results, function(a, b)
+			return a.ZIndex > b.ZIndex
+		end)
+		return results
+	end
+	function GuiHelper:getGuiRenderOrder(instance)
+		local result = {}
+		for _, surface in self:getRenderSurfaces(self:getGuiRoot(instance)) do
+			self:appendGuiObjects(surface.root, result)
+		end
+		return result
+	end
+	function GuiHelper:getGuiRoot(instance)
+		if RunService:IsRunning() then
+			return Players.LocalPlayer:WaitForChild("PlayerGui")
+		end
+		local r = self:findHighestAncestorOfClass(instance, "PluginGuiService")
+		if r == nil then
+			error(`No root`)
+		end
+		return r
+	end
+	function GuiHelper:getRenderSurfaces(root)
+		local surfaces = {}
+		local visit
+		visit = function(instance)
+			for index, child in ipairs(instance:GetChildren()) do
+				if child:IsA("LayerCollector") then
+					local _arg0 = {
+						root = child,
+						rootIndex = index,
+					}
+					table.insert(surfaces, _arg0)
+					-- Don't recurse into another render surface.
+					continue
+				end
+				visit(child)
+			end
+		end
+		visit(root)
+		table.sort(surfaces, function(a, b)
+			if a.root:IsA("ScreenGui") and b.root:IsA("ScreenGui") then
+				if a.root.DisplayOrder ~= b.root.DisplayOrder then
+					return a.root.DisplayOrder < b.root.DisplayOrder
+				end
+			end
+			return a.rootIndex < b.rootIndex
+		end)
+		return surfaces
+	end
+	function GuiHelper:appendGuiObjects(parent, result)
+		local children = {}
+		for index, child in ipairs(parent:GetChildren()) do
+			if not child:IsA("GuiObject") then
+				continue
+			end
+			local _arg0 = {
+				object = child,
+				siblingIndex = index,
+			}
+			table.insert(children, _arg0)
+		end
+		table.sort(children, function(a, b)
+			if a.object.ZIndex ~= b.object.ZIndex then
+				return a.object.ZIndex < b.object.ZIndex
+			end
+			-- Preserve sibling order.
+			return a.siblingIndex < b.siblingIndex
+		end)
+		for _, child in children do
+			-- Parent renders before its children.
+			local _result = result
+			local _object = child.object
+			table.insert(_result, _object)
+			self:appendGuiObjects(child.object, result)
+		end
+	end
+end
+return {
+	GuiHelper = GuiHelper,
+}

package/out/Helpers/index.d.ts

@@ -0,0 +1,8 @@
+export * from './breakpoint.helper';
+export * from './color.helper';
+export * from './create-ui-story';
+export * from './css.helper';
+export * from './gui.helper';
+export * from './size.helper';
+export * from './spacing.helper';
+export * from './typography.helper';