@colyseus/schema 2.0.4 → 2.0.6

package/src/types/CollectionSchema.ts

@@ -0,0 +1,199 @@
+import { ChangeTree } from "../changes/ChangeTree";
+import { OPERATION } from "../spec";
+import { SchemaDecoderCallbacks } from "../Schema";
+import { addCallback, removeChildRefs } from "./utils";
+import { DataChange } from "..";
+
+type K = number; // TODO: allow to specify K generic on MapSchema.
+
+export class CollectionSchema<V=any> implements SchemaDecoderCallbacks {
+    protected $changes: ChangeTree = new ChangeTree(this);
+
+    protected $items: Map<number, V> = new Map<number, V>();
+    protected $indexes: Map<number, number> = new Map<number, number>();
+
+    protected $refId: number = 0;
+
+    //
+    // Decoding callbacks
+    //
+    public $callbacks: { [operation: number]: Array<(item: V, key: string) => void> };
+    public onAdd(callback: (item: V, key: string) => void, triggerAll: boolean = true) {
+        return addCallback(
+            (this.$callbacks || (this.$callbacks = [])),
+            OPERATION.ADD,
+            callback,
+            (triggerAll)
+                ? this.$items
+                : undefined
+        );
+    }
+    public onRemove(callback: (item: V, key: string) => void) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.DELETE, callback); }
+    public onChange(callback: (item: V, key: string) => void) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.REPLACE, callback); }
+
+    static is(type: any) {
+        return type['collection'] !== undefined;
+    }
+
+    constructor (initialValues?: Array<V>) {
+        if (initialValues) {
+            initialValues.forEach((v) => this.add(v));
+        }
+    }
+
+    add(value: V) {
+        // set "index" for reference.
+        const index = this.$refId++;
+
+        const isRef = (value['$changes']) !== undefined;
+        if (isRef) {
+            (value['$changes'] as ChangeTree).setParent(this, this.$changes.root, index);
+        }
+
+        this.$changes.indexes[index] = index;
+
+        this.$indexes.set(index, index);
+        this.$items.set(index, value);
+
+        this.$changes.change(index);
+
+        return index;
+    }
+
+    at(index: number): V | undefined {
+        const key = Array.from(this.$items.keys())[index];
+        return this.$items.get(key);
+    }
+
+    entries() {
+        return this.$items.entries();
+    }
+
+    delete(item: V) {
+        const entries = this.$items.entries();
+
+        let index: K;
+        let entry: IteratorResult<[number, V]>;
+        while (entry = entries.next()) {
+            if (entry.done) { break; }
+
+            if (item === entry.value[1]) {
+                index = entry.value[0];
+                break;
+            }
+        }
+
+        if (index === undefined) {
+            return false;
+        }
+
+        this.$changes.delete(index);
+        this.$indexes.delete(index);
+
+        return this.$items.delete(index);
+    }
+
+    clear(changes?: DataChange[]) {
+        // discard previous operations.
+        this.$changes.discard(true, true);
+        this.$changes.indexes = {};
+
+        // clear previous indexes
+        this.$indexes.clear();
+
+        //
+        // When decoding:
+        // - enqueue items for DELETE callback.
+        // - flag child items for garbage collection.
+        //
+        if (changes) {
+            removeChildRefs.call(this, changes);
+        }
+
+        // clear items
+        this.$items.clear();
+
+        this.$changes.operation({ index: 0, op: OPERATION.CLEAR });
+
+        // touch all structures until reach root
+        this.$changes.touchParents();
+    }
+
+    has (value: V): boolean {
+        return Array.from(this.$items.values()).some((v) => v === value);
+    }
+
+    forEach(callbackfn: (value: V, key: K, collection: CollectionSchema<V>) => void) {
+        this.$items.forEach((value, key, _) => callbackfn(value, key, this));
+    }
+
+    values() {
+        return this.$items.values();
+    }
+
+    get size () {
+        return this.$items.size;
+    }
+
+    protected setIndex(index: number, key: number) {
+        this.$indexes.set(index, key);
+    }
+
+    protected getIndex(index: number) {
+        return this.$indexes.get(index);
+    }
+
+    protected getByIndex(index: number) {
+        return this.$items.get(this.$indexes.get(index));
+    }
+
+    protected deleteByIndex(index: number) {
+        const key = this.$indexes.get(index);
+        this.$items.delete(key);
+        this.$indexes.delete(index);
+    }
+
+    toArray() {
+        return Array.from(this.$items.values());
+    }
+
+    toJSON() {
+        const values: V[] = [];
+
+        this.forEach((value, key) => {
+            values.push(
+                (typeof (value['toJSON']) === "function")
+                    ? value['toJSON']()
+                    : value
+            );
+        });
+
+        return values;
+    }
+
+    //
+    // Decoding utilities
+    //
+    clone(isDecoding?: boolean): CollectionSchema<V> {
+        let cloned: CollectionSchema;
+
+        if (isDecoding) {
+            // client-side
+            cloned = Object.assign(new CollectionSchema(), this);
+
+        } else {
+            // server-side
+            cloned = new CollectionSchema();
+            this.forEach((value) => {
+                if (value['$changes']) {
+                    cloned.add(value['clone']());
+                } else {
+                    cloned.add(value);
+                }
+            })
+        }
+
+        return cloned;
+    }
+
+}

