@scalar/helpers 0.4.1 → 0.4.3

package/dist/regex/regex-helpers.js

@@ -1,18 +1,18 @@
-const REGEX = {
-  /** Checks for a valid scheme */
-  PROTOCOL: /^(?:https?|ftp|file|mailto|tel|data|wss?)*:\/\//,
-  /** Finds multiple slashes after the scheme to replace with a single slash */
-  MULTIPLE_SLASHES: /(?<!:)\/{2,}/g,
-  /** Finds all variables wrapped in {{double}} */
-  VARIABLES: /{{((?:[^{}]|{[^{}]*})*)}}/g,
-  /** Finds all variables wrapped in {single} */
-  PATH: /(?:{)([^{}]+)}(?!})/g,
-  /** Finds the name of the schema from the ref path */
-  REF_NAME: /\/([^\/]+)$/,
-  /** Finds template variables in multiple formats: {{var}}, {var}, or :var */
-  TEMPLATE_VARIABLE: /{{\s*([^}\s]+?)\s*}}|{\s*([^}\s]+?)\s*}|:\b[\w.]+\b/g
+/**
+ * Collection of regular expressions used throughout the application.
+ * These patterns handle URL parsing, variable detection, and reference path extraction.
+ */
+export const REGEX = {
+    /** Checks for a valid scheme */
+    PROTOCOL: /^(?:https?|ftp|file|mailto|tel|data|wss?)*:\/\//,
+    /** Finds multiple slashes after the scheme to replace with a single slash */
+    MULTIPLE_SLASHES: /(?<!:)\/{2,}/g,
+    /** Finds all variables wrapped in {{double}} */
+    VARIABLES: /{{((?:[^{}]|{[^{}]*})*)}}/g,
+    /** Finds all variables wrapped in {single} */
+    PATH: /(?:{)([^{}]+)}(?!})/g,
+    /** Finds the name of the schema from the ref path */
+    REF_NAME: /\/([^\/]+)$/,
+    /** Finds template variables in multiple formats: {{var}}, {var}, or :var */
+    TEMPLATE_VARIABLE: /{{\s*([^}\s]+?)\s*}}|{\s*([^}\s]+?)\s*}|:\b[\w.]+\b/g,
 };
-export {
-  REGEX
-};
-//# sourceMappingURL=regex-helpers.js.map

package/dist/regex/replace-variables.js

