@symbo.ls/utils 3.14.2 → 3.14.3

package/cookie.js

@@ -1,78 +0,0 @@
-'use strict'
-
-import { isUndefined } from './types.js'
-import { document } from './globals.js'
-
-export const isMobile = (() =>
-  typeof navigator === 'undefined' ? false : /Mobi/.test(navigator.userAgent))()
-
-export const setCookie = (cname, cvalue, exdays = 365) => {
-  if (isUndefined(document) || isUndefined(document.cookie)) return
-  const d = new Date()
-  d.setTime(d.getTime() + exdays * 24 * 60 * 60 * 1000)
-  const expires = `expires=${d.toUTCString()}`
-  document.cookie = `${cname}=${cvalue};${expires};path=/`
-}
-
-export const getCookie = cname => {
-  if (isUndefined(document) || isUndefined(document.cookie)) return
-  const name = `${cname}=`
-  const decodedCookie = decodeURIComponent(document.cookie)
-  const ca = decodedCookie.split(';')
-  for (let i = 0; i < ca.length; i++) {
-    let c = ca[i]
-    while (c.charAt(0) === ' ') c = c.substring(1)
-    if (c.indexOf(name) === 0) return c.substring(name.length, c.length)
-  }
-  return ''
-}
-
-export const removeCookie = cname => {
-  if (isUndefined(document) || isUndefined(document.cookie)) return
-  document.cookie = cname + '=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;'
-}
-/**
- * Load item from the localStorage
- *
- * @param key -- string to identify the storage item
- * @returns {*} -- parsed data or undefined
- */
-export function getLocalStorage (key) {
-  // localStorage access throws in: Safari private mode (quota), sandboxed
-  // iframes without `allow-storage-access-by-user-activation`, Firefox with
-  // `dom.storage.enabled=false`. Wrap the access itself, not just the
-  // JSON.parse — the existing try only covered parse and let the read
-  // crash the host.
-  let item
-  try {
-    if (!window.localStorage) return undefined
-    item = window.localStorage.getItem(key)
-  } catch (e) {
-    return undefined
-  }
-  if (item === null) return undefined
-  try {
-    return JSON.parse(item)
-  } catch (e) {
-    return undefined
-  }
-}
-
-/**
- * Save the data to window.localStorage
- *
- * @param key  - local storage key to save the data under
- * @param data - the data to save
- */
-export function setLocalStorage (key, data) {
-  if (data === undefined || data === null) return
-  try {
-    if (!window.localStorage) return
-    const value = typeof data === 'object' ? JSON.stringify(data) : data
-    window.localStorage.setItem(key, value)
-  } catch (e) {
-    // QuotaExceededError (Safari private + over quota), SecurityError
-    // (sandboxed iframe / disabled storage). Silent fail — caller doesn't
-    // expect an exception out of a "save best-effort" helper.
-  }
-}

package/date.js

@@ -1,10 +0,0 @@
-'use strict'
-
-export const formatDate = (timestamp) => {
-  if (!timestamp) return ''
-  const d = new Date(timestamp)
-  const ye = new Intl.DateTimeFormat('en', { year: 'numeric' }).format(d)
-  const mo = new Intl.DateTimeFormat('en', { month: 'short' }).format(d)
-  const da = new Intl.DateTimeFormat('en', { day: '2-digit' }).format(d)
-  return `${da} ${mo}, ${ye}`
-}

package/detectHeight.js

@@ -1,42 +0,0 @@
-'use strict'
-
-export const detectHeightOnInit = (element, state) => {
-  const heightTimeout = setTimeout(() => {
-    const { props } = element
-    if (!state.clientHeight) {
-      const {
-        node: { clientHeight }
-      } = element
-      if (clientHeight) {
-        state.clientHeight = clientHeight
-      }
-    }
-
-    if (state.active) {
-      if (props.height === 'auto') return
-      element.update(
-        {
-          height: state.clientHeight
-        },
-        { preventBeforeUpdateListener: true, preventChildrenUpdate: true }
-      )
-      const setAutoTimeout = setTimeout(() => {
-        element.update(
-          {
-            height: 'auto'
-          },
-          { preventBeforeUpdateListener: true, preventChildrenUpdate: true }
-        )
-        clearTimeout(setAutoTimeout)
-      }, 450)
-    } else {
-      element.update(
-        {
-          height: '0'
-        },
-        { preventBeforeUpdateListener: true, preventChildrenUpdate: true }
-      )
-    }
-    clearTimeout(heightTimeout)
-  })
-}

package/element.js

