totally-tubular 0.3.2 → 0.4.0

package/README.md

@@ -18,7 +18,7 @@ npm i totally-tubular --save
 
 ## Core concepts
 
-A `Tubular` instance wraps an object and gives you four things:
+A `Tubular` instance wraps an object and gives you five things:
 
 | Method | What it does |
 |---|---|
@@ -26,6 +26,7 @@ A `Tubular` instance wraps an object and gives you four things:
 | `update(path, fn)` | Calls `fn` with the current value, stores the return value, then notifies all observers |
 | `observe(path, fn)` | Registers a callback that fires whenever `path` is updated |
 | `unobserve(path, fn)` | Removes a previously registered callback |
+| `reset()` | Restores every key to its initial value and notifies all observers of each change |
 
 Paths are fully type-checked. TypeScript knows every valid dot-path into your state shape, so you get autocomplete and a compile error if you mistype a key.
 
@@ -63,6 +64,30 @@ store.update("meta.title", (prev) => `Supreme ${prev}`);
 console.info(store.read("meta.title")); // "Supreme Director"
 ```
 
+## Resetting state
+
+Call `reset()` to restore your entire state back to the value you passed to the constructor. Every updated key is restored and every registered observer fires with the new (initial) value.
+
+```typescript
+const store = new Tubular({
+  name: "Alice",
+  count: 0,
+  settings: { theme: "light" },
+});
+
+store.update("name", () => "Bob");
+store.update("count", (prev) => prev + 1);
+store.update("settings.theme", () => "dark");
+
+store.observe("name", (newVal, oldVal) => {
+  console.log(`name: ${oldVal} -> ${newVal}`);
+});
+
+store.reset();
+// Logs: name: Bob -> Alice
+// Reads back: "Alice", 0, { theme: "light" }
+```
+
 ## React
 
 Import `useTubular` from `totally-tubular/react`. It works exactly like React's
@@ -115,6 +140,24 @@ setCount((prev) => (prev ?? 0) + 1);
 `useTubular` automatically unsubscribes when the component unmounts, so you
 don't need to manage cleanup yourself.
 
+### Resetting from React
+
+Import `useTubularReset` from `totally-tubular/react`. It returns a stable
+callback that restores the store to its initial state. Every `useTubular` hook
+watching the store re-renders with the restored value.
+
+```tsx
+import { useTubularReset } from "totally-tubular/react";
+
+function ResetButton() {
+  const handleReset = useTubularReset(store);
+  return <button onClick={handleReset}>Reset</button>;
+}
+```
+
+The callback identity never changes, so it's safe to pass directly as an event
+handler or as a dependency to `useEffect`.
+
 ## Things you should know
 
 - **Arrays and nested objects are observed at their path, not their contents.**

package/dist/object.d.ts

@@ -0,0 +1,3 @@
+export declare function isArray(thing: unknown): thing is unknown[];
+export declare function isObject(thing: unknown): thing is object;
+export declare function isNullOrUndefined(thing: unknown): thing is null | undefined;

package/dist/object.js

@@ -0,0 +1,9 @@
+export function isArray(thing) {
+    return Array.isArray(thing);
+}
+export function isObject(thing) {
+    return typeof thing === 'object';
+}
+export function isNullOrUndefined(thing) {
+    return thing === null || thing === undefined || typeof thing === 'undefined';
+}

package/dist/{cjs/react.d.ts → react.d.ts}

@@ -28,3 +28,26 @@ import type { AllObjectKeys, PropType } from './types.js';
  * ```
  */
 export declare function useTubular<T extends object, K extends string>(tubular: Tubular<T>, key: K & AllObjectKeys<T>): readonly [PropType<T, K> | null, (newValOrCallback: PropType<T, K> | ((prevVal: PropType<T, K> | null) => PropType<T, K>)) => void];
+/**
+ * A React hook that returns a stable callback to reset a {@link Tubular} store
+ * back to its initial state.
+ *
+ * Every key in the store is restored to the value originally passed to the
+ * constructor, and every registered observer (including {@link useTubular}
+ * hooks) is notified of each change.
+ *
+ * The returned callback is stable across re-renders.
+ * It never changes its identity, so it is safe to pass as a dependency to `useEffect` or as a prop
+ * to memoized components.
+ *
+ * @example
+ * ```tsx
+ * const store = new Tubular({ name: 'Alice', count: 0 });
+ *
+ * function ResetButton() {
+ *   const handleReset = useTubularReset(store);
+ *   return <button onClick={handleReset}>Reset</button>;
+ * }
+ * ```
+ */
+export declare function useTubularReset<T extends object>(tubular: Tubular<T>): () => void;

