docusaurus-plugin-glossary 3.0.2 → 3.2.0

package/dist/validation.js

@@ -1,246 +1,11 @@
-/**
- * Validates a single glossary term object
- *
- * @param term - The term object to validate
- * @param index - The index in the terms array (for error messages)
- * @returns Array of validation errors (empty if valid)
- */
-function validateTerm(term, index) {
-    const errors = [];
-    const prefix = `terms[${index}]`;
-    if (term === null || term === undefined) {
-        errors.push({
-            field: prefix,
-            message: 'Term cannot be null or undefined',
-            value: term,
-        });
-        return errors;
-    }
-    if (typeof term !== 'object') {
-        errors.push({
-            field: prefix,
-            message: `Term must be an object, got ${typeof term}`,
-            value: term,
-        });
-        return errors;
-    }
-    const termObj = term;
-    // Required: term (string)
-    if (!('term' in termObj)) {
-        errors.push({
-            field: `${prefix}.term`,
-            message: 'Missing required field "term"',
-        });
-    }
-    else if (typeof termObj.term !== 'string') {
-        errors.push({
-            field: `${prefix}.term`,
-            message: `Field "term" must be a string, got ${typeof termObj.term}`,
-            value: termObj.term,
-        });
-    }
-    else if (termObj.term.trim() === '') {
-        errors.push({
-            field: `${prefix}.term`,
-            message: 'Field "term" cannot be empty',
-            value: termObj.term,
-        });
-    }
-    // Required: definition (string)
-    if (!('definition' in termObj)) {
-        errors.push({
-            field: `${prefix}.definition`,
-            message: 'Missing required field "definition"',
-        });
-    }
-    else if (typeof termObj.definition !== 'string') {
-        errors.push({
-            field: `${prefix}.definition`,
-            message: `Field "definition" must be a string, got ${typeof termObj.definition}`,
-            value: termObj.definition,
-        });
-    }
-    // Optional: abbreviation (string)
-    if ('abbreviation' in termObj && termObj.abbreviation !== undefined) {
-        if (typeof termObj.abbreviation !== 'string') {
-            errors.push({
-                field: `${prefix}.abbreviation`,
-                message: `Field "abbreviation" must be a string, got ${typeof termObj.abbreviation}`,
-                value: termObj.abbreviation,
-            });
-        }
-    }
-    // Optional: relatedTerms (string[])
-    if ('relatedTerms' in termObj && termObj.relatedTerms !== undefined) {
-        if (!Array.isArray(termObj.relatedTerms)) {
-            errors.push({
-                field: `${prefix}.relatedTerms`,
-                message: `Field "relatedTerms" must be an array, got ${typeof termObj.relatedTerms}`,
-                value: termObj.relatedTerms,
-            });
-        }
-        else {
-            termObj.relatedTerms.forEach((relatedTerm, relatedIndex) => {
-                if (typeof relatedTerm !== 'string') {
-                    errors.push({
-                        field: `${prefix}.relatedTerms[${relatedIndex}]`,
-                        message: `Related term must be a string, got ${typeof relatedTerm}`,
-                        value: relatedTerm,
-                    });
-                }
-            });
-        }
-    }
-    // Optional: id (string)
-    if ('id' in termObj && termObj.id !== undefined) {
-        if (typeof termObj.id !== 'string') {
-            errors.push({
-                field: `${prefix}.id`,
-                message: `Field "id" must be a string, got ${typeof termObj.id}`,
-                value: termObj.id,
-            });
-        }
-    }
-    return errors;
-}
-/**
- * Validates glossary data structure
- *
- * Ensures the glossary data conforms to the expected schema:
- * - Must be an object with a "terms" array
- * - Each term must have "term" (string) and "definition" (string)
- * - Optional fields: abbreviation (string), relatedTerms (string[]), id (string)
- *
- * @param data - The data to validate
- * @param options - Validation options
- * @param options.throwOnError - If true, throws an error on validation failure (default: true)
- * @returns Validation result with errors and sanitized data
- * @throws Error if data is invalid and throwOnError is true
- */
-export function validateGlossaryData(data, options = {}) {
-    const { throwOnError = true } = options;
-    const errors = [];
-    // Check if data is null or undefined
-    if (data === null || data === undefined) {
-        errors.push({
-            field: 'root',
-            message: 'Glossary data cannot be null or undefined',
-            value: data,
-        });
-        if (throwOnError && errors.length > 0) {
-            throw new GlossaryValidationError(errors);
-        }
-        return { valid: false, errors, data: { terms: [] } };
-    }
-    // Check if data is an object
-    if (typeof data !== 'object') {
-        errors.push({
-            field: 'root',
-            message: `Glossary data must be an object, got ${typeof data}`,
-            value: data,
-        });
-        if (throwOnError && errors.length > 0) {
-            throw new GlossaryValidationError(errors);
-        }
-        return { valid: false, errors, data: { terms: [] } };
-    }
-    const glossaryData = data;
-    // Check for terms array
-    if (!('terms' in glossaryData)) {
-        errors.push({
-            field: 'terms',
-            message: 'Glossary data must contain a "terms" array',
-        });
-        if (throwOnError && errors.length > 0) {
-            throw new GlossaryValidationError(errors);
-        }
-        return { valid: false, errors, data: { terms: [] } };
-    }
-    if (!Array.isArray(glossaryData.terms)) {
-        errors.push({
-            field: 'terms',
-            message: `Field "terms" must be an array, got ${typeof glossaryData.terms}`,
-            value: glossaryData.terms,
-        });
-        if (throwOnError && errors.length > 0) {
-            throw new GlossaryValidationError(errors);
-        }
-        return { valid: false, errors, data: { terms: [] } };
-    }
-    // Validate each term
-    const validTerms = [];
-    glossaryData.terms.forEach((term, index) => {
-        const termErrors = validateTerm(term, index);
-        if (termErrors.length > 0) {
-            errors.push(...termErrors);
-        }
-        else {
-            // Term is valid, add to valid terms
-            validTerms.push(term);
-        }
-    });
-    // Check for duplicate terms
-    const termNames = new Map();
-    validTerms.forEach((term, index) => {
-        const lowerName = term.term.toLowerCase();
-        if (termNames.has(lowerName)) {
-            errors.push({
-                field: `terms[${index}].term`,
-                message: `Duplicate term "${term.term}" (first occurrence at index ${termNames.get(lowerName)})`,
-                value: term.term,
-            });
-        }
-        else {
-            termNames.set(lowerName, index);
-        }
-    });
-    if (throwOnError && errors.length > 0) {
-        throw new GlossaryValidationError(errors);
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-        data: { terms: validTerms },
-    };
-}
-/**
- * Custom error class for glossary validation errors
- * Provides detailed error messages for debugging
- */
-export class GlossaryValidationError extends Error {
-    constructor(errors) {
-        const message = formatValidationErrors(errors);
-        super(message);
-        this.name = 'GlossaryValidationError';
-        this.errors = errors;
-        // Maintains proper stack trace for where error was thrown (V8 engines)
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, GlossaryValidationError);
-        }
-    }
-}
-/**
- * Formats validation errors into a readable string
- *
- * @param errors - Array of validation errors
- * @returns Formatted error message
- */
-export function formatValidationErrors(errors) {
-    if (errors.length === 0) {
-        return 'No validation errors';
-    }
-    const header = `Glossary validation failed with ${errors.length} error${errors.length > 1 ? 's' : ''}:`;
-    const errorList = errors
-        .map((err, index) => {
-        let msg = `  ${index + 1}. [${err.field}] ${err.message}`;
-        if (err.value !== undefined) {
-            const valueStr = typeof err.value === 'object' ? JSON.stringify(err.value) : String(err.value);
-            // Truncate long values
-            const truncated = valueStr.length > 50 ? valueStr.substring(0, 50) + '...' : valueStr;
-            msg += ` (got: ${truncated})`;
-        }
-        return msg;
-    })
-        .join('\n');
-    return `${header}\n${errorList}`;
-}
+import {
+  GlossaryValidationError,
+  formatValidationErrors,
+  validateGlossaryData
+} from "./chunk-SNP37IVL.js";
+export {
+  GlossaryValidationError,
+  formatValidationErrors,
+  validateGlossaryData
+};
+//# sourceMappingURL=validation.js.map

