@rbxts/centurion-ui 1.0.0-dev-284510d

package/out/components/suggestions/suggestion-list.lua

@@ -0,0 +1,70 @@
+-- Compiled with roblox-ts v2.3.0-dev-26ec859
+local TS = _G[script]
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local React = _react
+local useContext = _react.useContext
+local SUGGESTION_TEXT_SIZE = TS.import(script, script.Parent.Parent.Parent, "constants", "text").SUGGESTION_TEXT_SIZE
+local usePx = TS.import(script, script.Parent.Parent.Parent, "hooks", "use-px").usePx
+local OptionsContext = TS.import(script, script.Parent.Parent.Parent, "providers", "options-provider").OptionsContext
+local Frame = TS.import(script, script.Parent.Parent, "ui", "frame").Frame
+local Group = TS.import(script, script.Parent.Parent, "ui", "group").Group
+local Padding = TS.import(script, script.Parent.Parent, "ui", "padding").Padding
+local Text = TS.import(script, script.Parent.Parent, "ui", "text").Text
+local highlightMatching = TS.import(script, script.Parent, "util").highlightMatching
+local function SuggestionList(_param)
+	local suggestion = _param.suggestion
+	local currentText = _param.currentText
+	local size = _param.size
+	local px = usePx()
+	local options = useContext(OptionsContext)
+	local _exp = React.createElement("uilistlayout", {
+		SortOrder = "LayoutOrder",
+		Padding = UDim.new(0, px(8)),
+	})
+	local _result = suggestion
+	if _result ~= nil then
+		_result = _result.others
+		if _result ~= nil then
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#_result)
+			local _callback = function(name, i)
+				return React.createElement(Frame, {
+					key = `{i}-{name}`,
+					size = UDim2.new(1, 0, 0, px(SUGGESTION_TEXT_SIZE + 6)),
+					backgroundColor = options.palette.background,
+					backgroundTransparency = options.backgroundTransparency,
+					cornerRadius = UDim.new(0, px(8)),
+					clipsDescendants = true,
+				}, React.createElement(Padding, {
+					all = UDim.new(0, px(4)),
+				}), React.createElement(Text, {
+					size = UDim2.new(1, 0, 1, 0),
+					text = highlightMatching(options.palette.highlight, name, currentText),
+					textColor = options.palette.text,
+					textSize = px(SUGGESTION_TEXT_SIZE),
+					textXAlignment = "Left",
+					richText = true,
+				}))
+			end
+			for _k, _v in _result do
+				_newValue[_k] = _callback(_v, _k - 1, _result)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			_result = _newValue
+		end
+	end
+	return React.createElement(Group, {
+		size = size,
+		event = {
+			MouseEnter = function()
+				return options.setMouseOnGUI(true)
+			end,
+			MouseLeave = function()
+				return options.setMouseOnGUI(false)
+			end,
+		},
+	}, _exp, _result)
+end
+return {
+	SuggestionList = SuggestionList,
+}

package/out/components/suggestions/suggestions.d.ts

@@ -0,0 +1 @@
+export declare function Suggestions(): JSX.Element;

package/out/components/suggestions/suggestions.lua

