@rbxts/app-forge 0.6.0 → 0.7.0

package/out/vide/init.luau

@@ -0,0 +1,223 @@
+-- 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 _vide = TS.import(script, TS.getModule(script, "@rbxts", "vide").src)
+local apply = _vide.apply
+local create = _vide.create
+local effect = _vide.effect
+local mount = _vide.mount
+local source = _vide.source
+local untrack = _vide.untrack
+-- Classes
+local Renders = TS.import(script, script, "classes", "renders").default
+-- Helpers
+local AppRegistry = TS.import(script, script, "decorator").AppRegistry
+local AppForge
+do
+	local super = Renders
+	AppForge = setmetatable({}, {
+		__tostring = function()
+			return "AppForge"
+		end,
+		__index = super,
+	})
+	AppForge.__index = AppForge
+	function AppForge.new(...)
+		local self = setmetatable({}, AppForge)
+		return self:constructor(...) or self
+	end
+	function AppForge:constructor()
+		super.constructor(self)
+		self.sources = {}
+		self.loaded = {}
+		self.__px = false
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(_, name)
+			return self:createSource(name)
+		end
+		for _k, _v in AppRegistry do
+			_callback(_v, _k, AppRegistry)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+	end
+	function AppForge:createSource(name)
+		local _name = name
+		local app = AppRegistry[_name]
+		if not app then
+			error(`App "{name}" not registered`)
+		end
+		local _sources = self.sources
+		local _name_1 = name
+		if _sources[_name_1] ~= nil then
+			return nil
+		end
+		local _sources_1 = self.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
+	function AppForge:isLoaded(name)
+		local _loaded = self.loaded
+		local _name = name
+		return _loaded[_name] ~= nil
+	end
+	function AppForge:bind(name, value)
+		if not RunService:IsRunning() then
+			local _sources = self.sources
+			local _name = name
+			local _value = value
+			_sources[_name] = _value
+			effect(function()
+				value()
+				untrack(function()
+					return self:checkRules(name)
+				end)
+			end)
+		else
+			warn("forge.bind is used for studio when game isnt running")
+		end
+	end
+	function AppForge:anchor(name, anchorName, props)
+		if name == anchorName then
+			error(`Tried to anchor an App to itself`)
+		end
+		local _anchorName = anchorName
+		local anchorApp = AppRegistry[_anchorName]
+		if not anchorApp then
+			error(`Failed to get class for {anchorName} from AppRegistry for anchor`)
+		end
+		local _loaded = self.loaded
+		local _name = name
+		local _render = _loaded[_name]
+		if _render ~= nil then
+			_render = _render.render
+		end
+		local render = _render
+		if not render then
+			error(`Failed to get {name} from this.loaded for anchor to {anchorName}`)
+		end
+		local anchor = anchorApp.constructor.new(props, anchorName):render()
+		for _, children in anchor:GetDescendants() do
+			children:Destroy()
+		end
+		apply(anchor)({
+			Name = "Anchor",
+			BackgroundTransparency = 1,
+			[0] = render,
+		})
+		local _loaded_1 = self.loaded
+		local _name_1 = name
+		local prev = _loaded_1[_name_1]
+		if not prev then
+			error(`Failed to retreive prev loaded data for {name}`)
+		end
+		apply(prev.container)({
+			[0] = anchor,
+		})
+		local _loaded_2 = self.loaded
+		local _exp = name
+		local _object = table.clone(prev)
+		setmetatable(_object, nil)
+		_object.anchor = anchor
+		_loaded_2[_exp] = _object
+	end
+	function AppForge:index(name, index)
+		local _loaded = self.loaded
+		local _name = name
+		local loaded = _loaded[_name]
+		if not loaded then
+			error(`Failed to retreive loaded data for app: {name}`)
+		end
+		apply(loaded.container)({
+			ZIndex = index,
+		})
+	end
+	function AppForge:getSource(name)
+		local _sources = self.sources
+		local _name = name
+		if not (_sources[_name] ~= nil) then
+			self:createSource(name)
+		end
+		local _sources_1 = self.sources
+		local _name_1 = name
+		return _sources_1[_name_1]
+	end
+	function AppForge:set(name, value, rules)
+		if rules == nil then
+			rules = true
+		end
+		local _sources = self.sources
+		local _name = name
+		local src = _sources[_name]
+		if not src then
+			self:createSource(name)
+			local _sources_1 = self.sources
+			local _name_1 = name
+			src = _sources_1[_name_1]
+		end
+		if src() == value then
+			return nil
+		end
+		src(value)
+		if rules then
+			self:checkRules(name)
+		end
+	end
+	function AppForge:open(name, rules)
+		if rules == nil then
+			rules = true
+		end
+		self:set(name, true, rules)
+	end
+	function AppForge:close(name, rules)
+		if rules == nil then
+			rules = true
+		end
+		self:set(name, false, rules)
+	end
+	function AppForge:toggle(name, rules)
+		if rules == nil then
+			rules = true
+		end
+		self:set(name, not self:getSource(name)(), rules)
+	end
+	function AppForge:story(props)
+		local Container = create("Frame")({
+			Name = "Story Container",
+			BackgroundTransparency = 1,
+			AnchorPoint = Vector2.new(0.5, 0.5),
+			Position = UDim2.fromScale(0.5, 0.5),
+			Size = UDim2.fromScale(1, 1),
+		})
+		apply(Container)({
+			[0] = self:renderMount(props),
+		})
+		return Container
+	end
+	function AppForge:mount(callback, props, target)
+		local Container = callback()
+		self.innerMount = mount(function()
+			apply(Container)({
+				[0] = self:renderMount(props),
+			})
+			return Container
+		end, target)
+		return self.innerMount
+	end
+	function AppForge:unMount()
+		local _result = self.innerMount
+		if _result ~= nil then
+			_result()
+		end
+	end
+end
+return {
+	default = AppForge,
+}