@@ -1,20 +1,22 @@
-import { REGEX } from "../regex/regex-helpers.js";
-function replaceVariables(value, variablesOrCallback) {
-  const doubleCurlyBrackets = /{{\s*([\w.-]+)\s*}}/g;
-  const singleCurlyBrackets = /{\s*([\w.-]+)\s*}/g;
-  const callback = (_, match) => {
-    if (typeof variablesOrCallback === "function") {
-      return variablesOrCallback(match);
-    }
-    return variablesOrCallback[match]?.toString() || `{${match}}`;
-  };
-  return value.replace(doubleCurlyBrackets, callback).replace(singleCurlyBrackets, callback);
+import { REGEX } from '../regex/regex-helpers.js';
+/**
+ * This function takes a string and replaces both {single} and {{double}} curly brace variables with given values.
+ * Use the replacePathVariables and replaceEnvVariables functions if you only need to replace one type of variable.
+ */
+export function replaceVariables(value, variablesOrCallback) {
+    // Replace all variables (example: {{ baseurl }} with an HTML tag)
+    const doubleCurlyBrackets = /{{\s*([\w.-]+)\s*}}/g;
+    const singleCurlyBrackets = /{\s*([\w.-]+)\s*}/g;
+    const callback = (_, match) => {
+        if (typeof variablesOrCallback === 'function') {
+            return variablesOrCallback(match);
+        }
+        return variablesOrCallback[match]?.toString() || `{${match}}`;
+    };
+    // Loop through all matches and replace the match with the variable value
+    return value.replace(doubleCurlyBrackets, callback).replace(singleCurlyBrackets, callback);
 }
-const replacePathVariables = (path, variables = {}) => path.replace(REGEX.PATH, (match, key) => variables[key] ?? match);
-const replaceEnvVariables = (path, variables = {}) => path.replace(REGEX.VARIABLES, (match, key) => variables[key] ?? match);
-export {
-  replaceEnvVariables,
-  replacePathVariables,
-  replaceVariables
-};
-//# sourceMappingURL=replace-variables.js.map
+/** Replace {path} variables with their values */
+export const replacePathVariables = (path, variables = {}) => path.replace(REGEX.PATH, (match, key) => variables[key] ?? match);
+/** Replace {{env}} variables with their values */
+export const replaceEnvVariables = (path, variables = {}) => path.replace(REGEX.VARIABLES, (match, key) => variables[key] ?? match);

package/dist/string/camel-to-title.js

@@ -1,5 +1,10 @@
-const camelToTitleWords = (camelStr = "") => camelStr.replace(/([A-Z]{2,})/g, " $1").replace(/([A-Z])(?=[a-z])/g, " $1").replace(/^./, (str) => str.toUpperCase()).trim();
-export {
-  camelToTitleWords
-};
-//# sourceMappingURL=camel-to-title.js.map
+/**
+ * Converts a camelCase string to Title Words with spaces
+ *
+ * @param camelStr - MUST be in camelCase or this might not work
+ */
+export const camelToTitleWords = (camelStr = '') => camelStr
+    .replace(/([A-Z]{2,})/g, ' $1') // Add space before consecutive capitals
+    .replace(/([A-Z])(?=[a-z])/g, ' $1') // Add space before single capital followed by lowercase
+    .replace(/^./, (str) => str.toUpperCase()) // Capitalize first letter
+    .trim();

package/dist/string/capitalize.js

@@ -1,5 +1,5 @@
-const capitalize = (str = "") => (str[0]?.toUpperCase() ?? "") + str.slice(1);
-export {
-  capitalize
-};
-//# sourceMappingURL=capitalize.js.map
+/**
+ * Capitalize first letter
+ * You should normally do this in css, only use this if you have to
+ */
+export const capitalize = (str = '') => (str[0]?.toUpperCase() ?? '') + str.slice(1);

package/dist/string/create-hash.js

@@ -1,18 +1,21 @@
-const createHash = (input) => {
-  let chr = 0;
-  let hash = 0;
-  let i = 0;
-  if (!input?.length) {
+/**
+ * Simple 32 bit non-secure hash from a string input
+ *
+ * @deprecated Please use generateHash from ./generate-hash.ts instead
+ *
+ * @see https://stackoverflow.com/a/7616484/1624255
+ */
+export const createHash = (input) => {
+    let chr = 0;
+    let hash = 0;
+    let i = 0;
+    if (!input?.length) {
+        return hash;
+    }
+    for (i = 0; i < input.length; i++) {
+        chr = input.charCodeAt(i);
+        hash = (hash << 5) - hash + chr;
+        hash |= 0; // Convert to 32bit integer
+    }
     return hash;
-  }
-  for (i = 0; i < input.length; i++) {
-    chr = input.charCodeAt(i);
-    hash = (hash << 5) - hash + chr;
-    hash |= 0;
-  }
-  return hash;
 };
-export {
-  createHash
-};
-//# sourceMappingURL=create-hash.js.map

package/dist/string/generate-hash.js

@@ -1,130 +1,156 @@
-const generateHash = (input) => {
-  const seed = 0;
-  let h1 = seed;
-  let h2 = seed;
-  const len = input.length;
-  const remainder = len & 15;
-  const bytes = len - remainder;
-  const c1 = 2277735313;
-  const c2 = 1291169091;
-  const c3 = 1390208809;
-  const c4 = 944331445;
-  for (let i = 0; i < bytes; i += 16) {
-    let k1 = input.charCodeAt(i) & 255 | (input.charCodeAt(i + 1) & 255) << 8 | (input.charCodeAt(i + 2) & 255) << 16 | (input.charCodeAt(i + 3) & 255) << 24;
-    let k2 = input.charCodeAt(i + 4) & 255 | (input.charCodeAt(i + 5) & 255) << 8 | (input.charCodeAt(i + 6) & 255) << 16 | (input.charCodeAt(i + 7) & 255) << 24;
-    let k3 = input.charCodeAt(i + 8) & 255 | (input.charCodeAt(i + 9) & 255) << 8 | (input.charCodeAt(i + 10) & 255) << 16 | (input.charCodeAt(i + 11) & 255) << 24;
-    let k4 = input.charCodeAt(i + 12) & 255 | (input.charCodeAt(i + 13) & 255) << 8 | (input.charCodeAt(i + 14) & 255) << 16 | (input.charCodeAt(i + 15) & 255) << 24;
-    k1 = Math.imul(k1, c1);
-    k1 = k1 << 15 | k1 >>> 17;
-    k1 = Math.imul(k1, c2);
-    h1 ^= k1;
-    h1 = h1 << 13 | h1 >>> 19;
-    h1 = Math.imul(h1, 5) + 3864292196;
-    k2 = Math.imul(k2, c2);
-    k2 = k2 << 16 | k2 >>> 16;
-    k2 = Math.imul(k2, c3);
-    h2 ^= k2;
-    h2 = h2 << 17 | h2 >>> 15;
-    h2 = Math.imul(h2, 5) + 461845907;
-    k3 = Math.imul(k3, c3);
-    k3 = k3 << 17 | k3 >>> 15;
-    k3 = Math.imul(k3, c4);
-    h1 ^= k3;
-    h1 = h1 << 15 | h1 >>> 17;
-    h1 = Math.imul(h1, 5) + 1390208809;
-    k4 = Math.imul(k4, c4);
-    k4 = k4 << 18 | k4 >>> 14;
-    k4 = Math.imul(k4, c1);
-    h2 ^= k4;
-    h2 = h2 << 13 | h2 >>> 19;
-    h2 = Math.imul(h2, 5) + 944331445;
-  }
-  if (remainder > 0) {
-    let k1 = 0;
-    let k2 = 0;
-    let k3 = 0;
-    let k4 = 0;
-    if (remainder >= 15) {
-      k4 ^= (input.charCodeAt(bytes + 14) & 255) << 16;
+/**
+ * MurmurHash3 implementation
+ *
+ * Generate a hash from a string using the MurmurHash3 algorithm
+ * Provides 64-bit hash output with excellent speed and distribution
+ *
+ * We had to move away from xxhash-wasm since it was causing issues with content security policy (CSP) violations.
+ *
+ * We cannot use crypto.subtle because it is only available in secure contexts (HTTPS) or on localhost.
+ *
+ * @param input - The string to hash
+ * @returns The 64-bit hash of the input string as a 16-character hex string
+ */
+export const generateHash = (input) => {
+    const seed = 0;
+    // Working with 64-bit values using pairs of 32-bit integers
+    let h1 = seed;
+    let h2 = seed;
+    const len = input.length;
+    const remainder = len & 15; // len % 16
+    const bytes = len - remainder;
+    const c1 = 0x87c37b91;
+    const c2 = 0x4cf5ad43;
+    const c3 = 0x52dce729;
+    const c4 = 0x38495ab5;
+    // Process 16-byte chunks
+    for (let i = 0; i < bytes; i += 16) {
+        let k1 = (input.charCodeAt(i) & 0xff) |
+            ((input.charCodeAt(i + 1) & 0xff) << 8) |
+            ((input.charCodeAt(i + 2) & 0xff) << 16) |
+            ((input.charCodeAt(i + 3) & 0xff) << 24);
+        let k2 = (input.charCodeAt(i + 4) & 0xff) |
+            ((input.charCodeAt(i + 5) & 0xff) << 8) |
+            ((input.charCodeAt(i + 6) & 0xff) << 16) |
+            ((input.charCodeAt(i + 7) & 0xff) << 24);
+        let k3 = (input.charCodeAt(i + 8) & 0xff) |
+            ((input.charCodeAt(i + 9) & 0xff) << 8) |
+            ((input.charCodeAt(i + 10) & 0xff) << 16) |
+            ((input.charCodeAt(i + 11) & 0xff) << 24);
+        let k4 = (input.charCodeAt(i + 12) & 0xff) |
+            ((input.charCodeAt(i + 13) & 0xff) << 8) |
+            ((input.charCodeAt(i + 14) & 0xff) << 16) |
+            ((input.charCodeAt(i + 15) & 0xff) << 24);
+        k1 = Math.imul(k1, c1);
+        k1 = (k1 << 15) | (k1 >>> 17);
+        k1 = Math.imul(k1, c2);
+        h1 ^= k1;
+        h1 = (h1 << 13) | (h1 >>> 19);
+        h1 = Math.imul(h1, 5) + 0xe6546b64;
+        k2 = Math.imul(k2, c2);
+        k2 = (k2 << 16) | (k2 >>> 16);
+        k2 = Math.imul(k2, c3);
+        h2 ^= k2;
+        h2 = (h2 << 17) | (h2 >>> 15);
+        h2 = Math.imul(h2, 5) + 0x1b873593;
+        k3 = Math.imul(k3, c3);
+        k3 = (k3 << 17) | (k3 >>> 15);
+        k3 = Math.imul(k3, c4);
+        h1 ^= k3;
+        h1 = (h1 << 15) | (h1 >>> 17);
+        h1 = Math.imul(h1, 5) + 0x52dce729;
+        k4 = Math.imul(k4, c4);
+        k4 = (k4 << 18) | (k4 >>> 14);
+        k4 = Math.imul(k4, c1);
+        h2 ^= k4;
+        h2 = (h2 << 13) | (h2 >>> 19);
+        h2 = Math.imul(h2, 5) + 0x38495ab5;
     }
-    if (remainder >= 14) {
-      k4 ^= (input.charCodeAt(bytes + 13) & 255) << 8;
+    // Process remaining bytes
+    if (remainder > 0) {
+        let k1 = 0;
+        let k2 = 0;
+        let k3 = 0;
+        let k4 = 0;
+        if (remainder >= 15) {
+            k4 ^= (input.charCodeAt(bytes + 14) & 0xff) << 16;
+        }
+        if (remainder >= 14) {
+            k4 ^= (input.charCodeAt(bytes + 13) & 0xff) << 8;
+        }
+        if (remainder >= 13) {
+            k4 ^= input.charCodeAt(bytes + 12) & 0xff;
+            k4 = Math.imul(k4, c4);
+            k4 = (k4 << 18) | (k4 >>> 14);
+            k4 = Math.imul(k4, c1);
+            h2 ^= k4;
+        }
+        if (remainder >= 12) {
+            k3 ^= (input.charCodeAt(bytes + 11) & 0xff) << 24;
+        }
+        if (remainder >= 11) {
+            k3 ^= (input.charCodeAt(bytes + 10) & 0xff) << 16;
+        }
+        if (remainder >= 10) {
+            k3 ^= (input.charCodeAt(bytes + 9) & 0xff) << 8;
+        }
+        if (remainder >= 9) {
+            k3 ^= input.charCodeAt(bytes + 8) & 0xff;
+            k3 = Math.imul(k3, c3);
+            k3 = (k3 << 17) | (k3 >>> 15);
+            k3 = Math.imul(k3, c4);
+            h1 ^= k3;
+        }
+        if (remainder >= 8) {
+            k2 ^= (input.charCodeAt(bytes + 7) & 0xff) << 24;
+        }
+        if (remainder >= 7) {
+            k2 ^= (input.charCodeAt(bytes + 6) & 0xff) << 16;
+        }
+        if (remainder >= 6) {
+            k2 ^= (input.charCodeAt(bytes + 5) & 0xff) << 8;
+        }
+        if (remainder >= 5) {
+            k2 ^= input.charCodeAt(bytes + 4) & 0xff;
+            k2 = Math.imul(k2, c2);
+            k2 = (k2 << 16) | (k2 >>> 16);
+            k2 = Math.imul(k2, c3);
+            h2 ^= k2;
+        }
+        if (remainder >= 4) {
+            k1 ^= (input.charCodeAt(bytes + 3) & 0xff) << 24;
+        }
+        if (remainder >= 3) {
+            k1 ^= (input.charCodeAt(bytes + 2) & 0xff) << 16;
+        }
+        if (remainder >= 2) {
+            k1 ^= (input.charCodeAt(bytes + 1) & 0xff) << 8;
+        }
+        if (remainder >= 1) {
+            k1 ^= input.charCodeAt(bytes) & 0xff;
+            k1 = Math.imul(k1, c1);
+            k1 = (k1 << 15) | (k1 >>> 17);
+            k1 = Math.imul(k1, c2);
+            h1 ^= k1;
+        }
     }
-    if (remainder >= 13) {
-      k4 ^= input.charCodeAt(bytes + 12) & 255;
-      k4 = Math.imul(k4, c4);
-      k4 = k4 << 18 | k4 >>> 14;
-      k4 = Math.imul(k4, c1);
-      h2 ^= k4;
-    }
-    if (remainder >= 12) {
-      k3 ^= (input.charCodeAt(bytes + 11) & 255) << 24;
-    }
-    if (remainder >= 11) {
-      k3 ^= (input.charCodeAt(bytes + 10) & 255) << 16;
-    }
-    if (remainder >= 10) {
-      k3 ^= (input.charCodeAt(bytes + 9) & 255) << 8;
-    }
-    if (remainder >= 9) {
-      k3 ^= input.charCodeAt(bytes + 8) & 255;
-      k3 = Math.imul(k3, c3);
-      k3 = k3 << 17 | k3 >>> 15;
-      k3 = Math.imul(k3, c4);
-      h1 ^= k3;
-    }
-    if (remainder >= 8) {
-      k2 ^= (input.charCodeAt(bytes + 7) & 255) << 24;
-    }
-    if (remainder >= 7) {
-      k2 ^= (input.charCodeAt(bytes + 6) & 255) << 16;
-    }
-    if (remainder >= 6) {
-      k2 ^= (input.charCodeAt(bytes + 5) & 255) << 8;
-    }
-    if (remainder >= 5) {
-      k2 ^= input.charCodeAt(bytes + 4) & 255;
-      k2 = Math.imul(k2, c2);
-      k2 = k2 << 16 | k2 >>> 16;
-      k2 = Math.imul(k2, c3);
-      h2 ^= k2;
-    }
-    if (remainder >= 4) {
-      k1 ^= (input.charCodeAt(bytes + 3) & 255) << 24;
-    }
-    if (remainder >= 3) {
-      k1 ^= (input.charCodeAt(bytes + 2) & 255) << 16;
-    }
-    if (remainder >= 2) {
-      k1 ^= (input.charCodeAt(bytes + 1) & 255) << 8;
-    }
-    if (remainder >= 1) {
-      k1 ^= input.charCodeAt(bytes) & 255;
-      k1 = Math.imul(k1, c1);
-      k1 = k1 << 15 | k1 >>> 17;
-      k1 = Math.imul(k1, c2);
-      h1 ^= k1;
-    }
-  }
-  h1 ^= len;
-  h2 ^= len;
-  h1 += h2;
-  h2 += h1;
-  h1 ^= h1 >>> 16;
-  h1 = Math.imul(h1, 2246822507);
-  h1 ^= h1 >>> 13;
-  h1 = Math.imul(h1, 3266489909);
-  h1 ^= h1 >>> 16;
-  h2 ^= h2 >>> 16;
-  h2 = Math.imul(h2, 2246822507);
-  h2 ^= h2 >>> 13;
-  h2 = Math.imul(h2, 3266489909);
-  h2 ^= h2 >>> 16;
-  h1 += h2;
-  h2 += h1;
-  return (h1 >>> 0).toString(16).padStart(8, "0") + (h2 >>> 0).toString(16).padStart(8, "0");
-};
-export {
-  generateHash
+    // Finalization
+    h1 ^= len;
+    h2 ^= len;
+    h1 += h2;
+    h2 += h1;
+    h1 ^= h1 >>> 16;
+    h1 = Math.imul(h1, 0x85ebca6b);
+    h1 ^= h1 >>> 13;
+    h1 = Math.imul(h1, 0xc2b2ae35);
+    h1 ^= h1 >>> 16;
+    h2 ^= h2 >>> 16;
+    h2 = Math.imul(h2, 0x85ebca6b);
+    h2 ^= h2 >>> 13;
+    h2 = Math.imul(h2, 0xc2b2ae35);
+    h2 ^= h2 >>> 16;
+    h1 += h2;
+    h2 += h1;
+    // Return 64-bit hash as hex string (two 32-bit values concatenated)
+    return (h1 >>> 0).toString(16).padStart(8, '0') + (h2 >>> 0).toString(16).padStart(8, '0');
 };
-//# sourceMappingURL=generate-hash.js.map

package/dist/string/iterate-title.js

@@ -1,12 +1,14 @@
-const iterateTitle = (title, checkDuplicates, separator = " #") => {
-  if (!checkDuplicates(title)) {
-    return title;
-  }
-  const split = title.split(separator);
-  const newTitle = split.length > 1 ? `${split.slice(0, -1).join()}${separator}${Number(split.at(-1)) + 1}` : `${split.join()}${separator}2`;
-  return iterateTitle(newTitle, checkDuplicates, separator);
+/**
+ * Check for duplicate titles, and iterate title
+ */
+export const iterateTitle = (title, checkDuplicates, separator = ' #') => {
+    // If the title is not a duplicate return
+    if (!checkDuplicates(title)) {
+        return title;
+    }
+    const split = title.split(separator);
+    const newTitle = split.length > 1
+        ? `${split.slice(0, -1).join()}${separator}${Number(split.at(-1)) + 1}`
+        : `${split.join()}${separator}2`;
+    return iterateTitle(newTitle, checkDuplicates, separator);
 };
-export {
-  iterateTitle
-};
-//# sourceMappingURL=iterate-title.js.map

package/dist/string/truncate.js

@@ -1,10 +1,17 @@
-const truncate = (str, maxLength = 18) => {
-  if (str.length <= maxLength) {
-    return str;
-  }
-  return str.slice(0, maxLength) + "\u2026";
+/**
+ * Truncates a string to a specified length and adds an ellipsis if it's longer in JS
+ *
+ * @param str - The string to truncate
+ * @param maxLength - The maximum length before truncation (default: 18)
+ * @returns The truncated string with ellipsis if needed
+ *
+ * @example
+ * truncate('Very long name that needs truncation') // 'Very long name th…'
+ * truncate('Short') // 'Short'
+ */
+export const truncate = (str, maxLength = 18) => {
+    if (str.length <= maxLength) {
+        return str;
+    }
+    return str.slice(0, maxLength) + '…';
 };
-export {
-  truncate
-};
-//# sourceMappingURL=truncate.js.map

package/dist/testing/console-spies.js

@@ -1,25 +1,20 @@
-import { vi } from "vitest";
-const consoleWarnSpy = vi.spyOn(console, "warn");
-let isConsoleWarnEnabled = false;
-const consoleErrorSpy = vi.spyOn(console, "error");
-let isConsoleErrorEnabled = false;
-const resetConsoleSpies = () => {
-  consoleWarnSpy.mockClear();
-  consoleErrorSpy.mockClear();
+import { vi } from 'vitest';
+/** Spy on console.warn */
+export const consoleWarnSpy = vi.spyOn(console, 'warn');
+export let isConsoleWarnEnabled = false;
+/** Spy on console.error */
+export const consoleErrorSpy = vi.spyOn(console, 'error');
+export let isConsoleErrorEnabled = false;
+/** Reset the spies */
+export const resetConsoleSpies = () => {
+    consoleWarnSpy.mockClear();
+    consoleErrorSpy.mockClear();
 };
-const enableConsoleWarn = () => isConsoleWarnEnabled = true;
-const disableConsoleWarn = () => isConsoleWarnEnabled = false;
-const enableConsoleError = () => isConsoleErrorEnabled = true;
-const disableConsoleError = () => isConsoleErrorEnabled = false;
-export {
-  consoleErrorSpy,
-  consoleWarnSpy,
-  disableConsoleError,
-  disableConsoleWarn,
-  enableConsoleError,
-  enableConsoleWarn,
-  isConsoleErrorEnabled,
-  isConsoleWarnEnabled,
-  resetConsoleSpies
-};
-//# sourceMappingURL=console-spies.js.map
+/** Helper to re-enable console warn checks */
+export const enableConsoleWarn = () => (isConsoleWarnEnabled = true);
+/** Helper to disable console warn checks */
+export const disableConsoleWarn = () => (isConsoleWarnEnabled = false);
+/** Helper to enable console error checks */
+export const enableConsoleError = () => (isConsoleErrorEnabled = true);
+/** Helper to disable console error checks */
+export const disableConsoleError = () => (isConsoleErrorEnabled = false);

package/dist/testing/measure.js

@@ -1,21 +1,44 @@
-const measureSync = (name, fn) => {
-  const start = performance.now();
-  const result = fn();
-  const end = performance.now();
-  const duration = Math.round(end - start);
-  console.info(`${name}: ${duration} ms`);
-  return result;
+/**
+ * Measures the execution time of a function and logs it.
+ *
+ * Works only with sync functions and returns the result of the measured function.
+ *
+ * @example
+ *
+ * ```ts
+ * // Sync function
+ * const result = measureSync('computation', () => {
+ *   return heavyComputation()
+ * })
+ * ```
+ */
+export const measureSync = (name, fn) => {
+    const start = performance.now();
+    const result = fn();
+    const end = performance.now();
+    const duration = Math.round(end - start);
+    console.info(`${name}: ${duration} ms`);
+    return result;
 };
-const measureAsync = async (name, fn) => {
-  const start = performance.now();
-  const result = await fn();
-  const end = performance.now();
-  const duration = Math.round(end - start);
-  console.info(`${name}: ${duration} ms`);
-  return result;
+/**
+ * Measures the execution time of an async function and logs it.
+ *
+ * Works only with async functions and returns the result of the measured function.
+ *
+ * @example
+ *
+ * ```ts
+ * // Async function
+ * const result = await measure('api-call', async () => {
+ *   return await fetchData()
+ * })
+ * ````
+ */
+export const measureAsync = async (name, fn) => {
+    const start = performance.now();
+    const result = await fn();
+    const end = performance.now();
+    const duration = Math.round(end - start);
+    console.info(`${name}: ${duration} ms`);
+    return result;
 };
-export {
-  measureAsync,
-  measureSync
-};
-//# sourceMappingURL=measure.js.map

package/dist/testing/measure.test-d.js

@@ -1,12 +1,15 @@
-import { describe, vi } from "vitest";
-import { measureAsync, measureSync } from "./measure.js";
+import { describe, vi } from 'vitest';
+import { measureAsync, measureSync } from './measure.js';
 const asyncFunction = vi.fn();
-describe("measureAsync types", async () => {
-  await measureAsync("test", asyncFunction);
-  await measureAsync("test", () => 1);
+describe('measureAsync types', async () => {
+    // works with async methods
+    await measureAsync('test', asyncFunction);
+    // @ts-expect-error should error because `fn` doesn't return a Promise
+    await measureAsync('test', () => 1);
 });
-describe("measureSync types", () => {
-  measureSync("test", () => 1);
-  measureSync("test", asyncFunction);
+describe('measureSync types', () => {
+    // works with sync methods
+    measureSync('test', () => 1);
+    // @ts-expect-error should error because `fn` doesn't return a Promise
+    measureSync('test', asyncFunction);
 });
-//# sourceMappingURL=measure.test-d.js.map

package/dist/testing/sleep.js

@@ -1,5 +1,5 @@
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-export {
-  sleep
-};
-//# sourceMappingURL=sleep.js.map
+/**
+ * Little helper for sleeping for x milliseconds
+ * an async await friendly setTimeout
+ */
+export const sleep = (ms) => new Promise((r) => setTimeout(r, ms));