@ai-react-markdown/mantine 1.8.0 → 2.0.1

package/dist/index.d.ts

@@ -1,48 +1,39 @@
 import * as react from 'react';
-import * as _ai_react_markdown_core from '@ai-react-markdown/core';
-import { AIMarkdownMetadata, AIMarkdownRenderConfig, AIMarkdownProps, AIMarkdownTypographyProps, AIMarkdownExtraStylesComponent } from '@ai-react-markdown/core';
+import { AIMarkdownMetadata, AIMarkdownProps, AIMarkdownTypographyProps, AIMarkdownExtraStylesComponent, AIMarkdownBehaviorProps } from '@ai-react-markdown/core';
 
 /**
- * Mantine-specific type definitions and default configuration.
- *
- * Extends the core {@link AIMarkdownRenderConfig} and {@link AIMarkdownMetadata}
- * with Mantine-themed options such as uniform heading sizes and code block behavior.
+ * Mantine-specific type definitions and defaults: the `codeBlock` behavior
+ * group and the metadata extension point.
  *
  * @module defs
  */
 
 /**
- * Extended render configuration for the Mantine integration.
+ * Code block rendering options (the mantine `codeBlock` behavior group).
  *
- * Inherits all core config fields (extra syntax, display optimizations) and adds
- * Mantine-specific options for typography sizing and code block behavior.
+ * v2 transport: passed as the flat `codeBlock` prop on `MantineAIMarkdown`
+ * (group value replaces atomically) and read through
+ * `useMantineCodeBlockOptions()`, which applies the defaults below inside
+ * the hook — the single place defaults live at read time.
  */
