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

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

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

package/dist-cjs/schemas/Array.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IArray = void 0;
+/**
+ * @internal
+ */
+const IArray = (type) => {
+    return {
+        serialize(value, builder) {
+            builder.writeUint32(value.length);
+            for (const item of value) {
+                type.serialize(item, builder);
+            }
+        },
+        deserialize(reader) {
+            const newArray = [];
+            const length = reader.readUint32();
+            for (let index = 0; index < length; index++) {
+                newArray.push(type.deserialize(reader));
+            }
+            return newArray;
+        },
+        create() {
+            return [];
+        },
+        jsonSchema: {
+            type: 'array',
+            items: type.jsonSchema,
+            serializationType: 'array'
+        }
+    };
+};
+exports.IArray = IArray;

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

@@ -0,0 +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' | 'one-of' | 'unknown';
+} & JsonMap;
+/**
+ * @public
+ */
+export interface ISchema<T = any> {
+    serialize(value: DeepReadonly<T>, builder: ByteBuffer): void;
+    deserialize(reader: ByteBuffer): T;
+    create(): T;
+    extend?: (base: Partial<DeepReadonly<T>> | undefined) => T;
+    jsonSchema: JsonSchemaExtended;
+}

package/dist-cjs/schemas/ISchema.js

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

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

@@ -0,0 +1,20 @@
+import { ISchema } from './ISchema';
+import { ToOptional } from './typing';
+/**
+ * @public
+ */
+export interface Spec {
+    [key: string]: ISchema;
+}
+/**
+ * @public
+ */
+export type MapResult<T extends Spec> = ToOptional<{
+    [K in keyof T]: T[K] extends ISchema ? ReturnType<T[K]['deserialize']> : T[K] extends Spec ? MapResult<T[K]> : never;
+}>;
+/**
+ * @public
+ */
+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;
+}>;

package/dist-cjs/schemas/Map.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMap = void 0;
+/**
+ * @internal
+ */
+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) {
+                spec[key].serialize(value[key], builder);
+            }
+        },
+        deserialize(reader) {
+            const newValue = {};
+            for (const key in spec) {
+                ;
+                newValue[key] = spec[key].deserialize(reader);
+            }
+            return newValue;
+        },
+        create() {
+            const newValue = {};
+            for (const key in spec) {
+                ;
+                newValue[key] = spec[key].create();
+            }
+            return { ...newValue, ...defaultValue };
+        },
+        extend: (base) => {
+            const newValue = {};
+            for (const key in spec) {
+                ;
+                newValue[key] = spec[key].create();
+            }
+            return { ...newValue, ...defaultValue, ...base };
+        },
+        jsonSchema: {
+            type: 'object',
+            properties: specReflection,
+            serializationType: 'map'
+        }
+    };
+};
+exports.IMap = IMap;

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

@@ -0,0 +1,10 @@
+import { ISchema } from './ISchema';
+import { Spec } from './Map';
+type OneOfType<T extends Spec> = {
+    [K in keyof T]: {
+        readonly $case: K;
+        readonly value: ReturnType<T[K]['deserialize']>;
+    };
+}[keyof T];
+export declare const IOneOf: <T extends Spec>(specs: T) => ISchema<OneOfType<T>>;
+export {};

package/dist-cjs/schemas/OneOf.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOneOf = void 0;
+const IOneOf = (specs) => {
+    const specKeys = Object.keys(specs);
+    const keyToIndex = specKeys.reduce((dict, key, index) => {
+        dict[key] = index;
+        return dict;
+    }, {});
+    const specReflection = specKeys.reduce((specReflection, currentKey) => {
+        specReflection[currentKey] = specs[currentKey].jsonSchema;
+        return specReflection;
+    }, {});
+    return {
+        serialize({ $case, value }, builder) {
+            const _value = keyToIndex[$case.toString()] + 1;
+            builder.writeUint8(_value);
+            specs[$case].serialize(value, builder);
+        },
+        deserialize(reader) {
+            const $case = specKeys[reader.readInt8() - 1];
+            const value = specs[$case].deserialize(reader);
+            return { $case, value };
+        },
+        create() {
+            return {};
+        },
+        jsonSchema: {
+            type: 'object',
+            properties: specReflection,
+            serializationType: 'one-of'
+        }
+    };
+};
+exports.IOneOf = IOneOf;

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

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

package/dist-cjs/schemas/Optional.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IOptional = void 0;
+/**
+ * @internal
+ */
+const IOptional = (spec) => {
+    return {
+        serialize(value, builder) {
+            if (value) {
+                builder.writeInt8(1);
+                spec.serialize(value, builder);
+            }
+            else {
+                builder.writeInt8(0);
+            }
+        },
+        deserialize(reader) {
+            const exists = reader.readInt8();
+            if (exists) {
+                return spec.deserialize(reader);
+            }
+        },
+        create() {
+            return undefined;
+        },
+        jsonSchema: {
+            type: spec.jsonSchema.type,
+            serializationType: 'optional',
+            optionalJsonSchema: spec.jsonSchema
+        }
+    };
+};
+exports.IOptional = IOptional;

