@nymphjs/client 1.0.0-beta.12 → 1.0.0-beta.121

package/dist/Nymph.types.js

@@ -0,0 +1,45 @@
+export var TilmeldAccessRequest;
+(function (TilmeldAccessRequest) {
+    /**
+     * The default level, any possible entity readable by the user.
+     *
+     * This is the same as or-ing together all of the levels listed below.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["ALL_LEVELS"] = 0] = "ALL_LEVELS";
+    /**
+     * Owned by and accessible to the user.
+     *
+     * This is always enabled, so not including it has no effect. It's here to
+     * allow the selection of _only_ user owned entities.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["USER_OWNED"] = 1] = "USER_OWNED";
+    /**
+     * Owned by and accessible to the user's primary group.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["PRIMARY_GROUP_OWNED"] = 2] = "PRIMARY_GROUP_OWNED";
+    /**
+     * Owned by and accessible to one of the user's secondary groups.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["SECONDARY_GROUP_OWNED"] = 4] = "SECONDARY_GROUP_OWNED";
+    /**
+     * The user is listed in an access control list.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["USER_ACCESSIBLE"] = 8] = "USER_ACCESSIBLE";
+    /**
+     * The user's primary group is listed in an access control list.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["PRIMARY_GROUP_ACCESSIBLE"] = 16] = "PRIMARY_GROUP_ACCESSIBLE";
+    /**
+     * One of the user's secondary groups is listed in an access control list.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["SECONDARY_GROUP_ACCESSIBLE"] = 32] = "SECONDARY_GROUP_ACCESSIBLE";
+    /**
+     * The entity is accessible to any user.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["OTHER_ACCESSIBLE"] = 64] = "OTHER_ACCESSIBLE";
+    /**
+     * The entity is not owned by anyone.
+     */
+    TilmeldAccessRequest[TilmeldAccessRequest["UNOWNED"] = 128] = "UNOWNED";
+})(TilmeldAccessRequest || (TilmeldAccessRequest = {}));
+//# sourceMappingURL=Nymph.types.js.map

package/dist/Nymph.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Nymph.types.js","sourceRoot":"","sources":["../src/Nymph.types.ts"],"names":[],"mappings":"AAoOA,MAAM,CAAN,IAAY,oBA0CX;AA1CD,WAAY,oBAAoB;IAC9B;;;;OAIG;IACH,2EAAc,CAAA;IACd;;;;;OAKG;IACH,2EAAc,CAAA;IACd;;OAEG;IACH,6FAAuB,CAAA;IACvB;;OAEG;IACH,iGAAyB,CAAA;IACzB;;OAEG;IACH,qFAAmB,CAAA;IACnB;;OAEG;IACH,wGAA6B,CAAA;IAC7B;;OAEG;IACH,4GAA+B,CAAA;IAC/B;;OAEG;IACH,wFAAqB,CAAA;IACrB;;OAEG;IACH,uEAAa,CAAA;AACf,CAAC,EA1CW,oBAAoB,KAApB,oBAAoB,QA0C/B"}

package/{lib → dist}/PubSub.d.ts

