https://riversideca.gov/js/corweb/drupal.js

1
2var Drupal = Drupal || { 'settings': {}, 'behaviors': {}, 'locale': {} };
3
4// Allow other JavaScript libraries to use $.
5jQuery.noConflict();
6
7(function ($) {
8
9/**
10 * Override jQuery.fn.init to guard against XSS attacks.
11 *
12 * See http://bugs.jquery.com/ticket/9521
13 */
14var jquery_init = $.fn.init;
15$.fn.init = function (selector, context, rootjQuery) {
16  // If the string contains a "#" before a "<", treat it as invalid HTML.
17  if (selector && typeof selector === 'string') {
18    var hash_position = selector.indexOf('#');
19    if (hash_position >= 0) {
20      var bracket_position = selector.indexOf('<');
21      if (bracket_position > hash_position) {
22        throw 'Syntax error, unrecognized expression: ' + selector;
23      }
24    }
25  }
26  return jquery_init.call(this, selector, context, rootjQuery);
27};
28$.fn.init.prototype = jquery_init.prototype;
29
30/**
31 * Attach all registered behaviors to a page element.
32 *
33 * Behaviors are event-triggered actions that attach to page elements, enhancing
34 * default non-JavaScript UIs. Behaviors are registered in the Drupal.behaviors
35 * object using the method 'attach' and optionally also 'detach' as follows:
36 * @code
37 *    Drupal.behaviors.behaviorName = {
38 *      attach: function (context, settings) {
39 *        ...
40 *      },
41 *      detach: function (context, settings, trigger) {
42 *        ...
43 *      }
44 *    };
45 * @endcode
46 *
47 * Drupal.attachBehaviors is added below to the jQuery ready event and so
48 * runs on initial page load. Developers implementing AHAH/Ajax in their
49 * solutions should also call this function after new page content has been
50 * loaded, feeding in an element to be processed, in order to attach all
51 * behaviors to the new content.
52 *
53 * Behaviors should use
54 * @code
55 *   $(selector).once('behavior-name', function () {
56 *     ...
57 *   });
58 * @endcode
59 * to ensure the behavior is attached only once to a given element. (Doing so
60 * enables the reprocessing of given elements, which may be needed on occasion
61 * despite the ability to limit behavior attachment to a particular element.)
62 *
63 * @param context
64 *   An element to attach behaviors to. If none is given, the document element
65 *   is used.
66 * @param settings
67 *   An object containing settings for the current context. If none given, the
68 *   global Drupal.settings object is used.
69 */
70Drupal.attachBehaviors = function (context, settings) {
71  context = context || document;
72  settings = settings || Drupal.settings;
73  // Execute all of them.
74  $.each(Drupal.behaviors, function () {
75    if ($.isFunction(this.attach)) {
76      this.attach(context, settings);
77    }
78  });
79};
80
81/**
82 * Detach registered behaviors from a page element.
83 *
84 * Developers implementing AHAH/Ajax in their solutions should call this
85 * function before page content is about to be removed, feeding in an element
86 * to be processed, in order to allow special behaviors to detach from the
87 * content.
88 *
89 * Such implementations should look for the class name that was added in their
90 * corresponding Drupal.behaviors.behaviorName.attach implementation, i.e.
91 * behaviorName-processed, to ensure the behavior is detached only from
92 * previously processed elements.
93 *
94 * @param context
95 *   An element to detach behaviors from. If none is given, the document element
96 *   is used.
97 * @param settings
98 *   An object containing settings for the current context. If none given, the
99 *   global Drupal.settings object is used.
100 * @param trigger
101 *   A string containing what's causing the behaviors to be detached. The
102 *   possible triggers are:
103 *   - unload: (default) The context element is being removed from the DOM.
104 *   - move: The element is about to be moved within the DOM (for example,
105 *     during a tabledrag row swap). After the move is completed,
106 *     Drupal.attachBehaviors() is called, so that the behavior can undo
107 *     whatever it did in response to the move. Many behaviors won't need to
108 *     do anything simply in response to the element being moved, but because
109 *     IFRAME elements reload their "src" when being moved within the DOM,
110 *     behaviors bound to IFRAME elements (like WYSIWYG editors) may need to
111 *     take some action.
112 *   - serialize: When an Ajax form is submitted, this is called with the
113 *     form as the context. This provides every behavior within the form an
114 *     opportunity to ensure that the field elements have correct content
115 *     in them before the form is serialized. The canonical use-case is so
116 *     that WYSIWYG editors can update the hidden textarea to which they are
117 *     bound.
118 *
119 * @see Drupal.attachBehaviors
120 */
121Drupal.detachBehaviors = function (context, settings, trigger) {
122  context = context || document;
123  settings = settings || Drupal.settings;
124  trigger = trigger || 'unload';
125  // Execute all of them.
126  $.each(Drupal.behaviors, function () {
127    if ($.isFunction(this.detach)) {
128      this.detach(context, settings, trigger);
129    }
130  });
131};
132
133/**
134 * Encode special characters in a plain-text string for display as HTML.
135 *
136 * @ingroup sanitization
137 */
138Drupal.checkPlain = function (str) {
139  var character, regex,
140      replace = { '&': '&amp;', '"': '&quot;', '<': '&lt;', '>': '&gt;' };
141  str = String(str);
142  for (character in replace) {
143    if (replace.hasOwnProperty(character)) {
144      regex = new RegExp(character, 'g');
145      str = str.replace(regex, replace[character]);
146    }
147  }
148  return str;
149};
150
151/**
152 * Replace placeholders with sanitized values in a string.
153 *
154 * @param str
155 *   A string with placeholders.
156 * @param args
157 *   An object of replacements pairs to make. Incidences of any key in this
158 *   array are replaced with the corresponding value. Based on the first
159 *   character of the key, the value is escaped and/or themed:
160 *    - !variable: inserted as is
161 *    - @variable: escape plain text to HTML (Drupal.checkPlain)
162 *    - %variable: escape text and theme as a placeholder for user-submitted
163 *      content (checkPlain + Drupal.theme('placeholder'))
164 *
165 * @see Drupal.t()
166 * @ingroup sanitization
167 */
168Drupal.formatString = function(str, args) {
169  // Transform arguments before inserting them.
170  for (var key in args) {
171    if (args.hasOwnProperty(key)) {
172      switch (key.charAt(0)) {
173        // Escaped only.
174        case '@':
175          args[key] = Drupal.checkPlain(args[key]);
176          break;
177        // Pass-through.
178        case '!':
179          break;
180        // Escaped and placeholder.
181        default:
182          args[key] = Drupal.theme('placeholder', args[key]);
183          break;
184      }
185    }
186  }
187
188  return Drupal.stringReplace(str, args, null);
189};
190
191/**
192 * Replace substring.
193 *
194 * The longest keys will be tried first. Once a substring has been replaced,
195 * its new value will not be searched again.
196 *
197 * @param {String} str
198 *   A string with placeholders.
199 * @param {Object} args
200 *   Key-value pairs.
201 * @param {Array|null} keys
202 *   Array of keys from the "args".  Internal use only.
203 *
204 * @return {String}
205 *   Returns the replaced string.
206 */
207Drupal.stringReplace = function (str, args, keys) {
208  if (str.length === 0) {
209    return str;
210  }
211
212  // If the array of keys is not passed then collect the keys from the args.
213  if (!$.isArray(keys)) {
214    keys = [];
215    for (var k in args) {
216      if (args.hasOwnProperty(k)) {
217        keys.push(k);
218      }
219    }
220
221    // Order the keys by the character length. The shortest one is the first.
222    keys.sort(function (a, b) { return a.length - b.length; });
223  }
224
225  if (keys.length === 0) {
226    return str;
227  }
228
229  // Take next longest one from the end.
230  var key = keys.pop();
231  var fragments = str.split(key);
232
233  if (keys.length) {
234    for (var i = 0; i < fragments.length; i++) {
235      // Process each fragment with a copy of remaining keys.
236      fragments[i] = Drupal.stringReplace(fragments[i], args, keys.slice(0));
237    }
238  }
239
240  return fragments.join(args[key]);
241};
242
243/**
244 * Translate strings to the page language or a given language.
245 *
246 * See the documentation of the server-side t() function for further details.
247 *
248 * @param str
249 *   A string containing the English string to translate.
250 * @param args
251 *   An object of replacements pairs to make after translation. Incidences
252 *   of any key in this array are replaced with the corresponding value.
253 *   See Drupal.formatString().
254 *
255 * @param options
256 *   - 'context' (defaults to the empty context): The context the source string
257 *     belongs to.
258 *
259 * @return
260 *   The translated string.
261 */
262Drupal.t = function (str, args, options) {
263  options = options || {};
264  options.context = options.context || '';
265
266  // Fetch the localized version of the string.
267  if (Drupal.locale.strings && Drupal.locale.strings[options.context] && Drupal.locale.strings[options.context][str]) {
268    str = Drupal.locale.strings[options.context][str];
269  }
270
271  if (args) {
272    str = Drupal.formatString(str, args);
273  }
274  return str;
275};
276
277/**
278 * Format a string containing a count of items.
279 *
280 * This function ensures that the string is pluralized correctly. Since Drupal.t() is
281 * called by this function, make sure not to pass already-localized strings to it.
282 *
283 * See the documentation of the server-side format_plural() function for further details.
284 *
285 * @param count
286 *   The item count to display.
287 * @param singular
288 *   The string for the singular case. Please make sure it is clear this is
289 *   singular, to ease translation (e.g. use "1 new comment" instead of "1 new").
290 *   Do not use @count in the singular string.
291 * @param plural
292 *   The string for the plural case. Please make sure it is clear this is plural,
293 *   to ease translation. Use @count in place of the item count, as in "@count
294 *   new comments".
295 * @param args
296 *   An object of replacements pairs to make after translation. Incidences
297 *   of any key in this array are replaced with the corresponding value.
298 *   See Drupal.formatString().
299 *   Note that you do not need to include @count in this array.
300 *   This replacement is done automatically for the plural case.
301 * @param options
302 *   The options to pass to the Drupal.t() function.
303 * @return
304 *   A translated string.
305 */
306Drupal.formatPlural = function (count, singular, plural, args, options) {
307  args = args || {};
308  args['@count'] = count;
309  // Determine the index of the plural form.
310  var index = Drupal.locale.pluralFormula ? Drupal.locale.pluralFormula(args['@count']) : ((args['@count'] == 1) ? 0 : 1);
311
312  if (index == 0) {
313    return Drupal.t(singular, args, options);
314  }
315  else if (index == 1) {
316    return Drupal.t(plural, args, options);
317  }
318  else {
319    args['@count[' + index + ']'] = args['@count'];
320    delete args['@count'];
321    return Drupal.t(plural.replace('@count', '@count[' + index + ']'), args, options);
322  }
323};
324
325/**
326 * Returns the passed in URL as an absolute URL.
327 *
328 * @param url
329 *   The URL string to be normalized to an absolute URL.
330 *
331 * @return
332 *   The normalized, absolute URL.
333 *
334 * @see https://github.com/angular/angular.js/blob/v1.4.4/src/ng/urlUtils.js
335 * @see https://grack.com/blog/2009/11/17/absolutizing-url-in-javascript
336 * @see https://github.com/jquery/jquery-ui/blob/1.11.4/ui/tabs.js#L53
337 */
338Drupal.absoluteUrl = function (url) {
339  var urlParsingNode = document.createElement('a');
340
341  // Decode the URL first; this is required by IE <= 6. Decoding non-UTF-8
342  // strings may throw an exception.
343  try {
344    url = decodeURIComponent(url);
345  } catch (e) {}
346
347  urlParsingNode.setAttribute('href', url);
348

349  // IE <= 7 normalizes the URL when assigned to the anchor node similar to
350  // the other browsers.
351  return urlParsingNode.cloneNode(false).href;
352};
353
354/**
355 * Returns true if the URL is within Drupal's base path.
356 *
357 * @param url
358 *   The URL string to be tested.
359 *
360 * @return
361 *   Boolean true if local.
362 *
363 * @see https://github.com/jquery/jquery-ui/blob/1.11.4/ui/tabs.js#L58
364 */
365Drupal.urlIsLocal = function (url) {
366  // Always use browser-derived absolute URLs in the comparison, to avoid
367  // attempts to break out of the base path using directory traversal.
368  var absoluteUrl = Drupal.absoluteUrl(url);
369  var protocol = location.protocol;
370
371  // Consider URLs that match this site's base URL but use HTTPS instead of HTTP
372  // as local as well.
373  if (protocol === 'http:' && absoluteUrl.indexOf('https:') === 0) {
374    protocol = 'https:';
375  }
376  var baseUrl = protocol + '//' + location.host + Drupal.settings.basePath.slice(0, -1);
377
378  // Decoding non-UTF-8 strings may throw an exception.
379  try {
380    absoluteUrl = decodeURIComponent(absoluteUrl);
381  } catch (e) {}
382  try {
383    baseUrl = decodeURIComponent(baseUrl);
384  } catch (e) {}
385
386  // The given URL matches the site's base URL, or has a path under the site's
387  // base URL.
388  return absoluteUrl === baseUrl || absoluteUrl.indexOf(baseUrl + '/') === 0;
389};
390
391/**
392 * Generate the themed representation of a Drupal object.
393 *
394 * All requests for themed output must go through this function. It examines
395 * the request and routes it to the appropriate theme function. If the current
396 * theme does not provide an override function, the generic theme function is
397 * called.
398 *
399 * For example, to retrieve the HTML for text that should be emphasized and
400 * displayed as a placeholder inside a sentence, call
401 * Drupal.theme('placeholder', text).
402 *
403 * @param func
404 *   The name of the theme function to call.
405 * @param ...
406 *   Additional arguments to pass along to the theme function.
407 * @return
408 *   Any data the theme function returns. This could be a plain HTML string,
409 *   but also a complex object.
410 */
411Drupal.theme = function (func) {
412  var args = Array.prototype.slice.apply(arguments, [1]);
413
414  return (Drupal.theme[func] || Drupal.theme.prototype[func]).apply(this, args);
415};
416
417/**
418 * Freeze the current body height (as minimum height). Used to prevent
419 * unnecessary upwards scrolling when doing DOM manipulations.
420 */
421Drupal.freezeHeight = function () {
422  Drupal.unfreezeHeight();
423  $('<div id="freeze-height"></div>').css({
424    position: 'absolute',
425    top: '0px',
426    left: '0px',
427    width: '1px',
428    height: $('body').css('height')
429  }).appendTo('body');
430};
431
432/**
433 * Unfreeze the body height.
434 */
435Drupal.unfreezeHeight = function () {
436  $('#freeze-height').remove();
437};
438
439/**
440 * Encodes a Drupal path for use in a URL.
441 *
442 * For aesthetic reasons slashes are not escaped.
443 */
444Drupal.encodePath = function (item, uri) {
445  uri = uri || location.href;
446  return encodeURIComponent(item).replace(/%2F/g, '/');
447};
448
449/**
450 * Get the text selection in a textarea.
451 */
452Drupal.getSelection = function (element) {
453  if (typeof element.selectionStart != 'number' && document.selection) {
454    // The current selection.
455    var range1 = document.selection.createRange();
456    var range2 = range1.duplicate();
457    // Select all text.
458    range2.moveToElementText(element);
459    // Now move 'dummy' end point to end point of original range.
460    range2.setEndPoint('EndToEnd', range1);
461    // Now we can calculate start and end points.
462    var start = range2.text.length - range1.text.length;
463    var end = start + range1.text.length;
464    return { 'start': start, 'end': end };
465  }
466  return { 'start': element.selectionStart, 'end': element.selectionEnd };
467};
468
469/**
470 * Add a global variable which determines if the window is being unloaded.
471 *
472 * This is primarily used by Drupal.displayAjaxError().
473 */
474Drupal.beforeUnloadCalled = false;
475$(window).bind('beforeunload pagehide', function () {
476    Drupal.beforeUnloadCalled = true;
477});
478
479/**
480 * Displays a JavaScript error from an Ajax response when appropriate to do so.
481 */
482Drupal.displayAjaxError = function (message) {
483  // Skip displaying the message if the user deliberately aborted (for example,
484  // by reloading the page or navigating to a different page) while the Ajax
485  // request was still ongoing. See, for example, the discussion at
486  // http://stackoverflow.com/questions/699941/handle-ajax-error-when-a-user-clicks-refresh.
487  if (!Drupal.beforeUnloadCalled) {
488    alert(message);
489  }
490};
491
492/**
493 * Build an error message from an Ajax response.
494 */
495Drupal.ajaxError = function (xmlhttp, uri, customMessage) {
496  var statusCode, statusText, pathText, responseText, readyStateText, message;
497  if (xmlhttp.status) {
498    statusCode = "\n" + Drupal.t("An AJAX HTTP error occurred.") +  "\n" + Drupal.t("HTTP Result Code: !status", {'!status': xmlhttp.status});
499  }
500  else {
501    statusCode = "\n" + Drupal.t("An AJAX HTTP request terminated abnormally.");
502  }
503  statusCode += "\n" + Drupal.t("Debugging information follows.");
504  pathText = "\n" + Drupal.t("Path: !uri", {'!uri': uri} );
505  statusText = '';
506  // In some cases, when statusCode == 0, xmlhttp.statusText may not be defined.
507  // Unfortunately, testing for it with typeof, etc, doesn't seem to catch that
508  // and the test causes an exception. So we need to catch the exception here.
509  try {
510    statusText = "\n" + Drupal.t("StatusText: !statusText", {'!statusText': $.trim(xmlhttp.statusText)});
511  }
512  catch (e) {}
513
514  responseText = '';
515  // Again, we don't have a way to know for sure whether accessing
516  // xmlhttp.responseText is going to throw an exception. So we'll catch it.
517  try {
518    responseText = "\n" + Drupal.t("ResponseText: !responseText", {'!responseText': $.trim(xmlhttp.responseText) } );
519  } catch (e) {}
520
521  // Make the responseText more readable by stripping HTML tags and newlines.
522  responseText = responseText.replace(/<("[^"]*"|'[^']*'|[^'">])*>/gi,"");
523  responseText = responseText.replace(/[\n]+\s+/g,"\n");
524
525  // We don't need readyState except for status == 0.
526  readyStateText = xmlhttp.status == 0 ? ("\n" + Drupal.t("ReadyState: !readyState", {'!readyState': xmlhttp.readyState})) : "";
527
528  // Additional message beyond what the xmlhttp object provides.
529  customMessage = customMessage ? ("\n" + Drupal.t("CustomMessage: !customMessage", {'!customMessage': customMessage})) : "";
530
531  message = statusCode + pathText + statusText + customMessage + responseText + readyStateText;
532  return message;
533};
534
535// Class indicating that JS is enabled; used for styling purpose.
536$('html').addClass('js');
537
538// 'js enabled' cookie.
539document.cookie = 'has_js=1; path=/';
540
541/**
542 * Additions to jQuery.support.
543 */
544$(function () {
545  /**
546   * Boolean indicating whether or not position:fixed is supported.
547   */
548  if (jQuery.support.positionFixed === undefined) {
549    var el = $('<div style="position:fixed; top:10px" />').appendTo(document.body);
550    jQuery.support.positionFixed = el[0].offsetTop === 10;
551    el.remove();
552  }
553});
554
555//Attach all behaviors.
556$(function () {
557  Drupal.attachBehaviors(document, Drupal.settings);
558});
559
560/**
561 * The default themes.
562 */
563Drupal.theme.prototype = {
564
565  /**
566   * Formats text for emphasized display in a placeholder inside a sentence.
567   *
568   * @param str
569   *   The text to format (plain-text).
570   * @return
571   *   The formatted text (html).
572   */
573  placeholder: function (str) {
574    return '<em class="placeholder">' + Drupal.checkPlain(str) + '</em>';
575  }
576};
577
578})(jQuery);