Merge pull request #26411 from resir014/feature/types-signale

[signale] Add typings for signale

types/signale/index.d.ts

@@ -0,0 +1,136 @@
+// Type definitions for signale 1.1
+// Project: https://github.com/klauscfhq/signale
+// Definitions by: Resi Respati <https://github.com/resir014>
+//                 Kingdaro <https://github.com/kingdaro>
+//                 Joydip Roy <https://github.com/rjoydip>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.7
+
+/// <reference types="node" />
+
+declare namespace signale {
+    type DefaultMethods =
+        | "await"
+        | "complete"
+        | "error"
+        | "debug"
+        | "fatal"
+        | "fav"
+        | "info"
+        | "note"
+        | "pause"
+        | "pending"
+        | "star"
+        | "start"
+        | "success"
+        | "warn"
+        | "watch"
+        | "log";
+
+    interface CommandType {
+        /** The icon corresponding to the logger. */
+        badge: string;
+        /**
+         * The color of the label, can be any of the foreground colors supported by
+         * [chalk](https://github.com/chalk/chalk#colors).
+         */
+        color: string;
+        /** The label used to identify the type of the logger. */
+        label: string;
+    }
+
+    interface SignaleConfig {
+        /** Display the scope name of the logger. */
+        displayScope?: boolean;
+        /** Display the badge of the logger. */
+        displayBadge?: boolean;
+        /** Display the current local date in `YYYY-MM-DD` format. */
+        displayDate?: boolean;
+        /** Display the name of the file that the logger is reporting from. */
+        displayFilename?: boolean;
+        /** Display the label of the logger. */
+        displayLabel?: boolean;
+        /** Display the current local time in `HH:MM:SS` format. */
+        displayTimestamp?: boolean;
+        /** Underline the logger label. */
+        underlineLabel?: boolean;
+        /** Underline the logger message. */
+        underlineMessage?: boolean;
+    }
+
+    interface SignaleOptions<TTypes extends string = DefaultMethods> {
+        /** Sets the configuration of an instance overriding any existing global or local configuration. */
+        config?: SignaleConfig;
+        /**
+         * Name of the scope.
+         */
+        scope?: string;
+        /**
+         * Holds the configuration of the custom and default loggers.
+         */
+        types?: Partial<Record<TTypes, CommandType>>;
+        interactive?: boolean;
+        timers?: Map<string, Date>;
+        /**
+         * Destination to which the data is written, can be any valid
+         * [Writable stream](https://nodejs.org/api/stream.html#stream_writable_streams).
+         */
+        stream?: NodeJS.WriteStream;
+    }
+
+    interface SignaleConstructor {
+        new <TTypes extends string = DefaultMethods>(
+            options?: SignaleOptions<TTypes>
+        ): Signale<TTypes>;
+    }
+
+    interface SignaleBase<TTypes extends string = DefaultMethods> {
+        /**
+         * Sets the configuration of an instance overriding any existing global or local configuration.
+         *
+         * @param configObj Can hold any of the documented options.
+         */
+        config(configObj: SignaleConfig): Signale<TTypes>;
+        /**
+         * Defines the scope name of the logger.
+         *
+         * @param name Can be one or more comma delimited strings.
+         */
+        scope(...name: string[]): Signale<TTypes>;
+        /** Clears the scope name of the logger. */
+        unscope(): void;
+        /**
+         * Sets a timers and accepts an optional label. If none provided the timer will receive a unique label automatically.
+         *
+         * @param label Label corresponding to the timer. Each timer must have its own unique label.
+         * @returns a string corresponding to the timer label.
+         */
+        time(label?: string): string;
+        /**
+         * Deactivates the timer to which the given label corresponds. If no label
+         * is provided the most recent timer, that was created without providing a
+         * label, will be deactivated.
+         *
+         * @param label Label corresponding to the timer, each timer has its own unique label.
+         * @param span Total running time.
+         */
+        timeEnd(
+            label?: string,
+            span?: number
+        ): { label: string; span?: number };
+    }
+
+    type LoggerFunc = (message?: any, ...optionalArgs: any[]) => void;
+    type Signale<TTypes extends string = DefaultMethods> = SignaleBase<TTypes> &
+        Record<TTypes, LoggerFunc> &
+        Record<DefaultMethods, LoggerFunc>;
+}
+
+declare const signale: signale.Signale<signale.DefaultMethods> & {
+    Signale: signale.SignaleConstructor;
+    SignaleConfig: signale.SignaleConfig;
+    SignaleOptions: signale.SignaleOptions;
+    DefaultMethods: signale.DefaultMethods;
+};
+
+export = signale;

