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

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

@@ -1,118 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): util/sanitizer.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-const uriAttributes = new Set([
-  'background',
-  'cite',
-  'href',
-  'itemtype',
-  'longdesc',
-  'poster',
-  'src',
-  'xlink:href'
-])
-
-const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i
-
-/**
- * A pattern that recognizes a commonly useful subset of URLs that are safe.
- *
- * Shout-out to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts
- */
-const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i
-
-/**
- * A pattern that matches safe data URLs. Only matches image, video and audio types.
- *
- * Shout-out to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts
- */
-const DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i
-
-const allowedAttribute = (attribute, allowedAttributeList) => {
-  const attributeName = attribute.nodeName.toLowerCase()
-
-  if (allowedAttributeList.includes(attributeName)) {
-    if (uriAttributes.has(attributeName)) {
-      return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue) || DATA_URL_PATTERN.test(attribute.nodeValue))
-    }
-
-    return true
-  }
-
-  // Check if a regular expression validates the attribute.
-  return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp)
-    .some(regex => regex.test(attributeName))
-}
-
-export const DefaultAllowlist = {
-  // Global attributes allowed on any supplied element below.
-  '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
-  a: ['target', 'href', 'title', 'rel'],
-  area: [],
-  b: [],
-  br: [],
-  col: [],
-  code: [],
-  div: [],
-  em: [],
-  hr: [],
-  h1: [],
-  h2: [],
-  h3: [],
-  h4: [],
-  h5: [],
-  h6: [],
-  i: [],
-  img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],
-  li: [],
-  ol: [],
-  p: [],
-  pre: [],
-  s: [],
-  small: [],
-  span: [],
-  sub: [],
-  sup: [],
-  strong: [],
-  u: [],
-  ul: []
-}
-
-export function sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) {
-  if (!unsafeHtml.length) {
-    return unsafeHtml
-  }
-
-  if (sanitizeFunction && typeof sanitizeFunction === 'function') {
-    return sanitizeFunction(unsafeHtml)
-  }
-
-  const domParser = new window.DOMParser()
-  const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html')
-  const elements = [].concat(...createdDocument.body.querySelectorAll('*'))
-
-  for (const element of elements) {
-    const elementName = element.nodeName.toLowerCase()
-
-    if (!Object.keys(allowList).includes(elementName)) {
-      element.remove()
-
-      continue
-    }
-
-    const attributeList = [].concat(...element.attributes)
-    const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || [])
-
-    for (const attribute of attributeList) {
-      if (!allowedAttribute(attribute, allowedAttributes)) {
-        element.removeAttribute(attribute.nodeName)
-      }
-    }
-  }
-
-  return createdDocument.body.innerHTML
-}

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

