@symbo.ls/utils 3.14.2 → 3.14.4

package/state.js

@@ -1,203 +0,0 @@
-'use strict'
-
-import { addProtoToArray } from './array.js'
-import { STATE_METHODS } from './keys.js'
-import {
-  deepClone,
-  deepMerge,
-  overwriteDeep,
-  overwriteShallow
-} from './object.js'
-import {
-  is,
-  isObject,
-  isObjectLike,
-  isString
-} from './types.js'
-
-export const checkForStateTypes = element => {
-  const { state: orig, props, __ref: ref } = element
-  const state = props?.state || orig
-  if (is(state)('string', 'number')) {
-    ref.__state = state
-    return { value: state }
-  } else if (state === true) {
-    ref.__state = element.key
-    return {}
-  } else if (state) {
-    ref.__hasRootState = true
-    return state
-  } else {
-    return false
-  }
-}
-
-export const getRootStateInKey = (stateKey, parentState) => {
-  if (!stateKey.includes('~/')) return
-  const arr = stateKey.split('~/')
-  if (arr.length > 1) return parentState.root
-}
-
-export const getParentStateInKey = (stateKey, parentState) => {
-  if (!stateKey.includes('../')) return
-  const arr = stateKey.split('../')
-  const arrLength = arr.length - 1
-  for (let i = 0; i < arrLength; i++) {
-    if (!parentState.parent) return null
-    parentState = parentState.parent
-  }
-  return parentState
-}
-
-export const getChildStateInKey = (stateKey, parentState, options = {}) => {
-  const arr = isString(stateKey) ? stateKey.split('/') : [stateKey]
-  const arrLength = arr.length - 1
-  for (let i = 0; i < arrLength; i++) {
-    const childKey = arr[i]
-    const grandChildKey = arr[i + 1]
-
-    if (childKey === '__proto__' || grandChildKey === '__proto__') return
-
-    let childInParent = parentState[childKey]
-    if (!childInParent) childInParent = parentState[childKey] = {} // check for array
-    if (!childInParent[grandChildKey]) childInParent[grandChildKey] = {} // check for array
-
-    stateKey = grandChildKey
-    parentState = childInParent
-  }
-  if (options.returnParent) return parentState
-  return parentState[stateKey]
-}
-
-export const findInheritedState = (element, parent, options = {}) => {
-  const ref = element.__ref
-  let stateKey = ref.__state
-  if (!checkIfInherits(element)) return
-
-  const rootState = getRootStateInKey(stateKey, parent.state)
-  let parentState = parent.state
-
-  if (rootState) {
-    parentState = rootState
-    stateKey = stateKey.replaceAll('~/', '')
-  } else {
-    const findGrandParentState = getParentStateInKey(stateKey, parent.state)
-    if (findGrandParentState) {
-      parentState = findGrandParentState
-      stateKey = stateKey.replaceAll('../', '')
-    }
-  }
-
-  if (!parentState) return
-  return getChildStateInKey(stateKey, parentState, options)
-}
-
-export const createInheritedState = (element, parent) => {
-  const ref = element.__ref
-  const inheritedState = findInheritedState(element, parent)
-  if (inheritedState === undefined) return element.state
-
-  if (is(inheritedState)('object', 'array')) {
-    return deepClone(inheritedState)
-  } else if (is(inheritedState)('string', 'number', 'boolean')) {
-    ref.__stateType = typeof inheritedState
-    return { value: inheritedState }
-  }
-
-  console.warn(ref.__state, 'is not present. Replacing with', {})
-}
-
-export const checkIfInherits = element => {
-  const { __ref: ref } = element
-  const stateKey = ref?.__state
-  if (stateKey && is(stateKey)('number', 'string', 'boolean')) return true
-  return false
-}
-
-export const isState = function (state) {
-  if (!isObjectLike(state)) return false
-  return Boolean(
-    state.update &&
-      state.parse &&
-      state.clean &&
-      state.create &&
-      state.parent &&
-      state.destroy &&
-      state.rootUpdate &&
-      state.parentUpdate &&
-      state.keys &&
-      state.values &&
-      state.toggle &&
-      state.replace &&
-      state.quietUpdate &&
-      state.quietReplace &&
-      state.add &&
-      state.apply &&
-      state.applyReplace &&
-      state.setByPath &&
-      state.setPathCollection &&
-      state.removeByPath &&
-      state.removePathCollection &&
-      state.getByPath &&
-      state.applyFunction &&
-      state.__element &&
-      state.__children
-  )
-}
-
-export const createNestedObjectByKeyPath = (path, value) => {
-  if (!path) {
-    return value || {}
-  }
-  const keys = path.split('/')
-  const obj = {}
-  let ref = obj
-  const lastIdx = keys.length - 1
-  for (let i = 0; i <= lastIdx; i++) {
-    ref[keys[i]] = i === lastIdx ? value || {} : {}
-    ref = ref[keys[i]]
-  }
-  return obj
-}
-
-export const applyDependentState = (element, state) => {
-  const { __element } = state
-  const origState = __element?.state
-  if (!origState) return
-  const dependentState = deepClone(origState, STATE_METHODS)
-  const newDepends = { [element.key]: dependentState }
-
-  const __depends = isObject(origState.__depends)
-    ? { ...origState.__depends, ...newDepends }
-    : newDepends
-
-  if (Array.isArray(origState)) {
-    addProtoToArray(origState, {
-      ...Object.getPrototypeOf(origState),
-      __depends
-    })
-  } else {
-    Object.setPrototypeOf(origState, {
-      ...Object.getPrototypeOf(origState),
-      __depends
-    })
-  }
-
-  return dependentState
-}
-
-export const overwriteState = (state, obj, options = {}) => {
-  const { overwrite } = options
-  if (!overwrite) return
-
-  const shallow = overwrite === 'shallow'
-  const merge = overwrite === 'merge'
-
-  if (merge) {
-    deepMerge(state, obj, STATE_METHODS)
-    return
-  }
-
-  const overwriteFunc = shallow ? overwriteShallow : overwriteDeep
-  overwriteFunc(state, obj, STATE_METHODS)
-}

