@logtape/file 0.9.0-dev.134 → 0.9.1-dev.151

package/script/logtape/sink.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withFilter = withFilter;
-exports.getStreamSink = getStreamSink;
-exports.getConsoleSink = getConsoleSink;
-const filter_js_1 = require("./filter.js");
-const formatter_js_1 = require("./formatter.js");
-/**
- * Turns a sink into a filtered sink.  The returned sink only logs records that
- * pass the filter.
- *
- * @example Filter a console sink to only log records with the info level
- * ```typescript
- * const sink = withFilter(getConsoleSink(), "info");
- * ```
- *
- * @param sink A sink to be filtered.
- * @param filter A filter to apply to the sink.  It can be either a filter
- *               function or a {@link LogLevel} string.
- * @returns A sink that only logs records that pass the filter.
- */
-function withFilter(sink, filter) {
-    const filterFunc = (0, filter_js_1.toFilter)(filter);
-    return (record) => {
-        if (filterFunc(record))
-            sink(record);
-    };
-}
-/**
- * A factory that returns a sink that writes to a {@link WritableStream}.
- *
- * Note that the `stream` is of Web Streams API, which is different from
- * Node.js streams.  You can convert a Node.js stream to a Web Streams API
- * stream using [`stream.Writable.toWeb()`] method.
- *
- * [`stream.Writable.toWeb()`]: https://nodejs.org/api/stream.html#streamwritabletowebstreamwritable
- *
- * @example Sink to the standard error in Deno
- * ```typescript
- * const stderrSink = getStreamSink(Deno.stderr.writable);
- * ```
- *
- * @example Sink to the standard error in Node.js
- * ```typescript
- * import stream from "node:stream";
- * const stderrSink = getStreamSink(stream.Writable.toWeb(process.stderr));
- * ```
- *
- * @param stream The stream to write to.
- * @param options The options for the sink.
- * @returns A sink that writes to the stream.
- */
-function getStreamSink(stream, options = {}) {
-    const formatter = options.formatter ?? formatter_js_1.defaultTextFormatter;
-    const encoder = options.encoder ?? new TextEncoder();
-    const writer = stream.getWriter();
-    let lastPromise = Promise.resolve();
-    const sink = (record) => {
-        const bytes = encoder.encode(formatter(record));
-        lastPromise = lastPromise
-            .then(() => writer.ready)
-            .then(() => writer.write(bytes));
-    };
-    sink[Symbol.asyncDispose] = async () => {
-        await lastPromise;
-        await writer.close();
-    };
-    return sink;
-}
-/**
- * A console sink factory that returns a sink that logs to the console.
- *
- * @param options The options for the sink.
- * @returns A sink that logs to the console.
- */
-function getConsoleSink(options = {}) {
-    const formatter = options.formatter ?? formatter_js_1.defaultConsoleFormatter;
-    const levelMap = {
-        debug: "debug",
-        info: "info",
-        warning: "warn",
-        error: "error",
-        fatal: "error",
-        ...(options.levelMap ?? {}),
-    };
-    const console = options.console ?? globalThis.console;
-    return (record) => {
-        const args = formatter(record);
-        const method = levelMap[record.level];
-        if (method === undefined) {
-            throw new TypeError(`Invalid log level: ${record.level}.`);
-        }
-        if (typeof args === "string") {
-            const msg = args.replace(/\r?\n$/, "");
-            console[method](msg);
-        }
-        else {
-            console[method](...args);
-        }
-    };
-}

package/types/_dnt.shims.d.ts

@@ -1,2 +0,0 @@
-export declare const dntGlobalThis: Omit<typeof globalThis, never>;
-//# sourceMappingURL=_dnt.shims.d.ts.map

package/types/_dnt.shims.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/types/logtape/config.d.ts

