docusaurus-plugin-glossary 3.0.2 → 3.2.0

package/dist/remark/glossary-terms.js

@@ -1,440 +1,9 @@
-import { visit } from 'unist-util-visit';
-import path from 'path';
-import fs from 'fs';
-
-/**
- * Simple validation for glossary terms loaded from file
- * Returns only valid terms with required fields
- *
- * @param {unknown} data - The parsed JSON data
- * @param {string} filePath - Path to the file (for error messages)
- * @returns {{ terms: Array<{term: string, definition: string}>, errors: string[] }}
- */
-function validateGlossaryTerms(data, _filePath) {
-  const errors = [];
-  const validTerms = [];
-
-  if (data === null || data === undefined) {
-    errors.push(`Glossary data is null or undefined`);
-    return { terms: [], errors };
-  }
-
-  if (typeof data !== 'object') {
-    errors.push(`Glossary data must be an object, got ${typeof data}`);
-    return { terms: [], errors };
-  }
-
-  if (!('terms' in data)) {
-    errors.push(`Glossary data must contain a "terms" array`);
-    return { terms: [], errors };
-  }
-
-  if (!Array.isArray(data.terms)) {
-    errors.push(`Field "terms" must be an array, got ${typeof data.terms}`);
-    return { terms: [], errors };
-  }
-
-  data.terms.forEach((term, index) => {
-    if (term === null || term === undefined || typeof term !== 'object') {
-      errors.push(`terms[${index}]: Term must be an object`);
-      return;
-    }
-
-    if (typeof term.term !== 'string' || term.term.trim() === '') {
-      errors.push(`terms[${index}]: Missing or invalid "term" field`);
-      return;
-    }
-
-    if (typeof term.definition !== 'string') {
-      errors.push(`terms[${index}]: Missing or invalid "definition" field`);
-      return;
-    }
-
-    validTerms.push(term);
-  });
-
-  return { terms: validTerms, errors };
-}
-
-// Cache for glossary data to avoid repeated synchronous file reads
-// Key: absolute file path, Value: { terms, loadedAt }
-const glossaryCache = new Map();
-const CACHE_TTL = 5000; // 5 seconds TTL to allow for file changes during dev
-
-/**
- * Creates a remark plugin that automatically detects and replaces glossary terms in markdown
- *
- * This plugin transforms plain text terms into <GlossaryTerm> JSX elements.
- * The GlossaryTerm component is globally available via the MDXComponents theme wrapper,
- * so no import injection is needed - MDX files can use it without explicit imports.
- *
- * @param {object} options - Plugin options
- * @param {Array} options.terms - Array of glossary term objects with {term, definition}
- * @param {string} options.glossaryPath - Path to glossary JSON file (optional, if terms not provided)
- * @param {string} options.routePath - Route path to glossary page (default: '/glossary')
- * @param {string} options.siteDir - Docusaurus site directory (required if using glossaryPath)
- * @returns {function} Remark plugin function
- */
-export default function remarkGlossaryTerms({
-  terms = [],
-  glossaryPath = null,
-  routePath = '/glossary',
-  siteDir = null,
-} = {}) {
-  let glossaryTerms = terms;
-
-  // If terms not provided, try to load from glossaryPath with caching
-  if (!glossaryTerms.length && glossaryPath && siteDir) {
-    try {
-      const glossaryFilePath = path.resolve(siteDir, glossaryPath);
-      const now = Date.now();
-
-      // Check cache first to avoid repeated file reads
-      const cached = glossaryCache.get(glossaryFilePath);
-      if (cached && now - cached.loadedAt < CACHE_TTL) {
-        glossaryTerms = cached.terms;
-      } else {
-        // Cache miss or expired - load from file synchronously
-        // Note: This is synchronous I/O which can block the build process
-        // Consider passing terms directly to avoid this
-        if (fs.existsSync(glossaryFilePath)) {
-          const fileContent = fs.readFileSync(glossaryFilePath, 'utf8');
-          let glossaryData;
-          try {
-            glossaryData = JSON.parse(fileContent);
-          } catch (parseError) {
-            console.error(
-              `[glossary-plugin] Failed to parse glossary JSON at ${glossaryPath}:`,
-              parseError.message
-            );
-            glossaryCache.set(glossaryFilePath, {
-              terms: [],
-              loadedAt: now,
-            });
-            return tree => tree;
-          }
-
-          // Validate glossary data
-          const { terms: validTerms, errors } = validateGlossaryTerms(glossaryData, glossaryPath);
-
-          if (errors.length > 0) {
-            console.warn(`[glossary-plugin] Glossary validation errors in ${glossaryPath}:`);
-            errors.forEach(err => console.warn(`  - ${err}`));
-            if (validTerms.length > 0) {
-              console.warn(`[glossary-plugin] Proceeding with ${validTerms.length} valid term(s).`);
-            }
-          }
-
-          glossaryTerms = validTerms;
-
-          // Update cache
-          glossaryCache.set(glossaryFilePath, {
-            terms: glossaryTerms,
-            loadedAt: now,
-          });
-
-          // Log only once per file (when cache is first populated)
-          if (!cached && process.env.NODE_ENV !== 'production') {
-            console.log(
-              `[glossary-plugin] Loaded ${glossaryTerms.length} terms from ${glossaryPath}`
-            );
-          }
-        } else {
-          // File doesn't exist - cache empty result to avoid repeated checks
-          glossaryCache.set(glossaryFilePath, {
-            terms: [],
-            loadedAt: now,
-          });
-          if (process.env.NODE_ENV !== 'production') {
-            console.warn(`[glossary-plugin] Glossary file not found: ${glossaryPath}`);
-          }
-        }
-      }
-    } catch (error) {
-      console.warn(
-        `[glossary-plugin] Failed to load glossary from ${glossaryPath}:`,
-        error.message
-      );
-      // Cache the error to avoid repeated attempts
-      if (glossaryPath && siteDir) {
-        const glossaryFilePath = path.resolve(siteDir, glossaryPath);
-        glossaryCache.set(glossaryFilePath, {
-          terms: [],
-          loadedAt: Date.now(),
-        });
-      }
-    }
-  }
-
-  // Build a map of terms for efficient lookup
-  // Key: lowercase term, Value: term object with original case
-  const termMap = new Map();
-  glossaryTerms.forEach(termObj => {
-    if (termObj.term) {
-      termMap.set(termObj.term.toLowerCase(), termObj);
-    }
-  });
-
-  // Sort terms by length (longest first) to avoid partial matches
-  // e.g., "Application Programming Interface" should match before "API"
-  const sortedTerms = Array.from(termMap.entries()).sort((a, b) => b[0].length - a[0].length);
-
-  // If no terms, return a no-op transformer
-  if (sortedTerms.length === 0) {
-    return tree => tree;
-  }
-
-  /**
-   * Recursively replace glossary terms in text
-   * Returns an array of text nodes and MDX components
-   */
-  function replaceTermsInText(text) {
-    if (!text || !sortedTerms.length) {
-      return [{ type: 'text', value: text }];
-    }
-
-    const result = [];
-    let lastIndex = 0;
-    const textLower = text.toLowerCase();
-
-    // Find all matches
-    const matches = [];
-    for (const [lowerTerm, termObj] of sortedTerms) {
-      const term = termObj.term;
-      let searchIndex = 0;
-
-      while (searchIndex < textLower.length) {
-        const index = textLower.indexOf(lowerTerm, searchIndex);
-        if (index === -1) break;
-
-        // Check if it's a whole word match, with simple plural tolerance ('s' or 'es')
-        const beforeChar = index > 0 ? textLower[index - 1] : ' ';
-        const afterIndex = index + lowerTerm.length;
-        const afterChar = afterIndex < textLower.length ? textLower[afterIndex] : ' ';
-
-        let matchLength = term.length;
-        let isWordBoundary = !/\w/.test(beforeChar) && !/\w/.test(afterChar);
-
-        // Allow trailing 's' plural (e.g., webhook -> webhooks)
-        if (!isWordBoundary && afterChar === 's') {
-          const nextChar = afterIndex + 1 < textLower.length ? textLower[afterIndex + 1] : ' ';
-          if (!/\w/.test(nextChar)) {
-            isWordBoundary = true;
-            matchLength = term.length + 1;
-          }
-        }
-
-        // Allow trailing 'es' plural (e.g., API -> APIs, box -> boxes)
-        if (
-          !isWordBoundary &&
-          afterChar === 'e' &&
-          afterIndex + 1 < textLower.length &&
-          textLower[afterIndex + 1] === 's'
-        ) {
-          const nextChar = afterIndex + 2 < textLower.length ? textLower[afterIndex + 2] : ' ';
-          if (!/\w/.test(nextChar)) {
-            isWordBoundary = true;
-            matchLength = term.length + 2;
-          }
-        }
-
-        if (isWordBoundary) {
-          matches.push({
-            index,
-            length: matchLength,
-            term: term,
-            termObj: termObj,
-            // Store original case from the text
-            originalText: text.substring(index, index + matchLength),
-          });
-        }
-
-        searchIndex = index + 1;
-      }
-    }
-
-    // Sort matches by index
-    matches.sort((a, b) => a.index - b.index);
-
-    // Remove overlapping matches (keep the first one)
-    const nonOverlappingMatches = [];
-    let lastMatchEnd = 0;
-    for (const match of matches) {
-      if (match.index >= lastMatchEnd) {
-        nonOverlappingMatches.push(match);
-        lastMatchEnd = match.index + match.length;
-      }
-    }
-
-    // Build result array
-    for (const match of nonOverlappingMatches) {
-      // Add text before match
-      if (match.index > lastIndex) {
-        result.push({
-          type: 'text',
-          value: text.substring(lastIndex, match.index),
-        });
-      }
-
-      // Add MDX component for glossary term
-      result.push({
-        type: 'mdxJsxFlowElement',
-        name: 'GlossaryTerm',
-        attributes: [
-          {
-            type: 'mdxJsxAttribute',
-            name: 'term',
-            value: match.termObj.term,
-          },
-          {
-            type: 'mdxJsxAttribute',
-            name: 'definition',
-            value: match.termObj.definition || '',
-          },
-          {
-            type: 'mdxJsxAttribute',
-            name: 'routePath',
-            value: routePath,
-          },
-        ],
-        children: [
-          {
-            type: 'text',
-            value: match.originalText,
-          },
-        ],
-      });
-
-      lastIndex = match.index + match.length;
-    }
-
-    // Add remaining text
-    if (lastIndex < text.length) {
-      result.push({
-        type: 'text',
-        value: text.substring(lastIndex),
-      });
-    }
-
-    return result.length > 0 ? result : [{ type: 'text', value: text }];
-  }
-
-  // Return the transformer function
-  const transformer = tree => {
-    let usedGlossaryTerm = false;
-    visit(tree, 'text', (node, index, parent) => {
-      // Skip text nodes inside code blocks, links, or existing MDX components
-      if (
-        parent.type === 'code' ||
-        parent.type === 'inlineCode' ||
-        parent.type === 'link' ||
-        parent.type === 'mdxJsxFlowElement' ||
-        parent.type === 'mdxJsxTextElement'
-      ) {
-        return;
-      }
-
-      // Replace terms in text node
-      const replacements = replaceTermsInText(node.value);
-
-      // If we have replacements, replace the single text node with multiple nodes
-      if (
-        replacements.length > 1 ||
-        (replacements.length === 1 && replacements[0].type !== 'text')
-      ) {
-        // Convert to text elements for paragraph context if needed
-        const newNodes = replacements.map(replacement => {
-          if (replacement.type === 'mdxJsxFlowElement') {
-            // In paragraph context, we need mdxJsxTextElement instead
-            if (parent.type === 'paragraph') {
-              usedGlossaryTerm = true;
-              return {
-                type: 'mdxJsxTextElement',
-                name: replacement.name,
-                attributes: replacement.attributes,
-                children: replacement.children,
-              };
-            }
-            usedGlossaryTerm = true;
-          }
-          return replacement;
-        });
-
-        // Replace the single node with multiple nodes
-        parent.children.splice(index, 1, ...newNodes);
-        return index + newNodes.length - 1; // Return new index to continue
-      }
-    });
-
-    // Inject MDX import for GlossaryTerm if we used it
-    // The component is available via theme path, so we just need to import it
-    if (usedGlossaryTerm) {
-      const importNode = {
-        type: 'mdxjsEsm',
-        value: 'import GlossaryTerm from "@theme/GlossaryTerm";',
-        data: {
-          estree: {
-            type: 'Program',
-            sourceType: 'module',
-            body: [
-              {
-                type: 'ImportDeclaration',
-                specifiers: [
-                  {
-                    type: 'ImportDefaultSpecifier',
-                    local: { type: 'Identifier', name: 'GlossaryTerm' },
-                  },
-                ],
-                source: {
-                  type: 'Literal',
-                  value: '@theme/GlossaryTerm',
-                  raw: '"@theme/GlossaryTerm"',
-                },
-              },
-            ],
-          },
-        },
-      };
-
-      // Check for existing import
-      const hasImport =
-        Array.isArray(tree.children) &&
-        tree.children.some(
-          n =>
-            n.type === 'mdxjsEsm' &&
-            (n.value?.includes('@theme/GlossaryTerm') ||
-              n.data?.estree?.body?.some(s => s.source?.value === '@theme/GlossaryTerm'))
-        );
-
-      if (!hasImport) {
-        if (!Array.isArray(tree.children)) tree.children = [];
-        let insertIndex = 0;
-        for (let i = 0; i < tree.children.length; i++) {
-          const node = tree.children[i];
-          if (node.type === 'yaml' || node.type === 'toml') {
-            insertIndex = i + 1;
-          } else {
-            break;
-          }
-        }
-        tree.children.splice(insertIndex, 0, importNode);
-      }
-    }
-  };
-
-  return transformer;
-}
-
-/**
- * Clears the glossary cache
- * Useful for testing or when you want to force a reload of glossary data
- *
- * @param {string} [filePath] - Optional specific file path to clear. If not provided, clears entire cache.
- */
-export function clearGlossaryCache(filePath) {
-  if (filePath) {
-    glossaryCache.delete(filePath);
-  } else {
-    glossaryCache.clear();
-  }
-}
+import {
+  clearGlossaryCache,
+  remarkGlossaryTerms
+} from "../chunk-PEB4Y6RI.js";
+export {
+  clearGlossaryCache,
+  remarkGlossaryTerms as default
+};
+//# sourceMappingURL=glossary-terms.js.map

