chizu 0.4.0 → 0.5.2

package/dist/{error → src/library/error}/types.d.ts

@@ -7,12 +7,8 @@ export declare enum Reason {
     Timedout = 0,
     /** Action was cancelled by a newer dispatch. */
     Supplanted = 1,
-    /** Action was blocked by the regulator's `allow` function returning `false`. */
-    Disallowed = 2,
     /** A generic error thrown in the user's action handler. */
-    Errored = 3,
-    /** Action was aborted because the component unmounted. */
-    Unmounted = 4
+    Errored = 2
 }
 /**
  * Error thrown when an action is aborted, e.g., when a component unmounts
@@ -41,19 +37,6 @@ export declare class TimeoutError extends Error {
     name: string;
     constructor(message?: string);
 }
-/**
- * Error thrown when an action is blocked by the regulator policy.
- * Works across all platforms including React Native where `DOMException` is unavailable.
- *
- * @example
- * ```ts
- * throw new DisallowedError("Action blocked by regulator");
- * ```
- */
-export declare class DisallowedError extends Error {
-    name: string;
-    constructor(message?: string);
-}
 /**
  * Details about an error that occurred during action execution.
  *

package/dist/{hooks → src/library/hooks}/index.d.ts

@@ -1,5 +1,5 @@
 import { Data } from './types.ts';
-import { Model, Props, Actions, UseActions, ValidateFeatures, NullableNodes } from '../types/index.ts';
+import { Model, Props, Actions, UseActions } from '../types/index.ts';
 export { With } from './utils.ts';
 /**
  * A hook for managing state with actions.
@@ -40,4 +40,4 @@ export { With } from './utils.ts';
  * ```
  */
 export declare function useActions<_M extends void = void, A extends Actions | void = void, D extends Props = Props>(getData?: Data<D>): UseActions<void, A, D>;
-export declare function useActions<M extends Model, A extends Actions | void = void, D extends Props = Props>(initialModel: NullableNodes<M> & ValidateFeatures<M>, getData?: Data<D>): UseActions<M, A, D>;
+export declare function useActions<M extends Model, A extends Actions | void = void, D extends Props = Props>(initialModel: M, getData?: Data<D>): UseActions<M, A, D>;

package/dist/{hooks → src/library/hooks}/types.d.ts

@@ -1,24 +1,8 @@
 import { default as EventEmitter } from 'eventemitter3';
 import { RefObject } from 'react';
-import { Model, HandlerContext, Actions, Props, Tasks, ActionId, Phase, Filter, ExtractNodes } from '../types/index.ts';
+import { Model, HandlerContext, Actions, Props, Tasks, ActionId, Phase, Filter } from '../types/index.ts';
 import { BroadcastEmitter } from '../boundary/components/broadcast/utils.ts';
 import { ScopeContext } from '../boundary/components/scope/types.ts';
-/**
- * Return type for the useNodes hook.
- * Contains refs for captured nodes, pending captures, and last emitted nodes.
- *
- * @template M - The model type containing a `nodes` property
- */
-export type References<M extends Model | void> = {
-    /** Ref containing captured DOM nodes by name */
-    refs: RefObject<{
-        [K in keyof ExtractNodes<M>]: ExtractNodes<M>[K] | null;
-    }>;
-    /** Ref containing pending node captures to be processed after render */
-    pending: RefObject<Map<keyof ExtractNodes<M>, ExtractNodes<M>[keyof ExtractNodes<M>] | null>>;
-    /** Ref containing last emitted node values to detect true changes */
-    emitted: RefObject<Map<keyof ExtractNodes<M>, ExtractNodes<M>[keyof ExtractNodes<M>] | null>>;
-};
 /**
  * Function signature for action handlers registered via `useAction`.
  * Receives the reactive context and payload, returning void or a promise/generator.

package/dist/{hooks → src/library/hooks}/utils.d.ts

@@ -1,7 +1,7 @@
 import { RefObject } from 'react';
 import { Props, Model, Actions, Filter, ActionId, HandlerPayload, ChanneledAction, HandlerContext } from '../types/index.ts';
 import { default as EventEmitter } from 'eventemitter3';
-import { Dispatchers, LifecycleConfig, References, Scope } from './types.ts';
+import { Dispatchers, LifecycleConfig, Scope } from './types.ts';
 import { isChanneledAction, getActionSymbol } from '../action/index.ts';
 import * as React from "react";
 /**
@@ -38,12 +38,14 @@ export declare function emitAsync(emitter: EventEmitter, event: string | symbol,
  * Also invokes broadcast action handlers with cached values on mount.
  * Updates the phase ref to track the component's current lifecycle state.
  *
- * Uses a ref guard to prevent React Strict Mode from causing duplicate
- * Mount emissions during its development-only double-invocation cycle.
+ * The Mount effect skips when `phase` is already `Mounted` — this catches
+ * Strict Mode's dev-only double-invocation. It accepts both `Mounting` (first
+ * mount) and `Unmounted` (re-mount after `<Activity>` show) as entry states
+ * so that hidden-then-shown subtrees correctly re-emit Mount.
  *
- * Note: The phase transitions are:
- * - Mounting → (cached broadcast action values emitted here) → Mounted
- * - Mounted → Unmounting → Unmounted
+ * Phase transitions:
+ * - First mount:           Mounting → Mounted
+ * - Activity hide / show:  Mounted → Unmounting → Unmounted → Mounting → Mounted
  */
 export declare function useLifecycles({ unicast, broadcast, dispatchers, scope, phase, data, handlers, }: LifecycleConfig): void;
 /**
@@ -60,36 +62,44 @@ export declare function useLifecycles({ unicast, broadcast, dispatchers, scope,
  */
 export declare function useData<P extends Props>(props: P): P;
 /**
- * Creates a handler that binds an action's payload directly to a model property.
+ * Handler factories that wire an action directly to a model field.
  *
- * The returned handler updates `model[key]` with the payload when the action is dispatched.
- * Type safety is enforced at the call site: the payload type must be assignable to
- * the model property's type.
+ * - {@link With.Update} assigns the dispatched payload to `model[key]`.
+ * - {@link With.Invert} flips a boolean field on `model[key]`.
  *
- * @template K The property key type (inferred from the argument)
- * @param key The model property key to bind the payload to
- * @returns A handler function compatible with `useAction`
+ * Both are typed so the call site fails to compile when `key` is missing or
+ * has an incompatible type.
  *
  * @example
  * ```ts
  * import { With } from "chizu";
  *
- * type Model = { name: string; count: number };
+ * type Model = { name: string; sidebar: boolean };
  *
  * class Actions {
  *   static SetName = Action<string>("SetName");
- *   static SetCount = Action<number>("SetCount");
+ *   static ToggleSidebar = Action("ToggleSidebar");
  * }
  *
- * // These work - payload types match model property types
- * actions.useAction(Actions.SetName, With("name"));   // string -> string ✓
- * actions.useAction(Actions.SetCount, With("count")); // number -> number ✓
- *
- * // This would error - Country is not assignable to string
- * actions.useAction(Actions.Visitor, With("name")); // Country -> string ✗
+ * actions.useAction(Actions.SetName, With.Update("name"));
+ * actions.useAction(Actions.ToggleSidebar, With.Invert("sidebar"));
  * ```
  */
