@myusufazmi/ultimate-tools 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2026, Your Name
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# Ultimate JS Tools
+
+A lightweight, high-performance, and modular JavaScript utility library designed for modern web applications. No external dependencies.
+
+## Modules
+
+### DOM Utilities (`dom.js`)
+
+- `$(selector, context)`: Fast query selector.
+- `$$(selector, context)`: Query selector all returning an array.
+- `create(tag, options)`: Advanced element creation.
+- `on(parent, event, selector, handler)`: Efficient event delegation.
+
+### HTTP Utilities (`http.js`)
+
+- `http.get(url, options)`
+- `http.post(url, body, options)`
+- `http.put(url, body, options)`
+- `http.delete(url, options)`
+- Supports JSON by default and interceptors.
+
+### Storage Utilities (`storage.js`)
+
+- `local.set(key, value)`, `local.get(key, fallback)`
+- `session.set(key, value)`, `session.get(key, fallback)`
+- Auto-serialization/deserialization for all data types.
+
+### State Management (`state.js`)
+
+- `createStore(initialValue)`: Reactive state management with `subscribe`, `update`, and `get`.
+
+### General Utilities (`utils.js`)
+
+- `debounce(fn, delay)`
+- `throttle(fn, limit)`
+- `deepClone(obj)`
+- `uuid()`: Simple unique ID generator.
+
+## Usage
+
+```javascript
+import { $, on, createStore } from "./src/index.js";
+
+const count = createStore(0);
+count.subscribe((val) => console.log("Count:", val));
+
+on(document, "click", "#btn", () => count.update((n) => n + 1));
+```
+
+## Demo
+
+Open `examples/index.html` in your browser to see the tools in action.

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@myusufazmi/ultimate-tools",
+  "version": "1.0.0",
+  "description": "Modern JS utility library for high-performance projects",
+  "main": "src/index.js",
+  "module": "src/index.js",
+  "type": "module",
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "serve": "npx -y lite-server"
+  },
+  "keywords": [
+    "javascript",
+    "utilities",
+    "dom",
+    "state",
+    "http",
+    "storage"
+  ],
+  "author": "Your Name",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yourusername/ultimate-tools.git"
+  },
+  "bugs": {
+    "url": "https://github.com/yourusername/ultimate-tools/issues"
+  },
+  "homepage": "https://github.com/yourusername/ultimate-tools#readme"
+}

package/src/dom.js

@@ -0,0 +1,70 @@
+/**
+ * DOM Utilities
+ * Premium query selectors and manipulation tools.
+ */
+
+/**
+ * Higher performance querySelector wrapper
+ * @param {string} selector
+ * @param {HTMLElement|Document} context
+ * @returns {HTMLElement|null}
+ */
+export const $ = (selector, context = document) => {
+  return context.querySelector(selector);
+};
+
+/**
+ * querySelectorAll wrapper that returns an array instead of a NodeList
+ * @param {string} selector
+ * @param {HTMLElement|Document} context
+ * @returns {HTMLElement[]}
+ */
+export const $$ = (selector, context = document) => {
+  return Array.from(context.querySelectorAll(selector));
+};
+
+/**
+ * Create element with attributes and styles
+ * @param {string} tag
+ * @param {Object} options
+ * @returns {HTMLElement}
+ */
+export const create = (tag, options = {}) => {
+  const el = document.createElement(tag);
+  const {
+    attr = {},
+    style = {},
+    text = "",
+    html = "",
+    children = [],
+  } = options;
+
+  Object.entries(attr).forEach(([k, v]) => el.setAttribute(k, v));
+  Object.assign(el.style, style);
+
+  if (text) el.textContent = text;
+  if (html) el.innerHTML = html;
+
+  children.forEach((child) => {
+    if (child instanceof HTMLElement) el.appendChild(child);
+    else el.append(child);
+  });
+
+  return el;
+};
+
+/**
+ * Event delegation helper
+ * @param {HTMLElement|Document} parent
+ * @param {string} event
+ * @param {string} selector
+ * @param {Function} handler
+ */
+export const on = (parent, event, selector, handler) => {
+  parent.addEventListener(event, (e) => {
+    const target = e.target.closest(selector);
+    if (target && parent.contains(target)) {
+      handler.call(target, e, target);
+    }
+  });
+};

package/src/http.js

@@ -0,0 +1,60 @@
+/**
+ * HTTP Utilities
+ * Clean Fetch API wrapper with easy JSON handling and interceptors.
+ */
+
+const request = async (url, options = {}) => {
+  const {
+    method = "GET",
+    headers = {},
+    body = null,
+    interceptors = { request: [], response: [] },
+  } = options;
+
+  let config = {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      ...headers,
+    },
+  };
+
+  if (body && typeof body === "object") {
+    config.body = JSON.stringify(body);
+  } else if (body) {
+    config.body = body;
+  }
+
+  // Request Interceptors
+  interceptors.request.forEach((fn) => {
+    config = fn(config) || config;
+  });
+
+  try {
+    const response = await fetch(url, config);
+    let data = await response.json().catch(() => null);
+
+    // Response Interceptors
+    interceptors.response.forEach((fn) => {
+      data = fn(data, response) || data;
+    });
+
+    if (!response.ok) {
+      throw { status: response.status, data };
+    }
+
+    return data;
+  } catch (error) {
+    console.error("Fetch Error:", error);
+    throw error;
+  }
+};
+
+export const http = {
+  get: (url, options) => request(url, { ...options, method: "GET" }),
+  post: (url, body, options) =>
+    request(url, { ...options, method: "POST", body }),
+  put: (url, body, options) =>
+    request(url, { ...options, method: "PUT", body }),
+  delete: (url, options) => request(url, { ...options, method: "DELETE" }),
+};

