@rbxts/app-forge 0.0.1

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2024 Littensy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/out/container.d.ts

@@ -0,0 +1,5 @@
+import type AppManager from ".";
+export declare function AppContainer(props: AppProps & {
+    name: AppNames[number];
+    manager: AppManager;
+}): JSX.Element;

package/out/container.luau

@@ -0,0 +1,48 @@
+-- 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 _loners_pretty_react_hooks = TS.import(script, TS.getModule(script, "@rbxts", "loners-pretty-react-hooks").out)
+local useBindingListener = _loners_pretty_react_hooks.useBindingListener
+local useSpring = _loners_pretty_react_hooks.useSpring
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local React = _react
+local useState = _react.useState
+-- Types
+local function AppContainer(props)
+	local _binding = props
+	local name = _binding.name
+	local manager = _binding.manager
+	local binding, _ = manager:createBinding(name)
+	local spring = useSpring(binding:map(function(v)
+		return if v then 0 else 1
+	end), {
+		frequency = 0.4,
+		damping = 0.8,
+	})
+	local _isVisible, setisVisible = useState(binding:getValue())
+	local element = manager:createInstance(props, name)
+	if not element then
+		error(`Failed to create instance for app "{name}"`)
+	end
+	useBindingListener(spring, function(v)
+		setisVisible(v == 0)
+	end)
+	if RunService:IsRunning() then
+		return React.createElement("screengui", {
+			key = name,
+			ZIndexBehavior = "Sibling",
+			ResetOnSpawn = false,
+		}, element)
+	else
+		return React.createElement("frame", {
+			key = name,
+			BackgroundTransparency = 1,
+			Size = UDim2.fromScale(1, 1),
+		}, element)
+	end
+end
+return {
+	AppContainer = AppContainer,
+}

package/out/decorator.d.ts

@@ -0,0 +1,9 @@
+import React from "@rbxts/react";
+import type Types from "./types";
+export declare const AppRegistry: Map<string, Types.AppRegistry>;
+export declare function App(props: Types.AppRegistryProps): <T extends new (props: AppProps) => Args>(constructor: T) => T;
+export declare abstract class Args {
+    readonly props: AppProps;
+    constructor(props: AppProps);
+    abstract render(): React.Element;
+}

package/out/decorator.luau

@@ -0,0 +1,32 @@
+-- Compiled with roblox-ts v3.0.0
+-- Packages
+-- 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)
+		self.props = props
+	end
+end
+return {
+	App = App,
+	AppRegistry = AppRegistry,
+	Args = Args,
+}

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

@@ -0,0 +1,6 @@
+import type AppManager from ".";
+export declare function Render({ props, manager, names, }: {
+    props: AppProps;
+    manager: AppManager;
+    names?: AppNames[number] | AppNames[number][];
+}): JSX.Element | JSX.Element[];

package/out/helpers.luau

@@ -0,0 +1,18 @@
+-- Compiled with roblox-ts v3.0.0
+-- Types
+local function Render(_param)
+	local props = _param.props
+	local manager = _param.manager
+	local names = _param.names
+	if names ~= "" and names then
+		if type(names) == "table" then
+			return manager:renderApps(props, names)
+		else
+			return manager:renderApp(props, names)
+		end
+	end
+	return manager:renderAll(props)
+end
+return {
+	Render = Render,
+}

package/out/index.d.ts

@@ -0,0 +1,21 @@
+import React from "@rbxts/react";
+import { Args, App } from "./decorator";
+export default class AppManager {
+    private binds;
+    private loaded;
+    private rulesManager;
+    private getAllNames;
+    createBinding(name: AppNames[number]): LuaTuple<[React.Binding<boolean>, (newValue: boolean) => void]>;
+    createInstance(props: AppProps, name: AppNames[number]): React.Element<any, string | React.JSXElementConstructor<any>>;
+    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: AppProps, name: AppNames[number]): JSX.Element;
+    renderApps(props: AppProps, names: AppNames[number][]): JSX.Element[];
+    renderAll(props: AppProps): JSX.Element[];
+}
+export { App, Args };
+export { Render } from "./helpers";

package/out/init.luau

