@rdrudra99/hardlog 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rdrudra99
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,342 @@
+# @rdrudra99/hardlog
+
+[![npm version](https://img.shields.io/npm/v/@rdrudra99/hardlog.svg)](https://www.npmjs.com/package/@rdrudra99/hardlog)
+[![npm downloads](https://img.shields.io/npm/dm/@rdrudra99/hardlog.svg)](https://www.npmjs.com/package/@rdrudra99/hardlog)
+[![license](https://img.shields.io/npm/l/@rdrudra99/hardlog.svg)](https://github.com/Rdrudra99/hardlog/blob/main/LICENSE)
+[![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
+
+Beautiful, colorful dev-only logging for Node.js and Browser with **zero configuration**.
+
+Automatically detects your runtime environment and applies appropriate styling:
+- 🎨 **Node.js**: ANSI colors in terminal
+- 🌐 **Browser**: CSS-styled console messages
+- 🔒 **Production-safe**: Automatically disabled in production
+- 🚀 **Zero dependencies**: No external libraries needed
+
+## Installation
+
+```bash
+bun add @rdrudra99/hardlog
+```
+
+```bash
+npm install @rdrudra99/hardlog
+```
+
+```bash
+yarn add @rdrudra99/hardlog
+```
+
+```bash
+pnpm add @rdrudra99/hardlog
+```
+
+## Basic Usage
+
+```typescript
+import log from '@rdrudra99/hardlog';
+
+log.success('Server started successfully!');
+log.error('Database connection failed');
+log.warn('Missing environment variable');
+log.info('Listening on port 3000');
+```
+
+### Output in Node.js Terminal
+```
+✔ SUCCESS    Server started successfully!
+✖ ERROR      Database connection failed
+⚠ WARNING    Missing environment variable
+ℹ INFO       Listening on port 3000
+```
+
+### Output in Browser DevTools
+![Browser console with styled log messages](https://via.placeholder.com/800x200.png?text=Styled+Console+Messages)
+
+## Examples
+
+### Node.js / Express
+
+```typescript
+import express from 'express';
+import log from '@rdrudra99/hardlog';
+
+const app = express();
+const PORT = 3000;
+
+app.get('/', (req, res) => {
+  log.info(`${req.method} ${req.path}`);
+  res.send('Hello World!');
+});
+
+app.listen(PORT, () => {
+  log.success(`Server running on http://localhost:${PORT}`);
+});
+```
+
+### Next.js - App Router (Server Component)
+
+```typescript
+// app/page.tsx
+import log from '@rdrudra99/hardlog';
+
+export default async function HomePage() {
+  // This runs on the server
+  log.info('Rendering home page');
+  
+  const data = await fetchData();
+  log.success('Data fetched successfully');
+  
+  return <div>{data.title}</div>;
+}
+```
+
+### Next.js - App Router (Client Component)
+
+```typescript
+'use client';
+
+import { useEffect } from 'react';
+import log from '@rdrudra99/hardlog';
+
+export default function ClientComponent() {
+  useEffect(() => {
+    // This runs in the browser
+    log.success('Client component mounted');
+    
+    return () => {
+      log.info('Client component unmounted');
+    };
+  }, []);
+  
+  const handleClick = () => {
+    log.info('Button clicked');
+  };
+  
+  return <button onClick={handleClick}>Click me</button>;
+}
+```
+
+### Next.js - Pages Router
+
+```typescript
+// pages/index.tsx
+import { GetServerSideProps } from 'next';
+import log from '@rdrudra99/hardlog';
+
+export const getServerSideProps: GetServerSideProps = async () => {
+  log.info('Fetching data for page');
+  
+  const data = await fetchData();
+  log.success('Data loaded');
+  
+  return { props: { data } };
+};
+
+export default function Page({ data }) {
+  return <div>{data.title}</div>;
+}
+```
+
+### Browser-Only App
+
+```typescript
+import log from '@rdrudra99/hardlog';
+
+document.addEventListener('DOMContentLoaded', () => {
+  log.success('DOM loaded');
+  
+  const button = document.querySelector('#myButton');
+  button?.addEventListener('click', () => {
+    log.info('Button clicked');
+  });
+});
+```
+
+## API Reference
+
+### `log.success(message: string): void`
+Log a success message with green styling.
+
+```typescript
+log.success('Operation completed successfully');
+```
+
+### `log.error(message: string): void`
+Log an error message with red styling.
+
+```typescript
+log.error('Failed to connect to database');
+```
+
+### `log.warn(message: string): void`
+Log a warning message with yellow/orange styling.
+
+```typescript
+log.warn('API key is missing');
+```
+
+### `log.info(message: string): void`
+Log an info message with blue styling.
+
+```typescript
+log.info('Server is starting...');
+```
+
+### `log.config(options: LoggerConfig): typeof log`
+Configure logger options. Returns the log object for chaining.
+
+```typescript
+log.config({ 
+  enabled: true, 
+  showTimestamp: true 
+});
+```
+
+#### Configuration Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `enabled` | `boolean` | `true` in dev, `false` in production | Enable or disable logging |
+| `showTimestamp` | `boolean` | `false` | Show timestamp in log messages |
+
+### Configuration Examples
+
+#### Enable timestamps
+
+```typescript
+import log from '@rdrudra99/hardlog';
+
+log.config({ showTimestamp: true });
+
+log.info('Server started');
+// Output: ℹ INFO  [10:30:45 AM] Server started
+```
+
+#### Force enable in production (NOT RECOMMENDED)
+
+```typescript
+import log from '@rdrudra99/hardlog';
+
+// ⚠️ Only do this if you understand the implications
+log.config({ enabled: true });
+```
+
+#### Chain configuration
+
+```typescript
+import log from '@rdrudra99/hardlog';
+
+log
+  .config({ showTimestamp: true })
+  .success('Configured and ready!');
+```
+
+## ⚠️ Dev-Only Warning
+
+**This package is designed for development use only.**
+
+By default, all logging is **automatically disabled** when `NODE_ENV === 'production'`.
+
+This ensures:
+- No performance overhead in production
+- No sensitive information leaks
+- Clean production logs
+- Zero impact on bundle size behavior
+
+### How it works
+
+```typescript
+// Automatically disabled in production
+process.env.NODE_ENV = 'production';
+
+log.info('This will NOT appear'); // Silent in production
+```
+
+To explicitly enable in production (not recommended):
+
+```typescript
+log.config({ enabled: true });
+```
+
+## Features
+
+✅ **Zero Configuration** - Works immediately after install  
+✅ **Environment Detection** - Auto-detects Node.js vs Browser  
+✅ **Production Safe** - Disabled by default in production  
+✅ **TypeScript Support** - Full type definitions included  
+✅ **Zero Dependencies** - No external packages  
+✅ **Lightweight** - Minimal footprint  
+✅ **SSR Compatible** - Works with Next.js, Remix, etc.  
+✅ **Edge Runtime Safe** - Won't crash in Vercel, Cloudflare Workers  
+✅ **Never Throws** - Fails silently, never breaks your app  
+
+## Requirements
+
+- Node.js >= 14.0.0
+- Bun >= 1.0.0
+- Modern browser with console support
+
+## TypeScript
+
+This package is written in TypeScript and ships with type definitions.
+
+```typescript
+import log, { LoggerConfig } from '@rdrudra99/hardlog';
+
+const config: LoggerConfig = {
+  enabled: true,
+  showTimestamp: false,
+};
+
+log.config(config);
+```
+
+## Browser Support
+
+Works in all modern browsers that support:
+- `console.log` with CSS styling (`%c`)
+- ES2018 features
+
+Tested in:
+- Chrome/Edge (latest)
+- Firefox (latest)
+- Safari (latest)
+
+## Node.js Support
+
+Works in:
+- Bun (recommended)
+- Node.js 14+
+- Deno (with npm compatibility)
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT © Rdrudra99
+
+## Related Projects
+
+- [chalk](https://github.com/chalk/chalk) - Terminal string styling
+- [consola](https://github.com/unjs/consola) - Elegant Console Logger
+- [pino](https://github.com/pinojs/pino) - Super fast logger
+
+## Why Another Logger?
+
+Most logging libraries are either:
+- Too heavy (large dependencies)
+- Node.js only
+- Browser only
+- Require configuration
+- Not production-safe by default
+
+`@rdrudra99/hardlog` is designed specifically for the **developer experience** during development, with:
+- Automatic environment detection
+- Zero configuration
+- Production safety built-in
+- Works everywhere (Node + Browser)
+
+Perfect for quick debugging, prototyping, and development workflows.

package/dist/env.d.ts

@@ -0,0 +1,21 @@
+import type { RuntimeEnvironment } from './types';
+/**
+ * Safely detect if we're in a browser environment
+ */
+export declare function isBrowser(): boolean;
+/**
+ * Safely detect if we're in a Node.js environment
+ */
+export declare function isNode(): boolean;
+/**
+ * Detect the current runtime environment
+ */
+export declare function detectEnvironment(): RuntimeEnvironment;
+/**
+ * Check if we're in production mode
+ */
+export declare function isProduction(): boolean;
+/**
+ * Check if logging should be enabled by default
+ */
+export declare function shouldLogByDefault(): boolean;

package/dist/env.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBrowser = isBrowser;
+exports.isNode = isNode;
+exports.detectEnvironment = detectEnvironment;
+exports.isProduction = isProduction;
+exports.shouldLogByDefault = shouldLogByDefault;
+/**
+ * Safely detect if we're in a browser environment
+ */
+function isBrowser() {
+    try {
+        return typeof window !== 'undefined' && typeof window.document !== 'undefined';
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Safely detect if we're in a Node.js environment
+ */
+function isNode() {
+    try {
+        return (typeof process !== 'undefined' &&
+            process.versions != null &&
+            process.versions.node != null);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Detect the current runtime environment
+ */
+function detectEnvironment() {
+    try {
+        if (isBrowser()) {
+            return 'browser';
+        }
+        if (isNode()) {
+            return 'node';
+        }
+        return 'unknown';
+    }
+    catch (_a) {
+        return 'unknown';
+    }
+}
+/**
+ * Check if we're in production mode
+ */
+function isProduction() {
+    try {
+        if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV) {
+            return process.env.NODE_ENV === 'production';
+        }
+        return false;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+/**
+ * Check if logging should be enabled by default
+ */
+function shouldLogByDefault() {
+    return !isProduction();
+}

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+import type { LoggerConfig } from './types';
+/**
+ * Dev-only logger with beautiful, colorful output
+ *
+ * Automatically detects Node.js or Browser environment and applies appropriate styling.
+ * Disabled by default in production (NODE_ENV === 'production').
+ *
+ * @example
+ * ```ts
+ * import log from '@rdrudra99/hardlog';
+ *
+ * log.success('Server started successfully!');
+ * log.error('Database connection failed');
+ * log.warn('Missing environment variable');
+ * log.info('Listening on port 3000');
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Configure logger
+ * import log from '@rdrudra99/hardlog';
+ *
+ * log.config({ enabled: true, showTimestamp: true });
+ * ```
+ */
+declare const log: {
+    /**
+     * Log a success message
+     */
+    success: (message: string) => void;
+    /**
+     * Log an error message
+     */
+    error: (message: string) => void;
+    /**
+     * Log a warning message
+     */
+    warn: (message: string) => void;
+    /**
+     * Log an info message
+     */
+    info: (message: string) => void;
+    /**
+     * Configure logger options
+     */
+    config: (options: LoggerConfig) => /*elided*/ any;
+};
+export default log;
+export type { LoggerConfig };

package/dist/index.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("./logger");
+/**
+ * Dev-only logger with beautiful, colorful output
+ *
+ * Automatically detects Node.js or Browser environment and applies appropriate styling.
+ * Disabled by default in production (NODE_ENV === 'production').
+ *
+ * @example
+ * ```ts
+ * import log from '@rdrudra99/hardlog';
+ *
+ * log.success('Server started successfully!');
+ * log.error('Database connection failed');
+ * log.warn('Missing environment variable');
+ * log.info('Listening on port 3000');
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Configure logger
+ * import log from '@rdrudra99/hardlog';
+ *
+ * log.config({ enabled: true, showTimestamp: true });
+ * ```
+ */
+const log = {
+    /**
+     * Log a success message
+     */
+    success: (message) => logger_1.logger.success(message),
+    /**
+     * Log an error message
+     */
+    error: (message) => logger_1.logger.error(message),
+    /**
+     * Log a warning message
+     */
+    warn: (message) => logger_1.logger.warn(message),
+    /**
+     * Log an info message
+     */
+    info: (message) => logger_1.logger.info(message),
+    /**
+     * Configure logger options
+     */
+    config: (options) => {
+        logger_1.logger.configure(options);
+        return log;
+    },
+};
+exports.default = log;

package/dist/logger.d.ts

@@ -0,0 +1,50 @@
+import type { LoggerConfig } from './types';
+/**
+ * Logger class - handles all logging operations
+ */
+declare class Logger {
+    private config;
+    private runtime;
+    constructor();
+    /**
+     * Configure logger options
+     */
+    configure(options: LoggerConfig): this;
+    /**
+     * Get current timestamp string
+     */
+    private getTimestamp;
+    /**
+     * Log message in Node.js with ANSI colors
+     */
+    private logNode;
+    /**
+     * Log message in browser with CSS styling
+     */
+    private logBrowser;
+    /**
+     * Core log method - routes to appropriate handler
+     */
+    private log;
+    /**
+     * Log success message
+     */
+    success(message: string): void;
+    /**
+     * Log error message
+     */
+    error(message: string): void;
+    /**
+     * Log warning message
+     */
+    warn(message: string): void;
+    /**
+     * Log info message
+     */
+    info(message: string): void;
+}
+/**
+ * Singleton logger instance
+ */
+export declare const logger: Logger;
+export {};

package/dist/logger.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+const env_1 = require("./env");
+/**
+ * ANSI color codes for Node.js terminal
+ */
+const ANSI_COLORS = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[36m',
+};
+/**
+ * CSS styles for browser console
+ */
+const BROWSER_STYLES = {
+    success: 'background: #10b981; color: white; padding: 2px 6px; border-radius: 3px; font-weight: bold;',
+    error: 'background: #ef4444; color: white; padding: 2px 6px; border-radius: 3px; font-weight: bold;',
+    warn: 'background: #f59e0b; color: white; padding: 2px 6px; border-radius: 3px; font-weight: bold;',
+    info: 'background: #3b82f6; color: white; padding: 2px 6px; border-radius: 3px; font-weight: bold;',
+};
+/**
+ * Log level symbols and labels
+ */
+const LOG_CONFIG = {
+    success: { symbol: '✔', label: 'SUCCESS', color: ANSI_COLORS.green },
+    error: { symbol: '✖', label: 'ERROR', color: ANSI_COLORS.red },
+    warn: { symbol: '⚠', label: 'WARNING', color: ANSI_COLORS.yellow },
+    info: { symbol: 'ℹ', label: 'INFO', color: ANSI_COLORS.blue },
+};
+/**
+ * Logger class - handles all logging operations
+ */
+class Logger {
+    constructor() {
+        this.runtime = (0, env_1.detectEnvironment)();
+        this.config = {
+            enabled: (0, env_1.shouldLogByDefault)(),
+            showTimestamp: false,
+        };
+    }
+    /**
+     * Configure logger options
+     */
+    configure(options) {
+        try {
+            if (options.enabled !== undefined) {
+                this.config.enabled = options.enabled;
+            }
+            if (options.showTimestamp !== undefined) {
+                this.config.showTimestamp = options.showTimestamp;
+            }
+        }
+        catch (_a) {
+            // Fail silently
+        }
+        return this;
+    }
+    /**
+     * Get current timestamp string
+     */
+    getTimestamp() {
+        try {
+            const now = new Date();
+            return `[${now.toLocaleTimeString()}]`;
+        }
+        catch (_a) {
+            return '';
+        }
+    }
+    /**
+     * Log message in Node.js with ANSI colors
+     */
+    logNode(level, message) {
+        try {
+            const cfg = LOG_CONFIG[level];
+            const timestamp = this.config.showTimestamp ? `${this.getTimestamp()} ` : '';
+            const formattedMessage = `${cfg.color}${cfg.symbol} ${cfg.label.padEnd(10)}${ANSI_COLORS.reset} ${timestamp}${message}`;
+            console.log(formattedMessage);
+        }
+        catch (_a) {
+            // Fail silently
+        }
+    }
+    /**
+     * Log message in browser with CSS styling
+     */
+    logBrowser(level, message) {
+        try {
+            const cfg = LOG_CONFIG[level];
+            const timestamp = this.config.showTimestamp ? `${this.getTimestamp()} ` : '';
+            const label = `${cfg.symbol} ${cfg.label}`;
+            console.log(`%c${label}%c ${timestamp}${message}`, BROWSER_STYLES[level], '');
+        }
+        catch (_a) {
+            // Fail silently
+        }
+    }
+    /**
+     * Core log method - routes to appropriate handler
+     */
+    log(level, message) {
+        // Don't log if disabled
+        if (!this.config.enabled) {
+            return;
+        }
+        try {
+            // Convert message to string safely
+            const msg = String(message !== null && message !== void 0 ? message : '');
+            if (this.runtime === 'node') {
+                this.logNode(level, msg);
+            }
+            else if (this.runtime === 'browser') {
+                this.logBrowser(level, msg);
+            }
+            else {
+                // Fallback to plain console.log
+                console.log(`[${level.toUpperCase()}]`, msg);
+            }
+        }
+        catch (_a) {
+            // Fail silently - never break user's app
+        }
+    }
+    /**
+     * Log success message
+     */
+    success(message) {
+        this.log('success', message);
+    }
+    /**
+     * Log error message
+     */
+    error(message) {
+        this.log('error', message);
+    }
+    /**
+     * Log warning message
+     */
+    warn(message) {
+        this.log('warn', message);
+    }
+    /**
+     * Log info message
+     */
+    info(message) {
+        this.log('info', message);
+    }
+}
+/**
+ * Singleton logger instance
+ */
+exports.logger = new Logger();

package/dist/types.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Configuration options for the logger
+ */
+export interface LoggerConfig {
+    /**
+     * Enable or disable logging
+     * @default true in development, false in production
+     */
+    enabled?: boolean;
+    /**
+     * Show timestamp in logs
+     * @default false
+     */
+    showTimestamp?: boolean;
+}
+/**
+ * Runtime environment type
+ */
+export type RuntimeEnvironment = 'node' | 'browser' | 'unknown';
+/**
+ * Log level type
+ */
+export type LogLevel = 'success' | 'error' | 'warn' | 'info';

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@rdrudra99/hardlog",
+  "version": "0.1.0",
+  "description": "Beautiful, colorful dev-only logging for Node.js and Browser with zero configuration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "bun run build",
+    "watch": "tsc --watch",
+    "dev": "tsc --watch",
+    "test": "bun test-manual.js",
+    "clean": "rm -rf dist/"
+  },
+  "keywords": [
+    "logger",
+    "logging",
+    "dev",
+    "development",
+    "console",
+    "color",
+    "colors",
+    "pretty",
+    "terminal",
+    "browser",
+    "node",
+    "typescript",
+    "bun",
+    "nextjs",
+    "express",
+    "debug",
+    "ansi",
+    "styled",
+    "zero-config",
+    "dev-tools"
+  ],
+  "author": "Rdrudra99",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Rdrudra99/hardlog.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Rdrudra99/hardlog/issues"
+  },
+  "homepage": "https://github.com/Rdrudra99/hardlog#readme",
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}