package/dist/react.js

@@ -0,0 +1,79 @@
+import { useCallback, useEffect, useState } from 'react';
+/**
+ * A React hook that binds to a {@link Tubular} instance and a specific key path
+ * within its state.
+ *
+ * Returns a `[value, setter]` tuple that works exactly like React's built-in
+ * `useState`, except reads and writes go through the Tubular store — so every
+ * component (and non-React observer) watching the same path is notified on
+ * every update.
+ *
+ * The setter accepts either a new value directly or an updater function that
+ * receives the current value and returns the next one.
+ *
+ * @example
+ * ```tsx
+ * const store = new Tubular({ user: { name: 'Alice' }, count: 0 });
+ *
+ * function Counter() {
+ *   const [count, setCount] = useTubular(store, 'count');
+ *   return <button onClick={() => setCount(n => (n ?? 0) + 1)}>{count}</button>;
+ * }
+ *
+ * function Greeting() {
+ *   const [name] = useTubular(store, 'user.name');
+ *   return <p>Hello, {name}!</p>;
+ * }
+ * ```
+ */
+export function useTubular(tubular, key) {
+    /** state */
+    const [val, setVal] = useState(() => tubular.read(key));
+    /** callbacks */
+    const handleUpdateVal = useCallback((newValOrCallback) => {
+        if (typeof newValOrCallback === 'function') {
+            tubular.update(key, newValOrCallback);
+        }
+        else {
+            tubular.update(key, () => newValOrCallback);
+        }
+    }, [tubular, key]);
+    /** effects */
+    useEffect(() => {
+        // Sync in case the value changed between render and effect registration
+        setVal(tubular.read(key));
+        const observeCb = (newVal) => {
+            setVal(newVal);
+        };
+        tubular.observe(key, observeCb);
+        return () => {
+            tubular.unobserve(key, observeCb);
+        };
+    }, [tubular, key]);
+    return [val, handleUpdateVal];
+}
+/**
+ * A React hook that returns a stable callback to reset a {@link Tubular} store
+ * back to its initial state.
+ *
+ * Every key in the store is restored to the value originally passed to the
+ * constructor, and every registered observer (including {@link useTubular}
+ * hooks) is notified of each change.
+ *
+ * The returned callback is stable across re-renders.
+ * It never changes its identity, so it is safe to pass as a dependency to `useEffect` or as a prop
+ * to memoized components.
+ *
+ * @example
+ * ```tsx
+ * const store = new Tubular({ name: 'Alice', count: 0 });
+ *
+ * function ResetButton() {
+ *   const handleReset = useTubularReset(store);
+ *   return <button onClick={handleReset}>Reset</button>;
+ * }
+ * ```
+ */
+export function useTubularReset(tubular) {
+    return useCallback(() => tubular.reset(), [tubular]);
+}

package/dist/{esm/totally-tubular.d.ts → totally-tubular.d.ts}

