windmill-cli 1.407.0 → 1.407.2

package/types/deps/jsr.io/@std/log/0.224.9/logger.d.ts

@@ -0,0 +1,539 @@
+import type { LevelName, LogLevel } from "./levels.js";
+import type { BaseHandler } from "./base_handler.js";
+/** Any function that can be called with any arguments and return any value. */
+export type GenericFunction = (...args: any[]) => any;
+/**
+ * Options for {@linkcode LogRecord}.
+ */
+export interface LogRecordOptions {
+    /** The message to log. */
+    msg: string;
+    /** The arguments to log. */
+    args: unknown[];
+    /** The log level of the message. */
+    level: LogLevel;
+    /** The name of the logger that created the log record. */
+    loggerName: string;
+}
+export declare class LoggerConfig {
+    level?: LevelName;
+    handlers?: string[];
+}
+export interface LogConfig {
+    handlers?: {
+        [name: string]: BaseHandler;
+    };
+    loggers?: {
+        [name: string]: LoggerConfig;
+    };
+}
+/**
+ * An object that encapsulates provided message and arguments as well some
+ * metadata that can be later used when formatting a message.
+ *
+ * @example Usage
+ * ```ts
+ * import { LogRecord } from "@std/log/logger";
+ * import { LogLevels } from "@std/log/levels";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * const record = new LogRecord({
+ *   msg: "Hello, world!",
+ *   args: ["foo", "bar"],
+ *   level: LogLevels.INFO,
+ *   loggerName: "example",
+ * });
+ *
+ * assertEquals(record.msg, "Hello, world!");
+ * assertEquals(record.args, ["foo", "bar"]);
+ * assertEquals(record.level, LogLevels.INFO);
+ * assertEquals(record.loggerName, "example");
+ * ```
+ */
+export declare class LogRecord {
+    #private;
+    /** The message to log.
+     *
+     * @example Usage
+     * ```ts
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     *
+     * assertEquals(record.msg, "Hello, world!");
+     * ```
+     */
+    readonly msg: string;
+    /**
+     * The numeric log level of the log record.
+     *
+     * @example Usage
+     * ```ts
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     *
+     * assertEquals(record.level, LogLevels.INFO);
+     * ```
+     */
+    readonly level: number;
+    /**
+     * The name of the log level of the log record.
+     *
+     * @example Usage
+     * ```ts
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     *
+     * assertEquals(record.loggerName, "example");
+     * ```
+     */
+    readonly levelName: string;
+    /**
+     * The name of the logger that created the log record.
+     *
+     * @example Usage
+     * ```ts
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     *
+     * assertEquals(record.loggerName, "example");
+     * ```
+     */
+    readonly loggerName: string;
+    /**
+     * Constructs a new instance.
+     *
+     * @param options The options to create a new log record.
+     *
+     * @example Usage
+     * ```ts
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     *
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     * ```
+     */
+    constructor(options: LogRecordOptions);
+    /**
+     * Getter for the arguments to log.
+     *
+     * @example Usage
+     * ```ts
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     *
+     * assertEquals(record.args, ["foo", "bar"]);
+     * ```
+     *
+     * @returns A copy of the arguments to log.
+     */
+    get args(): unknown[];
+    /**
+     * Getter for the date and time the log record was created.
+     *
+     * @example Usage
+     * ```ts
+     * import { LogRecord } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertAlmostEquals } from "@std/assert/almost-equals";
+     *
+     * const record = new LogRecord({
+     *   msg: "Hello, world!",
+     *   args: ["foo", "bar"],
+     *   level: LogLevels.INFO,
+     *   loggerName: "example",
+     * });
+     *
+     * assertAlmostEquals(record.datetime.getTime(), Date.now(), 1);
+     * ```
+     *
+     * @returns The date and time the log record was created.
+     */
+    get datetime(): Date;
+}
+/** Options for {@linkcode Logger}. */
+export interface LoggerOptions {
+    /** The handlers to use for the logger. */
+    handlers?: BaseHandler[];
+}
+/**
+ * A logger that can log messages at different levels.
+ *
+ * @example Usage
+ * ```ts
+ * import { Logger } from "@std/log/logger";
+ * import { assertEquals } from "@std/assert/equals";
+ *
+ * const logger = new Logger("example", "INFO");
+ * const result = logger.info("Hello, world!");
+ *
+ * assertEquals(result, "Hello, world!");
+ * ```
+ */
+export declare class Logger {
+    #private;
+    /**
+     * The handlers to use for the logger.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { ConsoleHandler } from "@std/log/console-handler";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const handler = new ConsoleHandler("INFO");
+     * const logger = new Logger("example", "INFO", {
+     *  handlers: [handler],
+     * });
+     *
+     * assertEquals(logger.handlers, [handler]);
+     * ```
+     */
+    handlers: BaseHandler[];
+    /**
+     * Constructs a new instance.
+     *
+     * @param loggerName The name of the logger.
+     * @param levelName The name of the log level.
+     * @param options The options to create a new logger.
+     */
+    constructor(loggerName: string, levelName: LevelName, options?: LoggerOptions);
+    /**
+     * Getter for the log level.
+     *
+     * @returns The log level.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     * assertEquals(logger.level, LogLevels.INFO);
+     * ```
+     */
+    get level(): LogLevel;
+    /**
+     * Setter for the log level.
+     *
+     * @param level The log level to set.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     * logger.level = LogLevels.DEBUG;
+     *
+     * assertEquals(logger.level, LogLevels.DEBUG);
+     * ```
+     */
+    set level(level: LogLevel);
+    /**
+     * Getter for the name of the log level.
+     *
+     * @returns The name of the log level.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     * assertEquals(logger.levelName, "INFO");
+     * ```
+     */
+    get levelName(): LevelName;
+    /**
+     * Setter for the name of the log level.
+     *
+     * @param levelName The name of the log level to set.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { LogLevels } from "@std/log/levels";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     * logger.levelName = "DEBUG";
+     *
+     * assertEquals(logger.level, LogLevels.DEBUG);
+     * ```
+     */
+    set levelName(levelName: LevelName);
+    /**
+     * Getter for the name of the logger.
+     *
+     * @returns The name of the logger.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.loggerName, "example");
+     * ```
+     */
+    get loggerName(): string;
+    /**
+     * Log at the debug level.
+     *
+     * @template T The type of the message to log.
+     * @param msg The message to log.
+     * @param args Arguments to be formatted into the message.
+     * @returns The message that was logged.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.debug("Hello, world!"), "Hello, world!");
+     *
+     * assertEquals(logger.debug(() => "Hello, world!"), undefined);
+     * ```
+     */
+    debug<T>(msg: () => T, ...args: unknown[]): T | undefined;
+    /**
+     * Log at the debug level.
+     *
+     * @template T The type of the message to log.
+     * @param msg The message to log.
+     * @param args Arguments to be formatted into the message.
+     * @returns The message that was logged.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.debug("Hello, world!"), "Hello, world!");
+     *
+     * assertEquals(logger.debug(() => "Hello, world!"), undefined);
+     * ```
+     */
+    debug<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+    /**
+     * Log at the info level.
+     *
+     * @template T The type of the message to log.
+     * @param msg The message to log.
+     * @param args Arguments to be formatted into the message.
+     * @returns The message that was logged.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.info("Hello, world!"), "Hello, world!");
+     *
+     * assertEquals(logger.info(() => "Hello, world!"), "Hello, world!");
+     * ```
+     */
+    info<T>(msg: () => T, ...args: unknown[]): T | undefined;
+    /**
+     * Log at the info level.
+     *
+     * @template T The type of the message to log.
+     * @param msg The message to log.
+     * @param args Arguments to be formatted into the message.
+     * @returns The message that was logged.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.info("Hello, world!"), "Hello, world!");
+     *
+     * assertEquals(logger.info(() => "Hello, world!"), "Hello, world!");
+     * ```
+     */
+    info<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+    /**
+     * Log at the warning level.
+     *
+     * @template T The type of the message to log.
+     * @param msg The message to log.
+     * @param args Arguments to be formatted into the message.
+     * @returns The message that was logged.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.warn("Hello, world!"), "Hello, world!");
+     *
+     * assertEquals(logger.warn(() => "Hello, world!"), "Hello, world!");
+     * ```
+     */
+    warn<T>(msg: () => T, ...args: unknown[]): T | undefined;
+    /**
+     * Log at the warning level.
+     *
+     * @template T The type of the message to log.
+     * @param msg The message to log.
+     * @param args Arguments to be formatted into the message.
+     * @returns The message that was logged.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.warn("Hello, world!"), "Hello, world!");
+     *
+     * assertEquals(logger.warn(() => "Hello, world!"), "Hello, world!");
+     * ```
+     */
+    warn<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+    /**
+     * Log at the error level.
+     *
+     * @template T The type of the message to log.
+     * @param msg The message to log.
+     * @param args Arguments to be formatted into the message.
+     * @returns The message that was logged.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.error("Hello, world!"), "Hello, world!");
+     *
+     * assertEquals(logger.error(() => "Hello, world!"), "Hello, world!");
+     * ```
+     */
+    error<T>(msg: () => T, ...args: unknown[]): T | undefined;
+    /**
+     * Log at the error level.
+     *
+     * @template T The type of the message to log.
+     * @param msg The message to log.
+     * @param args Arguments to be formatted into the message.
+     * @returns The message that was logged.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.error("Hello, world!"), "Hello, world!");
+     *
+     * assertEquals(logger.error(() => "Hello, world!"), "Hello, world!");
+     * ```
+     */
+    error<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+    /**
+     * Log at the critical level.
+     *
+     * @template T The type of the message to log.
+     * @param msg The message to log.
+     * @param args Arguments to be formatted into the message.
+     * @returns The message that was logged.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.critical("Hello, world!"), "Hello, world!");
+     *
+     * assertEquals(logger.critical(() => "Hello, world!"), "Hello, world!");
+     * ```
+     */
+    critical<T>(msg: () => T, ...args: unknown[]): T | undefined;
+    /**
+     * Log at the critical level.
+     *
+     * @template T The type of the message to log.
+     * @param msg The message to log.
+     * @param args Arguments to be formatted into the message.
+     * @returns The message that was logged.
+     *
+     * @example Usage
+     * ```ts
+     * import { Logger } from "@std/log/logger";
+     * import { assertEquals } from "@std/assert/equals";
+     *
+     * const logger = new Logger("example", "INFO");
+     *
+     * assertEquals(logger.critical("Hello, world!"), "Hello, world!");
+     *
+     * assertEquals(logger.critical(() => "Hello, world!"), "Hello, world!");
+     * ```
+     */
+    critical<T>(msg: T extends GenericFunction ? never : T, ...args: unknown[]): T;
+}
+//# sourceMappingURL=logger.d.ts.map

