@primereact/mcp 11.0.0-rc.2

package/LICENSE.md

@@ -0,0 +1,45 @@
+# PrimeUI License
+
+This package is part of **PrimeUI**, a family of commercial UI libraries by PrimeTek Informatics.
+
+## How PrimeUI May Be Used
+
+PrimeUI may be used under one of two licenses. You choose the one that applies to you based on eligibility.
+
+### Community License (Free)
+
+Free for organizations that meet all of the following criteria:
+
+- Less than $1,000,000 USD in annual gross revenue
+- Fewer than 5 developers
+- Fewer than 10 employees
+- Less than $3,000,000 USD in venture capital or outside funding
+
+Individuals, students, non-profits, and non-commercial open source projects also qualify.
+
+The Community License provides full access to the core libraries and supports up to 4 developers. It requires annual renewal by confirming continued eligibility.
+
+### Commercial License (Paid)
+
+For organizations that do not qualify for the Community License.
+
+Licensed per developer, perpetual, with one year of updates included. Renewal is optional and extends access to new versions. The Commercial Suite also includes PrimeBlocks, Theme Designer, all PrimeUI Pro components, and Premium Support.
+
+## License Key
+
+A valid license key is required to use this software. License verification is performed offline, with no telemetry and no remote connection. A missing, invalid, or expired key may cause the software to display a license notice.
+
+## Full Terms
+
+The complete license terms, eligibility details, and renewal information are available at:
+
+- Community License: https://primeui.dev/licenses/community
+- Commercial License: https://primeui.dev/licenses/commercial
+
+## Restrictions
+
+This software is distributed as a compiled package. You may not reverse-engineer, decompile, or extract its source code, redistribute it as a component library or development tool, or remove its license mechanisms. Redistributing the software so that third parties can develop with it requires a separate OEM License. See the full terms for details.
+
+---
+
+Copyright 2026 PrimeTek Informatics. All rights reserved.

package/README.md

@@ -0,0 +1,94 @@
+# @primereact/mcp
+
+Model Context Protocol server for PrimeReact v11 generated documentation.
+
+The package is a thin PrimeReact server over the shared `@primeuix/mcp` v2 core. It exposes the compact v2 tool surface only:
+
+- `list`
+- `search`
+- `get_component`
+- `get_guide`
+- `get_example`
+- `get_setup`
+- `validate_usage`
+- `version`
+
+PrimeReact mode boundaries are preserved through the generated docs data: `styled`, `tailwind`, `primitive`, `headless`, and `hooks`.
+
+## Install
+
+Run the server with:
+
+```bash
+npx -y @primereact/mcp@alpha
+```
+
+The package bundles generated docs from `apps/showcase/public/llms` into `packages/mcp/data`. Generated Markdown and API resources are read from package-owned `data/llms` first, with the local showcase tree used only as a source-development fallback.
+
+Package-manager assumption: `@primereact/mcp` does not vendor the shared core. For the first alpha, its published dependency on `@primeuix/mcp` is exactly `2.0.0-alpha.1`; do not widen this to `^2.0.0` or `^2.0.0-alpha.1` until the alpha package install path has been validated from the public registry.
+
+## Claude Code
+
+```bash
+claude mcp add primereact -s user -- npx -y @primereact/mcp@alpha
+```
+
+Project-local install:
+
+```bash
+claude mcp add primereact -- npx -y @primereact/mcp@alpha
+```
+
+## Cursor
+
+Create `.cursor/mcp.json` in your project or `~/.cursor/mcp.json` globally:
+
+```json
+{
+    "mcpServers": {
+        "primereact": {
+            "command": "npx",
+            "args": ["-y", "@primereact/mcp@alpha"]
+        }
+    }
+}
+```
+
+## VS Code
+
+Create `.vscode/mcp.json` in your project:
+
+```json
+{
+    "servers": {
+        "primereact": {
+            "command": "npx",
+            "args": ["-y", "@primereact/mcp@alpha"]
+        }
+    }
+}
+```
+
+For a user-level setup, place the same `servers` object in your VS Code MCP user configuration.
+
+## Codex
+
+```bash
+codex mcp add primereact -- npx -y @primereact/mcp@alpha
+```
+
+Direct `~/.codex/config.toml` configuration:
+
+```toml
+[mcp_servers.primereact]
+command = "npx"
+args = ["-y", "@primereact/mcp@alpha"]
+```
+
+## Development
+
+```bash
+corepack pnpm --filter @primereact/mcp test
+corepack pnpm --filter @primereact/mcp build
+corepack pnpm --filter @primereact/mcp type:check
+```

