@splendidlabz/utils 1.11.3 → 1.11.4

package/dist/esm/lib/numbers/math.js

@@ -0,0 +1,10 @@
+function toDegrees(angle) {
+  return angle * (180 / Math.PI);
+}
+function toRadians(angle) {
+  return angle * (Math.PI / 180);
+}
+export {
+  toDegrees,
+  toRadians
+};

package/dist/esm/lib/objects/camelcase-keys.js

@@ -0,0 +1,16 @@
+import { objectForEach } from "./loop.js";
+import { toCamel } from "../strings/convert-case/convert-case.js";
+function camelCaseKeys(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  const result = {};
+  objectForEach(obj, ({ key, value }) => {
+    const camelCaseKey = toCamel(key);
+    result[camelCaseKey] = camelCaseKeys(value);
+  });
+  return result;
+}
+export {
+  camelCaseKeys
+};

package/dist/esm/lib/objects/empty.js

@@ -0,0 +1,13 @@
+function isEmpty(obj) {
+  if (typeof obj === "undefined") return true;
+  if (obj === null) return true;
+  if (Array.isArray(obj)) return obj.length === 0;
+  return Object.keys(obj).length === 0;
+}
+function notEmpty(obj) {
+  return !isEmpty(obj);
+}
+export {
+  isEmpty,
+  notEmpty
+};

package/dist/esm/lib/objects/equal.js

@@ -0,0 +1,11 @@
+import deepEqual from "deep-eql";
+function isEqual(a, b) {
+  return deepEqual(a, b);
+}
+function notEqual(a, b) {
+  return !isEqual(a, b);
+}
+export {
+  isEqual,
+  notEqual
+};

package/dist/esm/lib/objects/extend.js

@@ -0,0 +1,13 @@
+import { objectForEach, objectMap } from "./loop.js";
+import { curry } from "../functions/functional.js";
+import { mix } from "./mix/mix.js";
+function extendObject(object) {
+  const orig = object;
+  const extended = mix({}, object);
+  extended.forEach = curry(objectForEach)(orig);
+  extended.map = curry(objectMap)(orig);
+  return { orig, extended };
+}
+export {
+  extendObject
+};

package/dist/esm/lib/objects/flatten.js

@@ -0,0 +1,17 @@
+import { isObject } from "../checks.js";
+function flattenObject(obj, { separator, prefix = "" }) {
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    const newKey = prefix ? `${prefix}${separator}${key}` : key;
+    const isAnObject = isObject(value);
+    const hasNestedObject = isAnObject && Object.values(value).some(isObject);
+    if (hasNestedObject) {
+      Object.assign(acc, flattenObject(value, { separator, prefix: newKey }));
+    } else {
+      acc[newKey] = value;
+    }
+    return acc;
+  }, {});
+}
+export {
+  flattenObject
+};

package/dist/esm/lib/objects/index.js

@@ -0,0 +1,13 @@
+export * from "./camelcase-keys.js";
+export * from "./empty.js";
+export * from "./equal.js";
+export * from "./extend.js";
+export * from "./flatten.js";
+export * from "./json.js";
+export * from "./loop.js";
+export * from "./mix/mix.js";
+export * from "./nested-property.js";
+export * from "./normalize-object.js";
+export * from "./omit-empty.js";
+export * from "./size.js";
+export * from "./split.js";

package/dist/esm/lib/objects/json.js

@@ -0,0 +1,10 @@
+function parseJSON(value, defaultValue = {}) {
+  try {
+    return JSON.parse(value);
+  } catch (e) {
+    return defaultValue;
+  }
+}
+export {
+  parseJSON
+};

package/dist/esm/lib/objects/loop.js

@@ -0,0 +1,14 @@
+function objectForEach(object, callback) {
+  Object.entries(object).forEach(([key, value]) => {
+    callback({ key, value });
+  });
+}
+function objectMap(object, callback) {
+  return Object.entries(object).map(([key, value]) => {
+    return callback({ key, value });
+  });
+}
+export {
+  objectForEach,
+  objectMap
+};

