@rbxts/app-forge 0.6.0 → 0.7.0

package/out/init.luau

@@ -1,120 +1,21 @@
 -- 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)
+-- Decorators
+local _decorator = TS.import(script, script, "react", "decorator")
+exports.ReactApp = _decorator.App
+exports.ReactArgs = _decorator.Args
+local _decorator_1 = TS.import(script, script, "vide", "decorator")
+exports.VideApp = _decorator_1.App
+exports.VideArgs = _decorator_1.Args
+-- Creators
+exports.CreateReactForge = TS.import(script, script, "react").default
+exports.CreateVideForge = TS.import(script, script, "vide").default
+-- Helpers
+exports.RenderReact = TS.import(script, script, "react", "helpers").Render
 -- 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.useReactAppContext = TS.import(script, script, "react", "hooks", "useAppContext").default
+exports.ReactContexts = TS.import(script, script, "react", "context").default
+exports.useVideAppContext = TS.import(script, script, "vide", "hooks", "useAppContext").default
+exports.VideContexts = TS.import(script, script, "vide", "context").default
 return exports

package/out/react/container.d.ts

@@ -0,0 +1,10 @@
+import type Types from "./types";
+export declare function AppContainer(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>>;

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

@@ -1,36 +1,12 @@
 -- 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 source = _vide.source
+local createElement = TS.import(script, TS.getModule(script, "@rbxts", "react")).createElement
 -- Types
 -- Components
 local AppRegistry = TS.import(script, script.Parent, "decorator").AppRegistry
-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 _arg1 = source(_condition)
-	_sources_1[_exp] = _arg1
-	return source
-end
 local function createInstance(props)
 	local _binding = props
 	local name = _binding.name
@@ -44,8 +20,13 @@ local function createInstance(props)
 	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 = instance:render()
+		local _arg1 = createElement(Render, {
+			key = "Main",
+		})
 		_loaded[name] = _arg1
 	end
 	return forge.loaded[name]
@@ -53,29 +34,27 @@ 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
-	createSource(name, forge)
 	local element = createInstance(props)
 	if not element then
 		error(`Failed to create instance for app "{name}"`)
 	end
 	if RunService:IsRunning() then
-		return Vide.jsx("screengui", {
-			Name = name,
-			ZIndexBehavior = "Sibling",
+		return createElement("ScreenGui", {
+			key = name,
+			ZIndexBehavior = Enum.ZIndexBehavior.Sibling,
 			ResetOnSpawn = false,
 		}, element)
 	else
-		return Vide.jsx("frame", {
-			Name = name,
+		return createElement("Frame", {
+			key = name,
 			BackgroundTransparency = 1,
 			Size = UDim2.fromScale(1, 1),
 		}, element)
 	end
 end
 return {
-	default = AppContainer,
+	AppContainer = AppContainer,
 }

package/out/react/context.d.ts

@@ -0,0 +1,7 @@
+declare const Contexts: {
+    readonly App: import("@rbxts/react").Context<{
+        forge: import(".").default;
+        px: ReturnType<typeof import("@rbxts/loners-pretty-react-hooks").usePx>;
+    } | undefined>;
+};
+export default Contexts;

package/out/react/context.luau

@@ -0,0 +1,12 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+local createContext = TS.import(script, TS.getModule(script, "@rbxts", "react")).createContext
+-- Types
+local Contexts = {
+	App = createContext(nil),
+}
+local default = Contexts
+return {
+	default = default,
+}

package/out/{decorator.d.ts → react/decorator.d.ts}

@@ -1,4 +1,4 @@
-import Vide from "@rbxts/vide";
+import React from "@rbxts/react";
 import type Types from "./types";
 import type AppForge from ".";
 export declare const AppRegistry: Map<string, Types.AppRegistry>;
@@ -6,8 +6,9 @@ export declare function App(props: Types.AppRegistryProps): <T extends new (prop
 export declare abstract class Args {
     readonly forge: AppForge;
     readonly props: Types.ClassProps;
-    readonly name: AppNames[number];
-    readonly source: Vide.Source<boolean>;
+    readonly name: AppNames;
+    readonly bind: React.Binding<boolean>;
+    readonly state: Boolean;
     constructor(props: Types.NameProps & Types.MainProps);
-    abstract render(): Vide.Node;
+    abstract render(): React.ReactNode;
 }

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

@@ -2,7 +2,7 @@
 local TS = _G[script]
 -- Services
 -- Packages
-local pxScale = TS.import(script, TS.getModule(script, "@rbxts", "loners-pretty-vide-utils").out).px
+local usePx = TS.import(script, TS.getModule(script, "@rbxts", "loners-pretty-react-hooks").out).usePx
 -- Types
 local AppRegistry = {}
 local function App(props)
@@ -26,19 +26,22 @@ 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 px = pxScale
+		local px = usePx(target)
 		self.forge = forge
 		local _object = table.clone(props.props)
 		setmetatable(_object, nil)
 		_object.px = px
+		_object.forge = forge
 		self.props = _object
 		self.name = name
-		self.source = forge:getSource(name)
+		self.bind = forge:getBind(name)
+		self.state = forge:getState(name)
 	end
 end
 return {

package/out/react/helpers.d.ts

@@ -0,0 +1,6 @@
+import React from "@rbxts/react";
+import type Types from "./types";
+import type AppForge from ".";
+export declare function createBinding(name: AppNames, forge: AppForge): void;
+export declare function createState(name: AppNames, forge: AppForge): void;
+export declare function Render(props: Types.NameProps & Types.MainProps): React.ReactNode;

package/out/react/helpers.luau

@@ -0,0 +1,74 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local useBinding = _react.useBinding
+local useState = _react.useState
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent, "decorator").AppRegistry
+local function createBinding(name, forge)
+	local _name = name
+	local app = AppRegistry[_name]
+	if not app then
+		error(`App "{name}" not registered`)
+	end
+	local _binds = forge.binds
+	local _name_1 = name
+	if _binds[_name_1] ~= nil then
+		return nil
+	end
+	local _condition = app.visible
+	if _condition == nil then
+		_condition = false
+	end
+	local binding = { useBinding(_condition) }
+	local _binds_1 = forge.binds
+	local _name_2 = name
+	_binds_1[_name_2] = binding
+end
+local function createState(name, forge)
+	local _name = name
+	local app = AppRegistry[_name]
+	if not app then
+		error(`App "{name}" not registered`)
+	end
+	local _states = forge.states
+	local _name_1 = name
+	if _states[_name_1] ~= nil then
+		return nil
+	end
+	local _condition = app.visible
+	if _condition == nil then
+		_condition = false
+	end
+	local state = { useState(_condition) }
+	local _states_1 = forge.states
+	local _name_2 = name
+	_states_1[_name_2] = state
+end
+local function Render(props)
+	local names = props.names
+	local name = props.name
+	local forge = props.forge
+	-- ▼ ReadonlyMap.forEach ▼
+	local _callback = function(_, name)
+		createBinding(name, forge)
+		createState(name, forge)
+	end
+	for _k, _v in AppRegistry do
+		_callback(_v, _k, AppRegistry)
+	end
+	-- ▲ ReadonlyMap.forEach ▲
+	if name ~= "" and name then
+		return forge:renderApp(props)
+	elseif names then
+		return forge:renderApps(props)
+	end
+	return forge:renderAll(props)
+end
+return {
+	createBinding = createBinding,
+	createState = createState,
+	Render = Render,
+}

package/out/react/hooks/useAppContext.d.ts

@@ -0,0 +1,5 @@
+declare const _default: () => {
+    forge: import("..").default;
+    px: ReturnType<typeof import("@rbxts/loners-pretty-react-hooks").usePx>;
+};
+export default _default;

package/out/react/hooks/useAppContext.luau

@@ -0,0 +1,16 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+local useContext = TS.import(script, TS.getModule(script, "@rbxts", "react")).useContext
+-- Components
+local Contexts = TS.import(script, script.Parent.Parent, "context").default
+local default = function()
+	local context = useContext(Contexts.App)
+	if not context then
+		error(`Failed to retrieve App Props for React {debug.traceback()}`)
+	end
+	return context
+end
+return {
+	default = default,
+}

package/out/react/index.d.ts

@@ -0,0 +1,44 @@
+import React from "@rbxts/react";
+import type Types from "./types";
+type Binding = [React.Binding<boolean>, (T: boolean) => void];
+type State = [boolean, React.Dispatch<React.SetStateAction<boolean>>];
+export default class AppForge {
+    loaded: Map<string, React.Element<any, string | React.JSXElementConstructor<any>>>;
+    binds: Map<string, Binding>;
+    states: Map<string, State>;
+    private rulesManager;
+    getBind(name: AppNames): React.Binding<boolean>;
+    getState(name: AppNames): boolean;
+    set(name: AppNames, value: boolean): void;
+    open(name: AppNames): void;
+    close(name: AppNames): void;
+    toggle(name: AppNames): 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 {};

package/out/react/init.luau

@@ -0,0 +1,123 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+-- Types
+-- Components
+local AppContainer = TS.import(script, script, "container").AppContainer
+local AppRegistry = TS.import(script, script, "decorator").AppRegistry
+-- Classes
+local RulesManager = TS.import(script, script, "rules").default
+-- Helpers
+local _helpers = TS.import(script, script, "helpers")
+local createBinding = _helpers.createBinding
+local createState = _helpers.createState
+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.loaded = {}
+		self.binds = {}
+		self.states = {}
+		self.rulesManager = RulesManager.new(self)
+	end
+	function AppForge:getBind(name)
+		local _binds = self.binds
+		local _name = name
+		if not (_binds[_name] ~= nil) then
+			createBinding(name, self)
+		end
+		local _binds_1 = self.binds
+		local _name_1 = name
+		return _binds_1[_name_1][1]
+	end
+	function AppForge:getState(name)
+		local _states = self.states
+		local _name = name
+		if not (_states[_name] ~= nil) then
+			createState(name, self)
+		end
+		local _states_1 = self.states
+		local _name_1 = name
+		return _states_1[_name_1][1]
+	end
+	function AppForge:set(name, value)
+		self.rulesManager:applyRules(name)
+		local _binds = self.binds
+		local _name = name
+		local _binding = _binds[_name]
+		local _b = _binding[1]
+		local setBinding = _binding[2]
+		local _states = self.states
+		local _name_1 = name
+		local _binding_1 = _states[_name_1]
+		local _s = _binding_1[1]
+		local setState = _binding_1[2]
+		if not setBinding then
+			createBinding(name, self)
+		end
+		setBinding(value)
+		setState(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
+return {
+	default = AppForge,
+}

package/out/react/rules/index.d.ts

@@ -0,0 +1,6 @@
+import type AppForge from "..";
+export default class RulesManager {
+    private forge;
+    constructor(forge: AppForge);
+    applyRules(name: AppNames): void;
+}

package/out/react/rules/init.luau

@@ -0,0 +1,27 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Types
+-- Rules
+local ParentRule = TS.import(script, script, "parent").default
+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(forge)
+		self.forge = forge
+	end
+	function RulesManager:applyRules(name)
+		ParentRule(name, self.forge)
+	end
+end
+return {
+	default = RulesManager,
+}

package/out/react/rules/parent.d.ts

@@ -0,0 +1,2 @@
+import type AppForge from "..";
+export default function ParentRule(entry: AppNames, forge: AppForge): void;

package/out/react/rules/parent.luau

@@ -0,0 +1,42 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent.Parent, "decorator").AppRegistry
+local function ParentRule(entry, forge)
+	local children = {}
+	-- ▼ ReadonlyMap.forEach ▼
+	local _callback = function(app, name)
+		local rules = app.rules
+		if not rules then
+			return nil
+		end
+		local _condition = rules.parent
+		if _condition ~= "" and _condition then
+			_condition = rules.parent == entry
+		end
+		if _condition ~= "" and _condition then
+			local _binds = forge.binds
+			local _entry = entry
+			if not _binds[_entry] then
+				local _name = name
+				table.insert(children, _name)
+			end
+		end
+	end
+	for _k, _v in AppRegistry do
+		_callback(_v, _k, AppRegistry)
+	end
+	-- ▲ ReadonlyMap.forEach ▲
+	-- ▼ ReadonlyArray.forEach ▼
+	local _callback_1 = function(name)
+		return forge:close(name)
+	end
+	for _k, _v in children do
+		_callback_1(_v, _k - 1, children)
+	end
+	-- ▲ ReadonlyArray.forEach ▲
+end
+return {
+	default = ParentRule,
+}