@everystate/core 1.0.0 → 1.0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Imsirovic Ajdin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -13,9 +13,9 @@ npm install @everystate/core
 ## Quick Start
 
 ```js
-import { createEventState } from '@everystate/core';
+import { createEveryState } from '@everystate/core';
 
-const store = createEventState({ count: 0, user: { name: 'Alice' } });
+const store = createEveryState({ count: 0, user: { name: 'Alice' } });
 
 // Subscribe to specific path
 const unsub = store.subscribe('count', (value) => {
@@ -65,13 +65,26 @@ EveryState makes state **addressable, observable, and testable** without special
 ## Ecosystem
 
 - `@everystate/core`: Core state engine (you are here)
-- `@everystate/view`: DOM-as-state with surgical updates
-- `@everystate/perf`: Performance monitoring overlay
 - `@everystate/css`: Reactive styling and design tokens
-- `@everystate/router`: SPA routing as state
+- `@everystate/perf`: Performance monitoring overlay
 - `@everystate/react`: React hooks adapter
-- `@everystate/renderer`: Direct-binding reactive renderer
-- `@everystate/event-test`: Zero-dependency testing
+- `@everystate/router`: SPA routing as state
+- `@everystate/test`: Zero-dependency testing
+- `@everystate/view`: DOM-as-state with surgical updates
+
+
+| Package | Description | License |
+|---|---|---|
+| [@everystate/aliases](https://www.npmjs.com/package/@everystate/aliases) | Ergonomic single-character and short-name DOM aliases for vanilla JS | MIT |
+| [@everystate/core](https://www.npmjs.com/package/@everystate/core) | Path-based state management with wildcard subscriptions and async support. Core state engine (you are here). | MIT |
+| [@everystate/css](https://www.npmjs.com/package/@everystate/css) | Reactive CSSOM engine: design tokens, typed validation, WCAG enforcement, all via path-based state | MIT |
+| [@everystate/examples](https://www.npmjs.com/package/@everystate/examples) | Example applications and patterns | MIT |
+| [@everystate/perf](https://www.npmjs.com/package/@everystate/perf) | Performance monitoring overlay | MIT |
+| [@everystate/react](https://www.npmjs.com/package/@everystate/react) | React hooks adapter: `usePath`, `useIntent`, `useAsync` hooks and `EventStateProvider` | MIT |
+| [@everystate/renderer](https://www.npmjs.com/package/@everystate/renderer) | Direct-binding reactive renderer: `bind-*`, `set`, `each` attributes. Zero build step | Proprietary |
+| [@everystate/router](https://www.npmjs.com/package/@everystate/router) | SPA routing as state | MIT |
+| [@everystate/test](https://www.npmjs.com/package/@everystate/test) | Event-sequence testing for UIstate stores. Zero dependency. | Proprietary |
+| [@everystate/view](https://www.npmjs.com/package/@everystate/view) | State-driven view: DOMless resolve + surgical DOM projector. View tree as first-class state | MIT |
 
 ## Documentation
 

package/everyState.js

@@ -0,0 +1,304 @@
+/**
+ * EveryState v1.0.0 - Optimized Path-Based State Management
+ *
+ * A lightweight, performant state management library using path-based subscriptions.
+ * Optimized for selective notifications and granular updates.
+ *
+ * Features:
+ * - Path-based get/set operations (e.g., 'user.profile.name')
+ * - Selective subscriptions (only relevant subscribers fire)
+ * - Wildcard subscriptions (e.g., 'user.*' catches all user changes)
+ * - Global subscriptions (e.g., '*' catches all changes)
+ * - Atomic batching (batch/setMany — subscribers fire after all writes)
+ * - Zero dependencies
+ * - ~2KB minified
+ *
+ * Performance characteristics:
+ * - 2-9x faster than Zustand for selective subscriptions
+ * - Competitive overall performance
+ * - Minimal rendering overhead (1.27x faster paint times)
+ *
+ * @example
+ * const store = createEveryState({ count: 0, user: { name: 'Alice' } });
+ *
+ * // Subscribe to specific path
+ * const unsub = store.subscribe('count', (value) => {
+ *   console.log('Count changed:', value);
+ * });
+ *
+ * // Update state
+ * store.set('count', 1);
+ *
+ * // Get state
+ * const count = store.get('count');
+ *
+ * // Wildcard subscription
+ * store.subscribe('user.*', ({ path, value }) => {
+ *   console.log(`User field ${path} changed to:`, value);
+ * });
+ *
+ * // Global subscription
+ * store.subscribe('*', ({ path, value }) => {
+ *   console.log(`State changed at ${path}:`, value);
+ * });
+ *
+ * // Batch multiple writes (subscribers fire once per path, after batch)
+ * store.batch(() => {
+ *   store.set('user.name', 'Charlie');
+ *   store.set('user.email', 'charlie@example.com');
+ * });
+ *
+ * // Or use setMany for the same effect
+ * store.setMany({ 'user.name': 'Charlie', 'user.email': 'charlie@example.com' });
+ *
+ * // Cleanup
+ * unsub();
+ * store.destroy();
+ */
+
+export function createEveryState(initial = {}) {
+  const state = JSON.parse(JSON.stringify(initial));
+  const listeners = new Map();
+  const asyncOps = new Map();
+  let destroyed = false;
+
+  // Batching: buffer writes and flush once at the end
+  let batching = false;
+  const batchBuffer = new Map();
+
+  function writeAndNotify(path, value) {
+    const parts = path.split(".");
+    const key = parts.pop();
+    let cur = state;
+
+    for (const p of parts) {
+      if (!cur[p]) cur[p] = {};
+      cur = cur[p];
+    }
+
+    const oldValue = cur[key];
+    cur[key] = value;
+
+    // Fast-path: skip all listener dispatch when nobody is subscribed.
+    // This preserves observer-before-observable: the moment any subscriber
+    // registers, listeners.size > 0 and the full dispatch runs.
+    if (destroyed || listeners.size === 0) return value;
+
+    // Lazy detail allocation: only build the object when a listener is
+    // actually present.  No closure is created — the inline `||` re-uses
+    // the same object across exact / wildcard / global dispatch.
+    let detail = null;
+
+    const exactListeners = listeners.get(path);
+    if (exactListeners && exactListeners.size > 0) {
+      detail = { path, value, oldValue };
+      exactListeners.forEach(cb => cb(value, detail));
+    }
+
+    if (parts.length) {
+      let parent = "";
+      for (const p of parts) {
+        parent = parent ? `${parent}.${p}` : p;
+        const wildcardListeners = listeners.get(`${parent}.*`);
+        if (wildcardListeners && wildcardListeners.size > 0) {
+          detail = detail || { path, value, oldValue };
+          wildcardListeners.forEach(cb => cb(detail));
+        }
+      }
+    }
+
+    const globalListeners = listeners.get('*');
+    if (globalListeners && globalListeners.size > 0) {
+      detail = detail || { path, value, oldValue };
+      globalListeners.forEach(cb => cb(detail));
+    }
+
+    return value;
+  }
+
+  function flushBatch() {
+    const entries = Array.from(batchBuffer.entries());
+    batchBuffer.clear();
+    for (const [p, v] of entries) {
+      writeAndNotify(p, v);
+    }
+  }
+
+  return {
+    /**
+     * Get value at path
+     * @param {string} path - Dot-separated path (e.g., 'user.profile.name')
+     * @returns {*} Value at path, or entire state if no path provided
+     */
+    get(path) {
+      if (destroyed) throw new Error('Cannot get from destroyed store');
+      if (!path) return state;
+      const parts = path.split('.');
+      let cur = state;
+      for (const p of parts) {
+        if (cur == null) return undefined;
+        cur = cur[p];
+      }
+      return cur;
+    },
+
+    /**
+     * Set value at path and notify subscribers
+     * @param {string} path - Dot-separated path (e.g., 'user.profile.name')
+     * @param {*} value - New value
+     * @returns {*} The value that was set
+     */
+    set(path, value) {
+      if (destroyed) throw new Error('Cannot set on destroyed store');
+      if (!path) return value;
+
+      if (batching) {
+        batchBuffer.set(path, value);
+        return value;
+      }
+
+      return writeAndNotify(path, value);
+    },
+
+    async setAsync(path, fetcher) {
+      if (destroyed) throw new Error('Cannot setAsync on destroyed store');
+      if (!path) throw new TypeError('setAsync requires a path');
+      if (typeof fetcher !== 'function') {
+        throw new TypeError('setAsync(path, fetcher) requires a function fetcher');
+      }
+
+      if (asyncOps.has(path)) {
+        asyncOps.get(path).controller.abort();
+      }
+
+      const controller = new AbortController();
+      asyncOps.set(path, { controller });
+
+      try {
+        this.batch(() => {
+          this.set(`${path}.status`, 'loading');
+          this.set(`${path}.error`, null);
+        });
+
+        const data = await fetcher(controller.signal);
+
+        if (destroyed) throw new Error('Cannot setAsync on destroyed store');
+
+        this.batch(() => {
+          this.set(`${path}.data`, data);
+          this.set(`${path}.status`, 'success');
+        });
+        return data;
+      } catch (err) {
+        if (err?.name === 'AbortError') {
+          this.set(`${path}.status`, 'cancelled');
+          const cancelErr = new Error('Request cancelled');
+          cancelErr.name = 'AbortError';
+          throw cancelErr;
+        }
+
+        this.batch(() => {
+          this.set(`${path}.status`, 'error');
+          this.set(`${path}.error`, err?.message ?? String(err));
+        });
+        throw err;
+      } finally {
+        const op = asyncOps.get(path);
+        if (op?.controller === controller) {
+          asyncOps.delete(path);
+        }
+      }
+    },
+
+    cancel(path) {
+      if (destroyed) throw new Error('Cannot cancel on destroyed store');
+      if (!path) throw new TypeError('cancel requires a path');
+
+      if (asyncOps.has(path)) {
+        asyncOps.get(path).controller.abort();
+        asyncOps.delete(path);
+        this.set(`${path}.status`, 'cancelled');
+      }
+    },
+
+    /**
+     * Batch multiple set() calls. Subscribers fire once per unique path
+     * after the batch completes, not during. Supports nesting.
+     * @param {Function} fn - Function containing set() calls to batch
+     */
+    batch(fn) {
+      if (destroyed) throw new Error('Cannot batch on destroyed store');
+      if (typeof fn !== 'function') throw new TypeError('batch requires a function');
+      const wasBatching = batching;
+      batching = true;
+      try {
+        fn();
+      } finally {
+        batching = wasBatching;
+        if (!batching) flushBatch();
+      }
+    },
+
+    /**
+     * Set multiple paths atomically. Equivalent to batch(() => { set(a); set(b); ... }).
+     * Accepts a plain object, an array of [path, value] pairs, or a Map.
+     * @param {Object|Array|Map} entries - Paths and values to set
+     */
+    setMany(entries) {
+      if (destroyed) throw new Error('Cannot setMany on destroyed store');
+      if (!entries) return;
+      this.batch(() => {
+        if (Array.isArray(entries)) {
+          for (const [p, v] of entries) this.set(p, v);
+        } else if (entries instanceof Map) {
+          for (const [p, v] of entries.entries()) this.set(p, v);
+        } else if (typeof entries === 'object') {
+          for (const p of Object.keys(entries)) this.set(p, entries[p]);
+        }
+      });
+    },
+
+    /**
+     * Subscribe to changes at path
+     * @param {string} path - Path to subscribe to (supports wildcards: 'user.*', '*')
+     * @param {Function} handler - Callback function.
+     *   - Exact path subscriptions: (value, meta) => void
+     *   - Wildcard/global subscriptions: (meta) => void
+     * @returns {Function} Unsubscribe function
+     */
+    subscribe(path, handler) {
+      if (destroyed) throw new Error('Cannot subscribe to destroyed store');
+      if (!path || typeof handler !== 'function') {
+        throw new TypeError('subscribe requires path and handler');
+      }
+
+      if (!listeners.has(path)) {
+        listeners.set(path, new Set());
+      }
+      listeners.get(path).add(handler);
+
+      return () => {
+        const set = listeners.get(path);
+        if (set) {
+          set.delete(handler);
+          if (set.size === 0) listeners.delete(path);
+        }
+      };
+    },
+
+    /**
+     * Destroy store and clear all subscriptions
+     */
+    destroy() {
+      if (!destroyed) {
+        destroyed = true;
+        batchBuffer.clear();
+        asyncOps.forEach(({ controller }) => controller.abort());
+        asyncOps.clear();
+        listeners.clear();
+      }
+    }
+  };
+}
+
+export default createEveryState;

package/index.js

@@ -1,9 +1,6 @@
 /**
  * @everystate/core
- * 
- * EveryState wrapper for @uistate/core
- * Re-exports all functionality from the underlying @uistate/core package
  */
 
-export { createEventState } from '@uistate/core';
-export * from '@uistate/core';
+export { createEveryState } from './everyState.js';
+export { createQueryClient } from './queryClient.js';

package/package.json

@@ -1,9 +1,13 @@
 {
   "name": "@everystate/core",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "EveryState: Lightweight event-driven state management with path-based subscriptions, wildcards, and async support",
   "type": "module",
   "main": "index.js",
+  "types": "index.d.ts",
+  "scripts": {
+    "test": "node self-test.js"
+  },
   "keywords": [
     "everystate",
     "state-management",
@@ -30,9 +34,8 @@
   "homepage": "https://github.com/ImsirovicAjdin/everystate-core#readme",
   "files": [
     "index.js",
+    "everyState.js",
+    "queryClient.js",
     "README.md"
-  ],
-  "dependencies": {
-    "@uistate/core": "^5.6.0"
-  }
+  ]
 }

package/queryClient.js

@@ -0,0 +1,54 @@
+// Mini QueryClient wrapper for EveryState
+// Thin async layer with standard query patterns
+
+export const createQueryClient = (store) => {
+  return {
+    // Run a query with async state handling
+    async query(key, fetcher) {
+      return await store.setAsync(`query.${key}`, fetcher);
+    },
+
+    // Subscribe to query data
+    subscribe(key, cb) {
+      return store.subscribe(`query.${key}.data`, cb);
+    },
+
+    // Subscribe to query status
+    subscribeToStatus(key, cb) {
+      return store.subscribe(`query.${key}.status`, cb);
+    },
+
+    // Subscribe to query errors
+    subscribeToError(key, cb) {
+      return store.subscribe(`query.${key}.error`, cb);
+    },
+
+    // Read current query data
+    getData(key) {
+      return store.get(`query.${key}.data`);
+    },
+
+    // Read current query status
+    getStatus(key) {
+      return store.get(`query.${key}.status`);
+    },
+
+    // Read current query error
+    getError(key) {
+      return store.get(`query.${key}.error`);
+    },
+
+    // Cancel active query
+    cancel(key) {
+      store.cancel(`query.${key}`);
+    },
+
+    // Reset query to idle
+    invalidate(key) {
+      const p = `query.${key}`;
+      store.set(`${p}.data`, null);
+      store.set(`${p}.status`, "idle");
+      store.set(`${p}.error`, null);
+    },
+  };
+};