@dcl/ecs 1.0.0-20220601102612.commit-8b31ac4 → 1.0.0-2448628808.commit-1a55b7a

package/dist/serialization/ByteBuffer/index.js

@@ -1,281 +0,0 @@
-/**
- * Take the max between currentSize and intendedSize and then plus 1024. Then,
- *  find the next nearer multiple of 1024.
- * @param currentSize - number
- * @param intendedSize - number
- * @returns the calculated number
- */
-function getNextSize(currentSize, intendedSize) {
-    const minNewSize = Math.max(currentSize, intendedSize) + 1024;
-    return Math.ceil(minNewSize / 1024) * 1024;
-}
-const defaultInitialCapacity = 10240;
-/**
- * ByteBuffer is a wrapper of DataView which also adds a read and write offset.
- *  Also in a write operation it resizes the buffer is being used if it needs.
- *
- * - Use read and write function to generate or consume data.
- * - Use set and get only if you are sure that you're doing.
- */
-export function createByteBuffer(options = {}) {
-    const initialROffset = options.reading?.currentOffset || 0;
-    let initialBuffer = null;
-    let initialWOffset = 0;
-    if (options.writing) {
-        initialBuffer = options.writing.buffer;
-        if (options.writing.currentOffset) {
-            initialWOffset = options.writing.currentOffset;
-        }
-    }
-    else if (options.reading) {
-        initialBuffer = options.reading.buffer;
-        initialWOffset = options.reading.length || options.reading.buffer.length;
-    }
-    else {
-        initialBuffer = new Uint8Array(options.initialCapacity || defaultInitialCapacity);
-    }
-    let buffer = initialBuffer;
-    let view = new DataView(buffer.buffer, buffer.byteOffset);
-    let woffset = initialWOffset;
-    let roffset = initialROffset;
-    /**
-     * Increement the write offset and resize the buffer if it needs.
-     */
-    const woAdd = (amount) => {
-        if (woffset + amount > buffer.byteLength) {
-            const newsize = getNextSize(buffer.byteLength, woffset + amount);
-            const newBuffer = new Uint8Array(newsize);
-            newBuffer.set(buffer);
-            buffer = newBuffer;
-            view = new DataView(buffer.buffer);
-        }
-        woffset += amount;
-        return woffset - amount;
-    };
-    /**
-     * Increment the read offset and throw an error if it's trying to read
-     *  outside the bounds.
-     */
-    const roAdd = (amount) => {
-        if (roffset + amount > woffset) {
-            throw new Error('Outside of the bounds of writen data.');
-        }
-        roffset += amount;
-        return roffset - amount;
-    };
-    return {
-        /**
-         * @returns The entire current Uint8Array.
-         *
-         * WARNING: if the buffer grows, the view had changed itself,
-         *  and the reference will be a invalid one.
-         */
-        buffer() {
-            return buffer;
-        },
-        /**
-         * @returns The capacity of the current buffer
-         */
-        bufferLength() {
-            return buffer.length;
-        },
-        /**
-         * Resets byteBuffer to avoid creating a new one
-         */
-        resetBuffer() {
-            roffset = 0;
-            woffset = 0;
-        },
-        /**
-         * @returns The current read offset
-         */
-        currentReadOffset() {
-            return roffset;
-        },
-        /**
-         * @returns The current write offset
-         */
-        currentWriteOffset() {
-            return woffset;
-        },
-        /**
-         * Reading purpose
-         * Returns the previuos offsset size before incrementing
-         */
-        incrementReadOffset(amount) {
-            return roAdd(amount);
-        },
-        /**
-         * @returns How many bytes are available to read.
-         */
-        remainingBytes() {
-            return woffset - roffset;
-        },
-        readFloat32() {
-            return view.getFloat32(roAdd(4));
-        },
-        readFloat64() {
-            return view.getFloat64(roAdd(8));
-        },
-        readInt8() {
-            return view.getInt8(roAdd(1));
-        },
-        readInt16() {
-            return view.getInt16(roAdd(2));
-        },
-        readInt32() {
-            return view.getInt32(roAdd(4));
-        },
-        readInt64() {
-            return view.getBigInt64(roAdd(8));
-        },
-        readUint8() {
-            return view.getUint8(roAdd(1));
-        },
-        readUint16() {
-            return view.getUint16(roAdd(2));
-        },
-        readUint32() {
-            return view.getUint32(roAdd(4));
-        },
-        readUint64() {
-            return view.getBigUint64(roAdd(8));
-        },
-        readBuffer() {
-            const length = view.getUint32(roAdd(4));
-            return buffer.subarray(roAdd(length), roAdd(0));
-        },
-        /**
-         * Writing purpose
-         */
-        /**
-         * Increment offset
-         * @param amount - how many bytes
-         * @returns The offset when this reserving starts.
-         */
-        incrementWriteOffset(amount) {
-            return woAdd(amount);
-        },
-        /**
-         * @returns The total number of bytes writen in the buffer.
-         */
-        size() {
-            return woffset;
-        },
-        /**
-         * @returns The subarray from 0 to offset.
-         */
-        toBinary() {
-            return buffer.subarray(0, woffset);
-        },
-        writeBuffer(value, writeLength = true) {
-            if (writeLength) {
-                this.writeUint32(value.byteLength);
-            }
-            // TODO: lean
-            const o = woAdd(value.byteLength);
-            buffer.set(value, o);
-        },
-        writeFloat32(value) {
-            const o = woAdd(4);
-            view.setFloat32(o, value);
-        },
-        writeFloat64(value) {
-            const o = woAdd(8);
-            view.setFloat64(o, value);
-        },
-        writeInt8(value) {
-            const o = woAdd(1);
-            view.setInt8(o, value);
-        },
-        writeInt16(value) {
-            const o = woAdd(2);
-            view.setInt16(o, value);
-        },
-        writeInt32(value) {
-            const o = woAdd(4);
-            view.setInt32(o, value);
-        },
-        writeInt64(value) {
-            const o = woAdd(8);
-            view.setBigInt64(o, value);
-        },
-        writeUint8(value) {
-            const o = woAdd(1);
-            view.setUint8(o, value);
-        },
-        writeUint16(value) {
-            const o = woAdd(2);
-            view.setUint16(o, value);
-        },
-        writeUint32(value) {
-            const o = woAdd(4);
-            view.setUint32(o, value);
-        },
-        writeUint64(value) {
-            const o = woAdd(8);
-            view.setBigUint64(o, value);
-        },
-        // Dataview Proxy
-        getFloat32(offset) {
-            return view.getFloat32(offset);
-        },
-        getFloat64(offset) {
-            return view.getFloat64(offset);
-        },
-        getInt8(offset) {
-            return view.getInt8(offset);
-        },
-        getInt16(offset) {
-            return view.getInt16(offset);
-        },
-        getInt32(offset) {
-            return view.getInt32(offset);
-        },
-        getInt64(offset) {
-            return view.getBigInt64(offset);
-        },
-        getUint8(offset) {
-            return view.getUint8(offset);
-        },
-        getUint16(offset) {
-            return view.getUint16(offset);
-        },
-        getUint32(offset) {
-            return view.getUint32(offset);
-        },
-        getUint64(offset) {
-            return view.getBigUint64(offset);
-        },
-        setFloat32(offset, value) {
-            view.setFloat32(offset, value);
-        },
-        setFloat64(offset, value) {
-            view.setFloat64(offset, value);
-        },
-        setInt8(offset, value) {
-            view.setInt8(offset, value);
-        },
-        setInt16(offset, value) {
-            view.setInt16(offset, value);
-        },
-        setInt32(offset, value) {
-            view.setInt32(offset, value);
-        },
-        setInt64(offset, value) {
-            view.setBigInt64(offset, value);
-        },
-        setUint8(offset, value) {
-            view.setUint8(offset, value);
-        },
-        setUint16(offset, value) {
-            view.setUint16(offset, value);
-        },
-        setUint32(offset, value) {
-            view.setUint32(offset, value);
-        },
-        setUint64(offset, value) {
-            view.setBigUint64(offset, value);
-        }
-    };
-}

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

