@ai-matrx/summon 0.1.7 → 0.1.9

package/dist/react.d.ts

@@ -1,25 +1,12 @@
 import * as react from 'react';
-import { ComponentType, ReactNode, JSXElementConstructor, Component, ErrorInfo } from 'react';
-import * as _reduxjs_toolkit from '@reduxjs/toolkit';
-import { Store, Dispatch, UnknownAction } from '@reduxjs/toolkit';
-import { SummonPorts, SummonRootState, OverlayRawData, InstanceKey, AnyOverlayMeta, OverlayDefinitionMeta, OverlayId, OverlayDataOf, ErrorSinkPort } from '@ai-matrx/summon';
-import { ReactReduxContextValue, UseDispatch, UseSelector, UseStore } from 'react-redux';
+import { ReactNode, ComponentType, JSXElementConstructor, Component, ErrorInfo } from 'react';
+import { Store } from '@reduxjs/toolkit';
+import { SummonPorts, OverlayId, OverlayDataOf, ErrorSinkPort } from '@ai-matrx/summon';
+import { OverlayErrorExtrasContext, OverlayRenderContext, HostableOverlay, OverlayHandle } from '@ai-matrx/summon/root';
+export { CALLBACK_GROUP_KEY, HostableOverlay, OverlayControllerProps, OverlayDefinition, OverlayEmitter, OverlayErrorExtrasContext, OverlayEventMap, OverlayHandle, OverlayHandlers, OverlayInstanceContextValue, OverlayOpenOptions, OverlayOpener, OverlayRenderContext, OverlaySpec, SummonHostConfig, SummonReactDispatch, SummonReactStore, SummonRoot, SummonRootProps, SummonStoreContext, configureSummonHost, defineOverlay, useOptionalOverlayInstance, useOptionalSummonPorts, useOptionalSummonStore, useOverlayInstance, useSummonDispatch, useSummonPorts, useSummonSelector, useSummonStore } from '@ai-matrx/summon/root';
+import { O as OverlayRenderProps } from './instanceBody-CgZAFnic.js';
+export { R as RenderLoader, a as RenderModule, c as chunkTimeoutError } from './instanceBody-CgZAFnic.js';
 