package/dist-cjs/schemas/basic/Boolean.d.ts

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

package/dist-cjs/schemas/basic/Boolean.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bool = void 0;
+/**
+ * @internal
+ */
+exports.Bool = {
+    serialize(value, builder) {
+        builder.writeInt8(value ? 1 : 0);
+    },
+    deserialize(reader) {
+        return reader.readInt8() === 1;
+    },
+    create() {
+        return false;
+    },
+    jsonSchema: {
+        type: 'boolean',
+        serializationType: 'boolean'
+    }
+};

package/dist-cjs/schemas/basic/Enum.d.ts

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

package/dist-cjs/schemas/basic/Enum.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringEnum = exports.StringEnumReflectionType = exports.IntEnum = exports.IntEnumReflectionType = void 0;
+const Integer_1 = require("./Integer");
+const String_1 = require("./String");
+/**
+ * Validates the enum to ensure all member values are numbers and within the range of Int32.
+ * @param enumValue The enum to be checked.
+ * @throws If any member value is not a number or is outside the range of Int32.
+ */
+function validateMemberValuesAreNumbersAndInRangeInt32(enumValue) {
+    const MIN_VALUE = -(2 ** 31), MAX_VALUE = 2 ** 31 - 1;
+    let valueCount = 0, totalCount = 0;
+    for (const key in enumValue) {
+        if (typeof enumValue[key] === 'number') {
+            if (enumValue[key] > MAX_VALUE || enumValue[key] < MIN_VALUE) {
+                throw new Error(`Enum member values must be numbers within the range of ${MIN_VALUE} to ${MAX_VALUE}.`);
+            }
+            valueCount++;
+        }
+        totalCount++;
+    }
+    if (totalCount !== valueCount * 2) {
+        throw new Error('All enum member values must be of numeric type.');
+    }
+}
+/**
+ * Validates the enum to ensure all member values are of string type.
+ * @param enumValue The enum to be checked.
+ * @throws If any member value is not of string type.
+ */
+function validateMemberValuesAreStrings(enumValue) {
+    for (const key in enumValue) {
+        if (typeof enumValue[key] !== 'string') {
+            throw new Error('All enum member values must be of string type.');
+        }
+    }
+}
+/**
+ * @internal
+ */
+exports.IntEnumReflectionType = 'enum-int';
+/**
+ * @internal
+ */
+const IntEnum = (enumObject, defaultValue) => {
+    validateMemberValuesAreNumbersAndInRangeInt32(enumObject);
+    return {
+        serialize(value, builder) {
+            Integer_1.Int32.serialize(value, builder);
+        },
+        deserialize(reader) {
+            return Integer_1.Int32.deserialize(reader);
+        },
+        create() {
+            return defaultValue;
+        },
+        jsonSchema: {
+            // JSON-schema
+            type: 'integer',
+            enum: Object.values(enumObject).filter((item) => Number.isInteger(item)),
+            default: defaultValue,
+            // @dcl/ecs Schema Spec
+            serializationType: exports.IntEnumReflectionType,
+            enumObject
+        }
+    };
+};
+exports.IntEnum = IntEnum;
+/**
+ * @internal
+ */
+exports.StringEnumReflectionType = 'enum-string';
+/**
+ * @internal
+ */
+const StringEnum = (enumObject, defaultValue) => {
+    validateMemberValuesAreStrings(enumObject);
+    // String enum has the exact mapping from key (our reference in code) to values
+    return {
+        serialize(value, builder) {
+            String_1.FlatString.serialize(value, builder);
+        },
+        deserialize(reader) {
+            return String_1.FlatString.deserialize(reader);
+        },
+        create() {
+            return defaultValue;
+        },
+        jsonSchema: {
+            // JSON-schema
+            type: 'string',
+            enum: Object.values(enumObject),
+            default: defaultValue,
+            // @dcl/ecs Schema Spec
+            serializationType: exports.StringEnumReflectionType,
+            enumObject
+        }
+    };
+};
+exports.StringEnum = StringEnum;

package/dist-cjs/schemas/basic/Float.d.ts

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