@@ -1,183 +0,0 @@
-import type { ContextLocalStorage } from "./context.js";
-import { type FilterLike } from "./filter.js";
-import type { LogLevel } from "./level.js";
-import { type Sink } from "./sink.js";
-/**
- * A configuration for the loggers.
- */
-export interface Config<TSinkId extends string, TFilterId extends string> {
-    /**
-     * The sinks to use.  The keys are the sink identifiers, and the values are
-     * {@link Sink}s.
-     */
-    sinks: Record<TSinkId, Sink>;
-    /**
-     * The filters to use.  The keys are the filter identifiers, and the values
-     * are either {@link Filter}s or {@link LogLevel}s.
-     */
-    filters?: Record<TFilterId, FilterLike>;
-    /**
-     * The loggers to configure.
-     */
-    loggers: LoggerConfig<TSinkId, TFilterId>[];
-    /**
-     * The context-local storage to use for implicit contexts.
-     * @since 0.7.0
-     */
-    contextLocalStorage?: ContextLocalStorage<Record<string, unknown>>;
-    /**
-     * Whether to reset the configuration before applying this one.
-     */
-    reset?: boolean;
-}
-/**
- * A logger configuration.
- */
-export interface LoggerConfig<TSinkId extends string, TFilterId extends string> {
-    /**
-     * The category of the logger.  If a string, it is equivalent to an array
-     * with one element.
-     */
-    category: string | string[];
-    /**
-     * The sink identifiers to use.
-     */
-    sinks?: TSinkId[];
-    /**
-     * Whether to inherit the parent's sinks.  If `inherit`, the parent's sinks
-     * are used along with the specified sinks.  If `override`, the parent's
-     * sinks are not used, and only the specified sinks are used.
-     *
-     * The default is `inherit`.
-     * @default `"inherit"
-     * @since 0.6.0
-     */
-    parentSinks?: "inherit" | "override";
-    /**
-     * The filter identifiers to use.
-     */
-    filters?: TFilterId[];
-    /**
-     * The log level to filter by.  If `null`, the logger will reject all
-     * records.
-     * @deprecated Use `filters` instead for backward compatibility, or use
-     *             `lowestLevel` for less-misleading behavior.
-     */
-    level?: LogLevel | null;
-    /**
-     * The lowest log level to accept.  If `null`, the logger will reject all
-     * records.
-     * @since 0.8.0
-     */
-    lowestLevel?: LogLevel | null;
-}
-/**
- * Configure the loggers with the specified configuration.
- *
- * Note that if the given sinks or filters are disposable, they will be
- * disposed when the configuration is reset, or when the process exits.
- *
- * @example
- * ```typescript
- * await configure({
- *   sinks: {
- *     console: getConsoleSink(),
- *   },
- *   filters: {
- *     slow: (log) =>
- *       "duration" in log.properties &&
- *       log.properties.duration as number > 1000,
- *   },
- *   loggers: [
- *     {
- *       category: "my-app",
- *       sinks: ["console"],
- *       level: "info",
- *     },
- *     {
- *       category: ["my-app", "sql"],
- *       filters: ["slow"],
- *       level: "debug",
- *     },
- *     {
- *       category: "logtape",
- *       sinks: ["console"],
- *       level: "error",
- *     },
- *   ],
- * });
- * ```
- *
- * @param config The configuration.
- */
-export declare function configure<TSinkId extends string, TFilterId extends string>(config: Config<TSinkId, TFilterId>): Promise<void>;
-/**
- * Configure sync loggers with the specified configuration.
- *
- * Note that if the given sinks or filters are disposable, they will be
- * disposed when the configuration is reset, or when the process exits.
- *
- * Also note that passing async sinks or filters will throw. If
- * necessary use {@link resetSync} or {@link disposeSync}.
- *
- * @example
- * ```typescript
- * configureSync({
- *   sinks: {
- *     console: getConsoleSink(),
- *   },
- *   loggers: [
- *     {
- *       category: "my-app",
- *       sinks: ["console"],
- *       level: "info",
- *     },
- *     {
- *       category: "logtape",
- *       sinks: ["console"],
- *       level: "error",
- *     },
- *   ],
- * });
- * ```
- *
- * @param config The configuration.
- * @since 0.9.0
- */
-export declare function configureSync<TSinkId extends string, TFilterId extends string>(config: Config<TSinkId, TFilterId>): void;
-/**
- * Get the current configuration, if any.  Otherwise, `null`.
- * @returns The current configuration, if any.  Otherwise, `null`.
- */
-export declare function getConfig(): Config<string, string> | null;
-/**
- * Reset the configuration.  Mostly for testing purposes.
- */
-export declare function reset(): Promise<void>;
-/**
- * Reset the configuration.  Mostly for testing purposes. Will not clear async
- * sinks, only use with sync sinks. Use {@link reset} if you have async sinks.
- * @since 0.9.0
- */
-export declare function resetSync(): void;
-/**
- * Dispose of the disposables.
- */
-export declare function dispose(): Promise<void>;
-/**
- * Dispose of the sync disposables. Async disposables will be untouched,
- * use {@link dispose} if you have async sinks.
- * @since 0.9.0
- */
-export declare function disposeSync(): void;
-/**
- * A configuration error.
- */
-export declare class ConfigError extends Error {
-    /**
-     * Constructs a new configuration error.
-     * @param message The error message.
-     */
-    constructor(message: string);
-}
-//# sourceMappingURL=config.d.ts.map

