@maxal_studio/kratosjs-react 1.0.0

package/dist/components/widgets/WidgetRenderer.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface WidgetRendererProps {
+    widgets?: any[];
+    widgetData?: Record<string, any>;
+    className?: string;
+    /** When set, controlled mode: no internal toggle, use this value and callback */
+    expanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+}
+export declare function WidgetRenderer({ widgets, widgetData, className, expanded: controlledExpanded, onExpandedChange, }: WidgetRendererProps): React.JSX.Element;

package/dist/components/widgets/WidgetRenderer.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState, useEffect } from 'react';
+import { ChevronDown, ChevronUp } from 'lucide-react';
+import { useWidgetRegistry } from '../../contexts/WidgetRegistryContext';
+import { ErrorBoundary } from '../errors/ErrorBoundary';
+import { Slot } from '../../slots/Slot';
+import { cn } from '../../utils/classNames';
+import { widgetVisibilityStorage, getDefaultWidgetsExpanded } from '../../utils/widgetVisibilityStorage';
+import { PillButton } from '../ui/PillButton';
+import { translate } from '../../i18n/activeLocale';
+export function WidgetRenderer({ widgets, widgetData, className, expanded: controlledExpanded, onExpandedChange, }) {
+    const widgetRegistry = useWidgetRegistry();
+    const [internalExpanded, setInternalExpanded] = useState(false);
+    const isControlled = controlledExpanded !== undefined && onExpandedChange !== undefined;
+    const expanded = isControlled ? controlledExpanded : internalExpanded;
+    useEffect(() => {
+        if (isControlled)
+            return;
+        const stored = widgetVisibilityStorage.get();
+        if (stored !== null) {
+            setInternalExpanded(stored);
+        }
+        else {
+            setInternalExpanded(getDefaultWidgetsExpanded());
+        }
+    }, [isControlled]);
+    const toggleExpanded = () => {
+        const next = !expanded;
+        if (isControlled) {
+            widgetVisibilityStorage.set(next);
+            onExpandedChange(next);
+        }
+        else {
+            setInternalExpanded(next);
+            widgetVisibilityStorage.set(next);
+        }
+    };
+    if (!widgets || widgets.length === 0) {
+        return null;
+    }
+    return (_jsxs("div", { className: cn('mb-4', className), children: [!isControlled && (_jsx("div", { className: "mb-2 flex justify-end", children: _jsx(PillButton, { variant: "default", onClick: toggleExpanded, "aria-expanded": expanded, "aria-controls": "widgets-content", id: "widgets-toggle", icon: expanded ? _jsx(ChevronUp, { className: "h-4 w-4" }) : _jsx(ChevronDown, { className: "h-4 w-4" }), children: translate('core:common.widgets') }) })), _jsx("div", { id: "widgets-content", role: "region", "aria-labelledby": "widgets-toggle", className: cn('overflow-hidden transition-[grid-template-rows] duration-200 ease-out', expanded ? 'grid-rows-[1fr]' : 'grid-rows-[0fr]'), style: { display: 'grid' }, children: _jsx("div", { className: "min-h-0", children: _jsxs("div", { className: "grid grid-cols-1 gap-3 sm:grid-cols-2 xl:grid-cols-3 2xl:grid-cols-4", children: [widgets.map(widget => {
+                                const WidgetComponent = widgetRegistry[widget.type];
+                                if (!WidgetComponent) {
+                                    console.warn(`Widget type "${widget.type}" not registered`);
+                                    return null;
+                                }
+                                const data = widgetData?.[widget.name] ?? null;
+                                return (_jsx("div", { className: "min-w-0", children: _jsx(ErrorBoundary, { label: `widget "${widget.name}"`, children: _jsx(WidgetComponent, { widget: widget, data: data }) }) }, widget.name));
+                            }), _jsx(Slot, { name: "widgets.append" })] }) }) })] }));
+}

package/dist/components/widgets/WidgetShell.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export interface WidgetShellProps {
+    label?: string;
+    icon?: string;
+    className?: string;
+    children: React.ReactNode;
+}
+/** Shared card shell for dashboard/table widgets. */
+export declare function WidgetShell({ label, icon, className, children }: WidgetShellProps): React.JSX.Element;