@@ -8,6 +8,7 @@ import type { AllObjectKeys, ObservationCallback, PropType } from './types.js';
 export declare class Tubular<T extends object> {
     private observationCallbacks;
     private state;
+    private initialStateClone;
     constructor(initialState: T);
     private doSomethingToPath;
     private getPortionOfStateByPath;
@@ -19,6 +20,12 @@ export declare class Tubular<T extends object> {
      * reads a portion of your state
      */
     read<K extends string>(readPath: K & AllObjectKeys<T>): PropType<T, K> | null;
+    private resetImpl;
+    /**
+     * resets the state back to its initial value
+     * (the value you provided to the constructor)
+     */
+    reset(): void;
     /**
      * disconnects an observer callback from totally tubular
      */

package/dist/totally-tubular.js

@@ -0,0 +1,101 @@
+import { isArray, isNullOrUndefined, isObject } from './object.js';
+/**
+ * A totally tubular instance that tracks a top-level
+ * set of keys and values.
+ * if you want to support nested or "deep" state updates and observations,
+ * you should construct your state to be a series of Tubular instances
+ */
+export class Tubular {
+    observationCallbacks = new Map();
+    state;
+    initialStateClone;
+    constructor(initialState) {
+        this.state = initialState;
+        this.initialStateClone = globalThis.structuredClone(this.state);
+    }
+    doSomethingToPath(readPath, doSomething) {
+        let thing = this.state;
+        const splitPath = readPath.split('.');
+        const len = splitPath.length;
+        for (let i = 0; i < len; i++) {
+            const p = splitPath[i] || '';
+            if (i === len - 1) {
+                if (thing)
+                    thing[p] = doSomething(thing[p]);
+            }
+            else
+                thing = thing?.[p];
+        }
+    }
+    getPortionOfStateByPath(readPath) {
+        let thing = this.state;
+        const splitPath = readPath.split('.');
+        for (const p of splitPath) {
+            thing = thing?.[p];
+        }
+        return thing ?? null;
+    }
+    /**
+     * observe changes to some part of state that was updated
+     */
+    observe(propPath, observeCallback) {
+        const prevForPath = this.observationCallbacks.get(propPath) ?? [];
+        this.observationCallbacks.set(propPath, [...prevForPath, observeCallback]);
+    }
+    /**
+     * reads a portion of your state
+     */
+    read(readPath) {
+        return this.getPortionOfStateByPath(readPath);
+    }
+    resetImpl(parentKey) {
+        let sourceObj = this.initialStateClone;
+        if (parentKey) {
+            for (const p of parentKey.split('.')) {
+                sourceObj = sourceObj?.[p];
+            }
+            if (isNullOrUndefined(sourceObj) || !isObject(sourceObj))
+                return;
+        }
+        for (const [key, val] of Object.entries(sourceObj)) {
+            const childKey = parentKey ? `${parentKey}.${key}` : key;
+            if (!isNullOrUndefined(val) && isObject(val) && !isArray(val)) {
+                this.resetImpl(childKey);
+            }
+            else {
+                this.update(childKey, () => val);
+            }
+        }
+    }
+    /**
+     * resets the state back to its initial value
+     * (the value you provided to the constructor)
+     */
+    reset() {
+        this.resetImpl();
+    }
+    /**
+     * disconnects an observer callback from totally tubular
+     */
+    unobserve(propPath, observeCallback) {
+        const observers = this.observationCallbacks.get(propPath);
+        if (!observers?.length)
+            return;
+        this.observationCallbacks.set(propPath, observers.filter((ob) => ob !== observeCallback));
+    }
+    /**
+     * updates a portion of your state
+     */
+    update(updatePath, valUpdater) {
+        const prevVal = this.read(updatePath);
+        let newVal = null;
+        this.doSomethingToPath(updatePath, (oldVal) => {
+            const n = valUpdater(oldVal);
+            newVal = n;
+            return n;
+        });
+        for (const cb of this.observationCallbacks.get(updatePath) ?? []) {
+            cb(newVal, prevVal, updatePath);
+        }
+    }
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -3,10 +3,7 @@
   "description": "A completely framework-agnostic, JavaScript / TypeScript state management and update broadcasting library wit zero dependencies, solid performance and a micro file size.",
   "name": "totally-tubular",
   "type": "module",
-  "main": "./dist/cjs/index.cjs",
-  "types": "./dist/cjs/index.d.ts",
-  "typings": "./dist/totally-tubular.d.ts",
-  "version": "0.3.2",
+  "version": "0.4.0",
   "keywords": [
     "state",
     "management",
@@ -30,71 +27,52 @@
     "dist/"
   ],
   "scripts": {
-    "build": "ts-duality --clean",
+    "build": "rm -rf dist/ && tsc --project ./tsconfig.build.json",
     "clean": "rm -rf dist/",
     "test": "bun test",
     "test:watch": "bun test --watch"
   },
   "devDependencies": {
     "@better-builds/lets-version": "^1.6.0",
-    "@better-builds/ts-duality": "^1.3.2",
-    "@biomejs/biome": "^2.4.6",
-    "@commitlint/cli": "^20.4.3",
-    "@commitlint/config-conventional": "^20.4.3",
-    "@happy-dom/global-registrator": "^20.8.3",
+    "@biomejs/biome": "^2.4.16",
+    "@commitlint/cli": "^20.5.3",
+    "@commitlint/config-conventional": "^20.5.3",
+    "@happy-dom/global-registrator": "^20.10.2",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
     "@types/bun": "latest",
-    "@types/react": ">=18",
-    "happy-dom": "^20.8.3",
-    "react": ">=18",
-    "typescript": "^5"
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "happy-dom": "^20.10.2",
+    "react-dom": "^19.2.7",
+    "react": "^19.2.7",
+    "typescript": "^5.9.3"
   },
-  "optionalDependencies": {
+  "peerDependencies": {
     "react": ">=18"
   },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
   "exports": {
     ".": {
-      "require": {
-        "types": "./dist/cjs/index.d.ts",
-        "default": "./dist/cjs/index.cjs"
-      },
-      "import": {
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.mjs"
-      }
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./react": {
-      "require": {
-        "types": "./dist/cjs/react.d.ts",
-        "default": "./dist/cjs/react.cjs"
-      },
-      "import": {
-        "types": "./dist/esm/react.d.ts",
-        "default": "./dist/esm/react.mjs"
-      }
+      "types": "./dist/react.d.ts",
+      "default": "./dist/react.js"
     },
     "./totally-tubular": {
-      "require": {
-        "types": "./dist/cjs/totally-tubular.d.ts",
-        "default": "./dist/cjs/totally-tubular.cjs"
-      },
-      "import": {
-        "types": "./dist/esm/totally-tubular.d.ts",
-        "default": "./dist/esm/totally-tubular.mjs"
-      }
+      "types": "./dist/totally-tubular.d.ts",
+      "default": "./dist/totally-tubular.js"
     },
     "./types": {
-      "require": {
-        "types": "./dist/cjs/types.d.ts",
-        "default": "./dist/cjs/types.cjs"
-      },
-      "import": {
-        "types": "./dist/esm/types.d.ts",
-        "default": "./dist/esm/types.mjs"
-      }
+      "types": "./dist/types.d.ts",
+      "default": "./dist/types.js"
     },
     "./package.json": "./package.json"
-  },
-  "module": "./dist/esm/index.mjs"
+  }
 }

package/dist/cjs/index.cjs

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "Tubular", {
-    enumerable: true,
-    get: function() {
-        return _totallytubular.Tubular;
-    }
-});
-const _totallytubular = require("./totally-tubular.cjs");

package/dist/cjs/package.json

@@ -1 +0,0 @@
-{ "type": "commonjs" }

package/dist/cjs/react.cjs

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "useTubular", {
-    enumerable: true,
-    get: function() {
-        return useTubular;
-    }
-});
-const _react = require("./react.cjs");
-function useTubular(tubular, key) {
-    /** state */ const [val, setVal] = (0, _react.useState)(()=>tubular.read(key));
-    /** callbacks */ const handleUpdateVal = (0, _react.useCallback)((newValOrCallback)=>{
-        if (typeof newValOrCallback === 'function') {
-            tubular.update(key, newValOrCallback);
-        } else {
-            tubular.update(key, ()=>newValOrCallback);
-        }
-    }, [
-        tubular,
-        key
-    ]);
-    /** effects */ (0, _react.useEffect)(()=>{
-        // Sync in case the value changed between render and effect registration
-        setVal(tubular.read(key));
-        const observeCb = (newVal)=>{
-            setVal(newVal);
-        };
-        tubular.observe(key, observeCb);
-        return ()=>{
-            tubular.unobserve(key, observeCb);
-        };
-    }, [
-        tubular,
-        key
-    ]);
-    return [
-        val,
-        handleUpdateVal
-    ];
-}

