chizu 0.2.26 → 0.2.28

package/dist/hooks/index.d.ts

@@ -1,16 +1,72 @@
-import * as React from "react";
+import { Context, Model, Payload, Props, ActionsClass, Actions, UseActions } from '../types/index.ts';
 /**
- * Optimises the memoisation of a value based on its dependencies.
+ * Memoizes an action handler for performance optimization.
  *
- * @param factory {() => T}
- * @param dependencies {React.DependencyList}
- * @returns {T}
+ * @template Model The type of the model.
+ * @template Actions The type of the actions.
+ * @template Action The specific action being handled.
+ * @param {(context: Context<Model, Actions>, name: Action) => void} action The action handler function.
+ * @returns {React.useCallback} The memoized action handler.
  */
-export declare function useOptimisedMemo<T>(factory: () => T, dependencies: React.DependencyList): T;
+export declare function useAction<M extends Model, AC extends ActionsClass<any> = never>(handler: (context: Context<M, AC>, payload: AC extends Payload<infer P> ? P : never) => void | Promise<void> | AsyncGenerator | Generator): (context: Context<M, AC>, payload: AC extends Payload<infer P> ? P : never) => Promise<void>;
 /**
- *  Optimises the execution of an effect based on its dependencies.
+ * A hook for managing state with actions.
  *
- * @param effect {React.EffectCallback}
- * @param dependencies {React.DependencyList}
+ * Pass type parameters explicitly to get proper type inference for the returned tuple:
+ * `useActions<Model, typeof Actions>(initialModel, actionClass)`
+ *
+ * The hook returns a tuple containing:
+ * 1. The current model state
+ * 2. An actions object with `dispatch` and `inspect` properties
+ *
+ * The `inspect` property provides access to Immertation's annotation system,
+ * allowing you to check for pending operations on model properties using
+ * methods like `actions.inspect.count.pending()` and `actions.inspect.count.remaining()`.
+ *
+ * @template M The type of the model state.
+ * @template AC The type of the actions class (should be `typeof YourActionsClass`).
+ * @param {M} initialModel The initial model state.
+ * @param {Actions<M, AC> | (new () => unknown)} ActionClass The class defining the actions.
+ * @returns {UseActions<M, AC>} A tuple `[model, actions]` where `actions` includes `dispatch` and `inspect`.
+ *
+ * @example
+ * ```typescript
+ * // In your actions file
+ * export default function useCounterActions() {
+ *   return useActions<Model, typeof Actions>(
+ *     { count: 0 },
+ *     class {
+ *       [Actions.Increment] = incrementAction;
+ *       [Actions.Decrement] = decrementAction;
+ *     }
+ *   );
+ * }
+ *
+ * // In your component
+ * function Counter() {
+ *   const [model, actions] = useActions();
+ *
+ *   return (
+ *     <div>
+ *       <p>Count: {model.count}</p>
+ *       {actions.inspect.count.pending() && <Spinner />}
+ *       {actions.inspect.count.pending() && (
+ *         <p>Remaining: {actions.inspect.count.remaining()}</p>
+ *       )}
+ *       <button onClick={() => actions.dispatch(Actions.Increment)}>+</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useActions<M extends Model, AC extends ActionsClass<any>>(initialModel: M, ActionClass: Actions<M, AC> | (new () => unknown)): UseActions<M, AC>;
+/**
+ * Creates a snapshot of a given object, returning a memoized version.
+ * The snapshot provides stable access to the object's properties,
+ * even as the original object changes across renders.
+ *
+ * @template T The type of the object.
+ * @param {T} props The object to create a snapshot of.
+ * @returns {T} A memoized snapshot of the object.
  */
-export declare function useOptimisedEffect(effect: React.EffectCallback, dependencies: React.DependencyList): void;
+export declare function useSnapshot<P extends Props>(props: P): P;

package/dist/hooks/types.d.ts

@@ -0,0 +1,2 @@
+import { State } from 'immertation';
+export type Store = State<Record<string, unknown>> | null;

package/dist/hooks/utils.d.ts

