@quenty/snackbar 11.3.0 → 11.4.0

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [11.4.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/snackbar@11.3.0...@quenty/snackbar@11.4.0) (2024-05-09)
+
+
+### Bug Fixes
+
+* Fix .package-lock.json replicating in packages ([75d0efe](https://github.com/Quenty/NevermoreEngine/commit/75d0efeef239f221d93352af71a5b3e930ec23c5))
+
+
+### Features
+
+* Refactor snackbar package to new snackbar system ([6f5113b](https://github.com/Quenty/NevermoreEngine/commit/6f5113b3ff1b637f40abb17160ab61788245a05d))
+
+
+
+
+
 # [11.3.0](https://github.com/Quenty/NevermoreEngine/compare/@quenty/snackbar@11.2.0...@quenty/snackbar@11.3.0) (2024-04-28)
 
 

package/default.project.json

@@ -1,5 +1,6 @@
 {
   "name": "snackbar",
+  "globIgnorePaths": [ "**/.package-lock.json" ],
   "tree": {
     "$path": "src"
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quenty/snackbar",
-  "version": "11.3.0",
+  "version": "11.4.0",
   "description": "Snackbars provide lightweight feedback on an operation at the base of the screen. They automatically disappear after a timeout or user interaction. There can only be one on the screen at a time.",
   "keywords": [
     "Roblox",
@@ -25,13 +25,33 @@
     "Quenty"
   ],
   "dependencies": {
-    "@quenty/loader": "^10.2.0",
-    "@quenty/maid": "^3.1.0",
-    "@quenty/math": "^2.6.0",
-    "@quenty/qgui": "^2.2.1"
+    "@quenty/baseobject": "^10.3.0",
+    "@quenty/basicpane": "^13.3.0",
+    "@quenty/blend": "^12.3.0",
+    "@quenty/buttondragmodel": "^1.1.0",
+    "@quenty/buttonhighlightmodel": "file:../ButtonHighlightModel",
+    "@quenty/ducktype": "^5.3.0",
+    "@quenty/genericscreenguiprovider": "^13.5.0",
+    "@quenty/inputobjectutils": "^4.4.0",
+    "@quenty/lipsum": "^14.3.0",
+    "@quenty/loader": "^10.3.0",
+    "@quenty/maid": "^3.2.0",
+    "@quenty/math": "^2.7.0",
+    "@quenty/promise": "^10.3.0",
+    "@quenty/promisemaid": "^5.3.0",
+    "@quenty/promptqueue": "^1.1.0",
+    "@quenty/qgui": "^2.3.0",
+    "@quenty/rx": "^13.3.0",
+    "@quenty/servicebag": "^11.4.0",
+    "@quenty/table": "^3.5.0",
+    "@quenty/textserviceutils": "^13.3.0",
+    "@quenty/transitionmodel": "^7.3.0",
+    "@quenty/utf8": "^2.2.0",
+    "@quenty/valueobject": "^13.3.0",
+    "@quentystudios/t": "^3.0.1"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "1f65df4adb6f3c04fb25d70bfa93f0f7c332c143"
+  "gitHead": "3fd5cdca3128bf34c8d9dfae1e92d62533b6e6f5"
 }

package/src/Client/Gui/Snackbar.lua

@@ -0,0 +1,367 @@
+--[=[
+	Snackbars provide lightweight feedback on an operation
+	at the base of the screen. They automatically disappear
+	after a timeout or user interaction. There can only be
+	one on the screen at a time.
+
+	@class Snackbar
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local Blend = require("Blend")
+local ButtonDragModel = require("ButtonDragModel")
+local ButtonHighlightModel = require("ButtonHighlightModel")
+local DuckTypeUtils = require("DuckTypeUtils")
+local Math = require("Math")
+local PromiseMaidUtils = require("PromiseMaidUtils")
+local PromiseUtils = require("PromiseUtils")
+local SnackbarOptionUtils = require("SnackbarOptionUtils")
+local SpringTransitionModel = require("SpringTransitionModel")
+local TransitionModel = require("TransitionModel")
+local UTF8 = require("UTF8")
+local ValueObject = require("ValueObject")
+local SpringObject = require("SpringObject")
+local Table = require("Table")
+
+local SHADOW_RADIUS = 2
+local CORNER_RADIUS = 2
+local PADDING_FROM_BOTTOM = 10
+
+local DRAG_DISTANCE_TO_HIDE = 48
+local DURATION = 3
+local SHOW_POSITION = UDim2.new(1, 0, 1, 0)
+local HIDE_POSITION = UDim2.new(1, 0, 1, 48)
+
+local PADDING_X = 24
+local DEFAULT_TEXT_COLOR = Color3.fromRGB(78, 205, 196)
+
+local SnackbarDragDirections = Table.readonly({
+	HORIZONTAL = "horizontal";
+	VERTICAL = "vertical";
+	NONE = "none";
+})
+
+local Snackbar = setmetatable({}, TransitionModel)
+Snackbar.ClassName = "Snackbar"
+Snackbar.__index = Snackbar
+
+function Snackbar.new(text, options)
+	assert(SnackbarOptionUtils.isSnackbarOptions(options) or options == nil, "Bad options")
+	options = options or SnackbarOptionUtils.createSnackbarOptions({})
+
+	local self = setmetatable(TransitionModel.new(), Snackbar)
+
+	self._text = self._maid:Add(ValueObject.new(text, "string"))
+	self._backgroundColor = self._maid:Add(ValueObject.new(Color3.new(0.196, 0.196, 0.196), "Color3"))
+
+	self._percentVisibleModel = self._maid:Add(SpringTransitionModel.new())
+	self._percentVisibleModel:SetEpsilon(1e-2)
+	self._percentVisibleModel:SetSpeed(50)
+	self._percentVisibleModel:BindToPaneVisbility(self)
+
+	self._dragSpring = self._maid:Add(SpringObject.new(Vector2.zero, 30))
+
+	self._positionSpringModel = self._maid:Add(SpringTransitionModel.new(SHOW_POSITION, HIDE_POSITION))
+	self._positionSpringModel:SetEpsilon(1e-2)
+	self._positionSpringModel:BindToPaneVisbility(self)
+
+	self._dragModel = self._maid:Add(ButtonDragModel.new())
+	self._dragModel:SetClampWithinButton(false)
+
+	self:SetPromiseShow(function()
+		return self._percentVisibleModel:PromiseShow()
+	end)
+	self:SetPromiseHide(function()
+		return self._percentVisibleModel:PromiseHide()
+	end)
+
+	self._maid:GiveTask(self:_render():Subscribe(function(gui)
+		self.Gui = gui
+	end))
+
+	if options and options.CallToAction then
+		self._maid:GiveTask(self:_renderCallToAction(options.CallToAction):Subscribe(function(button)
+			button.Parent = self._callToActionContainer
+		end))
+	end
+
+	self:_setupDragging()
+
+	return self
+end
+
+function Snackbar.isSnackbar(value)
+	return DuckTypeUtils.isImplementation(Snackbar, value)
+end
+
+function Snackbar:PromiseSustain()
+	local promise = PromiseUtils.delayed(DURATION)
+
+	PromiseMaidUtils.whilePromise(promise, function(maid)
+		maid:GiveTask(self.VisibleChanged:Connect(function(isVisible)
+			if not isVisible then
+				promise:Resolve()
+			end
+		end))
+	end)
+
+	return promise
+end
+
+function Snackbar:_setupDragging()
+	self._maid:GiveTask(self._dragSpring:ObserveTarget():Subscribe(function()
+		self:_updateHideFromDragTarget()
+	end))
+	self._maid:GiveTask(self.Gui:GetPropertyChangedSignal("AbsoluteSize"):Connect(function()
+		self:_updateHideFromDragTarget()
+	end))
+
+	self._maid:GiveTask(self._dragModel:ObserveIsDraggingBrio():Subscribe(function(brio)
+		if brio:IsDead() then
+			return
+		end
+
+		local maid = brio:ToMaidAndValue()
+		local dragDirection = SnackbarDragDirections.NONE
+
+		maid:GiveTask(self._dragModel:ObserveDragDelta():Subscribe(function(delta)
+			if not delta then
+				dragDirection = SnackbarDragDirections.NONE
+				return
+			end
+
+			if delta.magnitude == 0 then
+				return
+			end
+
+			if dragDirection == SnackbarDragDirections.VERTICAL then
+				self._dragSpring:SetTarget(Vector2.new(0, delta.y), true)
+			elseif dragDirection == SnackbarDragDirections.HORIZONTAL then
+				self._dragSpring:SetTarget(Vector2.new(delta.x, 0), true)
+			else
+				if math.abs(delta.x) > math.abs(delta.y) then
+					dragDirection = SnackbarDragDirections.HORIZONTAL
+					self._dragSpring:SetTarget(Vector2.new(delta.x, 0), true)
+				else
+					dragDirection = SnackbarDragDirections.VERTICAL
+					self._dragSpring:SetTarget(Vector2.new(0, delta.y), true)
+				end
+			end
+		end))
+
+		maid:GiveTask(function()
+			if self._dragSpring.Target.magnitude > 0.5*DRAG_DISTANCE_TO_HIDE then
+				self:Hide()
+			else
+				self._dragSpring:SetTarget(Vector2.zero)
+			end
+		end)
+	end))
+
+	self:_updateHideFromDragTarget()
+end
+
+function Snackbar:_updateHideFromDragTarget(doNotAnimate)
+	local target = self._dragSpring.Target
+	local guiSize = self.Gui.AbsoluteSize
+	local hideTarget
+	if target.y > 0 then
+		-- Down
+		hideTarget = SHOW_POSITION + UDim2.new(0, 0, 0, guiSize.Y)
+	elseif target.y < 0 then
+		-- Up
+		hideTarget = SHOW_POSITION + UDim2.new(0, 0, 0, -guiSize.Y)
+	elseif target.x < 0 then
+		hideTarget = SHOW_POSITION + UDim2.new(0, -guiSize.X, 0, 0)
+	elseif target.x > 0 then
+		hideTarget = SHOW_POSITION + UDim2.new(0, guiSize.X, 0, 0)
+	else
+		hideTarget = SHOW_POSITION + UDim2.new(0, 0, 0, guiSize.Y)
+	end
+
+	self._positionSpringModel:SetHideTarget(hideTarget, doNotAnimate)
+end
+
+
+function Snackbar:_render()
+	local percentDragHidden = Blend.Computed(self._dragSpring:Observe(), function(value)
+		return math.clamp(Math.map(value.magnitude, 0, DRAG_DISTANCE_TO_HIDE, 0, 1), 0, 1)
+	end)
+	self._computedTransparency = Blend.Computed(self._percentVisibleModel:Observe(), percentDragHidden, function(visible, dragHidden)
+		return Math.map(visible, 0, 1, 1, dragHidden)
+	end)
+
+	return Blend.New "Frame" {
+		ZIndex = 1;
+		Name = "Snackbar";
+		Size = UDim2.new(0, 0, 0, 0);
+		AutomaticSize = Enum.AutomaticSize.XY;
+		Position = Blend.Computed(self._positionSpringModel:Observe(), self._dragSpring:Observe(), function(position, dragPosition)
+			return position + UDim2.fromOffset(dragPosition.x, dragPosition.y)
+		end);
+		AnchorPoint = Vector2.new(1, 1);
+		BackgroundTransparency = 1;
+
+		Blend.New "UIPadding" {
+			PaddingTop = UDim.new(0, PADDING_FROM_BOTTOM);
+			PaddingBottom = UDim.new(0, PADDING_FROM_BOTTOM);
+			PaddingLeft = UDim.new(0, PADDING_FROM_BOTTOM);
+			PaddingRight = UDim.new(0, PADDING_FROM_BOTTOM);
+		};
+
+		Blend.New "UIListLayout" {
+			FillDirection = Enum.FillDirection.Horizontal;
+		};
+
+		Blend.New "ImageButton" {
+			Size = UDim2.new(0, 0, 0, 0);
+			AnchorPoint = Vector2.new(1, 1);
+			AutomaticSize = Enum.AutomaticSize.XY;
+			BackgroundTransparency = 1;
+			AutoButtonColor = false;
+
+			[Blend.Instance] = function(gui)
+				self._mainButton = gui
+				self._dragModel:SetButton(gui)
+			end;
+
+			Blend.New "UICorner" {
+				CornerRadius = UDim.new(0, CORNER_RADIUS);
+			};
+
+			Blend.New "UIListLayout" {
+				FillDirection = Enum.FillDirection.Horizontal;
+			};
+
+
+			Blend.New "Folder" {
+				Name = "BackingFolder";
+
+				Blend.New "ImageLabel" {
+					Name = "Shadow";
+					ZIndex = 1;
+					Image = "rbxassetid://191838004";
+					AnchorPoint = Vector2.new(0.5, 0.5);
+					Position = UDim2.fromScale(0.5, 0.5);
+					ImageRectSize = Vector2.new(150, 150);
+					ScaleType = Enum.ScaleType.Slice;
+					SliceCenter = Rect.new(50, 50, 100, 100);
+					SliceScale = (2*SHADOW_RADIUS + CORNER_RADIUS)/50;
+					BackgroundTransparency = 1;
+					Size = UDim2.new(1, 2*SHADOW_RADIUS, 1, 2*SHADOW_RADIUS);
+					ImageTransparency = Blend.Computed(self._computedTransparency, function(value)
+						return Math.map(value, 0, 1, 0.75, 1)
+					end);
+				};
+			};
+
+			Blend.New "Frame" {
+				Name = "Container";
+				AutomaticSize = Enum.AutomaticSize.XY;
+				Size = UDim2.new(0, 0, 0, 0);
+				ZIndex = 2;
+				BackgroundColor3 = self._backgroundColor:Observe();
+				BackgroundTransparency = self._computedTransparency;
+
+				Blend.New "UISizeConstraint" {
+					MaxSize = Vector2.new(700, 48*2);
+					MinSize = Vector2.new(100, 0);
+				};
+
+				[Blend.Instance] = function(gui)
+					self._callToActionContainer = gui
+				end;
+
+				Blend.New "UICorner" {
+					CornerRadius = UDim.new(0, CORNER_RADIUS);
+				};
+
+				Blend.New "UIListLayout" {
+					FillDirection = Enum.FillDirection.Horizontal;
+					HorizontalAlignment = Enum.HorizontalAlignment.Left;
+					VerticalAlignment = Enum.VerticalAlignment.Center;
+					Padding = UDim.new(0, PADDING_X);
+				};
+
+				Blend.New "UIPadding" {
+					PaddingTop = UDim.new(0, 15);
+					PaddingBottom = UDim.new(0, 15);
+					PaddingLeft = UDim.new(0, PADDING_X);
+					PaddingRight = UDim.new(0, PADDING_X);
+				};
+
+
+				Blend.New "TextLabel" {
+					Name = "SnackbarLabel";
+					LayoutOrder = 1;
+					BackgroundTransparency = 1;
+					AutomaticSize = Enum.AutomaticSize.XY;
+					TextColor3 = Color3.new(1, 1, 1);
+					Size = UDim2.new(0, 0, 0, 0);
+					Position = UDim2.new(0, 0, 0, 18);
+					TextXAlignment = Enum.TextXAlignment.Left;
+					TextYAlignment = Enum.TextYAlignment.Center;
+					BorderSizePixel = 0;
+					Font = Enum.Font.SourceSans;
+					Text = self._text:Observe();
+					TextWrapped = false;
+					TextTransparency = Blend.Computed(self._computedTransparency, function(value)
+						return Math.map(value, 0, 1, 0.13, 1)
+					end);
+					TextSize = 18;
+
+					[Blend.Instance] = function(gui)
+						self._textLabel = gui
+					end;
+				};
+			};
+		}
+	}
+end
+
+function Snackbar:_renderCallToAction(callToAction)
+	local callToActionText = ""
+	local onClick = nil
+	if type(callToAction) == "string" then
+		callToActionText = callToAction
+	else
+		callToActionText = tostring(callToAction.Text)
+		onClick = callToAction.OnClick
+	end
+
+	local buttonModel = self._maid:Add(ButtonHighlightModel.new())
+
+	return Blend.New "TextButton" {
+		Name = "CallToActionButton";
+		AnchorPoint = Vector2.new(1, 0.5);
+		LayoutOrder = 2;
+		BackgroundTransparency = 1;
+		Position = UDim2.new(1, 0, 0.5, 0);
+		AutomaticSize = Enum.AutomaticSize.X;
+		Size = UDim2.new(0, 0, 0, 18);
+		Text = UTF8.upper(callToActionText);
+		Font = Enum.Font.SourceSans;
+		FontSize = self._textLabel.FontSize;
+		TextXAlignment = Enum.TextXAlignment.Right;
+		TextColor3 = Blend.Computed(buttonModel:ObservePercentHighlighted(), function(percent)
+			local scale = Math.map(percent, 0, 1, 0, 0.2)
+			return DEFAULT_TEXT_COLOR:Lerp(Color3.new(0, 0, 0), scale)
+		end);
+		TextTransparency = self._computedTransparency;
+
+		[Blend.Instance] = function(gui)
+			buttonModel:SetButton(gui)
+		end;
+
+		[Blend.OnEvent "Activated"] = function()
+			self:Hide()
+
+			if onClick then
+				onClick()
+			end
+		end;
+	}
+end
+
+return Snackbar

package/src/Client/SnackbarScreenGuiProvider.lua

@@ -0,0 +1,11 @@
+--[=[
+	@class SnackbarScreenGuiProvider
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local GenericScreenGuiProvider = require("GenericScreenGuiProvider")
+
+return GenericScreenGuiProvider.new({
+	SNACKBAR = 0;
+})

package/src/Client/SnackbarServiceClient.lua

@@ -5,7 +5,11 @@
 
 local require = require(script.Parent.loader).load(script)
 
-local DraggableSnackbar = require("DraggableSnackbar")
+local Snackbar = require("Snackbar")
+local SnackbarScreenGuiProvider = require("SnackbarScreenGuiProvider")
+local Maid = require("Maid")
+local SnackbarOptionUtils = require("SnackbarOptionUtils")
+local PromptQueue = require("PromptQueue")
 
 local SnackbarServiceClient = {}
 SnackbarServiceClient.ServiceName = "SnackbarServiceClient"
@@ -13,8 +17,12 @@ SnackbarServiceClient.ServiceName = "SnackbarServiceClient"
 function SnackbarServiceClient:Init(serviceBag)
 	assert(not self._serviceBag, "Already initialized")
 	self._serviceBag = assert(serviceBag, "No serviceBag")
+	self._maid = Maid.new()
 
-	self._currentSnackbar = nil
+	self._snackbarScreenGuiProvider = self._serviceBag:GetService(SnackbarScreenGuiProvider)
+	self._screenGui = self._maid:Add(self._snackbarScreenGuiProvider:Get("SNACKBAR"))
+
+	self._queue = self._maid:Add(PromptQueue.new())
 end
 
 --[=[
@@ -29,54 +37,50 @@ function SnackbarServiceClient:SetScreenGui(screenGui)
 	return self
 end
 
--- Automatically makes a snackbar and shows it
--- @param text to show
--- @param[opt] options
---[[
-		If options are included, in this format, a call to action will be presented to the player
-		options = {
-			CallToAction = {
-				Text = "Action";
-				OnClick = function() end;
-			};
+--[=[
+	Makes a snackbar and shows it to the user
+
+	If options are included, in this format, a call to action will be presented to the player
+
+	```
+	{
+		CallToAction = {
+			Text = "Action";
+			OnClick = function() end;
 		};
-]]
+	};
+	```
+
+	@param text string
+	@param options SnackbarOptions
+]=]
 function SnackbarServiceClient:ShowSnackbar(text, options)
 	assert(type(text) == "string", "text must be a string")
+	assert(SnackbarOptionUtils.isSnackbarOptions(options) or options == nil, "Bad snackbarOptions")
 
-	local snackbar = DraggableSnackbar.new(self._screenGui, text, true, options)
-	self:_showSnackbar(snackbar)
+	local snackbar = Snackbar.new(text, options)
+	snackbar.Gui.Parent = self._screenGui
+
+	self._queue:HideCurrent()
+
+	self._maid:GivePromise(self._queue:Queue(snackbar))
+		:Finally(function()
+			snackbar:Destroy()
+		end)
 
 	return snackbar
 end
 
-function SnackbarServiceClient:_showSnackbar(snackbar)
-	assert(snackbar, "Must send a snackbar")
-
-	if self._currentSnackbar == snackbar and self._currentSnackbar:IsVisible() then
-		snackbar:Dismiss()
-	else
-		local dismissedSnackbar = false
-
-		if self._currentSnackbar then
-			if self._currentSnackbar:IsVisible() then
-				self._currentSnackbar:Dismiss()
-				self._currentSnackbar = nil
-				dismissedSnackbar = true
-			end
-		end
-
-		self._currentSnackbar = snackbar
-		if dismissedSnackbar then
-			task.delay(snackbar.FadeTime, function()
-				if self._currentSnackbar == snackbar then
-					snackbar:Show()
-				end
-			end)
-		else
-			snackbar:Show()
-		end
-	end
+function SnackbarServiceClient:HideCurrent(doNotAnimate)
+	return self._queue:HideCurrent(doNotAnimate)
+end
+
+function SnackbarServiceClient:ClearQueue(doNotAnimate)
+	self._queue:Clear(doNotAnimate)
+end
+
+function SnackbarServiceClient:Destroy()
+	self._maid:DoCleaning()
 end
 
 return SnackbarServiceClient

package/src/Client/SnackbarServiceClient.story.lua

@@ -0,0 +1,98 @@
+--[[
+	@class snackbarServiceClient.story
+]]
+
+local require = require(game:GetService("ServerScriptService"):FindFirstChild("LoaderUtils", true).Parent).bootstrapStory(script)
+
+local Maid = require("Maid")
+local ServiceBag = require("ServiceBag")
+local SnackbarServiceClient = require("SnackbarServiceClient")
+local ScreenGuiService = require("ScreenGuiService")
+local LipsumUtils = require("LipsumUtils")
+local Blend = require("Blend")
+
+return function(target)
+	local maid = Maid.new()
+	local serviceBag = maid:Add(ServiceBag.new())
+
+	local snackbarServiceClient = serviceBag:GetService(SnackbarServiceClient)
+	maid:GiveTask(serviceBag:GetService(ScreenGuiService):SetGuiParent(target))
+
+	serviceBag:Init()
+	serviceBag:Start()
+
+	local function showSnackBar()
+		snackbarServiceClient:ShowSnackbar(LipsumUtils.sentence(10), {
+			CallToAction = {
+				Text = LipsumUtils.word();
+				OnClick = function()
+					print("Activated action")
+				end;
+			}
+		})
+	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
+
+	showSnackBar()
+
+	maid:GiveTask(Blend.mount(target, {
+		Blend.New "Frame" {
+			AutomaticSize = Enum.AutomaticSize.XY;
+			AnchorPoint = Vector2.new(0.5, 0);
+			Position = UDim2.fromScale(0.5, 0);
+			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 snackbar";
+				OnActivated = showSnackBar;
+			});
+			button({
+				Text = "Clear queue";
+				OnActivated = function()
+					snackbarServiceClient:ClearQueue()
+				end;
+			});
+			button({
+				Text = "Hide current";
+				OnActivated = function()
+					snackbarServiceClient:HideCurrent()
+				end;
+			});
+		};
+	}))
+
+	return function()
+		maid:DoCleaning()
+	end
+end

package/src/Server/SnackbarService.lua

@@ -0,0 +1,17 @@
+--[=[
+	@class SnackbarService
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local SnackbarService = {}
+SnackbarService.ServiceName = "SnackbarService"
+
+function SnackbarService:Init(serviceBag)
+	assert(not self._serviceBag, "Already initialized")
+	self._serviceBag = assert(serviceBag, "No serviceBag")
+
+
+end
+
+return SnackbarService

package/src/Shared/SnackbarOptionUtils.lua

@@ -0,0 +1,25 @@
+--[=[
+	@class SnackbarOptionUtils
+
+]=]
+
+local require = require(script.Parent.loader).load(script)
+
+local t = require("t")
+
+local SnackbarOptionUtils = {}
+
+function SnackbarOptionUtils.createSnackbarOptions(options)
+	assert(SnackbarOptionUtils.isSnackbarOptions(options))
+
+	return options
+end
+
+SnackbarOptionUtils.isSnackbarOptions = t.interface({
+	CallToAction = t.optional(t.union(t.string, t.interface({
+		Text = t.string;
+		OnClick = t.optional(t.callback);
+	})));
+})
+
+return SnackbarOptionUtils

package/test/default.project.json

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

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

@@ -0,0 +1,31 @@
+--[[
+	@class ClientMain
+]]
+local loader = game:GetService("ReplicatedStorage"):WaitForChild("snackbar"):WaitForChild("loader")
+local require = require(loader).bootstrapGame(loader.Parent)
+
+local serviceBag = require("ServiceBag").new()
+serviceBag:GetService(require("SnackbarServiceClient"))
+serviceBag:Init()
+serviceBag:Start()
+
+local snackbarServiceClient = serviceBag:GetService(require("SnackbarServiceClient"))
+
+local LipsumUtils = require("LipsumUtils")
+
+local function showSnackbar()
+	snackbarServiceClient:ShowSnackbar(LipsumUtils.sentence(5), {
+		CallToAction = {
+			Text = LipsumUtils.word();
+			OnClick = function()
+				print("Activated action")
+			end;
+		}
+	})
+end
+
+showSnackbar()
+
+workspace:WaitForChild("Part").ProximityPrompt.Triggered:Connect(function()
+	showSnackbar()
+end)

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

@@ -0,0 +1,12 @@
+--[[
+	@class ServerMain
+]]
+local ServerScriptService = game:GetService("ServerScriptService")
+
+local loader = ServerScriptService:FindFirstChild("LoaderUtils", true).Parent
+local require = require(loader).bootstrapGame(ServerScriptService.snackbar)
+
+local serviceBag = require("ServiceBag").new()
+serviceBag:GetService(require("SnackbarService"))
+serviceBag:Init()
+serviceBag:Start()

package/src/Client/DraggableSnackbar.lua

@@ -1,250 +0,0 @@
---[=[
-	Snackbar, but draggable
-	@class DraggableSnackbar
-]=]
-
-local require = require(script.Parent.loader).load(script)
-
-local UserInputService = game:GetService("UserInputService")
-local RunService = game:GetService("RunService")
-local Players  = game:GetService("Players")
-local GuiService = game:GetService("GuiService")
-
-local Snackbar = require("Snackbar")
-local qGUI = require("qGUI")
-
-local DraggableSnackbar = setmetatable({}, Snackbar)
-DraggableSnackbar.ClassName = "DraggableSnackbar"
-DraggableSnackbar.__index = DraggableSnackbar
-DraggableSnackbar.Vertical = true
-DraggableSnackbar.DefaultFadeOut = "FadeOutDown"
-DraggableSnackbar.Duration = 3
-
--- By default the Snackbar will close automatically if the user types outside or presses the esc key.
-DraggableSnackbar.AutoCloseDisabled = false
-
--- Note that this will not show until :Show() is called
--- @constructor
--- @param [GCOnDismissal] If true, will destroy itself and GC after being dismissed. Defaults to true
--- @param [Options] Table of optional values, adds call to actions, et cetera
-function DraggableSnackbar.new(Parent, Text, GCOnDismissal, Options)
-	local self = setmetatable(Snackbar.new(Parent, Text, Options), DraggableSnackbar)
-
-	self._visible = false
-	self._draggingCoroutine = nil
-	self._shouldDismiss = false
-	self._showId = 0
-
-	self._mouse = Players.LocalPlayer:GetMouse()
-	self._gcOnDismissal = GCOnDismissal == nil and true or false
-
-	-- Set to transparency and faded out direction automatically
-	self[self.DefaultFadeOut](self, true)
-
-	return self
-end
-
-function DraggableSnackbar:Show()
-	if not self._visible then
-		self._visible = true
-		self:FadeIn()
-		local LocalShowId = self._showId + 1
-		self._showId = LocalShowId
-
-		-- Connect events
-		self._whileActiveMaid:GiveTask(self.Gui.MouseButton1Down:Connect(function(X, Y)
-			if self._showId == LocalShowId then
-				if not self._draggingCoroutine then
-					self:StartTrack(X, Y)
-				end
-			else
-				warn("[DraggingBeginEvent] - self._showId ~= LocalShowId, but event fired")
-			end
-		end))
-
-		self._whileActiveMaid:GiveTask(UserInputService.InputBegan:Connect(function(InputObject, GameProcessedEvent)
-			if GameProcessedEvent then
-				return
-			end
-
-			if self._showId ~= LocalShowId then
-				warn("[InputDismissEvent] - self._showId ~= LocalShowId, but event fired")
-				return
-			end
-			if self.AutoCloseDisabled then
-				return
-			end
-
-			if qGUI.MouseOver(self._mouse, self.Gui) then
-				return
-			end
-
-			if self.AbsolutePosition ~= self.Gui.AbsolutePosition then
-				return -- Animating / dragging
-			end
-
-			if InputObject.UserInputType == Enum.UserInputType.Touch
-				or InputObject.UserInputType == Enum.UserInputType.MouseButton1 then
-
-				self:Dismiss()
-			end
-		end))
-
-		-- Setup hide on dismissal
-		task.delay(self.Duration, function()
-			if self.Destroy and self._showId == LocalShowId and self._visible then
-				self:Dismiss()
-			end
-		end)
-	end
-end
-
-function DraggableSnackbar:StartTrack(X, Y)
-	if self.Vertical then
-		self._startDragPosition = Y
-	else
-		self._startDragPosition = X
-	end
-	self.DragOffset = 0
-
-	local localDraggingCoroutine
-	localDraggingCoroutine = coroutine.create(function()
-		while self._draggingCoroutine == localDraggingCoroutine do
-			self:Track()
-			RunService.Stepped:Wait()
-		end
-	end)
-	self._draggingCoroutine = localDraggingCoroutine
-
-	self._whileActiveMaid.DraggingEnded = UserInputService.InputEnded:Connect(function(inputObject)
-		if self._draggingCoroutine == localDraggingCoroutine then
-			if inputObject.UserInputType.Name == "MouseButton1" then
-				self:EndTrack()
-			end
-		else
-			warn("[DraggableSnackbar] - InputEnded fire, but DraggingCoroutine was not the localDraggingCoroutine")
-		end
-	end)
-
-	self._whileActiveMaid.TouchDraggingEnded = UserInputService.TouchEnded:Connect(function(_)
-		if self._draggingCoroutine == localDraggingCoroutine then
-			self:EndTrack()
-		else
-			warn("[DraggableSnackbar] - TouchEnded fire, but DraggingCoroutine was not the localDraggingCoroutine")
-		end
-	end)
-
-	assert(coroutine.resume(self._draggingCoroutine))
-end
-
-function DraggableSnackbar:Track()
-	local DragOffset, DragLength
-	local TopLeftInset, _ = GuiService:GetGuiInset()
-
-	if self.Vertical then
-		DragOffset = (self._mouse.Y + TopLeftInset.Y) - self._startDragPosition
-		DragLength = self.Gui.AbsoluteSize.Y
-
-		self.Gui.Position = self.Position + UDim2.new(0, 0, 0, DragOffset)
-	else
-		DragOffset = (self._mouse.X + TopLeftInset.X) - self._startDragPosition
-		DragLength = self.Gui.AbsoluteSize.Y
-
-		self.Gui.Position = self.Position + UDim2.new(0, DragOffset, 0, 0)
-	end
-
-	local PercentFaded = math.abs(DragOffset) / DragLength
-	if PercentFaded > 1 then
-		PercentFaded = 1
-	elseif PercentFaded < 0 then
-		PercentFaded = 0
-	end
-
-	self:FadeOutTransparency(PercentFaded)
-end
-
-function DraggableSnackbar:GetOffsetXY()
-	local Offset = self.Gui.AbsolutePosition - self.AbsolutePosition
-	return Offset
-end
-
-function DraggableSnackbar:EndTrack()
-	self._startDragPosition = nil
-	self._draggingCoroutine = nil
-
-	-- Cleanup events
-	self._whileActiveMaid.DraggingEnded = nil
-	self._whileActiveMaid.TouchDraggingEnded = nil
-
-	-- Dismissal if dragged out
-	if self._shouldDismiss then
-		self:Dismiss()
-	else
-		local OffsetXY = self:GetOffsetXY()
-		local SizeXY = self.Gui.AbsoluteSize
-
-		if math.abs(OffsetXY.X) >= SizeXY.X or math.abs(OffsetXY.Y) >= SizeXY.Y then
-			self:Dismiss()
-		else
-			self:FadeIn()
-		end
-	end
-end
-
-function DraggableSnackbar:Dismiss()
-	if self._visible then
-		if self._draggingCoroutine then
-			self._shouldDismiss = true
-		else
-			self._visible = false
-			self._shouldDismiss = nil
-			self._whileActiveMaid:DoCleaning()
-
-			local OffsetXY = self:GetOffsetXY()
-			-- Determine what direction to fade out...
-			if OffsetXY.X > 0 then
-				self:FadeOutRight()
-			elseif OffsetXY.X < 0 then
-				self:FadeOutLeft()
-			elseif OffsetXY.Y > 0 then
-				self:FadeOutUp()
-			elseif OffsetXY.Y < 0 then
-				self:FadeOutDown()
-			else
-				self[self.DefaultFadeOut](self)
-			end
-
-			-- GC stuff
-			if self._gcOnDismissal then
-				self._gcOnDismissal = false -- Make sure this is only called once...
-				delay(self.FadeTime, function()
-					self:Destroy()
-				end)
-			end
-		end
-	else
-		warn("[DraggableSnackbar] - Cannot dismiss, already hidden")
-	end
-end
-
-function DraggableSnackbar:IsVisible()
-	return self._visible
-end
-
-function DraggableSnackbar:Destroy()
-	self.Gui:Destroy()
-	self.Gui = nil
-
-	self.TextLabel:Destroy()
-	self.TextLabel = nil
-
-	self._whileActiveMaid:DoCleaning()
-	self._whileActiveMaid = nil
-
-	self._visible = false
-	self._draggingCoroutine = nil
-
-	setmetatable(self, nil)
-end
-
-return DraggableSnackbar

package/src/Client/Snackbar.lua

@@ -1,292 +0,0 @@
---[=[
-	Snackbars provide lightweight feedback on an operation
-	at the base of the screen. They automatically disappear
-	after a timeout or user interaction. There can only be
-	one on the screen at a time.
-	@class Snackbar
-]=]
-
-local require = require(script.Parent.loader).load(script)
-
-local qGUI = require("qGUI")
-local Maid = require("Maid")
-local Math = require("Math")
-
--- Base clase, not functional
-local Snackbar = {}
-Snackbar.ClassName = "Snackbar"
-Snackbar.__index = Snackbar
-Snackbar.Height = 48
-Snackbar.MinimumWidth = 288 -- Taken from google material design
-Snackbar.MaximumWidth = 700
-Snackbar.TextWidthOffset = 24
-Snackbar.Position = UDim2.new(1, -10, 1, -10 - Snackbar.Height)
-Snackbar.FadeTime = 0.16
-Snackbar.CornerRadius = 2--24
-
-local DEFAULT_TEXT_COLOR = Color3.fromRGB(78, 205, 196)
-
-function Snackbar.new(Parent, Text, options)
-	local self = setmetatable({}, Snackbar)
-
-	local Gui = Instance.new("ImageButton")
-	Gui.ZIndex = 7
-	Gui.Name = "Snackbar"
-	Gui.Size = UDim2.new(0, 100, 0, self.Height)
-	Gui.BorderSizePixel = 0
-	Gui.BackgroundColor3 = Color3.new(0.196, 0.196, 0.196) -- Google design specifications
-	Gui.Archivable = false
-	Gui.ClipsDescendants = false
-	Gui.Position = self.Position
-	Gui.AutoButtonColor = false
-	Gui.BackgroundTransparency = 1
-	self.Gui = Gui
-
-	self.BackgroundImages = {qGUI.BackWithRoundedRectangle(Gui, self.CornerRadius, Gui.BackgroundColor3)}
-
-	local ShadowRadius = 1
-	local ShadowContainer = Instance.new("Frame")
-	ShadowContainer.AnchorPoint = Vector2.new(0.5, 0.5)
-	ShadowContainer.Parent = Gui
-	ShadowContainer.Name = "ShadowContainer"
-	ShadowContainer.BackgroundTransparency = 1
-	ShadowContainer.Size = UDim2.new(1, ShadowRadius*2, 1, ShadowRadius*2)
-	ShadowContainer.Archivable = false
-	ShadowContainer.Position = UDim2.new(0.5, 0, 0.5, 0)
-
-	-- Image is blurred at
-	self.ShadowImages = {
-		qGUI.AddNinePatch(ShadowContainer, "rbxassetid://191838004",
-			Vector2.new(150, 150),
-			self.CornerRadius + ShadowRadius,
-			"ImageLabel"
-		)
-	}
-
-	for _, item in pairs(self.ShadowImages) do
-		item.ImageTransparency = 0.74
-		item.ZIndex = Gui.ZIndex - 2
-	end
-
-	for _, item in pairs(self.BackgroundImages) do
-		item.ZIndex = Gui.ZIndex - 1
-	end
-
-	local textLabel = Instance.new("TextLabel")
-	textLabel.Size = UDim2.new(1, -self.TextWidthOffset*2, 0, 16)
-	textLabel.Position = UDim2.new(0, self.TextWidthOffset, 0, 16)
-	textLabel.TextXAlignment = Enum.TextXAlignment.Left
-	textLabel.TextYAlignment = Enum.TextYAlignment.Center
-	textLabel.Name = "SnackbarLabel"
-	textLabel.TextTransparency = 0.87
-	textLabel.TextColor3 = Color3.new(1, 1, 1)
-	textLabel.BackgroundTransparency = 1
-	textLabel.BorderSizePixel = 0
-	textLabel.Font = Enum.Font.SourceSans
-	textLabel.Text = Text
-	textLabel.FontSize = Enum.FontSize.Size18
-	textLabel.ZIndex = Gui.ZIndex-1
-	textLabel.Parent = Gui
-	self._textLabel = textLabel
-
-	self._whileActiveMaid = Maid.new()
-	self.Gui.Parent = Parent
-
-	local callToActionText
-	if options and options.CallToAction then
-		if type(options.CallToAction) == "string" then
-			callToActionText = options.CallToAction
-		else
-			callToActionText = tostring(options.CallToAction.Text)
-		end
-		callToActionText = callToActionText:upper()
-
-		local button = Instance.new("TextButton")
-		button.Name = "CallToActionButton"
-		button.AnchorPoint = Vector2.new(1, 0.5)
-		button.BackgroundTransparency = 1
-		button.Position = UDim2.new(1, -self.TextWidthOffset, 0.5, 0)
-		button.Size = UDim2.new(0.5, 0, 0.8, 0)
-		button.Text = callToActionText
-		button.Font = Enum.Font.SourceSans
-		button.FontSize = textLabel.FontSize
-		button.TextXAlignment = Enum.TextXAlignment.Right
-		button.TextColor3 = DEFAULT_TEXT_COLOR
-		button.ZIndex = Gui.ZIndex
-		button.Parent = Gui
-
-		-- Resize
-		button.Size = UDim2.new(UDim.new(0, button.TextBounds.X), button.Size.Y)
-
-		self._whileActiveMaid:GiveTask(button.MouseButton1Click:Connect(function()
-			if options.CallToAction.OnClick then
-				self:Dismiss()
-				options.CallToAction.OnClick()
-			end
-		end))
-
-		self._whileActiveMaid:GiveTask(button.MouseEnter:Connect(function()
-			button.TextColor3 = DEFAULT_TEXT_COLOR:lerp(Color3.new(0, 0, 0), 0.2)
-		end))
-
-		self._whileActiveMaid:GiveTask(button.MouseLeave:Connect(function()
-			button.TextColor3 = DEFAULT_TEXT_COLOR
-		end))
-
-		self._callToActionButton = button
-	end
-
-
-	local width = self._textLabel.TextBounds.X + self.TextWidthOffset*2
-	if self._callToActionButton then
-		width = width + self._callToActionButton.Size.X.Offset + self.TextWidthOffset*2
-	end
-
-	if width < self.MinimumWidth then
-		width = self.MinimumWidth
-	elseif width > self.MaximumWidth then
-		width = self.MaximumWidth
-	end
-
-	if callToActionText then
-		self._textLabel.Text = Text
-	end
-
-	self.Gui.Size = UDim2.new(0, width, 0, self.Height)
-
-	self.Position = self.Position + UDim2.new(0, -width, 0, 0)
-	self.Gui.Position = self.Position
-	self.AbsolutePosition = self.Gui.AbsolutePosition
-
-	return self
-end
-
-function Snackbar:Dismiss()
-	error("Not implemented")
-end
-
-function Snackbar:SetBackgroundTransparency(Transparency)
-	for _, item in pairs(self.BackgroundImages) do
-		item.ImageTransparency = Transparency
-	end
-	for _, item in pairs(self.ShadowImages) do
-		item.ImageTransparency = Math.map(Transparency, 0, 1, 0.74, 1)
-	end
-end
-
-function Snackbar:FadeOutTransparency(PercentFaded)
-	if PercentFaded then
-		self:SetBackgroundTransparency(Math.map(PercentFaded, 0, 1, 0, 1))
-		self._textLabel.TextTransparency = Math.map(PercentFaded, 0, 1, 0.13, 1)
-
-		if self._callToActionButton then
-			self._callToActionButton.TextTransparency = PercentFaded
-		end
-	else
-		local newProperties = {
-			ImageTransparency = 1;
-		}
-
-		for _, item in pairs(self.BackgroundImages) do
-			qGUI.TweenTransparency(item, newProperties, self.FadeTime, true)
-		end
-		for _, item in pairs(self.ShadowImages) do
-			qGUI.TweenTransparency(item, newProperties, self.FadeTime, true)
-		end
-
-		qGUI.TweenTransparency(self._textLabel, {
-			TextTransparency = 1;
-		}, self.FadeTime, true)
-
-		if self._callToActionButton then
-			qGUI.TweenTransparency(self._callToActionButton, {
-				TextTransparency = 1;
-			}, self.FadeTime, true)
-		end
-	end
-end
-
--- Will animate unless given PercentFaded
-function Snackbar:FadeInTransparency(PercentFaded)
-	if PercentFaded then
-		-- self.Gui.BackgroundTransparency = Math.map(PercentFaded, 0, 1, 1, 0)
-		self:SetBackgroundTransparency(Math.map(PercentFaded, 0, 1, 1, 0))
-		self._textLabel.TextTransparency = Math.map(PercentFaded, 0, 1, 1, 0.13)
-
-		if self._callToActionButton then
-			self._callToActionButton.TextTransparency = PercentFaded
-		end
-	else
-		-- Should be an ease-in-out transparency fade.
-		do
-			local newProperties = {
-				ImageTransparency = 0;
-			}
-			for _, item in pairs(self.BackgroundImages) do
-				qGUI.TweenTransparency(item, newProperties, self.FadeTime, true)
-			end
-		end
-
-		do
-			local newProperties = {
-				ImageTransparency = 0.74;
-			}
-			for _, item in pairs(self.ShadowImages) do
-				qGUI.TweenTransparency(item, newProperties, self.FadeTime, true)
-			end
-		end
-
-		qGUI.TweenTransparency(self._textLabel, {
-			TextTransparency = 0.13;
-		}, self.FadeTime, true)
-
-		if self._callToActionButton then
-			qGUI.TweenTransparency(self._callToActionButton, {
-				TextTransparency = 0;
-			}, self.FadeTime, true)
-		end
-	end
-end
-
--- Utility function
-function Snackbar:FadeHandler(NewPosition, DoNotAnimate, IsFadingOut)
-	assert(NewPosition, "[Snackbar] - Internal function should not have been called. Missing NewPosition")
-
-	if IsFadingOut then
-		self:FadeOutTransparency(DoNotAnimate and 1 or nil)
-	else
-		self:FadeInTransparency(DoNotAnimate and 1 or nil)
-	end
-
-	if DoNotAnimate then
-		self.Gui.Position = NewPosition
-	else
-		self.Gui:TweenPosition(NewPosition, "InOut", "Quad", self.FadeTime, true)
-	end
-end
-
-function Snackbar:FadeOutUp(DoNotAnimate)
-	local NewPosition = self.Position + UDim2.new(0, 0, 0, -self.Gui.AbsoluteSize.Y)
-	self:FadeHandler(NewPosition, DoNotAnimate, true)
-end
-
-function Snackbar:FadeOutDown(DoNotAnimate)
-	local NewPosition = self.Position + UDim2.new(0, 0, 0, self.Gui.AbsoluteSize.Y)
-	self:FadeHandler(NewPosition, DoNotAnimate, true)
-end
-
-function Snackbar:FadeOutRight(DoNotAnimate)
-	local NewPosition = self.Position + UDim2.new(0, self.Gui.AbsoluteSize.X, 0, 0)
-	self:FadeHandler(NewPosition, DoNotAnimate, true)
-end
-
-function Snackbar:FadeOutLeft(DoNotAnimate)
-	local NewPosition = self.Position + UDim2.new(0, -self.Gui.AbsoluteSize.X, 0, 0)
-	self:FadeHandler(NewPosition, DoNotAnimate, true)
-end
-
-function Snackbar:FadeIn(DoNotAnimate)
-	self:FadeHandler(self.Position, DoNotAnimate, false)
-end
-
-return Snackbar