goaded.utils 1.0.0

package/batcher.js

@@ -0,0 +1,32 @@
+class Batcher {
+  constructor(handler, timeout = 50) {
+    this.handler = handler; // Function that takes an array of inputs
+    this.timeout = timeout;
+    this.queue = [];
+    this.timer = null;
+  }
+
+  add(item) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ item, resolve, reject });
+      if (!this.timer) {
+        this.timer = setTimeout(() => this.flush(), this.timeout);
+      }
+    });
+  }
+
+  async flush() {
+    const currentQueue = this.queue;
+    this.queue = [];
+    this.timer = null;
+    
+    const items = currentQueue.map(q => q.item);
+    try {
+      const results = await this.handler(items); // Handler processes bulk
+      currentQueue.forEach((q, i) => q.resolve(results[i]));
+    } catch (err) {
+      currentQueue.forEach(q => q.reject(err));
+    }
+  }
+}
+module.exports = Batcher;

package/cache.js

@@ -0,0 +1,26 @@
+class CacheManager {
+  constructor() {
+    this.storage = new Map();
+  }
+
+  set(key, value, ttlSecs = 300) {
+    const record = {
+      value,
+      expires: Date.now() + ttlSecs * 1000,
+    };
+    this.storage.set(key, JSON.stringify(record));
+  }
+
+  get(key) {
+    const raw = this.storage.get(key);
+    if (!raw) return null;
+
+    const record = JSON.parse(raw);
+    if (Date.now() > record.expires) {
+      this.storage.delete(key);
+      return null;
+    }
+    return record.value;
+  }
+}
+module.exports = CacheManager;

package/connector.js

@@ -0,0 +1,30 @@
+class Connector {
+  constructor(fn, failureThreshold = 3, cooldownMs = 5000) {
+    this.fn = fn;
+    this.threshold = failureThreshold;
+    this.cooldown = cooldownMs;
+    this.failures = 0;
+    this.lastFailureTime = 0;
+  }
+
+  async fire(...args) {
+    if (this.failures >= this.threshold) {
+      if (Date.now() - this.lastFailureTime > this.cooldown) {
+        this.failures = 0; // Reset after cooldown
+      } else {
+        throw new Error("Circuit Open: Service Unavailable");
+      }
+    }
+
+    try {
+      const result = await this.fn(...args);
+      this.failures = 0; // Success resets the count
+      return result;
+    } catch (error) {
+      this.failures++;
+      this.lastFailureTime = Date.now();
+      throw error;
+    }
+  }
+}
+module.exports = Connector;

package/db.js

