@rbxts/app-forge 0.5.9 → 0.6.0-alpha.0

package/out/index.d.ts

@@ -1,19 +1,2 @@
-import Vide from "@rbxts/vide";
-import type Types from "./types";
-import { Args, App } from "./decorator";
-export default class AppForge {
-    sources: Map<string, Vide.Source<boolean>>;
-    loaded: Map<string, Vide.Node>;
-    private rulesManager;
-    getSource(name: AppNames[number]): Vide.Source<boolean>;
-    set(name: AppNames[number], value: Vide.Source<boolean> | boolean): void;
-    open(name: AppNames[number]): void;
-    close(name: AppNames[number]): void;
-    toggle(name: AppNames[number]): void;
-    renderApp(props: Types.NameProps & Types.MainProps): Vide.Node;
-    renderApps(props: Types.NameProps & Types.MainProps): Vide.Node[];
-    renderAll(props: Types.MainProps): Vide.Node[];
-}
-export { App, Args };
-export { Render } from "./helpers";
-export type { NameProps, MainProps, ClassProps } from "./types";
+export * as ReactForge from "./react";
+export * as VideForge from "./vide";

package/out/init.luau

@@ -1,120 +1,6 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
 local exports = {}
--- Services
--- Packages
-local Vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
--- Types
--- Components
-local _decorator = TS.import(script, script, "decorator")
-local AppRegistry = _decorator.AppRegistry
-local Args = _decorator.Args
-local App = _decorator.App
-local AppContainer = TS.import(script, script, "container").default
--- Classes
-local RulesManager = TS.import(script, script, "rules").default
-local AppForge
-do
-	AppForge = setmetatable({}, {
-		__tostring = function()
-			return "AppForge"
-		end,
-	})
-	AppForge.__index = AppForge
-	function AppForge.new(...)
-		local self = setmetatable({}, AppForge)
-		return self:constructor(...) or self
-	end
-	function AppForge:constructor()
-		self.sources = {}
-		self.loaded = {}
-		self.rulesManager = RulesManager.new(self)
-	end
-	function AppForge:getSource(name)
-		local _sources = self.sources
-		local _name = name
-		if not (_sources[_name] ~= nil) then
-			error(`App "{name}" has no source`)
-		end
-		local _sources_1 = self.sources
-		local _name_1 = name
-		return _sources_1[_name_1]
-	end
-	function AppForge:set(name, value)
-		if not self.rulesManager:applyRules(name, value) then
-			return nil
-		end
-		local _value = value
-		if type(_value) == "function" then
-			local _sources = self.sources
-			local _name = name
-			local _value_1 = value
-			_sources[_name] = _value_1
-		else
-			local _sources = self.sources
-			local _name = name
-			local source = _sources[_name]
-			if not source then
-				error(`App "{name}" has no source`)
-			end
-			source(value)
-		end
-	end
-	function AppForge:open(name)
-		self:set(name, true)
-	end
-	function AppForge:close(name)
-		self:set(name, false)
-	end
-	function AppForge:toggle(name)
-		self:set(name, not self:getSource(name)())
-	end
-	function AppForge:renderApp(props)
-		local _attributes = table.clone(props)
-		setmetatable(_attributes, nil)
-		return Vide.jsx(AppContainer, _attributes)
-	end
-	function AppForge:renderApps(props)
-		local names = props.names
-		if names then
-			-- ▼ ReadonlyArray.map ▼
-			local _newValue = table.create(#names)
-			local _callback = function(name)
-				local _self = self
-				local _object = table.clone(props)
-				setmetatable(_object, nil)
-				_object.name = name
-				_object.names = nil
-				return _self:renderApp(_object)
-			end
-			for _k, _v in names do
-				_newValue[_k] = _callback(_v, _k - 1, names)
-			end
-			-- ▲ ReadonlyArray.map ▲
-			return _newValue
-		end
-		error("No app names provided to renderApps")
-	end
-	function AppForge:renderAll(props)
-		local names = {}
-		-- ▼ ReadonlyMap.forEach ▼
-		local _callback = function(_, name)
-			local _name = name
-			table.insert(names, _name)
-		end
-		for _k, _v in AppRegistry do
-			_callback(_v, _k, AppRegistry)
-		end
-		-- ▲ ReadonlyMap.forEach ▲
-		local _self = self
-		local _object = table.clone(props)
-		setmetatable(_object, nil)
-		_object.names = names
-		return _self:renderApps(_object)
-	end
-end
-exports.Render = TS.import(script, script, "helpers").Render
-exports.default = AppForge
-exports.App = App
-exports.Args = Args
+exports.ReactForge = TS.import(script, script, "react")
+exports.VideForge = TS.import(script, script, "vide")
 return exports

package/out/react/container.d.ts

@@ -0,0 +1,11 @@
+import React from "@rbxts/react";
+import type Types from "./types";
+export declare function AppContainer(props: Types.NameProps & Types.MainProps): React.ReactElement<{
+    key: string;
+    ZIndexBehavior: Enum.ZIndexBehavior.Sibling;
+    ResetOnSpawn: boolean;
+}, string | React.JSXElementConstructor<any>> | React.ReactElement<{
+    key: string;
+    BackgroundTransparency: number;
+    Size: UDim2;
+}, string | React.JSXElementConstructor<any>>;

package/out/react/container.luau

@@ -0,0 +1,80 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Services
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+-- Packages
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local useBinding = _react.useBinding
+local createElement = _react.createElement
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent, "decorator").AppRegistry
+local function createBinding(name, manager)
+	local _name = name
+	local app = AppRegistry[_name]
+	if not app then
+		error(`App "{name}" not registered`)
+	end
+	local _condition = app.visible
+	if _condition == nil then
+		_condition = false
+	end
+	local binding = { useBinding(_condition) }
+	local _binds = manager.binds
+	local _name_1 = name
+	_binds[_name_1] = binding
+	return unpack(binding)
+end
+local function createInstance(props)
+	local _binding = props
+	local name = _binding.name
+	local forge = _binding.forge
+	if not (name ~= "" and name) then
+		error("App name is required to create instance")
+	end
+	local appClass = AppRegistry[name]
+	if not appClass then
+		error(`App "{name}" not registered`)
+	end
+	if not (forge.loaded[name] ~= nil) then
+		local instance = appClass.constructor.new(props)
+		local Render = function()
+			return instance:render()
+		end
+		local _loaded = forge.loaded
+		local _arg1 = createElement(Render, {
+			key = "Main",
+		})
+		_loaded[name] = _arg1
+	end
+	return forge.loaded[name]
+end
+local function AppContainer(props)
+	local _binding = props
+	local name = _binding.name
+	local forge = _binding.forge
+	if not (name ~= "" and name) then
+		error("App name is required in AppContainer")
+	end
+	createBinding(name, forge)
+	local element = createInstance(props)
+	if not element then
+		error(`Failed to create instance for app "{name}"`)
+	end
+	if RunService:IsRunning() then
+		return createElement("ScreenGui", {
+			key = name,
+			ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
+			ResetOnSpawn = false,
+		}, element)
+	else
+		return createElement("Frame", {
+			key = name,
+			BackgroundTransparency = 1,
+			Size = UDim2.fromScale(1, 1),
+		}, element)
+	end
+end
+return {
+	AppContainer = AppContainer,
+}

