@rbxts/replecs 0.2.3-test1 → 0.2.4

package/out/replecs/index.d.ts

@@ -1,229 +1,229 @@
-import type { Entity, Id, Pair, Tag, World } from "@rbxts/jecs";
-
-declare namespace Replecs {
-   export type SerdesTable =
-      | {
-           bytespan?: number;
-           includes_variants?: false;
-           serialize: (value: any) => buffer;
-           deserialize: (buffer: buffer) => any;
-        }
-      | {
-           bytespan?: number;
-           includes_variants: true;
-           serialize: (value: any) => LuaTuple<[buffer, defined[] | undefined]>;
-           deserialize: (buffer: buffer, blobs: defined[] | undefined) => any;
-        };
-
-   type MemberFilterMap = Map<Player, boolean>;
-   type MemberFilter = Player | MemberFilterMap | undefined;
-   type Member = unknown;
-
-   export interface SharedInfo<T> {
-      lookup: Record<string, T>;
-      keys: string[];
-      indexes: [T];
-      members: Map<T, number>;
-   }
-   export interface HandleContext {
-      entity_id: number;
-      component: <T>(component: Entity<T>) => T;
-      target: (relation: Id, index?: number) => Entity | undefined;
-      pair_value: <T>(relation: Id<T>, target: Entity) => T | undefined;
-      has_pair: (relation: Id, target: Entity) => boolean;
-
-      entity: (server_entity: number) => Entity | undefined;
-      has: (tag: Entity) => boolean;
-   }
-   export interface CustomId {
-      identifier: string;
-      handle_callback: (ctx: HandleContext) => Entity;
-      handle(handler: (ctx: HandleContext) => Entity): void;
-   }
-
-   export interface Shared {
-      components: SharedInfo<Entity>;
-      custom_ids: SharedInfo<CustomId>;
-   }
-   interface HandshakeSerdesInfo {
-      includes_variants?: boolean;
-      bytespan?: number;
-   }
-
-   export interface HandshakeInfo {
-      components: Record<string, boolean>;
-      custom_ids: Record<string, boolean>;
-      serdes: Record<string, HandshakeSerdesInfo>;
-   }
-
-   export interface Components {
-      shared: Tag;
-      networked: Entity<MemberFilter>;
-      reliable: Entity<MemberFilter>;
-      unreliable: Entity<MemberFilter>;
-      pair: Entity<MemberFilter>;
-
-      serdes: Entity<SerdesTable>;
-      custom: Entity;
-      custom_handler: Entity<(value: any) => Entity>;
-      global: Entity<number>;
-
-      Shared: Tag;
-      Networked: Entity<MemberFilter>;
-      Reliable: Entity<MemberFilter>;
-      Unreliable: Entity<MemberFilter>;
-      Pair: Entity<MemberFilter>;
-
-      Serdes: Entity<SerdesTable>;
-      Custom: Entity;
-      CustomHandler: Entity<(value: any) => Entity>;
-      Global: Entity<number>;
-   }
-
-   export interface Client {
-      world: World;
-      inited?: boolean;
-
-      is_relicating: boolean;
-      after_relication_callbacks: [() => void];
-
-      components: Components;
-
-      init(world?: World): void;
-      destroy(): void;
-
-      handle_global(handler: (id: number) => Entity): void;
-
-      get_server_entity(client_entity: Entity): number | undefined;
-      get_client_entity(server_entity: number): Entity | undefined;
-
-      register_entity(entity: Entity, server_entity: number): void;
-      unregister_entity(entity: Entity): void;
-
-      after_replication(callback: () => void): void;
-      added(callback: (entity: Entity) => void): () => void;
-
-      hook<T>(
-         action: "changed",
-         relation: Pair<MemberFilter, T>,
-         callback: (entity: Entity, id: Id<T>, value: T) => void
-      ): () => void;
-      hook<T>(
-         action: "removed",
-         relation: Pair<MemberFilter, T>,
-         callback: (entity: Entity, id: Id<T>) => void
-      ): () => void;
-      hook(
-         action: "deleted",
-         entity: Entity,
-         callback: (entity: Entity) => void
-      ): () => void;
-
-      override<T>(
-         action: "changed",
-         relation: Pair<MemberFilter, T>,
-         callback: (entity: Entity, id: Id<T>, value: any) => void
-      ): () => void;
-      override<T>(
-         action: "removed",
-         relation: Pair<MemberFilter, T>,
-         callback: (entity: Entity, id: Id<T>) => void
-      ): () => void;
-      override(
-         action: "deleted",
-         entity: Entity,
-         callback: (entity: Entity) => void
-      ): () => void;
-
-      encode_component(component: Entity): number;
-      decode_component(encoded: number): Entity;
-      register_custom_id(custom_id: CustomId): void;
-
-      apply_updates(buf: buffer, all_variants?: unknown[][]): void;
-      apply_unreliable(buf: buffer, all_variants?: unknown[][]): void;
-      apply_full(buf: buffer, all_variants?: unknown[][]): void;
-
-      generate_handshake(): HandshakeInfo;
-      verify_handshake(
-         handshake: HandshakeInfo
-      ): LuaTuple<[true]> | LuaTuple<[false, string]>;
-   }
-
-   export interface ServerImp {
-      set_networked(entity: Entity, filter?: MemberFilter): void;
-      stop_networked(entity: Entity): void;
-
-      set_reliable(
-         entity: Entity,
-         component: Entity,
-         filter?: MemberFilter
-      ): void;
-      set_unreliable(
-         entity: Entity,
-         component: Entity,
-         filter?: MemberFilter
-      ): void;
-      set_pair(entity: Entity, relation: Entity, filter?: MemberFilter): void;
-      set_custom(entity: Entity, handler: Entity | CustomId): void;
-
-      stop_reliable(entity: Entity, component: Entity): void;
-      stop_unreliable(entity: Entity, component: Entity): void;
-      stop_pair(entity: Entity, relation: Entity): void;
-      remove_custom(entity: Entity): void;
-   }
-
-   export interface Server extends ServerImp {
-      world: World;
-      inited?: boolean;
-
-      init(world?: World): void;
-      destroy(): void;
-
-      encode_component(component: Entity): number;
-      decode_component(encoded: number): Entity;
-      register_custom_id(custom_id: CustomId): void;
-
-      get_full(player: Player): LuaTuple<[buffer, unknown[][]]>;
-      collect_updates(): IterableFunction<
-         LuaTuple<[Player, buffer, unknown[][]]>
-      >;
-      collect_unreliable(): IterableFunction<
-         LuaTuple<[Player, buffer, unknown[][]]>
-      >;
-
-      mark_player_ready(player: Player): void;
-      is_player_ready(player: Player): boolean;
-
-      add_player_alias(client: Player, alias: defined): void;
-      remove_player_alias(alias: defined): void;
-
-      generate_handshake(): HandshakeInfo;
-      verify_handshake(
-         handshake: HandshakeInfo
-      ): LuaTuple<[true]> | LuaTuple<[false, string]>;
-   }
-
-   export interface ReplecsLib {
-      client: Client;
-      server: Server;
-
-      after_replication(callback: () => void): void;
-      register_custom_id(custom_id: CustomId): void;
-   }
-
-   export interface Replecs extends Components {
-      VERSION: string;
-
-      create: (world?: World) => ReplecsLib;
-      create_server: (world?: World) => Server;
-      create_client: (world?: World) => Client;
-      create_custom_id: (
-         identifier: string,
-         handler?: (ctx: HandleContext) => Entity
-      ) => CustomId;
-   }
-}
-
-declare const Replecs: Replecs.Replecs;
-
-export = Replecs;
+import type { Entity, Id, Pair, Tag, World } from "@rbxts/jecs";
+
+declare namespace Replecs {
+  export type SerdesTable =
+    | {
+        bytespan?: number;
+        includes_variants?: false;
+        serialize: (value: any) => buffer;
+        deserialize: (buffer: buffer) => any;
+      }
+    | {
+        bytespan?: number;
+        includes_variants: true;
+        serialize: (value: any) => LuaTuple<[buffer, defined[] | undefined]>;
+        deserialize: (buffer: buffer, blobs: defined[] | undefined) => any;
+      };
+
+  type MemberFilterMap = Map<Player, boolean>;
+  type MemberFilter = Player | MemberFilterMap | undefined;
+  type Member = unknown;
+
+  export interface SharedInfo<T> {
+    lookup: Record<string, T>;
+    keys: string[];
+    indexes: [T];
+    members: Map<T, number>;
+  }
+  export interface HandleContext {
+    entity_id: number;
+    component: <T>(component: Entity<T>) => T;
+    target: (relation: Id, index?: number) => Entity | undefined;
+    pair_value: <T>(relation: Id<T>, target: Entity) => T | undefined;
+    has_pair: (relation: Id, target: Entity) => boolean;
+
+    entity: (server_entity: number) => Entity | undefined;
+    has: (tag: Entity) => boolean;
+  }
+  export interface CustomId {
+    identifier: string;
+    handle_callback: (ctx: HandleContext) => Entity;
+    handle(handler: (ctx: HandleContext) => Entity): void;
+  }
+
+  export interface Shared {
+    components: SharedInfo<Entity>;
+    custom_ids: SharedInfo<CustomId>;
+  }
+  interface HandshakeSerdesInfo {
+    includes_variants?: boolean;
+    bytespan?: number;
+  }
+
+  export interface HandshakeInfo {
+    components: Record<string, boolean>;
+    custom_ids: Record<string, boolean>;
+    serdes: Record<string, HandshakeSerdesInfo>;
+  }
+
+  export interface Components {
+    shared: Tag;
+    networked: Entity<MemberFilter>;
+    reliable: Entity<MemberFilter>;
+    unreliable: Entity<MemberFilter>;
+    relation: Entity<MemberFilter>;
+
+    serdes: Entity<SerdesTable>;
+    custom: Entity;
+    custom_handler: Entity<(value: any) => Entity>;
+    global: Entity<number>;
+
+    Shared: Tag;
+    Networked: Entity<MemberFilter>;
+    Reliable: Entity<MemberFilter>;
+    Unreliable: Entity<MemberFilter>;
+    Relation: Entity<MemberFilter>;
+
+    Serdes: Entity<SerdesTable>;
+    Custom: Entity;
+    CustomHandler: Entity<(value: any) => Entity>;
+    Global: Entity<number>;
+  }
+
+  export interface Client {
+    world: World;
+    inited?: boolean;
+
+    is_relicating: boolean;
+    after_relication_callbacks: [() => void];
+
+    components: Components;
+
+    init(world?: World): void;
+    destroy(): void;
+
+    handle_global(handler: (id: number) => Entity): void;
+
+    get_server_entity(client_entity: Entity): number | undefined;
+    get_client_entity(server_entity: number): Entity | undefined;
+
+    register_entity(entity: Entity, server_entity: number): void;
+    unregister_entity(entity: Entity): void;
+
+    after_replication(callback: () => void): void;
+    added(callback: (entity: Entity) => void): () => void;
+
+    hook<T>(
+      action: "changed",
+      relation: Pair<MemberFilter, T>,
+      callback: (entity: Entity, id: Id<T>, value: T) => void,
+    ): () => void;
+    hook<T>(
+      action: "removed",
+      relation: Pair<MemberFilter, T>,
+      callback: (entity: Entity, id: Id<T>) => void,
+    ): () => void;
+    hook(
+      action: "deleted",
+      entity: Entity,
+      callback: (entity: Entity) => void,
+    ): () => void;
+
+    override<T>(
+      action: "changed",
+      relation: Pair<MemberFilter, T>,
+      callback: (entity: Entity, id: Id<T>, value: any) => void,
+    ): () => void;
+    override<T>(
+      action: "removed",
+      relation: Pair<MemberFilter, T>,
+      callback: (entity: Entity, id: Id<T>) => void,
+    ): () => void;
+    override(
+      action: "deleted",
+      entity: Entity,
+      callback: (entity: Entity) => void,
+    ): () => void;
+
+    encode_component(component: Entity): number;
+    decode_component(encoded: number): Entity;
+    register_custom_id(custom_id: CustomId): void;
+
+    apply_updates(buf: buffer, all_variants?: defined[][]): void;
+    apply_unreliable(buf: buffer, all_variants?: defined[][]): void;
+    apply_full(buf: buffer, all_variants?: defined[][]): void;
+
+    generate_handshake(): HandshakeInfo;
+    verify_handshake(
+      handshake: HandshakeInfo,
+    ): LuaTuple<[true]> | LuaTuple<[false, string]>;
+  }
+
+  export interface ServerImp {
+    set_networked(entity: Entity, filter?: MemberFilter): void;
+    set_reliable(
+      entity: Entity,
+      component: Entity,
+      filter?: MemberFilter,
+    ): void;
+    set_unreliable(
+      entity: Entity,
+      component: Entity,
+      filter?: MemberFilter,
+    ): void;
+    set_relation(entity: Entity, relation: Entity, filter?: MemberFilter): void;
+
+    stop_networked(entity: Entity, keep?: boolean): void;
+    stop_reliable(entity: Entity, component: Entity, keep?: boolean): void;
+    stop_unreliable(entity: Entity, component: Entity, keep?: boolean): void;
+    stop_relation(entity: Entity, relation: Entity, keep?: boolean): void;
+
+    set_custom(entity: Entity, handler: Entity | CustomId): void;
+    remove_custom(entity: Entity): void;
+  }
+
+  export interface Server extends ServerImp {
+    world: World;
+    inited?: boolean;
+
+    init(world?: World): void;
+    destroy(): void;
+
+    encode_component(component: Entity): number;
+    decode_component(encoded: number): Entity;
+    register_custom_id(custom_id: CustomId): void;
+
+    get_full(player: Player): LuaTuple<[buffer, defined[][]?]>;
+    collect_updates(): IterableFunction<
+      LuaTuple<[Player, buffer, defined[][]?]>
+    >;
+    collect_unreliable(): IterableFunction<
+      LuaTuple<[Player, buffer, defined[][]?]>
+    >;
+
+    mark_player_ready(player: Player): void;
+    is_player_ready(player: Player): boolean;
+
+    add_player_alias(client: Player, alias: defined): void;
+    remove_player_alias(alias: defined): void;
+
+    generate_handshake(): HandshakeInfo;
+    verify_handshake(
+      handshake: HandshakeInfo,
+    ): LuaTuple<[true]> | LuaTuple<[false, string]>;
+  }
+
+  export interface ReplecsLib {
+    client: Client;
+    server: Server;
+
+    after_replication(callback: () => void): void;
+    register_custom_id(custom_id: CustomId): void;
+  }
+
+  export interface Replecs extends Components {
+    VERSION: string;
+
+    create: (world?: World) => ReplecsLib;
+    create_server: (world?: World) => Server;
+    create_client: (world?: World) => Client;
+    create_custom_id: (
+      identifier: string,
+      handler?: (ctx: HandleContext) => Entity,
+    ) => CustomId;
+  }
+}
+
+declare const Replecs: Replecs.Replecs;
+
+export = Replecs;