@@ -0,0 +1,190 @@
+const sqlite3 = require('sqlite3').verbose();
+
+class Db {
+    constructor(file = ':memory:') {
+        this.db = new sqlite3.Database(file);
+        this.Schema = class {
+            constructor(definition) {
+                this.definition = definition;
+            }
+        };
+    }
+
+    model(name, schema) {
+        const db = this.db;
+        const tableName = name.toLowerCase() + 's';
+        const definition = schema.definition;
+
+        const createTableSql = `
+            CREATE TABLE IF NOT EXISTS ${tableName} (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                info TEXT NOT NULL
+            )
+        `;
+
+        const tableReady = new Promise((resolve, reject) => {
+            db.run(createTableSql, (err) => {
+                if (err) {
+                    console.error(`Error creating table ${tableName}:`, err.message);
+                    reject(err);
+                } else {
+                    resolve();
+                }
+            });
+        });
+
+        return class Model {
+            constructor(data) {
+                this._data = {}; 
+                
+                Object.keys(definition).forEach(key => {
+                    const rule = definition[key];
+                    const inputVal = data[key];
+
+                    if (inputVal === undefined && rule.default !== undefined) {
+                        this._data[key] = typeof rule.default === 'function' ? rule.default() : rule.default;
+                    } else if (inputVal !== undefined) {
+                        this._data[key] = inputVal;
+                    }
+                });
+                
+                if(data.id) this._data.id = data.id;
+            }
+
+            JSONify() {
+                console.log(this._data);
+                return this._data;
+            }
+
+            toJSON() {
+                return this._data;
+            }
+
+            static createProxy(instance) {
+                return new Proxy(instance, {
+                    get(target, prop) {
+                        if (prop in target) return target[prop];
+                        return target._data[prop];
+                    },
+                    set(target, prop, value) {
+                        if (prop in definition) {
+                            target._data[prop] = value;
+                            return true;
+                        }
+                        return true; 
+                    }
+                });
+            }
+
+            static validate(dataObject) {
+                const errors = {};
+                Object.keys(definition).forEach(key => {
+                    let value = dataObject[key];
+                    const rules = definition[key];
+
+                    if (typeof value === 'string') {
+                        if (rules.trim) value = value.trim();
+                        if (rules.lowercase) value = value.toLowerCase();
+                        if (rules.uppercase) value = value.toUpperCase();
+                        dataObject[key] = value;
+                    }
+
+                    if (rules.required && (value === undefined || value === null || value === '')) {
+                        errors[key] = `Path \`${key}\` is required.`;
+                        return;
+                    }
+
+                    if (value === undefined || value === null) return; 
+
+                    if (rules.type === Number && isNaN(value)) errors[key] = "Not a number";
+                    if (rules.type === Boolean && typeof value !== 'boolean') errors[key] = "Not a boolean";
+
+                    if (rules.type === String) {
+                        if (rules.enum && !rules.enum.includes(value)) 
+                            errors[key] = `\`${value}\` is not allowed.`;
+                        if (rules.match && !rules.match.test(value)) 
+                            errors[key] = "Regex validation failed";
+                    }
+                    if (rules.type === Number) {
+                        if (rules.min !== undefined && value < rules.min) errors[key] = `Min ${rules.min}`;
+                        if (rules.max !== undefined && value > rules.max) errors[key] = `Max ${rules.max}`;
+                    }
+                });
+
+                if (Object.keys(errors).length > 0) throw { message: "Validation failed", errors };
+            }
+
+            async save() {
+                await tableReady;
+                
+                try {
+                    Model.validate(this._data);
+                } catch (e) {
+                    return Promise.reject(e);
+                }
+
+                return new Promise((resolve, reject) => {
+                    const jsonPayload = JSON.stringify(this._data);
+                    const self = this; 
+
+                    if (this._data.id) {
+                         const sql = `UPDATE ${tableName} SET info = ? WHERE id = ?`;
+                         db.run(sql, [jsonPayload, this._data.id], function(err) {
+                             if(err) reject(err);
+                             else resolve(self); 
+                         });
+                    } else {
+                        const sql = `INSERT INTO ${tableName} (info) VALUES (?)`;
+                        db.run(sql, [jsonPayload], function(err) {
+                            if (err) reject(err);
+                            else {
+                                self._data.id = this.lastID; 
+                                resolve(Model.createProxy(self)); 
+                            }
+                        });
+                    }
+                });
+            }
+
+            static async find(query = {}) {
+                await tableReady;
+                return new Promise((resolve, reject) => {
+                    let sql = `SELECT id, info FROM ${tableName}`;
+                    const params = [];
+                    const keys = Object.keys(query);
+
+                    if (keys.length > 0) {
+                        const clauses = keys.map(key => {
+                            if(!definition[key] && key !== 'id') return null;
+                            if (key === 'id') return `id = ?`;
+                            return `json_extract(info, '$.${key}') = ?`;
+                        }).filter(x => x).join(' AND ');
+
+                        if(clauses) sql += ` WHERE ${clauses}`;
+                        keys.forEach(key => { 
+                            if(definition[key] || key === 'id') params.push(query[key]); 
+                        });
+                    }
+
+                    db.all(sql, params, (err, rows) => {
+                        if (err) reject(err);
+                        else {
+                            const results = rows.map(row => {
+                                const data = JSON.parse(row.info);
+                                data.id = row.id;
+                                return Model.createProxy(new Model(data));
+                            });
+                            resolve(results);
+                        }
+                    });
+                });
+            }
+
+            static async create(data) {
+                const instance = Model.createProxy(new Model(data));
+                return await instance.save();
+            }
+        };
+    }
+}
+module.exports = Db;