package/out/react/decorator.d.ts

@@ -0,0 +1,14 @@
+import React from "@rbxts/react";
+import type Types from "./types";
+import type AppForge from ".";
+export declare const AppRegistry: Map<string, Types.AppRegistry>;
+export declare function App(props: Types.AppRegistryProps): <T extends new (props: Types.MainProps) => Args>(constructor: T) => T;
+export declare abstract class Args {
+    readonly forge: AppForge;
+    readonly props: Types.ClassProps;
+    readonly name: AppNames[number];
+    readonly bind: React.Binding<boolean>;
+    readonly state: Boolean;
+    constructor(props: Types.NameProps & Types.MainProps);
+    abstract render(): JSX.Element;
+}

package/out/react/decorator.luau

@@ -0,0 +1,55 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Services
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+-- Packages
+local usePx = TS.import(script, TS.getModule(script, "@rbxts", "loners-pretty-react-hooks").out).usePx
+-- Types
+local AppRegistry = {}
+local function App(props)
+	return function(constructor)
+		local _name = props.name
+		if AppRegistry[_name] ~= nil then
+			error(`Duplicate registered App name "{props.name}"`)
+		end
+		local _name_1 = props.name
+		local _arg1 = {
+			constructor = constructor,
+			visible = props.visible,
+			rules = props.rules,
+		}
+		AppRegistry[_name_1] = _arg1
+		return constructor
+	end
+end
+local Args
+do
+	Args = {}
+	function Args:constructor(props)
+		local _binding = props
+		local target = _binding.target
+		local forge = _binding.forge
+		local name = _binding.name
+		if not (name ~= "" and name) then
+			error("App name is required in Args constructor")
+		end
+		local bind = forge:getBind(name)
+		if not bind and RunService:IsRunning() then
+			error("FAILED TO GET BIND FOR APP!")
+		end
+		local px = usePx(target)
+		self.forge = forge
+		local _object = table.clone(props.props)
+		setmetatable(_object, nil)
+		_object.px = px
+		self.props = _object
+		self.name = name
+		self.bind = bind
+		self.state = if self.bind then self.bind:getValue() else nil
+	end
+end
+return {
+	App = App,
+	AppRegistry = AppRegistry,
+	Args = Args,
+}

