@dvcol/common-utils/dist/chunk-F2ODECNN.js

Typescript library for common utility functions and constants

import {
  ParsingRelativePathError
} from "./chunk-27IUEUTL.js";

// lib/common/utils/string.utils.ts
import { v4 } from "uuid";
var parseJSON = (json) => typeof json == "string" && json?.length ? JSON.parse(json) : json;
var buildFormData = (params) => Object.keys(params).reduce((_form, key) => {
  let value = params[key];
  if (Array.isArray(value)) value = value?.join(",");
  _form.append(key, value);
  return _form;
}, new FormData());
var stringifyParams = (params) => Object.entries(params).map(([k, v]) => `${k}=${Array.isArray(v) ? v?.map(encodeURIComponent).join(",") : encodeURIComponent(v)}`).join("&");
var stringifyKeys = (record, stringify = false) => Object.entries(record).reduce((acc, [key, value]) => {
  if (value === void 0) return acc;
  if (value === null) return acc;
  acc[key] = stringify ? JSON.stringify(value) : value?.toString();
  return acc;
}, {});
var versionCompare = (version, current) => {
  for (let i = 0; i < version?.length; i += 1) {
    if (version[i] && !current[i]) return 1;
    if (version[i] < current[i]) return -1;
    if (version[i] > current[i]) return 1;
  }
  return version?.length >= current?.length ? 0 : -1;
};
var versionCheck = (version, compared) => {
  const _compared = compared?.split(".")?.map(Number);
  const _version = version?.split(".")?.map(Number);
  return versionCompare(_version, _compared);
};
var regex = /(^\w|[.:]\s\w)/g;
var sentenceCase = (input) => input?.toLowerCase().replace(regex, (letter) => {
  return letter.toUpperCase();
});
var capitalizeEachWord = (input) => input?.toLowerCase().replace(/\b\w/g, (match) => match.toUpperCase());
var deCapitalise = (input) => {
  if (!input?.trim()) return input;
  if (input !== input.toUpperCase()) return input;
  return capitalizeEachWord(input);
};
var getUUID = v4;
var toPathSegment = (str, trailing = false) => {
  let _str = str?.trim();
  if (!_str?.length) return "";
  if (!_str.startsWith("/")) _str = `/${_str}`;
  if (trailing && !_str.endsWith("/")) _str = `${_str}/`;
  if (!trailing && _str.endsWith("/")) _str = _str.slice(0, -1);
  return _str;
};
var computeAbsolutePath = (parent, relative) => {
  const relativeSegments = relative.split("/").filter(Boolean);
  const parentSegments = parent.split("/").filter(Boolean);
  relativeSegments.forEach((segment) => {
    if (segment === ".." && parentSegments.length < 1) throw new ParsingRelativePathError({ parent, relative });
    else if (segment === "..") parentSegments.pop();
    else if (segment !== ".") parentSegments.push(segment);
  });
  return `/${parentSegments.join("/")}`;
};
var toCase = (str, pattern, separator) => str.trim().replace(pattern, separator).replace(new RegExp(`^${separator}`), "").toLowerCase();
var toSnakeCase = (str) => str.trim().replace(/([A-Z])/g, "_$1").replace(/^_/, "").toLowerCase();
var toKebabCase = (str) => str.trim().replace(/([A-Z])/g, "-$1").replace(/^-/, "").toLowerCase();
function tokenizeString(str, pattern) {
  const result = [];
  let lastIndex = 0;
  str.replace(pattern, (match, group, offset) => {
    if (!group) return "";
    result.push({ mark: group, token: str.slice(lastIndex, offset) });
    lastIndex = offset + group.length;
    return "";
  });
  result.push({ mark: false, token: str.slice(lastIndex) });
  return result;
}
var markTokenizer = (str = "", pattern, { flags = "gi", html = false } = {}) => {
  if (!pattern?.trim()) return [{ mark: false, token: str }];
  const _regex = new RegExp(`(${pattern.trim()})`, flags);
  if (!html) return tokenizeString(str, _regex);
  const result = [];
  const parts = str.split(/(<[^>]+>)/g);
  parts.forEach((part) => {
    if (part.startsWith("<") && part.endsWith(">")) {
      result.push({ mark: false, token: part });
    } else {
      result.push(...tokenizeString(part, _regex));
    }
  });
  return result;
};

export {
  parseJSON,
  buildFormData,
  stringifyParams,
  stringifyKeys,
  versionCheck,
  sentenceCase,
  capitalizeEachWord,
  deCapitalise,
  getUUID,
  toPathSegment,
  computeAbsolutePath,
  toCase,
  toSnakeCase,
  toKebabCase,
  markTokenizer
};