@@ -1,114 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): util/scrollBar.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import SelectorEngine from '../dom/selector-engine'
-import Manipulator from '../dom/manipulator'
-import { isElement } from './index'
-
-/**
- * Constants
- */
-
-const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'
-const SELECTOR_STICKY_CONTENT = '.sticky-top'
-const PROPERTY_PADDING = 'padding-right'
-const PROPERTY_MARGIN = 'margin-right'
-
-/**
- * Class definition
- */
-
-class ScrollBarHelper {
-  constructor() {
-    this._element = document.body
-  }
-
-  // Public
-  getWidth() {
-    // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
-    const documentWidth = document.documentElement.clientWidth
-    return Math.abs(window.innerWidth - documentWidth)
-  }
-
-  hide() {
-    const width = this.getWidth()
-    this._disableOverFlow()
-    // give padding to element to balance the hidden scrollbar width
-    this._setElementAttributes(this._element, PROPERTY_PADDING, calculatedValue => calculatedValue + width)
-    // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
-    this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width)
-    this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width)
-  }
-
-  reset() {
-    this._resetElementAttributes(this._element, 'overflow')
-    this._resetElementAttributes(this._element, PROPERTY_PADDING)
-    this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING)
-    this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN)
-  }
-
-  isOverflowing() {
-    return this.getWidth() > 0
-  }
-
-  // Private
-  _disableOverFlow() {
-    this._saveInitialAttribute(this._element, 'overflow')
-    this._element.style.overflow = 'hidden'
-  }
-
-  _setElementAttributes(selector, styleProperty, callback) {
-    const scrollbarWidth = this.getWidth()
-    const manipulationCallBack = element => {
-      if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
-        return
-      }
-
-      this._saveInitialAttribute(element, styleProperty)
-      const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty)
-      element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`)
-    }
-
-    this._applyManipulationCallback(selector, manipulationCallBack)
-  }
-
-  _saveInitialAttribute(element, styleProperty) {
-    const actualValue = element.style.getPropertyValue(styleProperty)
-    if (actualValue) {
-      Manipulator.setDataAttribute(element, styleProperty, actualValue)
-    }
-  }
-
-  _resetElementAttributes(selector, styleProperty) {
-    const manipulationCallBack = element => {
-      const value = Manipulator.getDataAttribute(element, styleProperty)
-      // We only want to remove the property if the value is `null`; the value can also be zero
-      if (value === null) {
-        element.style.removeProperty(styleProperty)
-        return
-      }
-
-      Manipulator.removeDataAttribute(element, styleProperty)
-      element.style.setProperty(styleProperty, value)
-    }
-
-    this._applyManipulationCallback(selector, manipulationCallBack)
-  }
-
-  _applyManipulationCallback(selector, callBack) {
-    if (isElement(selector)) {
-      callBack(selector)
-      return
-    }
-
-    for (const sel of SelectorEngine.find(selector, this._element)) {
-      callBack(sel)
-    }
-  }
-}
-
-export default ScrollBarHelper

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

@@ -1,146 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): util/swipe.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import Config from './config'
-import EventHandler from '../dom/event-handler'
-import { execute } from './index'
-
-/**
- * Constants
- */
-
-const NAME = 'swipe'
-const EVENT_KEY = '.bs.swipe'
-const EVENT_TOUCHSTART = `touchstart${EVENT_KEY}`
-const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY}`
-const EVENT_TOUCHEND = `touchend${EVENT_KEY}`
-const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY}`
-const EVENT_POINTERUP = `pointerup${EVENT_KEY}`
-const POINTER_TYPE_TOUCH = 'touch'
-const POINTER_TYPE_PEN = 'pen'
-const CLASS_NAME_POINTER_EVENT = 'pointer-event'
-const SWIPE_THRESHOLD = 40
-
-const Default = {
-  endCallback: null,
-  leftCallback: null,
-  rightCallback: null
-}
-
-const DefaultType = {
-  endCallback: '(function|null)',
-  leftCallback: '(function|null)',
-  rightCallback: '(function|null)'
-}
-
-/**
- * Class definition
- */
-
-class Swipe extends Config {
-  constructor(element, config) {
-    super()
-    this._element = element
-
-    if (!element || !Swipe.isSupported()) {
-      return
-    }
-
-    this._config = this._getConfig(config)
-    this._deltaX = 0
-    this._supportPointerEvents = Boolean(window.PointerEvent)
-    this._initEvents()
-  }
-
-  // Getters
-  static get Default() {
-    return Default
-  }
-
-  static get DefaultType() {
-    return DefaultType
-  }
-
-  static get NAME() {
-    return NAME
-  }
-
-  // Public
-  dispose() {
-    EventHandler.off(this._element, EVENT_KEY)
-  }
-
-  // Private
-  _start(event) {
-    if (!this._supportPointerEvents) {
-      this._deltaX = event.touches[0].clientX
-
-      return
-    }
-
-    if (this._eventIsPointerPenTouch(event)) {
-      this._deltaX = event.clientX
-    }
-  }
-
-  _end(event) {
-    if (this._eventIsPointerPenTouch(event)) {
-      this._deltaX = event.clientX - this._deltaX
-    }
-
-    this._handleSwipe()
-    execute(this._config.endCallback)
-  }
-
-  _move(event) {
-    this._deltaX = event.touches && event.touches.length > 1 ?
-      0 :
-      event.touches[0].clientX - this._deltaX
-  }
-
-  _handleSwipe() {
-    const absDeltaX = Math.abs(this._deltaX)
-
-    if (absDeltaX <= SWIPE_THRESHOLD) {
-      return
-    }
-
-    const direction = absDeltaX / this._deltaX
-
-    this._deltaX = 0
-
-    if (!direction) {
-      return
-    }
-
-    execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback)
-  }
-
-  _initEvents() {
-    if (this._supportPointerEvents) {
-      EventHandler.on(this._element, EVENT_POINTERDOWN, event => this._start(event))
-      EventHandler.on(this._element, EVENT_POINTERUP, event => this._end(event))
-
-      this._element.classList.add(CLASS_NAME_POINTER_EVENT)
-    } else {
-      EventHandler.on(this._element, EVENT_TOUCHSTART, event => this._start(event))
-      EventHandler.on(this._element, EVENT_TOUCHMOVE, event => this._move(event))
-      EventHandler.on(this._element, EVENT_TOUCHEND, event => this._end(event))
-    }
-  }
-
-  _eventIsPointerPenTouch(event) {
-    return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)
-  }
-
-  // Static
-  static isSupported() {
-    return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0
-  }
-}
-
-export default Swipe

package/assets/bootstrap/js/src/util/template-factory.js

@@ -1,160 +0,0 @@
-/**
- * --------------------------------------------------------------------------
- * Bootstrap (v5.2.0): util/template-factory.js
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- * --------------------------------------------------------------------------
- */
-
-import { DefaultAllowlist, sanitizeHtml } from './sanitizer'
-import { getElement, isElement } from '../util/index'
-import SelectorEngine from '../dom/selector-engine'
-import Config from './config'
-
-/**
- * Constants
- */
-
-const NAME = 'TemplateFactory'
-
-const Default = {
-  allowList: DefaultAllowlist,
-  content: {}, // { selector : text ,  selector2 : text2 , }
-  extraClass: '',
-  html: false,
-  sanitize: true,
-  sanitizeFn: null,
-  template: '<div></div>'
-}
-
-const DefaultType = {
-  allowList: 'object',
-  content: 'object',
-  extraClass: '(string|function)',
-  html: 'boolean',
-  sanitize: 'boolean',
-  sanitizeFn: '(null|function)',
-  template: 'string'
-}
-
-const DefaultContentType = {
-  entry: '(string|element|function|null)',
-  selector: '(string|element)'
-}
-
-/**
- * Class definition
- */
-
-class TemplateFactory extends Config {
-  constructor(config) {
-    super()
-    this._config = this._getConfig(config)
-  }
-
-  // Getters
-  static get Default() {
-    return Default
-  }
-
-  static get DefaultType() {
-    return DefaultType
-  }
-
-  static get NAME() {
-    return NAME
-  }
-
-  // Public
-  getContent() {
-    return Object.values(this._config.content)
-      .map(config => this._resolvePossibleFunction(config))
-      .filter(Boolean)
-  }
-
-  hasContent() {
-    return this.getContent().length > 0
-  }
-
-  changeContent(content) {
-    this._checkContent(content)
-    this._config.content = { ...this._config.content, ...content }
-    return this
-  }
-
-  toHtml() {
-    const templateWrapper = document.createElement('div')
-    templateWrapper.innerHTML = this._maybeSanitize(this._config.template)
-
-    for (const [selector, text] of Object.entries(this._config.content)) {
-      this._setContent(templateWrapper, text, selector)
-    }
-
-    const template = templateWrapper.children[0]
-    const extraClass = this._resolvePossibleFunction(this._config.extraClass)
-
-    if (extraClass) {
-      template.classList.add(...extraClass.split(' '))
-    }
-
-    return template
-  }
-
-  // Private
-  _typeCheckConfig(config) {
-    super._typeCheckConfig(config)
-    this._checkContent(config.content)
-  }
-
-  _checkContent(arg) {
-    for (const [selector, content] of Object.entries(arg)) {
-      super._typeCheckConfig({ selector, entry: content }, DefaultContentType)
-    }
-  }
-
-  _setContent(template, content, selector) {
-    const templateElement = SelectorEngine.findOne(selector, template)
-
-    if (!templateElement) {
-      return
-    }
-
-    content = this._resolvePossibleFunction(content)
-
-    if (!content) {
-      templateElement.remove()
-      return
-    }
-
-    if (isElement(content)) {
-      this._putElementInTemplate(getElement(content), templateElement)
-      return
-    }
-
-    if (this._config.html) {
-      templateElement.innerHTML = this._maybeSanitize(content)
-      return
-    }
-
-    templateElement.textContent = content
-  }
-
-  _maybeSanitize(arg) {
-    return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg
-  }
-
-  _resolvePossibleFunction(arg) {
-    return typeof arg === 'function' ? arg(this) : arg
-  }
-
-  _putElementInTemplate(element, templateElement) {
-    if (this._config.html) {
-      templateElement.innerHTML = ''
-      templateElement.append(element)
-      return
-    }
-
-    templateElement.textContent = element.textContent
-  }
-}
-
-export default TemplateFactory