package/diff.js

@@ -0,0 +1,11 @@
+const deepDiff = (obj1, obj2) => {
+  const diff = {};
+  const keys = new Set([...Object.keys(obj1), ...Object.keys(obj2)]);
+  keys.forEach(key => {
+    if (JSON.stringify(obj1[key]) !== JSON.stringify(obj2[key])) {
+      diff[key] = { old: obj1[key], new: obj2[key] };
+    }
+  });
+  return diff;
+};
+module.exports = deepDiff;

package/events.js

@@ -0,0 +1,159 @@
+class emitter {
+    listeners = [];
+    
+    constructor() {}
+    
+    on(event, callback) {
+        this.listeners.push({event, callback});
+        return this;
+    }
+    
+    off(event, callback) {
+        this.listeners = this.listeners.filter(
+            listener => listener.event !== event || listener.callback !== callback
+        );
+        return this;
+    }
+    
+    once(event, callback) {
+        const wrappedCallback = (...args) => {
+            callback(...args);
+            this.off(event, wrappedCallback);
+        };
+        this.on(event, wrappedCallback);
+        return this;
+    }
+    
+    emit(event, ...args) {
+        this.listeners.forEach(listener => {
+            if(listener.event === event) {
+                try {
+                    listener.callback(...args);
+                } catch(error) {
+                    console.error(`Error in event listener for "${event}":`, error);
+                }
+            }
+        });
+    }
+    
+    async emitAsync(event, ...args) {
+        const promises = this.listeners
+            .filter(listener => listener.event === event)
+            .map(listener => Promise.resolve(listener.callback(...args)));
+        
+        await Promise.all(promises);
+    }
+    
+    emitOnce(event, ...args) {
+        this.listeners = this.listeners.filter(listener => {
+            if(listener.event === event) {
+                try {
+                    listener.callback(...args);
+                } catch(error) {
+                    console.error(`Error in event listener for "${event}":`, error);
+                }
+                return false;
+            }
+            return true;
+        });
+    }
+    
+    async emitOnceAsync(event, ...args) {
+        const matchingListeners = this.listeners.filter(
+            listener => listener.event === event
+        );
+        
+        this.listeners = this.listeners.filter(
+            listener => listener.event !== event
+        );
+        
+        await Promise.all(
+            matchingListeners.map(listener => 
+                Promise.resolve(listener.callback(...args))
+            )
+        );
+    }
+    
+    emitRepeat(event, times, ...args) {
+        this.listeners.forEach(listener => {
+            if(listener.event === event) {
+                for(let i = 0; i < times; i++) {
+                    try {
+                        listener.callback(...args);
+                    } catch(error) {
+                        console.error(`Error in event listener for "${event}":`, error);
+                    }
+                }
+            }
+        });
+    }
+    
+    async emitRepeatAsync(event, times, ...args) {
+        const matchingListeners = this.listeners.filter(
+            listener => listener.event === event
+        );
+        
+        for(let i = 0; i < times; i++) {
+            await Promise.all(
+                matchingListeners.map(listener => 
+                    Promise.resolve(listener.callback(...args))
+                )
+            );
+        }
+    }
+}
+
+class getter {
+    constructor() {
+        this.em = new emitter();
+        this.instances = [this.em];
+        
+        this.global = {
+            emit: (message, ...args) => {
+                this.instances.forEach(instance => instance.emit(message, ...args));
+            },
+            on: (event, callback) => {
+                this.instances.forEach(instance => instance.on(event, callback));
+            },
+            emitAsync: async (message, ...args) => {
+                await Promise.all(
+                    this.instances.map(instance => instance.emitAsync(message, ...args))
+                );
+            },
+            emitOnce: (message, ...args) => {
+                this.instances.forEach(instance => instance.emitOnce(message, ...args));
+            },
+            emitOnceAsync: async (message, ...args) => {
+                await Promise.all(
+                    this.instances.map(instance => instance.emitOnceAsync(message, ...args))
+                );
+            },
+            emitRepeat: (event, times, ...args) => {
+                this.instances.forEach(instance => instance.emitRepeat(event, times, ...args));
+            },
+            emitRepeatAsync: async (event, times, ...args) => {
+                await Promise.all(
+                    this.instances.map(instance => instance.emitRepeatAsync(event, times, ...args))
+                );
+            }
+        };
+        
+        Object.freeze(this.global);
+    }
+    
+    getClass() {
+        return emitter;
+    }
+    
+    getInstance(num = 0) {
+        return this.instances[num];
+    }
+    
+    getNewInstance() {
+        const newEm = new emitter();
+        this.instances.push(newEm);
+        return {'instance': newEm, 'num': this.instances.length - 1};
+    }
+}
+
+module.exports = new getter();

