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

package/out/mount.d.ts

@@ -15,23 +15,19 @@ export default class AppForge extends Renders {
     protected sources: Map<string, Vide.Source<boolean>>;
     protected loaded: Map<string, Loaded>;
     protected innerMount?: Destructor;
-    protected __px: boolean;
     constructor();
     protected createSource(name: AppNames): void;
     getSource(name: AppNames): Vide.Source<boolean>;
     isLoaded(name: AppNames): boolean;
     bind(name: AppNames, value: Vide.Source<boolean>): void;
-    anchor(name: AppNames, anchorName: AppNames, props: Types.Props.Main): void;
-    index(name: AppNames, index: number): 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;
-    story(props: AppProps, target: GuiObject, conf?: {
+    story(props: AppProps, target: GuiObject, config?: {
         render?: Types.Props.Render;
         minScale?: number;
     }): Frame;
     mount(node: Vide.Node, props: Types.Props.Main, target: Instance): Destructor;
-    unMount(): void;
 }
 export {};

package/out/mount.luau

@@ -39,7 +39,6 @@ do
 		end)
 		self.sources = {}
 		self.loaded = {}
-		self.__px = false
 		-- ▼ ReadonlyMap.forEach ▼
 		local _callback = function(_, name)
 			return self:createSource(name)
@@ -136,81 +135,6 @@ do
 			})
 		end
 	end
-	function AppForge:anchor(name, anchorName, props)
-		if name == anchorName then
-			self.logger:log("ERROR", "Attempted to anchor app to itself", {
-				name = name,
-			})
-			return nil
-		end
-		local _anchorName = anchorName
-		local anchorApp = AppRegistry[_anchorName]
-		if not anchorApp then
-			self.logger:log("ERROR", "Anchor parent not registered", {
-				child = name,
-				parent = anchorName,
-			})
-			return nil
-		end
-		local _loaded = self.loaded
-		local _name = name
-		local _render = _loaded[_name]
-		if _render ~= nil then
-			_render = _render.render
-		end
-		local render = _render
-		if not render then
-			self.debug:logTag("rules", name, "Anchor skipped (child not rendered yet)", {
-				parent = anchorName,
-			})
-			return nil
-		end
-		self.debug:logTag("rules", name, "Anchoring to parent", {
-			parent = anchorName,
-		})
-		local anchor = anchorApp.constructor.new(props, anchorName):render()
-		for _, child in anchor:GetDescendants() do
-			child:Destroy()
-		end
-		apply(anchor)({
-			Name = "Anchor",
-			BackgroundTransparency = 1,
-			[0] = render,
-		})
-		local _loaded_1 = self.loaded
-		local _name_1 = name
-		local prev = _loaded_1[_name_1]
-		if not prev then
-			error(`AppForge invariant broken: missing loaded app for {name}`, 2)
-		end
-		apply(prev.container)({
-			[0] = anchor,
-		})
-		local _loaded_2 = self.loaded
-		local _exp = name
-		local _object = table.clone(prev)
-		setmetatable(_object, nil)
-		_object.anchor = anchor
-		_loaded_2[_exp] = _object
-	end
-	function AppForge:index(name, index)
-		local _loaded = self.loaded
-		local _name = name
-		local loaded = _loaded[_name]
-		if not loaded then
-			self.logger:log("WARN", "ZIndex skipped (app not loaded)", {
-				name = name,
-				index = index,
-			})
-			return nil
-		end
-		self.debug:logTag("rules", name, "Applying ZIndex", {
-			index = index,
-		})
-		apply(loaded.container)({
-			ZIndex = index,
-		})
-	end
 	function AppForge:set(name, value, rules)
 		if rules == nil then
 			rules = true
@@ -261,7 +185,7 @@ do
 		end
 		self:set(name, not self:getSource(name)(), rules)
 	end
-	function AppForge:story(props, target, conf)
+	function AppForge:story(props, target, config)
 		self.debug:logTag("lifecycle", "story", "Creating story mount")
 		local Container = create("Frame")({
 			Name = "Story Container",
@@ -278,8 +202,8 @@ do
 			props = props,
 			forge = self,
 		}
-		local _left_1 = "render"
-		local _result = conf
+		local _left_1 = "renders"
+		local _result = config
 		if _result ~= nil then
 			_result = _result.render
 		end
@@ -291,14 +215,14 @@ do
 			target = target,
 		}
 		local _left_4 = "minScale"
-		local _result_1 = conf
+		local _result_1 = config
 		if _result_1 ~= nil then
 			_result_1 = _result_1.minScale
 		end
 		_object_3[_left_4] = _result_1
 		_object_2[_left_3] = _object_3
 		_object_1[_left_2] = _object_2
-		_object[_left] = _self:renderMount(_object_1)
+		_object[_left] = _self:initalize(_object_1)
 		_fn(_object)
 		return Container
 	end
@@ -306,19 +230,12 @@ do
 		self.debug:logTag("lifecycle", "mount", "Mounting AppForge")
 		self.innerMount = mount(function()
 			apply(node)({
-				[0] = self:renderMount(props),
+				[0] = self:initalize(props),
 			})
 			return node
 		end, target)
 		return self.innerMount
 	end
-	function AppForge:unMount()
-		self.debug:logTag("lifecycle", "unmount", "Unmounting AppForge")
-		local _result = self.innerMount
-		if _result ~= nil then
-			_result()
-		end
-	end
 end
 return {
 	default = AppForge,

package/out/renderManager.d.ts

@@ -1,32 +1,7 @@
-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;
-    }>;
+    private __px;
     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[];
+    protected initalize(props: Types.Props.Main): void;
 }

package/out/renderManager.luau

@@ -1,15 +1,9 @@
 -- 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
@@ -28,297 +22,13 @@ do
 	end
 	function Renders:constructor()
 		super.constructor(self)
-		self.anchored = {}
+		self.__px = false
 	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")
+	function Renders:initalize(props)
+		if not self.__px then
+			self.__px = true
 		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)
+		props.forge.logger:log("INFO", "Initalized Renders", props.renders)
 	end
 end
 return {

package/out/ruleEngine/init.luau

@@ -40,12 +40,14 @@ do
 			forge.debug:logTag("rules", name, "Applying parent anchor", {
 				parent = rules.parent,
 			})
-			forge:anchor(name, rules.parent, props)
+			-- TODO: will be a separate file under ruleEngine
+			-- forge.anchor(name, rules.parent, props);
 		end
 		-- Index
 		if rules.zIndex ~= nil then
 			forge.debug:logTag("rules", name, "Applying ZIndex", rules.zIndex)
-			forge:index(name, rules.zIndex)
+			-- TODO: will be a separate file under ruleEngine
+			-- forge.index(name, rules.zIndex);
 		end
 	end
 	function Rules:checkRules(forge, name)

package/out/types.d.ts

@@ -21,7 +21,7 @@ declare namespace Types {
 					minScale?: number;
 				};
 			};
-			render?: Render;
+			renders?: Render;
 		};
 
 		type Class = AppProps & {

package/package.json

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