package/dist-cjs/schemas/basic/Float.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Float64 = exports.Float32 = void 0;
+/**
+ * @internal
+ */
+exports.Float32 = {
+    serialize(value, builder) {
+        builder.writeFloat32(value);
+    },
+    deserialize(reader) {
+        return reader.readFloat32();
+    },
+    create() {
+        return 0.0;
+    },
+    jsonSchema: {
+        type: 'number',
+        serializationType: 'float32'
+    }
+};
+/**
+ * @internal
+ */
+exports.Float64 = {
+    serialize(value, builder) {
+        builder.writeFloat64(value);
+    },
+    deserialize(reader) {
+        return reader.readFloat64();
+    },
+    create() {
+        return 0.0;
+    },
+    jsonSchema: {
+        type: 'number',
+        serializationType: 'float64'
+    }
+};

package/dist-cjs/schemas/basic/Integer.d.ts

@@ -0,0 +1,9 @@
+import { ISchema } from '../ISchema';
+/**
+ * @public
+ */
+export declare const Int16: ISchema<number>;
+/**
+ * @public
+ */
+export declare const Int8: ISchema<number>;

package/dist-cjs/schemas/basic/Integer.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int8 = exports.Int16 = exports.Int32 = exports.Int64 = void 0;
+/**
+ * @internal
+ */
+exports.Int64 = {
+    serialize(value, builder) {
+        builder.writeInt64(BigInt(value));
+    },
+    deserialize(reader) {
+        return Number(reader.readInt64());
+    },
+    create() {
+        return 0;
+    },
+    jsonSchema: {
+        type: 'integer',
+        serializationType: 'int64'
+    }
+};
+/**
+ * @internal
+ */
+exports.Int32 = {
+    serialize(value, builder) {
+        builder.writeInt32(value);
+    },
+    deserialize(reader) {
+        return reader.readInt32();
+    },
+    create() {
+        return 0;
+    },
+    jsonSchema: {
+        type: 'integer',
+        serializationType: 'int32'
+    }
+};
+/**
+ * @public
+ */
+exports.Int16 = {
+    serialize(value, builder) {
+        builder.writeInt16(value);
+    },
+    deserialize(reader) {
+        return reader.readInt16();
+    },
+    create() {
+        return 0;
+    },
+    jsonSchema: {
+        type: 'integer',
+        serializationType: 'int16'
+    }
+};
+/**
+ * @public
+ */
+exports.Int8 = {
+    serialize(value, builder) {
+        builder.writeInt8(value);
+    },
+    deserialize(reader) {
+        return reader.readInt8();
+    },
+    create() {
+        return 0;
+    },
+    jsonSchema: {
+        type: 'integer',
+        serializationType: 'int8'
+    }
+};

package/dist-cjs/schemas/basic/String.d.ts

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

package/dist-cjs/schemas/basic/String.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcsString = exports.FlatString = void 0;
+/**
+ * @internal
+ */
+exports.FlatString = {
+    serialize(value, builder) {
+        builder.writeUtf8String(value);
+    },
+    deserialize(reader) {
+        return reader.readUtf8String();
+    },
+    create() {
+        return '';
+    },
+    jsonSchema: {
+        type: 'string',
+        serializationType: 'utf8-string'
+    }
+};
+/**
+ * @internal
+ */
+exports.EcsString = exports.FlatString;

package/dist-cjs/schemas/buildSchema/index.d.ts

