@rbxts/touch-button 1.0.9 → 1.0.11

package/README.md

@@ -0,0 +1,5 @@
+# TouchButton
+
+## Install
+Install with [wally](https://wally.run/):\
+`TouchButton = "shouxtech/touch-button@1.0.11"`

package/package.json

@@ -1,38 +1,24 @@
 {
   "name": "@rbxts/touch-button",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "",
-  "main": "out/init.lua",
-  "scripts": {
-    "build": "rbxtsc",
-    "watch": "rbxtsc -w",
-    "prepublishOnly": "npm run build"
-  },
+  "main": "src/init.lua",
+  "scripts": {},
   "keywords": [],
   "author": "CriShoux",
   "license": "ISC",
   "type": "commonjs",
-  "types": "out/index.d.ts",
+  "types": "src/index.d.ts",
   "files": [
-    "out",
-    "!**/*.tsbuildinfo"
+    "src"
   ],
   "publishConfig": {
     "access": "public"
   },
   "devDependencies": {
     "@rbxts/compiler-types": "^3.0.0-types.0",
-    "@rbxts/types": "^1.0.848",
+    "@rbxts/types": "^1.0.896",
     "roblox-ts": "^3.0.0",
-    "typescript": "^5.8.3"
-  },
-  "dependencies": {
-    "@rbxts/charm": "^0.10.0",
-    "@rbxts/remo": "^1.5.1",
-    "@rbxts/roblox-observers": "^1.0.10",
-    "@rbxts/services": "^1.5.5",
-    "@rbxts/sleitnick-signal": "^1.0.8",
-    "@rbxts/t": "^3.2.1",
-    "@rbxts/trove": "^1.3.0"
+    "typescript": "^5.9.3"
   }
-}
+}

package/src/Client.lua

