@rbxts/app-forge 0.6.0 → 0.7.0

package/out/react/types.d.ts

@@ -0,0 +1,44 @@
+// Types
+import type { Args } from "./decorator";
+import type AppForge from ".";
+
+declare namespace Types {
+	type AppRegistryProps = {
+		name: AppNames;
+		visible?: boolean;
+		rules?: Rules.All;
+	};
+
+	type NameProps =
+		| { name?: AppNames; names?: undefined }
+		| { names?: AppNames[]; name?: undefined };
+
+	type MainProps = {
+		props: AppProps;
+		forge: AppForge;
+		target?: GuiObject | Camera;
+	};
+
+	type ClassProps = AppProps & {
+		forge: AppForge;
+		px: ReturnType<typeof import("@rbxts/loners-pretty-react-hooks").usePx>;
+	};
+
+	type AppRegistry = {
+		constructor: new (props: MainProps) => Args;
+		visible?: boolean;
+		rules?: Rules.All;
+	};
+
+	namespace Rules {
+		type All = {
+			parent?: AppNames;
+		};
+	}
+}
+
+export type MainProps = Types.MainProps;
+export type NameProps = Types.NameProps;
+export type ClassProps = Types.ClassProps;
+
+export default Types;

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;

package/out/vide/classes/rules/exclusiveGroup.luau

@@ -0,0 +1,47 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent.Parent.Parent, "decorator").AppRegistry
+local function ExclusiveGroupRule(entry, forge)
+	local _entry = entry
+	local entryApp = AppRegistry[_entry]
+	local _result = entryApp
+	if _result ~= nil then
+		_result = _result.rules
+		if _result ~= nil then
+			_result = _result.exclusiveGroup
+		end
+	end
+	if not (_result ~= "" and _result) then
+		return nil
+	end
+	local group = entryApp.rules.exclusiveGroup
+	local entrySource = forge:getSource(entry)()
+	if not entrySource then
+		return nil
+	end
+	-- ▼ ReadonlyMap.forEach ▼
+	local _callback = function(app, name)
+		if name == entry then
+			return nil
+		end
+		local _result_1 = app.rules
+		if _result_1 ~= nil then
+			_result_1 = _result_1.exclusiveGroup
+		end
+		if _result_1 ~= group then
+			return nil
+		end
+		if forge:getSource(name)() then
+			forge:close(name, false)
+		end
+	end
+	for _k, _v in AppRegistry do
+		_callback(_v, _k, AppRegistry)
+	end
+	-- ▲ ReadonlyMap.forEach ▲
+end
+return {
+	default = ExclusiveGroupRule,
+}

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

@@ -0,0 +1,7 @@
+import type Types from "../../types";
+import type AppForge from "../..";
+export default class Rules {
+    protected processing: Set<string>;
+    protected renderRules(this: AppForge, name: AppNames, props: Types.Props.Main): void;
+    protected checkRules(this: AppForge, name: AppNames): void;
+}

package/out/vide/classes/rules/init.luau

@@ -0,0 +1,70 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent.Parent, "decorator").AppRegistry
+-- Rules
+local ExclusiveGroupRule = TS.import(script, script, "exclusiveGroup").default
+local ParentRule = TS.import(script, script, "parent").default
+local Rules
+do
+	Rules = setmetatable({}, {
+		__tostring = function()
+			return "Rules"
+		end,
+	})
+	Rules.__index = Rules
+	function Rules.new(...)
+		local self = setmetatable({}, Rules)
+		return self:constructor(...) or self
+	end
+	function Rules:constructor()
+		self.processing = {}
+	end
+	function Rules:renderRules(name, props)
+		local _name = name
+		local appClass = AppRegistry[_name]
+		if not appClass then
+			error(`Failed to get class for app: {name} for renderRules`)
+		end
+		local _result = appClass.rules
+		if _result ~= nil then
+			_result = _result.parent
+		end
+		local _condition = _result
+		if _condition ~= "" and _condition then
+			_condition = not appClass.rules.detach
+		end
+		if _condition ~= "" and _condition then
+			self:anchor(name, appClass.rules.parent, props)
+		end
+		local _result_1 = appClass.rules
+		if _result_1 ~= nil then
+			_result_1 = _result_1.index
+		end
+		if _result_1 ~= 0 and _result_1 == _result_1 and _result_1 then
+			self:index(name, appClass.rules.index)
+		end
+	end
+	function Rules:checkRules(name)
+		local _processing = self.processing
+		local _name = name
+		if _processing[_name] ~= nil then
+			return nil
+		end
+		local _processing_1 = self.processing
+		local _name_1 = name
+		_processing_1[_name_1] = true
+		TS.try(function()
+			ParentRule(name, self)
+			ExclusiveGroupRule(name, self)
+		end, nil, function()
+			local _processing_2 = self.processing
+			local _name_2 = name
+			_processing_2[_name_2] = nil
+		end)
+	end
+end
+return {
+	default = Rules,
+}

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

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

