@ecsframework/core 0.0.1

package/out/framework/dependencies-container.d.ts

@@ -0,0 +1,21 @@
+import { Modding } from "@flamework/core";
+import { Constructor } from "@flamework/core/out/utility";
+export declare class DependenciesContainer {
+    private factories;
+    private instances;
+    private wrapConstructorInFactory;
+    /** @metadata macro */
+    Register<T extends object>(ctor: Constructor<T>, spec?: Modding.Intrinsic<"symbol-id", [T], string>): void;
+    /** @metadata macro */
+    Register<T>(factory: () => T, spec?: Modding.Intrinsic<"symbol-id", [T], string>): void;
+    /** @metadata macro */
+    Unregister<T>(spec?: Modding.Generic<T, "id">): void;
+    private resolve;
+    /** @metadata macro */
+    Resolve<T>(spec?: Modding.Generic<T, "id">): {};
+    Inject(instance: object, handle?: (injecting: unknown) => void): void;
+    Instantiate<T extends object>(ctor: Constructor<T>, ...args: ConstructorParameters<Constructor<T>>): T;
+    InstantiateGroup(ctors: Constructor[], isRegister?: boolean): object[];
+    InstantiateWithoutConstruct<T extends object>(ctor: Constructor<T>): readonly [T, (...args: ConstructorParameters<Constructor<T>>) => void, () => void];
+    Clear(): void;
+}

package/out/framework/dependencies-container.luau

@@ -0,0 +1,169 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _utilities = TS.import(script, script.Parent, "utilities")
+local GetClassName = _utilities.GetClassName
+local getDeferredConstructor = _utilities.getDeferredConstructor
+local GetIdentifier = _utilities.GetIdentifier
+local GetInjectTypes = TS.import(script, script.Parent, "decorators", "inject-type").GetInjectTypes
+local DependenciesContainer
+do
+	DependenciesContainer = setmetatable({}, {
+		__tostring = function()
+			return "DependenciesContainer"
+		end,
+	})
+	DependenciesContainer.__index = DependenciesContainer
+	function DependenciesContainer.new(...)
+		local self = setmetatable({}, DependenciesContainer)
+		return self:constructor(...) or self
+	end
+	function DependenciesContainer:constructor()
+		self.factories = {}
+		self.instances = {}
+	end
+	function DependenciesContainer:wrapConstructorInFactory(ctor)
+		return function()
+			local _instances = self.instances
+			local _ctor = ctor
+			if _instances[_ctor] ~= nil then
+				local _instances_1 = self.instances
+				local _ctor_1 = ctor
+				return _instances_1[_ctor_1]
+			end
+			local instance = self:Instantiate(ctor)
+			local _instances_1 = self.instances
+			local _ctor_1 = ctor
+			_instances_1[_ctor_1] = instance
+			return instance
+		end
+	end
+	function DependenciesContainer:Register(factoryOrCtor, spec)
+		local _spec = spec
+		assert(_spec ~= "" and _spec)
+		local _factoryOrCtor = factoryOrCtor
+		local factory = if type(_factoryOrCtor) == "function" then factoryOrCtor else self:wrapConstructorInFactory(factoryOrCtor)
+		local _factories = self.factories
+		local _arg0 = `{spec}`
+		_factories[_arg0] = factory
+	end
+	function DependenciesContainer:Unregister(spec)
+		local _spec = spec
+		assert(_spec ~= "" and _spec)
+		local _factories = self.factories
+		local _spec_1 = spec
+		_factories[_spec_1] = nil
+	end
+	function DependenciesContainer:resolve(spec, ctor)
+		local _factories = self.factories
+		local _spec = spec
+		local _result = _factories[_spec]
+		if _result ~= nil then
+			_result = _result()
+		end
+		local result = _result
+		local _result_1 = result
+		local _arg1 = `No factory for {spec}`
+		assert(_result_1 ~= 0 and _result_1 == _result_1 and _result_1 ~= "" and _result_1, _arg1)
+		return result
+	end
+	function DependenciesContainer:Resolve(spec)
+		return self:resolve(spec)
+	end
+	function DependenciesContainer:Inject(instance, handle)
+		local injectedTypes = GetInjectTypes(instance)
+		if not injectedTypes then
+			return nil
+		end
+		-- ▼ ReadonlyMap.forEach ▼
+		local _callback = function(specType, fieldName)
+			local injectedType = self:resolve(specType, getmetatable(instance))
+			local _result = handle
+			if _result ~= nil then
+				_result(injectedType)
+			end
+			instance[fieldName] = injectedType
+		end
+		for _k, _v in injectedTypes do
+			_callback(_v, _k, injectedTypes)
+		end
+		-- ▲ ReadonlyMap.forEach ▲
+	end
+	function DependenciesContainer:Instantiate(ctor, ...)
+		local args = { ... }
+		local _binding = getDeferredConstructor(ctor)
+		local instance = _binding[1]
+		local construct = _binding[2]
+		self:Inject(instance)
+		construct(unpack(args))
+		return instance
+	end
+	function DependenciesContainer:InstantiateGroup(ctors, isRegister)
+		if isRegister == nil then
+			isRegister = false
+		end
+		local injects = {}
+		local constructructs = {}
+		local instances = {}
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback = function(ctor)
+			local _binding = self:InstantiateWithoutConstruct(ctor)
+			local instance = _binding[1]
+			local construct = _binding[2]
+			local inject = _binding[3]
+			table.insert(instances, instance)
+			table.insert(injects, inject)
+			table.insert(constructructs, construct)
+		end
+		for _k, _v in ctors do
+			_callback(_v, _k - 1, ctors)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+		if isRegister then
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback_1 = function(instance)
+				local id = GetIdentifier(instance)
+				local _arg1 = `No identifier for {GetClassName(instance)}`
+				assert(id ~= "" and id, _arg1)
+				self:Register(function()
+					return instance
+				end, id)
+			end
+			for _k, _v in instances do
+				_callback_1(_v, _k - 1, instances)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+		end
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback_1 = function(inject)
+			return inject()
+		end
+		for _k, _v in injects do
+			_callback_1(_v, _k - 1, injects)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback_2 = function(construct)
+			return construct()
+		end
+		for _k, _v in constructructs do
+			_callback_2(_v, _k - 1, constructructs)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+		return instances
+	end
+	function DependenciesContainer:InstantiateWithoutConstruct(ctor)
+		local _binding = getDeferredConstructor(ctor)
+		local instance = _binding[1]
+		local construct = _binding[2]
+		return { instance, construct, function()
+			return self:Inject(instance)
+		end }
+	end
+	function DependenciesContainer:Clear()
+		table.clear(self.factories)
+		table.clear(self.instances)
+	end
+end
+return {
+	DependenciesContainer = DependenciesContainer,
+}