package/src/types/HelperTypes.ts

@@ -0,0 +1,34 @@
+type Bool = 'true' | 'false'
+type Key = string | number | symbol;
+
+type Not<X extends Bool> = {
+    true: 'false',
+    false: 'true'
+}[X]
+
+type HaveIntersection<S1 extends string, S2 extends string> = (
+    { [K in S1]: 'true' } &
+    { [key: string]: 'false' }
+)[S2]
+
+type IsNeverWorker<S extends Key> = (
+    { [K in S]: 'false' } &
+    { [key: string]: 'true' }
+)[S]
+
+// Worker needed because of https://github.com/Microsoft/TypeScript/issues/18118
+type IsNever<T extends Key> = Not<HaveIntersection<IsNeverWorker<T>, 'false'>>
+
+type IsFunction<T> = IsNever<keyof T>
+
+export type NonFunctionProps<T> = {
+    [K in keyof T]: {
+        'false': K,
+        'true': never
+    }[IsFunction<T[K]>]
+}[keyof T];
+
+export type NonFunctionPropNames<T> = {
+    [K in keyof T]: T[K] extends Function ? never : K
+}[keyof T];
+

package/src/types/MapSchema.ts

@@ -0,0 +1,268 @@
+import { SchemaDecoderCallbacks } from "../Schema";
+import { addCallback, removeChildRefs } from "./utils";
+import { DataChange } from "..";
+import { ChangeTree } from "../changes/ChangeTree";
+import { OPERATION } from "../spec";
+
+export function getMapProxy(value: MapSchema) {
+    value['$proxy'] = true;
+
+    value = new Proxy(value, {
+        get: (obj, prop) => {
+            if (
+                typeof (prop) !== "symbol" && // accessing properties
+                typeof (obj[prop]) === "undefined"
+            ) {
+                return obj.get(prop as string);
+
+            } else {
+                return obj[prop];
+            }
+        },
+
+        set: (obj, prop, setValue) => {
+            if (
+                typeof (prop) !== "symbol" &&
+                (
+                    (prop as string).indexOf("$") === -1 &&
+                    prop !== "onAdd" &&
+                    prop !== "onRemove" &&
+                    prop !== "onChange"
+                )
+            ) {
+                obj.set(prop as string, setValue);
+
+            } else {
+                obj[prop] = setValue;
+            }
+            return true;
+        },
+
+        deleteProperty: (obj, prop) => {
+            obj.delete(prop as string);
+            return true;
+        },
+    });
+
+    return value;
+}
+
+export class MapSchema<V=any, K extends string = string> implements Map<K, V>, SchemaDecoderCallbacks {
+    protected $changes: ChangeTree = new ChangeTree(this);
+
+    protected $items: Map<K, V> = new Map<K, V>();
+    protected $indexes: Map<number, K> = new Map<number, K>();
+
+    protected $refId: number = 0;
+
+    //
+    // Decoding callbacks
+    //
+    public $callbacks: { [operation: number]: Array<(item: V, key: string) => void> };
+    public onAdd(callback: (item: V, key: string) => void, triggerAll: boolean = true) {
+        return addCallback(
+            (this.$callbacks || (this.$callbacks = [])),
+            OPERATION.ADD,
+            callback,
+            (triggerAll)
+                ? this.$items
+                : undefined
+        );
+    }
+    public onRemove(callback: (item: V, key: string) => void) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.DELETE, callback); }
+    public onChange(callback: (item: V, key: string) => void) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.REPLACE, callback); }
+
+    static is(type: any) {
+        return type['map'] !== undefined;
+    }
+
+    constructor (initialValues?: Map<K, V> | Record<K, V>) {
+        if (initialValues) {
+            if (
+                initialValues instanceof Map ||
+                initialValues instanceof MapSchema
+            ) {
+                initialValues.forEach((v, k) => this.set(k, v));
+
+            } else {
+                for (const k in initialValues) {
+                    this.set(k, initialValues[k]);
+                }
+            }
+        }
+    }
+
+    /** Iterator */
+    [Symbol.iterator](): IterableIterator<[K, V]> { return this.$items[Symbol.iterator](); }
+    get [Symbol.toStringTag]() { return this.$items[Symbol.toStringTag] }
+
+    set(key: K, value: V) {
+        if (value === undefined || value === null) {
+            throw new Error(`MapSchema#set('${key}', ${value}): trying to set ${value} value on '${key}'.`);
+        }
+
+        // get "index" for this value.
+        const hasIndex = typeof(this.$changes.indexes[key]) !== "undefined";
+        const index = (hasIndex)
+            ? this.$changes.indexes[key]
+            : this.$refId++;
+
+        let operation: OPERATION = (hasIndex)
+            ? OPERATION.REPLACE
+            : OPERATION.ADD;
+
+        const isRef = (value['$changes']) !== undefined;
+        if (isRef) {
+            (value['$changes'] as ChangeTree).setParent(
+                this,
+                this.$changes.root,
+                index
+            );
+        }
+
+        //
+        // (encoding)
+        // set a unique id to relate directly with this key/value.
+        //
+        if (!hasIndex) {
+            this.$changes.indexes[key] = index;
+            this.$indexes.set(index, key);
+
+        } else if (
+            isRef && // if is schema, force ADD operation if value differ from previous one.
+            this.$items.get(key) !== value
+        ) {
+            operation = OPERATION.ADD;
+        }
+
+        this.$items.set(key, value);
+
+        this.$changes.change(key, operation);
+
+        return this;
+    }
+
+    get(key: K): V | undefined {
+        return this.$items.get(key);
+    }
+
+    delete(key: K) {
+        //
+        // TODO: add a "purge" method after .encode() runs, to cleanup removed `$indexes`
+        //
+        // We don't remove $indexes to allow setting the same key in the same patch
+        // (See "should allow to remove and set an item in the same place" test)
+        //
+        // // const index = this.$changes.indexes[key];
+        // // this.$indexes.delete(index);
+
+        this.$changes.delete(key);
+        return this.$items.delete(key);
+    }
+
+    clear(changes?: DataChange[]) {
+        // discard previous operations.
+        this.$changes.discard(true, true);
+        this.$changes.indexes = {};
+
+        // clear previous indexes
+        this.$indexes.clear();
+
+        //
+        // When decoding:
+        // - enqueue items for DELETE callback.
+        // - flag child items for garbage collection.
+        //
+        if (changes) {
+            removeChildRefs.call(this, changes);
+        }
+
+        // clear items
+        this.$items.clear();
+
+        this.$changes.operation({ index: 0, op: OPERATION.CLEAR });
+
+        // touch all structures until reach root
+        this.$changes.touchParents();
+    }
+
+    has (key: K) {
+        return this.$items.has(key);
+    }
+
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void) {
+        this.$items.forEach(callbackfn);
+    }
+
+    entries () {
+        return this.$items.entries();
+    }
+
+    keys () {
+        return this.$items.keys();
+    }
+
+    values() {
+        return this.$items.values();
+    }
+
+    get size () {
+        return this.$items.size;
+    }
+
+    protected setIndex(index: number, key: K) {
+        this.$indexes.set(index, key);
+    }
+
+    protected getIndex(index: number) {
+        return this.$indexes.get(index);
+    }
+
+    protected getByIndex(index: number) {
+        return this.$items.get(this.$indexes.get(index));
+    }
+
+    protected deleteByIndex(index: number) {
+        const key = this.$indexes.get(index);
+        this.$items.delete(key);
+        this.$indexes.delete(index);
+    }
+
+    toJSON() {
+        const map: any = {};
+
+        this.forEach((value, key) => {
+            map[key] = (typeof (value['toJSON']) === "function")
+                ? value['toJSON']()
+                : value;
+        });
+
+        return map;
+    }
+
+    //
+    // Decoding utilities
+    //
+    clone(isDecoding?: boolean): MapSchema<V> {
+        let cloned: MapSchema;
+
+        if (isDecoding) {
+            // client-side
+            cloned = Object.assign(new MapSchema(), this);
+
+        } else {
+            // server-side
+            cloned = new MapSchema();
+            this.forEach((value, key) => {
+                if (value['$changes']) {
+                    cloned.set(key, value['clone']());
+                } else {
+                    cloned.set(key, value);
+                }
+            })
+        }
+
+        return cloned;
+    }
+
+}

