material 1.0.3 → 3.0.0-next.0

package/src/module/css.js

@@ -1,35 +0,0 @@
-const has = (element, className) => {
-  if (!element || !className) return false
-  return !!element.className.match(new RegExp(`(\\s|^)${className}(\\s|$)`))
-}
-
-const add = (element, className) => {
-  if (!element || !className) return
-
-  const sanitizedClassName = className.trim().replace(/\s+/g, ' ')
-  const classNames = sanitizedClassName.split(' ')
-
-  for (const cn of classNames) {
-    if (!has(element, cn)) {
-      element.classList.add(cn)
-    }
-  }
-  return element
-}
-
-const remove = (element, className) => {
-  if (!element || !className) return
-  element.classList.remove(className)
-  return element
-}
-
-const toggle = (element, className) => {
-  if (has(element, className)) {
-    remove(element, className)
-  } else {
-    add(element, className)
-  }
-  return element
-}
-
-export { has, add, remove, toggle }

package/src/module/dataset.js

@@ -1,19 +0,0 @@
-/**
- * Applies data attributes to a DOM element based on an object's properties.
- *
- * This function takes an object and applies its key-value pairs as data attributes
- * to a provided DOM element. Only the object's own properties (not inherited properties)
- * are applied.
- *
- * @param {Element} element - The DOM element to which data attributes will be applied.
- * @param {Object} data - An object containing key-value pairs to be applied as data attributes.
- */
-const dataset = (element, data) => {
-  if (data) {
-    Object.entries(data).forEach(([key, value]) => {
-      element.dataset[key] = value
-    })
-  }
-}
-
-export default dataset

package/src/module/device.js