package/types/logtape/config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/logtape/config.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,KAAK,UAAU,EAAY,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,EAAkB,KAAK,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,MAAM,CAAC,OAAO,SAAS,MAAM,EAAE,SAAS,SAAS,MAAM;IACtE;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IAC7B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,CAAC;IAExC;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,CAAC;IAE5C;;;OAGG;IACH,mBAAmB,CAAC,EAAE,mBAAmB,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAEnE;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY,CAC3B,OAAO,SAAS,MAAM,EACtB,SAAS,SAAS,MAAM;IAExB;;;OAGG;IACH,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IAE5B;;OAEG;IACH,KAAK,CAAC,EAAE,OAAO,EAAE,CAAC;IAElB;;;;;;;;OAQG;IACH,WAAW,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IAErC;;OAEG;IACH,OAAO,CAAC,EAAE,SAAS,EAAE,CAAC;IAEtB;;;;;OAKG;IACH,KAAK,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;IAExB;;;;OAIG;IACH,WAAW,CAAC,EAAE,QAAQ,GAAG,IAAI,CAAC;CAC/B;AAqCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAsB,SAAS,CAC7B,OAAO,SAAS,MAAM,EACtB,SAAS,SAAS,MAAM,EACxB,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAanD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAAC,OAAO,SAAS,MAAM,EAAE,SAAS,SAAS,MAAM,EAC5E,MAAM,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,CAAC,GACjC,IAAI,CAmBN;AAuGD;;;GAGG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAEzD;AAED;;GAEG;AACH,wBAAsB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAG3C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,IAAI,IAAI,CAGhC;AAUD;;GAEG;AACH,wBAAsB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CAQ7C;AAED;;;;GAIG;AACH,wBAAgB,WAAW,IAAI,IAAI,CAGlC;AAED;;GAEG;AACH,qBAAa,WAAY,SAAQ,KAAK;IACpC;;;OAGG;gBACS,OAAO,EAAE,MAAM;CAI5B"}

package/types/logtape/context.d.ts

@@ -1,35 +0,0 @@
-/**
- * A generic interface for a context-local storage.  It resembles
- * the {@link AsyncLocalStorage} API from Node.js.
- * @typeParam T The type of the context-local store.
- * @since 0.7.0
- */
-export interface ContextLocalStorage<T> {
-    /**
-     * Runs a callback with the given store as the context-local store.
-     * @param store The store to use as the context-local store.
-     * @param callback The callback to run.
-     * @returns The return value of the callback.
-     */
-    run<R>(store: T, callback: () => R): R;
-    /**
-     * Returns the current context-local store.
-     * @returns The current context-local store, or `undefined` if there is no
-     *          store.
-     */
-    getStore(): T | undefined;
-}
-/**
- * Runs a callback with the given implicit context.  Every single log record
- * in the callback will have the given context.
- *
- * If no `contextLocalStorage` is configured, this function does nothing and
- * just returns the return value of the callback.  It also logs a warning to
- * the `["logtape", "meta"]` logger in this case.
- * @param context The context to inject.
- * @param callback The callback to run.
- * @returns The return value of the callback.
- * @since 0.7.0
- */
-export declare function withContext<T>(context: Record<string, unknown>, callback: () => T): T;
-//# sourceMappingURL=context.d.ts.map

