trln-chosen-rails 1.30.0.pre.beta → 1.30.0.pre.beta3

data/vendor/assets/javascripts/chosen.proto.js

@@ -0,0 +1,650 @@
+/*
+ * decaffeinate suggestions:
+ * DS101: Remove unnecessary use of Array.from
+ * DS102: Remove unnecessary code created because of implicit returns
+ * DS103: Rewrite code to no longer use __guard__, or convert again using --optional-chaining
+ * DS205: Consider reworking code to avoid use of IIFEs
+ * DS206: Consider reworking classes to avoid initClass
+ * DS207: Consider shorter variations of null checks
+ * Full docs: https://github.com/decaffeinate/decaffeinate/blob/main/docs/suggestions.md
+ */
+(function() {
+  let triggerHtmlEvent = undefined;
+  const Cls = (this.Chosen = class Chosen extends AbstractChosen {
+    static initClass() {
+  
+      triggerHtmlEvent = function(element, eventType) {
+        if (element.dispatchEvent) {  // Modern way:
+          let evt;
+          try {
+            evt = new Event(eventType, {bubbles: true, cancelable: true});
+          } catch (error) {
+            evt = document.createEvent('HTMLEvents');
+            evt.initEvent(eventType, true, true);
+          }
+          return element.dispatchEvent(evt);
+        } else { // Old IE:
+          return element.fireEvent(`on${eventType}`, document.createEventObject());
+        }
+      };
+    }
+
+    setup() {
+      return this.current_selectedIndex = this.form_field.selectedIndex;
+    }
+
+    set_up_html() {
+      const container_classes = ["chosen-container"];
+      container_classes.push("chosen-container-" + (this.is_multiple ? "multi" : "single"));
+      if (this.inherit_select_classes && this.form_field.className) { container_classes.push(this.form_field.className); }
+      if (this.is_rtl) { container_classes.push("chosen-rtl"); }
+
+      const container_props = {
+        'class': container_classes.join(' '),
+        'title': this.form_field.title
+      };
+
+      if (this.form_field.id.length) { container_props.id = this.form_field.id.replace(/[^\w]/g, '_') + "_chosen"; }
+
+      this.container = new Element('div', container_props);
+
+      // CSP without 'unsafe-inline' doesn't allow setting the style attribute directly
+      this.container.setStyle({width: this.container_width()});
+
+      if (this.is_multiple) {
+        this.container.update(this.get_multi_html());
+      } else {
+        this.container.update(this.get_single_html());
+      }
+
+      this.form_field.hide().insert({ after: this.container });
+      this.dropdown = this.container.down('div.chosen-drop');
+
+      this.search_field = this.container.down('input');
+      this.search_results = this.container.down('ul.chosen-results');
+      this.search_field_scale();
+
+      this.search_no_results = this.container.down('li.no-results');
+
+      if (this.is_multiple) {
+        this.search_choices = this.container.down('ul.chosen-choices');
+        this.search_container = this.container.down('li.search-field');
+      } else {
+        this.search_container = this.container.down('div.chosen-search');
+        this.selected_item = this.container.down('.chosen-single');
+      }
+
+      this.results_build();
+      this.set_tab_index();
+      return this.set_label_behavior();
+    }
+
+    on_ready() {
+      return this.form_field.fire("chosen:ready", {chosen: this});
+    }
+
+    register_observers() {
+      this.container.observe("touchstart", evt => this.container_mousedown(evt));
+      this.container.observe("touchend", evt => this.container_mouseup(evt));
+
+      this.container.observe("mousedown", evt => this.container_mousedown(evt));
+      this.container.observe("mouseup", evt => this.container_mouseup(evt));
+      this.container.observe("mouseenter", evt => this.mouse_enter(evt));
+      this.container.observe("mouseleave", evt => this.mouse_leave(evt));
+
+      this.search_results.observe("mouseup", evt => this.search_results_mouseup(evt));
+      this.search_results.observe("mouseover", evt => this.search_results_mouseover(evt));
+      this.search_results.observe("mouseout", evt => this.search_results_mouseout(evt));
+      this.search_results.observe("mousewheel", evt => this.search_results_mousewheel(evt));
+      this.search_results.observe("DOMMouseScroll", evt => this.search_results_mousewheel(evt));
+
+      this.search_results.observe("touchstart", evt => this.search_results_touchstart(evt));
+      this.search_results.observe("touchmove", evt => this.search_results_touchmove(evt));
+      this.search_results.observe("touchend", evt => this.search_results_touchend(evt));
+
+      this.form_field.observe("chosen:updated", evt => this.results_update_field(evt));
+      this.form_field.observe("chosen:activate", evt => this.activate_field(evt));
+      this.form_field.observe("chosen:open", evt => this.container_mousedown(evt));
+      this.form_field.observe("chosen:close", evt => this.close_field(evt));
+
+      this.search_field.observe("blur", evt => this.input_blur(evt));
+      this.search_field.observe("keyup", evt => this.keyup_checker(evt));
+      this.search_field.observe("keydown", evt => this.keydown_checker(evt));
+      this.search_field.observe("focus", evt => this.input_focus(evt));
+      this.search_field.observe("cut", evt => this.clipboard_event_checker(evt));
+      this.search_field.observe("paste", evt => this.clipboard_event_checker(evt));
+
+      if (this.is_multiple) {
+        return this.search_choices.observe("click", evt => this.choices_click(evt));
+      } else {
+        return this.container.observe("click", evt => evt.preventDefault()); // gobble click of anchor
+      }
+    }
+
+    destroy() {
+      this.container.ownerDocument.stopObserving("click", this.click_test_action);
+
+      for (var event of ['chosen:updated', 'chosen:activate', 'chosen:open', 'chosen:close']) {
+        this.form_field.stopObserving(event);
+      }
+
+      this.container.stopObserving();
+      this.search_results.stopObserving();
+      this.search_field.stopObserving();
+      if (this.form_field_label != null) { this.form_field_label.stopObserving(); }
+
+      if (this.is_multiple) {
+        this.search_choices.stopObserving();
+        this.container.select(".search-choice-close").each(choice => choice.stopObserving());
+      } else {
+        this.selected_item.stopObserving();
+      }
+
+      if (this.search_field.tabIndex) {
+        this.form_field.tabIndex = this.search_field.tabIndex;
+      }
+
+      this.container.remove();
+      return this.form_field.show();
+    }
+
+    search_field_disabled() {
+      this.is_disabled = this.form_field.disabled || __guard__(this.form_field.up('fieldset'), x => x.disabled) || false;
+
+      if (this.is_disabled) {
+        this.container.addClassName('chosen-disabled');
+      } else {
+        this.container.removeClassName('chosen-disabled');
+      }
+
+      this.search_field.disabled = this.is_disabled;
+
+      if (!this.is_multiple) {
+        this.selected_item.stopObserving('focus', this.activate_field);
+      }
+
+      if (this.is_disabled) {
+        return this.close_field();
+      } else if (!this.is_multiple) {
+        return this.selected_item.observe('focus', this.activate_field);
+      }
+    }
+
+    container_mousedown(evt) {
+      if (this.is_disabled) { return; }
+
+      if (evt && ['mousedown', 'touchstart'].includes(evt.type) && !this.results_showing) {
+        evt.preventDefault();
+      }
+
+      if (!((evt != null) && evt.target.hasClassName("search-choice-close"))) {
+        if (!this.active_field) {
+          if (this.is_multiple) { this.search_field.clear(); }
+          this.container.ownerDocument.observe("click", this.click_test_action);
+          this.results_show();
+        } else if (!this.is_multiple && evt && ((evt.target === this.selected_item) || evt.target.up("a.chosen-single"))) {
+          this.results_toggle();
+        }
+
+        return this.activate_field();
+      }
+    }
+
+    container_mouseup(evt) {
+      if ((evt.target.nodeName === "ABBR") && !this.is_disabled) { return this.results_reset(evt); }
+    }
+
+    search_results_mousewheel(evt) {
+      let delta = evt.deltaY || -evt.wheelDelta || evt.detail;
+      if (delta != null) {
+        evt.preventDefault();
+        if (evt.type === 'DOMMouseScroll') { delta = delta * 40; }
+        return this.search_results.scrollTop = delta + this.search_results.scrollTop;
+      }
+    }
+
+    blur_test(evt) {
+      if (!this.active_field && this.container.hasClassName("chosen-container-active")) { return this.close_field(); }
+    }
+
+    close_field() {
+      this.container.ownerDocument.stopObserving("click", this.click_test_action);
+
+      this.active_field = false;
+      this.results_hide();
+
+      this.container.removeClassName("chosen-container-active");
+      this.clear_backstroke();
+
+      this.show_search_field_default();
+      this.search_field_scale();
+      return this.search_field.blur();
+    }
+
+    activate_field() {
+      if (this.is_disabled) { return; }
+
+      this.container.addClassName("chosen-container-active");
+      this.active_field = true;
+
+      this.search_field.value = this.get_search_field_value();
+      return this.search_field.focus();
+    }
+
+    test_active_click(evt) {
+      if (evt.target.up('.chosen-container') === this.container) {
+        return this.active_field = true;
+      } else {
+        return this.close_field();
+      }
+    }
+
+    results_build() {
+      this.parsing = true;
+      this.selected_option_count = null;
+
+      this.results_data = SelectParser.select_to_array(this.form_field);
+
+      if (this.is_multiple) {
+        this.search_choices.select("li.search-choice").invoke("remove");
+      } else {
+        this.single_set_selected_text();
+        if (this.disable_search || (this.form_field.options.length <= this.disable_search_threshold)) {
+          this.search_field.readOnly = true;
+          this.container.addClassName("chosen-container-single-nosearch");
+        } else {
+          this.search_field.readOnly = false;
+          this.container.removeClassName("chosen-container-single-nosearch");
+        }
+      }
+
+      this.update_results_content(this.results_option_build({first:true}));
+
+      this.search_field_disabled();
+      this.show_search_field_default();
+      this.search_field_scale();
+
+      return this.parsing = false;
+    }
+
+    result_do_highlight(el) {
+        this.result_clear_highlight();
+
+        this.result_highlight = el;
+        this.result_highlight.addClassName("highlighted");
+
+        const maxHeight = parseInt(this.search_results.getStyle('maxHeight'), 10);
+        const visible_top = this.search_results.scrollTop;
+        const visible_bottom = maxHeight + visible_top;
+
+        const high_top = this.result_highlight.positionedOffset().top;
+        const high_bottom = high_top + this.result_highlight.getHeight();
+
+        if (high_bottom >= visible_bottom) {
+          return this.search_results.scrollTop = (high_bottom - maxHeight) > 0 ? (high_bottom - maxHeight) : 0;
+        } else if (high_top < visible_top) {
+          return this.search_results.scrollTop = high_top;
+        }
+      }
+
+    result_clear_highlight() {
+      if (this.result_highlight) { this.result_highlight.removeClassName('highlighted'); }
+      return this.result_highlight = null;
+    }
+
+    results_show() {
+      if (this.is_multiple && (this.max_selected_options <= this.choices_count())) {
+        this.form_field.fire("chosen:maxselected", {chosen: this});
+        return false;
+      }
+
+      this.container.addClassName("chosen-with-drop");
+      this.results_showing = true;
+
+      this.search_field.focus();
+      this.search_field.value = this.get_search_field_value();
+
+      this.winnow_results();
+      return this.form_field.fire("chosen:showing_dropdown", {chosen: this});
+    }
+
+    update_results_content(content) {
+      return this.search_results.update(content);
+    }
+
+    results_hide() {
+      if (this.results_showing) {
+        this.result_clear_highlight();
+
+        this.container.removeClassName("chosen-with-drop");
+        this.form_field.fire("chosen:hiding_dropdown", {chosen: this});
+      }
+
+      return this.results_showing = false;
+    }
+
+
+    set_tab_index(el) {
+      if (this.form_field.tabIndex) {
+        const ti = this.form_field.tabIndex;
+        this.form_field.tabIndex = -1;
+        return this.search_field.tabIndex = ti;
+      }
+    }
+
+    set_label_behavior() {
+      this.form_field_label = this.form_field.up("label"); // first check for a parent label
+      if ((this.form_field_label == null)) {
+        this.form_field_label = $$(`label[for='${this.form_field.id}']`).first(); //next check for a for=#{id}
+      }
+
+      if (this.form_field_label != null) {
+        return this.form_field_label.observe("click", this.label_click_handler);
+      }
+    }
+
+    show_search_field_default() {
+      if (this.is_multiple && (this.choices_count() < 1) && !this.active_field) {
+        this.search_field.value = this.default_text;
+        return this.search_field.addClassName("default");
+      } else {
+        this.search_field.value = "";
+        return this.search_field.removeClassName("default");
+      }
+    }
+
+    search_results_mouseup(evt) {
+      const target = evt.target.hasClassName("active-result") ? evt.target : evt.target.up(".active-result");
+      if (target) {
+        this.result_highlight = target;
+        this.result_select(evt);
+        return this.search_field.focus();
+      }
+    }
+
+    search_results_mouseover(evt) {
+      const target = evt.target.hasClassName("active-result") ? evt.target : evt.target.up(".active-result");
+      if (target) { return this.result_do_highlight( target ); }
+    }
+
+    search_results_mouseout(evt) {
+      if (evt.target.hasClassName('active-result') || evt.target.up('.active-result')) { return this.result_clear_highlight(); }
+    }
+
+    choice_build(item) {
+      const choice = new Element('li', { class: "search-choice" }).update(`<span>${this.choice_label(item)}</span>`);
+
+      if (item.disabled) {
+        choice.addClassName('search-choice-disabled');
+      } else {
+        const close_link = new Element('a', { href: '#', class: 'search-choice-close', rel: item.array_index });
+        close_link.observe("click", evt => this.choice_destroy_link_click(evt));
+        choice.insert(close_link);
+      }
+
+      return this.search_container.insert({ before: choice });
+    }
+
+    choice_destroy_link_click(evt) {
+      evt.preventDefault();
+      evt.stopPropagation();
+      if (!this.is_disabled) { return this.choice_destroy(evt.target); }
+    }
+
+    choice_destroy(link) {
+      if (this.result_deselect(link.readAttribute("rel"))) {
+        if (this.active_field) {
+          this.search_field.focus();
+        } else {
+          this.show_search_field_default();
+        }
+
+        if (this.is_multiple && (this.choices_count() > 0) && (this.get_search_field_value().length < 1)) { this.results_hide(); }
+
+        link.up('li').remove();
+
+        return this.search_field_scale();
+      }
+    }
+
+    results_reset() {
+      this.reset_single_select_options();
+      this.form_field.options[0].selected = true;
+      this.single_set_selected_text();
+      this.show_search_field_default();
+      this.results_reset_cleanup();
+      this.trigger_form_field_change();
+      if (this.active_field) { return this.results_hide(); }
+    }
+
+    results_reset_cleanup() {
+      this.current_selectedIndex = this.form_field.selectedIndex;
+      const deselect_trigger = this.selected_item.down("abbr");
+      if(deselect_trigger) { return deselect_trigger.remove(); }
+    }
+
+    result_select(evt) {
+      if (this.result_highlight) {
+        const high = this.result_highlight;
+        this.result_clear_highlight();
+
+        if (this.is_multiple && (this.max_selected_options <= this.choices_count())) {
+          this.form_field.fire("chosen:maxselected", {chosen: this});
+          return false;
+        }
+
+        if (this.is_multiple) {
+          high.removeClassName("active-result");
+        } else {
+          this.reset_single_select_options();
+        }
+
+        high.addClassName("result-selected");
+
+        const item = this.results_data[ high.getAttribute("data-option-array-index") ];
+        item.selected = true;
+
+        this.form_field.options[item.options_index].selected = true;
+        this.selected_option_count = null;
+
+        if (this.is_multiple) {
+          this.choice_build(item);
+        } else {
+          this.single_set_selected_text(this.choice_label(item));
+        }
+
+        if (this.is_multiple && (!this.hide_results_on_select || (evt.metaKey || evt.ctrlKey))) {
+          if (evt.metaKey || evt.ctrlKey) {
+            this.winnow_results({skip_highlight: true});
+          } else {
+            this.search_field.value = "";
+            this.winnow_results();
+          }
+        } else {
+          this.results_hide();
+          this.show_search_field_default();
+        }
+
+        if (this.is_multiple || (this.form_field.selectedIndex !== this.current_selectedIndex)) { this.trigger_form_field_change(); }
+        this.current_selectedIndex = this.form_field.selectedIndex;
+
+        evt.preventDefault();
+
+        return this.search_field_scale();
+      }
+    }
+
+    single_set_selected_text(text) {
+      if (text == null) { text = this.default_text; }
+      if (text === this.default_text) {
+        this.selected_item.addClassName("chosen-default");
+      } else {
+        this.single_deselect_control_build();
+        this.selected_item.removeClassName("chosen-default");
+      }
+
+      return this.selected_item.down("span").update(text);
+    }
+
+    result_deselect(pos) {
+      const result_data = this.results_data[pos];
+
+      if (!this.form_field.options[result_data.options_index].disabled) {
+        result_data.selected = false;
+
+        this.form_field.options[result_data.options_index].selected = false;
+        this.selected_option_count = null;
+
+        this.result_clear_highlight();
+        if (this.results_showing) { this.winnow_results(); }
+
+        this.trigger_form_field_change();
+        this.search_field_scale();
+        return true;
+      } else {
+        return false;
+      }
+    }
+
+    single_deselect_control_build() {
+      if (!this.allow_single_deselect) { return; }
+      if (!this.selected_item.down("abbr")) { this.selected_item.down("span").insert({ after: "<abbr class=\"search-choice-close\"></abbr>" }); }
+      return this.selected_item.addClassName("chosen-single-with-deselect");
+    }
+
+    get_search_field_value() {
+      return this.search_field.value;
+    }
+
+    get_search_text() {
+      return this.get_search_field_value().strip();
+    }
+
+    escape_html(text) {
+      return text.escapeHTML();
+    }
+
+    winnow_results_set_highlight() {
+      let do_high;
+      if (!this.is_multiple) {
+        do_high = this.search_results.down(".result-selected.active-result");
+      }
+
+      if ((do_high == null)) {
+        do_high = this.search_results.down(".active-result");
+      }
+
+      if (do_high != null) { return this.result_do_highlight(do_high); }
+    }
+
+    no_results(terms) {
+      this.search_results.insert(this.get_no_results_html(terms));
+      return this.form_field.fire("chosen:no_results", {chosen: this});
+    }
+
+    no_results_clear() {
+      let nr = null;
+      return (() => {
+        const result = [];
+        while ((nr = this.search_results.down(".no-results"))) {
+          result.push(nr.remove());
+        }
+        return result;
+      })();
+    }
+
+
+    keydown_arrow() {
+      if (this.results_showing && this.result_highlight) {
+        const next_sib = this.result_highlight.next('.active-result');
+        if (next_sib) { return this.result_do_highlight(next_sib); }
+      } else {
+        return this.results_show();
+      }
+    }
+
+    keyup_arrow() {
+      if (!this.results_showing && !this.is_multiple) {
+        return this.results_show();
+      } else if (this.result_highlight) {
+        const sibs = this.result_highlight.previousSiblings();
+        const actives = this.search_results.select("li.active-result");
+        const prevs = sibs.intersect(actives);
+
+        if (prevs.length) {
+          return this.result_do_highlight(prevs.first());
+        } else {
+          if (this.choices_count() > 0) { this.results_hide(); }
+          return this.result_clear_highlight();
+        }
+      }
+    }
+
+    keydown_backstroke() {
+      if (this.pending_backstroke) {
+        this.choice_destroy(this.pending_backstroke.down("a"));
+        return this.clear_backstroke();
+      } else {
+        const next_available_destroy = this.search_container.siblings().last();
+        if (next_available_destroy && next_available_destroy.hasClassName("search-choice") && !next_available_destroy.hasClassName("search-choice-disabled")) {
+          this.pending_backstroke = next_available_destroy;
+          if (this.pending_backstroke) { this.pending_backstroke.addClassName("search-choice-focus"); }
+          if (this.single_backstroke_delete) {
+            return this.keydown_backstroke();
+          } else {
+            return this.pending_backstroke.addClassName("search-choice-focus");
+          }
+        }
+      }
+    }
+
+    clear_backstroke() {
+      if (this.pending_backstroke) { this.pending_backstroke.removeClassName("search-choice-focus"); }
+      return this.pending_backstroke = null;
+    }
+
+    search_field_scale() {
+      let container_width;
+      if (!this.is_multiple) { return; }
+
+      const style_block = {
+        position: 'absolute',
+        left: '-1000px',
+        top: '-1000px',
+        display: 'none',
+        whiteSpace: 'pre'
+      };
+
+      const styles = ['fontSize', 'fontStyle', 'fontWeight', 'fontFamily', 'lineHeight', 'textTransform', 'letterSpacing'];
+
+      for (var style of Array.from(styles)) {
+        style_block[style] = this.search_field.getStyle(style);
+      }
+
+      const div = new Element('div').update(this.escape_html(this.get_search_field_value()));
+      // CSP without 'unsafe-inline' doesn't allow setting the style attribute directly
+      div.setStyle(style_block);
+      document.body.appendChild(div);
+
+      let width = div.measure('width') + 25;
+      div.remove();
+
+      if (container_width = this.container.getWidth()) {
+        width = Math.min(container_width - 10, width);
+      }
+
+      return this.search_field.setStyle({width: width + 'px'});
+    }
+
+    trigger_form_field_change() {
+      triggerHtmlEvent(this.form_field, 'input');
+      return triggerHtmlEvent(this.form_field, 'change');
+    }
+  });
+  Cls.initClass();
+  return Cls;
+})();
+
+function __guard__(value, transform) {
+  return (typeof value !== 'undefined' && value !== null) ? transform(value) : undefined;
+}