@dcl/ecs 7.0.6-4177592674.commit-39cdc99 → 7.0.6-4183962432.commit-2fbe270

package/dist/engine/types.d.ts

@@ -1,25 +1,22 @@
 import type { ISchema } from '../schemas/ISchema';
 import { MapResult, Spec } from '../schemas/Map';
 import { Transport } from '../systems/crdt/types';
-import { ComponentDefinition } from './component';
+import { ComponentDefinition, GrowOnlyValueSetComponentDefinition, LastWriteWinElementSetComponentDefinition } from './component';
 import { Entity, EntityState } from './entity';
+import { ValueSetOptions } from './grow-only-value-set-component-definition';
 import { ReadonlyComponentSchema } from './readonly';
 import { SystemFn } from './systems';
+export * from './component';
+export { ValueSetOptions };
 /**
  * @public
  */
 export type Unpacked<T> = T extends (infer U)[] ? U : T;
-/**
- * @public
- */
-export type ComponentSchema<T extends [ComponentDefinition<any>, ...ComponentDefinition<any>[]]> = {
-    [K in keyof T]: T[K] extends ComponentDefinition<any> ? ReturnType<T[K]['getMutable']> : never;
-};
 /**
  * @public
  * Overrides component definition to support partial default values
  */
-export interface MapComponentDefinition<T> extends ComponentDefinition<T> {
+export interface MapComponentDefinition<T> extends LastWriteWinElementSetComponentDefinition<T> {
     /**
      * Add the current component to an entity, throw an error if the component already exists (use `createOrReplace` instead).
      * - Internal comment: This method adds the &lt;entity,component&gt; to the list to be reviewed next frame
@@ -128,7 +125,21 @@ export interface IEngine {
      * const StateComponent = engine.defineComponentFromSchema("my-lib::VisibleComponent", Schemas.Bool)
      * ```
      */
-    defineComponentFromSchema<T>(componentName: string, spec: ISchema<T>): ComponentDefinition<T>;
+    defineComponentFromSchema<T>(componentName: string, spec: ISchema<T>): LastWriteWinElementSetComponentDefinition<T>;
+    /**
+     * @public
+     * Defines a value set component.
+     * @param componentName - unique name to identify the component, a hash is calculated for it, it will fail if the hash has collisions.
+     * @param spec - An object with schema fields
+     * @returns The component definition
+     *
+     * @example
+     * ```ts
+     * const StateComponentId = 10023
+     * const StateComponent = engine.defineValueSetComponentFromSchema("my-lib::VisibleComponent", Schemas.Int)
+     * ```
+     */
+    defineValueSetComponentFromSchema<T>(componentName: string, spec: ISchema<T>, options: ValueSetOptions<T>): GrowOnlyValueSetComponentDefinition<T>;
     /**
      * @public
      * Get the component definition from the component id.

package/dist/engine/types.js

@@ -1 +1 @@
-export {};
+export * from './component';

package/dist/runtime/invariant.d.ts

@@ -1,3 +1,4 @@
 type K = unknown | Promise<unknown>;
+export declare const __DEV__: boolean;
 export declare function checkNotThenable<T extends K>(t: T, error: string): T;
 export {};

package/dist/runtime/invariant.js

@@ -1,5 +1,10 @@
+/* istanbul ignore file */
+export const __DEV__ = (typeof DEBUG === 'boolean' && DEBUG) ||
+    (typeof process === 'object' &&
+        (process.env?.NODE_ENV !== 'production' || process.env?.NODE_ENV === 'development')) ||
+    false;
 export function checkNotThenable(t, error) {
-    if (globalThis.DEBUG) {
+    if (__DEV__) {
         if (t && typeof t === 'object' && typeof t.then === 'function') {
             throw new Error(error);
         }

package/dist/runtime/types.d.ts

@@ -1,7 +1,6 @@
 export type { SystemFn } from '../engine/systems';
 export type { TransportMessage, ReceiveMessage, Transport } from '../systems/crdt/types';
-export { TransformType, TransformComponent } from '../components/legacy/Transform';
+export { TransformType, TransformComponent } from '../components/manual/Transform';
 export * from '../engine/component';
 export * from '../schemas/typing';
 export type { MapResult, Spec } from '../schemas/Map';
-export * from '../engine/component';

package/dist/runtime/types.js

@@ -1,3 +1,2 @@
 export * from '../engine/component';
 export * from '../schemas/typing';
-export * from '../engine/component';

package/dist/schemas/Array.js

@@ -19,6 +19,11 @@ export const IArray = (type) => {
         },
         create() {
             return [];
+        },
+        jsonSchema: {
+            type: 'array',
+            items: type.jsonSchema,
+            serializationType: 'array'
         }
     };
 };

package/dist/schemas/ISchema.d.ts

@@ -1,10 +1,35 @@
+import { DeepReadonly } from '../engine/readonly';
 import { ByteBuffer } from '../serialization/ByteBuffer';
+/**
+ * @public
+ */
+export type JsonPrimitive = string | number | boolean | null;
+/**
+ * @public
+ */
+export type JsonMap = {
+    [key: string]: JsonPrimitive | JsonMap | JsonArray;
+};
+/**
+ * @public
+ */
+export type JsonArray = Array<JsonPrimitive | JsonMap | JsonArray>;
+/**
+ * JsonSchemaExtended must specify the type, and it can has more primitives params.
+ * Functions are not allowed.
+ * @public
+ */
+export type JsonSchemaExtended = {
+    type: 'object' | 'number' | 'integer' | 'string' | 'array' | 'boolean';
+    serializationType: 'boolean' | 'enum-int' | 'enum-string' | 'int8' | 'int16' | 'int32' | 'int64' | 'float32' | 'float64' | 'vector3' | 'color3' | 'quaternion' | 'color4' | 'map' | 'optional' | 'entity' | 'array' | 'utf8-string' | 'protocol-buffer' | 'transform' | 'unknown';
+} & JsonMap;
 /**
  * @public
  */
 export interface ISchema<T = any> {
-    serialize(value: T, builder: ByteBuffer): void;
+    serialize(value: DeepReadonly<T>, builder: ByteBuffer): void;
     deserialize(reader: ByteBuffer): T;
     create(): T;
-    extend?: (base?: T) => T;
+    extend?: (base: Partial<DeepReadonly<T>> | undefined) => T;
+    jsonSchema: JsonSchemaExtended;
 }

package/dist/schemas/Map.d.ts

@@ -18,4 +18,3 @@ export type MapResult<T extends Spec> = ToOptional<{
 export type MapResultWithOptional<T extends Spec> = ToOptional<{
     [K in keyof T]?: T[K] extends ISchema ? ReturnType<T[K]['deserialize']> : T[K] extends Spec ? MapResult<T[K]> : never;
 }>;
-export type MapSchemaType<T extends Spec> = ISchema<MapResult<T>>;

package/dist/schemas/Map.js

@@ -2,6 +2,10 @@
  * @internal
  */
 export const IMap = (spec, defaultValue) => {
+    const specReflection = Object.keys(spec).reduce((specReflection, currentKey) => {
+        specReflection[currentKey] = spec[currentKey].jsonSchema;
+        return specReflection;
+    }, {});
     return {
         serialize(value, builder) {
             for (const key in spec) {
@@ -31,6 +35,11 @@ export const IMap = (spec, defaultValue) => {
                 newValue[key] = spec[key].create();
             }
             return { ...newValue, ...defaultValue, ...base };
+        },
+        jsonSchema: {
+            type: 'object',
+            properties: specReflection,
+            serializationType: 'map'
         }
     };
 };

package/dist/schemas/Optional.js

@@ -20,6 +20,11 @@ export const IOptional = (spec) => {
         },
         create() {
             return undefined;
+        },
+        jsonSchema: {
+            type: spec.jsonSchema.type,
+            serializationType: 'optional',
+            optionalJsonSchema: spec.jsonSchema
         }
     };
 };

package/dist/schemas/basic/Boolean.js

@@ -10,5 +10,9 @@ export const Bool = {
     },
     create() {
         return false;
+    },
+    jsonSchema: {
+        type: 'boolean',
+        serializationType: 'boolean'
     }
 };

package/dist/schemas/basic/Enum.js

@@ -33,6 +33,10 @@ function validateMemberValuesAreStrings(enumValue) {
         }
     }
 }
