@rbxts/react-clean-ui 1.0.5

package/out/Components/Layout/Group.luau

@@ -0,0 +1,168 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local React = _react
+local Component = _react.Component
+local ReactComponent = _react.ReactComponent
+local HttpService = TS.import(script, TS.getModule(script, "@rbxts", "services")).HttpService
+local GroupContext = React.createContext(nil)
+local function GroupElement(props)
+	local context = React.useContext(GroupContext)
+	local id = React.useRef(HttpService:GenerateGUID(false)).current
+	local _result = context
+	if _result ~= nil then
+		_result = _result.removeElement
+	end
+	local removeElementRef = React.useRef(_result)
+	local _result_1 = context
+	if _result_1 ~= nil then
+		_result_1 = _result_1.removeElement
+	end
+	removeElementRef.current = _result_1
+	React.useEffect(function()
+		return function()
+			local _result_2 = removeElementRef.current
+			if _result_2 ~= nil then
+				_result_2(id)
+			end
+		end
+	end, {})
+	if not props.enabled or context == nil then
+		return props.children
+	end
+	return React.createElement("frame", {
+		BackgroundTransparency = 1,
+		AutomaticSize = Enum.AutomaticSize.XY,
+		Change = {
+			AbsoluteSize = function(instance)
+				local _exp = instance.AbsoluteSize.X
+				local _result_2 = props.padding
+				if _result_2 ~= nil then
+					_result_2 = _result_2.left
+				end
+				local _condition = _result_2
+				if _condition == nil then
+					_condition = 0
+				end
+				local _exp_1 = _exp + _condition
+				local _result_3 = props.padding
+				if _result_3 ~= nil then
+					_result_3 = _result_3.right
+				end
+				local _condition_1 = _result_3
+				if _condition_1 == nil then
+					_condition_1 = 0
+				end
+				local _exp_2 = _exp_1 + _condition_1
+				local _exp_3 = instance.AbsoluteSize.Y
+				local _result_4 = props.padding
+				if _result_4 ~= nil then
+					_result_4 = _result_4.top
+				end
+				local _condition_2 = _result_4
+				if _condition_2 == nil then
+					_condition_2 = 0
+				end
+				local _exp_4 = _exp_3 + _condition_2
+				local _result_5 = props.padding
+				if _result_5 ~= nil then
+					_result_5 = _result_5.bottom
+				end
+				local _condition_3 = _result_5
+				if _condition_3 == nil then
+					_condition_3 = 0
+				end
+				context.reportSize(id, Vector2.new(_exp_2, _exp_4 + _condition_3))
+			end,
+		},
+	}, props.children)
+end
+local function getMaxVector2(map)
+	local max
+	for _, vector in map do
+		if max == nil then
+			max = vector
+		else
+			max = Vector2.new(math.max(max.X, vector.X), math.max(max.Y, vector.Y))
+		end
+	end
+	return max
+end
+local Group
+do
+	local super = Component
+	Group = setmetatable({}, {
+		__tostring = function()
+			return "Group"
+		end,
+		__index = super,
+	})
+	Group.__index = Group
+	function Group.new(...)
+		local self = setmetatable({}, Group)
+		return self:constructor(...) or self
+	end
+	function Group:constructor(...)
+		super.constructor(self, ...)
+		self.state = {
+			size = Vector2.new(0, 0),
+			sizes = {},
+		}
+	end
+	function Group:render()
+		local context = {
+			size = self.state.size,
+			sizes = self.state.sizes,
+			reportSize = function(id, size)
+				local _sizes = self.state.sizes
+				local _id = id
+				local current = _sizes[_id]
+				if current ~= nil and current.X == size.X and current.Y == size.Y then
+					return nil
+				end
+				self:setState(function(state)
+					local sizes = {}
+					for elementId, elementSize in state.sizes do
+						sizes[elementId] = elementSize
+					end
+					local _id_1 = id
+					local _size = size
+					sizes[_id_1] = _size
+					return {
+						sizes = sizes,
+						size = getMaxVector2(sizes) or Vector2.new(0, 0),
+					}
+				end)
+			end,
+			removeElement = function(id)
+				local _sizes = self.state.sizes
+				local _id = id
+				if not (_sizes[_id] ~= nil) then
+					return nil
+				end
+				self:setState(function(state)
+					local sizes = {}
+					for elementId, elementSize in state.sizes do
+						if elementId ~= id then
+							sizes[elementId] = elementSize
+						end
+					end
+					return {
+						sizes = sizes,
+						size = getMaxVector2(sizes) or Vector2.new(0, 0),
+					}
+				end)
+			end,
+		}
+		return React.createElement(GroupContext.Provider, {
+			value = context,
+		}, self.props.children)
+	end
+	Group.Element = GroupElement
+	Group.contextType = GroupContext
+	Group = ReactComponent(Group) or Group
+end
+return {
+	GroupContext = GroupContext,
+	Group = Group,
+}

