@trioforge/anvil 0.0.0-stage → 0.1.1

package/out/selection-policy.d.ts

@@ -0,0 +1,33 @@
+export interface Selection<T extends defined> {
+    readonly marked: readonly T[];
+    readonly remembered?: T;
+    readonly paused: boolean;
+}
+export type SelectionEvent<T> = {
+    readonly kind: "Shown";
+} | {
+    readonly kind: "Marked";
+    readonly object: T;
+    readonly replaces?: T;
+} | {
+    readonly kind: "Unmarked";
+    readonly object: T;
+} | {
+    readonly kind: "Selected";
+    readonly object: T;
+} | {
+    readonly kind: "Lost";
+    readonly removed: boolean;
+};
+export interface PolicyContext<T extends defined> {
+    readonly current?: T;
+    readonly alive: (object: T) => boolean;
+    readonly canSelect: boolean;
+    readonly close?: T;
+}
+export interface Decision<T extends defined> {
+    readonly selection: Selection<T>;
+    readonly target?: T | "Root";
+}
+export declare function emptySelection<T extends defined>(): Selection<T>;
+export declare function decide<T extends defined>(selection: Selection<T>, event: SelectionEvent<T>, context: PolicyContext<T>): Decision<T>;

package/out/selection-policy.luau

@@ -0,0 +1,112 @@
+-- Compiled with roblox-ts v3.0.0
+local function emptySelection()
+	return {
+		marked = {},
+		paused = false,
+	}
+end
+local function fallback(selection, context)
+	for i = #selection.marked - 1, 0, -1 do
+		local object = selection.marked[i + 1]
+		if context.alive(object) then
+			return object
+		end
+	end
+	return if context.close ~= nil and context.alive(context.close) then context.close else "Root"
+end
+local function decide(selection, event, context)
+	local _exp = event.kind
+	repeat
+		if _exp == "Shown" then
+			return {
+				selection = selection,
+				target = if context.canSelect and not selection.paused then if selection.remembered ~= nil and context.alive(selection.remembered) then selection.remembered else fallback(selection, context) else nil,
+			}
+		end
+		if _exp == "Marked" then
+			local _marked = selection.marked
+			local _object = event.object
+			if table.find(_marked, _object) ~= nil then
+				return {
+					selection = selection,
+				}
+			end
+			local _object_1 = table.clone(selection)
+			setmetatable(_object_1, nil)
+			local _left = "marked"
+			local _array = {}
+			local _length = #_array
+			local _array_1 = selection.marked
+			local _Length = #_array_1
+			table.move(_array_1, 1, _Length, _length + 1, _array)
+			_length += _Length
+			_array[_length + 1] = event.object
+			_object_1[_left] = _array
+			local changed = _object_1
+			return {
+				selection = changed,
+				target = if context.canSelect and not selection.paused and (context.current == nil or context.current == event.replaces) then event.object else nil,
+			}
+		end
+		if _exp == "Unmarked" then
+			local _object = {}
+			local _left = "selection"
+			local _object_1 = table.clone(selection)
+			setmetatable(_object_1, nil)
+			local _left_1 = "marked"
+			local _exp_1 = selection.marked
+			-- ▼ ReadonlyArray.filter ▼
+			local _newValue = {}
+			local _callback = function(object)
+				return object ~= event.object
+			end
+			local _length = 0
+			for _k, _v in _exp_1 do
+				if _callback(_v, _k - 1, _exp_1) == true then
+					_length += 1
+					_newValue[_length] = _v
+				end
+			end
+			-- ▲ ReadonlyArray.filter ▲
+			_object_1[_left_1] = _newValue
+			_object[_left] = _object_1
+			return _object
+		end
+		if _exp == "Selected" then
+			local _object = {}
+			local _left = "selection"
+			local _object_1 = table.clone(selection)
+			setmetatable(_object_1, nil)
+			_object_1.remembered = event.object
+			_object_1.paused = false
+			_object[_left] = _object_1
+			return _object
+		end
+		if _exp == "Lost" then
+			local _result
+			if event.removed then
+				local _object = {}
+				local _left = "selection"
+				local _object_1 = table.clone(selection)
+				setmetatable(_object_1, nil)
+				_object_1.remembered = nil
+				_object[_left] = _object_1
+				_object.target = if context.canSelect and not selection.paused then fallback(selection, context) else nil
+				_result = _object
+			else
+				local _object = {}
+				local _left = "selection"
+				local _object_1 = table.clone(selection)
+				setmetatable(_object_1, nil)
+				_object_1.paused = true
+				_object[_left] = _object_1
+				_result = _object
+			end
+			return _result
+		end
+	until true
+end
+return {
+	emptySelection = emptySelection,
+	decide = decide,
+}