+/**
+ * @internal
+ */
+export const IntEnumReflectionType = 'enum-int';
 /**
  * @internal
  */
@@ -47,14 +51,28 @@ export const IntEnum = (enumObject, defaultValue) => {
         },
         create() {
             return defaultValue;
+        },
+        jsonSchema: {
+            // JSON-schema
+            type: 'integer',
+            enum: Object.values(enumObject).filter((item) => Number.isInteger(item)),
+            default: defaultValue,
+            // @dcl/ecs Schema Spec
+            serializationType: IntEnumReflectionType,
+            enumObject
         }
     };
 };
+/**
+ * @internal
+ */
+export const StringEnumReflectionType = 'enum-string';
 /**
  * @internal
  */
 export const StringEnum = (enumObject, defaultValue) => {
     validateMemberValuesAreStrings(enumObject);
+    // String enum has the exact mapping from key (our reference in code) to values
     return {
         serialize(value, builder) {
             FlatString.serialize(value, builder);
@@ -64,6 +82,15 @@ export const StringEnum = (enumObject, defaultValue) => {
         },
         create() {
             return defaultValue;
+        },
+        jsonSchema: {
+            // JSON-schema
+            type: 'string',
+            enum: Object.values(enumObject),
+            default: defaultValue,
+            // @dcl/ecs Schema Spec
+            serializationType: StringEnumReflectionType,
+            enumObject
         }
     };
 };

package/dist/schemas/basic/Float.js

@@ -10,6 +10,10 @@ export const Float32 = {
     },
     create() {
         return 0.0;
+    },
+    jsonSchema: {
+        type: 'number',
+        serializationType: 'float32'
     }
 };
 /**
@@ -24,5 +28,9 @@ export const Float64 = {
     },
     create() {
         return 0.0;
+    },
+    jsonSchema: {
+        type: 'number',
+        serializationType: 'float64'
     }
 };

package/dist/schemas/basic/Integer.js

@@ -10,6 +10,10 @@ export const Int64 = {
     },
     create() {
         return 0;
+    },
+    jsonSchema: {
+        type: 'integer',
+        serializationType: 'int64'
     }
 };
 /**
@@ -24,6 +28,10 @@ export const Int32 = {
     },
     create() {
         return 0;
+    },
+    jsonSchema: {
+        type: 'integer',
+        serializationType: 'int32'
     }
 };
 /**
@@ -38,6 +46,10 @@ export const Int16 = {
     },
     create() {
         return 0;
+    },
+    jsonSchema: {
+        type: 'integer',
+        serializationType: 'int16'
     }
 };
 /**
@@ -52,5 +64,9 @@ export const Int8 = {
     },
     create() {
         return 0;
+    },
+    jsonSchema: {
+        type: 'integer',
+        serializationType: 'int8'
     }
 };

package/dist/schemas/basic/String.js

@@ -10,6 +10,10 @@ export const FlatString = {
     },
     create() {
         return '';
+    },
+    jsonSchema: {
+        type: 'string',
+        serializationType: 'utf8-string'
     }
 };
 /**

package/dist/schemas/buildSchema.d.ts

@@ -0,0 +1,7 @@
+import { ISchema, JsonSchemaExtended } from './ISchema';
+/**
+ * Create an ISchema object from the json-schema
+ * @param jsonSchema
+ * @returns a ISchema or fail for unsupported json-schema
+ */
+export declare function jsonSchemaToSchema(jsonSchema: JsonSchemaExtended): ISchema<any>;

