vibra 1.0.0

package/README.md

@@ -0,0 +1,85 @@
+# Vibra
+
+> A blazing fast, type-safe, and minimal state management library for TypeScript and JavaScript. Effortless reactivity, subscriptions, and memory safety in a tiny package.
+
+## 🚀 Features
+- **Type-safe**: Full TypeScript support out of the box
+- **Minimal API**: Only `get`, `set`, and `subscribe`
+- **Reactive**: Efficient observer pattern for instant updates
+- **Memory safe**: Automatic cleanup of subscriptions
+- **Zero dependencies**: Lightweight and fast
+- **Framework agnostic**: Works with any JS/TS project
+
+## 📦 Installation
+
+```bash
+npm install vibra
+# o
+bun add vibra
+```
+
+## 🛠️ Basic Usage
+
+```typescript
+import vibra from 'vibra';
+
+const counter = vibra(0);
+
+// Subscribe to changes
+const unsubscribe = counter.subscribe((value) => {
+  console.log(`Counter changed to: ${value}`);
+});
+
+// Update the state
+counter.set(1);
+
+// Get current value
+console.log(counter.get()); // 1
+
+// Cleanup subscription
+unsubscribe();
+```
+
+## ⚡ Advanced Usage
+
+### Complex State
+```typescript
+const user = vibra({ name: 'Alice', age: 30 });
+user.subscribe((u) => console.log(u));
+user.set({ name: 'Bob', age: 25 });
+```
+
+### Type Safety
+```typescript
+const store = vibra<string | null>(null);
+store.set('Ready!');
+```
+
+### Multiple Subscribers
+```typescript
+const store = vibra(0);
+const unsub1 = store.subscribe(v => console.log('A', v));
+const unsub2 = store.subscribe(v => console.log('B', v));
+store.set(5);
+// Both subscribers are notified
+```
+
+## 🧩 API Reference
+
+### `vibra<T>(initialValue: T)`
+Returns a store object with:
+- `get(): T` — Get the current value
+- `set(value: T): void` — Set a new value (notifies subscribers if changed)
+- `subscribe(callback: (value: T) => void): () => void` — Subscribe to changes (immediately calls with current value). Returns an unsubscribe function.
+
+## 💡 Why Vibra?
+- **Ultra-lightweight**: No bloat, just state
+- **Predictable**: No magic, no proxies, no hidden behaviors
+- **Easy to test**: Simple, functional API
+- **Perfect for libraries and apps**: Use it anywhere you need reactivity
+
+## 🤝 Contributing
+Pull requests and issues are welcome! Please open an issue to discuss your idea or bug before submitting a PR.
+
+## 📄 License
+MIT

package/dist/index.d.mts

