@iamproperty/components 7.7.1--beta14 → 7.7.1--beta16

package/assets/bootstrap/js/src/collapse.js

@@ -1,302 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): collapse.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import {
-  defineJQueryPlugin,
-  getElement,
-  getElementFromSelector,
-  getSelectorFromElement,
-  reflow
-} from './util/index'
-import EventHandler from './dom/event-handler'
-import SelectorEngine from './dom/selector-engine'
-import BaseComponent from './base-component'
-
-/**
- * Constants
- */
-
-const NAME = 'collapse'
-const DATA_KEY = 'bs.collapse'
-const EVENT_KEY = `.${DATA_KEY}`
-const DATA_API_KEY = '.data-api'
-
-const EVENT_SHOW = `show${EVENT_KEY}`
-const EVENT_SHOWN = `shown${EVENT_KEY}`
-const EVENT_HIDE = `hide${EVENT_KEY}`
-const EVENT_HIDDEN = `hidden${EVENT_KEY}`
-const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`
-
-const CLASS_NAME_SHOW = 'show'
-const CLASS_NAME_COLLAPSE = 'collapse'
-const CLASS_NAME_COLLAPSING = 'collapsing'
-const CLASS_NAME_COLLAPSED = 'collapsed'
-const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`
-const CLASS_NAME_HORIZONTAL = 'collapse-horizontal'
-
-const WIDTH = 'width'
-const HEIGHT = 'height'
-
-const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing'
-const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="collapse"]'
-
-const Default = {
-  parent: null,
-  toggle: true
-}
-
-const DefaultType = {
-  parent: '(null|element)',
-  toggle: 'boolean'
-}
-
-/**
- * Class definition
- */
-
-class Collapse extends BaseComponent {
-  constructor(element, config) {
-    super(element, config)
-
-    this._isTransitioning = false
-    this._triggerArray = []
-
-    const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE)
-
-    for (const elem of toggleList) {
-      const selector = getSelectorFromElement(elem)
-      const filterElement = SelectorEngine.find(selector)
-        .filter(foundElement => foundElement === this._element)
-
-      if (selector !== null && filterElement.length) {
-        this._triggerArray.push(elem)
-      }
-    }
-
-    this._initializeChildren()
-
-    if (!this._config.parent) {
-      this._addAriaAndCollapsedClass(this._triggerArray, this._isShown())
-    }
-
-    if (this._config.toggle) {
-      this.toggle()
-    }
-  }
-
-  // Getters
-  static get Default() {
-    return Default
-  }
-
-  static get DefaultType() {
-    return DefaultType
-  }
-
-  static get NAME() {
-    return NAME
-  }
-
-  // Public
-  toggle() {
-    if (this._isShown()) {
-      this.hide()
-    } else {
-      this.show()
-    }
-  }
-
-  show() {
-    if (this._isTransitioning || this._isShown()) {
-      return
-    }
-
-    let activeChildren = []
-
-    // find active children
-    if (this._config.parent) {
-      activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES)
-        .filter(element => element !== this._element)
-        .map(element => Collapse.getOrCreateInstance(element, { toggle: false }))
-    }
-
-    if (activeChildren.length && activeChildren[0]._isTransitioning) {
-      return
-    }
-
-    const startEvent = EventHandler.trigger(this._element, EVENT_SHOW)
-    if (startEvent.defaultPrevented) {
-      return
-    }
-
-    for (const activeInstance of activeChildren) {
-      activeInstance.hide()
-    }
-
-    const dimension = this._getDimension()
-
-    this._element.classList.remove(CLASS_NAME_COLLAPSE)
-    this._element.classList.add(CLASS_NAME_COLLAPSING)
-
-    this._element.style[dimension] = 0
-
-    this._addAriaAndCollapsedClass(this._triggerArray, true)
-    this._isTransitioning = true
-
-    const complete = () => {
-      this._isTransitioning = false
-
-      this._element.classList.remove(CLASS_NAME_COLLAPSING)
-      this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW)
-
-      this._element.style[dimension] = ''
-
-      EventHandler.trigger(this._element, EVENT_SHOWN)
-    }
-
-    const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1)
-    const scrollSize = `scroll${capitalizedDimension}`
-
-    this._queueCallback(complete, this._element, true)
-    this._element.style[dimension] = `${this._element[scrollSize]}px`
-  }
-
-  hide() {
-    if (this._isTransitioning || !this._isShown()) {
-      return
-    }
-
-    const startEvent = EventHandler.trigger(this._element, EVENT_HIDE)
-    if (startEvent.defaultPrevented) {
-      return
-    }
-
-    const dimension = this._getDimension()
-
-    this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`
-
-    reflow(this._element)
-
-    this._element.classList.add(CLASS_NAME_COLLAPSING)
-    this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW)
-
-    for (const trigger of this._triggerArray) {
-      const element = getElementFromSelector(trigger)
-
-      if (element && !this._isShown(element)) {
-        this._addAriaAndCollapsedClass([trigger], false)
-      }
-    }
-
-    this._isTransitioning = true
-
-    const complete = () => {
-      this._isTransitioning = false
-      this._element.classList.remove(CLASS_NAME_COLLAPSING)
-      this._element.classList.add(CLASS_NAME_COLLAPSE)
-      EventHandler.trigger(this._element, EVENT_HIDDEN)
-    }
-
-    this._element.style[dimension] = ''
-
-    this._queueCallback(complete, this._element, true)
-  }
-
-  _isShown(element = this._element) {
-    return element.classList.contains(CLASS_NAME_SHOW)
-  }
-
-  // Private
-  _configAfterMerge(config) {
-    config.toggle = Boolean(config.toggle) // Coerce string values
-    config.parent = getElement(config.parent)
-    return config
-  }
-
-  _getDimension() {
-    return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT
-  }
-
-  _initializeChildren() {
-    if (!this._config.parent) {
-      return
-    }
-
-    const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE)
-
-    for (const element of children) {
-      const selected = getElementFromSelector(element)
-
-      if (selected) {
-        this._addAriaAndCollapsedClass([element], this._isShown(selected))
-      }
-    }
-  }
-
-  _getFirstLevelChildren(selector) {
-    const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent)
-    // remove children if greater depth
-    return SelectorEngine.find(selector, this._config.parent).filter(element => !children.includes(element))
-  }
-
-  _addAriaAndCollapsedClass(triggerArray, isOpen) {
-    if (!triggerArray.length) {
-      return
-    }
-
-    for (const element of triggerArray) {
-      element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen)
-      element.setAttribute('aria-expanded', isOpen)
-    }
-  }
-
-  // Static
-  static jQueryInterface(config) {
-    const _config = {}
-    if (typeof config === 'string' && /show|hide/.test(config)) {
-      _config.toggle = false
-    }
-
-    return this.each(function () {
-      const data = Collapse.getOrCreateInstance(this, _config)
-
-      if (typeof config === 'string') {
-        if (typeof data[config] === 'undefined') {
-          throw new TypeError(`No method named "${config}"`)
-        }
-
-        data[config]()
-      }
-    })
-  }
-}
-
-/**
- * Data API implementation
- */
-
-EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
-  // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
-  if (event.target.tagName === 'A' || (event.delegateTarget && event.delegateTarget.tagName === 'A')) {
-    event.preventDefault()
-  }
-
-  const selector = getSelectorFromElement(this)
-  const selectorElements = SelectorEngine.find(selector)
-
-  for (const element of selectorElements) {
-    Collapse.getOrCreateInstance(element, { toggle: false }).toggle()
-  }
-})
-
-/**
- * jQuery
- */
-
-defineJQueryPlugin(Collapse)
-
-export default Collapse

package/assets/bootstrap/js/src/dom/data.js

@@ -1,55 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): 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)
-    }
-  }
-}

package/assets/bootstrap/js/src/dom/event-handler.js

@@ -1,320 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): 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 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 makeEventUid(element, uid) {
-  return (uid && `${uid}::${uidEvent++}`) || element.uidEvent || uidEvent++
-}
-
-function getElementEvents(element) {
-  const uid = makeEventUid(element)
-
-  element.uidEvent = uid
-  eventRegistry[uid] = eventRegistry[uid] || {}
-
-  return eventRegistry[uid]
-}
-
-function bootstrapHandler(element, fn) {
-  return function handler(event) {
-    hydrateObj(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 (const domElement of domElements) {
-        if (domElement !== target) {
-          continue
-        }
-
-        hydrateObj(event, { delegateTarget: target })
-
-        if (handler.oneOff) {
-          EventHandler.off(element, event.type, selector, fn)
-        }
-
-        return fn.apply(target, [event])
-      }
-    }
-  }
-}
-
-function findHandler(events, callable, delegationSelector = null) {
-  return Object.values(events)
-    .find(event => event.callable === callable && event.delegationSelector === delegationSelector)
-}
-
-function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
-  const isDelegated = typeof handler === 'string'
-  // todo: tooltip passes `false` instead of selector, so we need to check
-  const callable = isDelegated ? delegationFunction : (handler || delegationFunction)
-  let typeEvent = getTypeEvent(originalTypeEvent)
-
-  if (!nativeEvents.has(typeEvent)) {
-    typeEvent = originalTypeEvent
-  }
-
-  return [isDelegated, callable, typeEvent]
-}
-
-function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
-  if (typeof originalTypeEvent !== 'string' || !element) {
-    return
-  }
-
-  let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction)
-
-  // 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 (originalTypeEvent in customEvents) {
-    const wrapFunction = fn => {
-      return function (event) {
-        if (!event.relatedTarget || (event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget))) {
-          return fn.call(this, event)
-        }
-      }
-    }
-
-    callable = wrapFunction(callable)
-  }
-
-  const events = getElementEvents(element)
-  const handlers = events[typeEvent] || (events[typeEvent] = {})
-  const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null)
-
-  if (previousFunction) {
-    previousFunction.oneOff = previousFunction.oneOff && oneOff
-
-    return
-  }
-
-  const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''))
-  const fn = isDelegated ?
-    bootstrapDelegationHandler(element, handler, callable) :
-    bootstrapHandler(element, callable)
-
-  fn.delegationSelector = isDelegated ? handler : null
-  fn.callable = callable
-  fn.oneOff = oneOff
-  fn.uidEvent = uid
-  handlers[uid] = fn
-
-  element.addEventListener(typeEvent, fn, isDelegated)
-}
-
-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] || {}
-
-  for (const handlerKey of Object.keys(storeElementEvent)) {
-    if (handlerKey.includes(namespace)) {
-      const event = storeElementEvent[handlerKey]
-      removeHandler(element, events, typeEvent, event.callable, 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, delegationFunction) {
-    addHandler(element, event, handler, delegationFunction, false)
-  },
-
-  one(element, event, handler, delegationFunction) {
-    addHandler(element, event, handler, delegationFunction, true)
-  },
-
-  off(element, originalTypeEvent, handler, delegationFunction) {
-    if (typeof originalTypeEvent !== 'string' || !element) {
-      return
-    }
-
-    const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction)
-    const inNamespace = typeEvent !== originalTypeEvent
-    const events = getElementEvents(element)
-    const storeElementEvent = events[typeEvent] || {}
-    const isNamespace = originalTypeEvent.startsWith('.')
-
-    if (typeof callable !== 'undefined') {
-      // Simplest case: handler is passed, remove that listener ONLY.
-      if (!Object.keys(storeElementEvent).length) {
-        return
-      }
-
-      removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null)
-      return
-    }
-
-    if (isNamespace) {
-      for (const elementEvent of Object.keys(events)) {
-        removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1))
-      }
-    }
-
-    for (const keyHandlers of Object.keys(storeElementEvent)) {
-      const handlerKey = keyHandlers.replace(stripUidRegex, '')
-
-      if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
-        const event = storeElementEvent[keyHandlers]
-        removeHandler(element, events, typeEvent, event.callable, event.delegationSelector)
-      }
-    }
-  },
-
-  trigger(element, event, args) {
-    if (typeof event !== 'string' || !element) {
-      return null
-    }
-
-    const $ = getjQuery()
-    const typeEvent = getTypeEvent(event)
-    const inNamespace = event !== typeEvent
-
-    let jQueryEvent = null
-    let bubbles = true
-    let nativeDispatch = true
-    let defaultPrevented = false
-
-    if (inNamespace && $) {
-      jQueryEvent = $.Event(event, args)
-
-      $(element).trigger(jQueryEvent)
-      bubbles = !jQueryEvent.isPropagationStopped()
-      nativeDispatch = !jQueryEvent.isImmediatePropagationStopped()
-      defaultPrevented = jQueryEvent.isDefaultPrevented()
-    }
-
-    let evt = new Event(event, { bubbles, cancelable: true })
-    evt = hydrateObj(evt, args)
-
-    if (defaultPrevented) {
-      evt.preventDefault()
-    }
-
-    if (nativeDispatch) {
-      element.dispatchEvent(evt)
-    }
-
-    if (evt.defaultPrevented && jQueryEvent) {
-      jQueryEvent.preventDefault()
-    }
-
-    return evt
-  }
-}
-
-function hydrateObj(obj, meta) {
-  for (const [key, value] of Object.entries(meta || {})) {
-    try {
-      obj[key] = value
-    } catch {
-      Object.defineProperty(obj, key, {
-        configurable: true,
-        get() {
-          return value
-        }
-      })
-    }
-  }
-
-  return obj
-}
-
-export default EventHandler