polfan-server-js-client 0.3.3 → 0.4.1

package/src/types/src/schemes/UserData.ts

@@ -2,4 +2,9 @@ export type PrivateMessagePolicy = 'None' | 'Mutual' | 'All';
 
 export interface UserData {
     privateMessagePolicy: PrivateMessagePolicy;
+    /**
+     * Whether others may see that the user is reachable on a push-registered
+     * device while disconnected. When false the user simply reads as offline.
+     */
+    showAsyncPresence: boolean;
 }

package/src/types/src/schemes/commands/CreateMessage.ts

@@ -1,4 +1,5 @@
 import {ChatLocation} from "../ChatLocation";
+import {MessagePoll} from "../MessagePoll";
 
 export interface CreateMessage {
     location: ChatLocation;
@@ -6,4 +7,6 @@ export interface CreateMessage {
     attachments?: string[];
     customNick?: string;
     customColor?: string;
+    /** Turns the message into a poll; its content becomes the question. */
+    poll?: MessagePoll;
 }

package/src/types/src/schemes/commands/GetMessages.ts

@@ -6,4 +6,9 @@ export interface GetMessages {
     after?: string;
     around?: string;
     limit?: number;
+    /**
+     * Pull the reactions of the asking user along with the messages, instead of
+     * asking for their own state separately.
+     */
+    includeMyReactions?: boolean;
 }

package/src/types/src/schemes/commands/GetReactionDetails.ts

@@ -0,0 +1,9 @@
+import {ReactionType} from "../Reaction";
+
+export interface GetReactionDetails {
+    messageId: string;
+    type: ReactionType;
+    value: string;
+    limit?: number;
+    offset?: number;
+}

package/src/types/src/schemes/commands/React.ts

@@ -0,0 +1,7 @@
+import {ReactionType} from "../Reaction";
+
+export interface React {
+    messageId: string;
+    type: ReactionType;
+    value: string;
+}

package/src/types/src/schemes/commands/SetSessionData.ts

@@ -1,10 +1,19 @@
+import {SessionPlatform} from "../SessionData";
+
 export interface SessionPush {
     token?: string;
-    platform?: 'ios' | 'android' | 'web';
     active?: boolean;
+    /**
+     * @deprecated The platform describes the session, not its push registration.
+     * Use {@link SetSessionData.platform} (or the `platform` connection query
+     * parameter). Still accepted by the server, but the top-level field wins.
+     */
+    platform?: SessionPlatform;
 }
 
 export interface SetSessionData {
     clientFocused?: boolean;
     push?: SessionPush;
-}
+    /** Client platform of this session; null leaves the stored value unchanged. */
+    platform?: SessionPlatform;
+}

package/src/types/src/schemes/commands/SetUserData.ts

@@ -2,4 +2,5 @@ import {PrivateMessagePolicy} from "../UserData";
 
 export interface SetUserData {
     privateMessagePolicy?: PrivateMessagePolicy;
+    showAsyncPresence?: boolean;
 }

package/src/types/src/schemes/commands/Unreact.ts

@@ -0,0 +1,7 @@
+import {ReactionType} from "../Reaction";
+
+export interface Unreact {
+    messageId: string;
+    type: ReactionType;
+    value: string;
+}

package/src/types/src/schemes/events/Messages.ts

@@ -1,7 +1,10 @@
 import {ChatLocation} from "../ChatLocation";
 import {Message} from "../Message";
+import {UserReaction} from "../Reaction";
 
 export interface Messages {
     location: ChatLocation;
     messages: Message[];
+    /** Message id => reactions of the asking user; present only when requested. */
+    myReactions?: Record<string, UserReaction[]>;
 }

package/src/types/src/schemes/events/Reacted.ts

@@ -0,0 +1,10 @@
+import {ToggledReaction} from "../Reaction";
+
+/**
+ * Sent to every client of the voting user, so all of their devices know what they
+ * voted for without refetching the message history.
+ */
+export interface Reacted {
+    messageId: string;
+    reaction: ToggledReaction;
+}

package/src/types/src/schemes/events/ReactionDetails.ts

@@ -0,0 +1,12 @@
+import {ReactionType} from "../Reaction";
+
+/**
+ * Who reacted, oldest vote first. Only the ids travel - the nicks are already
+ * known from the room members collection.
+ */
+export interface ReactionDetails {
+    messageId: string;
+    type: ReactionType;
+    value: string;
+    userIds: string[];
+}

package/src/types/src/schemes/events/ReactionUpdated.ts

@@ -0,0 +1,9 @@
+import {MessageReaction} from "../Reaction";
+
+/**
+ * The single source of truth of a reaction counter, broadcast to the whole room.
+ */
+export interface ReactionUpdated {
+    messageId: string;
+    reaction: MessageReaction;
+}

package/tests/async-utils.test.ts