package/types/deps/jsr.io/@std/log/0.224.9/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.9/logger.ts"],"names":[],"mappings":"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"}

package/types/deps/jsr.io/@std/log/{0.224.8 → 0.224.9}/mod.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.8/mod.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsXG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.9/mod.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsXG;AAEH,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/types/deps/jsr.io/@std/log/{0.224.8 → 0.224.9}/rotating_file_handler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rotating_file_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.8/rotating_file_handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AASzE,UAAU,0BAA2B,SAAQ,kBAAkB;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;;gBAKtC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,0BAA0B;IAM5D,KAAK;IAyCL,GAAG,CAAC,GAAG,EAAE,MAAM;IAaxB,cAAc;CAkBf"}
+{"version":3,"file":"rotating_file_handler.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.9/rotating_file_handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAE7C,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AASzE,UAAU,0BAA2B,SAAQ,kBAAkB;IAC7D,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;;gBAKtC,SAAS,EAAE,SAAS,EAAE,OAAO,EAAE,0BAA0B;IAM5D,KAAK;IAyCL,GAAG,CAAC,GAAG,EAAE,MAAM;IAaxB,cAAc;CAkBf"}

package/types/deps/jsr.io/@std/log/{0.224.8 → 0.224.9}/setup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.8/setup.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,SAAS,EAAU,MAAM,aAAa,CAAC;AAGrD,2BAA2B;AAC3B,wBAAgB,KAAK,CAAC,MAAM,EAAE,SAAS,QAwCtC"}
+{"version":3,"file":"setup.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.9/setup.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,SAAS,EAAU,MAAM,aAAa,CAAC;AAGrD,2BAA2B;AAC3B,wBAAgB,KAAK,CAAC,MAAM,EAAE,SAAS,QAwCtC"}

