Proyectos de Subversion Moodle

Rev

| Ultima modificación | Ver Log |

Rev Autor Línea Nro. Línea
1 efrain 1
YUI.add('autocomplete-highlighters', function (Y, NAME) {
2
 
3
/**
4
Provides pre-built result highlighters for AutoComplete.
5
 
6
@module autocomplete
7
@submodule autocomplete-highlighters
8
@class AutoCompleteHighlighters
9
@static
10
**/
11
 
12
var YArray    = Y.Array,
13
    Highlight = Y.Highlight,
14
 
15
Highlighters = Y.mix(Y.namespace('AutoCompleteHighlighters'), {
16
    // -- Public Methods -------------------------------------------------------
17
 
18
    /**
19
    Highlights any individual query character that occurs anywhere in a result.
20
    Case-insensitive.
21
 
22
    @method charMatch
23
    @param {String} query Query to match
24
    @param {Array} results Results to highlight
25
    @return {Array} Highlighted results
26
    @static
27
    **/
28
    charMatch: function (query, results, caseSensitive) {
29
        // The caseSensitive parameter is only intended for use by
30
        // charMatchCase(). It's intentionally undocumented.
31
 
32
        var queryChars = YArray.unique((caseSensitive ? query :
33
                query.toLowerCase()).split(''));
34
 
35
        return YArray.map(results, function (result) {
36
            return Highlight.all(result.text, queryChars, {
37
                caseSensitive: caseSensitive
38
            });
39
        });
40
    },
41
 
42
    /**
43
    Case-sensitive version of `charMatch()`.
44
 
45
    @method charMatchCase
46
    @param {String} query Query to match
47
    @param {Array} results Results to highlight
48
    @return {Array} Highlighted results
49
    @static
50
    **/
51
    charMatchCase: function (query, results) {
52
        return Highlighters.charMatch(query, results, true);
53
    },
54
 
55
    /**
56
    Highlights the complete query as a phrase anywhere within a result. Case-
57
    insensitive.
58
 
59
    @method phraseMatch
60
    @param {String} query Query to match
61
    @param {Array} results Results to highlight
62
    @return {Array} Highlighted results
63
    @static
64
    **/
65
    phraseMatch: function (query, results, caseSensitive) {
66
        // The caseSensitive parameter is only intended for use by
67
        // phraseMatchCase(). It's intentionally undocumented.
68
 
69
        return YArray.map(results, function (result) {
70
            return Highlight.all(result.text, [query], {
71
                caseSensitive: caseSensitive
72
            });
73
        });
74
    },
75
 
76
    /**
77
    Case-sensitive version of `phraseMatch()`.
78
 
79
    @method phraseMatchCase
80
    @param {String} query Query to match
81
    @param {Array} results Results to highlight
82
    @return {Array} Highlighted results
83
    @static
84
    **/
85
    phraseMatchCase: function (query, results) {
86
        return Highlighters.phraseMatch(query, results, true);
87
    },
88
 
89
    /**
90
    Highlights the complete query as a phrase at the beginning of a result.
91
    Case-insensitive.
92
 
93
    @method startsWith
94
    @param {String} query Query to match
95
    @param {Array} results Results to highlight
96
    @return {Array} Highlighted results
97
    @static
98
    **/
99
    startsWith: function (query, results, caseSensitive) {
100
        // The caseSensitive parameter is only intended for use by
101
        // startsWithCase(). It's intentionally undocumented.
102
 
103
        return YArray.map(results, function (result) {
104
            return Highlight.all(result.text, [query], {
105
                caseSensitive: caseSensitive,
106
                startsWith   : true
107
            });
108
        });
109
    },
110
 
111
    /**
112
    Case-sensitive version of `startsWith()`.
113
 
114
    @method startsWithCase
115
    @param {String} query Query to match
116
    @param {Array} results Results to highlight
117
    @return {Array} Highlighted results
118
    @static
119
    **/
120
    startsWithCase: function (query, results) {
121
        return Highlighters.startsWith(query, results, true);
122
    },
123
 
124
    /**
125
    Highlights portions of results in which words from the query match either
126
    whole words or parts of words in the result. Non-word characters like
127
    whitespace and certain punctuation are ignored. Case-insensitive.
128
 
129
    @method subWordMatch
130
    @param {String} query Query to match
131
    @param {Array} results Results to highlight
132
    @return {Array} Highlighted results
133
    @static
134
    **/
135
    subWordMatch: function (query, results, caseSensitive) {
136
        // The caseSensitive parameter is only intended for use by
137
        // subWordMatchCase(). It's intentionally undocumented.
138
 
139
        var queryWords = Y.Text.WordBreak.getUniqueWords(query, {
140
            ignoreCase: !caseSensitive
141
        });
142
 
143
        return YArray.map(results, function (result) {
144
            return Highlight.all(result.text, queryWords, {
145
                caseSensitive: caseSensitive
146
            });
147
        });
148
    },
149
 
150
    /**
151
    Case-sensitive version of `subWordMatch()`.
152
 
153
    @method subWordMatchCase
154
    @param {String} query Query to match
155
    @param {Array} results Results to highlight
156
    @return {Array} Highlighted results
157
    @static
158
    **/
159
    subWordMatchCase: function (query, results) {
160
        return Highlighters.subWordMatch(query, results, true);
161
    },
162
 
163
    /**
164
    Highlights individual words in results that are also in the query. Non-word
165
    characters like punctuation are ignored. Case-insensitive.
166
 
167
    @method wordMatch
168
    @param {String} query Query to match
169
    @param {Array} results Results to highlight
170
    @return {Array} Highlighted results
171
    @static
172
    **/
173
    wordMatch: function (query, results, caseSensitive) {
174
        // The caseSensitive parameter is only intended for use by
175
        // wordMatchCase(). It's intentionally undocumented.
176
 
177
        return YArray.map(results, function (result) {
178
            return Highlight.words(result.text, query, {
179
                caseSensitive: caseSensitive
180
            });
181
        });
182
    },
183
 
184
    /**
185
    Case-sensitive version of `wordMatch()`.
186
 
187
    @method wordMatchCase
188
    @param {String} query Query to match
189
    @param {Array} results Results to highlight
190
    @return {Array} Highlighted results
191
    @static
192
    **/
193
    wordMatchCase: function (query, results) {
194
        return Highlighters.wordMatch(query, results, true);
195
    }
196
});
197
 
198
 
199
}, '3.18.1', {"requires": ["array-extras", "highlight-base"]});