usemods-nuxt 0.0.22 → 1.1.0

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "usemods-nuxt",
   "configKey": "usemods",
-  "version": "0.0.22",
+  "version": "1.1.0",
   "builder": {
     "@nuxt/module-builder": "0.6.0",
     "unbuild": "2.0.0"

package/dist/runtime/utils/README.txt

@@ -0,0 +1,2 @@
+# Synced Files
+Please note all Mod files sync via the `./docs.mjs` here for automagical imports into the Nuxt Website and Nuxt Module. For any changes to the functions please refer to the `./src` folder.

package/dist/runtime/utils/actions.d.ts

@@ -4,6 +4,7 @@
 export declare function scrollToAnchor(id: string): Promise<void>;
 /**
  * Toggles the body scroll with specified class names and returns a promise
+ * @info Use your own class names, or ensure fixed is within your Tailwindcss JIT
  */
 export declare function toggleBodyScroll(className?: string, action?: 'add' | 'remove' | 'toggle'): Promise<void>;
 /**

package/dist/runtime/utils/actions.mjs

@@ -4,6 +4,7 @@ export function scrollToAnchor(id) {
       const selector = `#${id}`;
       const element = document.querySelector(selector);
       if (!element) {
+        console.warn(`[MODS] Element with id '${id}' not found.`);
         reject(`Element with id '${id}' not found.`);
         return;
       }
@@ -22,17 +23,28 @@ export function toggleBodyScroll(className = "fixed", action = "toggle") {
       const isFixed = body.classList.contains(className);
       const scrollY = isFixed ? parseInt(body.style.top, 10) : window.scrollY;
       body.style.top = isFixed ? "" : `-${scrollY}px`;
-      body.classList[action](className);
+      if (action === "add") {
+        body.classList.add(className);
+      } else if (action === "remove") {
+        body.classList.remove(className);
+      } else {
+        body.classList.toggle(className);
+      }
       if (isFixed)
         window.scrollTo(0, -scrollY);
       resolve();
     } catch (error) {
+      console.warn("[MODS] Failed to toggle body scroll.");
       reject(error);
     }
   });
 }
 export function toggleElementScroll(element) {
   return new Promise((resolve) => {
+    if (!element) {
+      console.warn("[MODS] Element is required to toggle scroll.");
+      return resolve();
+    }
     if (element.dataset.isScrollLocked === "true") {
       element.style.overflow = "";
       delete element.dataset.isScrollLocked;
@@ -43,14 +55,16 @@ export function toggleElementScroll(element) {
     resolve();
   });
 }
-export function copyToClipboard(value) {
+export async function copyToClipboard(value) {
   if (!navigator.clipboard || !navigator.clipboard.writeText) {
-    return Promise.reject("Clipboard API is not available");
+    throw new Error("Clipboard API is not available");
   }
-  return navigator.clipboard.writeText(String(value)).catch((error) => {
+  try {
+    await navigator.clipboard.writeText(String(value));
+  } catch (error) {
     console.error("Failed to copy text: ", error);
     throw error;
-  });
+  }
 }
 export function toggleFullScreen() {
   return new Promise((resolve, reject) => {

package/dist/runtime/utils/data.d.ts

@@ -16,7 +16,7 @@ export declare function dataRemoveDuplicates<T extends string | number>(...array
 /**
  * Flatten an array of arrays or an object of objects into a single array or object. That was hard to say.
  */
-export declare function dataFlatten(items: object | string[] | number[]): object | string[] | number[];
+export declare function dataFlatten(items: object | any[]): object | any[];
 /**
  * Returns an array without a property or properties.
  */

package/dist/runtime/utils/data.mjs

@@ -32,18 +32,17 @@ export function dataReverse(items) {
 }
 export function dataRemoveDuplicates(...arrays) {
   const mergedArray = arrays.flat();
-  return mergedArray.filter((item, index) => mergedArray.indexOf(item) === index);
+  return Array.from(new Set(mergedArray));
 }
 export function dataFlatten(items) {
   if (isObject(items)) {
     const flattened = {};
-    Object.keys(items).forEach((key) => {
-      const item = items[key];
-      flattened[key] = Array.isArray(item) ? dataFlatten(item) : item;
-    });
+    for (const [key, value] of Object.entries(items)) {
+      flattened[key] = Array.isArray(value) ? dataFlatten(value) : value;
+    }
     return flattened;
   } else if (Array.isArray(items)) {
-    return items.reduce((acc, val) => acc.concat(Array.isArray(val) ? dataFlatten(val) : val), []);
+    return items.flatMap((item) => Array.isArray(item) ? dataFlatten(item) : item);
   } else {
     return items;
   }

package/dist/runtime/utils/detections.d.ts

@@ -7,6 +7,7 @@ export declare function detectScrollPosition(): {
 };
 /**
  * Detect the absolute mouse position with the page
+ * @info Don't forget to add a mousemove event listener to the window
  */
 export declare function detectMousePosition(event: MouseEvent): {
     x: number;
@@ -14,6 +15,7 @@ export declare function detectMousePosition(event: MouseEvent): {
 };
 /**
  * Detect the relative mouse position with the window size and returns a percentage value
+ * @info Don't forget to add a mousemove event listener to the window
  */
 export declare function detectRelativeMousePosition(event: MouseEvent): {
     x: number;

package/dist/runtime/utils/formatters.d.ts

@@ -26,6 +26,15 @@ export declare function formatPercentage(value: number, options?: {
     decimals?: number;
     locale?: string;
 }): string;
+/**
+ * Format a number into a your unit of choice
+ */
+export declare function formatUnit(value: number, options: {
+    unit: string;
+    decimals?: number;
+    unitDisplay?: 'short' | 'long';
+    locale?: string;
+}): string;
 /**
  * Format time into a human-readable string
  */
@@ -40,7 +49,7 @@ export declare function formatDurationNumbers(seconds: number): string;
 /**
  * Format numbers into words
  */
-export declare function formatNumberToWords(value: number): string;
+export declare function formatNumberToWords(number: number): string;
 /**
  * Generate initials from any string while ignoring common titles
  */
@@ -68,8 +77,6 @@ export declare function formatTitle(text: string): string;
 export declare function formatSentenceCase(text: string): string;
 /**
  * Adds a space between the last two words in a string to prevent lonely words.
+ * @info Remember `text-wrap: pretty` and `text-wrap: balance` are available for most browsers.
  */
 export declare function formatTextWrap(value: string): string;
-/**
- * Format a number into a unit formatting
- */

package/dist/runtime/utils/formatters.mjs

@@ -79,6 +79,17 @@ export function formatPercentage(value, options) {
   };
   return new Intl.NumberFormat(options?.locale ?? "en-US", config).format(value);
 }
+export function formatUnit(value, options) {
+  const safeDecimals = Math.max(0, Math.min(options?.decimals ?? 2, 20));
+  const config = {
+    unit: options.unit,
+    style: "unit",
+    unitDisplay: options.unitDisplay ?? "long",
+    minimumFractionDigits: safeDecimals === 0 ? 0 : safeDecimals === 1 ? 1 : 2,
+    maximumFractionDigits: safeDecimals
+  };
+  return new Intl.NumberFormat(options.locale ?? "en-US", config).format(value);
+}
 export function formatDurationLabels(seconds, options) {
   const time = [
     { unit: options?.labels === "short" ? "yr" : " year", secondsInUnit: 31536e3 },
@@ -116,7 +127,7 @@ export function formatDurationNumbers(seconds) {
   const remainingSeconds = seconds - hours * 3600 - minutes * 60;
   return [hours, minutes, remainingSeconds].map((value) => value.toString().padStart(2, "0")).join(":");
 }
-export function formatNumberToWords(value) {
+export function formatNumberToWords(number) {
   const underTwenty = [
     "zero",
     "one",
@@ -140,29 +151,27 @@ export function formatNumberToWords(value) {
     "nineteen"
   ];
   const tens = ["twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety"];
-  if (value < 20)
-    return underTwenty[value];
-  if (value < 100)
-    return `${tens[Math.floor(value / 10) - 2]}${value % 10 ? "-" + underTwenty[value % 10] : ""}`;
-  const formatGroup = (number) => {
-    if (number >= 100) {
-      const remainder = number % 100;
-      return `${underTwenty[Math.floor(number / 100)]} hundred${remainder ? ` and ${formatGroup(remainder)}` : ""}`;
-    } else if (number >= 20) {
-      return `${tens[Math.floor(number / 10) - 2]}${number % 10 ? "-" + underTwenty[number % 10] : ""}`;
-    } else {
-      return underTwenty[number];
-    }
-  };
   const scales = ["", " thousand", " million", " billion", " trillion", " quadrillion", " quintillion"];
+  if (number < 20)
+    return underTwenty[number];
+  if (number < 100)
+    return `${tens[Math.floor(number / 10) - 2]}${number % 10 ? "-" + underTwenty[number % 10] : ""}`;
+  const formatGroup = (num) => {
+    if (num < 20)
+      return underTwenty[num];
+    if (num < 100)
+      return `${tens[Math.floor(num / 10) - 2]}${num % 10 ? "-" + underTwenty[num % 10] : ""}`;
+    const remainder = num % 100;
+    return `${underTwenty[Math.floor(num / 100)]} hundred${remainder ? ` and ${formatGroup(remainder)}` : ""}`;
+  };
   let scaleIndex = 0;
   let result = "";
-  while (value > 0) {
-    const groupValue = value % 1e3;
+  while (number > 0) {
+    const groupValue = number % 1e3;
     if (groupValue > 0) {
       result = formatGroup(groupValue) + scales[scaleIndex] + (result ? ", " + result : "");
     }
-    value = Math.floor(value / 1e3);
+    number = Math.floor(number / 1e3);
     scaleIndex++;
   }
   return result.trim();
@@ -170,10 +179,14 @@ export function formatNumberToWords(value) {
 export function formatInitials(text, options) {
   if (!text)
     return "";
-  text = text.replace(/(Mrs|Mr|Ms|Dr|Jr|Sr|Prof|Hon|Snr|Jnr|St)\.?/g, "").trim();
+  text = text.replace(/\b(Mrs|Mr|Ms|Dr|Jr|Sr|Prof|Hon|Snr|Jnr|St)\b\.?/g, " ").trim();
   return text.split(" ").filter((word) => !["the", "third"].includes(word.toLowerCase())).map((word) => word.charAt(0).toUpperCase()).join("").substring(0, options?.length ?? 2);
 }
 export function formatUnixTime(timestamp) {
+  if (isNaN(timestamp) || timestamp < 0 || timestamp > 9999999999) {
+    console.warn("[MODS] Invalid Unix timestamp:", timestamp);
+    return String(timestamp);
+  }
   return new Date(timestamp * 1e3).toISOString().replace("T", " ").replace("Z", "");
 }
 export function formatList(items, options) {

package/dist/runtime/utils/generators.d.ts

@@ -15,9 +15,19 @@ export declare function generateUuid(): string;
  */
 export declare function generateShortId(length?: number): string;
 /**
- * Generate a random, secure password with a mix of character types.
+ * Generate a random, secure password with a mix of character types and pleasant special characters.
+ * @info Don't forget to use our Password Checker in the Goodies section
  */
-export declare function generatePassword(length?: number): string;
+export declare function generatePassword(options?: {
+    length?: number;
+    uppercase?: number;
+    number?: number;
+    special?: number;
+}): string;
+/**
+ * Random number generator using cryptographic methods to avoid random().
+ */
+export declare function generateRandomIndex(max: number): number;
 /**
  * Generate Lorem Ipsum text in various formats.
  */

package/dist/runtime/utils/generators.mjs

@@ -1,6 +1,10 @@
 export function generateNumber(length) {
-  const min = Math.pow(10, length - 1);
-  const max = Math.pow(10, length) - 1;
+  if (!Number.isInteger(length) || length <= 0) {
+    console.warn("[MODS] Warning: length must be a positive integer");
+    return 0;
+  }
+  const min = 10 ** (length - 1);
+  const max = 10 ** length - 1;
   return Math.floor(Math.random() * (max - min + 1) + min);
 }
 export function generateNumberBetween(min, max) {
@@ -19,28 +23,46 @@ export function generateShortId(length = 19) {
   const randomPart = Math.random().toString().slice(2).toUpperCase();
   return (timestampPart + randomPart).slice(0, length);
 }
-export function generatePassword(length = 8) {
-  length = Math.max(length, 8);
-  const uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-  const lowercase = uppercase.toLowerCase();
-  const numbers = "0123456789";
-  const symbols = "!@#$%^&*";
-  const allChars = uppercase + lowercase + numbers + symbols;
-  const passwordArray = [];
-  const types = [uppercase, lowercase, numbers, symbols];
-  types.forEach((type) => {
-    const randomIndex = window.crypto.getRandomValues(new Uint32Array(1))[0] % type.length;
-    passwordArray.push(type[randomIndex]);
-  });
-  for (let i = passwordArray.length; i < length; i++) {
-    const randomIndex = window.crypto.getRandomValues(new Uint32Array(1))[0] % allChars.length;
-    passwordArray.push(allChars[randomIndex]);
+export function generatePassword(options) {
+  const { length = 8, uppercase = 1, number = 1, special = 1 } = options || {};
+  const uppercaseChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+  const numberChars = "0123456789";
+  const specialChars = "!@#$%&()_+?";
+  const allChars = "abcdefghijklmnopqrstuvwxyz" + uppercaseChars + numberChars + specialChars;
+  let password = "";
+  password += allChars.charAt(generateRandomIndex(52));
+  for (let i = 1; i < length; i++) {
+    password += allChars.charAt(Math.floor(Math.random() * allChars.length));
   }
-  for (let i = passwordArray.length - 1; i > 0; i--) {
-    const j = window.crypto.getRandomValues(new Uint32Array(1))[0] % (i + 1);
-    [passwordArray[i], passwordArray[j]] = [passwordArray[j], passwordArray[i]];
+  const ensureCriteria = (regex, chars, count) => {
+    while ((password.match(regex) || []).length < count) {
+      const randomIndex = generateRandomIndex(password.length);
+      password = password.substring(0, randomIndex) + chars.charAt(Math.floor(Math.random() * chars.length)) + password.substring(randomIndex + 1);
+    }
+  };
+  ensureCriteria(/[A-Z]/g, uppercaseChars, uppercase);
+  ensureCriteria(/[0-9]/g, numberChars, number);
+  ensureCriteria(/[^a-zA-Z0-9]/g, specialChars, special);
+  return password;
+}
+export function generateRandomIndex(max) {
+  if (max <= 0)
+    throw new Error("[MODS] Max value must be a positive integer");
+  if (max > 256)
+    throw new Error("[MODS] Max value must be less than 256");
+  const range = 256 - 256 % max;
+  let randomValue;
+  if (typeof window !== "undefined" && window.crypto && window.crypto.getRandomValues) {
+    do {
+      randomValue = window.crypto.getRandomValues(new Uint8Array(1))[0];
+    } while (randomValue >= range);
+  } else {
+    const crypto2 = require("crypto");
+    do {
+      randomValue = crypto2.randomBytes(1)[0];
+    } while (randomValue >= range);
   }
-  return passwordArray.join("");
+  return randomValue % max;
 }
 export function generateLoremIpsum(count = 5, format = "words") {
   const lorem = "lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua".split(" ");

package/dist/runtime/utils/goodies.d.ts

@@ -1,16 +1,23 @@
 /**
  * Wraps each word, sentence or paragraph in a string with a tag.
+ * @info Don't forget to render the HTML safely.
  */
 export declare function splitByWords(text: string): string;
 /**
  * Check the strength of a password against a given policy.
+ * @info Don't forget to use our Password Generator in the Generators section
  */
-export declare function checkPasswordStrength(value: string, length: number, uppercase: number, numbers: number, special: number): object;
-/**
- * Returns the reading time of a string in Hours, Minutes, and Seconds.
- */
-export declare function readingTime(text: string, wordsPerMinute?: number): string;
+export declare function checkPasswordStrength(value: string, options?: {
+    length?: number;
+    uppercase?: number;
+    number?: number;
+    special?: number;
+}): object;
 /**
  * Replaces placeholders in a string with values from an object.
  */
 export declare function mergeFields(text: string, fields: Record<string | number, string | number>): string;
+/**
+ * Returns the reading time of a string in Hours, Minutes, and Seconds.
+ */
+export declare function readingTime(text: string, wordsPerMinute?: number): string;

package/dist/runtime/utils/goodies.mjs

@@ -15,7 +15,8 @@ export function splitByWords(text) {
   }
   return combinedSentences.join(" ");
 }
-export function checkPasswordStrength(value, length, uppercase, numbers, special) {
+export function checkPasswordStrength(value, options) {
+  const { length = 8, uppercase = 1, number = 1, special = 1 } = options || {};
   let strength = 0;
   const counts = {
     uppercase: (value.match(/[A-Z]/g) || []).length,
@@ -26,15 +27,15 @@ export function checkPasswordStrength(value, length, uppercase, numbers, special
     return { score: 1, label: `Password must be at least ${length} characters long` };
   if (counts.uppercase < uppercase)
     return { score: 1, label: `Password must contain ${uppercase} uppercase letter` };
-  if (counts.numbers < numbers)
-    return { score: 1, label: `Password must contain ${numbers} number` };
+  if (counts.numbers < number)
+    return { score: 1, label: `Password must contain ${number} number` };
   if (counts.special < special)
     return { score: 1, label: `Password must contain ${special} special character` };
   if (value.length >= length)
     strength++;
   if (counts.uppercase >= uppercase)
     strength++;
-  if (counts.numbers >= numbers)
+  if (counts.numbers >= number)
     strength++;
   if (counts.special >= special)
     strength++;
@@ -48,11 +49,6 @@ export function checkPasswordStrength(value, length, uppercase, numbers, special
     return { score: 1, label: "Weak" };
   return { score: 0, label: "Very Weak" };
 }
-export function readingTime(text, wordsPerMinute = 200) {
-  const words = text.split(" ").length;
-  const minutes = Math.ceil(words / wordsPerMinute);
-  return formatDurationLabels(minutes * 60);
-}
 export function mergeFields(text, fields) {
   const pattern = /\{\{\s*(\w+)\s*\}\}/g;
   return text.replace(pattern, (match, key) => {
@@ -64,3 +60,8 @@ export function mergeFields(text, fields) {
     }
   });
 }
+export function readingTime(text, wordsPerMinute = 200) {
+  const words = text.split(" ").length;
+  const minutes = Math.ceil(words / wordsPerMinute);
+  return formatDurationLabels(minutes * 60);
+}

package/dist/runtime/utils/modifiers.d.ts

@@ -20,10 +20,12 @@ export declare function endWithout(text: string, end: string): string;
 export declare function surroundWith(text: string, start: string, end: string): string;
 /**
  * Adds plurals to a string except for excluded words.
+ * @info This handles most english pluralisation rules, but there are exceptions.
  */
 export declare function pluralize(value: string, count: number): string;
 /**
  * Removes plurals from a string.
+ * @info This handles most english pluralisation rules, but there are exceptions.
  */
 export declare function singularize(value: string): string;
 /**

package/dist/runtime/utils/modifiers.mjs

@@ -139,7 +139,7 @@ export function ordinalize(value) {
   return value + (suffixes[(remainder - 20) % 10] || suffixes[remainder] || suffixes[0]);
 }
 export function stripHtml(text) {
-  return text.replace(/<[^>]*>/gm, "");
+  return text.replace(/<\/?[^>]+(>|$)/g, "");
 }
 export function stripWhitespace(text) {
   return text.replace(/\s+/g, "");

package/dist/runtime/utils/numbers.d.ts

@@ -59,7 +59,6 @@ export declare function range(numbers: number[]): number;
  */
 export declare function standardDeviation(numbers: number[]): number;
 /**
- * Returns the measure of asymmetry of the probability distribution of an array of numbers.
- * The skewness value can be positive, zero, negative, or undefined.
+ * Returns the measure of asymmetry of the probability distribution of an array of numbers. The skewness value can be positive, zero, negative, or undefined.
  */
-export declare function skewness(numbers: number[]): number | undefined;
+export declare function skewness(numbers: number[]): number;

package/dist/runtime/utils/numbers.mjs

@@ -1,10 +1,16 @@
 export function sum(numbers) {
+  if (numbers.length === 0)
+    return 0;
   return numbers.reduce((a, b) => a + b, 0);
 }
 export function mean(numbers) {
+  if (numbers.length === 0)
+    return 0;
   return sum(numbers) / numbers.length;
 }
 export function average(numbers) {
+  if (numbers.length === 0)
+    return 0;
   return mean(numbers);
 }
 export function margin(value, percentage) {
@@ -63,7 +69,7 @@ export function skewness(numbers) {
   const n = numbers.length;
   const meanValue = mean(numbers);
   if (standardDeviation(numbers) === 0)
-    return void 0;
+    return 0;
   let sum2 = 0;
   for (const num of numbers)
     sum2 += (num - meanValue) ** 3;

package/dist/runtime/utils/validators.mjs

@@ -1,5 +1,5 @@
 export function isEmail(value) {
-  const regex = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$/;
+  const regex = /^(?!.*[._+-]{2})(?!.*[._+-]$)[a-zA-Z0-9._+-]+(?<!\.)@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
   return regex.test(value);
 }
 export function isNumber(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "usemods-nuxt",
-  "version": "0.0.22",
+  "version": "1.1.0",
   "description": "Zippy little modifiers and utilities for your Nuxt app.",
   "repository": {
     "type": "git",