package/out/react/helpers.d.ts

@@ -0,0 +1,18 @@
+import Types from "./types";
+export declare function Render(props: Types.NameProps & Types.MainProps): import("@rbxts/react").ReactElement<{
+    key: string;
+    ZIndexBehavior: Enum.ZIndexBehavior.Sibling;
+    ResetOnSpawn: boolean;
+}, string | import("@rbxts/react").JSXElementConstructor<any>> | import("@rbxts/react").ReactElement<{
+    key: string;
+    BackgroundTransparency: number;
+    Size: UDim2;
+}, string | import("@rbxts/react").JSXElementConstructor<any>> | (import("@rbxts/react").ReactElement<{
+    key: string;
+    ZIndexBehavior: Enum.ZIndexBehavior.Sibling;
+    ResetOnSpawn: boolean;
+}, string | import("@rbxts/react").JSXElementConstructor<any>> | import("@rbxts/react").ReactElement<{
+    key: string;
+    BackgroundTransparency: number;
+    Size: UDim2;
+}, string | import("@rbxts/react").JSXElementConstructor<any>>)[];

package/out/react/helpers.luau

@@ -0,0 +1,16 @@
+-- Compiled with roblox-ts v3.0.0
+-- Types
+local function Render(props)
+	local names = props.names
+	local name = props.name
+	local forge = props.forge
+	if name ~= "" and name then
+		return forge:renderApp(props)
+	elseif names then
+		return forge:renderApps(props)
+	end
+	return forge:renderAll(props)
+end
+return {
+	Render = Render,
+}

package/out/react/index.d.ts