package/out/vide/types.d.ts

@@ -0,0 +1,85 @@
+// Types
+import type { Args } from "./decorator";
+import type AppForge from ".";
+
+declare namespace Types {
+	namespace Props {
+		type Render =
+			| { name?: AppNames; names?: never; group?: never }
+			| { names?: AppNames[]; name?: never; group?: never }
+			| { group?: GroupNames[] | GroupNames; names?: AppNames[]; name?: never }
+			| { group?: GroupNames[] | GroupNames; name?: AppNames; names?: never }
+			| { group?: GroupNames[] | GroupNames; names?: never; name?: never };
+
+		type Main = {
+			props: AppProps;
+			forge: AppForge;
+			config?: {
+				px: {
+					target?: GuiObject | Camera;
+					resolution?: Vector2;
+					minScale?: number;
+				};
+			};
+			render?: Render;
+		};
+
+		type Class = AppProps & {
+			forge: AppForge;
+			px: typeof import("@rbxts/loners-pretty-vide-utils").px;
+		};
+	}
+
+	namespace AppRegistry {
+		type Props<N extends AppNames> = {
+			name: N;
+			visible?: boolean;
+			renderGroup?: GroupNames;
+			rules?: Rules.Generic<N>;
+		};
+
+		type Static = {
+			constructor: new (props: Types.Props.Main, name: AppNames) => Args;
+
+			visible?: boolean;
+			renderGroup?: GroupNames;
+			rules?: Rules.Static;
+		};
+
+		type Generic<N extends AppNames = AppNames> = {
+			constructor: new (props: Types.Props.Main, name: AppNames) => Args;
+
+			visible?: boolean;
+			renderGroup?: GroupNames;
+			rules?: Rules.Generic<N>;
+		};
+	}
+
+	namespace Rules {
+		type WithParent<P> = {
+			parent: P;
+			detach?: boolean;
+		};
+
+		type WithoutParent = {
+			parent?: never;
+			detach?: never;
+		};
+
+		export type Static = {
+			exclusiveGroup?: string;
+			index?: number;
+		} & (WithParent<string> | WithoutParent);
+
+		export type Generic<N extends AppNames = AppNames> = {
+			exclusiveGroup?: GroupNames;
+			index?: number;
+		} & (WithParent<Exclude<AppNames, N>> | WithoutParent);
+	}
+}
+
+export type MainProps = Types.Props.Main;
+export type ClassProps = Types.Props.Class;
+export type RenderProps = Types.Props.Render;
+
+export default Types;