package/dist/schemas/buildSchema.js

@@ -0,0 +1,63 @@
+import { IArray } from './Array';
+import { Bool } from './basic/Boolean';
+import { IntEnum, StringEnum } from './basic/Enum';
+import { Float32, Float64 } from './basic/Float';
+import { Int16, Int32, Int64, Int8 } from './basic/Integer';
+import { EcsString } from './basic/String';
+import { Color3Schema } from './custom/Color3';
+import { Color4Schema } from './custom/Color4';
+import { EntitySchema } from './custom/Entity';
+import { QuaternionSchema } from './custom/Quaternion';
+import { Vector3Schema } from './custom/Vector3';
+import { IMap } from './Map';
+import { IOptional } from './Optional';
+const primitiveSchemas = {
+    [Bool.jsonSchema.serializationType]: Bool,
+    [EcsString.jsonSchema.serializationType]: EcsString,
+    [Float32.jsonSchema.serializationType]: Float32,
+    [Float64.jsonSchema.serializationType]: Float64,
+    [Int8.jsonSchema.serializationType]: Int8,
+    [Int16.jsonSchema.serializationType]: Int16,
+    [Int32.jsonSchema.serializationType]: Int32,
+    [Int64.jsonSchema.serializationType]: Int64,
+    [Vector3Schema.jsonSchema.serializationType]: Vector3Schema,
+    [QuaternionSchema.jsonSchema.serializationType]: QuaternionSchema,
+    [Color3Schema.jsonSchema.serializationType]: Color3Schema,
+    [Color4Schema.jsonSchema.serializationType]: Color4Schema,
+    [EntitySchema.jsonSchema.serializationType]: EntitySchema
+};
+/**
+ * Create an ISchema object from the json-schema
+ * @param jsonSchema
+ * @returns a ISchema or fail for unsupported json-schema
+ */
+export function jsonSchemaToSchema(jsonSchema) {
+    if (primitiveSchemas[jsonSchema.serializationType]) {
+        return primitiveSchemas[jsonSchema.serializationType];
+    }
+    if (jsonSchema.serializationType === 'map') {
+        const mapJsonSchema = jsonSchema;
+        const spec = {};
+        for (const key in mapJsonSchema.properties) {
+            spec[key] = jsonSchemaToSchema(mapJsonSchema.properties[key]);
+        }
+        return IMap(spec);
+    }
+    if (jsonSchema.serializationType === 'optional') {
+        const withItemsJsonSchema = jsonSchema;
+        return IOptional(jsonSchemaToSchema(withItemsJsonSchema.optionalJsonSchema));
+    }
+    if (jsonSchema.serializationType === 'array') {
+        const withItemsJsonSchema = jsonSchema;
+        return IArray(jsonSchemaToSchema(withItemsJsonSchema.items));
+    }
+    if (jsonSchema.serializationType === 'enum-int') {
+        const enumJsonSchema = jsonSchema;
+        return IntEnum(enumJsonSchema.enumObject, enumJsonSchema.default);
+    }
+    if (jsonSchema.serializationType === 'enum-string') {
+        const enumJsonSchema = jsonSchema;
+        return StringEnum(enumJsonSchema.enumObject, enumJsonSchema.default);
+    }
+    throw new Error(`${jsonSchema.serializationType} is not supported as reverse schema generation.`);
+}