package/types/deps/jsr.io/@std/log/{0.224.8 → 0.224.9}/warn.d.ts

@@ -1,10 +1,12 @@
 import type { GenericFunction } from "./logger.js";
+import "./setup.js";
 export type { GenericFunction };
 /**
  * Log at the warning level.
  *
  * This function is a pass-through to the default logger's `warn` method. By
- * default, the default logger is configured to use {@linkcode console.log}.
+ * default, the default logger is configured to use {@linkcode console.log} and
+ * print in yellow text.
  *
  * @template T The type of the message to log.
  * @param msg The message to log.

package/types/deps/jsr.io/@std/log/0.224.9/warn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warn.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/log/0.224.9/warn.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,YAAY,CAAC;AAEpB,YAAY,EAAE,eAAe,EAAE,CAAC;AAEhC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,GAAG,SAAS,CAAC;AACzE;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,IAAI,CAAC,CAAC,EACpB,GAAG,EAAE,CAAC,SAAS,eAAe,GAAG,KAAK,GAAG,CAAC,EAC1C,GAAG,IAAI,EAAE,OAAO,EAAE,GACjB,CAAC,CAAC"}

package/types/deps.d.ts

@@ -13,10 +13,10 @@ export { ensureDir } from "./deps/jsr.io/@std/fs/1.0.4/mod.js";
 export { SEPARATOR as SEP } from "./deps/jsr.io/@std/path/1.0.6/mod.js";
 export * as path from "./deps/jsr.io/@std/path/1.0.6/mod.js";
 export { encodeHex } from "./deps/jsr.io/@std/encoding/1.0.5/mod.js";
-export { writeAllSync } from "./deps/jsr.io/@std/io/0.224.9/write_all.js";
-export { copy } from "./deps/jsr.io/@std/io/0.224.9/copy.js";
-export { readAll } from "./deps/jsr.io/@std/io/0.224.9/read_all.js";
-export * as log from "./deps/jsr.io/@std/log/0.224.8/mod.js";
+export { writeAllSync } from "./deps/jsr.io/@std/io/0.225.0/write_all.js";
+export { copy } from "./deps/jsr.io/@std/io/0.225.0/copy.js";
+export { readAll } from "./deps/jsr.io/@std/io/0.225.0/read_all.js";
+export * as log from "./deps/jsr.io/@std/log/0.224.9/mod.js";
 export { stringify as yamlStringify, parse as yamlParse } from "./deps/jsr.io/@std/yaml/1.0.5/mod.js";
 export * as Diff from "diff";
 export { minimatch } from "minimatch";

package/types/main.d.ts

@@ -19,7 +19,7 @@ import { pull as hubPull } from "./hub.js";
 import { pull, push } from "./sync.js";
 import { add as workspaceAdd } from "./workspace.js";
 export { flow, app, script, workspace, resource, user, variable, hub, folder, schedule, sync, instance, dev, hubPull, pull, push, workspaceAdd, };
-export declare const VERSION = "1.407.0";
+export declare const VERSION = "1.407.2";
 declare const command: Command<{
     workspace?: (import("./deps/jsr.io/@windmill-labs/cliffy-command/1.0.0-rc.5/mod.js").StringType & string) | undefined;
 } & {

package/esm/deps/jsr.io/@std/log/0.224.8/base_handler.js

@@ -1,60 +0,0 @@
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _BaseHandler_levelName, _BaseHandler_level;
-// Copyright 2018-2024 the Deno authors. All rights reserved. MIT license.
-// This module is browser compatible.
-import { getLevelByName, getLevelName, } from "./levels.js";
-const DEFAULT_FORMATTER = ({ levelName, msg }) => `${levelName} ${msg}`;
-export class BaseHandler {
-    constructor(levelName, options) {
-        _BaseHandler_levelName.set(this, void 0);
-        _BaseHandler_level.set(this, void 0);
-        Object.defineProperty(this, "formatter", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        const { formatter = DEFAULT_FORMATTER } = options ?? {};
-        __classPrivateFieldSet(this, _BaseHandler_levelName, levelName, "f");
-        __classPrivateFieldSet(this, _BaseHandler_level, getLevelByName(levelName), "f");
-        this.formatter = formatter;
-    }
-    get level() {
-        return __classPrivateFieldGet(this, _BaseHandler_level, "f");
-    }
-    set level(level) {
-        __classPrivateFieldSet(this, _BaseHandler_level, level, "f");
-        __classPrivateFieldSet(this, _BaseHandler_levelName, getLevelName(level), "f");
-    }
-    get levelName() {
-        return __classPrivateFieldGet(this, _BaseHandler_levelName, "f");
-    }
-    set levelName(levelName) {
-        __classPrivateFieldSet(this, _BaseHandler_levelName, levelName, "f");
-        __classPrivateFieldSet(this, _BaseHandler_level, getLevelByName(levelName), "f");
-    }
-    handle(logRecord) {
-        if (this.level > logRecord.level)
-            return;
-        const msg = this.format(logRecord);
-        this.log(msg);
-    }
-    format(logRecord) {
-        return this.formatter(logRecord);
-    }
-    setup() { }
-    destroy() { }
-    [(_BaseHandler_levelName = new WeakMap(), _BaseHandler_level = new WeakMap(), Symbol.dispose)]() {
-        this.destroy();
-    }
-}