@iamproperty/components 7.7.1--beta15 → 7.7.1--beta17

package/assets/bootstrap/js/src/popover.js

@@ -1,97 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): popover.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import { defineJQueryPlugin } from './util/index'
-import Tooltip from './tooltip'
-
-/**
- * Constants
- */
-
-const NAME = 'popover'
-
-const SELECTOR_TITLE = '.popover-header'
-const SELECTOR_CONTENT = '.popover-body'
-
-const Default = {
-  ...Tooltip.Default,
-  content: '',
-  offset: [0, 8],
-  placement: 'right',
-  template: '<div class="popover" role="tooltip">' +
-    '<div class="popover-arrow"></div>' +
-    '<h3 class="popover-header"></h3>' +
-    '<div class="popover-body"></div>' +
-    '</div>',
-  trigger: 'click'
-}
-
-const DefaultType = {
-  ...Tooltip.DefaultType,
-  content: '(null|string|element|function)'
-}
-
-/**
- * Class definition
- */
-
-class Popover extends Tooltip {
-  // Getters
-  static get Default() {
-    return Default
-  }
-
-  static get DefaultType() {
-    return DefaultType
-  }
-
-  static get NAME() {
-    return NAME
-  }
-
-  // Overrides
-  _isWithContent() {
-    return this._getTitle() || this._getContent()
-  }
-
-  // Private
-  _getContentForTemplate() {
-    return {
-      [SELECTOR_TITLE]: this._getTitle(),
-      [SELECTOR_CONTENT]: this._getContent()
-    }
-  }
-
-  _getContent() {
-    return this._resolvePossibleFunction(this._config.content)
-  }
-
-  // Static
-  static jQueryInterface(config) {
-    return this.each(function () {
-      const data = Popover.getOrCreateInstance(this, config)
-
-      if (typeof config !== 'string') {
-        return
-      }
-
-      if (typeof data[config] === 'undefined') {
-        throw new TypeError(`No method named "${config}"`)
-      }
-
-      data[config]()
-    })
-  }
-}
-
-/**
- * jQuery
- */
-
-defineJQueryPlugin(Popover)
-
-export default Popover

package/assets/bootstrap/js/src/scrollspy.js