package/getter.js

@@ -0,0 +1,21 @@
+class getter {
+    constructor(obj) {
+        this.obj = new obj();
+        this.instances = [this.obj];
+    }
+    
+    getClass() {
+        return this.obj;
+    }
+    
+    getInstance(num = 0) {
+        return this.instances[num];
+    }
+    
+    getNewInstance() {
+        const newInst = new obj();
+        this.instances.push(newInst);
+        return {'instance': newInst, 'num': this.instances.length - 1};
+    }
+}
+module.exports = getter;

package/hook.js

@@ -0,0 +1,28 @@
+// core/Hooks.js
+class HookSystem {
+  constructor() {
+    this.hooks = new Map();
+  }
+
+  // Register a listener
+  tap(name, callback) {
+    if (!this.hooks.has(name)) {
+      this.hooks.set(name, []);
+    }
+    this.hooks.get(name).push(callback);
+  }
+
+  // Run the hooks in sequence, passing data through them
+  async call(name, initialValue) {
+    const callbacks = this.hooks.get(name) || [];
+    let currentValue = initialValue;
+
+    for (const callback of callbacks) {
+      // The output of one becomes the input of the next
+      currentValue = await callback(currentValue);
+    }
+
+    return currentValue;
+  }
+}
+module.exports = HookSystem

package/lazy.js

@@ -0,0 +1,14 @@
+class Lazy {
+  constructor(initializer) {
+    this.initializer = initializer;
+    this.instance = null;
+  }
+
+  get() {
+    if (!this.instance) {
+      this.instance = this.initializer();
+    }
+    return this.instance;
+  }
+}
+module.exports = Lazy;

package/logger.js

@@ -0,0 +1,81 @@
+const COLORS = {
+  reset: "\x1b[0m",
+  dim: "\x1b[2m",
+  fg: {
+    gray: "\x1b[90m",
+    cyan: "\x1b[36m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    magenta: "\x1b[35m",
+    white: "\x1b[37m",
+    vortex: "\x1b[38;5;129m",
+  },
+};
+
+const LEVELS = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60,
+};
+const LEVEL_COLORS = {
+  trace: COLORS.fg.gray,
+  debug: COLORS.fg.cyan,
+  info: COLORS.fg.green,
+  warn: COLORS.fg.yellow,
+  error: COLORS.fg.red,
+  fatal: COLORS.fg.magenta,
+};
+
+// Dont ask me how the FUCK this works.
+function fmtDate(d = new Date()) {
+  const pad = (n, w = 2) => `${n}`.padStart(w, "0");
+  const yyyy = d.getFullYear();
+  const MM = pad(d.getMonth() + 1);
+  const dd = pad(d.getDate());
+  const hh = pad(d.getHours());
+  const mm = pad(d.getMinutes());
+  const ss = pad(d.getSeconds());
+  const SSS = pad(d.getMilliseconds(), 3);
+  return `${yyyy}-${MM}-${dd} ${hh}:${mm}:${ss}.${SSS}`;
+}
+
+function colorize(text, color) {
+  return `${color}${text}${COLORS.reset}`;
+}
+module.exports = function createLogger(namespace = "app") {
+  function log(level, ...args) {
+    const lvlNum = LEVELS[level];
+
+    const ts = colorize(fmtDate(), COLORS.dim);
+    const lvl = colorize(
+      `[${level.toUpperCase()}]`,
+      LEVEL_COLORS[level] || COLORS.fg.white
+    );
+    const mod = colorize(`Module: ${namespace}`, COLORS.fg.yellow);
+    const msg = util.format(...args);
+
+    const arw = colorize(">", COLORS.fg.vortex);
+
+    const line = `${lvl} ${arw} ${ts} ${arw} ${mod} ${arw} ${msg}`;
+    if (lvlNum >= LEVELS.error) {
+      console.error(line);
+    } else if (lvlNum >= LEVELS.warn) {
+      console.warn(line);
+    } else {
+      console.log(line);
+    }
+  }
+
+  return {
+    trace: (...a) => log("trace", ...a),
+    debug: (...a) => log("debug", ...a),
+    info: (...a) => log("info", ...a),
+    warn: (...a) => log("warn", ...a),
+    error: (...a) => log("error", ...a),
+    fatal: (...a) => log("fatal", ...a),
+  };
+};

