@rbxts/forge 0.0.5

package/out/hooks/useAppContext.luau

@@ -0,0 +1,14 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Components
+local Contexts = TS.import(script, script.Parent.Parent, "context").default
+local default = function()
+	local context = Contexts.App()
+	if not context then
+		error(`Failed to retrieve App Props for Vide\n{debug.traceback()}`, 2)
+	end
+	return context
+end
+return {
+	default = default,
+}

package/out/hooks/useEventListener.d.ts

@@ -0,0 +1,22 @@
+type EventLike<T extends Callback = Callback> = {
+    Connect(callback: T): ConnectionLike;
+} | {
+    connect(callback: T): ConnectionLike;
+} | {
+    subscribe(callback: T): ConnectionLike;
+};
+type ConnectionLike = {
+    Disconnect(): void;
+} | {
+    disconnect(): void;
+} | (() => void);
+/**
+ * Subscribes to an event-like object. The subscription is automatically
+ * disconnected when the scope cleans up.
+ *
+ * @param event The event-like object to subscribe to.
+ * @param listener The listener to subscribe with.
+ * @returns The connection object.
+ */
+export default function useEventListener<T extends EventLike>(event: T, listener: T extends EventLike<infer U> ? U : never): ReturnType<T>;
+export {};

package/out/hooks/useEventListener.luau

@@ -0,0 +1,64 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+local cleanup = TS.import(script, TS.getModule(script, "@rbxts", "vide").src).cleanup
+local connect = function(event, callback)
+	local _event = event
+	if typeof(_event) == "RBXScriptSignal" then
+		local connection
+		connection = event:Connect(function(...)
+			local args = { ... }
+			if connection.Connected then
+				return callback(unpack(args))
+			end
+		end)
+		return connection
+	elseif event.Connect ~= nil then
+		return event:Connect(callback)
+	elseif event.connect ~= nil then
+		return event:connect(callback)
+	elseif event.subscribe ~= nil then
+		return event:subscribe(callback)
+	else
+		error("Event-like object does not have a supported connect method.")
+	end
+end
+local disconnect = function(connection)
+	local _connection = connection
+	if type(_connection) == "function" then
+		connection()
+	else
+		local _connection_1 = connection
+		local _condition = typeof(_connection_1) == "RBXScriptConnection"
+		if not _condition then
+			_condition = connection.Disconnect ~= nil
+		end
+		if _condition then
+			connection:Disconnect()
+		elseif connection.disconnect ~= nil then
+			connection:disconnect()
+		else
+			error("Connection-like object does not have a supported disconnect method.")
+		end
+	end
+end
+--[[
+	*
+	 * Subscribes to an event-like object. The subscription is automatically
+	 * disconnected when the scope cleans up.
+	 *
+	 * @param event The event-like object to subscribe to.
+	 * @param listener The listener to subscribe with.
+	 * @returns The connection object.
+	 
+]]
+local function useEventListener(event, listener)
+	local connection = connect(event, listener)
+	cleanup(function()
+		return disconnect(connection)
+	end)
+	return connection
+end
+return {
+	default = useEventListener,
+}

package/out/hooks/usePx.d.ts

@@ -0,0 +1,11 @@
+export declare const px: ((value: number) => number) & {
+    scale: (value: number) => number;
+    even: (value: number) => number;
+    floor: (value: number) => number;
+    ceil: (value: number) => number;
+};
+/**
+ * Initializes global px scaling.
+ * Must be called exactly once.
+ */
+export declare function usePx(target?: GuiObject | Camera, baseResolution?: Vector2, minScale?: number): void;

package/out/hooks/usePx.luau