package/dist/cjs/totally-tubular.cjs

@@ -1,80 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "Tubular", {
-    enumerable: true,
-    get: function() {
-        return Tubular;
-    }
-});
-class Tubular {
-    observationCallbacks = new Map();
-    state;
-    constructor(initialState){
-        this.state = initialState;
-    }
-    doSomethingToPath(readPath, doSomething) {
-        let thing = this.state;
-        if (typeof readPath !== 'string') {
-            return this.getPortionOfStateByPath(thing[readPath]);
-        }
-        const splitPath = readPath.split('.');
-        const len = splitPath.length;
-        for(let i = 0; i < len; i++){
-            const p = splitPath[i] || '';
-            if (i === len - 1) {
-                if (thing) thing[p] = doSomething(thing[p]);
-            } else thing = thing?.[p];
-        }
-        for (const p of splitPath){
-            thing = thing?.[p];
-        }
-    }
-    getPortionOfStateByPath(readPath) {
-        let thing = this.state;
-        if (typeof readPath !== 'string') {
-            return this.getPortionOfStateByPath(thing[readPath]);
-        }
-        const splitPath = readPath.split('.');
-        for (const p of splitPath){
-            thing = thing?.[p];
-        }
-        return thing ?? null;
-    }
-    /**
-   * observe changes to some part of state that was updated
-   */ observe(propPath, observeCallback) {
-        const prevForPath = this.observationCallbacks.get(propPath) ?? [];
-        this.observationCallbacks.set(propPath, [
-            ...prevForPath,
-            observeCallback
-        ]);
-    }
-    /**
-   * reads a portion of your state
-   */ read(readPath) {
-        return this.getPortionOfStateByPath(readPath);
-    }
-    /**
-   * disconnects an observer callback from totally tubular
-   */ unobserve(propPath, observeCallback) {
-        const observers = this.observationCallbacks.get(propPath);
-        if (!observers?.length) return;
-        this.observationCallbacks.set(propPath, observers.filter((ob)=>ob !== observeCallback));
-    }
-    /**
-   * updates a portion of your state
-   */ update(updatePath, valUpdater) {
-        const prevVal = this.read(updatePath);
-        let newVal = null;
-        this.doSomethingToPath(updatePath, (oldVal)=>{
-            const n = valUpdater(oldVal);
-            newVal = n;
-            return n;
-        });
-        for (const cb of this.observationCallbacks.get(updatePath) ?? []){
-            cb(newVal, prevVal, updatePath);
-        }
-    }
-}

