xmlui 0.11.4 → 0.11.7

package/dist/scripts/src/components/Table/doc-resources/list-component-data.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const data = [
-    {
-        id: 0,
-        name: "Apples",
-        quantity: 5,
-        unit: "pieces",
-        category: "fruits",
-        key: 5,
-    },
-    {
-        id: 1,
-        name: "Bananas",
-        quantity: 6,
-        unit: "pieces",
-        category: "fruits",
-        key: 4,
-    },
-    {
-        id: 2,
-        name: "Carrots",
-        quantity: 100,
-        unit: "grams",
-        category: "vegetables",
-        key: 3,
-    },
-    {
-        id: 3,
-        name: "Spinach",
-        quantity: 1,
-        unit: "bunch",
-        category: "vegetables",
-        key: 2,
-    },
-    {
-        id: 4,
-        name: "Milk",
-        quantity: 10,
-        unit: "liter",
-        category: "dairy",
-        key: 1,
-    },
-    {
-        id: 5,
-        name: "Cheese",
-        quantity: 200,
-        unit: "grams",
-        category: "dairy",
-        key: 0,
-    },
-];
-exports.default = data;

package/dist/scripts/src/components/Table/useRowSelection.js

@@ -1,454 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = useRowSelection;
-const react_1 = require("react");
-const lodash_es_1 = require("lodash-es");
-const misc_1 = require("../../components-core/utils/misc");
-const constants_1 = require("../../components-core/constants");
-const hooks_1 = require("../../components-core/utils/hooks");
-const SelectionStoreNative_1 = require("../SelectionStore/SelectionStoreNative");
-/**
- * Hook for managing table row selection with optional bidirectional AppState synchronization.
- *
- * ## AppState Synchronization Mechanism
- *
- * When `syncWithAppState` is provided, this hook implements a robust bidirectional synchronization
- * between the table's selection state and an AppState instance. The synchronization prevents
- * infinite loops using a state machine approach.
- *
- * ### State Machine Design
- *
- * The sync operates through three states:
- * - `idle`: Normal state, ready to respond to changes from either side
- * - `updating_to_appstate`: Currently propagating table selection → AppState (blocks AppState → table)
- * - `updating_from_appstate`: Currently propagating AppState → table selection (blocks table → AppState)
- *
- * ### Synchronization Flow
- *
- * **AppState → Table (External Updates)**:
- * 1. AppState.value.selectedIds changes externally (e.g., from another component)
- * 2. Effect detects change and validates it's not from our own update (using source tracking)
- * 3. Sets state to `updating_from_appstate` to block reverse sync
- * 4. Updates table selection via setSelectedRowIds()
- * 5. Uses requestAnimationFrame to reset state to `idle` after update completes
- *
- * **Table → AppState (User Interaction)**:
- * 1. User interacts with table (clicks, keyboard navigation)
- * 2. selectedItems changes through normal table selection logic
- * 3. Effect detects change and validates it's different from AppState
- * 4. Sets state to `updating_to_appstate` to block reverse sync
- * 5. Calls syncWithAppState.update({ selectedIds: [...] })
- * 6. Uses requestAnimationFrame to reset state to `idle` after update completes
- *
- * ### Loop Prevention Strategy
- *
- * Multiple mechanisms prevent infinite loops:
- * - **State Machine**: Directional blocking prevents simultaneous updates
- * - **Source Tracking**: lastUpdateSourceRef tracks whether the last change came from 'table' or 'appstate'
- * - **Value Tracking**: lastAppStateSelectionRef and lastTableSelectionRef track last known values
- * - **Change Detection**: Only triggers updates when values actually differ using JSON.stringify comparison
- * - **Frame-Based Reset**: Uses requestAnimationFrame instead of setTimeout for deterministic timing
- *
- * ### Usage with AppState
- *
- * ```typescript
- * // In your component
- * const appState = useAppState('myBucket');
- *
- * // Pass to Table
- * <Table
- *   items={data}
- *   syncWithAppState={appState}
- *   // ... other props
- * />
- *
- * // AppState will contain: { selectedIds: ['id1', 'id2', ...] }
- * // Changes from either side are automatically synchronized
- * ```
- *
- * ### Precedence Rules
- *
- * - When both `initiallySelected` and `syncWithAppState` are provided, `syncWithAppState` takes precedence
- * - Multi-row selection limits are respected (single selection truncates to first ID)
- * - Only valid item IDs (present in current `items` array) are synchronized
- *
- * @param options Configuration object for row selection behavior
- * @returns Row selection operations and state management interface
- */
-function useRowSelection({ items = constants_1.EMPTY_ARRAY, visibleItems = items, rowsSelectable, enableMultiRowSelection, rowDisabledPredicate, onSelectionDidChange, initiallySelected = constants_1.EMPTY_ARRAY, syncWithAppState, }) {
-    var _a;
-    // --- The focused index in the row source (if there is any)
-    const [focusedIndex, setFocusedIndex] = (0, react_1.useState)(-1);
-    // --- The current selection interval
-    const [selectionInterval, setSelectionInterval] = (0, react_1.useState)(null);
-    // --- Access the selection context that stores the current state of selection
-    const { selectedItems, setSelectedRowIds, refreshSelection, idKey } = (0, SelectionStoreNative_1.useSelectionContext)();
-    // --- Refresh the list of item IDs whenever the items in the selection change
-    const walkableList = (0, react_1.useMemo)(() => {
-        return visibleItems.map((item) => item[idKey]);
-    }, [idKey, visibleItems]);
-    // --- Track if initial selection has been applied
-    const [initialSelectionApplied, setInitialSelectionApplied] = (0, react_1.useState)(false);
-    // --- If the items change, refresh the selectable items (if the rows are selectable)
-    (0, react_1.useEffect)(() => {
-        refreshSelection(rowsSelectable ? items : constants_1.EMPTY_ARRAY);
-    }, [refreshSelection, items, rowsSelectable]);
-    // --- Handle AppState synchronization
-    // This implements bidirectional sync between Table selection and AppState.
-    // The approach uses React's useEffect pattern which is appropriate for React-to-React communication.
-    // The new AppState didUpdate event is more useful for non-React integrations.
-    const appStateSelection = (_a = syncWithAppState === null || syncWithAppState === void 0 ? void 0 : syncWithAppState.value) === null || _a === void 0 ? void 0 : _a.selectedIds;
-    const prevAppStateSelection = (0, hooks_1.usePrevious)(appStateSelection);
-    // --- State machine for sync direction control
-    const [syncState, setSyncState] = (0, react_1.useState)("idle");
-    // --- Use refs to track the last known selections to prevent update loops
-    const lastAppStateSelectionRef = (0, react_1.useRef)();
-    const lastTableSelectionRef = (0, react_1.useRef)();
-    // --- Track the source of the last update to prevent echoing
-    const lastUpdateSourceRef = (0, react_1.useRef)(null);
-    // --- Sync from AppState to table selection (when AppState changes externally)
-    (0, react_1.useEffect)(() => {
-        // Skip if not selectable, no sync, no selection, or we're currently updating to AppState
-        if (!rowsSelectable ||
-            !syncWithAppState ||
-            !appStateSelection ||
-            syncState === "updating_to_appstate") {
-            return;
-        }
-        // Only update if AppState selection actually changed and this wasn't caused by our own table update
-        const appStateChanged = appStateSelection !== prevAppStateSelection;
-        const isDifferentFromLastKnown = JSON.stringify([...(appStateSelection || [])].sort()) !==
-            JSON.stringify([...(lastAppStateSelectionRef.current || [])].sort());
-        const wasNotOurUpdate = lastUpdateSourceRef.current !== "table";
-        if (appStateChanged && isDifferentFromLastKnown && wasNotOurUpdate && items.length > 0) {
-            // Set state machine to indicate we're updating from AppState
-            setSyncState("updating_from_appstate");
-            const validIds = appStateSelection.filter((id) => items.some((item) => item[idKey] === id));
-            const idsToSelect = enableMultiRowSelection ? validIds : validIds.slice(0, 1);
-            // Track what we're setting to prevent loop
-            lastAppStateSelectionRef.current = [...appStateSelection];
-            lastTableSelectionRef.current = [...idsToSelect];
-            lastUpdateSourceRef.current = "appstate";
-            setSelectedRowIds(idsToSelect);
-            setInitialSelectionApplied(true);
-        }
-    }, [
-        appStateSelection,
-        prevAppStateSelection,
-        items,
-        rowsSelectable,
-        syncWithAppState,
-        idKey,
-        enableMultiRowSelection,
-        setSelectedRowIds,
-        syncState,
-    ]);
-    // --- Sync from table selection to AppState (when user interacts with table)
-    (0, react_1.useEffect)(() => {
-        var _a;
-        // Skip if not selectable, no sync, or currently updating from AppState
-        if (!rowsSelectable || !syncWithAppState || syncState === "updating_from_appstate") {
-            return;
-        }
-        const currentSelectionIds = selectedItems.map((item) => item[idKey]);
-        const appStateSelectionIds = appStateSelection || [];
-        // Only update if table selection is different from AppState, different from our last update, and wasn't caused by AppState
-        const tableChanged = JSON.stringify([...currentSelectionIds].sort()) !==
-            JSON.stringify([...(lastTableSelectionRef.current || [])].sort());
-        const isDifferentFromAppState = JSON.stringify([...currentSelectionIds].sort()) !==
-            JSON.stringify([...appStateSelectionIds].sort());
-        const wasNotAppStateUpdate = lastUpdateSourceRef.current !== "appstate";
-        if (tableChanged && isDifferentFromAppState && wasNotAppStateUpdate) {
-            // Set state machine to indicate we're updating to AppState
-            setSyncState("updating_to_appstate");
-            // Track what we're updating to prevent loop
-            lastTableSelectionRef.current = [...currentSelectionIds];
-            lastAppStateSelectionRef.current = [...currentSelectionIds];
-            lastUpdateSourceRef.current = "table";
-            (_a = syncWithAppState.update) === null || _a === void 0 ? void 0 : _a.call(syncWithAppState, { selectedIds: currentSelectionIds });
-        }
-    }, [selectedItems, syncWithAppState, appStateSelection, idKey, rowsSelectable, syncState]);
-    // --- Reset sync state machine to idle when updates are complete
-    (0, react_1.useEffect)(() => {
-        if (syncState !== "idle") {
-            // Reset to idle state in the next tick to allow the current update to complete
-            const resetTimer = requestAnimationFrame(() => {
-                setSyncState("idle");
-            });
-            return () => cancelAnimationFrame(resetTimer);
-        }
-    }, [syncState, appStateSelection, selectedItems]);
-    // --- Clear update source when sync state becomes idle
-    (0, react_1.useEffect)(() => {
-        if (syncState === "idle") {
-            // Use a separate frame to clear the source after the sync state is reset
-            const clearTimer = requestAnimationFrame(() => {
-                lastUpdateSourceRef.current = null;
-            });
-            return () => cancelAnimationFrame(clearTimer);
-        }
-    }, [syncState]);
-    // --- Set initial selection when component mounts and items are available
-    // Use a separate effect that runs after the refresh to ensure timing is correct
-    (0, react_1.useEffect)(() => {
-        // If we have AppState sync, don't use initiallySelected
-        if (syncWithAppState) {
-            return;
-        }
-        if (!rowsSelectable ||
-            !initiallySelected ||
-            initiallySelected.length === 0 ||
-            initialSelectionApplied) {
-            return;
-        }
-        // Only set initial selection when items are available and we haven't applied it yet
-        if (items.length > 0) {
-            // Use requestAnimationFrame to ensure this runs after the refreshSelection effect
-            const frameId = requestAnimationFrame(() => {
-                // Filter initiallySelected to only include IDs that exist in current items
-                const validIds = initiallySelected.filter((id) => items.some((item) => item[idKey] === id));
-                if (validIds.length > 0) {
-                    // If multi-row selection is disabled, only select the first valid ID
-                    const idsToSelect = enableMultiRowSelection ? validIds : [validIds[0]];
-                    setSelectedRowIds(idsToSelect);
-                    setInitialSelectionApplied(true);
-                }
-            });
-            return () => cancelAnimationFrame(frameId);
-        }
-    }, [
-        items,
-        initiallySelected,
-        rowsSelectable,
-        idKey,
-        enableMultiRowSelection,
-        setSelectedRowIds,
-        initialSelectionApplied,
-        selectedItems,
-        syncWithAppState,
-    ]);
-    // --- If the multi-row selection switches to disabled, keep only the first selected item
-    const prevEnableMultiRowSelection = (0, hooks_1.usePrevious)(enableMultiRowSelection);
-    (0, react_1.useEffect)(() => {
-        if (prevEnableMultiRowSelection && !enableMultiRowSelection) {
-            if (selectedItems.length > 1) {
-                setSelectedRowIds([selectedItems[0][idKey]]);
-            }
-        }
-    }, [
-        enableMultiRowSelection,
-        idKey,
-        prevEnableMultiRowSelection,
-        selectedItems,
-        setSelectedRowIds,
-    ]);
-    // --- If the focused item is not available set the focus to the first item
-    (0, react_1.useEffect)(() => {
-        if (!rowsSelectable) {
-            return;
-        }
-        if (focusedIndex !== -1 && !walkableList[focusedIndex] && walkableList[0]) {
-            setFocusedIndex(0);
-        }
-    }, [focusedIndex, rowsSelectable, setFocusedIndex, walkableList]);
-    // --- Handle the user event to change the current selection. The event function handles the SHIFT, CTRL,
-    // --- and META keys to decide how to change or extend the existing selection
-    const toggleRowIndex = (0, misc_1.useEvent)(
-    // targetIndex: the item affected by an event
-    // options: key event options
-    (targetIndex, options = {}) => {
-        if (!rowsSelectable) {
-            return;
-        }
-        const targetId = walkableList[targetIndex];
-        const { shiftKey, metaKey, ctrlKey } = options;
-        const singleItem = !enableMultiRowSelection || (!shiftKey && !metaKey && !ctrlKey);
-        // --- This variable will hold the newest selection interval
-        let newSelectionInterval;
-        let newSelectedRowsIdsInOrder = [...selectedItems.map((item) => item[idKey])];
-        if (singleItem) {
-            newSelectionInterval = {
-                from: targetId,
-                to: targetId,
-            };
-            newSelectedRowsIdsInOrder = [targetId];
-        }
-        else {
-            if (shiftKey) {
-                // --- SHIFT is pressed, extend the current selection
-                let normalizedFromIdx;
-                let normalizedToIdx;
-                let from;
-                let to;
-                if (selectionInterval) {
-                    // --- Get the selection boundaries and normalize them (from is less than or equal than to)
-                    let oldFromIdx = walkableList.indexOf(selectionInterval.from);
-                    let oldToIdx = walkableList.indexOf(selectionInterval.to);
-                    let normalizedOldFromIdx = Math.min(oldFromIdx, oldToIdx);
-                    let normalizedOldToIdx = Math.max(oldFromIdx, oldToIdx);
-                    // --- Get the slice of selected IDs
-                    const slice = walkableList.slice(normalizedOldFromIdx, normalizedOldToIdx + 1);
-                    newSelectedRowsIdsInOrder = newSelectedRowsIdsInOrder.filter((item) => !slice.includes(item));
-                    from = selectionInterval.from;
-                    to = targetId;
-                    let fromIdx = walkableList.indexOf(from);
-                    let toIdx = walkableList.indexOf(to);
-                    normalizedFromIdx = Math.min(fromIdx, toIdx);
-                    normalizedToIdx = Math.max(fromIdx, toIdx);
-                }
-                else {
-                    from = targetId;
-                    to = targetId;
-                    normalizedFromIdx = targetIndex;
-                    normalizedToIdx = targetIndex;
-                }
-                const sl = walkableList.slice(normalizedFromIdx, normalizedToIdx + 1);
-                newSelectedRowsIdsInOrder = (0, lodash_es_1.union)(newSelectedRowsIdsInOrder, sl);
-                newSelectionInterval = {
-                    from: from,
-                    to: to,
-                };
-            }
-            else {
-                // --- SHIFT is not pressed, set the new interval to the newly focused item
-                newSelectionInterval = {
-                    from: targetId,
-                    to: targetId,
-                };
-                if (metaKey || ctrlKey) {
-                    // --- If META key (Mac) or CTRL (Windows) is pressed, toggle the selection of the targeted item
-                    if (newSelectedRowsIdsInOrder.includes(targetId)) {
-                        newSelectedRowsIdsInOrder = newSelectedRowsIdsInOrder.filter((item) => item !== targetId);
-                    }
-                    else {
-                        newSelectedRowsIdsInOrder.push(targetId);
-                    }
-                }
-                else {
-                    // --- The targeted item remains the only selection
-                    newSelectedRowsIdsInOrder = [targetId];
-                }
-            }
-        }
-        // --- Update the state variables of the selection
-        setFocusedIndex(targetIndex);
-        setSelectedRowIds((0, lodash_es_1.uniq)(newSelectedRowsIdsInOrder));
-        setSelectionInterval(newSelectionInterval);
-    });
-    // --- This function handles the user event to change the current selection according to the row ID
-    // --- affected by the event
-    const toggleRow = (0, misc_1.useEvent)((item, options) => {
-        if (!rowsSelectable) {
-            return;
-        }
-        const targetIndex = walkableList.indexOf(item[idKey]);
-        toggleRowIndex(targetIndex, options);
-    });
-    // --- Handle the key events that may change the current selection
-    const onKeyDown = (0, misc_1.useEvent)((event) => {
-        if (!rowsSelectable) {
-            return;
-        }
-        if (event.key === "ArrowDown") {
-            // --- Move/extend the selection to the item below the focused one
-            event.preventDefault();
-            let newFocusIndex = Math.min(visibleItems.length - 1, focusedIndex + 1);
-            if (focusedIndex !== visibleItems.length - 1) {
-                toggleRowIndex(newFocusIndex, event);
-            }
-        }
-        if (event.key === "PageDown") {
-            // --- Move/extend the selection to the item 8 items below the focused one
-            event.preventDefault();
-            const newFocusIndex = Math.min(visibleItems.length - 1, focusedIndex + 8);
-            toggleRowIndex(newFocusIndex, event);
-        }
-        if (event.key === "ArrowUp") {
-            // --- Move/extend the selection to the item above the focused one
-            event.preventDefault();
-            let newFocusIndex = Math.max(0, focusedIndex - 1);
-            if (focusedIndex >= 0) {
-                toggleRowIndex(newFocusIndex, event);
-            }
-        }
-        if (event.key === "PageUp") {
-            // --- Move/extend the selection to the item 8 items above the focused one
-            event.preventDefault();
-            const newFocusIndex = Math.max(0, focusedIndex - 8);
-            toggleRowIndex(newFocusIndex, event);
-        }
-    });
-    (0, react_1.useEffect)(() => {
-        // console.log("selection DID CHANGE?");
-        void (onSelectionDidChange === null || onSelectionDidChange === void 0 ? void 0 : onSelectionDidChange(selectedItems));
-    }, [selectedItems, onSelectionDidChange]);
-    /**
-     * This operation checks or clears all rows
-     */
-    const checkAllRows = (0, misc_1.useEvent)((checked) => {
-        if (!rowsSelectable) {
-            return;
-        }
-        if (!enableMultiRowSelection && checked) {
-            return;
-        }
-        setSelectedRowIds(checked
-            ? items
-                .filter((item) => (rowDisabledPredicate ? !rowDisabledPredicate(item) : true))
-                .map((item) => item[idKey])
-            : []);
-    });
-    /**
-     * This operation creates a hash object that indicates the selected status of selected row IDs
-     */
-    const selectedRowIdMap = (0, react_1.useMemo)(() => {
-        let rows = {};
-        selectedItems.forEach((item) => {
-            rows[item[idKey]] = true;
-        });
-        return rows;
-    }, [idKey, selectedItems]);
-    const getSelectedItems = (0, react_1.useCallback)(() => {
-        return selectedItems;
-    }, [selectedItems]);
-    const getSelectedIds = (0, react_1.useCallback)(() => {
-        return selectedItems.map((item) => item[idKey]);
-    }, [idKey, selectedItems]);
-    const clearSelection = (0, react_1.useCallback)(() => {
-        checkAllRows(false);
-    }, [checkAllRows]);
-    const selectAll = (0, react_1.useCallback)(() => {
-        checkAllRows(true);
-    }, [checkAllRows]);
-    const selectId = (0, react_1.useCallback)((id) => {
-        if (!rowsSelectable) {
-            return;
-        }
-        let ids = Array.isArray(id) ? id : [id];
-        if (ids.length > 1 && !enableMultiRowSelection) {
-            ids = [ids[0]];
-        }
-        setSelectedRowIds(ids);
-    }, [enableMultiRowSelection, rowsSelectable, setSelectedRowIds]);
-    const api = (0, react_1.useMemo)(() => {
-        return {
-            getSelectedItems,
-            getSelectedIds,
-            clearSelection,
-            selectAll,
-            selectId,
-        };
-    }, [clearSelection, getSelectedIds, getSelectedItems, selectAll, selectId]);
-    // --- Retrieve the selection management object
-    return {
-        onKeyDown,
-        focusedIndex,
-        toggleRowIndex,
-        toggleRow,
-        checkAllRows,
-        selectedRowIdMap,
-        selectedItems,
-        idKey,
-        selectionApi: api,
-    };
-}

