@maxal_studio/kratosjs-react 1.0.0

package/dist/runtime/formTraversal.js

@@ -0,0 +1,37 @@
+/**
+ * Frontend implementation of the declarative children contract (mirrors
+ * `src/utils/formSchemaTraversal`). The core package's
+ * barrel pulls Node-only deps, so we share the *contract* (the serialized
+ * shape), not the module:
+ *   - children live under `schema`
+ *   - `isLayout` marks pure layout containers (no value of their own)
+ *   - `childScope: 'array'` marks item-template containers (Repeater)
+ *
+ * Any component (core or plugin) that follows the contract is traversed
+ * correctly with no type-specific code.
+ */
+/** Direct child components of a node. */
+export function getChildComponents(node) {
+    const schema = node.schema;
+    return Array.isArray(schema) ? schema : [];
+}
+/** A pure layout container (inherits parent value scope, holds no value of its own). */
+export function isLayout(node) {
+    return node.isLayout === true;
+}
+/** Children form an item template whose value lives under the node's own name (Repeater). */
+export function isArrayScope(node) {
+    return node.childScope === 'array';
+}
+/**
+ * Depth-first predicate over a node and all of its descendants. Recursion stops
+ * descending past array-scope containers (their item template is a separate
+ * value scope) — the predicate still sees the container node itself.
+ */
+export function someComponent(node, predicate) {
+    if (predicate(node))
+        return true;
+    if (isArrayScope(node))
+        return false;
+    return getChildComponents(node).some(child => someComponent(child, predicate));
+}

package/dist/runtime/serializedFunctions.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Runtime for executing functions serialized by the KratosJs backend.
+ *
+ * ## Trust boundary
+ *
+ * The strings executed here are NOT user input. They are functions written by
+ * the panel developer in resource/column definitions (kratosjs core
+ * serializes them with `.toString()`) and served by the developer's own server
+ * over the authenticated metadata API. They carry exactly the same trust as
+ * the application JS bundle itself: if an attacker can tamper with the
+ * metadata endpoint, they already control the panel.
+ *
+ * Implementation notes:
+ * - Compilation uses `new Function` (never `eval`), so serialized code cannot
+ *   capture local scope from this module.
+ * - Compiled functions are cached by source string — schemas re-render often
+ *   and re-parsing on every render is wasted work.
+ * - Deploying a CSP without `'unsafe-eval'` requires avoiding serialized
+ *   functions entirely (use structured conditions instead, see conditions.ts).
+ */
+/**
+ * Strip TypeScript/esbuild helper wrappers from serialized code.
+ * Toolchains wrap named function expressions as `__name(fn, "fnName")`;
+ * this extracts the first argument and drops the name, iterating until
+ * no `__name(` wrappers remain (handles nesting in block bodies).
+ */
+export declare function stripTypeScriptHelpers(code: string): string;
+/**
+ * Compile a serialized function string into a callable, with caching.
+ * Returns undefined (and logs) when the string cannot be compiled.
+ */
+export declare function compileSerializedFunction(functionString: string | undefined): ((...args: any[]) => any) | undefined;
+/**
+ * Execute a serialized function with the given arguments.
+ * Without arguments, returns the compiled function itself.
+ * Returns undefined on compile or runtime errors.
+ *
+ * @example
+ * executeSerializedFunction('(value, record) => value.toUpperCase()', 'hello', {});
+ */
+export declare function executeSerializedFunction(functionString: string | undefined, ...args: any[]): any;

package/dist/runtime/serializedFunctions.js

