@rbxts/app-forge 0.7.2-prototype.1 → 0.7.2-prototype.11

package/out/types.d.ts

@@ -21,7 +21,7 @@ declare namespace Types {
 					minScale?: number;
 				};
 			};
-			render?: Render;
+			renders?: Render;
 		};
 
 		type Class = AppProps & {
@@ -34,23 +34,23 @@ declare namespace Types {
 		type Props<N extends AppNames> = {
 			name: N;
 			visible?: boolean;
-			renderGroup?: AppGroups;
+			group?: AppGroups;
 			rules?: Rules.Generic<N>;
 		};
 
 		type Static = {
-			constructor: new (props: Types.Props.Main, name: AppNames) => Args;
+			constructor: new (props: Types.Props.Main, name: AppNames, group?: AppGroups) => Args;
 
 			visible?: boolean;
-			renderGroup?: AppGroups;
+			group?: AppGroups;
 			rules?: Rules.Static;
 		};
 
 		type Generic<N extends AppNames = AppNames> = {
-			constructor: new (props: Types.Props.Main, name: AppNames) => Args;
+			constructor: new (props: Types.Props.Main, name: AppNames, group?: AppGroups) => Args;
 
 			visible?: boolean;
-			renderGroup?: AppGroups;
+			group?: AppGroups;
 			rules?: Rules.Generic<N>;
 		};
 	}
@@ -58,12 +58,16 @@ declare namespace Types {
 	namespace Rules {
 		type WithParent<P> = {
 			parent: P;
-			detach?: boolean;
+
+			parentGroup?: AppGroups;
+			anchor?: boolean;
 		};
 
 		type WithoutParent = {
 			parent?: never;
-			detach?: never;
+
+			parentGroup?: never;
+			anchor?: never;
 		};
 
 		export type Static = {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rbxts/app-forge",
-	"version": "0.7.2-prototype.1",
+	"version": "0.7.2-prototype.11",
 	"description": "An App Manager for Vide",
 	"main": "out/init.lua",
 	"types": "out/index.d.ts",

package/out/renderManager.d.ts

@@ -1,32 +0,0 @@
-import Vide from "@rbxts/vide";
-import type Types from "./types";
-import type AppForge from "./mount";
-import Rules from "./ruleEngine";
-export default class Renders extends Rules {
-    protected anchored: Map<string, {
-        id: AppNames;
-        render: Vide.Node;
-    }>;
-    constructor();
-    /**
-     * Entry point for mounting renders.
-     * Decides render strategy based on props.
-     */
-    protected renderMount(this: AppForge, props: Types.Props.Main): Vide.Node;
-    /**
-     * Render multiple apps by name, avoiding duplicates.
-     */
-    private renderNames;
-    /**
-     * Render children of a parent app recursively inside parent container
-     */
-    private renderChildren;
-    private collectByGroup;
-    private normalizeGroups;
-    protected renderApp(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>, parentContainer?: Instance): Vide.Node;
-    protected renderApps(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>): Instance[];
-    protected renderGroup(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>): Instance[];
-    protected renderGroupByName(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>): Instance[];
-    protected renderGroupByNames(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>): Instance[];
-    protected renderAll(this: AppForge, props: Types.Props.Main, renderedSet?: Set<AppNames>): Instance[];
-}

package/out/renderManager.luau

@@ -1,326 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
--- Packages
-local _vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
-local apply = _vide.apply
-local create = _vide.create
-local mount = _vide.mount
--- 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
-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.anchored = {}
-	end
-	function Renders:renderMount(props)
-		local _binding = props
-		local config = _binding.config
-		local render = _binding.render
-		local forge = _binding.forge
-		if not forge.__px then
-			local _debug = forge.debug
-			local _result = config
-			if _result ~= nil then
-				_result = _result.px
-			end
-			_debug:logTag("px", "global", "Initializing px scaling", _result)
-			local _result_1 = config
-			if _result_1 ~= nil then
-				_result_1 = _result_1.px.target
-			end
-			local _result_2 = config
-			if _result_2 ~= nil then
-				_result_2 = _result_2.px.resolution
-			end
-			local _result_3 = config
-			if _result_3 ~= nil then
-				_result_3 = _result_3.px.minScale
-			end
-			usePx(_result_1, _result_2, _result_3)
-			forge.__px = true
-		else
-			forge.debug:logTag("px", "global", "Skipped duplicate px initialization")
-		end
-		local renderedSet = {}
-		if render then
-			local _condition = render.name
-			if _condition ~= "" and _condition then
-				_condition = render.group
-			end
-			if _condition ~= "" and _condition then
-				return self:renderGroupByName(props, renderedSet)
-			end
-			local _value = render.names and render.group
-			if _value ~= "" and _value then
-				return self:renderGroupByNames(props, renderedSet)
-			end
-			local _value_1 = render.name
-			if _value_1 ~= "" and _value_1 then
-				return self:renderApp(props, renderedSet)
-			end
-			if render.names then
-				return self:renderApps(props, renderedSet)
-			end
-			local _value_2 = render.group
-			if _value_2 ~= "" and _value_2 then
-				return self:renderGroup(props, renderedSet)
-			end
-		end
-		return self:renderAll(props, renderedSet)
-	end
-	function Renders:renderNames(props, names, forge, context, renderedSet, details, parentContainer)
-		if not names then
-			local _logger = forge.logger
-			local _exp = `Renderer resolved 0 apps ({context})`
-			local _condition = details
-			if _condition == nil then
-				_condition = props.render
-			end
-			_logger:log("WARN", _exp, _condition)
-			return {}
-		end
-		local rendered = {}
-		for _, name in names do
-			if renderedSet[name] ~= nil then
-				continue
-			end
-			renderedSet[name] = true
-			local _forge = forge
-			local _object = table.clone(props)
-			setmetatable(_object, nil)
-			_object.render = {
-				name = name,
-			}
-			local appRender = _forge:renderApp(_object, renderedSet, parentContainer)
-			table.insert(rendered, appRender)
-			self:renderChildren(props, name, forge, renderedSet, rendered, appRender)
-		end
-		return rendered
-	end
-	function Renders:renderChildren(props, parentName, forge, renderedSet, accumulated, parentContainer)
-		-- ▼ ReadonlyMap.forEach ▼
-		local _callback = function(app, childName)
-			local _result = app.rules
-			if _result ~= nil then
-				_result = _result.parent
-			end
-			local _condition = _result == parentName
-			if _condition then
-				local _renderedSet = renderedSet
-				local _childName = childName
-				_condition = not (_renderedSet[_childName] ~= nil)
-			end
-			if _condition then
-				local _renderedSet = renderedSet
-				local _childName = childName
-				_renderedSet[_childName] = true
-				local _forge = forge
-				local _object = table.clone(props)
-				setmetatable(_object, nil)
-				_object.render = {
-					name = childName,
-				}
-				local childRender = _forge:renderApp(_object, renderedSet, parentContainer)
-				table.insert(accumulated, childRender)
-				mount(function()
-					return childRender
-				end, parentContainer)
-				self:renderChildren(props, childName, forge, renderedSet, accumulated, childRender)
-			end
-		end
-		for _k, _v in AppRegistry do
-			_callback(_v, _k, AppRegistry)
-		end
-		-- ▲ ReadonlyMap.forEach ▲
-	end
-	function Renders:collectByGroup(groups, filter)
-		local result = {}
-		-- ▼ ReadonlyMap.forEach ▼
-		local _callback = function(app, name)
-			local appGroup = app.renderGroup
-			if not (appGroup ~= "" and appGroup) then
-				return nil
-			end
-			if not (table.find(groups, appGroup) ~= nil) then
-				return nil
-			end
-			if filter and not filter(name) then
-				return nil
-			end
-			local _name = name
-			table.insert(result, _name)
-		end
-		for _k, _v in AppRegistry do
-			_callback(_v, _k, AppRegistry)
-		end
-		-- ▲ ReadonlyMap.forEach ▲
-		return result
-	end
-	function Renders:normalizeGroups(group)
-		local _group = group
-		local _result
-		if type(_group) == "table" then
-			local _array = {}
-			local _length = #_array
-			table.move(group, 1, #group, _length + 1, _array)
-			_result = _array
-		else
-			_result = { group }
-		end
-		return _result
-	end
-	function Renders:renderApp(props, renderedSet, parentContainer)
-		local _name = props.render
-		if _name ~= nil then
-			_name = _name.name
-		end
-		local name = _name
-		if not (name ~= "" and name) then
-			error("renderApp requires an app name", 2)
-		end
-		local appClass = AppRegistry[name]
-		if not appClass then
-			error(`App "{name}" not registered`, 2)
-		end
-		self.debug:time("render", name)
-		if not (self.loaded[name] ~= nil) then
-			local render = appClass.constructor.new(props, name):render()
-			if not render then
-				error(`App "{name}" returned undefined from render()`, 2)
-			end
-			apply(render)({
-				Name = "Render",
-			})
-			local container = create("Frame")({
-				Name = name,
-				BackgroundTransparency = 1,
-				AnchorPoint = Vector2.new(0.5, 0.5),
-				Position = UDim2.fromScale(0.5, 0.5),
-				Size = UDim2.fromScale(1, 1),
-				[0] = render,
-			})
-			if parentContainer then
-				container.Parent = parentContainer
-			end
-			local _loaded = self.loaded
-			local _arg1 = {
-				container = container,
-				render = render,
-			}
-			_loaded[name] = _arg1
-		else
-			self.debug:logTag("render", name, "Reusing existing render instance")
-		end
-		local _result = renderedSet
-		if _result ~= nil then
-			_result[name] = true
-		end
-		self:renderRules(self, name, props)
-		self.debug:timeEnd("render", name)
-		return self.loaded[name].container
-	end
-	function Renders:renderApps(props, renderedSet)
-		if renderedSet == nil then
-			renderedSet = {}
-		end
-		local _names = props.render
-		if _names ~= nil then
-			_names = _names.names
-		end
-		local names = _names
-		if not names then
-			error("renderApps requires app names", 2)
-		end
-		return self:renderNames(props, names, self, "renderApps", renderedSet, names)
-	end
-	function Renders:renderGroup(props, renderedSet)
-		if renderedSet == nil then
-			renderedSet = {}
-		end
-		local _group = props.render
-		if _group ~= nil then
-			_group = _group.group
-		end
-		local group = _group
-		if not (group ~= "" and group) then
-			error("renderGroup requires a group", 2)
-		end
-		local groups = self:normalizeGroups(group)
-		return self:renderNames(props, self:collectByGroup(groups), self, "renderGroup", renderedSet, group)
-	end
-	function Renders:renderGroupByName(props, renderedSet)
-		if renderedSet == nil then
-			renderedSet = {}
-		end
-		local _binding = props.render or {}
-		local group = _binding.group
-		local name = _binding.name
-		if not (group ~= "" and group) or not (name ~= "" and name) then
-			error("Invalid renderGroupByName call", 2)
-		end
-		local groups = self:normalizeGroups(group)
-		return self:renderNames(props, self:collectByGroup(groups, function(n)
-			return n == name
-		end), self, "renderGroupByName", renderedSet, {
-			group = group,
-			name = name,
-		})
-	end
-	function Renders:renderGroupByNames(props, renderedSet)
-		if renderedSet == nil then
-			renderedSet = {}
-		end
-		local _binding = props.render or {}
-		local group = _binding.group
-		local names = _binding.names
-		if not (group ~= "" and group) or not names then
-			error("Invalid renderGroupByNames call", 2)
-		end
-		local groups = self:normalizeGroups(group)
-		return self:renderNames(props, self:collectByGroup(groups, function(n)
-			local _n = n
-			return table.find(names, _n) ~= nil
-		end), self, "renderGroupByNames", renderedSet, {
-			group = group,
-			names = names,
-		})
-	end
-	function Renders:renderAll(props, renderedSet)
-		if renderedSet == nil then
-			renderedSet = {}
-		end
-		local names = {}
-		-- ▼ ReadonlyMap.forEach ▼
-		local _callback = function(_, name)
-			local _name = name
-			table.insert(names, _name)
-			return #names
-		end
-		for _k, _v in AppRegistry do
-			_callback(_v, _k, AppRegistry)
-		end
-		-- ▲ ReadonlyMap.forEach ▲
-		return self:renderNames(props, names, self, "renderAll", renderedSet)
-	end
-end
-return {
-	default = Renders,
-}

package/out/ruleEngine/exclusiveGroup.d.ts

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

package/out/ruleEngine/exclusiveGroup.luau

@@ -1,54 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
--- Types
--- Components
-local AppRegistry = TS.import(script, script.Parent.Parent, "appRegistry").AppRegistry
-local function ExclusiveGroupRule(entry, forge)
-	local _entry = entry
-	local entryApp = AppRegistry[_entry]
-	local _group = entryApp
-	if _group ~= nil then
-		_group = _group.rules
-		if _group ~= nil then
-			_group = _group.exclusiveGroup
-		end
-	end
-	local group = _group
-	if not (group ~= "" and group) then
-		return nil
-	end
-	local entryVisible = forge:getSource(entry)()
-	if not entryVisible then
-		return nil
-	end
-	forge.debug:logTag("rules", entry, "Exclusive group activated", group)
-	-- ▼ ReadonlyMap.forEach ▼
-	local _callback = function(app, name)
-		if name == entry then
-			return nil
-		end
-		local _result = app.rules
-		if _result ~= nil then
-			_result = _result.exclusiveGroup
-		end
-		if _result ~= group then
-			return nil
-		end
-		local visible = forge:getSource(name)()
-		if not visible then
-			return nil
-		end
-		forge.debug:logTag("rules", entry, "Closing app due to exclusive group", {
-			closed = name,
-			group = group,
-		})
-		forge:close(name, false)
-	end
-	for _k, _v in AppRegistry do
-		_callback(_v, _k, AppRegistry)
-	end
-	-- ▲ ReadonlyMap.forEach ▲
-end
-return {
-	default = ExclusiveGroupRule,
-}

package/out/ruleEngine/parent.d.ts

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

package/out/ruleEngine/parent.luau

@@ -1,34 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
--- Types
--- Components
-local AppRegistry = TS.import(script, script.Parent.Parent, "appRegistry").AppRegistry
-local function ParentRule(entry, forge)
-	local entryVisible = forge:getSource(entry)()
-	-- ▼ ReadonlyMap.forEach ▼
-	local _callback = function(app, name)
-		local rules = app.rules
-		if not rules or rules.parent ~= entry then
-			return nil
-		end
-		if name == entry then
-			return nil
-		end
-		local childVisible = forge:getSource(name)()
-		if entryVisible or not childVisible then
-			return nil
-		end
-		forge.debug:logTag("rules", entry, "Closing child app (parent closed)", {
-			parent = entry,
-			child = name,
-		})
-		forge:close(name, false)
-	end
-	for _k, _v in AppRegistry do
-		_callback(_v, _k, AppRegistry)
-	end
-	-- ▲ ReadonlyMap.forEach ▲
-end
-return {
-	default = ParentRule,
-}