package/data/llms/headless/add-ons/introduction.md

@@ -0,0 +1,16 @@
+# Add-Ons
+
+Premium templates, UI blocks and design tooling that build on top of PrimeReact.
+
+## Overview
+
+Add-Ons are premium, production-ready resources built on top of PrimeReact. They help you skip the boilerplate and ship faster, from full application templates to ready-made UI blocks and design tooling.
+
+## What's included
+
+- **Templates**, complete, themeable application starters with layouts, pages and integrations wired up.
+- **Blocks**, copy-and-paste UI sections for application, marketing and e-commerce pages.
+- **Figma UI Kit**, the design source that mirrors the component library, for designing before you build.
+- **Theme Designer**, a visual tool to craft and export your own design tokens and themes.
+
+Pick a category from the sidebar to explore each add-on.

package/data/llms/headless/components/accordion/api.json

@@ -0,0 +1,252 @@
+[
+  {
+    "name": "useAccordion",
+    "source": "apps/showcase/assets/apidoc/useaccordion.json",
+    "data": {
+      "description": "The useAccordion manages the state and functionality of a Accordion component.",
+      "interfaces": {
+        "UseAccordionChangeEvent": {
+          "description": "Event fired when the accordion's value changes.",
+          "relatedProp": "",
+          "props": [
+            {
+              "name": "originalEvent",
+              "type": "E",
+              "default": "",
+              "description": "The original event that triggered the change."
+            },
+            {
+              "name": "value",
+              "type": "string | number | (string | number)[]",
+              "default": "",
+              "description": "The value of the accordion."
+            }
+          ],
+          "methods": []
+        },
+        "UseAccordionProps": {
+          "description": "Defines valid properties in useAccordion.",
+          "relatedProp": "",
+          "props": [
+            {
+              "name": "defaultValue",
+              "type": "string | number | (string | number)[]",
+              "default": "null",
+              "description": "Default value of the active panel or an array of values in multiple mode."
+            },
+            {
+              "name": "value",
+              "type": "string | number | (string | number)[]",
+              "default": "null",
+              "description": "Value of the active panel or an array of values in multiple mode."
+            },
+            {
+              "name": "multiple",
+              "type": "boolean",
+              "default": "false",
+              "description": "When enabled, multiple tabs can be activated at the same time."
+            },
+            {
+              "name": "disabled",
+              "type": "boolean",
+              "default": "false",
+              "description": "When disabled, the component cannot be interacted with."
+            },
+            {
+              "name": "tabIndex",
+              "type": "number",
+              "default": "0",
+              "description": "Index of the element in tabbing order."
+            },
+            {
+              "name": "openOnFocus",
+              "type": "boolean",
+              "default": "false",
+              "description": "When enabled, the accordion panel will be opened on focus."
+            },
+            {
+              "name": "onValueChange",
+              "type": "(event: UseAccordionChangeEvent) => void",
+              "default": "",
+              "description": "Callback fired when the accordion's value changes."
+            }
+          ],
+          "methods": []
+        },
+        "UseAccordionState": {
+          "description": "Defines valid state in useAccordion.",
+          "relatedProp": "",
+          "props": [
+            {
+              "name": "value",
+              "type": "string | number | (string | number)[]",
+              "default": "",
+              "description": "Value of the active panel or an array of values in multiple mode."
+            }
+          ],
+          "methods": []
+        },
+        "UseAccordionRootProps": {
+          "description": "Data attribute props for the Accordion root element.",
+          "relatedProp": "",
+          "props": [
+            {
+              "name": "data-scope",
+              "type": "string",
+              "default": "",
+              "description": "Component scope identifier."
+            },
+            {
+              "name": "data-part",
+              "type": "string",
+              "default": "",
+              "description": "Component part identifier."
+            },
+            {
+              "name": "data-disabled",
+              "type": "string",
+              "default": "",
+              "description": "Present when the accordion is disabled."
+            }
+          ],
+          "methods": []
+        },
+        "UseAccordionExposes": {
+          "description": "Defines the methods and properties exposed by useAccordion.",
+          "relatedProp": "",
+          "props": [
+            {
+              "name": "state",
+              "type": "UseAccordionState",
+              "default": "",
+              "description": "The state of the useAccordion."
+            },
+            {
+              "name": "rootProps",
+              "type": "UseAccordionRootProps",
+              "default": "",
+              "description": "Pre-built data attribute props for the root element.\nIncludes data-disabled."
+            },
+            {
+              "name": "updateValue",
+              "type": "(event: SyntheticEvent, key: string | number) => void",
+              "default": "",
+              "description": "The method to update the value of the active panel."
+            },
+            {
+              "name": "isItemActive",
+              "type": "(key: string | number) => boolean",
+              "default": "",
+              "description": "The method to check if the panel is active."
+            }
+          ],
+          "methods": []
+        }
+      },
+      "types": {
+        "UseAccordionInstance": {
+          "description": "Instance of useAccordion headless.",
+          "values": "HeadlessInstance<UseAccordionProps, UseAccordionState, UseAccordionExposes>"
+        }
+      },
+      "variables": {}
+    }
+  },
+  {
+    "name": "useAccordionPanel",
+    "source": "apps/showcase/assets/apidoc/useaccordionpanel.json",
+    "data": {
+      "description": "The useAccordionPanel manages the state and functionality of an Accordion panel.",
+      "interfaces": {
+        "UseAccordionPanelProps": {
+          "description": "Defines valid properties in useAccordionPanel.",
+          "relatedProp": "",
+          "props": [
+            {
+              "name": "value",
+              "type": "string | number",
+              "default": "null",
+              "description": "Unique value of the panel."
+            },
+            {
+              "name": "disabled",
+              "type": "boolean",
+              "default": "false",
+              "description": "Whether the panel is disabled."
+            },
+            {
+              "name": "context",
+              "type": "UseAccordionInstance",
+              "default": "",
+              "description": "The parent accordion instance providing state and methods."
+            }
+          ],
+          "methods": []
+        },
+        "UseAccordionPanelState": {
+          "description": "Defines valid state in useAccordionPanel.",
+          "relatedProp": "",
+          "props": [
+            {
+              "name": "open",
+              "type": "boolean",
+              "default": "",
+              "description": "Whether the panel is open (active)."
+            },
+            {
+              "name": "disabled",
+              "type": "boolean",
+              "default": "",
+              "description": "Whether the panel is disabled (combined panel + accordion root)."
+            }
+          ],
+          "methods": []
+        },
+        "UseAccordionPanelExposes": {
+          "description": "Defines the methods and properties exposed by useAccordionPanel.",
+          "relatedProp": "",
+          "props": [
+            {
+              "name": "panelProps",
+              "type": "AccordionPanelRootElementProps",
+              "default": "",
+              "description": "Pre-built props for the panel root element."
+            },
+            {
+              "name": "headerProps",
+              "type": "AccordionPanelHeaderProps",
+              "default": "",
+              "description": "Pre-built props for the header element."
+            },
+            {
+              "name": "triggerProps",
+              "type": "AccordionPanelTriggerProps",
+              "default": "",
+              "description": "Pre-built props for the trigger element."
+            },
+            {
+              "name": "contentProps",
+              "type": "AccordionPanelContentProps",
+              "default": "",
+              "description": "Pre-built props for the content element."
+            },
+            {
+              "name": "indicatorProps",
+              "type": "AccordionPanelIndicatorProps",
+              "default": "",
+              "description": "Pre-built props for the indicator element."
+            }
+          ],
+          "methods": []
+        }
+      },
+      "types": {
+        "UseAccordionPanelInstance": {
+          "description": "Instance of useAccordionPanel headless.",
+          "values": "HeadlessInstance<UseAccordionPanelProps, UseAccordionPanelState, UseAccordionPanelExposes>"
+        }
+      },
+      "variables": {}
+    }
+  }
+]