package/dist/components/widgets/WidgetShell.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Icon } from '../utils/Icon';
+import { cn } from '../../utils/classNames';
+/** Shared card shell for dashboard/table widgets. */
+export function WidgetShell({ label, icon, className, children }) {
+    return (_jsxs("div", { className: cn('flex min-h-[8.5rem] flex-col rounded-xl border border-border bg-surface p-4 transition-colors hover:bg-hover/20', className), children: [(label || icon) && (_jsxs("div", { className: "mb-3 flex items-start justify-between gap-2", children: [label ? (_jsx("p", { className: "text-[11px] font-medium uppercase tracking-wider text-fg-muted", children: label })) : (_jsx("span", {})), icon && (_jsx("div", { className: "flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-raised text-fg-secondary shadow-soft-sm", children: _jsx(Icon, { name: icon, className: "h-4 w-4" }) }))] })), _jsx("div", { className: "flex min-h-0 flex-1 flex-col", children: children })] }));
+}

package/dist/contexts/AuthChallengeRegistryContext.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import type { AuthChallengeComponent } from '../auth/types';
+export type AuthChallengeRegistry = Record<string, AuthChallengeComponent>;
+export declare const AuthChallengeRegistryContext: React.Context<Record<string, AuthChallengeComponent>>;
+export declare const useAuthChallengeRegistry: () => Record<string, AuthChallengeComponent>;
+export interface AuthChallengeRegistryProviderProps {
+    customAuthChallenges?: AuthChallengeRegistry;
+    children: React.ReactNode;
+}
+/**
+ * Provider for challenge UI components keyed by challenge `type`. Lives above the auth gate
+ * so the LoginPage (rendered when there is no user) can look up the component for a pending
+ * challenge.
+ */
+export declare function AuthChallengeRegistryProvider({ customAuthChallenges, children, }: AuthChallengeRegistryProviderProps): React.JSX.Element;

package/dist/contexts/AuthChallengeRegistryContext.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createRegistryContext } from './createRegistryContext';
+// No built-in challenge UIs: challenge components are entirely plugin-provided
+// (e.g. the 2FA plugin registers a '2fa-totp' component).
+const registry = createRegistryContext('AuthChallengeRegistry', {});
+export const AuthChallengeRegistryContext = registry.Context;
+export const useAuthChallengeRegistry = registry.useRegistry;
+/**
+ * Provider for challenge UI components keyed by challenge `type`. Lives above the auth gate
+ * so the LoginPage (rendered when there is no user) can look up the component for a pending
+ * challenge.
+ */
+export function AuthChallengeRegistryProvider({ customAuthChallenges = {}, children, }) {
+    return _jsx(registry.Provider, { registry: customAuthChallenges, children: children });
+}

package/dist/contexts/BlockRegistryContext.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+export interface CustomBlockComponentProps {
+    block: any;
+    blockData?: Record<string, any>;
+    apiBaseUrl?: string;
+}
+export type CustomBlockComponent = React.ComponentType<CustomBlockComponentProps>;
+export interface BlockRegistry {
+    [key: string]: CustomBlockComponent;
+}
+interface BlockRegistryProviderProps {
+    children: React.ReactNode;
+    customBlocks?: BlockRegistry;
+}
+export declare function BlockRegistryProvider({ children, customBlocks }: BlockRegistryProviderProps): React.JSX.Element;
+/** Returns the flat block registry (custom page blocks keyed by type). */
+export declare const useBlockRegistry: () => Record<string, CustomBlockComponent>;
+export {};

package/dist/contexts/BlockRegistryContext.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createRegistryContext } from './createRegistryContext';
+const registry = createRegistryContext('BlockRegistry', {});
+export function BlockRegistryProvider({ children, customBlocks }) {
+    return _jsx(registry.Provider, { registry: customBlocks, children: children });
+}
+/** Returns the flat block registry (custom page blocks keyed by type). */
+export const useBlockRegistry = registry.useRegistry;

package/dist/contexts/ColumnRegistryContext.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export type ColumnComponent = React.ComponentType<any>;
+export type ColumnRegistry = Record<string, ColumnComponent>;
+export declare const ColumnRegistryProvider: {
+    ({ registry, children }: import("./createRegistryContext").RegistryProviderProps<ColumnComponent>): React.JSX.Element;
+    displayName: string;
+};
+export declare const useColumnRegistry: () => Record<string, ColumnComponent>;