package/out/framework/flamecs/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./query";
+export * from "./registry";
+export type * from "./registry";
+export * from "./topo";

package/out/framework/flamecs/init.luau

@@ -0,0 +1,13 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+for _k, _v in TS.import(script, script, "query") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "registry") or {} do
+	exports[_k] = _v
+end
+for _k, _v in TS.import(script, script, "topo") or {} do
+	exports[_k] = _v
+end
+return exports

package/out/framework/flamecs/query.d.ts

@@ -0,0 +1,55 @@
+import * as ecs from "@rbxts/jecs";
+import type { ComponentKey, Entity, Id, ResolveKeys, ResolveValues, Unwrap } from "./registry";
+export interface Without<T> {
+    _flamecs_without: T;
+}
+export interface With<T> {
+    _flamecs_with: T;
+}
+export type Skip<T extends Array<unknown>> = T extends [unknown, ...infer R] ? R : [];
+export interface Bounds {
+    query: Array<unknown>;
+    with: Array<unknown>;
+    without: Array<unknown>;
+}
+export type BoundsTuple<T> = T extends {
+    length: number;
+} & ReadonlyArray<unknown> ? T : [];
+export type PushBound<B extends Bounds, K extends keyof B, V> = Omit<B, K> & Record<K, V extends ReadonlyArray<unknown> ? [...BoundsTuple<B[K]>, ...V] : [...BoundsTuple<B[K]>, V]>;
+export type Calculate<T extends Array<unknown>, B extends Bounds = Bounds> = T extends [] ? {
+    [k in keyof B]: BoundsTuple<B[k]>;
+} : T[0] extends Without<infer V> ? Calculate<Skip<T>, PushBound<B, "without", V>> : T[0] extends With<infer V> ? Calculate<Skip<T>, PushBound<B, "with", V>> : Calculate<Skip<T>, PushBound<B, "query", T[0]>>;
+export type ToIds<T> = T extends [] ? undefined : ResolveKeys<T>;
+export type ExtractQueryTypes<T extends Array<unknown>> = Reconstruct<ResolveValues<Calculate<T>["query"]>>;
+export type QueryHandle<T extends Array<unknown>> = {
+    __iter(): IterableFunction<LuaTuple<[Entity, ...T]>>;
+    registry: ecs.World;
+    filterWith?: Array<Id>;
+    filterWithout?: Array<Id>;
+    /**
+     * Adds a pair with a runtime entity id to the query. The value of the
+     * relationship is appended to the end of the iterator tuple.
+     *
+     * @template P - The type of the predicate component.
+     * @param object - The object component ID to filter.
+     * @param predicate - The optional predicate component key to filter.
+     * @returns A new QueryHandle with the pair filter added.
+     * @metadata macro
+     */
+    pair<P>(object: Entity, predicate?: ComponentKey<P>): QueryHandle<[...T, Unwrap<P>]>;
+    terms?: Array<Id>;
+} & IterableFunction<LuaTuple<[Entity, ...T]>>;
+/**
+ * A world contains entities associated with some components. This function
+ * creates a query handle for retrieving entities that match the specified
+ * components and filters.
+ *
+ * @template T - The types of the components involved in the query.
+ * @param terms - The component IDs to be queried.
+ * @param filterWithout - The component IDs that entities must not have.
+ * @param filterWith - The component IDs that entities must have.
+ * @returns A QueryHandle for chaining additional filters or executing the
+ *   query.
+ * @metadata macro
+ */
+export declare function query<T extends Array<unknown> = []>(registry: ecs.World, terms?: ToIds<Calculate<T>["query"]>, filterWithout?: ToIds<Calculate<T>["without"]>, filterWith?: ToIds<Calculate<T>["with"]>): QueryHandle<ExtractQueryTypes<T>>;