@@ -0,0 +1,93 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Services
+local Workspace = TS.import(script, TS.getModule(script, "@rbxts", "services")).Workspace
+-- Packages
+local source = TS.import(script, TS.getModule(script, "@rbxts", "vide").src).source
+-- Helpers
+local useEventListener = TS.import(script, script.Parent, "useEventListener").default
+--* Default reference resolution for px calculations 
+local BASE_RESOLUTION = source(Vector2.new(1920, 1080))
+--* Minimum allowed scale to prevent unreadable UI 
+local MIN_SCALE = source(0.5)
+--* 0 = width-based, 1 = height-based 
+local DOMINANT_AXIS = 0.5
+local TARGET = source(Workspace.CurrentCamera)
+local SCALE = source(1)
+local INITIALIZED = false
+local function callable(callback, object)
+	return setmetatable(object, {
+		__call = function(_, ...)
+			local args = { ... }
+			return callback(unpack(args))
+		end,
+	})
+end
+local px = callable(function(value)
+	return math.round(value * SCALE())
+end, {
+	scale = function(value)
+		return value * SCALE()
+	end,
+	even = function(value)
+		return math.round(value * SCALE() * 0.5) * 2
+	end,
+	floor = function(value)
+		return math.floor(value * SCALE())
+	end,
+	ceil = function(value)
+		return math.ceil(value * SCALE())
+	end,
+})
+local function calculateScale()
+	local target = TARGET()
+	if not target then
+		return nil
+	end
+	local size = if target:IsA("Camera") then target.ViewportSize elseif target:IsA("GuiObject") then target.AbsoluteSize else nil
+	if not size then
+		return nil
+	end
+	local res = BASE_RESOLUTION()
+	if res.X <= 0 or res.Y <= 0 then
+		return nil
+	end
+	local min = MIN_SCALE()
+	local width = math.log(size.X / res.X, 2)
+	local height = math.log(size.Y / res.Y, 2)
+	local centered = width + (height - width) * DOMINANT_AXIS
+	local scale = 2 ^ centered
+	SCALE(math.max(scale, min))
+end
+--[[
+	*
+	 * Initializes global px scaling.
+	 * Must be called exactly once.
+	 
+]]
+local function usePx(target, baseResolution, minScale)
+	if INITIALIZED then
+		return warn("usePx() called more than once")
+	end
+	INITIALIZED = true
+	if baseResolution then
+		BASE_RESOLUTION(baseResolution)
+	end
+	if minScale ~= 0 and minScale == minScale and minScale then
+		MIN_SCALE(minScale)
+	end
+	if target then
+		TARGET(target)
+	end
+	local resolvedTarget = TARGET()
+	if not resolvedTarget then
+		return warn("usePx(): no valid target to observe")
+	end
+	local signal = if resolvedTarget:IsA("Camera") then resolvedTarget:GetPropertyChangedSignal("ViewportSize") else resolvedTarget:GetPropertyChangedSignal("AbsoluteSize")
+	useEventListener(signal, calculateScale)
+	calculateScale()
+end
+return {
+	usePx = usePx,
+	px = px,
+}

package/out/index.d.ts

@@ -0,0 +1,5 @@
+export { App, Args } from "./appRegistry";
+export { default as CreateForge } from "./forge";
+export type { ForgeProps, ClassProps, RenderProps, } from "./types";
+export { default as useAppContext } from "./hooks/useAppContext";
+export { default as Contexts } from "./context";

package/out/init.luau

@@ -0,0 +1,13 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+-- Decorators
+local _appRegistry = TS.import(script, script, "appRegistry")
+exports.App = _appRegistry.App
+exports.Args = _appRegistry.Args
+-- Creators
+exports.CreateForge = TS.import(script, script, "forge").default
+-- Types
+exports.useAppContext = TS.import(script, script, "hooks", "useAppContext").default
+exports.Contexts = TS.import(script, script, "context").default
+return exports

package/out/renders.d.ts

@@ -0,0 +1,18 @@
+import type Types from "./types";
+import Rules from "./ruleEngine";
+type Render = {
+    instance: Instance;
+    container: Instance;
+    entry: Types.AppRegistry.Static;
+};
+export default class Renders extends Rules {
+    private __px;
+    protected Loaded: Map<string, Map<string, Render>>;
+    constructor();
+    private Load;
+    protected Initalize(props: Types.Props.Main): Instance[];
+    private collectEntries;
+    private expandWithChildren;
+    private createInstance;
+}
+export {};

