@symbo.ls/utils 3.2.3 → 3.14.0

package/state.js

@@ -0,0 +1,203 @@
+'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/{src/index.js → string-extra.js}

@@ -1,15 +1,8 @@
 'use strict'
 
-import { isString, isObject, isArray, isNumber } from '@domql/utils'
+import { isString, isObject, isArray, isNumber } from './types.js'
 
-export * from './browser.js'
-export * from './scaling.js'
-export * from './date.js'
-export * from './fibonacci.js'
-export * from './load.js'
-export * from './files.js'
-
-export const copyStringToClipboard = async str => {
+export const copyStringToClipboard = async (str) => {
   try {
     await navigator.clipboard.writeText(str)
   } catch (err) {
@@ -17,7 +10,7 @@ export const copyStringToClipboard = async str => {
   }
 }
 
-export const copyJavaScriptToClipboard = async jsCode => {
+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' })
@@ -34,25 +27,26 @@ export const copyJavaScriptToClipboard = async jsCode => {
   }
 }
 
-export const removeChars = str => {
+export const removeChars = (str) => {
   return str.replace(/[^a-zA-Z0-9_]/g, '')
 }
 
-export const toCamelCase = str => {
+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()
     })
-    .replaceAll(/\s+/g, '')
+    .replace(/\s+/g, '')
 }
 
-export const toTitleCase = str =>
+export const toTitleCase = (str) =>
   str &&
-  str.replace(/\w\S*/g, txt => {
+  str.replace(/\w\S*/g, (txt) => {
     return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase()
   })
 
-export const toDashCase = val =>
+export const toDashCase = (val) =>
   val
     .replace(/[^a-zA-Z0-9]/g, ' ') // Replace non-alphanumeric characters with spaces
     .trim() // Remove leading and trailing spaces
@@ -67,7 +61,7 @@ export const toDescriptionCase = (str = '') => {
   return result.charAt(0).toUpperCase() + result.slice(1)
 }
 
-export const arrayzeValue = val => {
+export const arrayzeValue = (val) => {
   if (isArray(val)) return val
   if (isString(val)) return val.split(' ')
   if (isObject(val)) return Object.values(val)

package/string.js

@@ -0,0 +1,206 @@
+'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/tags.js

@@ -0,0 +1,176 @@
+'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)