package/dist/contexts/ColumnRegistryContext.js

@@ -0,0 +1,30 @@
+import { createRegistryContext } from './createRegistryContext';
+import { TextColumnComponent } from '../components/columns/TextColumnComponent';
+import { IconColumnComponent } from '../components/columns/IconColumnComponent';
+import { ImageColumnComponent } from '../components/columns/ImageColumnComponent';
+import { VideoColumnComponent } from '../components/columns/VideoColumnComponent';
+import { MediaColumnComponent } from '../components/columns/MediaColumnComponent';
+import { ColorColumnComponent } from '../components/columns/ColorColumnComponent';
+import { TagsColumnComponent } from '../components/columns/TagsColumnComponent';
+import { ViewColumnComponent } from '../components/columns/ViewColumnComponent';
+import { CheckboxColumnComponent } from '../components/columns/CheckboxColumnComponent';
+import { ToggleColumnComponent } from '../components/columns/ToggleColumnComponent';
+import { SelectColumnComponent } from '../components/columns/SelectColumnComponent';
+import { TextInputColumnComponent } from '../components/columns/TextInputColumnComponent';
+const defaultColumns = {
+    text: TextColumnComponent,
+    icon: IconColumnComponent,
+    image: ImageColumnComponent,
+    video: VideoColumnComponent,
+    media: MediaColumnComponent,
+    color: ColorColumnComponent,
+    tags: TagsColumnComponent,
+    view: ViewColumnComponent,
+    checkbox: CheckboxColumnComponent,
+    toggle: ToggleColumnComponent,
+    select: SelectColumnComponent,
+    textinput: TextInputColumnComponent,
+};
+const registry = createRegistryContext('ColumnRegistry', defaultColumns);
+export const ColumnRegistryProvider = registry.Provider;
+export const useColumnRegistry = registry.useRegistry;

package/dist/contexts/FieldRegistryContext.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { FieldRegistry } from '../types';
+export declare const FieldRegistryContext: React.Context<Record<string, import("../types").FieldComponent>>;
+export declare const useFieldRegistry: () => Record<string, import("../types").FieldComponent>;
+export interface FieldRegistryProviderProps {
+    customFields?: FieldRegistry;
+    children: React.ReactNode;
+}
+/**
+ * Provider component that manages the field registry.
+ * Custom field components (e.g. from plugins) override the built-ins.
+ */
+export declare function FieldRegistryProvider({ customFields, children }: FieldRegistryProviderProps): React.JSX.Element;

package/dist/contexts/FieldRegistryContext.js

@@ -0,0 +1,46 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createRegistryContext } from './createRegistryContext';
+import { TextInputField } from '../components/TextInputField';
+import { SelectField } from '../components/SelectField';
+import { TextareaField } from '../components/TextareaField';
+import { CheckboxField } from '../components/CheckboxField';
+import { ToggleField } from '../components/ToggleField';
+import { RadioField } from '../components/RadioField';
+import { DateTimePickerField } from '../components/DateTimePickerField';
+import { ColorPickerField } from '../components/ColorPickerField';
+import { RepeaterField } from '../components/RepeaterField';
+import { TagsInputField } from '../components/TagsInputField';
+import { HiddenField } from '../components/HiddenField';
+import { FileUploadField } from '../components/FileUploadField';
+import { RichEditorField } from '../components/RichEditorField';
+import { SectionField } from '../components/SectionField';
+import { GroupField } from '../components/GroupField';
+import { TabsField } from '../components/TabsField';
+const defaultFields = {
+    'text-input': TextInputField,
+    select: SelectField,
+    textarea: TextareaField,
+    checkbox: CheckboxField,
+    toggle: ToggleField,
+    radio: RadioField,
+    'date-time-picker': DateTimePickerField,
+    'color-picker': ColorPickerField,
+    repeater: RepeaterField,
+    'tags-input': TagsInputField,
+    hidden: HiddenField,
+    fileUpload: FileUploadField,
+    richEditor: RichEditorField,
+    section: SectionField,
+    group: GroupField,
+    tabs: TabsField,
+};
+const registry = createRegistryContext('FieldRegistry', defaultFields);
+export const FieldRegistryContext = registry.Context;
+export const useFieldRegistry = registry.useRegistry;
+/**
+ * Provider component that manages the field registry.
+ * Custom field components (e.g. from plugins) override the built-ins.
+ */
+export function FieldRegistryProvider({ customFields = {}, children }) {
+    return _jsx(registry.Provider, { registry: customFields, children: children });
+}