package/out/replecs/init.luau

@@ -1,103 +1,90 @@
-local jecs = require "./jecs"
-local common = require "@self/common"
+local jecs = require (script.Parent:WaitForChild('jecs'))
+local common = require (script:WaitForChild('common'))
+local types = require (script:WaitForChild('types'))
+local utils = require (script:WaitForChild('utils'))
 
-local client = require "@self/client"
-local server = require "@self/server"
-local customid = require "@self/customid"
-local VERSION = require "@self/ver"
+local client = require (script:WaitForChild('client'))
+local server = require (script:WaitForChild('server'))
+local customid = require (script:WaitForChild('customid'))
+local VERSION = require (script:WaitForChild('ver'))
 
 export type Server = server.Server
 export type Client = client.Client
 
+type Entity = common.Entity
+type World = common.World
+
 export type HandleContext = customid.HandleContext
 export type CustomId = customid.CustomId
-export type HandshakeInfo = common.HandshakeInfo
-
-type Entity = jecs.Entity
+export type HandshakeInfo = types.HandshakeInfo
+export type Serdes = types.Serdes
 
 export type ReplecsLib = {
 	server: Server,
 	client: Client,
+	components: types.Components,
 
 	after_replication: (self: ReplecsLib, callback: () -> ()) -> (),
 	register_custom_id: (self: ReplecsLib, custom_id: CustomId) -> (),
 }
 