@@ -1,9 +1,12 @@
-import Nymph from './Nymph';
-import { NymphOptions, Options, Selector } from './Nymph.types';
-import { EntityConstructor, EntityInterface } from './Entity.types';
-import { PubSubCallbacks, PubSubConnectCallback, PubSubCountCallback, PubSubDisconnectCallback, PubSubEventType, PubSubRejectCallback, PubSubResolveCallback, PubSubSubscribable, PubSubUpdate } from './PubSub.types';
+import Nymph from './Nymph.js';
+import type { NymphOptions, Options, Selector } from './Nymph.types.js';
+import type { EntityInstanceType } from './Entity.js';
+import type { EntityConstructor, EntityInterface } from './Entity.types.js';
+import type { PubSubCallbacks, PubSubConnectCallback, PubSubCountCallback, PubSubDisconnectCallback, PubSubEventType, PubSubRejectCallback, PubSubResolveCallback, PubSubErrorCallback, PubSubSubscribable, PubSubUpdate } from './PubSub.types.js';
 export default class PubSub {
     private nymph;
+    private authToken;
+    private switchToken;
     private connection;
     private waitForConnectionTimeout;
     private pubsubUrl;
@@ -11,16 +14,17 @@ export default class PubSub {
     private subscriptions;
     private connectCallbacks;
     private disconnectCallbacks;
+    private errorCallbacks;
     private noConsole;
     constructor(nymphOptions: NymphOptions, nymph: Nymph);
     subscribeEntities<T extends EntityConstructor = EntityConstructor>(options: Options<T> & {
         return: 'guid';
     }, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<string[]>>;
-    subscribeEntities<T extends EntityConstructor = EntityConstructor>(options: Options<T>, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<ReturnType<T['factorySync']>[]>>;
+    subscribeEntities<T extends EntityConstructor = EntityConstructor>(options: Options<T>, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<EntityInstanceType<T>[]>>;
     subscribeEntity<T extends EntityConstructor = EntityConstructor>(options: Options<T> & {
         return: 'guid';
     }, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<string | null>>;
-    subscribeEntity<T extends EntityConstructor = EntityConstructor>(options: Options<T>, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<ReturnType<T['factorySync']> | null>>;
+    subscribeEntity<T extends EntityConstructor = EntityConstructor>(options: Options<T>, ...selectors: Selector[]): PubSubSubscribable<PubSubUpdate<EntityInstanceType<T> | null>>;
     subscribeUID(name: string): (resolve?: PubSubResolveCallback<number> | undefined, reject?: PubSubRejectCallback | undefined, count?: PubSubCountCallback | undefined) => {
         unsubscribe: () => void;
     };
@@ -34,6 +38,8 @@ export default class PubSub {
     private _onclose;
     private _send;
     isConnectionOpen(): boolean;
+    isConnectionConnecting(): boolean;
+    isConnection(): boolean;
     private _subscribeQuery;
     private _subscribeUID;
     private _sendQuery;
@@ -44,10 +50,10 @@ export default class PubSub {
     private _unsubscribeUID;
     private _sendUnQuery;
     private _sendUnUID;
-    updateArray(oldArr: EntityInterface[], update: PubSubUpdate<EntityInterface[]>): void;
-    on<T extends PubSubEventType>(event: T, callback: T extends 'connect' ? PubSubConnectCallback : T extends 'disconnect' ? PubSubDisconnectCallback : never): () => boolean;
-    off<T extends PubSubEventType>(event: T, callback: T extends 'connect' ? PubSubConnectCallback : T extends 'disconnect' ? PubSubDisconnectCallback : never): boolean;
-    setToken(token: string | null): void;
+    updateArray(current: EntityInterface[], update: PubSubUpdate<EntityInterface[]>): void;
+    on<T extends PubSubEventType>(event: T, callback: T extends 'connect' ? PubSubConnectCallback : T extends 'disconnect' ? PubSubDisconnectCallback : T extends 'error' ? PubSubErrorCallback : never): () => boolean;
+    off<T extends PubSubEventType>(event: T, callback: T extends 'connect' ? PubSubConnectCallback : T extends 'disconnect' ? PubSubDisconnectCallback : T extends 'error' ? PubSubErrorCallback : never): boolean;
+    authenticate(authToken: string | null, switchToken?: string | null): void;
 }
 export declare class PubSubSubscription<T> {
     query: string;

package/{lib → dist}/PubSub.js

@@ -1,18 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PubSubSubscription = void 0;
-const Nymph_1 = require("./Nymph");
-const utils_1 = require("./utils");
-let authToken = null;
-class PubSub {
+import { InvalidRequestError } from './Nymph.js';
+import { entityConstructorsToClassNames } from './utils.js';
+import { ClientError } from './HttpRequester.js';
+export default class PubSub {
+    nymph;
+    authToken = null;
+    switchToken = null;
+    connection;
+    waitForConnectionTimeout;
+    pubsubUrl;
+    WebSocket;
+    subscriptions = {
+        queries: {},
+        uids: {},
+    };
+    connectCallbacks = [];
+    disconnectCallbacks = [];
+    errorCallbacks = [];
+    noConsole = false;
     constructor(nymphOptions, nymph) {
-        this.subscriptions = {
-            queries: {},
-            uids: {},
-        };
-        this.connectCallbacks = [];
-        this.disconnectCallbacks = [];
-        this.noConsole = false;
         this.nymph = nymph;
         this.nymph.pubsub = this;
         this.pubsubUrl = nymphOptions.pubsubUrl;
@@ -24,20 +29,23 @@ class PubSub {
         if (typeof addEventListener !== 'undefined') {
             addEventListener('online', () => this.connect());
         }
-        if (typeof navigator === 'undefined' || navigator.onLine) {
+        if (!nymphOptions.noAutoconnect &&
+            (typeof navigator === 'undefined' || navigator.onLine)) {
             this.connect();
         }
     }
     subscribeEntities(options, ...selectors) {
-        const promise = this.nymph.getEntities(options, ...selectors);
         const query = [
-            (0, utils_1.entityConstructorsToClassNames)(options),
-            ...(0, utils_1.entityConstructorsToClassNames)(selectors),
+            entityConstructorsToClassNames(options),
+            ...entityConstructorsToClassNames(selectors),
         ];
         const jsonQuery = JSON.stringify(query);
         const subscribe = (resolve, reject, count) => {
             const callbacks = [resolve, reject, count];
-            promise.then(resolve, reject);
+            if (!this.isConnection()) {
+                // Fall back to a regular query if we're not connected.
+                this.nymph.getEntities(options, ...selectors).then(resolve, reject);
+            }
             this._subscribeQuery(jsonQuery, callbacks);
             return new PubSubSubscription(jsonQuery, callbacks, () => {
                 this._unsubscribeQuery(jsonQuery, callbacks);
@@ -46,10 +54,9 @@ class PubSub {
         return subscribe;
     }
     subscribeEntity(options, ...selectors) {
-        const promise = this.nymph.getEntity(options, ...selectors);
         const query = [
-            { ...(0, utils_1.entityConstructorsToClassNames)(options), limit: 1 },
-            ...(0, utils_1.entityConstructorsToClassNames)(selectors),
+            { ...entityConstructorsToClassNames(options), limit: 1 },
+            ...entityConstructorsToClassNames(selectors),
         ];
         const jsonQuery = JSON.stringify(query);
         const subscribe = (resolve, reject, count) => {
@@ -66,7 +73,10 @@ class PubSub {
                 }
             };
             const callbacks = [newResolve, reject, count];
-            promise.then(resolve, reject);
+            if (!this.isConnection()) {
+                // Fall back to a regular query if we're not connected.
+                this.nymph.getEntity(options, ...selectors).then(resolve, reject);
+            }
             this._subscribeQuery(jsonQuery, callbacks);
             return new PubSubSubscription(jsonQuery, callbacks, () => {
                 this._unsubscribeQuery(jsonQuery, callbacks);
@@ -75,10 +85,12 @@ class PubSub {
         return subscribe;
     }
     subscribeUID(name) {
-        const promise = this.nymph.getUID(name);
         const subscribe = (resolve, reject, count) => {
             const callbacks = [resolve, reject, count];
-            promise.then(resolve, reject);
+            if (!this.isConnection()) {
+                // Fall back to a regular query if we're not connected.
+                this.nymph.getUID(name).then(resolve, reject);
+            }
             this._subscribeUID(name, callbacks);
             return {
                 unsubscribe: () => {
@@ -90,7 +102,7 @@ class PubSub {
     }
     subscribeWith(entity, resolve, reject, count) {
         if (!entity.guid) {
-            throw new Nymph_1.InvalidRequestError("You can't subscribe to an entity with no GUID.");
+            throw new InvalidRequestError("You can't subscribe to an entity with no GUID.");
         }
         const query = [
             { class: entity.constructor.class, limit: 1 },
@@ -99,18 +111,24 @@ class PubSub {
         const jsonQuery = JSON.stringify(query);
         const newResolve = (args) => {
             if (Array.isArray(args)) {
-                if (args[0].length) {
-                    entity.$init(args[0]);
+                if (args.length) {
+                    entity.$init(args[0].toJSON());
                 }
                 else {
                     entity.guid = null;
                 }
             }
-            else if ('removed' in args) {
-                entity.guid = null;
-            }
             else {
-                entity.$init(args.data);
+                let update = args;
+                if ('multiple' in args && args.multiple) {
+                    update = args.messages.pop();
+                }
+                if ('removed' in update) {
+                    entity.guid = null;
+                }
+                else {
+                    entity.$init(update.data);
+                }
             }
             if (resolve) {
                 resolve(entity);
@@ -123,6 +141,7 @@ class PubSub {
         });
     }
     connect() {
+        // Are we already connected?
         if (this.connection &&
             (this.connection.readyState === this.WebSocket.OPEN ||
                 this.connection.readyState === this.WebSocket.CONNECTING)) {
@@ -138,28 +157,32 @@ class PubSub {
         if (!this.connection) {
             return;
         }
-        this.connection.close(4200, 'Closure requested by application.');
+        this.connection.close(1000, 'Closure requested by application.');
     }
-    _waitForConnection(attempts = 0) {
+    _waitForConnection(attempts = 1) {
+        // Wait 5 seconds, then check and attempt connection again if unsuccessful.
+        // Keep repeating, adding attempts^2*5 seconds each time to a max of ten
+        // minutes, until successful.
         this.waitForConnectionTimeout = setTimeout(() => {
-            if (this.connection &&
-                this.connection.readyState !== this.WebSocket.OPEN) {
-                if (this.connection.readyState !== this.WebSocket.CONNECTING ||
-                    attempts >= 5) {
-                    this.connection.close();
-                    this._waitForConnection();
-                    this._attemptConnect();
-                }
-                else {
-                    this._waitForConnection(attempts + 1);
+            if (this.connection) {
+                if (this.connection.readyState !== this.WebSocket.OPEN) {
+                    if (this.connection.readyState !== this.WebSocket.CONNECTING) {
+                        this.connection.close();
+                        this._waitForConnection(attempts + 1);
+                        this._attemptConnect();
+                    }
+                    else {
+                        this._waitForConnection(attempts + 1);
+                    }
                 }
             }
             else {
                 this._attemptConnect();
             }
-        }, 5000);
+        }, Math.max(Math.pow(attempts, 2) * 5000, 1000 * 60 * 10));
     }
     _attemptConnect() {
+        // Attempt to connect.
         if (this.pubsubUrl != null) {
             this.connection = new this.WebSocket(this.pubsubUrl, 'nymph');
             this.connection.onopen = this._onopen.bind(this);
@@ -170,16 +193,20 @@ class PubSub {
         if (typeof console !== 'undefined' && !this.noConsole) {
             console.log('Nymph-PubSub connection established!');
         }
+        if (this.waitForConnectionTimeout) {
+            clearTimeout(this.waitForConnectionTimeout);
+        }
         for (let i = 0; i < this.connectCallbacks.length; i++) {
             const callback = this.connectCallbacks[i];
             if (callback) {
                 callback();
             }
         }
-        if (authToken != null) {
+        if (this.authToken != null) {
             this._send({
                 action: 'authenticate',
-                token: authToken,
+                authToken: this.authToken,
+                switchToken: this.switchToken,
             });
         }
         for (let query in this.subscriptions.queries) {
@@ -215,15 +242,19 @@ class PubSub {
     _onmessage(e) {
         let data = JSON.parse(e.data);
         let subs = [];
+        let set = 'set' in data && data.set;
         let count = 'count' in data;
+        let error = 'error' in data;
         if (data.hasOwnProperty('query') &&
             this.subscriptions.queries.hasOwnProperty(data.query)) {
             subs = [...this.subscriptions.queries[data.query]];
-            if (!count) {
+            if (!count && !error) {
                 for (let i = 0; i < subs.length; i++) {
                     const callback = subs[i][0];
                     if (typeof callback === 'function') {
-                        callback(data);
+                        callback(set
+                            ? data.data.map((e) => this.nymph.initEntity(e))
+                            : data);
                     }
                 }
             }
@@ -231,15 +262,35 @@ class PubSub {
         else if (data.hasOwnProperty('uid') &&
             this.subscriptions.uids.hasOwnProperty(data.uid)) {
             subs = [...this.subscriptions.uids[data.uid]];
-            if (!count) {
+            if (!count && !error) {
                 for (let i = 0; i < subs.length; i++) {
                     const callback = subs[i][0];
-                    if (typeof callback === 'function') {
-                        callback(data.value ?? null, data.event);
+                    const errCallback = subs[i][1];
+                    if (set && data.data == null) {
+                        if (typeof errCallback === 'function') {
+                            errCallback(new ClientError({ status: 404, statusText: 'Not Found' }, { textStatus: 'Not Found' }));
+                        }
+                    }
+                    else if (typeof callback === 'function') {
+                        if (set) {
+                            callback(data.data);
+                        }
+                        else {
+                            callback(data.value ?? null, data.event);
+                        }
                     }
                 }
             }
         }
+        else if (error) {
+            for (let i = 0; i < this.errorCallbacks.length; i++) {
+                const callback = this.errorCallbacks[i];
+                if (callback) {
+                    callback(data.error);
+                }
+            }
+            return;
+        }
         if (count) {
             for (let i = 0; i < subs.length; i++) {
                 const callback = subs[i][2];
@@ -248,6 +299,14 @@ class PubSub {
                 }
             }
         }
+        if (error) {
+            for (let i = 0; i < subs.length; i++) {
+                const callback = subs[i][1];
+                if (typeof callback === 'function') {
+                    callback(data.error);
+                }
+            }
+        }
     }
     _onclose(e) {
         if (typeof console !== 'undefined' && !this.noConsole) {
@@ -259,7 +318,7 @@ class PubSub {
                 callback();
             }
         }
-        if (e.code !== 4200 &&
+        if (e.code !== 1000 &&
             (typeof navigator === 'undefined' || navigator.onLine)) {
             if (this.connection) {
                 this.connection.close();
@@ -276,6 +335,13 @@ class PubSub {
     isConnectionOpen() {
         return !!(this.connection && this.connection.readyState === this.WebSocket.OPEN);
     }
+    isConnectionConnecting() {
+        return !!(this.connection &&
+            this.connection.readyState === this.WebSocket.CONNECTING);
+    }
+    isConnection() {
+        return this.isConnectionOpen() || this.isConnectionConnecting();
+    }
     _subscribeQuery(query, callbacks) {
         let isNewSubscription = false;
         if (!this.subscriptions.queries.hasOwnProperty(query)) {
@@ -396,101 +462,103 @@ class PubSub {
             uid: name,
         });
     }
-    updateArray(oldArr, update) {
+    updateArray(current, update) {
         if (Array.isArray(update)) {
             const newArr = [...update];
-            if (oldArr.length === 0) {
-                oldArr.splice(0, 0, ...newArr);
+            if (current.length === 0) {
+                // This will happen on the first update from a subscribe.
+                current.splice(0, 0, ...newArr);
                 return;
             }
             const idMap = {};
-            const Entity = this.nymph.getEntityClass('Entity');
+            const newEntities = [];
+            while (current.length) {
+                const first = current.shift();
+                if (!first) {
+                    continue;
+                }
+                const guid = first.guid;
+                if (!guid) {
+                    newEntities.push(first);
+                    continue;
+                }
+                idMap[guid] = first;
+            }
             for (let i = 0; i < newArr.length; i++) {
                 const entity = newArr[i];
-                if (entity instanceof Entity && entity.guid != null) {
-                    idMap[entity.guid] = i;
+                const guid = entity.guid;
+                if (guid == null) {
+                    continue;
                 }
-            }
-            const remove = [];
-            for (let k in oldArr) {
-                if (typeof k === 'number' &&
-                    k <= 4294967294 &&
-                    /^0$|^[1-9]\d*$/.test(k) &&
-                    oldArr.hasOwnProperty(k)) {
-                    const guid = oldArr[k].guid;
-                    if (guid != null) {
-                        if (!idMap.hasOwnProperty(guid)) {
-                            remove.push(k);
-                        }
-                        else if (newArr[idMap[guid]].mdate !== oldArr[k].mdate) {
-                            oldArr[k].$init(newArr[idMap[guid]].toJSON());
-                            delete idMap[guid];
-                        }
-                        else {
-                            delete idMap[guid];
-                        }
-                    }
+                if (!idMap.hasOwnProperty(guid)) {
+                    // It was added.
+                    current.push(entity);
+                }
+                else if (idMap[guid].mdate !== entity.mdate) {
+                    // It was modified.
+                    idMap[guid].$init(entity.toJSON());
+                    current.push(idMap[guid]);
+                }
+                else {
+                    // Item wasn't modified.
+                    current.push(idMap[guid]);
                 }
             }
-            remove.sort(function (a, b) {
-                if (a > b)
-                    return -1;
-                if (a < b)
-                    return 1;
-                return 0;
-            });
-            for (let n = 0; n < remove.length; n++) {
-                oldArr.splice(remove[n], 1);
-            }
-            for (let value of Object.values(idMap)) {
-                oldArr.splice(oldArr.length, 0, newArr[value]);
-            }
+            current.splice(current.length, 0, ...newEntities);
         }
         else if (update != null && update.hasOwnProperty('query')) {
-            if ('removed' in update) {
-                for (let i = 0; i < oldArr.length; i++) {
-                    if (oldArr[i] != null && oldArr[i].guid === update.removed) {
-                        oldArr.splice(i, 1);
-                        return;
+            const updates = 'multiple' in update && update.multiple ? update.messages : [update];
+            for (let curUpdate of updates) {
+                if ('removed' in curUpdate) {
+                    for (let i = 0; i < current.length; i++) {
+                        if (current[i] != null && current[i].guid === curUpdate.removed) {
+                            current.splice(i, 1);
+                            continue;
+                        }
                     }
                 }
-            }
-            let entity = null;
-            if ('added' in update) {
-                for (let i = 0; i < oldArr.length; i++) {
-                    if (oldArr[i] != null && oldArr[i].guid === update.added) {
-                        entity = oldArr.splice(i, 1)[0].$init(update.data);
+                // Get the entity.
+                let entity = null;
+                if ('added' in curUpdate) {
+                    // Check for it in the array already.
+                    for (let i = 0; i < current.length; i++) {
+                        if (current[i] != null && current[i].guid === curUpdate.added) {
+                            entity = current.splice(i, 1)[0].$init(curUpdate.data);
+                        }
                     }
-                }
-                if (entity == null) {
-                    entity = this.nymph.initEntity(update.data);
-                }
-            }
-            if ('updated' in update) {
-                for (let i = 0; i < oldArr.length; i++) {
-                    if (oldArr[i] != null && oldArr[i].guid === update.updated) {
-                        entity = oldArr.splice(i, 1)[0].$init(update.data);
+                    if (entity == null) {
+                        // A new entity.
+                        entity = this.nymph.initEntity(curUpdate.data);
                     }
                 }
-            }
-            const query = JSON.parse(update.query);
-            if (entity != null) {
-                const sort = 'sort' in query[0] ? query[0].sort : 'cdate';
-                const reverse = query[0].hasOwnProperty('reverse')
-                    ? query[0].reverse
-                    : false;
-                let i;
-                if (reverse) {
-                    for (i = 0; ((oldArr[i] ?? {})[sort] ?? 0) >= (entity[sort] ?? 0) &&
-                        i < oldArr.length; i++)
-                        ;
+                if ('updated' in curUpdate) {
+                    // Extract it from the array.
+                    for (let i = 0; i < current.length; i++) {
+                        if (current[i] != null && current[i].guid === curUpdate.updated) {
+                            entity = current.splice(i, 1)[0].$init(curUpdate.data);
+                        }
+                    }
                 }
-                else {
-                    for (i = 0; ((oldArr[i] ?? {})[sort] ?? 0) < (entity[sort] ?? 0) &&
-                        i < oldArr.length; i++)
-                        ;
+                if (entity != null) {
+                    const query = JSON.parse(curUpdate.query);
+                    // Insert the entity in order.
+                    const sort = 'sort' in query[0] ? query[0].sort : 'cdate';
+                    const reverse = query[0].hasOwnProperty('reverse')
+                        ? query[0].reverse
+                        : false;
+                    let i;
+                    if (reverse) {
+                        for (i = 0; ((current[i] ?? {})[sort] ?? 0) >= (entity[sort] ?? 0) &&
+                            i < current.length; i++)
+                            ;
+                    }
+                    else {
+                        for (i = 0; ((current[i] ?? {})[sort] ?? 0) < (entity[sort] ?? 0) &&
+                            i < current.length; i++)
+                            ;
+                    }
+                    current.splice(i, 0, entity);
                 }
-                oldArr.splice(i, 0, entity);
             }
         }
     }
@@ -499,6 +567,7 @@ class PubSub {
         if (!(prop in this)) {
             throw new Error('Invalid event type.');
         }
+        // @ts-ignore: The callback should always be the right type here.
         this[prop].push(callback);
         return () => this.off(event, callback);
     }
@@ -507,29 +576,33 @@ class PubSub {
         if (!(prop in this)) {
             return false;
         }
+        // @ts-ignore: The callback should always be the right type here.
         const i = this[prop].indexOf(callback);
         if (i > -1) {
             this[prop].splice(i, 1);
         }
         return true;
     }
-    setToken(token) {
-        authToken = token;
+    authenticate(authToken, switchToken = null) {
+        this.authToken = authToken;
+        this.switchToken = switchToken;
         if (this.isConnectionOpen()) {
             this._send({
                 action: 'authenticate',
-                token: authToken,
+                authToken: this.authToken,
+                switchToken: this.switchToken,
             });
         }
     }
 }
-exports.default = PubSub;
-class PubSubSubscription {
+export class PubSubSubscription {
+    query;
+    callbacks;
+    unsubscribe;
     constructor(query, callbacks, unsubscribe) {
         this.query = query;
         this.callbacks = callbacks;
         this.unsubscribe = unsubscribe;
     }
 }
-exports.PubSubSubscription = PubSubSubscription;
 //# sourceMappingURL=PubSub.js.map