@k9kbdev/roblox-css 0.1.0

package/out/styles/gradientParser.luau

@@ -0,0 +1,434 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local parseColor = TS.import(script, script.Parent, "colorParser").parseColor
+local createLogger = TS.import(script, script.Parent.Parent, "logger").createLogger
+local log = createLogger("gradientParser")
+local function makeParsedGradient(colorSequence, transparencySequence, rotation)
+	return {
+		colorSequence = colorSequence,
+		transparencySequence = transparencySequence,
+		rotation = rotation,
+	}
+end
+local function isGradientString(input)
+	local _input = input
+	local _condition = type(_input) == "string"
+	if _condition then
+		_condition = string.sub(input, 1, 16) == "linear-gradient("
+	end
+	return _condition
+end
+local function parseAngle(directionStr, elementWidth, elementHeight)
+	local lower = string.lower(directionStr)
+	-- Keyword directions
+	if lower == "to top" then
+		return 0
+	end
+	if lower == "to right" then
+		return 90
+	end
+	if lower == "to bottom" then
+		return 180
+	end
+	if lower == "to left" then
+		return 270
+	end
+	-- Corner keywords
+	if string.sub(lower, 1, 3) == "to " then
+		local corner = string.sub(lower, 4)
+		local angleDeg = 45
+		if elementWidth ~= nil and elementHeight ~= nil and elementHeight ~= 0 then
+			local ratioAngle = math.deg(math.atan2(elementWidth, elementHeight))
+			if corner == "top right" then
+				return ratioAngle
+			end
+			if corner == "bottom right" then
+				return 180 - ratioAngle
+			end
+			if corner == "bottom left" then
+				return 180 + ratioAngle
+			end
+			if corner == "top left" then
+				return 360 - ratioAngle
+			end
+		else
+			if corner == "top right" then
+				return 45
+			end
+			if corner == "bottom right" then
+				return 135
+			end
+			if corner == "bottom left" then
+				return 225
+			end
+			if corner == "top left" then
+				return 315
+			end
+		end
+	end
+	-- Angle values
+	local degMatch = string.match(lower, "^([%d%.%-]+)deg$")
+	if degMatch ~= nil then
+		local _condition = tonumber(degMatch)
+		if _condition == nil then
+			_condition = 180
+		end
+		return _condition
+	end
+	local turnMatch = string.match(lower, "^([%d%.%-]+)turn$")
+	if turnMatch ~= nil then
+		local _condition = tonumber(turnMatch)
+		if _condition == nil then
+			_condition = 0
+		end
+		return _condition * 360
+	end
+	local gradMatch = string.match(lower, "^([%d%.%-]+)grad$")
+	if gradMatch ~= nil then
+		local _condition = tonumber(gradMatch)
+		if _condition == nil then
+			_condition = 0
+		end
+		return _condition * 0.9
+	end
+	local radMatch = string.match(lower, "^([%d%.%-]+)rad$")
+	if radMatch ~= nil then
+		local _condition = tonumber(radMatch)
+		if _condition == nil then
+			_condition = 0
+		end
+		return math.deg(_condition)
+	end
+	return 180
+end
+local function parseStop(stopStr)
+	local trimmedRaw = string.match(stopStr, "^%s*(.-)%s*$")
+	if trimmedRaw == nil or trimmedRaw == "" then
+		return nil
+	end
+	local trimmed = trimmedRaw
+	-- Check if it's a bare percentage (color hint)
+	local hintMatch = string.match(trimmed, "^([%d%.]+)%%$")
+	if hintMatch ~= nil then
+		local pos = tonumber(hintMatch)
+		if pos ~= nil then
+			return {
+				color = Color3.new(),
+				transparency = 0,
+				position = math.clamp(pos / 100, 0, 1),
+				isHint = true,
+			}
+		end
+	end
+	-- Split by space from the end to find optional position
+	-- Since color could be rgba(255, 0, 0, 0.5) we must be careful with spaces.
+	-- We'll look for a percentage at the end.
+	local colorStr = trimmed
+	local position
+	local endPercentMatch = string.match(trimmed, " ([%d%.%-]+)%%$")
+	if endPercentMatch ~= nil then
+		local pos = tonumber(endPercentMatch)
+		if pos ~= nil then
+			position = math.clamp(pos / 100, 0, 1)
+			local colorMatch = string.match(trimmed, "^(.*) [%d%.%-]+%%$")
+			if colorMatch ~= nil then
+				colorStr = colorMatch
+			end
+		end
+	end
+	local parsedColor = parseColor(colorStr)
+	return {
+		color = parsedColor.color,
+		transparency = parsedColor.transparency,
+		position = position,
+		isHint = false,
+	}
+end
+local function parseGradient(input, elementWidth, elementHeight)
+	if not isGradientString(input) then
+		return nil
+	end
+	local repeatingStart = string.find(string.lower(input), "^repeating%-linear%-gradient")
+	if repeatingStart ~= nil then
+		log:warn("UNSUPPORTED_GRADIENT", "repeating-linear-gradient is not supported", {
+			input = input,
+		})
+		return nil
+	end
+	local inner = string.sub(input, 17, -2)
+	if inner == "" then
+		return nil
+	end
+	-- Simple parser for comma-separated args, respecting parentheses for rgb/rgba
+	local args = {}
+	local currentArg = ""
+	local parenLevel = 0
+	for i = 1, #inner do
+		local _i = i
+		local _i_1 = i
+		local char = string.sub(inner, _i, _i_1)
+		if char == "(" then
+			parenLevel += 1
+		elseif char == ")" then
+			parenLevel -= 1
+		elseif char == "," and parenLevel == 0 then
+			local _currentArg = currentArg
+			table.insert(args, _currentArg)
+			currentArg = ""
+			continue
+		end
+		currentArg ..= char
+	end
+	local _currentArg = currentArg
+	table.insert(args, _currentArg)
+	if #args < 2 then
+		return nil
+	end
+	-- Determine if the first arg is a direction
+	local directionStr = args[1]
+	local directionAngle = 180
+	local firstStopIdx = 0
+	local lowerFirst = string.lower(directionStr)
+	local hasDeg = string.find(lowerFirst, "deg$")
+	local hasTurn = string.find(lowerFirst, "turn$")
+	local hasGrad = string.find(lowerFirst, "grad$")
+	local hasRad = string.find(lowerFirst, "rad$")
+	local _condition = string.sub(lowerFirst, 1, 3) == "to "
+	if not _condition then
+		_condition = hasDeg
+		if not (_condition ~= 0 and _condition == _condition and _condition) then
+			_condition = hasTurn
+			if not (_condition ~= 0 and _condition == _condition and _condition) then
+				_condition = hasGrad
+				if not (_condition ~= 0 and _condition == _condition and _condition) then
+					_condition = hasRad
+				end
+			end
+		end
+	end
+	if _condition ~= 0 and _condition == _condition and _condition then
+		directionAngle = parseAngle(directionStr, elementWidth, elementHeight)
+		firstStopIdx = 1
+	end
+	local stops = {}
+	do
+		local i = firstStopIdx
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				i += 1
+			else
+				_shouldIncrement = true
+			end
+			if not (i < #args) then
+				break
+			end
+			local parsed = parseStop(args[i + 1])
+			if parsed ~= nil then
+				table.insert(stops, parsed)
+			end
+		end
+	end
+	-- Remove leading/trailing hints and check valid color stops
+	while #stops > 0 and stops[1].isHint do
+		table.remove(stops, 1)
+	end
+	while #stops > 0 and stops[#stops].isHint do
+		stops[#stops] = nil
+	end
+	local colorStopCount = 0
+	for _, stop in stops do
+		if not stop.isHint then
+			colorStopCount += 1
+		end
+	end
+	if colorStopCount < 2 then
+		return nil
+	end
+	-- Distribute positions
+	if stops[1].position == nil then
+		stops[1].position = 0
+	end
+	if stops[#stops].position == nil then
+		stops[#stops].position = 1
+	end
+	local lastKnownIdx = 0
+	for i = 1, #stops - 1 do
+		if stops[i + 1].position ~= nil then
+			local steps = i - lastKnownIdx
+			local startPos = stops[lastKnownIdx + 1].position
+			local endPos = stops[i + 1].position
+			local stepSize = (endPos - startPos) / steps
+			do
+				local j = 1
+				local _shouldIncrement = false
+				while true do
+					if _shouldIncrement then
+						j += 1
+					else
+						_shouldIncrement = true
+					end
+					if not (j < steps) then
+						break
+					end
+					stops[lastKnownIdx + j + 1].position = startPos + stepSize * j
+				end
+			end
+			lastKnownIdx = i
+		end
+	end
+	-- Auto-correct out-of-order positions
+	local maxPos = 0
+	for _, stop in stops do
+		if stop.position < maxPos then
+			stop.position = maxPos
+		end
+		maxPos = stop.position
+	end
+	-- Apply hints
+	local finalStops = {}
+	for i = 0, #stops - 1 do
+		local stop = stops[i + 1]
+		if stop.isHint then
+			local prev = stops[i]
+			local nextStop = stops[i + 2]
+			local startPos = prev.position
+			local endPos = nextStop.position
+			if startPos == endPos then
+				continue
+			end
+			-- H = (hintAbsPos - stop1Pos) / (stop2Pos - stop1Pos)
+			local h = (stop.position - startPos) / (endPos - startPos)
+			h = math.clamp(h, 0.01, 0.99)
+			local exp = math.log(0.5) / math.log(h)
+			-- Pop the last added stop so we can replace the segment
+			finalStops[#finalStops] = nil
+			table.insert(finalStops, prev)
+			for sample = 1, 7 do
+				local p = sample / 8
+				local f = p ^ exp
+				local pos = startPos + p * (endPos - startPos)
+				local r = prev.color.R + f * (nextStop.color.R - prev.color.R)
+				local g = prev.color.G + f * (nextStop.color.G - prev.color.G)
+				local b = prev.color.B + f * (nextStop.color.B - prev.color.B)
+				local transp = prev.transparency + f * (nextStop.transparency - prev.transparency)
+				local _arg0 = {
+					color = Color3.new(r, g, b),
+					transparency = transp,
+					position = pos,
+					isHint = false,
+				}
+				table.insert(finalStops, _arg0)
+			end
+		else
+			table.insert(finalStops, stop)
+		end
+	end
+	-- Build sequences
+	local colorKeypoints = {}
+	local alphaKeypoints = {}
+	local hasTransparency = false
+	-- Roblox limits keypoints to 20, but we might have more.
+	-- For simplicity, we just push all and trust it's <= 20 or user will see engine err, 
+	-- but let's downsample if needed. Let's just create them as specified.
+	for _, stop in finalStops do
+		local pos = math.clamp(stop.position, 0, 1)
+		local _colorSequenceKeypoint = ColorSequenceKeypoint.new(pos, stop.color)
+		table.insert(colorKeypoints, _colorSequenceKeypoint)
+		local _numberSequenceKeypoint = NumberSequenceKeypoint.new(pos, stop.transparency)
+		table.insert(alphaKeypoints, _numberSequenceKeypoint)
+		if stop.transparency > 0 then
+			hasTransparency = true
+		end
+	end
+	-- Fix duplicate positions (Roblox requires strictly increasing times for ColorSequence, or at least no more than 2 at same time if they are immediate jumps, but usually increasing is safer)
+	-- We'll enforce non-decreasing and add epsilon for exact duplicates if needed.
+	local uniqueColorKeypoints = {}
+	local uniqueAlphaKeypoints = {}
+	local lastTime = -1
+	for i = 0, #colorKeypoints - 1 do
+		local t = colorKeypoints[i + 1].Time
+		if t <= lastTime then
+			t = math.clamp(lastTime + 0.001, 0, 1)
+		end
+		if t > lastTime or #uniqueColorKeypoints == 0 then
+			local _colorSequenceKeypoint = ColorSequenceKeypoint.new(t, colorKeypoints[i + 1].Value)
+			table.insert(uniqueColorKeypoints, _colorSequenceKeypoint)
+			local _numberSequenceKeypoint = NumberSequenceKeypoint.new(t, alphaKeypoints[i + 1].Value)
+			table.insert(uniqueAlphaKeypoints, _numberSequenceKeypoint)
+			lastTime = t
+		end
+	end
+	-- We must cap at 20 keypoints due to Roblox engine limits. 
+	-- (Skipping downsampling for now as prompt doesn't strictly demand it, but good to know)
+	-- Let's ensure time goes exactly up to 1 for the last one if it was squished.
+	if uniqueColorKeypoints[#uniqueColorKeypoints].Time < 1 then
+		-- Just ensure the last element is exactly 1, or adjust.
+		-- Actually, if it's less than 1, Roblox might error if the last keypoint is not at Time=1.
+		local lastC = uniqueColorKeypoints[#uniqueColorKeypoints]
+		if lastC.Time ~= 1 then
+			local _colorSequenceKeypoint = ColorSequenceKeypoint.new(1, lastC.Value)
+			table.insert(uniqueColorKeypoints, _colorSequenceKeypoint)
+		end
+		local lastA = uniqueAlphaKeypoints[#uniqueAlphaKeypoints]
+		if lastA.Time ~= 1 then
+			local _numberSequenceKeypoint = NumberSequenceKeypoint.new(1, lastA.Value)
+			table.insert(uniqueAlphaKeypoints, _numberSequenceKeypoint)
+		end
+	end
+	if uniqueColorKeypoints[1].Time > 0 then
+		local firstC = uniqueColorKeypoints[1]
+		local _colorSequenceKeypoint = ColorSequenceKeypoint.new(0, firstC.Value)
+		table.insert(uniqueColorKeypoints, 1, _colorSequenceKeypoint)
+		local firstA = uniqueAlphaKeypoints[1]
+		local _numberSequenceKeypoint = NumberSequenceKeypoint.new(0, firstA.Value)
+		table.insert(uniqueAlphaKeypoints, 1, _numberSequenceKeypoint)
+	end
+	-- Enforce 20 keypoints max — Roblox engine hard-limits ColorSequence/NumberSequence to 20.
+	-- Downsample by preserving first/last and evenly distributing interior points.
+	if #uniqueColorKeypoints > 20 then
+		log:warn("GRADIENT_KEYPOINT_LIMIT", "Gradient exceeds 20 keypoints, downsampling", {
+			count = #uniqueColorKeypoints,
+		})
+		local _array = {}
+		local _length = #_array
+		table.move(uniqueColorKeypoints, 1, #uniqueColorKeypoints, _length + 1, _array)
+		local srcColors = _array
+		local _array_1 = {}
+		local _length_1 = #_array_1
+		table.move(uniqueAlphaKeypoints, 1, #uniqueAlphaKeypoints, _length_1 + 1, _array_1)
+		local srcAlphas = _array_1
+		local total = #srcColors
+		local downsampled = { srcColors[1] }
+		local downsampledAlpha = { srcAlphas[1] }
+		-- Pick 18 evenly spaced interior points
+		for i = 1, 18 do
+			local idx = math.floor((i / 19) * (total - 1))
+			local _arg0 = srcColors[idx + 1]
+			table.insert(downsampled, _arg0)
+			local _arg0_1 = srcAlphas[idx + 1]
+			table.insert(downsampledAlpha, _arg0_1)
+		end
+		local _arg0 = srcColors[total]
+		table.insert(downsampled, _arg0)
+		local _arg0_1 = srcAlphas[total]
+		table.insert(downsampledAlpha, _arg0_1)
+		-- Replace the arrays in-place
+		table.clear(uniqueColorKeypoints)
+		table.clear(uniqueAlphaKeypoints)
+		for _, kp in downsampled do
+			table.insert(uniqueColorKeypoints, kp)
+		end
+		for _, kp in downsampledAlpha do
+			table.insert(uniqueAlphaKeypoints, kp)
+		end
+	end
+	local cSeq = ColorSequence.new(uniqueColorKeypoints)
+	local tSeq = if hasTransparency then NumberSequence.new(uniqueAlphaKeypoints) else nil
+	local robloxRotation = directionAngle - 90
+	return makeParsedGradient(cSeq, tSeq, robloxRotation)
+end
+return {
+	isGradientString = isGradientString,
+	parseGradient = parseGradient,
+}

package/out/styles/namedColors.d.ts

@@ -0,0 +1,7 @@
+/**
+ * namedColors.ts — All 148 CSS Level 4 named colors.
+ *
+ * Lookup table mapping lowercase color keywords to [R, G, B] tuples (0–255).
+ * Spec: https://www.w3.org/TR/css-color-4/#named-colors
+ */
+export declare const NAMED_COLORS: Map<string, [number, number, number]>;

package/out/styles/namedColors.luau

@@ -0,0 +1,162 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * namedColors.ts — All 148 CSS Level 4 named colors.
+	 *
+	 * Lookup table mapping lowercase color keywords to [R, G, B] tuples (0–255).
+	 * Spec: https://www.w3.org/TR/css-color-4/#named-colors
+	 
+]]
+local NAMED_COLORS = {
+	aliceblue = { 240, 248, 255 },
+	antiquewhite = { 250, 235, 215 },
+	aqua = { 0, 255, 255 },
+	aquamarine = { 127, 255, 212 },
+	azure = { 240, 255, 255 },
+	beige = { 245, 245, 220 },
+	bisque = { 255, 228, 196 },
+	black = { 0, 0, 0 },
+	blanchedalmond = { 255, 235, 205 },
+	blue = { 0, 0, 255 },
+	blueviolet = { 138, 43, 226 },
+	brown = { 165, 42, 42 },
+	burlywood = { 222, 184, 135 },
+	cadetblue = { 95, 158, 160 },
+	chartreuse = { 127, 255, 0 },
+	chocolate = { 210, 105, 30 },
+	coral = { 255, 127, 80 },
+	cornflowerblue = { 100, 149, 237 },
+	cornsilk = { 255, 248, 220 },
+	crimson = { 220, 20, 60 },
+	cyan = { 0, 255, 255 },
+	darkblue = { 0, 0, 139 },
+	darkcyan = { 0, 139, 139 },
+	darkgoldenrod = { 184, 134, 11 },
+	darkgray = { 169, 169, 169 },
+	darkgreen = { 0, 100, 0 },
+	darkgrey = { 169, 169, 169 },
+	darkkhaki = { 189, 183, 107 },
+	darkmagenta = { 139, 0, 139 },
+	darkolivegreen = { 85, 107, 47 },
+	darkorange = { 255, 140, 0 },
+	darkorchid = { 153, 50, 204 },
+	darkred = { 139, 0, 0 },
+	darksalmon = { 233, 150, 122 },
+	darkseagreen = { 143, 188, 143 },
+	darkslateblue = { 72, 61, 139 },
+	darkslategray = { 47, 79, 79 },
+	darkslategrey = { 47, 79, 79 },
+	darkturquoise = { 0, 206, 209 },
+	darkviolet = { 148, 0, 211 },
+	deeppink = { 255, 20, 147 },
+	deepskyblue = { 0, 191, 255 },
+	dimgray = { 105, 105, 105 },
+	dimgrey = { 105, 105, 105 },
+	dodgerblue = { 30, 144, 255 },
+	firebrick = { 178, 34, 34 },
+	floralwhite = { 255, 250, 240 },
+	forestgreen = { 34, 139, 34 },
+	fuchsia = { 255, 0, 255 },
+	gainsboro = { 220, 220, 220 },
+	ghostwhite = { 248, 248, 255 },
+	gold = { 255, 215, 0 },
+	goldenrod = { 218, 165, 32 },
+	gray = { 128, 128, 128 },
+	green = { 0, 128, 0 },
+	greenyellow = { 173, 255, 47 },
+	grey = { 128, 128, 128 },
+	honeydew = { 240, 255, 240 },
+	hotpink = { 255, 105, 180 },
+	indianred = { 205, 92, 92 },
+	indigo = { 75, 0, 130 },
+	ivory = { 255, 255, 240 },
+	khaki = { 240, 230, 140 },
+	lavender = { 230, 230, 250 },
+	lavenderblush = { 255, 240, 245 },
+	lawngreen = { 124, 252, 0 },
+	lemonchiffon = { 255, 250, 205 },
+	lightblue = { 173, 216, 230 },
+	lightcoral = { 240, 128, 128 },
+	lightcyan = { 224, 255, 255 },
+	lightgoldenrodyellow = { 250, 250, 210 },
+	lightgray = { 211, 211, 211 },
+	lightgreen = { 144, 238, 144 },
+	lightgrey = { 211, 211, 211 },
+	lightpink = { 255, 182, 193 },
+	lightsalmon = { 255, 160, 122 },
+	lightseagreen = { 32, 178, 170 },
+	lightskyblue = { 135, 206, 250 },
+	lightslategray = { 119, 136, 153 },
+	lightslategrey = { 119, 136, 153 },
+	lightsteelblue = { 176, 196, 222 },
+	lightyellow = { 255, 255, 224 },
+	lime = { 0, 255, 0 },
+	limegreen = { 50, 205, 50 },
+	linen = { 250, 240, 230 },
+	magenta = { 255, 0, 255 },
+	maroon = { 128, 0, 0 },
+	mediumaquamarine = { 102, 205, 170 },
+	mediumblue = { 0, 0, 205 },
+	mediumorchid = { 186, 85, 211 },
+	mediumpurple = { 147, 112, 219 },
+	mediumseagreen = { 60, 179, 113 },
+	mediumslateblue = { 123, 104, 238 },
+	mediumspringgreen = { 0, 250, 154 },
+	mediumturquoise = { 72, 209, 204 },
+	mediumvioletred = { 199, 21, 133 },
+	midnightblue = { 25, 25, 112 },
+	mintcream = { 245, 255, 250 },
+	mistyrose = { 255, 228, 225 },
+	moccasin = { 255, 228, 181 },
+	navajowhite = { 255, 222, 173 },
+	navy = { 0, 0, 128 },
+	oldlace = { 253, 245, 230 },
+	olive = { 128, 128, 0 },
+	olivedrab = { 107, 142, 35 },
+	orange = { 255, 165, 0 },
+	orangered = { 255, 69, 0 },
+	orchid = { 218, 112, 214 },
+	palegoldenrod = { 238, 232, 170 },
+	palegreen = { 152, 251, 152 },
+	paleturquoise = { 175, 238, 238 },
+	palevioletred = { 219, 112, 147 },
+	papayawhip = { 255, 239, 213 },
+	peachpuff = { 255, 218, 185 },
+	peru = { 205, 133, 63 },
+	pink = { 255, 192, 203 },
+	plum = { 221, 160, 221 },
+	powderblue = { 176, 224, 230 },
+	purple = { 128, 0, 128 },
+	rebeccapurple = { 102, 51, 153 },
+	red = { 255, 0, 0 },
+	rosybrown = { 188, 143, 143 },
+	royalblue = { 65, 105, 225 },
+	saddlebrown = { 139, 69, 19 },
+	salmon = { 250, 128, 114 },
+	sandybrown = { 244, 164, 96 },
+	seagreen = { 46, 139, 87 },
+	seashell = { 255, 245, 238 },
+	sienna = { 160, 82, 45 },
+	silver = { 192, 192, 192 },
+	skyblue = { 135, 206, 235 },
+	slateblue = { 106, 90, 205 },
+	slategray = { 112, 128, 144 },
+	slategrey = { 112, 128, 144 },
+	snow = { 255, 250, 250 },
+	springgreen = { 0, 255, 127 },
+	steelblue = { 70, 130, 180 },
+	tan = { 210, 180, 140 },
+	teal = { 0, 128, 128 },
+	thistle = { 216, 191, 216 },
+	tomato = { 255, 99, 71 },
+	turquoise = { 64, 224, 208 },
+	violet = { 238, 130, 238 },
+	wheat = { 245, 222, 179 },
+	white = { 255, 255, 255 },
+	whitesmoke = { 245, 245, 245 },
+	yellow = { 255, 255, 0 },
+	yellowgreen = { 154, 205, 50 },
+}
+return {
+	NAMED_COLORS = NAMED_COLORS,
+}

package/out/styles/transitions.d.ts

@@ -0,0 +1,18 @@
+/**
+ * transitions.ts — Pre-configured animation transitions for Motion primitives.
+ *
+ * Provides a standardized set of TweenInfo configurations to ensure consistency
+ * across all declarative animations, per ADR-0002.
+ */
+export declare const transitions: {
+    /** Standard UI state change, smooth and subtle */
+    default: TweenInfo;
+    /** Bouncy, energetic pop-in for modals or badges */
+    pop: TweenInfo;
+    /** Slow, looping breathing effect for idle states */
+    breathe: TweenInfo;
+    /** Fast, immediate snap for extremely snappy interactions */
+    snap: TweenInfo;
+    /** Looping shimmer or slide effect */
+    shimmer: TweenInfo;
+};

package/out/styles/transitions.luau

@@ -0,0 +1,19 @@
+-- Compiled with roblox-ts v3.0.0
+--[[
+	*
+	 * transitions.ts — Pre-configured animation transitions for Motion primitives.
+	 *
+	 * Provides a standardized set of TweenInfo configurations to ensure consistency
+	 * across all declarative animations, per ADR-0002.
+	 
+]]
+local transitions = {
+	default = TweenInfo.new(0.3, Enum.EasingStyle.Quad, Enum.EasingDirection.Out),
+	pop = TweenInfo.new(0.25, Enum.EasingStyle.Back, Enum.EasingDirection.Out),
+	breathe = TweenInfo.new(2, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut, -1, true),
+	snap = TweenInfo.new(0.1, Enum.EasingStyle.Linear),
+	shimmer = TweenInfo.new(1, Enum.EasingStyle.Linear, Enum.EasingDirection.InOut, -1),
+}
+return {
+	transitions = transitions,
+}