-interface MantineAIMarkdownRenderConfig extends AIMarkdownRenderConfig {
-    /** Code block rendering options. */
-    codeBlock: {
-        /**
-         * Whether code blocks start in their expanded state.
-         * When `false`, long code blocks are collapsed with an expand button.
-         *
-         * @default true
-         */
-        defaultExpanded: boolean;
-        /**
-         * When `true`, uses `highlight.js` auto-detection to determine the language
-         * of code blocks that lack an explicit language annotation.
-         *
-         * @default false
-         */
-        autoDetectUnknownLanguage: boolean;
-    };
+interface MantineCodeBlockOptions {
+    /**
+     * Whether code blocks start in their expanded state.
+     * When `false`, long code blocks are collapsed with an expand button.
+     *
+     * @default true
+     */
+    defaultExpanded: boolean;
+    /**
+     * When `true`, uses `highlight.js` auto-detection to determine the language
+     * of code blocks that lack an explicit language annotation.
+     *
+     * @default false
+     */
+    autoDetectUnknownLanguage: boolean;
 }
-/**
- * Default Mantine render configuration.
- *
- * Extends {@link defaultAIMarkdownRenderConfig} with Mantine-specific defaults.
- * Frozen to prevent accidental mutation.
- */
-declare const defaultMantineAIMarkdownRenderConfig: MantineAIMarkdownRenderConfig;
+/** Shipped defaults for the `codeBlock` behavior group. */
+declare const defaultMantineCodeBlockOptions: Readonly<MantineCodeBlockOptions>;
 /**
  * Metadata type for the Mantine integration.
  *
@@ -56,13 +47,19 @@ interface MantineAIMarkdownMetadata extends AIMarkdownMetadata {
 /**
  * Props for the {@link MantineAIMarkdown} component.
  *
- * Extends {@link AIMarkdownProps} with Mantine-specific config and metadata generics.
- * All core props (`content`, `streaming`, `fontSize`, `config`, etc.) are inherited.
+ * Extends {@link AIMarkdownProps} with the mantine behavior groups.
+ * All core props (`content`, `streaming`, `fontSize`, `enginePlugins`, etc.)
+ * are inherited.
  *
- * @typeParam TConfig - Render configuration type, defaults to {@link MantineAIMarkdownRenderConfig}.
- * @typeParam TRenderData - Metadata type, defaults to {@link MantineAIMarkdownMetadata}.
+ * @typeParam TMetadata - Metadata type, defaults to {@link MantineAIMarkdownMetadata}.
  */
-interface MantineAIMarkdownProps<TConfig extends MantineAIMarkdownRenderConfig = MantineAIMarkdownRenderConfig, TRenderData extends MantineAIMarkdownMetadata = MantineAIMarkdownMetadata> extends AIMarkdownProps<TConfig, TRenderData> {
+interface MantineAIMarkdownProps<TMetadata extends MantineAIMarkdownMetadata = MantineAIMarkdownMetadata> extends AIMarkdownProps<TMetadata> {
+    /**
+     * Code-block behavior group (Behaviors system). The group value replaces
+     * atomically; omitted fields resolve to the shipped defaults inside
+     * `useMantineCodeBlockOptions()`. `null` counts as absent.
+     */
+    codeBlock?: Partial<MantineCodeBlockOptions>;
 }
 /**
  * Inner (non-memoized) implementation of the Mantine AI markdown component.
@@ -71,10 +68,9 @@ interface MantineAIMarkdownProps<TConfig extends MantineAIMarkdownRenderConfig =
  * overrides take precedence). Automatically resolves the color scheme from Mantine's
  * `useComputedColorScheme` when no explicit `colorScheme` prop is provided.
  *
- * @typeParam TConfig - Render configuration type.
- * @typeParam TRenderData - Metadata type.
+ * @typeParam TMetadata - Metadata type.
  */
-declare const MantineAIMarkdownComponent: <TConfig extends MantineAIMarkdownRenderConfig = MantineAIMarkdownRenderConfig, TRenderData extends MantineAIMarkdownMetadata = MantineAIMarkdownMetadata>({ Typography, ExtraStyles, defaultConfig, customComponents, colorScheme, ...props }: MantineAIMarkdownProps<TConfig, TRenderData>) => react.JSX.Element;
+declare const MantineAIMarkdownComponent: <TMetadata extends MantineAIMarkdownMetadata = MantineAIMarkdownMetadata>({ Typography, ExtraStyles, customComponents, colorScheme, codeBlock, ...props }: MantineAIMarkdownProps<TMetadata>) => react.JSX.Element;
 declare const _default: typeof MantineAIMarkdownComponent;
 
 /**
@@ -105,29 +101,48 @@ declare const MantineAIMarkdownTypography: react.MemoExoticComponent<({ children
 declare const MantineAIMDefaultExtraStyles: AIMarkdownExtraStylesComponent;
 
 /**
- * Typed wrapper around the core {@link useAIMarkdownRenderState} hook.
+ * Narrow hook for the mantine `codeBlock` behavior group.
  *
- * Returns the current {@link AIMarkdownRenderState} defaulting to
- * {@link MantineAIMarkdownRenderConfig}. Accepts an optional generic parameter
- * for further extension, giving consumers direct access to Mantine-specific
- * config fields (`codeBlock`, etc.) without manual annotation.
+ * This is THE single type-assertion site for the group (the pattern that
+ * retires the public caller-asserted `TConfig` generic): the opaque
+ * extension record from `useAIMarkdownBehaviors()` is narrowed here, and
+ * group defaults are applied here — read sites must consume this hook and
+ * never re-apply defaults with bare `??` (multiple read sites duplicating
+ * defaults will drift).
  *
- * Must be called inside a component rendered within the `<MantineAIMarkdown>` tree.
- * Throws if called outside the provider boundary.
+ * @module hooks/useMantineCodeBlockOptions
+ */
+
+/**
+ * Read the resolved code-block options from the behaviors context.
  *
- * @typeParam TConfig - Config type (defaults to {@link MantineAIMarkdownRenderConfig}).
- * @returns The current render state typed with `TConfig`.
+ * Group values replace atomically at the transport layer; defaults are
+ * filled in here, so a partial group (e.g. `codeBlock={{ defaultExpanded:
+ * false }}`) resolves the omitted fields to the shipped defaults.
  *
- * @example
- * ```tsx
- * function MyComponent() {
- *   const { config, streaming, colorScheme } = useMantineAIMarkdownRenderState();
- *   const isExpanded = config.codeBlock.defaultExpanded;
- *   // ...
- * }
- * ```
+ * Must be called inside a `<MantineAIMarkdown>` (or any `<AIMarkdown>`
+ * wrapped in the mantine Provider stack) — throws outside, same contract
+ * as the core narrow hooks.
  */
-declare const useMantineAIMarkdownRenderState: <TConfig extends MantineAIMarkdownRenderConfig = MantineAIMarkdownRenderConfig>() => _ai_react_markdown_core.AIMarkdownRenderState<TConfig>;
+declare function useMantineCodeBlockOptions(): Required<MantineCodeBlockOptions>;
+
+/**
+ * Widened `define*` factory for the mantine wrapper (EXECUTION-PLAN §4
+ * item 8): identity + mantine prop types + freeze, zero logic. Core
+ * factories accept core fields only — passing `codeBlock` to core's
+ * `defineBehaviors` is a TS error; this widened factory is the wrapper's
+ * one-line obligation.
+ *
+ * @module define
+ */
+
+/** Behavior-system props packagable at integration time, mantine-widened. */
+interface MantineBehaviorProps extends AIMarkdownBehaviorProps {
+    /** The mantine `codeBlock` behavior group (atomic replacement; defaults applied at read time). */
+    codeBlock?: Partial<MantineCodeBlockOptions>;
+}
+/** Freeze a mantine behaviors fragment. Identity + types + freeze; zero logic. */
+declare function defineMantineBehaviors(values: MantineBehaviorProps): Readonly<MantineBehaviorProps>;
 
 /**
  * Typed wrapper around the core {@link useAIMarkdownMetadata} hook.
@@ -154,4 +169,4 @@ declare const useMantineAIMarkdownRenderState: <TConfig extends MantineAIMarkdow
  */
 declare const useMantineAIMarkdownMetadata: <TMetadata extends MantineAIMarkdownMetadata = MantineAIMarkdownMetadata>() => TMetadata | undefined;
 
-export { MantineAIMDefaultExtraStyles, type MantineAIMarkdownMetadata, type MantineAIMarkdownProps, type MantineAIMarkdownRenderConfig, MantineAIMarkdownTypography, _default as default, defaultMantineAIMarkdownRenderConfig, useMantineAIMarkdownMetadata, useMantineAIMarkdownRenderState };
+export { MantineAIMDefaultExtraStyles, type MantineAIMarkdownMetadata, type MantineAIMarkdownProps, MantineAIMarkdownTypography, type MantineBehaviorProps, type MantineCodeBlockOptions, _default as default, defaultMantineCodeBlockOptions, defineMantineBehaviors, useMantineAIMarkdownMetadata, useMantineCodeBlockOptions };

package/dist/index.js

@@ -1,7 +1,12 @@
 // src/MantineAIMarkdown.tsx
-import { memo as memo4, useMemo as useMemo2 } from "react";
+import { memo as memo4, useMemo as useMemo3 } from "react";
 import AIMarkdown from "@ai-react-markdown/core";
-import { useStableValue } from "@ai-react-markdown/core";
+import {
+  AIMarkdownBehaviorsProvider,
+  AIMarkdownStabilityPolicy,
+  useStableRecord,
+  useStableValue
+} from "@ai-react-markdown/core";
 
 // src/components/typography/MantineTypography.tsx
 import { memo } from "react";
@@ -18,33 +23,36 @@ var MantineAIMDefaultExtraStyles = ({ children }) => {
 };
 var DefaultExtraStyles_default = MantineAIMDefaultExtraStyles;
 
-// src/defs.tsx
-import { defaultAIMarkdownRenderConfig } from "@ai-react-markdown/core";
-var defaultMantineAIMarkdownRenderConfig = Object.freeze({
-  ...defaultAIMarkdownRenderConfig,
-  codeBlock: Object.freeze({
-    defaultExpanded: true,
-    autoDetectUnknownLanguage: false
-  })
-});
-
 // src/components/customized/PreCode.tsx
-import { memo as memo3, useMemo } from "react";
+import { memo as memo3, useMemo as useMemo2 } from "react";
 import { CodeHighlight, CodeHighlightTabs as CodeHighlightTabs2 } from "@mantine/code-highlight";
 import { deepParseJson } from "deep-parse-json";
 import hljs from "highlight.js";
+import { useAIMarkdownTheme as useAIMarkdownTheme2 } from "@ai-react-markdown/core";
 
-// src/hooks/useMantineAIMarkdownRenderState.ts
-import { useAIMarkdownRenderState } from "@ai-react-markdown/core";
-var useMantineAIMarkdownRenderState = () => {
-  return useAIMarkdownRenderState();
-};
+// src/hooks/useMantineCodeBlockOptions.ts
+import { useMemo } from "react";
+import { useAIMarkdownBehaviors } from "@ai-react-markdown/core";
+
+// src/defs.tsx
+var defaultMantineCodeBlockOptions = Object.freeze({
+  defaultExpanded: true,
+  autoDetectUnknownLanguage: false
+});
+
+// src/hooks/useMantineCodeBlockOptions.ts
+function useMantineCodeBlockOptions() {
+  const behaviors = useAIMarkdownBehaviors();
+  const group = behaviors.codeBlock;
+  return useMemo(() => ({ ...defaultMantineCodeBlockOptions, ...group }), [group]);
+}
 
 // src/components/customized/MermaidCode/index.tsx
 import { memo as memo2, useEffect, useRef, useState, useCallback } from "react";
 import { CodeHighlightControl, CodeHighlightTabs } from "@mantine/code-highlight";
 import { ActionIcon, CopyButton, Flex, Tooltip } from "@mantine/core";
 import mermaid from "mermaid";
+import { useAIMarkdownState, useAIMarkdownTheme } from "@ai-react-markdown/core";
 import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
 var PRE_STYLE = { cursor: "pointer", overflow: "auto", width: "100%", padding: "0.5rem" };
 var sameView = (a, b) => a.kind === "diagram" && b.kind === "diagram" ? a.chartType === b.chartType : a.kind === b.kind;
@@ -82,9 +90,10 @@ var handleViewSVGInNewWindow = (svgElement, isDark) => {
   }
 };
 var MantineAIMMermaidCode = memo2((props) => {
-  const renderState = useMantineAIMarkdownRenderState();
-  const isDark = renderState.colorScheme === "dark";
-  const streaming = renderState.streaming;
+  const { colorScheme, fontSize } = useAIMarkdownTheme();
+  const { streaming } = useAIMarkdownState();
+  const { defaultExpanded } = useMantineCodeBlockOptions();
+  const isDark = colorScheme === "dark";
   const ref = useRef(null);
   const renderVersionRef = useRef(0);
   const viewRef = useRef({ kind: "source" });
@@ -169,7 +178,7 @@ var MantineAIMMermaidCode = memo2((props) => {
       CodeHighlightTabs,
       {
         mb: 15,
-        fz: renderState.fontSize,
+        fz: fontSize,
         w: "100%",
         code: [
           {
@@ -178,7 +187,7 @@ var MantineAIMMermaidCode = memo2((props) => {
             language: "mermaid"
           }
         ],
-        defaultExpanded: renderState.config.codeBlock.defaultExpanded,
+        defaultExpanded,
         maxCollapsedHeight: "320px",
         styles: {
           filesScrollarea: {
@@ -273,15 +282,16 @@ var SpecialCodeLanguage = /* @__PURE__ */ ((SpecialCodeLanguage2) => {
 var SPECIAL_LANGUAGES = new Set(Object.values(SpecialCodeLanguage));
 var MantineAIMPreCode = memo3(
   (props) => {
-    const renderState = useMantineAIMarkdownRenderState();
-    const codeLanguage = useMemo(() => {
+    const { fontSize } = useAIMarkdownTheme2();
+    const { autoDetectUnknownLanguage, defaultExpanded } = useMantineCodeBlockOptions();
+    const codeLanguage = useMemo2(() => {
       if (props.existLanguage) return props.existLanguage;
-      if (renderState.config.codeBlock.autoDetectUnknownLanguage) {
+      if (autoDetectUnknownLanguage) {
         return hljs.highlightAuto(props.codeText).language || "";
       }
       return "";
-    }, [props.existLanguage, props.codeText, renderState.config.codeBlock.autoDetectUnknownLanguage]);
-    const [usedCodeLanguage, usedFileName] = useMemo(() => {
+    }, [props.existLanguage, props.codeText, autoDetectUnknownLanguage]);
+    const [usedCodeLanguage, usedFileName] = useMemo2(() => {
       if (!codeLanguage) return ["plaintext", "unknown"];
       if (!hljs.getLanguage(codeLanguage)) {
         return ["plaintext", codeLanguage];
@@ -289,7 +299,7 @@ var MantineAIMPreCode = memo3(
       return [codeLanguage, codeLanguage];
     }, [codeLanguage]);
     const isSpecialCodeBlock = SPECIAL_LANGUAGES.has(codeLanguage);
-    const normalCodeBlockContent = useMemo(() => {
+    const normalCodeBlockContent = useMemo2(() => {
       if (isSpecialCodeBlock) return null;
       let usedCodeStr = props.codeText;
       if (usedCodeStr && usedCodeLanguage.toLowerCase() === "json") {
@@ -300,19 +310,19 @@ var MantineAIMPreCode = memo3(
         CodeHighlight,
         {
           mb: 15,
-          fz: renderState.fontSize,
+          fz: fontSize,
           w: "100%",
           code: usedCodeStr,
           withBorder: true,
           withExpandButton: true,
-          defaultExpanded: renderState.config.codeBlock.defaultExpanded,
+          defaultExpanded,
           maxCollapsedHeight: "320px"
         }
       ) : /* @__PURE__ */ jsx4(
         CodeHighlightTabs2,
         {
           mb: 15,
-          fz: renderState.fontSize,
+          fz: fontSize,
           w: "100%",
           code: [
             {
@@ -323,19 +333,12 @@ var MantineAIMPreCode = memo3(
           ],
           withBorder: true,
           withExpandButton: true,
-          defaultExpanded: renderState.config.codeBlock.defaultExpanded,
+          defaultExpanded,
           maxCollapsedHeight: "320px"
         }
       );
-    }, [
-      isSpecialCodeBlock,
-      props.codeText,
-      usedCodeLanguage,
-      usedFileName,
-      renderState.fontSize,
-      renderState.config.codeBlock.defaultExpanded
-    ]);
-    const specialCodeBlockContent = useMemo(() => {
+    }, [isSpecialCodeBlock, props.codeText, usedCodeLanguage, usedFileName, fontSize, defaultExpanded]);
+    const specialCodeBlockContent = useMemo2(() => {
       switch (codeLanguage) {
         case "mermaid" /* Mermaid */:
           return /* @__PURE__ */ jsx4(MermaidCode_default, { code: props.codeText });
@@ -352,6 +355,10 @@ var PreCode_default = MantineAIMPreCode;
 // src/MantineAIMarkdown.tsx
 import { useComputedColorScheme } from "@mantine/core";
 import { jsx as jsx5 } from "react/jsx-runtime";
+var EMPTY_CODE_BLOCK = Object.freeze({});
+var MANTINE_STABILITY_TABLE = {
+  codeBlock: AIMarkdownStabilityPolicy.DEEP_EQUAL
+};
 var DefaultCustomComponents = {
   pre: ({ node, ...usefulProps }) => {
     const code = node?.children[0];
@@ -367,32 +374,38 @@ var DefaultCustomComponents = {
 var MantineAIMarkdownComponent = ({
   Typography: Typography2 = MantineTypography_default,
   ExtraStyles = DefaultExtraStyles_default,
-  defaultConfig = defaultMantineAIMarkdownRenderConfig,
   customComponents,
   colorScheme,
+  codeBlock,
   ...props
 }) => {
   const stableCustomComponents = useStableValue(customComponents);
-  const usedComponents = useMemo2(() => {
+  const usedComponents = useMemo3(() => {
     return stableCustomComponents ? { ...DefaultCustomComponents, ...stableCustomComponents } : DefaultCustomComponents;
   }, [stableCustomComponents]);
   const computedColorScheme = useComputedColorScheme("light");
-  return /* @__PURE__ */ jsx5(
+  const stable = useStableRecord({ codeBlock }, MANTINE_STABILITY_TABLE);
+  const behaviorGroups = useMemo3(() => ({ codeBlock: stable.codeBlock ?? EMPTY_CODE_BLOCK }), [stable.codeBlock]);
+  return /* @__PURE__ */ jsx5(AIMarkdownBehaviorsProvider, { value: behaviorGroups, children: /* @__PURE__ */ jsx5(
     AIMarkdown,
     {
       Typography: Typography2,
       ExtraStyles,
-      defaultConfig,
       customComponents: usedComponents,
       colorScheme: colorScheme ?? computedColorScheme,
       ...props
     }
-  );
+  ) });
 };
 var MantineAIMarkdown = memo4(MantineAIMarkdownComponent);
 MantineAIMarkdown.displayName = "MantineAIMarkdown";
 var MantineAIMarkdown_default = MantineAIMarkdown;
 
+// src/define.ts
+function defineMantineBehaviors(values) {
+  return Object.freeze(values);
+}
+
 // src/hooks/useMantineAIMarkdownMetadata.ts
 import { useAIMarkdownMetadata } from "@ai-react-markdown/core";
 var useMantineAIMarkdownMetadata = () => {
@@ -402,8 +415,9 @@ export {
   DefaultExtraStyles_default as MantineAIMDefaultExtraStyles,
   MantineTypography_default as MantineAIMarkdownTypography,
   MantineAIMarkdown_default as default,
-  defaultMantineAIMarkdownRenderConfig,
+  defaultMantineCodeBlockOptions,
+  defineMantineBehaviors,
   useMantineAIMarkdownMetadata,
-  useMantineAIMarkdownRenderState
+  useMantineCodeBlockOptions
 };
 //# sourceMappingURL=index.js.map