package/types/logtape/context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/logtape/context.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB,CAAC,CAAC;IACpC;;;;;OAKG;IACH,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;IAEvC;;;;OAIG;IACH,QAAQ,IAAI,CAAC,GAAG,SAAS,CAAC;CAC3B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAC3B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAChC,QAAQ,EAAE,MAAM,CAAC,GAChB,CAAC,CAcH"}

package/types/logtape/filter.d.ts

@@ -1,31 +0,0 @@
-import type { LogLevel } from "./level.js";
-import type { LogRecord } from "./record.js";
-/**
- * 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 declare function toFilter(filter: FilterLike): 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 declare function getLevelFilter(level: LogLevel | null): Filter;
-//# sourceMappingURL=filter.d.ts.map

package/types/logtape/filter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filter.d.ts","sourceRoot":"","sources":["../../src/logtape/filter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;GAMG;AACH,MAAM,MAAM,MAAM,GAAG,CAAC,MAAM,EAAE,SAAS,KAAK,OAAO,CAAC;AAEpD;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,IAAI,CAAC;AAElD;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAGnD;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,CAoB7D"}

package/types/logtape/formatter.d.ts

@@ -1,260 +0,0 @@
-import type { LogLevel } from "./level.js";
-import type { LogRecord } from "./record.js";
-/**
- * A text formatter is a function that accepts a log record and returns
- * a string.
- *
- * @param record The log record to format.
- * @returns The formatted log record.
- */
-export type TextFormatter = (record: LogRecord) => string;
-/**
- * The formatted values for a log record.
- * @since 0.6.0
- */
-export interface FormattedValues {
-    /**
-     * The formatted timestamp.
-     */
-    timestamp: string;
-    /**
-     * The formatted log level.
-     */
-    level: string;
-    /**
-     * The formatted category.
-     */
-    category: string;
-    /**
-     * The formatted message.
-     */
-    message: string;
-    /**
-     * The unformatted log record.
-     */
-    record: LogRecord;
-}
-/**
- * The various options for the built-in text formatters.
- * @since 0.6.0
- */
-export interface TextFormatterOptions {
-    /**
-     * The timestamp format.  This can be one of the following:
-     *
-     * - `"date-time-timezone"`: The date and time with the full timezone offset
-     *   (e.g., `"2023-11-14 22:13:20.000 +00:00"`).
-     * - `"date-time-tz"`: The date and time with the short timezone offset
-     *   (e.g., `"2023-11-14 22:13:20.000 +00"`).
-     * - `"date-time"`: The date and time without the timezone offset
-     *   (e.g., `"2023-11-14 22:13:20.000"`).
-     * - `"time-timezone"`: The time with the full timezone offset but without
-     *   the date (e.g., `"22:13:20.000 +00:00"`).
-     * - `"time-tz"`: The time with the short timezone offset but without the date
-     *   (e.g., `"22:13:20.000 +00"`).
-     * - `"time"`: The time without the date or timezone offset
-     *   (e.g., `"22:13:20.000"`).
-     * - `"date"`: The date without the time or timezone offset
-     *   (e.g., `"2023-11-14"`).
-     * - `"rfc3339"`: The date and time in RFC 3339 format
-     *   (e.g., `"2023-11-14T22:13:20.000Z"`).
-     *
-     * Alternatively, this can be a function that accepts a timestamp and returns
-     * a string.
-     *
-     * The default is `"date-time-timezone"`.
-     */
-    timestamp?: "date-time-timezone" | "date-time-tz" | "date-time" | "time-timezone" | "time-tz" | "time" | "date" | "rfc3339" | ((ts: number) => string);
-    /**
-     * The log level format.  This can be one of the following:
-     *
-     * - `"ABBR"`: The log level abbreviation in uppercase (e.g., `"INF"`).
-     * - `"FULL"`: The full log level name in uppercase (e.g., `"INFO"`).
-     * - `"L"`: The first letter of the log level in uppercase (e.g., `"I"`).
-     * - `"abbr"`: The log level abbreviation in lowercase (e.g., `"inf"`).
-     * - `"full"`: The full log level name in lowercase (e.g., `"info"`).
-     * - `"l"`: The first letter of the log level in lowercase (e.g., `"i"`).
-     *
-     * Alternatively, this can be a function that accepts a log level and returns
-     * a string.
-     *
-     * The default is `"ABBR"`.
-     */
-    level?: "ABBR" | "FULL" | "L" | "abbr" | "full" | "l" | ((level: LogLevel) => string);
-    /**
-     * The separator between category names.  For example, if the separator is
-     * `"·"`, the category `["a", "b", "c"]` will be formatted as `"a·b·c"`.
-     * The default separator is `"·"`.
-     *
-     * If this is a function, it will be called with the category array and
-     * should return a string, which will be used for rendering the category.
-     */
-    category?: string | ((category: readonly string[]) => string);
-    /**
-     * The format of the embedded values.
-     *
-     * A function that renders a value to a string.  This function is used to
-     * render the values in the log record.  The default is [`util.inspect()`] in
-     * Node.js/Bun and [`Deno.inspect()`] in Deno.
-     *
-     * [`util.inspect()`]: https://nodejs.org/api/util.html#utilinspectobject-options
-     * [`Deno.inspect()`]: https://docs.deno.com/api/deno/~/Deno.inspect
-     * @param value The value to render.
-     * @returns The string representation of the value.
-     */
-    value?: (value: unknown) => string;
-    /**
-     * How those formatted parts are concatenated.
-     *
-     * A function that formats the log record.  This function is called with the
-     * formatted values and should return a string.  Note that the formatted
-     * *should not* include a newline character at the end.
-     *
-     * By default, this is a function that formats the log record as follows:
-     *
-     * ```
-     * 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
-     * ```
-     * @param values The formatted values.
-     * @returns The formatted log record.
-     */
-    format?: (values: FormattedValues) => string;
-}
-/**
- * Get a text formatter with the specified options.  Although it's flexible
- * enough to create a custom formatter, if you want more control, you can
- * create a custom formatter that satisfies the {@link TextFormatter} type
- * instead.
- *
- * For more information on the options, see {@link TextFormatterOptions}.
- *
- * By default, the formatter formats log records as follows:
- *
- * ```
- * 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
- * ```
- * @param options The options for the text formatter.
- * @returns The text formatter.
- * @since 0.6.0
- */
-export declare function getTextFormatter(options?: TextFormatterOptions): TextFormatter;
-/**
- * The default text formatter.  This formatter formats log records as follows:
- *
- * ```
- * 2023-11-14 22:13:20.000 +00:00 [INF] category·subcategory: Hello, world!
- * ```
- *
- * @param record The log record to format.
- * @returns The formatted log record.
- */
-export declare const defaultTextFormatter: TextFormatter;
-/**
- * The ANSI colors.  These can be used to colorize text in the console.
- * @since 0.6.0
- */
-export type AnsiColor = "black" | "red" | "green" | "yellow" | "blue" | "magenta" | "cyan" | "white";
-/**
- * The ANSI text styles.
- * @since 0.6.0
- */
-export type AnsiStyle = "bold" | "dim" | "italic" | "underline" | "strikethrough";
-/**
- * The various options for the ANSI color formatter.
- * @since 0.6.0
- */
-export interface AnsiColorFormatterOptions extends TextFormatterOptions {
-    /**
-     * The timestamp format.  This can be one of the following:
-     *
-     * - `"date-time-timezone"`: The date and time with the full timezone offset
-     *   (e.g., `"2023-11-14 22:13:20.000 +00:00"`).
-     * - `"date-time-tz"`: The date and time with the short timezone offset
-     *   (e.g., `"2023-11-14 22:13:20.000 +00"`).
-     * - `"date-time"`: The date and time without the timezone offset
-     *   (e.g., `"2023-11-14 22:13:20.000"`).
-     * - `"time-timezone"`: The time with the full timezone offset but without
-     *   the date (e.g., `"22:13:20.000 +00:00"`).
-     * - `"time-tz"`: The time with the short timezone offset but without the date
-     *   (e.g., `"22:13:20.000 +00"`).
-     * - `"time"`: The time without the date or timezone offset
-     *   (e.g., `"22:13:20.000"`).
-     * - `"date"`: The date without the time or timezone offset
-     *   (e.g., `"2023-11-14"`).
-     * - `"rfc3339"`: The date and time in RFC 3339 format
-     *   (e.g., `"2023-11-14T22:13:20.000Z"`).
-     *
-     * Alternatively, this can be a function that accepts a timestamp and returns
-     * a string.
-     *
-     * The default is `"date-time-tz"`.
-     */
-    timestamp?: "date-time-timezone" | "date-time-tz" | "date-time" | "time-timezone" | "time-tz" | "time" | "date" | "rfc3339" | ((ts: number) => string);
-    /**
-     * The ANSI style for the timestamp.  `"dim"` is used by default.
-     */
-    timestampStyle?: AnsiStyle | null;
-    /**
-     * The ANSI color for the timestamp.  No color is used by default.
-     */
-    timestampColor?: AnsiColor | null;
-    /**
-     * The ANSI style for the log level.  `"bold"` is used by default.
-     */
-    levelStyle?: AnsiStyle | null;
-    /**
-     * The ANSI colors for the log levels.  The default colors are as follows:
-     *
-     * - `"debug"`: `"blue"`
-     * - `"info"`: `"green"`
-     * - `"warning"`: `"yellow"`
-     * - `"error"`: `"red"`
-     * - `"fatal"`: `"magenta"`
-     */
-    levelColors?: Record<LogLevel, AnsiColor | null>;
-    /**
-     * The ANSI style for the category.  `"dim"` is used by default.
-     */
-    categoryStyle?: AnsiStyle | null;
-    /**
-     * The ANSI color for the category.  No color is used by default.
-     */
-    categoryColor?: AnsiColor | null;
-}
-/**
- * Get an ANSI color formatter with the specified options.
- *
- * ![A preview of an ANSI color formatter.](https://i.imgur.com/I8LlBUf.png)
- * @param option The options for the ANSI color formatter.
- * @returns The ANSI color formatter.
- * @since 0.6.0
- */
-export declare function getAnsiColorFormatter(options?: AnsiColorFormatterOptions): TextFormatter;
-/**
- * A text formatter that uses ANSI colors to format log records.
- *
- * ![A preview of ansiColorFormatter.](https://i.imgur.com/I8LlBUf.png)
- *
- * @param record The log record to format.
- * @returns The formatted log record.
- * @since 0.5.0
- */
-export declare const ansiColorFormatter: TextFormatter;
-/**
- * A console formatter is a function that accepts a log record and returns
- * an array of arguments to pass to {@link console.log}.
- *
- * @param record The log record to format.
- * @returns The formatted log record, as an array of arguments for
- *          {@link console.log}.
- */
-export type ConsoleFormatter = (record: LogRecord) => readonly unknown[];
-/**
- * The default console formatter.
- *
- * @param record The log record to format.
- * @returns The formatted log record, as an array of arguments for
- *          {@link console.log}.
- */
-export declare function defaultConsoleFormatter(record: LogRecord): readonly unknown[];
-//# sourceMappingURL=formatter.d.ts.map

package/types/logtape/formatter.d.ts.map

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

package/types/logtape/level.d.ts

@@ -1,32 +0,0 @@
-declare const logLevels: readonly ["debug", "info", "warning", "error", "fatal"];
-/**
- * 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 declare function parseLogLevel(level: string): LogLevel;
-/**
- * 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 declare function isLogLevel(level: string): level is LogLevel;
-/**
- * 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 declare function compareLogLevel(a: LogLevel, b: LogLevel): number;
-export {};
-//# sourceMappingURL=level.d.ts.map