march-hare 0.8.0 → 0.10.0

package/dist/hooks/index.d.ts

@@ -1,83 +0,0 @@
-import { Data } from './types';
-import { Model, Props, Actions, UseActions, Context as ContextHandle } from '../types/index';
-export { With } from './utils';
-/**
- * A hook for managing state with actions.
- *
- * Call `useActions` first, then use `actions.useAction` to bind handlers
- * to action symbols. Types are pre-baked from the generic parameters, so
- * no additional type annotations are needed on handler calls.
- *
- * The hook returns a result containing:
- * 1. The current model state
- * 2. An actions object with `dispatch`, `inspect`, and `useAction`
- * 3. A read-only snapshot of the data values produced by `getData` —
- *    the same values handlers read via `context.data`, exposed here for
- *    JSX consumption so the view and the handler share one named source.
- *
- * The `inspect` property provides access to Immertation's annotation system,
- * allowing you to check for pending operations on model properties.
- *
- * @template M The model type representing the component's state.
- * @template AC The actions class containing action definitions.
- * @template D The data type for reactive external values.
- * @param initialModel The initial model state.
- * @param getData Optional function that returns reactive values as data.
- *   Values returned are accessible via `context.data` in action handlers,
- *   always reflecting the latest values even after await operations.
- * @returns A result `[model, actions, data]` with pre-typed `useAction` method.
- *
- * @example
- * ```typescript
- * // Basic usage
- * const [model, actions] = useActions<Model, typeof Actions>(model);
- *
- * // Without a model (actions-only)
- * const [, actions] = useActions<void, typeof Actions>();
- *
- * // With reactive data &mdash; consumed in JSX and handlers alike.
- * const [model, actions, data] = useActions<
- *   Model,
- *   typeof Actions,
- *   { query: string }
- * >(initialModel, () => ({ query: props.query }));
- * ```
- */
-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: M, getData?: Data<D>): UseActions<M, A, D>;
-/**
- * Returns a stable, typed controller handle up-front &mdash; before a
- * model is declared via `context.useActions(...)`. Use this when an
- * external imperative library (form, animation, third-party SDK) needs a
- * dispatch callback at construction time, while the value that library
- * returns must flow back into the controller's data callback.
- *
- * The handle exposes `dispatch(action, payload?)` and a `useView(...)`
- * method that materialises the component-local model and reactive data
- * &mdash; the M and D pair of `useContext<M, AC, D>` &mdash; and
- * returns the `[model, actions, data]` tuple with `useAction`, `dispatch`,
- * `inspect`, and `stream` attached. The first invocation of
- * `context.actions.dispatch(...)` must come from an event handler &mdash; not
- * synchronously during render &mdash; because the underlying dispatch
- * target is wired up when `context.useActions(...)` runs in the same
- * render pass.
- *
- * @template M The model type representing the component's state.
- * @template AC The actions class containing action definitions.
- * @template D The data type for reactive external values.
- *
- * @example
- * ```ts
- * const context = useContext<Model, typeof Actions, Data>();
- *
- * const form = useForm({
- *   onSubmit: () => void context.actions.dispatch(Actions.Submit),
- * });
- *
- * const actions = context.useActions(
- *   { user: user() },
- *   () => ({ form }),
- * );
- * ```
- */
-export declare function useContext<M extends Model | void = void, AC extends Actions | void = void, D extends Props = Props>(): ContextHandle<M, AC, D>;