@rbxts/app-forge 0.6.0-alpha.26 → 0.6.0-alpha.27

package/out/global.d.ts

@@ -0,0 +1,9 @@
+declare global {
+	// These will be overridden by the user
+	// They are only placeholders for your build
+
+	type AppGroups = readonly string[];
+	type AppNames = readonly string[];
+	type AppProps = {};
+}
+export {};

package/out/index.d.ts

@@ -0,0 +1,12 @@
+export { App as ReactApp, Args as ReactArgs } from "./react/decorator";
+export { App as VideApp, Args as VideArgs } from "./vide/decorator";
+export { default as CreateReactForge } from "./react";
+export { default as CreateVideForge } from "./vide";
+export { Render as RenderReact } from "./react/helpers";
+export { Render as RenderVide } from "./vide/helpers";
+export type { MainProps as VideProps, ClassProps as VideClassProps } from "./vide/types";
+export type { MainProps as ReactProps, ClassProps as ReactClassProps, NameProps, } from "./react/types";
+export { default as useReactAppContext } from "./react/hooks/useAppContext";
+export { default as ReactContexts } from "./react/context";
+export { default as useVideAppContext } from "./vide/hooks/useAppContext";
+export { default as VideContexts } from "./vide/context";

package/out/init.luau

@@ -0,0 +1,22 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+-- 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
+exports.RenderVide = TS.import(script, script, "vide", "helpers").Render
+-- Types
+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/react/container.luau

@@ -0,0 +1,60 @@
+-- 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 createElement = TS.import(script, TS.getModule(script, "@rbxts", "react")).createElement
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent, "decorator").AppRegistry
+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
+	if not (name ~= "" and name) then
+		error("App name is required in AppContainer")
+	end
+	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/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/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(): React.ReactNode;
+}

package/out/react/decorator.luau

@@ -0,0 +1,51 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Services
+-- 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 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 = forge:getBind(name)
+		self.state = forge:getState(name)
+	end
+end
+return {
+	App = App,
+	AppRegistry = AppRegistry,
+	Args = Args,
+}

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[number], forge: AppForge): void;
+export declare function createState(name: AppNames[number], 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[number]): React.Binding<boolean>;
+    getState(name: AppNames[number]): boolean;
+    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 {};

package/out/react/init.luau

@@ -0,0 +1,125 @@
+-- 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)
+		if not self.rulesManager:applyRules(name, value) then
+			return nil
+		end
+		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.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,195 @@
+-- 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
+				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,
+}