package/dist/validation.js.map

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

package/package.json

@@ -1,24 +1,26 @@
 {
   "name": "docusaurus-plugin-glossary",
-  "version": "3.0.2",
+  "version": "3.2.0",
   "description": "A Docusaurus plugin for creating and managing glossary terms with auto-generated pages and inline tooltips",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.js",
-      "default": "./dist/index.js"
+      "require": "./dist/index.cjs"
     },
     "./preset": {
+      "types": "./dist/preset.d.ts",
       "import": "./dist/preset.js",
-      "require": "./dist/preset.js",
-      "default": "./dist/preset.js"
+      "require": "./dist/preset.cjs"
     },
     "./remark/glossary-terms": {
+      "types": "./dist/remark/glossary-terms.d.ts",
       "import": "./dist/remark/glossary-terms.js",
-      "require": "./dist/remark/glossary-terms.js",
-      "default": "./dist/remark/glossary-terms.js"
+      "require": "./dist/remark/glossary-terms.cjs"
     }
   },
   "files": [
@@ -27,8 +29,11 @@
     "LICENSE"
   ],
   "scripts": {
-    "build": "tsc && node scripts/build.js",
-    "watch": "tsc && node scripts/watch.js",
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "watch": "npm run dev",
+    "clean": "rimraf dist",
+    "typecheck": "tsc --noEmit",
     "test": "jest",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
@@ -40,7 +45,6 @@
     "example:clear": "npm --prefix examples/docusaurus-v3 run clear",
     "prepare": "husky",
     "prepublishOnly": "npm run build && npm test",
-    "version": "npm version",
     "format": "prettier --write \"**/*.{js,jsx,ts,tsx,json,css,md}\"",
     "format:check": "prettier --check \"**/*.{js,jsx,ts,tsx,json,css,md}\"",
     "lint": "eslint \"src/**/*.{js,jsx,ts,tsx}\" \"__tests__/**/*.js\"",
@@ -82,25 +86,28 @@
     "@babel/preset-env": "^7.28.5",
     "@babel/preset-react": "^7.28.5",
     "@babel/preset-typescript": "^7.28.5",
-    "@eslint/js": "^9.28.0",
-    "@typescript-eslint/eslint-plugin": "^8.33.0",
-    "@typescript-eslint/parser": "^8.33.0",
-    "eslint": "^9.28.0",
-    "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^5.2.0",
     "@docusaurus/tsconfig": "^3.9.2",
     "@docusaurus/types": "^3.9.2",
+    "@eslint/js": "^9.28.0",
     "@playwright/test": "^1.56.1",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.0",
     "@testing-library/user-event": "^14.6.1",
+    "@types/fs-extra": "^11.0.4",
+    "@typescript-eslint/eslint-plugin": "^8.33.0",
+    "@typescript-eslint/parser": "^8.33.0",
     "babel-jest": "^30.2.0",
+    "eslint": "^9.28.0",
+    "eslint-plugin-react": "^7.37.5",
+    "eslint-plugin-react-hooks": "^5.2.0",
+    "husky": "^9.1.7",
     "identity-obj-proxy": "^3.0.0",
     "jest": "^30.2.0",
     "jest-environment-jsdom": "^30.2.0",
-    "husky": "^9.1.7",
     "lint-staged": "^15.5.1",
     "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "tsup": "^8.0.1",
     "typescript": "^5.7.3"
   },
   "lint-staged": {
@@ -111,17 +118,5 @@
     "*.{json,css,md}": [
       "prettier --write"
     ]
-  },
-  "browser": {
-    "path": false,
-    "url": false,
-    "fs": false,
-    "fs-extra": false,
-    "graceful-fs": false,
-    "jsonfile": false,
-    "util": false,
-    "assert": false,
-    "stream": false,
-    "constants": false
   }
 }