package/package.json

@@ -1,8 +1,9 @@
 {
 	"name": "@rbxts/app-forge",
-	"version": "0.6.0",
-	"description": "An App Manager for react",
+	"version": "0.7.0",
+	"description": "An App Manager for Vide",
 	"main": "out/init.lua",
+	"types": "out/index.d.ts",
 	"packageManager": "bun@1.3.1",
 	"scripts": {
 		"build": "rbxtsc",
@@ -11,7 +12,8 @@
 	},
 	"keywords": [
 		"roblox-ts",
-		"react"
+		"react",
+		"vide"
 	],
 	"author": "loner1536",
 	"license": "MIT",
@@ -22,7 +24,6 @@
 	"bugs": {
 		"url": "https://github.com/Loner1536/AppForge/issues"
 	},
-	"types": "out/index.d.ts",
 	"files": [
 		"out",
 		"!**/*.tsbuildinfo",
@@ -32,23 +33,21 @@
 	"publishConfig": {
 		"access": "public"
 	},
+	"dependencies": {
+		"@rbxts/services": "^1.6.0",
+		"@rbxts/set-timeout": "^1.1.2"
+	},
+	"peerDependencies": {
+		"@rbxts/loners-pretty-react-hooks": "^0.2.9",
+		"@rbxts/loners-pretty-vide-utils": "^0.1.7",
+		"@rbxts/react": "^17.3.7-ts.1",
+		"@rbxts/vide": "^0.5.7"
+	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.3.7",
 		"@rbxts/compiler-types": "3.0.0-types.0",
 		"@rbxts/types": "^1.0.891",
 		"roblox-ts": "3.0.0",
 		"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"
-	},
-	"peerDependencies": {
-		"@rbxts/loners-pretty-vide-utils": "*",
-		"@rbxts/object-utils": "*",
-		"@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;

package/out/helpers.d.ts

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

package/out/helpers.luau

@@ -1,40 +0,0 @@
--- Compiled with roblox-ts v3.0.0
-local TS = _G[script]
--- Packages
-local usePx = TS.import(script, TS.getModule(script, "@rbxts", "loners-pretty-vide-utils").out).usePx
--- Types
-local __px = false
-local function Render(props)
-	local _binding = props
-	local config = _binding.config
-	local name = _binding.name
-	local names = _binding.names
-	local forge = _binding.forge
-	if not __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)
-		__px = true
-	else
-		warn("Rendering twice making a second px")
-	end
-	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/rules.d.ts

@@ -1,12 +0,0 @@
-import Vide from "@rbxts/vide";
-import type AppForge from ".";
-export default class RulesManager {
-    private appManager;
-    constructor(appManager: AppForge);
-    applyRules(name: AppNames[number], source: Vide.Source<boolean> | boolean): boolean;
-    private inSameGroup;
-    private blockedBy;
-    private blocks;
-    private exclusive;
-    private layer;
-}

package/out/rules.luau

@@ -1,198 +0,0 @@
--- 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, source)
-		local _name = name
-		local appData = AppRegistry[_name]
-		local _rules = appData
-		if _rules ~= nil then
-			_rules = _rules.rules
-		end
-		local rules = _rules
-		local _source = source
-		local value = if type(_source) == "function" then source() else source
-		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:getSource(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:getSource(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:getSource(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:getSource(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

@@ -1,59 +0,0 @@
-// 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;
-		config?: {
-			px: {
-				target?: GuiObject | Camera;
-				resolution?: Vector2;
-				minScale?: number;
-			};
-		};
-	};
-
-	type ClassProps = AppProps & {
-		px: typeof import("@rbxts/loners-pretty-vide-utils").px;
-	};
-
-	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 NameProps = Types.NameProps;
-export type MainProps = Types.MainProps;
-export type ClassProps = Types.ClassProps;
-
-export default Types;