@@ -0,0 +1,395 @@
+--!strict
+local Players = game:GetService('Players');
+local UserInputService = game:GetService('UserInputService');
+local Workspace = game:GetService('Workspace');
+
+local Shared = require(script.Parent.Shared);
+local isTypeScriptEnv = script.Parent.Name == 'src';
+local dependencies = if isTypeScriptEnv then script.Parent.Parent.Parent else script.Parent.Parent;
+local Charm = require(isTypeScriptEnv and dependencies.charm or dependencies.Charm);
+local Trove = require(isTypeScriptEnv and dependencies['sleitnick-trove'] or dependencies.Trove);
+
+type TouchButton = {
+	setIcon: (self: TouchButton, icon: string) -> (),
+	setSize: (self: TouchButton, size: UDim2) -> (),
+	setPosition: (self: TouchButton, position: UDim2) -> (),
+	setConfig: (self: TouchButton, config: Shared.TouchButtonConfig) -> (),
+	destroy: (self: TouchButton) -> (),
+};
+
+type TouchButtonOptions = {
+	name: string,
+	icon: string,
+	size: UDim2,
+	position: UDim2,
+	sinkInput: boolean?,
+	onPress: (() -> ())?,
+	onRelease: (() -> ())?,
+};
+
+local localPlayer = Players.LocalPlayer;
+local camera = Workspace.CurrentCamera :: Camera;
+
+local touchGui: ScreenGui?;
+local jumpBtn: Frame?;
+
+local initialized = false;
+
+local EDITING_MODE_BUTTON_COLOR = Color3.fromRGB(15, 143, 255);
+local MIN_RESIZE = 40;
+
+local function getJumpButtonLayout()
+	local minAxis = math.min(camera.ViewportSize.X, camera.ViewportSize.Y);
+	local isSmallScreen = minAxis <= 500;
+	local jumpButtonSize = if isSmallScreen then 70 else 120;
+
+	return {
+		size = UDim2.fromOffset(jumpButtonSize, jumpButtonSize),
+		position = if isSmallScreen 
+			then UDim2.new(1, -(jumpButtonSize * 1.5 - 10), 1, -jumpButtonSize - 20) 
+			else UDim2.new(1, -(jumpButtonSize * 1.5 - 10), 1, -jumpButtonSize * 1.75),
+	};
+end;
+
+local function getTouchGui()
+	if touchGui and jumpBtn then
+		return touchGui, jumpBtn;
+	end;
+
+	local newTouchGui = Instance.new('ScreenGui');
+	newTouchGui.Name = 'CustomTouchGui';
+	newTouchGui.ResetOnSpawn = false;
+	newTouchGui.Parent = localPlayer:WaitForChild('PlayerGui');
+	touchGui = newTouchGui;
+
+	local newJumpBtn = Instance.new('Frame');
+	newJumpBtn.Name = 'Jump';
+	newJumpBtn.BackgroundTransparency = 1;
+
+	local function updateLayout()
+		local jumpBtnLayout = getJumpButtonLayout();
+		newJumpBtn.Position = jumpBtnLayout.position;
+		newJumpBtn.Size = jumpBtnLayout.size;
+	end;
+
+	camera:GetPropertyChangedSignal('ViewportSize'):Connect(updateLayout);
+	updateLayout();
+
+	newJumpBtn.Parent = newTouchGui;
+	jumpBtn = newJumpBtn;
+
+	local characterExists = Charm.atom(localPlayer.Character ~= nil);
+	local lastInputType = Charm.atom(UserInputService:GetLastInputType());
+
+	Charm.effect(function()
+		local charExists = characterExists();
+		local inputType = lastInputType();
+
+		newTouchGui.Enabled = (inputType == Enum.UserInputType.Touch) and charExists;
+	end);
+
+	localPlayer.CharacterAdded:Connect(function()
+		characterExists(true);
+	end);
+	localPlayer.CharacterRemoving:Connect(function()
+		characterExists(false);
+	end);
+
+	UserInputService.LastInputTypeChanged:Connect(lastInputType);
+
+	return newTouchGui, newJumpBtn;
+end;
+
+local Client = {};
+Client.__index = Client;
+
+Client.configEditingMode = Charm.atom(false);
+Client.touchButtons = {} :: { TouchButton };
+
+function Client._init()
+	if initialized then return; end;
+	initialized = true;
+
+	local editingTrove = Trove.new();
+
+	Charm.effect(function()
+		local isEditing = Client.configEditingMode();
+		if isEditing then
+			local function createButton(props: { name: string, text: string, backgroundColor: Color3, offsetY: number })
+				local btn = Instance.new('TextButton');
+				btn.Name = props.name;
+				btn.AnchorPoint = Vector2.new(0.5, 0.5);
+				btn.BackgroundColor3 = props.backgroundColor;
+				btn.BackgroundTransparency = 0.25;
+				btn.FontFace = Font.new('rbxasset://fonts/families/GothamSSm.json', Enum.FontWeight.Medium, Enum.FontStyle.Normal);
+				btn.Position = UDim2.new(0.5, 0, 0.5, props.offsetY);
+				btn.Size = UDim2.fromOffset(120, 32);
+				btn.Text = props.text;
+				btn.TextColor3 = Color3.new(1, 1, 1);
+				btn.TextSize = 16;
+				btn.Parent = touchGui;
+				editingTrove:Add(btn);
+
+				local uiCorner = Instance.new('UICorner');
+				uiCorner.CornerRadius = UDim.new(0, 5);
+				uiCorner.Parent = btn;
+
+				return btn;
+			end;
+
+			createButton({
+				name = 'Reset',
+				text = 'Reset Buttons',
+				backgroundColor = Color3.new(),
+				offsetY = -19,
+			}).MouseButton1Click:Connect(function()
+				for _, touchBtn in Client.touchButtons do
+					touchBtn:_resetConfigToDefault();
+				end;
+			end);
+
+			createButton({
+				name = 'Finish',
+				text = 'Finish Editing',
+				backgroundColor = Color3.fromRGB(30, 175, 30),
+				offsetY = 19,
+			}).MouseButton1Click:Connect(function()
+				Client.configEditingMode(false);
+			end);
+		else
+			editingTrove:Clean();
+		end;
+	end);
+end;
+
+function Client.new(options: TouchButtonOptions)
+	Client._init();
+
+	for _, otherTouchBtn in Client.touchButtons do
+		assert(otherTouchBtn._name ~= options.name, `A TouchButton with the name {options.name} already exists`);
+	end;
+
+	local self = setmetatable({}, Client);
+
+	self._name = options.name;
+	self._desiredBtnColor = Color3.fromRGB(255, 255, 255);
+	self._defaultConfig = {
+		position = options.position,
+		size = options.size,
+	};
+	self._configUpdateScheduled = false;
+
+	task.spawn(function()
+		local config = Shared.getTouchButtonConfig:InvokeServer(options.name);
+		if not config then return; end;
+		self:setConfig(config);
+	end);
+
+	local touchBtn = Instance.new('ImageButton');
+	touchBtn.Name = 'TouchButton';
+	touchBtn.Active = if options.sinkInput then true else false;
+	touchBtn.Image = 'http://www.roblox.com/asset/?id=15340864550';
+	touchBtn.ImageColor3 = Color3.fromRGB(255, 255, 255);
+	touchBtn.ImageTransparency = 0.5;
+	touchBtn.AnchorPoint = Vector2.new(0.5, 0.5);
+	touchBtn.BackgroundTransparency = 1;
+	touchBtn.Size = UDim2.fromScale(1, 1);
+
+	local iconImage = Instance.new('ImageLabel');
+	iconImage.Name = 'Icon';
+	iconImage.AnchorPoint = Vector2.new(0.5, 0.5);
+	iconImage.BackgroundTransparency = 1;
+	iconImage.ImageColor3 = self._desiredBtnColor;
+	iconImage.ImageTransparency = 0.2;
+	iconImage.Position = UDim2.fromScale(0.5, 0.5);
+	iconImage.Size = UDim2.fromScale(0.56, 0.56);
+	iconImage.Parent = touchBtn;
+
+	self._touchBtn = touchBtn;
+
+	touchBtn.InputBegan:Connect(function(input)
+		if (input.UserInputType ~= Enum.UserInputType.MouseButton1) and (input.UserInputType ~= Enum.UserInputType.Touch) then return; end;
+		if input.UserInputState ~= Enum.UserInputState.Begin then return; end;
+
+		if Client.configEditingMode() then return; end;
+
+		touchBtn.ImageColor3 = Color3.fromRGB(200, 200, 200);
+		iconImage.ImageColor3 = Color3.fromRGB(200, 200, 200);
+
+		if options.onPress then options.onPress(); end;
+
+		local connection;
+		connection = input:GetPropertyChangedSignal('UserInputState'):Connect(function()
+			if input.UserInputState ~= Enum.UserInputState.End then return; end;
+
+			connection:Disconnect();
+
+			touchBtn.ImageColor3 = Color3.fromRGB(255, 255, 255);
+			iconImage.ImageColor3 = self._desiredBtnColor;
+
+			if options.onRelease then options.onRelease(); end;
+		end);
+	end);
+
+	local editingTrove = Trove.new();
+	local lastActive = touchBtn.Active;
+
+	self._editEffect = Charm.effect(function()
+		local isEditing = Client.configEditingMode();
+
+		if isEditing then
+			lastActive = touchBtn.Active;
+
+			touchBtn.Active = true;
+			touchBtn.ImageColor3 = EDITING_MODE_BUTTON_COLOR;
+			iconImage.ImageColor3 = EDITING_MODE_BUTTON_COLOR;
+
+			local resizeBtn = Instance.new('ImageButton');
+			resizeBtn.AnchorPoint = Vector2.new(0.5, 0.5);
+			resizeBtn.BackgroundTransparency = 1;
+			resizeBtn.Image = 'http://www.roblox.com/asset/?id=101680714548913';
+			resizeBtn.Position = UDim2.fromScale(0.82, 0.82);
+			resizeBtn.Size = UDim2.fromOffset(18, 18);
+			resizeBtn.Parent = touchBtn;
+			editingTrove:Add(resizeBtn);
+
+			resizeBtn.InputBegan:Connect(function(input)
+				if (input.UserInputType ~= Enum.UserInputType.MouseButton1) and (input.UserInputType ~= Enum.UserInputType.Touch) then return; end;
+				if input.UserInputState ~= Enum.UserInputState.Begin then return; end;
+
+				local parent = touchBtn.Parent :: GuiObject;
+				local parentSize = parent.AbsoluteSize;
+				local initialAbsSize = touchBtn.AbsoluteSize;
+				local initialPos = Vector2.new(input.Position.X, input.Position.Y);
+
+				local moveConn = UserInputService.InputChanged:Connect(function(moveInput)
+					if (moveInput.UserInputType ~= Enum.UserInputType.MouseMovement) and (moveInput.UserInputType ~= Enum.UserInputType.Touch) then return; end;
+
+					local delta = Vector2.new(moveInput.Position.X, moveInput.Position.Y) - initialPos;
+					local maxDelta = math.max(delta.X, delta.Y);
+					local newAbsSize = initialAbsSize.X + maxDelta;
+
+					local finalAbsSize = math.max(MIN_RESIZE, newAbsSize);
+					local finalScale = finalAbsSize / parentSize.X;
+
+					self:setSize(UDim2.fromScale(finalScale, finalScale));
+				end);
+
+				local endConn;
+				endConn = UserInputService.InputEnded:Connect(function(endInput)
+					if (endInput.UserInputType ~= Enum.UserInputType.MouseButton1) and (endInput.UserInputType ~= Enum.UserInputType.Touch) then return; end;
+
+					moveConn:Disconnect();
+					endConn:Disconnect();
+				end);
+			end);
+
+			editingTrove:Add(touchBtn.InputBegan:Connect(function(input)
+				if (input.UserInputType ~= Enum.UserInputType.MouseButton1) and (input.UserInputType ~= Enum.UserInputType.Touch) then return; end;
+				if input.UserInputState ~= Enum.UserInputState.Begin then return; end;
+
+				local parent = touchBtn.Parent :: GuiObject;
+				local parentSize = parent.AbsoluteSize;
+				local initialInputPos = Vector2.new(input.Position.X, input.Position.Y);
+				local initialBtnPos = touchBtn.Position;
+
+				local moveConn = UserInputService.InputChanged:Connect(function(moveInput)
+					if (moveInput.UserInputType ~= Enum.UserInputType.MouseMovement) and (moveInput.UserInputType ~= Enum.UserInputType.Touch) then return; end;
+
+					local currentPos = Vector2.new(moveInput.Position.X, moveInput.Position.Y);
+					local delta = currentPos - initialInputPos;
+
+					local deltaScale = Vector2.new(delta.X / parentSize.X, delta.Y / parentSize.Y);
+
+					self:setPosition(UDim2.fromScale(initialBtnPos.X.Scale + deltaScale.X, initialBtnPos.Y.Scale + deltaScale.Y));
+				end);
+
+				local endConn;
+				endConn = UserInputService.InputEnded:Connect(function(endInput)
+					if (endInput.UserInputType ~= Enum.UserInputType.MouseButton1) and (endInput.UserInputType ~= Enum.UserInputType.Touch) then return; end;
+
+					moveConn:Disconnect();
+					endConn:Disconnect();
+				end);
+			end));
+		else
+			editingTrove:Clean();
+
+			touchBtn.Active = lastActive;
+			touchBtn.ImageColor3 = Color3.fromRGB(255, 255, 255);
+			iconImage.ImageColor3 = self._desiredBtnColor;
+		end;
+	end);
+
+	self:setIcon(options.icon);
+	self:setSize(options.size);
+	self:setPosition(options.position);
+
+	local _, currentJumpBtn = getTouchGui();
+	touchBtn.Parent = currentJumpBtn;
+
+	table.insert(Client.touchButtons, self);
+
+	return self;
+end;
+
+function Client:setIcon(icon: string)
+	self._touchBtn.Icon.Image = icon;
+end;
+
+function Client:setColor(color: Color3)
+	self._desiredBtnColor = color;
+	self._touchBtn.Icon.ImageColor3 = color;
+end;
+
+function Client:setSize(size: UDim2)
+	self._touchBtn.Size = size;
+	self:_scheduleConfigUpdate();
+end;
+
+function Client:setPosition(position: UDim2)
+	self._touchBtn.Position = position;
+	self:_scheduleConfigUpdate();
+end;
+
+function Client:setConfig(config: Shared.TouchButtonConfig)
+	self:setPosition(config.position);
+	self:setSize(config.size);
+end;
+
+function Client:_scheduleConfigUpdate()
+	if self._configUpdateScheduled then return; end;
+	self._configUpdateScheduled = true;
+
+	task.defer(function()
+		self._configUpdateScheduled = false;
+		self:_updateConfig();
+	end);
+end;
+
+function Client:_updateConfig()
+	Shared.setTouchButtonConfig:FireServer(self._name, {
+		position = self._touchBtn.Position,
+		size = self._touchBtn.Size,
+	});
+end;
+
+function Client:_resetConfigToDefault()
+	self:setConfig(self._defaultConfig);
+end;
+
+function Client:destroy()
+	self._touchBtn:Destroy();
+
+	if self._editEffect then
+		self._editEffect();
+		self._editEffect = nil;
+	end
+
+	local index = table.find(Client.touchButtons, self);
+	if index then
+		table.remove(Client.touchButtons, index);
+	end;
+end;
+
+return Client;

