@thefoxieflow/signalctx 0.1.1 → 1.0.1

package/README.md

@@ -6,7 +6,9 @@ A tiny, signal-based state utility for React that **solves the `useContext` re-r
 If you’ve ever had this issue:
 
 ```ts
-{ count, book }
+{
+  count, book;
+}
 // updating count re-renders book components 😡
 ```
 
@@ -21,7 +23,7 @@ If you’ve ever had this issue:
 React Context subscribes to the **entire value**.
 
 ```tsx
-const { book } = useContext(StoreCtx)
+const { book } = useContext(StoreCtx);
 ```
 
 When **any property changes**, **every consumer re-renders** — even if they don’t use it.
@@ -34,23 +36,23 @@ This is not a bug. Context has **no selector mechanism**.
 
 `signal-ctx`:
 
-* Moves state **outside React**
-* Uses **external subscriptions**
-* Allows **selector-based updates**
+- Moves state **outside React**
+- Uses **external subscriptions**
+- Allows **selector-based updates**
 
-So only the components that *actually use* the changed data re-render.
+So only the components that _actually use_ the changed data re-render.
 
 ---
 
 ## ✨ Features
 
-* ⚡ Signal-style state container
-* 🎯 Selector-based subscriptions
-* 🧵 React 18 concurrent-safe
-* 🧩 Context-backed but not context-driven
-* 📦 Very small bundle size
-* 🌳 Tree-shakable
-* 🧠 Explicit and predictable
+- ⚡ Signal-style state container
+- 🎯 Selector-based subscriptions
+- 🧵 React 18 concurrent-safe
+- 🧩 Context-backed but not context-driven
+- 📦 Very small bundle size
+- 🌳 Tree-shakable
+- 🧠 Explicit and predictable
 
 ---
 
@@ -78,39 +80,70 @@ The state lives **outside React**, and components subscribe **directly to the si
 
 ---
 
-## 🔹 Signal Store
+## 🔹 Signal
 
 A signal is:
 
-* A function that returns state
-* Can be subscribed to
-* Can be updated imperatively
+- A function that returns state
+- Can be subscribed to
+- Can be updated imperatively
 
 ```ts
-type Store<T> = {
-  (): T
-  subscribe(fn: () => void): () => void
-  set(action: SetStateAction<T>): void
-}
+type Signal<T extends object> = {
+  (): T; // get state
+
+  // add listener
+  on(fn: Subscriber): () => void;
+
+  // notify all listeners
+  notify(): void;
+
+  // reset to initial value
+  reset(): void;
+
+  // update state
+  set(action: SetAction<T>): void;
+};
 ```
 
 ---
 
-## 🔹 Low-Level Hooks
+## 🔹 Low-Level Functions
+
+### `newSignal(init)`
+
+Creates a low-level signal.
+
+```ts
+const signal = newSignal({ count: 0 });
+const state = signal(); // get state { count: 0 }
+
+signal.on(() => console.log("changed"));
+
+setInterval(() => {
+  signal.set((s) => {
+    s.count++;
+  });
+  // will trigger signal.on listeners
+  signal.notify();
+}, 2000);
+```
 
-### `createStore(()=>{})`
+---
+
+## 🔹 React Hooks
 
 ### `useValue(store, selector?)`
 
 Subscribe to a signal.
 
 ```tsx
-const count = useValue(store, s => s.count)
+const count = useValue(store, (s) => s.count);
 ```
 
-* Uses `useSyncExternalStore`
-* Re-renders only when the selected value changes
-* Selector is optional
+- Uses `useSyncExternalStore`
+- Re-renders only when the selected value changes
+- Selector is optional
 
 ---
 
