@versatiles/release-tool 2.5.0 → 2.7.0

package/dist/lib/log.d.ts

@@ -1,5 +1,65 @@
+/**
+ * Enables or disables verbose logging mode.
+ * When enabled, debug messages will be printed to stderr.
+ *
+ * @param enabled - Whether to enable verbose mode.
+ */
+export declare function setVerbose(enabled: boolean): void;
+/**
+ * Checks if verbose mode is currently enabled.
+ *
+ * @returns `true` if verbose mode is enabled, `false` otherwise.
+ */
+export declare function isVerbose(): boolean;
+/**
+ * Logs a fatal error message and terminates the process.
+ * The message is displayed in bold red text.
+ *
+ * @param text - The error message to display.
+ * @returns Never returns as the process is terminated.
+ */
 export declare function panic(text: string): never;
+/**
+ * Logs a warning message to stderr.
+ * The message is displayed in bold yellow text.
+ *
+ * @param text - The warning message to display.
+ */
 export declare function warn(text: string): void;
+/**
+ * Logs an informational message to stderr.
+ *
+ * @param text - The informational message to display.
+ */
 export declare function info(text: string): void;
+/**
+ * Logs a debug message to stderr if verbose mode is enabled.
+ * The message is displayed in gray text.
+ *
+ * @param text - The debug message to display.
+ */
+export declare function debug(text: string): void;
+/**
+ * Logs an abort message and terminates the process with exit code 1.
+ *
+ * @returns Never returns as the process is terminated.
+ */
 export declare function abort(): never;
-export declare function check<T>(message: string, promise: (Promise<T>) | (() => Promise<T>)): Promise<T>;
+/**
+ * Executes an async operation with progress indication.
+ * Displays a spinner-like message while the operation is in progress,
+ * then shows a success checkmark or failure X based on the result.
+ *
+ * @typeParam T - The return type of the promise.
+ * @param message - The message to display while the operation is running.
+ * @param promise - The promise to await, or a function that returns a promise.
+ * @returns The resolved value of the promise.
+ * @throws Calls `panic()` if the promise rejects, terminating the process.
+ *
+ * @example
+ * ```ts
+ * const result = await check('Fetching data', fetchData());
+ * const result = await check('Processing', async () => processData());
+ * ```
+ */
+export declare function check<T>(message: string, promise: Promise<T> | (() => Promise<T>)): Promise<T>;

package/dist/lib/log.js

@@ -1,17 +1,88 @@
+import { VrtError } from './errors.js';
+/** Internal flag to track verbose mode state. */
+let verboseMode = false;
+/**
+ * Enables or disables verbose logging mode.
+ * When enabled, debug messages will be printed to stderr.
+ *
+ * @param enabled - Whether to enable verbose mode.
+ */
+export function setVerbose(enabled) {
+    verboseMode = enabled;
+}
+/**
+ * Checks if verbose mode is currently enabled.
+ *
+ * @returns `true` if verbose mode is enabled, `false` otherwise.
+ */
+export function isVerbose() {
+    return verboseMode;
+}
+/**
+ * Logs a fatal error message and terminates the process.
+ * The message is displayed in bold red text.
+ *
+ * @param text - The error message to display.
+ * @returns Never returns as the process is terminated.
+ */
 export function panic(text) {
     process.stderr.write(`\x1b[1;31m! ERROR: ${text}\x1b[0m\n`);
     abort();
 }
+/**
+ * Logs a warning message to stderr.
+ * The message is displayed in bold yellow text.
+ *
+ * @param text - The warning message to display.
+ */
 export function warn(text) {
     process.stderr.write(`\x1b[1;33m! warning: ${text}\x1b[0m\n`);
 }
+/**
+ * Logs an informational message to stderr.
+ *
+ * @param text - The informational message to display.
+ */
 export function info(text) {
     process.stderr.write(`\x1b[0mi ${text}\n`);
 }
+/**
+ * Logs a debug message to stderr if verbose mode is enabled.
+ * The message is displayed in gray text.
+ *
+ * @param text - The debug message to display.
+ */
+export function debug(text) {
+    if (verboseMode) {
+        process.stderr.write(`\x1b[0;90m  ${text}\x1b[0m\n`);
+    }
+}
+/**
+ * Logs an abort message and terminates the process with exit code 1.
+ *
+ * @returns Never returns as the process is terminated.
+ */
 export function abort() {
     info('abort');
-    process.exit();
+    process.exit(1);
 }