package/src/Server.lua

@@ -0,0 +1,161 @@
+--!strict
+local DataStoreService = game:GetService('DataStoreService');
+local Players = game:GetService('Players');
+
+local Shared = require(script.Parent.Shared);
+local isTypeScriptEnv = script.Parent.Name == 'src';
+local dependencies = if isTypeScriptEnv then script.Parent.Parent.Parent else script.Parent.Parent;
+local Signal = require(isTypeScriptEnv and dependencies['sleitnick-signal'] or dependencies.Signal);
+
+type DataStoreEntry = { [string]: Shared.TouchButtonConfig };
+type SerializedTouchButtonConfig = { [string]: {number} };
+type SerializedDataStoreEntry = { [string]: SerializedTouchButtonConfig };
+
+local entriesCache: { [Player]: DataStoreEntry } = {};
+local playerDataLoaded = Signal.new();
+local initialized = false;
+
+local function getDataStoreKeyForPlayer(player: Player)
+	return `Player{player.UserId}`;
+end;
+
+local function waitForEntry(player: Player)
+	local entry = entriesCache[player];
+	if not entry then
+		local loadedPlayer, loadedEntry;
+		repeat
+			loadedPlayer, loadedEntry = playerDataLoaded:Wait();
+		until loadedPlayer == player;
+		entry = loadedEntry;
+	end;
+	return entry;
+end;
+
+local function serializeEntry(entry: DataStoreEntry)
+	local res: SerializedDataStoreEntry = {};
+
+	for buttonName, props in entry do
+		local serializedProps: SerializedTouchButtonConfig = {};
+
+		for propKey, propValue in props do
+			local serializedProp;
+
+			if typeof(propValue) == 'Vector2' then
+				serializedProp = { propValue.X, propValue.Y };
+			elseif typeof(propValue) == 'UDim2' then
+				serializedProp = { propValue.X.Scale, propValue.X.Offset, propValue.Y.Scale, propValue.Y.Offset };
+			end;
+
+			if serializedProp then
+				serializedProps[propKey] = serializedProp;
+			end;
+		end;
+
+		res[buttonName] = serializedProps;
+	end;
+
+	return res;
+end;
+
+local function deserializeEntry(entry: SerializedDataStoreEntry)
+	local res: DataStoreEntry = {};
+
+	for buttonName, serializedProps in entry do
+		local props: Shared.TouchButtonConfig = {};
+
+		for propKey, serializedValue in serializedProps do
+			local deserializedProp;
+
+			if #serializedValue == 2 then
+				deserializedProp = Vector2.new(serializedValue[1], serializedValue[2]);
+			elseif #serializedValue == 4 then
+				deserializedProp = UDim2.new(serializedValue[1], serializedValue[2], serializedValue[3], serializedValue[4]);
+			end;
+
+			props[propKey] = deserializedProp;
+		end;
+
+		res[buttonName] = props;
+	end;
+
+	return res;
+end;
+
+local function isDictOfSize(dict: { [unknown]: unknown }, size: number)
+	local dictSize = 0;
+	for _ in dict do
+		dictSize += 1;
+		if dictSize > size then return false; end;
+	end;
+	return dictSize == size;
+end;
+
+local Server = {};
+
+function Server.init(validTouchButtonNames: { string })
+	assert(not initialized, 'TouchButton.Server already initialized');
+	initialized = true;
+
+	local buttonsStore = DataStoreService:GetDataStore('TouchButtonConfigs');
+
+	Shared.getTouchButtonConfig.OnServerInvoke = function(player: Player, buttonName: string)
+		local entry = waitForEntry(player);
+		return entry[buttonName];
+	end;
+
+	Shared.setTouchButtonConfig.OnServerEvent:Connect(function(player: Player, buttonName: string, config: Shared.TouchButtonConfig)
+		assert(table.find(validTouchButtonNames, buttonName), `TouchButton: {buttonName} is not a valid savable TouchButton name`);
+
+		if typeof(config) ~= 'table' then return; end;
+		if not config.size then return; end;
+		if not config.position then return; end;
+		if not isDictOfSize(config, 2) then return; end;
+
+		local entry = waitForEntry(player);
+		entry[buttonName] = config;
+	end);
+
+	local function onPlayerAdded(player: Player)
+		local key = getDataStoreKeyForPlayer(player);
+
+		local suc, entryOrUndefinedOrErr = pcall(function()
+			return buttonsStore:GetAsync(key);
+		end);
+		if not suc then
+			warn('TouchButton: Failed to load DataStore entry:', entryOrUndefinedOrErr);
+			return;
+		end;
+
+		if not player:IsDescendantOf(Players) then return; end;
+
+		local entry = if entryOrUndefinedOrErr then deserializeEntry(entryOrUndefinedOrErr) else {};
+
+		entriesCache[player] = entry;
+		playerDataLoaded:Fire(player, entry);
+	end;
+
+	local function onPlayerRemoving(player: Player)
+		local entry = entriesCache[player];
+		if not entry then return; end;
+
+		local key = getDataStoreKeyForPlayer(player);
+		local serialized = serializeEntry(entry);
+
+		local suc, err = pcall(function()
+			buttonsStore:SetAsync(key, serialized, { player.UserId });
+		end);
+		if not suc then
+			warn(`TouchButton: Failed to save data for {player.Name}:`, err);
+		end;
+
+		entriesCache[player] = nil;
+	end;
+
+	for _, player in Players:GetPlayers() do
+		task.spawn(onPlayerAdded, player);
+	end;
+	Players.PlayerAdded:Connect(onPlayerAdded);
+	Players.PlayerRemoving:Connect(onPlayerRemoving);
+end;
+
+return Server;