@@ -0,0 +1,44 @@
+import React from "@rbxts/react";
+import type Types from "./types";
+import { Args, App } from "./decorator";
+export default class AppForge {
+    binds: Map<string, [React.Binding<boolean>, (T: boolean) => void]>;
+    loaded: Map<string, React.Element<any, string | React.JSXElementConstructor<any>>>;
+    private rulesManager;
+    getBind(name: AppNames[number]): React.Binding<boolean> | undefined;
+    getState(name: AppNames[number]): boolean | undefined;
+    set(name: AppNames[number], value: boolean): void;
+    open(name: AppNames[number]): void;
+    close(name: AppNames[number]): void;
+    toggle(name: AppNames[number]): void;
+    renderApp(props: Types.NameProps & Types.MainProps): React.ReactElement<{
+        key: string;
+        ZIndexBehavior: Enum.ZIndexBehavior.Sibling;
+        ResetOnSpawn: boolean;
+    }, string | React.JSXElementConstructor<any>> | React.ReactElement<{
+        key: string;
+        BackgroundTransparency: number;
+        Size: UDim2;
+    }, string | React.JSXElementConstructor<any>>;
+    renderApps(props: Types.NameProps & Types.MainProps): (React.ReactElement<{
+        key: string;
+        ZIndexBehavior: Enum.ZIndexBehavior.Sibling;
+        ResetOnSpawn: boolean;
+    }, string | React.JSXElementConstructor<any>> | React.ReactElement<{
+        key: string;
+        BackgroundTransparency: number;
+        Size: UDim2;
+    }, string | React.JSXElementConstructor<any>>)[];
+    renderAll(props: Types.MainProps): (React.ReactElement<{
+        key: string;
+        ZIndexBehavior: Enum.ZIndexBehavior.Sibling;
+        ResetOnSpawn: boolean;
+    }, string | React.JSXElementConstructor<any>> | React.ReactElement<{
+        key: string;
+        BackgroundTransparency: number;
+        Size: UDim2;
+    }, string | React.JSXElementConstructor<any>>)[];
+}
+export { App, Args };
+export { Render } from "./helpers";
+export type { MainProps, NameProps, Props } from "./types";

package/out/react/init.luau

@@ -0,0 +1,127 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+-- Packages
+-- Types
+-- Components
+local _decorator = TS.import(script, script, "decorator")
+local AppRegistry = _decorator.AppRegistry
+local Args = _decorator.Args
+local App = _decorator.App
+local AppContainer = TS.import(script, script, "container").AppContainer
+-- Classes
+local RulesManager = TS.import(script, script, "rules").default
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local AppForge
+do
+	AppForge = setmetatable({}, {
+		__tostring = function()
+			return "AppForge"
+		end,
+	})
+	AppForge.__index = AppForge
+	function AppForge.new(...)
+		local self = setmetatable({}, AppForge)
+		return self:constructor(...) or self
+	end
+	function AppForge:constructor()
+		self.binds = {}
+		self.loaded = {}
+		self.rulesManager = RulesManager.new(self)
+	end
+	function AppForge:getBind(name)
+		local _condition = not RunService:IsRunning()
+		if _condition then
+			local _binds = self.binds
+			local _name = name
+			_condition = not (_binds[_name] ~= nil)
+		end
+		if _condition then
+			return nil
+		end
+		local _binds = self.binds
+		local _name = name
+		if not (_binds[_name] ~= nil) then
+			error(`App "{name}" has no binding`)
+		end
+		local _binds_1 = self.binds
+		local _name_1 = name
+		return _binds_1[_name_1][1]
+	end
+	function AppForge:getState(name)
+		local _result = self:getBind(name)
+		if _result ~= nil then
+			_result = _result:getValue()
+		end
+		return _result
+	end
+	function AppForge:set(name, value)
+		if not self.rulesManager:applyRules(name, value) then
+			return nil
+		end
+		local _binds = self.binds
+		local _name = name
+		local _binding = _binds[_name]
+		local _ = _binding[1]
+		local setBinding = _binding[2]
+		if not setBinding then
+			error(`App "{name}" has no binding setter`)
+		end
+		setBinding(value)
+	end
+	function AppForge:open(name)
+		self:set(name, true)
+	end
+	function AppForge:close(name)
+		self:set(name, false)
+	end
+	function AppForge:toggle(name)
+		self:set(name, not self:getState(name))
+	end
+	function AppForge:renderApp(props)
+		return AppContainer(props)
+	end
+	function AppForge:renderApps(props)
+		local names = props.names
+		if names then
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#names)
+			local _callback = function(name)
+				local _self = self
+				local _object = table.clone(props)
+				setmetatable(_object, nil)
+				_object.name = name
+				_object.names = nil
+				return _self:renderApp(_object)
+			end
+			for _k, _v in names do
+				_newValue[_k] = _callback(_v, _k - 1, names)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			return _newValue
+		end
+		error("No app names provided to renderApps")
+	end
+	function AppForge:renderAll(props)
+		local names = {}
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(_, name)
+			local _name = name
+			table.insert(names, _name)
+		end
+		for _k, _v in AppRegistry do
+			_callback(_v, _k, AppRegistry)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		local _self = self
+		local _object = table.clone(props)
+		setmetatable(_object, nil)
+		_object.names = names
+		return _self:renderApps(_object)
+	end
+end
+exports.Render = TS.import(script, script, "helpers").Render
+exports.default = AppForge
+exports.App = App
+exports.Args = Args
+return exports

