@colyseus/schema 2.0.4 → 2.0.6

package/src/types/typeRegistry.ts

@@ -0,0 +1,19 @@
+export interface TypeDefinition {
+    constructor: any,
+
+    // //
+    // // TODO: deprecate proxy on next version
+    // // the proxy is used for compatibility with versions <1.0.0 of @colyseus/schema
+    // //
+    // getProxy?: any,
+}
+
+const registeredTypes: {[identifier: string] : TypeDefinition} = {};
+
+export function registerType(identifier: string, definition: TypeDefinition) {
+    registeredTypes[identifier] = definition;
+}
+
+export function getType(identifier: string): TypeDefinition {
+    return registeredTypes[identifier];
+}

package/src/types/utils.ts

@@ -0,0 +1,62 @@
+import { CollectionSchema, DataChange } from "..";
+import { OPERATION } from "../spec";
+
+export function addCallback(
+    $callbacks: { [op: number]: Function[] },
+    op: OPERATION,
+    callback: (item: any, key: any) => void,
+    existing?: { forEach(callback: (item: any, key: any) => void): void; }
+) {
+    // initialize list of callbacks
+    if (!$callbacks[op]) {
+        $callbacks[op] = [];
+    }
+
+    $callbacks[op].push(callback);
+
+    //
+    // Trigger callback for existing elements
+    // - OPERATION.ADD
+    // - OPERATION.REPLACE
+    //
+    existing?.forEach((item, key) => callback(item, key));
+
+    return () => spliceOne($callbacks[op], $callbacks[op].indexOf(callback));
+}
+
+
+export function removeChildRefs(this: CollectionSchema, changes: DataChange[]) {
+    const needRemoveRef = (typeof (this.$changes.getType()) !== "string");
+
+    this.$items.forEach((item: any, key: any) => {
+        changes.push({
+            refId: this.$changes.refId,
+            op: OPERATION.DELETE,
+            field: key,
+            value: undefined,
+            previousValue: item
+        });
+
+        if (needRemoveRef) {
+            this.$changes.root.removeRef(item['$changes'].refId);
+        }
+    });
+}
+
+
+export function spliceOne(arr: any[], index: number): boolean {
+    // manually splice an array
+    if (index === -1 || index >= arr.length) {
+        return false;
+    }
+
+    const len = arr.length - 1;
+
+    for (let i = index; i < len; i++) {
+        arr[i] = arr[i + 1];
+    }
+
+    arr.length = len;
+
+    return true;
+}

package/src/utils.ts

@@ -0,0 +1,28 @@
+import { Schema } from "./";
+import { ChangeTree } from "./changes/ChangeTree";
+
+export function dumpChanges(schema: Schema) {
+    const changeTrees: ChangeTree[] = [schema['$changes']];
+    let numChangeTrees = 1;
+
+    const dump = {};
+    let currentStructure = dump;
+
+    for (let i = 0; i < numChangeTrees; i++) {
+        const changeTree = changeTrees[i];
+
+        changeTree.changes.forEach((change) => {
+            const ref = changeTree.ref;
+            const fieldIndex = change.index;
+
+            const field = ((ref as Schema)['_definition'])
+                ? ref['_definition'].fieldsByIndex[fieldIndex]
+                : ref['$indexes'].get(fieldIndex);
+
+            currentStructure[field] = changeTree.getValue(fieldIndex);
+        });
+
+    }
+
+    return dump;
+}