@@ -1,389 +0,0 @@
-// based on the work of
-// https://github.com/matthewhudson/current-device
-
-const previousDevice = window.device
-
-const device = {}
-const os = ['ios', 'iphone', 'ipad', 'ipod', 'android', 'blackberry', 'macos', 'windows', 'fxos', 'meego', 'television']
-const type = ['mobile', 'tablet', 'desktop']
-const television = ['googletv', 'viera', 'smarttv', 'internet.tv', 'netcast', 'nettv', 'appletv', 'boxee', 'kylo', 'roku', 'dlnadoc', 'pov_tv', 'hbbtv', 'ce-html']
-
-const changeOrientationList = []
-
-// Add device as a global object.
-window.device = device
-
-// The <html> element.
-const documentElement = window.document.documentElement
-
-// The client user agent string.
-// Lowercase, so we can use the more efficient indexOf(), instead of Regex
-let userAgent = window.navigator.userAgent.toLowerCase()
-
-// Detectable television devices.
-
-// Main functions
-// --------------
-
-device.macos = function () {
-  return find('mac')
-}
-
-device.ios = function () {
-  return device.iphone() || device.ipod() || device.ipad()
-}
-
-device.iphone = function () {
-  return !device.windows() && find('iphone')
-}
-
-device.ipod = function () {
-  return find('ipod')
-}
-
-device.ipad = function () {
-  const iPadOS13Up =
-    navigator.platform === 'MacIntel' && navigator.maxTouchPoints > 1
-  return find('ipad') || iPadOS13Up
-}
-
-device.android = function () {
-  return !device.windows() && find('android')
-}
-
-device.androidPhone = function () {
-  return device.android() && find('mobile')
-}
-
-device.androidTablet = function () {
-  return device.android() && !find('mobile')
-}
-
-device.blackberry = function () {
-  return find('blackberry') || find('bb10')
-}
-
-device.blackberryPhone = function () {
-  return device.blackberry() && !find('tablet')
-}
-
-device.blackberryTablet = function () {
-  return device.blackberry() && find('tablet')
-}
-
-device.windows = function () {
-  return find('windows')
-}
-
-device.windowsPhone = function () {
-  return device.windows() && find('phone')
-}
-
-device.windowsTablet = function () {
-  return device.windows() && (find('touch') && !device.windowsPhone())
-}
-
-device.fxos = function () {
-  return (find('(mobile') || find('(tablet')) && find(' rv:')
-}
-
-device.fxosPhone = function () {
-  return device.fxos() && find('mobile')
-}
-
-device.fxosTablet = function () {
-  return device.fxos() && find('tablet')
-}
-
-device.meego = function () {
-  return find('meego')
-}
-
-device.cordova = function () {
-  return window.cordova && location.protocol === 'file:'
-}
-
-device.nodeWebkit = function () {
-  return typeof window.process === 'object'
-}
-
-device.mobile = function () {
-  return (
-    device.androidPhone() ||
-    device.iphone() ||
-    device.ipod() ||
-    device.windowsPhone() ||
-    device.blackberryPhone() ||
-    device.fxosPhone() ||
-    device.meego()
-  )
-}
-
-device.tablet = function () {
-  return (
-    device.ipad() ||
-    device.androidTablet() ||
-    device.blackberryTablet() ||
-    device.windowsTablet() ||
-    device.fxosTablet()
-  )
-}
-
-device.desktop = function () {
-  return !device.tablet() && !device.mobile()
-}
-
-device.television = function () {
-  let i = 0
-  while (i < television.length) {
-    if (find(television[i])) {
-      return true
-    }
-    i++
-  }
-  return false
-}
-
-device.portrait = function () {
-  if (
-    screen.orientation &&
-    Object.prototype.hasOwnProperty.call(window, 'onorientationchange')
-  ) {
-    return includes(screen.orientation.type, 'portrait')
-  }
-  if (
-    device.ios() &&
-    Object.prototype.hasOwnProperty.call(window, 'orientation')
-  ) {
-    return Math.abs(window.orientation) !== 90
-  }
-  return window.innerHeight / window.innerWidth > 1
-}
-
-device.landscape = function () {
-  if (
-    screen.orientation &&
-    Object.prototype.hasOwnProperty.call(window, 'onorientationchange')
-  ) {
-    return includes(screen.orientation.type, 'landscape')
-  }
-  if (
-    device.ios() &&
-    Object.prototype.hasOwnProperty.call(window, 'orientation')
-  ) {
-    return Math.abs(window.orientation) === 90
-  }
-  return window.innerHeight / window.innerWidth < 1
-}
-
-// Public Utility Functions
-// ------------------------
-
-// Run device.js in noConflict mode,
-// returning the device variable to its previous owner.
-device.noConflict = function () {
-  window.device = previousDevice
-  return this
-}
-
-// Private Utility Functions
-// -------------------------
-
-// Check if element exists
-function includes (haystack, needle) {
-  return haystack.indexOf(needle) !== -1
-}
-
-// Simple UA string search
-function find (needle) {
-  return includes(userAgent, needle)
-}
-
-// Check if documentElement already has a given class.
-function hasClass (className) {
-  return documentElement.className.match(new RegExp(className, 'i'))
-}
-
-// Add one or more CSS classes to the <html> element.
-function addClass (className) {
-  let currentClassNames = null
-  if (!hasClass(className)) {
-    currentClassNames = documentElement.className.replace(/^\s+|\s+$/g, '')
-    documentElement.className = `${currentClassNames} ${className}`
-  }
-}
-
-// Remove single CSS class from the <html> element.
-function removeClass (className) {
-  if (hasClass(className)) {
-    documentElement.className = documentElement.className.replace(
-      ` ${className}`,
-      ''
-    )
-  }
-}
-
-function cleanClasses () {
-  const classes = [...os, ...type]
-  for (let i = 0; i < classes.length; i++) {
-    removeClass(classes[i])
-  }
-}
-
-// HTML Element Handling
-// ---------------------
-
-// Insert the appropriate CSS class based on the _user_agent.
-function applyClass () {
-  cleanClasses()
-
-  if (device.ios()) {
-    if (device.ipad()) {
-      addClass('ios ipad tablet')
-    } else if (device.iphone()) {
-      addClass('ios iphone mobile')
-    } else if (device.ipod()) {
-      addClass('ios ipod mobile')
-    }
-  } else if (device.macos()) {
-    addClass('macos desktop')
-  } else if (device.android()) {
-    if (device.androidTablet()) {
-      addClass('android tablet')
-    } else {
-      addClass('android mobile')
-    }
-  } else if (device.blackberry()) {
-    if (device.blackberryTablet()) {
-      addClass('blackberry tablet')
-    } else {
-      addClass('blackberry mobile')
-    }
-  } else if (device.windows()) {
-    if (device.windowsTablet()) {
-      addClass('windows tablet')
-    } else if (device.windowsPhone()) {
-      addClass('windows mobile')
-    } else {
-      addClass('windows desktop')
-    }
-  } else if (device.fxos()) {
-    if (device.fxosTablet()) {
-      addClass('fxos tablet')
-    } else {
-      addClass('fxos mobile')
-    }
-  } else if (device.meego()) {
-    addClass('meego mobile')
-  } else if (device.nodeWebkit()) {
-    addClass('node-webkit')
-  } else if (device.television()) {
-    addClass('television')
-  } else if (device.desktop()) {
-    addClass('desktop')
-  }
-
-  if (device.cordova()) {
-    addClass('cordova')
-  }
-}
-
-applyClass()
-
-// Orientation Handling
-// --------------------
-
-// Handle device orientation changes.
-function handleOrientation () {
-  if (device.landscape()) {
-    removeClass('portrait')
-    addClass('landscape')
-    walkOnChangeOrientationList('landscape')
-  } else {
-    removeClass('landscape')
-    addClass('portrait')
-    walkOnChangeOrientationList('portrait')
-  }
-  setOrientationCache()
-}
-
-function walkOnChangeOrientationList (newOrientation) {
-  for (let index = 0; index < changeOrientationList.length; index++) {
-    changeOrientationList[index](newOrientation)
-  }
-}
-
-device.onChangeOrientation = function (cb) {
-  if (typeof cb === 'function') {
-    changeOrientationList.push(cb)
-  }
-}
-
-// Detect whether device supports orientationchange event,
-// otherwise fall back to the resize event.
-let orientationEvent = 'resize'
-if (Object.prototype.hasOwnProperty.call(window, 'onorientationchange')) {
-  orientationEvent = 'orientationchange'
-}
-
-// Listen for changes in orientation.
-if (window.addEventListener) {
-  window.addEventListener(orientationEvent, handleOrientation, false)
-} else if (window.attachEvent) {
-  window.attachEvent(orientationEvent, handleOrientation)
-} else {
-  window[orientationEvent] = handleOrientation
-}
-
-handleOrientation()
-
-// Public functions to get the current value of type, os, or orientation
-// ---------------------------------------------------------------------
-
-function findMatch (arr) {
-  for (let i = 0; i < arr.length; i++) {
-    if (device[arr[i]]()) {
-      return arr[i]
-    }
-  }
-  return 'unknown'
-}
-
-device.type = findMatch(type)
-device.os = findMatch(os)
-
-function setOrientationCache () {
-  device.orientation = findMatch(['portrait', 'landscape'])
-}
-
-setOrientationCache()
-
-let previousDeviceType = null
-device.onDeviceChange = null
-
-function updateDeviceDetection () {
-  userAgent = window.navigator.userAgent.toLowerCase()
-  device.type = findMatch(type)
-  device.os = findMatch(os)
-  setOrientationCache()
-  applyClass()
-  checkAndHandleDeviceChange()
-}
-
-window.addEventListener('resize', updateDeviceDetection)
-
-function triggerOnDeviceChange () {
-  if (typeof device.onDeviceChange === 'function') {
-    device.onDeviceChange(device.type)
-  }
-}
-
-function checkAndHandleDeviceChange () {
-  const currentDeviceType = device.type
-  if (previousDeviceType !== currentDeviceType) {
-    triggerOnDeviceChange()
-    previousDeviceType = currentDeviceType
-  }
-}
-
-export default device

