@ylsoo/core 1.1.0 → 2.0.0

package/README.md

@@ -1,17 +1,18 @@
 <div align="center">
-  <h1>@ylsoo/core</h1>
-  <p><b>The official, zero-dependency SDK powering all premium Ylsoo products.</b></p>
+  <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>
 
 <hr>
 
 ## 🚀 Overview
 
-`@ylsoo/core` provides fundamental, blazing-fast utility functions designed specifically for integrating Ylsoo services. Built completely from the ground up without any third-party dependencies, it guarantees ultra-fast execution and zero bloat.
+`@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
 
@@ -19,89 +20,73 @@
 npm i @ylsoo/core
 ```
 
-*Note: Fully typed out-of-the-box for perfect IDE intellisense!*
-
 ## 🛠️ API Reference
 
-### 1. Ylsoo Console (`logger`)
-A beautifully formatted console utility utilizing native ANSI escape codes for local development.
-
+### 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.logger.info('System initializing...');
-ylsoo.logger.success('Database connected successfully!');
-ylsoo.logger.warn('Rate limit approaching.');
-ylsoo.logger.error('Critical failure detected.');
-```
+// 1. Generate Secure V4 UUIDs
+const sessionID = ylsoo.crypto.uuid();
 
-### 2. Ylsoo Request Engine (`http`)
-A robust wrapper around the native `fetch` API. It automatically handles stringifying bodies, applying correct headers, parsing JSON, and safely throwing formatted errors.
+// 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
-const ylsoo = require('@ylsoo/core');
+// 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');
-    console.log(data);
   } catch (error) {
     ylsoo.logger.error('Failed to fetch user', error);
   }
 }
 ```
 
-### 3. Ylsoo Memory Cache (`cache`)
-A fast, volatile in-memory key/value store with Time-To-Live (TTL) functionality.
-
+### 4. 🧠 Ylsoo Memory Cache (`ylsoo.cache`)
+A volatile in-memory Map structure featuring native Time-To-Live (TTL) functionality.
 ```javascript
-const ylsoo = require('@ylsoo/core');
-
-// Cache a complex object for 5 seconds (5000 ms)
-ylsoo.cache.set('session_token', { id: 123 }, 5000);
-
-// Retrieve it instantly
-const session = ylsoo.cache.get('session_token');
-
-// Will return null after 5 seconds
-setTimeout(() => {
-  console.log(ylsoo.cache.get('session_token')); // null
-}, 5100);
-```
-
-### 4. Advanced Core Utilities
-
-#### `sleep(ms)`
-Promise-based execution halter.
-```javascript
-await ylsoo.sleep(2000); // Waits 2 seconds
+// Cache an object for 5000 ms (5 seconds)
+ylsoo.cache.set('session', { id: 123 }, 5000);
+const session = ylsoo.cache.get('session');
 ```
 
-#### `deepClone(obj)`
-Safely fully clones an object without retaining references, utilizing modern native standards where available.
+### 5. 🖥️ Ylsoo Console (`ylsoo.logger`)
+Formatted console utility employing native ANSI escape codes specifically designed for local backends.
 ```javascript
-const copy = ylsoo.deepClone(complexObject);
-```
-
-#### `debounce(func, wait)`
-Throttles function execution to ensure high performance during spam events (like window resizing or typing).
-```javascript
-const search = ylsoo.debounce(() => console.log('Searching...'), 300);
-```
-
-#### `isEmpty(value)`
-Intelligently determines if strings, arrays, objects, maps, or sets are empty.
-```javascript
-ylsoo.isEmpty({}); // true
-ylsoo.isEmpty([]); // true
-ylsoo.isEmpty("hello"); // false
+ylsoo.logger.info('System initializing...');
+ylsoo.logger.success('Database connected successfully!');
+ylsoo.logger.warn('Rate limit approaching.');
+ylsoo.logger.error('Critical failure detected.');
 ```
 
-#### `capitalize(str)`
-Easily standardize text formatting.
-```javascript
-ylsoo.capitalize('ylsoo'); // 'Ylsoo'
-```
+### 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">

package/index.d.ts

