@invisiblewater/menuprompt 1.0.0

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "luau-lsp.plugin.enabled": true
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Matthew Miller
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# MenuPrompt
+
+Base of a system for displaying menu prompts in Roblox games.

package/default.project.json

@@ -0,0 +1,7 @@
+{
+  "name": "menuprompt",
+  "globIgnorePaths": [ "**/.package-lock.json" ],
+  "tree": {
+    "$path": "src"
+  }
+}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@invisiblewater/menuprompt",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "keywords": [
+    "Roblox",
+    "Nevermore",
+    "Luau",
+    "menuprompt"
+  ],
+  "author": "InvisibleWater",
+  "license": "MIT",
+  "homepage": "https:/github.com/InvisibleWater/PlayerBankService#readme",
+  "bugs": {
+    "url": "https://github.com/InvisibleWater/MenuPrompt/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/InvisibleWater/MenuPrompt.git"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/InvisibleWater"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "^11.9.0",
+      "onFail": "download"
+    }
+  },
+  "type": "module",
+  "dependencies": {
+    "@quenty/basicpane": "^13.31.1",
+    "@quenty/blend": "^12.36.1",
+    "@quenty/gamescalingutils": "^13.36.1",
+    "@quenty/genericscreenguiprovider": "^13.39.1",
+    "@quenty/loader": "^10.11.0",
+    "@quenty/maid": "^3.9.0",
+    "@quenty/promise": "^10.18.1",
+    "@quenty/promptqueue": "^1.37.1",
+    "@quenty/rx": "^13.28.3",
+    "@quenty/servicebag": "^11.18.1",
+    "@quenty/transitionmodel": "^7.38.1",
+    "@quenty/valueobject": "^13.31.1"
+  },
+  "scripts": {
+    "preinstall": "npx only-allow pnpm"
+  }
+}

package/src/Client/MenuPrompt.luau

