@stryke/string-format 0.1.3

package/dist/get-words.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Regular expression pattern to split strings into words for various case conversions
+ *
+ * This pattern matches sequences of characters in a string, considering the following case:
+ * - Sequences of two or more uppercase letters followed by an uppercase letter and lowercase letters or digits (for acronyms)
+ * - Sequences of one uppercase letter optionally followed by lowercase letters and digits
+ * - Single uppercase letters
+ * - Sequences of digits
+ *
+ * The resulting match can be used to convert camelCase, snake_case, kebab-case, and other mixed formats into
+ * a consistent format like snake case.
+ *
+ * @example
+ * const matches = 'camelCaseHTTPRequest'.match(CASE_SPLIT_PATTERN);
+ * // matches: ['camel', 'Case', 'HTTP', 'Request']
+ */
+export declare const CASE_SPLIT_PATTERN: RegExp;
+/**
+ * Splits a string into words using a regular expression pattern
+ *
+ * @example
+ * const words = getWords('camelCaseHTTPRequest');
+ * // words: ['camel', 'Case', 'HTTP', 'Request']
+ *
+ * @param str - The string to split into words
+ * @returns An array of words
+ */
+export declare function getWords(str: string): string[];

package/dist/get-words.mjs

@@ -0,0 +1 @@
+export const CASE_SPLIT_PATTERN=/[A-Z]?[a-z]+|\d+|[A-Z]+(?![a-z])/g;export function getWords(r){if(r.length>1e3)throw new Error("The regular expression parameter of `get-words` can't handle strings longer than 1000 characters");return[...r.match(CASE_SPLIT_PATTERN)??[]]}

package/dist/index.cjs

@@ -0,0 +1,214 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _acronyms = require("./acronyms.cjs");
+Object.keys(_acronyms).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _acronyms[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _acronyms[key];
+    }
+  });
+});
+var _camelCase = require("./camel-case.cjs");
+Object.keys(_camelCase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _camelCase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _camelCase[key];
+    }
+  });
+});
+var _constantCase = require("./constant-case.cjs");
+Object.keys(_constantCase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _constantCase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _constantCase[key];
+    }
+  });
+});
+var _deburr = require("./deburr.cjs");
+Object.keys(_deburr).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _deburr[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _deburr[key];
+    }
+  });
+});
+var _escape = require("./escape.cjs");
+Object.keys(_escape).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _escape[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _escape[key];
+    }
+  });
+});
+var _getWords = require("./get-words.cjs");
+Object.keys(_getWords).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _getWords[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _getWords[key];
+    }
+  });
+});
+var _kebabCase = require("./kebab-case.cjs");
+Object.keys(_kebabCase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _kebabCase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _kebabCase[key];
+    }
+  });
+});
+var _lowerCaseFirst = require("./lower-case-first.cjs");
+Object.keys(_lowerCaseFirst).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _lowerCaseFirst[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _lowerCaseFirst[key];
+    }
+  });
+});
+var _normalizeEmail = require("./normalize-email.cjs");
+Object.keys(_normalizeEmail).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _normalizeEmail[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _normalizeEmail[key];
+    }
+  });
+});
+var _pad = require("./pad.cjs");
+Object.keys(_pad).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pad[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pad[key];
+    }
+  });
+});
+var _pascalCase = require("./pascal-case.cjs");
+Object.keys(_pascalCase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _pascalCase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _pascalCase[key];
+    }
+  });
+});
+var _periodSplit = require("./period-split.cjs");
+Object.keys(_periodSplit).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _periodSplit[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _periodSplit[key];
+    }
+  });
+});
+var _prettyBytes = require("./pretty-bytes.cjs");
+Object.keys(_prettyBytes).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _prettyBytes[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _prettyBytes[key];
+    }
+  });
+});
+var _snakeCase = require("./snake-case.cjs");
+Object.keys(_snakeCase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _snakeCase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _snakeCase[key];
+    }
+  });
+});
+var _startCase = require("./start-case.cjs");
+Object.keys(_startCase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _startCase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _startCase[key];
+    }
+  });
+});
+var _stripIndents = require("./strip-indents.cjs");
+Object.keys(_stripIndents).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _stripIndents[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _stripIndents[key];
+    }
+  });
+});
+var _titleCase = require("./title-case.cjs");
+Object.keys(_titleCase).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _titleCase[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _titleCase[key];
+    }
+  });
+});
+var _unescape = require("./unescape.cjs");
+Object.keys(_unescape).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _unescape[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _unescape[key];
+    }
+  });
+});
+var _upperCaseFirst = require("./upper-case-first.cjs");
+Object.keys(_upperCaseFirst).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _upperCaseFirst[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _upperCaseFirst[key];
+    }
+  });
+});

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The string-format library used by Storm Software for building TypeScript applications.
+ *
+ * @remarks
+ * A collection of helper functions used to manipulate string values
+ *
+ * @packageDocumentation
+ */
+export * from "./acronyms";
+export * from "./camel-case";
+export * from "./constant-case";
+export * from "./deburr";
+export * from "./escape";
+export * from "./get-words";
+export * from "./kebab-case";
+export * from "./lower-case-first";
+export * from "./normalize-email";
+export * from "./pad";
+export * from "./pascal-case";
+export * from "./period-split";
+export * from "./pretty-bytes";
+export * from "./snake-case";
+export * from "./start-case";
+export * from "./strip-indents";
+export * from "./title-case";
+export * from "./unescape";
+export * from "./upper-case-first";