package/dist/cjs/totally-tubular.d.ts

@@ -1,30 +0,0 @@
-import type { AllObjectKeys, ObservationCallback, PropType } from './types.js';
-/**
- * A totally tubular instance that tracks a top-level
- * set of keys and values.
- * if you want to support nested or "deep" state updates and observations,
- * you should construct your state to be a series of Tubular instances
- */
-export declare class Tubular<T extends object> {
-    private observationCallbacks;
-    private state;
-    constructor(initialState: T);
-    private doSomethingToPath;
-    private getPortionOfStateByPath;
-    /**
-     * observe changes to some part of state that was updated
-     */
-    observe<K extends string>(propPath: K & AllObjectKeys<T>, observeCallback: ObservationCallback<T>): void;
-    /**
-     * reads a portion of your state
-     */
-    read<K extends string>(readPath: K & AllObjectKeys<T>): PropType<T, K> | null;
-    /**
-     * disconnects an observer callback from totally tubular
-     */
-    unobserve<K extends string>(propPath: K & AllObjectKeys<T>, observeCallback: ObservationCallback<T>): void;
-    /**
-     * updates a portion of your state
-     */
-    update<K extends string>(updatePath: K & AllObjectKeys<T>, valUpdater: (oldVal: PropType<T, K>) => PropType<T, K>): void;
-}

package/dist/cjs/types.cjs

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/dist/esm/index.mjs

@@ -1 +0,0 @@
-export { Tubular } from './totally-tubular.mjs';

package/dist/esm/package.json

@@ -1 +0,0 @@
-{ "type": "module" }

package/dist/esm/react.d.ts

@@ -1,30 +0,0 @@
-import type { Tubular } from './totally-tubular.js';
-import type { AllObjectKeys, PropType } from './types.js';
-/**
- * A React hook that binds to a {@link Tubular} instance and a specific key path
- * within its state.
- *
- * Returns a `[value, setter]` tuple that works exactly like React's built-in
- * `useState`, except reads and writes go through the Tubular store — so every
- * component (and non-React observer) watching the same path is notified on
- * every update.
- *
- * The setter accepts either a new value directly or an updater function that
- * receives the current value and returns the next one.
- *
- * @example
- * ```tsx
- * const store = new Tubular({ user: { name: 'Alice' }, count: 0 });
- *
- * function Counter() {
- *   const [count, setCount] = useTubular(store, 'count');
- *   return <button onClick={() => setCount(n => (n ?? 0) + 1)}>{count}</button>;
- * }
- *
- * function Greeting() {
- *   const [name] = useTubular(store, 'user.name');
- *   return <p>Hello, {name}!</p>;
- * }
- * ```
- */
-export declare function useTubular<T extends object, K extends string>(tubular: Tubular<T>, key: K & AllObjectKeys<T>): readonly [PropType<T, K> | null, (newValOrCallback: PropType<T, K> | ((prevVal: PropType<T, K> | null) => PropType<T, K>)) => void];

