aboutsummaryrefslogtreecommitdiffstats
path: root/vendor/twbs/bootstrap/js/src/dom
diff options
context:
space:
mode:
authorMario <mario@mariovavti.com>2021-07-29 08:25:05 +0000
committerMario <mario@mariovavti.com>2021-07-29 08:25:05 +0000
commitd459dfac74e90c29950d49a82edc19fd913d435e (patch)
tree7bed5f2dbc318f87bbe0f4be2cde3dde09cd97c7 /vendor/twbs/bootstrap/js/src/dom
parentcec2f0d894b80f3affeb60cff2d4afa49a2019a8 (diff)
downloadvolse-hubzilla-d459dfac74e90c29950d49a82edc19fd913d435e.tar.gz
volse-hubzilla-d459dfac74e90c29950d49a82edc19fd913d435e.tar.bz2
volse-hubzilla-d459dfac74e90c29950d49a82edc19fd913d435e.zip
update to bootstrap 5.0.2
Diffstat (limited to 'vendor/twbs/bootstrap/js/src/dom')
-rw-r--r--vendor/twbs/bootstrap/js/src/dom/data.js57
-rw-r--r--vendor/twbs/bootstrap/js/src/dom/event-handler.js349
-rw-r--r--vendor/twbs/bootstrap/js/src/dom/manipulator.js80
-rw-r--r--vendor/twbs/bootstrap/js/src/dom/selector-engine.js75
4 files changed, 561 insertions, 0 deletions
diff --git a/vendor/twbs/bootstrap/js/src/dom/data.js b/vendor/twbs/bootstrap/js/src/dom/data.js
new file mode 100644
index 000000000..cb88ef53d
--- /dev/null
+++ b/vendor/twbs/bootstrap/js/src/dom/data.js
@@ -0,0 +1,57 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.0.2): dom/data.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
+
+const elementMap = new Map()
+
+export default {
+ set(element, key, instance) {
+ if (!elementMap.has(element)) {
+ elementMap.set(element, new Map())
+ }
+
+ const instanceMap = elementMap.get(element)
+
+ // make it clear we only want one instance per element
+ // can be removed later when multiple key/instances are fine to be used
+ if (!instanceMap.has(key) && instanceMap.size !== 0) {
+ // eslint-disable-next-line no-console
+ console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`)
+ return
+ }
+
+ instanceMap.set(key, instance)
+ },
+
+ get(element, key) {
+ if (elementMap.has(element)) {
+ return elementMap.get(element).get(key) || null
+ }
+
+ return null
+ },
+
+ remove(element, key) {
+ if (!elementMap.has(element)) {
+ return
+ }
+
+ const instanceMap = elementMap.get(element)
+
+ instanceMap.delete(key)
+
+ // free up element references if there are no instances left for an element
+ if (instanceMap.size === 0) {
+ elementMap.delete(element)
+ }
+ }
+}
diff --git a/vendor/twbs/bootstrap/js/src/dom/event-handler.js b/vendor/twbs/bootstrap/js/src/dom/event-handler.js
new file mode 100644
index 000000000..c8303f7f2
--- /dev/null
+++ b/vendor/twbs/bootstrap/js/src/dom/event-handler.js
@@ -0,0 +1,349 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.0.2): dom/event-handler.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import { getjQuery } from '../util/index'
+
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
+
+const namespaceRegex = /[^.]*(?=\..*)\.|.*/
+const stripNameRegex = /\..*/
+const stripUidRegex = /::\d+$/
+const eventRegistry = {} // Events storage
+let uidEvent = 1
+const customEvents = {
+ mouseenter: 'mouseover',
+ mouseleave: 'mouseout'
+}
+const customEventsRegex = /^(mouseenter|mouseleave)/i
+const nativeEvents = new Set([
+ 'click',
+ 'dblclick',
+ 'mouseup',
+ 'mousedown',
+ 'contextmenu',
+ 'mousewheel',
+ 'DOMMouseScroll',
+ 'mouseover',
+ 'mouseout',
+ 'mousemove',
+ 'selectstart',
+ 'selectend',
+ 'keydown',
+ 'keypress',
+ 'keyup',
+ 'orientationchange',
+ 'touchstart',
+ 'touchmove',
+ 'touchend',
+ 'touchcancel',
+ 'pointerdown',
+ 'pointermove',
+ 'pointerup',
+ 'pointerleave',
+ 'pointercancel',
+ 'gesturestart',
+ 'gesturechange',
+ 'gestureend',
+ 'focus',
+ 'blur',
+ 'change',
+ 'reset',
+ 'select',
+ 'submit',
+ 'focusin',
+ 'focusout',
+ 'load',
+ 'unload',
+ 'beforeunload',
+ 'resize',
+ 'move',
+ 'DOMContentLoaded',
+ 'readystatechange',
+ 'error',
+ 'abort',
+ 'scroll'
+])
+
+/**
+ * ------------------------------------------------------------------------
+ * Private methods
+ * ------------------------------------------------------------------------
+ */
+
+function getUidEvent(element, uid) {
+ return (uid && `${uid}::${uidEvent++}`) || element.uidEvent || uidEvent++
+}
+
+function getEvent(element) {
+ const uid = getUidEvent(element)
+
+ element.uidEvent = uid
+ eventRegistry[uid] = eventRegistry[uid] || {}
+
+ return eventRegistry[uid]
+}
+
+function bootstrapHandler(element, fn) {
+ return function handler(event) {
+ event.delegateTarget = element
+
+ if (handler.oneOff) {
+ EventHandler.off(element, event.type, fn)
+ }
+
+ return fn.apply(element, [event])
+ }
+}
+
+function bootstrapDelegationHandler(element, selector, fn) {
+ return function handler(event) {
+ const domElements = element.querySelectorAll(selector)
+
+ for (let { target } = event; target && target !== this; target = target.parentNode) {
+ for (let i = domElements.length; i--;) {
+ if (domElements[i] === target) {
+ event.delegateTarget = target
+
+ if (handler.oneOff) {
+ // eslint-disable-next-line unicorn/consistent-destructuring
+ EventHandler.off(element, event.type, selector, fn)
+ }
+
+ return fn.apply(target, [event])
+ }
+ }
+ }
+
+ // To please ESLint
+ return null
+ }
+}
+
+function findHandler(events, handler, delegationSelector = null) {
+ const uidEventList = Object.keys(events)
+
+ for (let i = 0, len = uidEventList.length; i < len; i++) {
+ const event = events[uidEventList[i]]
+
+ if (event.originalHandler === handler && event.delegationSelector === delegationSelector) {
+ return event
+ }
+ }
+
+ return null
+}
+
+function normalizeParams(originalTypeEvent, handler, delegationFn) {
+ const delegation = typeof handler === 'string'
+ const originalHandler = delegation ? delegationFn : handler
+
+ let typeEvent = getTypeEvent(originalTypeEvent)
+ const isNative = nativeEvents.has(typeEvent)
+
+ if (!isNative) {
+ typeEvent = originalTypeEvent
+ }
+
+ return [delegation, originalHandler, typeEvent]
+}
+
+function addHandler(element, originalTypeEvent, handler, delegationFn, oneOff) {
+ if (typeof originalTypeEvent !== 'string' || !element) {
+ return
+ }
+
+ if (!handler) {
+ handler = delegationFn
+ delegationFn = null
+ }
+
+ // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
+ // this prevents the handler from being dispatched the same way as mouseover or mouseout does
+ if (customEventsRegex.test(originalTypeEvent)) {
+ const wrapFn = fn => {
+ return function (event) {
+ if (!event.relatedTarget || (event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget))) {
+ return fn.call(this, event)
+ }
+ }
+ }
+
+ if (delegationFn) {
+ delegationFn = wrapFn(delegationFn)
+ } else {
+ handler = wrapFn(handler)
+ }
+ }
+
+ const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn)
+ const events = getEvent(element)
+ const handlers = events[typeEvent] || (events[typeEvent] = {})
+ const previousFn = findHandler(handlers, originalHandler, delegation ? handler : null)
+
+ if (previousFn) {
+ previousFn.oneOff = previousFn.oneOff && oneOff
+
+ return
+ }
+
+ const uid = getUidEvent(originalHandler, originalTypeEvent.replace(namespaceRegex, ''))
+ const fn = delegation ?
+ bootstrapDelegationHandler(element, handler, delegationFn) :
+ bootstrapHandler(element, handler)
+
+ fn.delegationSelector = delegation ? handler : null
+ fn.originalHandler = originalHandler
+ fn.oneOff = oneOff
+ fn.uidEvent = uid
+ handlers[uid] = fn
+
+ element.addEventListener(typeEvent, fn, delegation)
+}
+
+function removeHandler(element, events, typeEvent, handler, delegationSelector) {
+ const fn = findHandler(events[typeEvent], handler, delegationSelector)
+
+ if (!fn) {
+ return
+ }
+
+ element.removeEventListener(typeEvent, fn, Boolean(delegationSelector))
+ delete events[typeEvent][fn.uidEvent]
+}
+
+function removeNamespacedHandlers(element, events, typeEvent, namespace) {
+ const storeElementEvent = events[typeEvent] || {}
+
+ Object.keys(storeElementEvent).forEach(handlerKey => {
+ if (handlerKey.includes(namespace)) {
+ const event = storeElementEvent[handlerKey]
+
+ removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector)
+ }
+ })
+}
+
+function getTypeEvent(event) {
+ // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
+ event = event.replace(stripNameRegex, '')
+ return customEvents[event] || event
+}
+
+const EventHandler = {
+ on(element, event, handler, delegationFn) {
+ addHandler(element, event, handler, delegationFn, false)
+ },
+
+ one(element, event, handler, delegationFn) {
+ addHandler(element, event, handler, delegationFn, true)
+ },
+
+ off(element, originalTypeEvent, handler, delegationFn) {
+ if (typeof originalTypeEvent !== 'string' || !element) {
+ return
+ }
+
+ const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn)
+ const inNamespace = typeEvent !== originalTypeEvent
+ const events = getEvent(element)
+ const isNamespace = originalTypeEvent.startsWith('.')
+
+ if (typeof originalHandler !== 'undefined') {
+ // Simplest case: handler is passed, remove that listener ONLY.
+ if (!events || !events[typeEvent]) {
+ return
+ }
+
+ removeHandler(element, events, typeEvent, originalHandler, delegation ? handler : null)
+ return
+ }
+
+ if (isNamespace) {
+ Object.keys(events).forEach(elementEvent => {
+ removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1))
+ })
+ }
+
+ const storeElementEvent = events[typeEvent] || {}
+ Object.keys(storeElementEvent).forEach(keyHandlers => {
+ const handlerKey = keyHandlers.replace(stripUidRegex, '')
+
+ if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
+ const event = storeElementEvent[keyHandlers]
+
+ removeHandler(element, events, typeEvent, event.originalHandler, event.delegationSelector)
+ }
+ })
+ },
+
+ trigger(element, event, args) {
+ if (typeof event !== 'string' || !element) {
+ return null
+ }
+
+ const $ = getjQuery()
+ const typeEvent = getTypeEvent(event)
+ const inNamespace = event !== typeEvent
+ const isNative = nativeEvents.has(typeEvent)
+
+ let jQueryEvent
+ let bubbles = true
+ let nativeDispatch = true
+ let defaultPrevented = false
+ let evt = null
+
+ if (inNamespace && $) {
+ jQueryEvent = $.Event(event, args)
+
+ $(element).trigger(jQueryEvent)
+ bubbles = !jQueryEvent.isPropagationStopped()
+ nativeDispatch = !jQueryEvent.isImmediatePropagationStopped()
+ defaultPrevented = jQueryEvent.isDefaultPrevented()
+ }
+
+ if (isNative) {
+ evt = document.createEvent('HTMLEvents')
+ evt.initEvent(typeEvent, bubbles, true)
+ } else {
+ evt = new CustomEvent(event, {
+ bubbles,
+ cancelable: true
+ })
+ }
+
+ // merge custom information in our event
+ if (typeof args !== 'undefined') {
+ Object.keys(args).forEach(key => {
+ Object.defineProperty(evt, key, {
+ get() {
+ return args[key]
+ }
+ })
+ })
+ }
+
+ if (defaultPrevented) {
+ evt.preventDefault()
+ }
+
+ if (nativeDispatch) {
+ element.dispatchEvent(evt)
+ }
+
+ if (evt.defaultPrevented && typeof jQueryEvent !== 'undefined') {
+ jQueryEvent.preventDefault()
+ }
+
+ return evt
+ }
+}
+
+export default EventHandler
diff --git a/vendor/twbs/bootstrap/js/src/dom/manipulator.js b/vendor/twbs/bootstrap/js/src/dom/manipulator.js
new file mode 100644
index 000000000..113817bee
--- /dev/null
+++ b/vendor/twbs/bootstrap/js/src/dom/manipulator.js
@@ -0,0 +1,80 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.0.2): dom/manipulator.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+function normalizeData(val) {
+ if (val === 'true') {
+ return true
+ }
+
+ if (val === 'false') {
+ return false
+ }
+
+ if (val === Number(val).toString()) {
+ return Number(val)
+ }
+
+ if (val === '' || val === 'null') {
+ return null
+ }
+
+ return val
+}
+
+function normalizeDataKey(key) {
+ return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`)
+}
+
+const Manipulator = {
+ setDataAttribute(element, key, value) {
+ element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value)
+ },
+
+ removeDataAttribute(element, key) {
+ element.removeAttribute(`data-bs-${normalizeDataKey(key)}`)
+ },
+
+ getDataAttributes(element) {
+ if (!element) {
+ return {}
+ }
+
+ const attributes = {}
+
+ Object.keys(element.dataset)
+ .filter(key => key.startsWith('bs'))
+ .forEach(key => {
+ let pureKey = key.replace(/^bs/, '')
+ pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length)
+ attributes[pureKey] = normalizeData(element.dataset[key])
+ })
+
+ return attributes
+ },
+
+ getDataAttribute(element, key) {
+ return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`))
+ },
+
+ offset(element) {
+ const rect = element.getBoundingClientRect()
+
+ return {
+ top: rect.top + document.body.scrollTop,
+ left: rect.left + document.body.scrollLeft
+ }
+ },
+
+ position(element) {
+ return {
+ top: element.offsetTop,
+ left: element.offsetLeft
+ }
+ }
+}
+
+export default Manipulator
diff --git a/vendor/twbs/bootstrap/js/src/dom/selector-engine.js b/vendor/twbs/bootstrap/js/src/dom/selector-engine.js
new file mode 100644
index 000000000..381e45fe8
--- /dev/null
+++ b/vendor/twbs/bootstrap/js/src/dom/selector-engine.js
@@ -0,0 +1,75 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.0.2): dom/selector-engine.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+/**
+ * ------------------------------------------------------------------------
+ * Constants
+ * ------------------------------------------------------------------------
+ */
+
+const NODE_TEXT = 3
+
+const SelectorEngine = {
+ find(selector, element = document.documentElement) {
+ return [].concat(...Element.prototype.querySelectorAll.call(element, selector))
+ },
+
+ findOne(selector, element = document.documentElement) {
+ return Element.prototype.querySelector.call(element, selector)
+ },
+
+ children(element, selector) {
+ return [].concat(...element.children)
+ .filter(child => child.matches(selector))
+ },
+
+ parents(element, selector) {
+ const parents = []
+
+ let ancestor = element.parentNode
+
+ while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
+ if (ancestor.matches(selector)) {
+ parents.push(ancestor)
+ }
+
+ ancestor = ancestor.parentNode
+ }
+
+ return parents
+ },
+
+ prev(element, selector) {
+ let previous = element.previousElementSibling
+
+ while (previous) {
+ if (previous.matches(selector)) {
+ return [previous]
+ }
+
+ previous = previous.previousElementSibling
+ }
+
+ return []
+ },
+
+ next(element, selector) {
+ let next = element.nextElementSibling
+
+ while (next) {
+ if (next.matches(selector)) {
+ return [next]
+ }
+
+ next = next.nextElementSibling
+ }
+
+ return []
+ }
+}
+
+export default SelectorEngine