@@ -0,0 +1,264 @@
+/**
+ * Runtime for executing functions serialized by the KratosJs backend.
+ *
+ * ## Trust boundary
+ *
+ * The strings executed here are NOT user input. They are functions written by
+ * the panel developer in resource/column definitions (kratosjs core
+ * serializes them with `.toString()`) and served by the developer's own server
+ * over the authenticated metadata API. They carry exactly the same trust as
+ * the application JS bundle itself: if an attacker can tamper with the
+ * metadata endpoint, they already control the panel.
+ *
+ * Implementation notes:
+ * - Compilation uses `new Function` (never `eval`), so serialized code cannot
+ *   capture local scope from this module.
+ * - Compiled functions are cached by source string — schemas re-render often
+ *   and re-parsing on every render is wasted work.
+ * - Deploying a CSP without `'unsafe-eval'` requires avoiding serialized
+ *   functions entirely (use structured conditions instead, see conditions.ts).
+ */
+const compileCache = new Map();
+/**
+ * Strip TypeScript/esbuild helper wrappers from serialized code.
+ * Toolchains wrap named function expressions as `__name(fn, "fnName")`;
+ * this extracts the first argument and drops the name, iterating until
+ * no `__name(` wrappers remain (handles nesting in block bodies).
+ */
+export function stripTypeScriptHelpers(code) {
+    let cleaned = code;
+    let changed = true;
+    let iterations = 0;
+    const maxIterations = 100; // Safety limit to prevent infinite loops
+    while (changed && iterations < maxIterations) {
+        iterations++;
+        const before = cleaned;
+        let result = '';
+        let i = 0;
+        while (i < cleaned.length) {
+            // Check if we're at __name(
+            if (cleaned.substring(i, i + 6) === '__name' && (cleaned[i + 6] === '(' || /\s/.test(cleaned[i + 6]))) {
+                // Skip '__name' and any whitespace, find the opening parenthesis
+                let j = i + 6;
+                while (j < cleaned.length && /\s/.test(cleaned[j]))
+                    j++;
+                if (j >= cleaned.length || cleaned[j] !== '(') {
+                    // Not a __name( call, add it back and continue
+                    result += cleaned[i];
+                    i++;
+                    continue;
+                }
+                // Skip '('
+                j++;
+                // Find the first argument (the function expression),
+                // matching balanced parens/brackets/braces outside strings
+                let depth = 0;
+                const start = j;
+                let inString = false;
+                let stringChar = '';
+                let inTemplate = false;
+                while (j < cleaned.length) {
+                    const char = cleaned[j];
+                    const prevChar = j > 0 ? cleaned[j - 1] : '';
+                    if (!inString && !inTemplate) {
+                        if (char === '`') {
+                            inTemplate = true;
+                        }
+                        else if (char === '"' || char === "'") {
+                            inString = true;
+                            stringChar = char;
+                        }
+                    }
+                    else if (inString && char === stringChar && prevChar !== '\\') {
+                        inString = false;
+                    }
+                    else if (inTemplate && char === '`' && prevChar !== '\\') {
+                        inTemplate = false;
+                    }
+                    if (!inString && !inTemplate) {
+                        if (char === '(' || char === '[' || char === '{') {
+                            depth++;
+                        }
+                        else if (char === ')' || char === ']' || char === '}') {
+                            depth--;
+                        }
+                        // A comma at depth 0 ends the first argument
+                        if (char === ',' && depth === 0) {
+                            break;
+                        }
+                    }
+                    j++;
+                }
+                const functionExpr = cleaned.substring(start, j);
+                result += functionExpr;
+                // Skip the comma
+                if (cleaned[j] === ',')
+                    j++;
+                // Skip whitespace
+                while (j < cleaned.length && /\s/.test(cleaned[j]))
+                    j++;
+                // Skip the string argument ("functionName")
+                if (cleaned[j] === '"' || cleaned[j] === "'") {
+                    const quote = cleaned[j];
+                    j++;
+                    while (j < cleaned.length && cleaned[j] !== quote) {
+                        if (cleaned[j] === '\\')
+                            j++; // Skip escaped characters
+                        j++;
+                    }
+                    if (cleaned[j] === quote)
+                        j++; // Skip closing quote
+                }
+                // Skip whitespace and closing paren
+                while (j < cleaned.length && (/\s/.test(cleaned[j]) || cleaned[j] === ')'))
+                    j++;
+                i = j;
+            }
+            else {
+                result += cleaned[i];
+                i++;
+            }
+        }
+        cleaned = result;
+        changed = before !== cleaned;
+    }
+    return cleaned;
+}
+/**
+ * Extract parameter names from a function parameter list.
+ * Handles: (a, b), (a,b), a, (a = 1, b), etc.
+ */
+function extractParameters(paramString) {
+    if (!paramString)
+        return [];
+    const cleaned = paramString.replace(/^\(|\)$/g, '').trim();
+    if (!cleaned)
+        return [];
+    const params = [];
+    let current = '';
+    let depth = 0;
+    for (let i = 0; i < cleaned.length; i++) {
+        const char = cleaned[i];
+        if (char === '(' || char === '[' || char === '{') {
+            depth++;
+            current += char;
+        }
+        else if (char === ')' || char === ']' || char === '}') {
+            depth--;
+            current += char;
+        }
+        else if (char === ',' && depth === 0) {
+            const paramName = current.trim().split('=')[0].trim();
+            if (paramName) {
+                params.push(paramName);
+            }
+            current = '';
+        }
+        else {
+            current += char;
+        }
+    }
+    if (current.trim()) {
+        const paramName = current.trim().split('=')[0].trim();
+        if (paramName) {
+            params.push(paramName);
+        }
+    }
+    return params.length > 0 ? params : ['value', 'record']; // Default fallback
+}
+function compile(functionString) {
+    const trimmed = stripTypeScriptHelpers(functionString).trim();
+    if (trimmed.includes('=>')) {
+        const arrowIndex = trimmed.indexOf('=>');
+        const afterArrow = trimmed.substring(arrowIndex + 2).trim();
+        const beforeArrow = trimmed.substring(0, arrowIndex).trim();
+        const params = extractParameters(beforeArrow);
+        if (afterArrow.startsWith('{')) {
+            // Block body — extract content between balanced braces
+            let braceCount = 0;
+            let startIndex = 0;
+            let endIndex = afterArrow.length;
+            for (let i = 0; i < afterArrow.length; i++) {
+                if (afterArrow[i] === '{') {
+                    if (braceCount === 0)
+                        startIndex = i + 1;
+                    braceCount++;
+                }
+                else if (afterArrow[i] === '}') {
+                    braceCount--;
+                    if (braceCount === 0) {
+                        endIndex = i;
+                        break;
+                    }
+                }
+            }
+            const functionBody = afterArrow.substring(startIndex, endIndex).trim();
+            return new Function(...params, functionBody);
+        }
+        // Expression body — wrap in a return statement
+        return new Function(...params, `return ${afterArrow}`);
+    }
+    if (trimmed.startsWith('function')) {
+        return new Function(`return ${trimmed}`)();
+    }
+    // Bare function body, or an unrecognized wrapping
+    try {
+        return new Function('value', 'record', trimmed);
+    }
+    catch {
+        // Last resort: treat the string as an expression evaluating to a function
+        const fn = new Function(`return (${trimmed})`)();
+        if (typeof fn === 'function') {
+            return fn;
+        }
+        throw new Error('Serialized string is not a valid function');
+    }
+}
+/**
+ * Compile a serialized function string into a callable, with caching.
+ * Returns undefined (and logs) when the string cannot be compiled.
+ */
+export function compileSerializedFunction(functionString) {
+    if (!functionString) {
+        return undefined;
+    }
+    if (compileCache.has(functionString)) {
+        return compileCache.get(functionString);
+    }
+    let compiled;
+    try {
+        compiled = compile(functionString);
+    }
+    catch (error) {
+        console.error('Error compiling serialized function:', error);
+        console.error('Function string (first 500 chars):', functionString.substring(0, 500));
+        compiled = undefined;
+    }
+    compileCache.set(functionString, compiled);
+    return compiled;
+}
+/**
+ * Execute a serialized function with the given arguments.
+ * Without arguments, returns the compiled function itself.
+ * Returns undefined on compile or runtime errors.
+ *
+ * @example
+ * executeSerializedFunction('(value, record) => value.toUpperCase()', 'hello', {});
+ */
+export function executeSerializedFunction(functionString, ...args) {
+    const fn = compileSerializedFunction(functionString);
+    if (!fn) {
+        return undefined;
+    }
+    if (args.length === 0) {
+        return fn;
+    }
+    try {
+        return fn(...args);
+    }
+    catch (error) {
+        console.error('Error executing serialized function:', error);
+        console.error('Function string (first 500 chars):', functionString?.substring(0, 500));
+        return undefined;
+    }
+}