@@ -1,148 +0,0 @@
-'use strict'
-
-import { createExtends } from './extends.js'
-import { createKey } from './key.js'
-import { isNode } from './node.js'
-import { createProps } from './props.js'
-import { HTML_TAGS } from './tags.js'
-import { is, isFunction } from './types.js'
-
-const ENV = process.env.NODE_ENV
-
-export const returnValueAsText = (element, parent, key) => {
-  const childExtendsTag = parent.childExtends && parent.childExtends.tag
-  const childPropsTag = parent.childProps && parent.childProps.tag
-  const isKeyValidHTMLTag = HTML_TAGS.body.has(key) && key
-  return {
-    text: element,
-    tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || 'string'
-  }
-}
-
-export const createBasedOnType = (element, parent, key) => {
-  // if ELEMENT is not given
-  if (element === undefined) {
-    if (ENV === 'test' || ENV === 'development') {
-      console.warn(
-        key,
-        'element is undefined in',
-        parent?.__ref?.path
-      )
-    }
-    return {}
-  }
-
-  if (element === null) return
-  if (element === true) return {}
-
-  if (is(element)('string', 'number')) {
-    return returnValueAsText(element, parent, key)
-  }
-
-  if (isFunction(element)) {
-    return { props: element }
-  }
-
-  return element
-}
-
-export const addRef = (element, parent) => {
-  const ref = {}
-  ref.origin = element
-  ref.parent = parent
-  return ref
-}
-
-export const createParent = (element, parent, key, options, root) => {
-  if (!parent) return root
-  if (isNode(parent)) {
-    const parentNodeWrapper = { key: ':root', node: parent }
-    root[`${key}_parent`] = parentNodeWrapper
-    return parentNodeWrapper
-  }
-  return parent
-}
-
-export const createRoot = (element, parent) => {
-  const { __ref: ref } = element
-  const { __ref: parentRef } = parent
-
-  const hasRoot = parent && parent.key === ':root'
-  if (!ref?.root) {
-    ref.root = hasRoot ? element : parentRef?.root
-  }
-}
-
-export const createPath = (element, parent, key) => {
-  let { __ref: parentRef } = parent
-  // set the PATH array
-  if (!parentRef) parentRef = parent.ref = {}
-  if (!parentRef.path) parentRef.path = []
-  return parentRef.path.concat(key)
-}
-
-export const addContext = (element, parent, key, options, root) => {
-  const forcedOptionsContext =
-    options.context && !root.context && !element.context
-  if (forcedOptionsContext) root.context = options.context
-
-  // inherit from parent or root
-  return options.context || parent.context || root.context || element.context
-}
-
-export const addCaching = (element, parent, key) => {
-  const ref = addRef(element, parent)
-
-  element.__ref = ref
-
-  // enable CACHING
-  if (!ref.__defineCache) ref.__defineCache = {}
-
-  // enable EXEC
-  if (!ref.__exec) ref.__exec = {}
-  if (!ref.__execProps) ref.__execProps = {}
-
-  // enable CLASS CACHING
-  if (!ref.__class) ref.__class = {}
-  if (!ref.__classNames) ref.__classNames = {}
-
-  // enable CLASS CACHING
-  if (!ref.__attr) ref.__attr = {}
-
-  // enable CHANGES storing
-  if (!ref.__changes) ref.__changes = []
-
-  // enable CHANGES storing
-  if (!ref.__children) ref.__children = []
-
-  ref.__extends = createExtends(element, parent, key)
-  ref.path = createPath(element, parent, key)
-
-  return ref
-}
-
-export const createElement = (passedProps, parentEl, passedKey, opts, root) => {
-  const hashed = passedProps?.__hash
-  const element = hashed
-    ? { extends: [passedProps] }
-    : createBasedOnType(passedProps, parentEl, passedKey)
-  if (!element) return
-
-  const parent = createParent(element, parentEl, passedKey, opts, root)
-  const key = createKey(element, parent, passedKey)
-
-  addCaching(element, parent, key)
-
-  const props = createProps(element, parent, key)
-  const context = addContext(element, parent, key, opts, root)
-  const on = element.on || {}
-
-  return {
-    ...element,
-    key,
-    props,
-    parent,
-    context,
-    on
-  }
-}

package/env.js

@@ -1,15 +0,0 @@
-'use strict'
-
-// @preserve-env
-export const NODE_ENV = process.env.NODE_ENV
-export const ENV = NODE_ENV
-
-export const isProduction = (env = NODE_ENV) => env === 'production'
-export const isTest = (env = NODE_ENV) => env === 'testing' || env === 'test'
-export const isTesting = isTest
-export const isStaging = (env = NODE_ENV) => env === 'staging'
-export const isLocal = (env = NODE_ENV) => env === 'local'
-export const isDevelopment = (env = NODE_ENV) =>
-  env === 'development' || env === 'dev' || env === 'local'
-export const getNev = (key, env = NODE_ENV) => env[key]
-export const isNotProduction = (env = NODE_ENV) => !isProduction(env)

package/events.js

@@ -1,19 +0,0 @@
-'use strict'
-
-import { lowercaseFirstLetter } from './string.js'
-import { isFunction } from './types.js'
-
-export function addEventFromProps (key, obj) {
-  const { props, on } = obj
-  const eventName = lowercaseFirstLetter(key.split('on')[1])
-  const origEvent = on[eventName]
-  const funcFromProps = props[key]
-  if (isFunction(origEvent)) {
-    on[eventName] = (...args) => {
-      const originalEventRetunrs = origEvent(...args)
-      if (originalEventRetunrs !== false) {
-        if (isFunction(funcFromProps)) return funcFromProps(...args)
-      }
-    }
-  } else on[eventName] = funcFromProps
-}