package/dist/contexts/PanelMetadataContext.d.ts

@@ -0,0 +1,26 @@
+import React, { ReactNode } from 'react';
+import type { ResourceMetadata } from '../components/layout/Sidebar';
+export interface PageMetadata {
+    slug: string;
+    label: string;
+    icon?: string;
+    navigationGroup?: string;
+    navigationSort?: number;
+    hidden?: boolean;
+    badge?: string | number | null;
+    badgeColor?: string;
+}
+interface PanelMetadataContextType {
+    resources: ResourceMetadata[];
+    pages: PageMetadata[];
+    getResourceLabel: (slug: string) => string | undefined;
+    getPageLabel: (slug: string) => string | undefined;
+}
+export interface PanelMetadataProviderProps {
+    children: ReactNode;
+    resources: ResourceMetadata[];
+    pages: PageMetadata[];
+}
+export declare function PanelMetadataProvider({ children, resources, pages }: PanelMetadataProviderProps): React.JSX.Element;
+export declare function usePanelMetadata(): PanelMetadataContextType;
+export {};

package/dist/contexts/PanelMetadataContext.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from 'react';
+const PanelMetadataContext = createContext(undefined);
+export function PanelMetadataProvider({ children, resources, pages }) {
+    const getResourceLabel = (slug) => {
+        const resource = resources.find(r => r.slug === slug);
+        return resource?.label;
+    };
+    const getPageLabel = (slug) => {
+        const page = pages.find(p => p.slug === slug);
+        return page?.label;
+    };
+    return (_jsx(PanelMetadataContext.Provider, { value: {
+            resources,
+            pages,
+            getResourceLabel,
+            getPageLabel,
+        }, children: children }));
+}
+export function usePanelMetadata() {
+    const context = useContext(PanelMetadataContext);
+    if (!context) {
+        throw new Error('usePanelMetadata must be used within PanelMetadataProvider');
+    }
+    return context;
+}

package/dist/contexts/PanelProviders.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import { BlockRegistry } from './BlockRegistryContext';
+import { WidgetRegistry } from './WidgetRegistryContext';
+import { ColumnRegistry } from './ColumnRegistryContext';
+import { AuthChallengeRegistry } from './AuthChallengeRegistryContext';
+import type { ResolvedSlots } from '../slots/types';
+import type { ClientI18nConfig } from '../i18n/buildClientI18n';
+import { FieldRegistry } from '../types';
+export interface PanelProvidersProps {
+    apiBaseUrl: string;
+    customFields?: FieldRegistry;
+    customColumns?: ColumnRegistry;
+    customWidgets?: WidgetRegistry;
+    customBlocks?: BlockRegistry;
+    customAuthChallenges?: AuthChallengeRegistry;
+    customSlots?: ResolvedSlots;
+    i18nConfig?: ClientI18nConfig;
+    children: React.ReactNode;
+}
+/**
+ * Composes the auth gate and every panel-level provider (modal stack,
+ * table refresh, and the component registries) in one place.
+ *
+ * The auth-challenge registry wraps the auth gate so the LoginPage — rendered by
+ * ProtectedRoute when there is no user — can resolve the component for a pending challenge.
+ */
+export declare function PanelProviders({ apiBaseUrl, customFields, customColumns, customWidgets, customBlocks, customAuthChallenges, customSlots, i18nConfig, children, }: PanelProvidersProps): React.JSX.Element;

