@dcl/ecs 7.0.6-4057700455.commit-453395e → 7.0.6-4076330908.commit-cd40e5f

package/dist/schemas/index.d.ts

@@ -1,42 +1,50 @@
 import { Entity } from '../engine';
-import { IArray } from './Array';
-import { IEnum } from './basic/Enum';
 import { Color3Type } from './custom/Color3';
 import { Color4Type } from './custom/Color4';
 import { QuaternionType } from './custom/Quaternion';
 import { Vector3Type } from './custom/Vector3';
 import { ISchema } from './ISchema';
-import { IMap } from './Map';
-import { IOptional } from './Optional';
-export type { IOptional } from './Optional';
-export type { IMap } from './Map';
-export type { IArray } from './Array';
-export type { IEnum } from './basic/Enum';
-export type { Vector3Type } from './custom/Vector3';
-export type { QuaternionType } from './custom/Quaternion';
-export type { Color3Type } from './custom/Color3';
-export type { Color4Type } from './custom/Color4';
+export { QuaternionType, Vector3Type, ISchema, Color3Type, Color4Type };
 /**
  * @public
  */
 export declare namespace Schemas {
+    /** @public */
     type SchemaType = ISchema;
+    /** @public */
     const Boolean: ISchema<boolean>;
+    /** @public */
     const String: ISchema<string>;
+    /** @public */
     const Float: ISchema<number>;
+    /** @public */
     const Double: ISchema<number>;
+    /** @public */
     const Byte: ISchema<number>;
+    /** @public */
     const Short: ISchema<number>;
+    /** @public */
     const Int: ISchema<number>;
+    /** @public */
     const Int64: ISchema<number>;
+    /** @public */
     const Number: ISchema<number>;
+    /** @public */
     const Vector3: ISchema<Vector3Type>;
+    /** @public */
     const Quaternion: ISchema<QuaternionType>;
+    /** @public */
     const Color3: ISchema<Color3Type>;
+    /** @public */
     const Color4: ISchema<Color4Type>;
+    /** @public */
     const Entity: ISchema<Entity>;
-    const Enum: typeof IEnum;
-    const Array: typeof IArray;
-    const Map: typeof IMap;
-    const Optional: typeof IOptional;
+    /** @public */
+    const Enum: <T>(type: ISchema<any>) => ISchema<T>;
+    /** @public */
+    const Array: <T>(type: ISchema<T>) => ISchema<T[]>;
+    /** @public */
+    const Map: <T extends import("./Map").Spec>(spec: T, defaultValue?: Partial<import("./Map").MapResult<T>> | undefined) => ISchema<import("./Map").MapResult<T>>;
+    /** @public */
+    const Optional: <T>(spec: ISchema<T>) => ISchema<T | undefined>;
 }

package/dist/schemas/index.js

@@ -16,22 +16,40 @@ import { IOptional } from './Optional';
  */
 export var Schemas;
 (function (Schemas) {
+    /** @public */
     Schemas.Boolean = Bool;
+    /** @public */
     Schemas.String = EcsString;
+    /** @public */
     Schemas.Float = Float32;
+    /** @public */
     Schemas.Double = Float64;
+    /** @public */
     Schemas.Byte = Int8;
+    /** @public */
     Schemas.Short = Int16;
+    /** @public */
     Schemas.Int = Int32;
+    /** @public */
     Schemas.Int64 = iInt64;
+    /** @public */
     Schemas.Number = Float32;
+    /** @public */
     Schemas.Vector3 = Vector3Schema;
+    /** @public */
     Schemas.Quaternion = QuaternionSchema;
+    /** @public */
     Schemas.Color3 = Color3Schema;
+    /** @public */
     Schemas.Color4 = Color4Schema;
+    /** @public */
     Schemas.Entity = EntitySchema;
+    /** @public */
     Schemas.Enum = IEnum;
+    /** @public */
     Schemas.Array = IArray;
+    /** @public */
     Schemas.Map = IMap;
+    /** @public */
     Schemas.Optional = IOptional;
 })(Schemas || (Schemas = {}));