package/dist/remark/glossary-terms.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/theme/GlossaryTerm/index.cjs

@@ -0,0 +1,138 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/theme/GlossaryTerm/index.js
+var GlossaryTerm_exports = {};
+__export(GlossaryTerm_exports, {
+  default: () => GlossaryTerm
+});
+module.exports = __toCommonJS(GlossaryTerm_exports);
+var import_react = __toESM(require("react"), 1);
+var import_useGlobalData = require("@docusaurus/useGlobalData");
+var import_styles = __toESM(require("../../styles.module-N7ME3MWS.module.css"), 1);
+var import_jsx_runtime = require("react/jsx-runtime");
+function GlossaryTerm({ term, definition, routePath = "/glossary", children }) {
+  const [showTooltip, setShowTooltip] = (0, import_react.useState)(false);
+  const [tooltipStyle, setTooltipStyle] = (0, import_react.useState)(null);
+  const [placement, setPlacement] = (0, import_react.useState)("top");
+  const wrapperRef = (0, import_react.useRef)(null);
+  const tooltipRef = (0, import_react.useRef)(null);
+  const updatePosition = (0, import_react.useCallback)(() => {
+    if (!wrapperRef.current || !tooltipRef.current) return;
+    const wrapperRect = wrapperRef.current.getBoundingClientRect();
+    const tooltipRect = tooltipRef.current.getBoundingClientRect();
+    const viewportWidth = window.innerWidth;
+    const viewportHeight = window.innerHeight;
+    const preferredGap = 8;
+    const hasSpaceAbove = wrapperRect.top >= tooltipRect.height + preferredGap;
+    const hasSpaceBelow = viewportHeight - wrapperRect.bottom >= tooltipRect.height + preferredGap;
+    const nextPlacement = hasSpaceAbove || !hasSpaceBelow ? "top" : "bottom";
+    let top;
+    if (nextPlacement === "top") {
+      top = wrapperRect.top - tooltipRect.height - preferredGap;
+    } else {
+      top = wrapperRect.bottom + preferredGap;
+    }
+    const horizontalMargin = 8;
+    let left = wrapperRect.left + wrapperRect.width / 2 - tooltipRect.width / 2;
+    left = Math.max(
+      horizontalMargin,
+      Math.min(left, viewportWidth - tooltipRect.width - horizontalMargin)
+    );
+    setPlacement(nextPlacement);
+    setTooltipStyle({ top: Math.max(4, top), left });
+  }, []);
+  (0, import_react.useEffect)(() => {
+    if (!showTooltip) return;
+    let rafId2;
+    const rafId1 = requestAnimationFrame(() => {
+      rafId2 = requestAnimationFrame(() => {
+        updatePosition();
+      });
+    });
+    const onScroll = () => updatePosition();
+    const onResize = () => updatePosition();
+    window.addEventListener("scroll", onScroll, true);
+    window.addEventListener("resize", onResize);
+    return () => {
+      cancelAnimationFrame(rafId1);
+      if (rafId2) cancelAnimationFrame(rafId2);
+      window.removeEventListener("scroll", onScroll, true);
+      window.removeEventListener("resize", onResize);
+    };
+  }, [showTooltip, updatePosition]);
+  const pluginData = (0, import_useGlobalData.usePluginData)("docusaurus-plugin-glossary");
+  const effectiveDefinition = (0, import_react.useMemo)(() => {
+    if (definition && typeof definition === "string" && definition.length > 0) {
+      return definition;
+    }
+    const terms = pluginData && pluginData.terms || [];
+    const found = terms.find(
+      (t) => typeof t.term === "string" && t.term.toLowerCase() === String(term).toLowerCase()
+    );
+    return found && found.definition ? found.definition : void 0;
+  }, [definition, pluginData, term]);
+  const effectiveRoutePath = (0, import_react.useMemo)(() => {
+    if (routePath && typeof routePath === "string" && routePath.length > 0) return routePath;
+    return pluginData && pluginData.routePath || "/glossary";
+  }, [pluginData, routePath]);
+  const displayText = children || term;
+  const termId = term.toLowerCase().replace(/\s+/g, "-");
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("span", { ref: wrapperRef, className: import_styles.default.glossaryTermWrapper, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "a",
+      {
+        href: `${effectiveRoutePath}#${termId}`,
+        className: import_styles.default.glossaryTerm,
+        onMouseEnter: () => setShowTooltip(true),
+        onMouseLeave: () => setShowTooltip(false),
+        onFocus: () => setShowTooltip(true),
+        onBlur: () => setShowTooltip(false),
+        "aria-describedby": `tooltip-${termId}`,
+        children: displayText
+      }
+    ),
+    effectiveDefinition && /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(
+      "span",
+      {
+        ref: tooltipRef,
+        id: `tooltip-${termId}`,
+        className: `${import_styles.default.tooltip} ${showTooltip ? import_styles.default.tooltipVisible : ""} ${placement === "top" ? import_styles.default.tooltipTop : import_styles.default.tooltipBottom} ${import_styles.default.tooltipFloating}`,
+        role: "tooltip",
+        style: showTooltip && tooltipStyle ? { top: `${tooltipStyle.top}px`, left: `${tooltipStyle.left}px` } : void 0,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)("strong", { children: term }),
+          " ",
+          effectiveDefinition
+        ]
+      }
+    )
+  ] });
+}
+//# sourceMappingURL=index.cjs.map