@@ -1,25 +0,0 @@
-import { ComponentDefinition } from '../../engine/component';
-import { Entity } from '../../engine/entity';
-import { ByteBuffer } from '../ByteBuffer';
-import WireMessage from '../wireMessage';
-export declare namespace PutComponentOperation {
-    /**
-     * @param entity - Uint32 number of the entity
-     * @param componentId - Uint32 number of id
-     * @param timestamp - Uint64 Lamport timestamp
-     * @param data - Uint8[] data of component
-     */
-    type Type = {
-        entity: Entity;
-        componentId: number;
-        timestamp: number;
-        data: Uint8Array;
-    };
-    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, buf: ByteBuffer): void;
-    function read(buf: ByteBuffer): (WireMessage.Header & Type) | null;
-}

package/dist/serialization/crdt/componentOperation.js

@@ -1,39 +0,0 @@
-import WireMessage from '../wireMessage';
-export var PutComponentOperation;
-(function (PutComponentOperation) {
-    PutComponentOperation.MESSAGE_HEADER_LENGTH = 20;
-    /**
-     * Call this function for an optimal writing data passing the ByteBuffer
-     *  already allocated
-     */
-    function write(entity, timestamp, componentDefinition, buf) {
-        // reserve the beginning
-        const startMessageOffset = buf.incrementWriteOffset(WireMessage.HEADER_LENGTH + PutComponentOperation.MESSAGE_HEADER_LENGTH);
-        // write body
-        componentDefinition.writeToByteBuffer(entity, buf);
-        const messageLength = buf.size() - startMessageOffset;
-        // Write WireMessage header
-        buf.setUint32(startMessageOffset, messageLength);
-        buf.setUint32(startMessageOffset + 4, WireMessage.Enum.PUT_COMPONENT);
-        // Write ComponentOperation header
-        buf.setUint32(startMessageOffset + 8, entity);
-        buf.setUint32(startMessageOffset + 12, componentDefinition._id);
-        buf.setUint64(startMessageOffset + 16, BigInt(timestamp));
-        buf.setUint32(startMessageOffset + 24, messageLength - PutComponentOperation.MESSAGE_HEADER_LENGTH - WireMessage.HEADER_LENGTH);
-    }
-    PutComponentOperation.write = write;
-    function read(buf) {
-        const header = WireMessage.readHeader(buf);
-        if (!header) {
-            return null;
-        }
-        return {
-            ...header,
-            entity: buf.readUint32(),
-            componentId: buf.readInt32(),
-            timestamp: Number(buf.readUint64()),
-            data: buf.readBuffer()
-        };
-    }
-    PutComponentOperation.read = read;
-})(PutComponentOperation || (PutComponentOperation = {}));