-export declare function With<K extends string>(key: K): <M extends Model, A extends Actions | void, D extends Props, P extends K extends keyof M ? M[K] : never>(context: HandlerContext<M, A, D>, payload: P) => void;
+export declare const With: {
+    /**
+     * Returns a handler that assigns the action payload to `model[key]`.
+     *
+     * Type-checks at the call site: the payload type must be assignable to
+     * the model property's type, and the key must exist on the model.
+     */
+    Update<K extends string>(key: K): <M extends Model, A extends Actions | void, D extends Props, P extends K extends keyof M ? M[K] : never>(context: HandlerContext<M, A, D>, payload: P) => void;
+    /**
+     * Returns a handler that inverts a boolean field on the model.
+     *
+     * Type-checks at the call site: `model[key]` must be a boolean.
+     */
+    Invert<K extends string>(key: K): <M extends Model & Record<K, boolean>, A extends Actions | void, D extends Props>(context: HandlerContext<M, A, D>) => void;
+};
 /**
  * Scans a handler registry for a lifecycle action of the given type.
  *
@@ -169,14 +179,6 @@ export declare function useDispatchers(): Dispatchers;
  * @internal
  */
 export declare function useRegisterHandler<M extends Model | void, A extends Actions | void, D extends Props>(scope: React.RefObject<Scope<M, A, D>>, action: ActionId | HandlerPayload | ChanneledAction, handler: (context: HandlerContext<M, A, D>, payload: unknown) => void | Promise<void> | AsyncGenerator | Generator): void;
-/**
- * Manages captured DOM nodes for a model type.
- * Returns refs for nodes, pending captures, and last emitted nodes.
- *
- * @template M The model type containing a `nodes` property
- * @returns Object containing refs for nodes, pending captures, and emitted nodes
- */
-export declare function useNodes<M extends Model | void>(): References<M>;
 /**
  * Checks if a dispatch channel matches a registered handler channel.
  * All properties in the dispatch channel must match the corresponding properties in the registered channel.

package/dist/{index.d.ts → src/library/index.d.ts}

@@ -1,16 +1,16 @@
 export { Action } from './action/index.ts';
 export { Distribution, Lifecycle } from './types/index.ts';
-export { Reason, AbortError, TimeoutError, DisallowedError, } from './error/index.ts';
+export { Reason, AbortError, TimeoutError } from './error/index.ts';
 export { Operation, Op, State } from 'immertation';
 export { annotate } from './annotate/index.ts';
 export { Boundary } from './boundary/index.tsx';
-export { Regulators } from './boundary/components/regulators/index.tsx';
-export { Scope, withScope } from './boundary/components/scope/index.tsx';
+export { withScope } from './boundary/components/scope/index.tsx';
+export { useMode } from './boundary/components/mode/index.tsx';
+export type { ModeHandle } from './boundary/components/mode/index.tsx';
 export { useActions, With } from './hooks/index.ts';
 export { Resource } from './resource/index.ts';
 export type { ResourceHandle, ResourceDispatch, ResourceSuccess, ResourceFailure, } from './resource/index.ts';
 export * as utils from './utils/index.ts';
 export type { Box } from 'immertation';
 export type { Fault } from './error/index.ts';
-export type { Pk, Task, Tasks, Handlers, Meta } from './types/index.ts';
-export type { Regulator } from './boundary/components/regulators/index.tsx';
+export type { Pk, Task, Tasks, Handlers } from './types/index.ts';