stunk 1.4.5 → 1.4.6

package/dist/core/asyncChunk.d.ts

@@ -0,0 +1,22 @@
+import { Chunk } from "./core";
+import { AsyncChunkOpt } from "./types";
+export interface AsyncState<T> {
+    loading: boolean;
+    error: Error | null;
+    data: T | null;
+}
+export interface AsyncChunk<T> extends Chunk<AsyncState<T>> {
+    /**
+     * Reload the data from the source.
+     */
+    reload: () => Promise<void>;
+    /**
+     * Mutate the data directly.
+     */
+    mutate: (mutator: (currentData: T | null) => T) => void;
+    /**
+     * Reset the state to the initial value.
+     */
+    reset: () => void;
+}
+export declare function asyncChunk<T>(fetcher: () => Promise<T>, options?: AsyncChunkOpt<T>): AsyncChunk<T>;

package/dist/core/computed.d.ts

@@ -0,0 +1,10 @@
+import { Chunk } from "./core";
+export type ChunkValue<T> = T extends Chunk<infer U> ? U : never;
+export type DependencyValues<T extends Chunk<any>[]> = {
+    [K in keyof T]: T[K] extends Chunk<any> ? ChunkValue<T[K]> : never;
+};
+export interface Computed<T> extends Chunk<T> {
+    isDirty: () => boolean;
+    recompute: () => void;
+}
+export declare function computed<TDeps extends Chunk<any>[], TResult>(dependencies: [...TDeps], computeFn: (...args: DependencyValues<TDeps>) => TResult): Computed<TResult>;

package/dist/core/core.d.ts

@@ -0,0 +1,20 @@
+export type Subscriber<T> = (newValue: T) => void;
+export type Middleware<T> = (value: T, next: (newValue: T) => void) => void;
+export interface Chunk<T> {
+    /** Get the current value of the chunk. */
+    get: () => T;
+    /** Set a new value for the chunk. */
+    set: (value: T) => void;
+    /** Update existing value efficiently */
+    update: (updater: (currentValue: T) => T) => void;
+    /** Subscribe to changes in the chunk. Returns an unsubscribe function. */
+    subscribe: (callback: Subscriber<T>) => () => void;
+    /** Create a derived chunk based on this chunk's value. */
+    derive: <D>(fn: (value: T) => D) => Chunk<D>;
+    /** Reset the chunk to its initial value. */
+    reset: () => void;
+    /** Destroy the chunk and all its subscribers. */
+    destroy: () => void;
+}
+export declare function batch(callback: () => void): void;
+export declare function chunk<T>(initialValue: T, middleware?: Middleware<T>[]): Chunk<T>;

package/dist/core/selector.d.ts

@@ -0,0 +1,2 @@
+import { Chunk } from "./core";
+export declare function select<T, S>(sourceChunk: Chunk<T>, selector: (value: T) => S): Chunk<S>;

package/dist/core/types.d.ts