package/src/Shared.lua

@@ -0,0 +1,38 @@
+--!strict
+local RunService = game:GetService('RunService');
+
+export type TouchButtonConfig = {
+	position: UDim2,
+	size: UDim2,
+};
+
+local IS_SERVER = RunService:IsServer();
+
+local function getRemoteEvent(name: string)
+	if IS_SERVER then
+		local remote = Instance.new('RemoteEvent');
+		remote.Name = name;
+		remote.Parent = script;
+		return remote;
+	end;
+
+	return script:WaitForChild(name) :: RemoteEvent;
+end;
+
+local function getRemoteFunction(name: string)
+	if IS_SERVER then
+		local remote = Instance.new('RemoteFunction');
+		remote.Name = name;
+		remote.Parent = script;
+		return remote;
+	end;
+
+	return script:WaitForChild(name) :: RemoteFunction;
+end;
+
+local Shared = {};
+
+Shared.getTouchButtonConfig = getRemoteFunction('GetTouchButtonConfig');
+Shared.setTouchButtonConfig = getRemoteEvent('SetTouchButtonConfig');
+
+return Shared;

package/src/index.d.ts

@@ -0,0 +1,36 @@
+declare namespace TouchButton {
+    interface TouchButtonConfig {
+        position: UDim2;
+        size: UDim2;
+    }
+
+    interface TouchButtonOptions {
+        name: string;
+        icon: string;
+        size: UDim2;
+        position: UDim2;
+        sinkInput?: boolean;
+        onPress?: () => void;
+        onRelease?: () => void;
+    }
+
+    namespace Server {
+        function init(validTouchButtonNames: string[]): void;
+    }
+
+    class Client {
+        static touchButtons: Client[];
+        static configEditingMode: (enabled?: boolean) => boolean;
+
+        constructor(options: TouchButtonOptions);
+
+        setIcon(icon: string): void;
+        setColor(color: Color3): void;
+        setSize(size: UDim2): void;
+        setPosition(position: UDim2): void;
+        setConfig(config: TouchButtonConfig): void;
+        destroy(): void;
+    }
+}
+
+export = TouchButton;