package/out/react/rules.d.ts

@@ -0,0 +1,11 @@
+import AppManager from ".";
+export default class RulesManager {
+    private appManager;
+    constructor(appManager: AppManager);
+    applyRules(name: AppNames[number], value: boolean): boolean;
+    private inSameGroup;
+    private blockedBy;
+    private blocks;
+    private exclusive;
+    private layer;
+}

package/out/react/rules.luau

@@ -0,0 +1,196 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+local Object = TS.import(script, TS.getModule(script, "@rbxts", "object-utils"))
+-- Components
+local AppRegistry = TS.import(script, script.Parent, "decorator").AppRegistry
+-- Types
+local function asTable(value)
+	local _value = value
+	if type(_value) == "table" then
+		return value
+	else
+		local t = {}
+		t[2] = value
+		return t
+	end
+end
+local RulesManager
+do
+	RulesManager = setmetatable({}, {
+		__tostring = function()
+			return "RulesManager"
+		end,
+	})
+	RulesManager.__index = RulesManager
+	function RulesManager.new(...)
+		local self = setmetatable({}, RulesManager)
+		return self:constructor(...) or self
+	end
+	function RulesManager:constructor(appManager)
+		self.appManager = appManager
+	end
+	function RulesManager:applyRules(name, value)
+		local _name = name
+		local appData = AppRegistry[_name]
+		local _rules = appData
+		if _rules ~= nil then
+			_rules = _rules.rules
+		end
+		local rules = _rules
+		local _result = rules
+		if _result ~= nil then
+			_result = _result.groups
+		end
+		if _result == "Core" then
+			return true
+		end
+		if value then
+			local allNames = Object.keys(AppRegistry)
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback = function(n)
+				if not (n ~= "" and n) or n == name then
+					return nil
+				end
+				print(self.appManager.loaded)
+				local _n = n
+				local otherApp = AppRegistry[_n]
+				local _result_1 = otherApp
+				if _result_1 ~= nil then
+					_result_1 = _result_1.rules
+					if _result_1 ~= nil then
+						_result_1 = _result_1.groups
+					end
+				end
+				local groups = if _result_1 ~= "" and _result_1 then asTable(otherApp.rules.groups) else {}
+				-- ▼ ReadonlyArray.find ▼
+				local _callback_1 = function(g)
+					return g == "Core"
+				end
+				local _result_2
+				for _i, _v in groups do
+					if _callback_1(_v, _i - 1, groups) == true then
+						_result_2 = _v
+						break
+					end
+				end
+				-- ▲ ReadonlyArray.find ▲
+				if _result_2 then
+					return nil
+				end
+				if self.appManager:getState(n) then
+					self.appManager:set(n, false)
+				end
+			end
+			for _k, _v in allNames do
+				_callback(_v, _k - 1, allNames)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+		end
+		if not rules then
+			return true
+		end
+		local _condition = value
+		if _condition then
+			_condition = rules.blockedBy
+			if _condition ~= "" and _condition then
+				_condition = not self:blockedBy(name, rules.blockedBy)
+			end
+		end
+		if _condition ~= "" and _condition then
+			return false
+		end
+		local _value = value and rules.blocks
+		if _value ~= "" and _value then
+			self:blocks(name, rules.blocks)
+		end
+		if value and rules.layer ~= nil then
+			self:layer(name, rules.layer)
+		end
+		if value and rules.exclusive then
+			self:exclusive(name)
+		end
+		return true
+	end
+	function RulesManager:inSameGroup(a, b)
+		local _a = a
+		local appA = AppRegistry[_a]
+		local _b = b
+		local appB = AppRegistry[_b]
+		if not appA or not appB then
+			return false
+		end
+		local _result = appA.rules
+		if _result ~= nil then
+			_result = _result.groups
+		end
+		local _condition = _result
+		if _condition == nil then
+			_condition = {}
+		end
+		local groupsA = asTable(_condition)
+		local _result_1 = appB.rules
+		if _result_1 ~= nil then
+			_result_1 = _result_1.groups
+		end
+		local _condition_1 = _result_1
+		if _condition_1 == nil then
+			_condition_1 = {}
+		end
+		local groupsB = asTable(_condition_1)
+		for i = 1, #groupsA do
+			for j = 1, #groupsB do
+				if groupsA[i + 1] == groupsB[j + 1] then
+					return true
+				end
+			end
+		end
+		return false
+	end
+	function RulesManager:blockedBy(name, rule)
+		local blockers = asTable(rule)
+		for i = 1, #blockers do
+			local blocker = blockers[i + 1]
+			if self:inSameGroup(name, blocker) or not (blocker ~= "" and blocker) then
+				continue
+			end
+			if self.appManager:getState(blocker) then
+				return false
+			end
+		end
+		return true
+	end
+	function RulesManager:blocks(name, rule)
+		local blocked = asTable(rule)
+		for i = 1, #blocked do
+			local b = blocked[i + 1]
+			if self:inSameGroup(name, b) or not (b ~= "" and b) then
+				continue
+			end
+			if self.appManager:getState(b) then
+				self.appManager:set(b, false)
+			end
+		end
+	end
+	function RulesManager:exclusive(name)
+		local names = Object.keys(AppRegistry)
+		for i = 1, #names do
+			local other = names[i + 1]
+			if other == name or not (other ~= "" and other) then
+				continue
+			end
+			if self:inSameGroup(name, other) then
+				continue
+			end
+			if self.appManager:getState(other) then
+				self.appManager:set(other, false)
+			end
+		end
+	end
+	function RulesManager:layer(_name, _layer)
+		-- TODO: implement priority / layering
+	end
+end
+return {
+	default = RulesManager,
+}