package/dist/slots/Slot.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { SlotContext, SlotContribution, SlotName } from './types';
+/**
+ * Render one contribution. Both a React component and a plain
+ * `(ctx) => ReactNode` are function components of the context, so a single
+ * `createElement` path covers both forms.
+ */
+export declare function renderSlot(contribution: SlotContribution, context: SlotContext): React.ReactNode;
+export interface SlotProps {
+    /** The slot to render. */
+    name: SlotName;
+    /** Context passed to each contribution. `slot` is filled in automatically. */
+    context?: Omit<SlotContext, 'slot'>;
+    /** Optional wrapper element type. Defaults to a Fragment (no DOM). */
+    as?: React.ElementType;
+    /** className for the wrapper (ignored when `as` is omitted). */
+    className?: string;
+}
+/**
+ * Renders every contribution registered for `name`, in order, each isolated by
+ * an `ErrorBoundary`. Renders nothing (no wrapper DOM) when the slot is empty,
+ * so slots stay invisible until something is contributed.
+ */
+export declare function Slot({ name, context, as, className }: SlotProps): React.JSX.Element;

package/dist/slots/Slot.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+import { ErrorBoundary } from '../components/errors/ErrorBoundary';
+import { useSlot } from '../contexts/SlotRegistryContext';
+/**
+ * Render one contribution. Both a React component and a plain
+ * `(ctx) => ReactNode` are function components of the context, so a single
+ * `createElement` path covers both forms.
+ */
+export function renderSlot(contribution, context) {
+    return (_jsx(ErrorBoundary, { label: `slot "${context.slot}" (${contribution.id})`, children: React.createElement(contribution.render, context) }, contribution.id));
+}
+/**
+ * Renders every contribution registered for `name`, in order, each isolated by
+ * an `ErrorBoundary`. Renders nothing (no wrapper DOM) when the slot is empty,
+ * so slots stay invisible until something is contributed.
+ */
+export function Slot({ name, context, as, className }) {
+    const contributions = useSlot(name);
+    if (contributions.length === 0)
+        return null;
+    const fullContext = { ...context, slot: name };
+    const children = contributions.map(contribution => renderSlot(contribution, fullContext));
+    if (as) {
+        const Wrapper = as;
+        return _jsx(Wrapper, { className: className, children: children });
+    }
+    return _jsx(_Fragment, { children: children });
+}

