@view-models/core 2.1.0 → 2.2.0

package/README.md

@@ -118,7 +118,7 @@ class TodoViewModel extends ViewModelWithDerivedState<
   toggleTodo(id: string) {
     this.update(({ items }) => ({
       items: items.map((item) =>
-        item.id === id ? { ...item, done: !item.done } : item
+        item.id === id ? { ...item, done: !item.done } : item,
       ),
     }));
   }
@@ -160,107 +160,7 @@ function Counter({ model }) {
 
 ## API Reference
 
-### `ViewModel<T>`
-
-Abstract base class for creating view models.
-
-#### Constructor
-
-```typescript
-constructor(initialState: T)
-```
-
-Initialize the view model with an initial state.
-
-#### Methods
-
-##### `subscribe(listener: ViewModelListener): () => void`
-
-Subscribe to state changes. The listener will be called whenever `update()` is called. Returns a function to unsubscribe.
-
-```typescript
-const unsubscribe = viewModel.subscribe(() => {
-  console.log("State changed:", viewModel.state);
-});
-
-// Later, to unsubscribe:
-unsubscribe();
-```
-
-##### `update(updater: Updater<T>): void` (protected)
-
-Update the state and notify all subscribers. This method is protected and should only be called from within your view model subclass.
-
-```typescript
-protected update(updater: (currentState: T) => T): void
-```
-
-The updater function receives the current state and should return the new state.
-
-##### `state: T` (getter)
-
-Access the current state.
-
-```typescript
-const currentState = viewModel.state;
-```
-
-### `ViewModelWithDerivedState<S, D>`
-
-Abstract base class for creating view models with derived state. Use this when you need computed properties that are automatically recalculated when the internal state changes.
-
-#### Constructor
-
-```typescript
-constructor(initialState: S)
-```
-
-Initialize the view model with an initial internal state. The derived state is automatically computed during construction.
-
-#### Methods
-
-##### `subscribe(listener: ViewModelListener): () => void`
-
-Subscribe to state changes. The listener will be called whenever the derived state changes. Returns a function to unsubscribe.
-
-```typescript
-const unsubscribe = viewModel.subscribe(() => {
-  console.log("State changed:", viewModel.state);
-});
-
-// Later, to unsubscribe:
-unsubscribe();
-```
-
-##### `update(updater: Updater<S>): void` (protected)
-
-Update the internal state, automatically recompute derived state, and notify all subscribers. This method is protected and should only be called from within your view model subclass.
-
-```typescript
-protected update(updater: (currentState: S) => S): void
-```
-
-##### `computeDerivedState(state: S): D` (abstract)
-
-Abstract method that must be implemented to compute the derived state from the internal state. This is called automatically after each update and during initialization.
-
-```typescript
-computeDerivedState({ items }: InternalState): DerivedState {
-  return {
-    items,
-    count: items.length,
-    hasItems: items.length > 0,
-  };
-}
-```
-
-##### `state: D` (getter)
-
-Access the current derived state.
-
-```typescript
-const currentState = viewModel.state;
-```
+For detailed API documentation, see [docs](./docs).
 
 ## Patterns and Best Practices
 

package/dist/index.d.ts

@@ -1,3 +1,192 @@
-export * from "./ViewModel.js";
-export * from "./ViewModelWithDerivedState.js";
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Function that receives the current state and returns the new state.
+ * The updater function should be pure and return a new state object.
+ *
+ * @template T - The state type
+ * @param currentState - The current state
+ * @returns The new state
+ */
+type Updater<T> = (currentState: T) => T;
+/**
+ * Function that gets called when the state changes.
+ *
+ * @template T - The state type
+ */
+type ViewModelListener = () => void;
+/**
+ * Abstract base class for creating reactive view models with derived state.
+ *
+ * This class extends the basic ViewModel pattern by allowing you to compute
+ * derived state from internal state. The internal state is managed privately,
+ * while the derived state (which can include computed properties) is exposed
+ * to subscribers.
+ *
+ * @template S - The internal state type (managed internally)
+ * @template D - The derived state type (exposed to subscribers)
+ *
+ * @example
+ * ```typescript
+ * type TodoState = {
+ *   items: Array<{ id: string; text: string; done: boolean }>;
+ * };
+ *
+ * type TodoDerivedState = TodoState & {
+ *   totalCount: number;
+ *   completedCount: number;
+ *   remainingCount: number;
+ * };
+ *
+ * class TodoViewModel extends ViewModelWithDerivedState<TodoState, TodoDerivedState> {
+ *   constructor() {
+ *     super({ items: [] });
+ *   }
+ *
+ *   computeDerivedState({ items }: TodoState): TodoDerivedState {
+ *     return {
+ *       items,
+ *       totalCount: items.length,
+ *       completedCount: items.filter(item => item.done).length,
+ *       remainingCount: items.filter(item => !item.done).length,
+ *     };
+ *   }
+ *
+ *   addTodo(text: string) {
+ *     this.update(({ items }) => ({
+ *       items: [...items, { id: crypto.randomUUID(), text, done: false }],
+ *     }));
+ *   }
+ * }
+ *
+ * const todos = new TodoViewModel();
+ * todos.subscribe(() => {
+ *   console.log('Completed:', todos.state.completedCount);
+ * });
+ * todos.addTodo('Learn ViewModels'); // Logs: Completed: 0
+ * ```
+ */
+declare abstract class ViewModelWithDerivedState<S, D> {
+    private _listeners;
+    private _internalState;
+    private _state;
+    /**
+     * Subscribe to state changes.
+     *
+     * The listener will be called immediately after any state update.
+     *
+     * @param listener - Function to call when state changes
+     * @returns Function to unsubscribe the listener
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = viewModel.subscribe((state) => {
+     *   console.log('State changed:', state);
+     * });
+     *
+     * // Later, when you want to stop listening:
+     * unsubscribe();
+     * ```
+     */
+    subscribe(listener: ViewModelListener): () => void;
+    /**
+     * Create a new ViewModel with the given initial internal state.
+     *
+     * The constructor initializes the internal state and immediately computes
+     * the derived state by calling `computeDerivedState`.
+     *
+     * @param initialState - The initial internal state of the view model
+     */
+    constructor(initialState: S);
+    /**
+     * Update the internal state, recompute derived state, and notify all subscribers.
+     *
+     * This method is protected and should only be called from within your view model subclass.
+     * The updater function receives the current internal state and should return the new internal state.
+     * After updating, the derived state is automatically recomputed via `computeDerivedState`.
+     * Always return a new state object to ensure immutability.
+     *
+     * @param updater - Function that receives current internal state and returns new internal state
+     *
+     * @example
+     * ```typescript
+     * this.update((currentState) => ({
+     *   ...currentState,
+     *   count: currentState.count + 1
+     * }));
+     * ```
+     */
+    protected update(updater: Updater<S>): void;
+    /**
+     * Compute the derived state from the internal state.
+     *
+     * This abstract method must be implemented by subclasses to transform
+     * the internal state into the derived state that will be exposed to
+     * subscribers. This method is called automatically after each state
+     * update and during initialization.
+     *
+     * @param state - The current internal state
+     * @returns The derived state with any computed properties
+     *
+     * @example
+     * ```typescript
+     * computeDerivedState({ count }: CounterState): CounterDerivedState {
+     *   return {
+     *     count,
+     *     isEven: count % 2 === 0,
+     *     isPositive: count > 0,
+     *   };
+     * }
+     * ```
+     */
+    abstract computeDerivedState(state: S): D;
+    /**
+     * Get the current derived state.
+     *
+     * This returns the derived state computed by `computeDerivedState`,
+     * not the internal state.
+     *
+     * @returns The current derived state
+     */
+    get state(): D;
+}
+
+/**
+ * Abstract base class for creating reactive view models.
+ *
+ * A ViewModel manages state and notifies subscribers when the state changes.
+ * Extend this class to create your own view models with custom business logic.
+ *
+ * @template S - The state type
+ *
+ * @example
+ * ```typescript
+ * type CounterState = { count: number };
+ *
+ * class CounterViewModel extends ViewModel<CounterState> {
+ *   constructor() {
+ *     super({ count: 0 });
+ *   }
+ *
+ *   increment() {
+ *     this.update(({ count }) => ({ count: count + 1 }));
+ *   }
+ * }
+ *
+ * const counter = new CounterViewModel();
+ * const unsubscribe = counter.subscribe((state) => {
+ *   console.log('Count:', state.count);
+ * });
+ * counter.increment(); // Logs: Count: 1
+ * ```
+ */
+declare abstract class ViewModel<S> extends ViewModelWithDerivedState<S, S> {
+    /**
+     * Create a new ViewModel with the given initial state.
+     *
+     * @param initialState - The initial state of the view model
+     */
+    constructor(initialState: S);
+    computeDerivedState(state: S): S;
+}
+
+export { ViewModel, ViewModelWithDerivedState };
+export type { Updater, ViewModelListener };

package/dist/index.js

@@ -1,2 +1,2 @@
-export * from "./ViewModel.js";
-export * from "./ViewModelWithDerivedState.js";
+class t{subscribe(t){return this.t.add(t),()=>{this.t.delete(t)}}constructor(t){this.t=new Set,this.i=t,this.h=this.computeDerivedState(this.i)}update(t){this.i=t(this.i),this.h=this.computeDerivedState(this.i);for(const t of this.t)t()}get state(){return this.h}}class s extends t{constructor(t){super(t)}computeDerivedState(t){return t}}export{s as ViewModel,t as ViewModelWithDerivedState};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/ViewModelWithDerivedState.ts","../src/ViewModel.ts"],"sourcesContent":["/**\n * Function that receives the current state and returns the new state.\n * The updater function should be pure and return a new state object.\n *\n * @template T - The state type\n * @param currentState - The current state\n * @returns The new state\n */\nexport type Updater<T> = (currentState: T) => T;\n\n/**\n * Function that gets called when the state changes.\n *\n * @template T - The state type\n */\nexport type ViewModelListener = () => void;\n\n/**\n * Abstract base class for creating reactive view models with derived state.\n *\n * This class extends the basic ViewModel pattern by allowing you to compute\n * derived state from internal state. The internal state is managed privately,\n * while the derived state (which can include computed properties) is exposed\n * to subscribers.\n *\n * @template S - The internal state type (managed internally)\n * @template D - The derived state type (exposed to subscribers)\n *\n * @example\n * ```typescript\n * type TodoState = {\n *   items: Array<{ id: string; text: string; done: boolean }>;\n * };\n *\n * type TodoDerivedState = TodoState & {\n *   totalCount: number;\n *   completedCount: number;\n *   remainingCount: number;\n * };\n *\n * class TodoViewModel extends ViewModelWithDerivedState<TodoState, TodoDerivedState> {\n *   constructor() {\n *     super({ items: [] });\n *   }\n *\n *   computeDerivedState({ items }: TodoState): TodoDerivedState {\n *     return {\n *       items,\n *       totalCount: items.length,\n *       completedCount: items.filter(item => item.done).length,\n *       remainingCount: items.filter(item => !item.done).length,\n *     };\n *   }\n *\n *   addTodo(text: string) {\n *     this.update(({ items }) => ({\n *       items: [...items, { id: crypto.randomUUID(), text, done: false }],\n *     }));\n *   }\n * }\n *\n * const todos = new TodoViewModel();\n * todos.subscribe(() => {\n *   console.log('Completed:', todos.state.completedCount);\n * });\n * todos.addTodo('Learn ViewModels'); // Logs: Completed: 0\n * ```\n */\nexport abstract class ViewModelWithDerivedState<S, D> {\n  private _listeners: Set<ViewModelListener> = new Set();\n  private _internalState: S;\n  private _state: D;\n\n  /**\n   * Subscribe to state changes.\n   *\n   * The listener will be called immediately after any state update.\n   *\n   * @param listener - Function to call when state changes\n   * @returns Function to unsubscribe the listener\n   *\n   * @example\n   * ```typescript\n   * const unsubscribe = viewModel.subscribe((state) => {\n   *   console.log('State changed:', state);\n   * });\n   *\n   * // Later, when you want to stop listening:\n   * unsubscribe();\n   * ```\n   */\n  subscribe(listener: ViewModelListener): () => void {\n    this._listeners.add(listener);\n    return () => {\n      this._listeners.delete(listener);\n    };\n  }\n\n  /**\n   * Create a new ViewModel with the given initial internal state.\n   *\n   * The constructor initializes the internal state and immediately computes\n   * the derived state by calling `computeDerivedState`.\n   *\n   * @param initialState - The initial internal state of the view model\n   */\n  constructor(initialState: S) {\n    this._internalState = initialState;\n    this._state = this.computeDerivedState(this._internalState);\n  }\n\n  /**\n   * Update the internal state, recompute derived state, and notify all subscribers.\n   *\n   * This method is protected and should only be called from within your view model subclass.\n   * The updater function receives the current internal state and should return the new internal state.\n   * After updating, the derived state is automatically recomputed via `computeDerivedState`.\n   * Always return a new state object to ensure immutability.\n   *\n   * @param updater - Function that receives current internal state and returns new internal state\n   *\n   * @example\n   * ```typescript\n   * this.update((currentState) => ({\n   *   ...currentState,\n   *   count: currentState.count + 1\n   * }));\n   * ```\n   */\n  protected update(updater: Updater<S>) {\n    this._internalState = updater(this._internalState);\n    this._state = this.computeDerivedState(this._internalState);\n\n    for (const listener of this._listeners) {\n      listener();\n    }\n  }\n\n  /**\n   * Compute the derived state from the internal state.\n   *\n   * This abstract method must be implemented by subclasses to transform\n   * the internal state into the derived state that will be exposed to\n   * subscribers. This method is called automatically after each state\n   * update and during initialization.\n   *\n   * @param state - The current internal state\n   * @returns The derived state with any computed properties\n   *\n   * @example\n   * ```typescript\n   * computeDerivedState({ count }: CounterState): CounterDerivedState {\n   *   return {\n   *     count,\n   *     isEven: count % 2 === 0,\n   *     isPositive: count > 0,\n   *   };\n   * }\n   * ```\n   */\n  abstract computeDerivedState(state: S): D;\n\n  /**\n   * Get the current derived state.\n   *\n   * This returns the derived state computed by `computeDerivedState`,\n   * not the internal state.\n   *\n   * @returns The current derived state\n   */\n  get state(): D {\n    return this._state;\n  }\n}\n","import { ViewModelWithDerivedState } from \"./ViewModelWithDerivedState.js\";\n\n/**\n * Abstract base class for creating reactive view models.\n *\n * A ViewModel manages state and notifies subscribers when the state changes.\n * Extend this class to create your own view models with custom business logic.\n *\n * @template S - The state type\n *\n * @example\n * ```typescript\n * type CounterState = { count: number };\n *\n * class CounterViewModel extends ViewModel<CounterState> {\n *   constructor() {\n *     super({ count: 0 });\n *   }\n *\n *   increment() {\n *     this.update(({ count }) => ({ count: count + 1 }));\n *   }\n * }\n *\n * const counter = new CounterViewModel();\n * const unsubscribe = counter.subscribe((state) => {\n *   console.log('Count:', state.count);\n * });\n * counter.increment(); // Logs: Count: 1\n * ```\n */\nexport abstract class ViewModel<S> extends ViewModelWithDerivedState<S, S> {\n  /**\n   * Create a new ViewModel with the given initial state.\n   *\n   * @param initialState - The initial state of the view model\n   */\n  constructor(initialState: S) {\n    super(initialState);\n  }\n\n  computeDerivedState(state: S): S {\n    return state;\n  }\n}\n"],"names":["ViewModelWithDerivedState","subscribe","listener","this","_listeners","add","delete","constructor","initialState","Set","_internalState","_state","computeDerivedState","update","updater","state","ViewModel","super"],"mappings":"MAoEsBA,EAuBpB,SAAAC,CAAUC,GAER,OADAC,KAAKC,EAAWC,IAAIH,GACb,KACLC,KAAKC,EAAWE,OAAOJ,GAE3B,CAUA,WAAAK,CAAYC,GArCJL,KAAAC,EAAqC,IAAIK,IAsC/CN,KAAKO,EAAiBF,EACtBL,KAAKQ,EAASR,KAAKS,oBAAoBT,KAAKO,EAC9C,CAoBU,MAAAG,CAAOC,GACfX,KAAKO,EAAiBI,EAAQX,KAAKO,GACnCP,KAAKQ,EAASR,KAAKS,oBAAoBT,KAAKO,GAE5C,IAAK,MAAMR,KAAYC,KAAKC,EAC1BF,GAEJ,CAkCA,SAAIa,GACF,OAAOZ,KAAKQ,CACd,EC7II,MAAgBK,UAAqBhB,EAMzC,WAAAO,CAAYC,GACVS,MAAMT,EACR,CAEA,mBAAAI,CAAoBG,GAClB,OAAOA,CACT"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@view-models/core",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "A lightweight, framework-agnostic library for building reactive view models with TypeScript",
   "keywords": [
     "view",
@@ -36,18 +36,27 @@
     "node": ">=18.0.0"
   },
   "scripts": {
-    "build": "tsc",
+    "clean": "rm -rf dist",
+    "build": "npm run clean && rollup -c",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "format": "prettier --write \"**/*.{ts,js,json,md}\"",
     "format:check": "prettier --check \"**/*.{ts,js,json,md}\"",
+    "docs": "typedoc && npm run format",
     "prepublishOnly": "npm run build"
   },
   "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