package/dist/index.mjs

@@ -0,0 +1 @@
+export*from"./acronyms";export*from"./camel-case";export*from"./constant-case";export*from"./deburr";export*from"./escape";export*from"./get-words";export*from"./kebab-case";export*from"./lower-case-first";export*from"./normalize-email";export*from"./pad";export*from"./pascal-case";export*from"./period-split";export*from"./pretty-bytes";export*from"./snake-case";export*from"./start-case";export*from"./strip-indents";export*from"./title-case";export*from"./unescape";export*from"./upper-case-first";

package/dist/kebab-case.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.kebabCase = void 0;
+var _types = require("@stryke/types");
+var _upperCaseFirst = require("./upper-case-first.cjs");
+const kebabCase = t => {
+  const e = t?.replace(/(?<temp1>[A-Z])+/g, r => (0, _upperCaseFirst.upperCaseFirst)(r) ?? _types.EMPTY_STRING)?.split(/(?=[A-Z])|[\s._-]/).map(r => r.toLowerCase()) ?? [];
+  return e.length === 0 ? "" : e.length === 1 ? e[0] : e.reduce((r, s) => `${r}-${s.toLowerCase()}`.toLowerCase());
+};
+exports.kebabCase = kebabCase;

package/dist/kebab-case.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Convert the input string to kebab case.
+ *
+ * @remarks
+ * "this-is-an-example"
+ *
+ * @param input - The input string.
+ * @returns The kebab-cased string.
+ */
+export declare const kebabCase: (input?: string) => string | undefined;

package/dist/kebab-case.mjs

@@ -0,0 +1 @@
+import{EMPTY_STRING as n}from"@stryke/types";import{upperCaseFirst as o}from"./upper-case-first";export const kebabCase=t=>{const e=t?.replace(/(?<temp1>[A-Z])+/g,r=>o(r)??n)?.split(/(?=[A-Z])|[\s._-]/).map(r=>r.toLowerCase())??[];return e.length===0?"":e.length===1?e[0]:e.reduce((r,s)=>`${r}-${s.toLowerCase()}`.toLowerCase())};

package/dist/lower-case-first.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.lowerCaseFirst = void 0;
+const lowerCaseFirst = e => e && e.charAt(0).toLowerCase() + e.slice(1);
+exports.lowerCaseFirst = lowerCaseFirst;

package/dist/lower-case-first.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Lower case the first character of an input string.
+ *
+ * @remarks
+ * "tHISISANEXAMPLE"
+ *
+ * @param input - The input string.
+ * @returns The lower-cased string.
+ */
+export declare const lowerCaseFirst: (input?: string) => string | undefined;

package/dist/lower-case-first.mjs

@@ -0,0 +1 @@
+export const lowerCaseFirst=e=>e&&e.charAt(0).toLowerCase()+e.slice(1);

package/dist/normalize-email.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.normalizeEmail = void 0;
+const l = /\./g;
+const normalizeEmail = e => {
+  if (!e.includes("@") && !e.includes("+")) throw new Error("invalid_email_format");
+  const o = e.split("@").filter(Boolean);
+  if (o.length > 1) throw new Error("invalid_email_format");
+  const [i, n] = o;
+  let [r] = i.split("+");
+  if (!r) throw new Error("invalid_email_format");
+  r = r.replace(l, "");
+  const t = r.toLowerCase() + "@" + n.toLowerCase();
+  return Number(t), t;
+};
+exports.normalizeEmail = normalizeEmail;

package/dist/normalize-email.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 1. Lower-cases whole email.
+ * 2. Removes dots ".".
+ * 3. Remotes name part after "+".
+ * 4. Throws if cannot parse the email.
+ *
+ * For example, this email
+ *
+ *     Michal.Loler+twitter\@Gmail.com
+ *
+ * will be normalized to
+ *
+ *     michalloler\@gmail.com
+ *
+ */
+export declare const normalizeEmail: (email: string) => string;

package/dist/normalize-email.mjs

@@ -0,0 +1 @@
+const l=/\./g;export const normalizeEmail=e=>{if(!e.includes("@")&&!e.includes("+"))throw new Error("invalid_email_format");const o=e.split("@").filter(Boolean);if(o.length>1)throw new Error("invalid_email_format");const[i,n]=o;let[r]=i.split("+");if(!r)throw new Error("invalid_email_format");r=r.replace(l,"");const t=r.toLowerCase()+"@"+n.toLowerCase();return Number(t),t};

package/dist/pad.cjs

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pad = pad;
+function pad(n, t, r = " ") {
+  return n.padStart(Math.floor((t - n.length) / 2) + n.length, r).padEnd(t, r);
+}

package/dist/pad.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Pads string on the left and right sides if it's shorter than length. Padding characters are truncated if they can't be evenly divided by length.
+ * If the length is less than or equal to the original string's length, or if the padding character is an empty string, the original string is returned unchanged.
+ *
+ * @param str - The string to pad.
+ * @param length - The length of the resulting string once padded.
+ * @param chars - The character(s) to use for padding.
+ * @returns The padded string, or the original string if padding is not required.
+ *
+ * @example
+ * ```ts
+ * const result1 = pad('abc', 8);         // result will be '  abc   '
+ * const result2 = pad('abc', 8, '_-');   // result will be '_-abc_-_'
+ * const result3 = pad('abc', 3);         // result will be 'abc'
+ * const result4 = pad('abc', 2);         // result will be 'abc'
+ * ```
+ */
+export declare function pad(str: string, length: number, chars?: string): string;

package/dist/pad.mjs

@@ -0,0 +1 @@
+export function pad(n,t,r=" "){return n.padStart(Math.floor((t-n.length)/2)+n.length,r).padEnd(t,r)}

package/dist/pascal-case.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.pascalCase = void 0;
+const pascalCase = e => e && e.split(" ").map(r => r.length > 0 ? r.trim().charAt(0).toUpperCase() + r.trim().slice(1) : "").join("");
+exports.pascalCase = pascalCase;

package/dist/pascal-case.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Convert the input string to pascal case.
+ *
+ *  @remarks
+ * "ThisIsAnExample"
+ *
+ * @param input - The input string.
+ * @returns The pascal-cased string.
+ */
+export declare const pascalCase: (input?: string) => string | undefined;

package/dist/pascal-case.mjs

@@ -0,0 +1 @@
+export const pascalCase=e=>e&&e.split(" ").map(r=>r.length>0?r.trim().charAt(0).toUpperCase()+r.trim().slice(1):"").join("");

package/dist/period-split.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.periodSplit = void 0;
+var _types = require("@stryke/types");
+var _upperCaseFirst = require("./upper-case-first.cjs");
+const periodSplit = e => {
+  const t = e?.replace(/(?<temp1>[A-Z])+/g, r => (0, _upperCaseFirst.upperCaseFirst)(r) ?? _types.EMPTY_STRING)?.split(/(?=[A-Z])|[\s._-]/).map(r => r.toLowerCase()) ?? [];
+  return t.length === 0 ? "" : t.length === 1 ? t[0] : t.reduce((r, n) => `${r}.${n.toLowerCase()}`.toLowerCase());
+};
+exports.periodSplit = periodSplit;

package/dist/period-split.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Make all characters lowercase and add a period in between each word
+ *
+ * @remarks
+ * "this.is.an.example"
+ *
+ * @param input - The input string.
+ * @returns The period-split string.
+ */
+export declare const periodSplit: (input?: string) => string | undefined;

package/dist/period-split.mjs

@@ -0,0 +1 @@
+import{EMPTY_STRING as s}from"@stryke/types";import{upperCaseFirst as i}from"./upper-case-first";export const periodSplit=e=>{const t=e?.replace(/(?<temp1>[A-Z])+/g,r=>i(r)??s)?.split(/(?=[A-Z])|[\s._-]/).map(r=>r.toLowerCase())??[];return t.length===0?"":t.length===1?t[0]:t.reduce((r,n)=>`${r}.${n.toLowerCase()}`.toLowerCase())};