-type Replecs = common.Components & {
-	create: (world: jecs.World?) -> ReplecsLib,
+type Replecs = types.Components & {
+	__index: any,
+	VERSION: string,
+	create: (world: World?) -> ReplecsLib,
 
-	create_server: (world: jecs.World?) -> Server,
-	create_client: (world: jecs.World?) -> Client,
+	create_server: (world: World?) -> Server,
+	create_client: (world: World?) -> Client,
 	create_custom_id: (identifier: string, handler: (ctx: HandleContext) -> Entity?) -> CustomId,
 }
 
-type MemberFilter = {
-	[Player]: boolean,
-}
+local replecs = {}
+replecs.VERSION = VERSION
+replecs.__index = replecs
 
-local replecs = {
-	VERSION = VERSION,
-	shared = jecs.tag(),
-	networked = jecs.component(),
-	reliable = jecs.component(),
-	unreliable = jecs.component(),
-	pair = jecs.component(),
-
-	serdes = jecs.component(),
-	custom = jecs.tag(),
-	custom_handler = jecs.component(),
-	global = jecs.component(),
-	__alive_tracking__ = jecs.tag(),
-}
+local PREREGISTRATION = common.preregistration
 
-replecs.__index = replecs
-replecs.Serdes = replecs.serdes
-replecs.Custom = replecs.custom
-replecs.CustomHandler = replecs.custom_handler
-replecs.Networked = replecs.networked
-replecs.Reliable = replecs.reliable
-replecs.Unreliable = replecs.unreliable
-replecs.Pair = replecs.pair
-replecs.Shared = replecs.shared
-replecs.Global = replecs.global
-
-jecs.meta(replecs.serdes, jecs.Name, "replecs.serdes")
-jecs.meta(replecs.custom, jecs.Name, "replecs.custom")
-jecs.meta(replecs.custom_handler, jecs.Name, "replecs.custom_handler")
-jecs.meta(replecs.networked, jecs.Name, "replecs.networked")
-jecs.meta(replecs.reliable, jecs.Name, "replecs.reliable")
-jecs.meta(replecs.unreliable, jecs.Name, "replecs.unreliable")
-jecs.meta(replecs.pair, jecs.Name, "replecs.pair")
-jecs.meta(replecs.shared, jecs.Name, "replecs.shared")
-jecs.meta(replecs.global, jecs.Name, "replecs.global")
-
-jecs.meta(replecs.__alive_tracking__, jecs.Name, "replecs.__alive_tracking__")
-
-jecs.meta(replecs.custom, jecs.Exclusive)
-jecs.meta(replecs.global, jecs.Exclusive)
-
-function replecs.create_server(world: jecs.World?): Server
-	return server.create(world, replecs :: Replecs)
+if PREREGISTRATION then
+	local components = replecs :: Replecs
+	utils.create_components(common.preregister_tag, common.preregister_component, components)
+	utils.add_component_names(components, common.add_preregistered_name)
+
+	jecs.meta(components.custom, jecs.Exclusive)
+	jecs.meta(components.global, jecs.Exclusive)
 end
 
-function replecs.create_client(world: jecs.World?): Client
-	return client.create(world, replecs :: Replecs)
+local COMPONENTS = if PREREGISTRATION then replecs :: Replecs else nil
+
+function replecs.create_server(world: World?): Server
+	return server.create(world, COMPONENTS)
 end
 
-function replecs.create(world: jecs.World?): ReplecsLib
-	assert(game, "This is a Roblox specific function")
+function replecs.create_client(world: World?): Client
+	return client.create(world, COMPONENTS)
+end
 
+function replecs.create(world: World?): ReplecsLib
+	assert(game, "This is a Roblox specific function")
 	local RunService = game:GetService "RunService"
-	local lib = {} :: ReplecsLib
+	local self = {} :: ReplecsLib
+
+	if COMPONENTS then
+		self.components = COMPONENTS
+	elseif world then
+		self.components = utils.create_components(utils.tag_factory(world), utils.component_factory(world))
+		utils.add_component_names(self.components, function(component, name)
+			common.add_name(world, component, name)
+		end)
+	end
 
 	if RunService:IsServer() then
-		lib.server = server.create(world, replecs :: Replecs)
+		self.server = server.create(world, self.components)
 	end
 	if RunService:IsClient() then
-		lib.client = client.create(world, replecs :: Replecs)
+		self.client = client.create(world, self.components)
 	end
 
-	return setmetatable(lib, replecs) :: any
+	return setmetatable(self, replecs) :: any
 end
 
 function replecs.create_custom_id(identifier: string, handler: (ctx: HandleContext) -> Entity?)