@colyseus/schema 1.0.33 → 1.0.36

package/src/events/EventEmitter.ts

@@ -0,0 +1,32 @@
+/**
+ * Extracted from https://www.npmjs.com/package/strong-events
+ */
+
+type ExtractFunctionParameters<T extends (...args: any[]) => any> = T extends (...args: infer P) => any ? P : never;
+
+export class EventEmitter_<CallbackSignature extends (...args: any[]) => any> {
+  handlers: Array<CallbackSignature> = [];
+
+  register(cb: CallbackSignature, once: boolean = false) {
+    this.handlers.push(cb);
+    return this;
+  }
+
+  invoke(...args: ExtractFunctionParameters<CallbackSignature>) {
+    this.handlers.forEach((handler) => handler(...args));
+  }
+
+  invokeAsync(...args: ExtractFunctionParameters<CallbackSignature>) {
+    return Promise.all(this.handlers.map((handler) => handler(...args)));
+  }
+
+  remove (cb: CallbackSignature) {
+    const index = this.handlers.indexOf(cb);
+    this.handlers[index] = this.handlers[this.handlers.length - 1];
+    this.handlers.pop();
+  }
+
+  clear() {
+    this.handlers = [];
+  }
+}

package/src/filters/index.ts

@@ -0,0 +1,23 @@
+import { ChangeTree } from "../changes/ChangeTree";
+import { ClientWithSessionId } from "../annotations";
+
+export class ClientState {
+    refIds = new WeakSet<ChangeTree>();
+    containerIndexes = new WeakMap<ChangeTree, Set<number>>();
+    // containerIndexes = new Map<ChangeTree, Set<number>>();
+
+    addRefId(changeTree: ChangeTree) {
+        if (!this.refIds.has(changeTree)) {
+            this.refIds.add(changeTree);
+            this.containerIndexes.set(changeTree, new Set());
+        }
+    }
+
+    static get(client: ClientWithSessionId) {
+        if (client.$filterState === undefined) {
+            client.$filterState = new ClientState();
+        }
+
+        return client.$filterState as ClientState;
+    }
+}

package/src/index.ts

@@ -0,0 +1,59 @@
+export { Schema, DataChange } from "./Schema";
+
+import { MapSchema, getMapProxy } from "./types/MapSchema"
+export { MapSchema };
+
+import { ArraySchema, getArrayProxy } from "./types/ArraySchema";
+export { ArraySchema };
+
+import { CollectionSchema } from "./types/CollectionSchema";
+export { CollectionSchema };
+
+import { SetSchema } from "./types/SetSchema";
+export { SetSchema };
+
+import { registerType } from "./types";
+export { registerType };
+
+registerType("map", { constructor: MapSchema, getProxy: getMapProxy });
+registerType("array", { constructor: ArraySchema, getProxy: getArrayProxy });
+registerType("set", { constructor: SetSchema });
+registerType("collection", { constructor: CollectionSchema, });
+
+// Utils
+export { dumpChanges } from "./utils";
+
+// Encoder / Decoder
+export { Iterator } from "./encoding/decode";
+import * as encode from "./encoding/encode";
+import * as decode from "./encoding/decode";
+export { encode, decode };
+
+// Reflection
+export {
+    Reflection,
+    ReflectionType,
+    ReflectionField,
+} from "./Reflection";
+
+export {
+    // Annotations
+    type,
+    deprecated,
+    filter,
+    filterChildren,
+    defineTypes,
+    hasFilter,
+
+    // Internals
+    SchemaDefinition,
+
+    // Types
+    Context,
+    PrimitiveType,
+    Definition,
+    DefinitionType,
+    FilterCallback,
+} from "./annotations";
+
+export { OPERATION } from "./spec";

package/src/spec.ts

@@ -0,0 +1,49 @@
+// export const SWITCH_TO_STRUCTURE = 193; (easily collides with DELETE_AND_ADD + fieldIndex = 2)
+export const SWITCH_TO_STRUCTURE = 255; // (decoding collides with DELETE_AND_ADD + fieldIndex = 63)
+export const TYPE_ID = 213;
+
+/**
+ * Encoding Schema field operations.
+ */
+export enum OPERATION {
+    // add new structure/primitive
+    ADD = 128,
+
+    // replace structure/primitive
+    REPLACE = 0,
+
+    // delete field
+    DELETE = 64,
+
+    // DELETE field, followed by an ADD
+    DELETE_AND_ADD = 192, // 11100000
+
+    // TOUCH is used to determine hierarchy of nested Schema structures during serialization.
+    // touches are NOT encoded.
+    TOUCH = 1, // 00000000
+
+    // MapSchema Operations
+    CLEAR = 10,
+}
+
+// export enum OPERATION {
+//     // add new structure/primitive
+//     // (128)
+//     ADD = 128, // 10000000,
+
+//     // replace structure/primitive
+//     REPLACE = 1,// 00000001
+
+//     // delete field
+//     DELETE = 192, // 11000000
+
+//     // DELETE field, followed by an ADD
+//     DELETE_AND_ADD = 224, // 11100000
+
+//     // TOUCH is used to determine hierarchy of nested Schema structures during serialization.
+//     // touches are NOT encoded.
+//     TOUCH = 0, // 00000000
+
+//     // MapSchema Operations
+//     CLEAR = 10,
+// }