package/lru.js

@@ -0,0 +1,23 @@
+class LRUCache {
+  constructor(limit = 100) {
+    this.limit = limit;
+    this.cache = new Map();
+  }
+
+  get(key) {
+    if (!this.cache.has(key)) return null;
+    const val = this.cache.get(key);
+    this.cache.delete(key); // Refresh freshness
+    this.cache.set(key, val);
+    return val;
+  }
+
+  set(key, val) {
+    if (this.cache.has(key)) this.cache.delete(key);
+    else if (this.cache.size === this.limit) {
+      this.cache.delete(this.cache.keys().next().value); // Evict oldest
+    }
+    this.cache.set(key, val);
+  }
+}
+module.exports = LRUCache;

package/memo.js

@@ -0,0 +1,18 @@
+// core/Memoizer.js
+const memoize = (fn, keyResolver) => {
+  const cache = new Map();
+
+  return (...args) => {
+    // Default key is just the first argument, or a JSON string of all args
+    const key = keyResolver ? keyResolver(...args) : JSON.stringify(args);
+
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+
+    const result = fn(...args);
+    cache.set(key, result);
+    return result;
+  };
+};
+module.exports = memoize;

package/middleware.js

@@ -0,0 +1,16 @@
+class MiddlewareRunner {
+  constructor() {
+    this.middlewares = [];
+  }
+  use(fn) { this.middlewares.push(fn); }
+  
+  async run(context) {
+    const execute = async (index) => {
+      if (index < this.middlewares.length) {
+        await this.middlewares[index](context, () => execute(index + 1));
+      }
+    };
+    await execute(0);
+  }
+}
+module.exports = MiddlewareRunner;

package/package.json

@@ -0,0 +1,17 @@
+{
+  "dependencies": {
+    "sqlite3": "^5.1.7"
+  },
+  "name": "goaded.utils",
+  "version": "1.0.0",
+  "description": "",
+  "main": "services.js",
+  "devDependencies": {},
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": ["utils"],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs"
+}

package/pipeline.js

@@ -0,0 +1,22 @@
+class Pipeline {
+  constructor() {
+    this.steps = [];
+  }
+
+  use(step) {
+    this.steps.push(step);
+    return this;
+  }
+
+  async execute(input) {
+    let result = input;
+    for (const step of this.steps) {
+      result = await step(result);
+      if (result === null || result === undefined) {
+        throw new Error('Pipeline broken: Step returned null/undefined');
+      }
+    }
+    return result;
+  }
+}
+module.exports = Pipeline

package/polls.js

@@ -0,0 +1,19 @@
+const poll = async ({ fn, validate, interval, maxAttempts }) => {
+  let attempts = 0;
+  
+  const execute = async (resolve, reject) => {
+    const result = await fn();
+    attempts++;
+
+    if (validate(result)) {
+      return resolve(result);
+    } else if (attempts === maxAttempts) {
+      return reject(new Error('Exceeded max attempts'));
+    } else {
+      setTimeout(execute, interval, resolve, reject);
+    }
+  };
+
+  return new Promise(execute);
+};
+module.exports = poll;