package/out/use-press.d.ts

@@ -0,0 +1,22 @@
+import type { Value } from "./props";
+export type PressTiming = {
+    hold?: Value<number | undefined>;
+    repeating?: never;
+} | {
+    repeating: true;
+    hold?: never;
+};
+export type PressOptions = PressTiming & {
+    onPress: () => boolean | void;
+    onPressedChange?: (pressed: boolean) => void;
+    onHighlightChange?: (highlighted: boolean) => void;
+    disabled?: Value<boolean>;
+    selectFirst?: Value<boolean>;
+    silent?: boolean;
+};
+export declare function usePress(options: PressOptions): {
+    highlighted: () => boolean;
+    pressed: () => boolean;
+    progress: () => number;
+    action: (instance: GuiButton) => void;
+};

package/out/use-press.luau

@@ -0,0 +1,228 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local UserInputService = TS.import(script, TS.getModule(script, "@rbxts", "services")).UserInputService
+local _vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
+local cleanup = _vide.cleanup
+local derive = _vide.derive
+local effect = _vide.effect
+local read = _vide.read
+local source = _vide.source
+local untrack = _vide.untrack
+local useAtom = TS.import(script, TS.getModule(script, "@rbxts", "vide-charm").src).useAtom
+local heartbeat = TS.import(script, script.Parent, "frame-loop").heartbeat
+local adapter = TS.import(script, script.Parent, "adapter").adapter
+local _runtime = TS.import(script, script.Parent, "runtime")
+local menuOpen = _runtime.menuOpen
+local textEditing = _runtime.textEditing
+local useSelection = _runtime.useSelection
+local _press_state = TS.import(script, script.Parent, "press-state")
+local idlePress = _press_state.idlePress
+local transition = _press_state.transition
+local function usePress(options)
+	local host = adapter()
+	local device = useAtom(host.device)
+	local menu = useAtom(menuOpen)
+	local editing = useAtom(textEditing)
+	local hovered = source(false)
+	local state = source(idlePress())
+	local timedPress = false
+	local mode = function()
+		local hold = read(options.hold)
+		if hold ~= nil then
+			local _arg0 = hold > 0 and hold < math.huge
+			assert(_arg0, "Hold duration must be finite and positive")
+			return {
+				kind = "Hold",
+				seconds = hold,
+			}
+		end
+		return if options.repeating then {
+			kind = "Repeat",
+		} else {
+			kind = "Activate",
+		}
+	end
+	local selection
+	local fire = function()
+		return untrack(function()
+			if not selection.allowed() or menu() then
+				return nil
+			end
+			local _condition = options.disabled
+			if _condition == nil then
+				_condition = false
+			end
+			local _condition_1 = read(_condition)
+			if not _condition_1 then
+				_condition_1 = options.onPress() == false
+			end
+			local refused = _condition_1
+			if not options.silent then
+				host.feedback(if refused then "Refused" else "Press")
+			end
+		end)
+	end
+	local update = function(event)
+		return untrack(function()
+			local before = state()
+			local result = transition(before, mode(), event)
+			state(result.state)
+			if (before.source == nil) ~= (result.state.source == nil) then
+				local _result = options.onPressedChange
+				if _result ~= nil then
+					_result(result.state.source ~= nil)
+				end
+			end
+			if result.fire then
+				fire()
+			end
+		end)
+	end
+	local begin = function(input)
+		return untrack(function()
+			if not selection.allowed() or menu() or editing() then
+				return nil
+			end
+			if state().source == nil then
+				timedPress = mode().kind ~= "Activate"
+			end
+			local _condition = options.disabled
+			if _condition == nil then
+				_condition = false
+			end
+			if read(_condition) then
+				if not options.silent and mode().kind ~= "Activate" then
+					host.feedback("Refused")
+				end
+				return nil
+			end
+			update({
+				kind = "Begin",
+				source = input,
+			})
+		end)
+	end
+	selection = useSelection({
+		selectFirst = options.selectFirst,
+		buttonADown = if options.hold ~= nil or options.repeating then begin else nil,
+		buttonAUp = function(input)
+			return update({
+				kind = "End",
+				source = input,
+			})
+		end,
+	})
+	local highlighted = derive(function()
+		return device() ~= "Touch" and (hovered() or selection.selected())
+	end)
+	local pressed = derive(function()
+		return state().source ~= nil
+	end)
+	local previouslySelected = false
+	effect(function()
+		local selected = selection.selected()
+		local _condition = not selection.allowed()
+		if not _condition then
+			local _condition_1 = options.disabled
+			if _condition_1 == nil then
+				_condition_1 = false
+			end
+			_condition = read(_condition_1)
+			if not _condition then
+				_condition = menu() or editing() or (previouslySelected and not selected)
+			end
+		end
+		if _condition then
+			update({
+				kind = "Cancel",
+			})
+		end
+		previouslySelected = selected
+	end)
+	effect(function()
+		local on = highlighted()
+		if on and not options.silent then
+			host.feedback("Focus")
+		end
+		untrack(function()
+			local _result = options.onHighlightChange
+			if _result ~= nil then
+				_result = _result(on)
+			end
+			return _result
+		end)
+		cleanup(function()
+			if on then
+				untrack(function()
+					local _result = options.onHighlightChange
+					if _result ~= nil then
+						_result = _result(false)
+					end
+					return _result
+				end)
+			end
+		end)
+	end)
+	local ticking = derive(function()
+		return pressed() or state().progress > 0
+	end)
+	effect(function()
+		if not ticking() then
+			return nil
+		end
+		cleanup(heartbeat(function(_, delta)
+			return update({
+				kind = "Tick",
+				delta = delta,
+			})
+		end))
+	end)
+	cleanup(function()
+		return update({
+			kind = "Cancel",
+		})
+	end)
+	local pointer = function(input)
+		return input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch
+	end
+	return {
+		highlighted = highlighted,
+		pressed = pressed,
+		progress = function()
+			return state().progress
+		end,
+		action = function(instance)
+			selection.action(instance)
+			cleanup(instance.Activated:Connect(function()
+				if not timedPress and mode().kind == "Activate" then
+					fire()
+				end
+			end))
+			cleanup(instance.MouseEnter:Connect(function()
+				return hovered(true)
+			end))
+			cleanup(instance.MouseLeave:Connect(function()
+				hovered(false)
+				update({
+					kind = "Cancel",
+				})
+			end))
+			cleanup(instance.InputBegan:Connect(function(input)
+				if pointer(input) then
+					begin(input)
+				end
+			end))
+			cleanup(UserInputService.InputEnded:Connect(function(input)
+				if pointer(input) then
+					update({
+						kind = "End",
+						source = input,
+					})
+				end
+			end))
+		end,
+	}
+end
+return {
+	usePress = usePress,
+}