package/out/framework/flamecs/query.luau

@@ -0,0 +1,114 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local ecs = TS.import(script, TS.getModule(script, "@rbxts", "jecs").jecs)
+local _registry = TS.import(script, script.Parent, "registry")
+local component = _registry.component
+local getId = _registry.getId
+-- Almost full credits to @fireboltofdeath for all of these types.
+local function queryPair(self, object, predicate)
+	local _predicate = predicate
+	assert(_predicate ~= "" and _predicate)
+	local id = ecs.pair(component(self.registry, predicate), object)
+	local _result
+	if self.terms then
+		local _array = {}
+		local _length = #_array
+		local _array_1 = self.terms
+		local _Length = #_array_1
+		table.move(_array_1, 1, _Length, _length + 1, _array)
+		_length += _Length
+		_array[_length + 1] = id
+		_result = _array
+	else
+		_result = { id }
+	end
+	self.terms = _result
+	return self
+end
+local function queryIter(self)
+	if self.terms then
+		local ecsQuery = self.registry:query(unpack(self.terms))
+		if self.filterWithout then
+			ecsQuery = ecsQuery:without(unpack(self.filterWithout))
+		end
+		if self.filterWith then
+			ecsQuery = ecsQuery:with(unpack(self.filterWith))
+		end
+		return ecsQuery:iter()
+	end
+	return function()
+		-- Do nothing.
+	end
+end
+--[[
+	*
+	 * A world contains entities associated with some components. This function
+	 * creates a query handle for retrieving entities that match the specified
+	 * components and filters.
+	 *
+	 * @template T - The types of the components involved in the query.
+	 * @param terms - The component IDs to be queried.
+	 * @param filterWithout - The component IDs that entities must not have.
+	 * @param filterWith - The component IDs that entities must have.
+	 * @returns A QueryHandle for chaining additional filters or executing the
+	 *   query.
+	 * @metadata macro
+	 
+]]
+local function query(registry, terms, filterWithout, filterWith)
+	local _processedTerms = terms
+	if _processedTerms ~= nil then
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#_processedTerms)
+		local _callback = function(v)
+			return getId(registry, v)
+		end
+		for _k, _v in _processedTerms do
+			_newValue[_k] = _callback(_v, _k - 1, _processedTerms)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		_processedTerms = _newValue
+	end
+	local processedTerms = _processedTerms
+	local _processedFilterWithout = filterWithout
+	if _processedFilterWithout ~= nil then
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#_processedFilterWithout)
+		local _callback = function(v)
+			return getId(registry, v)
+		end
+		for _k, _v in _processedFilterWithout do
+			_newValue[_k] = _callback(_v, _k - 1, _processedFilterWithout)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		_processedFilterWithout = _newValue
+	end
+	local processedFilterWithout = _processedFilterWithout
+	local _processedFilterWith = filterWith
+	if _processedFilterWith ~= nil then
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#_processedFilterWith)
+		local _callback = function(v)
+			return getId(registry, v)
+		end
+		for _k, _v in _processedFilterWith do
+			_newValue[_k] = _callback(_v, _k - 1, _processedFilterWith)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		_processedFilterWith = _newValue
+	end
+	local processedFilterWith = _processedFilterWith
+	local queryHandle = {
+		registry = registry,
+		__iter = queryIter,
+		filterWith = processedFilterWith,
+		filterWithout = processedFilterWithout,
+		pair = queryPair,
+		terms = processedTerms,
+	}
+	setmetatable(queryHandle, queryHandle)
+	return queryHandle
+end
+return {
+	query = query,
+}