package/dist/components/GlossaryPage.test.js

@@ -1,205 +0,0 @@
-import React from 'react';
-import { render, screen } from '@testing-library/react';
-import userEvent from '@testing-library/user-event';
-import GlossaryPage from './GlossaryPage';
-
-// Mock CSS modules
-jest.mock('./GlossaryPage.module.css', () => ({
-  glossaryContainer: 'glossaryContainer',
-  glossaryHeader: 'glossaryHeader',
-  glossaryDescription: 'glossaryDescription',
-  searchContainer: 'searchContainer',
-  searchInput: 'searchInput',
-  noResults: 'noResults',
-  glossaryContent: 'glossaryContent',
-  letterNav: 'letterNav',
-  letterLink: 'letterLink',
-  letterSection: 'letterSection',
-  letterHeading: 'letterHeading',
-  termList: 'termList',
-  termItem: 'termItem',
-  termName: 'termName',
-  abbreviation: 'abbreviation',
-  termDefinition: 'termDefinition',
-  relatedTerms: 'relatedTerms',
-  glossaryFooter: 'glossaryFooter',
-}));
-
-const mockGlossaryData = {
-  description: 'Test glossary',
-  terms: [
-    {
-      id: 'api',
-      term: 'API',
-      definition: 'Application Programming Interface',
-      abbreviation: 'API',
-      relatedTerms: ['REST'],
-    },
-    {
-      id: 'rest',
-      term: 'REST',
-      definition: 'Representational State Transfer',
-      abbreviation: 'REST',
-      relatedTerms: ['API'],
-    },
-    {
-      id: 'ml',
-      term: 'Machine Learning',
-      definition: 'A type of artificial intelligence',
-    },
-  ],
-};
-
-describe('GlossaryPage', () => {
-  it('should render glossary with all terms', () => {
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    expect(screen.getByText('Glossary')).toBeInTheDocument();
-    expect(screen.getByText('Test glossary')).toBeInTheDocument();
-    // Use getAllBy since terms can appear multiple times (in term names and related links)
-    expect(screen.getAllByText('API').length).toBeGreaterThan(0);
-    expect(screen.getAllByText('REST').length).toBeGreaterThan(0);
-    expect(screen.getByText('Machine Learning')).toBeInTheDocument();
-  });
-
-  it('should show search input', () => {
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    const searchInput = screen.getByPlaceholderText('Search terms...');
-    expect(searchInput).toBeInTheDocument();
-  });
-
-  it('should filter terms by search query', async () => {
-    const user = userEvent.setup();
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    const searchInput = screen.getByPlaceholderText('Search terms...');
-    await user.type(searchInput, 'API');
-
-    expect(screen.getByText('API')).toBeInTheDocument();
-    expect(screen.queryByText('Machine Learning')).not.toBeInTheDocument();
-  });
-
-  it('should filter by definition text', async () => {
-    const user = userEvent.setup();
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    const searchInput = screen.getByPlaceholderText('Search terms...');
-    await user.type(searchInput, 'artificial');
-
-    expect(screen.getByText('Machine Learning')).toBeInTheDocument();
-    expect(screen.queryByText('API')).not.toBeInTheDocument();
-    expect(screen.queryByText('REST')).not.toBeInTheDocument();
-  });
-
-  it('should show no results message when no matches', async () => {
-    const user = userEvent.setup();
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    const searchInput = screen.getByPlaceholderText('Search terms...');
-    await user.type(searchInput, 'NonexistentTerm');
-
-    expect(screen.getByText(/No terms found matching/)).toBeInTheDocument();
-  });
-
-  it('should group terms by first letter', () => {
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    // Check that terms are grouped under their first letter (multiple elements per letter)
-    expect(screen.getAllByText('A').length).toBeGreaterThan(0);
-    expect(screen.getAllByText('M').length).toBeGreaterThan(0);
-    expect(screen.getAllByText('R').length).toBeGreaterThan(0);
-  });
-
-  it('should sort terms alphabetically within groups', () => {
-    const dataWithMultipleTerms = {
-      ...mockGlossaryData,
-      terms: [
-        { id: 'zebra', term: 'Zebra', definition: 'An animal' },
-        { id: 'alpha', term: 'Alpha', definition: 'First letter' },
-        { id: 'beta', term: 'Beta', definition: 'Second letter' },
-      ],
-    };
-
-    render(<GlossaryPage glossaryData={dataWithMultipleTerms} />);
-
-    const terms = screen.getAllByText(/Zebra|Alpha|Beta/);
-    expect(terms).toHaveLength(3);
-    // Check Alpha is before Beta, and Beta is before Zebra
-    expect(terms[0]).toHaveTextContent('Alpha');
-    expect(terms[1]).toHaveTextContent('Beta');
-    expect(terms[2]).toHaveTextContent('Zebra');
-  });
-
-  it('should display abbreviations', () => {
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    // Check abbreviation appears in document
-    expect(screen.getAllByText('(API)').length).toBeGreaterThan(0);
-    expect(screen.getAllByText('(REST)').length).toBeGreaterThan(0);
-  });
-
-  it('should display related terms', () => {
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    // Related terms header appears multiple times (once per term with related terms)
-    expect(screen.getAllByText('Related terms:').length).toBeGreaterThan(0);
-    // REST appears as a term and in related links
-    expect(screen.getAllByText('REST').length).toBeGreaterThan(0);
-  });
-
-  it('should show total term count in footer', () => {
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    expect(screen.getByText('Total terms: 3')).toBeInTheDocument();
-  });
-
-  it('should handle empty terms array', () => {
-    const emptyData = { terms: [] };
-    render(<GlossaryPage glossaryData={emptyData} />);
-
-    expect(screen.getByText('Glossary')).toBeInTheDocument();
-    expect(screen.getByText('Total terms: 0')).toBeInTheDocument();
-  });
-
-  it('should handle missing glossaryData gracefully', () => {
-    render(<GlossaryPage glossaryData={null} />);
-
-    expect(screen.getByText('Glossary')).toBeInTheDocument();
-    expect(screen.getByText('Total terms: 0')).toBeInTheDocument();
-  });
-
-  it('should handle missing description gracefully', () => {
-    const dataWithoutDescription = {
-      terms: mockGlossaryData.terms,
-    };
-    render(<GlossaryPage glossaryData={dataWithoutDescription} />);
-
-    expect(screen.getByText(/A collection of terms and their definitions/)).toBeInTheDocument();
-  });
-
-  it('should generate correct anchor links for terms', () => {
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    // Check navigation links are generated
-    const navLinks = screen.getAllByRole('link', { name: /^[AMR]$/ });
-    expect(navLinks.length).toBeGreaterThan(0);
-    expect(navLinks[0]).toHaveAttribute('href', '#letter-A');
-  });
-
-  it('should clear search when input is cleared', async () => {
-    const user = userEvent.setup();
-    render(<GlossaryPage glossaryData={mockGlossaryData} />);
-
-    const searchInput = screen.getByPlaceholderText('Search terms...');
-    await user.type(searchInput, 'Machine');
-
-    expect(screen.getByText('Machine Learning')).toBeInTheDocument();
-
-    await user.clear(searchInput);
-
-    expect(screen.getAllByText('API').length).toBeGreaterThan(0);
-    expect(screen.getAllByText('REST').length).toBeGreaterThan(0);
-    expect(screen.getByText('Machine Learning')).toBeInTheDocument();
-  });
-});

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,mBAAmB,MAAM,4BAA4B,CAAC;AAU7D,MAAM,WAAW,qBAAqB;IACpC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,YAAY,EAAE,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CACpC,OAAO,EAAE,WAAW,EACpB,OAAO,GAAE,qBAA0B,GAClC,MAAM,CAgGR;AAGD,eAAO,MAAM,YAAY,4BAAsB,CAAC;AAGhD,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAGhE,OAAO,EACL,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,EACtB,KAAK,eAAe,EACpB,KAAK,gBAAgB,GACtB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,aAAa,EAAE,qBAAqB,EACpC,OAAO,CAAC,EAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAC7B,CAAC,OAAO,mBAAmB,EAAE;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAa7F"}

