superjs-core 0.4.4 → 0.6.0

package/dist/isNoRekening-CHSpgD4P.d.ts

@@ -0,0 +1,167 @@
+/**
+ * Validates an Indonesian NIK (Nomor Induk Kependudukan / Resident Identity Number).
+ *
+ * A valid NIK:
+ * - Must be exactly 16 digits
+ * - Structure: PP CC DD DDMMYY SSSS
+ *   - PP: Province code (2 digits)
+ *   - CC: City code (2 digits)
+ *   - DD: District code (2 digits)
+ *   - DDMMYY: Birth date (6 digits; for women the day is incremented by 40)
+ *   - SSSS: Serial number (4 digits)
+ * - The birth date must correspond to a valid calendar date
+ *
+ * @param value - The NIK string (digits only or with dots)
+ * @returns `true` if the value is a valid NIK
+ *
+ * @example isNIK('3201010203940001') // => true (male, born 2 March 1994)
+ * @example isNIK('3201015203940001') // => true (female, born 12 March 1994)
+ * @example isNIK('1234567890123456') // => false (invalid birth date)
+ * @example isNIK('320101')          // => false (too short)
+ */
+declare function isNIK(value: string): boolean;
+
+/**
+ * Validates an Indonesian NPWP (Nomor Pokok Wajib Pajak / Tax Identification Number).
+ *
+ * A valid NPWP:
+ * - Must be 15 or 16 digits (formatted: `XX.XXX.XXX.X-XXX.XXX` or plain digits)
+ * - The last digit is a checksum computed from the preceding digits
+ *
+ * The checksum uses a weighted-sum algorithm with a repeating weight pattern of
+ * `[3, 7, 1]`. The computed checksum must equal the last digit.
+ *
+ * @param value - The NPWP string (formatted with dots & dash, or plain digits)
+ * @returns `true` if the value is a valid NPWP
+ *
+ * @example isNPWP('12.345.678.9-012.344') // => true
+ * @example isNPWP('123456789012344')      // => true (plain digits)
+ * @example isNPWP('12.345.678.9-012.345') // => false (invalid checksum)
+ */
+declare function isNPWP(value: string): boolean;
+
+/**
+ * Validates a phone number.
+ *
+ * For Indonesian numbers (`country = 'id'`):
+ * - Accepted formats: `08xx…`, `+628xx…`, `628xx…`
+ * - Must start with a valid operator prefix:
+ *   0811-0819, 0821-0829, 0851-0859, 0877-0879, 0895-0899
+ * - 10–13 digits after the country code
+ *
+ * For generic numbers (`country = 'any'`):
+ * - Any string with 10–15 digits is accepted
+ *
+ * @param value - The phone number string
+ * @param country - Country to validate against (`'id'` or `'any'`; default `'id'`)
+ * @returns `true` if the value is a valid phone number
+ *
+ * @example isPhone('08123456789')       // => true
+ * @example isPhone('+628123456789')     // => true
+ * @example isPhone('628123456789')      // => true
+ * @example isPhone('081234567')         // => false (too short)
+ * @example isPhone('089123456789')      // => false (invalid prefix 91)
+ */
+declare function isPhone(value: string, country?: 'id' | 'any'): boolean;
+
+/**
+ * RFC‑compliant email address validation.
+ *
+ * Validation rules:
+ * - Total length ≤ 254 characters
+ * - Local part ≤ 64 characters; supports quoted strings (including escaped
+ *   characters), unquoted letters / digits / `!#$%&'*+/=?^_`{|}~-`, and dots
+ *   (no leading, trailing, or consecutive dots)
+ * - Domain part ≤ 255 characters; valid DNS labels separated by dots, each
+ *   label ≤ 63 characters, no leading/trailing hyphens, at least two labels
+ *
+ * @param value - The email address string
+ * @returns `true` if the value is a syntactically valid email address
+ *
+ * @example isEmail('user@example.com')              // => true
+ * @example isEmail('user.name+tag@example.co.id')   // => true
+ * @example isEmail('"quoted@local"@example.com')    // => true
+ * @example isEmail('not-an-email')                  // => false
+ */
+declare function isEmail(value: string): boolean;
+
+/**
+ * Validates a URL.
+ *
+ * A valid URL:
+ * - Must use the `http` or `https` protocol
+ * - Must have a valid hostname (DNS name, IPv4, IPv6 literal, or `localhost`)
+ * - May include an optional port, path, query string, and fragment
+ *
+ * @param value - The URL string
+ * @returns `true` if the value is a valid http/https URL
+ *
+ * @example isURL('https://example.com')                 // => true
+ * @example isURL('http://example.com:8080/path?q=1#f')  // => true
+ * @example isURL('ftp://example.com')                   // => false
+ * @example isURL('not-a-url')                           // => false
+ */
+declare function isURL(value: string): boolean;
+
+/**
+ * Parse data dari NIK (Nomor Induk Kependudukan).
+ *
+ * @example parseNIK('3201010203940001')
+ * // { nik: '3201010203940001', valid: true, gender: 'LAKI-LAKI', birthDate: Date(1994-03-02), province: 'JAWA BARAT', city: 'BOGOR', district: 'CIAWI' }
+ *
+ * @example parseNIK('3201015203940001')
+ * // { nik: '3201015203940001', valid: true, gender: 'PEREMPUAN', birthDate: Date(1994-03-12), province: 'JAWA BARAT', ... }
+ */
+declare function parseNIK(value: string): NIKInfo;
+interface NIKInfo {
+    nik: string;
+    valid: boolean;
+    gender: 'LAKI-LAKI' | 'PEREMPUAN' | null;
+    birthDate: Date | null;
+    province: string | null;
+    provinceCode: string | null;
+    city: string | null;
+    cityCode: string | null;
+    district: string | null;
+    districtCode: string | null;
+    uniqueCode: string | null;
+}
+
+/**
+ * Validasi Plat Nomor Kendaraan Bermotor Indonesia.
+ *
+ * Format: [KODE_DEPAN] [ANGKA] [KODE_BELAKANG]
+ * - Kode depan: 1-2 huruf (kode daerah)
+ * - Angka: 1-4 digit
+ * - Kode belakang: 1-3 huruf (opsional)
+ *
+ * @example isPlatNomor('B 1234 CD') // true (Jakarta)
+ * @example isPlatNomor('AB 5678 XYZ') // true
+ * @example isPlatNomor('B 1 A') // true
+ * @example isPlatNomor('INVALID') // false
+ */
+declare function isPlatNomor(value: string): boolean;
+
+/**
+ * Validasi kode pos Indonesia.
+ * Kode pos Indonesia terdiri dari 5 digit angka.
+ *
+ * @example isKodepos('16110') // true (Bogor)
+ * @example isKodepos('12345') // true
+ * @example isKodepos('1234') // false (kurang)
+ * @example isKodepos('ABCDE') // false
+ */
+declare function isKodepos(value: string): boolean;
+
+/**
+ * Validasi nomor rekening bank Indonesia.
+ * Format: 8-16 digit angka (tergantung bank).
+ *
+ * @example isNoRekening('1234567890') // true (10 digit)
+ * @example isNoRekening('12345678') // true (8 digit - minimum)
+ * @example isNoRekening('1234567890123456') // true (16 digit - maksimum)
+ * @example isNoRekening('12345') // false (kurang dari 8 digit)
+ */
+declare function isNoRekening(value: string): boolean;
+
+export { type NIKInfo as N, isKodepos as a, isNIK as b, isNPWP as c, isNoRekening as d, isPhone as e, isPlatNomor as f, isURL as g, isEmail as i, parseNIK as p };

package/dist/math/index.d.ts

@@ -171,5 +171,192 @@ declare function formatCurrency(value: number, options?: {
     currency?: string;
     notation?: 'standard' | 'compact';
 }): string;
+/**
+ * Checks if a number is even.
+ *
+ * @example isEven(4) // true
+ * @example isEven(7) // false
+ *
+ * @param n - The number to check.
+ * @returns Whether the number is even.
+ */
+declare function isEven(n: number): boolean;
+/**
+ * Checks if a number is odd.
+ *
+ * @example isOdd(3) // true
+ * @example isOdd(8) // false
+ *
+ * @param n - The number to check.
+ * @returns Whether the number is odd.
+ */
+declare function isOdd(n: number): boolean;
+/**
+ * Computes the greatest common divisor (GCD) using the Euclidean algorithm.
+ *
+ * @example gcd(12, 8) // 4
+ * @example gcd(17, 5) // 1
+ *
+ * @param a - First integer.
+ * @param b - Second integer.
+ * @returns The GCD.
+ */
+declare function gcd(a: number, b: number): number;
+/**
+ * Computes the least common multiple (LCM).
+ *
+ * @example lcm(4, 6) // 12
+ * @example lcm(7, 5) // 35
+ *
+ * @param a - First integer.
+ * @param b - Second integer.
+ * @returns The LCM.
+ * @throws {RangeError} If either argument is zero.
+ */
+declare function lcm(a: number, b: number): number;
+/**
+ * Computes the factorial of a non-negative integer.
+ *
+ * @example factorial(5) // 120
+ * @example factorial(0) // 1
+ *
+ * @param n - Non-negative integer.
+ * @returns The factorial.
+ * @throws {RangeError} If n is negative or not an integer.
+ */
+declare function factorial(n: number): number;
+/**
+ * Tests whether a number is prime (optimized trial division).
+ *
+ * @example isPrime(7) // true
+ * @example isPrime(10) // false
+ *
+ * @param n - Positive integer.
+ * @returns Whether the number is prime.
+ * @throws {RangeError} If n is not an integer or is less than 2.
+ */
+declare function isPrime(n: number): boolean;
+/**
+ * Converts degrees to radians.
+ *
+ * @example toRadians(180) // ~3.14159
+ *
+ * @param degrees - Angle in degrees.
+ * @returns Angle in radians.
+ */
+declare function toRadians(degrees: number): number;
+/**
+ * Converts radians to degrees.
+ *
+ * @example toDegrees(Math.PI) // 180
+ *
+ * @param radians - Angle in radians.
+ * @returns Angle in degrees.
+ */
+declare function toDegrees(radians: number): number;
+/**
+ * Linearly interpolates between `a` and `b` by `t`.
+ *
+ * @example lerp(0, 100, 0.5) // 50
+ *
+ * @param a - Start value.
+ * @param b - End value.
+ * @param t - Interpolation factor (typically 0–1).
+ * @returns The interpolated value.
+ */
+declare function lerp(a: number, b: number, t: number): number;
+/**
+ * Calculates what percentage `value` is of `total`.
+ *
+ * @example percentageOf(25, 200) // 12.5
+ *
+ * @param value - The part value.
+ * @param total - The total value.
+ * @returns The percentage.
+ * @throws {RangeError} If total is zero.
+ */
+declare function percentageOf(value: number, total: number): number;
+/**
+ * Maps a value from one range to another.
+ *
+ * @example mapRange(0.5, 0, 1, 0, 100) // 50
+ *
+ * @param value - The value to map.
+ * @param inMin - Lower bound of the input range.
+ * @param inMax - Upper bound of the input range.
+ * @param outMin - Lower bound of the output range.
+ * @param outMax - Upper bound of the output range.
+ * @returns The mapped value.
+ * @throws {RangeError} If the input range is zero.
+ */
+declare function mapRange(value: number, inMin: number, inMax: number, outMin: number, outMax: number): number;
+/**
+ * Computes the statistical mode(s) — the most frequently occurring value(s).
+ *
+ * @example mode([1, 2, 2, 3]) // [2]
+ * @example mode([1, 1, 2, 2]) // [1, 2]
+ *
+ * @param values - Array of numbers.
+ * @returns Array of mode value(s).
+ * @throws {RangeError} If the array is empty.
+ */
+declare function mode(values: number[]): number[];
+/**
+ * Generates an array of numbers from `start` to `end` (inclusive),
+ * incremented by `step`.
+ *
+ * @example range(1, 5) // [1, 2, 3, 4, 5]
+ * @example range(0, 10, 2) // [0, 2, 4, 6, 8, 10]
+ *
+ * @param start - Start of the range.
+ * @param end - End of the range (inclusive).
+ * @param step - Increment (defaults to 1 or -1 based on direction).
+ * @returns Array of numbers.
+ * @throws {RangeError} If step is zero.
+ */
+declare function range(start: number, end: number, step?: number): number[];
+/**
+ * Computes the weighted mean of values with corresponding weights.
+ *
+ * @example weightedAverage([10, 20], [1, 4]) // 18
+ *
+ * @param values - Array of values.
+ * @param weights - Array of weights.
+ * @returns The weighted average.
+ * @throws {RangeError} If arrays are empty, differ in length, or sum of weights is zero.
+ */
+declare function weightedAverage(values: number[], weights: number[]): number;
+/**
+ * Computes the geometric mean of an array of numbers.
+ *
+ * @example geometricMean([4, 9]) // 6
+ *
+ * @param values - Array of positive numbers.
+ * @returns The geometric mean.
+ * @throws {RangeError} If the array is empty or contains negative values.
+ */
+declare function geometricMean(values: number[]): number;
+/**
+ * Computes the number of combinations (n choose k) — selecting k items from n without order.
+ *
+ * @example combinations(5, 2) // 10
+ *
+ * @param n - Total items.
+ * @param k - Chosen items.
+ * @returns The number of combinations.
+ * @throws {RangeError} If n < k, or either is negative / non-integer.
+ */
+declare function combinations(n: number, k: number): number;
+/**
+ * Computes the number of permutations — selecting k items from n in order.
+ *
+ * @example permutations(5, 2) // 20
+ *
+ * @param n - Total items.
+ * @param k - Chosen items.
+ * @returns The number of permutations.
+ * @throws {RangeError} If n < k, or either is negative / non-integer.
+ */
+declare function permutations(n: number, k: number): number;
 