package/dist/schemas/custom/Color3.js

@@ -16,5 +16,14 @@ export const Color3Schema = {
     },
     create() {
         return { r: 0, g: 0, b: 0 };
+    },
+    jsonSchema: {
+        type: 'object',
+        properties: {
+            r: { type: 'number' },
+            g: { type: 'number' },
+            b: { type: 'number' }
+        },
+        serializationType: 'color3'
     }
 };

package/dist/schemas/custom/Color4.js

@@ -18,5 +18,15 @@ export const Color4Schema = {
     },
     create() {
         return { r: 0, g: 0, b: 0, a: 0 };
+    },
+    jsonSchema: {
+        type: 'object',
+        properties: {
+            r: { type: 'number' },
+            g: { type: 'number' },
+            b: { type: 'number' },
+            a: { type: 'number' }
+        },
+        serializationType: 'color4'
     }
 };

package/dist/schemas/custom/Entity.js

@@ -10,5 +10,9 @@ export const EntitySchema = {
     },
     create() {
         return 0;
+    },
+    jsonSchema: {
+        type: 'integer',
+        serializationType: 'entity'
     }
 };

package/dist/schemas/custom/Quaternion.js

@@ -18,5 +18,15 @@ export const QuaternionSchema = {
     },
     create() {
         return { x: 0, y: 0, z: 0, w: 0 };
+    },
+    jsonSchema: {
+        type: 'object',
+        properties: {
+            x: { type: 'number' },
+            y: { type: 'number' },
+            z: { type: 'number' },
+            w: { type: 'number' }
+        },
+        serializationType: 'quaternion'
     }
 };