package/out/react/types.d.ts

@@ -0,0 +1,53 @@
+// Types
+import type { Args } from "./decorator";
+import type AppForge from ".";
+
+declare namespace Types {
+	type AppRegistryProps = {
+		name: AppNames[number];
+		visible?: boolean;
+		rules?: Rules.All;
+	};
+
+	type NameProps =
+		| { name?: AppNames[number]; names?: undefined }
+		| { names?: AppNames[number][]; name?: undefined };
+
+	type MainProps = {
+		props: AppProps;
+		forge: AppForge;
+		target?: GuiObject | Camera;
+	};
+
+	type ClassProps = AppProps & {
+		px: ReturnType<typeof import("@rbxts/loners-pretty-react-hooks").usePx>;
+	};
+
+	type AppRegistry = {
+		constructor: new (props: MainProps) => Args;
+		visible?: boolean;
+		rules?: Rules.All;
+	};
+
+	namespace Rules {
+		type Groups = AppGroups[number] | "Core" | "Core"[] | AppGroups[number][];
+		type BlockedBy = AppNames[number] | AppNames[number][];
+		type Blocks = AppNames[number] | AppNames[number][];
+		type Exclusive = boolean;
+		type Layer = number;
+
+		type All = {
+			blockedBy?: BlockedBy;
+			exclusive?: Exclusive;
+			groups?: Groups;
+			blocks?: Blocks;
+			layer?: Layer;
+		};
+	}
+}
+
+export type MainProps = Types.MainProps;
+export type NameProps = Types.NameProps;
+export type Props = Types.ClassProps;
+
+export default Types;

package/out/vide/container.d.ts

@@ -0,0 +1,2 @@
+import type Types from "./types";
+export declare function AppContainer(props: Types.NameProps & Types.MainProps): ScreenGui | Frame;

package/out/{container.luau → vide/container.luau}