package/dist/contexts/PanelProviders.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { AuthProvider } from '../auth/AuthContext';
+import { ProtectedRoute } from '../auth/ProtectedRoute';
+import { ResourceModalProvider } from './ResourceModalContext';
+import { TableRefreshProvider } from './TableRefreshContext';
+import { BlockRegistryProvider } from './BlockRegistryContext';
+import { WidgetRegistryProvider } from './WidgetRegistryContext';
+import { FieldRegistryProvider } from './FieldRegistryContext';
+import { ColumnRegistryProvider } from './ColumnRegistryContext';
+import { AuthChallengeRegistryProvider } from './AuthChallengeRegistryContext';
+import { SlotRegistryProvider } from './SlotRegistryContext';
+import { ToastProvider } from '../components/ui/Toast';
+import { ConfirmProvider } from '../components/ui/ConfirmDialog';
+import { I18nProvider } from '../i18n/I18nProvider';
+/**
+ * Composes the auth gate and every panel-level provider (modal stack,
+ * table refresh, and the component registries) in one place.
+ *
+ * The auth-challenge registry wraps the auth gate so the LoginPage — rendered by
+ * ProtectedRoute when there is no user — can resolve the component for a pending challenge.
+ */
+export function PanelProviders({ apiBaseUrl, customFields, customColumns, customWidgets, customBlocks, customAuthChallenges, customSlots, i18nConfig, children, }) {
+    return (_jsx(I18nProvider, { config: i18nConfig, children: _jsx(ToastProvider, { children: _jsx(ConfirmProvider, { children: _jsx(AuthProvider, { apiBaseUrl: apiBaseUrl, children: _jsx(AuthChallengeRegistryProvider, { customAuthChallenges: customAuthChallenges, children: _jsx(SlotRegistryProvider, { slots: customSlots, children: _jsx(ProtectedRoute, { apiBaseUrl: apiBaseUrl, children: _jsx(ResourceModalProvider, { children: _jsx(TableRefreshProvider, { children: _jsx(BlockRegistryProvider, { customBlocks: customBlocks, children: _jsx(WidgetRegistryProvider, { customWidgets: customWidgets, children: _jsx(FieldRegistryProvider, { customFields: customFields, children: _jsx(ColumnRegistryProvider, { registry: customColumns, children: children }) }) }) }) }) }) }) }) }) }) }) }) }));
+}

package/dist/contexts/ResourceModalContext.d.ts

@@ -0,0 +1,26 @@
+import React, { ReactNode } from 'react';
+export interface ModalState {
+    resource: string;
+    recordId?: string;
+    mode: 'view' | 'edit' | 'create' | 'action';
+    depth: number;
+    actionName?: string;
+    actionLabel?: string;
+    originUrl?: string;
+}
+interface ResourceModalContextType {
+    modalStack: ModalState[];
+    modalTitles: Record<string, string>;
+    openModal: (resource: string, mode: 'view' | 'edit' | 'create' | 'action', recordId?: string, actionName?: string, actionLabel?: string, originUrl?: string) => void;
+    closeModal: () => void;
+    closeAllModals: () => void;
+    clearModalsForResource: (resource: string) => void;
+    setModalTitle: (key: string, title: string) => void;
+    removeModalTitle: (key: string) => void;
+    clearModalTitles: () => void;
+}
+export declare function ResourceModalProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useResourceModal(): ResourceModalContextType;
+export {};

package/dist/contexts/ResourceModalContext.js

