ts: Convert poll_data to typescript.

Used zod schemas to validate inbound data types and removed some over
defensive code.

web/shared/src/poll_data.ts

@@ -0,0 +1,307 @@
+import assert from "minimalistic-assert";
+import z from "zod";
+
+export type PollDataConfig = {
+    message_sender_id: number;
+    current_user_id: number;
+    is_my_poll: boolean;
+    question: string;
+    options: string[];
+    comma_separated_names: (user_ids: number[]) => string;
+    report_error_function: (msg: string, more_info?: unknown) => void;
+};
+
+export type PollOptionData = {
+    option: string;
+    names: string;
+    count: number;
+    key: string;
+    current_user_vote: boolean;
+};
+
+type PollOption = {
+    option: string;
+    user_id: number;
+    votes: Map<number, number>;
+};
+
+export type WidgetData = {
+    options: PollOptionData[];
+    question: string;
+};
+
+export type InboundData = Record<string, unknown> & {type: string};
+
+export type PollHandle = {
+    // Add generic key property to allow string indexing on PollHandle type in `handle_event` method.
+    [key: string]: {
+        outbound: (arg: string) => InboundData | undefined;
+        inbound: (sender_id: number, data: InboundData) => void;
+    };
+    new_option: {
+        outbound: (option: string) => {type: string; idx: number; option: string};
+        inbound: (sender_id: number, data: InboundData) => void;
+    };
+    question: {
+        outbound: (question: string) => {type: string; question: string} | undefined;
+        inbound: (sender_id: number, data: InboundData) => void;
+    };
+    vote: {
+        outbound: (key: string) => {type: string; key: string; vote: number};
+        inbound: (sender_id: number, data: InboundData) => void;
+    };
+};
+
+const inbound_option_schema = z.object({
+    idx: z.number(),
+    option: z.string(),
+    type: z.literal("new_option"),
+});
+
+const inbound_question_schema = z.object({
+    question: z.string(),
+    type: z.literal("question"),
+});
+
+const inbound_vote_schema = z.object({
+    key: z.string(),
+    type: z.literal("vote"),
+    vote: z.number(),
+});
+
+// Any single user should send add a finite number of options
+// to a poll. We arbitrarily pick this value.
+const MAX_IDX = 1000;
+
+export class PollData {
+    // This object just holds data for a poll, although it
+    // works closely with the widget's concept of how data
+    // should be represented for rendering, plus how the
+    // server sends us data.
+
+    key_to_option = new Map<string, PollOption>();
+    my_idx = 1;
+    message_sender_id: number;
+    me: number;
+    is_my_poll: boolean;
+    poll_question: string;
+    input_mode: boolean;
+    comma_separated_names: (user_ids: number[]) => string;
+    report_error_function: (error_message: string) => void;
+    handle: PollHandle;
+
+    constructor({
+        message_sender_id,
+        current_user_id,
+        is_my_poll,
+        question,
+        options,
+        comma_separated_names,
+        report_error_function,
+    }: PollDataConfig) {
+        this.message_sender_id = message_sender_id;
+        this.me = current_user_id;
+        this.is_my_poll = is_my_poll;
+        this.poll_question = question;
+        this.input_mode = is_my_poll; // for now
+        this.comma_separated_names = comma_separated_names;
+        this.report_error_function = report_error_function;
+
+        if (question) {
+            this.set_question(question);
+        }
+
+        this.handle = {
+            new_option: {
+                outbound: (option) => {
+                    const event = {
+                        type: "new_option",
+                        idx: this.my_idx,
+                        option,
+                    };
+
+                    this.my_idx += 1;
+
+                    return event;
+                },
+
+                inbound: (sender_id, data) => {
+                    const safe_data = inbound_option_schema.parse(data);
+
+                    // All message readers may add a new option to the poll.
+                    const idx = safe_data.idx;
+                    const option = safe_data.option;
+                    const options = this.get_widget_data().options;
+
+                    // While the UI doesn't allow adding duplicate options
+                    // to an existing poll, the /poll command syntax to create
+                    // them does not prevent duplicates, so we suppress them here.
+                    if (this.is_option_present(options, option)) {
+                        return;
+                    }
+
+                    if (idx < 0 || idx > MAX_IDX) {
+                        this.report_error_function("poll widget: idx out of bound");
+                        return;
+                    }
+
+                    const key = `${sender_id},${idx}`;
+                    const votes = new Map();
+
+                    this.key_to_option.set(key, {
+                        option,
+                        user_id: sender_id,
+                        votes,
+                    });
+
+                    // I may have added a poll option from another device.
+                    if (sender_id === this.me && this.my_idx <= idx) {
+                        this.my_idx = idx + 1;
+                    }
+                },
+            },
+
+            question: {
+                outbound: (question) => {
+                    const event = {
+                        type: "question",
+                        question,
+                    };
+                    if (this.is_my_poll) {
+                        return event;
+                    }
+                    return undefined;
+                },
+
+                inbound: (sender_id, data) => {
+                    const safe_data = inbound_question_schema.parse(data);
+
+                    // Only the message author can edit questions.
+                    if (sender_id !== this.message_sender_id) {
+                        this.report_error_function(
+                            `user ${sender_id} is not allowed to edit the question`,
+                        );
+                        return;
+                    }
+
+                    this.set_question(safe_data.question);
+                },
+            },
+
+            vote: {
+                outbound: (key) => {
+                    let vote = 1;
+
+                    // toggle
+                    assert(this.key_to_option.has(key), `option key not found: ${key}`);
+                    if (this.key_to_option.get(key)!.votes.get(this.me)) {
+                        vote = -1;
+                    }
+
+                    const event = {
+                        type: "vote",
+                        key,
+                        vote,
+                    };
+
+                    return event;
+                },
+
+                inbound: (sender_id, data) => {
+                    const safe_data = inbound_vote_schema.parse(data);
+
+                    // All message readers may vote on poll options.
+                    const key = safe_data.key;
+                    const vote = safe_data.vote;
+
+                    if (!(vote === 1 || vote === -1)) {
+                        this.report_error_function("poll widget: bad value for inbound vote count");
+                        return;
+                    }
+
+                    const option = this.key_to_option.get(key);
+
+                    if (option === undefined) {
+                        this.report_error_function("unknown key for poll: " + key);
+                        return;
+                    }
+
+                    const votes = option.votes;
+
+                    if (vote === 1) {
+                        votes.set(sender_id, 1);
+                    } else {
+                        votes.delete(sender_id);
+                    }
+                },
+            },
+        };
+
+        for (const [i, option] of options.entries()) {
+            this.handle.new_option.inbound(-1, {
+                idx: i,
+                option,
+                type: "new_option",
+            });
+        }
+    }
+
+    set_question(new_question: string): void {
+        this.input_mode = false;
+        this.poll_question = new_question;
+    }
+
+    get_question(): string {
+        return this.poll_question;
+    }
+
+    set_input_mode(): void {
+        this.input_mode = true;
+    }
+
+    clear_input_mode(): void {
+        this.input_mode = false;
+    }
+
+    get_input_mode(): boolean {
+        return this.input_mode;
+    }
+
+    get_widget_data(): WidgetData {
+        const options: PollOptionData[] = [];
+
+        for (const [key, obj] of this.key_to_option) {
+            const voters = [...obj.votes.keys()];
+            const current_user_vote = voters.includes(this.me);
+
+            options.push({
+                option: obj.option,
+                names: this.comma_separated_names(voters),
+                count: voters.length,
+                key,
+                current_user_vote,
+            });
+        }
+
+        const widget_data = {
+            options,
+            question: this.poll_question,
+        };
+
+        return widget_data;
+    }
+
+    handle_event(sender_id: number, data: InboundData): void {
+        const type = data.type;
+        if (this.handle[type]) {
+            this.handle[type].inbound(sender_id, data);
+        } else {
+            this.report_error_function(`poll widget: unknown inbound type: ${type}`);
+        }
+    }
+
+    // function to check whether option already exists
+    is_option_present(data: PollOptionData[], latest_option: string): boolean {
+        return data.some((el) => el.option === latest_option);
+    }
+}