@@ -1,29 +1,34 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
-TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
 -- Services
 local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
 -- Packages
 local _vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
-local Vide = _vide
+local vide = _vide
 local source = _vide.source
 -- Types
 -- Components
 local AppRegistry = TS.import(script, script.Parent, "decorator").AppRegistry
-local function createSource(name, manager)
+local create = vide.create
+local function createSource(name, forge)
 	local _name = name
 	local app = AppRegistry[_name]
 	if not app then
 		error(`App "{name}" not registered`)
 	end
+	local _sources = forge.sources
+	local _name_1 = name
+	if _sources[_name_1] ~= nil then
+		return nil
+	end
+	local _sources_1 = forge.sources
+	local _exp = name
 	local _condition = app.visible
 	if _condition == nil then
 		_condition = false
 	end
-	local appSource = source(_condition)
-	local _sources = manager.sources
-	local _name_1 = name
-	_sources[_name_1] = appSource
+	local _arg1 = source(_condition)
+	_sources_1[_exp] = _arg1
 	return source
 end
 local function createInstance(props)
@@ -58,19 +63,21 @@ local function AppContainer(props)
 		error(`Failed to create instance for app "{name}"`)
 	end
 	if RunService:IsRunning() then
-		return Vide.jsx("screengui", {
+		return create("ScreenGui")({
 			Name = name,
 			ZIndexBehavior = "Sibling",
 			ResetOnSpawn = false,
-		}, element)
+			[0] = element,
+		})
 	else
-		return Vide.jsx("frame", {
+		return create("Frame")({
 			Name = name,
 			BackgroundTransparency = 1,
 			Size = UDim2.fromScale(1, 1),
-		}, element)
+			[0] = element,
+		})
 	end
 end
 return {
-	default = AppContainer,
+	AppContainer = AppContainer,
 }

package/out/{decorator.luau → vide/decorator.luau}

@@ -1,6 +1,5 @@
 -- Compiled with roblox-ts v3.0.0
 local TS = _G[script]
--- Services
 -- Packages
 local pxScale = TS.import(script, TS.getModule(script, "@rbxts", "loners-pretty-vide-utils").out).px
 -- Types

package/out/{helpers.d.ts → vide/helpers.d.ts}

@@ -1,2 +1,2 @@
 import Types from "./types";
-export declare function Render(props: Types.NameProps & Types.MainProps): import("@rbxts/vide").Node;
+export declare function Render(props: Types.NameProps & Types.MainProps): ScreenGui | Frame | (ScreenGui | Frame)[];

package/out/vide/index.d.ts

@@ -0,0 +1,19 @@
+import Vide from "@rbxts/vide";
+import type Types from "./types";
+import { Args, App } from "./decorator";
+export default class AppForge {
+    sources: Map<string, Vide.Source<boolean>>;
+    loaded: Map<string, Vide.Node>;
+    private rulesManager;
+    getSource(name: AppNames[number]): Vide.Source<boolean>;
+    set(name: AppNames[number], value: Vide.Source<boolean> | boolean): void;
+    open(name: AppNames[number]): void;
+    close(name: AppNames[number]): void;
+    toggle(name: AppNames[number]): void;
+    renderApp(props: Types.NameProps & Types.MainProps): ScreenGui | Frame;
+    renderApps(props: Types.NameProps & Types.MainProps): (ScreenGui | Frame)[];
+    renderAll(props: Types.MainProps): (ScreenGui | Frame)[];
+}
+export { App, Args };
+export { Render } from "./helpers";
+export type { NameProps, MainProps, ClassProps } from "./types";

package/out/vide/init.luau