package/dist/esm/lib/objects/mix/mix.js

@@ -0,0 +1,88 @@
+const DEFAULT_OPTIONS = { array: "replace" };
+const mix = createMix();
+const concatMix = createMix({ array: "concat" });
+function createMix(userOptions = {}) {
+  const options = { ...DEFAULT_OPTIONS, ...userOptions };
+  function _mix(...sources) {
+    const result = {};
+    for (const source of sources) {
+      if (source == null) continue;
+      merge(result, source, options);
+    }
+    return result;
+  }
+  return _mix;
+}
+function merge(output, input, options) {
+  const props = Object.keys(input);
+  for (const prop of props) {
+    if (prop === "__proto__") continue;
+    const descriptor = Object.getOwnPropertyDescriptor(input, prop);
+    const value = descriptor.value;
+    if (value) descriptor.value = cloneDescriptorValue(value);
+    if (!output[prop]) {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (typeof output[prop] !== "object") {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (descriptor.value == null || typeof descriptor.value !== "object") {
+      Object.defineProperty(output, prop, descriptor);
+      continue;
+    }
+    if (objectType(descriptor.value) === "[object Array]") {
+      output[prop] = options.array === "replace" ? descriptor.value.slice() : output[prop].concat(descriptor.value);
+      continue;
+    }
+    merge(output[prop], descriptor.value, options);
+  }
+}
+function cloneDescriptorValue(value) {
+  if (objectType(value) === "[object Array]") {
+    const array = [];
+    for (let v of value) {
+      v = cloneDescriptorValue(v);
+      array.push(v);
+    }
+    return array;
+  }
+  if (objectType(value) === "[object Object]") {
+    const obj = {};
+    const props = Object.keys(value);
+    for (const prop of props) {
+      const descriptor = Object.getOwnPropertyDescriptor(value, prop);
+      if (descriptor.value)
+        descriptor.value = cloneDescriptorValue(descriptor.value);
+      Object.defineProperty(obj, prop, descriptor);
+    }
+    return obj;
+  }
+  if (objectType(value) === "[object Date]") {
+    return new Date(value.getTime());
+  }
+  if (objectType(value) === "[object Map]") {
+    const map = /* @__PURE__ */ new Map();
+    for (const entry of value) {
+      map.set(entry[0], cloneDescriptorValue(entry[1]));
+    }
+    return map;
+  }
+  if (objectType(value) === "[object Set]") {
+    const set = /* @__PURE__ */ new Set();
+    for (const entry of value.entries()) {
+      set.add(cloneDescriptorValue(entry[0]));
+    }
+    return set;
+  }
+  return value;
+}
+function objectType(value) {
+  return Object.prototype.toString.call(value);
+}
+export {
+  concatMix,
+  createMix,
+  mix
+};

package/dist/esm/lib/objects/nested-property.js

@@ -0,0 +1,18 @@
+function getNestedProperty(object, pathArr) {
+  return pathArr.reduce(
+    (nestedObject, key) => nestedObject && nestedObject[key] !== "undefined" ? nestedObject[key] : void 0,
+    object
+  );
+}
+function getNestedProperty2(object, path) {
+  const pathArray = path.split(".");
+  return getNestedProperty(object, pathArray);
+}
+function getNestedValue(object, path) {
+  return path.split(".").reduce((acc, part) => acc?.[part], object);
+}
+export {
+  getNestedProperty,
+  getNestedProperty2,
+  getNestedValue
+};

package/dist/esm/lib/objects/normalize-object.js

@@ -0,0 +1,9 @@
+import { pipe } from "../functions/functional.js";
+import { camelCaseKeys } from "./camelcase-keys.js";
+import { omitEmpty } from "./omit-empty.js";
+function normalizeObject(object) {
+  return pipe(omitEmpty, camelCaseKeys)(object);
+}
+export {
+  normalizeObject
+};

package/dist/esm/lib/objects/omit-empty.js

@@ -0,0 +1,15 @@
+function omitEmpty(obj, shallow = false) {
+  if (typeof obj !== "object" || obj === null) return obj;
+  if (obj instanceof Date) return obj;
+  const result = Array.isArray(obj) ? [] : {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === null || value === void 0 || value === "" || typeof value === "object" && !(value instanceof Date) && Object.keys(value).length === 0) {
+      continue;
+    }
+    result[key] = shallow ? value : omitEmpty(value);
+  }
+  return result;
+}
+export {
+  omitEmpty
+};

package/dist/esm/lib/objects/size.js

@@ -0,0 +1,38 @@
+function sizeOf(obj) {
+  let bytes = 0;
+  function size(obj2) {
+    if (obj2 !== null && obj2 !== void 0) {
+      switch (typeof obj2) {
+        case "number":
+          bytes += 8;
+          break;
+        case "string":
+          bytes += obj2.length * 2;
+          break;
+        case "boolean":
+          bytes += 4;
+          break;
+        case "object":
+          const objClass = Object.prototype.toString.call(obj2).slice(8, -1);
+          if (objClass === "Object" || objClass === "Array") {
+            for (const key in obj2) {
+              if (!obj2.hasOwnProperty(key)) continue;
+              size(obj2[key]);
+            }
+          } else bytes += obj2.toString().length * 2;
+          break;
+      }
+    }
+    return bytes;
+  }
+  function formatByteSize(bytes2) {
+    if (bytes2 < 1024) return bytes2 + " bytes";
+    else if (bytes2 < 1048576) return (bytes2 / 1024).toFixed(3) + " KiB";
+    else if (bytes2 < 1073741824) return (bytes2 / 1048576).toFixed(3) + " MiB";
+    else return (bytes2 / 1073741824).toFixed(3) + " GiB";
+  }
+  return formatByteSize(size(obj));
+}
+export {
+  sizeOf
+};

package/dist/esm/lib/objects/split.js

@@ -0,0 +1,14 @@
+function splitObject(obj, keys) {
+  const picked = {};
+  const omitted = { ...obj };
+  keys.forEach((key) => {
+    if (key in obj) {
+      picked[key] = obj[key];
+      delete omitted[key];
+    }
+  });
+  return { picked, omitted, p: picked, o: omitted };
+}
+export {
+  splitObject
+};

package/dist/esm/lib/promises/index.js

@@ -0,0 +1 @@
+export * from "./reject.js";

package/dist/esm/lib/promises/reject.js

@@ -0,0 +1,17 @@
+import statuses from "statuses";
+import { omitEmpty } from "../objects/omit-empty.js";
+function reject(props, { includeStack = true } = {}) {
+  const { status, statusText, body, message } = props;
+  const e = new Error();
+  const err = {
+    status,
+    statusText: statusText || status && statuses(status),
+    body,
+    message,
+    stack: includeStack && e.stack
+  };
+  return Promise.reject(omitEmpty(err));
+}
+export {
+  reject
+};

package/dist/esm/lib/sse.js

@@ -0,0 +1,50 @@
+import { parseJSON } from "./objects/json.js";
+import { omitEmpty } from "./objects/omit-empty.js";
+function createSSE({ event, data, id, retry }) {
+  const eventString = event ? `event: ${event}
+` : "";
+  const idString = id ? `id: ${id}
+` : "";
+  const retryString = retry ? `retry: ${retry}
+` : "";
+  if (typeof data === "object") data = JSON.stringify(data);
+  const dataString = data ? `data: ${data}
+` : "";
+  return `${eventString}${dataString}${idString}${retryString}
+`;
+}
+function parseSSE(message) {
+  const lines = message.split("\n");
+  const result = {
+    event: "message",
+    // Default event type
+    data: "",
+    id: null,
+    retry: null
+  };
+  for (const line of lines) {
+    if (line.startsWith("data:")) {
+      const data = line.slice(5).trim();
+      result.data = parseJSON(data);
+      continue;
+    }
+    if (line.startsWith("event:")) {
+      result.event = line.slice(6).trim();
+      continue;
+    }
+    if (line.startsWith("id:")) {
+      result.id = line.slice(3).trim();
+      continue;
+    }
+    if (line.startsWith("retry:")) {
+      result.retry = parseInt(line.slice(6).trim(), 10);
+      continue;
+    }
+  }
+  const ret = omitEmpty(result);
+  return ret.data ? ret : null;
+}
+export {
+  createSSE,
+  parseSSE
+};

package/dist/esm/lib/strings/convert-case/convert-case.js

@@ -0,0 +1,64 @@
+function toKebab(string) {
+  if (!string) return "";
+  return string.split("").map((letter, index) => {
+    const previousLetter = string[index - 1] || "";
+    const currentLetter = letter;
+    if (isDigit(currentLetter) && !isDigit(previousLetter)) {
+      return `-${currentLetter}`;
+    }
+    if (!isCaps(currentLetter)) return currentLetter;
+    if (previousLetter === "") {
+      return `${currentLetter.toLowerCase()}`;
+    }
+    if (isCaps(previousLetter)) {
+      return `${currentLetter.toLowerCase()}`;
+    }
+    return `-${currentLetter.toLowerCase()}`;
+  }).join("").trim().replace(/[-_\s]+/g, "-");
+}
+function toCamel(string) {
+  return toKebab(string).split("-").map((word, index) => {
+    if (index === 0) return word;
+    return word.slice(0, 1).toUpperCase() + word.slice(1).toLowerCase();
+  }).join("");
+}
+function toPascal(string) {
+  const camel = toCamel(string);
+  return camel.slice(0, 1).toUpperCase() + camel.slice(1);
+}
+function toTitle(string) {
+  return toKebab(string).split("-").map((word) => {
+    return word.slice(0, 1).toUpperCase() + word.slice(1);
+  }).join(" ");
+}
+function toSlug(string) {
+  return toKebab(string);
+}
+function toSentence(string) {
+  const interim = toKebab(string).replace(/-/g, " ");
+  return interim.slice(0, 1).toUpperCase() + interim.slice(1);
+}
+function toUpper(string) {
+  const interim = toKebab(string).replace(/-/g, " ");
+  return interim.toUpperCase();
+}
+function toLower(string) {
+  const interim = toKebab(string).replace(/-/g, " ");
+  return interim.toLowerCase();
+}
+function isCaps(char) {
+  return /\p{Lu}/u.test(char);
+}
+function isDigit(char) {
+  return /[0-9]/.test(char);
+}
+export {
+  toCamel,
+  toKebab,
+  toLower,
+  toPascal,
+  toSentence,
+  toSlug,
+  toTitle,
+  toUpper
+};

package/dist/esm/lib/strings/index.js

@@ -0,0 +1,5 @@
+export * from "./convert-case/convert-case.js";
+export * from "./markdown.js";
+export * from "./name.js";
+export * from "./pluralize.js";
+export * from "./query-string.js";

package/dist/esm/lib/strings/markdown.js

@@ -0,0 +1,40 @@
+import markdownit from "markdown-it";
+import anchor from "markdown-it-anchor";
+const md = markdownit({
+  html: true,
+  linkify: true,
+  typographer: true
+});
+md.use(anchor, {
+  permalink: false,
+  slugify: (s) => s.toLowerCase().replace(/\s+/g, "-").replace(/[^\w-]/g, "")
+});
+function markdown(content, options = {}) {
+  const defaultOptions = { inline: false };
+  const opts = { ...defaultOptions, ...options };
+  const { content: treated } = treatMarkdownWhitespace(content, opts);
+  if (opts.inline) return md.renderInline(treated);
+  return md.render(treated);
+}
+function treatMarkdownWhitespace(content, { inline } = {}) {
+  if (!content) return { content: "", inline };
+  const lines = content.split("\n");
+  if (lines[0] !== "" && inline) return { content, inline: true };
+  const firstLineWithLeadingSpacesIndex = lines.findIndex(
+    (line) => line.match(/^\s+/)
+  );
+  const firstLineWithLeadingSpaces = lines[firstLineWithLeadingSpacesIndex];
+  const indentation = firstLineWithLeadingSpaces?.match(/^\s+/)?.[0]?.length ?? 0;
+  const retContent = lines.map((line, index) => {
+    if (index < firstLineWithLeadingSpacesIndex) return line + "\n";
+    return line.slice(indentation) + "\n";
+  }).join("");
+  return {
+    content: retContent,
+    inline
+  };
+}
+export {
+  markdown,
+  treatMarkdownWhitespace
+};

package/dist/esm/lib/strings/name.js

@@ -0,0 +1,21 @@
+function parseFullName(name) {
+  const parts = name.trim().split(/\s+/);
+  if (parts.length === 1) {
+    return { firstName: parts[0], middleName: "", lastName: "" };
+  }
+  if (parts.length === 2) {
+    return { firstName: parts[0], middleName: "", lastName: parts[1] };
+  }
+  if (parts.length === 3) {
+    const firstName2 = parts.slice(0, 2).join(" ");
+    const lastName2 = parts[2];
+    return { firstName: firstName2, middleName: "", lastName: lastName2 };
+  }
+  const firstName = parts.slice(0, 2).join(" ");
+  const lastName = parts[parts.length - 1];
+  const middleName = parts.slice(2, -1).join(" ");
+  return { firstName, middleName, lastName };
+}
+export {
+  parseFullName
+};

package/dist/esm/lib/strings/pluralize.js

@@ -0,0 +1,5 @@
+import pluralizeLib from "pluralize";
+const pluralize = pluralizeLib;
+export {
+  pluralize
+};

package/dist/esm/lib/strings/query-string.js

@@ -0,0 +1,16 @@
+function toQueryString(object) {
+  const searchParams = new URLSearchParams(object);
+  return searchParams.toString();
+}
+function plural(count, noun, suffix = "s") {
+  console.warn("plural is deprecated. Use pluralize instead");
+  return `${count} ${noun}${count !== 1 ? suffix : ""}`;
+}
+function stripNumbers(string) {
+  return string.replace(/\d*/, "");
+}
+export {
+  plural,
+  stripNumbers,
+  toQueryString
+};

package/dist/esm/lib/style/index.js

@@ -0,0 +1,12 @@
+import { toKebab } from "../strings/convert-case/convert-case.js";
+function toStyleString(style) {
+  if (!style) return null;
+  if (typeof style === "string") return style;
+  return Object.entries(style).map(([k, v]) => {
+    if (k.startsWith("--")) return `${k}:${v}`;
+    else return `${toKebab(k)}:${v}`;
+  }).join("; ").concat(";");
+}
+export {
+  toStyleString
+};

package/dist/esm/lib/symbols/index.js

@@ -0,0 +1 @@
+export * from "./symbols.js";

package/dist/esm/lib/symbols/symbols.js

@@ -0,0 +1,12 @@
+function getSymbol(object, description) {
+  return Object.getOwnPropertySymbols(object).find(
+    (s) => s.description === description
+  );
+}
+function getSymbolValue(object, description) {
+  return object[getSymbol(object, description)];
+}
+export {
+  getSymbol,
+  getSymbolValue
+};

package/dist/esm/node/dirname.js

@@ -0,0 +1,13 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+function __dirname(url) {
+  if (!url) throw Error("Please provide 'import.meta.url' to dirname");
+  return path.dirname(fileURLToPath(url));
+}
+function dirname(url) {
+  return __dirname(url);
+}
+export {
+  __dirname,
+  dirname
+};