@rbxts/app-forge 0.7.2-prototype.3 → 0.7.2-prototype.30

package/out/renders.d.ts

@@ -1,8 +1,19 @@
+import Vide from "@rbxts/vide";
 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 render;
-    protected initalize(props: Types.Props.Main): void;
+    Load: (props: Types.Props.Main) => Instance[];
+    private resolveGroupEntries;
+    private getGroupEntries;
+    private createInstance;
+    protected initalize(props: Types.Props.Main, target?: GuiObject | Instance, root?: GuiObject | Instance): Vide.Node;
 }
+export {};

package/out/renders.luau

@@ -1,12 +1,18 @@
 -- 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
@@ -24,41 +30,285 @@ do
 	function Renders:constructor()
 		super.constructor(self)
 		self.__px = false
+		self.Loaded = {}
+		self.Load = function(props)
+			local _binding = props
+			local renders = _binding.renders
+			local toLoad = {}
+			if not renders then
+				return {}
+			end
+			if renders.groups then
+				local _exp = renders.groups
+				-- ▼ ReadonlyArray.forEach ▼
+				local _callback = function(group)
+					local entries = self:resolveGroupEntries(group, renders.names, renders.name)
+					for _, entry in entries do
+						table.insert(toLoad, 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(renders.group, renders.names, renders.name)
+				for _, entry in entries do
+					table.insert(toLoad, entry)
+				end
+			end
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback = function(entry)
+				local name = tostring(entry.constructor)
+				local group = entry.group
+				-- ▼ ReadonlyMap.forEach ▼
+				local _callback_1 = function(groupEntries)
+					-- ▼ ReadonlyMap.forEach ▼
+					local _callback_2 = function(childEntry)
+						local _result = childEntry.rules
+						if _result ~= nil then
+							_result = _result.parent
+						end
+						local _condition = _result ~= name
+						if not _condition then
+							local _result_1 = childEntry.rules
+							if _result_1 ~= nil then
+								_result_1 = _result_1.parentGroup
+							end
+							_condition = _result_1 ~= group
+						end
+						if _condition then
+							return nil
+						end
+						local _childEntry = childEntry
+						table.insert(toLoad, _childEntry)
+					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 ▲
+			end
+			for _k, _v in toLoad do
+				_callback(_v, _k - 1, toLoad)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+			local load = {}
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback_1 = function(entry)
+				local name = tostring(entry.constructor)
+				local group = entry.group
+				self:createInstance(props, name, group)
+				local _exp = self.Loaded
+				-- ▼ ReadonlyMap.forEach ▼
+				local _callback_2 = function(renderGroup, loadedName)
+					if name ~= loadedName then
+						return nil
+					end
+					-- ▼ ReadonlyMap.forEach ▼
+					local _callback_3 = function(render, group)
+						if group ~= group 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 renderGroup do
+						_callback_3(_v, _k, renderGroup)
+					end
+					-- ▲ ReadonlyMap.forEach ▲
+				end
+				for _k, _v in _exp do
+					_callback_2(_v, _k, _exp)
+				end
+				-- ▲ ReadonlyMap.forEach ▲
+			end
+			for _k, _v in toLoad do
+				_callback_1(_v, _k - 1, toLoad)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+			print(load)
+			return load
+		end
 	end
-	function Renders:render(name, names, group)
-		print(name, names, group)
-	end
-	function Renders:initalize(props)
-		if not self.__px then
-			local _result = props.config
-			if _result ~= nil then
-				_result = _result.px.target
+	function Renders:resolveGroupEntries(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 _result_1 = props.config
-			if _result_1 ~= nil then
-				_result_1 = _result_1.px.resolution
+			local entry = _entry
+			if entry then
+				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 entry then
+					table.insert(result, entry)
+				end
 			end
-			local _result_2 = props.config
-			if _result_2 ~= nil then
-				_result_2 = _result_2.px.minScale
+			for _k, _v in names do
+				_callback(_v, _k - 1, names)
 			end
-			usePx(_result, _result_1, _result_2)
-			self.__px = true
+			-- ▲ ReadonlyArray.forEach ▲
 		end
-		local _self = self
-		local _result = props.renders
+		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:createInstance(props, name, group)
+		local entry = getAppEntry(name, group)
+		if not entry then
+			return nil
+		end
+		local parentContainer
+		local _result = entry.rules
 		if _result ~= nil then
-			_result = _result.name
+			_result = _result.parent
 		end
-		local _result_1 = props.renders
-		if _result_1 ~= nil then
-			_result_1 = _result_1.names
+		if _result ~= "" and _result then
+			local _value = entry.rules.parent
+			if _value ~= "" and _value 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
 		end
-		local _result_2 = props.renders
-		if _result_2 ~= nil then
-			_result_2 = _result_2.group
+		local instance = entry.constructor.new(props, name, group):render()
+		instance.Name = "Render"
+		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,
+		}, instance))
+		local newMap = {}
+		local _group = group
+		local _arg1 = {
+			container = container,
+			instance = instance,
+			entry = entry,
+		}
+		newMap[_group] = _arg1
+		local _loaded = self.Loaded
+		local _name = name
+		_loaded[_name] = newMap
+	end
+	function Renders:initalize(props, target, root)
+		if target then
+			mount(function()
+				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
+				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.Load, _attributes)))
+				end
+				return _result
+			end)
+		else
+			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
+			local _attributes = table.clone(props)
+			setmetatable(_attributes, nil)
+			return Vide.jsx(self.Load, _attributes)
 		end
