@rbxts/app-forge 0.7.2-prototype.2 → 0.7.2-prototype.21

package/out/appRegistry.d.ts

@@ -1,21 +1,23 @@
 import Vide from "@rbxts/vide";
 import type Types from "./types";
 import type AppForge from "./mount";
-export declare const AppRegistry: Map<string, Types.AppRegistry.Static>;
+export declare const AppRegistry: Map<string, Map<string, Types.AppRegistry.Static>>;
+export declare const AppSources: Map<string, Map<string, Vide.Source<boolean>>>;
 /**
  * Registers a Vide App with AppForge.
  *
  * This runs at definition time and validates static configuration.
  */
-export declare function App<N extends AppNames>(props: Types.AppRegistry.Props<N>): <T extends new (props: Types.Props.Main, name: AppNames) => Args>(constructor: T) => T;
+export declare function App<N extends AppNames>(props: Types.AppRegistry.Props<N>): <T extends new (props: Types.Props.Main, name: AppNames, group?: AppGroups) => Args>(constructor: T) => T;
 /**
  * Base class for all AppForge Apps.
  */
 export declare abstract class Args {
-    readonly forge: AppForge;
+    readonly source: Vide.Source<boolean>;
     readonly props: Types.Props.Class;
+    readonly forge: AppForge;
+    readonly group: AppGroups;
     readonly name: AppNames;
-    readonly source: Vide.Source<boolean>;
-    constructor(props: Types.Props.Main, name: AppNames);
+    constructor(props: Types.Props.Main, name: AppNames, group?: AppGroups);
     abstract render(): Vide.Node;
 }

package/out/appRegistry.luau

@@ -4,10 +4,8 @@ local TS = _G[script]
 -- Types
 -- Hooks
 local px = TS.import(script, script.Parent, "hooks", "usePx").px
--- Debug
-local Logger = TS.import(script, script.Parent, "logger").default
-local logger = Logger.new("AppRegistry")
 local AppRegistry = {}