@@ -0,0 +1,16 @@
+import { AsyncChunk } from "./asyncChunk";
+export type AsyncChunkOpt<T> = {
+    initialData?: T | null;
+    onError?: (error: Error) => void;
+    retryCount?: number;
+    retryDelay?: number;
+};
+export type InferAsyncData<T> = T extends AsyncChunk<infer U> ? U : never;
+export type CombinedData<T> = {
+    [K in keyof T]: InferAsyncData<T[K]> | null;
+};
+export type CombinedState<T> = {
+    loading: boolean;
+    error: Error | null;
+    data: CombinedData<T>;
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { chunk, batch } from './core/core';
+export { asyncChunk } from './core/asyncChunk';
+export { computed } from './core/computed';
+export { select } from './core/selector';
+export { combineAsyncChunks, once, isChunk, isValidChunkValue } from './utils';
+export type { Chunk, Middleware } from './core/core';
+export * as middleware from "./middleware";

package/dist/middleware/history.d.ts

@@ -0,0 +1,30 @@
+import { Chunk } from "../core/core";
+export interface ChunkWithHistory<T> extends Chunk<T> {
+    /**
+   * Reverts to the previous state (if available).
+   */
+    undo: () => void;
+    /**
+     * Moves to the next state (if available).
+     */
+    redo: () => void;
+    /**
+     * Returns true if there is a previous state to revert to.
+     */
+    canUndo: () => boolean;
+    /**
+     * Returns true if there is a next state to move to.
+     */
+    canRedo: () => boolean;
+    /**
+     * Returns an array of all the values in the history.
+     */
+    getHistory: () => T[];
+    /**
+     * Clears the history, keeping only the current value.
+     */
+    clearHistory: () => void;
+}
+export declare function withHistory<T>(baseChunk: Chunk<T>, options?: {
+    maxHistory?: number;
+}): ChunkWithHistory<T>;

package/dist/middleware/index.d.ts

@@ -0,0 +1,4 @@
+export { logger } from "./logger";
+export { nonNegativeValidator } from "./validator";
+export { withHistory } from "./history";
+export { withPersistence } from './persistence';

package/dist/middleware/logger.d.ts

@@ -0,0 +1,2 @@
+import { Middleware } from "../core/core";
+export declare const logger: Middleware<any>;

package/dist/middleware/persistence.d.ts

@@ -0,0 +1,8 @@
+import { Chunk } from "../core/core";
+export interface PersistOptions<T> {
+    key: string;
+    storage?: Storage;
+    serialize?: (value: T) => string;
+    deserialize?: (value: string) => T;
+}
+export declare function withPersistence<T>(baseChunk: Chunk<T>, options: PersistOptions<T>): Chunk<T>;

package/dist/middleware/validator.d.ts

@@ -0,0 +1,2 @@
+import { Middleware } from "../core/core";
+export declare const nonNegativeValidator: Middleware<number>;

package/dist/use-react/hooks/useAsyncChunk.d.ts

@@ -0,0 +1,14 @@
+import { AsyncChunk, AsyncState } from "../../core/asyncChunk";
+/**
+ * A hook that handles asynchronous state with built-in reactivity.
+ * Provides loading, error, and data states.
+ */
+export declare function useAsyncChunk<T>(asyncChunk: AsyncChunk<T>): {
+    state: AsyncState<T>;
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+    reload: () => Promise<void>;
+    mutate: (mutator: (currentData: T | null) => T) => void;
+    reset: () => void;
+};

package/dist/use-react/hooks/useChunk.d.ts

@@ -0,0 +1,6 @@
+import type { Chunk } from "../../core/core";
+/**
+ * A lightweight hook that subscribes to a chunk and returns its current value, along with setters, selector, reset and destroy.
+ * Ensures reactivity and prevents unnecessary re-renders.
+ */
+export declare function useChunk<T, S = T>(chunk: Chunk<T>, selector?: (value: T) => S): readonly [S, (value: T) => void, (updater: (currentValue: T) => T) => void, () => void, () => void];

package/dist/use-react/hooks/useChunkProperty.d.ts

@@ -0,0 +1,6 @@
+import type { Chunk } from "../../core/core";
+/**
+ * A hook that subscribes to a specific property of a chunk.
+ * This optimizes renders by only updating when the selected property changes.
+ */
+export declare function useChunkProperty<T, K extends keyof T>(chunk: Chunk<T>, property: K): T[K];

package/dist/use-react/hooks/useChunkValue.d.ts

@@ -0,0 +1,6 @@
+import type { Chunk } from "../../core/core";
+/**
+ * A lightweight hook that subscribes to a chunk and returns only its current value.
+ * Useful for read-only components that don't need to update the chunk.
+ */
+export declare function useChunkValue<T, S = T>(chunk: Chunk<T>, selector?: (value: T) => S): S;

package/dist/use-react/hooks/useChunkValues.d.ts

@@ -0,0 +1,8 @@
+import type { Chunk } from "../../core/core";
+/**
+ * Hook to read values from multiple chunks at once.
+ * Only re-renders when any of the chunk values change.
+ */
+export declare function useChunkValues<T extends Chunk<any>[]>(chunks: [...T]): {
+    [K in keyof T]: T[K] extends Chunk<infer U> ? U : never;
+};

package/dist/use-react/hooks/useComputed.d.ts

@@ -0,0 +1,7 @@
+import { DependencyValues } from "../../core/computed";
+import type { Chunk } from "../../core/core";
+/**
+ * A hook that computes a value based on multiple chunks.
+ * Automatically re-computes when any dependency changes.
+ */
+export declare function useComputed<TDeps extends Chunk<any>[], TResult>(dependencies: [...TDeps], computeFn: (...args: DependencyValues<TDeps>) => TResult): TResult;

package/dist/use-react/hooks/useDerive.d.ts

@@ -0,0 +1,6 @@
+import type { Chunk } from "../../core/core";
+/**
+ * A hook for creating a read-only derived value from a chunk.
+ * Ensures reactivity and updates when the source chunk changes.
+ */
+export declare function useDerive<T, D>(chunk: Chunk<T>, fn: (value: T) => D): D;

package/dist/use-react/index.d.ts

@@ -0,0 +1,7 @@
+export { useChunk } from './hooks/useChunk';
+export { useDerive } from './hooks/useDerive';
+export { useComputed } from './hooks/useComputed';
+export { useChunkValue } from './hooks/useChunkValue';
+export { useChunkProperty } from './hooks/useChunkProperty';
+export { useChunkValues } from './hooks/useChunkValues';
+export { useAsyncChunk } from './hooks/useAsyncChunk';

package/dist/utils.d.ts

@@ -0,0 +1,14 @@
+import { Chunk, Middleware } from "./core/core";
+import { AsyncChunk } from "./core/asyncChunk";
+import { InferAsyncData } from "./core/types";
+export declare function isValidChunkValue(value: any): boolean;
+export declare function isChunk<T>(value: any): value is Chunk<T>;
+export declare function once<T>(fn: () => T): () => T;
+export declare function combineAsyncChunks<T extends Record<string, AsyncChunk<any>>>(chunks: T): Chunk<{
+    loading: boolean;
+    error: Error | null;
+    data: {
+        [K in keyof T]: InferAsyncData<T[K]> | null;
+    };
+}>;
+export declare function processMiddleware<T>(initialValue: T, middleware?: Middleware<T>[]): T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stunk",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "description": "Stunk is a lightweight, framework-agnostic state management library for JavaScript and TypeScript. It uses chunk-based state units for efficient updates, reactivity, and performance optimization in React, Vue, Svelte, and Vanilla JS/TS applications.",
   "repository": {
     "type": "git",
@@ -11,19 +11,19 @@
     "url": "https://github.com/I-am-abdulazeez/stunk/issues"
   },
   "main": "dist/index.js",
-  "types": "dist/types/index.d.ts",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
-      "types": "./dist/types/index.d.ts"
+      "types": "./dist/index.d.ts"
     },
     "./middleware": {
       "import": "./dist/middleware/index.js",
-      "types": "./dist/types/middleware/index.d.ts"
+      "types": "./dist/middleware/index.d.ts"
     },
     "./react": {
       "import": "./dist/use-react/index.js",
-      "types": "./dist/types/use-react/index.d.ts"
+      "types": "./dist/use-react/index.d.ts"
     }
   },
   "scripts": {

package/tsconfig.json

@@ -5,7 +5,7 @@
     "moduleResolution": "Node",
     "outDir": "./dist",
     "declaration": true,
-    "declarationDir": "./dist/types",
+    "declarationDir": "./dist",
     "baseUrl": "./src",
     "paths": {
       "stunk/middleware": ["middleware"],
@@ -18,6 +18,6 @@
     "esModuleInterop": true,
     "allowSyntheticDefaultImports": true
   },
-  "include": ["src/**/*", "types/stunk.d.ts"],
+  "include": ["src/**/*"],
   "exclude": ["node_modules", "dist"]
 }

package/types/stunk.d.ts

@@ -1,15 +0,0 @@
-declare module 'stunk' {
-  export type Subscriber<T> = (newValue: T) => void;
-
-  export interface Chunk<T> {
-    get: () => T;
-    set: (value: T) => void;
-    update: (updater: (currentValue: T) => T) => void;
-    subscribe: (callback: Subscriber<T>) => () => void;
-    derive: <D>(fn: (value: T) => D) => Chunk<D>;
-    reset: () => void;
-    destroy: () => void;
-  }
-
-  export function chunk<T>(initialValue: T): Chunk<T>;
-}