package/out/renders.luau

@@ -0,0 +1,310 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Services
+-- Packages
+local _vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
+local Vide = _vide
+local apply = _vide.apply
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent, "appRegistry").AppRegistry
+-- Hooks
+local usePx = TS.import(script, script.Parent, "hooks", "usePx").usePx
+-- Classes
+local Rules = TS.import(script, script.Parent, "ruleEngine").default
+-- Helpers
+local getAppEntry = TS.import(script, script.Parent, "helpers", "getAppEntry").default
+local Renders
+do
+	local super = Rules
+	Renders = setmetatable({}, {
+		__tostring = function()
+			return "Renders"
+		end,
+		__index = super,
+	})
+	Renders.__index = Renders
+	function Renders.new(...)
+		local self = setmetatable({}, Renders)
+		return self:constructor(...) or self
+	end
+	function Renders:constructor()
+		super.constructor(self)
+		self.__px = false
+		self.Loaded = {}
+	end
+	function Renders:Load(props)
+		local baseEntries = self:collectEntries(props.renders)
+		local toLoad = self:expandWithChildren(baseEntries)
+		local load = {}
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback = function(entry)
+			local name = tostring(entry.constructor)
+			local group = entry.group
+			local render = self:createInstance(props, name, group)
+			if not render then
+				return nil
+			end
+			local _result = render.entry.rules
+			if _result ~= nil then
+				_result = _result.parent
+			end
+			if not (_result ~= "" and _result) then
+				local _container = render.container
+				table.insert(load, _container)
+			end
+		end
+		for _k, _v in toLoad do
+			_callback(_v, _k - 1, toLoad)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+		return load
+	end
+	function Renders:Initalize(props)
+		if not self.__px then
+			local _result = props.config
+			if _result ~= nil then
+				_result = _result.px.target
+			end
+			local _result_1 = props.config
+			if _result_1 ~= nil then
+				_result_1 = _result_1.px.resolution
+			end
+			local _result_2 = props.config
+			if _result_2 ~= nil then
+				_result_2 = _result_2.px.minScale
+			end
+			usePx(_result, _result_1, _result_2)
+			self.__px = true
+		end
+		return self:Load(props)
+	end
+	function Renders:collectEntries(renders)
+		local result = {}
+		local _result = renders
+		if _result ~= nil then
+			_result = _result.name
+		end
+		local _result_1
+		if _result ~= nil then
+			_result_1 = {
+				[renders.name] = true,
+			}
+		else
+			local _result_2 = renders
+			if _result_2 ~= nil then
+				_result_2 = _result_2.names
+			end
+			local _result_3
+			if _result_2 then
+				local _set = {}
+				for _, _v in renders.names do
+					_set[_v] = true
+				end
+				_result_3 = _set
+			else
+				_result_3 = nil
+			end
+			_result_1 = _result_3
+		end
+		local names = _result_1
+		local _result_2 = renders
+		if _result_2 ~= nil then
+			_result_2 = _result_2.group
+		end
+		local _result_3
+		if _result_2 ~= nil then
+			_result_3 = {
+				[renders.group] = true,
+			}
+		else
+			local _result_4 = renders
+			if _result_4 ~= nil then
+				_result_4 = _result_4.groups
+			end
+			local _result_5
+			if _result_4 then
+				local _set = {}
+				for _, _v in renders.groups do
+					_set[_v] = true
+				end
+				_result_5 = _set
+			else
+				_result_5 = nil
+			end
+			_result_3 = _result_5
+		end
+		local groups = _result_3
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(groupEntries, appName)
+			local _condition = names
+			if _condition then
+				local _appName = appName
+				_condition = not (names[_appName] ~= nil)
+			end
+			if _condition then
+				return nil
+			end
+			-- ▼ ReadonlyMap.forEach ▼
+			local _callback_1 = function(entry, group)
+				local _condition_1 = groups
+				if _condition_1 then
+					local _group = group
+					_condition_1 = not (groups[_group] ~= nil)
+				end
+				if _condition_1 then
+					return nil
+				end
+				local _entry = entry
+				table.insert(result, _entry)
+			end
+			for _k, _v in groupEntries do
+				_callback_1(_v, _k, groupEntries)
+			end
+			-- ▲ ReadonlyMap.forEach ▲
+		end
+		for _k, _v in AppRegistry do
+			_callback(_v, _k, AppRegistry)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		return result
+	end
+	function Renders:expandWithChildren(entries)
+		local _array = {}
+		local _length = #_array
+		table.move(entries, 1, #entries, _length + 1, _array)
+		local result = _array
+		local _set = {}
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#entries)
+		local _callback = function(e)
+			return tostring(e.constructor)
+		end
+		for _k, _v in entries do
+			_newValue[_k] = _callback(_v, _k - 1, entries)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		for _, _v in _newValue do
+			_set[_v] = true
+		end
+		local selected = _set
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback_1 = function(groupEntries)
+			-- ▼ ReadonlyMap.forEach ▼
+			local _callback_2 = function(entry)
+				local _parent = entry.rules
+				if _parent ~= nil then
+					_parent = _parent.parent
+				end
+				local parent = _parent
+				local _condition = parent
+				if _condition ~= "" and _condition then
+					_condition = selected[parent] ~= nil
+				end
+				if _condition ~= "" and _condition then
+					local _entry = entry
+					table.insert(result, _entry)
+				end
+			end
+			for _k, _v in groupEntries do
+				_callback_2(_v, _k, groupEntries)
+			end
+			-- ▲ ReadonlyMap.forEach ▲
+		end
+		for _k, _v in AppRegistry do
+			_callback_1(_v, _k, AppRegistry)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		return result
+	end
+	function Renders:createInstance(props, name, group)
+		local entry = getAppEntry(name, group)
+		if not entry then
+			return nil
+		end
+		-- App Entry Instance/Render
+		local entryInstance = entry.constructor.new(props, name, group):render()
+		entryInstance.Name = "Render"
+		-- Parent Container
+		local parentContainer
+		local _result = entry.rules
+		if _result ~= nil then
+			_result = _result.parent
+		end
+		if _result ~= "" and _result then
+			local _condition = entry.rules.parentGroup
+			if not (_condition ~= "" and _condition) then
+				_condition = "None"
+			end
+			local group = _condition
+			local _loaded = self.Loaded
+			local _parent = entry.rules.parent
+			local parentMap = _loaded[_parent]
+			if parentMap then
+				local parentEntry = parentMap[group]
+				if parentEntry then
+					parentContainer = parentEntry.container
+				end
+			end
+		end
+		-- Anchor
+		local anchor
+		local _result_1 = entry.rules
+		if _result_1 ~= nil then
+			_result_1 = _result_1.anchor
+		end
+		if _result_1 then
+			local parentName = entry.rules.parent
+			local _condition = entry.rules.parentGroup
+			if not (_condition ~= "" and _condition) then
+				_condition = "None"
+			end
+			local parentGroup = _condition
+			if not (parentName ~= "" and parentName) then
+				return nil
+			end
+			local parentEntry = getAppEntry(entry.rules.parent, parentGroup)
+			if not parentEntry then
+				return nil
+			end
+			anchor = parentEntry.constructor.new(props, parentName, parentGroup):render()
+			local _exp = anchor:GetDescendants()
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback = function(instance)
+				return instance:Destroy()
+			end
+			for _k, _v in _exp do
+				_callback(_v, _k - 1, _exp)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+			apply(anchor)({
+				Name = "Anchor",
+				BackgroundTransparency = 1,
+				[0] = entryInstance,
+			})
+		end
+		local container = (Vide.jsx("frame", {
+			Name = name,
+			BackgroundTransparency = 1,
+			AnchorPoint = Vector2.new(0.5, 0.5),
+			Position = UDim2.fromScale(0.5, 0.5),
+			Size = UDim2.fromScale(1, 1),
+			Parent = parentContainer,
+		}, if anchor then anchor else entryInstance))
+		local newMap = {}
+		local render = {
+			container = container,
+			instance = entryInstance,
+			entry = entry,
+		}
+		local _group = group
+		newMap[_group] = render
+		local _loaded = self.Loaded
+		local _name = name
+		_loaded[_name] = newMap
+		return render
+	end
+end
+return {
+	default = Renders,
+}

package/out/ruleEngine/check/exclusiveGroup.d.ts

@@ -0,0 +1,2 @@
+import type AppForge from "../../forge";
+export default function ExclusiveGroupRule(forge: AppForge, name: AppNames, group: AppGroups): void;

package/out/ruleEngine/check/exclusiveGroup.luau

@@ -0,0 +1,49 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent.Parent.Parent, "appRegistry").AppRegistry
+-- Helpers
+local getAppEntry = TS.import(script, script.Parent.Parent.Parent, "helpers", "getAppEntry").default
+local function ExclusiveGroupRule(forge, name, group)
+	local entry = getAppEntry(name, group)
+	if not entry then
+		error(`Failed to find app entry for "ExclusiveGroupRule" name {name} group {group}`)
+	end
+	local entryVisible = forge:getSource(name, group)()
+	if not entryVisible then
+		return nil
+	end
+	-- ▼ ReadonlyMap.forEach ▼
+	local _callback = function(entryMap, entryGroup)
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback_1 = function(entry, entryName)
+			if name == entryName then
+				return nil
+			end
+			local _result = entry.rules
+			if _result ~= nil then
+				_result = _result.exclusiveGroup
+			end
+			if _result ~= entryGroup then
+				return nil
+			end
+			local visible = forge:getSource(entryName)()
+			if not visible then
+				return nil
+			end
+			forge:close(entryName, entryGroup, false)
+		end
+		for _k, _v in entryMap do
+			_callback_1(_v, _k, entryMap)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+	end
+	for _k, _v in AppRegistry do
+		_callback(_v, _k, AppRegistry)
+	end
+	-- ▲ ReadonlyMap.forEach ▲
+end
+return {
+	default = ExclusiveGroupRule,
+}

