totally-tubular 0.3.1 → 0.3.3

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/{esm/react.mjs → react.js}

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useState } from './react.mjs';
+import { useCallback, useEffect, useState } from 'react';
 /**
  * A React hook that binds to a {@link Tubular} instance and a specific key path
  * within its state.
@@ -25,34 +25,30 @@ import { useCallback, useEffect, useState } from './react.mjs';
  *   return <p>Hello, {name}!</p>;
  * }
  * ```
- */ export function useTubular(tubular, key) {
-    /** state */ const [val, setVal] = useState(()=>tubular.read(key));
-    /** callbacks */ const handleUpdateVal = useCallback((newValOrCallback)=>{
+ */
+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(()=>{
+        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)=>{
+        const observeCb = (newVal) => {
             setVal(newVal);
         };
         tubular.observe(key, observeCb);
-        return ()=>{
+        return () => {
             tubular.unobserve(key, observeCb);
         };
-    }, [
-        tubular,
-        key
-    ]);
-    return [
-        val,
-        handleUpdateVal
-    ];
+    }, [tubular, key]);
+    return [val, handleUpdateVal];
 }

package/dist/{esm/totally-tubular.mjs → totally-tubular.js}

@@ -3,10 +3,11 @@
  * 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 {
+ */
+export class Tubular {
     observationCallbacks = new Map();
     state;
-    constructor(initialState){
+    constructor(initialState) {
         this.state = initialState;
     }
     doSomethingToPath(readPath, doSomething) {
@@ -16,13 +17,16 @@
         }
         const splitPath = readPath.split('.');
         const len = splitPath.length;
-        for(let i = 0; i < len; i++){
+        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];
+                if (thing)
+                    thing[p] = doSomething(thing[p]);
+            }
+            else
+                thing = thing?.[p];
         }
-        for (const p of splitPath){
+        for (const p of splitPath) {
             thing = thing?.[p];
         }
     }
@@ -32,43 +36,45 @@
             return this.getPortionOfStateByPath(thing[readPath]);
         }
         const splitPath = readPath.split('.');
-        for (const p of splitPath){
+        for (const p of splitPath) {
             thing = thing?.[p];
         }
         return thing ?? null;
     }
     /**
-   * observe changes to some part of state that was updated
-   */ observe(propPath, observeCallback) {
+     * 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
-        ]);
+        this.observationCallbacks.set(propPath, [...prevForPath, observeCallback]);
     }
     /**
-   * reads a portion of your state
-   */ read(readPath) {
+     * reads a portion of your state
+     */
+    read(readPath) {
         return this.getPortionOfStateByPath(readPath);
     }
     /**
-   * disconnects an observer callback from totally tubular
-   */ unobserve(propPath, observeCallback) {
+     * 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));
+        if (!observers?.length)
+            return;
+        this.observationCallbacks.set(propPath, observers.filter((ob) => ob !== observeCallback));
     }
     /**
-   * updates a portion of your state
-   */ update(updatePath, valUpdater) {
+     * updates a portion of your state
+     */
+    update(updatePath, valUpdater) {
         const prevVal = this.read(updatePath);
         let newVal = null;
-        this.doSomethingToPath(updatePath, (oldVal)=>{
+        this.doSomethingToPath(updatePath, (oldVal) => {
             const n = valUpdater(oldVal);
             newVal = n;
             return n;
         });
-        for (const cb of this.observationCallbacks.get(updatePath) ?? []){
+        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/totally-tubular.js",
-  "types": "./dist/totally-tubular.d.ts",
-  "typings": "./dist/totally-tubular.d.ts",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "keywords": [
     "state",
     "management",
@@ -30,59 +27,49 @@
     "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.11",
+    "@commitlint/cli": "^20.5.0",
+    "@commitlint/config-conventional": "^20.5.0",
+    "@happy-dom/global-registrator": "^20.9.0",
     "@testing-library/react": "^16.3.2",
     "@testing-library/user-event": "^14.6.1",
     "@types/bun": "latest",
-    "@types/react": ">=18",
-    "happy-dom": "^20.8.3",
+    "@types/react": "^19.2.14",
+    "happy-dom": "^20.9.0",
     "react": ">=18",
-    "typescript": "^5"
+    "typescript": "^5.9.3"
   },
-  "optionalDependencies": {
+  "peerDependencies": {
     "react": ">=18"
   },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
   "exports": {
+    ".": {
+      "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"
   }

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/types.cjs

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

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/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/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 { };