@@ -0,0 +1,76 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useState, useCallback } from 'react';
+const ResourceModalContext = createContext(undefined);
+export function ResourceModalProvider({ children }) {
+    const [modalStack, setModalStack] = useState([]);
+    const [modalTitles, setModalTitles] = useState({});
+    const openModal = useCallback((resource, mode, recordId, actionName, actionLabel, originUrl) => {
+        setModalStack(prev => {
+            // Check if this exact modal is already at the top of the stack (prevent duplicates)
+            const topModal = prev[prev.length - 1];
+            if (topModal &&
+                topModal.resource === resource &&
+                topModal.recordId === recordId &&
+                topModal.mode === mode &&
+                topModal.actionName === actionName) {
+                // Same modal already at top, don't add duplicate
+                return prev;
+            }
+            // Add new modal to stack with auto-calculated depth
+            const newModal = {
+                resource,
+                recordId,
+                mode,
+                depth: prev.length, // depth = current stack length
+                actionName,
+                actionLabel,
+                originUrl,
+            };
+            return [...prev, newModal];
+        });
+    }, []);
+    const closeModal = useCallback(() => {
+        setModalStack(prev => {
+            if (prev.length === 0)
+                return prev;
+            // Remove last modal from stack (pop)
+            return prev.slice(0, -1);
+        });
+    }, []);
+    const closeAllModals = useCallback(() => {
+        setModalStack([]);
+    }, []);
+    const clearModalsForResource = useCallback((resource) => {
+        setModalStack(prev => prev.filter(modal => modal.resource !== resource));
+    }, []);
+    const setModalTitle = useCallback((key, title) => {
+        setModalTitles(prev => ({ ...prev, [key]: title }));
+    }, []);
+    const removeModalTitle = useCallback((key) => {
+        setModalTitles(prev => {
+            const { [key]: _, ...rest } = prev;
+            return rest;
+        });
+    }, []);
+    const clearModalTitles = useCallback(() => {
+        setModalTitles({});
+    }, []);
+    return (_jsx(ResourceModalContext.Provider, { value: {
+            modalStack,
+            modalTitles,
+            openModal,
+            closeModal,
+            closeAllModals,
+            clearModalsForResource,
+            setModalTitle,
+            removeModalTitle,
+            clearModalTitles,
+        }, children: children }));
+}
+export function useResourceModal() {
+    const context = useContext(ResourceModalContext);
+    if (!context) {
+        throw new Error('useResourceModal must be used within ResourceModalProvider');
+    }
+    return context;
+}

package/dist/contexts/SlotRegistryContext.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import type { SlotContribution, ResolvedSlots, SlotName } from '../slots/types';
+declare const SlotRegistryContext: React.Context<ResolvedSlots>;
+export interface SlotRegistryProviderProps {
+    /** Resolved slot map (already merged across plugins + app). */
+    slots?: ResolvedSlots;
+    children: React.ReactNode;
+}
+/**
+ * Provides the merged slot map to the tree. Slots differ from the component
+ * registries (`createRegistryContext`): they are 1:many and concatenated rather
+ * than overridden, so this provider keeps a sorted array per slot name.
+ */
+export declare function SlotRegistryProvider({ slots, children }: SlotRegistryProviderProps): React.JSX.Element;
+/** Full resolved slot map (for introspection/tests). */
+export declare function useSlotRegistry(): ResolvedSlots;
+/** The sorted contributions for a single slot, or an empty array. */
+export declare function useSlot(name: SlotName): SlotContribution[];
+export { SlotRegistryContext };

package/dist/contexts/SlotRegistryContext.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+import { sortSlots } from '../slots/mergeSlots';
+const SlotRegistryContext = createContext({});
+SlotRegistryContext.displayName = 'SlotRegistry';
+/**
+ * Provides the merged slot map to the tree. Slots differ from the component
+ * registries (`createRegistryContext`): they are 1:many and concatenated rather
+ * than overridden, so this provider keeps a sorted array per slot name.
+ */
+export function SlotRegistryProvider({ slots = {}, children }) {
+    const value = useMemo(() => sortSlots({ ...slots }), [slots]);
+    return _jsx(SlotRegistryContext.Provider, { value: value, children: children });
+}
+/** Full resolved slot map (for introspection/tests). */
+export function useSlotRegistry() {
+    return useContext(SlotRegistryContext);
+}
+/** The sorted contributions for a single slot, or an empty array. */
+export function useSlot(name) {
+    const registry = useContext(SlotRegistryContext);
+    return registry[name] ?? [];
+}
+export { SlotRegistryContext };

package/dist/contexts/TableRefreshContext.d.ts

@@ -0,0 +1,10 @@
+import React, { ReactNode } from 'react';
+interface TableRefreshContextType {
+    refreshTable: (resourceSlug: string) => void;
+    registerRefresh: (resourceSlug: string, callback: () => void) => () => void;
+}
+export declare function TableRefreshProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useTableRefresh(): TableRefreshContextType;
+export {};