package/src/init.lua

@@ -0,0 +1,12 @@
+--!strict
+local RunService = game:GetService('RunService');
+
+local TouchButton = {};
+
+if RunService:IsServer() then
+	TouchButton.Server = require(script.Server);
+else
+	TouchButton.Client = require(script.Client);
+end;
+
+return TouchButton;

package/out/client/touch-button.d.ts

@@ -1,28 +0,0 @@
-import { TouchButtonConfig } from '../shared/remotes';
-export declare class TouchButton {
-    static configEditingMode: import("@rbxts/charm").Atom<boolean>;
-    static touchButtons: TouchButton[];
-    private static initialized;
-    private touchBtn;
-    private name;
-    private defaultConfig;
-    private configUpdateScheduled;
-    private static init;
-    constructor(options: {
-        name: string;
-        icon: string;
-        size: UDim2;
-        position: UDim2;
-        sinkInput?: boolean;
-        onPress?: () => void;
-        onRelease?: () => void;
-    });
-    setIcon(icon: string): void;
-    setSize(size: UDim2): void;
-    setPosition(position: UDim2): void;
-    setConfig(config: TouchButtonConfig): void;
-    private scheduleConfigUpdate;
-    private updateConfig;
-    private resetConfigToDefault;
-    destroy(): void;
-}

package/out/client/touch-button.luau