types/signale/signale-tests.ts

@@ -0,0 +1,129 @@
+import { Signale, SignaleOptions } from "signale";
+
+// --- Test 1: Basic Usage --- //
+
+const signale = new Signale();
+
+signale.success("Operation successful");
+signale.debug("Hello", "from", "L59");
+signale.pending("Write release notes for 1.2.0");
+signale.fatal(new Error("Unable to acquire lock"));
+signale.watch("Recursively watching build directory...");
+signale.complete({
+    prefix: "[task]",
+    message: "Fix issue #59",
+    suffix: "(@klauscfhq)"
+});
+
+// --- Test 2: Custom Loggers --- //
+
+type CustomLogger = "remind" | "santa";
+
+const optionsCustom: SignaleOptions<CustomLogger> = {
+    stream: process.stdout,
+    scope: "custom",
+    types: {
+        remind: {
+            badge: "**",
+            color: "yellow",
+            label: "reminder"
+        },
+        santa: {
+            badge: "🎅",
+            color: "red",
+            label: "santa"
+        }
+    }
+};
+
+const custom = new Signale(optionsCustom);
+custom.remind("Improve documentation.");
+custom.santa("Hoho! You have an unused variable on L45.");
+custom.debug("This should still work");
+
+// --- Test 3: Overriding Default Loggers --- //
+
+const optionsOverride: SignaleOptions = {
+    types: {
+        error: {
+            badge: "!!",
+            color: "red",
+            label: "fatal error"
+        },
+        success: {
+            badge: "++",
+            color: "green",
+            label: "huge success"
+        }
+    }
+};
+
+signale.error("Default Error Log");
+signale.success("Default Success Log");
+
+const customOverride = new Signale(optionsOverride);
+customOverride.error("Custom Error Log");
+customOverride.success("Custom Success Log");
+
+// --- Test 4: Scoped Loggers --- //
+
+const optionsScope: SignaleOptions = {
+    scope: "global scope"
+};
+
+const global = new Signale(optionsScope);
+global.success("Successful Operation");
+
+const global2 = signale.scope("global scope");
+global2.success("Hello from the global scope");
+
+function scopedTest() {
+    const outer = global2.scope("outer", "scope");
+    outer.success("Hello from the outer scope");
+
+    setTimeout(() => {
+        const inner = outer.scope("inner", "scope");
+        inner.success("Hello from the inner scope");
+    }, 500);
+}
+
+scopedTest();
+
+// --- Test 5: Timers --- //
+
+signale.time("test");
+signale.time();
+signale.time();
+
+setTimeout(() => {
+    signale.timeEnd();
+    signale.timeEnd();
+    signale.timeEnd("test");
+}, 500);
+
+// --- Test 6: Configuration --- //
+
+// Overrides any existing `package.json` config
+signale.config({
+    displayFilename: true,
+    displayTimestamp: true,
+    displayDate: false
+});
+
+signale.success("Hello from the Global scope");
+
+function scopedConfigTest() {
+    // `fooLogger` inherits the config of `signale`
+    const fooLogger = signale.scope("foo scope");
+
+    // Overrides both `signale` and `package.json` configs
+    fooLogger.config({
+        displayFilename: true,
+        displayTimestamp: false,
+        displayDate: true
+    });
+
+    fooLogger.success("Hello from the Local scope");
+}
+
+scopedConfigTest();

types/signale/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "strictFunctionTypes": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true,
+        "esModuleInterop": true
+    },
+    "files": [
+        "index.d.ts",
+        "signale-tests.ts"
+    ]
+}

types/signale/tslint.json

@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }