superjs-core 0.3.2 → 0.3.4

package/dist/index.js

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/core/index.ts
 function isPlainObject(value) {
   if (value === null || typeof value !== "object") return false;
@@ -302,7 +309,8 @@ function div(a, b) {
 }
 function round(value, precision = 0) {
   const factor = Math.pow(10, precision);
-  return Math.round(value * factor) / factor;
+  const shifted = Number((value * factor).toPrecision(15));
+  return Math.round(shifted) / factor;
 }
 function floor(value, precision = 0) {
   const factor = Math.pow(10, precision);
@@ -444,23 +452,20 @@ function parseDate(input) {
   }
   const dmyMatch = trimmed.match(/^(\d{1,2})[\/-](\d{1,2})[\/-](\d{4})$/);
   if (dmyMatch) {
-    const d = new Date(
-      parseInt(dmyMatch[3], 10),
-      parseInt(dmyMatch[2], 10) - 1,
-      parseInt(dmyMatch[1], 10)
-    );
-    if (!isNaN(d.getTime())) return d;
+    const year = parseInt(dmyMatch[3], 10);
+    const month = parseInt(dmyMatch[2], 10) - 1;
+    const day = parseInt(dmyMatch[1], 10);
+    const d = new Date(year, month, day);
+    if (!isNaN(d.getTime()) && d.getMonth() === month && d.getDate() === day) return d;
   }
   const textMatch = trimmed.match(/^(\d{1,2})\s+([a-zA-Z]+)\s+(\d{4})$/);
   if (textMatch) {
     const monthIndex = MONTH_MAP[textMatch[2].toLowerCase()];
     if (monthIndex !== void 0) {
-      const d = new Date(
-        parseInt(textMatch[3], 10),
-        monthIndex,
-        parseInt(textMatch[1], 10)
-      );
-      if (!isNaN(d.getTime())) return d;
+      const year = parseInt(textMatch[3], 10);
+      const day = parseInt(textMatch[1], 10);
+      const d = new Date(year, monthIndex, day);
+      if (!isNaN(d.getTime()) && d.getMonth() === monthIndex && d.getDate() === day) return d;
     }
   }
   const numMatch = trimmed.match(/^-?\d+$/);
@@ -1798,11 +1803,496 @@ async function analyzeUsage(projectPath, packageName) {
     importLocations
   };
 }
+
+// src/validation/isNIK.ts
+function isNIK(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length !== 16) return false;
+  const rawDay = Number.parseInt(digits.slice(6, 8), 10);
+  const month = Number.parseInt(digits.slice(8, 10), 10);
+  const year = Number.parseInt(digits.slice(10, 12), 10);
+  if (rawDay < 1 || rawDay > 71) return false;
+  if (month < 1 || month > 12) return false;
+  let day = rawDay;
+  if (day >= 41) day -= 40;
+  const fullYear = year < 70 ? 2e3 + year : 1900 + year;
+  const date = new Date(fullYear, month - 1, day);
+  return date.getFullYear() === fullYear && date.getMonth() === month - 1 && date.getDate() === day;
+}
+
+// src/validation/isNPWP.ts
+function isNPWP(value) {
+  const digits = value.replace(/\D/g, "");
+  if (digits.length !== 15 && digits.length !== 16) return false;
+  const nums = [];
+  for (let i = 0; i < digits.length; i++) {
+    nums.push(Number.parseInt(digits[i], 10));
+  }
+  const checkDigit = nums[nums.length - 1];
+  let sum2 = 0;
+  for (let i = 0; i < nums.length - 1; i++) {
+    sum2 += nums[i] * [3, 7, 1][i % 3];
+  }
+  const computed = (11 - sum2 % 11) % 10;
+  return computed === checkDigit;
+}
+
+// src/validation/isPhone.ts
+var INDONESIAN_PREFIXES = [
+  [11, 19],
+  [21, 29],
+  [51, 59],
+  [77, 79],
+  [95, 99]
+];
+function isValidIndonesianPrefix(prefix) {
+  for (const [min, max] of INDONESIAN_PREFIXES) {
+    if (prefix >= min && prefix <= max) return true;
+  }
+  return false;
+}
+function isPhone(value, country = "id") {
+  const digits = value.replace(/\D/g, "");
+  if (country === "any") {
+    return digits.length >= 10 && digits.length <= 15;
+  }
+  if (digits.length < 10) return false;
+  let normalized;
+  if (digits.startsWith("62")) {
+    normalized = digits.slice(2);
+  } else if (digits.startsWith("0")) {
+    normalized = digits.slice(1);
+  } else {
+    normalized = digits;
+  }
+  if (normalized.length < 10 || normalized.length > 13) return false;
+  if (!normalized.startsWith("8")) return false;
+  const prefix = Number.parseInt(normalized.slice(1, 3), 10);
+  return isValidIndonesianPrefix(prefix);
+}
+
+// src/validation/isEmail.ts
+var LOCAL_SPECIAL = "!#$%&'*+/=?^_`{|}~-";
+function isQuotedLocalPart(local) {
+  if (local.length < 2) return false;
+  let i = 1;
+  while (i < local.length - 1) {
+    const ch = local[i];
+    if (ch === "\\") {
+      i++;
+      if (i >= local.length - 1) return false;
+    } else if (ch === '"') {
+      return false;
+    }
+    i++;
+  }
+  return true;
+}
+function isUnquotedLocalPart(local) {
+  if (local.length === 0 || local.startsWith(".") || local.endsWith(".")) return false;
+  for (let i = 0; i < local.length; i++) {
+    const ch = local[i];
+    if (ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "." || LOCAL_SPECIAL.includes(ch)) {
+      continue;
+    }
+    return false;
+  }
+  for (let i = 1; i < local.length; i++) {
+    if (local[i] === "." && local[i - 1] === ".") return false;
+  }
+  return true;
+}
+function isValidDomain(domain) {
+  if (domain.length === 0 || domain.startsWith(".") || domain.endsWith(".")) return false;
+  const labels = domain.split(".");
+  if (labels.length < 2) return false;
+  for (const label of labels) {
+    if (label.length === 0 || label.length > 63) return false;
+    if (label.startsWith("-") || label.endsWith("-")) return false;
+    for (let i = 0; i < label.length; i++) {
+      const ch = label[i];
+      if (!(ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "-")) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isEmail(value) {
+  if (value.length > 254) return false;
+  const atIndex = value.lastIndexOf("@");
+  if (atIndex < 1 || atIndex === value.length - 1) return false;
+  const localPart = value.slice(0, atIndex);
+  const domainPart = value.slice(atIndex + 1);
+  if (localPart.length > 64) return false;
+  if (domainPart.length > 255) return false;
+  if (localPart.startsWith('"') && localPart.endsWith('"')) {
+    if (!isQuotedLocalPart(localPart)) return false;
+  } else {
+    if (!isUnquotedLocalPart(localPart)) return false;
+  }
+  return isValidDomain(domainPart);
+}
+
+// src/validation/isURL.ts
+var IPV4_OCTET = /^(?:[0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])$/;
+function isValidIPv4(hostname) {
+  const octets = hostname.split(".");
+  if (octets.length !== 4) return false;
+  return octets.every((octet) => IPV4_OCTET.test(octet));
+}
+function isValidDNSHostname(hostname) {
+  if (hostname.startsWith(".") || hostname.endsWith(".")) return false;
+  const labels = hostname.split(".");
+  if (labels.length < 2) return false;
+  for (const label of labels) {
+    if (label.length === 0 || label.length > 63) return false;
+    if (label.startsWith("-") || label.endsWith("-")) return false;
+    for (let i = 0; i < label.length; i++) {
+      const ch = label[i];
+      if (!(ch >= "a" && ch <= "z" || ch >= "A" && ch <= "Z" || ch >= "0" && ch <= "9" || ch === "-")) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isValidHostname(hostname) {
+  if (hostname.length === 0) return false;
+  if (hostname.startsWith("[") && hostname.endsWith("]")) {
+    return hostname.length > 2;
+  }
+  if (/^\d/.test(hostname) || /\d$/.test(hostname)) {
+    if (isValidIPv4(hostname)) return true;
+  }
+  if (hostname === "localhost") return true;
+  return isValidDNSHostname(hostname);
+}
+function isURL(value) {
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      return false;
+    }
+    return isValidHostname(url.hostname);
+  } catch {
+    return false;
+  }
+}
+
+// src/error/createError.ts
+var defaultStatus = {
+  "BAD_REQUEST": 400,
+  "UNAUTHORIZED": 401,
+  "FORBIDDEN": 403,
+  "NOT_FOUND": 404,
+  "CONFLICT": 409,
+  "VALIDATION_ERROR": 422,
+  "TOO_MANY": 429,
+  "INTERNAL": 500,
+  "BAD_GATEWAY": 502,
+  "UNAVAILABLE": 503
+};
+var TypedError = class extends Error {
+  code;
+  status;
+  details;
+  constructor(code, message, options) {
+    super(message, { cause: options?.cause });
+    this.name = "TypedError";
+    this.code = code;
+    this.status = options?.status ?? defaultStatus[code] ?? 500;
+    this.details = options?.details;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /**
+   * Serialize the error to a plain JSON-safe object.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      code: this.code,
+      status: this.status,
+      details: this.details,
+      cause: this.cause,
+      ...this.stack ? { stack: this.stack } : {}
+    };
+  }
+  toString() {
+    return `${this.name} [${this.code}]: ${this.message}`;
+  }
+};
+function createError(code, message, options) {
+  return new TypedError(code, message, options);
+}
+function isTypedError(error) {
+  return error instanceof TypedError;
+}
+
+// src/error/MultiError.ts
+var MultiError = class extends Error {
+  errors;
+  constructor(errors, message) {
+    const joined = errors.map((e) => e.message).join("; ");
+    super(message ?? joined);
+    this.name = "MultiError";
+    this.errors = [...errors];
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+  /** Number of collected errors. */
+  get length() {
+    return this.errors.length;
+  }
+  /**
+   * Check if any collected error satisfies `predicate`.
+   *
+   * @example
+   * ```ts
+   * if (err.some(e => e.message.includes('timeout'))) { … }
+   * ```
+   */
+  some(predicate) {
+    return this.errors.some(predicate);
+  }
+  /** Array of all error messages. */
+  get messages() {
+    return this.errors.map((e) => e.message);
+  }
+  /**
+   * Serialize to a plain JSON-safe object.
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      errors: this.errors.map((e) => ({
+        name: e.name,
+        message: e.message,
+        ...e.stack ? { stack: e.stack } : {}
+      })),
+      ...this.stack ? { stack: this.stack } : {}
+    };
+  }
+  toString() {
+    return `${this.name}: ${this.message}`;
+  }
+};
+function collectErrors(fn) {
+  try {
+    return { result: fn(), errors: [] };
+  } catch (err) {
+    return {
+      errors: [err instanceof Error ? err : new Error(String(err))]
+    };
+  }
+}
+
+// src/logger/logger.ts
+var LEVEL_ORDER = { debug: 0, info: 1, warn: 2, error: 3 };
+var Logger = class _Logger {
+  _level;
+  _name;
+  _transport;
+  _extraMeta;
+  constructor(options) {
+    this._level = options?.level ?? "info";
+    this._name = options?.name;
+    this._transport = options?.transport ?? consoleTransport;
+    this._extraMeta = /* @__PURE__ */ Object.create(null);
+  }
+  _shouldLog(target) {
+    return LEVEL_ORDER[this._level] <= LEVEL_ORDER[target];
+  }
+  _log(level, message, meta) {
+    if (level !== "error" && !this._shouldLog(level)) return;
+    const merged = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(this._extraMeta)) {
+      merged[key] = this._extraMeta[key];
+    }
+    if (meta !== void 0) {
+      for (const key of Object.keys(meta)) {
+        merged[key] = meta[key];
+      }
+    }
+    const label = this._name !== void 0 ? `[${this._name}] ${message}` : message;
+    const finalMeta = Object.keys(merged).length > 0 ? merged : void 0;
+    this._transport.log(level, label, finalMeta);
+  }
+  /** Log at `debug` level. Only emitted when the current level is `'debug'`. */
+  debug = (message, meta) => this._log("debug", message, meta);
+  /** Log at `info` level. Emitted when level is `'debug'` or `'info'`. */
+  info = (message, meta) => this._log("info", message, meta);
+  /** Log at `warn` level. Emitted when level is `'debug'`, `'info'`, or `'warn'`. */
+  warn = (message, meta) => this._log("warn", message, meta);
+  /** Log at `error` level. Always emitted regardless of current level. */
+  error = (message, meta) => this._log("error", message, meta);
+  /**
+   * Creates a child logger that inherits the parent's level, name, and transport,
+   * but merges `extraMeta` into every log call. Child metadata is shallow-merged
+   * on top of the parent's inherited metadata.
+   *
+   * @param extraMeta - Additional context to include in every log entry.
+   */
+  child(extraMeta) {
+    const child = new _Logger({
+      level: this._level,
+      name: this._name,
+      transport: this._transport
+    });
+    const inherited = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(this._extraMeta)) {
+      inherited[key] = this._extraMeta[key];
+    }
+    for (const key of Object.keys(extraMeta)) {
+      inherited[key] = extraMeta[key];
+    }
+    child._extraMeta = inherited;
+    return child;
+  }
+  /** Updates the minimum log level for this instance. */
+  setLevel(level) {
+    this._level = level;
+  }
+  /** Returns the current minimum log level. */
+  getLevel() {
+    return this._level;
+  }
+  /**
+   * Creates a new named Logger.
+   * Convenience shorthand for `new Logger({ ...options, name })`.
+   *
+   * @param name - The name tag shown in log output.
+   * @param options - Additional configuration.
+   */
+  static create(name, options) {
+    return new _Logger({ ...options, name });
+  }
+};
+var consoleTransport = {
+  log(level, message, meta) {
+    const metaStr = meta !== void 0 && Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
+    console.log(`[${level.toUpperCase()}] ${message}${metaStr}`);
+  }
+};
+var logger = new Logger();
+
+// src/logger/transports.ts
+var LEVEL_COLORS = {
+  debug: "\x1B[90m",
+  info: "\x1B[34m",
+  warn: "\x1B[33m",
+  error: "\x1B[31m"
+};
+var RESET = "\x1B[0m";
+function createConsoleTransport(options) {
+  const useColors = options?.colors !== false;
+  const showTimestamp = options?.timestamp ?? false;
+  return {
+    log(level, message, meta) {
+      const parts = [];
+      if (showTimestamp) {
+        parts.push((/* @__PURE__ */ new Date()).toISOString());
+      }
+      if (useColors) {
+        const color = LEVEL_COLORS[level];
+        parts.push(`${color}[${level.toUpperCase()}]${RESET}`);
+      } else {
+        parts.push(`[${level.toUpperCase()}]`);
+      }
+      parts.push(message);
+      if (meta !== void 0 && Object.keys(meta).length > 0) {
+        parts.push(JSON.stringify(meta));
+      }
+      console.log(parts.join(" "));
+    }
+  };
+}
+function createJsonTransport(options) {
+  const writeStream = options?.stream ?? (typeof process !== "undefined" && typeof process.stdout !== "undefined" && typeof process.stdout.write === "function" ? process.stdout : void 0);
+  return {
+    log(level, message, meta) {
+      const entry = {
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        message
+      };
+      if (meta !== void 0 && Object.keys(meta).length > 0) {
+        entry.meta = meta;
+      }
+      const line = JSON.stringify(entry);
+      if (writeStream !== void 0) {
+        writeStream.write(line + "\n");
+      } else {
+        console.log(line);
+      }
+    }
+  };
+}
+function createFileTransport(filename, _options) {
+  let fs = null;
+  try {
+    if (typeof process !== "undefined" && process.versions?.node) {
+      const m = __require("fs");
+      fs = m;
+    }
+  } catch {
+  }
+  return {
+    log(level, message, meta) {
+      if (fs === null) return;
+      const metaStr = meta !== void 0 && Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : "";
+      const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [${level.toUpperCase()}] ${message}${metaStr}
+`;
+      try {
+        fs.appendFileSync(filename, line);
+      } catch {
+      }
+    }
+  };
+}
+function createBufferedTransport(transport, options) {
+  const maxSize = options?.maxSize ?? 100;
+  const flushIntervalMs = options?.flushIntervalMs ?? 5e3;
+  const buffer = [];
+  let timer;
+  function flush() {
+    if (timer !== void 0) {
+      clearTimeout(timer);
+      timer = void 0;
+    }
+    for (let i = 0; i < buffer.length; i++) {
+      const entry = buffer[i];
+      transport.log(entry.level, entry.message, entry.meta);
+    }
+    buffer.length = 0;
+  }
+  function scheduleFlush() {
+    if (timer !== void 0 || flushIntervalMs <= 0) return;
+    timer = setTimeout(() => {
+      timer = void 0;
+      flush();
+    }, flushIntervalMs);
+  }
+  return {
+    log(level, message, meta) {
+      buffer.push({ level, message, meta });
+      if (buffer.length >= maxSize) {
+        flush();
+      } else {
+        scheduleFlush();
+      }
+    }
+  };
+}
 export {
   DivisionByZeroError,
   InvalidDateError,
   KNOWN_CVES,
   KNOWN_MAPPINGS,
+  Logger,
+  MultiError,
+  TypedError,
   add,
   addBusinessDays,
   addDays,
@@ -1825,8 +2315,15 @@ export {
   checksum,
   chunk,
   clamp,
+  collectErrors,
+  consoleTransport,
   constantTimeEqual,
   countOccurrences,
+  createBufferedTransport,
+  createConsoleTransport,
+  createError,
+  createFileTransport,
+  createJsonTransport,
   dateDiff,
   debounce,
   deepClone,
@@ -1864,24 +2361,31 @@ export {
   isBoolean,
   isBusinessDay,
   isDate,
+  isEmail,
   isEmpty,
   isFunction,
   isLeapYear,
   isMap,
+  isNIK,
+  isNPWP,
   isNil,
   isNull,
   isNumber,
   isObject,
+  isPhone,
   isPromise,
   isRegExp,
   isSet,
   isString,
+  isTypedError,
+  isURL,
   isUndefined,
   isWeekend,
   join,
   kebabCase,
   keyBy,
   last,
+  logger,
   memoize,
   mul,
   nanoid,