package/src/types/SetSchema.ts

@@ -0,0 +1,208 @@
+import { ChangeTree } from "../changes/ChangeTree";
+import { OPERATION } from "../spec";
+import { SchemaDecoderCallbacks } from "../Schema";
+import { addCallback, removeChildRefs } from "./utils";
+import { DataChange } from "..";
+
+export class SetSchema<V=any> implements SchemaDecoderCallbacks {
+    protected $changes: ChangeTree = new ChangeTree(this);
+
+    protected $items: Map<number, V> = new Map<number, V>();
+    protected $indexes: Map<number, number> = new Map<number, number>();
+
+    protected $refId: number = 0;
+
+    //
+    // Decoding callbacks
+    //
+    public $callbacks: { [operation: number]: Array<(item: V, key: string) => void> };
+    public onAdd(callback: (item: V, key: string) => void, triggerAll: boolean = true) {
+        return addCallback(
+            (this.$callbacks || (this.$callbacks = [])),
+            OPERATION.ADD,
+            callback,
+            (triggerAll)
+                ? this.$items
+                : undefined
+        );
+    }
+    public onRemove(callback: (item: V, key: string) => void) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.DELETE, callback); }
+    public onChange(callback: (item: V, key: string) => void) { return addCallback(this.$callbacks || (this.$callbacks = []), OPERATION.REPLACE, callback); }
+
+    static is(type: any) {
+        return type['set'] !== undefined;
+    }
+
+    constructor (initialValues?: Array<V>) {
+        if (initialValues) {
+            initialValues.forEach((v) => this.add(v));
+        }
+    }
+
+    add(value: V) {
+        // immediatelly return false if value already added.
+        if (this.has(value)) { return false; }
+
+        // set "index" for reference.
+        const index = this.$refId++;
+
+        if ((value['$changes']) !== undefined) {
+            (value['$changes'] as ChangeTree).setParent(this, this.$changes.root, index);
+        }
+
+        const operation = this.$changes.indexes[index]?.op ?? OPERATION.ADD;
+
+        this.$changes.indexes[index] = index;
+
+        this.$indexes.set(index, index);
+        this.$items.set(index, value);
+
+        this.$changes.change(index, operation);
+        return index;
+    }
+
+    entries () {
+        return this.$items.entries();
+    }
+
+    delete(item: V) {
+        const entries = this.$items.entries();
+
+        let index: number;
+        let entry: IteratorResult<[number, V]>;
+        while (entry = entries.next()) {
+            if (entry.done) { break; }
+
+            if (item === entry.value[1]) {
+                index = entry.value[0];
+                break;
+            }
+        }
+
+        if (index === undefined) {
+            return false;
+        }
+
+        this.$changes.delete(index);
+        this.$indexes.delete(index);
+
+        return this.$items.delete(index);
+    }
+
+    clear(changes?: DataChange[]) {
+        // discard previous operations.
+        this.$changes.discard(true, true);
+        this.$changes.indexes = {};
+
+        // clear previous indexes
+        this.$indexes.clear();
+
+        //
+        // When decoding:
+        // - enqueue items for DELETE callback.
+        // - flag child items for garbage collection.
+        //
+        if (changes) {
+            removeChildRefs.call(this, changes);
+        }
+
+        // clear items
+        this.$items.clear();
+
+        this.$changes.operation({ index: 0, op: OPERATION.CLEAR });
+
+        // touch all structures until reach root
+        this.$changes.touchParents();
+    }
+
+    has (value: V): boolean {
+        const values = this.$items.values();
+
+        let has = false;
+        let entry: IteratorResult<V>;
+
+        while (entry = values.next()) {
+            if (entry.done) { break; }
+            if (value === entry.value) {
+                has = true;
+                break;
+            }
+        }
+
+        return has;
+    }
+
+    forEach(callbackfn: (value: V, key: number, collection: SetSchema<V>) => void) {
+        this.$items.forEach((value, key, _) => callbackfn(value, key, this));
+    }
+
+    values() {
+        return this.$items.values();
+    }
+
+    get size () {
+        return this.$items.size;
+    }
+
+    protected setIndex(index: number, key: number) {
+        this.$indexes.set(index, key);
+    }
+
+    protected getIndex(index: number) {
+        return this.$indexes.get(index);
+    }
+
+    protected getByIndex(index: number) {
+        return this.$items.get(this.$indexes.get(index));
+    }
+
+    protected deleteByIndex(index: number) {
+        const key = this.$indexes.get(index);
+        this.$items.delete(key);
+        this.$indexes.delete(index);
+    }
+
+    toArray() {
+        return Array.from(this.$items.values());
+    }
+
+    toJSON() {
+        const values: V[] = [];
+
+        this.forEach((value, key) => {
+            values.push(
+                (typeof (value['toJSON']) === "function")
+                    ? value['toJSON']()
+                    : value
+            );
+        });
+
+        return values;
+    }
+
+    //
+    // Decoding utilities
+    //
+    clone(isDecoding?: boolean): SetSchema<V> {
+        let cloned: SetSchema;
+
+        if (isDecoding) {
+            // client-side
+            cloned = Object.assign(new SetSchema(), this);
+
+        } else {
+            // server-side
+            cloned = new SetSchema();
+            this.forEach((value) => {
+                if (value['$changes']) {
+                    cloned.add(value['clone']());
+                } else {
+                    cloned.add(value);
+                }
+            })
+        }
+
+        return cloned;
+    }
+
+}