@hz-9/a5-core 0.2.0-alpha.1

package/dist/test/unit/util/color.util.unit.spec.js

@@ -0,0 +1,277 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const color_util_1 = require("../../../util/color.util");
+describe('ColorUtil Unit Test', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+    describe('[[Static Public Properties]]', () => {
+        describe('[[Properties]]', () => {
+            describe('isColorAllowed', () => {
+                it('should return true when NO_COLOR is not set', () => {
+                    delete process.env.NO_COLOR;
+                    expect(color_util_1.ColorUtil.isColorAllowed).toBe(true);
+                });
+                it('should return false when NO_COLOR is set to non-empty string', () => {
+                    process.env.NO_COLOR = '1';
+                    expect(color_util_1.ColorUtil.isColorAllowed).toBe(false);
+                });
+                it('should return false when NO_COLOR is set to empty string', () => {
+                    process.env.NO_COLOR = '';
+                    expect(color_util_1.ColorUtil.isColorAllowed).toBe(false);
+                });
+                it('should return false when NO_COLOR is set to truthy value', () => {
+                    process.env.NO_COLOR = 'true';
+                    expect(color_util_1.ColorUtil.isColorAllowed).toBe(false);
+                });
+                it('should return false when NO_COLOR is set to any value', () => {
+                    process.env.NO_COLOR = 'disable';
+                    expect(color_util_1.ColorUtil.isColorAllowed).toBe(false);
+                });
+            });
+        });
+    });
+    describe('[[Static Public Methods]]', () => {
+        describe('bold', () => {
+            describe('text', () => {
+                it('should wrap text with bold ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.bold('test');
+                    expect(result).toBe('\x1B[1mtest\x1B[0m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.bold('test');
+                    expect(result).toBe('test');
+                });
+                it('should handle empty string', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.bold('');
+                    expect(result).toBe('\x1B[1m\x1B[0m');
+                });
+                it('should handle text with special characters', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.bold('test!@#$%^&*()');
+                    expect(result).toBe('\x1B[1mtest!@#$%^&*()\x1B[0m');
+                });
+                it('should handle multiline text', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.bold('line1\nline2');
+                    expect(result).toBe('\x1B[1mline1\nline2\x1B[0m');
+                });
+            });
+        });
+        describe('red', () => {
+            describe('text', () => {
+                it('should wrap text with red ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.red('test');
+                    expect(result).toBe('\x1B[31mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.red('test');
+                    expect(result).toBe('test');
+                });
+                it('should handle empty string', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.red('');
+                    expect(result).toBe('\x1B[31m\x1B[39m');
+                });
+            });
+        });
+        describe('green', () => {
+            describe('text', () => {
+                it('should wrap text with green ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.green('test');
+                    expect(result).toBe('\x1B[32mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.green('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('yellow', () => {
+            describe('text', () => {
+                it('should wrap text with yellow ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.yellow('test');
+                    expect(result).toBe('\x1B[33mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.yellow('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('blue', () => {
+            describe('text', () => {
+                it('should wrap text with blue ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.blue('test');
+                    expect(result).toBe('\x1B[34mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.blue('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('magenta', () => {
+            describe('text', () => {
+                it('should wrap text with magenta ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.magenta('test');
+                    expect(result).toBe('\x1B[35mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.magenta('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('cyan', () => {
+            describe('text', () => {
+                it('should wrap text with cyan ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.cyan('test');
+                    expect(result).toBe('\x1B[36mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.cyan('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('redBright', () => {
+            describe('text', () => {
+                it('should wrap text with bright red ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.redBright('test');
+                    expect(result).toBe('\x1B[91mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.redBright('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('greenBright', () => {
+            describe('text', () => {
+                it('should wrap text with bright green ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.greenBright('test');
+                    expect(result).toBe('\x1B[92mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.greenBright('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('yellowBright', () => {
+            describe('text', () => {
+                it('should wrap text with bright yellow ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.yellowBright('test');
+                    expect(result).toBe('\x1B[93mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.yellowBright('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('blueBright', () => {
+            describe('text', () => {
+                it('should wrap text with bright blue ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.blueBright('test');
+                    expect(result).toBe('\x1B[94mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.blueBright('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('magentaBright', () => {
+            describe('text', () => {
+                it('should wrap text with bright magenta ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.magentaBright('test');
+                    expect(result).toBe('\x1B[95mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.magentaBright('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('cyanBright', () => {
+            describe('text', () => {
+                it('should wrap text with bright cyan ANSI codes when color is allowed', () => {
+                    delete process.env.NO_COLOR;
+                    const result = color_util_1.ColorUtil.cyanBright('test');
+                    expect(result).toBe('\x1B[96mtest\x1B[39m');
+                });
+                it('should return plain text when color is not allowed', () => {
+                    process.env.NO_COLOR = '1';
+                    const result = color_util_1.ColorUtil.cyanBright('test');
+                    expect(result).toBe('test');
+                });
+            });
+        });
+        describe('clear', () => {
+            describe('text', () => {
+                it('should remove ANSI color codes from text', () => {
+                    const coloredText = '\x1B[31mred text\x1B[39m';
+                    const result = color_util_1.ColorUtil.clear(coloredText);
+                    expect(result).toBe('red text');
+                });
+                it('should remove multiple ANSI color codes from text', () => {
+                    const coloredText = '\x1B[31mred\x1B[39m \x1B[32mgreen\x1B[39m';
+                    const result = color_util_1.ColorUtil.clear(coloredText);
+                    expect(result).toBe('red green');
+                });
+                it('should handle text without ANSI codes', () => {
+                    const plainText = 'plain text';
+                    const result = color_util_1.ColorUtil.clear(plainText);
+                    expect(result).toBe('plain text');
+                });
+                it('should handle empty string', () => {
+                    const result = color_util_1.ColorUtil.clear('');
+                    expect(result).toBe('');
+                });
+                it('should remove complex ANSI codes', () => {
+                    const complexText = '\x1B[1;31mBold Red\x1B[0m';
+                    const result = color_util_1.ColorUtil.clear(complexText);
+                    expect(result).toBe('Bold Red');
+                });
+                it('should handle text with mixed content', () => {
+                    const mixedText = 'normal \x1B[31mred\x1B[39m normal';
+                    const result = color_util_1.ColorUtil.clear(mixedText);
+                    expect(result).toBe('normal red normal');
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=color.util.unit.spec.js.map

package/dist/test/unit/util/logo.util.unit.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/unit/util/logo.util.unit.spec.js

@@ -0,0 +1,202 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_console_1 = __importDefault(require("node:console"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const color_util_1 = require("../../../util/color.util");
+const logo_util_1 = require("../../../util/logo.util");
+describe('LogoUtil Unit Test', () => {
+    const toClearLines = (lines) => lines.map(([text]) => color_util_1.ColorUtil.clear(text));
+    const logoContent = node_fs_1.default.readFileSync(node_path_1.default.resolve(__dirname, '../../../../logo'), { encoding: 'utf8' });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        // @ts-expect-error: Accessing private property for testing
+        logo_util_1.LogoUtil._content = undefined;
+    });
+    describe('[[Public Static Properties]]', () => {
+        describe('content', () => {
+            it('should read and return the logo content from file', () => {
+                expect(logo_util_1.LogoUtil.content).toBe(logoContent);
+            });
+            it('should cache the logo content after first read', () => {
+                const fsSpy = jest.spyOn(node_fs_1.default, 'readFileSync').mockReturnValue(logoContent);
+                const content1 = logo_util_1.LogoUtil.content;
+                const content2 = logo_util_1.LogoUtil.content;
+                expect(content1).toBe(logoContent);
+                expect(content2).toBe(logoContent);
+                expect(fsSpy).toHaveBeenCalledTimes(1);
+                fsSpy.mockRestore();
+            });
+            it('should not read file multiple times', () => {
+                const fsSpy = jest.spyOn(node_fs_1.default, 'readFileSync').mockReturnValue(logoContent);
+                const content1 = logo_util_1.LogoUtil.content;
+                const content2 = logo_util_1.LogoUtil.content;
+                const content3 = logo_util_1.LogoUtil.content;
+                expect(content1).toBe(logoContent);
+                expect(content2).toBe(logoContent);
+                expect(content3).toBe(logoContent);
+                expect(fsSpy).toHaveBeenCalledTimes(1);
+                fsSpy.mockRestore();
+            });
+            it('should handle file read errors gracefully', () => {
+                // @ts-expect-error: Reset private property
+                logo_util_1.LogoUtil._content = undefined;
+                const fsSpy = jest.spyOn(node_fs_1.default, 'readFileSync').mockImplementation(() => {
+                    throw new Error('File not found');
+                });
+                expect(() => logo_util_1.LogoUtil.content).toThrow('File not found');
+                fsSpy.mockRestore();
+            });
+            it('should handle missing logo file', () => {
+                // @ts-expect-error: Reset private property
+                logo_util_1.LogoUtil._content = undefined;
+                const fsSpy = jest.spyOn(node_fs_1.default, 'readFileSync').mockImplementation(() => {
+                    const error = new Error('ENOENT: no such file or directory');
+                    // @ts-expect-error: Add code property
+                    error.code = 'ENOENT';
+                    throw error;
+                });
+                expect(() => logo_util_1.LogoUtil.content).toThrow();
+                fsSpy.mockRestore();
+            });
+            it('should handle empty logo file', () => {
+                // @ts-expect-error: Reset private property
+                logo_util_1.LogoUtil._content = undefined;
+                const fsSpy = jest.spyOn(node_fs_1.default, 'readFileSync').mockReturnValue('');
+                expect(logo_util_1.LogoUtil.content).toBe('');
+                fsSpy.mockRestore();
+            });
+            it('should handle logo file with special characters', () => {
+                // @ts-expect-error: Reset private property
+                logo_util_1.LogoUtil._content = undefined;
+                const specialContent = 'Logo with 特殊字符 and émojis 🚀';
+                const fsSpy = jest.spyOn(node_fs_1.default, 'readFileSync').mockReturnValue(specialContent);
+                expect(logo_util_1.LogoUtil.content).toBe(specialContent);
+                fsSpy.mockRestore();
+            });
+        });
+    });
+    describe('[[Public Static Methods]]', () => {
+        describe('print', () => {
+            describe('onlyLogo', () => {
+                it('should print only logo when onlyLogo is true', () => {
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    logo_util_1.LogoUtil.print(true);
+                    const logoLines = toClearLines(logSpy.mock.calls);
+                    const packageJsonContent = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.resolve(__dirname, '../../../../package.json'), { encoding: 'utf8' }));
+                    expect(logoLines.join('')).not.toContain(packageJsonContent.version);
+                    logSpy.mockRestore();
+                });
+                it('should print logo with version when onlyLogo is false', () => {
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    logo_util_1.LogoUtil.print(false);
+                    const logoLines = toClearLines(logSpy.mock.calls);
+                    const packageJsonContent = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.resolve(__dirname, '../../../../package.json'), { encoding: 'utf8' }));
+                    expect(logoLines.join('')).toContain(packageJsonContent.version);
+                    logSpy.mockRestore();
+                });
+                it('should print logo with version when onlyLogo is undefined', () => {
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    logo_util_1.LogoUtil.print();
+                    const logoLines = toClearLines(logSpy.mock.calls);
+                    const packageJsonContent = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.resolve(__dirname, '../../../../package.json'), { encoding: 'utf8' }));
+                    expect(logoLines.join('')).toContain(packageJsonContent.version);
+                    logSpy.mockRestore();
+                });
+                it('should handle onlyLogo as other truthy values', () => {
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    logo_util_1.LogoUtil.print('truthy string');
+                    const logoLines = toClearLines(logSpy.mock.calls);
+                    const packageJsonContent = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.resolve(__dirname, '../../../../package.json'), { encoding: 'utf8' }));
+                    expect(logoLines.join('')).not.toContain(packageJsonContent.version);
+                    logSpy.mockRestore();
+                });
+                it('should handle onlyLogo as other falsy values', () => {
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    logo_util_1.LogoUtil.print(0);
+                    const logoLines = toClearLines(logSpy.mock.calls);
+                    const packageJsonContent = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.resolve(__dirname, '../../../../package.json'), { encoding: 'utf8' }));
+                    expect(logoLines.join('')).toContain(packageJsonContent.version);
+                    logSpy.mockRestore();
+                });
+            });
+            describe('[[No Properties]]', () => {
+                it('should use console.log for output', () => {
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    logo_util_1.LogoUtil.print();
+                    expect(logSpy).toHaveBeenCalled();
+                    logSpy.mockRestore();
+                });
+                it('should apply magenta color to logo', () => {
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    const magentaSpy = jest.spyOn(color_util_1.ColorUtil, 'magenta');
+                    logo_util_1.LogoUtil.print();
+                    expect(magentaSpy).toHaveBeenCalled();
+                    logSpy.mockRestore();
+                    magentaSpy.mockRestore();
+                });
+                it('should add empty lines before and after logo', () => {
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    logo_util_1.LogoUtil.print();
+                    const { calls } = logSpy.mock;
+                    expect(calls[0][0]).toBe('');
+                    expect(calls[calls.length - 1][0]).toBe('');
+                    logSpy.mockRestore();
+                });
+                it('should read package.json for version information', () => {
+                    const fsSpy = jest.spyOn(node_fs_1.default, 'readFileSync');
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    logo_util_1.LogoUtil.print();
+                    expect(fsSpy).toHaveBeenCalledWith(expect.stringContaining('package.json'), { encoding: 'utf8' });
+                    logSpy.mockRestore();
+                    fsSpy.mockRestore();
+                });
+                it('should handle missing package.json gracefully', () => {
+                    const originalReadFileSync = node_fs_1.default.readFileSync;
+                    const fsSpy = jest.spyOn(node_fs_1.default, 'readFileSync').mockImplementation((filePath, options) => {
+                        if (typeof filePath === 'string' && filePath.includes('package.json')) {
+                            throw new Error('File not found');
+                        }
+                        return originalReadFileSync(filePath, options);
+                    });
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    expect(() => logo_util_1.LogoUtil.print()).toThrow();
+                    logSpy.mockRestore();
+                    fsSpy.mockRestore();
+                });
+                it('should handle invalid package.json format', () => {
+                    const originalReadFileSync = node_fs_1.default.readFileSync;
+                    const fsSpy = jest.spyOn(node_fs_1.default, 'readFileSync').mockImplementation((filePath, options) => {
+                        if (typeof filePath === 'string' && filePath.includes('package.json')) {
+                            return 'invalid json content';
+                        }
+                        return originalReadFileSync(filePath, options);
+                    });
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    expect(() => logo_util_1.LogoUtil.print()).toThrow();
+                    logSpy.mockRestore();
+                    fsSpy.mockRestore();
+                });
+                it('should handle package.json without version field', () => {
+                    const originalReadFileSync = node_fs_1.default.readFileSync;
+                    const fsSpy = jest.spyOn(node_fs_1.default, 'readFileSync').mockImplementation((filePath, options) => {
+                        if (typeof filePath === 'string' && filePath.includes('package.json')) {
+                            return JSON.stringify({ name: 'test-package' });
+                        }
+                        return originalReadFileSync(filePath, options);
+                    });
+                    const logSpy = jest.spyOn(node_console_1.default, 'log').mockImplementation();
+                    logo_util_1.LogoUtil.print();
+                    const logoLines = toClearLines(logSpy.mock.calls);
+                    expect(logoLines.join('')).toContain('undefined');
+                    logSpy.mockRestore();
+                    fsSpy.mockRestore();
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=logo.util.unit.spec.js.map

package/dist/test/unit/util/run-env.util.unit.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/unit/util/run-env.util.unit.spec.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const run_env_util_1 = require("../../../util/run-env.util");
+describe('RunEnvUtil Unit Test', () => {
+    const originalEnv = process.env;
+    const originalPkg = process.pkg;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+        delete process.pkg;
+    });
+    afterEach(() => {
+        process.env = originalEnv;
+        if (originalPkg) {
+            // eslint-disable-next-line @typescript-eslint/no-extra-semi
+            ;
+            process.pkg = originalPkg;
+        }
+        else {
+            delete process.pkg;
+        }
+    });
+    describe('[[Static Public Properties]]', () => {
+        describe('[[Properties]]', () => {
+            describe('isDev', () => {
+                it('should return true when NODE_ENV is development', () => {
+                    process.env.NODE_ENV = 'development';
+                    expect(run_env_util_1.RunEnvUtil.isDev).toBe(true);
+                });
+                it('should return true when NODE_ENV is dev', () => {
+                    process.env.NODE_ENV = 'dev';
+                    expect(run_env_util_1.RunEnvUtil.isDev).toBe(true);
+                });
+                it('should return false when NODE_ENV is production', () => {
+                    process.env.NODE_ENV = 'production';
+                    expect(run_env_util_1.RunEnvUtil.isDev).toBe(false);
+                });
+                it('should return false when NODE_ENV is prod', () => {
+                    process.env.NODE_ENV = 'prod';
+                    expect(run_env_util_1.RunEnvUtil.isDev).toBe(false);
+                });
+                it('should return true and set NODE_ENV to development when NODE_ENV is not set', () => {
+                    delete process.env.NODE_ENV;
+                    expect(run_env_util_1.RunEnvUtil.isDev).toBe(true);
+                    expect(process.env.NODE_ENV).toBe('development');
+                });
+                it('should return false when NODE_ENV is test', () => {
+                    process.env.NODE_ENV = 'test';
+                    expect(run_env_util_1.RunEnvUtil.isDev).toBe(false);
+                });
+                it('should return false when NODE_ENV is staging', () => {
+                    process.env.NODE_ENV = 'staging';
+                    expect(run_env_util_1.RunEnvUtil.isDev).toBe(false);
+                });
+                it('should return false when NODE_ENV is empty string', () => {
+                    process.env.NODE_ENV = '';
+                    expect(run_env_util_1.RunEnvUtil.isDev).toBe(false);
+                });
+            });
+            describe('isProd', () => {
+                it('should return true when NODE_ENV is production', () => {
+                    process.env.NODE_ENV = 'production';
+                    expect(run_env_util_1.RunEnvUtil.isProd).toBe(true);
+                });
+                it('should return true when NODE_ENV is prod', () => {
+                    process.env.NODE_ENV = 'prod';
+                    expect(run_env_util_1.RunEnvUtil.isProd).toBe(true);
+                });
+                it('should return false when NODE_ENV is development', () => {
+                    process.env.NODE_ENV = 'development';
+                    expect(run_env_util_1.RunEnvUtil.isProd).toBe(false);
+                });
+                it('should return false when NODE_ENV is dev', () => {
+                    process.env.NODE_ENV = 'dev';
+                    expect(run_env_util_1.RunEnvUtil.isProd).toBe(false);
+                });
+                it('should return false when NODE_ENV is test', () => {
+                    process.env.NODE_ENV = 'test';
+                    expect(run_env_util_1.RunEnvUtil.isProd).toBe(false);
+                });
+                it('should return false when NODE_ENV is not set', () => {
+                    delete process.env.NODE_ENV;
+                    expect(run_env_util_1.RunEnvUtil.isProd).toBe(false);
+                });
+                it('should return false when NODE_ENV is empty string', () => {
+                    process.env.NODE_ENV = '';
+                    expect(run_env_util_1.RunEnvUtil.isProd).toBe(false);
+                });
+            });
+            describe('inPKG', () => {
+                it('should return true when process.pkg is a non-null object', () => {
+                    // eslint-disable-next-line @typescript-eslint/no-extra-semi
+                    ;
+                    process.pkg = { snapshot: true };
+                    expect(run_env_util_1.RunEnvUtil.inPKG).toBe(true);
+                });
+                it('should return false when process.pkg does not exist', () => {
+                    delete process.pkg;
+                    expect(run_env_util_1.RunEnvUtil.inPKG).toBe(false);
+                });
+                it('should return false when process.pkg is null', () => {
+                    // eslint-disable-next-line @typescript-eslint/no-extra-semi
+                    ;
+                    process.pkg = null;
+                    expect(run_env_util_1.RunEnvUtil.inPKG).toBe(false);
+                });
+                it('should return false when process.pkg is undefined', () => {
+                    // eslint-disable-next-line @typescript-eslint/no-extra-semi
+                    ;
+                    process.pkg = undefined;
+                    expect(run_env_util_1.RunEnvUtil.inPKG).toBe(false);
+                });
+                it('should return false when process.pkg is not an object', () => {
+                    // eslint-disable-next-line @typescript-eslint/no-extra-semi
+                    ;
+                    process.pkg = 'string';
+                    expect(run_env_util_1.RunEnvUtil.inPKG).toBe(false);
+                });
+                it('should return false when process.pkg is a number', () => {
+                    // eslint-disable-next-line @typescript-eslint/no-extra-semi
+                    ;
+                    process.pkg = 123;
+                    expect(run_env_util_1.RunEnvUtil.inPKG).toBe(false);
+                });
+                it('should return true when process.pkg is an empty object', () => {
+                    // eslint-disable-next-line @typescript-eslint/no-extra-semi
+                    ;
+                    process.pkg = {};
+                    expect(run_env_util_1.RunEnvUtil.inPKG).toBe(true);
+                });
+            });
+            describe('inVSCodeDebugger', () => {
+                it('should return true when VSCODE_INSPECTOR_OPTIONS is set', () => {
+                    process.env.VSCODE_INSPECTOR_OPTIONS = 'some-value';
+                    expect(run_env_util_1.RunEnvUtil.inVSCodeDebugger).toBe(true);
+                });
+                it('should return false when VSCODE_INSPECTOR_OPTIONS is not set', () => {
+                    delete process.env.VSCODE_INSPECTOR_OPTIONS;
+                    expect(run_env_util_1.RunEnvUtil.inVSCodeDebugger).toBe(false);
+                });
+                it('should return false when VSCODE_INSPECTOR_OPTIONS is undefined', () => {
+                    process.env.VSCODE_INSPECTOR_OPTIONS = undefined;
+                    expect(run_env_util_1.RunEnvUtil.inVSCodeDebugger).toBe(false);
+                });
+                it('should return true when VSCODE_INSPECTOR_OPTIONS is empty string', () => {
+                    process.env.VSCODE_INSPECTOR_OPTIONS = '';
+                    expect(run_env_util_1.RunEnvUtil.inVSCodeDebugger).toBe(true);
+                });
+                it('should return true when VSCODE_INSPECTOR_OPTIONS is set to any string', () => {
+                    process.env.VSCODE_INSPECTOR_OPTIONS = 'debug-port=9229';
+                    expect(run_env_util_1.RunEnvUtil.inVSCodeDebugger).toBe(true);
+                });
+            });
+            describe('inJest', () => {
+                it('should return true when JEST_WORKER_ID is set', () => {
+                    process.env.JEST_WORKER_ID = '1';
+                    expect(run_env_util_1.RunEnvUtil.inJest).toBe(true);
+                });
+                it('should return false when JEST_WORKER_ID is not set', () => {
+                    delete process.env.JEST_WORKER_ID;
+                    expect(run_env_util_1.RunEnvUtil.inJest).toBe(false);
+                });
+                it('should return false when JEST_WORKER_ID is undefined', () => {
+                    process.env.JEST_WORKER_ID = undefined;
+                    expect(run_env_util_1.RunEnvUtil.inJest).toBe(false);
+                });
+                it('should return true when JEST_WORKER_ID is empty string', () => {
+                    process.env.JEST_WORKER_ID = '';
+                    expect(run_env_util_1.RunEnvUtil.inJest).toBe(true);
+                });
+                it('should return true when JEST_WORKER_ID is set to any string', () => {
+                    process.env.JEST_WORKER_ID = 'worker-1';
+                    expect(run_env_util_1.RunEnvUtil.inJest).toBe(true);
+                });
+                it('should return true when JEST_WORKER_ID is set to zero', () => {
+                    process.env.JEST_WORKER_ID = '0';
+                    expect(run_env_util_1.RunEnvUtil.inJest).toBe(true);
+                });
+            });
+        });
+    });
+});
+//# sourceMappingURL=run-env.util.unit.spec.js.map