package/pool.js

@@ -0,0 +1,16 @@
+class ObjectPool {
+  constructor(factory, size) {
+    this.pool = [];
+    this.factory = factory;
+    for (let i = 0; i < size; i++) this.pool.push(factory());
+  }
+
+  acquire() {
+    return this.pool.length > 0 ? this.pool.pop() : this.factory();
+  }
+
+  release(obj) {
+    this.pool.push(obj);
+  }
+}
+module.exports = ObjectPool;

package/priority.js

@@ -0,0 +1,24 @@
+class PriorityQueue {
+  constructor() {
+    this.items = [];
+  }
+
+  enqueue(element, priority) {
+    const node = { element, priority };
+    let added = false;
+    
+    for (let i = 0; i < this.items.length; i++) {
+      if (node.priority > this.items[i].priority) {
+        this.items.splice(i, 0, node);
+        added = true;
+        break;
+      }
+    }
+    if (!added) this.items.push(node);
+  }
+
+  dequeue() {
+    return this.items.shift()?.element;
+  }
+}
+module.exports = PriorityQueue;

package/queue.js

@@ -0,0 +1,33 @@
+class TaskQueue {
+  constructor(concurrency = 3) {
+    this.concurrency = concurrency;
+    this.running = 0;
+    this.queue = [];
+  }
+
+  add(task) {
+    return new Promise((resolve, reject) => {
+      this.queue.push({ task, resolve, reject });
+      this.process();
+    });
+  }
+
+  async process() {
+    if (this.running >= this.concurrency || this.queue.length === 0) return;
+
+    this.running++;
+    const { task, resolve, reject } = this.queue.shift();
+
+    try {
+      const result = await task();
+      resolve(result);
+    } catch (err) {
+      reject(err);
+    } finally {
+      this.running--;
+      this.process(); // Pick up the next task
+    }
+  }
+}
+
+module.exports = TaskQueue;

package/result.js

@@ -0,0 +1,19 @@
+class Result {
+  static ok(data) {
+    return { success: true, data, error: null };
+  }
+
+  static fail(error) {
+    return { success: false, data: null, error };
+  }
+
+  static async fromPromise(promise) {
+    try {
+      const data = await promise;
+      return Result.ok(data);
+    } catch (e) {
+      return Result.fail(e);
+    }
+  }
+}
+module.exports = new Result();

package/retry.js

@@ -0,0 +1,23 @@
+const createLogger = require('./logger');
+const logger = createLogger('retry');
+const sleep = require('./sleep');
+const retry = async (fn, options = {}) => {
+  const { retries = 3, delay = 20, factor = 2 } = options;
+  let attempt = 0;
+  
+  while (attempt <= retries) {
+    try {
+      return await fn();
+    } catch (err) {
+      if (attempt >= retries) throw err;
+      
+      const waitTime = delay * Math.pow(factor, attempt);
+      // Optional: Log the retry here using your custom logger
+      logger.warn(`Attempt ${attempt + 1} failed. Retrying in ${waitTime}ms...`);
+      
+      await sleep(delay);
+      attempt++;
+    }
+  }
+};
+module.exports = retry;

package/services.js

