@ylsoo/core 1.0.0 → 2.0.0

package/README.md

@@ -1,19 +1,94 @@
-# @ylsoo/core
+<div align="center">
+  <h1>@ylsoo/core (v2.0 Enterprise)</h1>
+  <p><b>The official, enterprise-grade SDK powering advanced Ylsoo web and server products.</b></p>
+  
+  [![npm version](https://img.shields.io/npm/v/@ylsoo/core.svg?style=flat-square)](https://www.npmjs.com/package/@ylsoo/core)
+  [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+  [![TypeScript Ready](https://img.shields.io/badge/TypeScript-Ready-blue?style=flat-square&logo=typescript)](https://www.typescriptlang.org/)
+  [![Cross-Platform](https://img.shields.io/badge/Cross--Platform-Node.js%20%7C%20Browser-brightgreen?style=flat-square)](#)
+</div>
 
-Core utility functions for Ylsoo projects.
+<hr>
 
-## Installation
+## 🚀 Overview
+
+`@ylsoo/core` v2 has been completely rewritten into a powerful, modular architecture. It provides blazing-fast utility functions designed specifically for Ylsoo services. It runs identically on **modern browsers** and **Node.js** servers thanks to custom polyfills acting entirely natively, without a single external dependency!
+
+## 📦 Installation
 
 ```bash
 npm i @ylsoo/core
 ```
 
-## Usage
+## 🛠️ API Reference
 
+### 1. 🔐 Distributed Security (`ylsoo.crypto`)
+Leverages Web Crypto API natively to perform secure operations identically across browsers and servers.
 ```javascript
 const ylsoo = require('@ylsoo/core');
 
-ylsoo.log('Hello World');
-console.log(ylsoo.capitalize('hello'));
-console.log(ylsoo.isEmpty(''));
+// 1. Generate Secure V4 UUIDs
+const sessionID = ylsoo.crypto.uuid();
+
+// 2. Hash strings natively
+const secretHash = await ylsoo.crypto.hash('my_super_secret');
+
+// 3. Encode/Decode Base64
+const encoded = ylsoo.crypto.encodeBase64('user:pass');
+```
+
+### 2. ⚡ Event Bus (`ylsoo.events`)
+An enterprise Publisher/Subscriber mechanism to handle inter-component state within Ylsoo frontends or microservices.
+```javascript
+// Component A (Subscribes)
+const unsubscribe = ylsoo.events.on('user:login', (user) => {
+  console.log('Welcome back,', user.name);
+});
+
+// Component B (Publishes)
+ylsoo.events.emit('user:login', { name: 'Admin' });
+
+// Listen exactly once
+ylsoo.events.once('system:boot', bootFunction);
+```
+
+### 3. 🌐 Ylsoo Request Engine (`ylsoo.http`)
+A robust wrapper around the versatile `fetch` API. It handles JSON stringification, applies custom headers, parses JSON, and safely formats errors automatically.
+```javascript
+async function fetchUserData() {
+  try {
+    const data = await ylsoo.http.get('https://api.ylsoo.com/v1/user/me');
+  } catch (error) {
+    ylsoo.logger.error('Failed to fetch user', error);
+  }
+}
+```
+
+### 4. 🧠 Ylsoo Memory Cache (`ylsoo.cache`)
+A volatile in-memory Map structure featuring native Time-To-Live (TTL) functionality.
+```javascript
+// Cache an object for 5000 ms (5 seconds)
+ylsoo.cache.set('session', { id: 123 }, 5000);
+const session = ylsoo.cache.get('session');
+```
+
+### 5. 🖥️ Ylsoo Console (`ylsoo.logger`)
+Formatted console utility employing native ANSI escape codes specifically designed for local backends.
+```javascript
+ylsoo.logger.info('System initializing...');
+ylsoo.logger.success('Database connected successfully!');
+ylsoo.logger.warn('Rate limit approaching.');
+ylsoo.logger.error('Critical failure detected.');
 ```
+
+### 6. 🧰 Native Enterprise Utilies 
+- **`ylsoo.sleep(ms)`**: Promise-based execution halter.
+- **`ylsoo.deepClone(obj)`**: Safely deep clones utilizing native modern standards like `structuredClone` when available.
+- **`ylsoo.debounce(func, wait)`**: High performance throttling mechanics.
+- **`ylsoo.isEmpty(val)`**: Semantic entity verification (detects empty Sets, Maps, Objects, Strings, Arrays).
+- **`ylsoo.capitalize(str)`**: Automatic string standardizer.
+
+---
+<div align="center">
+  <p>Built with ❤️ by <b>Ylsoo</b>.</p>
+</div>

package/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @ylsoo/core v2.0.0 Type Definitions
+ * Cross-platform Enterprise SDK
+ */
+
+declare module '@ylsoo/core' {
+
+  // --- Core Modules ---
+
+  export class YlsooLogger {
+      info(message: string | any): void;
+      success(message: string | any): void;
+      warn(message: string | any): void;
+      error(message: string | any): void;
+  }
+
+  export class YlsooCache {
+      set(key: string, value: any, ttlMs?: number): void;
+      get<T = any>(key: string): T | null;
+      delete(key: string): boolean;
+      clear(): void;
+  }
+
+  export interface YlsooHttpOptions {
+      method?: string;
+      headers?: Record<string, string>;
+      body?: any;
+      [key: string]: any;
+  }
+
+  export class YlsooHttp {
+      request<T = any>(endpoint: string, options?: YlsooHttpOptions): Promise<T>;
+      get<T = any>(endpoint: string, headers?: Record<string, string>): Promise<T>;
+      post<T = any>(endpoint: string, body: any, headers?: Record<string, string>): Promise<T>;
+  }
+
+  // --- Security Modules ---
+
+  export class YlsooCrypto {
+      /** Base64 encodes a utf-8 string securely */
+      encodeBase64(str: string): string;
+      
+      /** Base64 decodes a string */
+      decodeBase64(base64: string): string;
+      
+      /** Natively generates a secure SHA-256 hash */
+      hash(str: string): Promise<string>;
+
+      /** Generates a cryptographically strong v4 UUID */
+      uuid(): string;
+  }
+
+  // --- Event Modules ---
+
+  export class YlsooEventBus {
+      /** Subscribe to an event. Returns an unsubscribe function. */
+      on(event: string, callback: (data?: any) => void): () => void;
+      
+      /** Unsubscribe from an event. */
+      off(event: string, callback: (data?: any) => void): void;
+      
+      /** Publish an event to all subscribers. */
+      emit(event: string, data?: any): void;
+
+      /** Subscribe to an event, un-subscribing immediately after first emission. */
+      once(event: string, callback: (data?: any) => void): void;
+
+      /** clear all event listeners */
+      clear(): void;
+  }
+
+  // --- Main Export ---
+
+  export class YlsooCore {
+      version: string;
+      
+      // Systems
+      logger: YlsooLogger;
+      cache: YlsooCache;
+      http: YlsooHttp;
+      crypto: YlsooCrypto;
+      events: YlsooEventBus;
+
+      // Utilities
+      sleep(ms: number): Promise<void>;
+      deepClone<T>(obj: T): T;
+      debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
+      isEmpty(value: any): boolean;
+      capitalize(str: string): string;
+  }
+
+  const ylsoo: YlsooCore;
+  export default ylsoo;
+}

package/package.json

@@ -1,17 +1,30 @@
 {
   "name": "@ylsoo/core",
-  "version": "1.0.0",
-  "description": "Core utility functions for Ylsoo projects",
-  "main": "index.js",
+  "version": "2.0.0",
+  "description": "Enterprise cross-platform SDK for Ylsoo projects",
+  "main": "src/index.js",
+  "types": "index.d.ts",
+  "files": [
+    "src/",
+    "index.d.ts",
+    "README.md"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node test.js"
   },
   "keywords": [
     "ylsoo",
     "core",
-    "utilities"
+    "enterprise",
+    "sdk",
+    "fetch",
+    "logger",
+    "cache",
+    "crypto",
+    "uuid",
+    "events"
   ],
-  "author": "",
-  "license": "ISC",
+  "author": "Ylsoo",
+  "license": "MIT",
   "type": "commonjs"
 }

package/src/core/cache.js

@@ -0,0 +1,31 @@
+class YlsooCache {
+  constructor() {
+    this.store = new Map();
+  }
+
+  set(key, value, ttlMs = 0) {
+    const expiresAt = ttlMs > 0 ? Date.now() + ttlMs : null;
+    this.store.set(key, { value, expiresAt });
+  }
+
+  get(key) {
+    const item = this.store.get(key);
+    if (!item) return null;
+
+    if (item.expiresAt && Date.now() > item.expiresAt) {
+      this.store.delete(key);
+      return null;
+    }
+    return item.value;
+  }
+
+  delete(key) {
+    return this.store.delete(key);
+  }
+
+  clear() {
+    this.store.clear();
+  }
+}
+
+module.exports = { YlsooCache };

package/src/core/logger.js

@@ -0,0 +1,39 @@
+class YlsooLogger {
+  constructor() {
+    this.colors = {
+      reset: "\x1b[0m",
+      info: "\x1b[36m",    // Cyan
+      success: "\x1b[32m", // Green
+      warn: "\x1b[33m",    // Yellow
+      error: "\x1b[31m",   // Red
+      ylsoo: "\x1b[35m"    // Magenta
+    };
+  }
+
+  _format(level, message, color) {
+    // Only use colors in Node.js, not browsers. Check process briefly.
+    const isNode = typeof process !== 'undefined' && process.versions && process.versions.node;
+    if (isNode) {
+      return `${this.colors.ylsoo}[Ylsoo]${this.colors.reset} ${color}[${level.toUpperCase()}]${this.colors.reset} ${message}`;
+    }
+    return `[Ylsoo] [${level.toUpperCase()}] ${message}`;
+  }
+
+  info(message) {
+    console.log(this._format('info', message, this.colors.info));
+  }
+
+  success(message) {
+    console.log(this._format('success', message, this.colors.success));
+  }
+
+  warn(message) {
+    console.warn(this._format('warn', message, this.colors.warn));
+  }
+
+  error(message) {
+    console.error(this._format('error', message, this.colors.error));
+  }
+}
+
+module.exports = { YlsooLogger };

package/src/events/bus.js

@@ -0,0 +1,69 @@
+class YlsooEventBus {
+  constructor() {
+    this.events = {};
+  }
+
+  /**
+   * Subscribe to an event
+   * @param {string} event 
+   * @param {Function} callback 
+   * @returns {Function} Unsubscribe function
+   */
+  on(event, callback) {
+    if (!this.events[event]) {
+      this.events[event] = [];
+    }
+    this.events[event].push(callback);
+
+    // Return an un-subscriber
+    return () => this.off(event, callback);
+  }
+
+  /**
+   * Unsubscribe from an event
+   * @param {string} event 
+   * @param {Function} callback 
+   */
+  off(event, callback) {
+    if (!this.events[event]) return;
+    this.events[event] = this.events[event].filter(cb => cb !== callback);
+  }
+
+  /**
+   * Publish an event with optional payload
+   * @param {string} event 
+   * @param {*} data 
+   */
+  emit(event, data) {
+    if (!this.events[event]) return;
+    this.events[event].forEach(callback => {
+      try {
+        callback(data);
+      } catch (err) {
+        console.error(`[Ylsoo Event Bus] Error in callback for event "${event}":`, err);
+      }
+    });
+  }
+
+  /**
+   * Listen for an event exactly once
+   * @param {string} event 
+   * @param {Function} callback 
+   */
+  once(event, callback) {
+    const wrapper = (data) => {
+      this.off(event, wrapper);
+      callback(data);
+    };
+    this.on(event, wrapper);
+  }
+
+  /**
+   * Clear all events
+   */
+  clear() {
+    this.events = {};
+  }
+}
+
+module.exports = { YlsooEventBus };

package/src/http/client.js

@@ -0,0 +1,49 @@
+class YlsooHttp {
+  async request(endpoint, options = {}) {
+    const defaultHeaders = {
+      'Content-Type': 'application/json',
+      'User-Agent': 'Ylsoo-Core/2.0'
+    };
+
+    const config = {
+      ...options,
+      headers: {
+        ...defaultHeaders,
+        ...options.headers
+      }
+    };
+
+    if (config.body && typeof config.body === 'object') {
+      config.body = JSON.stringify(config.body);
+    }
+
+    try {
+      const response = await fetch(endpoint, config);
+      const isJson = response.headers.get('content-type')?.includes('application/json');
+      
+      const data = isJson ? await response.json() : await response.text();
+
+      if (!response.ok) {
+        throw {
+          status: response.status,
+          message: response.statusText,
+          data
+        };
+      }
+
+      return data;
+    } catch (error) {
+      throw new Error(`[Ylsoo HTTP Error]: ${error.message || JSON.stringify(error)}`);
+    }
+  }
+
+  get(endpoint, headers = {}) {
+    return this.request(endpoint, { method: 'GET', headers });
+  }
+
+  post(endpoint, body, headers = {}) {
+    return this.request(endpoint, { method: 'POST', body, headers });
+  }
+}
+
+module.exports = { YlsooHttp };

package/src/index.js

@@ -0,0 +1,36 @@
+/**
+ * @ylsoo/core v2.0.0
+ * Enterprise utilities for both Node.js and the Web.
+ */
+
+const { YlsooHttp } = require('./http/client');
+const { YlsooLogger } = require('./core/logger');
+const { YlsooCache } = require('./core/cache');
+const { YlsooCrypto } = require('./security/crypto');
+const { YlsooEventBus } = require('./events/bus');
+const { YlsooHelpers } = require('./utils/helpers');
+
+class YlsooCore {
+  constructor() {
+    this.version = '2.0.0';
+    
+    // Core Modules
+    this.http = new YlsooHttp();
+    this.logger = new YlsooLogger();
+    this.cache = new YlsooCache();
+    
+    // Advanced Modules
+    this.crypto = new YlsooCrypto();
+    this.events = new YlsooEventBus();
+    this.helpers = new YlsooHelpers();
+  }
+
+  // --- Helper Proxies to keep backwards compatibility with v1.1.0 ---
+  sleep(ms) { return this.helpers.sleep(ms); }
+  deepClone(obj) { return this.helpers.deepClone(obj); }
+  debounce(func, wait) { return this.helpers.debounce(func, wait); }
+  isEmpty(val) { return this.helpers.isEmpty(val); }
+  capitalize(str) { return this.helpers.capitalize(str); }
+}
+
+module.exports = new YlsooCore();

package/src/security/crypto.js

@@ -0,0 +1,67 @@
+class YlsooCrypto {
+  /**
+   * Base64 encode a string
+   * @param {string} str 
+   * @returns {string}
+   */
+  encodeBase64(str) {
+    if (typeof globalThis.btoa === 'function') {
+      return globalThis.btoa(str);
+    }
+    return Buffer.from(str).toString('base64');
+  }
+
+  /**
+   * Base64 decode a string
+   * @param {string} base64 
+   * @returns {string}
+   */
+  decodeBase64(base64) {
+    if (typeof globalThis.atob === 'function') {
+      return globalThis.atob(base64);
+    }
+    return Buffer.from(base64, 'base64').toString('utf-8');
+  }
+
+  /**
+   * Creates a SHA-256 hash of a string natively
+   * @param {string} str 
+   * @returns {Promise<string>}
+   */
+  async hash(str) {
+    // Attempt standard Web Crypto API (Browser + Modern Node)
+    if (globalThis.crypto && globalThis.crypto.subtle) {
+      const msgBuffer = new TextEncoder().encode(str);
+      const hashBuffer = await globalThis.crypto.subtle.digest('SHA-256', msgBuffer);
+      const hashArray = Array.from(new Uint8Array(hashBuffer));
+      return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+    
+    // Fallback for older Node.js contexts
+    try {
+      const crypto = require('crypto');
+      return crypto.createHash('sha256').update(str).digest('hex');
+    } catch(err) {
+      throw new Error('[Ylsoo Crypto Error] No secure hashing engine available on this platform.');
+    }
+  }
+
+  /**
+   * Generate a secure random v4 UUID
+   * @returns {string}
+   */
+  uuid() {
+    if (globalThis.crypto && typeof globalThis.crypto.randomUUID === 'function') {
+      return globalThis.crypto.randomUUID();
+    }
+    
+    // Fallback UUID v4 generator
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+      const r = Math.random() * 16 | 0;
+      const v = c === 'x' ? r : (r & 0x3 | 0x8);
+      return v.toString(16);
+    });
+  }
+}
+
+module.exports = { YlsooCrypto };

package/src/utils/helpers.js

@@ -0,0 +1,43 @@
+class YlsooHelpers {
+  sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  deepClone(obj) {
+    if (typeof structuredClone === 'function') {
+      return structuredClone(obj);
+    }
+    return JSON.parse(JSON.stringify(obj));
+  }
+
+  debounce(func, wait) {
+    let timeout;
+    return function executedFunction(...args) {
+      const later = () => {
+        clearTimeout(timeout);
+        func(...args);
+      };
+      clearTimeout(timeout);
+      timeout = setTimeout(later, wait);
+    };
+  }
+
+  isEmpty(value) {
+    if (value === null || value === undefined) return true;
+    if (typeof value === 'string' || Array.isArray(value)) return value.length === 0;
+    if (typeof value === 'object') {
+      if (value instanceof Map || value instanceof Set) return value.size === 0;
+      return Object.keys(value).length === 0;
+    }
+    return false;
+  }
+  
+  capitalize(str) {
+    if (typeof str !== 'string' || str.length === 0) {
+      return str;
+    }
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+}
+
+module.exports = { YlsooHelpers };

package/index.js

@@ -1,43 +0,0 @@
-/**
- * Ylsoo Core - Basic utility functions
- */
-
-class YlsooCore {
-  constructor() {
-    this.version = '1.0.0';
-  }
-
-  /**
-   * Logs a message with prefix
-   * @param {string} message - The message to log
-   */
-  log(message) {
-    console.log(`[Ylsoo Core] ${message}`);
-  }
-
-  /**
-   * Simple utility to capitalize a string
-   * @param {string} str - The string to capitalize
-   * @returns {string} Capitalized string
-   */
-  capitalize(str) {
-    if (typeof str !== 'string' || str.length === 0) {
-      return str;
-    }
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-
-  /**
-   * Simple utility to check if value is empty
-   * @param {*} value - The value to check
-   * @returns {boolean} True if empty
-   */
-  isEmpty(value) {
-    if (value === null || value === undefined) return true;
-    if (typeof value === 'string' || Array.isArray(value)) return value.length === 0;
-    if (typeof value === 'object') return Object.keys(value).length === 0;
-    return false;
-  }
-}
-
-module.exports = new YlsooCore();