chizu 0.4.0 → 0.5.0

package/dist/boundary/components/scope/index.d.ts

@@ -1,82 +0,0 @@
-import { Props } from './types.ts';
-import { ComponentType, ReactNode } from 'react';
-import * as React from "react";
-export { useScope, getScope } from './utils.ts';
-export type { ScopeEntry, ScopeContext } from './types.ts';
-/**
- * Creates a named scope boundary for multicast actions.
- *
- * Components within a `<Scope>` can dispatch multicast actions to all other
- * components within the same scope boundary. This is useful for creating
- * isolated groups of components that need to communicate without affecting
- * other parts of the application.
- *
- * Multiple scopes can be nested, and each scope name creates its own
- * communication channel. When dispatching, the nearest ancestor scope
- * with the matching name receives the event.
- *
- * Like Broadcast, multicast caches the most recent dispatched value so that
- * late-mounted components can read it via `context.actions.resolution()`.
- *
- * @param props.of - The scope name. Typically a `static Scope` literal co-located with the feature's multicast actions.
- * @param props.children - Components within the scope boundary.
- *
- * @example
- * ```tsx
- * class UserListActions {
- *   static Scope = "UserList" as const;
- *   static FilterChanged = Action<Filter>("FilterChanged", Distribution.Multicast);
- * }
- *
- * <Scope of={UserListActions.Scope}>
- *   <UserFilter />
- *   <UserTable />
- * </Scope>
- *
- * // Dispatch reaches every component in the UserList scope:
- * actions.dispatch(Actions.Multicast.FilterChanged, filter, { scope: Actions.Multicast.Scope });
- * ```
- *
- * @example
- * ```tsx
- * // Nested scopes - each class carries its own scope name
- * <Scope of={AppActions.Scope}>
- *   <Header />
- *   <Scope of={SidebarActions.Scope}>
- *     <SidebarItem />
- *   </Scope>
- *   <Scope of={ContentActions.Scope}>
- *     <ContentItem />
- *   </Scope>
- * </Scope>
- * ```
- */
-export declare function Scope({ of: name, children }: Props): React.ReactNode;
-/**
- * Higher-order component that wraps a component in a multicast `<Scope>`.
- *
- * Eliminates the need to manually wrap component output in `<Scope of={...}>`,
- * keeping the component body focused on its own rendering logic.
- *
- * @param scope - The scope name. Typically a `static Scope` literal co-located with the feature's multicast actions.
- * @param Component - The component to wrap.
- * @returns A new component that renders the original within a `<Scope>`.
- *
- * @example
- * ```tsx
- * class MulticastActions {
- *   static Scope = "payment-link" as const;
- *   static Update = Action<User>("Update", Distribution.Multicast);
- * }
- *
- * export default withScope(MulticastActions.Scope, function Layout(): ReactElement {
- *   return (
- *     <div>
- *       <Sidebar />
- *       <Content />
- *     </div>
- *   );
- * });
- * ```
- */
-export declare function withScope<P extends object>(scope: string, Component: ComponentType<P>): (props: P) => ReactNode;

package/dist/boundary/components/scope/types.d.ts

@@ -1,28 +0,0 @@
-import { BroadcastEmitter } from '../broadcast/utils.ts';
-import type * as React from "react";
-/**
- * Props for the Scope component.
- */
-export type Props = {
-    /** The scope name. Typically a `static Scope` literal co-located with the feature's multicast action declarations. */
-    of: string;
-    /** Children to render within the scope boundary. */
-    children: React.ReactNode;
-};
-/**
- * Represents a single scope in the ancestor chain.
- * Each scope has its own BroadcastEmitter for multicast events and caching.
- */
-export type ScopeEntry = {
-    /** The name of this scope */
-    name: string;
-    /** BroadcastEmitter for multicast events within this scope (caches last payload per event) */
-    emitter: BroadcastEmitter;
-};
-/**
- * The scope context is a flattened map of all ancestor scopes by name.
- * Each <Scope> merges its entry with the parent's map, building up a
- * complete lookup table for O(1) retrieval.
- * null indicates no scope ancestor.
- */
-export type ScopeContext = Map<string, ScopeEntry> | null;

package/dist/error/index.d.ts

@@ -1,2 +0,0 @@
-export { Reason, AbortError, TimeoutError, DisallowedError } from './types';
-export type { Fault } from './types';