package/out/vide/classes/rules/parent.luau

@@ -0,0 +1,29 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Types
+-- Components
+local AppRegistry = TS.import(script, script.Parent.Parent.Parent, "decorator").AppRegistry
+local function ParentRule(entry, forge)
+	local entrySource = forge:getSource(entry)()
+	-- ▼ ReadonlyMap.forEach ▼
+	local _callback = function(app, name)
+		local rules = app.rules
+		if not rules or rules.parent ~= entry then
+			return nil
+		end
+		if name == entry then
+			return nil
+		end
+		local childSource = forge:getSource(name)()
+		if not entrySource and childSource then
+			forge:close(name, false)
+		end
+	end
+	for _k, _v in AppRegistry do
+		_callback(_v, _k, AppRegistry)
+	end
+	-- ▲ ReadonlyMap.forEach ▲
+end
+return {
+	default = ParentRule,
+}

package/out/vide/context.d.ts

@@ -0,0 +1,7 @@
+declare const Contexts: {
+    readonly App: import("@rbxts/vide").Context<{
+        forge: import(".").default;
+        px: typeof import("@rbxts/loners-pretty-vide-utils").px;
+    } | undefined>;
+};
+export default Contexts;

package/out/vide/context.luau

@@ -0,0 +1,12 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+local context = TS.import(script, TS.getModule(script, "@rbxts", "vide").src).context
+-- Types
+local Contexts = {
+	App = context(nil),
+}
+local default = Contexts
+return {
+	default = default,
+}

package/out/vide/decorator.d.ts

@@ -0,0 +1,13 @@
+import Vide from "@rbxts/vide";
+import type Types from "./types";
+import type AppForge from ".";
+export declare const AppRegistry: Map<string, Types.AppRegistry.Static>;
+export declare function App<N extends AppNames>(props: Types.AppRegistry.Props<N>): <T extends new (props: Types.Props.Main, name: AppNames) => Args>(constructor: T) => T;
+export declare abstract class Args {
+    readonly forge: AppForge;
+    readonly props: Types.Props.Class;
+    readonly name: AppNames;
+    readonly source: Vide.Source<boolean>;
+    constructor(props: Types.Props.Main, name: AppNames);
+    abstract render(): Vide.Node;
+}

package/out/vide/decorator.luau

@@ -0,0 +1,44 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Packages
+local px = TS.import(script, TS.getModule(script, "@rbxts", "loners-pretty-vide-utils").out).px
+-- 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,
+			renderGroup = props.renderGroup,
+			visible = props.visible,
+			rules = props.rules,
+		}
+		AppRegistry[_name_1] = _arg1
+		return constructor
+	end
+end
+local Args
+do
+	Args = {}
+	function Args:constructor(props, name)
+		local _binding = props
+		local forge = _binding.forge
+		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.source = forge:getSource(name)
+	end
+end
+return {
+	App = App,
+	AppRegistry = AppRegistry,
+	Args = Args,
+}

package/out/vide/hooks/useAppContext.d.ts

@@ -0,0 +1,5 @@
+declare const _default: () => {
+    forge: import("..").default;
+    px: typeof import("@rbxts/loners-pretty-vide-utils").px;
+};
+export default _default;

package/out/vide/hooks/useAppContext.luau

@@ -0,0 +1,14 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+-- Components
+local Contexts = TS.import(script, script.Parent.Parent, "context").default
+local default = function()
+	local context = Contexts.App()
+	if not context then
+		error(`Failed to retrieve App Props for Vide {debug.traceback()}`)
+	end
+	return context
+end
+return {
+	default = default,
+}

package/out/vide/index.d.ts

@@ -0,0 +1,30 @@
+import Vide from "@rbxts/vide";
+import Renders from "./classes/renders";
+import Types from "./types";
+type Destructor = () => void;
+type Loaded = {
+    container: Vide.Node;
+    render: Vide.Node;
+    anchor?: Vide.Node;
+};
+export default class AppForge extends Renders {
+    protected sources: Map<string, Vide.Source<boolean>>;
+    protected loaded: Map<string, Loaded>;
+    protected innerMount?: Destructor;
+    protected __px: boolean;
+    constructor();
+    protected createSource(name: AppNames): typeof Vide.source | undefined;
+    isLoaded(name: AppNames): boolean;
+    bind(name: AppNames, value: Vide.Source<boolean>): void;
+    anchor(name: AppNames, anchorName: AppNames, props: Types.Props.Main): void;
+    index(name: AppNames, index: number): 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;
+    toggle(name: AppNames, rules?: boolean): void;
+    story(props: Types.Props.Main): Frame;
+    mount(callback: () => Vide.Node, props: Types.Props.Main, target: Instance): Destructor;
+    unMount(): void;
+}
+export {};