package/dist/serialization/wireMessage.d.ts

@@ -1,39 +0,0 @@
-/**
- * The wire message is the top-level message that can be packed
- *  inside it can contain a data with another structure or protocol
- *
- * Each wire message has three primitive property that it'll never change
- *   ---> length        uint32 (message size up to 4,294,967,295)
- *   ---> version       uint32 (for now just a number which is zero)
- *   ---> message type  uint32
- * The length indicates how many bytes are above self, the version in
- * combination with message type defines the set of handlers that will be
- * available to process the message
- *
- */
-import { ByteBuffer } from './ByteBuffer';
-declare type Uint32 = number;
-export declare namespace WireMessage {
-    enum Enum {
-        RESERVED = 0,
-        PUT_COMPONENT = 1,
-        DELETE_COMPONENT = 2,
-        MAX_MESSAGE_TYPE = 3
-    }
-    /**
-     * @param length - Uint32 the length of all message (including the header)
-     * @param type - define the function which handles the data
-     */
-    type Header = {
-        length: Uint32;
-        type: Uint32;
-    };
-    const HEADER_LENGTH = 8;
-    /**
-     * Validate if the message incoming is completed
-     * @param buf
-     */
-    function validate(buf: ByteBuffer): boolean;
-    function readHeader(buf: ByteBuffer): Header | null;
-}
-export default WireMessage;

package/dist/serialization/wireMessage.js