package/src/module/dom.js

@@ -1,49 +0,0 @@
-// DOM manipulation function
-
-function append (container, element) {
-  container.appendChild(element)
-  return element
-}
-
-function prepend (container, element) {
-  return container.insertBefore(element, container.firstChild)
-}
-
-function after (container, element) {
-  return container.parentNode.insertBefore(element, container.nextSibling)
-}
-
-function before (container, element) {
-  return container.insertBefore(element, container)
-}
-
-function replace (container, element) {
-  return container.parentNode.replaceChild(element, container)
-}
-
-function remove (element) {
-  const parent = element.parentNode
-  return parent.removeChild(element)
-}
-
-function dispose (element) {
-  const el = element
-  return (el.parentNode) ? el.parentNode.removeChild(el) : el
-}
-
-function empty (element) {
-  while (element.firstChild) {
-    element.removeChild(element.firstChild)
-  }
-}
-
-function destroy (element) {
-  if (element && element.parentNode) {
-    return element.parentNode.removeChild(element)
-  } else {
-    // console.error('Element or its parent node is null')
-    return null
-  }
-}
-
-export default { append, prepend, after, before, replace, remove, destroy, empty, dispose }

package/src/module/dot.js

@@ -1,38 +0,0 @@
-/**
- * Converts a nested object into a flat object with dotted paths as keys.
- *
- * @param {Object} obj - The object to be flattened.
- * @param {string} [base=''] - (Internal use) A prefix used to build the dotted paths. Users typically do not need to provide this.
- * @returns {Object} A new object with the same values as `obj`, but flattened.
- *
- * @example
- * const nested = { a: { b: { c: 1 }, d: 2 }, e: 3 };
- * const flat = dot(nested);
- * // flat is now { 'a.b.c': 1, 'a.d': 2, 'e': 3 }
- *
- * @example
- * // It does not flatten arrays or date objects
- * const complex = { a: [{ b: 1 }, { c: 2 }], d: new Date() };
- * const flatComplex = dot(complex);
- * // flatComplex is now { 'a': [{ b: 1 }, { c: 2 }], 'd': [Date Object] }
- */
-
-function dot (obj) {
-  const res = {}
-  function recurse (obj, current) {
-    for (const key in obj) {
-      const value = obj[key]
-      const newKey = (current ? current + '.' + key : key)
-      if (value && typeof value === 'object') {
-        recurse(value, newKey)
-      } else {
-        res[newKey] = value
-      }
-    }
-  }
-
-  recurse(obj)
-  return res
-}
-
-export default dot