package/dist/pretty-bytes.cjs

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.prettyBytes = prettyBytes;
+exports.toLocaleString = void 0;
+const u = ["B", "kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"],
+  B = ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"],
+  f = ["b", "kbit", "Mbit", "Gbit", "Tbit", "Pbit", "Ebit", "Zbit", "Ybit"],
+  y = ["b", "kibit", "Mibit", "Gibit", "Tibit", "Pibit", "Eibit", "Zibit", "Yibit"];
+const toLocaleString = (r, o, i = {}) => {
+  let t = r,
+    n = o;
+  return typeof n == "string" ? (n || (n = process.env.STORM_LOCALE || "en-US"), Array.isArray(n) && (t = r?.toLocaleString(n, i))) : (n === !0 || i !== void 0) && (t = r?.toLocaleString(void 0, i)), String(t);
+};
+exports.toLocaleString = toLocaleString;
+function prettyBytes(r, o) {
+  let i = r;
+  if (!Number.isFinite(i)) throw new TypeError(`Expected a finite number, got ${typeof i}: ${i}`);
+  const t = {
+      bits: !1,
+      binary: !1,
+      space: !0,
+      ...o
+    },
+    n = t.bits ? t.binary ? y : f : t.binary ? B : u,
+    a = t.space ? " " : "";
+  if (t.signed && i === 0) return ` 0${a}${n[0]}`;
+  const s = i < 0,
+    b = s ? "-" : t.signed ? "+" : "";
+  s && (i = -i);
+  let e;
+  if (t.minimumFractionDigits !== void 0 && (e = {
+    minimumFractionDigits: t.minimumFractionDigits
+  }), t.maximumFractionDigits !== void 0 && (e = {
+    maximumFractionDigits: t.maximumFractionDigits,
+    ...e
+  }), i < 1) {
+    const g = toLocaleString(i, t.locale, e);
+    return b + g + a + n[0];
+  }
+  const l = Math.min(Math.floor(t.binary ? Math.log(i) / Math.log(1024) : Math.log10(i) / 3), n.length - 1);
+  i /= (t.binary ? 1024 : 1e3) ** l, e || (i = i.toPrecision(3));
+  const c = toLocaleString(Number(i), t.locale, e),
+    m = n[l];
+  return b + c + a + m;
+}

package/dist/pretty-bytes.d.ts

