@ylsoo/core 1.1.0 → 2.0.1

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/src/utils/queue.js

@@ -0,0 +1,50 @@
+class YlsooTaskQueue {
+  /**
+   * Limit concurrency of massive promises automatically
+   * @param {number} concurrencyLimit 
+   */
+  constructor(concurrencyLimit = 5) {
+    this.concurrencyLimit = concurrencyLimit;
+    this.activeCount = 0;
+    this.queue = [];
+  }
+
+  /**
+   * Add a function that returns a Promise to the queue
+   * @param {Function} asyncTask 
+   * @returns {Promise<*>}
+   */
+  add(asyncTask) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        task: asyncTask,
+        resolve,
+        reject
+      });
+      this._next();
+    });
+  }
+
+  get remaining() {
+    return this.queue.length;
+  }
+
+  _next() {
+    if (this.activeCount >= this.concurrencyLimit || this.queue.length === 0) {
+      return;
+    }
+
+    this.activeCount++;
+    const { task, resolve, reject } = this.queue.shift();
+
+    task()
+      .then(resolve)
+      .catch(reject)
+      .finally(() => {
+        this.activeCount--;
+        this._next();
+      });
+  }
+}
+
+module.exports = { YlsooTaskQueue };

package/src/utils/time.js

@@ -0,0 +1,46 @@
+class YlsooTime {
+  /**
+   * Extremely lightweight date formatter (replaces heavy Moment.js)
+   * @param {Date|number|string} date 
+   * @param {string} formatStr (e.g. "YYYY-MM-DD HH:mm:ss")
+   */
+  format(date, formatStr = "YYYY-MM-DD") {
+    const d = new Date(date);
+    if (isNaN(d.getTime())) return null;
+
+    const pad = (n) => String(n).padStart(2, '0');
+    
+    return formatStr
+      .replace('YYYY', d.getFullYear())
+      .replace('YY', String(d.getFullYear()).slice(-2))
+      .replace('MM', pad(d.getMonth() + 1))
+      .replace('DD', pad(d.getDate()))
+      .replace('HH', pad(d.getHours()))
+      .replace('mm', pad(d.getMinutes()))
+      .replace('ss', pad(d.getSeconds()));
+  }
+
+  /**
+   * Fast "time ago" algorithm
+   * @param {Date|number|string} date 
+   */
+  timeAgo(date) {
+    const d = new Date(date);
+    const seconds = Math.floor((new Date() - d) / 1000);
+    
+    let interval = Math.floor(seconds / 31536000);
+    if (interval >= 1) return interval + " year" + (interval > 1 ? "s" : "") + " ago";
+    interval = Math.floor(seconds / 2592000);
+    if (interval >= 1) return interval + " month" + (interval > 1 ? "s" : "") + " ago";
+    interval = Math.floor(seconds / 86400);
+    if (interval >= 1) return interval + " day" + (interval > 1 ? "s" : "") + " ago";
+    interval = Math.floor(seconds / 3600);
+    if (interval >= 1) return interval + " hour" + (interval > 1 ? "s" : "") + " ago";
+    interval = Math.floor(seconds / 60);
+    if (interval >= 1) return interval + " minute" + (interval > 1 ? "s" : "") + " ago";
+    
+    return Math.floor(seconds) + " seconds ago";
+  }
+}
+
+module.exports = { YlsooTime };

package/src/validation/schema.js

@@ -0,0 +1,53 @@
+class YlsooValidator {
+  /**
+   * Validate an object against a strict schema mapping
+   * @param {*} data 
+   * @param {object} schema 
+   * @throws Error on validation failure
+   * @returns {boolean} true if valid
+   */
+  validate(data, schema) {
+    if (typeof data !== 'object' || data === null) {
+      throw new Error('[Ylsoo Validation] Target is not an object.');
+    }
+
+    for (const [key, rules] of Object.entries(schema)) {
+      const value = data[key];
+
+      // Handle raw type strings (e.g. { age: 'number' })
+      const type = typeof rules === 'string' ? rules : rules.type;
+      
+      // Check required
+      const isRequired = typeof rules === 'object' ? rules.required !== false : true;
+      if (value === undefined || value === null) {
+        if (isRequired) throw new Error(`[Ylsoo Validation] Missing required key: ${key}`);
+        continue;
+      }
+
+      // Check Types
+      if (type === 'array') {
+        if (!Array.isArray(value)) throw new Error(`[Ylsoo Validation] Type mismatch. ${key} must be an array.`);
+      } else if (type === 'email') {
+        if (typeof value !== 'string' || !/^\S+@\S+\.\S+$/.test(value)) {
+          throw new Error(`[Ylsoo Validation] Type mismatch. ${key} must be a valid email.`);
+        }
+      } else if (type === 'object') {
+        if (typeof value !== 'object' || Array.isArray(value)) {
+          throw new Error(`[Ylsoo Validation] Type mismatch. ${key} must be an object.`);
+        }
+        // Recursive dive
+        if (rules.schema) {
+          this.validate(value, rules.schema);
+        }
+      } else {
+        if (typeof value !== type) {
+          throw new Error(`[Ylsoo Validation] Type mismatch. ${key} must be a ${type}.`);
+        }
+      }
+    }
+    
+    return true;
+  }
+}
+
+module.exports = { YlsooValidator };

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();