@mui/internal-docs-infra 0.1.1-alpha.0 → 0.1.1-alpha.10

package/useCode/useFileNavigation.js

@@ -0,0 +1,370 @@
+import _typeof from "@babel/runtime/helpers/esm/typeof";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { stringOrHastToJsx } from "../pipeline/hastUtils/index.js";
+import { useUrlHashState } from "../useUrlHashState/index.js";
+/**
+ * Converts a string to kebab-case
+ * @param str - The string to convert
+ * @returns kebab-case string
+ */
+function toKebabCase(str) {
+  return str
+  // Insert a dash before any uppercase letter that follows a lowercase letter or digit
+  .replace(/([a-z0-9])([A-Z])/g, '$1-$2').toLowerCase().replace(/[^a-z0-9.]+/g, '-').replace(/^-+|-+$/g, '');
+}
+
+/**
+ * Generates a file slug based on main slug, file name, and variant name
+ * @param mainSlug - The main component/demo slug
+ * @param fileName - The file name
+ * @param variantName - The variant name
+ * @param isInitialVariant - Whether this is the initial/default variant
+ * @returns Generated file slug
+ */
+function generateFileSlug(mainSlug, fileName, variantName, isInitialVariant) {
+  // Extract base name from filename (strip extension)
+  var lastDotIndex = fileName.lastIndexOf('.');
+  var baseName = lastDotIndex !== -1 ? fileName.substring(0, lastDotIndex) : fileName;
+  var extension = lastDotIndex !== -1 ? fileName.substring(lastDotIndex) : '';
+
+  // Convert to kebab-case
+  var kebabMainSlug = toKebabCase(mainSlug);
+  var kebabBaseName = toKebabCase(baseName);
+  var kebabVariantName = toKebabCase(variantName);
+
+  // Reconstruct filename with kebab-case base name but preserved extension
+  var kebabFileName = "".concat(kebabBaseName).concat(extension);
+
+  // Handle empty main slug case
+  if (!kebabMainSlug) {
+    return kebabFileName;
+  }
+
+  // Format: mainSlug:fileName.ext (for initial variant) or mainSlug:variantName:fileName.ext
+  if (isInitialVariant) {
+    return "".concat(kebabMainSlug, ":").concat(kebabFileName);
+  }
+  return "".concat(kebabMainSlug, ":").concat(kebabVariantName, ":").concat(kebabFileName);
+}
+/**
+ * Hook for managing file selection and navigation within a code variant
+ */
+export function useFileNavigation(_ref) {
+  var selectedVariant = _ref.selectedVariant,
+    transformedFiles = _ref.transformedFiles,
+    _ref$mainSlug = _ref.mainSlug,
+    mainSlug = _ref$mainSlug === void 0 ? '' : _ref$mainSlug,
+    _ref$selectedVariantK = _ref.selectedVariantKey,
+    selectedVariantKey = _ref$selectedVariantK === void 0 ? '' : _ref$selectedVariantK,
+    _ref$variantKeys = _ref.variantKeys,
+    variantKeys = _ref$variantKeys === void 0 ? [] : _ref$variantKeys,
+    initialVariant = _ref.initialVariant,
+    shouldHighlight = _ref.shouldHighlight;
+  // Keep selectedFileName as untransformed filename for internal tracking
+  var _React$useState = React.useState(selectedVariant == null ? void 0 : selectedVariant.fileName),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    selectedFileNameInternal = _React$useState2[0],
+    setSelectedFileNameInternal = _React$useState2[1];
+
+  // Use the new URL hash hook
+  var _useUrlHashState = useUrlHashState(),
+    hash = _useUrlHashState.hash,
+    setHash = _useUrlHashState.setHash,
+    hasUserInteraction = _useUrlHashState.hasUserInteraction,
+    markUserInteraction = _useUrlHashState.markUserInteraction;
+
+  // Helper function to check URL hash and switch to matching file
+  var checkUrlHashAndSelectFile = React.useCallback(function () {
+    if (!selectedVariant || !hash) {
+      return;
+    }
+
+    // Check if hash matches any file slug
+    var matchingFileName;
+
+    // Determine if this is the initial variant
+    var isInitialVariant = initialVariant ? selectedVariantKey === initialVariant : variantKeys.length === 0 || selectedVariantKey === variantKeys[0];
+
+    // Check main file
+    if (selectedVariant.fileName) {
+      var mainFileSlug = generateFileSlug(mainSlug, selectedVariant.fileName, selectedVariantKey, isInitialVariant);
+      if (hash === mainFileSlug) {
+        matchingFileName = selectedVariant.fileName;
+      }
+    }
+
+    // Check extra files
+    if (!matchingFileName && selectedVariant.extraFiles) {
+      for (var _i = 0, _Object$keys = Object.keys(selectedVariant.extraFiles); _i < _Object$keys.length; _i++) {
+        var fileName = _Object$keys[_i];
+        var fileSlug = generateFileSlug(mainSlug, fileName, selectedVariantKey, isInitialVariant);
+        if (hash === fileSlug) {
+          matchingFileName = fileName;
+          break;
+        }
+      }
+    }
+
+    // Check transformed files if available
+    if (!matchingFileName && transformedFiles) {
+      var _iterator = _createForOfIteratorHelper(transformedFiles.files),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var file = _step.value;
+          var _fileSlug = generateFileSlug(mainSlug, file.originalName, selectedVariantKey, isInitialVariant);
+          if (hash === _fileSlug) {
+            matchingFileName = file.originalName;
+            break;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+    if (matchingFileName) {
+      setSelectedFileNameInternal(matchingFileName);
+      markUserInteraction(); // Mark that user has made a selection via URL
+    }
+  }, [selectedVariant, hash, transformedFiles, mainSlug, selectedVariantKey, variantKeys, initialVariant, markUserInteraction]);
+
+  // On hydration/variant change, check URL hash and switch to matching file
+  React.useEffect(function () {
+    checkUrlHashAndSelectFile();
+  }, [checkUrlHashAndSelectFile]);
+
+  // Reset selectedFileName when variant changes
+  React.useEffect(function () {
+    if (selectedVariant && selectedFileNameInternal !== selectedVariant.fileName) {
+      // Only reset if current selectedFileName doesn't exist in the new variant
+      var hasFile = selectedVariant.fileName === selectedFileNameInternal || selectedFileNameInternal && selectedVariant.extraFiles && selectedVariant.extraFiles[selectedFileNameInternal];
+      if (!hasFile) {
+        setSelectedFileNameInternal(selectedVariant.fileName);
+      }
+    }
+  }, [selectedVariant, selectedFileNameInternal]);
+
+  // Update URL when variant changes (to reflect new slug for current file)
+  React.useEffect(function () {
+    if (!selectedVariant || typeof window === 'undefined' || !selectedFileNameInternal || !hasUserInteraction) {
+      return;
+    }
+
+    // Determine if this is the initial variant
+    var isInitialVariant = initialVariant ? selectedVariantKey === initialVariant : variantKeys.length === 0 || selectedVariantKey === variantKeys[0];
+
+    // Generate the new slug for the currently selected file
+    var fileSlug = '';
+    if (transformedFiles) {
+      var file = transformedFiles.files.find(function (f) {
+        return f.originalName === selectedFileNameInternal;
+      });
+      if (file) {
+        fileSlug = generateFileSlug(mainSlug, file.originalName, selectedVariantKey, isInitialVariant);
+      }
+    } else {
+      fileSlug = generateFileSlug(mainSlug, selectedFileNameInternal, selectedVariantKey, isInitialVariant);
+    }
+
+    // Update the URL hash without adding to history (replaceState)
+    if (fileSlug) {
+      setHash(fileSlug); // Use the new URL hash hook
+    }
+  }, [selectedVariant, selectedFileNameInternal, transformedFiles, mainSlug, selectedVariantKey, variantKeys, initialVariant, hasUserInteraction, setHash]);
+
+  // Compute the displayed filename (transformed if applicable)
+  var selectedFileName = React.useMemo(function () {
+    if (!selectedVariant) {
+      return undefined;
+    }
+
+    // If selectedFileNameInternal is undefined, we're selecting the main file
+    var effectiveFileName = selectedFileNameInternal || selectedVariant.fileName;
+    if (!effectiveFileName) {
+      return undefined;
+    }
+
+    // If we have transformed files, return the transformed name
+    if (transformedFiles) {
+      var file = transformedFiles.files.find(function (f) {
+        return f.originalName === effectiveFileName;
+      });
+      return file ? file.name : effectiveFileName;
+    }
+
+    // Otherwise, return the original filename
+    return effectiveFileName;
+  }, [selectedVariant, selectedFileNameInternal, transformedFiles]);
+  var selectedFile = React.useMemo(function () {
+    if (!selectedVariant) {
+      return null;
+    }
+
+    // If we have transformed files, use them
+    if (transformedFiles) {
+      var effectiveFileName = selectedFileNameInternal || selectedVariant.fileName;
+      var file = transformedFiles.files.find(function (f) {
+        return f.originalName === effectiveFileName;
+      });
+      return file ? file.source : null;
+    }
+
+    // Otherwise, use the original untransformed files
+    if (selectedFileNameInternal === selectedVariant.fileName || !selectedFileNameInternal) {
+      return selectedVariant.source;
+    }
+
+    // Look in extraFiles
+    if (selectedFileNameInternal && selectedVariant.extraFiles && selectedVariant.extraFiles[selectedFileNameInternal]) {
+      var extraFile = selectedVariant.extraFiles[selectedFileNameInternal];
+      if (typeof extraFile === 'string') {
+        return extraFile;
+      }
+      if (extraFile && _typeof(extraFile) === 'object' && 'source' in extraFile) {
+        return extraFile.source;
+      }
+    }
+    return null;
+  }, [selectedVariant, selectedFileNameInternal, transformedFiles]);
+  var selectedFileComponent = React.useMemo(function () {
+    if (!selectedVariant) {
+      return null;
+    }
+
+    // If we have transformed files, use them
+    if (transformedFiles) {
+      var file = transformedFiles.files.find(function (f) {
+        return f.originalName === selectedFileNameInternal;
+      });
+      return file ? file.component : null;
+    }
+
+    // Otherwise, create component from original untransformed files
+    if (selectedFileNameInternal === selectedVariant.fileName || !selectedFileNameInternal) {
+      return stringOrHastToJsx(selectedVariant.source, shouldHighlight);
+    }
+
+    // Look in extraFiles
+    if (selectedFileNameInternal && selectedVariant.extraFiles && selectedVariant.extraFiles[selectedFileNameInternal]) {
+      var extraFile = selectedVariant.extraFiles[selectedFileNameInternal];
+      var source;
+      if (typeof extraFile === 'string') {
+        source = extraFile;
+      } else if (extraFile && _typeof(extraFile) === 'object' && 'source' in extraFile) {
+        source = extraFile.source;
+      } else {
+        return null;
+      }
+      return stringOrHastToJsx(source, shouldHighlight);
+    }
+    return null;
+  }, [selectedVariant, selectedFileNameInternal, transformedFiles, shouldHighlight]);
+
+  // Convert files for the return interface
+  var files = React.useMemo(function () {
+    if (!selectedVariant) {
+      return [];
+    }
+
+    // Determine if this is the initial variant
+    var isInitialVariant = initialVariant ? selectedVariantKey === initialVariant : variantKeys.length === 0 || selectedVariantKey === variantKeys[0];
+
+    // If we have transformed files, use them
+    if (transformedFiles) {
+      return transformedFiles.files.map(function (f) {
+        return {
+          name: f.name,
+          slug: generateFileSlug(mainSlug, f.originalName, selectedVariantKey, isInitialVariant),
+          component: f.component
+        };
+      });
+    }
+
+    // Otherwise, create files from original untransformed data
+    var result = [];
+
+    // Only add main file if it has a fileName
+    if (selectedVariant.fileName) {
+      result.push({
+        name: selectedVariant.fileName,
+        slug: generateFileSlug(mainSlug, selectedVariant.fileName, selectedVariantKey, isInitialVariant),
+        component: stringOrHastToJsx(selectedVariant.source, shouldHighlight)
+      });
+    }
+    if (selectedVariant.extraFiles) {
+      Object.entries(selectedVariant.extraFiles).forEach(function (_ref2) {
+        var _ref3 = _slicedToArray(_ref2, 2),
+          fileName = _ref3[0],
+          fileData = _ref3[1];
+        var source;
+        if (typeof fileData === 'string') {
+          source = fileData;
+        } else if (fileData && _typeof(fileData) === 'object' && 'source' in fileData) {
+          source = fileData.source;
+        } else {
+          return; // Skip invalid entries
+        }
+        result.push({
+          name: fileName,
+          slug: generateFileSlug(mainSlug, fileName, selectedVariantKey, isInitialVariant),
+          component: stringOrHastToJsx(source, shouldHighlight)
+        });
+      });
+    }
+    return result;
+  }, [selectedVariant, transformedFiles, mainSlug, selectedVariantKey, variantKeys, initialVariant, shouldHighlight]);
+
+  // Create a wrapper for selectFileName that handles transformed filenames and URL updates
+  var selectFileName = React.useCallback(function (fileName) {
+    if (!selectedVariant) {
+      return;
+    }
+    var targetFileName = fileName;
+    var fileSlug = '';
+
+    // Determine if this is the initial variant
+    var isInitialVariant = initialVariant ? selectedVariantKey === initialVariant : variantKeys.length === 0 || selectedVariantKey === variantKeys[0];
+
+    // If we have transformed files, we need to reverse-lookup the original filename
+    if (transformedFiles) {
+      // Check if the fileName is a transformed name - if so, find the original
+      var fileByTransformedName = transformedFiles.files.find(function (f) {
+        return f.name === fileName;
+      });
+      if (fileByTransformedName) {
+        targetFileName = fileByTransformedName.originalName;
+        fileSlug = generateFileSlug(mainSlug, fileByTransformedName.originalName, selectedVariantKey, isInitialVariant);
+      } else {
+        // Check if the fileName is already an original name
+        var fileByOriginalName = transformedFiles.files.find(function (f) {
+          return f.originalName === fileName;
+        });
+        if (fileByOriginalName) {
+          targetFileName = fileName;
+          fileSlug = generateFileSlug(mainSlug, fileName, selectedVariantKey, isInitialVariant);
+        }
+      }
+    } else {
+      // No transformed files, generate slug directly
+      fileSlug = generateFileSlug(mainSlug, fileName, selectedVariantKey, isInitialVariant);
+    }
+
+    // Update the URL hash without adding to history (replaceState)
+    if (typeof window !== 'undefined' && fileSlug) {
+      setHash(fileSlug); // Use the new URL hash hook
+    }
+    markUserInteraction(); // Mark that user has made an explicit selection
+    setSelectedFileNameInternal(targetFileName);
+  }, [selectedVariant, transformedFiles, mainSlug, selectedVariantKey, variantKeys, initialVariant, setHash, markUserInteraction]);
+  return {
+    selectedFileName: selectedFileName,
+    selectedFile: selectedFile,
+    selectedFileComponent: selectedFileComponent,
+    files: files,
+    selectFileName: selectFileName
+  };
+}

package/useCode/useSourceEditing.d.ts

@@ -0,0 +1,19 @@
+interface UseSourceEditingProps {
+  context?: any;
+  selectedVariantKey: string;
+  effectiveCode: any;
+  selectedVariant: any;
+}
+export interface UseSourceEditingResult {
+  setSource?: (source: string) => void;
+}
+/**
+ * Hook for managing source code editing functionality
+ */
+export declare function useSourceEditing({
+  context,
+  selectedVariantKey,
+  effectiveCode,
+  selectedVariant
+}: UseSourceEditingProps): UseSourceEditingResult;
+export {};

package/useCode/useSourceEditing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSourceEditing.d.ts","sourceRoot":"","sources":["../../src/useCode/useSourceEditing.ts"],"names":[],"mappings":"AAGA,UAAU,qBAAqB;IAC7B,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,kBAAkB,EAAE,MAAM,CAAC;IAC3B,aAAa,EAAE,GAAG,CAAC;IACnB,eAAe,EAAE,GAAG,CAAC;CACtB;AAED,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAC;CACtC;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,OAAO,EACP,kBAAkB,EAClB,aAAa,EACb,eAAe,GAChB,EAAE,qBAAqB,GAAG,sBAAsB,CAgChD"}

package/useCode/useSourceEditing.js

@@ -0,0 +1,32 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import * as React from 'react';
+/**
+ * Hook for managing source code editing functionality
+ */
+export function useSourceEditing(_ref) {
+  var context = _ref.context,
+    selectedVariantKey = _ref.selectedVariantKey,
+    effectiveCode = _ref.effectiveCode,
+    selectedVariant = _ref.selectedVariant;
+  var contextSetCode = context == null ? void 0 : context.setCode;
+  var setSource = React.useCallback(function (source) {
+    if (contextSetCode) {
+      contextSetCode(function (currentCode) {
+        var newCode = {};
+        if (!currentCode) {
+          newCode = _objectSpread({}, effectiveCode); // TODO: ensure all source are strings
+        }
+        newCode[selectedVariantKey] = _objectSpread(_objectSpread({}, newCode[selectedVariantKey] || selectedVariant), {}, {
+          source: source,
+          extraFiles: {}
+        });
+        return newCode;
+      });
+    } else {
+      console.warn('setCode is not available in the current context. Ensure you are using CodeControllerContext.');
+    }
+  }, [contextSetCode, selectedVariantKey, effectiveCode, selectedVariant]);
+  return {
+    setSource: contextSetCode ? setSource : undefined
+  };
+}

package/useCode/useTransformManagement.d.ts

@@ -0,0 +1,28 @@
+import type { Code } from "../CodeHighlighter/types.js";
+interface UseTransformManagementProps {
+  context?: any;
+  effectiveCode: Code;
+  selectedVariantKey: string;
+  selectedVariant: any;
+  initialTransform?: string;
+  shouldHighlight: boolean;
+}
+export interface UseTransformManagementResult {
+  availableTransforms: string[];
+  selectedTransform: string | null;
+  transformedFiles: any;
+  selectTransform: (transformName: string | null) => void;
+}
+/**
+ * Hook for managing code transforms and their application
+ * Uses the useLocalStorage hook for local storage persistence of transform preferences
+ */
+export declare function useTransformManagement({
+  context,
+  effectiveCode,
+  selectedVariantKey,
+  selectedVariant,
+  initialTransform,
+  shouldHighlight
+}: UseTransformManagementProps): UseTransformManagementResult;
+export {};

package/useCode/useTransformManagement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTransformManagement.d.ts","sourceRoot":"","sources":["../../src/useCode/useTransformManagement.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAIrD,UAAU,2BAA2B;IACnC,OAAO,CAAC,EAAE,GAAG,CAAC;IACd,aAAa,EAAE,IAAI,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,GAAG,CAAC;IACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,eAAe,EAAE,OAAO,CAAC;CAC1B;AAED,MAAM,WAAW,4BAA4B;IAC3C,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,gBAAgB,EAAE,GAAG,CAAC;IACtB,eAAe,EAAE,CAAC,aAAa,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CACzD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,OAAO,EACP,aAAa,EACb,kBAAkB,EAClB,eAAe,EACf,gBAAgB,EAChB,eAAe,GAChB,EAAE,2BAA2B,GAAG,4BAA4B,CAqE5D"}

package/useCode/useTransformManagement.js

@@ -0,0 +1,82 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import * as React from 'react';
+import { getAvailableTransforms, createTransformedFiles } from "./useCodeUtils.js";
+import useLocalStorageState from "../useLocalStorageState/index.js";
+/**
+ * Hook for managing code transforms and their application
+ * Uses the useLocalStorage hook for local storage persistence of transform preferences
+ */
+export function useTransformManagement(_ref) {
+  var context = _ref.context,
+    effectiveCode = _ref.effectiveCode,
+    selectedVariantKey = _ref.selectedVariantKey,
+    selectedVariant = _ref.selectedVariant,
+    initialTransform = _ref.initialTransform,
+    shouldHighlight = _ref.shouldHighlight;
+  // Transform state - get available transforms from context or from the effective code data
+  var availableTransforms = React.useMemo(function () {
+    // First try to get from context
+    if (context != null && context.availableTransforms && context.availableTransforms.length > 0) {
+      return context.availableTransforms;
+    }
+
+    // Otherwise, get from the effective code data using the utility function
+    return getAvailableTransforms(effectiveCode, selectedVariantKey);
+  }, [context == null ? void 0 : context.availableTransforms, effectiveCode, selectedVariantKey]);
+
+  // Generate storage key from sorted available transforms
+  var storageKey = React.useMemo(function () {
+    if (availableTransforms.length === 0) {
+      return null; // Don't use localStorage when no transforms are available
+    }
+    var sortedTransforms = _toConsumableArray(availableTransforms).sort();
+    return "_docs_infra_transform_prefs_".concat(sortedTransforms.join(':'));
+  }, [availableTransforms]);
+
+  // Use localStorage hook for transform persistence - this is our single source of truth
+  var _useLocalStorageState = useLocalStorageState(storageKey, function () {
+      // Don't use initialTransform as the fallback - localStorage should always take precedence
+      // We'll handle the initial transform separately below
+      return null;
+    }),
+    _useLocalStorageState2 = _slicedToArray(_useLocalStorageState, 2),
+    storedValue = _useLocalStorageState2[0],
+    setStoredValue = _useLocalStorageState2[1];
+
+  // Handle validation manually - empty string means "no transform selected"
+  var selectedTransform = React.useMemo(function () {
+    // If we have a stored value (including empty string), use it
+    if (storedValue !== null) {
+      if (storedValue === '') {
+        return null;
+      }
+      // Validate the stored value
+      if (!availableTransforms.includes(storedValue)) {
+        return null;
+      }
+      return storedValue;
+    }
+
+    // If no stored value and we have an initial transform, use it (but don't store it yet)
+    if (initialTransform && availableTransforms.includes(initialTransform)) {
+      return initialTransform;
+    }
+    return null;
+  }, [storedValue, availableTransforms, initialTransform]);
+  var setSelectedTransformAsUser = React.useCallback(function (value) {
+    var valueToStore = value === null ? '' : value;
+    setStoredValue(valueToStore);
+  }, [setStoredValue]);
+
+  // Memoize all transformed files based on selectedTransform
+  var transformedFiles = React.useMemo(function () {
+    return createTransformedFiles(selectedVariant, selectedTransform, shouldHighlight);
+  }, [selectedVariant, selectedTransform, shouldHighlight]);
+  return {
+    availableTransforms: availableTransforms,
+    selectedTransform: selectedTransform,
+    transformedFiles: transformedFiles,
+    selectTransform: setSelectedTransformAsUser
+  };
+}

package/useCode/useUIState.d.ts

@@ -0,0 +1,16 @@
+import * as React from 'react';
+interface UseUIStateProps {
+  defaultOpen?: boolean;
+}
+export interface UseUIStateResult {
+  expanded: boolean;
+  expand: () => void;
+  setExpanded: React.Dispatch<React.SetStateAction<boolean>>;
+}
+/**
+ * Hook for managing UI state like expansion and focus
+ */
+export declare function useUIState({
+  defaultOpen
+}: UseUIStateProps): UseUIStateResult;
+export {};

package/useCode/useUIState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUIState.d.ts","sourceRoot":"","sources":["../../src/useCode/useUIState.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,UAAU,eAAe;IACvB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,WAAW,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC;CAC5D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,EAAE,WAAmB,EAAE,EAAE,eAAe,GAAG,gBAAgB,CASrF"}

package/useCode/useUIState.js

@@ -0,0 +1,21 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+/**
+ * Hook for managing UI state like expansion and focus
+ */
+export function useUIState(_ref) {
+  var _ref$defaultOpen = _ref.defaultOpen,
+    defaultOpen = _ref$defaultOpen === void 0 ? false : _ref$defaultOpen;
+  var _React$useState = React.useState(defaultOpen),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    expanded = _React$useState2[0],
+    setExpanded = _React$useState2[1];
+  var expand = React.useCallback(function () {
+    return setExpanded(true);
+  }, []);
+  return {
+    expanded: expanded,
+    expand: expand,
+    setExpanded: setExpanded
+  };
+}

package/useCode/useVariantSelection.d.ts

@@ -0,0 +1,21 @@
+import * as React from 'react';
+import type { Code } from "../CodeHighlighter/types.js";
+interface UseVariantSelectionProps {
+  effectiveCode: Code;
+  initialVariant?: string;
+}
+export interface UseVariantSelectionResult {
+  variantKeys: string[];
+  selectedVariantKey: string;
+  selectedVariant: any;
+  selectVariant: React.Dispatch<React.SetStateAction<string>>;
+}
+/**
+ * Hook for managing variant selection and providing variant-related data
+ * Uses the useLocalStorage hook for local storage persistence of variant preferences
+ */
+export declare function useVariantSelection({
+  effectiveCode,
+  initialVariant
+}: UseVariantSelectionProps): UseVariantSelectionResult;
+export {};

package/useCode/useVariantSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useVariantSelection.d.ts","sourceRoot":"","sources":["../../src/useCode/useVariantSelection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAC/B,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAGrD,UAAU,wBAAwB;IAChC,aAAa,EAAE,IAAI,CAAC;IACpB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,eAAe,EAAE,GAAG,CAAC;IACrB,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,CAAC,CAAC,CAAC;CAC7D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,aAAa,EACb,cAAc,GACf,EAAE,wBAAwB,GAAG,yBAAyB,CA+EtD"}