@@ -1,53 +0,0 @@
-/**
- * The wire message is the top-level message that can be packed
- *  inside it can contain a data with another structure or protocol
- *
- * Each wire message has three primitive property that it'll never change
- *   ---> length        uint32 (message size up to 4,294,967,295)
- *   ---> version       uint32 (for now just a number which is zero)
- *   ---> message type  uint32
- * The length indicates how many bytes are above self, the version in
- * combination with message type defines the set of handlers that will be
- * available to process the message
- *
- */
-export var WireMessage;
-(function (WireMessage) {
-    let Enum;
-    (function (Enum) {
-        Enum[Enum["RESERVED"] = 0] = "RESERVED";
-        // Component Operation
-        Enum[Enum["PUT_COMPONENT"] = 1] = "PUT_COMPONENT";
-        Enum[Enum["DELETE_COMPONENT"] = 2] = "DELETE_COMPONENT";
-        // TODO: ?
-        Enum[Enum["MAX_MESSAGE_TYPE"] = 3] = "MAX_MESSAGE_TYPE";
-    })(Enum = WireMessage.Enum || (WireMessage.Enum = {}));
-    WireMessage.HEADER_LENGTH = 8;
-    /**
-     * Validate if the message incoming is completed
-     * @param buf
-     */
-    function validate(buf) {
-        const rem = buf.remainingBytes();
-        if (rem < WireMessage.HEADER_LENGTH) {
-            return false;
-        }
-        const messageLength = buf.getUint32(buf.currentReadOffset());
-        if (rem < messageLength) {
-            return false;
-        }
-        return true;
-    }
-    WireMessage.validate = validate;
-    function readHeader(buf) {
-        if (!validate(buf)) {
-            return null;
-        }
-        return {
-            length: buf.readUint32(),
-            type: buf.readUint32()
-        };
-    }
-    WireMessage.readHeader = readHeader;
-})(WireMessage || (WireMessage = {}));
-export default WireMessage;

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

@@ -1,6 +0,0 @@
-import type { PreEngine } from '../../engine';
-import { Entity } from '../../engine/entity';
-export declare function crdtSceneSystem(engine: PreEngine): {
-    createMessages: (dirtyMap: Map<Entity, Set<number>>) => void;
-    receiveMessages: () => void;
-};

package/dist/systems/crdt/index.js

@@ -1,147 +0,0 @@
-import { crdtProtocol } from '@dcl/crdt';
-import EntityUtils from '../../engine/entity-utils';
-import { createByteBuffer } from '../../serialization/ByteBuffer';
-import { PutComponentOperation as Message } from '../../serialization/crdt/componentOperation';
-import WireMessage from '../../serialization/wireMessage';
-import { getTransports } from './transport';
-import CrdtUtils from './utils';
-export function crdtSceneSystem(engine) {
-    // CRDT Client
-    const crdtClient = crdtProtocol();
-    // Messages that we received at transport.onMessage waiting to be processed
-    const receivedMessages = [];
-    // Messages already processed by the engine but that we need to broadcast to other transports.
-    const transportMessages = [];
-    // Map of entities already processed at least once
-    const crdtEntities = new Map();
-    const transports = getTransports();
-    transports.forEach((transport) => (transport.onmessage = parseChunkMessage(transport.type)));
-    /**
-     *
-     * @param transportType tranport id to identiy messages
-     * @returns a function to process received messages
-     */
-    function parseChunkMessage(transportType) {
-        /**
-         * Receives a chunk of binary messages and stores all the valid
-         * Component Operation Messages at messages queue
-         * @param chunkMessage A chunk of binary messages
-         */
-        return function parseChunkMessage(chunkMessage) {
-            if (!chunkMessage.data?.length)
-                return;
-            const buffer = createByteBuffer({
-                reading: { buffer: chunkMessage.data, currentOffset: 0 }
-            });
-            while (WireMessage.validate(buffer)) {
-                const offset = buffer.currentReadOffset();
-                const message = Message.read(buffer);
-                const { entity, componentId, data, timestamp } = message;
-                receivedMessages.push({
-                    entity,
-                    componentId,
-                    data,
-                    timestamp,
-                    transportType,
-                    messageBuffer: buffer
-                        .buffer()
-                        .subarray(offset, buffer.currentReadOffset())
-                });
-            }
-        };
-    }
-    /**
-     * Return and clear the messaes queue
-     * @returns messages recieved by the transport to process on the next tick
-     */
-    function getMessages(value) {
-        const messagesToProcess = Array.from(value);
-        value.length = 0;
-        return messagesToProcess;
-    }
-    /**
-     * This fn will be called on every tick.
-     * Process all the messages queue received by the transport
-     */
-    function receiveMessages() {
-        const messagesToProcess = getMessages(receivedMessages);
-        for (const transport of transports) {
-            const buffer = createByteBuffer();
-            for (const message of messagesToProcess) {
-                const { data, timestamp, componentId, entity } = message;
-                const crdtMessage = {
-                    key: CrdtUtils.getKey(entity, componentId),
-                    data: data,
-                    timestamp: timestamp
-                };
-                const component = engine.getComponent(componentId);
-                const currentMessage = crdtClient.processMessage(crdtMessage);
-                // CRDT outdated message. Resend this message through the wire
-                // TODO: perf transactor
-                if (crdtMessage !== currentMessage) {
-                    // CRDT outdated message. Resend this message through the wire
-                    Message.write(entity, currentMessage.timestamp, component, buffer);
-                }
-                else {
-                    const opts = { reading: { buffer: message.data, currentOffset: 0 } };
-                    const bb = createByteBuffer(opts);
-                    // Update engine component
-                    component.upsertFromBinary(message.entity, bb);
-                    component.clearDirty();
-                    // Add message to transport queue to be processed by others transports
-                    transportMessages.push(message);
-                }
-            }
-            if (buffer.size()) {
-                transport.send(buffer.toBinary());
-            }
-        }
-    }
-    /**
-     * Iterates the dirty map and generates crdt messages to be send
-     * @param dirtyMap a map of { entities: [componentId] }
-     */
-    function createMessages(dirtyMap) {
-        // CRDT Messages will be the merge between the recieved transport messages and the new crdt messages
-        const crdtMessages = getMessages(transportMessages);
-        const buffer = createByteBuffer();
-        for (const [entity, componentsId] of dirtyMap) {
-            for (const componentId of componentsId) {
-                const component = engine.getComponent(componentId);
-                const event = crdtClient.createEvent(CrdtUtils.getKey(entity, componentId), component.toBinary(entity).toBinary());
-                const offset = buffer.currentWriteOffset();
-                // There is no need to create messages for the static entities the first time they are created
-                // They are part of the scene loading. Send only updates.
-                if (!EntityUtils.isStaticEntity(entity) || crdtEntities.has(entity)) {
-                    Message.write(entity, event.timestamp, component, buffer);
-                    crdtMessages.push({
-                        componentId,
-                        entity,
-                        timestamp: event.timestamp,
-                        messageBuffer: buffer
-                            .buffer()
-                            .subarray(offset, buffer.currentWriteOffset())
-                    });
-                }
-            }
-            crdtEntities.set(entity, true);
-        }
-        // Send messages to transports
-        const transportBuffer = createByteBuffer();
-        for (const transport of transports) {
-            transportBuffer.resetBuffer();
-            for (const message of crdtMessages) {
-                if (transport.filter(message)) {
-                    transportBuffer.writeBuffer(message.messageBuffer, false);
-                }
-            }
-            if (transportBuffer.size()) {
-                transport.send(transportBuffer.toBinary());
-            }
-        }
-    }
-    return {
-        createMessages,
-        receiveMessages
-    };
-}

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