package/out/Components/Layout/HStack.d.ts

@@ -0,0 +1,12 @@
+import React from "@rbxts/react";
+import { SpacedElementProps } from "../../Interfaces";
+interface HStackProps extends SpacedElementProps {
+    children?: React.ReactNode;
+    valign?: Enum.VerticalAlignment | "Center" | "Top" | "Bottom" | React.Binding<Enum.VerticalAlignment> | undefined;
+    Wraps?: boolean;
+    HorizontalFlex?: Enum.UIFlexAlignment;
+    Event?: React.InstanceEvent<UIListLayout>;
+    Change?: React.InstanceChangeEvent<UIListLayout>;
+}
+export declare function HStack(props: HStackProps): React.JSX.Element;
+export {};

package/out/Components/Layout/HStack.luau

@@ -0,0 +1,21 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local React = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local CleanThemeContext = TS.import(script, script.Parent.Parent.Parent, "Contexts").CleanThemeContext
+local SpacingHelper = TS.import(script, script.Parent.Parent.Parent, "Helpers").SpacingHelper
+local function HStack(props)
+	local theme = React.useContext(CleanThemeContext)
+	local padding = UDim.new(0, math.ceil(SpacingHelper:GetPadding(theme, props.spacing) / 2))
+	return React.createElement(React.Fragment, nil, React.createElement("uilistlayout", {
+		FillDirection = Enum.FillDirection.Horizontal,
+		HorizontalFlex = props.HorizontalFlex,
+		VerticalAlignment = props.valign,
+		Padding = padding,
+		Wraps = if props.Wraps == nil then true else props.Wraps,
+		Change = props.Change,
+		Event = props.Event,
+	}), props.children)
+end
+return {
+	HStack = HStack,
+}

package/out/Components/Layout/Row.d.ts

@@ -0,0 +1,15 @@
+import React, { Component } from "@rbxts/react";
+import { BreakPointElementProps, SpacedElementProps } from "../../Interfaces/";
+import { CleanThemeContext } from "../../Contexts";
+interface RowProps extends SpacedElementProps, BreakPointElementProps {
+}
+interface RowState {
+    width: number;
+}
+export declare class Row extends Component<RowProps, RowState> {
+    static contextType: React.Context<import("../..").CleanTheme>;
+    context: React.ContextType<typeof CleanThemeContext>;
+    state: RowState;
+    render(): React.JSX.Element;
+}
+export {};

package/out/Components/Layout/Row.luau