package/dist/esm/react.mjs

@@ -1,58 +0,0 @@
-import { useCallback, useEffect, useState } from './react.mjs';
-/**
- * A React hook that binds to a {@link Tubular} instance and a specific key path
- * within its state.
- *
- * Returns a `[value, setter]` tuple that works exactly like React's built-in
- * `useState`, except reads and writes go through the Tubular store — so every
- * component (and non-React observer) watching the same path is notified on
- * every update.
- *
- * The setter accepts either a new value directly or an updater function that
- * receives the current value and returns the next one.
- *
- * @example
- * ```tsx
- * const store = new Tubular({ user: { name: 'Alice' }, count: 0 });
- *
- * function Counter() {
- *   const [count, setCount] = useTubular(store, 'count');
- *   return <button onClick={() => setCount(n => (n ?? 0) + 1)}>{count}</button>;
- * }
- *
- * function Greeting() {
- *   const [name] = useTubular(store, 'user.name');
- *   return <p>Hello, {name}!</p>;
- * }
- * ```
- */ export function useTubular(tubular, key) {
-    /** state */ const [val, setVal] = useState(()=>tubular.read(key));
-    /** callbacks */ const handleUpdateVal = useCallback((newValOrCallback)=>{
-        if (typeof newValOrCallback === 'function') {
-            tubular.update(key, newValOrCallback);
-        } else {
-            tubular.update(key, ()=>newValOrCallback);
-        }
-    }, [
-        tubular,
-        key
-    ]);
-    /** effects */ useEffect(()=>{
-        // Sync in case the value changed between render and effect registration
-        setVal(tubular.read(key));
-        const observeCb = (newVal)=>{
-            setVal(newVal);
-        };
-        tubular.observe(key, observeCb);
-        return ()=>{
-            tubular.unobserve(key, observeCb);
-        };
-    }, [
-        tubular,
-        key
-    ]);
-    return [
-        val,
-        handleUpdateVal
-    ];
-}

package/dist/esm/totally-tubular.mjs

@@ -1,75 +0,0 @@
-/**
- * A totally tubular instance that tracks a top-level
- * set of keys and values.
- * if you want to support nested or "deep" state updates and observations,
- * you should construct your state to be a series of Tubular instances
- */ export class Tubular {
-    observationCallbacks = new Map();
-    state;
-    constructor(initialState){
-        this.state = initialState;
-    }
-    doSomethingToPath(readPath, doSomething) {
-        let thing = this.state;
-        if (typeof readPath !== 'string') {
-            return this.getPortionOfStateByPath(thing[readPath]);
-        }
-        const splitPath = readPath.split('.');
-        const len = splitPath.length;
-        for(let i = 0; i < len; i++){
-            const p = splitPath[i] || '';
-            if (i === len - 1) {
-                if (thing) thing[p] = doSomething(thing[p]);
-            } else thing = thing?.[p];
-        }
-        for (const p of splitPath){
-            thing = thing?.[p];
-        }
-    }
-    getPortionOfStateByPath(readPath) {
-        let thing = this.state;
-        if (typeof readPath !== 'string') {
-            return this.getPortionOfStateByPath(thing[readPath]);
-        }
-        const splitPath = readPath.split('.');
-        for (const p of splitPath){
-            thing = thing?.[p];
-        }
-        return thing ?? null;
-    }
-    /**
-   * observe changes to some part of state that was updated
-   */ observe(propPath, observeCallback) {
-        const prevForPath = this.observationCallbacks.get(propPath) ?? [];
-        this.observationCallbacks.set(propPath, [
-            ...prevForPath,
-            observeCallback
-        ]);
-    }
-    /**
-   * reads a portion of your state
-   */ read(readPath) {
-        return this.getPortionOfStateByPath(readPath);
-    }
-    /**
-   * disconnects an observer callback from totally tubular
-   */ unobserve(propPath, observeCallback) {
-        const observers = this.observationCallbacks.get(propPath);
-        if (!observers?.length) return;
-        this.observationCallbacks.set(propPath, observers.filter((ob)=>ob !== observeCallback));
-    }
-    /**
-   * updates a portion of your state
-   */ update(updatePath, valUpdater) {
-        const prevVal = this.read(updatePath);
-        let newVal = null;
-        this.doSomethingToPath(updatePath, (oldVal)=>{
-            const n = valUpdater(oldVal);
-            newVal = n;
-            return n;
-        });
-        for (const cb of this.observationCallbacks.get(updatePath) ?? []){
-            cb(newVal, prevVal, updatePath);
-        }
-    }
-}