package/dist/scripts/src/components/TableOfContents/TableOfContents.js

@@ -1,76 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tableOfContentsRenderer = exports.TableOfContentsMd = void 0;
-const jsx_runtime_1 = require("react/jsx-runtime");
-const TableOfContents_module_scss_1 = __importDefault(require("./TableOfContents.module.scss"));
-const renderers_1 = require("../../components-core/renderers");
-const themeVars_1 = require("../../components-core/theming/themeVars");
-const TableOfContentsNative_1 = require("./TableOfContentsNative");
-const IndexerContext_1 = require("../App/IndexerContext");
-const metadata_helpers_1 = require("../metadata-helpers");
-const COMP = "TableOfContents";
-const COMP_CHILD = "TableOfContentsItem";
-exports.TableOfContentsMd = (0, metadata_helpers_1.createMetadata)({
-    status: "stable",
-    description: "`TableOfContents` component collects [Heading](/components/Heading) and " +
-        "[Bookmark](/components/Bookmark) within the current page and displays them in a navigable tree.",
-    props: {
-        smoothScrolling: {
-            description: `This property indicates that smooth scrolling is used while scrolling the selected table ` +
-                `of contents items into view.`,
-            valueType: "boolean",
-            defaultValue: TableOfContentsNative_1.defaultProps.smoothScrolling,
-        },
-        maxHeadingLevel: {
-            description: "Defines the maximum heading level (1 to 6) to include in the table of contents. " +
-                "For example, if it is 2, then `H1` and `H2` are displayed, but lower levels " +
-                "(`H3` to `H6`) are not.",
-            valueType: "number",
-            defaultValue: TableOfContentsNative_1.defaultProps.maxHeadingLevel,
-        },
-        omitH1: {
-            description: "If true, the `H1` heading is not included in the table of contents. " +
-                "This is useful when the `H1` is used for the page title and you want to avoid duplication.",
-            valueType: "boolean",
-            defaultValue: false,
-        },
-    },
-    themeVars: (0, themeVars_1.parseScssVar)(TableOfContents_module_scss_1.default.themeVars),
-    defaultThemeVars: {
-        [`padding-${COMP}`]: "$space-2",
-        [`textColor-${COMP_CHILD}`]: "$color-secondary-500",
-        [`textColor-${COMP_CHILD}--hover`]: "$textColor-primary",
-        [`fontSize-${COMP_CHILD}`]: "$fontSize-sm",
-        [`wordWrap-${COMP_CHILD}`]: "break-word",
-        [`paddingVertical-${COMP_CHILD}`]: "$space-1",
-        [`paddingLeft-${COMP_CHILD}`]: "$space-1",
-        [`paddingLeft-${COMP_CHILD}-level-2`]: "$space-3",
-        [`paddingLeft-${COMP_CHILD}-level-3`]: "$space-5",
-        [`paddingLeft-${COMP_CHILD}-level-4`]: "$space-6",
-        [`paddingLeft-${COMP_CHILD}-level-5`]: "$space-6",
-        [`paddingLeft-${COMP_CHILD}-level-6`]: "$space-6",
-        [`fontWeight-${COMP_CHILD}`]: "$fontWeight-bold",
-        [`fontWeight-${COMP_CHILD}-level-2`]: "$fontWeight-medium",
-        [`fontWeight-${COMP_CHILD}-level-3`]: "$fontWeight-normal",
-        [`fontWeight-${COMP_CHILD}-level-4`]: "$fontWeight-normal",
-        [`fontWeight-${COMP_CHILD}-level-5`]: "$fontWeight-normal",
-        [`fontWeight-${COMP_CHILD}-level-6`]: "$fontWeight-normal",
-        [`fontStyle-${COMP_CHILD}-level-6`]: "italic",
-        [`textColor-${COMP_CHILD}--active`]: "$color-primary-400",
-        [`fontWeight-${COMP_CHILD}--active`]: "$fontWeight-bold",
-    },
-});
-function IndexAwareTableOfContents(props) {
-    const { indexing } = (0, IndexerContext_1.useIndexerContext)();
-    if (indexing) {
-        return null;
-    }
-    return (0, jsx_runtime_1.jsx)(TableOfContentsNative_1.TableOfContents, Object.assign({}, props));
-}
-exports.tableOfContentsRenderer = (0, renderers_1.createComponentRenderer)(COMP, exports.TableOfContentsMd, ({ className, node, extractValue }) => {
-    var _a, _b, _c;
-    return ((0, jsx_runtime_1.jsx)(IndexAwareTableOfContents, { className: className, smoothScrolling: extractValue.asOptionalBoolean((_a = node.props) === null || _a === void 0 ? void 0 : _a.smoothScrolling), maxHeadingLevel: extractValue.asOptionalNumber((_b = node.props) === null || _b === void 0 ? void 0 : _b.maxHeadingLevel), omitH1: extractValue.asOptionalBoolean((_c = node.props) === null || _c === void 0 ? void 0 : _c.omitH1) }));
-});