@@ -0,0 +1,87 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local React = _react
+local Component = _react.Component
+local ReactComponent = _react.ReactComponent
+local Column = TS.import(script, script.Parent, "Column").Column
+local _Contexts = TS.import(script, script.Parent.Parent.Parent, "Contexts")
+local CleanThemeContext = _Contexts.CleanThemeContext
+local RowContext = _Contexts.RowContext
+local _ = TS.import(script, script.Parent.Parent.Parent, "Helpers")
+local BreakpointHelper = _.BreakpointHelper
+local SpacingHelper = _.SpacingHelper
+local Row
+do
+	local super = Component
+	Row = setmetatable({}, {
+		__tostring = function()
+			return "Row"
+		end,
+		__index = super,
+	})
+	Row.__index = Row
+	function Row.new(...)
+		local self = setmetatable({}, Row)
+		return self:constructor(...) or self
+	end
+	function Row:constructor(...)
+		super.constructor(self, ...)
+		self.state = {
+			width = 0,
+		}
+	end
+	function Row:render()
+		local breakpoints = (if self.props.breakpoints ~= nil then self.props.breakpoints else self.context.breakpoints)
+		local padding = UDim.new(0, SpacingHelper:GetPadding(self.context, self.props.spacing))
+		local _exp = React.createElement("uilistlayout", {
+			FillDirection = Enum.FillDirection.Horizontal,
+			SortOrder = Enum.SortOrder.LayoutOrder,
+			Padding = padding,
+			Wraps = true,
+		})
+		local _attributes = {}
+		local _object = {
+			width = self.state.width,
+		}
+		local _left = "children"
+		local _exp_1 = React.Children.toArray(self.props.children)
+		-- ▼ ReadonlyArray.filter ▼
+		local _newValue = {}
+		local _callback = function(child)
+			return React.isValidElement(child) and child.type == Column
+		end
+		local _length = 0
+		for _k, _v in _exp_1 do
+			if _callback(_v, _k - 1, _exp_1) == true then
+				_length += 1
+				_newValue[_length] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filter ▲
+		_object[_left] = #_newValue
+		_object.padding = padding
+		_object.breakpoint = BreakpointHelper:getBreakpoint(self.state.width, breakpoints)
+		_attributes.value = _object
+		return React.createElement("frame", {
+			Size = UDim2.fromScale(1, 1),
+			AutomaticSize = Enum.AutomaticSize.Y,
+			BackgroundTransparency = 1,
+			Change = {
+				AbsoluteSize = function(instance)
+					local width = instance.AbsoluteSize.X
+					if width ~= self.state.width then
+						self:setState({
+							width = width,
+						})
+					end
+				end,
+			},
+		}, _exp, React.createElement(RowContext.Provider, _attributes, self.props.children))
+	end
+	Row.contextType = CleanThemeContext
+	Row = ReactComponent(Row) or Row
+end
+return {
+	Row = Row,
+}

package/out/Components/Layout/Scroller.d.ts

@@ -0,0 +1,7 @@
+import React from "@rbxts/react";
+import { PositionElementProps, SizeElementProps, SpacedElementProps } from "../../Interfaces";
+interface ScrollerProps extends SizeElementProps, SpacedElementProps, PositionElementProps {
+    children?: React.ReactNode;
+}
+export declare function Scroller(props: ScrollerProps): React.JSX.Element;
+export {};

package/out/Components/Layout/Scroller.luau

@@ -0,0 +1,54 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local React = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local CleanThemeContext = TS.import(script, script.Parent.Parent.Parent, "Contexts").CleanThemeContext
+local _Helpers = TS.import(script, script.Parent.Parent.Parent, "Helpers")
+local SizeHelper = _Helpers.SizeHelper
+local SpacingHelper = _Helpers.SpacingHelper
+local function Scroller(props)
+	local theme = React.useContext(CleanThemeContext)
+	local thickness = 12
+	local isScrolling, setIsScrolling = React.useState(false)
+	local ref = React.useRef()
+	React.useEffect(function()
+		local frame = ref.current
+		if not frame then
+			return nil
+		end
+		local updateScrolling = function()
+			setIsScrolling(frame.AbsoluteCanvasSize.Y > frame.AbsoluteWindowSize.Y)
+		end
+		updateScrolling()
+		local canvasConn = frame:GetPropertyChangedSignal("AbsoluteCanvasSize"):Connect(updateScrolling)
+		local windowConn = frame:GetPropertyChangedSignal("AbsoluteWindowSize"):Connect(updateScrolling)
+		return function()
+			canvasConn:Disconnect()
+			windowConn:Disconnect()
+		end
+	end, {})
+	local spacing = SpacingHelper:GetPadding(theme, props.spacing)
+	return React.createElement("scrollingframe", {
+		ref = ref,
+		AnchorPoint = SizeHelper:GetAnchor(props),
+		AutomaticSize = SizeHelper:GetAutoSize(props, Enum.AutomaticSize.None),
+		Position = SizeHelper:GetPosition(props),
+		Size = SizeHelper:GetSize(props, UDim2.fromScale(1, 1)),
+		BorderSizePixel = 0,
+		ScrollingDirection = Enum.ScrollingDirection.Y,
+		ScrollBarImageColor3 = theme.components.scroller.barColor,
+		CanvasSize = UDim2.fromScale(1, 0),
+		BackgroundTransparency = 1,
+		ScrollBarThickness = thickness,
+		VerticalScrollBarInset = Enum.ScrollBarInset.ScrollBar,
+		AutomaticCanvasSize = Enum.AutomaticSize.Y,
+	}, React.createElement("uilistlayout", {
+		FillDirection = Enum.FillDirection.Horizontal,
+	}), React.createElement("frame", {
+		Size = UDim2.new(1, if isScrolling then -thickness - spacing else 0, 0, 0),
+		AutomaticSize = Enum.AutomaticSize.Y,
+		BackgroundTransparency = 1,
+	}, props.children))
+end
+return {
+	Scroller = Scroller,
+}