@@ -0,0 +1,49 @@
+/**
+ * Vibra - A Simple Yet Powerful State Management Solution
+ *
+ * Vibra is a lightweight state management library that provides a simple and efficient
+ * way to handle reactive state in your applications.
+ * It follows the observer pattern to create a
+ * reactive data store that can be used across your application.
+ *
+ * Key Features:
+ * - Type-safe with TypeScript support
+ * - Minimal API surface (get, set, subscribe)
+ * - Reactive updates through subscription system
+ * - Memory efficient with automatic cleanup
+ * - Zero dependencies
+ *
+ * @template T - The type of the state value
+ * @param initialValue - The initial value for the state
+ * @returns An object containing methods to interact with the state
+ *
+ * @example
+ * ```typescript
+ * const counter = vibra(0);
+ *
+ * // Subscribe to changes
+ * const unsubscribe = counter.subscribe((value) => {
+ *   console.log(`Counter changed to: ${value}`);
+ * });
+ *
+ * // Update the state
+ * counter.set(1);
+ *
+ * // Get current value
+ * console.log(counter.get()); // 1
+ *
+ * // Cleanup subscription
+ * unsubscribe();
+ * ```
+ */
+declare function vibra<T>(initialValue: T): {
+    get: () => T;
+    set: (value: T) => void;
+    subscribe: (callback: (value: T) => void) => () => void;
+};
+
+interface Main {
+    test: true;
+}
+
+export { type Main, vibra as default };

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Vibra - A Simple Yet Powerful State Management Solution
+ *
+ * Vibra is a lightweight state management library that provides a simple and efficient
+ * way to handle reactive state in your applications.
+ * It follows the observer pattern to create a
+ * reactive data store that can be used across your application.
+ *
+ * Key Features:
+ * - Type-safe with TypeScript support
+ * - Minimal API surface (get, set, subscribe)
+ * - Reactive updates through subscription system
+ * - Memory efficient with automatic cleanup
+ * - Zero dependencies
+ *
+ * @template T - The type of the state value
+ * @param initialValue - The initial value for the state
+ * @returns An object containing methods to interact with the state
+ *
+ * @example
+ * ```typescript
+ * const counter = vibra(0);
+ *
+ * // Subscribe to changes
+ * const unsubscribe = counter.subscribe((value) => {
+ *   console.log(`Counter changed to: ${value}`);
+ * });
+ *
+ * // Update the state
+ * counter.set(1);
+ *
+ * // Get current value
+ * console.log(counter.get()); // 1
+ *
+ * // Cleanup subscription
+ * unsubscribe();
+ * ```
+ */
+declare function vibra<T>(initialValue: T): {
+    get: () => T;
+    set: (value: T) => void;
+    subscribe: (callback: (value: T) => void) => () => void;
+};
+
+interface Main {
+    test: true;
+}
+
+export { type Main, vibra as default };

package/dist/index.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => vibra_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/vibra.ts
+function vibra(initialValue) {
+  let data = initialValue;
+  const subscribers = /* @__PURE__ */ new Set();
+  function subscribe(callback) {
+    subscribers.add(callback);
+    callback(data);
+    return () => {
+      subscribers.delete(callback);
+    };
+  }
+  function set(value) {
+    if (data !== value) {
+      data = value;
+      subscribers.forEach((callback) => callback(data));
+    }
+  }
+  function get() {
+    return data;
+  }
+  return {
+    get,
+    set,
+    subscribe
+  };
+}
+var vibra_default = vibra;

package/dist/index.mjs

@@ -0,0 +1,30 @@
+// src/vibra.ts
+function vibra(initialValue) {
+  let data = initialValue;
+  const subscribers = /* @__PURE__ */ new Set();
+  function subscribe(callback) {
+    subscribers.add(callback);
+    callback(data);
+    return () => {
+      subscribers.delete(callback);
+    };
+  }
+  function set(value) {
+    if (data !== value) {
+      data = value;
+      subscribers.forEach((callback) => callback(data));
+    }
+  }
+  function get() {
+    return data;
+  }
+  return {
+    get,
+    set,
+    subscribe
+  };
+}
+var vibra_default = vibra;
+export {
+  vibra_default as default
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "vibra",
+  "version": "1.0.0",
+  "description": "Vibra: A blazing fast, type-safe, and minimal state management library for TypeScript and JavaScript. Effortless reactivity, subscriptions, and memory safety in a tiny package.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "jest",
+    "prepublishOnly": "bun run build",
+    "lint": "eslint src"
+  },
+  "keywords": [
+    "state-management",
+    "reactive",
+    "typescript",
+    "javascript",
+    "store",
+    "observable",
+    "minimal",
+    "reactivity",
+    "vibra",
+    "library"
+  ],
+  "author": "Roberto Ríos <roberto@rrios.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rrios-dev/vibra"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.27.0",
+    "@types/bun": "latest",
+    "@types/jest": "^29.5.14",
+    "eslint": "^9.27.0",
+    "globals": "^16.1.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.3.2",
+    "tsup": "^8.0.2",
+    "typescript": "^5.0.0",
+    "typescript-eslint": "^8.32.1"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}