@@ -0,0 +1,18 @@
+import { RefObject } from 'react';
+import { Props } from '../types';
+/**
+ * @name withGetters
+ * @description This function creates a new object with getters for each property of the input object.
+ * The getters retrieve the current value from a ref, ensuring that the latest value is always accessed.
+ * @param {P} a The object to create getters for.
+ * @param {RefObject<P>} b The ref object containing the current values.
+ * @returns {P} A new object with getters that access the current values from the ref.
+ */
+export declare function withGetters<P extends Props>(a: P, b: RefObject<P>): P;
+/**
+ * @name isGenerator
+ * @description Checks if the given result is a generator or async generator.
+ * @param result The result to check.
+ * @returns {boolean} True if the result is a generator or async generator, false otherwise.
+ */
+export declare function isGenerator(result: unknown): result is Generator | AsyncGenerator;

package/dist/index.d.ts

@@ -1,11 +1,8 @@
-import { ControllerDefinition } from './controller/types.ts';
-import { ViewArgs } from './view/types.ts';
-export { Lifecycle, State, Boundary } from './types/index.ts';
+export { ActionError } from './error/index.tsx';
+export { createAction, createDistributedAction } from './action/index.ts';
+export type { Pk, Context, ActionInstance, ActionsClass, UseActions, Actions, } from './types/index.ts';
+export { Lifecycle } from './types/index.ts';
 export * as utils from './utils/index.ts';
-export { default as Scope } from './module/index.tsx';
 export { Broadcaster } from './broadcast/index.tsx';
-export { useScoped } from './module/renderer/utils.ts';
-export { isTypedError, TypedError } from './errors/utils.ts';
-export type { Schema, Pk } from './types/index.ts';
-export type { ViewArgs as Scoped };
-export type { ControllerDefinition as Actions };
+export { useActions, useAction, useSnapshot } from './hooks/index.ts';
+export { Operation, Op, State } from 'immertation';

package/dist/types/index.d.ts

