@ix-xs/node-comfort 1.1.31 → 2.0.0

package/types/src/Num.d.ts

@@ -0,0 +1,578 @@
+/**
+ * Options for `formatBytes()`.
+ */
+export type FormatBytesOptions = {
+    /**
+     * Maximum decimals. Defaults to `1`.
+     */
+    decimals?: number | undefined;
+    /**
+     * 1 KB is 1024 bytes when `true`, 1000 when `false`. Defaults to `true`.
+     */
+    binary?: boolean | undefined;
+    /**
+     * Use `KiB`, `MiB`, `GiB` labels.
+     */
+    iec?: boolean | undefined;
+    /**
+     * Formats the number for a language, like `"fr"` for `"1,5 KB"`.
+     */
+    locale?: string | undefined;
+    /**
+     * Your own labels from bytes up, like `["o", "Ko", "Mo", "Go", "To"]`.
+     */
+    units?: string[] | undefined;
+};
+/**
+ * Options for `parseBytes()`.
+ */
+export type ParseBytesOptions = {
+    /**
+     * 1 KB is 1024 bytes when `true`, 1000 when `false`. `KiB` units are always 1024. Defaults to `true`.
+     */
+    binary?: boolean | undefined;
+};
+/**
+ * Options for `format()`.
+ */
+export type FormatNumberOptions = {
+    /**
+     * Language, like `"fr"` or `"en-US"`. Defaults to the one set with `setLocale()`, or `"en"`.
+     */
+    locale?: string | undefined;
+    /**
+     * Exact number of decimals.
+     */
+    decimals?: number | undefined;
+    /**
+     * Minimum decimals.
+     */
+    minDecimals?: number | undefined;
+    /**
+     * Maximum decimals. Defaults to `3`.
+     */
+    maxDecimals?: number | undefined;
+    /**
+     * Short notation like `1.2K` or `3.4M`.
+     */
+    compact?: boolean | undefined;
+    /**
+     * `"percent"` multiplies by 100 and adds `%`.
+     */
+    style?: "decimal" | "percent" | undefined;
+    /**
+     * Any `Intl` unit: `"kilometer"`, `"celsius"`, `"megabyte"`...
+     */
+    unit?: string | undefined;
+    /**
+     * How the unit is written. Defaults to `"short"`.
+     */
+    unitDisplay?: "long" | "short" | "narrow" | undefined;
+    /**
+     * When to show the sign. `"exceptZero"` gives `+5`.
+     */
+    signDisplay?: "always" | "auto" | "never" | "exceptZero" | undefined;
+    /**
+     * Thousands separators. Defaults to `true`.
+     */
+    grouping?: boolean | undefined;
+};
+/**
+ * Options for `currency()`.
+ */
+export type CurrencyOptions = {
+    /**
+     * Language. Defaults to the one set with `setLocale()`, or `"en"`.
+     */
+    locale?: string | undefined;
+    /**
+     * Defaults to the currency's usual decimals (2 for EUR, 0 for JPY).
+     */
+    decimals?: number | undefined;
+    /**
+     * `€`, `€`, `EUR` or `euros`. Defaults to `"symbol"`.
+     */
+    display?: "symbol" | "code" | "name" | "narrowSymbol" | undefined;
+    /**
+     * Show negative amounts in parentheses, like `($5.00)`.
+     */
+    accounting?: boolean | undefined;
+};
+/**
+ * Options for `ordinal()`.
+ */
+export type OrdinalOptions = {
+    /**
+     * Built in: `en`, `fr`, `es`, `it`, `pt`, `de`, `nl`. Defaults to the one set with `setLocale()`, or `"en"`.
+     */
+    locale?: string | undefined;
+    /**
+     * Your own suffixes, for other languages.
+     */
+    suffixes?: Partial<Record<Intl.LDMLPluralRule, string>> | undefined;
+};
+/**
+ * Options for `variance()` and `stdDev()`.
+ */
+export type VarianceOptions = {
+    /**
+     * Sample statistic (divides by n - 1) instead of population.
+     */
+    sample?: boolean | undefined;
+};
+/**
+ * Sets the default language of `format`, `currency`, `percent`,
+ * `abbreviate`, `ordinal` and `formatBytes`.
+ *
+ * @example
+ * num.setLocale("fr");
+ * num.currency(1234.5, "EUR"); // "1 234,50 €"
+ *
+ * @param {string} locale Like `"fr"`, `"en-GB"` or `"pt-BR"`.
+ * @returns {typeof import("./Num")} The module, so calls chain.
+ */
+export function setLocale(locale: string): typeof import("./Num");
+/**
+ * The current default language.
+ *
+ * @example
+ * num.getLocale(); // "en"
+ *
+ * @returns {string}
+ */
+export function getLocale(): string;
+/**
+ * Keeps a number between `min` and `max`.
+ *
+ * @example
+ * num.clamp(150, 0, 100); // 100
+ * num.clamp(-5, 0, 100);  // 0
+ *
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export function clamp(value: number, min: number, max: number): number;
+/**
+ * Is the number between `min` and `max`, both included?
+ *
+ * @example
+ * num.inRange(10, 0, 10); // true
+ *
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @returns {boolean}
+ */
+export function inRange(value: number, min: number, max: number): boolean;
+/**
+ * Wraps a number around a range, like an angle or a carousel index.
+ * `max` is excluded.
+ *
+ * @example
+ * num.wrap(370, 0, 360); // 10
+ * num.wrap(-1, 0, 5);    // 4
+ *
+ * @param {number} value
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export function wrap(value: number, min: number, max: number): number;
+/**
+ * Rounds to `decimals` places without floating-point surprises:
+ * `Math.round(1.005 * 100) / 100` gives `1`, this gives `1.01`. Halves round
+ * away from zero, like in a spreadsheet.
+ *
+ * @example
+ * num.round(1.005, 2); // 1.01
+ * num.round(1234, -2); // 1200
+ * num.round(-2.5);     // -3
+ *
+ * @param {number} value
+ * @param {number} [decimals=0] Negative values round to tens, hundreds...
+ * @returns {number}
+ */
+export function round(value: number, decimals?: number): number;
+/**
+ * Rounds down to `decimals` places.
+ *
+ * @example
+ * num.floor(1.789, 2); // 1.78
+ *
+ * @param {number} value
+ * @param {number} [decimals=0]
+ * @returns {number}
+ */
+export function floor(value: number, decimals?: number): number;
+/**
+ * Rounds up to `decimals` places.
+ *
+ * @example
+ * num.ceil(1.231, 2); // 1.24
+ *
+ * @param {number} value
+ * @param {number} [decimals=0]
+ * @returns {number}
+ */
+export function ceil(value: number, decimals?: number): number;
+/**
+ * Rounds to the nearest multiple of `step`.
+ *
+ * @example
+ * num.snap(17, 5);        // 15
+ * num.snap(0.37, 0.25);   // 0.25
+ *
+ * @param {number} value
+ * @param {number} step
+ * @returns {number}
+ */
+export function snap(value: number, step: number): number;
+/**
+ * Are two numbers equal within a small tolerance? The right way to compare
+ * float results, since `0.1 + 0.2 === 0.3` is `false`.
+ *
+ * @example
+ * num.approxEqual(0.1 + 0.2, 0.3); // true
+ *
+ * @param {number} a
+ * @param {number} b
+ * @param {number} [epsilon=Number.EPSILON * 16] Allowed difference, relative to the size of the numbers.
+ * @returns {boolean}
+ */
+export function approxEqual(a: number, b: number, epsilon?: number): boolean;
+/**
+ * The value at ratio `t` between `start` and `end`.
+ *
+ * @example
+ * num.lerp(0, 100, 0.25); // 25
+ *
+ * @param {number} start
+ * @param {number} end
+ * @param {number} t Usually between 0 and 1.
+ * @returns {number}
+ */
+export function lerp(start: number, end: number, t: number): number;
+/**
+ * Moves a number from one range to another, keeping its relative position.
+ *
+ * @example
+ * num.mapRange(5, 0, 10, 0, 100); // 50
+ * num.mapRange(75, 0, 100, 1, 0); // 0.25
+ *
+ * @param {number} value
+ * @param {number} inMin
+ * @param {number} inMax
+ * @param {number} outMin
+ * @param {number} outMax
+ * @returns {number}
+ */
+export function mapRange(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+/**
+ * A random float from `min` (included) to `max` (excluded). Not for
+ * security: it uses `Math.random`.
+ *
+ * @example
+ * num.random(10, 20); // 13.84...
+ *
+ * @param {number} [min=0]
+ * @param {number} [max=1]
+ * @returns {number}
+ */
+export function random(min?: number, max?: number): number;
+/**
+ * A random integer from `min` to `max`, both included. Not for security.
+ *
+ * @example
+ * num.randomInt(1, 6); // a dice roll
+ *
+ * @param {number} min
+ * @param {number} max
+ * @returns {number}
+ */
+export function randomInt(min: number, max: number): number;
+/**
+ * Adds up numbers.
+ *
+ * @example
+ * num.sum([1, 2, 3]); // 6
+ *
+ * @param {Iterable<number>} values
+ * @returns {number}
+ */
+export function sum(values: Iterable<number>): number;
+/**
+ * The mean, or `0` for an empty list.
+ *
+ * @example
+ * num.average([2, 4, 9]); // 5
+ *
+ * @param {Iterable<number>} values
+ * @returns {number}
+ */
+export function average(values: Iterable<number>): number;
+/**
+ * The middle value once sorted, or `0` for an empty list.
+ *
+ * @example
+ * num.median([3, 1, 2]);    // 2
+ * num.median([1, 2, 3, 4]); // 2.5
+ *
+ * @param {Iterable<number>} values
+ * @returns {number}
+ */
+export function median(values: Iterable<number>): number;
+/**
+ * The most frequent values.
+ *
+ * @example
+ * num.mode([1, 1, 2, 2, 3]); // [1, 2]
+ *
+ * @param {Iterable<number>} values
+ * @returns {number[]}
+ */
+export function mode(values: Iterable<number>): number[];
+/**
+ * The variance: the average squared distance from the mean.
+ *
+ * @example
+ * num.variance([2, 4, 4, 4, 5, 5, 7, 9]); // 4
+ *
+ * @param {Iterable<number>} values
+ * @param {VarianceOptions} [options]
+ * @returns {number}
+ */
+export function variance(values: Iterable<number>, options?: VarianceOptions): number;
+/**
+ * The standard deviation.
+ *
+ * @example
+ * num.stdDev([2, 4, 4, 4, 5, 5, 7, 9]); // 2
+ *
+ * @param {Iterable<number>} values
+ * @param {VarianceOptions} [options]
+ * @returns {number}
+ */
+export function stdDev(values: Iterable<number>, options?: VarianceOptions): number;
+/**
+ * The value under which `p` percent of the values fall, interpolated like
+ * Excel's `PERCENTILE.INC`.
+ *
+ * @example
+ * num.percentile([1, 2, 3, 4, 5], 90); // 4.6
+ * num.percentile(responseTimes, 95);   // p95 latency
+ *
+ * @param {Iterable<number>} values
+ * @param {number} p From 0 to 100.
+ * @returns {number} `NaN` for an empty list.
+ */
+export function percentile(values: Iterable<number>, p: number): number;
+/**
+ * The smallest number. Unlike `Math.min(...array)`, huge arrays are fine.
+ *
+ * @param {Iterable<number>} values
+ * @returns {number | undefined} `undefined` for an empty list.
+ */
+export function min(values: Iterable<number>): number | undefined;
+/**
+ * The largest number. Unlike `Math.max(...array)`, huge arrays are fine.
+ *
+ * @param {Iterable<number>} values
+ * @returns {number | undefined} `undefined` for an empty list.
+ */
+export function max(values: Iterable<number>): number | undefined;
+/**
+ * What percentage `value` is of `total`. Returns `0` when `total` is `0`.
+ *
+ * @example
+ * num.percent(25, 200); // 12.5
+ * num.percent(1, 3, 1); // 33.3
+ *
+ * @param {number} value
+ * @param {number} total
+ * @param {number} [decimals=2]
+ * @returns {number}
+ */
+export function percent(value: number, total: number, decimals?: number): number;
+/**
+ * Greatest common divisor.
+ *
+ * @example
+ * num.gcd(12, 18, 27); // 3
+ *
+ * @param {...number} values
+ * @returns {number}
+ */
+export function gcd(...values: number[]): number;
+/**
+ * Least common multiple.
+ *
+ * @example
+ * num.lcm(2, 3, 4); // 12
+ *
+ * @param {...number} values
+ * @returns {number}
+ */
+export function lcm(...values: number[]): number;
+/**
+ * Is it a prime number?
+ *
+ * @example
+ * num.isPrime(7); // true
+ * num.isPrime(1); // false
+ *
+ * @param {number} value
+ * @returns {boolean}
+ */
+export function isPrime(value: number): boolean;
+/**
+ * `n!`. Pass `true` to get an exact bigint, since numbers lose precision
+ * past 18!.
+ *
+ * @example
+ * num.factorial(5);        // 120
+ * num.factorial(25, true); // 15511210043330985984000000n
+ *
+ * @param {number} n
+ * @param {boolean} [asBigInt=false]
+ * @returns {number | bigint}
+ * @throws {RangeError} If `n` is negative or not an integer.
+ */
+export function factorial(n: number, asBigInt?: boolean): number | bigint;
+/**
+ * Is it even?
+ *
+ * @param {number} value
+ * @returns {boolean}
+ */
+export function isEven(value: number): boolean;
+/**
+ * Is it odd? Negative numbers work too.
+ *
+ * @param {number} value
+ * @returns {boolean}
+ */
+export function isOdd(value: number): boolean;
+/**
+ * Numbers from `start` up to `end` (excluded). With one argument, counts
+ * from 0. Goes down when `end` is smaller.
+ *
+ * @example
+ * num.range(4);        // [0, 1, 2, 3]
+ * num.range(0, 10, 2); // [0, 2, 4, 6, 8]
+ * num.range(5, 0);     // [5, 4, 3, 2, 1]
+ *
+ * @param {number} start
+ * @param {number} [end]
+ * @param {number} [step] Defaults to `1`, or `-1` when counting down.
+ * @returns {number[]}
+ */
+export function range(start: number, end?: number, step?: number): number[];
+/**
+ * Reads a number from anything, ignoring trailing text like units.
+ *
+ * @example
+ * num.parse("42px");     // 42
+ * num.parse(" -3.5 kg"); // -3.5
+ * num.parse("nope", 0);  // 0
+ *
+ * @param {unknown} value
+ * @param {number} [fallback=NaN] Returned when there's no number to read.
+ * @returns {number}
+ */
+export function parse(value: unknown, fallback?: number): number;
+/**
+ * Turns a size like `"10 MB"` into bytes. The opposite of `formatBytes()`.
+ *
+ * @example
+ * num.parseBytes("1.5 KB");                   // 1536
+ * num.parseBytes("2 GiB");                    // 2147483648
+ * num.parseBytes("1 KB", { binary: false });  // 1000
+ *
+ * @param {string | number} value A size like `"512kb"` or `"1.5G"`, or a number of bytes.
+ * @param {ParseBytesOptions} [options]
+ * @returns {number} Bytes, or `NaN` if it can't be read.
+ */
+export function parseBytes(value: string | number, options?: ParseBytesOptions): number;
+/**
+ * Formats a byte count as a readable size.
+ *
+ * @example
+ * num.formatBytes(1536);                     // "1.5 KB"
+ * num.formatBytes(1000, { binary: false });  // "1 KB"
+ * num.formatBytes(1536, { locale: "fr", units: ["o", "Ko", "Mo", "Go"] }); // "1,5 Ko"
+ *
+ * @param {number} bytes
+ * @param {FormatBytesOptions} [options]
+ * @returns {string}
+ */
+export function formatBytes(bytes: number, options?: FormatBytesOptions): string;
+/**
+ * Formats a number for display, with `Intl.NumberFormat` doing the work:
+ * separators, decimals, compact notation, percentages, units.
+ *
+ * @example
+ * num.format(1234567.891);                   // "1,234,567.891"
+ * num.format(1234567.891, { locale: "fr" }); // "1 234 567,891"
+ * num.format(0.256, { style: "percent" });   // "26%"
+ * num.format(1500, { compact: true });       // "1.5K"
+ * num.format(3.5, { unit: "kilometer" });    // "3.5 km"
+ *
+ * @param {number | bigint} value
+ * @param {FormatNumberOptions} [options]
+ * @returns {string}
+ */
+export function format(value: number | bigint, options?: FormatNumberOptions): string;
+/**
+ * Formats an amount of money.
+ *
+ * @example
+ * num.currency(1234.5, "USD");                   // "$1,234.50"
+ * num.currency(1234.5, "EUR", { locale: "fr" }); // "1 234,50 €"
+ * num.currency(-5, "USD", { accounting: true }); // "($5.00)"
+ *
+ * @param {number | bigint} value
+ * @param {string} code A currency code like `"EUR"`, `"USD"` or `"JPY"`.
+ * @param {CurrencyOptions} [options]
+ * @returns {string}
+ */
+export function currency(value: number | bigint, code: string, options?: CurrencyOptions): string;
+/**
+ * Shortens big numbers with `K`, `M`, `B` or `T`. For other languages, use
+ * `format(value, { compact: true, locale })`.
+ *
+ * @example
+ * num.abbreviate(1500);      // "1.5K"
+ * num.abbreviate(2_400_000); // "2.4M"
+ *
+ * @param {number} value
+ * @param {number} [decimals=1]
+ * @returns {string}
+ */
+export function abbreviate(value: number, decimals?: number): string;
+/**
+ * Adds thousands separators, leaving decimals alone.
+ *
+ * @example
+ * num.thousands(1234567.89, " "); // "1 234 567.89"
+ *
+ * @param {number | string} value
+ * @param {string} [separator=","]
+ * @returns {string}
+ */
+export function thousands(value: number | string, separator?: string): string;
+/**
+ * Adds the ordinal suffix: 1st, 2nd, 3rd... in several languages.
+ *
+ * @example
+ * num.ordinal(22);                   // "22nd"
+ * num.ordinal(1, { locale: "fr" });  // "1er"
+ * num.ordinal(3, { locale: "de" });  // "3."
+ *
+ * @param {number} value
+ * @param {OrdinalOptions} [options]
+ * @returns {string}
+ */
+export function ordinal(value: number, options?: OrdinalOptions): string;
+//# sourceMappingURL=Num.d.ts.map

package/types/src/Num.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Num.d.ts","sourceRoot":"","sources":["../../src/Num.js"],"names":[],"mappings":"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"}