package/dist/slots/SlotCluster.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import type { SlotContext, SlotName } from './types';
+export interface SlotClusterProps {
+    /** The slot to render. */
+    name: SlotName;
+    /** Context passed to each contribution. `slot` is filled in automatically. */
+    context?: Omit<SlotContext, 'slot'>;
+    /**
+     * How many contributions render inline on `sm`+ screens before the rest
+     * collapse into a "…" menu. Below `sm`, everything collapses. Default 2.
+     */
+    maxInline?: number;
+    /** className for the inline flex row. */
+    className?: string;
+}
+/**
+ * A responsive slot for tight horizontal areas (header right, table toolbar).
+ * On `sm`+ the first `maxInline` items render inline and any extras fall into a
+ * "…" dropdown; below `sm` every item collapses into the dropdown, so a crowded
+ * slot can never overflow a phone-width row regardless of contributor count.
+ */
+export declare function SlotCluster({ name, context, maxInline, className }: SlotClusterProps): React.JSX.Element;

package/dist/slots/SlotCluster.js

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from 'react';
+import { MoreHorizontal } from 'lucide-react';
+import { IconButton } from '../components/ui';
+import { cn } from '../utils/classNames';
+import { translate } from '../i18n/activeLocale';
+import { useSlot } from '../contexts/SlotRegistryContext';
+import { renderSlot } from './Slot';
+/** A self-contained "…" dropdown holding overflow slot contributions. */
+function OverflowMenu({ items, context, className, }) {
+    const [open, setOpen] = useState(false);
+    const ref = useRef(null);
+    useEffect(() => {
+        if (!open)
+            return;
+        const onClick = (event) => {
+            if (ref.current && !ref.current.contains(event.target))
+                setOpen(false);
+        };
+        const onEsc = (event) => {
+            if (event.key === 'Escape')
+                setOpen(false);
+        };
+        document.addEventListener('mousedown', onClick);
+        document.addEventListener('keydown', onEsc);
+        return () => {
+            document.removeEventListener('mousedown', onClick);
+            document.removeEventListener('keydown', onEsc);
+        };
+    }, [open]);
+    if (items.length === 0)
+        return null;
+    return (_jsxs("div", { className: cn('relative', className), ref: ref, children: [_jsx(IconButton, { variant: "ghost", size: "sm", "aria-label": translate('core:common.more'), "aria-expanded": open, "aria-haspopup": "menu", className: "h-9 w-9 shrink-0", onClick: () => setOpen(o => !o), children: _jsx(MoreHorizontal, { className: "h-4 w-4" }) }), open && (_jsx("div", { role: "menu", className: "absolute right-0 z-50 mt-2 flex w-56 flex-col gap-1 rounded-xl border border-border bg-raised p-2 shadow-soft-lg", children: items.map(item => renderSlot(item, context)) }))] }));
+}
+/**
+ * A responsive slot for tight horizontal areas (header right, table toolbar).
+ * On `sm`+ the first `maxInline` items render inline and any extras fall into a
+ * "…" dropdown; below `sm` every item collapses into the dropdown, so a crowded
+ * slot can never overflow a phone-width row regardless of contributor count.
+ */
+export function SlotCluster({ name, context, maxInline = 2, className }) {
+    const contributions = useSlot(name);
+    if (contributions.length === 0)
+        return null;
+    const fullContext = { ...context, slot: name };
+    const inline = contributions.slice(0, maxInline);
+    const overflow = contributions.slice(maxInline);
+    return (_jsxs(_Fragment, { children: [_jsxs("div", { className: cn('hidden items-center gap-1 sm:flex sm:gap-2', className), children: [inline.map(item => (_jsx("div", { className: "shrink-0", children: renderSlot(item, fullContext) }, item.id))), _jsx(OverflowMenu, { items: overflow, context: fullContext })] }), _jsx(OverflowMenu, { items: contributions, context: fullContext, className: "sm:hidden" })] }));
+}