@@ -1,334 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local observeProperty = TS.import(script, TS.getModule(script, "@rbxts", "roblox-observers").src).observeProperty
-local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
-local Players = _services.Players
-local UserInputService = _services.UserInputService
-local Workspace = _services.Workspace
-local remotes = TS.import(script, script.Parent.Parent, "shared", "remotes").remotes
-local _charm = TS.import(script, TS.getModule(script, "@rbxts", "charm"))
-local atom = _charm.atom
-local effect = _charm.effect
-local Trove = TS.import(script, TS.getModule(script, "@rbxts", "trove").out).Trove
-local localPlayer = Players.LocalPlayer
-local camera = Workspace.CurrentCamera
-local touchGui
-local jumpBtn
-local EDITING_MODE_BUTTON_COLOR = Color3.fromRGB(15, 143, 255)
-local MIN_RESIZE = 40
--- This is taken from TouchJump.lua in PlayerScripts.
-local function getJumpButtonLayout()
-	local minAxis = math.min(camera.ViewportSize.X, camera.ViewportSize.Y)
-	local isSmallScreen = minAxis <= 500
-	local jumpButtonSize = if isSmallScreen then 70 else 120
-	return {
-		size = UDim2.fromOffset(jumpButtonSize, jumpButtonSize),
-		position = if isSmallScreen then UDim2.new(1, -(jumpButtonSize * 1.5 - 10), 1, -jumpButtonSize - 20) else UDim2.new(1, -(jumpButtonSize * 1.5 - 10), 1, -jumpButtonSize * 1.75),
-	}
-end
-local function getTouchGui()
-	if touchGui and jumpBtn then
-		return { touchGui, jumpBtn }
-	end
-	touchGui = Instance.new("ScreenGui")
-	touchGui.Name = "CustomTouchGui"
-	touchGui.ResetOnSpawn = false
-	touchGui.Parent = localPlayer.PlayerGui
-	jumpBtn = Instance.new("Frame")
-	jumpBtn.Name = "Jump"
-	jumpBtn.BackgroundTransparency = 1
-	observeProperty(camera, "ViewportSize", function()
-		local jumpBtnLayout = getJumpButtonLayout()
-		jumpBtn.Position = jumpBtnLayout.position
-		jumpBtn.Size = jumpBtnLayout.size
-	end)
-	jumpBtn.Parent = touchGui
-	local characterExists = atom(not not localPlayer.Character)
-	local lastInputType = atom(UserInputService:GetLastInputType())
-	effect(function()
-		local charExists = characterExists()
-		local inputType = lastInputType()
-		touchGui.Enabled = (inputType == Enum.UserInputType.Touch) and charExists
-	end)
-	localPlayer.CharacterAdded:Connect(function()
-		characterExists(true)
-	end)
-	localPlayer.CharacterRemoving:Connect(function()
-		characterExists(false)
-	end)
-	UserInputService.LastInputTypeChanged:Connect(lastInputType)
-	return { touchGui, jumpBtn }
-end
-local TouchButton
-do
-	TouchButton = setmetatable({}, {
-		__tostring = function()
-			return "TouchButton"
-		end,
-	})
-	TouchButton.__index = TouchButton
-	function TouchButton.new(...)
-		local self = setmetatable({}, TouchButton)
-		return self:constructor(...) or self
-	end
-	function TouchButton:constructor(options)
-		self.configUpdateScheduled = false
-		TouchButton:init()
-		for _1, otherTouchBtn in TouchButton.touchButtons do
-			local _arg0 = otherTouchBtn.name ~= options.name
-			local _arg1 = `A TouchButton with the name {options.name} already exists`
-			assert(_arg0, _arg1)
-		end
-		self.name = options.name
-		self.defaultConfig = {
-			position = options.position,
-			size = options.size,
-		}
-		local configPromise = remotes.getTouchButtonConfig:request(options.name)
-		local touchBtn = Instance.new("ImageButton")
-		touchBtn.Name = "TouchButton"
-		touchBtn.Active = not not options.sinkInput
-		touchBtn.Image = "http://www.roblox.com/asset/?id=15340864550"
-		touchBtn.ImageColor3 = Color3.fromRGB(255, 255, 255)
-		touchBtn.ImageTransparency = 0.5
-		touchBtn.AnchorPoint = Vector2.new(0.5, 0.5)
-		touchBtn.BackgroundTransparency = 1
-		touchBtn.Size = UDim2.fromScale(1, 1)
-		local iconImage = Instance.new("ImageLabel")
-		iconImage.Name = "Icon"
-		iconImage.AnchorPoint = Vector2.new(0.5, 0.5)
-		iconImage.BackgroundTransparency = 1
-		iconImage.ImageTransparency = 0.2
-		iconImage.Position = UDim2.fromScale(0.5, 0.5)
-		iconImage.Size = UDim2.fromScale(0.56, 0.56)
-		iconImage.Parent = touchBtn
-		touchBtn.InputBegan:Connect(function(input)
-			if (input.UserInputType ~= Enum.UserInputType.MouseButton1) and (input.UserInputType ~= Enum.UserInputType.Touch) then
-				return nil
-			end
-			if input.UserInputState ~= Enum.UserInputState.Begin then
-				return nil
-			end
-			if TouchButton.configEditingMode() then
-				return nil
-			end
-			touchBtn.ImageColor3 = Color3.fromRGB(200, 200, 200)
-			iconImage.ImageColor3 = Color3.fromRGB(200, 200, 200)
-			local _result = options.onPress
-			if _result ~= nil then
-				_result()
-			end
-			local connection
-			connection = input:GetPropertyChangedSignal("UserInputState"):Connect(function()
-				if input.UserInputState ~= Enum.UserInputState.End then
-					return nil
-				end
-				connection:Disconnect()
-				touchBtn.ImageColor3 = Color3.fromRGB(255, 255, 255)
-				iconImage.ImageColor3 = Color3.fromRGB(255, 255, 255)
-				local _result_1 = options.onRelease
-				if _result_1 ~= nil then
-					_result_1()
-				end
-			end)
-		end)
-		local editingTrove = Trove.new()
-		local lastActive = touchBtn.Active
-		effect(function()
-			local isEditing = TouchButton.configEditingMode()
-			if isEditing then
-				lastActive = touchBtn.Active
-				touchBtn.Active = true
-				touchBtn.ImageColor3 = EDITING_MODE_BUTTON_COLOR
-				iconImage.ImageColor3 = EDITING_MODE_BUTTON_COLOR
-				local resizeBtn = Instance.new("ImageButton")
-				resizeBtn.AnchorPoint = Vector2.new(0.5, 0.5)
-				resizeBtn.BackgroundTransparency = 1
-				resizeBtn.Image = "http://www.roblox.com/asset/?id=101680714548913"
-				resizeBtn.Position = UDim2.fromScale(0.82, 0.82)
-				resizeBtn.Size = UDim2.fromOffset(18, 18)
-				resizeBtn.Parent = touchBtn
-				editingTrove:add(resizeBtn)
-				resizeBtn.InputBegan:Connect(function(input)
-					if (input.UserInputType ~= Enum.UserInputType.MouseButton1) and (input.UserInputType ~= Enum.UserInputType.Touch) then
-						return nil
-					end
-					if input.UserInputState ~= Enum.UserInputState.Begin then
-						return nil
-					end
-					local parentSize = (touchBtn.Parent).AbsoluteSize
-					local initialAbsSize = touchBtn.AbsoluteSize
-					local initialPos = Vector2.new(input.Position.X, input.Position.Y)
-					local moveConn = UserInputService.InputChanged:Connect(function(moveInput)
-						if (moveInput.UserInputType ~= Enum.UserInputType.MouseMovement) and (moveInput.UserInputType ~= Enum.UserInputType.Touch) then
-							return nil
-						end
-						local delta = Vector2.new(moveInput.Position.X, moveInput.Position.Y) - initialPos
-						local maxDelta = math.max(delta.X, delta.Y)
-						local newAbsSize = initialAbsSize.X + maxDelta
-						local finalAbsSize = math.max(MIN_RESIZE, newAbsSize)
-						local finalScale = finalAbsSize / parentSize.X
-						self:setSize(UDim2.fromScale(finalScale, finalScale))
-					end)
-					local endConn
-					endConn = UserInputService.InputEnded:Connect(function(endInput)
-						if (endInput.UserInputType ~= Enum.UserInputType.MouseButton1) and (endInput.UserInputType ~= Enum.UserInputType.Touch) then
-							return nil
-						end
-						moveConn:Disconnect()
-						endConn:Disconnect()
-					end)
-				end)
-				editingTrove:add(touchBtn.InputBegan:Connect(function(input)
-					if (input.UserInputType ~= Enum.UserInputType.MouseButton1) and (input.UserInputType ~= Enum.UserInputType.Touch) then
-						return nil
-					end
-					if input.UserInputState ~= Enum.UserInputState.Begin then
-						return nil
-					end
-					local parentSize = (touchBtn.Parent).AbsoluteSize
-					local initialInputPos = Vector2.new(input.Position.X, input.Position.Y)
-					local initialBtnPos = touchBtn.Position
-					local moveConn = UserInputService.InputChanged:Connect(function(moveInput)
-						if (moveInput.UserInputType ~= Enum.UserInputType.MouseMovement) and (moveInput.UserInputType ~= Enum.UserInputType.Touch) then
-							return nil
-						end
-						local currentPos = Vector2.new(moveInput.Position.X, moveInput.Position.Y)
-						local delta = currentPos - initialInputPos
-						local deltaScale = Vector2.new(delta.X / parentSize.X, delta.Y / parentSize.Y)
-						self:setPosition(UDim2.fromScale(initialBtnPos.X.Scale + deltaScale.X, initialBtnPos.Y.Scale + deltaScale.Y))
-					end)
-					local endConn
-					endConn = UserInputService.InputEnded:Connect(function(endInput)
-						if (endInput.UserInputType ~= Enum.UserInputType.MouseButton1) and (endInput.UserInputType ~= Enum.UserInputType.Touch) then
-							return nil
-						end
-						moveConn:Disconnect()
-						endConn:Disconnect()
-					end)
-				end))
-			else
-				editingTrove:clean()
-				touchBtn.Active = lastActive
-				touchBtn.ImageColor3 = Color3.fromRGB(255, 255, 255)
-				iconImage.ImageColor3 = Color3.fromRGB(255, 255, 255)
-			end
-		end)
-		self.touchBtn = touchBtn
-		self:setIcon(options.icon)
-		self:setSize(options.size)
-		self:setPosition(options.position)
-		configPromise:andThen(function(config)
-			if not config then
-				return nil
-			end
-			self:setConfig(config)
-		end)
-		local _binding = getTouchGui()
-		local _ = _binding[1]
-		local jumpBtn = _binding[2]
-		touchBtn.Parent = jumpBtn
-		local _touchButtons = TouchButton.touchButtons
-		local _self = self
-		table.insert(_touchButtons, _self)
-	end
-	function TouchButton:init()
-		if self.initialized then
-			return nil
-		end
-		self.initialized = true
-		local editingTrove = Trove.new()
-		effect(function()
-			local isEditing = TouchButton.configEditingMode()
-			if isEditing then
-				local createButton = function(props)
-					local btn = Instance.new("TextButton")
-					btn.Name = props.name
-					btn.AnchorPoint = Vector2.new(0.5, 0.5)
-					btn.BackgroundColor3 = props.backgroundColor
-					btn.BackgroundTransparency = 0.25
-					btn.FontFace = Font.new("rbxasset://fonts/families/GothamSSm.json", Enum.FontWeight.Medium, Enum.FontStyle.Normal)
-					btn.Position = UDim2.new(0.5, 0, 0.5, props.offsetY)
-					btn.Size = UDim2.fromOffset(120, 32)
-					btn.Text = props.text
-					btn.TextColor3 = Color3.new(1, 1, 1)
-					btn.TextSize = 16
-					btn.Parent = touchGui
-					editingTrove:add(btn)
-					local UICorner = Instance.new("UICorner")
-					UICorner.CornerRadius = UDim.new(0, 5)
-					UICorner.Parent = btn
-					return btn
-				end
-				createButton({
-					name = "Reset",
-					text = "Reset Buttons",
-					backgroundColor = Color3.new(),
-					offsetY = -19,
-				}).MouseButton1Click:Connect(function()
-					for _, touchBtn in TouchButton.touchButtons do
-						touchBtn:resetConfigToDefault()
-					end
-				end)
-				createButton({
-					name = "Finish",
-					text = "Finish Editing",
-					backgroundColor = Color3.fromRGB(30, 175, 30),
-					offsetY = 19,
-				}).MouseButton1Click:Connect(function()
-					self.configEditingMode(false)
-				end)
-			else
-				editingTrove:clean()
-			end
-		end)
-	end
-	function TouchButton:setIcon(icon)
-		self.touchBtn.Icon.Image = icon
-	end
-	function TouchButton:setSize(size)
-		self.touchBtn.Size = size
-		self:scheduleConfigUpdate()
-	end
-	function TouchButton:setPosition(position)
-		self.touchBtn.Position = position
-		self:scheduleConfigUpdate()
-	end
-	function TouchButton:setConfig(config)
-		self:setPosition(config.position)
-		self:setSize(config.size)
-	end
-	function TouchButton:scheduleConfigUpdate()
-		if self.configUpdateScheduled then
-			return nil
-		end
-		self.configUpdateScheduled = true
-		task.defer(function()
-			self.configUpdateScheduled = false
-			self:updateConfig()
-		end)
-	end
-	function TouchButton:updateConfig()
-		remotes.setTouchButtonConfig:fire(self.name, {
-			position = self.touchBtn.Position,
-			size = self.touchBtn.Size,
-		})
-	end
-	function TouchButton:resetConfigToDefault()
-		self:setConfig(self.defaultConfig)
-	end
-	function TouchButton:destroy()
-		self.touchBtn:Destroy()
-		local _touchButtons = TouchButton.touchButtons
-		local _touchButtons_1 = TouchButton.touchButtons
-		local _self = self
-		local _arg0 = (table.find(_touchButtons_1, _self) or 0) - 1
-		table.remove(_touchButtons, _arg0 + 1)
-	end
-	TouchButton.configEditingMode = atom(false)
-	TouchButton.touchButtons = {}
-	TouchButton.initialized = false
-end
-return {
-	TouchButton = TouchButton,
-}