package/src/index.js

@@ -0,0 +1,5 @@
+export * from "./dom.js";
+export * from "./http.js";
+export * from "./storage.js";
+export * from "./state.js";
+export * from "./utils.js";

package/src/state.js

@@ -0,0 +1,46 @@
+/**
+ * State Management
+ * A tiny reactive store (inspired by Svelte stores).
+ */
+
+/**
+ * Creates a reactive store
+ * @param {any} initialValue
+ * @returns {Object}
+ */
+export const createStore = (initialValue) => {
+  let value = initialValue;
+  const subscribers = new Set();
+
+  /**
+   * Subscribe to changes
+   * @param {Function} fn
+   * @returns {Function} Unsubscribe function
+   */
+  const subscribe = (fn) => {
+    subscribers.add(fn);
+    fn(value);
+    return () => subscribers.delete(fn);
+  };
+
+  /**
+   * Update value and notify subscribers
+   * @param {any|Function} newValue
+   */
+  const update = (newValue) => {
+    if (typeof newValue === "function") {
+      value = newValue(value);
+    } else {
+      value = newValue;
+    }
+    subscribers.forEach((fn) => fn(value));
+  };
+
+  /**
+   * Get current value
+   * @returns {any}
+   */
+  const get = () => value;
+
+  return { subscribe, update, get };
+};

package/src/storage.js

@@ -0,0 +1,58 @@
+/**
+ * Storage Utilities
+ * Type-safe and auto-serialized local/session storage.
+ */
+
+const createStorage = (type = "localStorage") => {
+  const storage = window[type];
+
+  return {
+    /**
+     * Set item with auto-serialization
+     * @param {string} key
+     * @param {any} value
+     */
+    set(key, value) {
+      try {
+        const serialized = JSON.stringify(value);
+        storage.setItem(key, serialized);
+      } catch (e) {
+        console.error(`Storage Error (set): ${key}`, e);
+      }
+    },
+
+    /**
+     * Get item with auto-deserialization
+     * @param {string} key
+     * @param {any} fallback
+     * @returns {any}
+     */
+    get(key, fallback = null) {
+      try {
+        const item = storage.getItem(key);
+        return item ? JSON.parse(item) : fallback;
+      } catch (e) {
+        console.error(`Storage Error (get): ${key}`, e);
+        return fallback;
+      }
+    },
+
+    /**
+     * Remove item
+     * @param {string} key
+     */
+    remove(key) {
+      storage.removeItem(key);
+    },
+
+    /**
+     * Clear all items
+     */
+    clear() {
+      storage.clear();
+    },
+  };
+};
+
+export const local = createStorage("localStorage");
+export const session = createStorage("sessionStorage");

package/src/utils.js

@@ -0,0 +1,67 @@
+/**
+ * General Utilities
+ * Common helper functions.
+ */
+
+/**
+ * Debounce function
+ * @param {Function} fn
+ * @param {number} delay
+ * @returns {Function}
+ */
+export const debounce = (fn, delay = 300) => {
+  let timeout;
+  return (...args) => {
+    clearTimeout(timeout);
+    timeout = setTimeout(() => fn.apply(this, args), delay);
+  };
+};
+
+/**
+ * Throttle function
+ * @param {Function} fn
+ * @param {number} limit
+ * @returns {Function}
+ */
+export const throttle = (fn, limit = 300) => {
+  let lastFunc;
+  let lastRan;
+  return (...args) => {
+    if (!lastRan) {
+      fn.apply(this, args);
+      lastRan = Date.now();
+    } else {
+      clearTimeout(lastFunc);
+      lastFunc = setTimeout(
+        () => {
+          if (Date.now() - lastRan >= limit) {
+            fn.apply(this, args);
+            lastRan = Date.now();
+          }
+        },
+        limit - (Date.now() - lastRan),
+      );
+    }
+  };
+};
+
+/**
+ * Deep clone an object
+ * @param {any} obj
+ * @returns {any}
+ */
+export const deepClone = (obj) => {
+  if (obj === null || typeof obj !== "object") return obj;
+  return JSON.parse(JSON.stringify(obj));
+};
+
+/**
+ * Generates a simple UUID-like string
+ * @returns {string}
+ */
+export const uuid = () => {
+  return (
+    Math.random().toString(36).substring(2, 10) +
+    Date.now().toString(36).substring(2, 6)
+  );
+};