package/dist/slots/index.d.ts

@@ -0,0 +1,7 @@
+export { Slot, renderSlot } from './Slot';
+export type { SlotProps } from './Slot';
+export { SlotCluster } from './SlotCluster';
+export type { SlotClusterProps } from './SlotCluster';
+export { mergeSlots, appendSlots, sortSlots } from './mergeSlots';
+export { SLOT_NAMES } from './types';
+export type { SlotName, BuiltInSlotName, SlotContext, SlotRender, SlotContribution, SlotMap, ResolvedSlots, } from './types';

package/dist/slots/index.js

@@ -0,0 +1,4 @@
+export { Slot, renderSlot } from './Slot';
+export { SlotCluster } from './SlotCluster';
+export { mergeSlots, appendSlots, sortSlots } from './mergeSlots';
+export { SLOT_NAMES } from './types';

package/dist/slots/mergeSlots.d.ts

@@ -0,0 +1,18 @@
+import type { SlotMap, ResolvedSlots, SlotContribution } from './types';
+/**
+ * Append the contributions of one `SlotMap` onto an accumulator. Unlike the
+ * override-based component registries, slots are 1:many — every contribution is
+ * kept, preserving the order contributors were applied in.
+ */
+export declare function appendSlots(target: ResolvedSlots, slots?: SlotMap): ResolvedSlots;
+/**
+ * Stable-sort every slot's contributions by `order` (default 0). Equal orders
+ * keep registration order, since `Array.prototype.sort` is stable.
+ */
+export declare function sortSlots(resolved: ResolvedSlots): ResolvedSlots;
+/**
+ * Merge an ordered list of slot maps into a single resolved, sorted map.
+ * Earlier maps contribute first; the app map is appended last by the caller.
+ */
+export declare function mergeSlots(maps: Array<SlotMap | undefined>): ResolvedSlots;
+export type { SlotContribution };