-export { DivisionByZeroError, add, approxEqual, average, ceil, clamp, correlation, div, floor, formatCurrency, inRange, median, mul, percentile, randomInt, round, sampleStddev, stddev, sub, sum };
+export { DivisionByZeroError, add, approxEqual, average, ceil, clamp, combinations, correlation, div, factorial, floor, formatCurrency, gcd, geometricMean, inRange, isEven, isOdd, isPrime, lcm, lerp, mapRange, median, mode, mul, percentageOf, percentile, permutations, randomInt, range, round, sampleStddev, stddev, sub, sum, toDegrees, toRadians, weightedAverage };

package/dist/math/index.js

@@ -149,6 +149,187 @@ function formatCurrency(value, options) {
     return `${currency} ${value.toLocaleString(locale)}`;
   }
 }
+function isEven(n) {
+  return n % 2 === 0;
+}
+function isOdd(n) {
+  return n % 2 !== 0;
+}
+function gcd(a, b) {
+  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+    throw new RangeError("Arguments must be integers");
+  }
+  a = Math.abs(a);
+  b = Math.abs(b);
+  while (b !== 0) {
+    const t = b;
+    b = a % b;
+    a = t;
+  }
+  return a;
+}
+function lcm(a, b) {
+  if (!Number.isInteger(a) || !Number.isInteger(b)) {
+    throw new RangeError("Arguments must be integers");
+  }
+  if (a === 0 || b === 0) {
+    throw new RangeError("Arguments must be non-zero");
+  }
+  return Math.abs(a * b) / gcd(a, b);
+}
+function factorial(n) {
+  if (!Number.isInteger(n)) {
+    throw new RangeError("Argument must be an integer");
+  }
+  if (n < 0) {
+    throw new RangeError("Factorial is not defined for negative numbers");
+  }
+  let result = 1;
+  for (let i = 2; i <= n; i++) {
+    result *= i;
+  }
+  return result;
+}
+function isPrime(n) {
+  if (!Number.isInteger(n)) {
+    throw new RangeError("Argument must be an integer");
+  }
+  if (n < 2) return false;
+  if (n === 2 || n === 3) return true;
+  if (n % 2 === 0 || n % 3 === 0) return false;
+  const limit = Math.sqrt(n);
+  for (let i = 5; i <= limit; i += 6) {
+    if (n % i === 0 || n % (i + 2) === 0) return false;
+  }
+  return true;
+}
+function toRadians(degrees) {
+  return degrees * Math.PI / 180;
+}
+function toDegrees(radians) {
+  return radians * 180 / Math.PI;
+}
+function lerp(a, b, t) {
+  return a + (b - a) * t;
+}
+function percentageOf(value, total) {
+  if (total === 0) {
+    throw new RangeError("Total must be non-zero");
+  }
+  return value / total * 100;
+}
+function mapRange(value, inMin, inMax, outMin, outMax) {
+  if (inMin === inMax) {
+    throw new RangeError("Input range must not be zero");
+  }
+  return (value - inMin) / (inMax - inMin) * (outMax - outMin) + outMin;
+}
+function mode(values) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute mode of an empty array");
+  }
+  const freq = /* @__PURE__ */ new Map();
+  let maxFreq = 0;
+  for (const v of values) {
+    const count = (freq.get(v) ?? 0) + 1;
+    freq.set(v, count);
+    if (count > maxFreq) maxFreq = count;
+  }
+  const result = [];
+  for (const [v, count] of freq) {
+    if (count === maxFreq) result.push(v);
+  }
+  return result;
+}
+function range(start, end, step) {
+  const dir = end >= start ? 1 : -1;
+  const s = step ?? dir;
+  if (s === 0) {
+    throw new RangeError("Step must not be zero");
+  }
+  if ((end - start) * s < 0) {
+    return [];
+  }
+  const result = [];
+  let i = start;
+  if (s > 0) {
+    while (i <= end) {
+      result.push(i);
+      i += s;
+    }
+  } else {
+    while (i >= end) {
+      result.push(i);
+      i += s;
+    }
+  }
+  return result;
+}
+function weightedAverage(values, weights) {
+  if (values.length === 0 || weights.length === 0) {
+    throw new RangeError("Arrays must not be empty");
+  }
+  if (values.length !== weights.length) {
+    throw new RangeError("Values and weights must have the same length");
+  }
+  let weightedSum = 0;
+  let weightSum = 0;
+  for (let i = 0; i < values.length; i++) {
+    weightedSum += values[i] * weights[i];
+    weightSum += weights[i];
+  }
+  if (weightSum === 0) {
+    throw new RangeError("Sum of weights must be non-zero");
+  }
+  return weightedSum / weightSum;
+}
+function geometricMean(values) {
+  if (values.length === 0) {
+    throw new RangeError("Cannot compute geometric mean of an empty array");
+  }
+  for (const v of values) {
+    if (v < 0) {
+      throw new RangeError("Values must be non-negative for geometric mean");
+    }
+  }
+  const logSum = values.reduce((acc, v) => v === 0 ? acc : acc + Math.log(v), 0);
+  if (logSum === -Infinity) return 0;
+  return Math.exp(logSum / values.length);
+}
+function combinations(n, k) {
+  if (!Number.isInteger(n) || !Number.isInteger(k)) {
+    throw new RangeError("Arguments must be integers");
+  }
+  if (n < 0 || k < 0) {
+    throw new RangeError("Arguments must be non-negative");
+  }
+  if (k > n) {
+    throw new RangeError("k must not exceed n");
+  }
+  if (k === 0 || k === n) return 1;
+  const r = Math.min(k, n - k);
+  let result = 1;
+  for (let i = 1; i <= r; i++) {
+    result = result * (n - r + i) / i;
+  }
+  return result;
+}
+function permutations(n, k) {
+  if (!Number.isInteger(n) || !Number.isInteger(k)) {
+    throw new RangeError("Arguments must be integers");
+  }
+  if (n < 0 || k < 0) {
+    throw new RangeError("Arguments must be non-negative");
+  }
+  if (k > n) {
+    throw new RangeError("k must not exceed n");
+  }
+  let result = 1;
+  for (let i = n; i > n - k; i--) {
+    result *= i;
+  }
+  return result;
+}
 export {
   DivisionByZeroError,
   add,
@@ -156,19 +337,36 @@ export {
   average,
   ceil,
   clamp,
+  combinations,
   correlation,
   div,
+  factorial,
   floor,
   formatCurrency,
+  gcd,
+  geometricMean,
   inRange,
+  isEven,
+  isOdd,
+  isPrime,
+  lcm,
+  lerp,
+  mapRange,
   median,
+  mode,
   mul,
+  percentageOf,
   percentile,
+  permutations,
   randomInt,
+  range,
   round,
   sampleStddev,
   stddev,
   sub,
-  sum
+  sum,
+  toDegrees,
+  toRadians,
+  weightedAverage
 };
 //# sourceMappingURL=index.js.map