+local AppSources = {}
 --[[
 	*
 	 * Registers a Vide App with AppForge.
@@ -18,25 +16,51 @@ local AppRegistry = {}
 local function App(props)
 	return function(constructor)
 		local _name = props.name
-		if AppRegistry[_name] ~= nil then
-			logger:log("ERROR", "Duplicate App name detected", {
-				name = props.name,
-			})
-			error(`Duplicate registered App name "{props.name}". ` .. `App names must be globally unique.`, 2)
+		local _result = AppRegistry[_name]
+		if _result ~= nil then
+			local _condition = props.group
+			if not (_condition ~= "" and _condition) then
+				_condition = "None"
+			end
+			_result = _result[_condition] ~= nil
+		end
+		if _result then
+			local _exp = props.name
+			local _condition = props.group
+			if not (_condition ~= "" and _condition) then
+				_condition = "None"
+			end
+			error(`Duplicate registered App name "{_exp} in same Group name {_condition}". ` .. `App names must be globally unique.`, 2)
 		end
 		local _value = props.name
 		if not (_value ~= "" and _value) then
-			logger:log("ERROR", "Attempted to register App without a name", props)
 			error("App registration failed: missing app name", 2)
 		end
 		local _name_1 = props.name
-		local _arg1 = {
-			constructor = constructor,
-			renderGroup = props.renderGroup,
-			visible = props.visible,
-			rules = props.rules,
-		}
-		AppRegistry[_name_1] = _arg1
+		if not AppRegistry[_name_1] then
+			local _name_2 = props.name
+			AppRegistry[_name_2] = {}
+		end
+		local _name_2 = props.name
+		local _result_1 = AppRegistry[_name_2]
+		if _result_1 ~= nil then
+			local _condition = props.group
+			if not (_condition ~= "" and _condition) then
+				_condition = "None"
+			end
+			local _object = {
+				constructor = constructor,
+			}
+			local _left = "renderGroup"
+			local _condition_1 = props.group
+			if not (_condition_1 ~= "" and _condition_1) then
+				_condition_1 = "None"
+			end
+			_object[_left] = _condition_1
+			_object.visible = props.visible
+			_object.rules = props.rules
+			_result_1[_condition] = _object
+		end
 		return constructor
 	end
 end
@@ -48,28 +72,27 @@ end
 local Args
 do
 	Args = {}
-	function Args:constructor(props, name)
+	function Args:constructor(props, name, group)
 		local _binding = props
 		local forge = _binding.forge
 		self.forge = forge
+		local _condition = group
+		if not (_condition ~= "" and _condition) then
+			_condition = "None"
+		end
+		self.group = _condition
 		self.name = name
 		local _object = table.clone(props.props)
 		setmetatable(_object, nil)
-		_object.px = px
 		_object.forge = forge
+		_object.px = px
 		self.props = _object
-		local src = forge:getSource(name)
-		if not src then
-			logger:log("ERROR", "Missing visibility source for App", {
-				name = name,
-			})
-			error(`Failed to retrieve visibility source for app "{name}"`, 2)
-		end
-		self.source = src
+		self.source = forge:getSource(name, group)
 	end
 end
 return {
 	App = App,
 	AppRegistry = AppRegistry,
+	AppSources = AppSources,
 	Args = Args,
 }

package/out/helpers/bindAppSource.d.ts

@@ -0,0 +1,2 @@
+import Vide from "@rbxts/vide";
+export default function bindAppSource(name: AppNames, group: AppGroups, value: Vide.Source<boolean>): void;

package/out/helpers/bindAppSource.luau

@@ -0,0 +1,22 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+-- Components
+local AppSources = TS.import(script, script.Parent.Parent, "appRegistry").AppSources
+local function bindAppSource(name, group, value)
+	local _name = name
+	if not AppSources[_name] then
+		local _name_1 = name
+		AppSources[_name_1] = {}
+	end
+	local _name_1 = name
+	local _result = AppSources[_name_1]
+	if _result ~= nil then
+		local _group = group
+		local _value = value
+		_result[_group] = _value
+	end
+end
+return {
+	default = bindAppSource,
+}

package/out/helpers/getAppEntry.d.ts

@@ -0,0 +1,2 @@
+import type CreateForge from "../mount";
+export default function getAppEntry(forge: CreateForge, name: AppNames, group: AppGroups): import("../types").default.AppRegistry.Static | undefined;

package/out/helpers/getAppEntry.luau

@@ -0,0 +1,22 @@
+-- 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 getAppEntry(forge, name, group)
+	local _name = name
+	local entryMap = AppRegistry[_name]
+	local _entry = entryMap
+	if _entry ~= nil then
+		local _group = group
+		_entry = _entry[_group]
+	end
+	local entry = _entry
+	if not entry then
+		forge.logger:log("WARN", `Failed to get entry for name {name} and group {group}`)
+	end
+	return entry
+end
+return {
+	default = getAppEntry,
+}

package/out/helpers/getAppSource.d.ts

@@ -0,0 +1,2 @@
+import type CreateForge from "../mount";
+export default function getAppSource(forge: CreateForge, name: AppNames, group: AppGroups): import("@rbxts/vide").Source<boolean> | undefined;

package/out/helpers/getAppSource.luau

@@ -0,0 +1,25 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Types
+-- Components
+local AppSources = TS.import(script, script.Parent.Parent, "appRegistry").AppSources
+local function getAppSource(forge, name, group)
+	local _name = name
+	local sourceMap = AppSources[_name]
+	if not sourceMap then
+		forge.logger:log("WARN", `Failed to get source map for name {name} and group {group}`)
+	end
+	local _source = sourceMap
+	if _source ~= nil then
+		local _group = group
+		_source = _source[_group]
+	end
+	local source = _source
+	if not source then
+		forge.logger:log("WARN", `Failed to get source for name {name} and group {group}`)
+	end
+	return source
+end
+return {
+	default = getAppSource,
+}

package/out/helpers/hasAppSource.d.ts

@@ -0,0 +1 @@
+export default function hasAppSource(name: AppNames, group: AppGroups): boolean;

package/out/helpers/hasAppSource.luau

@@ -0,0 +1,24 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Components
+local AppSources = TS.import(script, script.Parent.Parent, "appRegistry").AppSources
+local function hasAppSource(name, group)
+	local _name = name
+	local sourceMap = AppSources[_name]
+	if not sourceMap then
+		local _ = false
+	end
+	local _source = sourceMap
+	if _source ~= nil then
+		local _group = group
+		_source = _source[_group]
+	end
+	local source = _source
+	if not source then
+		local _ = false
+	end
+	return true
+end
+return {
+	default = hasAppSource,
+}

package/out/helpers/setAppSource.d.ts

@@ -0,0 +1 @@
+export default function setAppSource(name: AppNames, group: AppGroups, value: boolean): void;

package/out/helpers/setAppSource.luau

@@ -0,0 +1,34 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+local source = TS.import(script, TS.getModule(script, "@rbxts", "vide").src).source
+-- Components
+local AppSources = TS.import(script, script.Parent.Parent, "appRegistry").AppSources
+local function setAppSource(name, group, value)
+	local _name = name
+	if not AppSources[_name] then
+		local _name_1 = name
+		AppSources[_name_1] = {}
+	end
+	local _name_1 = name
+	local _src = AppSources[_name_1]
+	if _src ~= nil then
+		local _group = group
+		_src = _src[_group]
+	end
+	local src = _src
+	if not src then
+		local newSource = source(value)
+		local _name_2 = name
+		local _result = AppSources[_name_2]
+		if _result ~= nil then
+			local _group = group
+			_result[_group] = newSource
+		end
+	else
+		src(false)
+	end
+end
+return {
+	default = setAppSource,
+}

package/out/mount.d.ts

@@ -1,33 +1,25 @@
 import Vide from "@rbxts/vide";
-import Renders from "./renderManager";
+import type Types from "./types";
+import Renders from "./renders";
 import Debugger from "./debugger";
 import Logger from "./logger";
-import Types from "./types";
 type Destructor = () => void;
-type Loaded = {
-    container: Vide.Node;
-    render: Vide.Node;
-    anchor?: Vide.Node;
-};
 export default class AppForge extends Renders {
     readonly logger: Logger;
     readonly debug: Debugger;
-    protected sources: Map<string, Vide.Source<boolean>>;
-    protected loaded: Map<string, Loaded>;
-    protected innerMount?: Destructor;
+    private innerMount?;
     constructor();
-    protected createSource(name: AppNames): void;
-    getSource(name: AppNames): Vide.Source<boolean>;
-    isLoaded(name: AppNames): boolean;
-    bind(name: AppNames, value: Vide.Source<boolean>): void;
-    set(name: AppNames, value: boolean, rules?: boolean): void;
-    open(name: AppNames, rules?: boolean): void;
-    close(name: AppNames, rules?: boolean): void;
-    toggle(name: AppNames, rules?: boolean): void;
+    private createSource;
+    getSource(name: AppNames, group?: AppGroups): Vide.Source<boolean>;
+    bind(name: AppNames, group: AppGroups | undefined, value: Vide.Source<boolean>): void;
+    set(name: AppNames, group: AppGroups | undefined, value: boolean, rules?: boolean): void;
+    open(name: AppNames, group?: AppGroups, rules?: boolean): void;
+    close(name: AppNames, group?: AppGroups, rules?: boolean): void;
+    toggle(name: AppNames, group?: AppGroups, rules?: boolean): void;
     story(props: AppProps, target: GuiObject, config?: {
         render?: Types.Props.Render;
         minScale?: number;
     }): Frame;
-    mount(node: Vide.Node, props: Types.Props.Main, target: Instance): Destructor;
+    mount(props: Omit<Types.Props.Main, "forge">, target: Instance, root?: GuiObject | Instance): Destructor | undefined;
 }
 export {};

package/out/mount.luau

@@ -8,15 +8,21 @@ local Vide = _vide
 local apply = _vide.apply
 local create = _vide.create
 local effect = _vide.effect
-local mount = _vide.mount
-local source = _vide.source
 local untrack = _vide.untrack
+-- Types
 -- Classes
-local Renders = TS.import(script, script.Parent, "renderManager").default
--- Helpers
+local Renders = TS.import(script, script.Parent, "renders").default
+-- Components
 local AppRegistry = TS.import(script, script.Parent, "appRegistry").AppRegistry
+-- Classes
 local Debugger = TS.import(script, script.Parent, "debugger").default
 local Logger = TS.import(script, script.Parent, "logger").default
+-- Helpers
+local bindAppSource = TS.import(script, script.Parent, "helpers", "bindAppSource").default
+local getAppSource = TS.import(script, script.Parent, "helpers", "getAppSource").default
+local hasAppSource = TS.import(script, script.Parent, "helpers", "hasAppSource").default
+local setAppSource = TS.import(script, script.Parent, "helpers", "setAppSource").default
+local getAppEntry = TS.import(script, script.Parent, "helpers", "getAppEntry").default
 local AppForge
 do
 	local super = Renders
@@ -37,76 +43,74 @@ do
 		self.debug = Debugger.new(function(level, msg, data, trace)
 			return self.logger:log(level, msg, data, trace)
 		end)
-		self.sources = {}
-		self.loaded = {}
 		-- ▼ ReadonlyMap.forEach ▼
-		local _callback = function(_, name)
-			return self:createSource(name)
+		local _callback = function(entryMap, name)
+			-- ▼ ReadonlyMap.forEach ▼
+			local _callback_1 = function(_, group)
+				self:createSource(name, group)
+			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
-	function AppForge:createSource(name)
-		local _name = name
-		local app = AppRegistry[_name]
-		if not app then
-			self.logger:log("ERROR", "App not registered while creating source", {
+	function AppForge:createSource(name, group)
+		if group == nil then
+			group = "None"
+		end
+		local entry = getAppEntry(self, name, group)
+		if not entry then
+			self.logger:log("ERROR", "App Entry not registered while creating source", {
 				name = name,
 			})
 			return nil
 		end
-		local _sources = self.sources
-		local _name_1 = name
-		if _sources[_name_1] ~= nil then
+		if hasAppSource(name, group) then
 			return nil
 		end
 		local _debug = self.debug
 		local _exp = name
 		local _object = {}
 		local _left = "default"
-		local _condition = app.visible
+		local _condition = entry.visible
 		if _condition == nil then
 			_condition = false
 		end
 		_object[_left] = _condition
 		_debug:logTag("state", _exp, "Creating visibility source", _object)
-		local _sources_1 = self.sources
 		local _exp_1 = name
-		local _condition_1 = app.visible
+		local _exp_2 = group
+		local _condition_1 = entry.visible
 		if _condition_1 == nil then
 			_condition_1 = false
 		end
-		local _arg1 = source(_condition_1)
-		_sources_1[_exp_1] = _arg1
+		setAppSource(_exp_1, _exp_2, _condition_1)
 	end
-	function AppForge:getSource(name)
-		local _sources = self.sources
-		local _name = name
-		if not (_sources[_name] ~= nil) then
-			self:createSource(name)
-		end
-		local _sources_1 = self.sources
-		local _name_1 = name
-		local src = _sources_1[_name_1]
+	function AppForge:getSource(name, group)
+		if group == nil then
+			group = "None"
+		end
+		if not hasAppSource(name, group) then
+			self:createSource(name, group)
+		end
+		local src = getAppSource(self, name, group)
 		if not src then
-			error(`AppForge invariant broken: missing visibility source for {name}`, 2)
+			self.logger:log("WARN", `Failed to get source for name {name} group {group}`)
 		end
 		return src
 	end
-	function AppForge:isLoaded(name)
-		local _loaded = self.loaded
-		local _name = name
-		return _loaded[_name] ~= nil
-	end
-	function AppForge:bind(name, value)
+	function AppForge:bind(name, group, value)
+		if group == nil then
+			group = "None"
+		end
 		if not RunService:IsRunning() then
 			self.debug:logTag("state", name, "Binding external visibility source")
-			local _sources = self.sources
-			local _name = name
-			local _value = value
-			_sources[_name] = _value
+			bindAppSource(name, group, value)
 			local prev
 			local log = function()
 				return self.debug:logTag("state", name, "Visibility changed", {
@@ -119,7 +123,7 @@ do
 				count += 1
 				prev = value()
 				untrack(function()
-					return self:checkRules(self, name)
+					return self:checkRules(self, name, group)
 				end)
 				if Vide.strict and count == 2 then
 					log()
@@ -135,23 +139,15 @@ do
 			})
 		end
 	end
-	function AppForge:set(name, value, rules)
+	function AppForge:set(name, group, value, rules)
+		if group == nil then
+			group = "None"
+		end
 		if rules == nil then
 			rules = true
 		end
-		local _sources = self.sources
-		local _name = name
-		local src = _sources[_name]
+		local src = getAppSource(self, name, group)
 		if not src then
-			self:createSource(name)
-			local _sources_1 = self.sources
-			local _name_1 = name
-			src = _sources_1[_name_1]
-		end
-		if not src then
-			self.logger:log("ERROR", "Failed to set visibility (missing source)", {
-				name = name,
-			})
 			return nil
 		end
 		local prev = src()
@@ -164,26 +160,39 @@ do
 			to = value,
 		})
 		if rules then
-			self:checkRules(self, name)
+			self:checkRules(self, name, group)
 		end
 	end
-	function AppForge:open(name, rules)
+	function AppForge:open(name, group, rules)
+		if group == nil then
+			group = "None"
+		end
 		if rules == nil then
 			rules = true
 		end
-		self:set(name, true, rules)
+		self:set(name, group, true, rules)
 	end
-	function AppForge:close(name, rules)
+	function AppForge:close(name, group, rules)
+		if group == nil then
+			group = "None"
+		end
 		if rules == nil then
 			rules = true
 		end
-		self:set(name, false, rules)
+		self:set(name, group, false, rules)
 	end
-	function AppForge:toggle(name, rules)
+	function AppForge:toggle(name, group, rules)
+		if group == nil then
+			group = "None"
+		end
 		if rules == nil then
 			rules = true
 		end
-		self:set(name, not self:getSource(name)(), rules)
+		local src = self:getSource(name, group)
+		if not src then
+			return self.logger:log("ERROR", `Failed to get Source for name {name} group {group}`)
+		end
+		self:set(name, group, not src(), rules)
 	end
 	function AppForge:story(props, target, config)
 		self.debug:logTag("lifecycle", "story", "Creating story mount")
@@ -226,14 +235,13 @@ do
 		_fn(_object)
 		return Container
 	end
-	function AppForge:mount(node, props, target)
+	function AppForge:mount(props, target, root)
 		self.debug:logTag("lifecycle", "mount", "Mounting AppForge")
-		self.innerMount = mount(function()
-			apply(node)({
-				[0] = self:initalize(props),
-			})
-			return node
-		end, target)
+		local _self = self
+		local _object = table.clone(props)
+		setmetatable(_object, nil)
+		_object.forge = self
+		_self:initalize(_object, target, root)
 		return self.innerMount
 	end
 end

package/out/renders.d.ts

@@ -0,0 +1,19 @@
+import Vide from "@rbxts/vide";
+import type Types from "./types";
+import Rules from "./ruleEngine";
+type Render = {
+    instance: Instance;
+    container: Instance;
+};
+export default class Renders extends Rules {
+    private __px;
+    protected Rendered: Map<string, Map<string, Render>>;
+    constructor();
+    Render: (props: Types.Props.Main) => Instance[];
+    private resolveGroupEntries;
+    private getGroupEntries;
+    private createRender;
+    private getChildren;
+    protected initalize(props: Types.Props.Main, target?: GuiObject | Instance, root?: GuiObject | Instance): Vide.Node;
+}
+export {};

package/out/renders.luau

@@ -0,0 +1,199 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+local _vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
+local Vide = _vide
+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
+-- 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.Rendered = {}
+		self.Render = function(props)
+			local _binding = props
+			local forge = _binding.forge
+			local renders = _binding.renders
+			local selected = {}
+			if not renders then
+				return {}
+			end
+			if renders.groups then
+				local _exp = renders.groups
+				-- ▼ ReadonlyArray.forEach ▼
+				local _callback = function(group)
+					local entries = self:resolveGroupEntries(forge, group, renders.names, renders.name)
+					for _, entry in entries do
+						table.insert(selected, entry)
+					end
+				end
+				for _k, _v in _exp do
+					_callback(_v, _k - 1, _exp)
+				end
+				-- ▲ ReadonlyArray.forEach ▲
+			end
+			local _value = renders.group
+			if _value ~= "" and _value then
+				local entries = self:resolveGroupEntries(forge, renders.group, renders.names, renders.name)
+				for _, entry in entries do
+					table.insert(selected, entry)
+				end
+			end
+			print(selected)
+			local rendered = {}
+			local _exp = self.Rendered
+			-- ▼ ReadonlyMap.forEach ▼
+			local _callback = function(entries)
+				-- ▼ ReadonlyMap.forEach ▼
+				local _callback_1 = function(entry)
+					local _container = entry.container
+					table.insert(rendered, _container)
+				end
+				for _k, _v in entries do
+					_callback_1(_v, _k, entries)
+				end
+				-- ▲ ReadonlyMap.forEach ▲
+			end
+			for _k, _v in _exp do
+				_callback(_v, _k, _exp)
+			end
+			-- ▲ ReadonlyMap.forEach ▲
+			return rendered
+		end
+	end
+	function Renders:resolveGroupEntries(forge, group, names, name)
+		local groupEntries = self:getGroupEntries(group)
+		local result = {}
+		if name ~= "" and name then
+			local _name = name
+			local _entry = groupEntries[_name]
+			if _entry ~= nil then
+				local _group = group
+				_entry = _entry[_group]
+			end
+			local entry = _entry
+			if not entry then
+				forge.logger:log("INFO", `Failed to find a Name of {name} in group {group}`)
+			else
+				table.insert(result, entry)
+			end
+		end
+		if names then
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback = function(n)
+				local _n = n
+				local _entry = groupEntries[_n]
+				if _entry ~= nil then
+					local _group = group
+					_entry = _entry[_group]
+				end
+				local entry = _entry
+				if not entry then
+					forge.logger:log("INFO", `Failed to find a Name of {n} in group {group}`)
+				else
+					table.insert(result, entry)
+				end
+			end
+			for _k, _v in names do
+				_callback(_v, _k - 1, names)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+		end
+		return result
+	end
+	function Renders:getGroupEntries(group)
+		local entries = {}
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(regGroupEntries, name)
+			-- ▼ ReadonlyMap.forEach ▼
+			local _callback_1 = function(_, regGroup)
+				if group ~= regGroup then
+					return nil
+				end
+				local _entries = entries
+				local _name = name
+				local _regGroupEntries = regGroupEntries
+				_entries[_name] = _regGroupEntries
+			end
+			for _k, _v in regGroupEntries do
+				_callback_1(_v, _k, regGroupEntries)
+			end
+			-- ▲ ReadonlyMap.forEach ▲
+		end
+		for _k, _v in AppRegistry do
+			_callback(_v, _k, AppRegistry)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		return entries
+	end
+	function Renders:createRender(forge, name, group)
+		local entry = getAppEntry(forge, name, group)
+		print(entry)
+		return nil
+	end
+	function Renders:getChildren()
+	end
+	function Renders:initalize(props, target, root)
+		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
+		if target then
+			mount(function()
+				local _result
+				if root then
+					_result = root
+				else
+					local _attributes = table.clone(props)
+					setmetatable(_attributes, nil)
+					_result = (Vide.jsx("screengui", {
+						Name = "App Tree",
+						ZIndexBehavior = "Sibling",
+						ResetOnSpawn = false,
+					}, Vide.jsx(self.Render, _attributes)))
+				end
+				return _result
+			end)
+		else
+			local _attributes = table.clone(props)
+			setmetatable(_attributes, nil)
+			return Vide.jsx(self.Render, _attributes)
+		end
+	end
+end
+return {
+	default = Renders,
+}

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

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

package/out/ruleEngine/check/exclusiveGroup.luau

@@ -0,0 +1,54 @@
+-- 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(forge, name, group)
+	if not entry then
+		forge.logger:log("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
+	forge.debug:logTag("rules", name, "Exclusive group activated", group)
+	-- ▼ 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.debug:logTag("rules", entryName, "Closing app due to exclusive group", {
+				closed = entryName,
+				entryGroup = entryGroup,
+			})
+			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 "../../mount";
+export default function ParentRule(forge: AppForge, name: AppNames, group: AppGroups): void;

package/out/ruleEngine/check/parent.luau

@@ -0,0 +1,38 @@
+-- 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(forge, 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 = forge
+	local _exp_1 = entry.rules.parent
+	local _condition = entry.rules.parentGroup
+	if _condition == nil then
+		_condition = "None"
+	end
+	local parentSource = getAppSource(_exp, _exp_1, _condition)
+	if parentSource and parentSource() == false then
+		local source = forge:getSource(name, group)
+		if not source then
+			return forge.logger:log("ERROR", `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

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

package/out/ruleEngine/init.luau

@@ -2,10 +2,12 @@
 local TS = _G[script]
 -- Types
 -- Components
-local AppRegistry = TS.import(script, script.Parent, "appRegistry").AppRegistry
 -- Rules
-local ExclusiveGroupRule = TS.import(script, script, "exclusiveGroup").default
-local ParentRule = TS.import(script, script, "parent").default
+local ExclusiveGroupRule = TS.import(script, script, "check", "exclusiveGroup").default
+local AnchorRule = TS.import(script, script, "render", "anchor").default
+local ParentRule = TS.import(script, script, "check", "parent").default
+-- Helpers
+local getAppEntry = TS.import(script, script.Parent, "helpers", "getAppEntry").default
 local Rules
 do
 	Rules = setmetatable({}, {
@@ -21,27 +23,28 @@ do
 	function Rules:constructor()
 		self.processing = {}
 	end
-	function Rules:renderRules(forge, name, props)
-		local _name = name
-		local appClass = AppRegistry[_name]
-		if not appClass then
-			error(`renderRules: App "{name}" not registered`, 2)
+	function Rules:renderRules(forge, name, group, props)
+		if group == nil then
+			group = "None"
+		end
+		local entry = getAppEntry(forge, name, group)
+		if not entry then
+			error(`renderRules: App Entry name "{name}" group "{group}" not registered`, 2)
 		end
-		local rules = appClass.rules
+		local rules = entry.rules
 		if not rules then
 			return nil
 		end
 		-- Parent Anchor
 		local _condition = rules.parent
 		if _condition ~= "" and _condition then
-			_condition = not rules.detach
+			_condition = not rules.anchor
 		end
 		if _condition ~= "" and _condition then
 			forge.debug:logTag("rules", name, "Applying parent anchor", {
 				parent = rules.parent,
 			})
-			-- TODO: will be a separate file under ruleEngine
-			-- forge.anchor(name, rules.parent, props);
+			AnchorRule(name, group, props)
 		end
 		-- Index
 		if rules.zIndex ~= nil then
@@ -50,7 +53,7 @@ do
 			-- forge.index(name, rules.zIndex);
 		end
 	end
-	function Rules:checkRules(forge, name)
+	function Rules:checkRules(forge, name, group)
 		local _processing = self.processing
 		local _name = name
 		if _processing[_name] ~= nil then
@@ -62,8 +65,8 @@ do
 		_processing_1[_name_1] = true
 		forge.debug:logTag("rules", name, "Evaluating rules")
 		TS.try(function()
-			ParentRule(name, forge)
-			ExclusiveGroupRule(name, forge)
+			ParentRule(forge, name, group)
+			ExclusiveGroupRule(forge, name, group)
 		end, nil, function()
 			local _processing_2 = self.processing
 			local _name_2 = name

package/out/ruleEngine/render/anchor.d.ts

@@ -0,0 +1,2 @@
+import type Types from "../../types";
+export default function anchor(name: AppNames, group: AppGroups | undefined, props: Types.Props.Main): void;

package/out/ruleEngine/render/anchor.luau

@@ -0,0 +1,11 @@
+-- Compiled with roblox-ts v3.0.0
+-- Types
+local function anchor(name, group, props)
+	if group == nil then
+		group = "None"
+	end
+	-- TODO: FIX THIS TO ANCHOR APP TO PARENT IF HAS ONE WARN IF DOESN'T
+end
+return {
+	default = anchor,
+}

package/out/types.d.ts

@@ -4,12 +4,12 @@ import type AppForge from "./mount";
 
 declare namespace Types {
 	namespace Props {
-		type Render =
-			| { name?: AppNames; names?: never; group?: never }
-			| { names?: AppNames[]; name?: never; group?: never }
-			| { group?: AppGroups[] | AppGroups; names?: AppNames[]; name?: never }
-			| { group?: AppGroups[] | AppGroups; name?: AppNames; names?: never }
-			| { group?: AppGroups[] | AppGroups; names?: never; name?: never };
+		type NameSelector = { name: AppNames; names?: never } | { names: AppNames[]; name?: never };
+		type GroupSelector =
+			| { group: AppGroups; groups?: never }
+			| { groups: AppGroups[]; group?: never };
+
+		export type Render = NameSelector & GroupSelector;
 
 		type Main = {
 			props: 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,15 +1,17 @@
 {
 	"name": "@rbxts/app-forge",
-	"version": "0.7.2-prototype.2",
+	"version": "0.7.2-prototype.21",
 	"description": "An App Manager for Vide",
 	"main": "out/init.lua",
 	"types": "out/index.d.ts",
 	"packageManager": "bun@1.3.1",
+
 	"scripts": {
 		"build": "rbxtsc",
 		"dev": "rbxtsc -w --type game --rojo test.project.json",
 		"login": "bunx npm login --auth-type=legacy"
 	},
+
 	"keywords": [
 		"roblox-ts",
 		"react",
@@ -17,6 +19,7 @@
 	],
 	"author": "loner1536",
 	"license": "MIT",
+
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/Loner1536/AppForge"
@@ -24,15 +27,18 @@
 	"bugs": {
 		"url": "https://github.com/Loner1536/AppForge/issues"
 	},
+
 	"files": [
 		"out",
 		"!**/*.tsbuildinfo",
 		"!**/*.spec.lua",
 		"!**/*.spec.d.ts"
 	],
+
 	"publishConfig": {
 		"access": "public"
 	},
+
 	"dependencies": {
 		"@rbxts/set-timeout": "^1.1.2",
 		"@rbxts/services": "^1.6.0",
@@ -43,6 +49,7 @@
 			"optional": true
 		}
 	},
+
 	"devDependencies": {
 		"@rbxts/compiler-types": "3.0.0-types.0",
 		"@biomejs/biome": "^2.3.7",

package/out/renderManager.d.ts

@@ -1,7 +0,0 @@
-import type Types from "./types";
-import Rules from "./ruleEngine";
-export default class Renders extends Rules {
-    private __px;
-    constructor();
-    protected initalize(props: Types.Props.Main): void;
-}

package/out/renderManager.luau

@@ -1,36 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
--- Packages
--- Types
--- Components
--- Hooks
--- 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.__px = false
-	end
-	function Renders:initalize(props)
-		if not self.__px then
-			self.__px = true
-		end
-		props.forge.logger:log("INFO", "Initalized Renders", props.renders)
-	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,
-}