@@ -1,8 +0,0 @@
-import { TransportMessage } from './types';
-export declare type Transport = {
-    type: string;
-    send(message: Uint8Array): void;
-    onmessage?(message: MessageEvent<Uint8Array>): void;
-    filter(message: TransportMessage): boolean;
-};
-export declare function getTransports(): Transport[];

package/dist/systems/crdt/transport.js

@@ -1,21 +0,0 @@
-function networkTransport() {
-    // const rpc = new RpcTransport()
-    const rpc = {
-        send: () => { }
-    };
-    const type = 'network-transport';
-    return {
-        ...rpc,
-        type,
-        filter(message) {
-            // Echo message, ignore them
-            if (message.transportType === type) {
-                return false;
-            }
-            return !!message; // validComponents.includes(componentId)
-        }
-    };
-}
-export function getTransports() {
-    return [networkTransport()];
-}

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

@@ -1,10 +0,0 @@
-import { Entity } from '../../engine/entity';
-export declare type ReceiveMessage = {
-    entity: Entity;
-    componentId: number;
-    timestamp: number;
-    transportType?: string;
-    data: Uint8Array;
-    messageBuffer: Uint8Array;
-};
-export declare type TransportMessage = Omit<ReceiveMessage, 'data'>;

package/dist/systems/crdt/types.js

@@ -1 +0,0 @@
-export {};

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

@@ -1,11 +0,0 @@
-import { ComponentDefinition } from '../../engine/component';
-import { Entity } from '../../engine/entity';
-export declare namespace CrdtUtils {
-    type ComponentID = ComponentDefinition['_id'];
-    function getKey(entity: Entity, componentId: ComponentID): string;
-    enum SynchronizedEntityType {
-        NETWORKED = 0,
-        RENDERER = 1
-    }
-}
-export default CrdtUtils;