-interface RenderModule<P> {
-    readonly default: ComponentType<P>;
-}
-type RenderLoader<P> = () => Promise<RenderModule<P>>;
-/** The error a stalled import becomes, so the error boundary always fires. */
-declare function chunkTimeoutError(key: string, timeoutMs: number): Error;
-
-declare const SummonStoreContext: react.Context<ReactReduxContextValue<any, _reduxjs_toolkit.UnknownAction> | null>;
-/** What every slot hands to `renderWrapper`, error extras and the fallbacks. */
-interface OverlayRenderContext {
-    readonly overlayId: string;
-    readonly instanceId: string;
-    readonly instanceKey: string;
-    readonly label: string;
-}
 interface OverlayLoadingFallbackProps {
     readonly overlayId: string;
     readonly label: string;
@@ -37,14 +24,11 @@ interface OverlayErrorFallbackProps {
     /** Host-provided extras (AI Matrx: "Copy for AI"), already rendered for this error. */
     readonly extras: ReactNode;
 }
-interface OverlayErrorExtrasContext extends OverlayRenderContext {
-    readonly error: unknown;
-    readonly componentStack: string | null;
-}
 
 declare const DEFAULT_KEEP_ALIVE_LIMIT = 8;
 declare const DEFAULT_IMPORT_TIMEOUT_MS = 12000;
 declare const DEFAULT_STALL_WARN_MS = 10000;
+
 interface SummonProviderProps {
     /** The host's Redux store with `summonReducers` mounted at their root keys. Omit for a private store. */
     readonly store?: Store<unknown>;
@@ -68,119 +52,8 @@ interface SummonProviderProps {
 }
 declare function SummonProvider({ store, ports, fallbacks, errorReportExtras, renderWrapper, keepAliveLimit, importTimeoutMs, stallWarnMs, children, }: SummonProviderProps): react.JSX.Element;
 
-/** Dispatch as the React section uses it: plain actions (thunks are the host's business). */
-type SummonReactDispatch = Dispatch<UnknownAction>;
-/** The store as the React section sees it: the overlays slices at their root keys (a host store has more). */
-type SummonReactStore = Store<SummonRootState>;
-/** Select from the overlays store. */
-declare const useSummonSelector: UseSelector<SummonRootState>;
-/** The overlays store's dispatch. */
-declare const useSummonDispatch: UseDispatch<SummonReactDispatch>;
-/** The overlays store itself (for `getState()` inside callbacks). */
-declare const useSummonStore: UseStore<SummonReactStore>;
-/** The resolved ports of the nearest provider. */
-declare function useSummonPorts(): SummonPorts;
-/**
- * The provider's ports, or the working defaults when no SummonProvider is above — for
- * components that are usable page-local without the system (dialogs, sheets).
- */
-declare function useOptionalSummonPorts(): SummonPorts;
-/**
- * The nearest provider's store, or `null` when no SummonProvider is above — for packages that
- * mount their own provider only when the host has none (chat's windows on a bare host).
- */
-declare function useOptionalSummonStore(): SummonReactStore | null;
-
-/** Event name → payload, declared once per overlay: `defineOverlay<Data, { uploaded: Result }>()`. */
-type OverlayEventMap = Record<string, unknown>;
-type OverlayHandlers<Events extends OverlayEventMap> = {
-    readonly [K in keyof Events]?: (payload: Events[K]) => void;
-};
-
-/** The props every overlay's render module receives. */
-interface OverlayRenderProps<Data = OverlayRawData> {
-    readonly overlayId: string;
-    readonly instanceId: string;
-    /** The open data: raw (narrow it yourself) unless the definition declares `parse`. */
-    readonly data: Data;
-    readonly isOpen: true;
-    readonly close: () => void;
-    /** True while kept alive behind a close (`keepAlive: "hidden"`). */
-    readonly hidden: boolean;
-}
-/** What the host hands each instance — no data type, by design. */
-interface InstanceBodyProps {
-    readonly instanceId: string;
-    readonly instanceKey: InstanceKey;
-    readonly data: OverlayRawData;
-    readonly hidden: boolean;
-    readonly close: () => void;
-}
-
-/** The open-data key that carries an overlay's event channel id (the old callback-group key). */
-declare const CALLBACK_GROUP_KEY = "callbackGroupId";
-interface OverlayHandle {
-    readonly overlayId: string;
-    readonly instanceId: string;
-    close(): void;
-}
-interface OverlayOpenOptions<Data, Events extends OverlayEventMap> {
-    readonly data?: Data;
-    /** Single-instance overlays ignore it unless given; multi-instance generate one when omitted. */
-    readonly instanceId?: string;
-    /** Plain functions; they reach the caller through an event channel owned by the instance. */
-    readonly handlers?: OverlayHandlers<Events>;
-}
-type OverlayOpener<Data, Events extends OverlayEventMap> = (options?: OverlayOpenOptions<Data, Events>) => OverlayHandle;
-type OverlayControllerProps<Data, Events extends OverlayEventMap> = Data & {
-    readonly instanceId?: string;
-    readonly handlers?: OverlayHandlers<Events>;
-};
-type OverlayEmitter<Events extends OverlayEventMap> = <K extends keyof Events & string>(event: K, payload: Events[K]) => void;
-/** What a definition file passes to `defineOverlay<Data>()(…)`. */
-interface OverlaySpec<Id extends string, Data, Parsed> extends OverlayDefinitionMeta<Id, Data> {
-    /**
-     * The lazily loaded render module. Its default export receives `OverlayRenderProps<Parsed>`.
-     * Optional: a large app leaves it out and hands `<SummonHost renders={…}>` one id → import map,
-     * so files that import a definition for its opener never gain an import() edge to the window
-     * (the host-build law). When present it wins over the host map.
-     */
-    readonly render?: () => Promise<RenderModule<OverlayRenderProps<NoInfer<Parsed>>>>;
-    /** Narrow raw open data once. `null` = refuse: the instance is closed with a warning. */
-    readonly parse?: (raw: OverlayRawData) => Parsed | null;
-}
-/** The type-erased half the host renders; no data types cross this line. */
-interface HostableOverlay {
-    readonly id: string;
-    readonly label: string;
-    readonly instance: "single" | "multi";
-    readonly keepAlive: "none" | "hidden" | "restore";
-    /** The metadata the core registry stores (links, window options, defaults…). */
-    readonly meta: AnyOverlayMeta;
-    readonly Body: ComponentType<InstanceBodyProps>;
-}
-interface OverlayDefinition<Id extends string, Data, Parsed, Events extends OverlayEventMap> extends Omit<OverlayDefinitionMeta<Id, Data>, "id" | "instance" | "keepAlive">, HostableOverlay {
-    readonly id: Id;
-    readonly render?: () => Promise<RenderModule<OverlayRenderProps<Parsed>>>;
-    /** Imperative opener: `const open = def.useSummon(); open({ data })` → handle. */
-    useSummon(): OverlayOpener<Data, Events>;
-    /** Declarative form: opens on mount, closes on unmount, re-opens when its data changes. */
-    readonly Controller: (props: OverlayControllerProps<Data, Events>) => null;
-    useIsOpen(instanceId?: string): boolean;
-    /** `const close = def.useClose(); close(instanceId?)`. */
-    useClose(): (instanceId?: string) => void;
-    /** Inside the render tree: emit a declared event to the opener's handlers. */
-    useEmit(): OverlayEmitter<Events>;
-}
-/**
- * Declare an overlay once. Curried so `Data` (and `Events`) are named while the id and the
- * parsed-data type are inferred:
- *
- *   export const notesWindow = defineOverlay<NotesWindowData>()({
- *     id: "notesWindow", label: "Notes", render: () => import("./notesWindow.render"),
- *   });
- */
-declare function defineOverlay<Data extends object = Record<string, never>, Events extends OverlayEventMap = Record<never, never>>(): <const Id extends string, Parsed = OverlayRawData>(spec: OverlaySpec<Id, Data, Parsed>) => OverlayDefinition<Id, Data, Parsed, Events>;
+/** Deliver one event on a channel; a disposed or unknown channel is a silent no-op by contract. */
+declare function emitOverlayEvent(channelId: string, type: string, payload: unknown): void;
 
 /**
  * One overlay's loader with its data type erased. `never` data accepts every render component
@@ -209,19 +82,6 @@ interface SummonHostProps {
 declare function useCloseOnNavigation(): void;
 declare function SummonHost({ definitions, renders }: SummonHostProps): react.JSX.Element;
 
-interface OverlayInstanceContextValue {
-    readonly overlayId: string;
-    readonly instanceId: string;
-    readonly instanceKey: InstanceKey;
-    readonly close: () => void;
-    readonly hidden: boolean;
-    /** The open data as it arrived (pre-parse); event emitters read their channel id from it. */
-    readonly rawData: OverlayRawData;
-}
-/** The open instance this component renders inside. Throws outside an overlay. */
-declare function useOverlayInstance(): OverlayInstanceContextValue;
-/** Same as `useOverlayInstance`, but `null` outside an overlay. */
-declare function useOptionalOverlayInstance(): OverlayInstanceContextValue | null;
 type OverlayStateSetter<T> = (next: T | ((previous: T) => T)) => void;
 /**
  * Saved state for the current overlay instance — `useState`, but kept in the overlays store under
@@ -294,4 +154,4 @@ declare function OverlayLoadingFallback({ overlayId, label }: OverlayLoadingFall
 /** The error card: what failed, and a way out that never needs a page reload. */
 declare function OverlayErrorFallback({ label, error, retry, close, extras }: OverlayErrorFallbackProps): react.JSX.Element;
 
-export { CALLBACK_GROUP_KEY, DEFAULT_IMPORT_TIMEOUT_MS, DEFAULT_KEEP_ALIVE_LIMIT, DEFAULT_STALL_WARN_MS, type ErasedRenderLoader, type HostableOverlay, MISSING_RENDER_ERROR, type NormalizedOverlayError, type OpenOverlayOptions, type OverlayControllerProps, type OverlayDefinition, type OverlayEmitter, OverlayErrorBoundary, type OverlayErrorBoundaryProps, type OverlayErrorExtrasContext, OverlayErrorFallback, type OverlayErrorFallbackProps, type OverlayEventMap, type OverlayHandle, type OverlayHandlers, type OverlayInstanceContextValue, OverlayLoadingFallback, type OverlayLoadingFallbackProps, type OverlayOpenOptions, type OverlayOpener, type OverlayRenderContext, type OverlayRenderMap, type OverlayRenderProps, type OverlaySpec, type OverlayStateSetter, type RenderLoader, type RenderModule, SummonHost, type SummonHostProps, SummonProvider, type SummonProviderProps, type SummonReactDispatch, type SummonReactStore, SummonStoreContext, chunkTimeoutError, defineOverlay, normalizeOverlayError, useCloseOnNavigation, useCloseOverlay, useIsOverlayOpen, useOpenOverlay, useOptionalOverlayInstance, useOptionalSummonPorts, useOptionalSummonStore, useOverlayInstance, useOverlayLink, useOverlayState, useSummonDispatch, useSummonPorts, useSummonSelector, useSummonStore };
+export { DEFAULT_IMPORT_TIMEOUT_MS, DEFAULT_KEEP_ALIVE_LIMIT, DEFAULT_STALL_WARN_MS, type ErasedRenderLoader, MISSING_RENDER_ERROR, type NormalizedOverlayError, type OpenOverlayOptions, OverlayErrorBoundary, type OverlayErrorBoundaryProps, OverlayErrorFallback, type OverlayErrorFallbackProps, OverlayLoadingFallback, type OverlayLoadingFallbackProps, type OverlayRenderMap, OverlayRenderProps, type OverlayStateSetter, SummonHost, type SummonHostProps, SummonProvider, type SummonProviderProps, emitOverlayEvent, normalizeOverlayError, useCloseOnNavigation, useCloseOverlay, useIsOverlayOpen, useOpenOverlay, useOverlayLink, useOverlayState };