package/string-extra.js

@@ -1,69 +0,0 @@
-'use strict'
-
-import { isString, isObject, isArray, isNumber } from './types.js'
-
-export const copyStringToClipboard = async (str) => {
-  try {
-    await navigator.clipboard.writeText(str)
-  } catch (err) {
-    console.warn('Failed to copy text: ', err)
-  }
-}
-
-export const copyJavaScriptToClipboard = async (jsCode) => {
-  try {
-    // Create a Blob for the JavaScript code with the 'text/javascript' MIME type
-    const blob = new Blob([jsCode], { type: 'text/javascript' })
-
-    // Create a ClipboardItem with the 'text/javascript' Blob
-    const clipboardItem = new window.ClipboardItem({ 'text/plain': blob })
-
-    // Copy the ClipboardItem to the clipboard
-    await navigator.clipboard.write([clipboardItem])
-
-    console.log('JavaScript code copied to clipboard as text/javascript')
-  } catch (err) {
-    console.error('Failed to copy JavaScript code: ', err)
-  }
-}
-
-export const removeChars = (str) => {
-  return str.replace(/[^a-zA-Z0-9_]/g, '')
-}
-
-export const toCamelCase = (str) => {
-  if (typeof str !== 'string') str = String(str || '')
-  return str
-    .replace(/(?:^\w|[A-Z]|\b\w)/g, function (word, index) {
-      return index === 0 ? word.toLowerCase() : word.toUpperCase()
-    })
-    .replace(/\s+/g, '')
-}
-
-export const toTitleCase = (str) =>
-  str &&
-  str.replace(/\w\S*/g, (txt) => {
-    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()
-  })
-
-export const toDashCase = (val) =>
-  val
-    .replace(/[^a-zA-Z0-9]/g, ' ') // Replace non-alphanumeric characters with spaces
-    .trim() // Remove leading and trailing spaces
-    .toLowerCase() // Convert to lowercase
-    .replace(/\s+/g, '-') // Replace spaces with dashes
-    .replace(/-+/g, '-') // Replace consecutive dashes with a single dash
-    .replace(/^-|-$/g, '') // Remove leading and trailing dashes
-
-export const toDescriptionCase = (str = '') => {
-  if (typeof str !== 'string') return
-  const result = str.replace(/([A-Z])/g, ' $1')
-  return result.charAt(0).toUpperCase() + result.slice(1)
-}
-
-export const arrayzeValue = (val) => {
-  if (isArray(val)) return val
-  if (isString(val)) return val.split(' ')
-  if (isObject(val)) return Object.values(val)
-  if (isNumber(val)) return [val]
-}

