@logtape/logtape 0.11.0-dev.175 → 0.12.0-dev.181

package/level.test.ts

@@ -0,0 +1,47 @@
+import { suite } from "@hongminhee/suite";
+import { assert } from "@std/assert/assert";
+import { assertEquals } from "@std/assert/equals";
+import { assertFalse } from "@std/assert/false";
+import { assertThrows } from "@std/assert/throws";
+import {
+  compareLogLevel,
+  isLogLevel,
+  type LogLevel,
+  parseLogLevel,
+} from "./level.ts";
+
+const test = suite(import.meta);
+
+test("parseLogLevel()", () => {
+  assertEquals(parseLogLevel("debug"), "debug");
+  assertEquals(parseLogLevel("info"), "info");
+  assertEquals(parseLogLevel("warning"), "warning");
+  assertEquals(parseLogLevel("error"), "error");
+  assertEquals(parseLogLevel("fatal"), "fatal");
+  assertEquals(parseLogLevel("DEBUG"), "debug");
+  assertEquals(parseLogLevel("INFO"), "info");
+  assertEquals(parseLogLevel("WARNING"), "warning");
+  assertEquals(parseLogLevel("ERROR"), "error");
+  assertEquals(parseLogLevel("FATAL"), "fatal");
+  assertThrows(
+    () => parseLogLevel("invalid"),
+    TypeError,
+    "Invalid log level: invalid.",
+  );
+});
+
+test("isLogLevel()", () => {
+  assert(isLogLevel("debug"));
+  assert(isLogLevel("info"));
+  assert(isLogLevel("warning"));
+  assert(isLogLevel("error"));
+  assert(isLogLevel("fatal"));
+  assertFalse(isLogLevel("DEBUG"));
+  assertFalse(isLogLevel("invalid"));
+});
+
+test("compareLogLevel()", () => {
+  const levels: LogLevel[] = ["info", "debug", "error", "warning", "fatal"];
+  levels.sort(compareLogLevel);
+  assertEquals(levels, ["debug", "info", "warning", "error", "fatal"]);
+});

package/level.ts

@@ -0,0 +1,67 @@
+const logLevels = ["debug", "info", "warning", "error", "fatal"] as const;
+
+/**
+ * The severity level of a {@link LogRecord}.
+ */
+export type LogLevel = typeof logLevels[number];
+
+/**
+ * Parses a log level from a string.
+ *
+ * @param level The log level as a string.  This is case-insensitive.
+ * @returns The log level.
+ * @throws {TypeError} If the log level is invalid.
+ */
+export function parseLogLevel(level: string): LogLevel {
+  level = level.toLowerCase();
+  switch (level) {
+    case "debug":
+    case "info":
+    case "warning":
+    case "error":
+    case "fatal":
+      return level;
+    default:
+      throw new TypeError(`Invalid log level: ${level}.`);
+  }
+}
+
+/**
+ * Checks if a string is a valid log level.  This function can be used as
+ * as a type guard to narrow the type of a string to a {@link LogLevel}.
+ *
+ * @param level The log level as a string.  This is case-sensitive.
+ * @returns `true` if the string is a valid log level.
+ */
+export function isLogLevel(level: string): level is LogLevel {
+  switch (level) {
+    case "debug":
+    case "info":
+    case "warning":
+    case "error":
+    case "fatal":
+      return true;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Compares two log levels.
+ * @param a The first log level.
+ * @param b The second log level.
+ * @returns A negative number if `a` is less than `b`, a positive number if `a`
+ *          is greater than `b`, or zero if they are equal.
+ * @since 0.8.0
+ */
+export function compareLogLevel(a: LogLevel, b: LogLevel): number {
+  const aIndex = logLevels.indexOf(a);
+  if (aIndex < 0) {
+    throw new TypeError(`Invalid log level: ${JSON.stringify(a)}.`);
+  }
+  const bIndex = logLevels.indexOf(b);
+  if (bIndex < 0) {
+    throw new TypeError(`Invalid log level: ${JSON.stringify(b)}.`);
+  }
+  return aIndex - bIndex;
+}