Sovereignty/jecs
1
0
Fork 0
mirror of https://github.com/Ukendio/jecs.git synced 2025-04-25 01:20:04 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

fixed typescript types

Browse source
This commit is contained in:
hautajoki 2024-09-09 10:31:53 -07:00
parent 411138e1f7
commit b0321fc92d
1 changed files with 164 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

290
src/index.d.ts vendored
View file

@ -1,142 +1,179 @@
type Query<T extends unknown[]> = { /**
* Represents an entity
* The generic type T defines the data type when this entity is used as a component
*/
export type Entity<T = unknown> = number & { __T: T };
/** export type Pair = number;
* this: Query<T> is necessary to use a colon instead of a period for emits.
*/
export type Id<T = unknown> = Entity<T> | Pair;
/** type FlattenTuple<T extends any[]> = T extends [infer U] ? U : LuaTuple<T>;
* Get the next result in the query. Drain must have been called beforehand or otherwise it will error. type Nullable<T extends unknown[]> = { [K in keyof T]: T[K] | undefined };
*/ type InferComponents<A extends Id[]> = { [K in keyof A]: A[K] extends Id<infer T> ? T : never };
next: (this: Query<T>) => Query<T>; type TupleForWorldGet = [Id] | [Id, Id] | [Id, Id, Id] | [Id, Id, Id, Id];
/**
* Resets the Iterator for a query. type Item<T extends unknown[]> = (this: Query<T>) => LuaTuple<[Entity, ...T]>;
*/
drain: (this: Query<T>) => Query<T> export type Query<T extends unknown[]> = {
/** /**
* Modifies the query to include specified components, but will not include the values. * Get the next result in the query. Drain must have been called beforehand or otherwise it will error.
* @param components The components to include */
* @returns Modified Query next: Item<T>;
*/
with: (this: Query<T>, ...components: Entity[]) => Query<T> /**
/** * Resets the Iterator for a query.
* Modifies the Query to exclude specified components */
* @param components The components to exclude drain: (this: Query<T>) => Query<T>;
* @returns Modified Query
*/ /**
without: (this: Query<T>, ...components: Entity[]) => Query<T>; * Modifies the query to include specified components, but will not include the values.
/** * @param components The components to include
* Modifies component data with a callback function * @returns Modified Query
* @param fn The function to modify data */
*/ with: (this: Query<T>, ...components: Id[]) => Query<T>;
replace: (this: Query<T>, fn: (...components: T) => FlattenTuple<T>) => void;
/**
* Modifies the Query to exclude specified components
* @param components The components to exclude
* @returns Modified Query
*/
without: (this: Query<T>, ...components: Id[]) => Query<T>;
/**
* Modifies component data with a callback function
* @param fn The function to modify data
*/
replace: (this: Query<T>, fn: (...components: T) => FlattenTuple<T>) => void;
/**
* Returns the archetypes associated with this query.
*/
archetypes: () => Archetype[];
} & IterableFunction<LuaTuple<[Entity, ...T]>>; } & IterableFunction<LuaTuple<[Entity, ...T]>>;
// Utility Types export type Archetype = {
export type Entity<T = unknown> = number & { __T: T }; id: number;
export type EntityType<T> = T extends Entity<infer A> ? A : never; edges: { [key: number]: ArchetypeEdge };
export type InferComponents<A extends Entity[]> = { types: number[];
[K in keyof A]: EntityType<A[K]>; type: string | number;
entities: number[];
columns: unknown[][];
records: { [key: number]: ArchetypeRecord };
}; };
type Nullable<T extends unknown[]> = {
[K in keyof T]: T[K] | undefined;
};
type FlattenTuple<T extends any[]> = T extends [infer U] ? U : LuaTuple<T>;
// Utility type for world:get type ArchetypeRecord = {
type TupleForWorldGet = count: number;
| [Entity] column: number;
| [Entity, Entity] };
| [Entity, Entity, Entity]
| [Entity, Entity, Entity, Entity] type ArchetypeEdge = {
add: Archetype;
remove: Archetype;
};
export class World { export class World {
/** /**
* Creates a new World * Creates a new World
*/ */
constructor(); constructor();
/** /**
* Creates a new entity * Creates a new entity
* @returns Entity * @returns Entity
*/ */
entity(): Entity; entity(): Entity;
/** /**
* Creates a new entity located in the first 256 ids. * Creates a new entity located in the first 256 ids.
* These should be used for static components for fast access. * These should be used for static components for fast access.
* @returns Entity<T> * @returns Entity<T>
*/ */
component<T = unknown>(): Entity<T>; component<T = unknown>(): Entity<T>;
/** /**
* Gets the target of a relationship. For example, when a user calls * Gets the target of a relationship. For example, when a user calls
* `world.target(entity, ChildOf(parent))`, you will obtain the parent entity. * `world.target(entity, ChildOf(parent))`, you will obtain the parent entity.
* @param entity Entity * @param entity Entity
* @param relation The Relationship * @param relation The Relationship
* @returns The Parent Entity if it exists * @returns The Parent Entity if it exists
*/ */
target(entity: Entity, relation: Entity): Entity | undefined; target(entity: Entity, relation: Entity): Entity | undefined;
/** /**
* Clears an entity from the world. * Clears an entity from the world.
* @praram entity Entity to be cleared * @param entity Entity to be cleared
*/ */
clear(entity: Entity): void; clear(entity: Entity): void;
/** /**
* Deletes an entity and all its related components and relationships. * Deletes an entity and all its related components and relationships.
* @param entity Entity to be destroyed * @param entity Entity to be destroyed
*/ */
delete(entity: Entity): void; delete(entity: Entity): void;
/** /**
* Adds a component to the entity with no value * Adds a component to the entity with no value
* @param entity Target Entity * @param entity Target Entity
* @param component Component * @param component Component
*/ */
add<T>(entity: Entity, component: Entity<T>): void; add<T>(entity: Entity, component: Id<T>): void;
/** /**
* Assigns a value to a component on the given entity * Assigns a value to a component on the given entity
* @param entity Target Entity * @param entity Target Entity
* @param component Target Component * @param component Target Component
* @param data Component Data * @param data Component Data
*/ */
set<T>(entity: Entity, component: Entity<T>, data: T): void; set<T>(entity: Entity, component: Id<T>, data: T): void;
/** /**
* Removes a component from the given entity * Removes a component from the given entity
* @param entity Target Entity * @param entity Target Entity
* @param component Target Component * @param component Target Component
*/ */
remove(entity: Entity, component: Entity): void; remove(entity: Entity, component: Id): void;
/** /**
* Retrieves the values of specified components for an entity. * Retrieves the values of specified components for an entity.
* Some values may not exist when called. * Some values may not exist when called.
* A maximum of 4 components are allowed at a time. * A maximum of 4 components are allowed at a time.
* @param id Target Entity * @param id Target Entity
* @param components Target Components * @param components Target Components
* @returns Data associated with target components if it exists. * @returns Data associated with target components if it exists.
*/ */
get<T extends TupleForWorldGet>(id: Entity, ...components: T): FlattenTuple<Nullable<InferComponents<T>>> get<T extends TupleForWorldGet>(id: Entity, ...components: T): FlattenTuple<Nullable<InferComponents<T>>>;
/** /**
* Returns whether the entity has the specified components. * Returns whether the entity has the specified components.
* A maximum of 4 components are allowed at a time. * A maximum of 4 components are allowed at a time.
* @param entity Target Entity * @param entity Target Entity
* @param components Target Components * @param components Target Components
* @returns If the entity contains the components * @returns If the entity contains the components
*/ */
has<T extends TupleForWorldGet>(entity: Entity, ...components: T): boolean; has(entity: Entity, ...components: Id[]): boolean;
/** /**
* Searches the world for entities that match a given query * Checks if an entity exists in the world
* @param components Queried Components * @param entity Entity to check
* @returns Query * @returns Whether the entity exists in the world
*/ */
query<T extends Entity[]>(...components: T): Query<InferComponents<T>>; contains(entity: Entity): boolean;
/**
* Searches the world for entities that match a given query
* @param components Queried Components
* @returns Query
*/
query<T extends Id[]>(...components: T): Query<InferComponents<T>>;
/**
* Get parent (target of ChildOf relationship) for entity.
* If there is no ChildOf relationship pair, it will return undefined.
* @param entity Target Entity
* @returns Parent Entity or undefined
*/
parent(entity: Entity): Entity | undefined;
} }
/** /**
@ -145,27 +182,28 @@ export class World {
* @param obj The second entity * @param obj The second entity
* @returns The composite key * @returns The composite key
*/ */
export const pair: (pred: Entity, obj: Entity) => Entity; export function pair<R, T>(pred: Entity<R>, obj: Entity<T>): Pair;
/** /**
* Checks if the entity is a composite key * Checks if the entity is a composite key
* @param e The entity to check * @param e The entity to check
* @returns If the entity is a pair * @returns If the entity is a pair
*/ */
export const IS_PAIR: (e: Entity) => boolean; export function IS_PAIR(e: Id): boolean;
/** /** Built-in Component used to find every component id */
* Built-in Component used to find every component id
*/
export const Component: Entity; export const Component: Entity;
export const OnAdd: Entity<(e: Entity) => void>; export const OnAdd: Entity<(e: Entity) => void>;
export const OnRemove: Entity<(e: Entity) => void>; export const OnRemove: Entity<(e: Entity) => void>;
export const OnSet: Entity<(e: Entity, value: unknown) => void>; export const OnSet: Entity<(e: Entity, value: unknown) => void>;
export const OnDeleteTarget: Entity; export const ChildOf: Entity;
export const Wildcard: Entity;
export const w: Entity;
export const OnDelete: Entity; export const OnDelete: Entity;
export const OnDeleteTarget: Entity;
export const Delete: Entity; export const Delete: Entity;
export const Remove: Entity; export const Remove: Entity;
export const Tag: Entity; export const Tag: Entity;
export const Wildcard: Entity; export const Name: Entity<string>;
export const Rest: Entity; export const Rest: Entity;