stimulus_reflex 3.5.0.pre9 → 3.5.0.rc1

data/app/assets/javascripts/stimulus_reflex.umd.min.js

@@ -1,905 +0,0 @@
-(function(global, factory) {
-  typeof exports === "object" && typeof module !== "undefined" ? factory(exports, require("@hotwired/stimulus"), require("cable_ready"), require("@rails/actioncable")) : typeof define === "function" && define.amd ? define([ "exports", "@hotwired/stimulus", "cable_ready", "@rails/actioncable" ], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, 
-  factory(global.StimulusReflex = {}, global.Stimulus, global.CableReady, global.actioncable));
-})(this, (function(exports, stimulus, CableReady, actioncable) {
-  "use strict";
-  function _interopDefaultLegacy(e) {
-    return e && typeof e === "object" && "default" in e ? e : {
-      default: e
-    };
-  }
-  var CableReady__default = _interopDefaultLegacy(CableReady);
-  const defaultSchema = {
-    reflexAttribute: "data-reflex",
-    reflexPermanentAttribute: "data-reflex-permanent",
-    reflexRootAttribute: "data-reflex-root",
-    reflexSuppressLoggingAttribute: "data-reflex-suppress-logging",
-    reflexDatasetAttribute: "data-reflex-dataset",
-    reflexDatasetAllAttribute: "data-reflex-dataset-all",
-    reflexSerializeFormAttribute: "data-reflex-serialize-form",
-    reflexFormSelectorAttribute: "data-reflex-form-selector",
-    reflexIncludeInnerHtmlAttribute: "data-reflex-include-inner-html",
-    reflexIncludeTextContentAttribute: "data-reflex-include-text-content"
-  };
-  let schema = {};
-  var Schema = {
-    set(application) {
-      schema = {
-        ...defaultSchema,
-        ...application.schema
-      };
-      for (const attribute in schema) {
-        Object.defineProperty(this, attribute.slice(0, -9), {
-          get: () => schema[attribute]
-        });
-      }
-    }
-  };
-  let debugging = false;
-  var Debug$1 = {
-    get enabled() {
-      return debugging;
-    },
-    get disabled() {
-      return !debugging;
-    },
-    get value() {
-      return debugging;
-    },
-    set(value) {
-      debugging = !!value;
-    },
-    set debug(value) {
-      debugging = !!value;
-    }
-  };
-  const reflexes = {};
-  const request = (reflexId, target, args, controller, element, controllerElement) => {
-    const reflex = reflexes[reflexId];
-    if (Debug$1.disabled || reflex.promise.data.suppressLogging) return;
-    reflex.timestamp = new Date;
-    console.log(`↑ stimulus ↑ ${target}`, {
-      reflexId: reflexId,
-      args: args,
-      controller: controller,
-      element: element,
-      controllerElement: controllerElement
-    });
-  };
-  const success = (event, halted) => {
-    const {detail: detail} = event || {};
-    const {selector: selector, payload: payload} = detail || {};
-    const {reflexId: reflexId, target: target, morph: morph} = detail.stimulusReflex || {};
-    const reflex = reflexes[reflexId];
-    if (Debug$1.disabled || reflex.promise.data.suppressLogging) return;
-    const progress = reflex.totalOperations > 1 ? ` ${reflex.completedOperations}/${reflex.totalOperations}` : "";
-    const duration = reflex.timestamp ? `in ${new Date - reflex.timestamp}ms` : "CLONED";
-    const operation = event.type.split(":")[1].split("-").slice(1).join("_");
-    console.log(`↓ reflex ↓ ${target} → ${selector || "∞"}${progress} ${duration}`, {
-      reflexId: reflexId,
-      morph: morph,
-      operation: operation,
-      halted: halted,
-      payload: payload
-    });
-  };
-  const error$1 = event => {
-    const {detail: detail} = event || {};
-    const {reflexId: reflexId, target: target, payload: payload} = detail.stimulusReflex || {};
-    const reflex = reflexes[reflexId];
-    if (Debug$1.disabled || reflex.promise.data.suppressLogging) return;
-    const duration = reflex.timestamp ? `in ${new Date - reflex.timestamp}ms` : "CLONED";
-    console.log(`↓ reflex ↓ ${target} ${duration} %cERROR: ${event.detail.body}`, "color: #f00;", {
-      reflexId: reflexId,
-      payload: payload
-    });
-  };
-  var Log = {
-    request: request,
-    success: success,
-    error: error$1
-  };
-  let deprecationWarnings = true;
-  var Deprecate = {
-    get enabled() {
-      return deprecationWarnings;
-    },
-    get disabled() {
-      return !deprecationWarnings;
-    },
-    get value() {
-      return deprecationWarnings;
-    },
-    set(value) {
-      deprecationWarnings = !!value;
-    },
-    set deprecate(value) {
-      deprecationWarnings = !!value;
-    }
-  };
-  const uuidv4 = () => {
-    const crypto = window.crypto || window.msCrypto;
-    return ([ 1e7 ] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c => (c ^ crypto.getRandomValues(new Uint8Array(1))[0] & 15 >> c / 4).toString(16)));
-  };
-  const serializeForm = (form, options = {}) => {
-    if (!form) return "";
-    const w = options.w || window;
-    const {element: element} = options;
-    const formData = new w.FormData(form);
-    const data = Array.from(formData, (e => e.map(encodeURIComponent).join("=")));
-    const submitButton = form.querySelector("input[type=submit]");
-    if (element && element.name && element.nodeName === "INPUT" && element.type === "submit") {
-      data.push(`${encodeURIComponent(element.name)}=${encodeURIComponent(element.value)}`);
-    } else if (submitButton && submitButton.name) {
-      data.push(`${encodeURIComponent(submitButton.name)}=${encodeURIComponent(submitButton.value)}`);
-    }
-    return Array.from(data).join("&");
-  };
-  const camelize = (value, uppercaseFirstLetter = true) => {
-    if (typeof value !== "string") return "";
-    value = value.replace(/[\s_](.)/g, ($1 => $1.toUpperCase())).replace(/[\s_]/g, "").replace(/^(.)/, ($1 => $1.toLowerCase()));
-    if (uppercaseFirstLetter) value = value.substr(0, 1).toUpperCase() + value.substr(1);
-    return value;
-  };
-  const debounce = (callback, delay = 250) => {
-    let timeoutId;
-    return (...args) => {
-      clearTimeout(timeoutId);
-      timeoutId = setTimeout((() => {
-        timeoutId = null;
-        callback(...args);
-      }), delay);
-    };
-  };
-  const extractReflexName = reflexString => {
-    const match = reflexString.match(/(?:.*->)?(.*?)(?:Reflex)?#/);
-    return match ? match[1] : "";
-  };
-  const emitEvent = (event, detail) => {
-    document.dispatchEvent(new CustomEvent(event, {
-      bubbles: true,
-      cancelable: false,
-      detail: detail
-    }));
-    if (window.jQuery) window.jQuery(document).trigger(event, detail);
-  };
-  const elementToXPath = element => {
-    if (element.id !== "") return "//*[@id='" + element.id + "']";
-    if (element === document.body) return "/html/body";
-    let ix = 0;
-    const siblings = element?.parentNode ? element.parentNode.childNodes : [];
-    for (var i = 0; i < siblings.length; i++) {
-      const sibling = siblings[i];
-      if (sibling === element) {
-        const computedPath = elementToXPath(element.parentNode);
-        const tagName = element.tagName.toLowerCase();
-        const ixInc = ix + 1;
-        return `${computedPath}/${tagName}[${ixInc}]`;
-      }
-      if (sibling.nodeType === 1 && sibling.tagName === element.tagName) {
-        ix++;
-      }
-    }
-  };
-  const XPathToElement = xpath => document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
-  const XPathToArray = (xpath, reverse = false) => {
-    const snapshotList = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-    const snapshots = [];
-    for (let i = 0; i < snapshotList.snapshotLength; i++) {
-      snapshots.push(snapshotList.snapshotItem(i));
-    }
-    return reverse ? snapshots.reverse() : snapshots;
-  };
-  const multipleInstances = element => {
-    if ([ "checkbox", "radio" ].includes(element.type)) {
-      return document.querySelectorAll(`input[type="${element.type}"][name="${element.name}"]`).length > 1;
-    }
-    return false;
-  };
-  const collectCheckedOptions = element => Array.from(element.querySelectorAll("option:checked")).concat(Array.from(document.querySelectorAll(`input[type="${element.type}"][name="${element.name}"]`)).filter((elem => elem.checked))).map((o => o.value));
-  const attributeValue = (values = []) => {
-    const value = values.filter((v => v && String(v).length)).map((v => v.trim())).join(" ").trim();
-    return value.length ? value : null;
-  };
-  const attributeValues = value => {
-    if (!value) return [];
-    if (!value.length) return [];
-    return value.split(" ").filter((v => v.trim().length));
-  };
-  const extractElementAttributes = element => {
-    let attrs = Array.from(element.attributes).reduce(((memo, attr) => {
-      memo[attr.name] = attr.value;
-      return memo;
-    }), {});
-    attrs.checked = !!element.checked;
-    attrs.selected = !!element.selected;
-    attrs.tag_name = element.tagName;
-    if (element.tagName.match(/select/i) || multipleInstances(element)) {
-      const collectedOptions = collectCheckedOptions(element);
-      attrs.values = collectedOptions;
-      attrs.value = collectedOptions.join(",");
-    } else {
-      attrs.value = element.value;
-    }
-    return attrs;
-  };
-  const getElementsFromTokens = (element, tokens) => {
-    if (!tokens || tokens.length === 0) return [];
-    let elements = [ element ];
-    const xPath = elementToXPath(element);
-    tokens.forEach((token => {
-      try {
-        switch (token) {
-         case "combined":
-          if (Deprecate.enabled) console.warn("In the next version of StimulusReflex, the 'combined' option to data-reflex-dataset will become 'ancestors'.");
-          elements = [ ...elements, ...XPathToArray(`${xPath}/ancestor::*`, true) ];
-          break;
-
-         case "ancestors":
-          elements = [ ...elements, ...XPathToArray(`${xPath}/ancestor::*`, true) ];
-          break;
-
-         case "parent":
-          elements = [ ...elements, ...XPathToArray(`${xPath}/parent::*`) ];
-          break;
-
-         case "siblings":
-          elements = [ ...elements, ...XPathToArray(`${xPath}/preceding-sibling::*|${xPath}/following-sibling::*`) ];
-          break;
-
-         case "children":
-          elements = [ ...elements, ...XPathToArray(`${xPath}/child::*`) ];
-          break;
-
-         case "descendants":
-          elements = [ ...elements, ...XPathToArray(`${xPath}/descendant::*`) ];
-          break;
-
-         default:
-          elements = [ ...elements, ...document.querySelectorAll(token) ];
-        }
-      } catch (error) {
-        if (Debug$1.enabled) console.error(error);
-      }
-    }));
-    return elements;
-  };
-  const extractElementDataset = element => {
-    const dataset = element.attributes[Schema.reflexDataset];
-    const allDataset = element.attributes[Schema.reflexDatasetAll];
-    const tokens = dataset && dataset.value.split(" ") || [];
-    const allTokens = allDataset && allDataset.value.split(" ") || [];
-    const datasetElements = getElementsFromTokens(element, tokens);
-    const datasetAllElements = getElementsFromTokens(element, allTokens);
-    const datasetAttributes = datasetElements.reduce(((acc, ele) => ({
-      ...extractDataAttributes(ele),
-      ...acc
-    })), {});
-    const reflexElementAttributes = extractDataAttributes(element);
-    const elementDataset = {
-      dataset: {
-        ...reflexElementAttributes,
-        ...datasetAttributes
-      },
-      datasetAll: {}
-    };
-    datasetAllElements.forEach((element => {
-      const elementAttributes = extractDataAttributes(element);
-      Object.keys(elementAttributes).forEach((key => {
-        const value = elementAttributes[key];
-        if (elementDataset.datasetAll[key] && Array.isArray(elementDataset.datasetAll[key])) {
-          elementDataset.datasetAll[key].push(value);
-        } else {
-          elementDataset.datasetAll[key] = [ value ];
-        }
-      }));
-    }));
-    return elementDataset;
-  };
-  const extractDataAttributes = element => {
-    let attrs = {};
-    if (element && element.attributes) {
-      Array.from(element.attributes).forEach((attr => {
-        if (attr.name.startsWith("data-")) {
-          attrs[attr.name] = attr.value;
-        }
-      }));
-    }
-    return attrs;
-  };
-  let isolationMode = false;
-  var IsolationMode = {
-    get disabled() {
-      return !isolationMode;
-    },
-    set(value) {
-      isolationMode = value;
-    }
-  };
-  const invokeLifecycleMethod = (stage, reflexElement, controllerElement, reflexId, payload) => {
-    if (!controllerElement || !controllerElement.reflexData[reflexId]) return;
-    const controller = controllerElement.reflexController[reflexId];
-    const reflex = controllerElement.reflexData[reflexId].target;
-    const reflexMethodName = reflex.split("#")[1];
-    const specificLifecycleMethodName = [ "before", "after", "finalize" ].includes(stage) ? `${stage}${camelize(reflexMethodName)}` : `${camelize(reflexMethodName, false)}${camelize(stage)}`;
-    const specificLifecycleMethod = controller[specificLifecycleMethodName];
-    const genericLifecycleMethodName = [ "before", "after", "finalize" ].includes(stage) ? `${stage}Reflex` : `reflex${camelize(stage)}`;
-    const genericLifecycleMethod = controller[genericLifecycleMethodName];
-    if (typeof specificLifecycleMethod === "function") {
-      specificLifecycleMethod.call(controller, reflexElement, reflex, controllerElement.reflexError[reflexId], reflexId, payload);
-    }
-    if (typeof genericLifecycleMethod === "function") {
-      genericLifecycleMethod.call(controller, reflexElement, reflex, controllerElement.reflexError[reflexId], reflexId, payload);
-    }
-    if (reflexes[reflexId] && stage === reflexes[reflexId].finalStage) {
-      Reflect.deleteProperty(controllerElement.reflexController, reflexId);
-      Reflect.deleteProperty(controllerElement.reflexData, reflexId);
-      Reflect.deleteProperty(controllerElement.reflexError, reflexId);
-    }
-  };
-  document.addEventListener("stimulus-reflex:before", (event => invokeLifecycleMethod("before", event.detail.element, event.detail.controller.element, event.detail.reflexId, event.detail.payload)), true);
-  document.addEventListener("stimulus-reflex:success", (event => {
-    invokeLifecycleMethod("success", event.detail.element, event.detail.controller.element, event.detail.reflexId, event.detail.payload);
-    dispatchLifecycleEvent("after", event.detail.element, event.detail.controller.element, event.detail.reflexId, event.detail.payload);
-  }), true);
-  document.addEventListener("stimulus-reflex:nothing", (event => {
-    dispatchLifecycleEvent("success", event.detail.element, event.detail.controller.element, event.detail.reflexId, event.detail.payload);
-  }), true);
-  document.addEventListener("stimulus-reflex:error", (event => {
-    invokeLifecycleMethod("error", event.detail.element, event.detail.controller.element, event.detail.reflexId, event.detail.payload);
-    dispatchLifecycleEvent("after", event.detail.element, event.detail.controller.element, event.detail.reflexId, event.detail.payload);
-  }), true);
-  document.addEventListener("stimulus-reflex:halted", (event => invokeLifecycleMethod("halted", event.detail.element, event.detail.controller.element, event.detail.reflexId, event.detail.payload)), true);
-  document.addEventListener("stimulus-reflex:after", (event => invokeLifecycleMethod("after", event.detail.element, event.detail.controller.element, event.detail.reflexId, event.detail.payload)), true);
-  document.addEventListener("stimulus-reflex:finalize", (event => invokeLifecycleMethod("finalize", event.detail.element, event.detail.controller.element, event.detail.reflexId, event.detail.payload)), true);
-  const dispatchLifecycleEvent = (stage, reflexElement, controllerElement, reflexId, payload) => {
-    if (!controllerElement) {
-      if (Debug$1.enabled && !reflexes[reflexId].warned) {
-        console.warn(`StimulusReflex was not able execute callbacks or emit events for "${stage}" or later life-cycle stages for this Reflex. The StimulusReflex Controller Element is no longer present in the DOM. Could you move the StimulusReflex Controller to an element higher in your DOM?`);
-        reflexes[reflexId].warned = true;
-      }
-      return;
-    }
-    if (!controllerElement.reflexController || controllerElement.reflexController && !controllerElement.reflexController[reflexId]) {
-      if (Debug$1.enabled && !reflexes[reflexId].warned) {
-        console.warn(`StimulusReflex detected that the StimulusReflex Controller responsible for this Reflex has been replaced with a new instance. Callbacks and events for "${stage}" or later life-cycle stages cannot be executed.`);
-        reflexes[reflexId].warned = true;
-      }
-      return;
-    }
-    const {target: target} = controllerElement.reflexData[reflexId] || {};
-    const controller = controllerElement.reflexController[reflexId] || {};
-    const event = `stimulus-reflex:${stage}`;
-    const action = `${event}:${target.split("#")[1]}`;
-    const detail = {
-      reflex: target,
-      controller: controller,
-      reflexId: reflexId,
-      element: reflexElement,
-      payload: payload
-    };
-    const options = {
-      bubbles: true,
-      cancelable: false,
-      detail: detail
-    };
-    controllerElement.dispatchEvent(new CustomEvent(event, options));
-    controllerElement.dispatchEvent(new CustomEvent(action, options));
-    if (window.jQuery) {
-      window.jQuery(controllerElement).trigger(event, detail);
-      window.jQuery(controllerElement).trigger(action, detail);
-    }
-  };
-  const localReflexControllers = (app, element) => attributeValues(element.getAttribute(Schema.controller)).reduce(((memo, name) => {
-    const controller = app.getControllerForElementAndIdentifier(element, name);
-    if (controller && controller.StimulusReflex) memo.push(controller);
-    return memo;
-  }), []);
-  const allReflexControllers = (app, element) => {
-    let controllers = [];
-    while (element) {
-      controllers = controllers.concat(localReflexControllers(app, element));
-      element = element.parentElement;
-    }
-    return controllers;
-  };
-  const findControllerByReflexName = (reflexName, controllers) => {
-    const controller = controllers.find((controller => {
-      if (!controller.identifier) return;
-      return extractReflexName(reflexName).replace(/([a-z0–9])([A-Z])/g, "$1-$2").replace(/(::)/g, "--").toLowerCase() === controller.identifier;
-    }));
-    return controller || controllers[0];
-  };
-  const received = data => {
-    if (!data.cableReady) return;
-    if (data.version.replace(".pre", "-pre") !== CableReady__default["default"].version) {
-      if (Debug$1.enabled) console.error(`Reflex failed due to cable_ready gem/NPM package version mismatch. Package versions must match exactly.\nNote that if you are using pre-release builds, gems use the "x.y.z.preN" version format, while NPM packages use "x.y.z-preN".\n\ncable_ready gem: ${data.version}\ncable_ready NPM: ${CableReady__default["default"].version}`);
-      return;
-    }
-    let reflexOperations = [];
-    for (let i = data.operations.length - 1; i >= 0; i--) {
-      if (data.operations[i].stimulusReflex) {
-        reflexOperations.push(data.operations[i]);
-        data.operations.splice(i, 1);
-      }
-    }
-    if (reflexOperations.some((operation => operation.stimulusReflex.url !== location.href))) {
-      return;
-    }
-    let reflexData;
-    if (reflexOperations.length) {
-      reflexData = reflexOperations[0].stimulusReflex;
-      reflexData.payload = reflexOperations[0].payload;
-    }
-    if (reflexData) {
-      const {reflexId: reflexId, payload: payload} = reflexData;
-      if (!reflexes[reflexId] && IsolationMode.disabled) {
-        const controllerElement = XPathToElement(reflexData.xpathController);
-        const reflexElement = XPathToElement(reflexData.xpathElement);
-        controllerElement.reflexController = controllerElement.reflexController || {};
-        controllerElement.reflexData = controllerElement.reflexData || {};
-        controllerElement.reflexError = controllerElement.reflexError || {};
-        controllerElement.reflexController[reflexId] = reflexes.app.getControllerForElementAndIdentifier(controllerElement, reflexData.reflexController);
-        controllerElement.reflexData[reflexId] = reflexData;
-        dispatchLifecycleEvent("before", reflexElement, controllerElement, reflexId, payload);
-        registerReflex(reflexData);
-      }
-      if (reflexes[reflexId]) {
-        reflexes[reflexId].totalOperations = reflexOperations.length;
-        reflexes[reflexId].pendingOperations = reflexOperations.length;
-        reflexes[reflexId].completedOperations = 0;
-        reflexes[reflexId].piggybackOperations = data.operations;
-        CableReady__default["default"].perform(reflexOperations);
-      }
-    } else {
-      if (data.operations.length && reflexes[data.operations[0].reflexId]) {
-        CableReady__default["default"].perform(data.operations);
-      }
-    }
-  };
-  const registerReflex = data => {
-    const {reflexId: reflexId} = data;
-    reflexes[reflexId] = {
-      finalStage: "finalize"
-    };
-    const promise = new Promise(((resolve, reject) => {
-      reflexes[reflexId].promise = {
-        resolve: resolve,
-        reject: reject,
-        data: data
-      };
-    }));
-    promise.reflexId = reflexId;
-    if (Debug$1.enabled) promise.catch((() => {}));
-    return promise;
-  };
-  const getReflexRoots = element => {
-    let list = [];
-    while (list.length === 0 && element) {
-      let reflexRoot = element.getAttribute(Schema.reflexRoot);
-      if (reflexRoot) {
-        if (reflexRoot.length === 0 && element.id) reflexRoot = `#${element.id}`;
-        const selectors = reflexRoot.split(",").filter((s => s.trim().length));
-        if (Debug$1.enabled && selectors.length === 0) {
-          console.error(`No value found for ${Schema.reflexRoot}. Add an #id to the element or provide a value for ${Schema.reflexRoot}.`, element);
-        }
-        list = list.concat(selectors.filter((s => document.querySelector(s))));
-      }
-      element = element.parentElement ? element.parentElement.closest(`[${Schema.reflexRoot}]`) : null;
-    }
-    return list;
-  };
-  const setupDeclarativeReflexes = debounce((() => {
-    document.querySelectorAll(`[${Schema.reflex}]`).forEach((element => {
-      const controllers = attributeValues(element.getAttribute(Schema.controller));
-      const reflexAttributeNames = attributeValues(element.getAttribute(Schema.reflex));
-      const actions = attributeValues(element.getAttribute(Schema.action));
-      reflexAttributeNames.forEach((reflexName => {
-        const controller = findControllerByReflexName(reflexName, allReflexControllers(reflexes.app, element));
-        let action;
-        if (controller) {
-          action = `${reflexName.split("->")[0]}->${controller.identifier}#__perform`;
-          if (!actions.includes(action)) actions.push(action);
-        } else {
-          action = `${reflexName.split("->")[0]}->stimulus-reflex#__perform`;
-          if (!controllers.includes("stimulus-reflex")) {
-            controllers.push("stimulus-reflex");
-          }
-          if (!actions.includes(action)) actions.push(action);
-        }
-      }));
-      const controllerValue = attributeValue(controllers);
-      const actionValue = attributeValue(actions);
-      if (controllerValue && element.getAttribute(Schema.controller) != controllerValue) {
-        element.setAttribute(Schema.controller, controllerValue);
-      }
-      if (actionValue && element.getAttribute(Schema.action) != actionValue) element.setAttribute(Schema.action, actionValue);
-    }));
-    emitEvent("stimulus-reflex:ready");
-  }), 20);
-  var version = "3.5.0-pre9";
-  class ReflexData {
-    constructor(options, reflexElement, controllerElement, reflexController, permanentAttributeName, target, args, url, tabId) {
-      this.options = options;
-      this.reflexElement = reflexElement;
-      this.controllerElement = controllerElement;
-      this.reflexController = reflexController;
-      this.permanentAttributeName = permanentAttributeName;
-      this.target = target;
-      this.args = args;
-      this.url = url;
-      this.tabId = tabId;
-    }
-    get attrs() {
-      this._attrs = this._attrs || this.options["attrs"] || extractElementAttributes(this.reflexElement);
-      return this._attrs;
-    }
-    get reflexId() {
-      this._reflexId = this._reflexId || this.options["reflexId"] || uuidv4();
-      return this._reflexId;
-    }
-    get selectors() {
-      this._selectors = this._selectors || this.options["selectors"] || getReflexRoots(this.reflexElement);
-      return typeof this._selectors === "string" ? [ this._selectors ] : this._selectors;
-    }
-    get resolveLate() {
-      return this.options["resolveLate"] || false;
-    }
-    get dataset() {
-      this._dataset = this._dataset || extractElementDataset(this.reflexElement);
-      return this._dataset;
-    }
-    get innerHTML() {
-      return this.includeInnerHtml ? this.reflexElement.innerHTML : "";
-    }
-    get textContent() {
-      return this.includeTextContent ? this.reflexElement.textContent : "";
-    }
-    get xpathController() {
-      return elementToXPath(this.controllerElement);
-    }
-    get xpathElement() {
-      return elementToXPath(this.reflexElement);
-    }
-    get formSelector() {
-      const attr = this.reflexElement.attributes[Schema.reflexFormSelector] ? this.reflexElement.attributes[Schema.reflexFormSelector].value : undefined;
-      return this.options["formSelector"] || attr;
-    }
-    get includeInnerHtml() {
-      const attr = this.reflexElement.attributes[Schema.reflexIncludeInnerHtml] || false;
-      return this.options["includeInnerHTML"] || attr ? attr.value !== "false" : false;
-    }
-    get includeTextContent() {
-      const attr = this.reflexElement.attributes[Schema.reflexIncludeTextContent] || false;
-      return this.options["includeTextContent"] || attr ? attr.value !== "false" : false;
-    }
-    get suppressLogging() {
-      return this.options["suppressLogging"] || this.reflexElement.attributes[Schema.reflexSuppressLogging] || false;
-    }
-    valueOf() {
-      return {
-        attrs: this.attrs,
-        dataset: this.dataset,
-        selectors: this.selectors,
-        reflexId: this.reflexId,
-        resolveLate: this.resolveLate,
-        suppressLogging: this.suppressLogging,
-        xpathController: this.xpathController,
-        xpathElement: this.xpathElement,
-        inner_html: this.innerHTML,
-        text_content: this.textContent,
-        formSelector: this.formSelector,
-        reflexController: this.reflexController,
-        permanentAttributeName: this.permanentAttributeName,
-        target: this.target,
-        args: this.args,
-        url: this.url,
-        tabId: this.tabId,
-        version: version
-      };
-    }
-  }
-  let consumer;
-  let params;
-  let subscriptionActive;
-  const createSubscription = controller => {
-    consumer = consumer || controller.application.consumer || actioncable.createConsumer();
-    const {channel: channel} = controller.StimulusReflex;
-    const subscription = {
-      channel: channel,
-      ...params
-    };
-    const identifier = JSON.stringify(subscription);
-    controller.StimulusReflex.subscription = consumer.subscriptions.findAll(identifier)[0] || consumer.subscriptions.create(subscription, {
-      received: received,
-      connected: connected,
-      rejected: rejected,
-      disconnected: disconnected
-    });
-  };
-  const connected = () => {
-    subscriptionActive = true;
-    document.body.classList.replace("stimulus-reflex-disconnected", "stimulus-reflex-connected");
-    emitEvent("stimulus-reflex:connected");
-    emitEvent("stimulus-reflex:action-cable:connected");
-  };
-  const rejected = () => {
-    subscriptionActive = false;
-    document.body.classList.replace("stimulus-reflex-connected", "stimulus-reflex-disconnected");
-    emitEvent("stimulus-reflex:rejected");
-    emitEvent("stimulus-reflex:action-cable:rejected");
-    if (Debug.enabled) console.warn("Channel subscription was rejected.");
-  };
-  const disconnected = willAttemptReconnect => {
-    subscriptionActive = false;
-    document.body.classList.replace("stimulus-reflex-connected", "stimulus-reflex-disconnected");
-    emitEvent("stimulus-reflex:disconnected", willAttemptReconnect);
-    emitEvent("stimulus-reflex:action-cable:disconnected", willAttemptReconnect);
-  };
-  var ActionCableTransport = {
-    consumer: consumer,
-    params: params,
-    get subscriptionActive() {
-      return subscriptionActive;
-    },
-    createSubscription: createSubscription,
-    connected: connected,
-    rejected: rejected,
-    disconnected: disconnected,
-    set(consumerValue, paramsValue) {
-      consumer = consumerValue;
-      params = paramsValue;
-    }
-  };
-  const beforeDOMUpdate = event => {
-    const {stimulusReflex: stimulusReflex, payload: payload} = event.detail || {};
-    if (!stimulusReflex) return;
-    const {reflexId: reflexId, xpathElement: xpathElement, xpathController: xpathController} = stimulusReflex;
-    const controllerElement = XPathToElement(xpathController);
-    const reflexElement = XPathToElement(xpathElement);
-    const reflex = reflexes[reflexId];
-    const {promise: promise} = reflex;
-    reflex.pendingOperations--;
-    if (reflex.pendingOperations > 0) return;
-    if (!stimulusReflex.resolveLate) setTimeout((() => promise.resolve({
-      element: reflexElement,
-      event: event,
-      data: promise.data,
-      payload: payload,
-      reflexId: reflexId,
-      toString: () => ""
-    })));
-    setTimeout((() => dispatchLifecycleEvent("success", reflexElement, controllerElement, reflexId, payload)));
-  };
-  const afterDOMUpdate = event => {
-    const {stimulusReflex: stimulusReflex, payload: payload} = event.detail || {};
-    if (!stimulusReflex) return;
-    const {reflexId: reflexId, xpathElement: xpathElement, xpathController: xpathController} = stimulusReflex;
-    const controllerElement = XPathToElement(xpathController);
-    const reflexElement = XPathToElement(xpathElement);
-    const reflex = reflexes[reflexId];
-    const {promise: promise} = reflex;
-    reflex.completedOperations++;
-    Log.success(event, false);
-    if (reflex.completedOperations < reflex.totalOperations) return;
-    if (stimulusReflex.resolveLate) setTimeout((() => promise.resolve({
-      element: reflexElement,
-      event: event,
-      data: promise.data,
-      payload: payload,
-      reflexId: reflexId,
-      toString: () => ""
-    })));
-    setTimeout((() => dispatchLifecycleEvent("finalize", reflexElement, controllerElement, reflexId, payload)));
-    if (reflex.piggybackOperations.length) CableReady__default["default"].perform(reflex.piggybackOperations);
-  };
-  const routeReflexEvent = event => {
-    const {stimulusReflex: stimulusReflex, payload: payload, name: name, body: body} = event.detail || {};
-    const eventType = name.split("-")[2];
-    if (!stimulusReflex || ![ "nothing", "halted", "error" ].includes(eventType)) return;
-    const {reflexId: reflexId, xpathElement: xpathElement, xpathController: xpathController} = stimulusReflex;
-    const reflexElement = XPathToElement(xpathElement);
-    const controllerElement = XPathToElement(xpathController);
-    const reflex = reflexes[reflexId];
-    const {promise: promise} = reflex;
-    if (controllerElement) {
-      controllerElement.reflexError = controllerElement.reflexError || {};
-      if (eventType === "error") controllerElement.reflexError[reflexId] = body;
-    }
-    switch (eventType) {
-     case "nothing":
-      nothing(event, payload, promise, reflex, reflexElement);
-      break;
-
-     case "error":
-      error(event, payload, promise, reflex, reflexElement);
-      break;
-
-     case "halted":
-      halted(event, payload, promise, reflex, reflexElement);
-      break;
-    }
-    setTimeout((() => dispatchLifecycleEvent(eventType, reflexElement, controllerElement, reflexId, payload)));
-    if (reflex.piggybackOperations.length) CableReady__default["default"].perform(reflex.piggybackOperations);
-  };
-  const nothing = (event, payload, promise, reflex, reflexElement) => {
-    reflex.finalStage = "after";
-    Log.success(event, false);
-    setTimeout((() => promise.resolve({
-      data: promise.data,
-      element: reflexElement,
-      event: event,
-      payload: payload,
-      reflexId: promise.data.reflexId,
-      toString: () => ""
-    })));
-  };
-  const halted = (event, payload, promise, reflex, reflexElement) => {
-    reflex.finalStage = "halted";
-    Log.success(event, true);
-    setTimeout((() => promise.resolve({
-      data: promise.data,
-      element: reflexElement,
-      event: event,
-      payload: payload,
-      reflexId: promise.data.reflexId,
-      toString: () => ""
-    })));
-  };
-  const error = (event, payload, promise, reflex, reflexElement) => {
-    reflex.finalStage = "after";
-    Log.error(event);
-    setTimeout((() => promise.reject({
-      data: promise.data,
-      element: reflexElement,
-      event: event,
-      payload: payload,
-      reflexId: promise.data.reflexId,
-      error: event.detail.body,
-      toString: () => event.detail.body
-    })));
-  };
-  class StimulusReflexController extends stimulus.Controller {
-    constructor(...args) {
-      super(...args);
-      register(this);
-    }
-  }
-  const initialize = (application, {controller: controller, consumer: consumer, debug: debug, params: params, isolate: isolate, deprecate: deprecate} = {}) => {
-    ActionCableTransport.set(consumer, params);
-    document.addEventListener("DOMContentLoaded", (() => {
-      document.body.classList.remove("stimulus-reflex-connected");
-      document.body.classList.add("stimulus-reflex-disconnected");
-      if (Deprecate.enabled && consumer) console.warn("Deprecation warning: the next version of StimulusReflex will obtain a reference to consumer via the Stimulus application object.\nPlease add 'application.consumer = consumer' to your index.js after your Stimulus application has been established, and remove the consumer key from your StimulusReflex initialize() options object.");
-      if (Deprecate.enabled && IsolationMode.disabled) console.warn("Deprecation warning: the next version of StimulusReflex will standardize isolation mode, and the isolate option will be removed.\nPlease update your applications to assume that every tab will be isolated.");
-    }), {
-      once: true
-    });
-    IsolationMode.set(!!isolate);
-    reflexes.app = application;
-    Schema.set(application);
-    reflexes.app.register("stimulus-reflex", controller || StimulusReflexController);
-    Debug$1.set(!!debug);
-    if (typeof deprecate !== "undefined") Deprecate.set(deprecate);
-    const observer = new MutationObserver(setupDeclarativeReflexes);
-    observer.observe(document.documentElement, {
-      attributeFilter: [ Schema.reflex, Schema.action ],
-      childList: true,
-      subtree: true
-    });
-  };
-  const register = (controller, options = {}) => {
-    const channel = "StimulusReflex::Channel";
-    controller.StimulusReflex = {
-      ...options,
-      channel: channel
-    };
-    ActionCableTransport.createSubscription(controller);
-    Object.assign(controller, {
-      isActionCableConnectionOpen() {
-        return this.StimulusReflex.subscription.consumer.connection.isOpen();
-      },
-      stimulate() {
-        const url = location.href;
-        const args = Array.from(arguments);
-        const target = args.shift() || "StimulusReflex::Reflex#default_reflex";
-        const controllerElement = this.element;
-        const reflexElement = args[0] && args[0].nodeType === Node.ELEMENT_NODE ? args.shift() : controllerElement;
-        if (reflexElement.type === "number" && reflexElement.validity && reflexElement.validity.badInput) {
-          if (Debug$1.enabled) console.warn("Reflex aborted: invalid numeric input");
-          return;
-        }
-        const options = {};
-        if (args[0] && typeof args[0] === "object" && Object.keys(args[0]).filter((key => [ "attrs", "selectors", "reflexId", "resolveLate", "serializeForm", "suppressLogging", "includeInnerHTML", "includeTextContent" ].includes(key))).length) {
-          const opts = args.shift();
-          Object.keys(opts).forEach((o => options[o] = opts[o]));
-        }
-        const reflexData = new ReflexData(options, reflexElement, controllerElement, this.identifier, Schema.reflexPermanent, target, args, url, tabId);
-        const reflexId = reflexData.reflexId;
-        if (!this.isActionCableConnectionOpen()) throw "The ActionCable connection is not open! `this.isActionCableConnectionOpen()` must return true before calling `this.stimulate()`";
-        if (!ActionCableTransport.subscriptionActive) throw "The ActionCable channel subscription for StimulusReflex was rejected.";
-        controllerElement.reflexController = controllerElement.reflexController || {};
-        controllerElement.reflexData = controllerElement.reflexData || {};
-        controllerElement.reflexError = controllerElement.reflexError || {};
-        controllerElement.reflexController[reflexId] = this;
-        controllerElement.reflexData[reflexId] = reflexData.valueOf();
-        dispatchLifecycleEvent("before", reflexElement, controllerElement, reflexId);
-        setTimeout((() => {
-          const {params: params} = controllerElement.reflexData[reflexId] || {};
-          const check = reflexElement.attributes[Schema.reflexSerializeForm];
-          if (check) {
-            options["serializeForm"] = check.value !== "false";
-          }
-          const form = reflexElement.closest(reflexData.formSelector) || document.querySelector(reflexData.formSelector) || reflexElement.closest("form");
-          if (Deprecate.enabled && options["serializeForm"] === undefined && form) console.warn(`Deprecation warning: the next version of StimulusReflex will not serialize forms by default.\nPlease set ${Schema.reflexSerializeForm}="true" on your Reflex Controller Element or pass { serializeForm: true } as an option to stimulate.`);
-          const formData = options["serializeForm"] === false ? "" : serializeForm(form, {
-            element: reflexElement
-          });
-          controllerElement.reflexData[reflexId] = {
-            ...reflexData.valueOf(),
-            params: params,
-            formData: formData
-          };
-          this.StimulusReflex.subscription.send(controllerElement.reflexData[reflexId]);
-        }));
-        const promise = registerReflex(reflexData.valueOf());
-        Log.request(reflexId, target, args, this.context.scope.identifier, reflexElement, controllerElement);
-        return promise;
-      },
-      __perform(event) {
-        let element = event.target;
-        let reflex;
-        while (element && !reflex) {
-          reflex = element.getAttribute(Schema.reflex);
-          if (!reflex || !reflex.trim().length) element = element.parentElement;
-        }
-        const match = attributeValues(reflex).find((reflex => reflex.split("->")[0] === event.type));
-        if (match) {
-          event.preventDefault();
-          event.stopPropagation();
-          this.stimulate(match.split("->")[1], element);
-        }
-      }
-    });
-  };
-  const tabId = uuidv4();
-  const useReflex = (controller, options = {}) => {
-    register(controller, options);
-  };
-  document.addEventListener("cable-ready:after-dispatch-event", routeReflexEvent);
-  document.addEventListener("cable-ready:before-inner-html", beforeDOMUpdate);
-  document.addEventListener("cable-ready:before-morph", beforeDOMUpdate);
-  document.addEventListener("cable-ready:after-inner-html", afterDOMUpdate);
-  document.addEventListener("cable-ready:after-morph", afterDOMUpdate);
-  window.addEventListener("load", setupDeclarativeReflexes);
-  var StimulusReflex = Object.freeze({
-    __proto__: null,
-    initialize: initialize,
-    register: register,
-    useReflex: useReflex
-  });
-  const global = {
-    ...StimulusReflex,
-    get debug() {
-      return Debug$1.value;
-    },
-    set debug(value) {
-      Debug$1.set(!!value);
-    },
-    get deprecate() {
-      return Deprecate.value;
-    },
-    set deprecate(value) {
-      Deprecate.set(!!value);
-    }
-  };
-  window.StimulusReflex = global;
-  exports["default"] = global;
-  exports.initialize = initialize;
-  exports.register = register;
-  exports.useReflex = useReflex;
-  Object.defineProperty(exports, "__esModule", {
-    value: true
-  });
-}));
-//# sourceMappingURL=stimulus_reflex.umd.min.js.map