-		_self:render(_result, _result_1, _result_2)
 	end
 end
 return {

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

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

package/out/ruleEngine/check/exclusiveGroup.luau

@@ -3,46 +3,41 @@ local TS = _G[script]
 -- Types
 -- Components
 local AppRegistry = TS.import(script, script.Parent.Parent.Parent, "appRegistry").AppRegistry
-local function ExclusiveGroupRule(name, forge)
-	local _name = name
-	local entryApp = AppRegistry[_name]
-	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
+-- 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)()
+	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(app, name)
-		if name == name then
-			return nil
-		end
-		local _result = app.rules
-		if _result ~= nil then
-			_result = _result.exclusiveGroup
-		end
-		if _result ~= group then
-			return nil
+	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
-		local visible = forge:getSource(name)()
-		if not visible then
-			return nil
+		for _k, _v in entryMap do
+			_callback_1(_v, _k, entryMap)
 		end
-		forge.debug:logTag("rules", name, "Closing app due to exclusive group", {
-			closed = name,
-			group = group,
-		})
-		forge:close(name, false)
+		-- ▲ ReadonlyMap.forEach ▲
 	end
 	for _k, _v in AppRegistry do
 		_callback(_v, _k, AppRegistry)

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

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

package/out/ruleEngine/check/parent.luau

@@ -1,11 +1,11 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
 -- Types
--- Components
-local AppRegistry = TS.import(script, script.Parent.Parent.Parent, "appRegistry").AppRegistry
-local function ParentRule(name, forge)
-	local _name = name
-	local entry = AppRegistry[_name]
+-- 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
@@ -16,17 +16,17 @@ local function ParentRule(name, forge)
 	if not (_result ~= "" and _result) then
 		return nil
 	end
-	local _forge = forge
-	local _result_1 = entry
-	if _result_1 ~= nil then
-		_result_1 = _result_1.rules
-		if _result_1 ~= nil then
-			_result_1 = _result_1.parent
-		end
+	local _exp = entry.rules.parent
+	local _condition = entry.rules.parentGroup
+	if _condition == nil then
+		_condition = "None"
 	end
-	local parentSource = _forge:getSource(_result_1)
-	if not parentSource() then
-		local source = forge:getSource(name)
+	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

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(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,11 +2,12 @@
 local TS = _G[script]
 -- Types
 -- Components
-local AppRegistry = TS.import(script, script.Parent, "appRegistry").AppRegistry
 -- Rules
 local ExclusiveGroupRule = TS.import(script, script, "check", "exclusiveGroup").default
-local ParentRule = TS.import(script, script, "check", "parent").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({}, {
@@ -22,13 +23,15 @@ 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(name, group, props)
+		if group == nil then
+			group = "None"
+		end
+		local entry = getAppEntry(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
@@ -38,32 +41,26 @@ do
 			_condition = not rules.anchor
 		end
 		if _condition ~= "" and _condition then
-			forge.debug:logTag("rules", name, "Applying parent anchor", {
-				parent = rules.parent,
-			})
-			AnchorRule(name, props)
+			AnchorRule(name, group, props)
 		end
 		-- Index
 		if rules.zIndex ~= nil then
-			forge.debug:logTag("rules", name, "Applying ZIndex", rules.zIndex)
 			-- TODO: will be a separate file under ruleEngine
 			-- 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
-			forge.debug:logTag("rules", name, "Skipped rule processing (cycle detected)")
 			return nil
 		end
 		local _processing_1 = self.processing
 		local _name_1 = name
 		_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

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

package/out/ruleEngine/render/anchor.luau

@@ -1,37 +1,10 @@
 -- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
 -- Types
--- Components
-local _appRegistry = TS.import(script, script.Parent.Parent.Parent, "appRegistry")
-local AppRegistry = _appRegistry.AppRegistry
-local AppsLoaded = _appRegistry.AppsLoaded
-local function anchor(name, props)
-	local _binding = props
-	local forge = _binding.forge
-	local _name = name
-	local app = AppRegistry[_name]
-	local _result = app
-	if _result ~= nil then
-		_result = _result.renderGroup
+local function anchor(name, group, props)
+	if group == nil then
+		group = "None"
 	end
-	local _condition = _result
-	if _condition == nil then
-		_condition = "None"
-	end
-	local _arg0 = `{_condition}-{name}`
-	local loaded = AppsLoaded[_arg0]
-	local _result_1 = app
-	if _result_1 ~= nil then
-		_result_1 = _result_1.rules
-		if _result_1 ~= nil then
-			_result_1 = _result_1.parent
-		end
-	end
-	local parentApp = AppRegistry[_result_1]
-	if not parentApp then
-		forge.debug:logTag("rules", name, `Has no Parent to Anchor to, Remove the Anchor For {name}`)
-	end
-	print(`App: {app} \n Loaded: {loaded} \n parentApp: {parentApp}`)
+	-- 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,11 +58,15 @@ declare namespace Types {
 	namespace Rules {
 		type WithParent<P> = {
 			parent: P;
+
+			parentGroup?: AppGroups;
 			anchor?: boolean;
 		};
 
 		type WithoutParent = {
 			parent?: never;
+
+			parentGroup?: never;
 			anchor?: never;
 		};