package/out/ruleEngine/check/parent.d.ts

@@ -0,0 +1,2 @@
+import type AppForge from "../../forge";
+export default function ParentRule(forge: AppForge, name: AppNames, group: AppGroups): void;

package/out/ruleEngine/check/parent.luau

@@ -0,0 +1,37 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Types
+-- Helpers
+local getAppSource = TS.import(script, script.Parent.Parent.Parent, "helpers", "getAppSource").default
+local getAppEntry = TS.import(script, script.Parent.Parent.Parent, "helpers", "getAppEntry").default
+local function ParentRule(forge, name, group)
+	local entry = getAppEntry(name, group)
+	local _result = entry
+	if _result ~= nil then
+		_result = _result.rules
+		if _result ~= nil then
+			_result = _result.parent
+		end
+	end
+	if not (_result ~= "" and _result) then
+		return nil
+	end
+	local _exp = entry.rules.parent
+	local _condition = entry.rules.parentGroup
+	if _condition == nil then
+		_condition = "None"
+	end
+	local parentSource = getAppSource(_exp, _condition)
+	if parentSource and parentSource() == false then
+		local source = forge:getSource(name, group)
+		if not source then
+			warn(`Failed to get Source for name {name} group {group}`)
+		end
+		if source() then
+			source(false)
+		end
+	end
+end
+return {
+	default = ParentRule,
+}

package/out/ruleEngine/index.d.ts

@@ -0,0 +1,7 @@
+import type AppForge from "../forge";
+import type Types from "../types";
+export default class Rules {
+    protected processing: Set<string>;
+    protected renderRules(name: AppNames, group: AppGroups | undefined, props: Types.Props.Main): void;
+    protected checkRules(forge: AppForge, name: AppNames, group: AppGroups): void;
+}