package/src/module/emitter.js

@@ -1,54 +0,0 @@
-// Event emitter mixin that can be extended into other objects
-export default {
-  // Initialize the events storage if needed
-  _initEvents () {
-    this.events = this.events || {}
-  },
-
-  // Add an event listener
-  on (event, listener) {
-    this._initEvents()
-    // Use nullish coalescing assignment for array initialization
-    this.events[event] ??= []
-    this.events[event].push(listener)
-    return this
-  },
-
-  // Emit an event with optional arguments
-  emit (event, ...args) {
-    this._initEvents()
-    // Use optional chaining to safely access and iterate events
-    this.events[event]?.forEach(listener => {
-      try {
-        listener.apply(this, args)
-      } catch (error) {
-        console.error(`Error in event listener for ${event}:`, error)
-      }
-    })
-    return this
-  },
-
-  // Remove a specific listener for an event
-  off (event, listener) {
-    this._initEvents()
-    const listeners = this.events[event]
-    if (listeners?.length) {
-      const index = listeners.indexOf(listener)
-      if (index !== -1) {
-        listeners.splice(index, 1)
-      }
-    }
-    return this
-  },
-
-  // Remove all listeners for an event or all events
-  removeAll (event) {
-    this._initEvents()
-    if (event) {
-      delete this.events[event]
-    } else {
-      this.events = {}
-    }
-    return this
-  }
-}

package/src/module/event.js

@@ -1,58 +0,0 @@
-export default {
-
-  /**
-   * cross browser event add functions
-   * @param {string}   event The event to add
-   * @param {Function} fn    [description]
-   */
-  add (element, event, fn) {
-    // avoid memory overhead of new anonymous functions for every event handler that's installed
-    // by using local functions
-    function listenHandler (e) {
-      const ret = fn.apply(this, arguments)
-      if (ret === false) {
-        e.stopPropagation()
-        e.preventDefault()
-      }
-      return (ret)
-    }
-
-    function attachHandler () {
-      // set the this pointer same as addEventListener when fn is called
-      // and make sure the event is passed to the fn also so that works the same too
-      const ret = fn.call(element, window.event)
-      if (ret === false) {
-        window.event.returnValue = false
-        window.event.cancelBubble = true
-      }
-      return (ret)
-    }
-
-    if (element.addEventListener) {
-      element.addEventListener(event, listenHandler, false)
-    } else {
-      element.attachEvent('on' + event, attachHandler)
-    }
-
-    return this
-  },
-
-  /**
-   * cross browser event remove function
-   * @param  {string}   event The event to remove
-   * @param  {Function} fn    [description]
-   * @return {Object}         [description]
-   */
-  remove (element, event, fn) {
-    if (element.removeEventListener) {
-      element.removeEventListener(event, fn, false)
-    } else if (element.detachEvent) {
-      element.detachEvent('on' + event, element[fn.toString() + event])
-      element[fn.toString() + event] = null
-    } else {
-      element['on' + event] = function () {}
-    }
-
-    return this
-  }
-}