@rbxts/app-forge 0.6.0-alpha.71 → 0.6.0-alpha.73

package/README.md

@@ -9,6 +9,8 @@ AppForge is a UI/app orchestration system for Vide/React in Roblox, enabling:
 
 ---
 
+# REACT is PLANNED to be worked on but is NOT recommended ATM
+
 # 📦 Installation
 
 ```bash

package/out/index.d.ts

@@ -3,7 +3,6 @@ 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, RenderProps as VideRenderProps, } from "./vide/types";
 export type { MainProps as ReactProps, ClassProps as ReactClassProps, } from "./react/types";
 export { default as useReactAppContext } from "./react/hooks/useAppContext";

package/out/init.luau

@@ -13,7 +13,6 @@ 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

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

@@ -0,0 +1,15 @@
+import type AppForge from "..";
+import type Types from "../types";
+import Rules from "./rules";
+export default class Renders extends Rules {
+    constructor();
+    private renderNames;
+    private collectByGroup;
+    private normalizeGroups;
+    protected renderApp(this: AppForge, props: Types.Props.Main): ScreenGui | Frame;
+    protected renderApps(this: AppForge, props: Types.Props.Main): (ScreenGui | Frame)[];
+    protected renderGroup(this: AppForge, props: Types.Props.Main): (ScreenGui | Frame)[];
+    protected renderGroupByName(this: AppForge, props: Types.Props.Main): (ScreenGui | Frame)[];
+    protected renderGroupByNames(this: AppForge, props: Types.Props.Main): (ScreenGui | Frame)[];
+    protected renderAll(this: AppForge, props: Types.Props.Main): (ScreenGui | Frame)[];
+}

package/out/vide/classes/renders.luau

@@ -0,0 +1,193 @@
+-- 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 create = TS.import(script, TS.getModule(script, "@rbxts", "vide").src).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)
+	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 instance = appClass.constructor.new(props, name)
+			local _loaded = forge.loaded
+			local _arg1 = instance:render()
+			_loaded[name] = _arg1
+		end
+		local element = forge.loaded[name]
+		if not element then
+			error(`Failed to create instance for app "{name}"`)
+		end
+		if RunService:IsRunning() then
+			return create("ScreenGui")({
+				Name = name,
+				ZIndexBehavior = "Sibling",
+				ResetOnSpawn = false,
+				[0] = element,
+			})
+		else
+			return create("Frame")({
+				Name = name,
+				BackgroundTransparency = 1,
+				Size = UDim2.fromScale(1, 1),
+				[0] = element,
+			})
+		end
+	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/{rules → classes/rules}/exclusiveGroup.d.ts

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

package/out/vide/{rules → classes/rules}/exclusiveGroup.luau

@@ -2,7 +2,7 @@
 local TS = _G[script]
 -- Types
 -- Components
-local AppRegistry = TS.import(script, script.Parent.Parent, "decorator").AppRegistry
+local AppRegistry = TS.import(script, script.Parent.Parent.Parent, "decorator").AppRegistry
 local function ExclusiveGroupRule(entry, forge)
 	local _entry = entry
 	local entryApp = AppRegistry[_entry]

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

@@ -0,0 +1,5 @@
+import type AppForge from "../..";
+export default class Rules {
+    protected processing: Set<string>;
+    protected applyRules(this: AppForge, name: AppNames): void;
+}

package/out/vide/{rules → classes/rules}/init.luau

@@ -4,23 +4,22 @@ local TS = _G[script]
 -- Rules
 local ExclusiveGroupRule = TS.import(script, script, "exclusiveGroup").default
 local ParentRule = TS.import(script, script, "parent").default
-local RulesManager
+local Rules
 do
-	RulesManager = setmetatable({}, {
+	Rules = setmetatable({}, {
 		__tostring = function()
-			return "RulesManager"
+			return "Rules"
 		end,
 	})
-	RulesManager.__index = RulesManager
-	function RulesManager.new(...)
-		local self = setmetatable({}, RulesManager)
+	Rules.__index = Rules
+	function Rules.new(...)
+		local self = setmetatable({}, Rules)
 		return self:constructor(...) or self
 	end
-	function RulesManager:constructor(forge)
-		self.forge = forge
+	function Rules:constructor()
 		self.processing = {}
 	end
-	function RulesManager:applyRules(name)
+	function Rules:applyRules(name)
 		local _processing = self.processing
 		local _name = name
 		if _processing[_name] ~= nil then
@@ -30,8 +29,8 @@ do
 		local _name_1 = name
 		_processing_1[_name_1] = true
 		TS.try(function()
-			ParentRule(name, self.forge)
-			ExclusiveGroupRule(name, self.forge)
+			ParentRule(name, self)
+			ExclusiveGroupRule(name, self)
 		end, nil, function()
 			local _processing_2 = self.processing
 			local _name_2 = name
@@ -40,5 +39,5 @@ do
 	end
 end
 return {
-	default = RulesManager,
+	default = Rules,
 }

package/out/vide/{rules → classes/rules}/parent.d.ts

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

package/out/vide/{rules → classes/rules}/parent.luau

@@ -2,7 +2,7 @@
 local TS = _G[script]
 -- Types
 -- Components
-local AppRegistry = TS.import(script, script.Parent.Parent, "decorator").AppRegistry
+local AppRegistry = TS.import(script, script.Parent.Parent.Parent, "decorator").AppRegistry
 local function ParentRule(entry, forge)
 	local entrySource = forge:getSource(entry)()
 	-- ▼ ReadonlyMap.forEach ▼

package/out/vide/index.d.ts

@@ -1,23 +1,20 @@
 import Vide from "@rbxts/vide";
-import type Types from "./types";
-import { type RenderAPI } from "./helpers";
-export default class AppForge {
-    sources: Map<string, Vide.Source<boolean>>;
-    loaded: Map<string, Vide.Node>;
-    innerMount: () => void;
-    private rulesManager;
-    getSource(name: AppNames): Vide.Source<boolean>;
+import Renders from "./classes/renders";
+import Types from "./types";
+export default class AppForge extends Renders {
+    protected sources: Map<string, Vide.Source<boolean>>;
+    protected loaded: Map<string, Vide.Node>;
+    protected innerMount?: () => void;
+    protected __px: boolean;
+    constructor();
+    protected createSource(name: AppNames): typeof Vide.source | undefined;
+    isLoaded(name: AppNames): boolean;
     bind(name: AppNames, value: Vide.Source<boolean>): void;
+    getSource(name: AppNames): Vide.Source<boolean>;
     set(name: AppNames, value: boolean, rules?: boolean): void;
     open(name: AppNames, rules?: boolean): void;
     close(name: AppNames, rules?: boolean): void;
-    mount(callback: (Render: RenderAPI) => Vide.Node, target: Instance): void;
+    mount(callback: () => Vide.Node, props: Types.Props.Main, target: Instance): void;
     unMount(): void;
     toggle(name: AppNames, rules?: boolean): void;
-    renderApp(props: Types.Props.Main): ScreenGui | Frame;
-    renderApps(props: Types.Props.Main): (ScreenGui | Frame)[];
-    renderGroup(props: Types.Props.Main): (ScreenGui | Frame)[];
-    renderGroupByName(props: Types.Props.Main): (ScreenGui | Frame)[];
-    renderGroupByNames(props: Types.Props.Main): (ScreenGui | Frame)[];
-    renderAll(props: Types.Props.Main): (ScreenGui | Frame)[];
 }

package/out/vide/init.luau

@@ -4,28 +4,24 @@ local TS = _G[script]
 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 effect = _vide.effect
 local mount = _vide.mount
+local source = _vide.source
 local untrack = _vide.untrack
--- Types
--- Components
-local AppContainer = TS.import(script, script, "container").AppContainer
-local AppRegistry = TS.import(script, script, "decorator").AppRegistry
+local usePx = TS.import(script, TS.getModule(script, "@rbxts", "loners-pretty-vide-utils").out).usePx
 -- Classes
-local RulesManager = TS.import(script, script, "rules").default
+local Renders = TS.import(script, script, "classes", "renders").default
 -- Helpers
-local _helpers = TS.import(script, script, "helpers")
-local createSource = _helpers.createSource
-local renderNames = _helpers.renderNames
-local collectByGroup = _helpers.collectByGroup
-local normalizeGroups = _helpers.normalizeGroups
-local Render = _helpers.Render
+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(...)
@@ -33,19 +29,44 @@ do
 		return self:constructor(...) or self
 	end
 	function AppForge:constructor()
+		super.constructor(self)
 		self.sources = {}
 		self.loaded = {}
-		self.rulesManager = RulesManager.new(self)
+		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:getSource(name)
-		local _sources = self.sources
+	function AppForge:createSource(name)
 		local _name = name
-		if not (_sources[_name] ~= nil) then
-			createSource(name, self)
+		local app = AppRegistry[_name]
+		if not app then
+			error(`App "{name}" not registered`)
 		end
-		local _sources_1 = self.sources
+		local _sources = self.sources
 		local _name_1 = name
-		return _sources_1[_name_1]
+		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
@@ -56,25 +77,35 @@ do
 			effect(function()
 				value()
 				untrack(function()
-					return self.rulesManager:applyRules(name)
+					return self:applyRules(name)
 				end)
 			end)
 		else
 			warn("forge.bind is used for studio when game isnt running")
 		end
 	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
 		if rules then
-			self.rulesManager:applyRules(name)
+			self:applyRules(name)
 		end
 		local _sources = self.sources
 		local _name = name
 		local src = _sources[_name]
 		if not src then
-			createSource(name, self)
+			self:createSource(name)
 			local _sources_1 = self.sources
 			local _name_1 = name
 			src = _sources_1[_name_1]
@@ -96,13 +127,72 @@ do
 		end
 		self:set(name, false, rules)
 	end
-	function AppForge:mount(callback, target)
+	function AppForge:mount(callback, props, target)
+		local _binding = props
+		local config = _binding.config
+		local render = _binding.render
+		if not self.__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)
+			self.__px = true
+		else
+			warn("Rendering twice making a second px")
+		end
+		local children
+		if render then
+			local _condition = render.name
+			if _condition ~= "" and _condition then
+				_condition = render.group
+			end
+			if _condition ~= "" and _condition then
+				children = self:renderGroupByName(props)
+			else
+				local _value = render.names and render.group
+				if _value ~= "" and _value then
+					children = self:renderGroupByNames(props)
+				else
+					local _result = render
+					if _result ~= nil then
+						_result = _result.name
+					end
+					if _result ~= "" and _result then
+						children = self:renderApp(props)
+					elseif render.names then
+						children = self:renderApps(props)
+					else
+						local _value_1 = render.group
+						if _value_1 ~= "" and _value_1 then
+							children = self:renderGroup(props)
+						end
+					end
+				end
+			end
+		end
+		children = self:renderAll(props)
+		local Container = callback()
+		apply(Container)({
+			[0] = children,
+		})
 		self.innerMount = mount(function()
-			return callback(Render)
+			return Container
 		end, target)
 	end
 	function AppForge:unMount()
-		self.innerMount()
+		local _result = self.innerMount
+		if _result ~= nil then
+			_result()
+		end
 	end
 	function AppForge:toggle(name, rules)
 		if rules == nil then
@@ -110,71 +200,6 @@ do
 		end
 		self:set(name, not self:getSource(name)(), rules)
 	end
-	function AppForge:renderApp(props)
-		return AppContainer(props)
-	end
-	function AppForge: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 to renderApps")
-		end
-		return renderNames(props, names, self)
-	end
-	function AppForge: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 app names provided to renderApps")
-		end
-		local groups = normalizeGroups(group)
-		return renderNames(props, collectByGroup(groups), self)
-	end
-	function AppForge: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("No app names provided to renderApps")
-		end
-		local groups = normalizeGroups(group)
-		return renderNames(props, collectByGroup(groups, function(n)
-			return n == name
-		end), self)
-	end
-	function AppForge: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("No app names provided to renderApps")
-		end
-		local groups = normalizeGroups(group)
-		return renderNames(props, collectByGroup(groups, function(n)
-			local _n = n
-			return table.find(names, _n) ~= nil
-		end), self)
-	end
-	function AppForge: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 renderNames(props, names, self)
-	end
 end
 return {
 	default = AppForge,

package/out/vide/types.d.ts

@@ -59,11 +59,13 @@ declare namespace Types {
 		type Static = {
 			parent?: string;
 			exclusiveGroup?: string;
+			layer: number;
 		};
 
 		type Generic<N extends AppNames = AppNames> = {
 			parent?: Exclude<AppNames, N>;
 			exclusiveGroup?: GroupNames;
+			layer: number;
 		};
 	}
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rbxts/app-forge",
-	"version": "0.6.0-alpha.71",
+	"version": "0.6.0-alpha.73",
 	"description": "An App Manager for Vide",
 	"main": "out/init.lua",
 	"types": "out/index.d.ts",

package/out/vide/container.d.ts

@@ -1,2 +0,0 @@
-import type Types from "./types";
-export declare function AppContainer(props: Types.Props.Main): ScreenGui | Frame;

package/out/vide/container.luau

@@ -1,68 +0,0 @@
--- 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)
--- Types
--- Components
-local AppRegistry = TS.import(script, script.Parent, "decorator").AppRegistry
-local create = vide.create
-local function createInstance(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 instance = appClass.constructor.new(props, name)
-		local _loaded = forge.loaded
-		local _arg1 = instance:render()
-		_loaded[name] = _arg1
-	end
-	return forge.loaded[name]
-end
-local function AppContainer(props)
-	local _binding = props
-	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 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 create("ScreenGui")({
-			Name = name,
-			ZIndexBehavior = "Sibling",
-			ResetOnSpawn = false,
-			[0] = element,
-		})
-	else
-		return create("Frame")({
-			Name = name,
-			BackgroundTransparency = 1,
-			Size = UDim2.fromScale(1, 1),
-			[0] = element,
-		})
-	end
-end
-return {
-	AppContainer = AppContainer,
-}

package/out/vide/helpers.d.ts

@@ -1,9 +0,0 @@
-import Vide from "@rbxts/vide";
-import type Types from "./types";
-import type AppForge from ".";
-export declare function createSource(name: AppNames, forge: AppForge): typeof Vide.source | undefined;
-export declare function normalizeGroups(group: GroupNames | GroupNames[]): GroupNames[];
-export declare function collectByGroup(groups: GroupNames[], filter?: (name: AppNames) => boolean): AppNames[];
-export declare function renderNames(props: Types.Props.Main, names: AppNames[], forge: AppForge): (ScreenGui | Frame)[];
-export declare function Render(props: Types.Props.Main): Vide.Node;
-export type RenderAPI = typeof Render;

package/out/vide/helpers.luau

@@ -1,156 +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
-local source = TS.import(script, TS.getModule(script, "@rbxts", "vide").src).source
--- Types
--- Components
-local AppRegistry = TS.import(script, script.Parent, "decorator").AppRegistry
-local __px = false
-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 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
-local function 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
-local function 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
-local function Render(props)
-	local _binding = props
-	local config = _binding.config
-	local render = _binding.render
-	local forge = _binding.forge
-	-- ▼ ReadonlyMap.forEach ▼
-	local _callback = function(_, name)
-		return createSource(name, forge)
-	end
-	for _k, _v in AppRegistry do
-		_callback(_v, _k, AppRegistry)
-	end
-	-- ▲ ReadonlyMap.forEach ▲
-	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 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 forge:renderAll(props)
-end
-return {
-	createSource = createSource,
-	normalizeGroups = normalizeGroups,
-	collectByGroup = collectByGroup,
-	renderNames = renderNames,
-	Render = Render,
-}

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

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