+/**
+ * Executes an async operation with progress indication.
+ * Displays a spinner-like message while the operation is in progress,
+ * then shows a success checkmark or failure X based on the result.
+ *
+ * @typeParam T - The return type of the promise.
+ * @param message - The message to display while the operation is running.
+ * @param promise - The promise to await, or a function that returns a promise.
+ * @returns The resolved value of the promise.
+ * @throws Calls `panic()` if the promise rejects, terminating the process.
+ *
+ * @example
+ * ```ts
+ * const result = await check('Fetching data', fetchData());
+ * const result = await check('Processing', async () => processData());
+ * ```
+ */
 export async function check(message, promise) {
     process.stderr.write(`\x1b[0;90m\u2B95 ${message}\x1b[0m`);
     try {
@@ -21,8 +92,10 @@ export async function check(message, promise) {
     }
     catch (error) {
         process.stderr.write(`\r\x1b[0;91m\u2718 ${message}\x1b[0m\n`);
-        panic(error.message);
-        throw error;
+        if (error instanceof VrtError) {
+            panic(`[${error.code}] ${error.message}`);
+        }
+        panic(error.message ?? String(error));
     }
 }
 //# sourceMappingURL=log.js.map

package/dist/lib/retry.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Options for retry behavior
+ */
+export interface RetryOptions {
+    /** Maximum number of retry attempts (default: 3) */
+    maxRetries?: number;
+    /** Initial delay in milliseconds before first retry (default: 1000) */
+    initialDelayMs?: number;
+    /** Multiplier for exponential backoff (default: 2) */
+    backoffMultiplier?: number;
+    /** Maximum delay in milliseconds (default: 30000) */
+    maxDelayMs?: number;
+    /** Optional callback called before each retry */
+    onRetry?: (attempt: number, error: Error, nextDelayMs: number) => void;
+}
+/**
+ * Executes an async function with retry logic and exponential backoff.
+ *
+ * @param fn - The async function to execute
+ * @param options - Retry configuration options
+ * @returns The result of the function if successful
+ * @throws The last error encountered after all retries are exhausted
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/lib/retry.js

@@ -0,0 +1,44 @@
+const DEFAULT_OPTIONS = {
+    maxRetries: 3,
+    initialDelayMs: 1000,
+    backoffMultiplier: 2,
+    maxDelayMs: 30000,
+};
+/**
+ * Executes an async function with retry logic and exponential backoff.
+ *
+ * @param fn - The async function to execute
+ * @param options - Retry configuration options
+ * @returns The result of the function if successful
+ * @throws The last error encountered after all retries are exhausted
+ */
+export async function withRetry(fn, options = {}) {
+    const { maxRetries, initialDelayMs, backoffMultiplier, maxDelayMs } = { ...DEFAULT_OPTIONS, ...options };
+    const { onRetry } = options;
+    let lastError;
+    let currentDelay = initialDelayMs;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+            if (attempt < maxRetries) {
+                const nextDelay = Math.min(currentDelay, maxDelayMs);
+                if (onRetry) {
+                    onRetry(attempt + 1, lastError, nextDelay);
+                }
+                await sleep(nextDelay);
+                currentDelay *= backoffMultiplier;
+            }
+        }
+    }
+    throw lastError;
+}
+/**
+ * Sleep for a specified number of milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=retry.js.map

package/dist/lib/shell.d.ts

@@ -1,17 +1,138 @@
+/**
+ * Result of a shell command execution.
+ */
+export interface ShellResult {
+    /** Exit code of the process, or null if terminated by signal. */
+    code: number | null;
+    /** Signal that terminated the process, or null if exited normally. */
+    signal: string | null;
+    /** Captured standard output. */
+    stdout: string;
+    /** Captured standard error. */
+    stderr: string;
+}
+/**
+ * Result of an interactive shell command execution.
+ */
+export interface ShellInteractiveResult {
+    /** Exit code of the process, or null if terminated by signal. */
+    code: number | null;
+    /** Signal that terminated the process, or null if exited normally. */
+    signal: string | null;
+}
+/**
+ * A utility class for executing shell commands in a specified working directory.
+ * Provides methods for running commands with captured output, interactive commands,
+ * and convenience methods for common patterns.
+ *
+ * @example
+ * ```ts
+ * const shell = new Shell('/path/to/project');
+ * const output = await shell.stdout('git status');
+ * const success = await shell.ok('npm test');
+ * ```
+ */
 export declare class Shell {
+    /** The working directory for all commands. */
     private cwd;
+    /**
+     * Creates a new Shell instance.
+     *
+     * @param cwd - The working directory for executing commands.
+     */
     constructor(cwd: string);
-    run(command: string, errorOnCodeNonZero?: boolean): Promise<{
-        code: number | null;
-        signal: string | null;
-        stdout: string;
-        stderr: string;
-    }>;
-    runInteractive(command: string, errorOnCodeNonZero?: boolean): Promise<{
-        code: number | null;
-        signal: string | null;
-    }>;
+    /**
+     * Runs a shell command through bash and captures its output.
+     *
+     * @remarks
+     * **⚠️ SECURITY WARNING: Command Injection Risk**
+     *
+     * This method passes the command string directly to `bash -c`, which means
+     * shell metacharacters (`;`, `|`, `$()`, `` ` ``, etc.) are interpreted.
+     *
+     * **NEVER** pass unsanitized user input to this method:
+     * ```ts
+     * // DANGEROUS - command injection vulnerability!
+     * shell.run(`git checkout ${userInput}`);  // userInput could be "; rm -rf /"
+     *
+     * // SAFE - use exec() with array arguments instead
+     * shell.exec('git', ['checkout', userInput]);
+     * ```
+     *
+     * Only use this method with:
+     * - Hardcoded command strings
+     * - Values that have been strictly validated (e.g., version numbers matching `/^\d+\.\d+\.\d+$/`)
+     *
+     * For commands with dynamic arguments, prefer {@link Shell.exec} which passes
+     * arguments directly without shell interpretation.
+     *
+     * @param command - The shell command to execute. Must be a trusted string.
+     * @param errorOnCodeNonZero - If true (default), rejects the promise on non-zero exit code.
+     * @returns A promise resolving to the command result with exit code, signal, stdout, and stderr.
+     * @throws Rejects with the result object if errorOnCodeNonZero is true and exit code is non-zero.
+     */
+    run(command: string, errorOnCodeNonZero?: boolean): Promise<ShellResult>;
+    /**
+     * Executes a command with arguments directly, avoiding shell escaping issues.
+     * Preferred over `run()` when dealing with arguments that may contain special characters.
+     *
+     * @param command - The command executable to run.
+     * @param args - Array of arguments to pass to the command.
+     * @param errorOnCodeNonZero - If true (default), rejects the promise on non-zero exit code.
+     * @param skipLog - If true, suppresses debug logging of the command.
+     * @returns A promise resolving to the command result with exit code, signal, stdout, and stderr.
+     * @throws Rejects with the result object if errorOnCodeNonZero is true and exit code is non-zero.
+     */
+    exec(command: string, args: string[], errorOnCodeNonZero?: boolean, skipLog?: boolean): Promise<ShellResult>;
+    /**
+     * Runs a command interactively with full TTY passthrough.
+     * The user can interact with the command's stdin/stdout/stderr directly.
+     * Useful for commands that require user input (e.g., npm publish with OTP).
+     *
+     * @remarks
+     * **⚠️ SECURITY WARNING:** Same command injection risks as {@link Shell.run}.
+     * Never pass unsanitized user input. See {@link Shell.run} for details.
+     *
+     * @param command - The shell command to execute. Must be a trusted string.
+     * @param errorOnCodeNonZero - If true (default), rejects the promise on non-zero exit code.
+     * @returns A promise resolving to the exit code and signal (no captured output).
+     * @throws Rejects with the result object if errorOnCodeNonZero is true and exit code is non-zero.
+     */
+    runInteractive(command: string, errorOnCodeNonZero?: boolean): Promise<ShellInteractiveResult>;
+    /**
+     * Runs a command and returns only the trimmed stderr output.
+     *
+     * @remarks
+     * **⚠️ SECURITY WARNING:** Uses {@link Shell.run} internally.
+     * Never pass unsanitized user input. See {@link Shell.run} for details.
+     *
+     * @param command - The shell command to execute. Must be a trusted string.
+     * @param errorOnCodeZero - If true (default), rejects on non-zero exit code.
+     * @returns A promise resolving to the trimmed stderr string.
+     */
     stderr(command: string, errorOnCodeZero?: boolean): Promise<string>;
+    /**
+     * Runs a command and returns only the trimmed stdout output.
+     *
+     * @remarks
+     * **⚠️ SECURITY WARNING:** Uses {@link Shell.run} internally.
+     * Never pass unsanitized user input. See {@link Shell.run} for details.
+     *
+     * @param command - The shell command to execute. Must be a trusted string.
+     * @param errorOnCodeZero - If true (default), rejects on non-zero exit code.
+     * @returns A promise resolving to the trimmed stdout string.
+     */
     stdout(command: string, errorOnCodeZero?: boolean): Promise<string>;
+    /**
+     * Runs a command and returns whether it succeeded (exit code 0).
+     * Never throws on non-zero exit codes.
+     *
+     * @remarks
+     * **⚠️ SECURITY WARNING:** Uses {@link Shell.run} internally.
+     * Never pass unsanitized user input. See {@link Shell.run} for details.
+     *
+     * @param command - The shell command to execute. Must be a trusted string.
+     * @returns A promise resolving to true if exit code is 0, false otherwise.
+     */
     ok(command: string): Promise<boolean>;
 }

