@rbxts/app-forge 0.6.0-alpha.9 → 0.7.0

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/react/decorator.d.ts

@@ -6,7 +6,7 @@ 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 name: AppNames;
     readonly bind: React.Binding<boolean>;
     readonly state: Boolean;
     constructor(props: Types.NameProps & Types.MainProps);

package/out/react/decorator.luau

@@ -1,7 +1,6 @@
 -- 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
@@ -33,19 +32,16 @@ do
 		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
+		_object.forge = forge
 		self.props = _object
 		self.name = name
-		self.bind = bind
-		self.state = if self.bind then self.bind:getValue() else nil
+		self.bind = forge:getBind(name)
+		self.state = forge:getState(name)
 	end
 end
 return {

package/out/react/helpers.d.ts

@@ -1,3 +1,6 @@
 import React from "@rbxts/react";
-import Types from "./types";
+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

@@ -1,9 +1,65 @@
 -- 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
@@ -12,5 +68,7 @@ local function Render(props)
 	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

@@ -1,15 +1,18 @@
 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 {
-    binds: Map<string, [React.Binding<boolean>, (T: boolean) => void]>;
     loaded: Map<string, React.Element<any, string | React.JSXElementConstructor<any>>>;
+    binds: Map<string, Binding>;
+    states: Map<string, State>;
     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;
+    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;
@@ -38,3 +41,4 @@ export default class AppForge {
         Size: UDim2;
     }, string | React.JSXElementConstructor<any>>)[];
 }
+export {};

package/out/react/init.luau

@@ -7,7 +7,10 @@ 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
-local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+-- Helpers
+local _helpers = TS.import(script, script, "helpers")
+local createBinding = _helpers.createBinding
+local createState = _helpers.createState
 local AppForge
 do
 	AppForge = setmetatable({}, {
@@ -21,49 +24,48 @@ do
 		return self:constructor(...) or self
 	end
 	function AppForge:constructor()
-		self.binds = {}
 		self.loaded = {}
+		self.binds = {}
+		self.states = {}
 		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`)
+			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 _result = self:getBind(name)
-		if _result ~= nil then
-			_result = _result:getValue()
+		local _states = self.states
+		local _name = name
+		if not (_states[_name] ~= nil) then
+			createState(name, self)
 		end
-		return _result
+		local _states_1 = self.states
+		local _name_1 = name
+		return _states_1[_name_1][1]
 	end
 	function AppForge:set(name, value)
-		if not self.rulesManager:applyRules(name, value) then
-			return nil
-		end
+		self.rulesManager:applyRules(name)
 		local _binds = self.binds
 		local _name = name
 		local _binding = _binds[_name]
-		local _ = _binding[1]
+		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
-			error(`App "{name}" has no binding setter`)
+			createBinding(name, self)
 		end
 		setBinding(value)
+		setState(value)
 	end
 	function AppForge:open(name)
 		self:set(name, true)

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,
+}

package/out/react/types.d.ts

@@ -4,14 +4,14 @@ import type AppForge from ".";
 
 declare namespace Types {
 	type AppRegistryProps = {
-		name: AppNames[number];
+		name: AppNames;
 		visible?: boolean;
 		rules?: Rules.All;
 	};
 
 	type NameProps =
-		| { name?: AppNames[number]; names?: undefined }
-		| { names?: AppNames[number][]; name?: undefined };
+		| { name?: AppNames; names?: undefined }
+		| { names?: AppNames[]; name?: undefined };
 
 	type MainProps = {
 		props: AppProps;
@@ -20,6 +20,7 @@ declare namespace Types {
 	};
 
 	type ClassProps = AppProps & {
+		forge: AppForge;
 		px: ReturnType<typeof import("@rbxts/loners-pretty-react-hooks").usePx>;
 	};
 
@@ -30,18 +31,8 @@ declare namespace Types {
 	};
 
 	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;
+			parent?: AppNames;
 		};
 	}
 }

package/out/vide/classes/renders.d.ts

@@ -0,0 +1,21 @@
+import Vide from "@rbxts/vide";
+import type Types from "../types";
+import type AppForge from "..";
+import Rules from "./rules";
+export default class Renders extends Rules {
+    protected anchored: Map<string, {
+        id: AppNames;
+        render: Vide.Node;
+    }>;
+    constructor();
+    protected renderMount(this: AppForge, props: Types.Props.Main): Vide.Node;
+    private renderNames;
+    private collectByGroup;
+    private normalizeGroups;
+    protected renderApp(this: AppForge, props: Types.Props.Main): Vide.Node;
+    protected renderApps(this: AppForge, props: Types.Props.Main): Vide.Node[];
+    protected renderGroup(this: AppForge, props: Types.Props.Main): Vide.Node[];
+    protected renderGroupByName(this: AppForge, props: Types.Props.Main): Vide.Node[];
+    protected renderGroupByNames(this: AppForge, props: Types.Props.Main): Vide.Node[];
+    protected renderAll(this: AppForge, props: Types.Props.Main): Vide.Node[];
+}

package/out/vide/classes/renders.luau

@@ -0,0 +1,251 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Services
+-- Packages
+local usePx = TS.import(script, TS.getModule(script, "@rbxts", "loners-pretty-vide-utils").out).usePx
+local _vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
+local apply = _vide.apply
+local create = _vide.create
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent.Parent, "decorator").AppRegistry
+-- Classes
+local Rules = TS.import(script, script.Parent, "rules").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.anchored = {}
+	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 _result = config
+			if _result ~= nil then
+				_result = _result.px.target
+			end
+			local _result_1 = config
+			if _result_1 ~= nil then
+				_result_1 = _result_1.px.resolution
+			end
+			local _result_2 = config
+			if _result_2 ~= nil then
+				_result_2 = _result_2.px.minScale
+			end
+			usePx(_result, _result_1, _result_2)
+			forge.__px = true
+		else
+			warn("Rendering twice making a second px")
+		end
+		if render then
+			local _condition = render.name
+			if _condition ~= "" and _condition then
+				_condition = render.group
+			end
+			if _condition ~= "" and _condition then
+				return forge:renderGroupByName(props)
+			else
+				local _value = render.names and render.group
+				if _value ~= "" and _value then
+					return forge:renderGroupByNames(props)
+				else
+					local _result = render
+					if _result ~= nil then
+						_result = _result.name
+					end
+					if _result ~= "" and _result then
+						return forge:renderApp(props)
+					elseif render.names then
+						return forge:renderApps(props)
+					else
+						local _value_1 = render.group
+						if _value_1 ~= "" and _value_1 then
+							return forge:renderGroup(props)
+						end
+					end
+				end
+			end
+		end
+		return self:renderAll(props)
+	end
+	function Renders:renderNames(props, names, forge)
+		if #names == 0 then
+			error("No app names provided to renderApps")
+		end
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#names)
+		local _callback = function(name)
+			local _forge = forge
+			local _object = table.clone(props)
+			setmetatable(_object, nil)
+			_object.render = {
+				name = name,
+			}
+			return _forge:renderApp(_object)
+		end
+		for _k, _v in names do
+			_newValue[_k] = _callback(_v, _k - 1, names)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		return _newValue
+	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)
+		local _binding = props
+		local forge = _binding.forge
+		local render = _binding.render
+		local _name = render
+		if _name ~= nil then
+			_name = _name.name
+		end
+		local name = _name
+		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 render = appClass.constructor.new(props, name):render()
+			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,
+			})
+			local _loaded = forge.loaded
+			local _arg1 = {
+				container = container,
+				render = render,
+			}
+			_loaded[name] = _arg1
+		end
+		local element = forge.loaded[name]
+		if not element then
+			error(`Failed to create instance for app "{name}"`)
+		end
+		self:renderRules(name, props)
+		return element.container
+	end
+	function Renders:renderApps(props)
+		local _names = props.render
+		if _names ~= nil then
+			_names = _names.names
+		end
+		local names = _names
+		if not names then
+			error("No app names provided")
+		end
+		return self:renderNames(props, names, self)
+	end
+	function Renders:renderGroup(props)
+		local _group = props.render
+		if _group ~= nil then
+			_group = _group.group
+		end
+		local group = _group
+		if not (group ~= "" and group) then
+			error("No group provided")
+		end
+		local groups = self:normalizeGroups(group)
+		return self:renderNames(props, self:collectByGroup(groups), self)
+	end
+	function Renders:renderGroupByName(props)
+		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")
+		end
+		local groups = self:normalizeGroups(group)
+		return self:renderNames(props, self:collectByGroup(groups, function(n)
+			return n == name
+		end), self)
+	end
+	function Renders:renderGroupByNames(props)
+		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")
+		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)
+	end
+	function Renders:renderAll(props)
+		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)
+	end
+end
+return {
+	default = Renders,
+}

package/out/vide/classes/rules/exclusiveGroup.d.ts

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