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

package/assets/bootstrap/js/src/util/backdrop.js

@@ -1,149 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): util/backdrop.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import EventHandler from '../dom/event-handler'
-import { execute, executeAfterTransition, getElement, reflow } from './index'
-import Config from './config'
-
-/**
- * Constants
- */
-
-const NAME = 'backdrop'
-const CLASS_NAME_FADE = 'fade'
-const CLASS_NAME_SHOW = 'show'
-const EVENT_MOUSEDOWN = `mousedown.bs.${NAME}`
-
-const Default = {
-  className: 'modal-backdrop',
-  clickCallback: null,
-  isAnimated: false,
-  isVisible: true, // if false, we use the backdrop helper without adding any element to the dom
-  rootElement: 'body' // give the choice to place backdrop under different elements
-}
-
-const DefaultType = {
-  className: 'string',
-  clickCallback: '(function|null)',
-  isAnimated: 'boolean',
-  isVisible: 'boolean',
-  rootElement: '(element|string)'
-}
-
-/**
- * Class definition
- */
-
-class Backdrop extends Config {
-  constructor(config) {
-    super()
-    this._config = this._getConfig(config)
-    this._isAppended = false
-    this._element = null
-  }
-
-  // Getters
-  static get Default() {
-    return Default
-  }
-
-  static get DefaultType() {
-    return DefaultType
-  }
-
-  static get NAME() {
-    return NAME
-  }
-
-  // Public
-  show(callback) {
-    if (!this._config.isVisible) {
-      execute(callback)
-      return
-    }
-
-    this._append()
-
-    const element = this._getElement()
-    if (this._config.isAnimated) {
-      reflow(element)
-    }
-
-    element.classList.add(CLASS_NAME_SHOW)
-
-    this._emulateAnimation(() => {
-      execute(callback)
-    })
-  }
-
-  hide(callback) {
-    if (!this._config.isVisible) {
-      execute(callback)
-      return
-    }
-
-    this._getElement().classList.remove(CLASS_NAME_SHOW)
-
-    this._emulateAnimation(() => {
-      this.dispose()
-      execute(callback)
-    })
-  }
-
-  dispose() {
-    if (!this._isAppended) {
-      return
-    }
-
-    EventHandler.off(this._element, EVENT_MOUSEDOWN)
-
-    this._element.remove()
-    this._isAppended = false
-  }
-
-  // Private
-  _getElement() {
-    if (!this._element) {
-      const backdrop = document.createElement('div')
-      backdrop.className = this._config.className
-      if (this._config.isAnimated) {
-        backdrop.classList.add(CLASS_NAME_FADE)
-      }
-
-      this._element = backdrop
-    }
-
-    return this._element
-  }
-
-  _configAfterMerge(config) {
-    // use getElement() with the default "body" to get a fresh Element on each instantiation
-    config.rootElement = getElement(config.rootElement)
-    return config
-  }
-
-  _append() {
-    if (this._isAppended) {
-      return
-    }
-
-    const element = this._getElement()
-    this._config.rootElement.append(element)
-
-    EventHandler.on(element, EVENT_MOUSEDOWN, () => {
-      execute(this._config.clickCallback)
-    })
-
-    this._isAppended = true
-  }
-
-  _emulateAnimation(callback) {
-    executeAfterTransition(callback, this._getElement(), this._config.isAnimated)
-  }
-}
-
-export default Backdrop

package/assets/bootstrap/js/src/util/component-functions.js

@@ -1,34 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): util/component-functions.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import EventHandler from '../dom/event-handler'
-import { getElementFromSelector, isDisabled } from './index'
-
-const enableDismissTrigger = (component, method = 'hide') => {
-  const clickEvent = `click.dismiss${component.EVENT_KEY}`
-  const name = component.NAME
-
-  EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
-    if (['A', 'AREA'].includes(this.tagName)) {
-      event.preventDefault()
-    }
-
-    if (isDisabled(this)) {
-      return
-    }
-
-    const target = getElementFromSelector(this) || this.closest(`.${name}`)
-    const instance = component.getOrCreateInstance(target)
-
-    // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
-    instance[method]()
-  })
-}
-
-export {
-  enableDismissTrigger
-}

package/assets/bootstrap/js/src/util/config.js

@@ -1,66 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): util/config.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import { isElement, toType } from './index'
-import Manipulator from '../dom/manipulator'
-
-/**
- * Class definition
- */
-
-class Config {
-  // Getters
-  static get Default() {
-    return {}
-  }
-
-  static get DefaultType() {
-    return {}
-  }
-
-  static get NAME() {
-    throw new Error('You have to implement the static method "NAME", for each component!')
-  }
-
-  _getConfig(config) {
-    config = this._mergeConfigObj(config)
-    config = this._configAfterMerge(config)
-    this._typeCheckConfig(config)
-    return config
-  }
-
-  _configAfterMerge(config) {
-    return config
-  }
-
-  _mergeConfigObj(config, element) {
-    const jsonConfig = isElement(element) ? Manipulator.getDataAttribute(element, 'config') : {} // try to parse
-
-    return {
-      ...this.constructor.Default,
-      ...(typeof jsonConfig === 'object' ? jsonConfig : {}),
-      ...(isElement(element) ? Manipulator.getDataAttributes(element) : {}),
-      ...(typeof config === 'object' ? config : {})
-    }
-  }
-
-  _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
-    for (const property of Object.keys(configTypes)) {
-      const expectedTypes = configTypes[property]
-      const value = config[property]
-      const valueType = isElement(value) ? 'element' : toType(value)
-
-      if (!new RegExp(expectedTypes).test(valueType)) {
-        throw new TypeError(
-          `${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`
-        )
-      }
-    }
-  }
-}
-
-export default Config

package/assets/bootstrap/js/src/util/focustrap.js

@@ -1,115 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): util/focustrap.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import EventHandler from '../dom/event-handler'
-import SelectorEngine from '../dom/selector-engine'
-import Config from './config'
-
-/**
- * Constants
- */
-
-const NAME = 'focustrap'
-const DATA_KEY = 'bs.focustrap'
-const EVENT_KEY = `.${DATA_KEY}`
-const EVENT_FOCUSIN = `focusin${EVENT_KEY}`
-const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY}`
-
-const TAB_KEY = 'Tab'
-const TAB_NAV_FORWARD = 'forward'
-const TAB_NAV_BACKWARD = 'backward'
-
-const Default = {
-  autofocus: true,
-  trapElement: null // The element to trap focus inside of
-}
-
-const DefaultType = {
-  autofocus: 'boolean',
-  trapElement: 'element'
-}
-
-/**
- * Class definition
- */
-
-class FocusTrap extends Config {
-  constructor(config) {
-    super()
-    this._config = this._getConfig(config)
-    this._isActive = false
-    this._lastTabNavDirection = null
-  }
-
-  // Getters
-  static get Default() {
-    return Default
-  }
-
-  static get DefaultType() {
-    return DefaultType
-  }
-
-  static get NAME() {
-    return NAME
-  }
-
-  // Public
-  activate() {
-    if (this._isActive) {
-      return
-    }
-
-    if (this._config.autofocus) {
-      this._config.trapElement.focus()
-    }
-
-    EventHandler.off(document, EVENT_KEY) // guard against infinite focus loop
-    EventHandler.on(document, EVENT_FOCUSIN, event => this._handleFocusin(event))
-    EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event))
-
-    this._isActive = true
-  }
-
-  deactivate() {
-    if (!this._isActive) {
-      return
-    }
-
-    this._isActive = false
-    EventHandler.off(document, EVENT_KEY)
-  }
-
-  // Private
-  _handleFocusin(event) {
-    const { trapElement } = this._config
-
-    if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) {
-      return
-    }
-
-    const elements = SelectorEngine.focusableChildren(trapElement)
-
-    if (elements.length === 0) {
-      trapElement.focus()
-    } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {
-      elements[elements.length - 1].focus()
-    } else {
-      elements[0].focus()
-    }
-  }
-
-  _handleKeydown(event) {
-    if (event.key !== TAB_KEY) {
-      return
-    }
-
-    this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD
-  }
-}
-
-export default FocusTrap

package/assets/bootstrap/js/src/util/index.js

@@ -1,336 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): util/index.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-const MAX_UID = 1_000_000
-const MILLISECONDS_MULTIPLIER = 1000
-const TRANSITION_END = 'transitionend'
-
-// Shout-out Angus Croll (https://goo.gl/pxwQGp)
-const toType = object => {
-  if (object === null || object === undefined) {
-    return `${object}`
-  }
-
-  return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase()
-}
-
-/**
- * Public Util API
- */
-
-const getUID = prefix => {
-  do {
-    prefix += Math.floor(Math.random() * MAX_UID)
-  } while (document.getElementById(prefix))
-
-  return prefix
-}
-
-const getSelector = element => {
-  let selector = element.getAttribute('data-bs-target')
-
-  if (!selector || selector === '#') {
-    let hrefAttribute = element.getAttribute('href')
-
-    // The only valid content that could double as a selector are IDs or classes,
-    // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
-    // `document.querySelector` will rightfully complain it is invalid.
-    // See https://github.com/twbs/bootstrap/issues/32273
-    if (!hrefAttribute || (!hrefAttribute.includes('#') && !hrefAttribute.startsWith('.'))) {
-      return null
-    }
-
-    // Just in case some CMS puts out a full URL with the anchor appended
-    if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) {
-      hrefAttribute = `#${hrefAttribute.split('#')[1]}`
-    }
-
-    selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null
-  }
-
-  return selector
-}
-
-const getSelectorFromElement = element => {
-  const selector = getSelector(element)
-
-  if (selector) {
-    return document.querySelector(selector) ? selector : null
-  }
-
-  return null
-}
-
-const getElementFromSelector = element => {
-  const selector = getSelector(element)
-
-  return selector ? document.querySelector(selector) : null
-}
-
-const getTransitionDurationFromElement = element => {
-  if (!element) {
-    return 0
-  }
-
-  // Get transition-duration of the element
-  let { transitionDuration, transitionDelay } = window.getComputedStyle(element)
-
-  const floatTransitionDuration = Number.parseFloat(transitionDuration)
-  const floatTransitionDelay = Number.parseFloat(transitionDelay)
-
-  // Return 0 if element or transition duration is not found
-  if (!floatTransitionDuration && !floatTransitionDelay) {
-    return 0
-  }
-
-  // If multiple durations are defined, take the first
-  transitionDuration = transitionDuration.split(',')[0]
-  transitionDelay = transitionDelay.split(',')[0]
-
-  return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER
-}
-
-const triggerTransitionEnd = element => {
-  element.dispatchEvent(new Event(TRANSITION_END))
-}
-
-const isElement = object => {
-  if (!object || typeof object !== 'object') {
-    return false
-  }
-
-  if (typeof object.jquery !== 'undefined') {
-    object = object[0]
-  }
-
-  return typeof object.nodeType !== 'undefined'
-}
-
-const getElement = object => {
-  // it's a jQuery object or a node element
-  if (isElement(object)) {
-    return object.jquery ? object[0] : object
-  }
-
-  if (typeof object === 'string' && object.length > 0) {
-    return document.querySelector(object)
-  }
-
-  return null
-}
-
-const isVisible = element => {
-  if (!isElement(element) || element.getClientRects().length === 0) {
-    return false
-  }
-
-  const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible'
-  // Handle `details` element as its content may falsie appear visible when it is closed
-  const closedDetails = element.closest('details:not([open])')
-
-  if (!closedDetails) {
-    return elementIsVisible
-  }
-
-  if (closedDetails !== element) {
-    const summary = element.closest('summary')
-    if (summary && summary.parentNode !== closedDetails) {
-      return false
-    }
-
-    if (summary === null) {
-      return false
-    }
-  }
-
-  return elementIsVisible
-}
-
-const isDisabled = element => {
-  if (!element || element.nodeType !== Node.ELEMENT_NODE) {
-    return true
-  }
-
-  if (element.classList.contains('disabled')) {
-    return true
-  }
-
-  if (typeof element.disabled !== 'undefined') {
-    return element.disabled
-  }
-
-  return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'
-}
-
-const findShadowRoot = element => {
-  if (!document.documentElement.attachShadow) {
-    return null
-  }
-
-  // Can find the shadow root otherwise it'll return the document
-  if (typeof element.getRootNode === 'function') {
-    const root = element.getRootNode()
-    return root instanceof ShadowRoot ? root : null
-  }
-
-  if (element instanceof ShadowRoot) {
-    return element
-  }
-
-  // when we don't find a shadow root
-  if (!element.parentNode) {
-    return null
-  }
-
-  return findShadowRoot(element.parentNode)
-}
-
-const noop = () => {}
-
-/**
- * Trick to restart an element's animation
- *
- * @param {HTMLElement} element
- * @return void
- *
- * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
- */
-const reflow = element => {
-  element.offsetHeight // eslint-disable-line no-unused-expressions
-}
-
-const getjQuery = () => {
-  if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
-    return window.jQuery
-  }
-
-  return null
-}
-
-const DOMContentLoadedCallbacks = []
-
-const onDOMContentLoaded = callback => {
-  if (document.readyState === 'loading') {
-    // add listener on the first call when the document is in loading state
-    if (!DOMContentLoadedCallbacks.length) {
-      document.addEventListener('DOMContentLoaded', () => {
-        for (const callback of DOMContentLoadedCallbacks) {
-          callback()
-        }
-      })
-    }
-
-    DOMContentLoadedCallbacks.push(callback)
-  } else {
-    callback()
-  }
-}
-
-const isRTL = () => document.documentElement.dir === 'rtl'
-
-const defineJQueryPlugin = plugin => {
-  onDOMContentLoaded(() => {
-    const $ = getjQuery()
-    /* istanbul ignore if */
-    if ($) {
-      const name = plugin.NAME
-      const JQUERY_NO_CONFLICT = $.fn[name]
-      $.fn[name] = plugin.jQueryInterface
-      $.fn[name].Constructor = plugin
-      $.fn[name].noConflict = () => {
-        $.fn[name] = JQUERY_NO_CONFLICT
-        return plugin.jQueryInterface
-      }
-    }
-  })
-}
-
-const execute = callback => {
-  if (typeof callback === 'function') {
-    callback()
-  }
-}
-
-const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
-  if (!waitForTransition) {
-    execute(callback)
-    return
-  }
-
-  const durationPadding = 5
-  const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding
-
-  let called = false
-
-  const handler = ({ target }) => {
-    if (target !== transitionElement) {
-      return
-    }
-
-    called = true
-    transitionElement.removeEventListener(TRANSITION_END, handler)
-    execute(callback)
-  }
-
-  transitionElement.addEventListener(TRANSITION_END, handler)
-  setTimeout(() => {
-    if (!called) {
-      triggerTransitionEnd(transitionElement)
-    }
-  }, emulatedDuration)
-}
-
-/**
- * Return the previous/next element of a list.
- *
- * @param {array} list    The list of elements
- * @param activeElement   The active element
- * @param shouldGetNext   Choose to get next or previous element
- * @param isCycleAllowed
- * @return {Element|elem} The proper element
- */
-const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
-  const listLength = list.length
-  let index = list.indexOf(activeElement)
-
-  // if the element does not exist in the list return an element
-  // depending on the direction and if cycle is allowed
-  if (index === -1) {
-    return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0]
-  }
-
-  index += shouldGetNext ? 1 : -1
-
-  if (isCycleAllowed) {
-    index = (index + listLength) % listLength
-  }
-
-  return list[Math.max(0, Math.min(index, listLength - 1))]
-}
-
-export {
-  defineJQueryPlugin,
-  execute,
-  executeAfterTransition,
-  findShadowRoot,
-  getElement,
-  getElementFromSelector,
-  getjQuery,
-  getNextActiveElement,
-  getSelectorFromElement,
-  getTransitionDurationFromElement,
-  getUID,
-  isDisabled,
-  isElement,
-  isRTL,
-  isVisible,
-  noop,
-  onDOMContentLoaded,
-  reflow,
-  triggerTransitionEnd,
-  toType
-}