@@ -0,0 +1,106 @@
+// core/ServiceLocator.js
+const cache = require('./cache');
+const Connector = require('./connector');
+const events = require('./events')
+const hooks = require('./hook');
+const createLogger = require('./logger');
+const memoize = require('./memo');
+const StateMachine = require('./states');
+const pipeline = require('./pipeline');
+const queue = require('./queue');
+const retry = require('./retry');
+const result = require('./result');
+const sleep = require('./sleep');
+const batcher = require('./batcher');
+const poll = require('./polls');
+const lru = require('./lru');
+const priority = require('./priority');
+const lazy = require('./lazy');
+const pool = require('./pool');
+const diff = require('./diff');
+const middleware = require('./middleware');
+const signal = require('./signal');
+const getter = require('./getter');
+const Db = require("./db");
+class ServiceLocator {
+  constructor() {
+    this.services = new Map();
+  }
+
+  register(name, instance) {
+    if (this.services.has(name)) {
+      console.warn(`Service ${name} already registered, overwriting.`);
+    }
+    this.services.set(name, instance);
+  }
+
+  get(name) {
+    const service = this.services.get(name);
+    if (!service) {
+      throw new Error(`Service ${name} not found`);
+    }
+    return service;
+  }
+}
+class Services {
+    constructor() {
+        this.utils = new ServiceLocator();
+        this.registerUtils();
+        this.active = new ServiceLocator();
+        this.registerActive();
+        this.getters = new ServiceLocator();
+        this.registerGetters();
+    }
+    registerGetters(){
+        const g = this.getters;
+        //same classes as active, but with getter for more customization
+        const gs = [{'name':"batcher",'obj':batcher},{'name':"cache",'obj':cache},{'name':"hooks",'obj':hooks},
+        {'name':"lru",'obj':lru},{'name':"queue",'obj':queue},
+        {'name':"signal",'obj':signal},{'name':"stateMachine",'obj':StateMachine},
+        {'name':"middleware",'obj':middleware},
+        {'name':"pool",'obj':pool}]; 
+        gs.forEach(item=>{
+            g.register(item.name, new getter(item.obj));
+        });
+    }
+    registerActive(){
+      const a = this.active;
+      a.register('batcher', new batcher());
+      a.register('cache', new cache());
+      a.register('hooks',new hooks());
+      a.register('lru', new lru());
+      a.register('queue', new queue());
+      a.register('signal', new signal());
+      a.register('stateMachine', new StateMachine());
+      a.register('middleware', new middleware());
+      a.register('pool', new pool(() => ({}), 10));
+      a.register('db',new Db('database.db'));
+    }
+    registerUtils(){
+        this.utils.register('cache', cache);
+        this.utils.register('connector', Connector);
+        this.utils.register('events', events);
+        this.utils.register('hooks', hooks);
+        this.utils.register('logger', createLogger);
+        this.utils.register('memoize', memoize);
+        this.utils.register('stateMachine', StateMachine);
+        this.utils.register('pipeline', pipeline);
+        this.utils.register('queue', queue);
+        this.utils.register('retry', retry);
+        this.utils.register('result', result);
+        this.utils.register('sleep', sleep);
+        this.utils.register('ServiceLocator', ServiceLocator);
+        this.utils.register('batcher', batcher);
+        this.utils.register('poll', poll);
+        this.utils.register('lru', lru);
+        this.utils.register('priority',priority);
+        this.utils.register('lazy', lazy);
+        this.utils.register('pool', pool);
+        this.utils.register('diff', diff);
+        this.utils.register('middleware', middleware);
+        this.utils.register('signal',signal);
+        this.utils.register('getter', getter);
+        this.utils.register('db',Db);
+    }
+}
+module.exports = new Services();

package/signal.js

@@ -0,0 +1,16 @@
+class Signal {
+  constructor(val) {
+    this._val = val;
+    this.subs = new Set();
+  }
+  get value() { return this._val; }
+  set value(v) { 
+    this._val = v; 
+    this.subs.forEach(fn => fn(v)); 
+  }
+  subscribe(fn) { 
+    this.subs.add(fn); 
+    return () => this.subs.delete(fn); 
+  }
+}
+module.exports = Signal;

package/sleep.js

@@ -0,0 +1 @@
+module.exports = async (ms) => await new Promise((resolve) => setTimeout(resolve, ms));

package/states.js

@@ -0,0 +1,25 @@
+class StateMachine {
+  constructor(initialState, transitions) {
+    this.state = initialState;
+    this.transitions = transitions;
+  }
+
+  transition(action) {
+    const currentStateConfig = this.transitions[this.state];
+    const nextState = currentStateConfig ? currentStateConfig[action] : null;
+
+    if (!nextState) {
+      console.warn(`Invalid transition: Cannot '${action}' from '${this.state}'`);
+      return;
+    }
+
+    this.state = nextState;
+    return this.state;
+  }
+  
+  is(state) {
+    return this.state === state;
+  }
+}
+
+module.exports = StateMachine;