package/string.js

@@ -1,206 +0,0 @@
-'use strict'
-
-export const stringIncludesAny = (str, characters) => {
-  for (const char of characters) {
-    if (str.includes(char)) {
-      return true
-    }
-  }
-  return false
-}
-
-export const trimStringFromSymbols = (str, characters) => {
-  // Create a regular expression pattern to match the specified symbols
-  const pattern = new RegExp(`[${characters.join('\\')}]`, 'g')
-
-  // Replace matched symbols with an empty string
-  return str.replace(pattern, '')
-}
-
-/**
- * Replaces placeholders in a string with corresponding {{ }} values from an object.
- *
- * @param {string} str - The string containing placeholders to replace.
- * @param {object} state - The object containing the values to substitute.
- * @returns {string} The modified string with placeholders replaced by values from the object.
- */
-const brackRegex = {
-  2: /{{\s*((?:\.\.\/)*)([\w\d.]+)\s*(?:\|\s*([\w\d.]+))?\s*}}/g,
-  3: /{{{(\s*(?:\.\.\/)*)([\w\d.]+)\s*(?:\|\s*([\w\d.]+))?\s*}}}/g
-}
-
-const getNestedValue = (obj, path) => {
-  return path.split('.').reduce((acc, part) => {
-    return acc?.[part]
-  }, obj)
-}
-
-export function replaceLiteralsWithObjectFields (str, state, options = {}) {
-  const { bracketsLength = 2 } = options
-  const bracketPattern = bracketsLength === 3 ? '{{{' : '{{'
-  if (!str.includes(bracketPattern)) return str
-
-  const reg = brackRegex[bracketsLength]
-  const obj = state || this.state || {}
-
-  const element = this
-
-  return str.replace(reg, (_, parentPath, variable, filter) => {
-    const key = variable.trim()
-
-    // Pipe filter: {{ key | filterName }}
-    // Always passes the raw key to the filter — the filter is responsible for resolution
-    if (filter) {
-      const ctx = element?.context
-      const filterFn = ctx?.functions?.[filter] || ctx?.utils?.[filter] || ctx?.methods?.[filter] || ctx?.snippets?.[filter] || element?.[filter]
-      if (filterFn && typeof filterFn === 'function') {
-        try {
-          return String(filterFn.call(element, key) ?? '')
-        } catch (e) { return '' }
-      }
-      return ''
-    }
-
-    if (parentPath) {
-      const parentLevels = (parentPath.match(/\.\.\//g) || []).length
-      let parentState = obj
-
-      for (let i = 0; i < parentLevels; i++) {
-        if (!parentState || !parentState.parent) return ''
-        parentState = parentState.parent
-      }
-
-      // If the variable is 'parent', return the value property
-      if (key === 'parent') {
-        return String(parentState.value ?? '')
-      }
-
-      const value = getNestedValue(parentState, key)
-      return String(value ?? '')
-    } else {
-      // Check state value first
-      const value = getNestedValue(obj, key)
-      if (value != null) return String(value)
-
-      // Fall back to polyglot translations for current language
-      const poly = element?.context?.polyglot
-      if (poly?.translations) {
-        const lang = obj?.root?.lang || obj?.lang || element?.context?.state?.lang || poly.defaultLang || 'en'
-        const langT = poly.translations[lang]
-        if (langT) {
-          const tValue = getNestedValue(langT, key)
-          if (tValue != null && typeof tValue !== 'object') return String(tValue)
-          // Search nested sections (e.g. ka.nav.about for key 'about')
-          for (const section in langT) {
-            const sectionData = langT[section]
-            if (sectionData && typeof sectionData === 'object' && !Array.isArray(sectionData)) {
-              const nested = getNestedValue(sectionData, key)
-              if (nested != null && typeof nested !== 'object') return String(nested)
-            }
-          }
-        }
-        // Check top-level translations
-        const topValue = getNestedValue(poly.translations, key)
-        if (topValue != null && typeof topValue !== 'object') return String(topValue)
-      }
-      return ''
-    }
-  })
-}
-
-export const lowercaseFirstLetter = inputString => {
-  return `${inputString.charAt(0).toLowerCase()}${inputString.slice(1)}`
-}
-
-export const findKeyPosition = (str, key) => {
-  const lines = str.split('\n')
-  let startLineNumber = -1
-  let endLineNumber = -1
-  let startColumn = -1
-  let endColumn = -1
-
-  const keyPattern = new RegExp(`\\b${key}\\b\\s*:\\s*`)
-  let braceCount = 0
-  let foundKey = false
-
-  for (let i = 0; i < lines.length; i++) {
-    if (keyPattern.test(lines[i]) && !foundKey) {
-      foundKey = true
-      startLineNumber = i + 1
-      startColumn = lines[i].indexOf(key) + 1
-
-      // Check if the value is an empty object
-      if (lines[i].includes('{}')) {
-        endLineNumber = startLineNumber
-        endColumn = lines[i].indexOf('{}') + 3
-        break
-      }
-
-      // Check if the value starts with '{' (object) or '[' (array)
-      const line = lines[i].slice(startColumn + key.length)
-      if (line.includes('{') || line.includes('[')) {
-        braceCount = 1
-      } else {
-        endLineNumber = i + 1
-        endColumn = lines[i].length + 1
-        break
-      }
-    } else if (foundKey) {
-      braceCount += (lines[i].match(/{/g) || []).length
-      braceCount += (lines[i].match(/\[/g) || []).length
-      braceCount -= (lines[i].match(/}/g) || []).length
-      braceCount -= (lines[i].match(/]/g) || []).length
-
-      // If braceCount is 0 and we find the end of the object/array
-      if (braceCount === 0) {
-        endLineNumber = i + 1
-        endColumn =
-          lines[i].lastIndexOf('}') !== -1
-            ? lines[i].lastIndexOf('}') + 2
-            : lines[i].length + 1
-        break
-      }
-    }
-  }
-
-  return {
-    startColumn,
-    endColumn,
-    startLineNumber,
-    endLineNumber
-  }
-}
-
-const RE_OCTAL = /\\([0-7]{1,3})/g
-
-export const replaceOctalEscapeSequences = str => {
-  return str.replace(RE_OCTAL, (_, p1) => String.fromCharCode(parseInt(p1, 8)))
-}
-
-export const encodeNewlines = str => {
-  return str
-    .replace(/\n/g, '/////n')
-    .replace(/`/g, '/////tilde')
-    .replace(/\$/g, '/////dlrsgn')
-}
-
-export const decodeNewlines = encodedStr => {
-  return encodedStr
-    .replace(/\/\/\/\/\/n/g, '\n')
-    .replace(/\/\/\/\/\/tilde/g, '`')
-    .replace(/\/\/\/\/\/dlrsgn/g, '$')
-}
-
-const RE_NON_ALNUM = /[^a-zA-Z0-9\s]/g
-
-export const customEncodeURIComponent = str => {
-  return str.replace(RE_NON_ALNUM, char =>
-    '%' + char.charCodeAt(0).toString(16).toUpperCase()
-  )
-}
-
-export const customDecodeURIComponent = encodedStr => {
-  return encodedStr.replace(/%[0-9A-Fa-f]{2}/g, match =>
-    String.fromCharCode(parseInt(match.slice(1), 16))
-  )
-}

package/style.js

@@ -1,23 +0,0 @@
-'use strict'
-
-export const getEmotionStylesheet = () => {
-  // Access the first stylesheet
-  const stylesheet = document.styleSheets[0]
-  let str = ''
-  if (stylesheet) {
-    try {
-      // Access the CSS rules
-      const cssRules = stylesheet.cssRules || stylesheet.rules // For older browsers, use `rules`
-
-      // Iterate over the rules and log them
-      for (let i = 0; i < cssRules.length; i++) {
-        str += cssRules[i].cssText
-      }
-    } catch (error) {
-      console.error('Unable to access CSS rules. This may be due to CORS restrictions:', error)
-    }
-  } else {
-    console.log('No stylesheets found in document.styleSheets[0].')
-  }
-  return str
-}

package/tags.js

@@ -1,176 +0,0 @@
-'use strict'
-
-export const HTML_TAGS = {
-  root: ['body', 'html'],
-
-  head: ['title', 'base', 'meta', 'style', 'noscript', 'script'],
-
-  body: new Set([
-    'string',
-    'style',
-    'fragment',
-    'a',
-    'abbr',
-    'acronym',
-    'address',
-    'applet',
-    'area',
-    'article',
-    'aside',
-    'audio',
-    'b',
-    'basefont',
-    'bdi',
-    'bdo',
-    'big',
-    'blockquote',
-    'br',
-    'button',
-    'canvas',
-    'caption',
-    'center',
-    'cite',
-    'code',
-    'search',
-    'col',
-    'colgroup',
-    'data',
-    'datalist',
-    'dd',
-    'del',
-    'details',
-    'dfn',
-    'dialog',
-    'dir',
-    'div',
-    'dl',
-    'dt',
-    'em',
-    'embed',
-    'fieldset',
-    'figcaption',
-    'figure',
-    'font',
-    'footer',
-    'form',
-    'frame',
-    'frameset',
-    'h1',
-    'h2',
-    'h3',
-    'h4',
-    'h5',
-    'h6',
-    'head',
-    'header',
-    'hr',
-    'i',
-    'iframe',
-    'img',
-    'input',
-    'ins',
-    'kbd',
-    'label',
-    'legend',
-    'li',
-    'link',
-    'main',
-    'map',
-    'mark',
-    'meter',
-    'nav',
-    'noframes',
-    'noscript',
-    'object',
-    'ol',
-    'optgroup',
-    'option',
-    'output',
-    'p',
-    'param',
-    'picture',
-    'pre',
-    'progress',
-    'hgroup',
-    'q',
-    'rp',
-    'rt',
-    'ruby',
-    's',
-    'samp',
-    'script',
-    'section',
-    'select',
-    'small',
-    'source',
-    'span',
-    'strike',
-    'strong',
-    'sub',
-    'summary',
-    'sup',
-    'table',
-    'tbody',
-    'td',
-    'template',
-    'hgroup',
-    'textarea',
-    'tfoot',
-    'th',
-    'thead',
-    'time',
-    'tr',
-    'track',
-    'tt',
-    'u',
-    'ul',
-    'var',
-    'video',
-    'wbr',
-
-    // SVG
-    'svg',
-    'path',
-    'circle',
-    'ellipse',
-    'line',
-    'polygon',
-    'polyline',
-    'rect',
-    'g',
-    'defs',
-    'symbol',
-    'use',
-    'text',
-    'tspan',
-    'image',
-    'clipPath',
-    'mask',
-    'pattern',
-    'marker',
-    'linearGradient',
-    'radialGradient',
-    'stop',
-    'filter',
-    'feGaussianBlur',
-    'feOffset',
-    'feMerge',
-    'feMergeNode',
-    'feBlend',
-    'feColorMatrix',
-    'feFlood',
-    'feComposite',
-    'foreignObject'
-  ])
-}
-
-export const SVG_TAGS = new Set([
-  'svg', 'path', 'circle', 'ellipse', 'line', 'polygon', 'polyline',
-  'rect', 'g', 'defs', 'symbol', 'use', 'text', 'tspan', 'image',
-  'clipPath', 'mask', 'pattern', 'marker', 'linearGradient',
-  'radialGradient', 'stop', 'filter', 'feGaussianBlur', 'feOffset',
-  'feMerge', 'feMergeNode', 'feBlend', 'feColorMatrix', 'feFlood',
-  'feComposite', 'foreignObject'
-])
-
-export const isValidHtmlTag = arg => HTML_TAGS.body.has(arg)