@@ -1,30 +1,30 @@
-import {PromiseRegistry} from "../src/state-tracker/AsyncUtils";
-
-test('promise registry - limit the calling of async process', async () => {
-    const pr = new PromiseRegistry();
-    let generationCount = 0;
-
-    async function generateResult() {
-        return ++generationCount;
-    }
-
-    async function getResult() {
-        const resultKey = 'test';
-
-        if (pr.notExist('test')) {
-            pr.registerByFunction(generateResult, resultKey);
-        }
-
-        await pr.get(resultKey);
-        return generationCount;
-    }
-
-    const call1 = await getResult();
-    expect(call1).toBe(1);
-    const call2 = await getResult();
-    expect(call2).toBe(1);
-    const call3 = await getResult();
-    expect(call3).toBe(1);
-
-    expect(generationCount).toBe(1);
+import {PromiseRegistry} from "../src/state-tracker/AsyncUtils";
+
+test('promise registry - limit the calling of async process', async () => {
+    const pr = new PromiseRegistry();
+    let generationCount = 0;
+
+    async function generateResult() {
+        return ++generationCount;
+    }
+
+    async function getResult() {
+        const resultKey = 'test';
+
+        if (pr.notExist('test')) {
+            pr.registerByFunction(generateResult, resultKey);
+        }
+
+        await pr.get(resultKey);
+        return generationCount;
+    }
+
+    const call1 = await getResult();
+    expect(call1).toBe(1);
+    const call2 = await getResult();
+    expect(call2).toBe(1);
+    const call3 = await getResult();
+    expect(call3).toBe(1);
+
+    expect(generationCount).toBe(1);
 });

package/tests/history-window.test.ts

@@ -209,137 +209,6 @@ test('history window - reset to latest', async () => {
     [7,8,9].forEach(id => expect(window.items.map(item => item.id)).toContain(id));
 });
 
-test('history window - resync to latest merges the new page into loaded items', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.resetToLatest(); // [7,8,9]
-    await window.fetchPrevious(); // [4,5,6,7,8,9]
-
-    await window.resyncToLatest(); // fetched [7,8,9] overlaps -> nothing is lost
-
-    expect(window.state).toEqual(WindowState.LATEST);
-    expect(window.items.map(item => item.id)).toEqual([4, 5, 6, 7, 8, 9]);
-});
-
-test('history window - resync to latest trims the merged items to the limit', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 4;
-    window.fetchLimit = 3;
-
-    await window.resetToLatest(); // [7,8,9]
-    await window.fetchPrevious(); // [4,5,6,7] (trimmed to the limit)
-
-    // [4,5,6,7] merged with the page [7,8,9] -> [4,5,6,7,8,9], trimmed again.
-    await window.resyncToLatest();
-
-    expect(window.state).toEqual(WindowState.LATEST);
-    expect(window.items.map(item => item.id)).toEqual([6, 7, 8, 9]);
-});
-
-test('history window - resync to latest marks the gap instead of dropping items', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.jumpTo('1'); // [0,1,2]
-
-    expect(window.gaps).toEqual([]);
-
-    // A full page ([7,8,9]) that does not reach the newest loaded item (2):
-    // items 3..6 were never fetched, so the seam in front of 7 is marked.
-    await window.resyncToLatest();
-
-    expect(window.state).toEqual(WindowState.LATEST);
-    expect(window.items.map(item => item.id)).toEqual([0, 1, 2, 7, 8, 9]);
-    expect(window.gaps).toEqual([7]);
-});
-
-test('history window - gap marker disappears with the item it points at', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.jumpTo('1'); // [0,1,2]
-    await window.resyncToLatest(); // [0,1,2] | [7,8,9]
-
-    expect(window.gaps).toEqual([7]);
-
-    window.delete(7);
-
-    expect(window.gaps).toEqual([]);
-});
-
-test('history window - gap marker is closed by fetching what is before it', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.jumpTo('1'); // [0,1,2]
-    await window.resyncToLatest(); // [0,1,2] | [7,8,9]
-    window.delete(0, 1, 2); // the items above the gap are gone, 7 is the top one
-
-    expect(window.gaps).toEqual([7]);
-
-    // Whatever comes back was fetched as the direct predecessor of 7, so the
-    // history is continuous again.
-    await window.fetchPrevious(); // [4,5,6,7,8,9]
-
-    expect(window.items.map(item => item.id)).toEqual([4, 5, 6, 7, 8, 9]);
-    expect(window.gaps).toEqual([]);
-});
-
-test('history window - gap markers are cleared when the whole window is replaced', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.jumpTo('1'); // [0,1,2]
-    await window.resyncToLatest(); // [0,1,2] | [7,8,9]
-
-    expect(window.gaps).toEqual([7]);
-
-    await window.resetToLatest(true); // [7,8,9] - a continuous window again
-
-    expect(window.items.map(item => item.id)).toEqual([7, 8, 9]);
-    expect(window.gaps).toEqual([]);
-});
-
-test('history window - gap marker is forgotten when trimmed out of the window', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 3;
-
-    await window.jumpTo('1'); // [0,1,2]
-    await window.resyncToLatest(); // [0,1,2] | [7,8,9]
-
-    expect(window.gaps).toEqual([7]);
-
-    // The window shrinks and the trimming pushes item 7 (and everything above
-    // it) out, so the marker has nothing left to point at.
-    window.limit = 2;
-    await window.resyncToLatest();
-
-    expect(window.items.map(item => item.id)).toEqual([8, 9]);
-    expect(window.gaps).toEqual([]);
-});
-
-test('history window - resync to latest keeps loaded items when the page is not full', async () => {
-    const window = new TestableHistoryWindow();
-    window.limit = 10;
-    window.fetchLimit = 5; // The fetch returns 3 items only - all there is.
-
-    await window.jumpTo('1'); // [0,1,2,3]
-
-    // Nothing is missing in between: the page is everything the remote side has,
-    // so the loaded items are kept even though the page does not reach them.
-    await window.resyncToLatest();
-
-    expect(window.state).toEqual(WindowState.LATEST);
-    expect(window.items.map(item => item.id)).toEqual([0, 1, 2, 3, 7, 8, 9]);
-});
-
 test('history window - jump to message', async () => {
     const window = new TestableHistoryWindow();
     window.limit = 5;

package/tests/space-roles.test.ts

@@ -1,43 +1,43 @@
-import {IndexedObjectCollection} from "../src";
-import {Role} from "pserv-ts-types";
-import {reorderRolesOnPriorityUpdate} from "../src/state-tracker/functions";
-
-const createCollection = () => new IndexedObjectCollection<Role>(
-    role => role.id,
-    [
-        {id: 'id1', name: 'everyone', priority: 0, color: '#ff0000'},
-        {id: 'id2', name: 'roleA', priority: 1, color: '#ff0000'},
-        {id: 'id3', name: 'roleB', priority: 2, color: '#ff0000'},
-        {id: 'id4', name: 'roleC', priority: 3, color: '#ff0000'},
-        {id: 'id5', name: 'roleD', priority: 4, color: '#ff0000'},
-    ],
-);
-
-test('roles reorder - increase', () => {
-    const collection = createCollection();
-    const oldRole = collection.get('id2');
-    const newRole: Role = {...oldRole, priority: 4};
-    const result = reorderRolesOnPriorityUpdate(collection.items, oldRole, newRole);
-    collection.set(newRole, ...result);
-
-    //expect(result.length).toBe(3);
-    expect(collection.get('id1').priority).toBe(0);
-    expect(collection.get('id2').priority).toBe(4);
-    expect(collection.get('id3').priority).toBe(1);
-    expect(collection.get('id4').priority).toBe(2);
-    expect(collection.get('id5').priority).toBe(3);
-});
-
-test('roles reorder - decrease', () => {
-    const collection = createCollection();
-    const oldRole = collection.get('id5');
-    const newRole: Role = {...oldRole, priority: 0};
-    const result = reorderRolesOnPriorityUpdate(collection.items, oldRole, newRole);
-    collection.set(newRole, ...result);
-
-    expect(collection.get('id1').priority).toBe(1);
-    expect(collection.get('id2').priority).toBe(2);
-    expect(collection.get('id3').priority).toBe(3);
-    expect(collection.get('id4').priority).toBe(4);
-    expect(collection.get('id5').priority).toBe(0);
+import {IndexedObjectCollection} from "../src";
+import {Role} from "pserv-ts-types";
+import {reorderRolesOnPriorityUpdate} from "../src/state-tracker/functions";
+
+const createCollection = () => new IndexedObjectCollection<Role>(
+    role => role.id,
+    [
+        {id: 'id1', name: 'everyone', priority: 0, color: '#ff0000'},
+        {id: 'id2', name: 'roleA', priority: 1, color: '#ff0000'},
+        {id: 'id3', name: 'roleB', priority: 2, color: '#ff0000'},
+        {id: 'id4', name: 'roleC', priority: 3, color: '#ff0000'},
+        {id: 'id5', name: 'roleD', priority: 4, color: '#ff0000'},
+    ],
+);
+
+test('roles reorder - increase', () => {
+    const collection = createCollection();
+    const oldRole = collection.get('id2');
+    const newRole: Role = {...oldRole, priority: 4};
+    const result = reorderRolesOnPriorityUpdate(collection.items, oldRole, newRole);
+    collection.set(newRole, ...result);
+
+    //expect(result.length).toBe(3);
+    expect(collection.get('id1').priority).toBe(0);
+    expect(collection.get('id2').priority).toBe(4);
+    expect(collection.get('id3').priority).toBe(1);
+    expect(collection.get('id4').priority).toBe(2);
+    expect(collection.get('id5').priority).toBe(3);
+});
+
+test('roles reorder - decrease', () => {
+    const collection = createCollection();
+    const oldRole = collection.get('id5');
+    const newRole: Role = {...oldRole, priority: 0};
+    const result = reorderRolesOnPriorityUpdate(collection.items, oldRole, newRole);
+    collection.set(newRole, ...result);
+
+    expect(collection.get('id1').priority).toBe(1);
+    expect(collection.get('id2').priority).toBe(2);
+    expect(collection.get('id3').priority).toBe(3);
+    expect(collection.get('id4').priority).toBe(4);
+    expect(collection.get('id5').priority).toBe(0);
 });