@@ -1,42 +1,23 @@
 /**
- * @ylsoo/core Type Definitions
+ * @ylsoo/core v2.0.0 Type Definitions
+ * Cross-platform Enterprise SDK
  */
 
 declare module '@ylsoo/core' {
 
+  // --- Core Modules ---
+
   export class YlsooLogger {
-      /** Logs an informational message */
       info(message: string | any): void;
-      /** Logs a success message */
       success(message: string | any): void;
-      /** Logs a warning message */
       warn(message: string | any): void;
-      /** Logs an error message */
       error(message: string | any): void;
   }
 
   export class YlsooCache {
-      /**
-       * Set a key-value pair in memory
-       * @param key String identifier
-       * @param value The raw value to store
-       * @param ttlMs Time to live in milliseconds (0 for infinite)
-       */
       set(key: string, value: any, ttlMs?: number): void;
-      
-      /**
-       * Retrieve a value from the cache. Returns null if expired or missing.
-       */
       get<T = any>(key: string): T | null;
-
-      /**
-       * Delete a specific key from the cache
-       */
       delete(key: string): boolean;
-
-      /**
-       * Clear all cached data
-       */
       clear(): void;
   }
 
@@ -48,41 +29,63 @@ declare module '@ylsoo/core' {
   }
 
   export class YlsooHttp {
-      /** Makes a raw fetch request but automatically handles JSON mapping and errors */
       request<T = any>(endpoint: string, options?: YlsooHttpOptions): Promise<T>;
-      
-      /** Performs a GET request */
       get<T = any>(endpoint: string, headers?: Record<string, string>): Promise<T>;
-      
-      /** Performs a POST request with an automatic JSON-stringified body */
       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;
       
-      /** The official Ylsoo logging console */
+      // Systems
       logger: YlsooLogger;
-      
-      /** The official Ylsoo memory cache */
       cache: YlsooCache;
-      
-      /** The official Ylsoo request engine */
       http: YlsooHttp;
+      crypto: YlsooCrypto;
+      events: YlsooEventBus;
 
-      /** Halt execution for a set duration */
+      // Utilities
       sleep(ms: number): Promise<void>;
-
-      /** Safely deep clone an object */
       deepClone<T>(obj: T): T;
-
-      /** Creates a debounced version of a function */
       debounce<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
-
-      /** Check if an array, string, object, map, or set is semantically empty */
       isEmpty(value: any): boolean;
-
-      /** Capitalizes the first letter of a string */
       capitalize(str: string): string;
   }
 

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@ylsoo/core",
-  "version": "1.1.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": [
-    "index.js",
+    "src/",
     "index.d.ts",
     "README.md"
   ],
@@ -15,11 +15,14 @@
   "keywords": [
     "ylsoo",
     "core",
-    "utilities",
+    "enterprise",
     "sdk",
     "fetch",
     "logger",
-    "cache"
+    "cache",
+    "crypto",
+    "uuid",
+    "events"
   ],
   "author": "Ylsoo",
   "license": "MIT",

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,202 +0,0 @@
-/**
- * @ylsoo/core
- * Premium utility functions for Ylsoo projects
- * Zero dependency, extremely fast, robust.
- */
-
-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) {
-    const time = new Date().toISOString().split('T')[1].slice(0, -1);
-    return `${this.colors.ylsoo}[Ylsoo]${this.colors.reset} ${color}[${level.toUpperCase()}]${this.colors.reset} ${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));
-  }
-}
-
-class YlsooCache {
-  constructor() {
-    this.store = new Map();
-  }
-
-  /**
-   * Set a key-value pair with an optional Time-To-Live
-   * @param {string} key 
-   * @param {*} value 
-   * @param {number} ttlMs - Time to live in milliseconds
-   */
-  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();
-  }
-}
-
-class YlsooHttp {
-  /**
-   * Premium wrapper for fetch
-   * @param {string} endpoint 
-   * @param {object} options 
-   * @returns {Promise<any>}
-   */
-  async request(endpoint, options = {}) {
-    const defaultHeaders = {
-      'Content-Type': 'application/json',
-      'User-Agent': 'Ylsoo-Core/1.1'
-    };
-
-    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 });
-  }
-}
-
-class YlsooCore {
-  constructor() {
-    this.version = '1.1.0';
-    this.logger = new YlsooLogger();
-    this.cache = new YlsooCache();
-    this.http = new YlsooHttp();
-  }
-
-  /**
-   * Sleep for a given amount of time (Promise based)
-   * @param {number} ms 
-   */
-  sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Deep clone an object natively
-   * @param {object} obj 
-   */
-  deepClone(obj) {
-    if (typeof structuredClone === 'function') {
-      return structuredClone(obj);
-    }
-    return JSON.parse(JSON.stringify(obj));
-  }
-
-  /**
-   * Creates a debounced function that delays invoking func until after wait milliseconds have elapsed
-   * @param {Function} func 
-   * @param {number} wait 
-   */
-  debounce(func, wait) {
-    let timeout;
-    return function executedFunction(...args) {
-      const later = () => {
-        clearTimeout(timeout);
-        func(...args);
-      };
-      clearTimeout(timeout);
-      timeout = setTimeout(later, wait);
-    };
-  }
-
-  /**
-   * Simple utility to verify if a value is semantically empty
-   * @param {*} value 
-   */
-  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;
-  }
-  
-  /**
-   * 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);
-  }
-}
-
-module.exports = new YlsooCore();