package/out/index.d.ts

@@ -1,2 +0,0 @@
-export { TouchButton } from './client/touch-button';
-export { TouchButtonServer } from './server';

package/out/init.luau

@@ -1,6 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local exports = {}
-exports.TouchButton = TS.import(script, script, "client", "touch-button").TouchButton
-exports.TouchButtonServer = TS.import(script, script, "server").TouchButtonServer
-return exports

package/out/server/index.d.ts

@@ -1,3 +0,0 @@
-export declare namespace TouchButtonServer {
-    function init(validTouchButtonNames: Set<string>): void;
-}

package/out/server/init.luau

@@ -1,115 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local _services = TS.import(script, TS.getModule(script, "@rbxts", "services"))
-local DataStoreService = _services.DataStoreService
-local RunService = _services.RunService
-local remotes = TS.import(script, script.Parent, "shared", "remotes").remotes
-local observePlayers = TS.import(script, TS.getModule(script, "@rbxts", "roblox-observers").src).observePlayers
-local Signal = TS.import(script, TS.getModule(script, "@rbxts", "sleitnick-signal"))
-local entriesCache = {}
-local playerDataLoaded = Signal.new()
-local initialized = false
-local function getDataStoreKeyForPlayer(player)
-	return `Player{player.UserId}`
-end
-local function waitForEntry(player)
-	local _player = player
-	local entry = entriesCache[_player]
-	if not entry then
-		local loadedPlayer
-		local loadedEntry
-		repeat
-			do
-				loadedPlayer, loadedEntry = playerDataLoaded:Wait()
-			end
-		until not (loadedPlayer ~= player)
-		entry = loadedEntry
-	end
-	return entry
-end
-local function serializeEntry(entry)
-	local res = {}
-	for buttonName, props in pairs(entry) do
-		local serializedProps = {}
-		for propKey, propValue in pairs(props) do
-			local serializedProp
-			if typeof(propValue) == "Vector2" then
-				serializedProp = { propValue.X, propValue.Y }
-			elseif typeof(propValue) == "UDim2" then
-				serializedProp = { propValue.X.Scale, propValue.X.Offset, propValue.Y.Scale, propValue.Y.Offset }
-			end
-			serializedProps[propKey] = serializedProp
-		end
-		res[buttonName] = serializedProps
-	end
-	return res
-end
-local function deserializeEntry(entry)
-	local res = {}
-	for buttonName, serializedProps in pairs(entry) do
-		local props = {}
-		for propKey, serializedValue in pairs(serializedProps) do
-			local deserializedProp
-			if #serializedValue == 2 then
-				deserializedProp = Vector2.new(serializedValue[1], serializedValue[2])
-			elseif #serializedValue == 4 then
-				deserializedProp = UDim2.new(serializedValue[1], serializedValue[2], serializedValue[3], serializedValue[4])
-			end
-			props[propKey] = deserializedProp
-		end
-		res[buttonName] = props
-	end
-	return res
-end
-local TouchButtonServer = {}
-do
-	local _container = TouchButtonServer
-	local function init(validTouchButtonNames)
-		local _arg0 = RunService:IsServer()
-		assert(_arg0, "TouchButtonServer can only be initialized from the server")
-		local _arg0_1 = not initialized
-		assert(_arg0_1, "TouchButtonServer already initialized")
-		initialized = true
-		local buttonsStore = DataStoreService:GetDataStore("TouchButtonConfigs")
-		remotes.getTouchButtonConfig:onRequest(function(player, buttonName)
-			local entry = waitForEntry(player)
-			return entry[buttonName]
-		end)
-		remotes.setTouchButtonConfig:connect(function(player, buttonName, config)
-			local _validTouchButtonNames = validTouchButtonNames
-			local _buttonName = buttonName
-			local _arg0_2 = _validTouchButtonNames[_buttonName] ~= nil
-			local _arg1 = `[TOUCH BUTTONS] {buttonName} is not a valid savable TouchButton name`
-			assert(_arg0_2, _arg1)
-			local entry = waitForEntry(player)
-			entry[buttonName] = config
-		end)
-		observePlayers(function(player)
-			local key = getDataStoreKeyForPlayer(player)
-			local suc, entryOrUndefinedOrErr = pcall(function()
-				return buttonsStore:GetAsync(key)
-			end)
-			if not suc then
-				warn(`[TOUCH BUTTONS] Failed to load DataStore entry:`, entryOrUndefinedOrErr)
-				return nil
-			end
-			local entry = if entryOrUndefinedOrErr ~= 0 and entryOrUndefinedOrErr == entryOrUndefinedOrErr and entryOrUndefinedOrErr ~= "" and entryOrUndefinedOrErr then deserializeEntry(entryOrUndefinedOrErr) else {}
-			local _player = player
-			local _entry = entry
-			entriesCache[_player] = _entry
-			playerDataLoaded:Fire(player, entry)
-			return function()
-				local _player_1 = player
-				local entry = entriesCache[_player_1]
-				if not entry then
-					return nil
-				end
-				buttonsStore:SetAsync(key, serializeEntry(entry), { player.UserId })
-			end
-		end)
-	end
-	_container.init = init
-end
-return {
-	TouchButtonServer = TouchButtonServer,
-}

package/out/shared/remotes.d.ts

@@ -1,9 +0,0 @@
-import { Server } from '@rbxts/remo';
-export interface TouchButtonConfig {
-    position: UDim2;
-    size: UDim2;
-}
-export declare const remotes: import("@rbxts/remo").Remotes<{
-    getTouchButtonConfig: import("@rbxts/remo").RemoteBuilder<(buttonName: string) => TouchButtonConfig | undefined, Server>;
-    setTouchButtonConfig: import("@rbxts/remo").RemoteBuilder<(buttonName: string, config: TouchButtonConfig) => void, Server>;
-}>;

package/out/shared/remotes.luau

@@ -1,16 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
-local _remo = TS.import(script, TS.getModule(script, "@rbxts", "remo").src)
-local createRemotes = _remo.createRemotes
-local remote = _remo.remote
-local t = TS.import(script, TS.getModule(script, "@rbxts", "t").lib.ts).t
-local remotes = createRemotes({
-	getTouchButtonConfig = remote(t.string).returns(),
-	setTouchButtonConfig = remote(t.string, t.strictInterface({
-		position = t.UDim2,
-		size = t.UDim2,
-	})),
-})
-return {
-	remotes = remotes,
-}