@symbo.ls/smbls-utils 3.2.7

package/dist/esm/load.js

@@ -0,0 +1,151 @@
+const loadJavascriptFile = (FILE_URL, async = false, doc = document, type = "text/javascript") => {
+  return new Promise((resolve, reject) => {
+    try {
+      const scriptEle = doc.createElement("script");
+      scriptEle.type = type;
+      scriptEle.async = async;
+      scriptEle.src = FILE_URL;
+      scriptEle.addEventListener("load", (ev) => {
+        resolve({
+          status: true
+        });
+      });
+      scriptEle.addEventListener("error", (ev) => {
+        reject(
+          new Error({
+            status: false,
+            message: `Failed to load the script ${FILE_URL}`
+          })
+        );
+      });
+      doc.body.appendChild(scriptEle);
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+const loadJavascriptFileSync = (fileUrl, doc = document, type = "text/javascript") => {
+  return new Promise((resolve, reject) => {
+    const scriptEle = doc.createElement("script");
+    scriptEle.type = type;
+    scriptEle.src = fileUrl;
+    const blocker = doc.createElement("div");
+    blocker.style.cssText = "position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(255,255,255,0.8);z-index:9999;";
+    doc.body.appendChild(blocker);
+    scriptEle.onload = () => {
+      console.log(`Successfully loaded: ${fileUrl}`);
+      doc.body.removeChild(blocker);
+      resolve();
+    };
+    scriptEle.onerror = () => {
+      doc.body.removeChild(blocker);
+      reject(new Error(`Failed to load: ${fileUrl}`));
+    };
+    doc.body.appendChild(scriptEle);
+  });
+};
+const loadJavascriptFileEmbedSync = (FILE_URL, doc = document, fallback, type = "text/javascript") => {
+  const xhr = new window.XMLHttpRequest();
+  xhr.open("GET", FILE_URL, false);
+  xhr.send();
+  if (xhr.status === 200) {
+    const scriptEle = doc.createElement("script");
+    scriptEle.type = type;
+    scriptEle.text = xhr.responseText;
+    doc.body.appendChild(scriptEle);
+    if (typeof fallback === "function") fallback();
+  } else {
+    throw new Error(`Failed to load the script ${FILE_URL}`);
+  }
+};
+const loadCssFile = (FILE_URL, async = false, doc = document, type = "text/javascript") => {
+  return new Promise((resolve, reject) => {
+    try {
+      const linkElem = doc.createElement("link");
+      linkElem.rel = "stylesheet";
+      linkElem.href = FILE_URL;
+      linkElem.addEventListener("load", (ev) => {
+        resolve({
+          status: true
+        });
+      });
+      doc.head.appendChild(linkElem);
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+const loadJavascript = (body, async = false, doc = document, type = "text/javascript", id = "smbls-script") => {
+  try {
+    const scriptEle = doc.createElement("script");
+    scriptEle.type = type;
+    scriptEle.async = async;
+    scriptEle.id = id;
+    scriptEle.innerHTML = body;
+    doc.body.appendChild(scriptEle);
+  } catch (error) {
+    console.warn(error);
+  }
+};
+function loadRemoteScript(url, options = {}) {
+  const { window: window2 = globalThis } = options;
+  const { document: document2 = window2.document } = options;
+  return new Promise((resolve, reject) => {
+    const existingScript = document2.querySelector(`script[src="${url}"]`);
+    if (existingScript) {
+      return resolve(existingScript);
+    }
+    const script = document2.createElement("script");
+    script.src = url;
+    script.async = options.async === true;
+    script.type = options.type || "text/javascript";
+    if (options.id) script.id = options.id;
+    if (options.integrity) script.integrity = options.integrity;
+    if (options.crossOrigin) script.crossOrigin = options.crossOrigin;
+    script.onload = () => {
+      script.onerror = script.onload = null;
+      resolve(script);
+    };
+    script.onerror = () => {
+      script.onerror = script.onload = null;
+      reject(new Error(`Failed to load script: ${url}`));
+    };
+    document2.head.appendChild(script);
+  });
+}
+async function loadRemoteCSS(url, options = {}) {
+  const { window: window2 = globalThis } = options;
+  const { document: document2 = window2.document } = options;
+  return new Promise((resolve, reject) => {
+    const existingLink = document2.querySelector(`link[href="${url}"]`);
+    if (existingLink) {
+      return resolve(existingLink);
+    }
+    const link = document2.createElement("link");
+    link.href = url;
+    link.rel = options.rel || "stylesheet";
+    link.type = "text/css";
+    link.media = options.media || "all";
+    if (options.id) link.id = options.id;
+    if (options.integrity) link.integrity = options.integrity;
+    if (options.crossOrigin) link.crossOrigin = options.crossOrigin;
+    link.onload = () => {
+      link.onerror = link.onload = null;
+      resolve(link);
+    };
+    link.onerror = () => {
+      link.onerror = link.onload = null;
+      reject(new Error(`Failed to load stylesheet: ${url}`));
+    };
+    document2.head.appendChild(link);
+  });
+}
+export {
+  loadCssFile,
+  loadJavascript,
+  loadJavascriptFile,
+  loadJavascriptFileEmbedSync,
+  loadJavascriptFileSync,
+  loadRemoteCSS,
+  loadRemoteScript
+};

package/dist/esm/scaling.js

@@ -0,0 +1,15 @@
+import { isObject, isArray } from "@domql/utils";
+const findClosestNumber = (number, arr) => {
+  return (isArray(arr) ? arr : Object.values(arr)).reduce((prev, curr) => {
+    return Math.abs(curr - number) < Math.abs(prev - number) ? curr : prev;
+  });
+};
+const findClosestNumberInFactory = (val, factory) => {
+  val = parseFloat(val);
+  if (isObject(factory)) factory = Object.values(factory);
+  return findClosestNumber(val, factory);
+};
+export {
+  findClosestNumber,
+  findClosestNumberInFactory
+};

package/dist/esm/style.js

@@ -0,0 +1,20 @@
+const getEmotionStylesheet = () => {
+  const stylesheet = document.styleSheets[0];
+  let str = "";
+  if (stylesheet) {
+    try {
+      const cssRules = stylesheet.cssRules || stylesheet.rules;
+      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;
+};
+export {
+  getEmotionStylesheet
+};

package/dist/iife/index.js

@@ -0,0 +1,289 @@
+"use strict";
+var SmblsSmblsUtils = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.js
+  var index_exports = {};
+  __export(index_exports, {
+    arrayzeValue: () => arrayzeValue,
+    copyJavaScriptToClipboard: () => copyJavaScriptToClipboard,
+    copyStringToClipboard: () => copyStringToClipboard,
+    fibonacciNumberByIndex: () => fibonacciNumberByIndex,
+    findClosestNumber: () => findClosestNumber,
+    findClosestNumberInFactory: () => findClosestNumberInFactory,
+    formatDate: () => formatDate,
+    isPhoto: () => isPhoto,
+    loadCssFile: () => loadCssFile,
+    loadJavascript: () => loadJavascript,
+    loadJavascriptFile: () => loadJavascriptFile,
+    loadJavascriptFileEmbedSync: () => loadJavascriptFileEmbedSync,
+    loadJavascriptFileSync: () => loadJavascriptFileSync,
+    loadRemoteCSS: () => loadRemoteCSS,
+    loadRemoteScript: () => loadRemoteScript,
+    removeChars: () => removeChars,
+    toCamelCase: () => toCamelCase,
+    toDashCase: () => toDashCase,
+    toDescriptionCase: () => toDescriptionCase,
+    toTitleCase: () => toTitleCase,
+    toggleFullscreen: () => toggleFullscreen
+  });
+
+  // ../utils/dist/esm/types.js
+  var isObject = (arg) => {
+    if (arg === null) return false;
+    return typeof arg === "object" && arg.constructor === Object;
+  };
+  var isString = (arg) => typeof arg === "string";
+  var isNumber = (arg) => typeof arg === "number";
+  var isArray = (arg) => Array.isArray(arg);
+
+  // src/browser.js
+  async function toggleFullscreen(opts) {
+    if (!document.fullscreenElement) {
+      try {
+        await (this.node || document).requestFullscreen();
+      } catch (err) {
+        console.warn(`Error attempting to enable fullscreen mode: ${err.message} (${err.name})`);
+      }
+    } else {
+      await document.exitFullscreen();
+    }
+  }
+
+  // src/scaling.js
+  var findClosestNumber = (number, arr) => {
+    return (isArray(arr) ? arr : Object.values(arr)).reduce((prev, curr) => {
+      return Math.abs(curr - number) < Math.abs(prev - number) ? curr : prev;
+    });
+  };
+  var findClosestNumberInFactory = (val, factory) => {
+    val = parseFloat(val);
+    if (isObject(factory)) factory = Object.values(factory);
+    return findClosestNumber(val, factory);
+  };
+
+  // src/date.js
+  var 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}`;
+  };
+
+  // src/fibonacci.js
+  var fibonacciNumberByIndex = function fibonacciNumberByIndex2(n) {
+    const fib = [0, 1];
+    for (let i = 2; i <= n; i++) {
+      fib[i] = fib[i - 1] + fib[i - 2];
+    }
+    return fib[n];
+  };
+
+  // src/load.js
+  var loadJavascriptFile = (FILE_URL, async = false, doc = document, type = "text/javascript") => {
+    return new Promise((resolve, reject) => {
+      try {
+        const scriptEle = doc.createElement("script");
+        scriptEle.type = type;
+        scriptEle.async = async;
+        scriptEle.src = FILE_URL;
+        scriptEle.addEventListener("load", (ev) => {
+          resolve({
+            status: true
+          });
+        });
+        scriptEle.addEventListener("error", (ev) => {
+          reject(
+            new Error({
+              status: false,
+              message: `Failed to load the script ${FILE_URL}`
+            })
+          );
+        });
+        doc.body.appendChild(scriptEle);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+  var loadJavascriptFileSync = (fileUrl, doc = document, type = "text/javascript") => {
+    return new Promise((resolve, reject) => {
+      const scriptEle = doc.createElement("script");
+      scriptEle.type = type;
+      scriptEle.src = fileUrl;
+      const blocker = doc.createElement("div");
+      blocker.style.cssText = "position:fixed;top:0;left:0;right:0;bottom:0;background:rgba(255,255,255,0.8);z-index:9999;";
+      doc.body.appendChild(blocker);
+      scriptEle.onload = () => {
+        console.log(`Successfully loaded: ${fileUrl}`);
+        doc.body.removeChild(blocker);
+        resolve();
+      };
+      scriptEle.onerror = () => {
+        doc.body.removeChild(blocker);
+        reject(new Error(`Failed to load: ${fileUrl}`));
+      };
+      doc.body.appendChild(scriptEle);
+    });
+  };
+  var loadJavascriptFileEmbedSync = (FILE_URL, doc = document, fallback, type = "text/javascript") => {
+    const xhr = new window.XMLHttpRequest();
+    xhr.open("GET", FILE_URL, false);
+    xhr.send();
+    if (xhr.status === 200) {
+      const scriptEle = doc.createElement("script");
+      scriptEle.type = type;
+      scriptEle.text = xhr.responseText;
+      doc.body.appendChild(scriptEle);
+      if (typeof fallback === "function") fallback();
+    } else {
+      throw new Error(`Failed to load the script ${FILE_URL}`);
+    }
+  };
+  var loadCssFile = (FILE_URL, async = false, doc = document, type = "text/javascript") => {
+    return new Promise((resolve, reject) => {
+      try {
+        const linkElem = doc.createElement("link");
+        linkElem.rel = "stylesheet";
+        linkElem.href = FILE_URL;
+        linkElem.addEventListener("load", (ev) => {
+          resolve({
+            status: true
+          });
+        });
+        doc.head.appendChild(linkElem);
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+  var loadJavascript = (body, async = false, doc = document, type = "text/javascript", id = "smbls-script") => {
+    try {
+      const scriptEle = doc.createElement("script");
+      scriptEle.type = type;
+      scriptEle.async = async;
+      scriptEle.id = id;
+      scriptEle.innerHTML = body;
+      doc.body.appendChild(scriptEle);
+    } catch (error) {
+      console.warn(error);
+    }
+  };
+  function loadRemoteScript(url, options = {}) {
+    const { window: window2 = globalThis } = options;
+    const { document: document2 = window2.document } = options;
+    return new Promise((resolve, reject) => {
+      const existingScript = document2.querySelector(`script[src="${url}"]`);
+      if (existingScript) {
+        return resolve(existingScript);
+      }
+      const script = document2.createElement("script");
+      script.src = url;
+      script.async = options.async === true;
+      script.type = options.type || "text/javascript";
+      if (options.id) script.id = options.id;
+      if (options.integrity) script.integrity = options.integrity;
+      if (options.crossOrigin) script.crossOrigin = options.crossOrigin;
+      script.onload = () => {
+        script.onerror = script.onload = null;
+        resolve(script);
+      };
+      script.onerror = () => {
+        script.onerror = script.onload = null;
+        reject(new Error(`Failed to load script: ${url}`));
+      };
+      document2.head.appendChild(script);
+    });
+  }
+  async function loadRemoteCSS(url, options = {}) {
+    const { window: window2 = globalThis } = options;
+    const { document: document2 = window2.document } = options;
+    return new Promise((resolve, reject) => {
+      const existingLink = document2.querySelector(`link[href="${url}"]`);
+      if (existingLink) {
+        return resolve(existingLink);
+      }
+      const link = document2.createElement("link");
+      link.href = url;
+      link.rel = options.rel || "stylesheet";
+      link.type = "text/css";
+      link.media = options.media || "all";
+      if (options.id) link.id = options.id;
+      if (options.integrity) link.integrity = options.integrity;
+      if (options.crossOrigin) link.crossOrigin = options.crossOrigin;
+      link.onload = () => {
+        link.onerror = link.onload = null;
+        resolve(link);
+      };
+      link.onerror = () => {
+        link.onerror = link.onload = null;
+        reject(new Error(`Failed to load stylesheet: ${url}`));
+      };
+      document2.head.appendChild(link);
+    });
+  }
+
+  // src/files.js
+  var isPhoto = (format) => ["jpeg", "gif", "jpg", "png", "tiff", "woff"].includes(format);
+
+  // src/index.js
+  var copyStringToClipboard = async (str) => {
+    try {
+      await navigator.clipboard.writeText(str);
+    } catch (err) {
+      console.warn("Failed to copy text: ", err);
+    }
+  };
+  var copyJavaScriptToClipboard = async (jsCode) => {
+    try {
+      const blob = new Blob([jsCode], { type: "text/javascript" });
+      const clipboardItem = new window.ClipboardItem({ "text/plain": blob });
+      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);
+    }
+  };
+  var removeChars = (str) => {
+    return str.replace(/[^a-zA-Z0-9_]/g, "");
+  };
+  var toCamelCase = (str) => {
+    return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
+      return index === 0 ? word.toLowerCase() : word.toUpperCase();
+    }).replaceAll(/\s+/g, "");
+  };
+  var toTitleCase = (str) => str && str.replace(/\w\S*/g, (txt) => {
+    return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+  });
+  var toDashCase = (val) => val.replace(/[^a-zA-Z0-9]/g, " ").trim().toLowerCase().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+  var toDescriptionCase = (str = "") => {
+    if (typeof str !== "string") return;
+    const result = str.replace(/([A-Z])/g, " $1");
+    return result.charAt(0).toUpperCase() + result.slice(1);
+  };
+  var 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];
+  };
+  return __toCommonJS(index_exports);
+})();

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@symbo.ls/smbls-utils",
+  "version": "3.2.7",
+  "author": "symbo.ls",
+  "files": [
+    "dist",
+    "*.js",
+    "src"
+  ],
+  "main": "./dist/cjs/index.js",
+  "type": "module",
+  "module": "./dist/esm/index.js",
+  "unpkg": "./dist/iife/index.js",
+  "jsdelivr": "./dist/iife/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "browser": "./dist/iife/index.js",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "source": "src/index.js",
+  "publishConfig": {},
+  "scripts": {
+    "copy:package:cjs": "cp ../../build/package-cjs.json dist/cjs/package.json",
+    "build:esm": "cross-env NODE_ENV=$NODE_ENV esbuild src/*.js --target=es2020 --format=esm --outdir=dist/esm --define:process.env.NODE_ENV=process.env.NODE_ENV",
+    "build:cjs": "cross-env NODE_ENV=$NODE_ENV esbuild src/*.js --target=node18 --format=cjs --outdir=dist/cjs --define:process.env.NODE_ENV=process.env.NODE_ENV",
+    "build:iife": "cross-env NODE_ENV=$NODE_ENV esbuild src/index.js --bundle --target=es2020 --format=iife --global-name=SmblsSmblsUtils --outfile=dist/iife/index.js --define:process.env.NODE_ENV=process.env.NODE_ENV",
+    "build": "node ../../build/build.js",
+    "prepublish": "npm run build && npm run copy:package:cjs"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "@domql/element": "^3.2.3",
+    "@domql/utils": "^3.2.3"
+  },
+  "gitHead": "9fc1b79b41cdc725ca6b24aec64920a599634681",
+  "browser": "./dist/iife/index.js",
+  "sideEffects": false
+}

package/src/browser.js

@@ -0,0 +1,13 @@
+'use strict'
+
+export async function toggleFullscreen (opts) {
+  if (!document.fullscreenElement) {
+    try {
+      await (this.node || document).requestFullscreen()
+    } catch (err) {
+      console.warn(`Error attempting to enable fullscreen mode: ${err.message} (${err.name})`)
+    }
+  } else {
+    await document.exitFullscreen()
+  }
+}

package/src/date.js

@@ -0,0 +1,10 @@
+'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/src/detectHeight.js

@@ -0,0 +1,42 @@
+'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.setProps(
+        {
+          height: state.clientHeight
+        },
+        { preventBeforeUpdateListener: true, preventChildrenUpdate: true }
+      )
+      const setAutoTimeout = setTimeout(() => {
+        element.setProps(
+          {
+            height: 'auto'
+          },
+          { preventBeforeUpdateListener: true, preventChildrenUpdate: true }
+        )
+        clearTimeout(setAutoTimeout)
+      }, 450)
+    } else {
+      element.setProps(
+        {
+          height: '0'
+        },
+        { preventBeforeUpdateListener: true, preventChildrenUpdate: true }
+      )
+    }
+    clearTimeout(heightTimeout)
+  })
+}

package/src/fibonacci.js

@@ -0,0 +1,9 @@
+'use strict'
+
+export const fibonacciNumberByIndex = function fibonacciNumberByIndex (n) {
+  const fib = [0, 1]
+  for (let i = 2; i <= n; i++) {
+    fib[i] = fib[i - 1] + fib[i - 2]
+  }
+  return fib[n]
+}

package/src/files.js

@@ -0,0 +1,3 @@
+'use strict'
+
+export const isPhoto = format => ['jpeg', 'gif', 'jpg', 'png', 'tiff', 'woff'].includes(format)

package/src/index.js

@@ -0,0 +1,75 @@
+'use strict'
+
+import { isString, isObject, isArray, isNumber } from '@domql/utils'
+
+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) => {
+  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) => {
+  return str
+    .replace(/(?:^\w|[A-Z]|\b\w)/g, function (word, index) {
+      return index === 0 ? word.toLowerCase() : word.toUpperCase()
+    })
+    .replaceAll(/\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]
+}