@@ -119,27 +152,40 @@ const count = useValue(store, s => s.count)
 Returns a setter function.
 
 ```ts
-const set = useSet(store)
+const set = useSet(store);
+
+// update entire state
+const prev = store();
+set({ ...prev, count: prev.count + 1 });
 
-set(prev => ({ ...prev, count: prev.count + 1 }))
+// or update partially
+set((s) => {
+  s.count++;
+});
 ```
 
 Scoped update:
 
 ```ts
+const store = newSignal(() => ({
+  book: { title: "1984", page: 1 },
+  user: { name: "Alice" },
+}));
 // book must be object for selector
-const setBook = useSet(store, s => s.book)
-
-
-// put: update an object
-setBook({
-    title : "book"
-})
-
-// patch: update partially
-setBook((b)=>{
-    b.title = "book"
-})
+const setBook = useSet(store, (s) => s.book);
+
+// update an object
+const setBook = () => {
+  setBook({
+    title: "1999",
+    page: 10,
+  });
+};
+
+// or update partially
+setBook((b) => {
+  b.title = "1999";
+});
 ```
 
 ⚠️ Updates are **mutation-based**. Spread manually if you want immutability.
@@ -153,14 +199,21 @@ setBook((b)=>{
 Creates a **context-backed signal store hook**.
 
 ```ts
-import { createCtx } from "@your-scope/signal-ctx"
+import { createCtx } from "@thefoxieflow/signalctx";
 
-export const useStore = createCtx(() => ({
+export const useAppCtx = createCtx(() => ({
   count: 0,
-  book: { title: "1984" }
-}))
+  book: { title: "1984" },
+}));
 ```
 
+The returned function has these properties:
+
+- **`useAppCtx(selector, options)`** - Hook to select state
+- **`useAppCtx.Provider`** - Context provider component
+- **`useAppCtx.useSet(selector, options)`** - Hook to get setter function
+- **`useAppCtx.useSignal(options)`** - Hook to access raw signal underlying the context
+
 ---
 
 ## 🚀 Usage
@@ -168,33 +221,34 @@ export const useStore = createCtx(() => ({
 ### 1. Create a Provider
 
 ```tsx
-// use default initial value from useStore
+// use default initial value from useAppCtx
 type Props = {
-  children: React.ReactNode
-}
+  children: React.ReactNode;
+};
 
-export function StoreProvider({ children }: Props) {
-  const Provider = useStore.provide()
-  return <Provider>{children}</Provider>
+export function AppCtxProvider({ children }: Props) {
+  return <useAppCtx.Provider>{children}</useAppCtx.Provider>;
 }
 
 // overwrite value
-export function StoreProvider({ children }: Props) {
-  const Provider = useStore.provide({
-    value: {
-      count: 10,
-      book: { title: "Brave New World" }
-    }
-  })
-
-  return <Provider>{children}</Provider>
+export function AppCtxProvider({ children }: Props) {
+  return (
+    <useAppCtx.Provider
+      value={{
+        count: 10,
+        book: { title: "Brave New World" },
+      }}
+    >
+      {children}
+    </useAppCtx.Provider>
+  );
 }
 ```
 
 ```tsx
-<StoreProvider>
+<AppCtxProvider>
   <App />
-</StoreProvider>
+</AppCtxProvider>
 ```
 
 ---
@@ -203,13 +257,13 @@ export function StoreProvider({ children }: Props) {
 
 ```tsx
 function Count() {
-  const count = useStore(s => s.count)
-  return <div>{count}</div>
+  const count = useAppCtx((s) => s.count);
+  return <div>{count}</div>;
 }
 
 function Book() {
-  const book = useStore(s => s.book)
-  return <div>{book.title}</div>
+  const book = useAppCtx((s) => s.book);
+  return <div>{book.title}</div>;
 }
 ```
 
@@ -219,34 +273,69 @@ function Book() {
 
 ```tsx
 function Increment() {
-  const set = useStore.useSet()
+  const setCount = useAppCtx.useSet((s) => s);
 
   return (
-    <button onClick={() =>
-      set(s => ({ ...s, count: s.count + 1 }))
-    }>
+    <button
+      onClick={() =>
+        setCount((s) => {
+          s.count++;
+        })
+      }
+    >
       +
     </button>
-  )
+  );
 }
 ```
 
+### 4. Custom signal for additional logic
+
+```tsx
+const signalWithTraceSet = <T extends object & { traceSet: number }>(
+  init: () => T
+) => {
+  const core = newSignal(init);
+
+  const signal: Signal<T> = () => core();
+
+  signal.reset = core.reset;
+  signal.notify = core.notify;
+  signal.on = core.on;
+
+  // set interceptor
+  signal.set = (action: SetAction<T>) => {
+    console.log("before set", core().traceSet);
+    core.set(action);
+    core().traceSet += 1;
+    console.log("after set", core().traceSet);
+  };
+
+  return signal;
+};
+
+const useHelloCtx = createCtx(
+  () => ({ traceSet: 0, text: "hello" }),
+  signalWithTraceSet
+);
+```
+
 ✅ Updating `count` **does NOT re-render** `Book`.
 
 ---
 
 ## 🧩 Why This Works
 
-* Context value never changes
-* React does not re-render on context updates
-* `useSyncExternalStore` compares selected snapshots
-* Only changed selectors trigger re-renders
+- Context value never changes
+- React does not re-render on context updates
+- `useSyncExternalStore` compares selected snapshots
+- Only changed selectors trigger re-renders
 
 This is the **same model** used by:
 
-* Redux `useSelector`
-* Zustand selectors
-* React’s official external store docs
+- Redux `useSelector`
+- Zustand selectors
+- React’s official external store docs
 
 ---
 
@@ -258,68 +347,75 @@ This is the **same model** used by:
 ❌ Bad:
 
 ```ts
-const state = useStore(s => s)
+const { count } = useAppCtx((s) => s);
 ```
 
 ✅ Good:
 
 ```ts
-const count = useStore(s => s.count)
+const count = useAppCtx((s) => s.count);
 ```
 
 ---
 
 ## 🧩 Multiple Stores
 
-You can create isolated stores using `storeName`.
+You can create isolated stores using `name`.
 
 ```tsx
 type Props = {
-  children: React.ReactNode
-  storeName: string
-  initialValue?: { count: number; book: { title: string } }
-}
-
-export function StoreProvider({ children, storeName, initialValue }: Props) {
-  const Provider = useStore.provide({
-    storeName,
-    value: initialValue || { count: 0, book: { title: "1984" } }
-  })
+  children: React.ReactNode;
+  name?: string;
+  initialValue?: { count: number; book: { title: string } };
+};
 
-  return <Provider>{children}</Provider>
+export function AppCtxProvider({ children, name, initialValue }: Props) {
+  return (
+    <useAppCtx.Provider value={initialValue} name={name}>
+      {children}
+    </useAppCtx.Provider>
+  );
 }
 ```
 
 ### Usage
+
 ```tsx
-<StoreProvider storeName="storeA" initialValue={{ count: 1, book: { title: "A" } }}>
+<AppCtxProvider name="storeA" initialValue={{ count: 1, book: { title: "A" } }}>
+  {/* useAppCtx(s => s.book) is from storeA */}
   <AppA />
-  <StoreProvider storeName="storeB" initialValue={{ count: 5, book: { title: "B" } }}>
+  <AppCtxProvider
+    name="storeB"
+    initialValue={{ count: 5, book: { title: "B" } }}
+  >
+    {/* useAppCtx(s => s.book) is from storeB */}
+    {/* useAppCtx(s => s.book, { name: "storeA" }) is from storeA */}
     <AppB />
-  </StoreProvider>
-</StoreProvider>
-
-function AppB(){
-  // book from parent context; parent = "storeA" so book.title = "A"
-  const book = useStore(s => s.book)
-
-  // but i want a book from storeA; so it requires storeName
-  // book.title = "B"
-  const storeABook = useStore(s => s.book,{ storeName :"storeA" })
-
-  // same apply to setter
-  const setBookStoreA = useStore.useSet((s)=>s.book, {storeName : "storeA"})
-
-  const handleClick = (text)=>{
-    setCountStoreA((s) => {
-       s.title = "change A to AA"
-       return s
-    })
-  }
-}
-```
+  </AppCtxProvider>
+</AppCtxProvider>;
+
+function AppB() {
+  // Read from parent storeB, book.title = "B"
+  const currentBook = useAppCtx((s) => s.book); // or useAppCtx(s => s.book, { name: "storeB" })
 
+  const layerAbook = useAppCtx((s) => s.book, { name: "storeA" }); // book.title = "A"
 
+  // AppB want to change data in context StoreA layer
+  const setLayerAbook = useAppCtx.useSet((s) => s.book, {
+    name: "storeA",
+  });
+
+  const handleSetLayerABook = (text) => {
+    setLayerAbook((b) => {
+      if (b.title !== "A") {
+        console.error("title in storeA should be A");
+      }
+
+      b.title = text;
+    });
+  };
+}
+```
 
 Each store is independent.
 
@@ -329,24 +425,24 @@ Each store is independent.
 
 `Signal Ctx` is SSR-safe.
 
-* Uses `useSyncExternalStore`
-* Identical snapshot logic on server & client
-* No shared global state between requests
+- Uses `useSyncExternalStore`
+- Identical snapshot logic on server & client
+- No shared global state between requests
 
 ---
 
 ## ⚠️ Caveats
 
-* No middleware
-* No devtools
-* No persistence
-* Mutation-based updates by design
+- No middleware
+- No devtools
+- No persistence
+- Mutation-based updates by design
 
 Best suited for:
 
-* UI state
-* App-level shared state
-* Lightweight global stores
+- UI state
+- Lightweight global stores
+- flexible shared state
 
 ---
 
@@ -355,7 +451,7 @@ Best suited for:
 Fully typed with generics and inferred selectors.
 
 ```ts
-const count = useStore(s => s.count) // number
+const count = useAppCtx((s) => s.count); // number
 ```
 
 ---
@@ -372,8 +468,8 @@ MIT
 
 It favors:
 
-* Explicit ownership
-* Predictable updates
-* Minimal abstraction
+- Explicit ownership
+- Predictable updates
+- Minimal abstraction
 
 If you understand React, you understand `signalctx`.

package/dist/index.d.mts

@@ -10,27 +10,20 @@ type Signal<T> = {
     reset: () => void;
     set: (action: SetAction<T>) => void;
 };
-type Store<T> = {
-    (): T;
-    on: (sub: Subscriber) => () => void;
-    reset: () => void;
-    set: (action: SetAction<T>) => void;
-    $: Signal<T>;
-};
+declare const newSignal: <T extends object>(init: () => T) => Signal<T>;
+declare const useValue: <T extends object, Dest = T>(store: Signal<T>, selector?: (state: T) => Dest) => Dest;
+declare const useSet: <T extends object = any, Dest extends object = T>($: Signal<T>, selector?: (state: T) => Dest) => (action: SetAction<Dest>) => void;
 type StoreOption = {
-    storeName?: string;
+    name?: string;
 };
-declare const newStore: <T extends Record<string, any>>(init: () => T) => Store<T>;
-declare const useValue: <T extends object, Dest = T>(store: Store<T>, selector?: (state: T) => Dest) => Dest;
-declare const useSet: <T extends object = any, Dest extends object = T>(store: Store<T>, selector?: (state: T) => Dest) => (action: SetAction<Dest>) => void;
-declare function createCtx<T extends object>(init: () => T): {
-    <Dest = any>(selector: (state: T) => Dest, opt?: StoreOption): Dest;
-    Provider: ({ children, value, storeName, }: PropsWithChildren<{
+declare function createCtx<T extends object>(init: () => T, makeSignal?: (init: () => T) => Signal<T>): {
+    <Dest extends object = T>(selector: (state: T) => Dest, opt?: StoreOption): Dest;
+    useSet<Dest extends object = T>(selector?: (state: T) => Dest, opt?: StoreOption): (action: SetAction<Dest>) => void;
+    useSignal<Dest extends object = T>(selector: (state: T) => Dest, opt?: StoreOption): Dest;
+    Provider(props: PropsWithChildren<{
         value?: T;
-        storeName?: string;
-    }>) => react_jsx_runtime.JSX.Element;
-    useSet: <Dest extends object = T>(selector?: (state: T) => Dest, opt?: StoreOption) => (action: SetAction<Dest>) => void;
-    useStore: (opt?: StoreOption) => Store<T>;
+        name?: string;
+    }>): react_jsx_runtime.JSX.Element;
 };
 
-export { type SetAction, type Signal, type Store, type Subscriber, createCtx, newStore, useSet, useValue };
+export { type SetAction, type Signal, type Subscriber, createCtx, newSignal, useSet, useValue };

package/dist/index.d.ts

@@ -10,27 +10,20 @@ type Signal<T> = {
     reset: () => void;
     set: (action: SetAction<T>) => void;
 };
-type Store<T> = {
-    (): T;
-    on: (sub: Subscriber) => () => void;
-    reset: () => void;
-    set: (action: SetAction<T>) => void;
-    $: Signal<T>;
-};
+declare const newSignal: <T extends object>(init: () => T) => Signal<T>;
+declare const useValue: <T extends object, Dest = T>(store: Signal<T>, selector?: (state: T) => Dest) => Dest;
+declare const useSet: <T extends object = any, Dest extends object = T>($: Signal<T>, selector?: (state: T) => Dest) => (action: SetAction<Dest>) => void;
 type StoreOption = {
-    storeName?: string;
+    name?: string;
 };
-declare const newStore: <T extends Record<string, any>>(init: () => T) => Store<T>;
-declare const useValue: <T extends object, Dest = T>(store: Store<T>, selector?: (state: T) => Dest) => Dest;
-declare const useSet: <T extends object = any, Dest extends object = T>(store: Store<T>, selector?: (state: T) => Dest) => (action: SetAction<Dest>) => void;
-declare function createCtx<T extends object>(init: () => T): {
-    <Dest = any>(selector: (state: T) => Dest, opt?: StoreOption): Dest;
-    Provider: ({ children, value, storeName, }: PropsWithChildren<{
+declare function createCtx<T extends object>(init: () => T, makeSignal?: (init: () => T) => Signal<T>): {
+    <Dest extends object = T>(selector: (state: T) => Dest, opt?: StoreOption): Dest;
+    useSet<Dest extends object = T>(selector?: (state: T) => Dest, opt?: StoreOption): (action: SetAction<Dest>) => void;
+    useSignal<Dest extends object = T>(selector: (state: T) => Dest, opt?: StoreOption): Dest;
+    Provider(props: PropsWithChildren<{
         value?: T;
-        storeName?: string;
-    }>) => react_jsx_runtime.JSX.Element;
-    useSet: <Dest extends object = T>(selector?: (state: T) => Dest, opt?: StoreOption) => (action: SetAction<Dest>) => void;
-    useStore: (opt?: StoreOption) => Store<T>;
+        name?: string;
+    }>): react_jsx_runtime.JSX.Element;
 };
 
-export { type SetAction, type Signal, type Store, type Subscriber, createCtx, newStore, useSet, useValue };
+export { type SetAction, type Signal, type Subscriber, createCtx, newSignal, useSet, useValue };

package/dist/index.js

@@ -21,7 +21,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   createCtx: () => createCtx,
-  newStore: () => newStore,
+  newSignal: () => newSignal,
   useSet: () => useSet,
   useValue: () => useValue
 });
@@ -31,21 +31,21 @@ var import_jsx_runtime = require("react/jsx-runtime");
 var newSignal = (init) => {
   let ref;
   const subs = /* @__PURE__ */ new Set();
-  const store = () => ref || (ref = init());
-  store.set = (action) => {
-    act(store(), action);
+  const signal = () => ref || (ref = init());
+  signal.set = (action) => {
+    act(signal(), action);
   };
-  store.reset = () => {
+  signal.reset = () => {
     ref = init();
   };
-  store.notify = () => {
+  signal.notify = () => {
     subs.forEach((sub) => sub());
   };
-  store.on = (sub) => {
+  signal.on = (sub) => {
     subs.add(sub);
     return () => subs.delete(sub);
   };
-  return store;
+  return signal;
 };
 var replaceIfDiff = (target, newVal) => {
   if (Object.is(target, newVal)) return;
@@ -59,89 +59,74 @@ var act = (target, action) => {
     replaceIfDiff(target, action);
   }
 };
-var newStore = (init) => {
-  const $ = newSignal(init);
-  const store = () => $();
-  store.$ = $;
-  store.on = $.on;
-  store.reset = () => {
-    $.reset();
-    $.notify();
-  };
-  store.set = (action) => {
-    $.set(action);
-    $.notify();
-  };
-  return store;
-};
 var useValue = (store, selector) => {
   const get = () => selector ? selector(store()) : store();
   return (0, import_react.useSyncExternalStore)(store.on, get, get);
 };
-var useSet = (store, selector) => {
+var useSet = ($, selector) => {
   const setter = (action) => {
-    const ref = store.$();
+    const ref = $();
     const targetRef = selector ? selector(ref) : ref;
     act(targetRef, action);
-    store.$.notify();
+    $.notify();
   };
   return setter;
 };
-function createCtx(init) {
+function createCtx(init, makeSignal = (init2) => newSignal(init2)) {
   const ctx = (0, import_react.createContext)(null);
-  const stores = /* @__PURE__ */ new Map();
-  const initStore = (init2, name) => {
-    if (!name) return newStore(init2);
-    if (!stores.has(name)) {
-      stores.set(name, newStore(init2));
-    }
+  let stores;
+  const initSignal = (init2, name) => {
+    if (!name) return makeSignal(init2);
+    if (!stores) stores = /* @__PURE__ */ new Map();
+    if (!stores.has(name)) stores.set(name, makeSignal(init2));
     return stores.get(name);
   };
-  const useStore = (opt) => {
+  const useSignal = (opt) => {
+    if (opt?.name) {
+      if (!stores || !stores.has(opt.name))
+        throw new Error(`<Provider name="${opt.name}" ...> does not exist`);
+      return stores.get(opt.name);
+    }
     const store = (0, import_react.useContext)(ctx);
-    if (opt?.storeName && stores.has(opt.storeName)) return stores.get(opt.storeName);
     if (!store) throw new Error("useCtx must be used within a Provider");
     return store;
   };
-  const Provider = ({
-    children,
-    value,
-    storeName
-  }) => {
-    const [store, name] = (0, import_react.useMemo)(() => {
-      const storeInit = value ? () => value : init;
-      const store2 = initStore(storeInit, storeName);
-      return [store2, storeName];
-    }, [value, storeName]);
+  const useSelect = (selector, opt) => {
+    const store = useSignal(opt);
+    return useValue(store, selector);
+  };
+  useSelect.useSet = (selector, opt) => {
+    const store = useSignal(opt);
+    return useSet(store, selector);
+  };
+  useSelect.useSignal = (selector, opt) => {
+    const store = useSignal(opt);
+    return useValue(store, selector);
+  };
+  useSelect.Provider = (props) => {
+    const [signal, name] = (0, import_react.useMemo)(() => {
+      const initor = props.value ? () => props.value : init;
+      const _signal = initSignal(initor, props.name);
+      return [_signal, props.name];
+    }, [props.value, props.name]);
     (0, import_react.useEffect)(
       () => () => {
         if (name) stores.delete(name);
       },
-      [store, name]
+      [signal, name]
     );
-    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(ctx.Provider, { value: store, children: [
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(ctx.Provider, { value: signal, children: [
       " ",
-      children,
+      props.children,
       " "
     ] });
   };
-  const useSelect = (selector, opt) => {
-    const store = useStore(opt);
-    return useValue(store, selector);
-  };
-  const useSetter = (selector, opt) => {
-    const store = useStore(opt);
-    return useSet(store, selector);
-  };
-  useSelect.Provider = Provider;
-  useSelect.useSet = useSetter;
-  useSelect.useStore = useStore;
   return useSelect;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   createCtx,
-  newStore,
+  newSignal,
   useSet,
   useValue
 });

package/dist/index.mjs

@@ -10,21 +10,21 @@ import { jsxs } from "react/jsx-runtime";
 var newSignal = (init) => {
   let ref;
   const subs = /* @__PURE__ */ new Set();
-  const store = () => ref || (ref = init());
-  store.set = (action) => {
-    act(store(), action);
+  const signal = () => ref || (ref = init());
+  signal.set = (action) => {
+    act(signal(), action);
   };
-  store.reset = () => {
+  signal.reset = () => {
     ref = init();
   };
-  store.notify = () => {
+  signal.notify = () => {
     subs.forEach((sub) => sub());
   };
-  store.on = (sub) => {
+  signal.on = (sub) => {
     subs.add(sub);
     return () => subs.delete(sub);
   };
-  return store;
+  return signal;
 };
 var replaceIfDiff = (target, newVal) => {
   if (Object.is(target, newVal)) return;
@@ -38,88 +38,73 @@ var act = (target, action) => {
     replaceIfDiff(target, action);
   }
 };
-var newStore = (init) => {
-  const $ = newSignal(init);
-  const store = () => $();
-  store.$ = $;
-  store.on = $.on;
-  store.reset = () => {
-    $.reset();
-    $.notify();
-  };
-  store.set = (action) => {
-    $.set(action);
-    $.notify();
-  };
-  return store;
-};
 var useValue = (store, selector) => {
   const get = () => selector ? selector(store()) : store();
   return useSyncExternalStore(store.on, get, get);
 };
-var useSet = (store, selector) => {
+var useSet = ($, selector) => {
   const setter = (action) => {
-    const ref = store.$();
+    const ref = $();
     const targetRef = selector ? selector(ref) : ref;
     act(targetRef, action);
-    store.$.notify();
+    $.notify();
   };
   return setter;
 };
-function createCtx(init) {
+function createCtx(init, makeSignal = (init2) => newSignal(init2)) {
   const ctx = createContext(null);
-  const stores = /* @__PURE__ */ new Map();
-  const initStore = (init2, name) => {
-    if (!name) return newStore(init2);
-    if (!stores.has(name)) {
-      stores.set(name, newStore(init2));
-    }
+  let stores;
+  const initSignal = (init2, name) => {
+    if (!name) return makeSignal(init2);
+    if (!stores) stores = /* @__PURE__ */ new Map();
+    if (!stores.has(name)) stores.set(name, makeSignal(init2));
     return stores.get(name);
   };
-  const useStore = (opt) => {
+  const useSignal = (opt) => {
+    if (opt?.name) {
+      if (!stores || !stores.has(opt.name))
+        throw new Error(`<Provider name="${opt.name}" ...> does not exist`);
+      return stores.get(opt.name);
+    }
     const store = useContext(ctx);
-    if (opt?.storeName && stores.has(opt.storeName)) return stores.get(opt.storeName);
     if (!store) throw new Error("useCtx must be used within a Provider");
     return store;
   };
-  const Provider = ({
-    children,
-    value,
-    storeName
-  }) => {
-    const [store, name] = useMemo(() => {
-      const storeInit = value ? () => value : init;
-      const store2 = initStore(storeInit, storeName);
-      return [store2, storeName];
-    }, [value, storeName]);
+  const useSelect = (selector, opt) => {
+    const store = useSignal(opt);
+    return useValue(store, selector);
+  };
+  useSelect.useSet = (selector, opt) => {
+    const store = useSignal(opt);
+    return useSet(store, selector);
+  };
+  useSelect.useSignal = (selector, opt) => {
+    const store = useSignal(opt);
+    return useValue(store, selector);
+  };
+  useSelect.Provider = (props) => {
+    const [signal, name] = useMemo(() => {
+      const initor = props.value ? () => props.value : init;
+      const _signal = initSignal(initor, props.name);
+      return [_signal, props.name];
+    }, [props.value, props.name]);
     useEffect(
       () => () => {
         if (name) stores.delete(name);
       },
-      [store, name]
+      [signal, name]
     );
-    return /* @__PURE__ */ jsxs(ctx.Provider, { value: store, children: [
+    return /* @__PURE__ */ jsxs(ctx.Provider, { value: signal, children: [
       " ",
-      children,
+      props.children,
       " "
     ] });
   };
-  const useSelect = (selector, opt) => {
-    const store = useStore(opt);
-    return useValue(store, selector);
-  };
-  const useSetter = (selector, opt) => {
-    const store = useStore(opt);
-    return useSet(store, selector);
-  };
-  useSelect.Provider = Provider;
-  useSelect.useSet = useSetter;
-  useSelect.useStore = useStore;
   return useSelect;
 }
 export {
   createCtx,
-  newStore,
+  newSignal,
   useSet,
   useValue
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thefoxieflow/signalctx",
-  "version": "0.1.1",
+  "version": "1.0.1",
   "description": "Lightweight signal-based React context store",
   "main": "dist/index.cjs",
   "module": "dist/index.js",