package/dist/slots/mergeSlots.js

@@ -0,0 +1,35 @@
+/**
+ * Append the contributions of one `SlotMap` onto an accumulator. Unlike the
+ * override-based component registries, slots are 1:many — every contribution is
+ * kept, preserving the order contributors were applied in.
+ */
+export function appendSlots(target, slots = {}) {
+    for (const [name, value] of Object.entries(slots)) {
+        if (!value)
+            continue;
+        const contributions = Array.isArray(value) ? value : [value];
+        (target[name] ?? (target[name] = [])).push(...contributions);
+    }
+    return target;
+}
+/**
+ * Stable-sort every slot's contributions by `order` (default 0). Equal orders
+ * keep registration order, since `Array.prototype.sort` is stable.
+ */
+export function sortSlots(resolved) {
+    for (const name of Object.keys(resolved)) {
+        resolved[name] = [...resolved[name]].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+    }
+    return resolved;
+}
+/**
+ * Merge an ordered list of slot maps into a single resolved, sorted map.
+ * Earlier maps contribute first; the app map is appended last by the caller.
+ */
+export function mergeSlots(maps) {
+    const resolved = {};
+    for (const map of maps) {
+        appendSlots(resolved, map);
+    }
+    return sortSlots(resolved);
+}

package/dist/slots/types.d.ts