@@ -1,58 +1,53 @@
-export declare enum Transmit {
-    Unicast = "unicast",
-    Multicast = "multicast",
-    Broadcast = "broadcast"
+import { Operation, Process, Inspect } from 'immertation';
+import { context } from '../use';
+export declare class Lifecycle {
+    static Mount: symbol;
+    static Node: symbol;
+    static Derive: symbol;
+    static Error: symbol;
+    static Unmount: symbol;
 }
-export declare class Draft<T> {
-    value: T;
-    constructor(value: T);
-}
-export declare class State {
-    static Op: {
-        Add: number;
-        Remove: number;
-        Update: number;
-        Move: number;
-        Replace: number;
-    };
-    static Draft<T>(value: T): Draft<T>;
-}
-export type ActionName = Lifecycle | symbol | string | number;
-type ActionPayload = [any, ...any[]];
-export declare enum Lifecycle {
-    Mount = "lifecycle/mount",
-    Node = "lifecycle/node",
-    Derive = "lifecycle/derive",
-    Error = "lifecycle/error",
-    Unmount = "lifecycle/unmount"
-}
-export type Model = Record<symbol | string, any>;
-export type Actions = [] | [ActionName] | [ActionName, ...ActionPayload];
-export type Props = Record<string, unknown>;
-export type Context = Record<string, React.Context<any>>;
-export type Schema<M extends Model, A extends Actions = [], P extends Props = Record<string, never>> = {
-    Model: M;
-    Actions: A;
-    Props: P;
-};
-export type ModuleDefinition = {
-    Model: Model;
-    Actions: Actions;
-    Props: Props;
-};
 export type Pk<T> = undefined | symbol | T;
 export type Task = PromiseWithResolvers<void>;
-export type Process = symbol;
-export type Op = number;
-export declare enum Boundary {
-    Default = 0,
-    Error = 1
-}
-export type Meta = {
-    boundary: Boundary;
+export type Model<M = Record<string, unknown>> = M;
+export declare const PayloadKey: unique symbol;
+export type Payload<T = unknown> = symbol & {
+    [PayloadKey]: T;
+};
+type PayloadType<A> = A extends Payload<infer P> ? P : never;
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export type Props = Record<string, unknown>;
+export type Action = symbol | string;
+export type ActionsClass<AC extends Record<string, Payload<any>>> = {
+    new (): unknown;
+} & AC;
+export type ActionInstance<M extends Model, AC extends ActionsClass<any>> = UnionToIntersection<AC[keyof AC] extends infer P ? P extends symbol ? P extends Payload<infer T> ? {
+    [K in P]: ((context: Context<M, AC>, payload: T) => void | Promise<void>) & {
+        payload: T;
+    };
+} : never : never : never>;
+export type Result = {
+    processes: Set<Process>;
 };
-export type ContextType<T> = T extends React.Context<infer U> ? U : never;
-export type ContextTypes<T extends Record<string, React.Context<any>>> = {
-    [K in keyof T]: ContextType<T[K]>;
+export type OperationFunction = <T>(value: T, process: Process) => T;
+export type Context<M extends Model, AC extends ActionsClass<any>> = {
+    model: M;
+    signal: AbortSignal;
+    actions: {
+        produce(ƒ: (model: M) => void): M;
+        dispatch<A extends AC[keyof AC] & Payload<any>>(...args: [PayloadType<A>] extends [never] ? [A] : [A, PayloadType<A>]): void;
+        annotate<T>(operation: Operation, value: T): T;
+    };
+    [context]: {
+        controller: AbortController;
+    };
 };
+export type Actions<M extends Model, AC extends ActionsClass<any>> = new () => ActionInstance<M, AC>;
+export type UseActions<M extends Model, AC extends ActionsClass<any>> = [
+    M,
+    {
+        dispatch<A extends AC[keyof AC] & Payload<any>>(...args: [PayloadType<A>] extends [never] ? [A] : [A, PayloadType<A>]): void;
+        inspect: Inspect<M>;
+    }
+];
 export {};

package/dist/use/index.d.ts

@@ -0,0 +1,5 @@
+import { Field } from './types';
+export { context } from './utils';
+export declare const use: {
+    serial(): (_: unknown, field: Field) => void;
+};

package/dist/use/types.d.ts

@@ -0,0 +1,3 @@
+import { ActionsClass, Context, Model } from '../types';
+export type Field = ClassFieldDecoratorContext<any, Context<Model, ActionsClass<any>>>;
+export type Args = Context<Model, ActionsClass<any>>;

package/dist/use/utils.d.ts

@@ -0,0 +1,2 @@
+export declare const contexts: WeakMap<typeof context, any>;
+export declare const context: unique symbol;

package/dist/utils/index.d.ts

@@ -1,6 +1,31 @@
-import { Pk } from '../types/index.ts';
+import { ActionsClass, Context, Model, Payload, Pk } from '../types/index.ts';
 export { default as sleep } from './sleep/index.ts';
+/**
+ * Generates a unique primary key.
+ * @returns A new unique symbol representing the primary key.
+ */
 export declare function pk(): symbol;
+/**
+ * Checks if the provided ID is a valid primary key.
+ * A valid primary key is considered any value that is not a symbol.
+ * @template T The type of the object.
+ * @param id The primary key to validate.
+ * @returns `true` if the ID is valid, `false` otherwise.
+ */
 export declare function pk<T>(id: Pk<T>): boolean;
-export declare function hash<T>(x: T): string;
-export declare const meta: unique symbol;
+/** Shorthand alias for {@link pk}. */
+export declare const κ: typeof pk;
+/**
+ * Creates a generic "setter" action that updates a specific property in the state.
+ * This is a higher-order function that takes a property name and returns an action function.
+ * The returned action, when called, will update the state with the provided payload for the specified property.
+ * It uses `produce` to handle immutable state updates.
+ *
+ * @template M The model (state) type.
+ * @template A The actions type.
+ * @param property The name of the property in the state to update.
+ * @returns An action function that takes the context and a payload, and updates the state.
+ */
+export declare function set<M extends Model, AC extends ActionsClass<any>>(property: string): (context: Context<M, AC>, payload: Payload) => void;
+/** Shorthand alias for {@link set}. */
+export declare const λ: typeof set;

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "chizu",
-  "version": "0.2.26",
+  "version": "0.2.28",
   "type": "module",
+  "license": "MIT",
   "main": "./dist/chizu.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -13,52 +14,70 @@
   },
   "dependencies": {
     "eventemitter3": "^5.0.1",
-    "immer": "^10.1.1",
+    "immertation": "^0.1.15",
     "lodash": "^4.17.21",
-    "react": "^19.1.0",
-    "traverse": "0.6.8"
+    "traverse": "0.6.11"
+  },
+  "peerDependencies": {
+    "@mobily/ts-belt": "^3.0.0",
+    "immer": "^10.0.0",
+    "react": "^18.0.0 || ^19.0.0",
+    "react-dom": "^18.0.0 || ^19.0.0"
   },
   "files": [
     "dist"
   ],
   "scripts": {
+    "build": "vite build",
+    "build:example": "vite build --mode example --outDir dist-example --base /Chizu/",
+    "dev": "vite",
+    "preview": "vite preview",
     "release": "make checks"
   },
   "devDependencies": {
-    "@babel/preset-env": "^7.27.2",
-    "@babel/preset-react": "^7.27.1",
-    "@babel/preset-typescript": "^7.27.1",
+    "@babel/plugin-proposal-decorators": "^7.28.0",
+    "@babel/preset-env": "^7.28.5",
+    "@babel/preset-react": "^7.28.5",
+    "@babel/preset-typescript": "^7.28.5",
     "@emotion/css": "^11.13.5",
-    "@eslint/js": "^9.27.0",
-    "@jest/globals": "^30.0.0-beta.3",
-    "@testing-library/dom": "^10.4.0",
-    "@testing-library/jest-dom": "^6.6.3",
+    "@eslint/js": "^9.39.1",
+    "@faker-js/faker": "^10.1.0",
+    "@jest/globals": "^30.2.0",
+    "@mobily/ts-belt": "^3.13.1",
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.0",
-    "@types/lodash": "^4.17.17",
-    "@types/react": "^19.1.6",
-    "@types/react-dom": "^19.1.5",
+    "@types/lodash": "^4.17.21",
+    "@types/ramda": "^0.31.1",
+    "@types/react": "^19.2.7",
+    "@types/react-dom": "^19.2.3",
     "@types/traverse": "^0.6.37",
-    "commit-and-tag-version": "^12.5.1",
-    "dayjs": "^1.11.13",
-    "dexie": "^4.0.11",
-    "eslint": "^9.27.0",
+    "@vitejs/plugin-react": "^5.1.1",
+    "commit-and-tag-version": "^12.6.1",
+    "dayjs": "^1.11.19",
+    "dexie": "^4.2.1",
+    "eslint": "^9.39.1",
     "eslint-plugin-react": "^7.37.5",
     "get-port-cli": "^3.0.0",
-    "globals": "^16.2.0",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^30.0.0-beta.3",
-    "lucide-react": "^0.511.0",
-    "prettier": "^3.5.3",
-    "react-dom": "^19.1.0",
-    "react-router-dom": "^7.6.1",
-    "react-test-renderer": "^19.1.0",
-    "rollup-plugin-visualizer": "^6.0.1",
-    "ts-jest": "^29.3.4",
+    "globals": "^16.5.0",
+    "immer": "^11.0.1",
+    "jest": "^30.2.0",
+    "jest-environment-jsdom": "^30.2.0",
+    "lucide-react": "^0.555.0",
+    "prettier": "^3.7.4",
+    "ramda": "^0.32.0",
+    "react": "^19.2.1",
+    "react-dom": "^19.2.1",
+    "react-flip-numbers": "^3.0.9",
+    "react-router-dom": "^7.10.1",
+    "react-test-renderer": "^19.2.1",
+    "rollup-plugin-visualizer": "^6.0.5",
+    "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
-    "typescript": "^5.8.3",
-    "typescript-eslint": "^8.33.0",
-    "vite": "^6.3.5",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.48.1",
+    "vite": "^7.2.6",
     "vite-plugin-dts": "^4.5.4",
-    "wait-on": "^8.0.3"
+    "wait-on": "^9.0.3"
   }
 }

package/dist/context/index.d.ts

@@ -1,7 +0,0 @@
-import { Context, ContextTypes } from '../types/index.ts';
-import * as React from "react";
-export default function useContext<C extends Context>(): {
-    use: React.RefObject<C>;
-    values: React.RefObject<ContextTypes<C>>;
-    update: () => void;
-};

package/dist/context/types.d.ts

@@ -1,2 +0,0 @@
-import { default as useContext } from './index.ts';
-export type UseContext = ReturnType<typeof useContext>;

package/dist/controller/index.d.ts

@@ -1,3 +0,0 @@
-import { ModuleDefinition } from '../types/index.ts';
-import { ControllerDefinition } from './types.ts';
-export default function controller<M extends ModuleDefinition>(definition: ControllerDefinition<M>): ControllerDefinition<M>;

package/dist/controller/types.d.ts

@@ -1,30 +0,0 @@
-import { TypedError } from '../errors/utils.ts';
-import { Models } from '../module/renderer/model/utils.ts';
-import { Head } from '../module/renderer/types.ts';
-import { Actions, Context, ContextTypes, Draft, Lifecycle, Meta, ModuleDefinition, Op } from '../types/index.ts';
-export type ControllerActions<M extends ModuleDefinition> = {
-    annotate<T>(value: T, operations?: (Op | Draft<T>)[]): T;
-    produce(ƒ: (model: M["Model"], meta: Meta) => void): (models: Models<M["Model"]>, process: symbol) => Models<M["Model"]>;
-    dispatch(action: M["Actions"]): Promise<void>;
-    context<C extends Context>(context: C): ContextTypes<C>;
-};
-export type ControllerArgs<M extends ModuleDefinition> = Readonly<{
-    model: Readonly<M["Model"]>;
-    props: Readonly<M["Props"]>;
-    actions: Readonly<ControllerActions<M>>;
-}>;
-export type ActionEvent<M extends ModuleDefinition> = (...args: M["Actions"][number]) => ActionGenerator<M>;
-type ActionEvents<M extends ModuleDefinition> = {
-    [K in Head<M["Actions"]>]: (payload: Payload<M["Actions"], K>) => ActionGenerator<M>;
-};
-export type ActionGenerator<M extends ModuleDefinition> = void | Promise<void> | ((models: Models<M["Model"]>, process: symbol) => Models<M["Model"]>) | Promise<(models: Models<M["Model"]>, process: symbol) => Models<M["Model"]>> | AsyncGenerator<(models: Models<M["Model"]>, process: symbol) => Models<M["Model"]>, (models: Models<M["Model"]>, process: symbol) => Models<M["Model"]>, unknown>;
-export type ControllerDefinition<M extends ModuleDefinition> = (controller: ControllerArgs<M>) => ControllerInstance<M>;
-export type ControllerInstance<M extends ModuleDefinition> = {
-    [Lifecycle.Mount]?(): ActionGenerator<M>;
-    [Lifecycle.Derive]?(): ActionGenerator<M>;
-    [Lifecycle.Node]?(tree: HTMLElement): ActionGenerator<M>;
-    [Lifecycle.Error]?(error: Error | TypedError): ActionGenerator<M>;
-    [Lifecycle.Unmount]?(): ActionGenerator<M>;
-} & Partial<ActionEvents<M>>;
-type Payload<A extends Actions, K> = A extends [K, infer P] ? P : never;
-export {};

package/dist/errors/index.d.ts

@@ -1,8 +0,0 @@
-import { Props } from './types.ts';
-import { ModuleDefinition } from '../types/index.ts';
-import * as React from "react";
-export default class ErrorBoundary<M extends ModuleDefinition> extends React.Component<Props<M>> {
-    constructor(props: Props<M>);
-    componentDidCatch(error: unknown): void;
-    render(): import("react/jsx-runtime").JSX.Element;
-}

package/dist/errors/types.d.ts

@@ -1,13 +0,0 @@
-import { ModuleDefinition } from '../types/index.ts';
-import { ViewArgs } from '../view/types.ts';
-import { UseModel } from '../module/renderer/model/types.ts';
-import { UseDispatchers } from '../module/renderer/dispatchers/types.ts';
-import { UseUpdate } from '../module/renderer/update/types.ts';
-import * as React from "react";
-export type Props<M extends ModuleDefinition> = {
-    module: ViewArgs<M>;
-    model: UseModel;
-    dispatchers: UseDispatchers;
-    update: UseUpdate;
-    children(): React.ReactNode;
-};

package/dist/errors/utils.d.ts

@@ -1,30 +0,0 @@
-import { ModuleDefinition } from '../types/index.ts';
-import { Props } from './types.ts';
-/**
- *  Check if the error is an instance of TypedError.
- *
- * @param error {Error | TypedError}
- * @returns {boolean}
- */
-export declare function isTypedError(error: Error | TypedError): error is TypedError;
-/**
- * Convert an unknown error into a known error type.
- *
- * @function intoError
- * @param error {unknown} - The error to convert to a known error type.
- * @returns {Error | TypedError}
- */
-export declare function intoError(error: unknown): Error | TypedError;
-/**
- * @class TypedError
- * @extends Error
- * @param type {string} - The type of the error.
- * @param message {string} - The error message.
- */
-export declare class TypedError extends Error {
-    #private;
-    constructor(type: number | string | symbol, message?: null | string);
-    get type(): number | string | symbol;
-    get message(): string;
-}
-export declare function Child<M extends ModuleDefinition>({ children, }: Pick<Props<M>, "children">): React.ReactNode;

package/dist/module/index.d.ts

@@ -1,4 +0,0 @@
-import { ModuleDefinition } from '../types/index.ts';
-import { UseOptions } from './types.ts';
-import * as React from "react";
-export default function Scope<M extends ModuleDefinition>(options: UseOptions<M>): React.ReactNode;

package/dist/module/renderer/actions/index.d.ts

@@ -1,3 +0,0 @@
-import { ModuleDefinition } from '../../../types/index.ts';
-import { Props, UseActions } from './types.ts';
-export default function useActions<M extends ModuleDefinition>(props: Props<M>): UseActions<M>;

package/dist/module/renderer/actions/types.d.ts

@@ -1,19 +0,0 @@
-import { UseBroadcast } from '../../../broadcast/types.ts';
-import { UseContext } from '../../../context/types.ts';
-import { ControllerArgs } from '../../../controller/types.ts';
-import { ModuleDefinition } from '../../../types/index.ts';
-import { ViewArgs } from '../../../view/types.ts';
-import { UseOptions } from '../../types.ts';
-import { UseDispatchers } from '../dispatchers/types.ts';
-import { UseModel } from '../model/types.ts';
-export type Props<M extends ModuleDefinition> = {
-    broadcast: UseBroadcast;
-    options: UseOptions<M>;
-    model: UseModel;
-    dispatchers: UseDispatchers;
-    context: UseContext;
-};
-export type UseActions<M extends ModuleDefinition> = {
-    controller: ControllerArgs<M>;
-    view: ViewArgs<M>;
-};

package/dist/module/renderer/controller/index.d.ts

@@ -1,4 +0,0 @@
-import { ModuleDefinition } from '../../../types/index.ts';
-import { Props } from './types.ts';
-import { ControllerInstance } from '../../../controller/types.ts';
-export default function useController<M extends ModuleDefinition>(props: Props<M>): ControllerInstance<M> | undefined;

package/dist/module/renderer/controller/types.d.ts

@@ -1,11 +0,0 @@
-import { ModuleDefinition } from '../../../types/index.ts';
-import { UseOptions } from '../../types.ts';
-import { UseActions } from '../actions/types.ts';
-import { UseDispatchers } from '../dispatchers/types.ts';
-import { default as useController } from './index.ts';
-export type Props<M extends ModuleDefinition> = {
-    actions: UseActions<M>;
-    options: UseOptions<M>;
-    dispatchers: UseDispatchers;
-};
-export type UseController = ReturnType<typeof useController>;

package/dist/module/renderer/dispatchers/index.d.ts

@@ -1,12 +0,0 @@
-import { ActionEvent } from '../../../controller/types.ts';
-import { ModuleDefinition, Task } from '../../../types/index.ts';
-import { Head, Tail } from '../types.ts';
-import { Props } from './types.ts';
-/**
- * @param props {Props<M>}
- * @returns { attach: (action: Head<M["Actions"]>, ƒ: F) => void; dispatch: (action: Head<M["Actions"]>, data: Tail<M["Actions"]>) => void; }
- */
-export default function useDispatchers<M extends ModuleDefinition>(props: Props<M>): {
-    attach<F extends ActionEvent<M>>(action: Head<M["Actions"]>, ƒ: F): void;
-    dispatch(action: Head<M["Actions"]>, data: Tail<M["Actions"]>, task?: Task): void;
-};

package/dist/module/renderer/dispatchers/types.d.ts

@@ -1,18 +0,0 @@
-import { default as EventEmitter } from 'eventemitter3';
-import { UseBroadcast } from '../../../broadcast/types.ts';
-import { ModuleDefinition } from '../../../types/index.ts';
-import { UseOptions } from '../../types.ts';
-import { UseModel } from '../model/types.ts';
-import { UseUpdate } from '../update/types.ts';
-import { default as useDispatchers } from './index.ts';
-export type Props<M extends ModuleDefinition> = {
-    broadcast: UseBroadcast;
-    options: UseOptions<M>;
-    update: UseUpdate;
-    model: UseModel;
-};
-export type UseDispatchers = ReturnType<typeof useDispatchers>;
-export type UseDispatchHandlerProps<M extends ModuleDefinition> = Props<M> & {
-    unicast: EventEmitter;
-};
-export type Fn = (...args: any[]) => void;

package/dist/module/renderer/dispatchers/utils.d.ts

@@ -1,10 +0,0 @@
-import { ActionEvent } from '../../../controller/types.ts';
-import { ModuleDefinition, Task } from '../../../types/index.ts';
-import { Head, Tail } from '../types.ts';
-import { UseDispatchHandlerProps } from './types.ts';
-/**
- * @function useDispatcher
- * @param props {UseDispatchHandlerProps<M>}
- * @returns {(name: Head<M["Actions"]>, ƒ: GeneratorFn<M>) => (payload: Tail<M["Actions"]>) => Promise<void>}
- */
-export declare function useDispatcher<M extends ModuleDefinition>(props: UseDispatchHandlerProps<M>): (_name: Head<M["Actions"]>, ƒ: ActionEvent<M>) => (task: Task | undefined, payload: Tail<M["Actions"]>) => Promise<void>;

package/dist/module/renderer/elements/index.d.ts

@@ -1,4 +0,0 @@
-import * as React from "react";
-export default function useElements(): {
-    customElement: React.RefObject<HTMLElement | null>;
-};

package/dist/module/renderer/elements/types.d.ts

@@ -1,2 +0,0 @@
-import { default as useElements } from './index.ts';
-export type UseElements = ReturnType<typeof useElements>;

package/dist/module/renderer/elements/utils.d.ts

@@ -1,4 +0,0 @@
-/**
- * @returns {string}
- */
-export declare function useCacheKey(): string;

package/dist/module/renderer/index.d.ts

@@ -1,4 +0,0 @@
-import { ModuleDefinition } from '../../types/index.ts';
-import { Props } from './types.ts';
-import * as React from "react";
-export default function Renderer<M extends ModuleDefinition>({ options, }: Props<M>): React.ReactNode;

package/dist/module/renderer/lifecycles/index.d.ts

@@ -1,3 +0,0 @@
-import { ModuleDefinition } from '../../../types/index.ts';
-import { Props } from './types.ts';
-export default function useLifecycles<M extends ModuleDefinition>(props: Props<M>): void;