@rbxts/app-forge 0.7.2-prototype.33 → 0.7.2-prototype.35

package/out/appRegistry.d.ts

@@ -1,6 +1,6 @@
 import Vide from "@rbxts/vide";
 import type Types from "./types";
-import type AppForge from "./mount";
+import type AppForge from "./forge";
 export declare const AppRegistry: Map<string, Map<string, Types.AppRegistry.Static>>;
 export declare const AppSources: Map<string, Map<string, Vide.Source<boolean>>>;
 /**

package/out/context.d.ts

@@ -1,6 +1,6 @@
 declare const Contexts: {
     readonly App: import("@rbxts/vide").Context<{
-        forge: import("./mount").default;
+        forge: import("./forge").default;
         px: typeof import("./hooks/usePx").px;
     } | undefined>;
 };

package/out/index.d.ts

@@ -1,5 +1,5 @@
 export { App, Args } from "./appRegistry";
-export { default as CreateForge } from "./mount";
+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

@@ -6,7 +6,7 @@ local _appRegistry = TS.import(script, script, "appRegistry")
 exports.App = _appRegistry.App
 exports.Args = _appRegistry.Args
 -- Creators
-exports.CreateForge = TS.import(script, script, "mount").default
+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

package/out/renders.d.ts

@@ -11,8 +11,8 @@ export default class Renders extends Rules {
     protected Loaded: Map<string, Map<string, Render>>;
     constructor();
     Load: (props: Types.Props.Main) => Instance[];
-    private resolveGroupEntries;
-    private getGroupEntries;
+    private collectEntries;
+    private expandWithChildren;
     private createInstance;
     protected initalize(props: Types.Props.Main, target?: GuiObject | Instance, root?: GuiObject | Instance): Vide.Node;
 }

package/out/renders.luau

@@ -33,177 +33,170 @@ do
 		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
+			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
-				-- ▼ 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)
+				local render = self:createInstance(props, name, group)
+				if not render then
+					return nil
 				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 ▲
+				local _result = render.entry.rules
+				if _result ~= nil then
+					_result = _result.parent
 				end
-				for _k, _v in _exp do
-					_callback_2(_v, _k, _exp)
+				if not (_result ~= "" and _result) then
+					local _container = render.container
+					table.insert(load, _container)
 				end
-				-- ▲ ReadonlyMap.forEach ▲
 			end
 			for _k, _v in toLoad do
-				_callback_1(_v, _k - 1, toLoad)
+				_callback(_v, _k - 1, toLoad)
 			end
 			-- ▲ ReadonlyArray.forEach ▲
-			print(load)
 			return load
 		end
 	end
-	function Renders:resolveGroupEntries(group, names, name)
-		local groupEntries = self:getGroupEntries(group)
+	function Renders:collectEntries(renders)
 		local result = {}
-		if name ~= "" and name then
-			local _name = name
-			local _entry = groupEntries[_name]
-			if _entry ~= nil then
-				local _group = group
-				_entry = _entry[_group]
+		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 entry = _entry
-			if entry then
-				table.insert(result, entry)
+			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
-		if names then
-			-- ▼ ReadonlyArray.forEach ▼
-			local _callback = function(n)
-				local _n = n
-				local _entry = groupEntries[_n]
-				if _entry ~= nil then
+		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
-					_entry = _entry[_group]
+					_condition_1 = not (groups[_group] ~= nil)
 				end
-				local entry = _entry
-				if entry then
-					table.insert(result, entry)
+				if _condition_1 then
+					return nil
 				end
+				local _entry = entry
+				table.insert(result, _entry)
 			end
-			for _k, _v in names do
-				_callback(_v, _k - 1, names)
+			for _k, _v in groupEntries do
+				_callback_1(_v, _k, groupEntries)
 			end
-			-- ▲ ReadonlyArray.forEach ▲
+			-- ▲ ReadonlyMap.forEach ▲
+		end
+		for _k, _v in AppRegistry do
+			_callback(_v, _k, AppRegistry)
 		end
+		-- ▲ ReadonlyMap.forEach ▲
 		return result
 	end
-	function Renders:getGroupEntries(group)
-		local entries = {}
+	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 = function(regGroupEntries, name)
+		local _callback_1 = function(groupEntries)
 			-- ▼ ReadonlyMap.forEach ▼
-			local _callback_1 = function(_, regGroup)
-				if group ~= regGroup then
-					return nil
+			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
-				local _entries = entries
-				local _name = name
-				local _regGroupEntries = regGroupEntries
-				_entries[_name] = _regGroupEntries
 			end
-			for _k, _v in regGroupEntries do
-				_callback_1(_v, _k, regGroupEntries)
+			for _k, _v in groupEntries do
+				_callback_2(_v, _k, groupEntries)
 			end
 			-- ▲ ReadonlyMap.forEach ▲
 		end
 		for _k, _v in AppRegistry do
-			_callback(_v, _k, AppRegistry)
+			_callback_1(_v, _k, AppRegistry)
 		end
 		-- ▲ ReadonlyMap.forEach ▲
-		return entries
+		return result
 	end
 	function Renders:createInstance(props, name, group)
 		local entry = getAppEntry(name, group)
@@ -245,21 +238,19 @@ do
 			Parent = parentContainer,
 		}, instance))
 		local newMap = {}
-		local _group = group
-		local _arg1 = {
+		local render = {
 			container = container,
 			instance = instance,
 			entry = entry,
 		}
-		newMap[_group] = _arg1
+		local _group = group
+		newMap[_group] = render
 		local _loaded = self.Loaded
 		local _name = name
 		_loaded[_name] = newMap
+		return render
 	end
 	function Renders:initalize(props, target, root)
-		local _attributes = table.clone(props)
-		setmetatable(_attributes, nil)
-		local renders = Vide.jsx(self.Load, _attributes)
 		if target then
 			mount(function()
 				if not self.__px then
@@ -278,6 +269,9 @@ do
 					usePx(_result, _result_1, _result_2)
 					self.__px = true
 				end
+				local _attributes = table.clone(props)
+				setmetatable(_attributes, nil)
+				local renders = Vide.jsx(self.Load, _attributes)
 				if root then
 					root.Name = "App Tree"
 					apply(root)({
@@ -308,7 +302,9 @@ do
 				usePx(_result, _result_1, _result_2)
 				self.__px = true
 			end
-			return renders
+			local _attributes = table.clone(props)
+			setmetatable(_attributes, nil)
+			return Vide.jsx(self.Load, _attributes)
 		end
 	end
 end

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

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

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

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

package/out/ruleEngine/index.d.ts

@@ -1,4 +1,4 @@
-import type AppForge from "../mount";
+import type AppForge from "../forge";
 import type Types from "../types";
 export default class Rules {
     protected processing: Set<string>;

package/out/types.d.ts

@@ -1,13 +1,18 @@
 // Types
 import type { Args } from "./appRegistry";
-import type AppForge from "./mount";
+import type AppForge from "./forge";
 
 declare namespace Types {
 	namespace Props {
-		type NameSelector = { name: AppNames; names?: never } | { names: AppNames[]; name?: never };
+		type NameSelector =
+			| { name: AppNames; names?: never }
+			| { names: AppNames[]; name?: never }
+			| { name?: undefined; names?: undefined };
+
 		type GroupSelector =
 			| { group: AppGroups; groups?: never }
-			| { groups: AppGroups[]; group?: never };
+			| { groups: AppGroups[]; group?: never }
+			| { group?: undefined; groups?: undefined };
 
 		export type Render = NameSelector & GroupSelector;
 

package/package.json

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