@dcl/ecs 7.1.4 → 7.1.5

package/dist/schemas/ISchema.d.ts

@@ -21,7 +21,7 @@ export type JsonArray = Array<JsonPrimitive | JsonMap | JsonArray>;
  */
 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';
+    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

package/dist/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/schemas/OneOf.js

@@ -0,0 +1,31 @@
+export 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'
+        }
+    };
+};

package/dist/schemas/{buildSchema.d.ts → buildSchema/index.d.ts}

@@ -1,4 +1,4 @@
-import { ISchema, JsonSchemaExtended } from './ISchema';
+import { ISchema, JsonSchemaExtended } from '../ISchema';
 /**
  * Create an ISchema object from the json-schema
  * @param jsonSchema

package/dist/schemas/{buildSchema.js → buildSchema/index.js}

@@ -1,16 +1,18 @@
-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';
+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 { IOneOf } from '../OneOf';
+import { IOptional } from '../Optional';
+import { getTypeAndValue, isCompoundType } from './utils';
 const primitiveSchemas = {
     [Bool.jsonSchema.serializationType]: Bool,
     [EcsString.jsonSchema.serializationType]: EcsString,
@@ -59,35 +61,45 @@ export function jsonSchemaToSchema(jsonSchema) {
         const enumJsonSchema = jsonSchema;
         return 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 IOneOf(spec);
+    }
     throw new Error(`${jsonSchema.serializationType} is not supported as reverse schema generation.`);
 }
 export function mutateValues(jsonSchema, value, mutateFn) {
     if (jsonSchema.serializationType === 'map') {
-        const mapJsonSchema = jsonSchema;
-        const mapValue = value;
-        for (const key in mapJsonSchema.properties) {
-            const valueType = mapJsonSchema.properties[key];
-            if (valueType.serializationType === 'array' || valueType.serializationType === 'map') {
-                mutateValues(mapJsonSchema.properties[key], mapValue[key], mutateFn);
+        const { properties } = jsonSchema;
+        const typedValue = value;
+        for (const key in properties) {
+            const { type, value: mapValue } = getTypeAndValue(properties, typedValue, key);
+            if (type.serializationType === 'unknown')
+                continue;
+            if (isCompoundType(type)) {
+                mutateValues(type, mapValue, mutateFn);
             }
             else {
-                const newValue = mutateFn(mapValue[key], valueType);
+                const newValue = mutateFn(mapValue, type);
                 if (newValue.changed) {
-                    mapValue[key] = newValue.value;
+                    typedValue[key] = newValue.value;
                 }
             }
         }
     }
     else if (jsonSchema.serializationType === 'array') {
-        const withItemsJsonSchema = jsonSchema;
+        const { items } = jsonSchema;
         const arrayValue = value;
-        const nestedMutateValues = withItemsJsonSchema.items.serializationType === 'array' || withItemsJsonSchema.items.serializationType === 'map';
         for (let i = 0, n = arrayValue.length; i < n; i++) {
-            if (nestedMutateValues) {
-                mutateValues(withItemsJsonSchema.items, arrayValue[i], mutateFn);
+            const { type, value } = getTypeAndValue({ items: items }, { items: arrayValue[i] }, 'items');
+            if (isCompoundType(type)) {
+                mutateValues(type, value, mutateFn);
             }
             else {
-                const newValue = mutateFn(arrayValue[i], withItemsJsonSchema.items);
+                const newValue = mutateFn(value, type);
                 if (newValue.changed) {
                     arrayValue[i] = newValue.value;
                 }

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

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

package/dist/schemas/buildSchema/types.js

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

package/dist/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;

package/dist/schemas/buildSchema/utils.js

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

package/dist/schemas/index.d.ts

@@ -49,6 +49,11 @@ export declare namespace Schemas {
     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

package/dist/schemas/index.js

@@ -11,6 +11,7 @@ import { QuaternionSchema } from './custom/Quaternion';
 import { Vector3Schema } from './custom/Vector3';
 import { IMap } from './Map';
 import { IOptional } from './Optional';
+import { IOneOf } from './OneOf';
 import { jsonSchemaToSchema, mutateValues } from './buildSchema';
 /**
  * @public
@@ -55,6 +56,8 @@ export var Schemas;
     Schemas.Map = IMap;
     /** @public */
     Schemas.Optional = IOptional;
+    /** @public */
+    Schemas.OneOf = IOneOf;
     /**
      * @public Create an ISchema object from the json-schema
      * @param jsonSchema

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@dcl/ecs",
   "description": "Decentraland ECS",
-  "version": "7.1.4",
+  "version": "7.1.5",
   "author": "DCL",
   "bugs": "https://github.com/decentraland/ecs/issues",
   "dependencies": {
-    "@dcl/js-runtime": "7.1.4"
+    "@dcl/js-runtime": "7.1.5"
   },
   "devDependencies": {
     "ts-proto": "^1.122.0"
@@ -34,5 +34,5 @@
   },
   "types": "./dist/index.d.ts",
   "typings": "./dist/index.d.ts",
-  "commit": "3f2952c5e02d012a18b91605485925bc3dd6f756"
+  "commit": "f6a337a9f93f7738174df9448d5a735ebc9468a1"
 }