@ecsframework/core 0.0.1

package/out/framework/init.luau

@@ -0,0 +1,295 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local _core = TS.import(script, TS.getModule(script, "@flamework", "core").out)
+local Modding = _core.Modding
+local Reflect = _core.Reflect
+local world = TS.import(script, TS.getModule(script, "@rbxts", "jecs").jecs).world
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local DependenciesContainer = TS.import(script, script, "dependencies-container").DependenciesContainer
+local start = TS.import(script, script, "flamecs").start
+local _registry = TS.import(script, script, "flamecs", "registry")
+local hookListeners = _registry.hookListeners
+local initWorld = _registry.initWorld
+local reserve = _registry.reserve
+local scheduleComponent = _registry.scheduleComponent
+local _utilities = TS.import(script, script, "utilities")
+local ApplyClassComponentMeta = _utilities.ApplyClassComponentMeta
+local GetIdentifier = _utilities.GetIdentifier
+local function getCachedMethod(instance, methodName)
+	return instance[methodName]
+end
+local ECSFramework
+do
+	ECSFramework = setmetatable({}, {
+		__tostring = function()
+			return "ECSFramework"
+		end,
+	})
+	ECSFramework.__index = ECSFramework
+	function ECSFramework.new(...)
+		local self = setmetatable({}, ECSFramework)
+		return self:constructor(...) or self
+	end
+	function ECSFramework:constructor(container)
+		if container == nil then
+			container = DependenciesContainer.new()
+		end
+		self.container = container
+		self.systems = {}
+		self.canCallEffect = true
+		self.isStarted = false
+		self.componentsMap = {}
+		self.components = {}
+		self.signals = {
+			added = {},
+			changed = {},
+			removed = {},
+		}
+		self.baseSystemCtor = Modding.getObjectFromId("$ecsframework:core:framework/base-system@BaseSystem")
+		container:Register(function()
+			return self
+		end, "$ecsframework:core:framework/init@ECSFramework")
+		container:Register(function()
+			return container
+		end, "$ecsframework:core:framework/dependencies-container@DependenciesContainer")
+		self:initComponents()
+		self.world = world()
+		self:initComponentLifecycles()
+		container:Register(function()
+			return self.world
+		end, "@rbxts/jecs:jecs@World")
+	end
+	function ECSFramework:GetAllComponents()
+		-- ▼ ReadonlyMap.size ▼
+		local _size = 0
+		for _ in self.componentsMap do
+			_size += 1
+		end
+		-- ▲ ReadonlyMap.size ▲
+		if _size > 0 then
+			return self.components
+		end
+		local _result = Reflect.getOwnMetadata(self.baseSystemCtor, "ECSFramework:Components")
+		if _result ~= nil then
+			-- ▼ ReadonlyArray.map ▼
+			local _newValue = table.create(#_result)
+			local _callback = function(ctor)
+				local options = Reflect.getOwnMetadata(ctor, "ECSFramework:ComponentOptions")
+				if not options then
+					warn(`Component {ctor} is missing ECSComponentOptions.`)
+					return nil
+				end
+				if options.RunContext ~= nil and options.RunContext ~= 2 and (if RunService:IsServer() then 0 else 1) ~= options.RunContext then
+					return nil
+				end
+				local _exp = (self.componentsMap)
+				local _arg0 = GetIdentifier(ctor)
+				local _ctor = ctor
+				_exp[_arg0] = _ctor
+				return ctor
+			end
+			for _k, _v in _result do
+				_newValue[_k] = _callback(_v, _k - 1, _result)
+			end
+			-- ▲ ReadonlyArray.map ▲
+			-- ▼ ReadonlyArray.filterUndefined ▼
+			local _length = 0
+			for _i in _newValue do
+				if _i > _length then
+					_length = _i
+				end
+			end
+			local _result_1 = {}
+			local _resultLength = 0
+			for _i = 1, _length do
+				local _v = _newValue[_i]
+				if _v ~= nil then
+					_resultLength += 1
+					_result_1[_resultLength] = _v
+				end
+			end
+			-- ▲ ReadonlyArray.filterUndefined ▲
+			_result = _result_1
+		end
+		local _condition = _result
+		if _condition == nil then
+			_condition = {}
+		end
+		self.components = _condition
+		return self.components
+	end
+	function ECSFramework:initSystems()
+		local systems = Reflect.getMetadata(self.baseSystemCtor, "ECSFramework:Systems") or {}
+		local _exp = self.container:InstantiateGroup(systems, true)
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#_exp)
+		local _callback = function(instance)
+			local options = Reflect.getOwnMetadata(getmetatable(instance), "ECSFramework:Options") or {}
+			if options.RunContext ~= nil and options.RunContext ~= 2 and (if RunService:IsServer() then 0 else 1) ~= options.RunContext then
+				return nil
+			end
+			return {
+				Instance = instance,
+				OnStartup = getCachedMethod(instance, "OnStartup"),
+				OnEffect = getCachedMethod(instance, "OnEffect"),
+				OnUpdate = getCachedMethod(instance, "OnUpdate"),
+				Options = options,
+			}
+		end
+		for _k, _v in _exp do
+			_newValue[_k] = _callback(_v, _k - 1, _exp)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		-- ▼ ReadonlyArray.filterUndefined ▼
+		local _length = 0
+		for _i in _newValue do
+			if _i > _length then
+				_length = _i
+			end
+		end
+		local _result = {}
+		local _resultLength = 0
+		for _i = 1, _length do
+			local _v = _newValue[_i]
+			if _v ~= nil then
+				_resultLength += 1
+				_result[_resultLength] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filterUndefined ▲
+		table.sort(_result, function(a, b)
+			local _condition = a.Options.Priority
+			if _condition == nil then
+				_condition = 1
+			end
+			local _condition_1 = b.Options.Priority
+			if _condition_1 == nil then
+				_condition_1 = 1
+			end
+			return _condition > _condition_1
+		end)
+		self.systems = _result
+	end
+	function ECSFramework:invokeStartup()
+		local _exp = self.systems
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback = function(system)
+			start(system.Instance.__hookStates, system.Instance, self.world, function()
+				return system.OnStartup(system.Instance)
+			end)
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k - 1, _exp)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+	end
+	function ECSFramework:initUpdate()
+		RunService.Heartbeat:Connect(function(dt)
+			for _, system in self.systems do
+				start(system.Instance.__hookStates, system.Instance, self.world, function()
+					return system.OnUpdate(system.Instance, dt)
+				end)
+			end
+		end)
+	end
+	function ECSFramework:initComponents()
+		local _exp = self:GetAllComponents()
+		-- ▼ ReadonlyArray.forEach ▼
+		local _callback = function(component)
+			local runtimeId = Reflect.getOwnMetadata(component, "ECSFramework:Id")
+			if runtimeId == nil then
+				error(`Component {component} does not have a runtime id.`)
+			end
+			reserve(self.world, runtimeId, GetIdentifier(component))
+			ApplyClassComponentMeta(component, runtimeId)
+		end
+		for _k, _v in _exp do
+			_callback(_v, _k - 1, _exp)
+		end
+		-- ▲ ReadonlyArray.forEach ▲
+	end
+	function ECSFramework:initComponentLifecycles()
+		-- ▼ ReadonlySet.forEach ▼
+		local _callback = function(component)
+			hookListeners(self.world, component)
+		end
+		for _v in scheduleComponent do
+			_callback(_v, _v, scheduleComponent)
+		end
+		-- ▲ ReadonlySet.forEach ▲
+	end
+	function ECSFramework:initEvents()
+		RunService.Heartbeat:Connect(function()
+			if not self.canCallEffect then
+				return nil
+			end
+			self.canCallEffect = false
+			for _, system in self.systems do
+				start(system.Instance.__hookStates, system.Instance, self.world, function()
+					return system.OnEffect(system.Instance)
+				end)
+			end
+		end)
+		local _exp = self:GetAllComponents()
+		-- ▼ ReadonlyArray.map ▼
+		local _newValue = table.create(#_exp)
+		local _callback = function(obj)
+			local _condition = Reflect.getOwnMetadata(obj, "ECSFramework:Unaffectable")
+			if _condition == nil then
+				_condition = false
+			end
+			local unaffectable = _condition
+			local id = Reflect.getOwnMetadata(obj, "ECSFramework:Id")
+			return if not unaffectable then id else nil
+		end
+		for _k, _v in _exp do
+			_newValue[_k] = _callback(_v, _k - 1, _exp)
+		end
+		-- ▲ ReadonlyArray.map ▲
+		-- ▼ ReadonlyArray.filterUndefined ▼
+		local _length = 0
+		for _i in _newValue do
+			if _i > _length then
+				_length = _i
+			end
+		end
+		local _result = {}
+		local _resultLength = 0
+		for _i = 1, _length do
+			local _v = _newValue[_i]
+			if _v ~= nil then
+				_resultLength += 1
+				_result[_resultLength] = _v
+			end
+		end
+		-- ▲ ReadonlyArray.filterUndefined ▲
+		local reactives = _result
+		for _, ct in reactives do
+			self.world:added(ct, function()
+				self.canCallEffect = true
+			end)
+			self.world:changed(ct, function()
+				self.canCallEffect = true
+			end)
+			self.world:removed(ct, function()
+				self.canCallEffect = true
+			end)
+		end
+	end
+	function ECSFramework:Start()
+		if self.isStarted then
+			return nil
+		end
+		self.isStarted = true
+		-- Init
+		initWorld(self.world)
+		self:initSystems()
+		self:initUpdate()
+		self:initEvents()
+		-- Call events
+		self:invokeStartup()
+	end
+end
+return {
+	ECSFramework = ECSFramework,
+}

package/out/framework/systems/roblox-instance-system.d.ts

@@ -0,0 +1,7 @@
+import { Tag } from "@rbxts/jecs";
+import { BaseSystem } from "../base-system";
+export declare class RobloxInstanceSystem extends BaseSystem {
+    private container;
+    GetEntityFromInstance(instance: Instance): Tag | undefined;
+    OnStartup(): void;
+}

package/out/framework/systems/roblox-instance-system.luau

@@ -0,0 +1,112 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Reflect = TS.import(script, TS.getModule(script, "@flamework", "core").out).Reflect
+local CollectionService = TS.import(script, TS.getModule(script, "@rbxts", "services")).CollectionService
+local BaseSystem = TS.import(script, script.Parent.Parent, "base-system").BaseSystem
+local ECSSystem = TS.import(script, script.Parent.Parent, "decorators", "system").ECSSystem
+local INSTANCE_ATTRIBUTE_ENTITY_ID = TS.import(script, script.Parent.Parent, "utilities").INSTANCE_ATTRIBUTE_ENTITY_ID
+local InjectType = TS.import(script, script.Parent.Parent, "decorators", "inject-type").InjectType
+local RobloxInstanceSystem
+do
+	local super = BaseSystem
+	RobloxInstanceSystem = setmetatable({}, {
+		__tostring = function()
+			return "RobloxInstanceSystem"
+		end,
+		__index = super,
+	})
+	RobloxInstanceSystem.__index = RobloxInstanceSystem
+	function RobloxInstanceSystem.new(...)
+		local self = setmetatable({}, RobloxInstanceSystem)
+		return self:constructor(...) or self
+	end
+	function RobloxInstanceSystem:constructor(...)
+		super.constructor(self, ...)
+	end
+	function RobloxInstanceSystem:GetEntityFromInstance(instance)
+		local id = instance:GetAttribute(INSTANCE_ATTRIBUTE_ENTITY_ID)
+		return id
+	end
+	function RobloxInstanceSystem:OnStartup()
+		self:Added("$ecsframework:core:framework/components/roblox-instance-component@RobloxInstanceComponent"):connect(function(entity, data)
+			data.Instance:SetAttribute(INSTANCE_ATTRIBUTE_ENTITY_ID, entity)
+		end)
+		self:Removed("$ecsframework:core:framework/components/roblox-instance-component@RobloxInstanceComponent"):connect(function(entity)
+			local _result = self:GetComponent(entity, "$ecsframework:core:framework/components/roblox-instance-component@RobloxInstanceComponent")
+			if _result ~= nil then
+				_result = _result.Instance:Destroy()
+			end
+		end)
+		for component in self:Each("$ecsframework:core:framework/decorators/tagged@TaggedInstance") do
+			local options = self:GetComponent(component, "$ecsframework:core:framework/decorators/tagged@TaggedInstance")
+			local key = self:GetComponentKey(component)
+			local _exp = CollectionService:GetTagged(options.Tag)
+			-- ▼ ReadonlyArray.forEach ▼
+			local _callback = function(instance)
+				local _condition = self:GetEntityFromInstance(instance)
+				if _condition == nil then
+					_condition = self.world:entity()
+				end
+				local entity = _condition
+				self:SetComponent(entity, options.OnCreateData(instance, self.world, self.container), key)
+				self:SetComponent(entity, {
+					Instance = instance,
+				}, "$ecsframework:core:framework/components/roblox-instance-component@RobloxInstanceComponent")
+				instance.AncestryChanged:Once(function(_, parent)
+					if parent ~= nil then
+						return nil
+					end
+					if not self:ExistEntity(entity) then
+						return nil
+					end
+					self:DespawnEntity(entity)
+				end)
+			end
+			for _k, _v in _exp do
+				_callback(_v, _k - 1, _exp)
+			end
+			-- ▲ ReadonlyArray.forEach ▲
+			CollectionService:GetInstanceAddedSignal(options.Tag):Connect(function(instance)
+				local _condition = self:GetEntityFromInstance(instance)
+				if _condition == nil then
+					_condition = self.world:entity()
+				end
+				local entity = _condition
+				self:SetComponent(entity, options.OnCreateData(instance, self.world, self.container), key)
+				self:SetComponent(entity, {
+					Instance = instance,
+				}, "$ecsframework:core:framework/components/roblox-instance-component@RobloxInstanceComponent")
+				instance.AncestryChanged:Once(function(_, parent)
+					if parent ~= nil then
+						return nil
+					end
+					if not self:ExistEntity(entity) then
+						return nil
+					end
+					self:DespawnEntity(entity)
+				end)
+			end)
+			CollectionService:GetInstanceRemovedSignal(options.Tag):Connect(function(instance)
+				local entity = self:GetEntityFromInstance(instance)
+				if entity == nil then
+					return nil
+				end
+				self:RemoveComponent(entity, key)
+			end)
+		end
+	end
+	do
+		-- (Flamework) RobloxInstanceSystem metadata
+		Reflect.defineMetadata(RobloxInstanceSystem, "identifier", "$ecsframework:core:framework/systems/roblox-instance-system@RobloxInstanceSystem")
+		-- (Flamework) RobloxInstanceSystem.container metadata
+		Reflect.defineMetadata(RobloxInstanceSystem, "flamework:type", "$ecsframework:core:framework/dependencies-container@DependenciesContainer", "container")
+	end
+	RobloxInstanceSystem = ECSSystem({
+		Priority = -math.huge,
+	})(RobloxInstanceSystem) or RobloxInstanceSystem
+end
+-- (Flamework) RobloxInstanceSystem.container decorators
+Reflect.decorate(RobloxInstanceSystem, "$ecsframework:core:framework/decorators/inject-type@InjectType", InjectType, {}, "container", false)
+return {
+	RobloxInstanceSystem = RobloxInstanceSystem,
+}

package/out/framework/utilities.d.ts

@@ -0,0 +1,17 @@
+import { Constructor } from "@flamework/core/out/utility";
+import { Entity } from "./flamecs";
+import { ResolveKey } from "./flamecs/registry";
+export declare function GetIdentifier(obj: object, suffix?: string): string;
+export declare const GetClassName: (object: object) => string;
+export declare function getDeferredConstructor<T extends object>(ctor: Constructor<T>): readonly [InstanceType<T>, (...args: ConstructorParameters<Constructor<T>>) => void];
+export type VoidCallback = () => void;
+export declare const enum RunContext {
+    Server = 0,
+    Client = 1,
+    Shared = 2
+}
+export declare const INSTANCE_ATTRIBUTE_ENTITY_ID: string;
+export declare const SERVER_ATTRIBUTE_ENTITY_ID = "__Server_EntityId";
+/** @metadata macro */
+export declare function DefineClassComponentMeta<T>(ctor: Constructor, value?: unknown, key?: ResolveKey<T>): void;
+export declare function ApplyClassComponentMeta(ctor: Constructor, componentRuntimeId: Entity): void;

package/out/framework/utilities.luau

@@ -0,0 +1,69 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local Reflect = TS.import(script, TS.getModule(script, "@flamework", "core").out).Reflect
+local meta = TS.import(script, TS.getModule(script, "@rbxts", "jecs").jecs).meta
+local getId = TS.import(script, script.Parent, "flamecs", "registry").getId
+local RunService = TS.import(script, TS.getModule(script, "@rbxts", "services")).RunService
+local function GetIdentifier(obj, suffix)
+	if suffix == nil then
+		suffix = ""
+	end
+	local _condition = Reflect.getMetadata(obj, "identifier")
+	if _condition == nil then
+		_condition = `UnidentifiedFlameworkListener{suffix}`
+	end
+	return _condition
+end
+local GetClassName = function(object)
+	return `{getmetatable(object)}`
+end
+local function getDeferredConstructor(ctor)
+	local obj = setmetatable({}, ctor)
+	return { obj, function(...)
+		local args = { ... }
+		local result = obj:constructor(unpack(args))
+		local _arg0 = result == nil or result == obj
+		local _arg1 = `Deferred constructors are not allowed to return values.`
+		assert(_arg0, _arg1)
+	end }
+end
+local INSTANCE_ATTRIBUTE_ENTITY_ID = `__{if RunService:IsServer() then "Server" else "Client"}_EntityId`
+local SERVER_ATTRIBUTE_ENTITY_ID = `__Server_EntityId`
+--* @metadata macro 
+local function DefineClassComponentMeta(ctor, value, key)
+	local metadata = { key, value }
+	local datas = Reflect.getOwnMetadata(ctor, "ECSFramework:Meta") or {}
+	local _exp = ctor
+	local _array = {}
+	local _length = #_array
+	local _datasLength = #datas
+	table.move(datas, 1, _datasLength, _length + 1, _array)
+	_length += _datasLength
+	_array[_length + 1] = metadata
+	Reflect.defineMetadata(_exp, "ECSFramework:Meta", _array)
+end
+local function ApplyClassComponentMeta(ctor, componentRuntimeId)
+	local datas = Reflect.getOwnMetadata(ctor, "ECSFramework:Meta")
+	if datas == nil then
+		return nil
+	end
+	-- ▼ ReadonlyArray.forEach ▼
+	local _callback = function(_param)
+		local key = _param[1]
+		local value = _param[2]
+		meta(componentRuntimeId, getId(nil, key), value)
+	end
+	for _k, _v in datas do
+		_callback(_v, _k - 1, datas)
+	end
+	-- ▲ ReadonlyArray.forEach ▲
+end
+return {
+	GetIdentifier = GetIdentifier,
+	getDeferredConstructor = getDeferredConstructor,
+	DefineClassComponentMeta = DefineClassComponentMeta,
+	ApplyClassComponentMeta = ApplyClassComponentMeta,
+	GetClassName = GetClassName,
+	INSTANCE_ATTRIBUTE_ENTITY_ID = INSTANCE_ATTRIBUTE_ENTITY_ID,
+	SERVER_ATTRIBUTE_ENTITY_ID = SERVER_ATTRIBUTE_ENTITY_ID,
+}

package/out/index.d.ts

@@ -0,0 +1,19 @@
+export { ECSFramework } from "./framework";
+export { Flamework } from "@flamework/core";
+export { ECSComponent } from "./framework/decorators/component";
+export { ECSSystem } from "./framework/decorators/system";
+export { InjectType } from "./framework/decorators/inject-type";
+export { Unaffectable } from "./framework/decorators/unaffectable";
+export { Tagged } from "./framework/decorators/tagged";
+export { BaseSystem } from "./framework/base-system";
+export { DestroyComponent } from "./framework/components/destroyed-component";
+export { RobloxInstanceComponent } from "./framework/components/roblox-instance-component";
+export { RobloxInstanceSystem } from "./framework/systems/roblox-instance-system";
+export { RunContext, DefineClassComponentMeta, ApplyClassComponentMeta, INSTANCE_ATTRIBUTE_ENTITY_ID, SERVER_ATTRIBUTE_ENTITY_ID } from "./framework/utilities";
+export * from "./framework/hooks/query-change";
+export { useAdded } from "./framework/hooks/use-added";
+export { useRemoved } from "./framework/hooks/use-removed";
+export { useChanged } from "./framework/hooks/use-changed";
+export { useEvent } from "./framework/hooks/use-event";
+export { useThrottle } from "./framework/hooks/use-throttle";
+export * from "./framework/flamecs";

package/out/init.luau

@@ -0,0 +1,30 @@
+-- Compiled with roblox-ts v3.0.0
+local TS = _G[script]
+local exports = {}
+exports.ECSFramework = TS.import(script, script, "framework").ECSFramework
+exports.Flamework = TS.import(script, TS.getModule(script, "@flamework", "core").out).Flamework
+exports.ECSComponent = TS.import(script, script, "framework", "decorators", "component").ECSComponent
+exports.ECSSystem = TS.import(script, script, "framework", "decorators", "system").ECSSystem
+exports.InjectType = TS.import(script, script, "framework", "decorators", "inject-type").InjectType
+exports.Unaffectable = TS.import(script, script, "framework", "decorators", "unaffectable").Unaffectable
+exports.Tagged = TS.import(script, script, "framework", "decorators", "tagged").Tagged
+exports.BaseSystem = TS.import(script, script, "framework", "base-system").BaseSystem
+exports.RobloxInstanceComponent = TS.import(script, script, "framework", "components", "roblox-instance-component").RobloxInstanceComponent
+exports.RobloxInstanceSystem = TS.import(script, script, "framework", "systems", "roblox-instance-system").RobloxInstanceSystem
+local _utilities = TS.import(script, script, "framework", "utilities")
+exports.DefineClassComponentMeta = _utilities.DefineClassComponentMeta
+exports.ApplyClassComponentMeta = _utilities.ApplyClassComponentMeta
+exports.INSTANCE_ATTRIBUTE_ENTITY_ID = _utilities.INSTANCE_ATTRIBUTE_ENTITY_ID
+exports.SERVER_ATTRIBUTE_ENTITY_ID = _utilities.SERVER_ATTRIBUTE_ENTITY_ID
+for _k, _v in TS.import(script, script, "framework", "hooks", "query-change") or {} do
+	exports[_k] = _v
+end
+exports.useAdded = TS.import(script, script, "framework", "hooks", "use-added").useAdded
+exports.useRemoved = TS.import(script, script, "framework", "hooks", "use-removed").useRemoved
+exports.useChanged = TS.import(script, script, "framework", "hooks", "use-changed").useChanged
+exports.useEvent = TS.import(script, script, "framework", "hooks", "use-event").useEvent
+exports.useThrottle = TS.import(script, script, "framework", "hooks", "use-throttle").useThrottle
+for _k, _v in TS.import(script, script, "framework", "flamecs") or {} do
+	exports[_k] = _v
+end
+return exports

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@ecsframework/core",
+  "version": "0.0.1",
+  "description": "",
+  "main": "out/init.lua",
+  "scripts": {
+    "build": "rbxtsc",
+    "watch": "rbxtsc -w",
+    "test:watch": "rbxtsc -w --type=game -p test -i test/include",
+    "serve": "rojo serve test/default.project.json",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "types": "out/index.d.ts",
+  "files": [
+    "out",
+    "!**/*.tsbuildinfo",
+    "!**/*.spec.lua"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@rbxts/compiler-types": "^3.0.0-types.0",
+    "@rbxts/types": "^1.0.876",
+    "@typescript-eslint/eslint-plugin": "^8.39.1",
+    "@typescript-eslint/parser": "^8.39.1",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.4",
+    "eslint-plugin-roblox-ts": "^1.1.0",
+    "prettier": "^3.6.2",
+    "roblox-ts": "^3.0.0",
+    "typescript": "^5.5.3"
+  },
+  "dependencies": {
+    "@rbxts/immut": "^0.4.4-ts.0",
+    "@rbxts/jecs": "^0.9.0-rc.10",
+    "@rbxts/services": "^1.5.5",
+    "@rbxts/signal": "^1.1.1"
+  },
+  "peerDependencies": {
+    "@flamework/core": "*",
+    "rbxts-transformer-flamework": "*"
+  }
+}