@@ -0,0 +1,87 @@
+import type { ReactNode, ComponentType } from 'react';
+/**
+ * Built-in slot ids — the named injection points the framework renders in the
+ * panel chrome. Plugins may also use arbitrary strings to declare their own
+ * slots inside components they render.
+ */
+export type BuiltInSlotName = 'header.left' | 'header.right' | 'header.userMenu' | 'sidebar.brand' | 'sidebar.top' | 'sidebar.bottom' | 'panel.footer' | 'table.toolbar' | 'table.aboveTable' | 'table.belowTable' | 'table.bulkActions' | 'table.rowActions' | 'form.header' | 'form.footer' | 'detail.actions' | 'detail.tabs' | 'detail.afterDetails' | 'page.top' | 'page.bottom' | 'widgets.append' | 'modal.headerActions' | 'modal.footer' | 'login.top' | 'login.belowForm';
+/**
+ * A slot name. The built-in names give autocomplete; the `string & {}` arm keeps
+ * the union open so plugins can define and target their own slots.
+ */
+export type SlotName = BuiltInSlotName | (string & {});
+/**
+ * Context passed to every slot render. The base shape is always present; each
+ * placement widens it with the data it can supply (e.g. the current record for
+ * detail/form slots, the resource slug for table slots).
+ */
+export interface SlotContext {
+    /** The slot being rendered. */
+    slot: SlotName;
+    /** Slug of the resource in scope, when the slot sits inside a resource view. */
+    resourceSlug?: string;
+    /** Resource/page schema in scope, when available. */
+    schema?: unknown;
+    /** The record in scope, for detail/form slots. */
+    record?: Record<string, unknown>;
+    /** Current router pathname. */
+    location?: string;
+    /** Authenticated user, for header/userMenu slots. Cast to your `AuthUser`. */
+    user?: unknown;
+    /** Slot-specific extras (e.g. `{ selectedIds }` for `table.bulkActions`, `{ rowId }` for `table.rowActions`). */
+    data?: Record<string, unknown>;
+}
+/**
+ * A slot's renderable: either a React component that receives the slot context
+ * as props, or a plain function of the context returning a node.
+ */
+export type SlotRender<C extends SlotContext = SlotContext> = ComponentType<C> | ((ctx: C) => ReactNode);
+/**
+ * A single contribution to a slot. Multiple contributions stack into one slot,
+ * unlike the override-based component registries.
+ */
+export interface SlotContribution<C extends SlotContext = SlotContext> {
+    /** Stable id — used as the React key and to dedupe across contributors. */
+    id: string;
+    /** Component or function that produces the slot content. */
+    render: SlotRender<C>;
+    /** Lower renders first. Defaults to 0; ties keep registration order. */
+    order?: number;
+}
+/**
+ * What a plugin/app contributes: a single contribution or an array per slot.
+ * Authored on `KratosPluginClient.slots` and `mountAdminPanel({ slots })`.
+ */
+export type SlotMap = Partial<Record<SlotName, SlotContribution | SlotContribution[]>>;
+/** Internal resolved form: every slot maps to a sorted array of contributions. */
+export type ResolvedSlots = Record<string, SlotContribution[]>;
+/**
+ * Built-in slot names as a const object, for autocomplete and refactor-safe
+ * references without losing the open `SlotName` string union.
+ */
+export declare const SLOT_NAMES: {
+    readonly headerLeft: "header.left";
+    readonly headerRight: "header.right";
+    readonly headerUserMenu: "header.userMenu";
+    readonly sidebarBrand: "sidebar.brand";
+    readonly sidebarTop: "sidebar.top";
+    readonly sidebarBottom: "sidebar.bottom";
+    readonly panelFooter: "panel.footer";
+    readonly tableToolbar: "table.toolbar";
+    readonly tableAboveTable: "table.aboveTable";
+    readonly tableBelowTable: "table.belowTable";
+    readonly tableBulkActions: "table.bulkActions";
+    readonly tableRowActions: "table.rowActions";
+    readonly formHeader: "form.header";
+    readonly formFooter: "form.footer";
+    readonly detailActions: "detail.actions";
+    readonly detailTabs: "detail.tabs";
+    readonly detailAfterDetails: "detail.afterDetails";
+    readonly pageTop: "page.top";
+    readonly pageBottom: "page.bottom";
+    readonly widgetsAppend: "widgets.append";
+    readonly modalHeaderActions: "modal.headerActions";
+    readonly modalFooter: "modal.footer";
+    readonly loginTop: "login.top";
+    readonly loginBelowForm: "login.belowForm";
+};

package/dist/slots/types.js

@@ -0,0 +1,30 @@
+/**
+ * Built-in slot names as a const object, for autocomplete and refactor-safe
+ * references without losing the open `SlotName` string union.
+ */
+export const SLOT_NAMES = {
+    headerLeft: 'header.left',
+    headerRight: 'header.right',
+    headerUserMenu: 'header.userMenu',
+    sidebarBrand: 'sidebar.brand',
+    sidebarTop: 'sidebar.top',
+    sidebarBottom: 'sidebar.bottom',
+    panelFooter: 'panel.footer',
+    tableToolbar: 'table.toolbar',
+    tableAboveTable: 'table.aboveTable',
+    tableBelowTable: 'table.belowTable',
+    tableBulkActions: 'table.bulkActions',
+    tableRowActions: 'table.rowActions',
+    formHeader: 'form.header',
+    formFooter: 'form.footer',
+    detailActions: 'detail.actions',
+    detailTabs: 'detail.tabs',
+    detailAfterDetails: 'detail.afterDetails',
+    pageTop: 'page.top',
+    pageBottom: 'page.bottom',
+    widgetsAppend: 'widgets.append',
+    modalHeaderActions: 'modal.headerActions',
+    modalFooter: 'modal.footer',
+    loginTop: 'login.top',
+    loginBelowForm: 'login.belowForm',
+};