@dcl/ecs 7.0.0-3532389879.commit-c89c80c → 7.0.0-3568547351.commit-5420eac

package/dist/runtime/initialization/index.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @alpha * This file initialization is an alpha one. This is based on the old-ecs
+ * init and it'll be changing.
+ */
+import { IEngine } from '../../engine';
+import { Task } from '../../systems/async-task';
+export declare const engine: IEngine;
+export declare const inputSystem: import("../../engine").IInputSystem;
+export declare const pointerEventsSystem: {
+    removeOnClick(entity: unknown): void;
+    removeOnPointerDown(entity: unknown): void;
+    removeOnPointerUp(entity: unknown): void;
+    onClick(entity: unknown, cb: import("../../systems/events").EventSystemCallback, opts?: import("../../systems/events").EventSystemOptions | undefined): void;
+    onPointerDown(entity: unknown, cb: import("../../systems/events").EventSystemCallback, opts?: import("../../systems/events").EventSystemOptions | undefined): void;
+    onPointerUp(entity: unknown, cb: import("../../systems/events").EventSystemCallback, opts?: import("../../systems/events").EventSystemOptions | undefined): void;
+};
+/**
+ * @public
+ */
+export declare const executeTask: (task: Task<unknown>) => void;
+export type { Task };

package/dist/runtime/initialization/index.js

@@ -0,0 +1,20 @@
+/**
+ * @alpha * This file initialization is an alpha one. This is based on the old-ecs
+ * init and it'll be changing.
+ */
+import { Engine } from '../../engine';
+import { createTaskSystem } from '../../systems/async-task';
+import { createPointerEventSystem } from '../../systems/events';
+import { createInputSystem } from './../../engine/input';
+/*#__PURE__*/
+export const engine = Engine();
+// INPUT Manager
+/*#__PURE__*/
+export const inputSystem = createInputSystem(engine);
+/*#__PURE__*/
+export const pointerEventsSystem = createPointerEventSystem(engine, inputSystem);
+/**
+ * @public
+ */
+/*#__PURE__*/
+export const executeTask = createTaskSystem(engine).executeTask;

package/dist/runtime/invariant.d.ts

@@ -0,0 +1 @@
+export declare function checkNotThenable<T>(t: T, error: string): T;

package/dist/runtime/invariant.js

@@ -0,0 +1,8 @@
+export function checkNotThenable(t, error) {
+    if (globalThis.DEBUG) {
+        if (t && typeof t === 'object' && typeof t.then === 'function') {
+            throw new Error(error);
+        }
+    }
+    return t;
+}

package/dist/runtime/types.d.ts

@@ -0,0 +1,22 @@
+export type { SystemFn } from '../engine/systems';
+export type { Result, Spec } from '../schemas/Map';
+export type { TransportMessage, ReceiveMessage, Transport } from '../systems/crdt/types';
+export type { WireMessage } from '../serialization/wireMessage';
+export { TransformType, TransformComponent } from '../components/legacy/Transform';
+export * from '../engine/component';
+export * from '../schemas/typing';
+export { BillboardMode } from '../components/generated/pb/decentraland/sdk/components/billboard.gen';
+export { AvatarModifierType } from '../components/generated/pb/decentraland/sdk/components/avatar_modifier_area.gen';
+export { CameraType } from '../components/generated/pb/decentraland/sdk/components/common/camera_type.gen';
+export { Font, TextAlignMode } from '../components/generated/pb/decentraland/sdk/components/common/texts.gen';
+export { RaycastQueryType } from '../components/generated/pb/decentraland/sdk/components/raycast.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/ui_transform.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/avatar_attach.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/material.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/pointer_hover_feedback.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
+export * from '../components/generated/pb/decentraland/common/texture.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/raycast_result.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/animator.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/mesh_collider.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/mesh_renderer.gen';

package/dist/runtime/types.js

@@ -0,0 +1,19 @@
+export * from '../engine/component';
+export * from '../schemas/typing';
+// ColliderLayer is not used in the .pb definition because the field value is a number
+//   and it can have multiple values of this enum. It needs to be exposed here.
+export { BillboardMode } from '../components/generated/pb/decentraland/sdk/components/billboard.gen';
+export { AvatarModifierType } from '../components/generated/pb/decentraland/sdk/components/avatar_modifier_area.gen';
+export { CameraType } from '../components/generated/pb/decentraland/sdk/components/common/camera_type.gen';
+export { Font, TextAlignMode } from '../components/generated/pb/decentraland/sdk/components/common/texts.gen';
+export { RaycastQueryType } from '../components/generated/pb/decentraland/sdk/components/raycast.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/ui_transform.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/avatar_attach.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/material.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/pointer_hover_feedback.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/pointer_events_result.gen';
+export * from '../components/generated/pb/decentraland/common/texture.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/raycast_result.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/animator.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/mesh_collider.gen';
+export * from '../components/generated/pb/decentraland/sdk/components/mesh_renderer.gen';

package/dist/schemas/Array.d.ts

@@ -0,0 +1,5 @@
+import { ISchema } from './ISchema';
+/**
+ * @public
+ */
+export declare function IArray<T>(type: ISchema<T>): ISchema<Array<T>>;

