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

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,77 +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 = {}
-		self.__px = false
 		-- ▼ 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)
+	function AppForge:getSource(name, group)
+		if group == nil then
+			group = "None"
+		end
+		if not hasAppSource(name, group) then
+			self:createSource(name, group)
 		end
-		local _sources_1 = self.sources
-		local _name_1 = name
-		local src = _sources_1[_name_1]
+		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", {
@@ -120,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()
@@ -136,98 +139,15 @@ 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
+	function AppForge:set(name, group, value, rules)
+		if group == nil then
+			group = "None"
 		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
 		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()
@@ -240,28 +160,41 @@ 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, conf)
+	function AppForge:story(props, target, config)
 		self.debug:logTag("lifecycle", "story", "Creating story mount")
 		local Container = create("Frame")({
 			Name = "Story Container",
@@ -278,8 +211,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,34 +224,26 @@ 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
-	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:renderMount(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
-	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/renders.d.ts

@@ -0,0 +1,9 @@
+import Vide from "@rbxts/vide";
+import type Types from "./types";
+import Rules from "./ruleEngine";
+export default class Renders extends Rules {
+    private __px;
+    constructor();
+    private Render;
+    protected initalize(props: Types.Props.Main, target?: GuiObject | Instance, root?: GuiObject | Instance): Vide.Node;
+}

package/out/renders.luau

@@ -0,0 +1,76 @@
+-- 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")
+local AppRegistry = _appRegistry.AppRegistry
+local AppSources = _appRegistry.AppSources
+-- 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.__px = false
+	end
+	function Renders:Render(_param)
+		local props = _param.props
+		print(props)
+		print(AppRegistry)
+		print(AppSources)
+	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()
+				return if root then root else (Vide.jsx("screengui", {
+					Name = "App Tree",
+					ZIndexBehavior = "Sibling",
+					ResetOnSpawn = false,
+				}, Vide.jsx(self.Render, {
+					props = props,
+				})))
+			end)
+		else
+			return Vide.jsx(self.Render, {
+				props = props,
+			})
+		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)()
+	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,34 +23,37 @@ 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,
 			})
-			forge:anchor(name, rules.parent, props)
+			AnchorRule(name, group, 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)
+	function Rules:checkRules(forge, name, group)
 		local _processing = self.processing
 		local _name = name
 		if _processing[_name] ~= nil then
@@ -60,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,
+}