@rbxts/uiblox 0.1.53 → 0.2.0-alpha.1

package/out/ui/packages/rectEditor/components/RectEditor.luau

@@ -0,0 +1,85 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local React = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local NumberInput = TS.import(script, script.Parent.Parent.Parent, "numberInput").NumberInput
+local useRectEditorStyles = TS.import(script, script.Parent, "RectEditor.styles").default
+local _rectValue = TS.import(script, script.Parent, "rectValue")
+local rectFields = _rectValue.rectFields
+local writeRectParts = _rectValue.writeRectParts
+local function RectEditor(props)
+	local _binding = props
+	local value = _binding.value
+	local onChange = _binding.onChange
+	local disabled = _binding.disabled
+	local className = _binding.className
+	local sx = _binding.sx
+	local id = _binding.id
+	local ref = _binding.ref
+	local styles = useRectEditorStyles()
+	local amounts = { value.Min.X, value.Min.Y, value.Max.X, value.Max.Y }
+	local commit = function(field, amount)
+		local parts = writeRectParts(value.Min.X, value.Min.Y, value.Max.X, value.Max.Y, field, amount)
+		onChange(Rect.new(parts[1], parts[2], parts[3], parts[4]))
+	end
+	local _attributes = {}
+	local _condition = id
+	if not (_condition ~= 0 and _condition == _condition and _condition ~= "" and _condition) then
+		_condition = "RectEditor"
+	end
+	_attributes.key = _condition
+	_attributes.ref = ref
+	for _k, _v in styles.root do
+		_attributes[_k] = _v
+	end
+	if className then
+		for _k, _v in className do
+			_attributes[_k] = _v
+		end
+	end
+	if sx then
+		for _k, _v in sx do
+			_attributes[_k] = _v
+		end
+	end
+	local _attributes_1 = table.clone(styles.wrap)
+	setmetatable(_attributes_1, nil)
+	local _exp = React.createElement("uilistlayout", _attributes_1)
+	local _exp_1 = rectFields()
+	-- ▼ ReadonlyArray.map ▼
+	local _newValue = table.create(#_exp_1)
+	local _callback = function(field, index)
+		local _attributes_2 = {
+			key = field,
+		}
+		for _k, _v in styles.axis do
+			_attributes_2[_k] = _v
+		end
+		_attributes_2.LayoutOrder = index + 1
+		local _attributes_3 = table.clone(styles.row)
+		setmetatable(_attributes_3, nil)
+		local _exp_2 = React.createElement("uilistlayout", _attributes_3)
+		local _attributes_4 = table.clone(styles.label)
+		setmetatable(_attributes_4, nil)
+		_attributes_4.Text = field
+		local _exp_3 = React.createElement("textlabel", _attributes_4)
+		local _attributes_5 = table.clone(styles.field)
+		setmetatable(_attributes_5, nil)
+		return React.createElement("frame", _attributes_2, _exp_2, _exp_3, React.createElement("frame", _attributes_5, React.createElement(NumberInput, {
+			value = amounts[index + 1],
+			disabled = disabled,
+			width = UDim.new(1, 0),
+			onChange = function(amount)
+				return commit(field, amount)
+			end,
+		})))
+	end
+	for _k, _v in _exp_1 do
+		_newValue[_k] = _callback(_v, _k - 1, _exp_1)
+	end
+	-- ▲ ReadonlyArray.map ▲
+	return React.createElement("frame", _attributes, _exp, _newValue)
+end
+local default = RectEditor
+return {
+	default = default,
+}

package/out/ui/packages/rectEditor/components/RectEditor.styles.d.ts

@@ -0,0 +1,2 @@
+declare const useRectEditorStyles: () => import("../../../../theme/index").ClassNameMap<string>;
+export default useRectEditorStyles;

package/out/ui/packages/rectEditor/components/RectEditor.styles.luau

@@ -0,0 +1,46 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _theme = TS.import(script, script.Parent.Parent.Parent.Parent.Parent, "theme")
+local createStyles = _theme.createStyles
+local componentStyles = _theme.componentStyles
+local useRectEditorStyles = componentStyles("RectEditor", function(theme)
+	return createStyles({
+		root = {
+			Size = UDim2.new(1, 0, 0, 0),
+			AutomaticSize = Enum.AutomaticSize.Y,
+			BackgroundTransparency = 1,
+			BorderSizePixel = 0,
+		},
+		wrap = {
+			FillDirection = Enum.FillDirection.Vertical,
+			Padding = UDim.new(0, theme.padding.calc(0.5)),
+			SortOrder = Enum.SortOrder.LayoutOrder,
+		},
+		row = {
+			FillDirection = Enum.FillDirection.Horizontal,
+			Padding = UDim.new(0, theme.padding.calc(1)),
+			VerticalAlignment = Enum.VerticalAlignment.Center,
+			SortOrder = Enum.SortOrder.LayoutOrder,
+		},
+		axis = {
+			Size = UDim2.new(1, 0, 0, theme.spacing.calc(2)),
+			BackgroundTransparency = 1,
+		},
+		label = {
+			Size = UDim2.new(0, theme.spacing.calc(3), 1, 0),
+			BackgroundTransparency = 1,
+			Font = theme.typography.fontFamilies.default,
+			TextSize = theme.typography.fontSizes.caption,
+			TextColor3 = theme.palette.text.secondary,
+			TextXAlignment = Enum.TextXAlignment.Left,
+		},
+		field = {
+			Size = UDim2.new(1, -theme.spacing.calc(3), 1, 0),
+			BackgroundTransparency = 1,
+		},
+	})
+end)
+local default = useRectEditorStyles
+return {
+	default = default,
+}

package/out/ui/packages/rectEditor/components/rectValue.d.ts

@@ -0,0 +1,3 @@
+export type RectField = "MinX" | "MinY" | "MaxX" | "MaxY";
+export declare function writeRectParts(minX: number, minY: number, maxX: number, maxY: number, field: RectField, amount: number): number[];
+export declare function rectFields(): RectField[];

package/out/ui/packages/rectEditor/components/rectValue.luau

@@ -0,0 +1,14 @@
+-- Compiled with roblox-ts v3.0.0
+local function writeRectParts(minX, minY, maxX, maxY, field, amount)
+	local parts = { minX, minY, maxX, maxY }
+	local index = if field == "MinX" then 0 elseif field == "MinY" then 1 elseif field == "MaxX" then 2 else 3
+	parts[index + 1] = amount
+	return parts
+end
+local function rectFields()
+	return { "MinX", "MinY", "MaxX", "MaxY" }
+end
+return {
+	writeRectParts = writeRectParts,
+	rectFields = rectFields,
+}

package/out/ui/packages/rectEditor/index.d.ts

@@ -0,0 +1,2 @@
+export { default as RectEditor } from "./components/RectEditor";
+export { RectEditorProps } from "./components/RectEditor";

package/out/ui/packages/rectEditor/init.luau

@@ -0,0 +1,5 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+exports.RectEditor = TS.import(script, script, "components", "RectEditor").default
+return exports

package/out/ui/packages/scroll/dragScroll.d.ts

@@ -0,0 +1,8 @@
+export declare const DRAG_SCROLL_THRESHOLD = 6;
+export type DragScrollAxis = "x" | "y" | "xy";
+export declare function scrollAxis(direction: Enum.ScrollingDirection): DragScrollAxis;
+export declare function shouldBeginDragScroll(start: Vector2, current: Vector2, axis: DragScrollAxis, threshold?: number): boolean;
+export declare function nextCanvasPosition(startCanvas: Vector2, startPointer: Vector2, currentPointer: Vector2, axis: DragScrollAxis, maxCanvas: Vector2): Vector2;
+export declare function canvasScrollMax(frame: ScrollingFrame): Vector2;
+export declare function pointerInFrame(frame: GuiObject, position: Vector3 | Vector2): boolean;
+export declare function isDragScrollPress(input: InputObject): boolean;

package/out/ui/packages/scroll/dragScroll.luau

@@ -0,0 +1,51 @@
+-- Compiled with roblox-ts v3.0.0
+local DRAG_SCROLL_THRESHOLD = 6
+local function scrollAxis(direction)
+	if direction == Enum.ScrollingDirection.X then
+		return "x"
+	end
+	if direction == Enum.ScrollingDirection.Y then
+		return "y"
+	end
+	return "xy"
+end
+local function shouldBeginDragScroll(start, current, axis, threshold)
+	if threshold == nil then
+		threshold = DRAG_SCROLL_THRESHOLD
+	end
+	local dx = math.abs(current.X - start.X)
+	local dy = math.abs(current.Y - start.Y)
+	if axis == "x" then
+		return dx >= threshold and dx >= dy
+	end
+	if axis == "y" then
+		return dy >= threshold and dy >= dx
+	end
+	return math.max(dx, dy) >= threshold
+end
+local function nextCanvasPosition(startCanvas, startPointer, currentPointer, axis, maxCanvas)
+	local dx = if axis == "y" then 0 else startPointer.X - currentPointer.X
+	local dy = if axis == "x" then 0 else startPointer.Y - currentPointer.Y
+	return Vector2.new(math.clamp(startCanvas.X + dx, 0, math.max(0, maxCanvas.X)), math.clamp(startCanvas.Y + dy, 0, math.max(0, maxCanvas.Y)))
+end
+local function canvasScrollMax(frame)
+	return Vector2.new(math.max(0, frame.AbsoluteCanvasSize.X - frame.AbsoluteWindowSize.X), math.max(0, frame.AbsoluteCanvasSize.Y - frame.AbsoluteWindowSize.Y))
+end
+local function pointerInFrame(frame, position)
+	local origin = frame.AbsolutePosition
+	local size = frame.AbsoluteSize
+	return position.X >= origin.X and position.X <= origin.X + size.X and position.Y >= origin.Y and position.Y <= origin.Y + size.Y
+end
+local function isDragScrollPress(input)
+	local kind = input.UserInputType
+	return kind == Enum.UserInputType.MouseButton1 or kind == Enum.UserInputType.Touch
+end
+return {
+	scrollAxis = scrollAxis,
+	shouldBeginDragScroll = shouldBeginDragScroll,
+	nextCanvasPosition = nextCanvasPosition,
+	canvasScrollMax = canvasScrollMax,
+	pointerInFrame = pointerInFrame,
+	isDragScrollPress = isDragScrollPress,
+	DRAG_SCROLL_THRESHOLD = DRAG_SCROLL_THRESHOLD,
+}

package/out/ui/packages/scroll/index.d.ts

@@ -0,0 +1,2 @@
+export { useDragScroll } from "./useDragScroll";
+export type { DragScrollHandle } from "./useDragScroll";

package/out/ui/packages/scroll/init.luau

@@ -0,0 +1,5 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+exports.useDragScroll = TS.import(script, script, "useDragScroll").useDragScroll
+return exports

package/out/ui/packages/scroll/useDragScroll.d.ts

@@ -0,0 +1,5 @@
+export interface DragScrollHandle {
+    dragging: boolean;
+    suppressClick: () => boolean;
+}
+export declare function useDragScroll(frame?: ScrollingFrame): DragScrollHandle;

package/out/ui/packages/scroll/useDragScroll.luau

@@ -0,0 +1,127 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local useEffect = _react.useEffect
+local useRef = _react.useRef
+local useState = _react.useState
+local UserInputService = TS.import(script, TS.getModule(script, "@rbxts", "services")).UserInputService
+local _dragScroll = TS.import(script, script.Parent, "dragScroll")
+local DRAG_SCROLL_THRESHOLD = _dragScroll.DRAG_SCROLL_THRESHOLD
+local canvasScrollMax = _dragScroll.canvasScrollMax
+local isDragScrollPress = _dragScroll.isDragScrollPress
+local nextCanvasPosition = _dragScroll.nextCanvasPosition
+local pointerInFrame = _dragScroll.pointerInFrame
+local scrollAxis = _dragScroll.scrollAxis
+local shouldBeginDragScroll = _dragScroll.shouldBeginDragScroll
+local function useDragScroll(frame)
+	local dragging, setDragging = useState(false)
+	local tookRef = useRef(false)
+	local draggingRef = useRef(false)
+	useEffect(function()
+		if not frame then
+			return nil
+		end
+		local tracking = false
+		local startPointer = Vector2.new(0, 0)
+		local startCanvas = Vector2.new(0, 0)
+		local restBar = frame.ScrollBarImageTransparency
+		local activeInput = {
+			current = nil,
+		}
+		local finish = function(consumed)
+			if not tracking and not draggingRef.current then
+				return nil
+			end
+			tracking = false
+			activeInput.current = nil
+			if draggingRef.current then
+				draggingRef.current = false
+				setDragging(false)
+				frame.ScrollBarImageTransparency = restBar
+				tookRef.current = consumed
+			end
+		end
+		local began = UserInputService.InputBegan:Connect(function(input)
+			-- Gui rows mark input processed; still allow content drag from those hits.
+			if not isDragScrollPress(input) or not frame.ScrollingEnabled then
+				return nil
+			end
+			if not pointerInFrame(frame, input.Position) then
+				return nil
+			end
+			local box = UserInputService:GetFocusedTextBox()
+			if box and pointerInFrame(box, input.Position) then
+				return nil
+			end
+			local max = canvasScrollMax(frame)
+			local axis = scrollAxis(frame.ScrollingDirection)
+			if axis == "x" and max.X <= 0 then
+				return nil
+			end
+			if axis == "y" and max.Y <= 0 then
+				return nil
+			end
+			if axis == "xy" and max.X <= 0 and max.Y <= 0 then
+				return nil
+			end
+			tracking = true
+			tookRef.current = false
+			activeInput.current = input
+			startPointer = Vector2.new(input.Position.X, input.Position.Y)
+			startCanvas = frame.CanvasPosition
+			restBar = frame.ScrollBarImageTransparency
+		end)
+		local changed = UserInputService.InputChanged:Connect(function(input)
+			if not tracking or activeInput.current == nil then
+				return nil
+			end
+			if input.UserInputType ~= Enum.UserInputType.MouseMovement and input.UserInputType ~= Enum.UserInputType.Touch then
+				return nil
+			end
+			local pointer = Vector2.new(input.Position.X, input.Position.Y)
+			local axis = scrollAxis(frame.ScrollingDirection)
+			if not draggingRef.current then
+				if not shouldBeginDragScroll(startPointer, pointer, axis, DRAG_SCROLL_THRESHOLD) then
+					return nil
+				end
+				draggingRef.current = true
+				setDragging(true)
+				frame.ScrollBarImageTransparency = 0
+			end
+			frame.CanvasPosition = nextCanvasPosition(startCanvas, startPointer, pointer, axis, canvasScrollMax(frame))
+		end)
+		local ended = UserInputService.InputEnded:Connect(function(input)
+			local press = activeInput.current
+			if press == nil then
+				return nil
+			end
+			if input ~= press and input.UserInputType ~= press.UserInputType then
+				return nil
+			end
+			finish(draggingRef.current)
+		end)
+		return function()
+			began:Disconnect()
+			changed:Disconnect()
+			ended:Disconnect()
+			if draggingRef.current then
+				frame.ScrollBarImageTransparency = restBar
+			end
+			draggingRef.current = false
+			tracking = false
+		end
+	end, { frame })
+	return {
+		dragging = dragging,
+		suppressClick = function()
+			if not tookRef.current then
+				return false
+			end
+			tookRef.current = false
+			return true
+		end,
+	}
+end
+return {
+	useDragScroll = useDragScroll,
+}

package/out/ui/packages/select/components/Select.d.ts

@@ -0,0 +1,16 @@
+import { ControlSize, CustomizedProps } from "../../../../theme/index";
+import { ChoiceOption } from "../../radioGroup/index";
+export interface SelectProps<T> {
+    value: T;
+    values?: ReadonlyArray<T>;
+    options: ChoiceOption<T>[];
+    onChange: (value: T) => void;
+    disabled?: boolean;
+    loading?: boolean;
+    placeholder?: string;
+    searchable?: boolean;
+    reducedMotion?: boolean;
+    size?: ControlSize;
+}
+declare function Select<T>(props: CustomizedProps<Frame, SelectProps<T>>): JSX.Element;
+export default Select;