package/out/Components/Layout/Tabs.d.ts

@@ -0,0 +1,31 @@
+import React, { Component } from "@rbxts/react";
+import { CleanThemeContext } from "../../Contexts";
+import { ScalableElementProps } from "../../Interfaces";
+interface TabProps {
+    children?: React.ReactNode;
+}
+declare function Tab(props: TabProps): undefined;
+interface TabTitleProps {
+    text: string;
+    children?: React.ReactNode;
+}
+declare function TabTitle(props: TabTitleProps): undefined;
+interface TabContentProps {
+    children?: React.ReactNode;
+}
+declare function TabContent(props: TabContentProps): undefined;
+interface TabsProps extends ScalableElementProps {
+}
+interface TabsState {
+    selected: number;
+}
+export declare class Tabs extends Component<TabsProps, TabsState> {
+    static Tab: typeof Tab;
+    static Title: typeof TabTitle;
+    static Content: typeof TabContent;
+    static contextType: React.Context<import("../..").CleanTheme>;
+    context: React.ContextType<typeof CleanThemeContext>;
+    state: TabsState;
+    render(): React.ReactNode;
+}
+export {};

package/out/Components/Layout/Tabs.luau

@@ -0,0 +1,189 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local React = _react
+local Component = _react.Component
+local ReactComponent = _react.ReactComponent
+local HStack = TS.import(script, script.Parent, "HStack").HStack
+local VStack = TS.import(script, script.Parent, "VStack").VStack
+local Text = TS.import(script, script.Parent.Parent, "Typography").Text
+local Container = TS.import(script, script.Parent, "Container").Container
+local CleanThemeContext = TS.import(script, script.Parent.Parent.Parent, "Contexts").CleanThemeContext
+local _Decorator = TS.import(script, script.Parent.Parent, "Decorator")
+local BoxShadow = _Decorator.BoxShadow
+local Corners = _Decorator.Corners
+local Padding = _Decorator.Padding
+local _Helpers = TS.import(script, script.Parent.Parent.Parent, "Helpers")
+local ColorHelper = _Helpers.ColorHelper
+local SpacingHelper = _Helpers.SpacingHelper
+local TypographyHelper = _Helpers.TypographyHelper
+local _HoverButton = TS.import(script, script.Parent.Parent, "Input", "HoverButton")
+local HoverButton = _HoverButton.HoverButton
+local HoverButtonContext = _HoverButton.HoverButtonContext
+local TabsContext = React.createContext(nil)
+local function Tab(props)
+	return nil
+end
+local function TabTitle(props)
+	return nil
+end
+local function TabContent(props)
+	return nil
+end
+local function TabButtonContent(props)
+	local theme = React.useContext(CleanThemeContext)
+	local hover = React.useContext(HoverButtonContext)
+	local _result = hover
+	if _result ~= nil then
+		_result = _result.isSelected
+	end
+	local _result_1
+	if _result then
+		_result_1 = "focus"
+	else
+		local _result_2 = hover
+		if _result_2 ~= nil then
+			_result_2 = _result_2.hover
+		end
+		_result_1 = if _result_2 then "hover" else "default"
+	end
+	local intent = ColorHelper:getIntentColors(theme, "primary", _result_1, theme.components.tabs.button.intents)
+	return React.createElement(React.Fragment, nil, React.createElement(Corners, {
+		radius = theme.components.tabs.button.cornerRadius,
+	}), React.createElement(Padding, {
+		resolvedPadding = SpacingHelper:GetResolvedPadding(theme, {}, theme.components.tabs.button.spacing),
+	}), React.createElement(BoxShadow, {
+		value = intent.boxShadow,
+	}), React.createElement(Text, {
+		TextColor3 = intent.textColor,
+		text = props.text,
+		typography = TypographyHelper:getTypography(theme, nil, intent.typography),
+	}))
+end
+local Tabs
+do
+	local super = Component
+	Tabs = setmetatable({}, {
+		__tostring = function()
+			return "Tabs"
+		end,
+		__index = super,
+	})
+	Tabs.__index = Tabs
+	function Tabs.new(...)
+		local self = setmetatable({}, Tabs)
+		return self:constructor(...) or self
+	end
+	function Tabs:constructor(...)
+		super.constructor(self, ...)
+		self.state = {
+			selected = 0,
+		}
+	end
+	function Tabs:render()
+		local context = {
+			selected = self.state.selected,
+		}
+		local tabs = {}
+		React.Children.forEach(self.props.children, function(child)
+			if not React.isValidElement(child) or child.type ~= Tab then
+				return nil
+			end
+			local title
+			local content
+			local tab = child
+			React.Children.forEach(tab.props.children, function(tabChild)
+				if not React.isValidElement(tabChild) then
+					return nil
+				end
+				if tabChild.type == TabTitle then
+					title = (tabChild.props)
+				elseif tabChild.type == TabContent then
+					content = (tabChild.props).children
+				end
+			end)
+			if title ~= nil then
+				local _arg0 = {
+					title = title,
+					content = content,
+				}
+				table.insert(tabs, _arg0)
+			end
+		end)
+		local selectedTab = tabs[self.state.selected + 1]
+		local _exp = React.createElement(Corners, {
+			radius = self.context.components.tabs.list.cornerRadius,
+		})
+		local _exp_1 = React.createElement(Padding, {
+			resolvedPadding = SpacingHelper:GetResolvedPadding(self.context, {}, self.context.components.tabs.list.spacing),
+		})
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#tabs)
+		local _callback = function(tab, index)
+			return React.createElement(HoverButton, {
+				isSelected = self.state.selected == index,
+				default = {
+					Size = UDim2.fromScale(0, 0),
+					AutomaticSize = Enum.AutomaticSize.XY,
+					ImageTransparency = 1,
+					BackgroundColor3 = ColorHelper:getIntentColors(self.context, "primary", "default", self.context.components.tabs.button.intents).backgroundColor,
+					BackgroundTransparency = ColorHelper:getIntentColors(self.context, "primary", "default", self.context.components.tabs.button.intents).backgroundTransparency,
+					BorderSizePixel = 0,
+					AutoButtonColor = false,
+					Event = {
+						Activated = function()
+							self:setState({
+								selected = index,
+							})
+						end,
+					},
+				},
+				hover = {
+					BackgroundColor3 = ColorHelper:getIntentColors(self.context, "primary", "hover", self.context.components.tabs.button.intents).backgroundColor,
+					BackgroundTransparency = ColorHelper:getIntentColors(self.context, "primary", "hover", self.context.components.tabs.button.intents).backgroundTransparency,
+				},
+				focus = {
+					BackgroundColor3 = ColorHelper:getIntentColors(self.context, "primary", "focus", self.context.components.tabs.button.intents).backgroundColor,
+					BackgroundTransparency = ColorHelper:getIntentColors(self.context, "primary", "focus", self.context.components.tabs.button.intents).backgroundTransparency,
+				},
+			}, React.createElement(TabButtonContent, {
+				text = tab.title.text,
+			}))
+		end
+		for _k, _v in tabs do
+			_newValue[_k] = _callback(_v, _k - 1, tabs)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		local _exp_2 = React.createElement(Container, {
+			BackgroundColor3 = self.context.components.tabs.list.backgroundColor,
+			width = "100%",
+			BackgroundTransparency = 0,
+		}, _exp, _exp_1, React.createElement(HStack, nil, _newValue))
+		local _exp_3 = React.createElement("uistroke", {
+			Thickness = self.context.components.tabs.borderThickness,
+			BorderStrokePosition = Enum.BorderStrokePosition.Inner,
+			Color = self.context.components.tabs.borderColor,
+		})
+		local _exp_4 = React.createElement(Padding, {
+			resolvedPadding = SpacingHelper:GetResolvedPadding(self.context, {}, self.context.components.tabs.spacing),
+		})
+		local _exp_5 = React.createElement(Corners, {
+			radius = self.context.components.tabs.list.cornerRadius,
+		})
+		local _result = selectedTab
+		if _result ~= nil then
+			_result = _result.content
+		end
+		return React.createElement(TabsContext.Provider, {
+			value = context,
+		}, React.createElement(VStack, nil, _exp_2, React.createElement(Container, nil, _exp_3, _exp_4, _exp_5, _result)))
+	end
+	Tabs.Tab = Tab
+	Tabs.Title = TabTitle
+	Tabs.Content = TabContent
+	Tabs.contextType = CleanThemeContext
+	Tabs = ReactComponent(Tabs) or Tabs
+end
+return {
+	Tabs = Tabs,
+}