@@ -0,0 +1,110 @@
+--!strict
+
+local require = require(script.Parent.loader).load(script)
+
+local BasicPane = require("BasicPane")
+local BasicPaneUtils = require("BasicPaneUtils")
+local Blend = require("Blend")
+local Maid = require("Maid")
+local Observable = require("Observable")
+local Promise = require("Promise")
+local SpringTransitionModel = require("SpringTransitionModel")
+local SustainModel = require("SustainModel")
+local TransitionModel = require("TransitionModel")
+local ValueObject = require("ValueObject")
+
+local MenuPrompt = setmetatable({}, TransitionModel)
+MenuPrompt.__index = MenuPrompt
+
+export type MenuPrompt = typeof(setmetatable(
+    {} :: {
+        _percentVisibleModel: SpringTransitionModel.SpringTransitionModel<number>,
+        _sustainModel: SustainModel.SustainModel,
+        _backgroundColor: ValueObject.ValueObject<Color3>,
+        _sizeValue: ValueObject.ValueObject<Vector2>,
+        _buildPromptBody: PromptBodyBuilder
+    },
+    {} :: typeof({__index = MenuPrompt})
+)) & TransitionModel.TransitionModel
+
+export type PromptBodyBuilder = (MenuPrompt, Maid.Maid) -> BasicPane.BasicPane
+
+function MenuPrompt.new(promptBodyBuilder: PromptBodyBuilder): MenuPrompt
+    local self = setmetatable(TransitionModel.new() :: any, MenuPrompt)
+
+    self._buildPromptBody = promptBodyBuilder
+
+    self._percentVisibleModel = self._maid:Add(SpringTransitionModel.new())
+    self._percentVisibleModel:SetSpeed(100)
+    self._percentVisibleModel:SetEpsilon(1e-2)
+    self._percentVisibleModel:BindToPaneVisbility(self)
+
+    self._sustainModel = self._maid:Add(SustainModel.new())
+
+    self._sizeValue = self._maid:Add(ValueObject.new(Vector2.new(4, 3), "Vector2"))
+    self._backgroundColor = self._maid:Add(ValueObject.new(Color3.fromRGB(27, 42, 53), "Color3"))
+
+    self._maid:GiveTask(self:_render():Subscribe(function(gui)
+        self.Gui = gui
+    end))
+
+    self:SetPromiseShow(function(maid, doNotAnimate)
+        self._percentVisibleModel:PromiseShow(maid, doNotAnimate)
+    end)
+    self:SetPromiseHide(function(...)
+        self._percentVisibleModel:PromiseHide(...)
+    end)
+
+    return self
+end
+
+function MenuPrompt.SetPromiseSustain(self: MenuPrompt, callback: SustainModel.SustainCallback): ()
+    self._sustainModel:SetPromiseSustain(callback)
+end
+
+function MenuPrompt.PromiseSustain(self: MenuPrompt, doNotAnimate: boolean?): Promise.Promise<()>
+    return self._sustainModel:PromiseSustain(doNotAnimate)
+end
+
+function MenuPrompt.Stop(self: MenuPrompt, doNotAnimate: boolean?): ()
+    return self._sustainModel:Stop(doNotAnimate)
+end
+
+function MenuPrompt.SetSize(self: MenuPrompt, size: ValueObject.Mountable<Vector2>): () -> ()
+    return self._sizeValue:Mount(size)
+end
+
+function MenuPrompt.SetBackgroundColor(self: MenuPrompt, color: ValueObject.Mountable<Color3>): () -> ()
+    return self._backgroundColor:Mount(color)
+end
+
+function MenuPrompt._render(self: MenuPrompt): Observable.Observable<Instance>
+    return Blend.New "Frame" {
+        Position = UDim2.fromScale(0.5, 0.5),
+        Size = UDim2.fromScale(0.75, 0.75),
+        AnchorPoint = Vector2.new(0.5, 0.5),
+        BackgroundColor3 = self._backgroundColor,
+        BackgroundTransparency = Blend.Computed(self._percentVisibleModel, function(alpha): number
+            return 0.5 * (1 - alpha)
+        end),
+        Blend.New "UIAspectRatioConstraint" {
+            AspectRatio = Blend.Computed(self._sizeValue, function(size): number
+                if size.X <= 0 or size.Y <= 0 then
+                    return 1
+                else
+                    return size.X / size.Y
+                end
+            end)
+        },
+        Blend.New "UIScale" {
+            Scale = self._percentVisibleModel
+        },
+        (self:ObserveIsShowingComplete() :: any):Pipe{
+            BasicPaneUtils.whenVisibleBrio(function(maid): BasicPane.BasicPane 
+                return self:_buildPromptBody(maid)
+            end)
+        }
+    }
+end
+
+return MenuPrompt

package/src/Client/MenuPromptScreenGuiProvider.luau

@@ -0,0 +1,7 @@
+local require = require(script.Parent.loader).load(script)
+
+local GenericScreenGuiProvider = require("GenericScreenGuiProvider")
+
+return GenericScreenGuiProvider.new({
+    MENU_PROMPT = 9999
+})

package/src/Client/MenuPromptService.luau