@@ -0,0 +1,11 @@
+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>;
+export declare function mutateValues(jsonSchema: JsonSchemaExtended, value: unknown, mutateFn: (value: unknown, valueType: JsonSchemaExtended) => {
+    changed: boolean;
+    value?: any;
+}): void;

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mutateValues = exports.jsonSchemaToSchema = 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 OneOf_1 = require("../OneOf");
+const Optional_1 = require("../Optional");
+const utils_1 = require("./utils");
+const primitiveSchemas = {
+    [Boolean_1.Bool.jsonSchema.serializationType]: Boolean_1.Bool,
+    [String_1.EcsString.jsonSchema.serializationType]: String_1.EcsString,
+    [Float_1.Float32.jsonSchema.serializationType]: Float_1.Float32,
+    [Float_1.Float64.jsonSchema.serializationType]: Float_1.Float64,
+    [Integer_1.Int8.jsonSchema.serializationType]: Integer_1.Int8,
+    [Integer_1.Int16.jsonSchema.serializationType]: Integer_1.Int16,
+    [Integer_1.Int32.jsonSchema.serializationType]: Integer_1.Int32,
+    [Integer_1.Int64.jsonSchema.serializationType]: Integer_1.Int64,
+    [Vector3_1.Vector3Schema.jsonSchema.serializationType]: Vector3_1.Vector3Schema,
+    [Quaternion_1.QuaternionSchema.jsonSchema.serializationType]: Quaternion_1.QuaternionSchema,
+    [Color3_1.Color3Schema.jsonSchema.serializationType]: Color3_1.Color3Schema,
+    [Color4_1.Color4Schema.jsonSchema.serializationType]: Color4_1.Color4Schema,
+    [Entity_1.EntitySchema.jsonSchema.serializationType]: Entity_1.EntitySchema
+};
+/**
+ * Create an ISchema object from the json-schema
+ * @param jsonSchema
+ * @returns a ISchema or fail for unsupported json-schema
+ */
+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 (0, Map_1.IMap)(spec);
+    }
+    if (jsonSchema.serializationType === 'optional') {
+        const withItemsJsonSchema = jsonSchema;
+        return (0, Optional_1.IOptional)(jsonSchemaToSchema(withItemsJsonSchema.optionalJsonSchema));
+    }
+    if (jsonSchema.serializationType === 'array') {
+        const withItemsJsonSchema = jsonSchema;
+        return (0, Array_1.IArray)(jsonSchemaToSchema(withItemsJsonSchema.items));
+    }
+    if (jsonSchema.serializationType === 'enum-int') {
+        const enumJsonSchema = jsonSchema;
+        return (0, Enum_1.IntEnum)(enumJsonSchema.enumObject, enumJsonSchema.default);
+    }
+    if (jsonSchema.serializationType === 'enum-string') {
+        const enumJsonSchema = jsonSchema;
+        return (0, Enum_1.StringEnum)(enumJsonSchema.enumObject, enumJsonSchema.default);
+    }
+    if (jsonSchema.serializationType === 'one-of') {
+        const oneOfJsonSchema = jsonSchema;
+        const spec = {};
+        for (const key in oneOfJsonSchema.properties) {
+            spec[key] = jsonSchemaToSchema(oneOfJsonSchema.properties[key]);
+        }
+        return (0, OneOf_1.IOneOf)(spec);
+    }
+    throw new Error(`${jsonSchema.serializationType} is not supported as reverse schema generation.`);
+}
+exports.jsonSchemaToSchema = jsonSchemaToSchema;
+function mutateValues(jsonSchema, value, mutateFn) {
+    if (jsonSchema.serializationType === 'map') {
+        const { properties } = jsonSchema;
+        const typedValue = value;
+        for (const key in properties) {
+            const { type, value: mapValue } = (0, utils_1.getTypeAndValue)(properties, typedValue, key);
+            if (type.serializationType === 'unknown')
+                continue;
+            if ((0, utils_1.isCompoundType)(type)) {
+                mutateValues(type, mapValue, mutateFn);
+            }
+            else {
+                const newValue = mutateFn(mapValue, type);
+                if (newValue.changed) {
+                    typedValue[key] = newValue.value;
+                }
+            }
+        }
+    }
+    else if (jsonSchema.serializationType === 'array') {
+        const { items } = jsonSchema;
+        const arrayValue = value;
+        for (let i = 0, n = arrayValue.length; i < n; i++) {
+            const { type, value } = (0, utils_1.getTypeAndValue)({ items: items }, { items: arrayValue[i] }, 'items');
+            if ((0, utils_1.isCompoundType)(type)) {
+                mutateValues(type, value, mutateFn);
+            }
+            else {
+                const newValue = mutateFn(value, type);
+                if (newValue.changed) {
+                    arrayValue[i] = newValue.value;
+                }
+            }
+        }
+    }
+}
+exports.mutateValues = mutateValues;

package/dist-cjs/schemas/buildSchema/types.d.ts

@@ -0,0 +1,5 @@
+import { JsonSchemaExtended } from '../ISchema';
+export type UnknownSchema = {
+    type: JsonSchemaExtended;
+    value: unknown;
+};

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

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

package/dist-cjs/schemas/buildSchema/utils.d.ts

@@ -0,0 +1,12 @@
+import { JsonSchemaExtended } from '../ISchema';
+import { UnknownSchema } from './types';
+export declare const isSchemaType: (value: JsonSchemaExtended, types: JsonSchemaExtended['serializationType'][]) => boolean;
+export declare const isOneOfJsonSchema: (type: JsonSchemaExtended) => type is {
+    type: "string" | "number" | "boolean" | "object" | "integer" | "array";
+    serializationType: "boolean" | "map" | "array" | "enum-int" | "enum-string" | "int8" | "int16" | "int32" | "int64" | "float32" | "float64" | "vector3" | "color3" | "quaternion" | "color4" | "optional" | "entity" | "utf8-string" | "protocol-buffer" | "transform" | "one-of" | "unknown";
+} & import("../ISchema").JsonMap & {
+    properties: Record<string, JsonSchemaExtended>;
+};
+export declare const getUnknownSchema: () => UnknownSchema;
+export declare const isCompoundType: (type: JsonSchemaExtended) => boolean;
+export declare const getTypeAndValue: (properties: Record<string, JsonSchemaExtended>, value: Record<string, unknown>, key: string) => UnknownSchema;