package/out/Components/Layout/VStack.d.ts

@@ -0,0 +1,11 @@
+import React from "@rbxts/react";
+import { SpacedElementProps } from "../../Interfaces";
+interface VStackProps extends SpacedElementProps {
+    children?: React.ReactNode;
+    HorizontalFlex?: Enum.UIFlexAlignment;
+    VerticalFlex?: Enum.UIFlexAlignment;
+    Event?: React.InstanceEvent<UIListLayout>;
+    Change?: React.InstanceChangeEvent<UIListLayout>;
+}
+export declare function VStack(props: VStackProps): React.JSX.Element;
+export {};

package/out/Components/Layout/VStack.luau

@@ -0,0 +1,21 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local React = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local CleanThemeContext = TS.import(script, script.Parent.Parent.Parent, "Contexts").CleanThemeContext
+local SpacingHelper = TS.import(script, script.Parent.Parent.Parent, "Helpers").SpacingHelper
+local function VStack(props)
+	local theme = React.useContext(CleanThemeContext)
+	local padding = UDim.new(0, SpacingHelper:GetPadding(theme, props.spacing))
+	return React.createElement(React.Fragment, nil, React.createElement("uilistlayout", {
+		FillDirection = Enum.FillDirection.Vertical,
+		HorizontalFlex = props.HorizontalFlex or Enum.UIFlexAlignment.Fill,
+		VerticalFlex = props.VerticalFlex,
+		Padding = padding,
+		SortOrder = Enum.SortOrder.LayoutOrder,
+		Change = props.Change,
+		Event = props.Event,
+	}), props.children)
+end
+return {
+	VStack = VStack,
+}

package/out/Components/Layout/index.d.ts

@@ -0,0 +1,12 @@
+export * from './Column';
+export * from './Container';
+export * from './Draggable';
+export * from './Droppable';
+export * from './Fieldset';
+export * from './FlexItem';
+export * from './Group';
+export * from './HStack';
+export * from './Row';
+export * from './Scroller';
+export * from './Tabs';
+export * from './VStack';

package/out/Components/Layout/init.luau

@@ -0,0 +1,40 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+for _k, _v in TS.import(script, script, "Column") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "Container") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "Draggable") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "Droppable") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "Fieldset") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "FlexItem") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "Group") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "HStack") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "Row") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "Scroller") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "Tabs") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "VStack") or {} do
+	exports[_k] = _v
+end
+return exports