@@ -0,0 +1,85 @@
+--!nonstrict
+
+--[=[
+	@class MenuPromptService
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Blend = require("Blend")
+local GameScalingUtils = require("GameScalingUtils")
+local Maid = require("Maid")
+local MenuPrompt = require("MenuPrompt")
+local MenuPromptScreenGuiProvider = require("MenuPromptScreenGuiProvider")
+local Observable = require("Observable")
+local Promise = require("Promise")
+local PromptQueue = require("PromptQueue")
+local ServiceBag = require("ServiceBag")
+
+local MenuPromptService = {}
+MenuPromptService.ServiceName = "MenuPromptService"
+
+export type MenuPromptService = typeof(setmetatable(
+	{} :: {
+		_maid: Maid.Maid,
+		_queue: PromptQueue.PromptQueue,
+		_screenGui: ScreenGui
+	},
+	{} :: typeof({__index = MenuPromptService})
+))
+
+function MenuPromptService.Init(self: MenuPromptService, serviceBag: ServiceBag.ServiceBag)
+	self._maid = Maid.new()
+	self._queue = self._maid:Add(PromptQueue.new())
+	self._screenGui = self._maid:Add(serviceBag:GetService(MenuPromptScreenGuiProvider):Get("MENU_PROMPT"))
+end
+
+function MenuPromptService._renderUICorner(self: MenuPromptService, object: GuiObject): Observable.Observable<UICorner>
+	return Blend.New "UICorner" {
+		CornerRadius = GameScalingUtils.observeDialogPadding(self._screenGui),
+		Parent = object
+	}
+end
+
+function MenuPromptService.SetScreenGui(self: MenuPromptService, screenGui: ScreenGui): MenuPromptService
+	self._screenGui = screenGui or error("No ScreenGui")
+
+	return self
+end
+
+function MenuPromptService.PushPrompt(self: MenuPromptService, promptBodyBuilder: MenuPrompt.PromptBodyBuilder): MenuPrompt.MenuPrompt
+	local maid = Maid.new()
+
+	local prompt = maid:Add(MenuPrompt.new(promptBodyBuilder))
+	prompt.Gui.Parent = self._screenGui
+
+	maid:GiveTask(GameScalingUtils.renderDialogPadding{
+		Parent = prompt.Gui,
+		ScreenGui = self._screenGui
+	}:Subscribe())
+	maid:GiveTask(self:_renderUICorner(prompt.Gui):Subscribe())
+
+	self._maid:GivePromise(self._queue:Queue(prompt)):Finally(function()
+		maid:DoCleaning()
+	end)
+
+	return prompt
+end
+
+function MenuPromptService.HideCurrent(self: MenuPromptService, doNotAnimate: boolean?): Promise.Promise<()>
+	return self._queue:HideCurrent(doNotAnimate)
+end
+
+function MenuPromptService.ClearQueue(self: MenuPromptService, doNotAnimate: boolean?)
+	self._queue:Clear(doNotAnimate)
+end
+
+function MenuPromptService.ObserveIsShowing(self: MenuPromptService): Observable.Observable<boolean>
+	return self._queue:ObserveIsShowing()
+end
+
+function MenuPromptService.Destroy(self: MenuPromptService)
+	self._maid:DoCleaning()
+end
+
+return MenuPromptService

package/src/Client/MenuPromptService.story.luau

@@ -0,0 +1,105 @@
+--!nonstrict
+--[[
+    @class menuPromptService.story
+]]
+
+local require = (require :: any)(
+    game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent
+).bootstrapStory(script) :: typeof(require(script.Parent.loader).load(script))
+
+local BasicPane = require("BasicPane")
+local Blend = require("Blend")
+local Maid = require("Maid")
+local MenuPrompt = require("MenuPrompt")
+local MenuPromptService = require("MenuPromptService")
+local PromiseUtils = require("PromiseUtils")
+local ScreenGuiService = require("ScreenGuiService")
+local ServiceBag = require("ServiceBag")
+
+return function(target): () -> ()
+    local maid = Maid.new()
+    local serviceBag = maid:Add(ServiceBag.new())
+
+    local menuPromptService = serviceBag:GetService(MenuPromptService)
+    maid:GiveTask(serviceBag:GetService(ScreenGuiService):SetGuiParent(target))
+
+    serviceBag:Init()
+    serviceBag:Start()
+
+    local function buildPrompt(prompt: MenuPrompt.MenuPrompt, innerMaid: Maid.Maid)
+        prompt:SetPromiseSustain(function()
+            return PromiseUtils.delayed(10)
+        end)
+
+        local label = innerMaid:Add(Instance.new("TextLabel"))
+        label.Size = UDim2.fromScale(1, 1)
+        label.BackgroundTransparency = 1
+        label.Text = "Hello, world!"
+        label.TextColor3 = Color3.new(1, 1, 1)
+        label.TextScaled = true
+
+        return BasicPane.new(label)
+    end
+
+    local function showPrompt()
+        menuPromptService:PushPrompt(buildPrompt)
+    end
+
+    local function button(props)
+        return Blend.New "TextButton" {
+            AutomaticSize = Enum.AutomaticSize.XY,
+            AutoButtonColor = true,
+            Text = props.Text,
+            [Blend.OnEvent "Activated"] = props.OnActivated,
+            Blend.New "UIPadding" {
+                PaddingTop = UDim.new(0, 10),
+                PaddingBottom = UDim.new(0, 10),
+                PaddingLeft = UDim.new(0, 10),
+                PaddingRight = UDim.new(0, 10)
+            },
+            Blend.New "UICorner" {
+                CornerRadius = UDim.new(0, 5)
+            }
+        }
+    end
+
+    showPrompt()
+
+    maid:GiveTask(Blend.mount(target, {
+        Blend.New "Frame" {
+            AutomaticSize = Enum.AutomaticSize.XY,
+            Position = UDim2.new(),
+            BackgroundTransparency = 1,
+            Blend.New "UIPadding" {
+                PaddingTop = UDim.new(0, 5),
+				PaddingBottom = UDim.new(0, 5),
+				PaddingLeft = UDim.new(0, 5),
+				PaddingRight = UDim.new(0, 5),
+            },
+            Blend.New "UIListLayout" {
+                FillDirection = Enum.FillDirection.Horizontal,
+                Padding = UDim.new(0, 5)
+            },
+            button({
+                Text = "Show Prompt",
+                OnActivated = showPrompt
+            }),
+            button({
+                Text = "Clear Queue",
+                OnActivated = function()
+                    menuPromptService:ClearQueue()
+                end
+            }),
+            button({
+                Text = "Hide Current",
+                OnActivated = function()
+                    menuPromptService:ClearQueue()
+                end
+            })
+        }
+    }))
+
+    return function()
+        maid:DoCleaning()
+    end
+end

package/src/node_modules.project.json

@@ -0,0 +1,7 @@
+{
+  "name": "node_modules",
+  "globIgnorePaths": [ "**/.package-lock.json" ],
+  "tree": {
+    "$path": { "optional": "../node_modules" }
+  }
+}

package/test/default.project.json

@@ -0,0 +1,22 @@
+{
+  "name": "MenuPromptTest",
+  "globIgnorePaths": [ "**/.package-lock.json" ],
+  "tree": {
+    "$className": "DataModel",
+    "ServerScriptService": {
+      "menuprompt": {
+        "$path": ".."
+      },
+      "Script": {
+        "$path": "scripts/Server"
+      }
+    },
+    "StarterPlayer": {
+      "StarterPlayerScripts": {
+        "Main": {
+          "$path": "scripts/Client"
+        }
+      }
+    }
+  }
+}

package/test/scripts/Client/ClientMain.client.luau

@@ -0,0 +1,10 @@
+--[[
+	@class ClientMain
+]]
+local loader = game:GetService("ReplicatedStorage"):WaitForChild("menuprompt"):WaitForChild("loader")
+local require = require(loader).bootstrapGame(loader.Parent)
+
+local serviceBag = require("ServiceBag").new()
+serviceBag:GetService(require("MenuPromptService"))
+serviceBag:Init()
+serviceBag:Start()

package/test/scripts/Server/ServerMain.server.luau

@@ -0,0 +1,8 @@
+--[[
+	@class ServerMain
+]]
+
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local loader = ServerScriptService.menuprompt:FindFirstChild("loader", true).Parent
+require(loader).bootstrapGame(ServerScriptService.menuprompt)