@@ -0,0 +1,117 @@
+-- Compiled with roblox-ts v2.3.0-dev-26ec859
+local TS = _G[script]
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local React = _react
+local useBinding = _react.useBinding
+local useContext = _react.useContext
+local useEffect = _react.useEffect
+local useMemo = _react.useMemo
+local useSelector = TS.import(script, TS.getModule(script, "@rbxts", "react-reflex")).useSelector
+local TextService = TS.import(script, TS.getModule(script, "@rbxts", "services")).TextService
+local springs = TS.import(script, script.Parent.Parent.Parent, "constants", "springs").springs
+local _text = TS.import(script, script.Parent.Parent.Parent, "constants", "text")
+local SUGGESTION_TEXT_SIZE = _text.SUGGESTION_TEXT_SIZE
+local SUGGESTION_TITLE_TEXT_SIZE = _text.SUGGESTION_TITLE_TEXT_SIZE
+local useMotion = TS.import(script, script.Parent.Parent.Parent, "hooks", "use-motion").useMotion
+local usePx = TS.import(script, script.Parent.Parent.Parent, "hooks", "use-px").usePx
+local OptionsContext = TS.import(script, script.Parent.Parent.Parent, "providers", "options-provider").OptionsContext
+local selectSuggestion = TS.import(script, script.Parent.Parent.Parent, "store", "suggestion").selectSuggestion
+local selectText = TS.import(script, script.Parent.Parent.Parent, "store", "text").selectText
+local Group = TS.import(script, script.Parent.Parent, "ui", "group").Group
+local MainSuggestion = TS.import(script, script.Parent, "main-suggestion").MainSuggestion
+local SuggestionList = TS.import(script, script.Parent, "suggestion-list").SuggestionList
+local getSuggestionTextBounds = TS.import(script, script.Parent, "util").getSuggestionTextBounds
+local MAX_SUGGESTION_WIDTH = 180
+local MAX_BADGE_WIDTH = 80
+local PADDING = 8
+local function Suggestions()
+	local options = useContext(OptionsContext)
+	local px = usePx()
+	local terminalText = useSelector(selectText)
+	local currentTextPart = useMemo(function()
+		if terminalText.index == -1 or terminalText.index >= #terminalText.parts then
+			return nil
+		end
+		return terminalText.parts[terminalText.index + 1]
+	end, { terminalText })
+	local textBoundsParams = useMemo(function()
+		return Instance.new("GetTextBoundsParams")
+	end, {})
+	-- Suggestions
+	local currentSuggestion = useSelector(selectSuggestion)
+	local sizes, setSizes = useBinding({
+		title = UDim2.fromOffset(0, px(SUGGESTION_TITLE_TEXT_SIZE)),
+		description = UDim2.fromOffset(0, px(SUGGESTION_TEXT_SIZE)),
+		errorTextHeight = 0,
+		typeBadgeWidth = 0,
+	})
+	local suggestionSize, suggestionSizeMotion = useMotion(UDim2.new())
+	local otherSuggestionSize, otherSuggestionSizeMotion = useMotion(UDim2.new())
+	-- Resize window based on suggestions
+	useEffect(function()
+		if currentSuggestion == nil then
+			suggestionSizeMotion:spring(UDim2.new())
+			otherSuggestionSizeMotion:spring(UDim2.new())
+			return nil
+		end
+		local mainSuggestion = currentSuggestion.main
+		local otherSuggestions = currentSuggestion.others
+		if #otherSuggestions == 0 then
+			otherSuggestionSizeMotion:spring(UDim2.new())
+		end
+		local textBounds = getSuggestionTextBounds(options, mainSuggestion, px(SUGGESTION_TITLE_TEXT_SIZE), px(SUGGESTION_TEXT_SIZE), px(MAX_SUGGESTION_WIDTH), px(MAX_BADGE_WIDTH))
+		setSizes(textBounds)
+		local windowWidth = math.max(textBounds.title.X.Offset, textBounds.description.X.Offset) + px(PADDING * 2)
+		local windowHeight = textBounds.title.Y.Offset + textBounds.description.Y.Offset + textBounds.errorTextHeight + px(PADDING * 2)
+		if textBounds.typeBadgeWidth > 0 then
+			windowWidth += textBounds.typeBadgeWidth + px(16)
+		end
+		if textBounds.errorTextHeight > 0 then
+			windowHeight += px(8)
+		end
+		-- Calculate other suggestion sizes
+		local otherHeight = 0
+		if not (#otherSuggestions == 0) then
+			local maxSuggestionWidth = 0
+			textBoundsParams.Font = options.font.regular
+			textBoundsParams.Size = px(SUGGESTION_TEXT_SIZE)
+			textBoundsParams.Width = math.huge
+			for _, name in otherSuggestions do
+				textBoundsParams.Text = name
+				local suggestionBounds = TextService:GetTextBoundsAsync(textBoundsParams)
+				if suggestionBounds.X > maxSuggestionWidth then
+					maxSuggestionWidth = suggestionBounds.X
+				end
+			end
+			otherHeight = #otherSuggestions * px(SUGGESTION_TEXT_SIZE + 6) + (#otherSuggestions - 1) * px(4) + px(8)
+			windowWidth = math.max(windowWidth, maxSuggestionWidth)
+			otherSuggestionSizeMotion:spring(UDim2.fromOffset(windowWidth, otherHeight), springs.gentle)
+		end
+		suggestionSizeMotion:spring(UDim2.fromOffset(windowWidth, windowHeight), springs.responsive)
+	end, { currentSuggestion, px })
+	local _attributes = {
+		suggestion = currentSuggestion,
+	}
+	local _result = currentSuggestion
+	if _result ~= nil then
+		_result = _result.main.type
+	end
+	_attributes.argument = _result == "argument"
+	_attributes.currentText = currentTextPart
+	_attributes.size = suggestionSize
+	_attributes.sizes = sizes
+	return React.createElement(Group, {
+		size = UDim2.fromScale(1, 1),
+		visible = currentSuggestion ~= nil,
+	}, React.createElement(MainSuggestion, _attributes), React.createElement(SuggestionList, {
+		suggestion = currentSuggestion,
+		currentText = currentTextPart,
+		size = otherSuggestionSize,
+	}), React.createElement("uilistlayout", {
+		SortOrder = "LayoutOrder",
+		Padding = UDim.new(0, px(PADDING)),
+	}))
+end
+return {
+	Suggestions = Suggestions,
+}

package/out/components/suggestions/types.d.ts

@@ -0,0 +1,6 @@
+export interface SuggestionTextBounds {
+    title: UDim2;
+    description: UDim2;
+    errorTextHeight: number;
+    typeBadgeWidth: number;
+}

package/out/components/suggestions/types.lua

@@ -0,0 +1,2 @@
+-- Compiled with roblox-ts v2.3.0-dev-26ec859
+return nil

package/out/components/suggestions/util.d.ts

@@ -0,0 +1,4 @@
+import { ArgumentSuggestion, CommandSuggestion, InterfaceOptions } from "../../types";
+import { SuggestionTextBounds } from "./types";
+export declare function highlightMatching(color: Color3, text?: string, terminalText?: string): string;
+export declare function getSuggestionTextBounds(options: InterfaceOptions, suggestion: ArgumentSuggestion | CommandSuggestion, titleTextSize: number, textSize: number, maxWidth: number, maxBadgeWidth: number): SuggestionTextBounds;

package/out/components/suggestions/util.lua

@@ -0,0 +1,72 @@
+-- Compiled with roblox-ts v2.3.0-dev-26ec859
+local TS = _G[script]
+local TextService = TS.import(script, TS.getModule(script, "@rbxts", "services")).TextService
+local TEXT_BOUNDS_PARAMS = Instance.new("GetTextBoundsParams")
+local DEFAULT_BOUNDS = Vector2.new()
+local prevColor
+local prevColorHex
+local function highlightMatching(color, text, terminalText)
+	if text == nil then
+		return ""
+	end
+	if terminalText == nil then
+		return text
+	end
+	local _text = text
+	local _arg1 = #terminalText
+	local subText = string.sub(_text, 0, _arg1)
+	if string.lower(terminalText) ~= string.lower(subText) then
+		return text
+	end
+	if prevColor ~= color then
+		prevColor = color
+		prevColorHex = color:ToHex()
+	end
+	local _text_1 = text
+	local _arg0 = #terminalText + 1
+	local unhighlightedText = string.sub(_text_1, _arg0)
+	return `<font color="#{prevColorHex}">{subText}</font>{unhighlightedText}`
+end
+local function getSuggestionTextBounds(options, suggestion, titleTextSize, textSize, maxWidth, maxBadgeWidth)
+	-- Get title text bounds
+	TEXT_BOUNDS_PARAMS.Text = suggestion.title
+	TEXT_BOUNDS_PARAMS.Size = titleTextSize
+	TEXT_BOUNDS_PARAMS.Font = options.font.bold
+	local titleBounds = TextService:GetTextBoundsAsync(TEXT_BOUNDS_PARAMS)
+	-- Get description text bounds
+	TEXT_BOUNDS_PARAMS.Width = maxWidth
+	TEXT_BOUNDS_PARAMS.Size = textSize
+	TEXT_BOUNDS_PARAMS.Font = options.font.regular
+	local descriptionBounds = DEFAULT_BOUNDS
+	if suggestion.description ~= nil then
+		TEXT_BOUNDS_PARAMS.Text = suggestion.description
+		descriptionBounds = TextService:GetTextBoundsAsync(TEXT_BOUNDS_PARAMS)
+	end
+	local errorTextHeight = 0
+	local typeBadgeWidth = 0
+	if suggestion.type == "argument" then
+		-- Get error text bounds
+		if suggestion.error ~= nil then
+			local _condition = suggestion.error
+			if _condition == nil then
+				_condition = ""
+			end
+			TEXT_BOUNDS_PARAMS.Text = _condition
+			errorTextHeight = TextService:GetTextBoundsAsync(TEXT_BOUNDS_PARAMS).Y
+		end
+		-- Get type badge bounds
+		TEXT_BOUNDS_PARAMS.Text = suggestion.dataType
+		TEXT_BOUNDS_PARAMS.Width = maxBadgeWidth
+		typeBadgeWidth = TextService:GetTextBoundsAsync(TEXT_BOUNDS_PARAMS).X
+	end
+	return {
+		title = UDim2.fromOffset(titleBounds.X, titleBounds.Y),
+		description = UDim2.fromOffset(descriptionBounds.X, descriptionBounds.Y),
+		errorTextHeight = errorTextHeight,
+		typeBadgeWidth = typeBadgeWidth,
+	}
+end
+return {
+	highlightMatching = highlightMatching,
+	getSuggestionTextBounds = getSuggestionTextBounds,
+}

package/out/components/terminal-text-field.d.ts

@@ -0,0 +1,11 @@
+import { BindingOrValue } from "@rbxts/pretty-react-hooks";
+interface TerminalTextFieldProps {
+    anchorPoint?: BindingOrValue<Vector2>;
+    size?: BindingOrValue<UDim2>;
+    position?: BindingOrValue<UDim2>;
+    backgroundTransparency?: BindingOrValue<number>;
+    onTextChange?: (text: string) => void;
+    onSubmit?: (text: string) => void;
+}
+export declare function TerminalTextField({ anchorPoint, size, position, backgroundTransparency, onTextChange, onSubmit, }: TerminalTextFieldProps): JSX.Element;
+export {};

package/out/components/terminal-text-field.lua

@@ -0,0 +1,289 @@
+-- Compiled with roblox-ts v2.3.0-dev-26ec859
+local TS = _G[script]
+local _string = TS.import(script, TS.getModule(script, "@rbxts", "centurion").out.shared.util.string)
+local endsWithSpace = _string.endsWithSpace
+local formatPartsAsPath = _string.formatPartsAsPath
+local _pretty_react_hooks = TS.import(script, TS.getModule(script, "@rbxts", "pretty-react-hooks").out)
+local getBindingValue = _pretty_react_hooks.getBindingValue
+local useEventListener = _pretty_react_hooks.useEventListener
+local useMountEffect = _pretty_react_hooks.useMountEffect
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local React = _react
+local useBinding = _react.useBinding
+local useCallback = _react.useCallback
+local useContext = _react.useContext
+local useEffect = _react.useEffect
+local useRef = _react.useRef
+local useState = _react.useState
+local useSelector = TS.import(script, TS.getModule(script, "@rbxts", "react-reflex")).useSelector
+local UserInputService = TS.import(script, TS.getModule(script, "@rbxts", "services")).UserInputService
+local usePx = TS.import(script, script.Parent.Parent, "hooks", "use-px").usePx
+local useStore = TS.import(script, script.Parent.Parent, "hooks", "use-store").useStore
+local ApiContext = TS.import(script, script.Parent.Parent, "providers", "api-provider").ApiContext
+local OptionsContext = TS.import(script, script.Parent.Parent, "providers", "options-provider").OptionsContext
+local selectVisible = TS.import(script, script.Parent.Parent, "store", "app").selectVisible
+local selectCommand = TS.import(script, script.Parent.Parent, "store", "command").selectCommand
+local selectSuggestion = TS.import(script, script.Parent.Parent, "store", "suggestion").selectSuggestion
+local selectValid = TS.import(script, script.Parent.Parent, "store", "text").selectValid
+local getArgumentNames = TS.import(script, script.Parent.Parent, "util", "argument").getArgumentNames
+local Frame = TS.import(script, script.Parent, "ui", "frame").Frame
+local Padding = TS.import(script, script.Parent, "ui", "padding").Padding
+local Text = TS.import(script, script.Parent, "ui", "text").Text
+local TextField = TS.import(script, script.Parent, "ui", "text-field").TextField
+local TEXT_SIZE = 22
+local function TerminalTextField(_param)
+	local anchorPoint = _param.anchorPoint
+	local size = _param.size
+	local position = _param.position
+	local backgroundTransparency = _param.backgroundTransparency
+	local onTextChange = _param.onTextChange
+	local onSubmit = _param.onSubmit
+	local px = usePx()
+	local ref = useRef()
+	local api = useContext(ApiContext)
+	local options = useContext(OptionsContext)
+	local store = useStore()
+	local appVisible = useSelector(selectVisible)
+	local currentSuggestion = useSelector(selectSuggestion)
+	local text, setText = useBinding("")
+	local suggestionText, setSuggestionText = useBinding("")
+	local valid, setValid = useState(false)
+	local traverseHistory = useCallback(function(up)
+		local history = store:getState().history.commandHistory
+		if #history == 0 then
+			return nil
+		end
+		local historyIndex = store:getState().history.commandHistoryIndex
+		if (up and historyIndex == 0) or (not up and historyIndex == -1) then
+			return nil
+		end
+		local newIndex
+		if up then
+			newIndex = if historyIndex == -1 then #history - 1 else historyIndex - 1
+		else
+			newIndex = if historyIndex ~= #history - 1 then historyIndex + 1 else -1
+		end
+		local newText = if newIndex ~= -1 then history[newIndex + 1] else ""
+		setText(newText)
+		setSuggestionText("")
+		store.setCommandHistoryIndex(newIndex)
+		if ref.current ~= nil then
+			ref.current.CursorPosition = #newText + 1
+		end
+	end, {})
+	useEffect(function()
+		if ref.current == nil then
+			return nil
+		end
+		if appVisible then
+			ref.current:CaptureFocus()
+		else
+			ref.current:ReleaseFocus()
+		end
+	end, { appVisible })
+	useMountEffect(function()
+		store:subscribe(selectValid, function(valid)
+			setValid(valid)
+		end)
+		store:subscribe(selectCommand, function(command)
+			if not store:getState().text.valid then
+				return nil
+			end
+			setValid(command ~= nil)
+		end)
+	end)
+	useEffect(function()
+		if currentSuggestion == nil then
+			setSuggestionText("")
+			return nil
+		end
+		local state = store:getState()
+		local atNextPart = endsWithSpace(state.text.value)
+		local suggestionStartIndex = if #state.text.parts > 0 then (if not atNextPart then #state.text.parts[#state.text.parts] else 0) + 1 else -1
+		local command = state.command.path
+		local argIndex = state.command.argIndex
+		if currentSuggestion.main.type == "command" and suggestionStartIndex > -1 then
+			setSuggestionText(getBindingValue(text) .. string.sub(currentSuggestion.main.title, suggestionStartIndex))
+			return nil
+		end
+		if currentSuggestion.main.type ~= "argument" or command == nil or argIndex == nil then
+			return nil
+		end
+		local newText = getBindingValue(text)
+		local argNames = getArgumentNames(api.registry, command)
+		for i = argIndex, #argNames - 1 do
+			if i == argIndex and not atNextPart then
+				if not (#currentSuggestion.others == 0) then
+					newText ..= string.sub(currentSuggestion.others[1], suggestionStartIndex)
+				end
+				newText ..= " "
+				continue
+			end
+			newText = `{newText}{argNames[i + 1]} `
+		end
+		setSuggestionText(newText)
+	end, { currentSuggestion })
+	useEventListener(UserInputService.InputBegan, function(input)
+		if ref.current == nil or not ref.current:IsFocused() then
+			return nil
+		end
+		if input.KeyCode == Enum.KeyCode.Up then
+			traverseHistory(true)
+		elseif input.KeyCode == Enum.KeyCode.Down then
+			traverseHistory(false)
+		end
+		if input.KeyCode ~= Enum.KeyCode.Tab then
+			return nil
+		end
+		local state = store:getState()
+		local commandPath = state.command.path
+		-- Handle command suggestions
+		if commandPath == nil then
+			local _suggestionTitle = currentSuggestion
+			if _suggestionTitle ~= nil then
+				_suggestionTitle = _suggestionTitle.main.title
+			end
+			local suggestionTitle = _suggestionTitle
+			if suggestionTitle == nil then
+				return nil
+			end
+			local currentText = text:getValue()
+			local newText = ""
+			if endsWithSpace(currentText) then
+				newText = currentText .. suggestionTitle
+			elseif not (#state.text.parts == 0) then
+				local textPartSize = #state.text.parts[#state.text.parts]
+				local _arg1 = #currentText - textPartSize
+				newText = string.sub(currentText, 0, _arg1) .. suggestionTitle
+			end
+			local suggestionTextParts = string.split((string.gsub(suggestionText:getValue(), "%s+", " ")), " ")
+			local _nextCommand = api.registry:getCommandByString(formatPartsAsPath(suggestionTextParts))
+			if _nextCommand ~= nil then
+				_nextCommand = _nextCommand.options
+			end
+			local nextCommand = _nextCommand
+			local _condition = nextCommand == nil
+			if not _condition then
+				local _result = nextCommand.arguments
+				if _result ~= nil then
+					_result = #_result
+				end
+				local _condition_1 = _result
+				if _condition_1 == nil then
+					_condition_1 = 0
+				end
+				_condition = _condition_1 > 0
+			end
+			if _condition then
+				newText ..= " "
+			end
+			setSuggestionText("")
+			setText(newText)
+			ref.current.CursorPosition = #newText + 1
+			return nil
+		end
+		-- Handle argument suggestions
+		if commandPath == nil or currentSuggestion == nil or #currentSuggestion.others == 0 then
+			return nil
+		end
+		local argIndex = state.command.argIndex
+		local _commandArgs = api.registry:getCommand(commandPath)
+		if _commandArgs ~= nil then
+			_commandArgs = _commandArgs.options.arguments
+		end
+		local commandArgs = _commandArgs
+		if argIndex == nil or commandArgs == nil then
+			return nil
+		end
+		local newText = getBindingValue(text)
+		local parts = state.text.parts
+		if not endsWithSpace(newText) and not (#parts == 0) then
+			local _newText = newText
+			local _arg1 = #newText - #parts[#parts]
+			newText = string.sub(_newText, 0, _arg1)
+		end
+		local suggestion = currentSuggestion.others[1]
+		if (string.match(suggestion, "%s")) ~= nil then
+			suggestion = `"{suggestion}"`
+		end
+		newText ..= suggestion
+		if argIndex < #commandArgs - 1 then
+			newText ..= " "
+		end
+		setSuggestionText("")
+		setText(newText)
+		ref.current.CursorPosition = #newText + 1
+	end)
+	return React.createElement(Frame, {
+		anchorPoint = anchorPoint,
+		size = size,
+		position = position,
+		backgroundColor = options.palette.surface,
+		backgroundTransparency = backgroundTransparency,
+		cornerRadius = UDim.new(0, px(4)),
+	}, React.createElement(Padding, {
+		all = UDim.new(0, px(8)),
+	}), React.createElement(TextField, {
+		size = UDim2.fromScale(1, 1),
+		placeholderText = "Enter command...",
+		text = text,
+		textSize = px(TEXT_SIZE),
+		textColor = if valid then options.palette.success else options.palette.error,
+		placeholderColor = options.palette.subtext,
+		textXAlignment = "Left",
+		clearTextOnFocus = false,
+		font = options.font.medium,
+		ref = ref,
+		event = {
+			FocusLost = function(rbx, enterPressed)
+				if not enterPressed then
+					return nil
+				end
+				store.addCommandHistory(rbx.Text, api.options.historyLength)
+				store.setCommandHistoryIndex(-1)
+				local _result = onSubmit
+				if _result ~= nil then
+					_result(rbx.Text)
+				end
+				local _result_1 = ref.current
+				if _result_1 ~= nil then
+					_result_1:CaptureFocus()
+				end
+				setText("")
+			end,
+		},
+		change = {
+			Text = function(rbx)
+				local newText = rbx.Text
+				-- Remove line breaks
+				if (string.match(newText, "[\n\r]")) ~= nil then
+					newText = (string.gsub(newText, "[\n\r]", ""))
+				end
+				-- Remove all tabs from text input - we use these for autocompletion
+				if (string.match(newText, "\t")) ~= nil then
+					newText = (string.gsub(newText, "\t", ""))
+				end
+				-- Reset command history index
+				if store:getState().history.commandHistoryIndex ~= -1 then
+					store.setCommandHistoryIndex(-1)
+				end
+				setText(newText)
+				local _result = onTextChange
+				if _result ~= nil then
+					_result(newText)
+				end
+			end,
+		},
+		zIndex = 2,
+	}), React.createElement(Text, {
+		size = UDim2.fromScale(1, 1),
+		text = suggestionText,
+		textColor = options.palette.subtext,
+		textSize = px(TEXT_SIZE),
+		textXAlignment = "Left",
+		font = options.font.medium,
+	}))
+end
+return {
+	TerminalTextField = TerminalTextField,
+}

package/out/components/terminal-window.d.ts

@@ -0,0 +1 @@
+export declare function TerminalWindow(): JSX.Element;