diff --git a/app/assets/builds/administrate/application.js b/app/assets/builds/administrate/application.js
index 06c480338d..ebce1dc527 100644
--- a/app/assets/builds/administrate/application.js
+++ b/app/assets/builds/administrate/application.js
@@ -486,7 +486,7 @@
context.setAttribute("id", nid = expando);
}
}
- groups = tokenize(selector);
+ groups = tokenize2(selector);
i2 = groups.length;
while (i2--) {
groups[i2] = (nid ? "#" + nid : ":scope") + " " + toSelector(groups[i2]);
@@ -831,7 +831,7 @@
if (match[3]) {
match[2] = match[4] || match[5] || "";
} else if (unquoted && rpseudo.test(unquoted) && // Get excess from tokenize (recursively)
- (excess = tokenize(unquoted, true)) && // advance to the next closing parenthesis
+ (excess = tokenize2(unquoted, true)) && // advance to the next closing parenthesis
(excess = unquoted.indexOf(")", unquoted.length - excess) - unquoted.length)) {
match[0] = match[0].slice(0, excess);
match[2] = unquoted.slice(0, excess);
@@ -1134,7 +1134,7 @@
}
setFilters.prototype = Expr.filters = Expr.pseudos;
Expr.setFilters = new setFilters();
- function tokenize(selector, parseOnly) {
+ function tokenize2(selector, parseOnly) {
var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + " "];
if (cached) {
return parseOnly ? 0 : cached.slice(0);
@@ -1436,7 +1436,7 @@
var i2, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + " "];
if (!cached) {
if (!match) {
- match = tokenize(selector);
+ match = tokenize2(selector);
}
i2 = match.length;
while (i2--) {
@@ -1456,7 +1456,7 @@
return cached;
}
function select(selector, context, results, seed) {
- var i2, tokens, token, type, find2, compiled = typeof selector === "function" && selector, match = !seed && tokenize(selector = compiled.selector || selector);
+ var i2, tokens, token, type, find2, compiled = typeof selector === "function" && selector, match = !seed && tokenize2(selector = compiled.selector || selector);
results = results || [];
if (match.length === 1) {
tokens = match[0] = match[0].slice(0);
@@ -1840,14 +1840,14 @@
firingIndex = list.length - 1;
queue.push(memory);
}
- (function add(args) {
+ (function add2(args) {
jQuery2.each(args, function(_, arg) {
if (isFunction(arg)) {
if (!options.unique || !self.has(arg)) {
list.push(arg);
}
} else if (arg && arg.length && toType(arg) !== "string") {
- add(arg);
+ add2(arg);
}
});
})(arguments);
@@ -2179,24 +2179,24 @@
}
});
var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
- jQuery2.Deferred.exceptionHook = function(error, asyncError) {
- if (window2.console && window2.console.warn && error && rerrorNames.test(error.name)) {
+ jQuery2.Deferred.exceptionHook = function(error2, asyncError) {
+ if (window2.console && window2.console.warn && error2 && rerrorNames.test(error2.name)) {
window2.console.warn(
- "jQuery.Deferred exception: " + error.message,
- error.stack,
+ "jQuery.Deferred exception: " + error2.message,
+ error2.stack,
asyncError
);
}
};
- jQuery2.readyException = function(error) {
+ jQuery2.readyException = function(error2) {
window2.setTimeout(function() {
- throw error;
+ throw error2;
});
};
var readyList = jQuery2.Deferred();
jQuery2.fn.ready = function(fn) {
- readyList.then(fn).catch(function(error) {
- jQuery2.readyException(error);
+ readyList.then(fn).catch(function(error2) {
+ jQuery2.readyException(error2);
});
return this;
};
@@ -5178,31 +5178,31 @@
}
});
var rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i;
- function buildParams(prefix, obj, traditional, add) {
+ function buildParams(prefix, obj, traditional, add2) {
var name;
if (Array.isArray(obj)) {
jQuery2.each(obj, function(i, v) {
if (traditional || rbracket.test(prefix)) {
- add(prefix, v);
+ add2(prefix, v);
} else {
buildParams(
prefix + "[" + (typeof v === "object" && v != null ? i : "") + "]",
v,
traditional,
- add
+ add2
);
}
});
} else if (!traditional && toType(obj) === "object") {
for (name in obj) {
- buildParams(prefix + "[" + name + "]", obj[name], traditional, add);
+ buildParams(prefix + "[" + name + "]", obj[name], traditional, add2);
}
} else {
- add(prefix, obj);
+ add2(prefix, obj);
}
}
jQuery2.param = function(a, traditional) {
- var prefix, s = [], add = function(key, valueOrFunction) {
+ var prefix, s = [], add2 = function(key, valueOrFunction) {
var value = isFunction(valueOrFunction) ? valueOrFunction() : valueOrFunction;
s[s.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value == null ? "" : value);
};
@@ -5211,11 +5211,11 @@
}
if (Array.isArray(a) || a.jquery && !jQuery2.isPlainObject(a)) {
jQuery2.each(a, function() {
- add(this.name, this.value);
+ add2(this.name, this.value);
});
} else {
for (prefix in a) {
- buildParams(prefix, a[prefix], traditional, add);
+ buildParams(prefix, a[prefix], traditional, add2);
}
}
return s.join("&");
@@ -5629,7 +5629,7 @@
}
}
function done(status, nativeStatusText, responses, headers) {
- var isSuccess, success, error, response, modified, statusText = nativeStatusText;
+ var isSuccess, success, error2, response, modified, statusText = nativeStatusText;
if (completed2) {
return;
}
@@ -5667,11 +5667,11 @@
} else {
statusText = response.state;
success = response.data;
- error = response.error;
- isSuccess = !error;
+ error2 = response.error;
+ isSuccess = !error2;
}
} else {
- error = statusText;
+ error2 = statusText;
if (status || !statusText) {
statusText = "error";
if (status < 0) {
@@ -5684,14 +5684,14 @@
if (isSuccess) {
deferred.resolveWith(callbackContext, [success, statusText, jqXHR]);
} else {
- deferred.rejectWith(callbackContext, [jqXHR, statusText, error]);
+ deferred.rejectWith(callbackContext, [jqXHR, statusText, error2]);
}
jqXHR.statusCode(statusCode);
statusCode = void 0;
if (fireGlobals) {
globalEventContext.trigger(
isSuccess ? "ajaxSuccess" : "ajaxError",
- [jqXHR, s, isSuccess ? success : error]
+ [jqXHR, s, isSuccess ? success : error2]
);
}
completeDeferred.fireWith(callbackContext, [jqXHR, statusText]);
@@ -6370,13 +6370,13 @@
"node_modules/jquery-ujs/src/rails.js"(exports, module) {
(function() {
"use strict";
- var jqueryUjsInit = function($2, undefined2) {
- if ($2.rails !== undefined2) {
- $2.error("jquery-ujs has already been loaded!");
+ var jqueryUjsInit = function($4, undefined2) {
+ if ($4.rails !== undefined2) {
+ $4.error("jquery-ujs has already been loaded!");
}
var rails;
- var $document = $2(document);
- $2.rails = rails = {
+ var $document = $4(document);
+ $4.rails = rails = {
// Link elements bound by jquery-ujs
linkClickSelector: "a[data-confirm], a[data-method], a[data-remote]:not([disabled]), a[data-disable-with], a[data-disable]",
// Button elements bound by jquery-ujs
@@ -6401,11 +6401,11 @@
buttonDisableSelector: "button[data-remote][data-disable-with], button[data-remote][data-disable]",
// Up-to-date Cross-Site Request Forgery token
csrfToken: function() {
- return $2("meta[name=csrf-token]").attr("content");
+ return $4("meta[name=csrf-token]").attr("content");
},
// URL param that must contain the CSRF token
csrfParam: function() {
- return $2("meta[name=csrf-param]").attr("content");
+ return $4("meta[name=csrf-param]").attr("content");
},
// Make sure that every Ajax request sends the CSRF token
CSRFProtection: function(xhr) {
@@ -6415,11 +6415,11 @@
},
// Make sure that all forms have actual up-to-date tokens (cached forms contain old ones)
refreshCSRFTokens: function() {
- $2('form input[name="' + rails.csrfParam() + '"]').val(rails.csrfToken());
+ $4('form input[name="' + rails.csrfParam() + '"]').val(rails.csrfToken());
},
// Triggers an event on an element and returns false if the event result is false
fire: function(obj, name, data) {
- var event = $2.Event(name);
+ var event = $4.Event(name);
obj.trigger(event, data);
return event.result !== false;
},
@@ -6429,7 +6429,7 @@
},
// Default ajax function, may be overridden with custom function in $.rails.ajax
ajax: function(options) {
- return $2.ajax(options);
+ return $4.ajax(options);
},
// Default way to get an element's href. May be overridden at $.rails.href.
href: function(element) {
@@ -6444,11 +6444,11 @@
var method, url, data, withCredentials, dataType, options;
if (rails.fire(element, "ajax:before")) {
withCredentials = element.data("with-credentials") || null;
- dataType = element.data("type") || $2.ajaxSettings && $2.ajaxSettings.dataType;
+ dataType = element.data("type") || $4.ajaxSettings && $4.ajaxSettings.dataType;
if (element.is("form")) {
method = element.data("ujs:submit-button-formmethod") || element.attr("method");
url = element.data("ujs:submit-button-formaction") || element.attr("action");
- data = $2(element[0]).serializeArray();
+ data = $4(element[0]).serializeArray();
var button = element.data("ujs:submit-button");
if (button) {
data.push(button);
@@ -6494,8 +6494,8 @@
complete: function(xhr, status) {
element.trigger("ajax:complete", [xhr, status]);
},
- error: function(xhr, status, error) {
- element.trigger("ajax:error", [xhr, status, error]);
+ error: function(xhr, status, error2) {
+ element.trigger("ajax:error", [xhr, status, error2]);
},
crossDomain: rails.isCrossDomain(url)
};
@@ -6528,7 +6528,7 @@
// Handles "data-method" on links such as:
// Delete
handleMethod: function(link) {
- var href = rails.href(link), method = link.data("method"), target = link.attr("target"), csrfToken = rails.csrfToken(), csrfParam = rails.csrfParam(), form = $2(''), metadataInput = '';
+ var href = rails.href(link), method = link.data("method"), target = link.attr("target"), csrfToken = rails.csrfToken(), csrfParam = rails.csrfParam(), form = $4(''), metadataInput = '';
if (csrfParam !== undefined2 && csrfToken !== undefined2 && !rails.isCrossDomain(href)) {
metadataInput += '';
}
@@ -6542,7 +6542,7 @@
// If form is actually a "form" element this will return associated elements outside the from that have
// the html form attribute set
formElements: function(form, selector) {
- return form.is("form") ? $2(form[0].elements).filter(selector) : form.find(selector);
+ return form.is("form") ? $4(form[0].elements).filter(selector) : form.find(selector);
},
/* Disables form elements:
- Caches element value in 'ujs:enable-with' data store
@@ -6551,7 +6551,7 @@
*/
disableFormElements: function(form) {
rails.formElements(form, rails.disableSelector).each(function() {
- rails.disableFormElement($2(this));
+ rails.disableFormElement($4(this));
});
},
disableFormElement: function(element) {
@@ -6571,7 +6571,7 @@
*/
enableFormElements: function(form) {
rails.formElements(form, rails.enableSelector).each(function() {
- rails.enableFormElement($2(this));
+ rails.enableFormElement($4(this));
});
},
enableFormElement: function(element) {
@@ -6610,9 +6610,9 @@
},
// Helper function which checks for blank inputs in a form that match the specified CSS selector
blankInputs: function(form, specifiedSelector, nonBlank) {
- var foundInputs = $2(), input, valueToCheck, radiosForNameWithNoneSelected, radioName, selector = specifiedSelector || "input,textarea", requiredInputs = form.find(selector), checkedRadioButtonNames = {};
+ var foundInputs = $4(), input, valueToCheck, radiosForNameWithNoneSelected, radioName, selector = specifiedSelector || "input,textarea", requiredInputs = form.find(selector), checkedRadioButtonNames = {};
requiredInputs.each(function() {
- input = $2(this);
+ input = $4(this);
if (input.is("input[type=radio]")) {
radioName = input.attr("name");
if (!checkedRadioButtonNames[radioName]) {
@@ -6639,7 +6639,7 @@
},
// Helper function, needed to provide consistent behavior in IE
stopEverything: function(e) {
- $2(e.target).trigger("ujs:everythingStopped");
+ $4(e.target).trigger("ujs:everythingStopped");
e.stopImmediatePropagation();
return false;
},
@@ -6667,33 +6667,33 @@
}
};
if (rails.fire($document, "rails:attachBindings")) {
- $2.ajaxPrefilter(function(options, originalOptions, xhr) {
+ $4.ajaxPrefilter(function(options, originalOptions, xhr) {
if (!options.crossDomain) {
rails.CSRFProtection(xhr);
}
});
- $2(window).on("pageshow.rails", function() {
- $2($2.rails.enableSelector).each(function() {
- var element = $2(this);
+ $4(window).on("pageshow.rails", function() {
+ $4($4.rails.enableSelector).each(function() {
+ var element = $4(this);
if (element.data("ujs:disabled")) {
- $2.rails.enableFormElement(element);
+ $4.rails.enableFormElement(element);
}
});
- $2($2.rails.linkDisableSelector).each(function() {
- var element = $2(this);
+ $4($4.rails.linkDisableSelector).each(function() {
+ var element = $4(this);
if (element.data("ujs:disabled")) {
- $2.rails.enableElement(element);
+ $4.rails.enableElement(element);
}
});
});
$document.on("ajax:complete", rails.linkDisableSelector, function() {
- rails.enableElement($2(this));
+ rails.enableElement($4(this));
});
$document.on("ajax:complete", rails.buttonDisableSelector, function() {
- rails.enableFormElement($2(this));
+ rails.enableFormElement($4(this));
});
$document.on("click.rails", rails.linkClickSelector, function(e) {
- var link = $2(this), method = link.data("method"), data = link.data("params"), metaClick = e.metaKey || e.ctrlKey;
+ var link = $4(this), method = link.data("method"), data = link.data("params"), metaClick = e.metaKey || e.ctrlKey;
if (!rails.allowAction(link))
return rails.stopEverything(e);
if (!metaClick && link.is(rails.linkDisableSelector))
@@ -6717,7 +6717,7 @@
}
});
$document.on("click.rails", rails.buttonClickSelector, function(e) {
- var button = $2(this);
+ var button = $4(this);
if (!rails.allowAction(button) || !rails.isRemote(button))
return rails.stopEverything(e);
if (button.is(rails.buttonDisableSelector))
@@ -6733,14 +6733,14 @@
return false;
});
$document.on("change.rails", rails.inputChangeSelector, function(e) {
- var link = $2(this);
+ var link = $4(this);
if (!rails.allowAction(link) || !rails.isRemote(link))
return rails.stopEverything(e);
rails.handleRemote(link);
return false;
});
$document.on("submit.rails", rails.formSubmitSelector, function(e) {
- var form = $2(this), remote = rails.isRemote(form), blankRequiredInputs, nonBlankFileInputs;
+ var form = $4(this), remote = rails.isRemote(form), blankRequiredInputs, nonBlankFileInputs;
if (!rails.allowAction(form))
return rails.stopEverything(e);
if (form.attr("novalidate") === undefined2) {
@@ -6776,13 +6776,13 @@
}
});
$document.on("click.rails", rails.formInputClickSelector, function(event) {
- var button = $2(this);
+ var button = $4(this);
if (!rails.allowAction(button))
return rails.stopEverything(event);
var name = button.attr("name"), data = name ? { name, value: button.val() } : null;
var form = button.closest("form");
if (form.length === 0) {
- form = $2("#" + button.attr("form"));
+ form = $4("#" + button.attr("form"));
}
form.data("ujs:submit-button", data);
form.data("ujs:formnovalidate-button", button.attr("formnovalidate"));
@@ -6791,13 +6791,13 @@
});
$document.on("ajax:send.rails", rails.formSubmitSelector, function(event) {
if (this === event.target)
- rails.disableFormElements($2(this));
+ rails.disableFormElements($4(this));
});
$document.on("ajax:complete.rails", rails.formSubmitSelector, function(event) {
if (this === event.target)
- rails.enableFormElements($2(this));
+ rails.enableFormElements($4(this));
});
- $2(function() {
+ $4(function() {
rails.refreshCSRFTokens();
});
}
@@ -7011,7 +7011,7 @@
Sifter.prototype.prepareSearch = function(query, options) {
if (typeof query === "object")
return query;
- options = extend({}, options);
+ options = extend2({}, options);
var option_fields = options.fields;
var option_sort = options.sort;
var option_sort_empty = options.sort_empty;
@@ -7070,7 +7070,7 @@
return -1;
return 0;
};
- var extend = function(a, b) {
+ var extend2 = function(a, b) {
var i, n, k, object;
for (i = 1, n = arguments.length; i < n; i++) {
object = arguments[i];
@@ -8059,36 +8059,2488 @@
var import_jquery_ujs = __toESM(require_rails());
var import_selectize_min = __toESM(require_selectize_min());
- // app/assets/javascripts/administrate/components/associative.js
- $(function() {
- $(".field-unit--belongs-to select").selectize({});
- $(".field-unit--has-many select").selectize({});
- $(".field-unit--polymorphic select").selectize({});
- });
+ // node_modules/@hotwired/stimulus/dist/stimulus.js
+ var EventListener = class {
+ constructor(eventTarget, eventName, eventOptions) {
+ this.eventTarget = eventTarget;
+ this.eventName = eventName;
+ this.eventOptions = eventOptions;
+ this.unorderedBindings = /* @__PURE__ */ new Set();
+ }
+ connect() {
+ this.eventTarget.addEventListener(this.eventName, this, this.eventOptions);
+ }
+ disconnect() {
+ this.eventTarget.removeEventListener(this.eventName, this, this.eventOptions);
+ }
+ bindingConnected(binding) {
+ this.unorderedBindings.add(binding);
+ }
+ bindingDisconnected(binding) {
+ this.unorderedBindings.delete(binding);
+ }
+ handleEvent(event) {
+ const extendedEvent = extendEvent(event);
+ for (const binding of this.bindings) {
+ if (extendedEvent.immediatePropagationStopped) {
+ break;
+ } else {
+ binding.handleEvent(extendedEvent);
+ }
+ }
+ }
+ hasBindings() {
+ return this.unorderedBindings.size > 0;
+ }
+ get bindings() {
+ return Array.from(this.unorderedBindings).sort((left, right) => {
+ const leftIndex = left.index, rightIndex = right.index;
+ return leftIndex < rightIndex ? -1 : leftIndex > rightIndex ? 1 : 0;
+ });
+ }
+ };
+ function extendEvent(event) {
+ if ("immediatePropagationStopped" in event) {
+ return event;
+ } else {
+ const { stopImmediatePropagation } = event;
+ return Object.assign(event, {
+ immediatePropagationStopped: false,
+ stopImmediatePropagation() {
+ this.immediatePropagationStopped = true;
+ stopImmediatePropagation.call(this);
+ }
+ });
+ }
+ }
+ var Dispatcher = class {
+ constructor(application2) {
+ this.application = application2;
+ this.eventListenerMaps = /* @__PURE__ */ new Map();
+ this.started = false;
+ }
+ start() {
+ if (!this.started) {
+ this.started = true;
+ this.eventListeners.forEach((eventListener) => eventListener.connect());
+ }
+ }
+ stop() {
+ if (this.started) {
+ this.started = false;
+ this.eventListeners.forEach((eventListener) => eventListener.disconnect());
+ }
+ }
+ get eventListeners() {
+ return Array.from(this.eventListenerMaps.values()).reduce((listeners, map) => listeners.concat(Array.from(map.values())), []);
+ }
+ bindingConnected(binding) {
+ this.fetchEventListenerForBinding(binding).bindingConnected(binding);
+ }
+ bindingDisconnected(binding, clearEventListeners = false) {
+ this.fetchEventListenerForBinding(binding).bindingDisconnected(binding);
+ if (clearEventListeners)
+ this.clearEventListenersForBinding(binding);
+ }
+ handleError(error2, message, detail = {}) {
+ this.application.handleError(error2, `Error ${message}`, detail);
+ }
+ clearEventListenersForBinding(binding) {
+ const eventListener = this.fetchEventListenerForBinding(binding);
+ if (!eventListener.hasBindings()) {
+ eventListener.disconnect();
+ this.removeMappedEventListenerFor(binding);
+ }
+ }
+ removeMappedEventListenerFor(binding) {
+ const { eventTarget, eventName, eventOptions } = binding;
+ const eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);
+ const cacheKey = this.cacheKey(eventName, eventOptions);
+ eventListenerMap.delete(cacheKey);
+ if (eventListenerMap.size == 0)
+ this.eventListenerMaps.delete(eventTarget);
+ }
+ fetchEventListenerForBinding(binding) {
+ const { eventTarget, eventName, eventOptions } = binding;
+ return this.fetchEventListener(eventTarget, eventName, eventOptions);
+ }
+ fetchEventListener(eventTarget, eventName, eventOptions) {
+ const eventListenerMap = this.fetchEventListenerMapForEventTarget(eventTarget);
+ const cacheKey = this.cacheKey(eventName, eventOptions);
+ let eventListener = eventListenerMap.get(cacheKey);
+ if (!eventListener) {
+ eventListener = this.createEventListener(eventTarget, eventName, eventOptions);
+ eventListenerMap.set(cacheKey, eventListener);
+ }
+ return eventListener;
+ }
+ createEventListener(eventTarget, eventName, eventOptions) {
+ const eventListener = new EventListener(eventTarget, eventName, eventOptions);
+ if (this.started) {
+ eventListener.connect();
+ }
+ return eventListener;
+ }
+ fetchEventListenerMapForEventTarget(eventTarget) {
+ let eventListenerMap = this.eventListenerMaps.get(eventTarget);
+ if (!eventListenerMap) {
+ eventListenerMap = /* @__PURE__ */ new Map();
+ this.eventListenerMaps.set(eventTarget, eventListenerMap);
+ }
+ return eventListenerMap;
+ }
+ cacheKey(eventName, eventOptions) {
+ const parts = [eventName];
+ Object.keys(eventOptions).sort().forEach((key) => {
+ parts.push(`${eventOptions[key] ? "" : "!"}${key}`);
+ });
+ return parts.join(":");
+ }
+ };
+ var defaultActionDescriptorFilters = {
+ stop({ event, value }) {
+ if (value)
+ event.stopPropagation();
+ return true;
+ },
+ prevent({ event, value }) {
+ if (value)
+ event.preventDefault();
+ return true;
+ },
+ self({ event, value, element }) {
+ if (value) {
+ return element === event.target;
+ } else {
+ return true;
+ }
+ }
+ };
+ var descriptorPattern = /^(?:(?:([^.]+?)\+)?(.+?)(?:\.(.+?))?(?:@(window|document))?->)?(.+?)(?:#([^:]+?))(?::(.+))?$/;
+ function parseActionDescriptorString(descriptorString) {
+ const source = descriptorString.trim();
+ const matches = source.match(descriptorPattern) || [];
+ let eventName = matches[2];
+ let keyFilter = matches[3];
+ if (keyFilter && !["keydown", "keyup", "keypress"].includes(eventName)) {
+ eventName += `.${keyFilter}`;
+ keyFilter = "";
+ }
+ return {
+ eventTarget: parseEventTarget(matches[4]),
+ eventName,
+ eventOptions: matches[7] ? parseEventOptions(matches[7]) : {},
+ identifier: matches[5],
+ methodName: matches[6],
+ keyFilter: matches[1] || keyFilter
+ };
+ }
+ function parseEventTarget(eventTargetName) {
+ if (eventTargetName == "window") {
+ return window;
+ } else if (eventTargetName == "document") {
+ return document;
+ }
+ }
+ function parseEventOptions(eventOptions) {
+ return eventOptions.split(":").reduce((options, token) => Object.assign(options, { [token.replace(/^!/, "")]: !/^!/.test(token) }), {});
+ }
+ function stringifyEventTarget(eventTarget) {
+ if (eventTarget == window) {
+ return "window";
+ } else if (eventTarget == document) {
+ return "document";
+ }
+ }
+ function camelize(value) {
+ return value.replace(/(?:[_-])([a-z0-9])/g, (_, char) => char.toUpperCase());
+ }
+ function namespaceCamelize(value) {
+ return camelize(value.replace(/--/g, "-").replace(/__/g, "_"));
+ }
+ function capitalize(value) {
+ return value.charAt(0).toUpperCase() + value.slice(1);
+ }
+ function dasherize(value) {
+ return value.replace(/([A-Z])/g, (_, char) => `-${char.toLowerCase()}`);
+ }
+ function tokenize(value) {
+ return value.match(/[^\s]+/g) || [];
+ }
+ function isSomething(object) {
+ return object !== null && object !== void 0;
+ }
+ function hasProperty(object, property) {
+ return Object.prototype.hasOwnProperty.call(object, property);
+ }
+ var allModifiers = ["meta", "ctrl", "alt", "shift"];
+ var Action = class {
+ constructor(element, index, descriptor, schema) {
+ this.element = element;
+ this.index = index;
+ this.eventTarget = descriptor.eventTarget || element;
+ this.eventName = descriptor.eventName || getDefaultEventNameForElement(element) || error("missing event name");
+ this.eventOptions = descriptor.eventOptions || {};
+ this.identifier = descriptor.identifier || error("missing identifier");
+ this.methodName = descriptor.methodName || error("missing method name");
+ this.keyFilter = descriptor.keyFilter || "";
+ this.schema = schema;
+ }
+ static forToken(token, schema) {
+ return new this(token.element, token.index, parseActionDescriptorString(token.content), schema);
+ }
+ toString() {
+ const eventFilter = this.keyFilter ? `.${this.keyFilter}` : "";
+ const eventTarget = this.eventTargetName ? `@${this.eventTargetName}` : "";
+ return `${this.eventName}${eventFilter}${eventTarget}->${this.identifier}#${this.methodName}`;
+ }
+ shouldIgnoreKeyboardEvent(event) {
+ if (!this.keyFilter) {
+ return false;
+ }
+ const filters = this.keyFilter.split("+");
+ if (this.keyFilterDissatisfied(event, filters)) {
+ return true;
+ }
+ const standardFilter = filters.filter((key) => !allModifiers.includes(key))[0];
+ if (!standardFilter) {
+ return false;
+ }
+ if (!hasProperty(this.keyMappings, standardFilter)) {
+ error(`contains unknown key filter: ${this.keyFilter}`);
+ }
+ return this.keyMappings[standardFilter].toLowerCase() !== event.key.toLowerCase();
+ }
+ shouldIgnoreMouseEvent(event) {
+ if (!this.keyFilter) {
+ return false;
+ }
+ const filters = [this.keyFilter];
+ if (this.keyFilterDissatisfied(event, filters)) {
+ return true;
+ }
+ return false;
+ }
+ get params() {
+ const params = {};
+ const pattern = new RegExp(`^data-${this.identifier}-(.+)-param$`, "i");
+ for (const { name, value } of Array.from(this.element.attributes)) {
+ const match = name.match(pattern);
+ const key = match && match[1];
+ if (key) {
+ params[camelize(key)] = typecast(value);
+ }
+ }
+ return params;
+ }
+ get eventTargetName() {
+ return stringifyEventTarget(this.eventTarget);
+ }
+ get keyMappings() {
+ return this.schema.keyMappings;
+ }
+ keyFilterDissatisfied(event, filters) {
+ const [meta, ctrl, alt, shift] = allModifiers.map((modifier) => filters.includes(modifier));
+ return event.metaKey !== meta || event.ctrlKey !== ctrl || event.altKey !== alt || event.shiftKey !== shift;
+ }
+ };
+ var defaultEventNames = {
+ a: () => "click",
+ button: () => "click",
+ form: () => "submit",
+ details: () => "toggle",
+ input: (e) => e.getAttribute("type") == "submit" ? "click" : "input",
+ select: () => "change",
+ textarea: () => "input"
+ };
+ function getDefaultEventNameForElement(element) {
+ const tagName = element.tagName.toLowerCase();
+ if (tagName in defaultEventNames) {
+ return defaultEventNames[tagName](element);
+ }
+ }
+ function error(message) {
+ throw new Error(message);
+ }
+ function typecast(value) {
+ try {
+ return JSON.parse(value);
+ } catch (o_O) {
+ return value;
+ }
+ }
+ var Binding = class {
+ constructor(context, action) {
+ this.context = context;
+ this.action = action;
+ }
+ get index() {
+ return this.action.index;
+ }
+ get eventTarget() {
+ return this.action.eventTarget;
+ }
+ get eventOptions() {
+ return this.action.eventOptions;
+ }
+ get identifier() {
+ return this.context.identifier;
+ }
+ handleEvent(event) {
+ const actionEvent = this.prepareActionEvent(event);
+ if (this.willBeInvokedByEvent(event) && this.applyEventModifiers(actionEvent)) {
+ this.invokeWithEvent(actionEvent);
+ }
+ }
+ get eventName() {
+ return this.action.eventName;
+ }
+ get method() {
+ const method = this.controller[this.methodName];
+ if (typeof method == "function") {
+ return method;
+ }
+ throw new Error(`Action "${this.action}" references undefined method "${this.methodName}"`);
+ }
+ applyEventModifiers(event) {
+ const { element } = this.action;
+ const { actionDescriptorFilters } = this.context.application;
+ const { controller } = this.context;
+ let passes = true;
+ for (const [name, value] of Object.entries(this.eventOptions)) {
+ if (name in actionDescriptorFilters) {
+ const filter = actionDescriptorFilters[name];
+ passes = passes && filter({ name, value, event, element, controller });
+ } else {
+ continue;
+ }
+ }
+ return passes;
+ }
+ prepareActionEvent(event) {
+ return Object.assign(event, { params: this.action.params });
+ }
+ invokeWithEvent(event) {
+ const { target, currentTarget } = event;
+ try {
+ this.method.call(this.controller, event);
+ this.context.logDebugActivity(this.methodName, { event, target, currentTarget, action: this.methodName });
+ } catch (error2) {
+ const { identifier, controller, element, index } = this;
+ const detail = { identifier, controller, element, index, event };
+ this.context.handleError(error2, `invoking action "${this.action}"`, detail);
+ }
+ }
+ willBeInvokedByEvent(event) {
+ const eventTarget = event.target;
+ if (event instanceof KeyboardEvent && this.action.shouldIgnoreKeyboardEvent(event)) {
+ return false;
+ }
+ if (event instanceof MouseEvent && this.action.shouldIgnoreMouseEvent(event)) {
+ return false;
+ }
+ if (this.element === eventTarget) {
+ return true;
+ } else if (eventTarget instanceof Element && this.element.contains(eventTarget)) {
+ return this.scope.containsElement(eventTarget);
+ } else {
+ return this.scope.containsElement(this.action.element);
+ }
+ }
+ get controller() {
+ return this.context.controller;
+ }
+ get methodName() {
+ return this.action.methodName;
+ }
+ get element() {
+ return this.scope.element;
+ }
+ get scope() {
+ return this.context.scope;
+ }
+ };
+ var ElementObserver = class {
+ constructor(element, delegate) {
+ this.mutationObserverInit = { attributes: true, childList: true, subtree: true };
+ this.element = element;
+ this.started = false;
+ this.delegate = delegate;
+ this.elements = /* @__PURE__ */ new Set();
+ this.mutationObserver = new MutationObserver((mutations) => this.processMutations(mutations));
+ }
+ start() {
+ if (!this.started) {
+ this.started = true;
+ this.mutationObserver.observe(this.element, this.mutationObserverInit);
+ this.refresh();
+ }
+ }
+ pause(callback) {
+ if (this.started) {
+ this.mutationObserver.disconnect();
+ this.started = false;
+ }
+ callback();
+ if (!this.started) {
+ this.mutationObserver.observe(this.element, this.mutationObserverInit);
+ this.started = true;
+ }
+ }
+ stop() {
+ if (this.started) {
+ this.mutationObserver.takeRecords();
+ this.mutationObserver.disconnect();
+ this.started = false;
+ }
+ }
+ refresh() {
+ if (this.started) {
+ const matches = new Set(this.matchElementsInTree());
+ for (const element of Array.from(this.elements)) {
+ if (!matches.has(element)) {
+ this.removeElement(element);
+ }
+ }
+ for (const element of Array.from(matches)) {
+ this.addElement(element);
+ }
+ }
+ }
+ processMutations(mutations) {
+ if (this.started) {
+ for (const mutation of mutations) {
+ this.processMutation(mutation);
+ }
+ }
+ }
+ processMutation(mutation) {
+ if (mutation.type == "attributes") {
+ this.processAttributeChange(mutation.target, mutation.attributeName);
+ } else if (mutation.type == "childList") {
+ this.processRemovedNodes(mutation.removedNodes);
+ this.processAddedNodes(mutation.addedNodes);
+ }
+ }
+ processAttributeChange(element, attributeName) {
+ if (this.elements.has(element)) {
+ if (this.delegate.elementAttributeChanged && this.matchElement(element)) {
+ this.delegate.elementAttributeChanged(element, attributeName);
+ } else {
+ this.removeElement(element);
+ }
+ } else if (this.matchElement(element)) {
+ this.addElement(element);
+ }
+ }
+ processRemovedNodes(nodes) {
+ for (const node of Array.from(nodes)) {
+ const element = this.elementFromNode(node);
+ if (element) {
+ this.processTree(element, this.removeElement);
+ }
+ }
+ }
+ processAddedNodes(nodes) {
+ for (const node of Array.from(nodes)) {
+ const element = this.elementFromNode(node);
+ if (element && this.elementIsActive(element)) {
+ this.processTree(element, this.addElement);
+ }
+ }
+ }
+ matchElement(element) {
+ return this.delegate.matchElement(element);
+ }
+ matchElementsInTree(tree = this.element) {
+ return this.delegate.matchElementsInTree(tree);
+ }
+ processTree(tree, processor) {
+ for (const element of this.matchElementsInTree(tree)) {
+ processor.call(this, element);
+ }
+ }
+ elementFromNode(node) {
+ if (node.nodeType == Node.ELEMENT_NODE) {
+ return node;
+ }
+ }
+ elementIsActive(element) {
+ if (element.isConnected != this.element.isConnected) {
+ return false;
+ } else {
+ return this.element.contains(element);
+ }
+ }
+ addElement(element) {
+ if (!this.elements.has(element)) {
+ if (this.elementIsActive(element)) {
+ this.elements.add(element);
+ if (this.delegate.elementMatched) {
+ this.delegate.elementMatched(element);
+ }
+ }
+ }
+ }
+ removeElement(element) {
+ if (this.elements.has(element)) {
+ this.elements.delete(element);
+ if (this.delegate.elementUnmatched) {
+ this.delegate.elementUnmatched(element);
+ }
+ }
+ }
+ };
+ var AttributeObserver = class {
+ constructor(element, attributeName, delegate) {
+ this.attributeName = attributeName;
+ this.delegate = delegate;
+ this.elementObserver = new ElementObserver(element, this);
+ }
+ get element() {
+ return this.elementObserver.element;
+ }
+ get selector() {
+ return `[${this.attributeName}]`;
+ }
+ start() {
+ this.elementObserver.start();
+ }
+ pause(callback) {
+ this.elementObserver.pause(callback);
+ }
+ stop() {
+ this.elementObserver.stop();
+ }
+ refresh() {
+ this.elementObserver.refresh();
+ }
+ get started() {
+ return this.elementObserver.started;
+ }
+ matchElement(element) {
+ return element.hasAttribute(this.attributeName);
+ }
+ matchElementsInTree(tree) {
+ const match = this.matchElement(tree) ? [tree] : [];
+ const matches = Array.from(tree.querySelectorAll(this.selector));
+ return match.concat(matches);
+ }
+ elementMatched(element) {
+ if (this.delegate.elementMatchedAttribute) {
+ this.delegate.elementMatchedAttribute(element, this.attributeName);
+ }
+ }
+ elementUnmatched(element) {
+ if (this.delegate.elementUnmatchedAttribute) {
+ this.delegate.elementUnmatchedAttribute(element, this.attributeName);
+ }
+ }
+ elementAttributeChanged(element, attributeName) {
+ if (this.delegate.elementAttributeValueChanged && this.attributeName == attributeName) {
+ this.delegate.elementAttributeValueChanged(element, attributeName);
+ }
+ }
+ };
+ function add(map, key, value) {
+ fetch(map, key).add(value);
+ }
+ function del(map, key, value) {
+ fetch(map, key).delete(value);
+ prune(map, key);
+ }
+ function fetch(map, key) {
+ let values = map.get(key);
+ if (!values) {
+ values = /* @__PURE__ */ new Set();
+ map.set(key, values);
+ }
+ return values;
+ }
+ function prune(map, key) {
+ const values = map.get(key);
+ if (values != null && values.size == 0) {
+ map.delete(key);
+ }
+ }
+ var Multimap = class {
+ constructor() {
+ this.valuesByKey = /* @__PURE__ */ new Map();
+ }
+ get keys() {
+ return Array.from(this.valuesByKey.keys());
+ }
+ get values() {
+ const sets = Array.from(this.valuesByKey.values());
+ return sets.reduce((values, set) => values.concat(Array.from(set)), []);
+ }
+ get size() {
+ const sets = Array.from(this.valuesByKey.values());
+ return sets.reduce((size, set) => size + set.size, 0);
+ }
+ add(key, value) {
+ add(this.valuesByKey, key, value);
+ }
+ delete(key, value) {
+ del(this.valuesByKey, key, value);
+ }
+ has(key, value) {
+ const values = this.valuesByKey.get(key);
+ return values != null && values.has(value);
+ }
+ hasKey(key) {
+ return this.valuesByKey.has(key);
+ }
+ hasValue(value) {
+ const sets = Array.from(this.valuesByKey.values());
+ return sets.some((set) => set.has(value));
+ }
+ getValuesForKey(key) {
+ const values = this.valuesByKey.get(key);
+ return values ? Array.from(values) : [];
+ }
+ getKeysForValue(value) {
+ return Array.from(this.valuesByKey).filter(([_key, values]) => values.has(value)).map(([key, _values]) => key);
+ }
+ };
+ var SelectorObserver = class {
+ constructor(element, selector, delegate, details) {
+ this._selector = selector;
+ this.details = details;
+ this.elementObserver = new ElementObserver(element, this);
+ this.delegate = delegate;
+ this.matchesByElement = new Multimap();
+ }
+ get started() {
+ return this.elementObserver.started;
+ }
+ get selector() {
+ return this._selector;
+ }
+ set selector(selector) {
+ this._selector = selector;
+ this.refresh();
+ }
+ start() {
+ this.elementObserver.start();
+ }
+ pause(callback) {
+ this.elementObserver.pause(callback);
+ }
+ stop() {
+ this.elementObserver.stop();
+ }
+ refresh() {
+ this.elementObserver.refresh();
+ }
+ get element() {
+ return this.elementObserver.element;
+ }
+ matchElement(element) {
+ const { selector } = this;
+ if (selector) {
+ const matches = element.matches(selector);
+ if (this.delegate.selectorMatchElement) {
+ return matches && this.delegate.selectorMatchElement(element, this.details);
+ }
+ return matches;
+ } else {
+ return false;
+ }
+ }
+ matchElementsInTree(tree) {
+ const { selector } = this;
+ if (selector) {
+ const match = this.matchElement(tree) ? [tree] : [];
+ const matches = Array.from(tree.querySelectorAll(selector)).filter((match2) => this.matchElement(match2));
+ return match.concat(matches);
+ } else {
+ return [];
+ }
+ }
+ elementMatched(element) {
+ const { selector } = this;
+ if (selector) {
+ this.selectorMatched(element, selector);
+ }
+ }
+ elementUnmatched(element) {
+ const selectors = this.matchesByElement.getKeysForValue(element);
+ for (const selector of selectors) {
+ this.selectorUnmatched(element, selector);
+ }
+ }
+ elementAttributeChanged(element, _attributeName) {
+ const { selector } = this;
+ if (selector) {
+ const matches = this.matchElement(element);
+ const matchedBefore = this.matchesByElement.has(selector, element);
+ if (matches && !matchedBefore) {
+ this.selectorMatched(element, selector);
+ } else if (!matches && matchedBefore) {
+ this.selectorUnmatched(element, selector);
+ }
+ }
+ }
+ selectorMatched(element, selector) {
+ this.delegate.selectorMatched(element, selector, this.details);
+ this.matchesByElement.add(selector, element);
+ }
+ selectorUnmatched(element, selector) {
+ this.delegate.selectorUnmatched(element, selector, this.details);
+ this.matchesByElement.delete(selector, element);
+ }
+ };
+ var StringMapObserver = class {
+ constructor(element, delegate) {
+ this.element = element;
+ this.delegate = delegate;
+ this.started = false;
+ this.stringMap = /* @__PURE__ */ new Map();
+ this.mutationObserver = new MutationObserver((mutations) => this.processMutations(mutations));
+ }
+ start() {
+ if (!this.started) {
+ this.started = true;
+ this.mutationObserver.observe(this.element, { attributes: true, attributeOldValue: true });
+ this.refresh();
+ }
+ }
+ stop() {
+ if (this.started) {
+ this.mutationObserver.takeRecords();
+ this.mutationObserver.disconnect();
+ this.started = false;
+ }
+ }
+ refresh() {
+ if (this.started) {
+ for (const attributeName of this.knownAttributeNames) {
+ this.refreshAttribute(attributeName, null);
+ }
+ }
+ }
+ processMutations(mutations) {
+ if (this.started) {
+ for (const mutation of mutations) {
+ this.processMutation(mutation);
+ }
+ }
+ }
+ processMutation(mutation) {
+ const attributeName = mutation.attributeName;
+ if (attributeName) {
+ this.refreshAttribute(attributeName, mutation.oldValue);
+ }
+ }
+ refreshAttribute(attributeName, oldValue) {
+ const key = this.delegate.getStringMapKeyForAttribute(attributeName);
+ if (key != null) {
+ if (!this.stringMap.has(attributeName)) {
+ this.stringMapKeyAdded(key, attributeName);
+ }
+ const value = this.element.getAttribute(attributeName);
+ if (this.stringMap.get(attributeName) != value) {
+ this.stringMapValueChanged(value, key, oldValue);
+ }
+ if (value == null) {
+ const oldValue2 = this.stringMap.get(attributeName);
+ this.stringMap.delete(attributeName);
+ if (oldValue2)
+ this.stringMapKeyRemoved(key, attributeName, oldValue2);
+ } else {
+ this.stringMap.set(attributeName, value);
+ }
+ }
+ }
+ stringMapKeyAdded(key, attributeName) {
+ if (this.delegate.stringMapKeyAdded) {
+ this.delegate.stringMapKeyAdded(key, attributeName);
+ }
+ }
+ stringMapValueChanged(value, key, oldValue) {
+ if (this.delegate.stringMapValueChanged) {
+ this.delegate.stringMapValueChanged(value, key, oldValue);
+ }
+ }
+ stringMapKeyRemoved(key, attributeName, oldValue) {
+ if (this.delegate.stringMapKeyRemoved) {
+ this.delegate.stringMapKeyRemoved(key, attributeName, oldValue);
+ }
+ }
+ get knownAttributeNames() {
+ return Array.from(new Set(this.currentAttributeNames.concat(this.recordedAttributeNames)));
+ }
+ get currentAttributeNames() {
+ return Array.from(this.element.attributes).map((attribute) => attribute.name);
+ }
+ get recordedAttributeNames() {
+ return Array.from(this.stringMap.keys());
+ }
+ };
+ var TokenListObserver = class {
+ constructor(element, attributeName, delegate) {
+ this.attributeObserver = new AttributeObserver(element, attributeName, this);
+ this.delegate = delegate;
+ this.tokensByElement = new Multimap();
+ }
+ get started() {
+ return this.attributeObserver.started;
+ }
+ start() {
+ this.attributeObserver.start();
+ }
+ pause(callback) {
+ this.attributeObserver.pause(callback);
+ }
+ stop() {
+ this.attributeObserver.stop();
+ }
+ refresh() {
+ this.attributeObserver.refresh();
+ }
+ get element() {
+ return this.attributeObserver.element;
+ }
+ get attributeName() {
+ return this.attributeObserver.attributeName;
+ }
+ elementMatchedAttribute(element) {
+ this.tokensMatched(this.readTokensForElement(element));
+ }
+ elementAttributeValueChanged(element) {
+ const [unmatchedTokens, matchedTokens] = this.refreshTokensForElement(element);
+ this.tokensUnmatched(unmatchedTokens);
+ this.tokensMatched(matchedTokens);
+ }
+ elementUnmatchedAttribute(element) {
+ this.tokensUnmatched(this.tokensByElement.getValuesForKey(element));
+ }
+ tokensMatched(tokens) {
+ tokens.forEach((token) => this.tokenMatched(token));
+ }
+ tokensUnmatched(tokens) {
+ tokens.forEach((token) => this.tokenUnmatched(token));
+ }
+ tokenMatched(token) {
+ this.delegate.tokenMatched(token);
+ this.tokensByElement.add(token.element, token);
+ }
+ tokenUnmatched(token) {
+ this.delegate.tokenUnmatched(token);
+ this.tokensByElement.delete(token.element, token);
+ }
+ refreshTokensForElement(element) {
+ const previousTokens = this.tokensByElement.getValuesForKey(element);
+ const currentTokens = this.readTokensForElement(element);
+ const firstDifferingIndex = zip(previousTokens, currentTokens).findIndex(([previousToken, currentToken]) => !tokensAreEqual(previousToken, currentToken));
+ if (firstDifferingIndex == -1) {
+ return [[], []];
+ } else {
+ return [previousTokens.slice(firstDifferingIndex), currentTokens.slice(firstDifferingIndex)];
+ }
+ }
+ readTokensForElement(element) {
+ const attributeName = this.attributeName;
+ const tokenString = element.getAttribute(attributeName) || "";
+ return parseTokenString(tokenString, element, attributeName);
+ }
+ };
+ function parseTokenString(tokenString, element, attributeName) {
+ return tokenString.trim().split(/\s+/).filter((content) => content.length).map((content, index) => ({ element, attributeName, content, index }));
+ }
+ function zip(left, right) {
+ const length = Math.max(left.length, right.length);
+ return Array.from({ length }, (_, index) => [left[index], right[index]]);
+ }
+ function tokensAreEqual(left, right) {
+ return left && right && left.index == right.index && left.content == right.content;
+ }
+ var ValueListObserver = class {
+ constructor(element, attributeName, delegate) {
+ this.tokenListObserver = new TokenListObserver(element, attributeName, this);
+ this.delegate = delegate;
+ this.parseResultsByToken = /* @__PURE__ */ new WeakMap();
+ this.valuesByTokenByElement = /* @__PURE__ */ new WeakMap();
+ }
+ get started() {
+ return this.tokenListObserver.started;
+ }
+ start() {
+ this.tokenListObserver.start();
+ }
+ stop() {
+ this.tokenListObserver.stop();
+ }
+ refresh() {
+ this.tokenListObserver.refresh();
+ }
+ get element() {
+ return this.tokenListObserver.element;
+ }
+ get attributeName() {
+ return this.tokenListObserver.attributeName;
+ }
+ tokenMatched(token) {
+ const { element } = token;
+ const { value } = this.fetchParseResultForToken(token);
+ if (value) {
+ this.fetchValuesByTokenForElement(element).set(token, value);
+ this.delegate.elementMatchedValue(element, value);
+ }
+ }
+ tokenUnmatched(token) {
+ const { element } = token;
+ const { value } = this.fetchParseResultForToken(token);
+ if (value) {
+ this.fetchValuesByTokenForElement(element).delete(token);
+ this.delegate.elementUnmatchedValue(element, value);
+ }
+ }
+ fetchParseResultForToken(token) {
+ let parseResult = this.parseResultsByToken.get(token);
+ if (!parseResult) {
+ parseResult = this.parseToken(token);
+ this.parseResultsByToken.set(token, parseResult);
+ }
+ return parseResult;
+ }
+ fetchValuesByTokenForElement(element) {
+ let valuesByToken = this.valuesByTokenByElement.get(element);
+ if (!valuesByToken) {
+ valuesByToken = /* @__PURE__ */ new Map();
+ this.valuesByTokenByElement.set(element, valuesByToken);
+ }
+ return valuesByToken;
+ }
+ parseToken(token) {
+ try {
+ const value = this.delegate.parseValueForToken(token);
+ return { value };
+ } catch (error2) {
+ return { error: error2 };
+ }
+ }
+ };
+ var BindingObserver = class {
+ constructor(context, delegate) {
+ this.context = context;
+ this.delegate = delegate;
+ this.bindingsByAction = /* @__PURE__ */ new Map();
+ }
+ start() {
+ if (!this.valueListObserver) {
+ this.valueListObserver = new ValueListObserver(this.element, this.actionAttribute, this);
+ this.valueListObserver.start();
+ }
+ }
+ stop() {
+ if (this.valueListObserver) {
+ this.valueListObserver.stop();
+ delete this.valueListObserver;
+ this.disconnectAllActions();
+ }
+ }
+ get element() {
+ return this.context.element;
+ }
+ get identifier() {
+ return this.context.identifier;
+ }
+ get actionAttribute() {
+ return this.schema.actionAttribute;
+ }
+ get schema() {
+ return this.context.schema;
+ }
+ get bindings() {
+ return Array.from(this.bindingsByAction.values());
+ }
+ connectAction(action) {
+ const binding = new Binding(this.context, action);
+ this.bindingsByAction.set(action, binding);
+ this.delegate.bindingConnected(binding);
+ }
+ disconnectAction(action) {
+ const binding = this.bindingsByAction.get(action);
+ if (binding) {
+ this.bindingsByAction.delete(action);
+ this.delegate.bindingDisconnected(binding);
+ }
+ }
+ disconnectAllActions() {
+ this.bindings.forEach((binding) => this.delegate.bindingDisconnected(binding, true));
+ this.bindingsByAction.clear();
+ }
+ parseValueForToken(token) {
+ const action = Action.forToken(token, this.schema);
+ if (action.identifier == this.identifier) {
+ return action;
+ }
+ }
+ elementMatchedValue(element, action) {
+ this.connectAction(action);
+ }
+ elementUnmatchedValue(element, action) {
+ this.disconnectAction(action);
+ }
+ };
+ var ValueObserver = class {
+ constructor(context, receiver) {
+ this.context = context;
+ this.receiver = receiver;
+ this.stringMapObserver = new StringMapObserver(this.element, this);
+ this.valueDescriptorMap = this.controller.valueDescriptorMap;
+ }
+ start() {
+ this.stringMapObserver.start();
+ this.invokeChangedCallbacksForDefaultValues();
+ }
+ stop() {
+ this.stringMapObserver.stop();
+ }
+ get element() {
+ return this.context.element;
+ }
+ get controller() {
+ return this.context.controller;
+ }
+ getStringMapKeyForAttribute(attributeName) {
+ if (attributeName in this.valueDescriptorMap) {
+ return this.valueDescriptorMap[attributeName].name;
+ }
+ }
+ stringMapKeyAdded(key, attributeName) {
+ const descriptor = this.valueDescriptorMap[attributeName];
+ if (!this.hasValue(key)) {
+ this.invokeChangedCallback(key, descriptor.writer(this.receiver[key]), descriptor.writer(descriptor.defaultValue));
+ }
+ }
+ stringMapValueChanged(value, name, oldValue) {
+ const descriptor = this.valueDescriptorNameMap[name];
+ if (value === null)
+ return;
+ if (oldValue === null) {
+ oldValue = descriptor.writer(descriptor.defaultValue);
+ }
+ this.invokeChangedCallback(name, value, oldValue);
+ }
+ stringMapKeyRemoved(key, attributeName, oldValue) {
+ const descriptor = this.valueDescriptorNameMap[key];
+ if (this.hasValue(key)) {
+ this.invokeChangedCallback(key, descriptor.writer(this.receiver[key]), oldValue);
+ } else {
+ this.invokeChangedCallback(key, descriptor.writer(descriptor.defaultValue), oldValue);
+ }
+ }
+ invokeChangedCallbacksForDefaultValues() {
+ for (const { key, name, defaultValue, writer } of this.valueDescriptors) {
+ if (defaultValue != void 0 && !this.controller.data.has(key)) {
+ this.invokeChangedCallback(name, writer(defaultValue), void 0);
+ }
+ }
+ }
+ invokeChangedCallback(name, rawValue, rawOldValue) {
+ const changedMethodName = `${name}Changed`;
+ const changedMethod = this.receiver[changedMethodName];
+ if (typeof changedMethod == "function") {
+ const descriptor = this.valueDescriptorNameMap[name];
+ try {
+ const value = descriptor.reader(rawValue);
+ let oldValue = rawOldValue;
+ if (rawOldValue) {
+ oldValue = descriptor.reader(rawOldValue);
+ }
+ changedMethod.call(this.receiver, value, oldValue);
+ } catch (error2) {
+ if (error2 instanceof TypeError) {
+ error2.message = `Stimulus Value "${this.context.identifier}.${descriptor.name}" - ${error2.message}`;
+ }
+ throw error2;
+ }
+ }
+ }
+ get valueDescriptors() {
+ const { valueDescriptorMap } = this;
+ return Object.keys(valueDescriptorMap).map((key) => valueDescriptorMap[key]);
+ }
+ get valueDescriptorNameMap() {
+ const descriptors = {};
+ Object.keys(this.valueDescriptorMap).forEach((key) => {
+ const descriptor = this.valueDescriptorMap[key];
+ descriptors[descriptor.name] = descriptor;
+ });
+ return descriptors;
+ }
+ hasValue(attributeName) {
+ const descriptor = this.valueDescriptorNameMap[attributeName];
+ const hasMethodName = `has${capitalize(descriptor.name)}`;
+ return this.receiver[hasMethodName];
+ }
+ };
+ var TargetObserver = class {
+ constructor(context, delegate) {
+ this.context = context;
+ this.delegate = delegate;
+ this.targetsByName = new Multimap();
+ }
+ start() {
+ if (!this.tokenListObserver) {
+ this.tokenListObserver = new TokenListObserver(this.element, this.attributeName, this);
+ this.tokenListObserver.start();
+ }
+ }
+ stop() {
+ if (this.tokenListObserver) {
+ this.disconnectAllTargets();
+ this.tokenListObserver.stop();
+ delete this.tokenListObserver;
+ }
+ }
+ tokenMatched({ element, content: name }) {
+ if (this.scope.containsElement(element)) {
+ this.connectTarget(element, name);
+ }
+ }
+ tokenUnmatched({ element, content: name }) {
+ this.disconnectTarget(element, name);
+ }
+ connectTarget(element, name) {
+ var _a;
+ if (!this.targetsByName.has(name, element)) {
+ this.targetsByName.add(name, element);
+ (_a = this.tokenListObserver) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.targetConnected(element, name));
+ }
+ }
+ disconnectTarget(element, name) {
+ var _a;
+ if (this.targetsByName.has(name, element)) {
+ this.targetsByName.delete(name, element);
+ (_a = this.tokenListObserver) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.targetDisconnected(element, name));
+ }
+ }
+ disconnectAllTargets() {
+ for (const name of this.targetsByName.keys) {
+ for (const element of this.targetsByName.getValuesForKey(name)) {
+ this.disconnectTarget(element, name);
+ }
+ }
+ }
+ get attributeName() {
+ return `data-${this.context.identifier}-target`;
+ }
+ get element() {
+ return this.context.element;
+ }
+ get scope() {
+ return this.context.scope;
+ }
+ };
+ function readInheritableStaticArrayValues(constructor, propertyName) {
+ const ancestors = getAncestorsForConstructor(constructor);
+ return Array.from(ancestors.reduce((values, constructor2) => {
+ getOwnStaticArrayValues(constructor2, propertyName).forEach((name) => values.add(name));
+ return values;
+ }, /* @__PURE__ */ new Set()));
+ }
+ function readInheritableStaticObjectPairs(constructor, propertyName) {
+ const ancestors = getAncestorsForConstructor(constructor);
+ return ancestors.reduce((pairs, constructor2) => {
+ pairs.push(...getOwnStaticObjectPairs(constructor2, propertyName));
+ return pairs;
+ }, []);
+ }
+ function getAncestorsForConstructor(constructor) {
+ const ancestors = [];
+ while (constructor) {
+ ancestors.push(constructor);
+ constructor = Object.getPrototypeOf(constructor);
+ }
+ return ancestors.reverse();
+ }
+ function getOwnStaticArrayValues(constructor, propertyName) {
+ const definition = constructor[propertyName];
+ return Array.isArray(definition) ? definition : [];
+ }
+ function getOwnStaticObjectPairs(constructor, propertyName) {
+ const definition = constructor[propertyName];
+ return definition ? Object.keys(definition).map((key) => [key, definition[key]]) : [];
+ }
+ var OutletObserver = class {
+ constructor(context, delegate) {
+ this.started = false;
+ this.context = context;
+ this.delegate = delegate;
+ this.outletsByName = new Multimap();
+ this.outletElementsByName = new Multimap();
+ this.selectorObserverMap = /* @__PURE__ */ new Map();
+ this.attributeObserverMap = /* @__PURE__ */ new Map();
+ }
+ start() {
+ if (!this.started) {
+ this.outletDefinitions.forEach((outletName) => {
+ this.setupSelectorObserverForOutlet(outletName);
+ this.setupAttributeObserverForOutlet(outletName);
+ });
+ this.started = true;
+ this.dependentContexts.forEach((context) => context.refresh());
+ }
+ }
+ refresh() {
+ this.selectorObserverMap.forEach((observer) => observer.refresh());
+ this.attributeObserverMap.forEach((observer) => observer.refresh());
+ }
+ stop() {
+ if (this.started) {
+ this.started = false;
+ this.disconnectAllOutlets();
+ this.stopSelectorObservers();
+ this.stopAttributeObservers();
+ }
+ }
+ stopSelectorObservers() {
+ if (this.selectorObserverMap.size > 0) {
+ this.selectorObserverMap.forEach((observer) => observer.stop());
+ this.selectorObserverMap.clear();
+ }
+ }
+ stopAttributeObservers() {
+ if (this.attributeObserverMap.size > 0) {
+ this.attributeObserverMap.forEach((observer) => observer.stop());
+ this.attributeObserverMap.clear();
+ }
+ }
+ selectorMatched(element, _selector, { outletName }) {
+ const outlet = this.getOutlet(element, outletName);
+ if (outlet) {
+ this.connectOutlet(outlet, element, outletName);
+ }
+ }
+ selectorUnmatched(element, _selector, { outletName }) {
+ const outlet = this.getOutletFromMap(element, outletName);
+ if (outlet) {
+ this.disconnectOutlet(outlet, element, outletName);
+ }
+ }
+ selectorMatchElement(element, { outletName }) {
+ const selector = this.selector(outletName);
+ const hasOutlet = this.hasOutlet(element, outletName);
+ const hasOutletController = element.matches(`[${this.schema.controllerAttribute}~=${outletName}]`);
+ if (selector) {
+ return hasOutlet && hasOutletController && element.matches(selector);
+ } else {
+ return false;
+ }
+ }
+ elementMatchedAttribute(_element, attributeName) {
+ const outletName = this.getOutletNameFromOutletAttributeName(attributeName);
+ if (outletName) {
+ this.updateSelectorObserverForOutlet(outletName);
+ }
+ }
+ elementAttributeValueChanged(_element, attributeName) {
+ const outletName = this.getOutletNameFromOutletAttributeName(attributeName);
+ if (outletName) {
+ this.updateSelectorObserverForOutlet(outletName);
+ }
+ }
+ elementUnmatchedAttribute(_element, attributeName) {
+ const outletName = this.getOutletNameFromOutletAttributeName(attributeName);
+ if (outletName) {
+ this.updateSelectorObserverForOutlet(outletName);
+ }
+ }
+ connectOutlet(outlet, element, outletName) {
+ var _a;
+ if (!this.outletElementsByName.has(outletName, element)) {
+ this.outletsByName.add(outletName, outlet);
+ this.outletElementsByName.add(outletName, element);
+ (_a = this.selectorObserverMap.get(outletName)) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.outletConnected(outlet, element, outletName));
+ }
+ }
+ disconnectOutlet(outlet, element, outletName) {
+ var _a;
+ if (this.outletElementsByName.has(outletName, element)) {
+ this.outletsByName.delete(outletName, outlet);
+ this.outletElementsByName.delete(outletName, element);
+ (_a = this.selectorObserverMap.get(outletName)) === null || _a === void 0 ? void 0 : _a.pause(() => this.delegate.outletDisconnected(outlet, element, outletName));
+ }
+ }
+ disconnectAllOutlets() {
+ for (const outletName of this.outletElementsByName.keys) {
+ for (const element of this.outletElementsByName.getValuesForKey(outletName)) {
+ for (const outlet of this.outletsByName.getValuesForKey(outletName)) {
+ this.disconnectOutlet(outlet, element, outletName);
+ }
+ }
+ }
+ }
+ updateSelectorObserverForOutlet(outletName) {
+ const observer = this.selectorObserverMap.get(outletName);
+ if (observer) {
+ observer.selector = this.selector(outletName);
+ }
+ }
+ setupSelectorObserverForOutlet(outletName) {
+ const selector = this.selector(outletName);
+ const selectorObserver = new SelectorObserver(document.body, selector, this, { outletName });
+ this.selectorObserverMap.set(outletName, selectorObserver);
+ selectorObserver.start();
+ }
+ setupAttributeObserverForOutlet(outletName) {
+ const attributeName = this.attributeNameForOutletName(outletName);
+ const attributeObserver = new AttributeObserver(this.scope.element, attributeName, this);
+ this.attributeObserverMap.set(outletName, attributeObserver);
+ attributeObserver.start();
+ }
+ selector(outletName) {
+ return this.scope.outlets.getSelectorForOutletName(outletName);
+ }
+ attributeNameForOutletName(outletName) {
+ return this.scope.schema.outletAttributeForScope(this.identifier, outletName);
+ }
+ getOutletNameFromOutletAttributeName(attributeName) {
+ return this.outletDefinitions.find((outletName) => this.attributeNameForOutletName(outletName) === attributeName);
+ }
+ get outletDependencies() {
+ const dependencies = new Multimap();
+ this.router.modules.forEach((module) => {
+ const constructor = module.definition.controllerConstructor;
+ const outlets = readInheritableStaticArrayValues(constructor, "outlets");
+ outlets.forEach((outlet) => dependencies.add(outlet, module.identifier));
+ });
+ return dependencies;
+ }
+ get outletDefinitions() {
+ return this.outletDependencies.getKeysForValue(this.identifier);
+ }
+ get dependentControllerIdentifiers() {
+ return this.outletDependencies.getValuesForKey(this.identifier);
+ }
+ get dependentContexts() {
+ const identifiers = this.dependentControllerIdentifiers;
+ return this.router.contexts.filter((context) => identifiers.includes(context.identifier));
+ }
+ hasOutlet(element, outletName) {
+ return !!this.getOutlet(element, outletName) || !!this.getOutletFromMap(element, outletName);
+ }
+ getOutlet(element, outletName) {
+ return this.application.getControllerForElementAndIdentifier(element, outletName);
+ }
+ getOutletFromMap(element, outletName) {
+ return this.outletsByName.getValuesForKey(outletName).find((outlet) => outlet.element === element);
+ }
+ get scope() {
+ return this.context.scope;
+ }
+ get schema() {
+ return this.context.schema;
+ }
+ get identifier() {
+ return this.context.identifier;
+ }
+ get application() {
+ return this.context.application;
+ }
+ get router() {
+ return this.application.router;
+ }
+ };
+ var Context = class {
+ constructor(module, scope) {
+ this.logDebugActivity = (functionName, detail = {}) => {
+ const { identifier, controller, element } = this;
+ detail = Object.assign({ identifier, controller, element }, detail);
+ this.application.logDebugActivity(this.identifier, functionName, detail);
+ };
+ this.module = module;
+ this.scope = scope;
+ this.controller = new module.controllerConstructor(this);
+ this.bindingObserver = new BindingObserver(this, this.dispatcher);
+ this.valueObserver = new ValueObserver(this, this.controller);
+ this.targetObserver = new TargetObserver(this, this);
+ this.outletObserver = new OutletObserver(this, this);
+ try {
+ this.controller.initialize();
+ this.logDebugActivity("initialize");
+ } catch (error2) {
+ this.handleError(error2, "initializing controller");
+ }
+ }
+ connect() {
+ this.bindingObserver.start();
+ this.valueObserver.start();
+ this.targetObserver.start();
+ this.outletObserver.start();
+ try {
+ this.controller.connect();
+ this.logDebugActivity("connect");
+ } catch (error2) {
+ this.handleError(error2, "connecting controller");
+ }
+ }
+ refresh() {
+ this.outletObserver.refresh();
+ }
+ disconnect() {
+ try {
+ this.controller.disconnect();
+ this.logDebugActivity("disconnect");
+ } catch (error2) {
+ this.handleError(error2, "disconnecting controller");
+ }
+ this.outletObserver.stop();
+ this.targetObserver.stop();
+ this.valueObserver.stop();
+ this.bindingObserver.stop();
+ }
+ get application() {
+ return this.module.application;
+ }
+ get identifier() {
+ return this.module.identifier;
+ }
+ get schema() {
+ return this.application.schema;
+ }
+ get dispatcher() {
+ return this.application.dispatcher;
+ }
+ get element() {
+ return this.scope.element;
+ }
+ get parentElement() {
+ return this.element.parentElement;
+ }
+ handleError(error2, message, detail = {}) {
+ const { identifier, controller, element } = this;
+ detail = Object.assign({ identifier, controller, element }, detail);
+ this.application.handleError(error2, `Error ${message}`, detail);
+ }
+ targetConnected(element, name) {
+ this.invokeControllerMethod(`${name}TargetConnected`, element);
+ }
+ targetDisconnected(element, name) {
+ this.invokeControllerMethod(`${name}TargetDisconnected`, element);
+ }
+ outletConnected(outlet, element, name) {
+ this.invokeControllerMethod(`${namespaceCamelize(name)}OutletConnected`, outlet, element);
+ }
+ outletDisconnected(outlet, element, name) {
+ this.invokeControllerMethod(`${namespaceCamelize(name)}OutletDisconnected`, outlet, element);
+ }
+ invokeControllerMethod(methodName, ...args) {
+ const controller = this.controller;
+ if (typeof controller[methodName] == "function") {
+ controller[methodName](...args);
+ }
+ }
+ };
+ function bless(constructor) {
+ return shadow(constructor, getBlessedProperties(constructor));
+ }
+ function shadow(constructor, properties) {
+ const shadowConstructor = extend(constructor);
+ const shadowProperties = getShadowProperties(constructor.prototype, properties);
+ Object.defineProperties(shadowConstructor.prototype, shadowProperties);
+ return shadowConstructor;
+ }
+ function getBlessedProperties(constructor) {
+ const blessings = readInheritableStaticArrayValues(constructor, "blessings");
+ return blessings.reduce((blessedProperties, blessing) => {
+ const properties = blessing(constructor);
+ for (const key in properties) {
+ const descriptor = blessedProperties[key] || {};
+ blessedProperties[key] = Object.assign(descriptor, properties[key]);
+ }
+ return blessedProperties;
+ }, {});
+ }
+ function getShadowProperties(prototype, properties) {
+ return getOwnKeys(properties).reduce((shadowProperties, key) => {
+ const descriptor = getShadowedDescriptor(prototype, properties, key);
+ if (descriptor) {
+ Object.assign(shadowProperties, { [key]: descriptor });
+ }
+ return shadowProperties;
+ }, {});
+ }
+ function getShadowedDescriptor(prototype, properties, key) {
+ const shadowingDescriptor = Object.getOwnPropertyDescriptor(prototype, key);
+ const shadowedByValue = shadowingDescriptor && "value" in shadowingDescriptor;
+ if (!shadowedByValue) {
+ const descriptor = Object.getOwnPropertyDescriptor(properties, key).value;
+ if (shadowingDescriptor) {
+ descriptor.get = shadowingDescriptor.get || descriptor.get;
+ descriptor.set = shadowingDescriptor.set || descriptor.set;
+ }
+ return descriptor;
+ }
+ }
+ var getOwnKeys = (() => {
+ if (typeof Object.getOwnPropertySymbols == "function") {
+ return (object) => [...Object.getOwnPropertyNames(object), ...Object.getOwnPropertySymbols(object)];
+ } else {
+ return Object.getOwnPropertyNames;
+ }
+ })();
+ var extend = (() => {
+ function extendWithReflect(constructor) {
+ function extended() {
+ return Reflect.construct(constructor, arguments, new.target);
+ }
+ extended.prototype = Object.create(constructor.prototype, {
+ constructor: { value: extended }
+ });
+ Reflect.setPrototypeOf(extended, constructor);
+ return extended;
+ }
+ function testReflectExtension() {
+ const a = function() {
+ this.a.call(this);
+ };
+ const b = extendWithReflect(a);
+ b.prototype.a = function() {
+ };
+ return new b();
+ }
+ try {
+ testReflectExtension();
+ return extendWithReflect;
+ } catch (error2) {
+ return (constructor) => class extended extends constructor {
+ };
+ }
+ })();
+ function blessDefinition(definition) {
+ return {
+ identifier: definition.identifier,
+ controllerConstructor: bless(definition.controllerConstructor)
+ };
+ }
+ var Module = class {
+ constructor(application2, definition) {
+ this.application = application2;
+ this.definition = blessDefinition(definition);
+ this.contextsByScope = /* @__PURE__ */ new WeakMap();
+ this.connectedContexts = /* @__PURE__ */ new Set();
+ }
+ get identifier() {
+ return this.definition.identifier;
+ }
+ get controllerConstructor() {
+ return this.definition.controllerConstructor;
+ }
+ get contexts() {
+ return Array.from(this.connectedContexts);
+ }
+ connectContextForScope(scope) {
+ const context = this.fetchContextForScope(scope);
+ this.connectedContexts.add(context);
+ context.connect();
+ }
+ disconnectContextForScope(scope) {
+ const context = this.contextsByScope.get(scope);
+ if (context) {
+ this.connectedContexts.delete(context);
+ context.disconnect();
+ }
+ }
+ fetchContextForScope(scope) {
+ let context = this.contextsByScope.get(scope);
+ if (!context) {
+ context = new Context(this, scope);
+ this.contextsByScope.set(scope, context);
+ }
+ return context;
+ }
+ };
+ var ClassMap = class {
+ constructor(scope) {
+ this.scope = scope;
+ }
+ has(name) {
+ return this.data.has(this.getDataKey(name));
+ }
+ get(name) {
+ return this.getAll(name)[0];
+ }
+ getAll(name) {
+ const tokenString = this.data.get(this.getDataKey(name)) || "";
+ return tokenize(tokenString);
+ }
+ getAttributeName(name) {
+ return this.data.getAttributeNameForKey(this.getDataKey(name));
+ }
+ getDataKey(name) {
+ return `${name}-class`;
+ }
+ get data() {
+ return this.scope.data;
+ }
+ };
+ var DataMap = class {
+ constructor(scope) {
+ this.scope = scope;
+ }
+ get element() {
+ return this.scope.element;
+ }
+ get identifier() {
+ return this.scope.identifier;
+ }
+ get(key) {
+ const name = this.getAttributeNameForKey(key);
+ return this.element.getAttribute(name);
+ }
+ set(key, value) {
+ const name = this.getAttributeNameForKey(key);
+ this.element.setAttribute(name, value);
+ return this.get(key);
+ }
+ has(key) {
+ const name = this.getAttributeNameForKey(key);
+ return this.element.hasAttribute(name);
+ }
+ delete(key) {
+ if (this.has(key)) {
+ const name = this.getAttributeNameForKey(key);
+ this.element.removeAttribute(name);
+ return true;
+ } else {
+ return false;
+ }
+ }
+ getAttributeNameForKey(key) {
+ return `data-${this.identifier}-${dasherize(key)}`;
+ }
+ };
+ var Guide = class {
+ constructor(logger) {
+ this.warnedKeysByObject = /* @__PURE__ */ new WeakMap();
+ this.logger = logger;
+ }
+ warn(object, key, message) {
+ let warnedKeys = this.warnedKeysByObject.get(object);
+ if (!warnedKeys) {
+ warnedKeys = /* @__PURE__ */ new Set();
+ this.warnedKeysByObject.set(object, warnedKeys);
+ }
+ if (!warnedKeys.has(key)) {
+ warnedKeys.add(key);
+ this.logger.warn(message, object);
+ }
+ }
+ };
+ function attributeValueContainsToken(attributeName, token) {
+ return `[${attributeName}~="${token}"]`;
+ }
+ var TargetSet = class {
+ constructor(scope) {
+ this.scope = scope;
+ }
+ get element() {
+ return this.scope.element;
+ }
+ get identifier() {
+ return this.scope.identifier;
+ }
+ get schema() {
+ return this.scope.schema;
+ }
+ has(targetName) {
+ return this.find(targetName) != null;
+ }
+ find(...targetNames) {
+ return targetNames.reduce((target, targetName) => target || this.findTarget(targetName) || this.findLegacyTarget(targetName), void 0);
+ }
+ findAll(...targetNames) {
+ return targetNames.reduce((targets, targetName) => [
+ ...targets,
+ ...this.findAllTargets(targetName),
+ ...this.findAllLegacyTargets(targetName)
+ ], []);
+ }
+ findTarget(targetName) {
+ const selector = this.getSelectorForTargetName(targetName);
+ return this.scope.findElement(selector);
+ }
+ findAllTargets(targetName) {
+ const selector = this.getSelectorForTargetName(targetName);
+ return this.scope.findAllElements(selector);
+ }
+ getSelectorForTargetName(targetName) {
+ const attributeName = this.schema.targetAttributeForScope(this.identifier);
+ return attributeValueContainsToken(attributeName, targetName);
+ }
+ findLegacyTarget(targetName) {
+ const selector = this.getLegacySelectorForTargetName(targetName);
+ return this.deprecate(this.scope.findElement(selector), targetName);
+ }
+ findAllLegacyTargets(targetName) {
+ const selector = this.getLegacySelectorForTargetName(targetName);
+ return this.scope.findAllElements(selector).map((element) => this.deprecate(element, targetName));
+ }
+ getLegacySelectorForTargetName(targetName) {
+ const targetDescriptor = `${this.identifier}.${targetName}`;
+ return attributeValueContainsToken(this.schema.targetAttribute, targetDescriptor);
+ }
+ deprecate(element, targetName) {
+ if (element) {
+ const { identifier } = this;
+ const attributeName = this.schema.targetAttribute;
+ const revisedAttributeName = this.schema.targetAttributeForScope(identifier);
+ this.guide.warn(element, `target:${targetName}`, `Please replace ${attributeName}="${identifier}.${targetName}" with ${revisedAttributeName}="${targetName}". The ${attributeName} attribute is deprecated and will be removed in a future version of Stimulus.`);
+ }
+ return element;
+ }
+ get guide() {
+ return this.scope.guide;
+ }
+ };
+ var OutletSet = class {
+ constructor(scope, controllerElement) {
+ this.scope = scope;
+ this.controllerElement = controllerElement;
+ }
+ get element() {
+ return this.scope.element;
+ }
+ get identifier() {
+ return this.scope.identifier;
+ }
+ get schema() {
+ return this.scope.schema;
+ }
+ has(outletName) {
+ return this.find(outletName) != null;
+ }
+ find(...outletNames) {
+ return outletNames.reduce((outlet, outletName) => outlet || this.findOutlet(outletName), void 0);
+ }
+ findAll(...outletNames) {
+ return outletNames.reduce((outlets, outletName) => [...outlets, ...this.findAllOutlets(outletName)], []);
+ }
+ getSelectorForOutletName(outletName) {
+ const attributeName = this.schema.outletAttributeForScope(this.identifier, outletName);
+ return this.controllerElement.getAttribute(attributeName);
+ }
+ findOutlet(outletName) {
+ const selector = this.getSelectorForOutletName(outletName);
+ if (selector)
+ return this.findElement(selector, outletName);
+ }
+ findAllOutlets(outletName) {
+ const selector = this.getSelectorForOutletName(outletName);
+ return selector ? this.findAllElements(selector, outletName) : [];
+ }
+ findElement(selector, outletName) {
+ const elements = this.scope.queryElements(selector);
+ return elements.filter((element) => this.matchesElement(element, selector, outletName))[0];
+ }
+ findAllElements(selector, outletName) {
+ const elements = this.scope.queryElements(selector);
+ return elements.filter((element) => this.matchesElement(element, selector, outletName));
+ }
+ matchesElement(element, selector, outletName) {
+ const controllerAttribute = element.getAttribute(this.scope.schema.controllerAttribute) || "";
+ return element.matches(selector) && controllerAttribute.split(" ").includes(outletName);
+ }
+ };
+ var Scope = class _Scope {
+ constructor(schema, element, identifier, logger) {
+ this.targets = new TargetSet(this);
+ this.classes = new ClassMap(this);
+ this.data = new DataMap(this);
+ this.containsElement = (element2) => {
+ return element2.closest(this.controllerSelector) === this.element;
+ };
+ this.schema = schema;
+ this.element = element;
+ this.identifier = identifier;
+ this.guide = new Guide(logger);
+ this.outlets = new OutletSet(this.documentScope, element);
+ }
+ findElement(selector) {
+ return this.element.matches(selector) ? this.element : this.queryElements(selector).find(this.containsElement);
+ }
+ findAllElements(selector) {
+ return [
+ ...this.element.matches(selector) ? [this.element] : [],
+ ...this.queryElements(selector).filter(this.containsElement)
+ ];
+ }
+ queryElements(selector) {
+ return Array.from(this.element.querySelectorAll(selector));
+ }
+ get controllerSelector() {
+ return attributeValueContainsToken(this.schema.controllerAttribute, this.identifier);
+ }
+ get isDocumentScope() {
+ return this.element === document.documentElement;
+ }
+ get documentScope() {
+ return this.isDocumentScope ? this : new _Scope(this.schema, document.documentElement, this.identifier, this.guide.logger);
+ }
+ };
+ var ScopeObserver = class {
+ constructor(element, schema, delegate) {
+ this.element = element;
+ this.schema = schema;
+ this.delegate = delegate;
+ this.valueListObserver = new ValueListObserver(this.element, this.controllerAttribute, this);
+ this.scopesByIdentifierByElement = /* @__PURE__ */ new WeakMap();
+ this.scopeReferenceCounts = /* @__PURE__ */ new WeakMap();
+ }
+ start() {
+ this.valueListObserver.start();
+ }
+ stop() {
+ this.valueListObserver.stop();
+ }
+ get controllerAttribute() {
+ return this.schema.controllerAttribute;
+ }
+ parseValueForToken(token) {
+ const { element, content: identifier } = token;
+ return this.parseValueForElementAndIdentifier(element, identifier);
+ }
+ parseValueForElementAndIdentifier(element, identifier) {
+ const scopesByIdentifier = this.fetchScopesByIdentifierForElement(element);
+ let scope = scopesByIdentifier.get(identifier);
+ if (!scope) {
+ scope = this.delegate.createScopeForElementAndIdentifier(element, identifier);
+ scopesByIdentifier.set(identifier, scope);
+ }
+ return scope;
+ }
+ elementMatchedValue(element, value) {
+ const referenceCount = (this.scopeReferenceCounts.get(value) || 0) + 1;
+ this.scopeReferenceCounts.set(value, referenceCount);
+ if (referenceCount == 1) {
+ this.delegate.scopeConnected(value);
+ }
+ }
+ elementUnmatchedValue(element, value) {
+ const referenceCount = this.scopeReferenceCounts.get(value);
+ if (referenceCount) {
+ this.scopeReferenceCounts.set(value, referenceCount - 1);
+ if (referenceCount == 1) {
+ this.delegate.scopeDisconnected(value);
+ }
+ }
+ }
+ fetchScopesByIdentifierForElement(element) {
+ let scopesByIdentifier = this.scopesByIdentifierByElement.get(element);
+ if (!scopesByIdentifier) {
+ scopesByIdentifier = /* @__PURE__ */ new Map();
+ this.scopesByIdentifierByElement.set(element, scopesByIdentifier);
+ }
+ return scopesByIdentifier;
+ }
+ };
+ var Router = class {
+ constructor(application2) {
+ this.application = application2;
+ this.scopeObserver = new ScopeObserver(this.element, this.schema, this);
+ this.scopesByIdentifier = new Multimap();
+ this.modulesByIdentifier = /* @__PURE__ */ new Map();
+ }
+ get element() {
+ return this.application.element;
+ }
+ get schema() {
+ return this.application.schema;
+ }
+ get logger() {
+ return this.application.logger;
+ }
+ get controllerAttribute() {
+ return this.schema.controllerAttribute;
+ }
+ get modules() {
+ return Array.from(this.modulesByIdentifier.values());
+ }
+ get contexts() {
+ return this.modules.reduce((contexts, module) => contexts.concat(module.contexts), []);
+ }
+ start() {
+ this.scopeObserver.start();
+ }
+ stop() {
+ this.scopeObserver.stop();
+ }
+ loadDefinition(definition) {
+ this.unloadIdentifier(definition.identifier);
+ const module = new Module(this.application, definition);
+ this.connectModule(module);
+ const afterLoad = definition.controllerConstructor.afterLoad;
+ if (afterLoad) {
+ afterLoad.call(definition.controllerConstructor, definition.identifier, this.application);
+ }
+ }
+ unloadIdentifier(identifier) {
+ const module = this.modulesByIdentifier.get(identifier);
+ if (module) {
+ this.disconnectModule(module);
+ }
+ }
+ getContextForElementAndIdentifier(element, identifier) {
+ const module = this.modulesByIdentifier.get(identifier);
+ if (module) {
+ return module.contexts.find((context) => context.element == element);
+ }
+ }
+ proposeToConnectScopeForElementAndIdentifier(element, identifier) {
+ const scope = this.scopeObserver.parseValueForElementAndIdentifier(element, identifier);
+ if (scope) {
+ this.scopeObserver.elementMatchedValue(scope.element, scope);
+ } else {
+ console.error(`Couldn't find or create scope for identifier: "${identifier}" and element:`, element);
+ }
+ }
+ handleError(error2, message, detail) {
+ this.application.handleError(error2, message, detail);
+ }
+ createScopeForElementAndIdentifier(element, identifier) {
+ return new Scope(this.schema, element, identifier, this.logger);
+ }
+ scopeConnected(scope) {
+ this.scopesByIdentifier.add(scope.identifier, scope);
+ const module = this.modulesByIdentifier.get(scope.identifier);
+ if (module) {
+ module.connectContextForScope(scope);
+ }
+ }
+ scopeDisconnected(scope) {
+ this.scopesByIdentifier.delete(scope.identifier, scope);
+ const module = this.modulesByIdentifier.get(scope.identifier);
+ if (module) {
+ module.disconnectContextForScope(scope);
+ }
+ }
+ connectModule(module) {
+ this.modulesByIdentifier.set(module.identifier, module);
+ const scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);
+ scopes.forEach((scope) => module.connectContextForScope(scope));
+ }
+ disconnectModule(module) {
+ this.modulesByIdentifier.delete(module.identifier);
+ const scopes = this.scopesByIdentifier.getValuesForKey(module.identifier);
+ scopes.forEach((scope) => module.disconnectContextForScope(scope));
+ }
+ };
+ var defaultSchema = {
+ controllerAttribute: "data-controller",
+ actionAttribute: "data-action",
+ targetAttribute: "data-target",
+ targetAttributeForScope: (identifier) => `data-${identifier}-target`,
+ outletAttributeForScope: (identifier, outlet) => `data-${identifier}-${outlet}-outlet`,
+ keyMappings: Object.assign(Object.assign({ enter: "Enter", tab: "Tab", esc: "Escape", space: " ", up: "ArrowUp", down: "ArrowDown", left: "ArrowLeft", right: "ArrowRight", home: "Home", end: "End", page_up: "PageUp", page_down: "PageDown" }, objectFromEntries("abcdefghijklmnopqrstuvwxyz".split("").map((c) => [c, c]))), objectFromEntries("0123456789".split("").map((n) => [n, n])))
+ };
+ function objectFromEntries(array) {
+ return array.reduce((memo, [k, v]) => Object.assign(Object.assign({}, memo), { [k]: v }), {});
+ }
+ var Application = class {
+ constructor(element = document.documentElement, schema = defaultSchema) {
+ this.logger = console;
+ this.debug = false;
+ this.logDebugActivity = (identifier, functionName, detail = {}) => {
+ if (this.debug) {
+ this.logFormattedMessage(identifier, functionName, detail);
+ }
+ };
+ this.element = element;
+ this.schema = schema;
+ this.dispatcher = new Dispatcher(this);
+ this.router = new Router(this);
+ this.actionDescriptorFilters = Object.assign({}, defaultActionDescriptorFilters);
+ }
+ static start(element, schema) {
+ const application2 = new this(element, schema);
+ application2.start();
+ return application2;
+ }
+ async start() {
+ await domReady();
+ this.logDebugActivity("application", "starting");
+ this.dispatcher.start();
+ this.router.start();
+ this.logDebugActivity("application", "start");
+ }
+ stop() {
+ this.logDebugActivity("application", "stopping");
+ this.dispatcher.stop();
+ this.router.stop();
+ this.logDebugActivity("application", "stop");
+ }
+ register(identifier, controllerConstructor) {
+ this.load({ identifier, controllerConstructor });
+ }
+ registerActionOption(name, filter) {
+ this.actionDescriptorFilters[name] = filter;
+ }
+ load(head, ...rest) {
+ const definitions = Array.isArray(head) ? head : [head, ...rest];
+ definitions.forEach((definition) => {
+ if (definition.controllerConstructor.shouldLoad) {
+ this.router.loadDefinition(definition);
+ }
+ });
+ }
+ unload(head, ...rest) {
+ const identifiers = Array.isArray(head) ? head : [head, ...rest];
+ identifiers.forEach((identifier) => this.router.unloadIdentifier(identifier));
+ }
+ get controllers() {
+ return this.router.contexts.map((context) => context.controller);
+ }
+ getControllerForElementAndIdentifier(element, identifier) {
+ const context = this.router.getContextForElementAndIdentifier(element, identifier);
+ return context ? context.controller : null;
+ }
+ handleError(error2, message, detail) {
+ var _a;
+ this.logger.error(`%s
- // app/assets/javascripts/administrate/components/select.js
- $(function() {
- $(".field-unit--select select").selectize({});
- });
+%o
+
+%o`, message, error2, detail);
+ (_a = window.onerror) === null || _a === void 0 ? void 0 : _a.call(window, message, "", 0, 0, error2);
+ }
+ logFormattedMessage(identifier, functionName, detail = {}) {
+ detail = Object.assign({ application: this }, detail);
+ this.logger.groupCollapsed(`${identifier} #${functionName}`);
+ this.logger.log("details:", Object.assign({}, detail));
+ this.logger.groupEnd();
+ }
+ };
+ function domReady() {
+ return new Promise((resolve) => {
+ if (document.readyState == "loading") {
+ document.addEventListener("DOMContentLoaded", () => resolve());
+ } else {
+ resolve();
+ }
+ });
+ }
+ function ClassPropertiesBlessing(constructor) {
+ const classes = readInheritableStaticArrayValues(constructor, "classes");
+ return classes.reduce((properties, classDefinition) => {
+ return Object.assign(properties, propertiesForClassDefinition(classDefinition));
+ }, {});
+ }
+ function propertiesForClassDefinition(key) {
+ return {
+ [`${key}Class`]: {
+ get() {
+ const { classes } = this;
+ if (classes.has(key)) {
+ return classes.get(key);
+ } else {
+ const attribute = classes.getAttributeName(key);
+ throw new Error(`Missing attribute "${attribute}"`);
+ }
+ }
+ },
+ [`${key}Classes`]: {
+ get() {
+ return this.classes.getAll(key);
+ }
+ },
+ [`has${capitalize(key)}Class`]: {
+ get() {
+ return this.classes.has(key);
+ }
+ }
+ };
+ }
+ function OutletPropertiesBlessing(constructor) {
+ const outlets = readInheritableStaticArrayValues(constructor, "outlets");
+ return outlets.reduce((properties, outletDefinition) => {
+ return Object.assign(properties, propertiesForOutletDefinition(outletDefinition));
+ }, {});
+ }
+ function getOutletController(controller, element, identifier) {
+ return controller.application.getControllerForElementAndIdentifier(element, identifier);
+ }
+ function getControllerAndEnsureConnectedScope(controller, element, outletName) {
+ let outletController = getOutletController(controller, element, outletName);
+ if (outletController)
+ return outletController;
+ controller.application.router.proposeToConnectScopeForElementAndIdentifier(element, outletName);
+ outletController = getOutletController(controller, element, outletName);
+ if (outletController)
+ return outletController;
+ }
+ function propertiesForOutletDefinition(name) {
+ const camelizedName = namespaceCamelize(name);
+ return {
+ [`${camelizedName}Outlet`]: {
+ get() {
+ const outletElement = this.outlets.find(name);
+ const selector = this.outlets.getSelectorForOutletName(name);
+ if (outletElement) {
+ const outletController = getControllerAndEnsureConnectedScope(this, outletElement, name);
+ if (outletController)
+ return outletController;
+ throw new Error(`The provided outlet element is missing an outlet controller "${name}" instance for host controller "${this.identifier}"`);
+ }
+ throw new Error(`Missing outlet element "${name}" for host controller "${this.identifier}". Stimulus couldn't find a matching outlet element using selector "${selector}".`);
+ }
+ },
+ [`${camelizedName}Outlets`]: {
+ get() {
+ const outlets = this.outlets.findAll(name);
+ if (outlets.length > 0) {
+ return outlets.map((outletElement) => {
+ const outletController = getControllerAndEnsureConnectedScope(this, outletElement, name);
+ if (outletController)
+ return outletController;
+ console.warn(`The provided outlet element is missing an outlet controller "${name}" instance for host controller "${this.identifier}"`, outletElement);
+ }).filter((controller) => controller);
+ }
+ return [];
+ }
+ },
+ [`${camelizedName}OutletElement`]: {
+ get() {
+ const outletElement = this.outlets.find(name);
+ const selector = this.outlets.getSelectorForOutletName(name);
+ if (outletElement) {
+ return outletElement;
+ } else {
+ throw new Error(`Missing outlet element "${name}" for host controller "${this.identifier}". Stimulus couldn't find a matching outlet element using selector "${selector}".`);
+ }
+ }
+ },
+ [`${camelizedName}OutletElements`]: {
+ get() {
+ return this.outlets.findAll(name);
+ }
+ },
+ [`has${capitalize(camelizedName)}Outlet`]: {
+ get() {
+ return this.outlets.has(name);
+ }
+ }
+ };
+ }
+ function TargetPropertiesBlessing(constructor) {
+ const targets = readInheritableStaticArrayValues(constructor, "targets");
+ return targets.reduce((properties, targetDefinition) => {
+ return Object.assign(properties, propertiesForTargetDefinition(targetDefinition));
+ }, {});
+ }
+ function propertiesForTargetDefinition(name) {
+ return {
+ [`${name}Target`]: {
+ get() {
+ const target = this.targets.find(name);
+ if (target) {
+ return target;
+ } else {
+ throw new Error(`Missing target element "${name}" for "${this.identifier}" controller`);
+ }
+ }
+ },
+ [`${name}Targets`]: {
+ get() {
+ return this.targets.findAll(name);
+ }
+ },
+ [`has${capitalize(name)}Target`]: {
+ get() {
+ return this.targets.has(name);
+ }
+ }
+ };
+ }
+ function ValuePropertiesBlessing(constructor) {
+ const valueDefinitionPairs = readInheritableStaticObjectPairs(constructor, "values");
+ const propertyDescriptorMap = {
+ valueDescriptorMap: {
+ get() {
+ return valueDefinitionPairs.reduce((result, valueDefinitionPair) => {
+ const valueDescriptor = parseValueDefinitionPair(valueDefinitionPair, this.identifier);
+ const attributeName = this.data.getAttributeNameForKey(valueDescriptor.key);
+ return Object.assign(result, { [attributeName]: valueDescriptor });
+ }, {});
+ }
+ }
+ };
+ return valueDefinitionPairs.reduce((properties, valueDefinitionPair) => {
+ return Object.assign(properties, propertiesForValueDefinitionPair(valueDefinitionPair));
+ }, propertyDescriptorMap);
+ }
+ function propertiesForValueDefinitionPair(valueDefinitionPair, controller) {
+ const definition = parseValueDefinitionPair(valueDefinitionPair, controller);
+ const { key, name, reader: read, writer: write } = definition;
+ return {
+ [name]: {
+ get() {
+ const value = this.data.get(key);
+ if (value !== null) {
+ return read(value);
+ } else {
+ return definition.defaultValue;
+ }
+ },
+ set(value) {
+ if (value === void 0) {
+ this.data.delete(key);
+ } else {
+ this.data.set(key, write(value));
+ }
+ }
+ },
+ [`has${capitalize(name)}`]: {
+ get() {
+ return this.data.has(key) || definition.hasCustomDefaultValue;
+ }
+ }
+ };
+ }
+ function parseValueDefinitionPair([token, typeDefinition], controller) {
+ return valueDescriptorForTokenAndTypeDefinition({
+ controller,
+ token,
+ typeDefinition
+ });
+ }
+ function parseValueTypeConstant(constant) {
+ switch (constant) {
+ case Array:
+ return "array";
+ case Boolean:
+ return "boolean";
+ case Number:
+ return "number";
+ case Object:
+ return "object";
+ case String:
+ return "string";
+ }
+ }
+ function parseValueTypeDefault(defaultValue) {
+ switch (typeof defaultValue) {
+ case "boolean":
+ return "boolean";
+ case "number":
+ return "number";
+ case "string":
+ return "string";
+ }
+ if (Array.isArray(defaultValue))
+ return "array";
+ if (Object.prototype.toString.call(defaultValue) === "[object Object]")
+ return "object";
+ }
+ function parseValueTypeObject(payload) {
+ const { controller, token, typeObject } = payload;
+ const hasType = isSomething(typeObject.type);
+ const hasDefault = isSomething(typeObject.default);
+ const fullObject = hasType && hasDefault;
+ const onlyType = hasType && !hasDefault;
+ const onlyDefault = !hasType && hasDefault;
+ const typeFromObject = parseValueTypeConstant(typeObject.type);
+ const typeFromDefaultValue = parseValueTypeDefault(payload.typeObject.default);
+ if (onlyType)
+ return typeFromObject;
+ if (onlyDefault)
+ return typeFromDefaultValue;
+ if (typeFromObject !== typeFromDefaultValue) {
+ const propertyPath = controller ? `${controller}.${token}` : token;
+ throw new Error(`The specified default value for the Stimulus Value "${propertyPath}" must match the defined type "${typeFromObject}". The provided default value of "${typeObject.default}" is of type "${typeFromDefaultValue}".`);
+ }
+ if (fullObject)
+ return typeFromObject;
+ }
+ function parseValueTypeDefinition(payload) {
+ const { controller, token, typeDefinition } = payload;
+ const typeObject = { controller, token, typeObject: typeDefinition };
+ const typeFromObject = parseValueTypeObject(typeObject);
+ const typeFromDefaultValue = parseValueTypeDefault(typeDefinition);
+ const typeFromConstant = parseValueTypeConstant(typeDefinition);
+ const type = typeFromObject || typeFromDefaultValue || typeFromConstant;
+ if (type)
+ return type;
+ const propertyPath = controller ? `${controller}.${typeDefinition}` : token;
+ throw new Error(`Unknown value type "${propertyPath}" for "${token}" value`);
+ }
+ function defaultValueForDefinition(typeDefinition) {
+ const constant = parseValueTypeConstant(typeDefinition);
+ if (constant)
+ return defaultValuesByType[constant];
+ const hasDefault = hasProperty(typeDefinition, "default");
+ const hasType = hasProperty(typeDefinition, "type");
+ const typeObject = typeDefinition;
+ if (hasDefault)
+ return typeObject.default;
+ if (hasType) {
+ const { type } = typeObject;
+ const constantFromType = parseValueTypeConstant(type);
+ if (constantFromType)
+ return defaultValuesByType[constantFromType];
+ }
+ return typeDefinition;
+ }
+ function valueDescriptorForTokenAndTypeDefinition(payload) {
+ const { token, typeDefinition } = payload;
+ const key = `${dasherize(token)}-value`;
+ const type = parseValueTypeDefinition(payload);
+ return {
+ type,
+ key,
+ name: camelize(key),
+ get defaultValue() {
+ return defaultValueForDefinition(typeDefinition);
+ },
+ get hasCustomDefaultValue() {
+ return parseValueTypeDefault(typeDefinition) !== void 0;
+ },
+ reader: readers[type],
+ writer: writers[type] || writers.default
+ };
+ }
+ var defaultValuesByType = {
+ get array() {
+ return [];
+ },
+ boolean: false,
+ number: 0,
+ get object() {
+ return {};
+ },
+ string: ""
+ };
+ var readers = {
+ array(value) {
+ const array = JSON.parse(value);
+ if (!Array.isArray(array)) {
+ throw new TypeError(`expected value of type "array" but instead got value "${value}" of type "${parseValueTypeDefault(array)}"`);
+ }
+ return array;
+ },
+ boolean(value) {
+ return !(value == "0" || String(value).toLowerCase() == "false");
+ },
+ number(value) {
+ return Number(value.replace(/_/g, ""));
+ },
+ object(value) {
+ const object = JSON.parse(value);
+ if (object === null || typeof object != "object" || Array.isArray(object)) {
+ throw new TypeError(`expected value of type "object" but instead got value "${value}" of type "${parseValueTypeDefault(object)}"`);
+ }
+ return object;
+ },
+ string(value) {
+ return value;
+ }
+ };
+ var writers = {
+ default: writeString,
+ array: writeJSON,
+ object: writeJSON
+ };
+ function writeJSON(value) {
+ return JSON.stringify(value);
+ }
+ function writeString(value) {
+ return `${value}`;
+ }
+ var Controller = class {
+ constructor(context) {
+ this.context = context;
+ }
+ static get shouldLoad() {
+ return true;
+ }
+ static afterLoad(_identifier, _application) {
+ return;
+ }
+ get application() {
+ return this.context.application;
+ }
+ get scope() {
+ return this.context.scope;
+ }
+ get element() {
+ return this.scope.element;
+ }
+ get identifier() {
+ return this.scope.identifier;
+ }
+ get targets() {
+ return this.scope.targets;
+ }
+ get outlets() {
+ return this.scope.outlets;
+ }
+ get classes() {
+ return this.scope.classes;
+ }
+ get data() {
+ return this.scope.data;
+ }
+ initialize() {
+ }
+ connect() {
+ }
+ disconnect() {
+ }
+ dispatch(eventName, { target = this.element, detail = {}, prefix = this.identifier, bubbles = true, cancelable = true } = {}) {
+ const type = prefix ? `${prefix}:${eventName}` : eventName;
+ const event = new CustomEvent(type, { detail, bubbles, cancelable });
+ target.dispatchEvent(event);
+ return event;
+ }
+ };
+ Controller.blessings = [
+ ClassPropertiesBlessing,
+ TargetPropertiesBlessing,
+ ValuePropertiesBlessing,
+ OutletPropertiesBlessing
+ ];
+ Controller.targets = [];
+ Controller.outlets = [];
+ Controller.values = {};
+
+ // app/assets/javascripts/administrate/controllers/application.js
+ var application = Application.start();
+ application.debug = false;
+ window.Stimulus = application;
- // app/assets/javascripts/administrate/components/table.js
- $(function() {
- var keycodes = { space: 32, enter: 13 };
- var visitDataUrl = function(event) {
+ // app/assets/javascripts/administrate/controllers/select_controller.js
+ var import_jquery2 = __toESM(require_jquery());
+ var select_controller_default = class extends Controller {
+ connect() {
+ (0, import_jquery2.default)(this.element).selectize({});
+ }
+ };
+
+ // app/assets/javascripts/administrate/controllers/table_controller.js
+ var import_jquery3 = __toESM(require_jquery());
+ var keycodes = { space: 32, enter: 13 };
+ var table_controller_default = class extends Controller {
+ visitDataUrl(event) {
if (event.type == "click" || event.keyCode == keycodes.space || event.keyCode == keycodes.enter) {
if (event.target.href) {
return;
}
- var dataUrl = $(event.target).closest("tr").data("url");
+ var dataUrl = (0, import_jquery3.default)(event.target).closest("tr").data("url");
var selection = window.getSelection().toString();
if (selection.length === 0 && dataUrl) {
window.location = window.location.protocol + "//" + window.location.host + dataUrl;
}
}
- };
- $("table").on("click", ".js-table-row", visitDataUrl);
- $("table").on("keydown", ".js-table-row", visitDataUrl);
- });
+ }
+ };
+
+ // app/assets/javascripts/administrate/controllers/index.js
+ application.register("select", select_controller_default);
+ application.register("table", table_controller_default);
})();
/*! Bundled license information:
diff --git a/app/assets/builds/administrate/application.js.map b/app/assets/builds/administrate/application.js.map
index f041d5ed17..369ead68e5 100644
--- a/app/assets/builds/administrate/application.js.map
+++ b/app/assets/builds/administrate/application.js.map
@@ -1,7 +1,7 @@
{
"version": 3,
- "sources": ["../../../../node_modules/jquery/dist/jquery.js", "../../../../node_modules/jquery-ujs/src/rails.js", "../../../../node_modules/sifter/sifter.js", "../../../../node_modules/microplugin/src/microplugin.js", "../../../../node_modules/selectize/dist/js/selectize.min.js", "../../javascripts/administrate/add_jquery.js", "../../javascripts/administrate/application.js", "../../javascripts/administrate/components/associative.js", "../../javascripts/administrate/components/select.js", "../../javascripts/administrate/components/table.js"],
- "sourcesContent": ["/*!\n * jQuery JavaScript Library v3.7.0\n * https://jquery.com/\n *\n * Copyright OpenJS Foundation and other contributors\n * Released under the MIT license\n * https://jquery.org/license\n *\n * Date: 2023-05-11T18:29Z\n */\n( function( global, factory ) {\n\n\t\"use strict\";\n\n\tif ( typeof module === \"object\" && typeof module.exports === \"object\" ) {\n\n\t\t// For CommonJS and CommonJS-like environments where a proper `window`\n\t\t// is present, execute the factory and get jQuery.\n\t\t// For environments that do not have a `window` with a `document`\n\t\t// (such as Node.js), expose a factory as module.exports.\n\t\t// This accentuates the need for the creation of a real `window`.\n\t\t// e.g. var jQuery = require(\"jquery\")(window);\n\t\t// See ticket trac-14549 for more info.\n\t\tmodule.exports = global.document ?\n\t\t\tfactory( global, true ) :\n\t\t\tfunction( w ) {\n\t\t\t\tif ( !w.document ) {\n\t\t\t\t\tthrow new Error( \"jQuery requires a window with a document\" );\n\t\t\t\t}\n\t\t\t\treturn factory( w );\n\t\t\t};\n\t} else {\n\t\tfactory( global );\n\t}\n\n// Pass this if window is not defined yet\n} )( typeof window !== \"undefined\" ? window : this, function( window, noGlobal ) {\n\n// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1\n// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode\n// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common\n// enough that all such attempts are guarded in a try block.\n\"use strict\";\n\nvar arr = [];\n\nvar getProto = Object.getPrototypeOf;\n\nvar slice = arr.slice;\n\nvar flat = arr.flat ? function( array ) {\n\treturn arr.flat.call( array );\n} : function( array ) {\n\treturn arr.concat.apply( [], array );\n};\n\n\nvar push = arr.push;\n\nvar indexOf = arr.indexOf;\n\nvar class2type = {};\n\nvar toString = class2type.toString;\n\nvar hasOwn = class2type.hasOwnProperty;\n\nvar fnToString = hasOwn.toString;\n\nvar ObjectFunctionString = fnToString.call( Object );\n\nvar support = {};\n\nvar isFunction = function isFunction( obj ) {\n\n\t\t// Support: Chrome <=57, Firefox <=52\n\t\t// In some browsers, typeof returns \"function\" for HTML