@dcl/ecs 7.1.12-4982829389.commit-f2f84bd → 7.1.12-4983011170.commit-adaaaa2

package/dist-cjs/schemas/buildSchema/utils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeAndValue = exports.isCompoundType = exports.getUnknownSchema = exports.isOneOfJsonSchema = exports.isSchemaType = void 0;
+const isSchemaType = (value, types) => types.includes(value.serializationType);
+exports.isSchemaType = isSchemaType;
+const isOneOfJsonSchema = (type) => (0, exports.isSchemaType)(type, ['one-of']);
+exports.isOneOfJsonSchema = isOneOfJsonSchema;
+const getUnknownSchema = () => ({
+    type: { type: 'object', serializationType: 'unknown' },
+    value: undefined
+});
+exports.getUnknownSchema = getUnknownSchema;
+const isCompoundType = (type) => (0, exports.isSchemaType)(type, ['array', 'map']);
+exports.isCompoundType = isCompoundType;
+const getTypeAndValue = (properties, value, key) => {
+    const type = properties[key];
+    const valueKey = value[key];
+    if ((0, exports.isOneOfJsonSchema)(type)) {
+        const typedMapValue = valueKey;
+        if (!typedMapValue.$case)
+            return (0, exports.getUnknownSchema)();
+        const propType = type.properties[typedMapValue.$case];
+        // transform { $case: string; value: unknown } => { [$case]: value }
+        if ((0, exports.isCompoundType)(propType))
+            value[key] = { [typedMapValue.$case]: typedMapValue.value };
+        return { type: propType, value: typedMapValue.value };
+    }
+    return { type, value: valueKey };
+};
+exports.getTypeAndValue = getTypeAndValue;

package/dist-cjs/schemas/custom/Color3.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @public
+ */
+export type Color3Type = {
+    r: number;
+    g: number;
+    b: number;
+};

package/dist-cjs/schemas/custom/Color3.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color3Schema = void 0;
+/**
+ * @internal
+ */
+exports.Color3Schema = {
+    serialize(value, builder) {
+        builder.writeFloat32(value.r);
+        builder.writeFloat32(value.g);
+        builder.writeFloat32(value.b);
+    },
+    deserialize(reader) {
+        return {
+            r: reader.readFloat32(),
+            g: reader.readFloat32(),
+            b: reader.readFloat32()
+        };
+    },
+    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-cjs/schemas/custom/Color4.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @public
+ */
+export type Color4Type = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};