@@ -0,0 +1,138 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+-- Packages
+local _react = TS.import(script, TS.getModule(script, "@rbxts", "react"))
+local React = _react
+local cloneElement = _react.cloneElement
+local useBinding = _react.useBinding
+local Object = TS.import(script, TS.getModule(script, "@rbxts", "object-utils"))
+-- 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
+local RulesManager = TS.import(script, script, "rules").default
+local AppManager
+do
+	AppManager = setmetatable({}, {
+		__tostring = function()
+			return "AppManager"
+		end,
+	})
+	AppManager.__index = AppManager
+	function AppManager.new(...)
+		local self = setmetatable({}, AppManager)
+		return self:constructor(...) or self
+	end
+	function AppManager:constructor()
+		self.binds = {}
+		self.loaded = {}
+		self.rulesManager = RulesManager.new(self)
+	end
+	function AppManager:getAllNames()
+		return Object.keys(AppRegistry)
+	end
+	function AppManager:createBinding(name)
+		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 = self.binds
+		local _name_1 = name
+		_binds[_name_1] = binding
+		return unpack(binding)
+	end
+	function AppManager:createInstance(props, name)
+		local _name = name
+		local appClass = AppRegistry[_name]
+		if not appClass then
+			error(`App "{name}" not registered`)
+		end
+		local _loaded = self.loaded
+		local _name_1 = name
+		if not (_loaded[_name_1] ~= nil) then
+			local instance = appClass.constructor.new(props)
+			local element = cloneElement(instance:render(), {
+				key = "Main",
+			})
+			local _loaded_1 = self.loaded
+			local _name_2 = name
+			_loaded_1[_name_2] = element
+		end
+		local _loaded_1 = self.loaded
+		local _name_2 = name
+		return _loaded_1[_name_2]
+	end
+	function AppManager:getBind(name)
+		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 AppManager:getState(name)
+		return self:getBind(name):getValue()
+	end
+	function AppManager: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]
+		setBinding(value)
+	end
+	function AppManager:open(name)
+		self:set(name, true)
+	end
+	function AppManager:close(name)
+		self:set(name, false)
+	end
+	function AppManager:toggle(name)
+		self:set(name, not self:getState(name))
+	end
+	function AppManager:renderApp(props, name)
+		local _attributes = {
+			key = `{name}_Container`,
+			name = name,
+			manager = self,
+		}
+		for _k, _v in props do
+			_attributes[_k] = _v
+		end
+		return React.createElement(AppContainer, _attributes)
+	end
+	function AppManager:renderApps(props, names)
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#names)
+		local _callback = function(n)
+			return self:renderApp(props, n)
+		end
+		for _k, _v in names do
+			_newValue[_k] = _callback(_v, _k - 1, names)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		return _newValue
+	end
+	function AppManager:renderAll(props)
+		return self:renderApps(props, self:getAllNames())
+	end
+end
+exports.Render = TS.import(script, script, "helpers").Render
+exports.default = AppManager
+exports.App = App
+exports.Args = Args
+return exports

package/out/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/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,
+}

package/out/types.d.ts

@@ -0,0 +1,34 @@
+// Types
+import type { Args } from "./decorator";
+
+declare namespace Types {
+	type AppRegistryProps = {
+		name: AppNames[number];
+		visible?: boolean;
+		rules?: Rules.All;
+	};
+
+	type AppRegistry = {
+		constructor: new (props: AppProps) => 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 default Types;

package/package.json

@@ -0,0 +1,60 @@
+{
+    "name": "@rbxts/app-forge",
+    "version": "0.0.1",
+    "description": "An App Manager for react",
+    "main": "out/init.lua",
+    "packageManager": "bun@1.3.1",
+    "scripts": {
+        "build": "rbxtsc",
+        "dev": "rbxtsc -w --type game --rojo test.project.json",
+        "login": "bunx npm login --auth-type=legacy"
+
+    },
+    "keywords": [
+        "roact",
+        "react",
+        "roblox-ts"
+    ],
+    "author": "Add your name here",
+    "license": "Add your license here etc. MIT",
+    "repository": {
+        "type": "git",
+        "url": "Add your repository url here"
+    },
+    "bugs": {
+        "url": "add your issues url here"
+    },
+    "types": "out/index.d.ts",
+    "files": [
+        "out",
+        "!**/*.tsbuildinfo",
+        "!**/*.spec.lua",
+        "!**/*.spec.d.ts"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "devDependencies": {
+        "@rbxts/compiler-types": "3.0.0-types.0",
+        "@rbxts/react": "17.3.0-alpha.1",
+        "@rbxts/react-roblox": "17.3.0-alpha.1",
+        "@rbxts/types": "^1.0.891",
+        "@typescript-eslint/eslint-plugin": "^8.46.4",
+        "@typescript-eslint/parser": "^8.46.4",
+        "roblox-ts": "3.0.0",
+        "typescript": "^5.9.3"
+    },
+    "dependencies": {
+        "@rbxts/charm": "^0.10.0",
+        "@rbxts/loners-pretty-react-hooks": "^0.0.3",
+        "@rbxts/react-charm": "^0.3.0",
+        "@rbxts/ripple": "^0.9.3",
+        "@rbxts/services": "^1.6.0",
+        "@rbxts/set-timeout": "^1.1.2"
+    },
+    "peerDependencies": {
+        "@rbxts/object-utils": "*",
+        "@rbxts/react-roblox": "*",
+        "@rbxts/react": "*"
+    }
+}