← Back to branch summary

~michael.nelson/ubuntu-webcatalog/1267731-import-sca-apps-error

« back to all changes in this revision

Viewing changes to src/webcatalog/static/yui/3.10.3/build/autocomplete-highlighters/autocomplete-highlighters-debug.js

  • Committer: Tarmac
  • Author(s): Stephen Stewart
  • Date: 2013-06-26 09:19:32 UTC
  • mfrom: (184.1.4 ubuntu-global-nav)
  • Revision ID: tarmac-20130626091932-8urtuli368k8p7ds
[r=beuno,jonas-drange] add ubuntu global nav to apps.ubuntu.com

Show diffs side-by-side

added added

removed removed

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