package/dist/theme/GlossaryTerm/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/theme/GlossaryTerm/index.js"],"sourcesContent":["import React, { useMemo, useState, useRef, useEffect, useCallback } from 'react';\nimport { usePluginData } from '@docusaurus/useGlobalData';\nimport styles from './styles.module.css';\n\n/**\n * GlossaryTerm component - displays an inline term with tooltip\n *\n * Usage:\n * import GlossaryTerm from '@theme/GlossaryTerm';\n *\n * <GlossaryTerm term=\"API\" definition=\"Application Programming Interface\" />\n * or\n * <GlossaryTerm term=\"API\">custom display text</GlossaryTerm>\n *\n * @param {object} props\n * @param {string} props.term - The glossary term\n * @param {string} props.definition - The definition to show in tooltip\n * @param {string} props.routePath - Route path to glossary page (default: '/glossary')\n * @param {React.ReactNode} props.children - Optional custom display text\n */\nexport default function GlossaryTerm({ term, definition, routePath = '/glossary', children }) {\n  const [showTooltip, setShowTooltip] = useState(false);\n  const [tooltipStyle, setTooltipStyle] = useState(null);\n  const [placement, setPlacement] = useState('top'); // 'top' | 'bottom'\n  const wrapperRef = useRef(null);\n  const tooltipRef = useRef(null);\n\n  const updatePosition = useCallback(() => {\n    if (!wrapperRef.current || !tooltipRef.current) return;\n    const wrapperRect = wrapperRef.current.getBoundingClientRect();\n    const tooltipRect = tooltipRef.current.getBoundingClientRect();\n\n    const viewportWidth = window.innerWidth;\n    const viewportHeight = window.innerHeight;\n\n    const preferredGap = 8; // px\n\n    // Decide top vs bottom based on available space\n    const hasSpaceAbove = wrapperRect.top >= tooltipRect.height + preferredGap;\n    const hasSpaceBelow = viewportHeight - wrapperRect.bottom >= tooltipRect.height + preferredGap;\n    const nextPlacement = hasSpaceAbove || !hasSpaceBelow ? 'top' : 'bottom';\n\n    let top;\n    if (nextPlacement === 'top') {\n      top = wrapperRect.top - tooltipRect.height - preferredGap;\n    } else {\n      top = wrapperRect.bottom + preferredGap;\n    }\n\n    // Center horizontally on the wrapper, then clamp within viewport with margin\n    const horizontalMargin = 8;\n    let left = wrapperRect.left + wrapperRect.width / 2 - tooltipRect.width / 2;\n    left = Math.max(\n      horizontalMargin,\n      Math.min(left, viewportWidth - tooltipRect.width - horizontalMargin)\n    );\n\n    setPlacement(nextPlacement);\n    setTooltipStyle({ top: Math.max(4, top), left });\n  }, []);\n\n  useEffect(() => {\n    if (!showTooltip) return;\n\n    // Use double requestAnimationFrame to ensure DOM is fully rendered and layout is complete\n    // This ensures tooltipRef.current is available and has proper dimensions\n    let rafId2;\n    const rafId1 = requestAnimationFrame(() => {\n      rafId2 = requestAnimationFrame(() => {\n        updatePosition();\n      });\n    });\n\n    const onScroll = () => updatePosition();\n    const onResize = () => updatePosition();\n    window.addEventListener('scroll', onScroll, true);\n    window.addEventListener('resize', onResize);\n    return () => {\n      cancelAnimationFrame(rafId1);\n      if (rafId2) cancelAnimationFrame(rafId2);\n      window.removeEventListener('scroll', onScroll, true);\n      window.removeEventListener('resize', onResize);\n    };\n  }, [showTooltip, updatePosition]);\n\n  // Pull definition/route from plugin global data if not provided\n  const pluginData = usePluginData('docusaurus-plugin-glossary');\n  const effectiveDefinition = useMemo(() => {\n    if (definition && typeof definition === 'string' && definition.length > 0) {\n      return definition;\n    }\n    const terms = (pluginData && pluginData.terms) || [];\n    const found = terms.find(\n      t => typeof t.term === 'string' && t.term.toLowerCase() === String(term).toLowerCase()\n    );\n    return found && found.definition ? found.definition : undefined;\n  }, [definition, pluginData, term]);\n\n  const effectiveRoutePath = useMemo(() => {\n    if (routePath && typeof routePath === 'string' && routePath.length > 0) return routePath;\n    return (pluginData && pluginData.routePath) || '/glossary';\n  }, [pluginData, routePath]);\n\n  const displayText = children || term;\n  const termId = term.toLowerCase().replace(/\\s+/g, '-');\n\n  return (\n    <span ref={wrapperRef} className={styles.glossaryTermWrapper}>\n      <a\n        href={`${effectiveRoutePath}#${termId}`}\n        className={styles.glossaryTerm}\n        onMouseEnter={() => setShowTooltip(true)}\n        onMouseLeave={() => setShowTooltip(false)}\n        onFocus={() => setShowTooltip(true)}\n        onBlur={() => setShowTooltip(false)}\n        aria-describedby={`tooltip-${termId}`}\n      >\n        {displayText}\n      </a>\n      {effectiveDefinition && (\n        <span\n          ref={tooltipRef}\n          id={`tooltip-${termId}`}\n          className={\n            `${styles.tooltip} ${showTooltip ? styles.tooltipVisible : ''} ` +\n            `${placement === 'top' ? styles.tooltipTop : styles.tooltipBottom} ` +\n            `${styles.tooltipFloating}`\n          }\n          role=\"tooltip\"\n          style={\n            showTooltip && tooltipStyle\n              ? { top: `${tooltipStyle.top}px`, left: `${tooltipStyle.left}px` }\n              : undefined\n          }\n        >\n          <strong>{term}</strong> {effectiveDefinition}\n        </span>\n      )}\n    </span>\n  );\n}\n"],"mappings":"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","names":["styles"]}