package/dist/schemas/custom/Vector3.js

@@ -16,5 +16,15 @@ export const Vector3Schema = {
     },
     create() {
         return { x: 0, y: 0, z: 0 };
+    },
+    jsonSchema: {
+        type: 'object',
+        properties: {
+            x: { type: 'number' },
+            y: { type: 'number' },
+            z: { type: 'number' },
+            w: { type: 'number' }
+        },
+        serializationType: 'vector3'
     }
 };

package/dist/schemas/index.d.ts

@@ -3,8 +3,8 @@ import { Color3Type } from './custom/Color3';
 import { Color4Type } from './custom/Color4';
 import { QuaternionType } from './custom/Quaternion';
 import { Vector3Type } from './custom/Vector3';
-import { ISchema } from './ISchema';
-export { QuaternionType, Vector3Type, ISchema, Color3Type, Color4Type };
+import { ISchema, JsonSchemaExtended, JsonArray, JsonMap, JsonPrimitive } from './ISchema';
+export { QuaternionType, Vector3Type, ISchema, Color3Type, Color4Type, JsonSchemaExtended, JsonArray, JsonMap, JsonPrimitive };
 /**
  * @public
  */

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

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

package/dist/serialization/crdt/appendValue.js

@@ -0,0 +1,49 @@
+import { CrdtMessageProtocol } from './crdtMessageProtocol';
+import { CrdtMessageType, CRDT_MESSAGE_HEADER_LENGTH } from './types';
+/**
+ * @internal
+ */
+export var AppendValueOperation;
+(function (AppendValueOperation) {
+    AppendValueOperation.MESSAGE_HEADER_LENGTH = 16;
+    /**
+     * Call this function for an optimal writing data passing the ByteBuffer
+     *  already allocated
+     */
+    function write(entity, timestamp, componentId, data, buf) {
+        // reserve the beginning
+        const startMessageOffset = buf.incrementWriteOffset(CRDT_MESSAGE_HEADER_LENGTH + AppendValueOperation.MESSAGE_HEADER_LENGTH);
+        // write body
+        buf.writeBuffer(data, false);
+        const messageLength = buf.currentWriteOffset() - startMessageOffset;
+        // Write CrdtMessage header
+        buf.setUint32(startMessageOffset, messageLength);
+        buf.setUint32(startMessageOffset + 4, CrdtMessageType.APPEND_VALUE);
+        // Write ComponentOperation header
+        buf.setUint32(startMessageOffset + 8, entity);
+        buf.setUint32(startMessageOffset + 12, componentId);
+        buf.setUint32(startMessageOffset + 16, timestamp);
+        const newLocal = messageLength - AppendValueOperation.MESSAGE_HEADER_LENGTH - CRDT_MESSAGE_HEADER_LENGTH;
+        buf.setUint32(startMessageOffset + 20, newLocal);
+    }
+    AppendValueOperation.write = write;
+    function read(buf) {
+        const header = CrdtMessageProtocol.readHeader(buf);
+        /* istanbul ignore if */
+        if (!header) {
+            return null;
+        }
+        /* istanbul ignore if */
+        if (header.type !== CrdtMessageType.APPEND_VALUE) {
+            throw new Error('AppendValueOperation tried to read another message type.');
+        }
+        return {
+            ...header,
+            entityId: buf.readUint32(),
+            componentId: buf.readUint32(),
+            timestamp: buf.readUint32(),
+            data: buf.readBuffer()
+        };
+    }
+    AppendValueOperation.read = read;
+})(AppendValueOperation || (AppendValueOperation = {}));

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

@@ -1,4 +1,5 @@
 export * from './deleteComponent';
+export * from './appendValue';
 export * from './deleteEntity';
 export * from './putComponent';
 export * from './types';

package/dist/serialization/crdt/index.js

@@ -1,4 +1,5 @@
 export * from './deleteComponent';
+export * from './appendValue';
 export * from './deleteEntity';
 export * from './putComponent';
 export * from './types';

package/dist/serialization/crdt/message.js

@@ -3,6 +3,7 @@ import { CrdtMessageType } from './types';
 import { PutComponentOperation } from './putComponent';
 import { DeleteComponent } from './deleteComponent';
 import { DeleteEntity } from './deleteEntity';