+    "@rollup/plugin-typescript": "^12.3.0",
     "@vitest/coverage-v8": "^4.0.16",
     "prettier": "^3.7.4",
+    "rollup": "^4.57.0",
+    "rollup-plugin-dts": "^6.3.0",
+    "tslib": "^2.8.1",
+    "typedoc": "^0.28.16",
+    "typedoc-plugin-markdown": "^4.9.0",
     "typescript": "^5.7.3",
     "vitest": "^4.0.16"
   },

package/src/ViewModel.ts

@@ -1,4 +1,4 @@
-import { ViewModelWithDerivedState } from "./ViewModelWithDerivedState";
+import { ViewModelWithDerivedState } from "./ViewModelWithDerivedState.js";
 
 /**
  * Abstract base class for creating reactive view models.

package/src/ViewModelWithDerivedState.ts

@@ -12,7 +12,6 @@ export type Updater<T> = (currentState: T) => T;
  * Function that gets called when the state changes.
  *
  * @template T - The state type
- * @param state - The new state
  */
 export type ViewModelListener = () => void;
 
@@ -29,22 +28,22 @@ export type ViewModelListener = () => void;
  *
  * @example
  * ```typescript
- * type TodoInternalState = {
+ * type TodoState = {
  *   items: Array<{ id: string; text: string; done: boolean }>;
  * };
  *
- * type TodoDerivedState = TodoInternalState & {
+ * type TodoDerivedState = TodoState & {
  *   totalCount: number;
  *   completedCount: number;
  *   remainingCount: number;
  * };
  *
- * class TodoViewModel extends ViewModelWithDerivedState<TodoInternalState, TodoDerivedState> {
+ * class TodoViewModel extends ViewModelWithDerivedState<TodoState, TodoDerivedState> {
  *   constructor() {
  *     super({ items: [] });
  *   }
  *
- *   computeDerivedState({ items }: TodoInternalState): TodoDerivedState {
+ *   computeDerivedState({ items }: TodoState): TodoDerivedState {
  *     return {
  *       items,
  *       totalCount: items.length,

package/dist/ViewModel.d.ts

@@ -1,40 +0,0 @@
-import { ViewModelWithDerivedState } from "./ViewModelWithDerivedState";
-/**
- * Abstract base class for creating reactive view models.
- *
- * A ViewModel manages state and notifies subscribers when the state changes.
- * Extend this class to create your own view models with custom business logic.
- *
- * @template S - The state type
- *
- * @example
- * ```typescript
- * type CounterState = { count: number };
- *
- * class CounterViewModel extends ViewModel<CounterState> {
- *   constructor() {
- *     super({ count: 0 });
- *   }
- *
- *   increment() {
- *     this.update(({ count }) => ({ count: count + 1 }));
- *   }
- * }
- *
- * const counter = new CounterViewModel();
- * const unsubscribe = counter.subscribe((state) => {
- *   console.log('Count:', state.count);
- * });
- * counter.increment(); // Logs: Count: 1
- * ```
- */
-export declare abstract class ViewModel<S> extends ViewModelWithDerivedState<S, S> {
-    /**
-     * Create a new ViewModel with the given initial state.
-     *
-     * @param initialState - The initial state of the view model
-     */
-    constructor(initialState: S);
-    computeDerivedState(state: S): S;
-}
-//# sourceMappingURL=ViewModel.d.ts.map

package/dist/ViewModel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ViewModel.d.ts","sourceRoot":"","sources":["../src/ViewModel.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AAExE;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,8BAAsB,SAAS,CAAC,CAAC,CAAE,SAAQ,yBAAyB,CAAC,CAAC,EAAE,CAAC,CAAC;IACxE;;;;OAIG;gBACS,YAAY,EAAE,CAAC;IAI3B,mBAAmB,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC;CAGjC"}

package/dist/ViewModel.js

@@ -1,43 +0,0 @@
-import { ViewModelWithDerivedState } from "./ViewModelWithDerivedState";
-/**
- * Abstract base class for creating reactive view models.
- *
- * A ViewModel manages state and notifies subscribers when the state changes.
- * Extend this class to create your own view models with custom business logic.
- *
- * @template S - The state type
- *
- * @example
- * ```typescript
- * type CounterState = { count: number };
- *
- * class CounterViewModel extends ViewModel<CounterState> {
- *   constructor() {
- *     super({ count: 0 });
- *   }
- *
- *   increment() {
- *     this.update(({ count }) => ({ count: count + 1 }));
- *   }
- * }
- *
- * const counter = new CounterViewModel();
- * const unsubscribe = counter.subscribe((state) => {
- *   console.log('Count:', state.count);
- * });
- * counter.increment(); // Logs: Count: 1
- * ```
- */
-export class ViewModel extends ViewModelWithDerivedState {
-    /**
-     * Create a new ViewModel with the given initial state.
-     *
-     * @param initialState - The initial state of the view model
-     */
-    constructor(initialState) {
-        super(initialState);
-    }
-    computeDerivedState(state) {
-        return state;
-    }
-}

package/dist/ViewModelWithDerivedState.d.ts

@@ -1,152 +0,0 @@
-/**
- * Function that receives the current state and returns the new state.
- * The updater function should be pure and return a new state object.
- *
- * @template T - The state type
- * @param currentState - The current state
- * @returns The new state
- */
-export type Updater<T> = (currentState: T) => T;
-/**
- * Function that gets called when the state changes.
- *
- * @template T - The state type
- * @param state - The new state
- */
-export type ViewModelListener = () => void;
-/**
- * Abstract base class for creating reactive view models with derived state.
- *
- * This class extends the basic ViewModel pattern by allowing you to compute
- * derived state from internal state. The internal state is managed privately,
- * while the derived state (which can include computed properties) is exposed
- * to subscribers.
- *
- * @template S - The internal state type (managed internally)
- * @template D - The derived state type (exposed to subscribers)
- *
- * @example
- * ```typescript
- * type TodoInternalState = {
- *   items: Array<{ id: string; text: string; done: boolean }>;
- * };
- *
- * type TodoDerivedState = TodoInternalState & {
- *   totalCount: number;
- *   completedCount: number;
- *   remainingCount: number;
- * };
- *
- * class TodoViewModel extends ViewModelWithDerivedState<TodoInternalState, TodoDerivedState> {
- *   constructor() {
- *     super({ items: [] });
- *   }
- *
- *   computeDerivedState({ items }: TodoInternalState): TodoDerivedState {
- *     return {
- *       items,
- *       totalCount: items.length,
- *       completedCount: items.filter(item => item.done).length,
- *       remainingCount: items.filter(item => !item.done).length,
- *     };
- *   }
- *
- *   addTodo(text: string) {
- *     this.update(({ items }) => ({
- *       items: [...items, { id: crypto.randomUUID(), text, done: false }],
- *     }));
- *   }
- * }
- *
- * const todos = new TodoViewModel();
- * todos.subscribe(() => {
- *   console.log('Completed:', todos.state.completedCount);
- * });
- * todos.addTodo('Learn ViewModels'); // Logs: Completed: 0
- * ```
- */
-export declare abstract class ViewModelWithDerivedState<S, D> {
-    private _listeners;
-    private _internalState;
-    private _state;
-    /**
-     * Subscribe to state changes.
-     *
-     * The listener will be called immediately after any state update.
-     *
-     * @param listener - Function to call when state changes
-     * @returns Function to unsubscribe the listener
-     *
-     * @example
-     * ```typescript
-     * const unsubscribe = viewModel.subscribe((state) => {
-     *   console.log('State changed:', state);
-     * });
-     *
-     * // Later, when you want to stop listening:
-     * unsubscribe();
-     * ```
-     */
-    subscribe(listener: ViewModelListener): () => void;
-    /**
-     * Create a new ViewModel with the given initial internal state.
-     *
-     * The constructor initializes the internal state and immediately computes
-     * the derived state by calling `computeDerivedState`.
-     *
-     * @param initialState - The initial internal state of the view model
-     */
-    constructor(initialState: S);
-    /**
-     * Update the internal state, recompute derived state, and notify all subscribers.
-     *
-     * This method is protected and should only be called from within your view model subclass.
-     * The updater function receives the current internal state and should return the new internal state.
-     * After updating, the derived state is automatically recomputed via `computeDerivedState`.
-     * Always return a new state object to ensure immutability.
-     *
-     * @param updater - Function that receives current internal state and returns new internal state
-     *
-     * @example
-     * ```typescript
-     * this.update((currentState) => ({
-     *   ...currentState,
-     *   count: currentState.count + 1
-     * }));
-     * ```
-     */
-    protected update(updater: Updater<S>): void;
-    /**
-     * Compute the derived state from the internal state.
-     *
-     * This abstract method must be implemented by subclasses to transform
-     * the internal state into the derived state that will be exposed to
-     * subscribers. This method is called automatically after each state
-     * update and during initialization.
-     *
-     * @param state - The current internal state
-     * @returns The derived state with any computed properties
-     *
-     * @example
-     * ```typescript
-     * computeDerivedState({ count }: CounterState): CounterDerivedState {
-     *   return {
-     *     count,
-     *     isEven: count % 2 === 0,
-     *     isPositive: count > 0,
-     *   };
-     * }
-     * ```
-     */
-    abstract computeDerivedState(state: S): D;
-    /**
-     * Get the current derived state.
-     *
-     * This returns the derived state computed by `computeDerivedState`,
-     * not the internal state.
-     *
-     * @returns The current derived state
-     */
-    get state(): D;
-}
-//# sourceMappingURL=ViewModelWithDerivedState.d.ts.map

package/dist/ViewModelWithDerivedState.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ViewModelWithDerivedState.d.ts","sourceRoot":"","sources":["../src/ViewModelWithDerivedState.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC,KAAK,CAAC,CAAC;AAEhD;;;;;GAKG;AACH,MAAM,MAAM,iBAAiB,GAAG,MAAM,IAAI,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,8BAAsB,yBAAyB,CAAC,CAAC,EAAE,CAAC;IAClD,OAAO,CAAC,UAAU,CAAqC;IACvD,OAAO,CAAC,cAAc,CAAI;IAC1B,OAAO,CAAC,MAAM,CAAI;IAElB;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI;IAOlD;;;;;;;OAOG;gBACS,YAAY,EAAE,CAAC;IAK3B;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;IASpC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,QAAQ,CAAC,mBAAmB,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC;IAEzC;;;;;;;OAOG;IACH,IAAI,KAAK,IAAI,CAAC,CAEb;CACF"}

package/dist/ViewModelWithDerivedState.js

@@ -1,126 +0,0 @@
-/**
- * Abstract base class for creating reactive view models with derived state.
- *
- * This class extends the basic ViewModel pattern by allowing you to compute
- * derived state from internal state. The internal state is managed privately,
- * while the derived state (which can include computed properties) is exposed
- * to subscribers.
- *
- * @template S - The internal state type (managed internally)
- * @template D - The derived state type (exposed to subscribers)
- *
- * @example
- * ```typescript
- * type TodoInternalState = {
- *   items: Array<{ id: string; text: string; done: boolean }>;
- * };
- *
- * type TodoDerivedState = TodoInternalState & {
- *   totalCount: number;
- *   completedCount: number;
- *   remainingCount: number;
- * };
- *
- * class TodoViewModel extends ViewModelWithDerivedState<TodoInternalState, TodoDerivedState> {
- *   constructor() {
- *     super({ items: [] });
- *   }
- *
- *   computeDerivedState({ items }: TodoInternalState): TodoDerivedState {
- *     return {
- *       items,
- *       totalCount: items.length,
- *       completedCount: items.filter(item => item.done).length,
- *       remainingCount: items.filter(item => !item.done).length,
- *     };
- *   }
- *
- *   addTodo(text: string) {
- *     this.update(({ items }) => ({
- *       items: [...items, { id: crypto.randomUUID(), text, done: false }],
- *     }));
- *   }
- * }
- *
- * const todos = new TodoViewModel();
- * todos.subscribe(() => {
- *   console.log('Completed:', todos.state.completedCount);
- * });
- * todos.addTodo('Learn ViewModels'); // Logs: Completed: 0
- * ```
- */
-export class ViewModelWithDerivedState {
-    /**
-     * Subscribe to state changes.
-     *
-     * The listener will be called immediately after any state update.
-     *
-     * @param listener - Function to call when state changes
-     * @returns Function to unsubscribe the listener
-     *
-     * @example
-     * ```typescript
-     * const unsubscribe = viewModel.subscribe((state) => {
-     *   console.log('State changed:', state);
-     * });
-     *
-     * // Later, when you want to stop listening:
-     * unsubscribe();
-     * ```
-     */
-    subscribe(listener) {
-        this._listeners.add(listener);
-        return () => {
-            this._listeners.delete(listener);
-        };
-    }
-    /**
-     * Create a new ViewModel with the given initial internal state.
-     *
-     * The constructor initializes the internal state and immediately computes
-     * the derived state by calling `computeDerivedState`.
-     *
-     * @param initialState - The initial internal state of the view model
-     */
-    constructor(initialState) {
-        this._listeners = new Set();
-        this._internalState = initialState;
-        this._state = this.computeDerivedState(this._internalState);
-    }
-    /**
-     * Update the internal state, recompute derived state, and notify all subscribers.
-     *
-     * This method is protected and should only be called from within your view model subclass.
-     * The updater function receives the current internal state and should return the new internal state.
-     * After updating, the derived state is automatically recomputed via `computeDerivedState`.
-     * Always return a new state object to ensure immutability.
-     *
-     * @param updater - Function that receives current internal state and returns new internal state
-     *
-     * @example
-     * ```typescript
-     * this.update((currentState) => ({
-     *   ...currentState,
-     *   count: currentState.count + 1
-     * }));
-     * ```
-     */
-    update(updater) {
-        this._internalState = updater(this._internalState);
-        this._state = this.computeDerivedState(this._internalState);
-        for (const listener of this._listeners) {
-            listener();
-        }
-    }
-    /**
-     * Get the current derived state.
-     *
-     * This returns the derived state computed by `computeDerivedState`,
-     * not the internal state.
-     *
-     * @returns The current derived state
-     */
-    get state() {
-        return this._state;
-    }
-}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gCAAgC,CAAC"}