just-kit 0.8.0

package/just-kit.js

@@ -0,0 +1,9 @@
+/**
+ * just-kit – small collection of lightweight JavaScript utilities
+ * 
+ * @module just-kit
+ */
+
+export { default as Next }       from './just-next.js';
+export { default as JustPool }   from './just-pool.js';
+export { default as Prompt } from './just-prompt.js';

package/just-next.js

@@ -0,0 +1,95 @@
+/**
+ * NextUp - Simple sequential or random cycling through a list of items
+ */
+ 
+const MODE_SEQUENTIAL = 'sequential';
+const MODE_RANDOM = 'random';
+
+export default class Next {
+  #items = [];
+  #mode = MODE_SEQUENTIAL;
+  #index = 0;
+
+  /**
+   * @param {any[]} [items=[]] Initial items
+   * @param {'sequential'|'random'} [mode='sequential']
+   */
+  constructor(items = [], mode = MODE_SEQUENTIAL) {
+    this.setItems(items);
+    this.setMode(mode);
+  }
+
+  /** Replace all items and reset position */
+  setItems(items) {
+    if (!Array.isArray(items)) throw new Error('Items must be an array');
+    this.#items = [...items];
+    this.#index = 0;
+  }
+
+  /** Add one or more items */
+  add(...items) {
+    this.#items.push(...items);
+  }
+
+  /** Set retrieval mode */
+  setMode(mode) {
+    if (![MODE_SEQUENTIAL, MODE_RANDOM].includes(mode)) {
+      throw new Error("Mode must be 'sequential' or 'random'");
+    }
+    this.#mode = mode;
+  }
+
+  /** Get current mode */
+  get mode() {
+    return this.#mode;
+  }
+
+  /** Get current number of items */
+  get length() {
+    return this.#items.length;
+  }
+
+  /** Reset position to beginning (affects sequential mode only) */
+  reset() {
+    this.#index = 0;
+  }
+
+  /** Get next item according to current mode */
+  next() {
+    if (this.#items.length === 0) return undefined;
+
+    if (this.#mode === MODE_RANDOM) {
+      const i = Math.floor(Math.random() * this.#items.length);
+      return this.#items[i];
+    }
+
+    // sequential
+    const item = this.#items[this.#index];
+    this.#index = (this.#index + 1) % this.#items.length;
+    return item;
+  }
+
+  /** Preview next item without advancing position */
+  peek() {
+    if (this.#items.length === 0) return undefined;
+
+    if (this.#mode === MODE_RANDOM) {
+      const i = Math.floor(Math.random() * this.#items.length);
+      return this.#items[i];
+    }
+
+    return this.#items[this.#index];
+  }
+
+  /** Get a shallow copy of all items */
+  getAll() {
+    return [...this.#items];
+  }
+
+  /** Remove all items */
+  clear() {
+    this.#items = [];
+    this.#index = 0;
+  }
+}
+

package/just-pool.js

@@ -0,0 +1,94 @@
+/**
+ * JustPool – lazy instance creator & holder
+ * Creates objects only when first requested via .get(key)
+ * Reuses the same instance on repeated .get() calls with same key
+ */
+export default class JustPool {
+  /**
+   * @param {function(key: any): T} factory - called to create new instance when needed
+   */
+  constructor(factory) {
+    if (typeof factory !== 'function') {
+      throw new TypeError('Factory must be a function');
+    }
+
+    this.factory = factory;
+    this.cache = Object.create(null);
+  }
+
+  /**
+   * Get (or lazily create) the instance for given key
+   * @param {any} key
+   * @returns {T}
+   */
+  get(key) {
+    if (key in this.cache) {
+      return this.cache[key];
+    }
+
+    const instance = this.factory(key);
+    this.cache[key] = instance;
+    return instance;
+  }
+
+  /**
+   * Check if an instance already exists for this key
+   */
+  has(key) {
+    return key in this.cache;
+  }
+
+  /**
+   * Remove instance for given key
+   * @returns {boolean} true if something was removed
+   */
+  delete(key) {
+    if (key in this.cache) {
+      delete this.cache[key];
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Clear all cached instances
+   */
+  clear() {
+    this.cache = Object.create(null);
+  }
+
+  /**
+   * Approximate number of cached items
+   */
+  size() {
+    return Object.keys(this.cache).length;
+  }
+
+  /**
+   * Get all currently used keys (only string/symbol keys are enumerated)
+   */
+  keys() {
+    return Object.keys(this.cache);
+  }
+
+  /**
+   * Get all cached values
+   */
+  values() {
+    return Object.values(this.cache);
+  }
+
+  /**
+   * Iterate over all cached entries
+   * @param {(value: T, key: any) => void} callback
+   */
+  forEach(callback) {
+    for (const key in this.cache) {
+      if (Object.hasOwn(this.cache, key)) {
+        callback(this.cache[key], key);
+      }
+    }
+  }
+}
+
+

package/just-prompt.js

@@ -0,0 +1,53 @@
+import readline from 'readline';
+
+export default class Prompt {
+    #rl;
+    #onexit;
+
+    constructor(message, targetCommand, work) {
+        this.message = message;
+        this.targetCommand = targetCommand;
+        this.work = work;
+        this.#rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+    }
+
+    onExit(callback) {
+        this.#onexit = callback;
+    }
+
+    write(message) {
+        process.stdout.write(message);
+    }
+
+    // Start prompting the user
+    start() {
+        return new Promise((resolve) => {
+            const ask = () => {
+                this.#rl.question(this.message, async (input) => {
+                    const trimmed = input.trim();
+                    
+                    if (trimmed.toLowerCase() === this.targetCommand.toLowerCase()) {
+                        this.stop();
+                        resolve(input);
+                    } else {
+                        await this.work(trimmed);
+                        ask();
+                    }
+                });
+            };
+            ask();
+        });
+    }
+
+    // Stop the readline interface
+    stop() {
+        this.#rl.close();
+        this.#onexit?.();
+    }
+	
+	static app = (message, targetCommand, work) =>  new Prompt(message, targetCommand, work);
+}
+

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "just-kit",
+  "version": "0.8.0",
+  "description": "simple nodejs utility",
+  "keywords": [
+    "just",
+    "just-kit",
+    "prompt",
+	"next",
+	"pool"
+  ],
+  "homepage": "https://github.com/just-node/just-kit#readme",
+  "bugs": {
+    "url": "https://github.com/just-node/just-kit/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/just-node/just-kit.git"
+  },
+  "license": "MIT",
+  "author": "littlejustnode",
+  "type": "module",
+  "main": "just-kit.js",
+  "scripts": {
+    "test": "n/a"
+  }
+}

package/test.js

@@ -0,0 +1,22 @@
+import { Next, JustPool, Prompt } from './just-kit.js';
+
+// 1. Cycling list
+const playlist = new Next(['song1.mp3', 'song2.mp3', 'song3.mp3'], 'random');
+console.log(playlist.next());   // → random song
+console.log(playlist.peek());   // → another (or same) random song
+
+// 2. Lazy pool
+const dbPool = new JustPool((dbName) => "hello: "+dbName);
+const db1 = dbPool.get('users');   // created once
+const db2 = dbPool.get('users');   // same instance
+
+
+
+
+Prompt.app(
+  'Type your message (type "exit" to quit): ',
+  'exit',
+  async (input) => {
+    console.log(`You said: ${input}`);
+  }
+).start();