summaryrefslogtreecommitdiffstats
path: root/asset/js/widget/TermInput.js
blob: f85115f759d024f4572faf4d82006bc9c178d4dd (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
define(["BaseInput"], function (BaseInput) {

    "use strict";

    class TermInput extends BaseInput {
        constructor(input) {
            super(input);

            this.separator = ' ';
            this.ignoreSpaceUntil = null;
            this.ignoreSpaceSince = null;
        }

        reset() {
            super.reset();

            this.ignoreSpaceUntil = null;
            this.ignoreSpaceSince = null;
        }

        writePartialTerm(value, input) {
            if (this.ignoreSpaceUntil !== null && this.ignoreSpaceSince === 0) {
                value = this.ignoreSpaceUntil + value;
            }

            super.writePartialTerm(value, input);
        }

        readFullTerm(input, termIndex = null) {
            let termData = super.readFullTerm(input, termIndex);
            if (this.ignoreSpaceUntil !== null && termData.label[this.ignoreSpaceSince] === this.ignoreSpaceUntil) {
                if (termData.label.length - 1 === this.ignoreSpaceSince
                    || termData.label.slice(-1) !== this.ignoreSpaceUntil
                    || (this.ignoreSpaceSince === 0 && (termData.label.length < 2
                        || termData.label.slice(0, 1) !== this.ignoreSpaceUntil)
                    )
                ) {
                    return false;
                }
            }

            return termData;
        }

        addTerm(termData, termIndex = null) {
            if (this.ignoreSpaceUntil !== null) {
                if (this.ignoreSpaceSince === 0 && termData.label[this.ignoreSpaceSince] === this.ignoreSpaceUntil) {
                    termData.label = termData.label.slice(1, -1);
                }

                this.ignoreSpaceUntil = null;
                this.ignoreSpaceSince = null;
            }

            super.addTerm(termData, termIndex);
        }

        complete(input, data) {
            data.exclude = this.usedTerms.map(termData => termData.search);

            super.complete(input, data);
        }

        /**
         * Event listeners
         */

        onSubmit(event) {
            super.onSubmit(event);

            this.ignoreSpaceUntil = null;
            this.ignoreSpaceSince = null;
        }

        onKeyDown(event) {
            super.onKeyDown(event);
            if (event.defaultPrevented) {
                return;
            }

            let label = event.target.parentNode;
            if (label.dataset.index >= 0) {
                return;
            }

            if (event.key !== this.separator) {
                return;
            }

            let addedTerms = this.exchangeTerm();
            if (addedTerms.length) {
                this.togglePlaceholder();
                event.preventDefault();
                this.autoSubmit(this.input, 'exchange', addedTerms);
            }
        }

        onKeyUp(event) {
            super.onKeyUp(event);

            let label = event.target.parentNode;
            if (label.dataset.index >= 0) {
                return;
            }

            if (this.ignoreSpaceUntil !== null) {
                // Reset if the user changes/removes the source char
                let value = event.target.value;
                if (value[this.ignoreSpaceSince] !== this.ignoreSpaceUntil) {
                    this.ignoreSpaceUntil = null;
                    this.ignoreSpaceSince = null;
                }
            }

            let input = event.target;
            switch (event.key) {
                case '"':
                case "'":
                    if (this.ignoreSpaceUntil === null) {
                        this.ignoreSpaceUntil = event.key;
                        this.ignoreSpaceSince = input.selectionStart - 1;
                    }
            }
        }
    }

    return TermInput;
});