package/package.json

@@ -1,6 +1,43 @@
 {
-  "name": "@trioforge/anvil",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@trioforge/anvil",
+	"version": "0.1.1",
+	"description": "Headless UI primitives for Roblox games, built on Vide",
+	"keywords": ["roblox", "roblox-ts", "vide", "ui", "headless", "gamepad"],
+	"bugs": "https://github.com/Trio-Forge-Studio/anvil/issues",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/Trio-Forge-Studio/anvil.git"
+	},
+	"license": "MIT",
+	"main": "out/init.luau",
+	"types": "out/index.d.ts",
+	"files": ["out", "!**/*.tsbuildinfo", "README.md", "LICENSE"],
+	"packageManager": "pnpm@12.15.0",
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "rbxtsc --type package",
+		"test": "rbxtsc --type package && lune run test",
+		"fmt": "oxfmt src",
+		"check": "oxfmt --check src && rbxtsc --type package && stylua --check test .lune && lune run test",
+		"prepack": "rbxtsc --type package"
+	},
+	"peerDependencies": {
+		"@rbxts/charm": "^0.11.1",
+		"@rbxts/services": "^1.6.0",
+		"@rbxts/vide": "^0.6.1",
+		"@rbxts/vide-charm": "^0.4.1"
+	},
+	"devDependencies": {
+		"@rbxts/charm": "^0.11.1",
+		"@rbxts/compiler-types": "3.0.0-types.0",
+		"@rbxts/services": "^1.6.0",
+		"@rbxts/types": "^1.0.958",
+		"@rbxts/vide": "^0.6.1",
+		"@rbxts/vide-charm": "^0.4.1",
+		"oxfmt": "^0.74.0",
+		"roblox-ts": "^3.0.0",
+		"typescript": "5.5.3"
+	}
+}