package/dist/contexts/TableRefreshContext.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { createContext, useContext, useCallback } from 'react';
+const TableRefreshContext = createContext(undefined);
+export function TableRefreshProvider({ children }) {
+    const refreshCallbacks = React.useRef(new Map());
+    const refreshTable = useCallback((resourceSlug) => {
+        const callback = refreshCallbacks.current.get(resourceSlug);
+        if (callback) {
+            callback();
+        }
+    }, []);
+    const registerRefresh = useCallback((resourceSlug, callback) => {
+        refreshCallbacks.current.set(resourceSlug, callback);
+        return () => {
+            refreshCallbacks.current.delete(resourceSlug);
+        };
+    }, []);
+    return (_jsx(TableRefreshContext.Provider, { value: { refreshTable, registerRefresh }, children: children }));
+}
+export function useTableRefresh() {
+    const context = useContext(TableRefreshContext);
+    if (!context) {
+        // Return no-op functions if context is not available
+        return {
+            refreshTable: () => { },
+            registerRefresh: () => () => { },
+        };
+    }
+    return context;
+}

package/dist/contexts/WidgetRegistryContext.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+export interface WidgetComponentProps {
+    widget: any;
+    data: any;
+}
+export type WidgetComponent = React.ComponentType<WidgetComponentProps>;
+export interface WidgetRegistry {
+    [key: string]: WidgetComponent;
+}
+interface WidgetRegistryProviderProps {
+    children: React.ReactNode;
+    customWidgets?: WidgetRegistry;
+}
+export declare function WidgetRegistryProvider({ children, customWidgets }: WidgetRegistryProviderProps): React.JSX.Element;
+/** Returns the flat widget registry (built-ins merged with custom widgets). */
+export declare const useWidgetRegistry: () => Record<string, WidgetComponent>;
+export {};

package/dist/contexts/WidgetRegistryContext.js

@@ -0,0 +1,14 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createRegistryContext } from './createRegistryContext';
+import { StatsWidget } from '../components/widgets/StatsWidget';
+import { ChartWidget } from '../components/widgets/ChartWidget';
+const builtInWidgets = {
+    stats: StatsWidget,
+    chart: ChartWidget,
+};
+const registry = createRegistryContext('WidgetRegistry', builtInWidgets);
+export function WidgetRegistryProvider({ children, customWidgets }) {
+    return _jsx(registry.Provider, { registry: customWidgets, children: children });
+}
+/** Returns the flat widget registry (built-ins merged with custom widgets). */
+export const useWidgetRegistry = registry.useRegistry;

package/dist/contexts/createRegistryContext.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+export interface RegistryProviderProps<T> {
+    /** Custom entries; merged over the defaults, custom entries win */
+    registry?: Record<string, T>;
+    children: React.ReactNode;
+}
+/**
+ * Factory for component registries (fields, columns, widgets, blocks).
+ * All registries share one pattern: a flat `Record<string, Component>` of
+ * defaults that custom (plugin) entries can extend or override.
+ */
+export declare function createRegistryContext<T>(displayName: string, defaults: Record<string, T>): {
+    Context: React.Context<Record<string, T>>;
+    Provider: {
+        ({ registry, children }: RegistryProviderProps<T>): React.JSX.Element;
+        displayName: string;
+    };
+    useRegistry: () => Record<string, T>;
+};

package/dist/contexts/createRegistryContext.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useMemo } from 'react';
+/**
+ * Factory for component registries (fields, columns, widgets, blocks).
+ * All registries share one pattern: a flat `Record<string, Component>` of
+ * defaults that custom (plugin) entries can extend or override.
+ */
+export function createRegistryContext(displayName, defaults) {
+    const Context = createContext(defaults);
+    Context.displayName = displayName;
+    function Provider({ registry = {}, children }) {
+        const merged = useMemo(() => ({ ...defaults, ...registry }), [registry]);
+        return _jsx(Context.Provider, { value: merged, children: children });
+    }
+    Provider.displayName = `${displayName}Provider`;
+    function useRegistry() {
+        return useContext(Context);
+    }
+    return { Context, Provider, useRegistry };
+}

package/dist/hooks/useAfterStateUpdated.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Hook to execute afterStateUpdated callback when a field's value changes
+ * @param fieldName - Name of the field to watch
+ * @param callbackString - Serialized callback function as string
+ */
+export declare function useAfterStateUpdated(fieldName: string, callbackString?: string): void;