package/dist/schemas/Array.js

@@ -0,0 +1,24 @@
+/**
+ * @public
+ */
+export function 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 [];
+        }
+    };
+}

package/dist/schemas/ISchema.d.ts

@@ -0,0 +1,9 @@
+import { ByteBuffer } from '../serialization/ByteBuffer';
+/**
+ * @public
+ */
+export declare type ISchema<T = any> = {
+    serialize(value: T, builder: ByteBuffer): void;
+    deserialize(reader: ByteBuffer): T;
+    create(): T;
+};

package/dist/schemas/ISchema.js

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

package/dist/schemas/Map.d.ts

@@ -0,0 +1,19 @@
+import { ISchema } from './ISchema';
+import { ToOptional } from './typing';
+/**
+ * @public
+ */
+export interface Spec {
+    [key: string]: ISchema;
+}
+/**
+ * @public
+ */
+export declare type Result<T extends Spec> = ToOptional<{
+    [K in keyof T]: T[K] extends ISchema ? ReturnType<T[K]['deserialize']> : T[K] extends Spec ? Result<T[K]> : never;
+}>;
+export declare type MapSchemaType<T extends Spec> = ISchema<Result<T>>;
+/**
+ * @public
+ */
+export declare function IMap<T extends Spec>(spec: T): ISchema<Result<T>>;

package/dist/schemas/Map.js

@@ -0,0 +1,31 @@
+/**
+ * @public
+ */
+export function IMap(spec) {
+    return {
+        serialize(value, builder) {
+            for (const key in spec) {
+                // TODO: as any
+                spec[key].serialize(value[key], builder);
+            }
+        },
+        deserialize(reader) {
+            const newValue = {};
+            for (const key in spec) {
+                // TODO: as any
+                ;
+                newValue[key] = spec[key].deserialize(reader);
+            }
+            return newValue;
+        },
+        create() {
+            const newValue = {};
+            for (const key in spec) {
+                // TODO: as any
+                ;
+                newValue[key] = spec[key].create();
+            }
+            return newValue;
+        }
+    };
+}

package/dist/schemas/Optional.d.ts

@@ -0,0 +1,5 @@
+import { ISchema } from './ISchema';
+/**
+ * @public
+ */
+export declare function IOptional<T>(spec: ISchema<T>): ISchema<T | undefined>;

package/dist/schemas/Optional.js

@@ -0,0 +1,25 @@
+/**
+ * @public
+ */
+export function 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;
+        }
+    };
+}

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

@@ -0,0 +1,5 @@
+import { ISchema } from '../ISchema';
+/**
+ * @public
+ */
+export declare const Bool: ISchema<boolean>;

package/dist/schemas/basic/Boolean.js

@@ -0,0 +1,14 @@
+/**
+ * @public
+ */
+export const Bool = {
+    serialize(value, builder) {
+        builder.writeInt8(value ? 1 : 0);
+    },
+    deserialize(reader) {
+        return reader.readInt8() === 1;
+    },
+    create() {
+        return false;
+    }
+};

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

@@ -0,0 +1,5 @@
+import { ISchema } from '../ISchema';
+/**
+ * @public
+ */
+export declare function IEnum<T>(type: ISchema<any>): ISchema<T>;

package/dist/schemas/basic/Enum.js

@@ -0,0 +1,16 @@
+/**
+ * @public
+ */
+export function IEnum(type) {
+    return {
+        serialize(value, builder) {
+            type.serialize(value, builder);
+        },
+        deserialize(reader) {
+            return type.deserialize(reader);
+        },
+        create() {
+            return type.create();
+        }
+    };
+}

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

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

package/dist/schemas/basic/Float.js

@@ -0,0 +1,28 @@
+/**
+ * @public
+ */
+export const Float32 = {
+    serialize(value, builder) {
+        builder.writeFloat32(value);
+    },
+    deserialize(reader) {
+        return reader.readFloat32();
+    },
+    create() {
+        return 0.0;
+    }
+};
+/**
+ * @public
+ */
+export const Float64 = {
+    serialize(value, builder) {
+        builder.writeFloat64(value);
+    },
+    deserialize(reader) {
+        return reader.readFloat64();
+    },
+    create() {
+        return 0.0;
+    }
+};

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

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

package/dist/schemas/basic/Integer.js

@@ -0,0 +1,56 @@
+/**
+ * @public
+ */
+export const Int64 = {
+    serialize(value, builder) {
+        builder.writeInt64(BigInt(value));
+    },
+    deserialize(reader) {
+        return Number(reader.readInt64());
+    },
+    create() {
+        return 0;
+    }
+};
+/**
+ * @public
+ */
+export const Int32 = {
+    serialize(value, builder) {
+        builder.writeInt32(value);
+    },
+    deserialize(reader) {
+        return reader.readInt32();
+    },
+    create() {
+        return 0;
+    }
+};
+/**
+ * @public
+ */
+export const Int16 = {
+    serialize(value, builder) {
+        builder.writeInt16(value);
+    },
+    deserialize(reader) {
+        return reader.readInt16();
+    },
+    create() {
+        return 0;
+    }
+};
+/**
+ * @public
+ */
+export const Int8 = {
+    serialize(value, builder) {
+        builder.writeInt8(value);
+    },
+    deserialize(reader) {
+        return reader.readInt8();
+    },
+    create() {
+        return 0;
+    }
+};

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

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