@@ -0,0 +1,116 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+-- Packages
+-- Types
+-- Components
+local _decorator = TS.import(script, script, "decorator")
+local AppRegistry = _decorator.AppRegistry
+local Args = _decorator.Args
+local App = _decorator.App
+local AppContainer = TS.import(script, script, "container").AppContainer
+-- Classes
+local RulesManager = TS.import(script, script, "rules").default
+local AppForge
+do
+	AppForge = setmetatable({}, {
+		__tostring = function()
+			return "AppForge"
+		end,
+	})
+	AppForge.__index = AppForge
+	function AppForge.new(...)
+		local self = setmetatable({}, AppForge)
+		return self:constructor(...) or self
+	end
+	function AppForge:constructor()
+		self.sources = {}
+		self.loaded = {}
+		self.rulesManager = RulesManager.new(self)
+	end
+	function AppForge:getSource(name)
+		local _sources = self.sources
+		local _name = name
+		if not (_sources[_name] ~= nil) then
+			error(`App "{name}" has no source`)
+		end
+		local _sources_1 = self.sources
+		local _name_1 = name
+		return _sources_1[_name_1]
+	end
+	function AppForge:set(name, value)
+		if not self.rulesManager:applyRules(name, value) then
+			return nil
+		end
+		local _value = value
+		if type(_value) == "function" then
+			local _sources = self.sources
+			local _name = name
+			local _value_1 = value
+			_sources[_name] = _value_1
+		else
+			local _sources = self.sources
+			local _name = name
+			local source = _sources[_name]
+			if not source then
+				error(`App "{name}" has no source`)
+			end
+			source(value)
+		end
+	end
+	function AppForge:open(name)
+		self:set(name, true)
+	end
+	function AppForge:close(name)
+		self:set(name, false)
+	end
+	function AppForge:toggle(name)
+		self:set(name, not self:getSource(name)())
+	end
+	function AppForge:renderApp(props)
+		return AppContainer(props)
+	end
+	function AppForge:renderApps(props)
+		local names = props.names
+		if names then
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#names)
+			local _callback = function(name)
+				local _self = self
+				local _object = table.clone(props)
+				setmetatable(_object, nil)
+				_object.name = name
+				_object.names = nil
+				return _self:renderApp(_object)
+			end
+			for _k, _v in names do
+				_newValue[_k] = _callback(_v, _k - 1, names)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			return _newValue
+		end
+		error("No app names provided to renderApps")
+	end
+	function AppForge:renderAll(props)
+		local names = {}
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(_, name)
+			local _name = name
+			table.insert(names, _name)
+		end
+		for _k, _v in AppRegistry do
+			_callback(_v, _k, AppRegistry)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+		local _self = self
+		local _object = table.clone(props)
+		setmetatable(_object, nil)
+		_object.names = names
+		return _self:renderApps(_object)
+	end
+end
+exports.Render = TS.import(script, script, "helpers").Render
+exports.default = AppForge
+exports.App = App
+exports.Args = Args
+return exports

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rbxts/app-forge",
-	"version": "0.5.9",
+	"version": "0.6.0-alpha.0",
 	"description": "An App Manager for react",
 	"main": "out/init.lua",
 	"packageManager": "bun@1.3.1",
@@ -11,7 +11,8 @@
 	},
 	"keywords": [
 		"roblox-ts",
-		"react"
+		"react",
+		"vide"
 	],
 	"author": "loner1536",
 	"license": "MIT",
@@ -40,15 +41,14 @@
 		"typescript": "^5.9.3"
 	},
 	"dependencies": {
-		"@rbxts/vide": "^0.5.7",
-		"@rbxts/ripple": "^0.9.3",
-		"@rbxts/services": "^1.6.0",
 		"@rbxts/set-timeout": "^1.1.2",
-		"@rbxts/loners-pretty-vide-utils": "^0.1.4"
+		"@rbxts/services": "^1.6.0"
 	},
 	"peerDependencies": {
+		"@rbxts/loners-pretty-react-hooks": "*",
 		"@rbxts/loners-pretty-vide-utils": "*",
 		"@rbxts/object-utils": "*",
+		"@rbxts/react": "*",
 		"@rbxts/vide": "*"
 	}
 }

package/out/container.d.ts

@@ -1,4 +0,0 @@
-import "@rbxts/vide";
-import Vide from "@rbxts/vide";
-import type Types from "./types";
-export default function AppContainer(props: Types.NameProps & Types.MainProps): Vide.Node;