package/dist/lib/shell.js

@@ -1,40 +1,121 @@
 import { spawn } from 'child_process';
+import { debug, isVerbose } from './log.js';
+/**
+ * A utility class for executing shell commands in a specified working directory.
+ * Provides methods for running commands with captured output, interactive commands,
+ * and convenience methods for common patterns.
+ *
+ * @example
+ * ```ts
+ * const shell = new Shell('/path/to/project');
+ * const output = await shell.stdout('git status');
+ * const success = await shell.ok('npm test');
+ * ```
+ */
 export class Shell {
+    /** The working directory for all commands. */
     cwd;
+    /**
+     * Creates a new Shell instance.
+     *
+     * @param cwd - The working directory for executing commands.
+     */
     constructor(cwd) {
         this.cwd = cwd;
     }
+    /**
+     * Runs a shell command through bash and captures its output.
+     *
+     * @remarks
+     * **⚠️ SECURITY WARNING: Command Injection Risk**
+     *
+     * This method passes the command string directly to `bash -c`, which means
+     * shell metacharacters (`;`, `|`, `$()`, `` ` ``, etc.) are interpreted.
+     *
+     * **NEVER** pass unsanitized user input to this method:
+     * ```ts
+     * // DANGEROUS - command injection vulnerability!
+     * shell.run(`git checkout ${userInput}`);  // userInput could be "; rm -rf /"
+     *
+     * // SAFE - use exec() with array arguments instead
+     * shell.exec('git', ['checkout', userInput]);
+     * ```
+     *
+     * Only use this method with:
+     * - Hardcoded command strings
+     * - Values that have been strictly validated (e.g., version numbers matching `/^\d+\.\d+\.\d+$/`)
+     *
+     * For commands with dynamic arguments, prefer {@link Shell.exec} which passes
+     * arguments directly without shell interpretation.
+     *
+     * @param command - The shell command to execute. Must be a trusted string.
+     * @param errorOnCodeNonZero - If true (default), rejects the promise on non-zero exit code.
+     * @returns A promise resolving to the command result with exit code, signal, stdout, and stderr.
+     * @throws Rejects with the result object if errorOnCodeNonZero is true and exit code is non-zero.
+     */
     async run(command, errorOnCodeNonZero = true) {
-        try {
-            return await new Promise((resolve, reject) => {
-                const stdout = [];
-                const stderr = [];
-                const cp = spawn('bash', ['-c', command], { cwd: this.cwd })
-                    .on('error', error => reject(error))
-                    .on('close', (code, signal) => {
-                    const result = {
-                        code,
-                        signal,
-                        stdout: Buffer.concat(stdout).toString(),
-                        stderr: Buffer.concat(stderr).toString(),
-                    };
-                    if (errorOnCodeNonZero && code !== 0) {
-                        reject(result);
-                    }
-                    else {
-                        resolve(result);
-                    }
-                });
-                cp.stdout.on('data', chunk => stdout.push(chunk));
-                cp.stderr.on('data', chunk => stderr.push(chunk));
-            });
-        }
-        catch (error) {
-            console.error(error);
-            throw error;
+        debug(`$ ${command}`);
+        return this.exec('bash', ['-c', command], errorOnCodeNonZero, true);
+    }
+    /**
+     * Executes a command with arguments directly, avoiding shell escaping issues.
+     * Preferred over `run()` when dealing with arguments that may contain special characters.
+     *
+     * @param command - The command executable to run.
+     * @param args - Array of arguments to pass to the command.
+     * @param errorOnCodeNonZero - If true (default), rejects the promise on non-zero exit code.
+     * @param skipLog - If true, suppresses debug logging of the command.
+     * @returns A promise resolving to the command result with exit code, signal, stdout, and stderr.
+     * @throws Rejects with the result object if errorOnCodeNonZero is true and exit code is non-zero.
+     */
+    async exec(command, args, errorOnCodeNonZero = true, skipLog = false) {
+        if (!skipLog) {
+            debug(`$ ${command} ${args.join(' ')}`);
         }
+        return await new Promise((resolve, reject) => {
+            const stdout = [];
+            const stderr = [];
+            const cp = spawn(command, args, { cwd: this.cwd })
+                .on('error', (error) => reject(error))
+                .on('close', (code, signal) => {
+                const result = {
+                    code,
+                    signal,
+                    stdout: Buffer.concat(stdout).toString(),
+                    stderr: Buffer.concat(stderr).toString(),
+                };
+                if (isVerbose()) {
+                    if (result.stdout)
+                        result.stdout.split('\n').forEach((line) => debug(`  stdout: ${line}`));
+                    if (result.stderr)
+                        result.stderr.split('\n').forEach((line) => debug(`  stderr: ${line}`));
+                    debug(`  exit code: ${code}`);
+                }
+                if (errorOnCodeNonZero && code !== 0) {
+                    reject(result);
+                }
+                else {
+                    resolve(result);
+                }
+            });
+            cp.stdout.on('data', (chunk) => stdout.push(chunk));
+            cp.stderr.on('data', (chunk) => stderr.push(chunk));
+        });
     }
-    // Runs a command interactively, so the user can interact with stdin/stdout/stderr directly.
+    /**
+     * Runs a command interactively with full TTY passthrough.
+     * The user can interact with the command's stdin/stdout/stderr directly.
+     * Useful for commands that require user input (e.g., npm publish with OTP).
+     *
+     * @remarks
+     * **⚠️ SECURITY WARNING:** Same command injection risks as {@link Shell.run}.
+     * Never pass unsanitized user input. See {@link Shell.run} for details.
+     *
+     * @param command - The shell command to execute. Must be a trusted string.
+     * @param errorOnCodeNonZero - If true (default), rejects the promise on non-zero exit code.
+     * @returns A promise resolving to the exit code and signal (no captured output).
+     * @throws Rejects with the result object if errorOnCodeNonZero is true and exit code is non-zero.
+     */
     async runInteractive(command, errorOnCodeNonZero = true) {
         return await new Promise((resolve, reject) => {
             const cp = spawn('bash', ['-c', command], {
@@ -53,14 +134,47 @@ export class Shell {
             });
         });
     }
+    /**
+     * Runs a command and returns only the trimmed stderr output.
+     *
+     * @remarks
+     * **⚠️ SECURITY WARNING:** Uses {@link Shell.run} internally.
+     * Never pass unsanitized user input. See {@link Shell.run} for details.
+     *
+     * @param command - The shell command to execute. Must be a trusted string.
+     * @param errorOnCodeZero - If true (default), rejects on non-zero exit code.
+     * @returns A promise resolving to the trimmed stderr string.
+     */
     async stderr(command, errorOnCodeZero) {
         const result = await this.run(command, errorOnCodeZero);
         return result.stderr.trim();
     }
+    /**
+     * Runs a command and returns only the trimmed stdout output.
+     *
+     * @remarks
+     * **⚠️ SECURITY WARNING:** Uses {@link Shell.run} internally.
+     * Never pass unsanitized user input. See {@link Shell.run} for details.
+     *
+     * @param command - The shell command to execute. Must be a trusted string.
+     * @param errorOnCodeZero - If true (default), rejects on non-zero exit code.
+     * @returns A promise resolving to the trimmed stdout string.
+     */
     async stdout(command, errorOnCodeZero) {
         const result = await this.run(command, errorOnCodeZero);
         return result.stdout.trim();
     }
+    /**
+     * Runs a command and returns whether it succeeded (exit code 0).
+     * Never throws on non-zero exit codes.
+     *
+     * @remarks
+     * **⚠️ SECURITY WARNING:** Uses {@link Shell.run} internally.
+     * Never pass unsanitized user input. See {@link Shell.run} for details.
+     *
+     * @param command - The shell command to execute. Must be a trusted string.
+     * @returns A promise resolving to true if exit code is 0, false otherwise.
+     */
     async ok(command) {
         const result = await this.run(command, false);
         return result.code === 0;

package/dist/lib/utils.d.ts

@@ -1,2 +1,31 @@
+/**
+ * Extracts a human-readable error message from an unknown error value.
+ * Safely handles various error formats including Error objects, objects with message properties,
+ * and other unknown values.
+ *
+ * @param error - The error value to extract a message from. Can be any type.
+ * @returns The extracted error message string, or 'unknown' if no message could be extracted.
+ *
+ * @example
+ * ```ts
+ * getErrorMessage(new Error('Something went wrong')); // 'Something went wrong'
+ * getErrorMessage({ message: 'Custom error' }); // 'Custom error'
+ * getErrorMessage(null); // 'unknown'
+ * ```
+ */
 export declare function getErrorMessage(error: unknown): string;
+/**
+ * Formats JSON data with custom styling rules for map-style configurations.
+ * Applies special formatting for certain paths (like bounds, layers, filters, paint, layout)
+ * to keep them on a single line while expanding other nested structures.
+ *
+ * @param inputData - The data to format as styled JSON.
+ * @returns A formatted JSON string with custom indentation and line breaks.
+ *
+ * @example
+ * ```ts
+ * prettyStyleJSON({ name: 'test', bounds: [0, 0, 1, 1] });
+ * // Returns formatted JSON with bounds on a single line
+ * ```
+ */
 export declare function prettyStyleJSON(inputData: unknown): string;

package/dist/lib/utils.js

@@ -1,3 +1,18 @@
+/**
+ * Extracts a human-readable error message from an unknown error value.
+ * Safely handles various error formats including Error objects, objects with message properties,
+ * and other unknown values.
+ *
+ * @param error - The error value to extract a message from. Can be any type.
+ * @returns The extracted error message string, or 'unknown' if no message could be extracted.
+ *
+ * @example
+ * ```ts
+ * getErrorMessage(new Error('Something went wrong')); // 'Something went wrong'
+ * getErrorMessage({ message: 'Custom error' }); // 'Custom error'
+ * getErrorMessage(null); // 'unknown'
+ * ```
+ */
 export function getErrorMessage(error) {
     if (error == null)
         return 'unknown';
@@ -10,6 +25,20 @@ export function getErrorMessage(error) {
     }
     return 'unknown';
 }
+/**
+ * Formats JSON data with custom styling rules for map-style configurations.
+ * Applies special formatting for certain paths (like bounds, layers, filters, paint, layout)
+ * to keep them on a single line while expanding other nested structures.
+ *
+ * @param inputData - The data to format as styled JSON.
+ * @returns A formatted JSON string with custom indentation and line breaks.
+ *
+ * @example
+ * ```ts
+ * prettyStyleJSON({ name: 'test', bounds: [0, 0, 1, 1] });
+ * // Returns formatted JSON with bounds on a single line
+ * ```
+ */
 export function prettyStyleJSON(inputData) {
     return recursive(inputData);
     function recursive(data, prefix = '', path = '') {
@@ -24,10 +53,22 @@ export function prettyStyleJSON(inputData) {
             return singleLine(data);
         if (typeof data === 'object') {
             if (Array.isArray(data)) {
-                return '[\n\t' + prefix + data.map((value) => recursive(value, prefix + '\t', path + '[]')).join(',\n\t' + prefix) + '\n' + prefix + ']';
+                return ('[\n\t' +
+                    prefix +
+                    data.map((value) => recursive(value, prefix + '\t', path + '[]')).join(',\n\t' + prefix) +
+                    '\n' +
+                    prefix +
+                    ']');
             }
             if (data) {
-                return '{\n\t' + prefix + Object.entries(data).map(([key, value]) => '"' + key + '": ' + recursive(value, prefix + '\t', path + '.' + key)).join(',\n\t' + prefix) + '\n' + prefix + '}';
+                return ('{\n\t' +
+                    prefix +
+                    Object.entries(data)
+                        .map(([key, value]) => '"' + key + '": ' + recursive(value, prefix + '\t', path + '.' + key))
+                        .join(',\n\t' + prefix) +
+                    '\n' +
+                    prefix +
+                    '}');
             }
         }
         return singleLine(data);