@@ -1,290 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): scrollspy.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import { defineJQueryPlugin, getElement, isDisabled, isVisible } from './util/index'
-import EventHandler from './dom/event-handler'
-import SelectorEngine from './dom/selector-engine'
-import BaseComponent from './base-component'
-
-/**
- * Constants
- */
-
-const NAME = 'scrollspy'
-const DATA_KEY = 'bs.scrollspy'
-const EVENT_KEY = `.${DATA_KEY}`
-const DATA_API_KEY = '.data-api'
-
-const EVENT_ACTIVATE = `activate${EVENT_KEY}`
-const EVENT_CLICK = `click${EVENT_KEY}`
-const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`
-
-const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item'
-const CLASS_NAME_ACTIVE = 'active'
-
-const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]'
-const SELECTOR_TARGET_LINKS = '[href]'
-const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'
-const SELECTOR_NAV_LINKS = '.nav-link'
-const SELECTOR_NAV_ITEMS = '.nav-item'
-const SELECTOR_LIST_ITEMS = '.list-group-item'
-const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`
-const SELECTOR_DROPDOWN = '.dropdown'
-const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'
-
-const Default = {
-  offset: null, // TODO: v6 @deprecated, keep it for backwards compatibility reasons
-  rootMargin: '0px 0px -25%',
-  smoothScroll: false,
-  target: null
-}
-
-const DefaultType = {
-  offset: '(number|null)', // TODO v6 @deprecated, keep it for backwards compatibility reasons
-  rootMargin: 'string',
-  smoothScroll: 'boolean',
-  target: 'element'
-}
-
-/**
- * Class definition
- */
-
-class ScrollSpy extends BaseComponent {
-  constructor(element, config) {
-    super(element, config)
-
-    // this._element is the observablesContainer and config.target the menu links wrapper
-    this._targetLinks = new Map()
-    this._observableSections = new Map()
-    this._rootElement = getComputedStyle(this._element).overflowY === 'visible' ? null : this._element
-    this._activeTarget = null
-    this._observer = null
-    this._previousScrollData = {
-      visibleEntryTop: 0,
-      parentScrollTop: 0
-    }
-    this.refresh() // initialize
-  }
-
-  // Getters
-  static get Default() {
-    return Default
-  }
-
-  static get DefaultType() {
-    return DefaultType
-  }
-
-  static get NAME() {
-    return NAME
-  }
-
-  // Public
-  refresh() {
-    this._initializeTargetsAndObservables()
-    this._maybeEnableSmoothScroll()
-
-    if (this._observer) {
-      this._observer.disconnect()
-    } else {
-      this._observer = this._getNewObserver()
-    }
-
-    for (const section of this._observableSections.values()) {
-      this._observer.observe(section)
-    }
-  }
-
-  dispose() {
-    this._observer.disconnect()
-    super.dispose()
-  }
-
-  // Private
-  _configAfterMerge(config) {
-    // TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case
-    config.target = getElement(config.target) || document.body
-
-    return config
-  }
-
-  _maybeEnableSmoothScroll() {
-    if (!this._config.smoothScroll) {
-      return
-    }
-
-    // unregister any previous listeners
-    EventHandler.off(this._config.target, EVENT_CLICK)
-
-    EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, event => {
-      const observableSection = this._observableSections.get(event.target.hash)
-      if (observableSection) {
-        event.preventDefault()
-        const root = this._rootElement || window
-        const height = observableSection.offsetTop - this._element.offsetTop
-        if (root.scrollTo) {
-          root.scrollTo({ top: height, behavior: 'smooth' })
-          return
-        }
-
-        // Chrome 60 doesn't support `scrollTo`
-        root.scrollTop = height
-      }
-    })
-  }
-
-  _getNewObserver() {
-    const options = {
-      root: this._rootElement,
-      threshold: [0.1, 0.5, 1],
-      rootMargin: this._getRootMargin()
-    }
-
-    return new IntersectionObserver(entries => this._observerCallback(entries), options)
-  }
-
-  // The logic of selection
-  _observerCallback(entries) {
-    const targetElement = entry => this._targetLinks.get(`#${entry.target.id}`)
-    const activate = entry => {
-      this._previousScrollData.visibleEntryTop = entry.target.offsetTop
-      this._process(targetElement(entry))
-    }
-
-    const parentScrollTop = (this._rootElement || document.documentElement).scrollTop
-    const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop
-    this._previousScrollData.parentScrollTop = parentScrollTop
-
-    for (const entry of entries) {
-      if (!entry.isIntersecting) {
-        this._activeTarget = null
-        this._clearActiveClass(targetElement(entry))
-
-        continue
-      }
-
-      const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop
-      // if we are scrolling down, pick the bigger offsetTop
-      if (userScrollsDown && entryIsLowerThanPrevious) {
-        activate(entry)
-        // if parent isn't scrolled, let's keep the first visible item, breaking the iteration
-        if (!parentScrollTop) {
-          return
-        }
-
-        continue
-      }
-
-      // if we are scrolling up, pick the smallest offsetTop
-      if (!userScrollsDown && !entryIsLowerThanPrevious) {
-        activate(entry)
-      }
-    }
-  }
-
-  // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only
-  _getRootMargin() {
-    return this._config.offset ? `${this._config.offset}px 0px -30%` : this._config.rootMargin
-  }
-
-  _initializeTargetsAndObservables() {
-    this._targetLinks = new Map()
-    this._observableSections = new Map()
-
-    const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target)
-
-    for (const anchor of targetLinks) {
-      // ensure that the anchor has an id and is not disabled
-      if (!anchor.hash || isDisabled(anchor)) {
-        continue
-      }
-
-      const observableSection = SelectorEngine.findOne(anchor.hash, this._element)
-
-      // ensure that the observableSection exists & is visible
-      if (isVisible(observableSection)) {
-        this._targetLinks.set(anchor.hash, anchor)
-        this._observableSections.set(anchor.hash, observableSection)
-      }
-    }
-  }
-
-  _process(target) {
-    if (this._activeTarget === target) {
-      return
-    }
-
-    this._clearActiveClass(this._config.target)
-    this._activeTarget = target
-    target.classList.add(CLASS_NAME_ACTIVE)
-    this._activateParents(target)
-
-    EventHandler.trigger(this._element, EVENT_ACTIVATE, { relatedTarget: target })
-  }
-
-  _activateParents(target) {
-    // Activate dropdown parents
-    if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
-      SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE, target.closest(SELECTOR_DROPDOWN))
-        .classList.add(CLASS_NAME_ACTIVE)
-      return
-    }
-
-    for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) {
-      // Set triggered links parents as active
-      // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
-      for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) {
-        item.classList.add(CLASS_NAME_ACTIVE)
-      }
-    }
-  }
-
-  _clearActiveClass(parent) {
-    parent.classList.remove(CLASS_NAME_ACTIVE)
-
-    const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE}`, parent)
-    for (const node of activeNodes) {
-      node.classList.remove(CLASS_NAME_ACTIVE)
-    }
-  }
-
-  // Static
-  static jQueryInterface(config) {
-    return this.each(function () {
-      const data = ScrollSpy.getOrCreateInstance(this, config)
-
-      if (typeof config !== 'string') {
-        return
-      }
-
-      if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
-        throw new TypeError(`No method named "${config}"`)
-      }
-
-      data[config]()
-    })
-  }
-}
-
-/**
- * Data API implementation
- */
-
-EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
-  for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) {
-    ScrollSpy.getOrCreateInstance(spy)
-  }
-})
-
-/**
- * jQuery
- */
-
-defineJQueryPlugin(ScrollSpy)
-
-export default ScrollSpy

package/assets/bootstrap/js/src/tab.js

@@ -1,307 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): tab.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import { defineJQueryPlugin, getElementFromSelector, getNextActiveElement, isDisabled } from './util/index'
-import EventHandler from './dom/event-handler'
-import SelectorEngine from './dom/selector-engine'
-import BaseComponent from './base-component'
-
-/**
- * Constants
- */
-
-const NAME = 'tab'
-const DATA_KEY = 'bs.tab'
-const EVENT_KEY = `.${DATA_KEY}`
-
-const EVENT_HIDE = `hide${EVENT_KEY}`
-const EVENT_HIDDEN = `hidden${EVENT_KEY}`
-const EVENT_SHOW = `show${EVENT_KEY}`
-const EVENT_SHOWN = `shown${EVENT_KEY}`
-const EVENT_CLICK_DATA_API = `click${EVENT_KEY}`
-const EVENT_KEYDOWN = `keydown${EVENT_KEY}`
-const EVENT_LOAD_DATA_API = `load${EVENT_KEY}`
-
-const ARROW_LEFT_KEY = 'ArrowLeft'
-const ARROW_RIGHT_KEY = 'ArrowRight'
-const ARROW_UP_KEY = 'ArrowUp'
-const ARROW_DOWN_KEY = 'ArrowDown'
-
-const CLASS_NAME_ACTIVE = 'active'
-const CLASS_NAME_FADE = 'fade'
-const CLASS_NAME_SHOW = 'show'
-const CLASS_DROPDOWN = 'dropdown'
-
-const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'
-const SELECTOR_DROPDOWN_MENU = '.dropdown-menu'
-const SELECTOR_DROPDOWN_ITEM = '.dropdown-item'
-const NOT_SELECTOR_DROPDOWN_TOGGLE = ':not(.dropdown-toggle)'
-
-const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]'
-const SELECTOR_OUTER = '.nav-item, .list-group-item'
-const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`
-const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]' // todo:v6: could be only `tab`
-const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`
-
-const SELECTOR_DATA_TOGGLE_ACTIVE = `.${CLASS_NAME_ACTIVE}[data-bs-toggle="tab"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="pill"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="list"]`
-
-/**
- * Class definition
- */
-
-class Tab extends BaseComponent {
-  constructor(element) {
-    super(element)
-    this._parent = this._element.closest(SELECTOR_TAB_PANEL)
-
-    if (!this._parent) {
-      return
-      // todo: should Throw exception on v6
-      // throw new TypeError(`${element.outerHTML} has not a valid parent ${SELECTOR_INNER_ELEM}`)
-    }
-
-    // Set up initial aria attributes
-    this._setInitialAttributes(this._parent, this._getChildren())
-
-    EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event))
-  }
-
-  // Getters
-  static get NAME() {
-    return NAME
-  }
-
-  // Public
-  show() { // Shows this elem and deactivate the active sibling if exists
-    const innerElem = this._element
-    if (this._elemIsActive(innerElem)) {
-      return
-    }
-
-    // Search for active tab on same parent to deactivate it
-    const active = this._getActiveElem()
-
-    const hideEvent = active ?
-      EventHandler.trigger(active, EVENT_HIDE, { relatedTarget: innerElem }) :
-      null
-
-    const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW, { relatedTarget: active })
-
-    if (showEvent.defaultPrevented || (hideEvent && hideEvent.defaultPrevented)) {
-      return
-    }
-
-    this._deactivate(active, innerElem)
-    this._activate(innerElem, active)
-  }
-
-  // Private
-  _activate(element, relatedElem) {
-    if (!element) {
-      return
-    }
-
-    element.classList.add(CLASS_NAME_ACTIVE)
-
-    this._activate(getElementFromSelector(element)) // Search and activate/show the proper section
-
-    const complete = () => {
-      if (element.getAttribute('role') !== 'tab') {
-        element.classList.add(CLASS_NAME_SHOW)
-        return
-      }
-
-      element.focus()
-      element.removeAttribute('tabindex')
-      element.setAttribute('aria-selected', true)
-      this._toggleDropDown(element, true)
-      EventHandler.trigger(element, EVENT_SHOWN, {
-        relatedTarget: relatedElem
-      })
-    }
-
-    this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE))
-  }
-
-  _deactivate(element, relatedElem) {
-    if (!element) {
-      return
-    }
-
-    element.classList.remove(CLASS_NAME_ACTIVE)
-    element.blur()
-
-    this._deactivate(getElementFromSelector(element)) // Search and deactivate the shown section too
-
-    const complete = () => {
-      if (element.getAttribute('role') !== 'tab') {
-        element.classList.remove(CLASS_NAME_SHOW)
-        return
-      }
-
-      element.setAttribute('aria-selected', false)
-      element.setAttribute('tabindex', '-1')
-      this._toggleDropDown(element, false)
-      EventHandler.trigger(element, EVENT_HIDDEN, { relatedTarget: relatedElem })
-    }
-
-    this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE))
-  }
-
-  _keydown(event) {
-    if (!([ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY].includes(event.key))) {
-      return
-    }
-
-    event.stopPropagation()// stopPropagation/preventDefault both added to support up/down keys without scrolling the page
-    event.preventDefault()
-    const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key)
-    const nextActiveElement = getNextActiveElement(this._getChildren().filter(element => !isDisabled(element)), event.target, isNext, true)
-
-    if (nextActiveElement) {
-      Tab.getOrCreateInstance(nextActiveElement).show()
-    }
-  }
-
-  _getChildren() { // collection of inner elements
-    return SelectorEngine.find(SELECTOR_INNER_ELEM, this._parent)
-  }
-
-  _getActiveElem() {
-    return this._getChildren().find(child => this._elemIsActive(child)) || null
-  }
-
-  _setInitialAttributes(parent, children) {
-    this._setAttributeIfNotExists(parent, 'role', 'tablist')
-
-    for (const child of children) {
-      this._setInitialAttributesOnChild(child)
-    }
-  }
-
-  _setInitialAttributesOnChild(child) {
-    child = this._getInnerElement(child)
-    const isActive = this._elemIsActive(child)
-    const outerElem = this._getOuterElement(child)
-    child.setAttribute('aria-selected', isActive)
-
-    if (outerElem !== child) {
-      this._setAttributeIfNotExists(outerElem, 'role', 'presentation')
-    }
-
-    if (!isActive) {
-      child.setAttribute('tabindex', '-1')
-    }
-
-    this._setAttributeIfNotExists(child, 'role', 'tab')
-
-    // set attributes to the related panel too
-    this._setInitialAttributesOnTargetPanel(child)
-  }
-
-  _setInitialAttributesOnTargetPanel(child) {
-    const target = getElementFromSelector(child)
-
-    if (!target) {
-      return
-    }
-
-    this._setAttributeIfNotExists(target, 'role', 'tabpanel')
-
-    if (child.id) {
-      this._setAttributeIfNotExists(target, 'aria-labelledby', `#${child.id}`)
-    }
-  }
-
-  _toggleDropDown(element, open) {
-    const outerElem = this._getOuterElement(element)
-    if (!outerElem.classList.contains(CLASS_DROPDOWN)) {
-      return
-    }
-
-    const toggle = (selector, className) => {
-      const element = SelectorEngine.findOne(selector, outerElem)
-      if (element) {
-        element.classList.toggle(className, open)
-      }
-    }
-
-    toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE)
-    toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW)
-    toggle(SELECTOR_DROPDOWN_ITEM, CLASS_NAME_ACTIVE)
-    outerElem.setAttribute('aria-expanded', open)
-  }
-
-  _setAttributeIfNotExists(element, attribute, value) {
-    if (!element.hasAttribute(attribute)) {
-      element.setAttribute(attribute, value)
-    }
-  }
-
-  _elemIsActive(elem) {
-    return elem.classList.contains(CLASS_NAME_ACTIVE)
-  }
-
-  // Try to get the inner element (usually the .nav-link)
-  _getInnerElement(elem) {
-    return elem.matches(SELECTOR_INNER_ELEM) ? elem : SelectorEngine.findOne(SELECTOR_INNER_ELEM, elem)
-  }
-
-  // Try to get the outer element (usually the .nav-item)
-  _getOuterElement(elem) {
-    return elem.closest(SELECTOR_OUTER) || elem
-  }
-
-  // Static
-  static jQueryInterface(config) {
-    return this.each(function () {
-      const data = Tab.getOrCreateInstance(this)
-
-      if (typeof config !== 'string') {
-        return
-      }
-
-      if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
-        throw new TypeError(`No method named "${config}"`)
-      }
-
-      data[config]()
-    })
-  }
-}
-
-/**
- * Data API implementation
- */
-
-EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
-  if (['A', 'AREA'].includes(this.tagName)) {
-    event.preventDefault()
-  }
-
-  if (isDisabled(this)) {
-    return
-  }
-
-  Tab.getOrCreateInstance(this).show()
-})
-
-/**
- * Initialize on focus
- */
-EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
-  for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) {
-    Tab.getOrCreateInstance(element)
-  }
-})
-/**
- * jQuery
- */
-
-defineJQueryPlugin(Tab)
-
-export default Tab