package/dist/preset.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"preset.d.ts","sourceRoot":"","sources":["../src/preset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE7D,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD;;;GAGG;AACH,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC1C,aAAa,CAAC,EAAE,OAAO,EAAE,CAAC;CAC3B,CAAC;AAEF;;;GAGG;AACH,KAAK,UAAU,GACX,KAAK,GACL,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IACzB,aAAa,CAAC,EAAE,OAAO,EAAE,CAAC;CAC3B,CAAC,CAAC;AAEP;;GAEG;AACH,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC3C,aAAa,CAAC,EAAE,OAAO,EAAE,CAAC;CAC3B,CAAC;AAEF;;GAEG;AACH,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE3C;;GAEG;AACH,KAAK,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE/C;;;GAGG;AACH,KAAK,aAAa,GAAG,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAErD;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,eAAe,CAAC,EAAE,eAAe,CAAC;IAClC,gBAAgB,CAAC,EAAE,eAAe,CAAC;IACnC,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,qBAAsB,SAAQ,oBAAoB;IACjE,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,iFAAiF;IACjF,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,GAAE,qBAA0B,GAAG,MAAM,CAgGhG"}

package/dist/remark/glossary-terms.d.ts

@@ -1,28 +0,0 @@
-/**
- * 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, routePath, siteDir, }?: {
-    terms: any[];
-    glossaryPath: string;
-    routePath: string;
-    siteDir: string;
-}): Function;
-/**
- * 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?: string): void;
-//# sourceMappingURL=glossary-terms.d.ts.map

package/dist/remark/glossary-terms.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"glossary-terms.d.ts","sourceRoot":"","sources":["../../src/remark/glossary-terms.js"],"names":[],"mappings":"AA+DA;;;;;;;;;;;;;GAaG;AACH,2FANG;IAAuB,KAAK;IACJ,YAAY,EAA5B,MAAM;IACU,SAAS,EAAzB,MAAM;IACU,OAAO,EAAvB,MAAM;CACd,YA8VF;AAED;;;;;GAKG;AACH,8CAFW,MAAM,QAQhB"}