package/dist/esm/types.d.ts

@@ -1,53 +0,0 @@
-export type TSPrimitve = string | number | bigint | boolean | symbol | undefined | null;
-/**
- * Single-check collection guard.
- * `readonly any[]` covers both `any[]` and `ReadonlyArray<any>` since `Array<T>`
- * extends `ReadonlyArray<T>`. One distributive check instead of four sequential ones.
- */
-type IsCollection<T> = T extends readonly any[] | Map<any, any> | Set<any> ? true : false;
-/**
- * Produces every dot-separated key path into T as a string union.
- *
- * - The `Depth` tuple acts as a recursion counter: when its length reaches 5 the
- *   type resolves to `never`, which caps the union size and prevents the language
- *   server from hanging on deeply-nested or self-referential shapes.
- * - Top-level keys are included as bare strings (`K`), so this type supersedes
- *   `keyof T & string` — there is no need for a separate union with `keyof T`.
- * - Collections (arrays, Map, Set) are terminated at their key rather than
- *   recursed into.
- * - Returning `never` (not `''`) from every terminal branch avoids the need for
- *   a secondary `Extract<D, string>` pass over the full union.
- */
-export type DotNestedKeys<T, Depth extends 1[] = []> = Depth['length'] extends 5 ? never : T extends object ? IsCollection<T> extends true ? never : {
-    [K in keyof T & string]: IsCollection<T[K]> extends true ? K : T[K] extends object ? K | `${K}.${DotNestedKeys<T[K], [...Depth, 1]>}` : K;
-}[keyof T & string] : never;
-/**
- * All valid key paths into T (top-level and dot-nested).
- *
- * `DotNestedKeys<T>` already emits top-level string keys alongside nested paths,
- * so a `keyof T` union is redundant and was previously responsible for duplicate
- * entries that the checker had to deduplicate on every instantiation.
- */
-export type AllObjectKeys<T> = DotNestedKeys<T>;
-/**
- * Resolves the value type at a dot-separated path P within T.
- *
- * The intermediate `Rest extends AllObjectKeys<T[Head]>` guard that previously
- * existed here forced a full re-evaluation of `AllObjectKeys` at every recursive
- * level. It has been removed: if `Rest` is not a valid path the recursion
- * naturally returns `never`, which is the correct result.
- */
-export type PropType<T, P extends string> = P extends keyof T ? T[P] : P extends `${infer Head}.${infer Rest}` ? Head extends keyof T ? PropType<T[Head], Rest> : never : never;
-/**
- * Callback invoked by Tubular whenever an observed path changes.
- *
- * The previous definition used defaulted type parameters
- * (`K = AllObjectKeys<T>`, `V = PropType<T, K & string>`). Default type
- * parameters are eagerly evaluated by the checker at *every* reference to
- * `ObservationCallback<T>`, causing a full `AllObjectKeys<T>` + distributed
- * `PropType` expansion each time. Using `unknown` for the value parameters
- * defers any narrowing to call sites that actually need it, which is a far
- * smaller surface area.
- */
-export type ObservationCallback<T> = (newVal: unknown, oldVal: unknown, propPath: AllObjectKeys<T>) => void;
-export {};

package/dist/esm/types.mjs

@@ -1,11 +0,0 @@
-/**
- * Callback invoked by Tubular whenever an observed path changes.
- *
- * The previous definition used defaulted type parameters
- * (`K = AllObjectKeys<T>`, `V = PropType<T, K & string>`). Default type
- * parameters are eagerly evaluated by the checker at *every* reference to
- * `ObservationCallback<T>`, causing a full `AllObjectKeys<T>` + distributed
- * `PropType` expansion each time. Using `unknown` for the value parameters
- * defers any narrowing to call sites that actually need it, which is a far
- * smaller surface area.
- */ export { };