package/dist/schemas/typing.d.ts

@@ -1,15 +1,30 @@
-/** Include property keys from T where the property is assignable to U */
+/**
+ * Include property keys from T where the property is assignable to U
+ * @public
+ */
 export type IncludeUndefined<T> = {
     [P in keyof T]: undefined extends T[P] ? P : never;
 }[keyof T];
-/** Excludes property keys from T where the property is assignable to U */
+/**
+ * Excludes property keys from T where the property is assignable to U
+ * @public
+ */
 export type ExcludeUndefined<T> = {
     [P in keyof T]: undefined extends T[P] ? never : P;
 }[keyof T];
+/**
+ * @public
+ */
 export type OnlyOptionalUndefinedTypes<T> = {
     [K in IncludeUndefined<T>]?: T[K];
 };
+/**
+ * @public
+ */
 export type OnlyNonUndefinedTypes<T> = {
     [K in ExcludeUndefined<T>]: T[K];
 };
+/**
+ * @public
+ */
 export type ToOptional<T> = OnlyOptionalUndefinedTypes<T> & OnlyNonUndefinedTypes<T>;

package/dist/serialization/ByteBuffer/index.d.ts

@@ -75,7 +75,7 @@ export declare class ReadWriteByteBuffer implements ByteBuffer {
 /**
  * @public
  */
-export type ByteBuffer = {
+export interface ByteBuffer {
     /**
      * @returns The entire current Uint8Array.
      *
@@ -175,4 +175,4 @@ export type ByteBuffer = {
     setUint16(offset: number, value: number): void;
     setUint32(offset: number, value: number): void;
     setUint64(offset: number, value: bigint): void;
-};
+}

package/dist/serialization/crdt/deleteComponent.d.ts

@@ -1,11 +1 @@
-import { Entity } from '../../engine/entity';
-import { ByteBuffer } from '../ByteBuffer';
-import { DeleteComponentMessage } from './types';
-export declare namespace DeleteComponent {
-    const MESSAGE_HEADER_LENGTH = 20;
-    /**
-     * Write DeleteComponent message
-     */
-    function write(entity: Entity, componentId: number, timestamp: number, buf: ByteBuffer): void;
-    function read(buf: ByteBuffer): DeleteComponentMessage | null;
-}
+export {};

package/dist/serialization/crdt/deleteComponent.js

@@ -1,5 +1,8 @@
-import CrdtMessageProtocol from '.';
+import { CrdtMessageProtocol } from '.';
 import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from './types';
+/**
+ * @internal
+ */
 export var DeleteComponent;
 (function (DeleteComponent) {
     // TODO: change timestamp to 32 bit and remove buffer length (-8 bytes)

package/dist/serialization/crdt/deleteEntity.d.ts

@@ -1,8 +1 @@
-import { Entity } from '../../engine/entity';
-import { ByteBuffer } from '../ByteBuffer';
-import { DeleteEntityMessage } from './types';
-export declare namespace DeleteEntity {
-    const MESSAGE_HEADER_LENGTH = 4;
-    function write(entity: Entity, buf: ByteBuffer): void;
-    function read(buf: ByteBuffer): DeleteEntityMessage | null;
-}
+export {};

package/dist/serialization/crdt/deleteEntity.js

@@ -1,5 +1,8 @@
-import CrdtMessageProtocol from '.';
+import { CrdtMessageProtocol } from '.';
 import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from './types';
+/**
+ * @internal
+ */
 export var DeleteEntity;
 (function (DeleteEntity) {
     DeleteEntity.MESSAGE_HEADER_LENGTH = 4;

package/dist/serialization/crdt/index.d.ts

@@ -1,32 +1,4 @@
-import { ByteBuffer } from '../ByteBuffer';
-import { CrdtMessageHeader } from './types';
 export * from './types';
 export * from './deleteComponent';
 export * from './putComponent';
 export * from './deleteEntity';
-export declare namespace CrdtMessageProtocol {
-    /**
-     * Validate if the message incoming is completed
-     * @param buf - ByteBuffer
-     */
-    function validate(buf: ByteBuffer): boolean;
-    /**
-     * Get the current header, consuming the bytes involved.
-     * @param buf - ByteBuffer
-     * @returns header or null if there is no validated message
-     */
-    function readHeader(buf: ByteBuffer): CrdtMessageHeader | null;
-    /**
-     * Get the current header, without consuming the bytes involved.
-     * @param buf - ByteBuffer
-     * @returns header or null if there is no validated message
-     */
-    function getHeader(buf: ByteBuffer): CrdtMessageHeader | null;
-    /**
-     * Consume the incoming message without processing it.
-     * @param buf - ByteBuffer
-     * @returns true in case of success or false if there is no valid message.
-     */
-    function consumeMessage(buf: ByteBuffer): boolean;
-}
-export default CrdtMessageProtocol;

package/dist/serialization/crdt/index.js

@@ -3,6 +3,9 @@ export * from './types';
 export * from './deleteComponent';
 export * from './putComponent';
 export * from './deleteEntity';
+/**
+ * @internal
+ */
 export var CrdtMessageProtocol;
 (function (CrdtMessageProtocol) {
     /**
@@ -67,4 +70,3 @@ export var CrdtMessageProtocol;
     }
     CrdtMessageProtocol.consumeMessage = consumeMessage;
 })(CrdtMessageProtocol || (CrdtMessageProtocol = {}));
-export default CrdtMessageProtocol;

package/dist/serialization/crdt/message.js

@@ -1,4 +1,4 @@
-import CrdtMessageProtocol, { DeleteComponent, DeleteEntity, PutComponentOperation } from '.';
+import { CrdtMessageProtocol, DeleteComponent, DeleteEntity, PutComponentOperation } from '.';
 import { CrdtMessageType } from './types';
 export function readMessage(buf) {
     const header = CrdtMessageProtocol.getHeader(buf);

package/dist/serialization/crdt/putComponent.d.ts

@@ -1,13 +1 @@
-import { ComponentDefinition } from '../../engine/component';
-import { Entity } from '../../engine/entity';
-import { ByteBuffer } from '../ByteBuffer';
-import { PutComponentMessage } from './types';
-export declare namespace PutComponentOperation {
-    const MESSAGE_HEADER_LENGTH = 20;
-    /**
-     * Call this function for an optimal writing data passing the ByteBuffer
-     *  already allocated
-     */
-    function write(entity: Entity, timestamp: number, componentDefinition: ComponentDefinition<unknown>, buf: ByteBuffer): void;
-    function read(buf: ByteBuffer): PutComponentMessage | null;
-}
+export {};

package/dist/serialization/crdt/putComponent.js

@@ -1,5 +1,8 @@
-import CrdtMessageProtocol from '.';
+import { CrdtMessageProtocol } from '.';
 import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from './types';
+/**
+ * @internal
+ */
 export var PutComponentOperation;
 (function (PutComponentOperation) {
     PutComponentOperation.MESSAGE_HEADER_LENGTH = 20;

package/dist/serialization/crdt/types.d.ts

@@ -1,5 +1,7 @@
 import { Entity } from '../../engine/entity';
-export type Uint32 = number;
+/**
+ * @public
+ */
 export declare enum CrdtMessageType {
     RESERVED = 0,
     PUT_COMPONENT = 1,
@@ -7,24 +9,14 @@ export declare enum CrdtMessageType {
     DELETE_ENTITY = 3,
     MAX_MESSAGE_TYPE = 4
 }
-/**
- * Min length = 8 bytes
- * All message length including
- * @param length - Uint32 the length of all message (including the header)
- * @param type - define the function which handles the data
- */
-export type CrdtMessageHeader = {
-    length: Uint32;
-    type: Uint32;
-};
-export declare const CRDT_MESSAGE_HEADER_LENGTH = 8;
 /**
  * Min. length = header (8 bytes) + 20 bytes = 28 bytes
  *
- * @param entity - Uint32 number of the entity
- * @param componentId - Uint32 number of id
+ * @param entity - uint32 number of the entity
+ * @param componentId - uint32 number of id
  * @param timestamp - Uint64 Lamport timestamp
  * @param data - Uint8[] data of component => length(4 bytes) + block of bytes[0..length-1]
+ * @public
  */
 export type PutComponentMessageBody = {
     type: CrdtMessageType.PUT_COMPONENT;
@@ -33,6 +25,9 @@ export type PutComponentMessageBody = {
     timestamp: number;
     data: Uint8Array;
 };
+/**
+ * @public
+ */
 export type DeleteComponentMessageBody = {
     type: CrdtMessageType.DELETE_COMPONENT;
     entityId: Entity;
@@ -40,14 +35,14 @@ export type DeleteComponentMessageBody = {
     timestamp: number;
 };
 /**
- * @param entity - Uint32 number of the entity
+ * @param entity - uint32 number of the entity
+ * @public
  */
 export type DeleteEntityMessageBody = {
     type: CrdtMessageType.DELETE_ENTITY;
     entityId: Entity;
 };
-export type PutComponentMessage = CrdtMessageHeader & PutComponentMessageBody;
-export type DeleteComponentMessage = CrdtMessageHeader & DeleteComponentMessageBody;
-export type DeleteEntityMessage = CrdtMessageHeader & DeleteEntityMessageBody;
-export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | DeleteEntityMessage;
-export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessage;
+/**
+ * @public
+ */
+export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody;

package/dist/serialization/crdt/types.js

@@ -1,3 +1,6 @@
+/**
+ * @public
+ */
 export var CrdtMessageType;
 (function (CrdtMessageType) {
     CrdtMessageType[CrdtMessageType["RESERVED"] = 0] = "RESERVED";
@@ -7,4 +10,7 @@ export var CrdtMessageType;
     CrdtMessageType[CrdtMessageType["DELETE_ENTITY"] = 3] = "DELETE_ENTITY";
     CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 4] = "MAX_MESSAGE_TYPE";
 })(CrdtMessageType || (CrdtMessageType = {}));
+/**
+ * @internal
+ */
 export const CRDT_MESSAGE_HEADER_LENGTH = 8;

package/dist/systems/async-task.d.ts

@@ -1,5 +1 @@
-import { IEngine } from '../engine';
 export type Task<T = unknown> = () => Promise<T>;
-export declare function createTaskSystem(engine: IEngine): {
-    executeTask(task: Task): void;
-};

package/dist/systems/async-task.js

@@ -3,6 +3,9 @@ function getAndClean(value) {
     value.length = 0;
     return messagesToProcess;
 }
+/**
+ * @internal
+ */
 export function createTaskSystem(engine) {
     const tasks = [];
     async function runTask(task) {

package/dist/systems/crdt/index.d.ts

@@ -1,15 +1,7 @@
 import { Entity } from '../../engine/entity';
-import type { ComponentDefinition, IEngine } from '../../engine';
+import type { ComponentDefinition } from '../../engine';
 import { CrdtMessageType } from '../../serialization/crdt/types';
-import { Transport } from './types';
 /**
  * @public
  */
 export type OnChangeFunction = (entity: Entity, operation: CrdtMessageType, component?: ComponentDefinition<any>) => void;
-export declare function crdtSceneSystem(engine: Pick<IEngine, 'getComponentOrNull' | 'getComponent' | 'entityContainer' | 'componentsIter'>, onProcessEntityComponentChange: OnChangeFunction | null): {
-    getCrdt: () => import("@dcl/crdt").State<Uint8Array>;
-    sendMessages: (dirtyEntities: Map<ComponentDefinition<unknown>, Array<Entity>>, deletedEntities: Entity[]) => Promise<void>;
-    receiveMessages: () => Promise<void>;
-    addTransport: (transport: Transport) => void;
-    updateState: () => Map<ComponentDefinition<unknown>, Entity[]>;
-};

package/dist/systems/crdt/index.js

@@ -2,11 +2,14 @@ import { crdtProtocol } from '@dcl/crdt';
 import { CRDTMessageType, ProcessMessageResultType } from '@dcl/crdt/dist/types';
 import { EntityState, EntityUtils } from '../../engine/entity';
 import { ReadWriteByteBuffer } from '../../serialization/ByteBuffer';
-import CrdtMessageProtocol from '../../serialization/crdt';
+import { CrdtMessageProtocol } from '../../serialization/crdt';
 import { DeleteComponent } from '../../serialization/crdt/deleteComponent';
 import { DeleteEntity } from '../../serialization/crdt/deleteEntity';
 import { PutComponentOperation } from '../../serialization/crdt/putComponent';
 import { CrdtMessageType } from '../../serialization/crdt/types';
+/**
+ * @internal
+ */
 export function crdtSceneSystem(engine, onProcessEntityComponentChange) {
     const transports = [];
     // CRDT Client

package/dist/systems/crdt/types.d.ts

@@ -1,9 +1,18 @@
 import { CrdtMessageBody } from '../../serialization/crdt/types';
+/**
+ * @public
+ */
 export type ReceiveMessage = CrdtMessageBody & {
     transportId?: number;
     messageBuffer: Uint8Array;
 };
+/**
+ * @public
+ */
 export type TransportMessage = Omit<ReceiveMessage, 'data'>;
+/**
+ * @public
+ */
 export type Transport = {
     send(message: Uint8Array): Promise<void>;
     onmessage?(message: Uint8Array): void;

package/dist/systems/events.d.ts

@@ -1,23 +1,23 @@
 import { InputAction } from '../components/generated/pb/decentraland/sdk/components/common/input_action.gen';
 import { PBPointerEventsResult_PointerCommand } from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
-import { IEngine } from '../engine/types';
 import { Entity } from '../engine/entity';
-import { IInputSystem } from '../engine/input';
+/**
+ * @public
+ */
 export type EventSystemCallback = (event: PBPointerEventsResult_PointerCommand) => void;
+/**
+ * @public
+ */
 export type EventSystemOptions = {
     button: InputAction;
     hoverText?: string;
     maxDistance?: number;
     showFeedback?: boolean;
 };
-export type PointerEventsSystem = ReturnType<typeof createPointerEventSystem>;
-export declare function createPointerEventSystem(engine: IEngine, inputSystem: IInputSystem): {
-    /**
-     * @internal
-     * Remove the callback for onClick event
-     * @param entity - Entity where the callback was attached
-     */
-    removeOnClick(entity: Entity): void;
+/**
+ * @public
+ */
+export interface PointerEventsSystem {
     /**
      * @public
      * Remove the callback for onPointerDown event
@@ -30,14 +30,6 @@ export declare function createPointerEventSystem(engine: IEngine, inputSystem: I
      * @param entity - Entity where the callback was attached
      */
     removeOnPointerUp(entity: Entity): void;
-    /**
-     * @internal
-     * Execute callback when the user clicks the entity.
-     * @param entity - Entity to attach the callback
-     * @param cb - Function to execute when onPointerDown fires
-     * @param opts - Opts to trigger Feedback and Button
-     */
-    onClick(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void;
     /**
      * @public
      * Execute callback when the user press the InputButton pointing at the entity
@@ -54,4 +46,4 @@ export declare function createPointerEventSystem(engine: IEngine, inputSystem: I
      * @param opts - Opts to trigger Feedback and Button
      */
     onPointerUp(entity: Entity, cb: EventSystemCallback, opts?: Partial<EventSystemOptions>): void;
-};
+}

package/dist/systems/events.js

@@ -1,6 +1,9 @@
 import * as components from '../components';
 import { EntityState } from '../engine/entity';
 import { checkNotThenable } from '../runtime/invariant';
+/**
+ * @internal
+ */
 export function createPointerEventSystem(engine, inputSystem) {
     const PointerEvents = components.PointerEvents(engine);
     let EventType;
@@ -74,37 +77,15 @@ export function createPointerEventSystem(engine, inputSystem) {
         }
     });
     return {
-        /**
-         * @internal
-         * Remove the callback for onClick event
-         * @param entity - Entity where the callback was attached
-         */
         removeOnClick(entity) {
             removeEvent(entity, EventType.Click);
         },
-        /**
-         * @public
-         * Remove the callback for onPointerDown event
-         * @param entity - Entity where the callback was attached
-         */
         removeOnPointerDown(entity) {
             removeEvent(entity, EventType.Down);
         },
-        /**
-         * @public
-         * Remove the callback for onPointerUp event
-         * @param entity - Entity where the callback was attached
-         */
         removeOnPointerUp(entity) {
             removeEvent(entity, EventType.Up);
         },
-        /**
-         * @internal
-         * Execute callback when the user clicks the entity.
-         * @param entity - Entity to attach the callback
-         * @param cb - Function to execute when onPointerDown fires
-         * @param opts - Opts to trigger Feedback and Button
-         */
         onClick(entity, cb, opts) {
             const options = getDefaultOpts(opts);
             // Clear previous event with over feedback included
@@ -113,26 +94,12 @@ export function createPointerEventSystem(engine, inputSystem) {
             getEvent(entity).set(EventType.Click, { cb, opts: options });
             setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
         },
-        /**
-         * @public
-         * Execute callback when the user press the InputButton pointing at the entity
-         * @param entity - Entity to attach the callback
-         * @param cb - Function to execute when click fires
-         * @param opts - Opts to trigger Feedback and Button
-         */
         onPointerDown(entity, cb, opts) {
             const options = getDefaultOpts(opts);
             removeEvent(entity, EventType.Down);
             getEvent(entity).set(EventType.Down, { cb, opts: options });
             setPointerEvent(entity, 1 /* PointerEventType.PET_DOWN */, options);
         },
-        /**
-         * @public
-         * Execute callback when the user releases the InputButton pointing at the entity
-         * @param entity - Entity to attach the callback
-         * @param cb - Function to execute when click fires
-         * @param opts - Opts to trigger Feedback and Button
-         */
         onPointerUp(entity, cb, opts) {
             const options = getDefaultOpts(opts);
             removeEvent(entity, EventType.Up);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dcl/ecs",
-  "version": "7.0.6-4057700455.commit-453395e",
+  "version": "7.0.6-4076330908.commit-cd40e5f",
   "description": "Decentraland ECS",
   "main": "./dist/index.js",
   "typings": "./dist/index.d.ts",
@@ -27,7 +27,7 @@
     "ts-proto": "^1.112.0"
   },
   "dependencies": {
-    "@dcl/crdt": "7.0.6-4057700455.commit-453395e",
+    "@dcl/crdt": "7.0.6-4076330908.commit-cd40e5f",
     "@dcl/js-runtime": "file:../js-runtime",
     "@dcl/protocol": "1.0.0-4009547712.commit-472ea24"
   },
@@ -41,5 +41,5 @@
     "displayName": "ECS",
     "tsconfig": "./tsconfig.json"
   },
-  "commit": "453395e8e59ee7b01541bc8232b4864b1405024a"
+  "commit": "cd40e5fe70cbeabc3231fc374729bfd52b1127e2"
 }