@@ -0,0 +1,148 @@
+export interface Options {
+    /**
+     * Include plus sign for positive numbers. If the difference is exactly zero a space character will be prepended instead for better alignment.
+     *
+     * @defaultValue false
+     * */
+    readonly signed?: boolean;
+    /**
+     * - If `false`: Output won't be localized.
+     * - If `true`: Localize the output using the system/browser locale.
+     * - If `string`: Expects a [BCP 47 language tag](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)
+     * - If `string[]`: Expects a list of [BCP 47 language tags](https://en.wikipedia.org/wiki/IETF_language_tag) (For example: `en`, `de`, …)
+     *
+     * @defaultValue false
+     */
+    readonly locale?: boolean | string | readonly string[];
+    /**
+     * Format the number as [bits](https://en.wikipedia.org/wiki/Bit) instead of [bytes](https://en.wikipedia.org/wiki/Byte). This can be useful when, for example, referring to [bit rate](https://en.wikipedia.org/wiki/Bit_rate).
+     *
+     * @defaultValue false
+     *
+     * @example
+     * ```ts
+     * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
+     *
+     * prettyBytes(1337, {bits: true});
+     * //=> '1.34 kbit'
+     * ```
+     */
+    readonly bits?: boolean;
+    /**
+     * Format the number using the [Binary Prefix](https://en.wikipedia.org/wiki/Binary_prefix) instead of the [SI Prefix](https://en.wikipedia.org/wiki/SI_prefix). This can be useful for presenting memory amounts. However, this should not be used for presenting file sizes.
+     *
+     * @defaultValue false
+     *
+     * @example
+     * ```ts
+     * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
+     *
+     * prettyBytes(1000, {binary: true});
+     * //=> '1000 bit'
+     *
+     * prettyBytes(1024, {binary: true});
+     * //=> '1 kiB'
+     * ```
+     */
+    readonly binary?: boolean;
+    /**
+     * The minimum number of fraction digits to display.
+     *
+     * If neither `minimumFractionDigits` or `maximumFractionDigits` are set, the default behavior is to round to 3 significant digits.
+     *
+     * @defaultValue undefined
+     *
+     * @example
+     * ```ts
+     * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
+     *
+     * // Show the number with at least 3 fractional digits
+     * prettyBytes(1900, {minimumFractionDigits: 3});
+     * //=> '1.900 kB'
+     *
+     * prettyBytes(1900);
+     * //=> '1.9 kB'
+     * ```
+     */
+    readonly minimumFractionDigits?: number;
+    /**
+     * The maximum number of fraction digits to display.
+     *
+     * If neither `minimumFractionDigits` or `maximumFractionDigits` are set, the default behavior is to round to 3 significant digits.
+     *
+     * @defaultValue undefined
+     *
+     * @example
+     * ```ts
+     * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
+     *
+     * // Show the number with at most 1 fractional digit
+     * prettyBytes(1920, {maximumFractionDigits: 1});
+     * //=> '1.9 kB'
+     *
+     * prettyBytes(1920);
+     * //=> '1.92 kB'
+     * ```
+     */
+    readonly maximumFractionDigits?: number;
+    /**
+     * Put a space between the number and unit.
+     *
+     * @defaultValue true
+     *
+     * @example
+     * ```ts
+     * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
+     *
+     * prettyBytes(1920, {space: false});
+     * //=> '1.9kB'
+     *
+     * prettyBytes(1920);
+     * //=> '1.92 kB'
+     * ```
+     */
+    readonly space?: boolean;
+}
+/**
+ * Formats the given number using `Number#toLocaleString`.
+ *
+ * @remarks
+ * - If locale is a string, the value is expected to be a locale-key (for example: `de`).
+ * - If locale is true, the system default locale is used for translation.
+ * - If no value for locale is specified, the number is returned unmodified.
+ *
+ * @param number - The number to format.
+ * @param locale - The locale to use for formatting the number.
+ * @param options - The options to use for formatting the number.
+ * @returns The formatted number.
+ */
+export declare const toLocaleString: (number?: number | string, locale?: string | readonly string[] | boolean, options?: Options) => string;
+/**
+ * Convert bytes to a human readable string: `1337` → `1.34 kB`.
+ *
+ * @param number - The number to format.
+ *
+ * @example
+ * ```ts
+ * import { prettyBytes } from '@stryke/string-fns/pretty-bytes';
+ *
+ * prettyBytes(1337);
+ * //=> '1.34 kB'
+ *
+ * prettyBytes(100);
+ * //=> '100 B'
+ *
+ * // Display file size differences
+ * prettyBytes(42, {signed: true});
+ * //=> '+42 B'
+ *
+ * // Localized output using German locale
+ * prettyBytes(1337, {locale: 'de'});
+ * //=> '1,34 kB'
+ * ```
+ *
+ * @param number - The number to format.
+ * @param options - The options to use.
+ * @returns The formatted string.
+ */
+export declare function prettyBytes(number: number, options?: Options): string;

package/dist/pretty-bytes.mjs

@@ -0,0 +1 @@
+const u=["B","kB","MB","GB","TB","PB","EB","ZB","YB"],B=["B","KiB","MiB","GiB","TiB","PiB","EiB","ZiB","YiB"],f=["b","kbit","Mbit","Gbit","Tbit","Pbit","Ebit","Zbit","Ybit"],y=["b","kibit","Mibit","Gibit","Tibit","Pibit","Eibit","Zibit","Yibit"];export const toLocaleString=(r,o,i={})=>{let t=r,n=o;return typeof n=="string"?(n||(n=process.env.STORM_LOCALE||"en-US"),Array.isArray(n)&&(t=r?.toLocaleString(n,i))):(n===!0||i!==void 0)&&(t=r?.toLocaleString(void 0,i)),String(t)};export function prettyBytes(r,o){let i=r;if(!Number.isFinite(i))throw new TypeError(`Expected a finite number, got ${typeof i}: ${i}`);const t={bits:!1,binary:!1,space:!0,...o},n=t.bits?t.binary?y:f:t.binary?B:u,a=t.space?" ":"";if(t.signed&&i===0)return` 0${a}${n[0]}`;const s=i<0,b=s?"-":t.signed?"+":"";s&&(i=-i);let e;if(t.minimumFractionDigits!==void 0&&(e={minimumFractionDigits:t.minimumFractionDigits}),t.maximumFractionDigits!==void 0&&(e={maximumFractionDigits:t.maximumFractionDigits,...e}),i<1){const g=toLocaleString(i,t.locale,e);return b+g+a+n[0]}const l=Math.min(Math.floor(t.binary?Math.log(i)/Math.log(1024):Math.log10(i)/3),n.length-1);i/=(t.binary?1024:1e3)**l,e||(i=i.toPrecision(3));const c=toLocaleString(Number(i),t.locale,e),m=n[l];return b+c+a+m}