@logtape/logtape 1.1.4 → 1.1.6

package/src/filter.test.ts

@@ -1,84 +0,0 @@
-import { suite } from "@alinea/suite";
-import { assert } from "@std/assert/assert";
-import { assertFalse } from "@std/assert/false";
-import { assertStrictEquals } from "@std/assert/strict-equals";
-import { assertThrows } from "@std/assert/throws";
-import { type Filter, getLevelFilter, toFilter } from "./filter.ts";
-import { debug, error, fatal, info, trace, warning } from "./fixtures.ts";
-import type { LogLevel } from "./level.ts";
-
-const test = suite(import.meta);
-
-test("getLevelFilter()", () => {
-  const noneFilter = getLevelFilter(null);
-  assertFalse(noneFilter(fatal));
-  assertFalse(noneFilter(error));
-  assertFalse(noneFilter(warning));
-  assertFalse(noneFilter(info));
-  assertFalse(noneFilter(debug));
-  assertFalse(noneFilter(trace));
-
-  const fatalFilter = getLevelFilter("fatal");
-  assert(fatalFilter(fatal));
-  assertFalse(fatalFilter(error));
-  assertFalse(fatalFilter(warning));
-  assertFalse(fatalFilter(info));
-  assertFalse(fatalFilter(debug));
-  assertFalse(fatalFilter(trace));
-
-  const errorFilter = getLevelFilter("error");
-  assert(errorFilter(fatal));
-  assert(errorFilter(error));
-  assertFalse(errorFilter(warning));
-  assertFalse(errorFilter(info));
-  assertFalse(errorFilter(debug));
-  assertFalse(errorFilter(trace));
-
-  const warningFilter = getLevelFilter("warning");
-  assert(warningFilter(fatal));
-  assert(warningFilter(error));
-  assert(warningFilter(warning));
-  assertFalse(warningFilter(info));
-  assertFalse(warningFilter(debug));
-  assertFalse(warningFilter(trace));
-
-  const infoFilter = getLevelFilter("info");
-  assert(infoFilter(fatal));
-  assert(infoFilter(error));
-  assert(infoFilter(warning));
-  assert(infoFilter(info));
-  assertFalse(infoFilter(debug));
-  assertFalse(infoFilter(trace));
-
-  const debugFilter = getLevelFilter("debug");
-  assert(debugFilter(fatal));
-  assert(debugFilter(error));
-  assert(debugFilter(warning));
-  assert(debugFilter(info));
-  assert(debugFilter(debug));
-  assertFalse(debugFilter(trace));
-
-  const traceFilter = getLevelFilter("trace");
-  assert(traceFilter(fatal));
-  assert(traceFilter(error));
-  assert(traceFilter(warning));
-  assert(traceFilter(info));
-  assert(traceFilter(debug));
-  assert(traceFilter(trace));
-
-  assertThrows(
-    () => getLevelFilter("invalid" as LogLevel),
-    TypeError,
-    "Invalid log level: invalid.",
-  );
-});
-
-test("toFilter()", () => {
-  const hasJunk: Filter = (record) => record.category.includes("junk");
-  assertStrictEquals(toFilter(hasJunk), hasJunk);
-
-  const infoFilter = toFilter("info");
-  assertFalse(infoFilter(debug));
-  assert(infoFilter(info));
-  assert(infoFilter(warning));
-});

package/src/filter.ts

@@ -1,64 +0,0 @@
-import type { LogLevel } from "./level.ts";
-import type { LogRecord } from "./record.ts";
-
-/**
- * A filter is a function that accepts a log record and returns `true` if the
- * record should be passed to the sink.
- *
- * @param record The log record to filter.
- * @returns `true` if the record should be passed to the sink.
- */
-export type Filter = (record: LogRecord) => boolean;
-
-/**
- * A filter-like value is either a {@link Filter} or a {@link LogLevel}.
- * `null` is also allowed to represent a filter that rejects all records.
- */
-export type FilterLike = Filter | LogLevel | null;
-
-/**
- * Converts a {@link FilterLike} value to an actual {@link Filter}.
- *
- * @param filter The filter-like value to convert.
- * @returns The actual filter.
- */
-export function toFilter(filter: FilterLike): Filter {
-  if (typeof filter === "function") return filter;
-  return getLevelFilter(filter);
-}
-
-/**
- * Returns a filter that accepts log records with the specified level.
- *
- * @param level The level to filter by.  If `null`, the filter will reject all
- *              records.
- * @returns The filter.
- */
-export function getLevelFilter(level: LogLevel | null): Filter {
-  if (level == null) return () => false;
-  if (level === "fatal") {
-    return (record: LogRecord) => record.level === "fatal";
-  } else if (level === "error") {
-    return (record: LogRecord) =>
-      record.level === "fatal" || record.level === "error";
-  } else if (level === "warning") {
-    return (record: LogRecord) =>
-      record.level === "fatal" ||
-      record.level === "error" ||
-      record.level === "warning";
-  } else if (level === "info") {
-    return (record: LogRecord) =>
-      record.level === "fatal" ||
-      record.level === "error" ||
-      record.level === "warning" ||
-      record.level === "info";
-  } else if (level === "debug") {
-    return (record: LogRecord) =>
-      record.level === "fatal" ||
-      record.level === "error" ||
-      record.level === "warning" ||
-      record.level === "info" ||
-      record.level === "debug";
-  } else if (level === "trace") return () => true;
-  throw new TypeError(`Invalid log level: ${level}.`);
-}

package/src/fixtures.ts

@@ -1,35 +0,0 @@
-import type { LogRecord } from "./record.ts";
-
-export const info: LogRecord = {
-  level: "info",
-  category: ["my-app", "junk"],
-  message: ["Hello, ", 123, " & ", 456, "!"],
-  rawMessage: "Hello, {a} & {b}!",
-  timestamp: 1700000000000,
-  properties: {},
-};
-
-export const trace: LogRecord = {
-  ...info,
-  level: "trace",
-};
-
-export const debug: LogRecord = {
-  ...info,
-  level: "debug",
-};
-
-export const warning: LogRecord = {
-  ...info,
-  level: "warning",
-};
-
-export const error: LogRecord = {
-  ...info,
-  level: "error",
-};
-
-export const fatal: LogRecord = {
-  ...info,
-  level: "fatal",
-};