package/data/llms/headless/components/accordion.md

@@ -0,0 +1,196 @@
+# useAccordion
+
+Hooks that manage accordion state, keyboard navigation, and ARIA attributes.
+
+```tsx
+'use client';
+import { ChevronDown } from '@primeicons/react/chevron-down';
+import { useAccordion, useAccordionPanel } from '@primereact/headless/accordion';
+
+export default function BasicDemo() {
+    const accordion = useAccordion({ defaultValue: '1' });
+
+    const panel1 = useAccordionPanel({ value: '1', context: accordion });
+    const panel2 = useAccordionPanel({ value: '2', context: accordion });
+    const panel3 = useAccordionPanel({ value: '3', context: accordion });
+
+    const items = [
+        { panel: panel1, title: 'What is PrimeReact?', content: 'PrimeReact is a rich set of open source UI components for React.' },
+        { panel: panel2, title: 'How to get started?', content: 'Install PrimeReact via npm and import the components you need.' },
+        { panel: panel3, title: 'What about accessibility?', content: 'All components follow WAI-ARIA guidelines with full keyboard support.' }
+    ];
+
+    return (
+        <div {...accordion.rootProps} className="max-w-md mx-auto">
+            {items.map(({ panel, title, content }) => (
+                <div key={title} {...panel.panelProps} className="border-b border-surface-200 dark:border-surface-700">
+                    <div {...panel.headerProps}>
+                        <button
+                            {...panel.triggerProps}
+                            className="flex items-center justify-between w-full py-3 px-4 text-left cursor-pointer text-muted-color hover:text-color transition focus-visible:outline-1 focus-visible:-outline-offset-1 focus-visible:outline-primary"
+                        >
+                            <span>{title}</span>
+                            <span {...panel.indicatorProps} className="transition-transform duration-200 data-[open]:rotate-180">
+                                <ChevronDown />
+                            </span>
+                        </button>
+                    </div>
+                    {panel.state.open && (
+                        <div {...panel.contentProps} className="px-4 pb-3 text-surface-600 dark:text-surface-300 text-sm">
+                            {content}
+                        </div>
+                    )}
+                </div>
+            ))}
+        </div>
+    );
+}
+```
+
+## Usage
+
+```tsx
+import { useAccordion, useAccordionPanel } from '@primereact/headless/accordion';
+```
+
+```tsx
+const accordion = useAccordion({ defaultValue: '1' });
+const { rootProps } = accordion;
+
+const { panelProps, headerProps, triggerProps, contentProps, indicatorProps, state } = useAccordionPanel({
+    value: '1',
+    context: accordion
+});
+
+<div {...rootProps}>
+    <div {...panelProps}>
+        <div {...headerProps}>
+            <button {...triggerProps}>
+                <span {...indicatorProps} />
+            </button>
+        </div>
+        {state.open && <div {...contentProps}></div>}
+    </div>
+</div>;
+```
+
+`useAccordion` manages root state while `useAccordionPanel` consumes that context to return prop objects for each panel element, see [Primitive](/docs/primitive/components/accordion) for a component-based API.
+
+## Features
+
+- **Two-hook architecture**, `useAccordion` owns root state and keyboard focus cycling; `useAccordionPanel` consumes its context to render individual panels
+- **Single or multiple expansion**, one open panel at a time or an array of open keys, switchable via the `multiple` flag
+- **Controlled or uncontrolled**, drive the active key(s) from outside or let the hook manage its own state
+- **Focus-triggered expansion**, opt into `openOnFocus` to open a panel the moment its trigger is focused via keyboard
+- **Imperative controls**, `updateValue()` toggles a key and `isItemActive()` checks open state from custom code paths
+- **Full render control**, `state.open` lets you conditionally mount content, pair with CSS, or wire up animation hooks
+
+## Working with callbacks
+
+### Controlled active panel
+
+Drive the open panel from outside state by pairing `value` with `onValueChange`.
+
+```tsx
+const [value, setValue] = React.useState<string | null>('1');
+
+const accordion = useAccordion({
+    value,
+    onValueChange: (e) => setValue(e.value)
+});
+```
+
+`onValueChange` receives `{ originalEvent, value }`, `value` is a single key in single mode or the new array in multiple mode.
+
+### Multiple open panels
+
+Set `multiple` to keep several panels open at once. Both `value` and `defaultValue` become arrays.
+
+```tsx
+const accordion = useAccordion({
+    multiple: true,
+    defaultValue: ['1', '2'],
+    onValueChange: (e) => console.log(e.value) // string[]
+});
+```
+
+### Imperative toggling from custom UI
+
+Use `updateValue` to toggle panels from buttons that live outside the accordion tree, such as a sidebar or toolbar.
+
+```tsx
+const accordion = useAccordion({ multiple: true });
+
+<button onClick={(e) => accordion.updateValue(e, '3')}>Toggle section 3</button>;
+
+if (accordion.isItemActive('2')) {
+    // run logic only when panel 2 is open
+}
+```
+
+In single mode `updateValue` toggles between the key and `null`; in multiple mode it adds or removes the key from the array.
+
+### Animated enter/leave with `state.open`
+
+Because the hook leaves content rendering to you, pair `state.open` with a motion primitive to animate transitions.
+
+```tsx
+const { contentProps, state } = useAccordionPanel({ value: '1', context: accordion });
+
+<AnimatePresence>
+    {state.open && (
+        <motion.div {...contentProps} initial={{ height: 0 }} animate={{ height: 'auto' }} exit={{ height: 0 }}>
+            Panel content
+        </motion.div>
+    )}
+</AnimatePresence>;
+```
+
+For a built-in approach, use the [useMotion](/docs/headless/components/motion) hook alongside `state.open`.
+
+## Styling with data attributes
+
+Every prop object includes `data-scope="accordion"` and a `data-part` attribute. State-dependent attributes are applied automatically so styling can stay in CSS.
+
+| Scope       | Part      | States                                      |
+| ----------- | --------- | ------------------------------------------- |
+| `accordion` | `panel`   | `data-open`, `data-closed`, `data-disabled` |
+| `accordion` | `trigger` | `data-content-open`, `data-content-closed`  |
+| `accordion` | `content` | `data-open`, `data-closed`                  |
+
+```css
+[data-scope='accordion'][data-part='trigger'] {
+    font-weight: 600;
+}
+
+[data-scope='accordion'][data-part='content'][data-open] {
+    animation: slideDown 200ms ease-out;
+}
+
+[data-scope='accordion'][data-part='content'][data-closed] {
+    animation: slideUp 200ms ease-out;
+}
+
+[data-scope='accordion'][data-part='panel'][data-disabled] {
+    opacity: 0.5;
+}
+
+[data-scope='accordion'][data-part='trigger'][data-content-open] {
+    color: blue;
+    font-weight: 700;
+}
+```
+
+## API
+
+### useAccordion
+
+<DocTable name="useAccordion" category="api" />
+
+### useAccordionPanel
+
+<DocTable name="useAccordionPanel" category="api" />
+
+## Accessibility
+
+Arrow keys move between headers, Home/End jump to first/last, and Enter or Space toggles the focused panel. See [Primitive](/docs/primitive/components/accordion#accessibility) for full WAI-ARIA compliance details.

package/data/llms/headless/components/animateonscroll/api.json

@@ -0,0 +1,88 @@
+[
+  {
+    "name": "useAnimateOnScroll",
+    "source": "apps/showcase/assets/apidoc/useanimateonscroll.json",
+    "data": {
+      "description": "The useAnimateOnScroll manages the state and functionality of an AnimateOnScroll component.",
+      "interfaces": {
+        "UseAnimateOnScrollProps": {
+          "description": "Defines valid properties in useAnimateOnScroll.",
+          "relatedProp": "",
+          "extendedTypes": "Pick<IntersectionObserverInit, \"root\" | \"rootMargin\" | \"threshold\">",
+          "props": [
+            {
+              "name": "enterClassName",
+              "type": "string",
+              "default": "",
+              "description": "CSS class names that are applied when the element enters the viewport."
+            },
+            {
+              "name": "leaveClassName",
+              "type": "string",
+              "default": "",
+              "description": "CSS class names that are applied when the element leaves the viewport."
+            },
+            {
+              "name": "once",
+              "type": "boolean",
+              "default": "false",
+              "description": "When enabled, animation is triggered only once."
+            }
+          ],
+          "methods": []
+        },
+        "UseAnimateOnScrollState": {
+          "description": "Defines valid state in useAnimateOnScroll.",
+          "relatedProp": "",
+          "props": [],
+          "methods": []
+        },
+        "UseAnimateOnScrollRootProps": {
+          "description": "Pre-built props for the root element.",
+          "relatedProp": "",
+          "props": [
+            {
+              "name": "data-scope",
+              "type": "string",
+              "default": "",
+              "description": "Component scope identifier."
+            },
+            {
+              "name": "data-part",
+              "type": "string",
+              "default": "",
+              "description": "Component part identifier."
+            }
+          ],
+          "methods": []
+        },
+        "UseAnimateOnScrollExposes": {
+          "description": "Defines the methods and properties exposed by useAnimateOnScroll.",
+          "relatedProp": "",
+          "props": [
+            {
+              "name": "state",
+              "type": "UseAnimateOnScrollState",
+              "default": "",
+              "description": "State of the animate on scroll."
+            },
+            {
+              "name": "rootProps",
+              "type": "UseAnimateOnScrollRootProps",
+              "default": "",
+              "description": "Pre-built props for the root element."
+            }
+          ],
+          "methods": []
+        }
+      },
+      "types": {
+        "UseAnimateOnScrollInstance": {
+          "description": "Instance of useAnimateOnScroll headless.",
+          "values": "HeadlessInstance<UseAnimateOnScrollProps, UseAnimateOnScrollState, UseAnimateOnScrollExposes>"
+        }
+      },
+      "variables": {}
+    }
+  }
+]