package/dist-cjs/schemas/custom/Color4.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Color4Schema = void 0;
+/**
+ * @internal
+ */
+exports.Color4Schema = {
+    serialize(value, builder) {
+        builder.writeFloat32(value.r);
+        builder.writeFloat32(value.g);
+        builder.writeFloat32(value.b);
+        builder.writeFloat32(value.a);
+    },
+    deserialize(reader) {
+        return {
+            r: reader.readFloat32(),
+            g: reader.readFloat32(),
+            b: reader.readFloat32(),
+            a: reader.readFloat32()
+        };
+    },
+    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-cjs/schemas/custom/Entity.d.ts

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

package/dist-cjs/schemas/custom/Entity.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntitySchema = void 0;
+/**
+ * @internal
+ */
+exports.EntitySchema = {
+    serialize(value, builder) {
+        builder.writeInt32(value);
+    },
+    deserialize(reader) {
+        return reader.readInt32();
+    },
+    create() {
+        return 0;
+    },
+    jsonSchema: {
+        type: 'integer',
+        serializationType: 'entity'
+    }
+};

package/dist-cjs/schemas/custom/Quaternion.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @public
+ */
+export type QuaternionType = {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+};

package/dist-cjs/schemas/custom/Quaternion.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuaternionSchema = void 0;
+/**
+ * @internal
+ */
+exports.QuaternionSchema = {
+    serialize(value, builder) {
+        builder.writeFloat32(value.x);
+        builder.writeFloat32(value.y);
+        builder.writeFloat32(value.z);
+        builder.writeFloat32(value.w);
+    },
+    deserialize(reader) {
+        return {
+            x: reader.readFloat32(),
+            y: reader.readFloat32(),
+            z: reader.readFloat32(),
+            w: reader.readFloat32()
+        };
+    },
+    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-cjs/schemas/custom/Vector3.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @public
+ */
+export type Vector3Type = {
+    x: number;
+    y: number;
+    z: number;
+};

package/dist-cjs/schemas/custom/Vector3.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector3Schema = void 0;
+/**
+ * @internal
+ */
+exports.Vector3Schema = {
+    serialize(value, builder) {
+        builder.writeFloat32(value.x);
+        builder.writeFloat32(value.y);
+        builder.writeFloat32(value.z);
+    },
+    deserialize(reader) {
+        return {
+            x: reader.readFloat32(),
+            y: reader.readFloat32(),
+            z: reader.readFloat32()
+        };
+    },
+    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-cjs/schemas/index.d.ts

@@ -0,0 +1,80 @@
+import { Entity } from '../engine';
+import { Color3Type } from './custom/Color3';
+import { Color4Type } from './custom/Color4';
+import { QuaternionType } from './custom/Quaternion';
+import { Vector3Type } from './custom/Vector3';
+import { ISchema, JsonSchemaExtended, JsonArray, JsonMap, JsonPrimitive } from './ISchema';
+export { QuaternionType, Vector3Type, ISchema, Color3Type, Color4Type, JsonSchemaExtended, JsonArray, JsonMap, JsonPrimitive };
+/**
+ * @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>;
+    /** @public */
+    const EnumNumber: <T>(enumObject: Record<any, any>, defaultValue: T) => ISchema<T>;
+    /** @public */
+    const EnumString: <T>(enumObject: Record<any, any>, defaultValue: T) => 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>;
+    /** @public */
+    const OneOf: <T extends import("./Map").Spec>(specs: T) => ISchema<{ [K in keyof T]: {
+        readonly $case: K;
+        readonly value: ReturnType<T[K]["deserialize"]>;
+    }; }[keyof T]>;
+    /**
+     * @public Create an ISchema object from the json-schema
+     * @param jsonSchema
+     * @returns a ISchema or fail for unsupported json-schema
+     */
+    const fromJson: (json: JsonSchemaExtended) => ISchema<unknown>;
+    /**
+     * @public
+     *
+     * Traverses and mutates values in a JSON schema-based structure, applying the given mutation function to each value.
+     * The function is designed to work with nested maps and arrays, recursively processing each element.
+     *
+     * @param jsonSchema - The JSON schema object that describes the structure of the value.
+     *                   It must have a serializationType of 'map', 'array', or other custom types like 'entity'.
+     * @param value - The value to be mutated, which should conform to the provided JSON schema.
+     * @param mutateFn - A function that takes a value and its corresponding valueType (JsonSchemaExtended) as arguments
+     *                   and returns a tuple [boolean, any]. The boolean indicates whether the mutation should be applied,
+     *                   and the second element is the mutated value.
+     */
+    const mutateNestedValues: (jsonSchema: JsonSchemaExtended, value: unknown, mutateFn: (value: unknown, valueType: JsonSchemaExtended) => {
+        changed: boolean;
+        value?: any;
+    }) => void;
+}

package/dist-cjs/schemas/index.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schemas = void 0;
+const Array_1 = require("./Array");
+const Boolean_1 = require("./basic/Boolean");
+const Enum_1 = require("./basic/Enum");
+const Float_1 = require("./basic/Float");
+const Integer_1 = require("./basic/Integer");
+const String_1 = require("./basic/String");
+const Color3_1 = require("./custom/Color3");
+const Color4_1 = require("./custom/Color4");
+const Entity_1 = require("./custom/Entity");
+const Quaternion_1 = require("./custom/Quaternion");
+const Vector3_1 = require("./custom/Vector3");
+const Map_1 = require("./Map");
+const Optional_1 = require("./Optional");
+const OneOf_1 = require("./OneOf");
+const buildSchema_1 = require("./buildSchema");
+/**
+ * @public
+ */
+var Schemas;
+(function (Schemas) {
+    /** @public */
+    Schemas.Boolean = Boolean_1.Bool;
+    /** @public */
+    Schemas.String = String_1.EcsString;
+    /** @public */
+    Schemas.Float = Float_1.Float32;
+    /** @public */
+    Schemas.Double = Float_1.Float64;
+    /** @public */
+    Schemas.Byte = Integer_1.Int8;
+    /** @public */
+    Schemas.Short = Integer_1.Int16;
+    /** @public */
+    Schemas.Int = Integer_1.Int32;
+    /** @public */
+    Schemas.Int64 = Integer_1.Int64;
+    /** @public */
+    Schemas.Number = Float_1.Float32;
+    /** @public */
+    Schemas.Vector3 = Vector3_1.Vector3Schema;
+    /** @public */
+    Schemas.Quaternion = Quaternion_1.QuaternionSchema;
+    /** @public */
+    Schemas.Color3 = Color3_1.Color3Schema;
+    /** @public */
+    Schemas.Color4 = Color4_1.Color4Schema;
+    /** @public */
+    Schemas.Entity = Entity_1.EntitySchema;
+    /** @public */
+    Schemas.EnumNumber = Enum_1.IntEnum;
+    /** @public */
+    Schemas.EnumString = Enum_1.StringEnum;
+    /** @public */
+    Schemas.Array = Array_1.IArray;
+    /** @public */
+    Schemas.Map = Map_1.IMap;
+    /** @public */
+    Schemas.Optional = Optional_1.IOptional;
+    /** @public */
+    Schemas.OneOf = OneOf_1.IOneOf;
+    /**
+     * @public Create an ISchema object from the json-schema
+     * @param jsonSchema
+     * @returns a ISchema or fail for unsupported json-schema
+     */
+    Schemas.fromJson = buildSchema_1.jsonSchemaToSchema;
+    /**
+     * @public
+     *
+     * Traverses and mutates values in a JSON schema-based structure, applying the given mutation function to each value.
+     * The function is designed to work with nested maps and arrays, recursively processing each element.
+     *
+     * @param jsonSchema - The JSON schema object that describes the structure of the value.
+     *                   It must have a serializationType of 'map', 'array', or other custom types like 'entity'.
+     * @param value - The value to be mutated, which should conform to the provided JSON schema.
+     * @param mutateFn - A function that takes a value and its corresponding valueType (JsonSchemaExtended) as arguments
+     *                   and returns a tuple [boolean, any]. The boolean indicates whether the mutation should be applied,
+     *                   and the second element is the mutated value.
+     */
+    Schemas.mutateNestedValues = buildSchema_1.mutateValues;
+})(Schemas = exports.Schemas || (exports.Schemas = {}));

package/dist-cjs/schemas/typing.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 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
+ * @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-cjs/schemas/typing.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,180 @@
+/**
+ * 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.
+ *
+ * It always passes littleEndian param as true
+ */
+export declare class ReadWriteByteBuffer implements ByteBuffer {
+    #private;
+    _buffer: Uint8Array;
+    view: DataView;
+    woffset: number;
+    roffset: number;
+    /**
+     * @param buffer - The initial buffer, provide a buffer if you need to set "initial capacity"
+     * @param readingOffset - Set the cursor where begins to read. Default 0
+     * @param writingOffset - Set the cursor to not start writing from the begin of it. Defaults to the buffer size
+     */
+    constructor(buffer?: Uint8Array | undefined, readingOffset?: number | undefined, writingOffset?: number | undefined);
+    buffer(): Uint8Array;
+    bufferLength(): number;
+    resetBuffer(): void;
+    currentReadOffset(): number;
+    currentWriteOffset(): number;
+    incrementReadOffset(amount: number): number;
+    remainingBytes(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readInt64(): bigint;
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readUint64(): bigint;
+    readBuffer(): Uint8Array;
+    readUtf8String(): string;
+    incrementWriteOffset(amount: number): number;
+    toBinary(): Uint8Array;
+    toCopiedBinary(): Uint8Array;
+    writeBuffer(value: Uint8Array, writeLength?: boolean): void;
+    writeUtf8String(value: string, writeLength?: boolean): void;
+    writeFloat32(value: number): void;
+    writeFloat64(value: number): void;
+    writeInt8(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeInt64(value: bigint): void;
+    writeUint8(value: number): void;
+    writeUint16(value: number): void;
+    writeUint32(value: number): void;
+    writeUint64(value: bigint): void;
+    getFloat32(offset: number): number;
+    getFloat64(offset: number): number;
+    getInt8(offset: number): number;
+    getInt16(offset: number): number;
+    getInt32(offset: number): number;
+    getInt64(offset: number): bigint;
+    getUint8(offset: number): number;
+    getUint16(offset: number): number;
+    getUint32(offset: number): number;
+    getUint64(offset: number): bigint;
+    setFloat32(offset: number, value: number): void;
+    setFloat64(offset: number, value: number): void;
+    setInt8(offset: number, value: number): void;
+    setInt16(offset: number, value: number): void;
+    setInt32(offset: number, value: number): void;
+    setInt64(offset: number, value: bigint): void;
+    setUint8(offset: number, value: number): void;
+    setUint16(offset: number, value: number): void;
+    setUint32(offset: number, value: number): void;
+    setUint64(offset: number, value: bigint): void;
+}
+/**
+ * @public
+ */
+export interface ByteBuffer {
+    /**
+     * @returns The entire current Uint8Array.
+     *
+     * WARNING: if the buffer grows, the view had changed itself,
+     *  and the reference will be a invalid one.
+     */
+    buffer(): Uint8Array;
+    /**
+     * @returns The capacity of the current buffer
+     */
+    bufferLength(): number;
+    /**
+     * Resets byteBuffer to avoid creating a new one
+     */
+    resetBuffer(): void;
+    /**
+     * @returns The current read offset
+     */
+    currentReadOffset(): number;
+    /**
+     * @returns The current write offset
+     */
+    currentWriteOffset(): number;
+    /**
+     * Reading purpose
+     * Returns the previuos offsset size before incrementing
+     */
+    incrementReadOffset(amount: number): number;
+    /**
+     * @returns How many bytes are available to read.
+     */
+    remainingBytes(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+    readInt8(): number;
+    readInt16(): number;
+    readInt32(): number;
+    readInt64(): bigint;
+    readUint8(): number;
+    readUint16(): number;
+    readUint32(): number;
+    readUint64(): bigint;
+    readBuffer(): Uint8Array;
+    readUtf8String(): string;
+    /**
+     * Writing purpose
+     */
+    /**
+     * Increment offset
+     * @param amount - how many bytes
+     * @returns The offset when this reserving starts.
+     */
+    incrementWriteOffset(amount: number): number;
+    /**
+     * Take care using this function, if you modify the data after, the
+     * returned subarray will change too. If you'll modify the content of the
+     * bytebuffer, maybe you want to use toCopiedBinary()
+     *
+     * @returns The subarray from 0 to offset as reference.
+     */
+    toBinary(): Uint8Array;
+    /**
+     * Safe copied buffer of the current data of ByteBuffer
+     *
+     * @returns The subarray from 0 to offset.
+     */
+    toCopiedBinary(): Uint8Array;
+    writeUtf8String(value: string, writeLength?: boolean): void;
+    writeBuffer(value: Uint8Array, writeLength?: boolean): void;
+    writeFloat32(value: number): void;
+    writeFloat64(value: number): void;
+    writeInt8(value: number): void;
+    writeInt16(value: number): void;
+    writeInt32(value: number): void;
+    writeInt64(value: bigint): void;
+    writeUint8(value: number): void;
+    writeUint16(value: number): void;
+    writeUint32(value: number): void;
+    writeUint64(value: bigint): void;
+    getFloat32(offset: number): number;
+    getFloat64(offset: number): number;
+    getInt8(offset: number): number;
+    getInt16(offset: number): number;
+    getInt32(offset: number): number;
+    getInt64(offset: number): bigint;
+    getUint8(offset: number): number;
+    getUint16(offset: number): number;
+    getUint32(offset: number): number;
+    getUint64(offset: number): bigint;
+    setFloat32(offset: number, value: number): void;
+    setFloat64(offset: number, value: number): void;
+    setInt8(offset: number, value: number): void;
+    setInt16(offset: number, value: number): void;
+    setInt32(offset: number, value: number): void;
+    setInt64(offset: number, value: bigint): void;
+    setUint8(offset: number, value: number): void;
+    setUint16(offset: number, value: number): void;
+    setUint32(offset: number, value: number): void;
+    setUint64(offset: number, value: bigint): void;
+}