package/dist/schemas/basic/String.js

@@ -0,0 +1,18 @@
+/**
+ * @public
+ */
+export const FlatString = {
+    serialize(value, builder) {
+        builder.writeBuffer(new TextEncoder().encode(value));
+    },
+    deserialize(reader) {
+        return new TextDecoder().decode(reader.readBuffer());
+    },
+    create() {
+        return '';
+    }
+};
+/**
+ * @public
+ */
+export const EcsString = FlatString;

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

@@ -0,0 +1,13 @@
+import { ISchema } from '../ISchema';
+/**
+ * @public
+ */
+export declare type Color3Type = {
+    r: number;
+    g: number;
+    b: number;
+};
+/**
+ * @public
+ */
+export declare const Color3Schema: ISchema<Color3Type>;

package/dist/schemas/custom/Color3.js

@@ -0,0 +1,20 @@
+/**
+ * @public
+ */
+export const 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 };
+    }
+};

package/dist/schemas/custom/Color4.d.ts

@@ -0,0 +1,14 @@
+import { ISchema } from '../ISchema';
+/**
+ * @public
+ */
+export declare type Color4Type = {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+};
+/**
+ * @public
+ */
+export declare const Color4Schema: ISchema<Color4Type>;

package/dist/schemas/custom/Color4.js

@@ -0,0 +1,22 @@
+/**
+ * @public
+ */
+export const 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 };
+    }
+};

package/dist/schemas/custom/Entity.d.ts

@@ -0,0 +1,6 @@
+import { Entity } from '../../engine/entity';
+import { ISchema } from '../ISchema';
+/**
+ * @public
+ */
+export declare const EntitySchema: ISchema<Entity>;

package/dist/schemas/custom/Entity.js

@@ -0,0 +1,14 @@
+/**
+ * @public
+ */
+export const EntitySchema = {
+    serialize(value, builder) {
+        builder.writeInt32(value);
+    },
+    deserialize(reader) {
+        return reader.readInt32();
+    },
+    create() {
+        return 0;
+    }
+};

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

@@ -0,0 +1,14 @@
+import { ISchema } from '../ISchema';
+/**
+ * @public
+ */
+export declare type QuaternionType = {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+};
+/**
+ * @public
+ */
+export declare const QuaternionSchema: ISchema<QuaternionType>;

package/dist/schemas/custom/Quaternion.js

@@ -0,0 +1,22 @@
+/**
+ * @public
+ */
+export const 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 };
+    }
+};

package/dist/schemas/custom/Vector3.d.ts

@@ -0,0 +1,13 @@
+import { ISchema } from '../ISchema';
+/**
+ * @public
+ */
+export declare type Vector3Type = {
+    x: number;
+    y: number;
+    z: number;
+};
+/**
+ * @public
+ */
+export declare const Vector3Schema: ISchema<Vector3Type>;

package/dist/schemas/custom/Vector3.js

@@ -0,0 +1,20 @@
+/**
+ * @public
+ */
+export const 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 };
+    }
+};

package/dist/schemas/index.d.ts

@@ -0,0 +1,42 @@
+import { Entity } from '../engine';
+import { IArray } from './Array';
+import { IEnum } from './basic/Enum';
+import { Color3Type } from './custom/Color3';
+import { Color4Type } from './custom/Color4';
+import { QuaternionType } from './custom/Quaternion';
+import { Vector3Type } from './custom/Vector3';
+import { ISchema } from './ISchema';
+import { IMap } from './Map';
+import { IOptional } from './Optional';
+export type { IOptional } from './Optional';
+export type { IMap } from './Map';
+export type { IArray } from './Array';
+export type { IEnum } from './basic/Enum';
+export type { Vector3Type } from './custom/Vector3';
+export type { QuaternionType } from './custom/Quaternion';
+export type { Color3Type } from './custom/Color3';
+export type { Color4Type } from './custom/Color4';
+/**
+ * @public
+ */
+export declare namespace Schemas {
+    type SchemaType = ISchema;
+    const Boolean: ISchema<boolean>;
+    const String: ISchema<string>;
+    const Float: ISchema<number>;
+    const Double: ISchema<number>;
+    const Byte: ISchema<number>;
+    const Short: ISchema<number>;
+    const Int: ISchema<number>;
+    const Int64: ISchema<number>;
+    const Number: ISchema<number>;
+    const Vector3: ISchema<Vector3Type>;
+    const Quaternion: ISchema<QuaternionType>;
+    const Color3: ISchema<Color3Type>;
+    const Color4: ISchema<Color4Type>;
+    const Entity: ISchema<Entity>;
+    const Enum: typeof IEnum;
+    const Array: typeof IArray;
+    const Map: typeof IMap;
+    const Optional: typeof IOptional;
+}