igniteui-theming 25.0.0-beta.4 → 25.0.0

package/README.md

@@ -1,4 +1,3 @@
-
 <h1 align="center">
   Ignite UI Theming - from Infragistics 
 </h1>
@@ -8,6 +7,7 @@
 The Ignite UI Theming repository collects a set of Sass mixins, functions, and variables used to create themes for a variety of UI frameworks built by Infragistics. The theming package makes it super easy to create palettes, elevations and typography styles for your projects.
 
 ## Palettes
+
 We provide four predefined palettes - material, bootstrap, fluent and indigo that have all the necessary colors along with diffent variants of those colors to make it even easier picking the right one for your case. Here's what they look like:
 
 ![Palettes](https://user-images.githubusercontent.com/45598235/189592212-0d58b08d-3c98-4f27-8ec3-c6f674c9942b.png)
@@ -18,10 +18,10 @@ To access any of the colors in the palettes, you can use the `color` function:
 background: color($light-material-palette, 'primary', 500);
 ```
 
-You can take a further look on what color functions and mixins the package contains and how to use them in the [Colors Wiki Page](https://github.com/IgniteUI/igniteui-theming/wiki/Colors-(Draft))
-
+You can take a further look on what color functions and mixins the package contains and how to use them in the [Colors Wiki Page](<https://github.com/IgniteUI/igniteui-theming/wiki/Colors-(Draft)>)
 
 ## Typography
+
 Another valuable module of our theming package is the typography, helping you have consistency all over your project. There are again four typography presets for the four themes that we provide out of the box.
 
 ![Typography](https://user-images.githubusercontent.com/45598235/189596034-d8697bc1-e683-4d4a-a113-96e17fc90d4b.png)
@@ -32,9 +32,10 @@ You can set any of the typefaces by using the `typography` mixin, which accepts
 @include typography($font-family: $material-typeface, $type-scale: $material-type-scale);
 ```
 
-Learn more about the typography module in the package by checking out the [Typography Wiki Page](https://github.com/IgniteUI/igniteui-theming/wiki/Typography-(Draft))
+Learn more about the typography module in the package by checking out the [Typography Wiki Page](<https://github.com/IgniteUI/igniteui-theming/wiki/Typography-(Draft)>)
 
 ## Elevations
+
 The theming package is providing one preset of shadows that can be used to give your components a lift. They're super helpful using with buttons, cards, navigation bars, etc.
 
 ![Elevations](https://user-images.githubusercontent.com/45598235/189627744-1fa47d35-6b3b-4b7a-b26e-5b46fe4311a4.png)
@@ -45,7 +46,7 @@ You can set elevations 0-24, by using the `elevation` function, which accepts th
 box-shadow: elevation(12);
 ```
 
-Learn more about elevations and their abilities in the [Elevations Wiki Page](https://github.com/IgniteUI/igniteui-theming/wiki/Elevations-(draft))
+Learn more about elevations and their abilities in the [Elevations Wiki Page](<https://github.com/IgniteUI/igniteui-theming/wiki/Elevations-(draft)>)
 
 ## Usage
 
@@ -106,8 +107,285 @@ npm run serve:docs
 ## Testing and Debugging
 
 ### Preview Palettes
+
 To preview a palette you can pass the palette (`material`, `bootstrap`, `fluent`, `indigo`) and variant (`light` or `dark`) to the `palette` and `variant` arguments respectively. If you want to output the result to a file in the `./dist` folder add the `out` option.
 
 ```
 npm run preview:palette -- --palette=material --variant=light --out
 ```
+
+---
+
+## MCP Server (AI-Assisted Theming)
+
+The Ignite UI Theming package includes a [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server that enables AI assistants to generate production-ready theming code for your Ignite UI applications.
+
+### What is MCP?
+
+The Model Context Protocol allows AI assistants (like Claude, GitHub Copilot, and others) to connect to external tools and data sources. The Ignite UI Theming MCP server acts as an expert theming assistant that can:
+
+- 🎨 **Generate color palettes** with automatic shade variations
+- 📝 **Create typography systems** following design standards
+- 🌓 **Build complete themes** for light and dark modes
+- 🎯 **Customize components** with design tokens
+- ✅ **Validate colors** for accessibility compliance
+
+### Quick Start
+
+#### 1. Clone and Build
+
+Clone the repository and build the MCP server:
+
+```bash
+npm install
+npm run build:mcp
+```
+
+#### 2. Configure Your AI Client
+
+The MCP server works with any MCP-compatible client. Here are setup instructions for popular clients:
+
+<details>
+<summary><strong>VS Code</strong> (with MCP-compatible extensions)</summary>
+
+**For local development** - Create or edit `.vscode/mcp.json`:
+
+```json
+{
+  "mcp.servers": {
+    "igniteui-theming": {
+      "command": "node",
+      "args": ["/absolute/path/to/igniteui-theming/dist/mcp/index.js"]
+    }
+  }
+}
+```
+
+**Using published package**:
+
+```json
+{
+  "mcp.servers": {
+    "igniteui-theming": {
+      "command": "npx",
+      "args": ["-y", "igniteui-theming", "igniteui-theming-mcp"]
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary><strong>WebStorm / JetBrains IDEs</strong></summary>
+
+1. Go to **Settings → Tools → AI Assistant → MCP Servers**
+2. Click **+ Add MCP Server**
+3. Configure:
+   - **Name**: `igniteui-theming`
+   - **Command**: `node` (for local) or `npx` (for package)
+   - **Arguments**:
+     - Local: `/absolute/path/to/igniteui-theming/dist/mcp/index.js`
+     - Package: `igniteui-theming igniteui-theming-mcp`
+4. Click **OK** and restart AI Assistant
+
+</details>
+
+<details>
+<summary><strong>Claude Desktop</strong></summary>
+
+Add to your configuration file:
+
+**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`  
+**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+
+**For local development**:
+
+```json
+{
+  "mcpServers": {
+    "igniteui-theming": {
+      "command": "node",
+      "args": ["/absolute/path/to/igniteui-theming/dist/mcp/index.js"]
+    }
+  }
+}
+```
+
+**Using published package**:
+
+```json
+{
+  "mcpServers": {
+    "igniteui-theming": {
+      "command": "npx",
+      "args": ["-y", "igniteui-theming", "igniteui-theming-mcp"]
+    }
+  }
+}
+```
+
+</details>
+
+<details>
+<summary><strong>Cursor</strong></summary>
+
+Create or edit `.cursor/mcp.json` in your project:
+
+**For local development**:
+
+```json
+{
+  "mcpServers": {
+    "igniteui-theming": {
+      "command": "node",
+      "args": ["/absolute/path/to/igniteui-theming/dist/mcp/index.js"]
+    }
+  }
+}
+```
+
+**Using published package**:
+
+```json
+{
+  "mcpServers": {
+    "igniteui-theming": {
+      "command": "npx",
+      "args": ["-y", "igniteui-theming", "igniteui-theming-mcp"]
+    }
+  }
+}
+```
+
+</details>
+
+### What Can It Do?
+
+#### 🎨 Create Complete Themes
+
+Simply describe your theme to your AI assistant:
+
+> "Create a Material Design dark theme for my Angular app with that takes inspiration from the Gruvbox color scheme."
+
+The AI will generate production-ready Sass code with:
+
+- Color palette with all shade variations
+- Typography setup with proper type scales
+- Elevation shadows
+- Platform-specific imports and configuration
+
+#### 🌈 Generate Color Palettes
+
+> "Generate a light theme palette using teal as primary and purple as secondary"
+
+Get perfectly calculated color shades following design system standards.
+
+#### 📝 Setup Typography
+
+> "Set up typography using Inter font with Material Design type scale for Web Components"
+
+Get proper typography configuration with font families and responsive type scales.
+
+#### 🎯 Customize Components
+
+> "What design tokens are available for the button component?"
+>
+> "Create a flat button theme with purple background and white text"
+
+Discover and customize individual component styles using design tokens.
+
+### Available Capabilities
+
+The MCP server provides **8 tools** and **16 resources**:
+
+#### Tools (Actions)
+
+| Tool                          | Description                                                     |
+| ----------------------------- | --------------------------------------------------------------- |
+| `detect_platform`             | Auto-detect which Ignite UI platform your project uses          |
+| `create_palette`              | Generate color palette with automatic shade calculations        |
+| `create_custom_palette`       | Create palette with fine-grained control over individual shades |
+| `create_typography`           | Setup typography with font families and type scales             |
+| `create_elevations`           | Configure elevation shadows                                     |
+| `create_theme`                | Generate complete theme (palette + typography + elevations)     |
+| `get_component_design_tokens` | Discover customizable properties for components                 |
+| `create_component_theme`      | Generate component-specific theme code                          |
+
+#### Resources (Reference Data)
+
+- **Platform Information**: Configuration for Angular, Web Components, React, and Blazor
+- **Preset Libraries**: Pre-built palettes, typography, and elevation sets
+- **Color Guidance**: Best practices for color selection and usage
+- **Design System Schemas**: Material, Bootstrap, Fluent, and Indigo configurations
+
+### Supported Platforms
+
+- **Angular** - `igniteui-angular`
+- **Web Components** - `igniteui-webcomponents`
+- **React** - `igniteui-react`
+- **Blazor** - `igniteui-blazor`
+
+### Example Interactions
+
+<details>
+<summary><strong>Creating a new project theme</strong></summary>
+
+**You**: "I'm starting a new Angular project with Ignite UI. Create a complete Material Design theme with primary blue, secondary coral, light theme, and Roboto font"
+
+**AI**: _Uses `create_theme` tool and generates complete Sass code ready to use_
+
+</details>
+
+<details>
+<summary><strong>Adding dark mode</strong></summary>
+
+**You**: "I need a dark mode version with the same primary blue but dark surface"
+
+**AI**: _Uses `create_theme` with `variant: "dark"` and generates dark theme code_
+
+</details>
+
+<details>
+<summary><strong>Customizing components</strong></summary>
+
+**You**: "What properties can I customize on the card component?"
+
+**AI**: _Uses `get_component_design_tokens` to show available tokens_
+
+**You**: "Make the card have a light gray background with subtle shadow"
+
+**AI**: _Uses `create_component_theme` to generate component theme code_
+
+</details>
+
+### Full Documentation
+
+For detailed documentation including:
+
+- Complete tool parameter reference
+- All prompt examples
+- Platform-specific differences
+- Troubleshooting guide
+- Development instructions
+
+See the [MCP Server README](./src/mcp/README.md)
+
+### Development Scripts
+
+```bash
+# Build for production
+npm run build:mcp
+
+# Debug with MCP Inspector
+npm run mcp:inspector
+
+# Run tests
+npm run test
+```
+
+---
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/dist/mcp/generators/css.d.ts

@@ -0,0 +1,115 @@
+import { ColorDefinition, GrayDefinition, PLATFORMS, ThemeVariant } from '../utils/types.js';
+/**
+ * Result from generating CSS palette variables.
+ */
+export interface CssPaletteResult {
+    css: string;
+    description: string;
+}
+/**
+ * Result from generating component theme CSS.
+ */
+export interface CssComponentThemeResult {
+    css: string;
+    description: string;
+}
+/**
+ * Options for generating standard palette CSS variables.
+ */
+export interface PaletteCssOptions {
+    primary: string;
+    secondary: string;
+    surface: string;
+    gray?: string;
+    info?: string;
+    success?: string;
+    warn?: string;
+    error?: string;
+    variant?: ThemeVariant;
+    _loadPaths?: string[];
+}
+/**
+ * Generate CSS custom properties for a standard palette.
+ *
+ * This function compiles Sass code that uses the palette() function and
+ * @include palette() mixin, then returns the compiled CSS output.
+ *
+ * @example
+ * const result = await generatePaletteCss({
+ *   primary: '#1976d2',
+ *   secondary: '#ff9800',
+ *   surface: '#fafafa',
+ *   variant: 'light'
+ * });
+ * // result.css contains :root { --ig-primary-50: ...; --ig-primary-100: ...; ... }
+ */
+export declare function generatePaletteCss(options: PaletteCssOptions): Promise<CssPaletteResult>;
+/**
+ * Options for generating custom palette CSS variables.
+ */
+export interface CustomPaletteCssOptions {
+    variant?: ThemeVariant;
+    surfaceColor?: string;
+    colors: {
+        primary: ColorDefinition;
+        secondary: ColorDefinition;
+        surface: ColorDefinition;
+        gray: GrayDefinition;
+        info: ColorDefinition;
+        success: ColorDefinition;
+        warn: ColorDefinition;
+        error: ColorDefinition;
+    };
+    _loadPaths?: string[];
+}
+/**
+ * Generate CSS custom properties for a custom palette.
+ *
+ * This function generates Sass code for the custom palette structure
+ * (using either shades() function or explicit values), compiles it,
+ * and returns the CSS output.
+ */
+export declare function generateCustomPaletteCss(options: CustomPaletteCssOptions): Promise<CssPaletteResult>;
+/**
+ * Format CSS output for display.
+ * Adds a header comment and ensures consistent formatting.
+ */
+export declare function formatCssOutput(css: string, description: string): string;
+/**
+ * Options for generating component theme CSS variables.
+ */
+export interface ComponentThemeCssOptions {
+    platform: (typeof PLATFORMS)[number];
+    /** Design system (defaults to 'material') */
+    designSystem?: string;
+    /** Theme variant - light or dark (defaults to 'light') */
+    variant?: string;
+    /** Component name (e.g., "button", "avatar") */
+    component: string;
+    /** Token name-value pairs */
+    tokens: Record<string, string | number>;
+    /** CSS selector to scope the theme (optional) */
+    selector?: string;
+    /** Custom variable name (optional) */
+    name?: string;
+    /** Internal testing parameter for load paths */
+    _loadPaths?: string[];
+}
+/**
+ * Generate CSS custom properties for a component theme.
+ *
+ * This function compiles Sass code that uses the component theme function
+ * and @include tokens() mixin, then returns the compiled CSS output.
+ *
+ * @example
+ * const result = await generateComponentThemeCss({
+ *   platform: 'webcomponents',
+ *   designSystem: 'bootstrap',
+ *   variant: 'light',
+ *   component: 'button',
+ *   tokens: { background: '#1976d2', 'text-color': 'white' },
+ *   selector: 'igc-button'
+ * });
+ * // result.css contains: igc-button { --ig-button-background: var(--ig-button-background, #1976d2); ... }
+ */
+export declare function generateComponentThemeCss(options: ComponentThemeCssOptions): Promise<CssComponentThemeResult>;

package/dist/mcp/generators/css.js

@@ -0,0 +1,143 @@
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import * as sass from "sass-embedded";
+const __filename$1 = fileURLToPath(import.meta.url);
+const __dirname$1 = path.dirname(__filename$1);
+const PACKAGE_ROOT = path.resolve(__dirname$1, "..", "..", "..");
+async function generatePaletteCss(options) {
+  const variant = options.variant ?? "light";
+  const paletteArgs = [
+    `$primary: ${options.primary}`,
+    `$secondary: ${options.secondary}`,
+    `$surface: ${options.surface}`
+  ];
+  if (options.gray) paletteArgs.push(`$gray: ${options.gray}`);
+  if (options.info) paletteArgs.push(`$info: ${options.info}`);
+  if (options.success) paletteArgs.push(`$success: ${options.success}`);
+  if (options.warn) paletteArgs.push(`$warn: ${options.warn}`);
+  if (options.error) paletteArgs.push(`$error: ${options.error}`);
+  const sassCode = `
+@use 'sass/color' as *;
+
+$palette: palette(
+  ${paletteArgs.join(",\n  ")}
+);
+
+@include palette($palette);
+`;
+  try {
+    const loadPaths = options._loadPaths ?? [PACKAGE_ROOT];
+    const result = await sass.compileStringAsync(sassCode, {
+      loadPaths,
+      style: "expanded"
+    });
+    return {
+      css: result.css,
+      description: `Generated CSS custom properties for a ${variant} palette with primary color ${options.primary}`
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to compile palette CSS: ${message}`);
+  }
+}
+async function generateCustomPaletteCss(options) {
+  const variant = options.variant ?? "light";
+  const { generateCustomPaletteCode } = await import("../utils/sass.js");
+  const paletteLines = generateCustomPaletteCode({
+    variant,
+    variableName: "custom",
+    surfaceColor: options.surfaceColor,
+    colors: options.colors
+  });
+  const sassCode = `
+@use 'sass/color' as *;
+
+${paletteLines.join("\n")}
+
+@include palette($custom-palette);
+`;
+  try {
+    const loadPaths = options._loadPaths ?? [PACKAGE_ROOT];
+    const result = await sass.compileStringAsync(sassCode, {
+      loadPaths,
+      style: "expanded"
+    });
+    return {
+      css: result.css,
+      description: `Generated CSS custom properties for a custom ${variant} palette`
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to compile custom palette CSS: ${message}`);
+  }
+}
+function formatCssOutput(css, description) {
+  const header = `/* Generated by Ignite UI Theming MCP Server */
+/* ${description} */
+`;
+  return header + css;
+}
+async function generateComponentThemeCss(options) {
+  const {
+    getComponentTheme,
+    getComponentSelector,
+    getVariablePrefix,
+    SCHEMA_PRESETS
+  } = await import("../knowledge/index.js");
+  const { toVariableName } = await import("../utils/sass.js");
+  const theme = getComponentTheme(options.component);
+  if (!theme) {
+    throw new Error(`Unknown component: ${options.component}`);
+  }
+  const designSystem = options.designSystem ?? "material";
+  const variant = options.variant ?? "light";
+  const themeFn = theme.themeFunctionName;
+  const themeName = options.name ? `$${toVariableName(options.name)}` : `$custom-${options.component}-theme`;
+  const schemaVar = SCHEMA_PRESETS[variant][designSystem];
+  const tokenArgs = [`$schema: ${schemaVar}`];
+  for (const [tokenName, value] of Object.entries(options.tokens)) {
+    const stringValue = typeof value === "number" ? String(value) : value;
+    tokenArgs.push(`$${tokenName}: ${stringValue}`);
+  }
+  const defaultSelectors = getComponentSelector(
+    options.component,
+    options.platform
+  );
+  const selector = options.selector || (defaultSelectors.length > 0 ? defaultSelectors[0] : options.component);
+  const prefix = getVariablePrefix(options.platform);
+  `${prefix}-${options.component}`;
+  const sassCode = `
+@use 'sass/themes' as *;
+@use 'sass/themes/schemas' as *;
+
+// Custom ${options.component} theme
+${themeName}: ${themeFn}(
+  ${tokenArgs.join(",\n  ")}
+);
+
+// Apply the theme to ${selector}
+${selector} {
+  @include tokens(${themeName});
+}
+`;
+  try {
+    const loadPaths = options._loadPaths ?? [PACKAGE_ROOT];
+    const result = await sass.compileStringAsync(sassCode, {
+      loadPaths,
+      style: "expanded"
+    });
+    return {
+      css: result.css,
+      description: `Generated CSS custom properties for ${options.component} component with ${Object.keys(options.tokens).length} token(s) using ${designSystem} design system (${variant} variant)`
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Failed to compile component theme CSS: ${message}`);
+  }
+}
+export {
+  formatCssOutput,
+  generateComponentThemeCss,
+  generateCustomPaletteCss,
+  generatePaletteCss
+};

package/dist/mcp/generators/sass.d.ts

@@ -0,0 +1,50 @@
+import { CreateElevationsInput, CreatePaletteInput, CreateThemeInput, CreateTypographyInput, DesignSystem, GeneratedCode, Platform, ThemeVariant } from '../utils/types.js';
+export type { ElevationsCodeOptions, PaletteCodeOptions, PaletteCodeResult, TypographyCodeOptions, } from '../utils/sass.js';
+export { generateElevationsCode, generateHeader, generatePaletteCode, generateTypographyCode, generateUseStatement, quoteFontFamily, toVariableName, } from '../utils/sass.js';
+/**
+ * Generate a palette definition.
+ */
+export declare function generatePalette(input: CreatePaletteInput): GeneratedCode;
+/**
+ * Generate typography setup.
+ */
+export declare function generateTypography(input: CreateTypographyInput): GeneratedCode;
+/**
+ * Generate elevations setup.
+ */
+export declare function generateElevations(input: CreateElevationsInput): GeneratedCode;
+/**
+ * Generate a complete theme (palette + typography + elevations).
+ *
+ * Supports two platforms:
+ * - `angular`: Uses `igniteui-angular/theming` with `core()` and `theme()` mixins
+ * - `webcomponents`: Uses `igniteui-theming` directly with individual mixins
+ *
+ * If no platform is specified, defaults to generating platform-agnostic code
+ * using igniteui-theming directly (similar to webcomponents but simpler).
+ */
+export declare function generateTheme(input: CreateThemeInput): GeneratedCode;
+/**
+ * Input for generating a component theme.
+ */
+export interface CreateComponentThemeInput {
+    platform: Platform;
+    /** Whether to use licensed @infragistics package (Angular only, defaults to false) */
+    licensed?: boolean;
+    /** Design system (defaults to 'material') */
+    designSystem?: DesignSystem;
+    /** Theme variant - light or dark (defaults to 'light') */
+    variant?: ThemeVariant;
+    /** Component name (e.g., "flat-button", "avatar") */
+    component: string;
+    /** Token name-value pairs */
+    tokens: Record<string, string | number>;
+    /** Optional CSS selector to scope the theme */
+    selector?: string;
+    /** Optional custom variable name */
+    name?: string;
+}
+/**
+ * Generate Sass code for a component theme.
+ */
+export declare function generateComponentTheme(input: CreateComponentThemeInput): GeneratedCode;