+import { AppendValueOperation } from './appendValue';
 export function readMessage(buf) {
     const header = CrdtMessageProtocol.getHeader(buf);
     if (!header)
@@ -13,6 +14,9 @@ export function readMessage(buf) {
     else if (header.type === CrdtMessageType.DELETE_COMPONENT) {
         return DeleteComponent.read(buf);
     }
+    else if (header.type === CrdtMessageType.APPEND_VALUE) {
+        return AppendValueOperation.read(buf);
+    }
     else if (header.type === CrdtMessageType.DELETE_ENTITY) {
         return DeleteEntity.read(buf);
     }

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

@@ -7,7 +7,8 @@ export declare enum CrdtMessageType {
     PUT_COMPONENT = 1,
     DELETE_COMPONENT = 2,
     DELETE_ENTITY = 3,
-    MAX_MESSAGE_TYPE = 4
+    APPEND_VALUE = 4,
+    MAX_MESSAGE_TYPE = 5
 }
 /**
  * Min length = 8 bytes
@@ -40,6 +41,22 @@ export type PutComponentMessageBody = {
     timestamp: number;
     data: Uint8Array;
 };
+/**
+ * Min. length = header (8 bytes) + 16 bytes = 24 bytes
+ *
+ * @param entity - Uint32 number of the entity
+ * @param componentId - Uint32 number of id
+ * @param timestamp - Uint32 timestamp
+ * @param data - Uint8[] data of component => length(4 bytes) + block of bytes[0..length-1]
+ * @public
+ */
+export type AppendValueMessageBody = {
+    type: CrdtMessageType.APPEND_VALUE;
+    entityId: Entity;
+    componentId: number;
+    timestamp: number;
+    data: Uint8Array;
+};
 /**
  * @param entity - Uint32 number of the entity
  * @param componentId - Uint32 number of id
@@ -60,6 +77,10 @@ export type DeleteEntityMessageBody = {
     type: CrdtMessageType.DELETE_ENTITY;
     entityId: Entity;
 };
+/**
+ * @public
+ */
+export type AppendValueMessage = CrdtMessageHeader & AppendValueMessageBody;
 /**
  * @public
  */
@@ -75,11 +96,11 @@ export type DeleteEntityMessage = CrdtMessageHeader & DeleteEntityMessageBody;
 /**
  * @public
  */
-export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | DeleteEntityMessage;
+export type CrdtMessage = PutComponentMessage | DeleteComponentMessage | DeleteEntityMessage | AppendValueMessage;
 /**
  * @public
  */
-export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody;
+export type CrdtMessageBody = PutComponentMessageBody | DeleteComponentMessageBody | DeleteEntityMessageBody | AppendValueMessageBody;
 export declare enum ProcessMessageResultType {
     /**
      * Typical message and new state set.

package/dist/serialization/crdt/types.js

@@ -8,7 +8,8 @@ export var CrdtMessageType;
     CrdtMessageType[CrdtMessageType["PUT_COMPONENT"] = 1] = "PUT_COMPONENT";
     CrdtMessageType[CrdtMessageType["DELETE_COMPONENT"] = 2] = "DELETE_COMPONENT";
     CrdtMessageType[CrdtMessageType["DELETE_ENTITY"] = 3] = "DELETE_ENTITY";
-    CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 4] = "MAX_MESSAGE_TYPE";
+    CrdtMessageType[CrdtMessageType["APPEND_VALUE"] = 4] = "APPEND_VALUE";
+    CrdtMessageType[CrdtMessageType["MAX_MESSAGE_TYPE"] = 5] = "MAX_MESSAGE_TYPE";
 })(CrdtMessageType || (CrdtMessageType = {}));
 /**
  * @public

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

@@ -4,4 +4,4 @@ import { CrdtMessageType } from '../../serialization/crdt/types';
 /**
  * @public
  */
-export type OnChangeFunction = (entity: Entity, operation: CrdtMessageType, component?: ComponentDefinition<any>) => void;
+export type OnChangeFunction = (entity: Entity, operation: CrdtMessageType, component?: ComponentDefinition<any>, componentValue?: any) => void;