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

package/useDemo/useDemo.d.ts

@@ -0,0 +1,78 @@
+import * as React from 'react';
+import { UseCopierOpts } from "../useCopier/index.js";
+import type { ContentProps } from "../CodeHighlighter/types.js";
+/**
+ * Demo templates use the exportVariant/exportVariantAsCra with flattenVariant pattern:
+ *
+ * For StackBlitz:
+ * const { exported: exportedVariant, entrypoint } = exportVariant(variantCode);
+ * const flattenedFiles = flattenVariant(exportedVariant);
+ * createStackBlitzDemo({ title, description, flattenedFiles, useTypescript, initialFile: entrypoint })
+ *
+ * For CodeSandbox:
+ * const { exported: craExport, entrypoint } = exportVariantAsCra(variantCode, { title, description, useTypescript });
+ * const flattenedFiles = flattenVariant(craExport);
+ * createCodeSandboxDemo({ title, description, flattenedFiles, useTypescript, initialFile: entrypoint })
+ * createCodeSandboxDemo({ title, description, flattenedFiles, useTypescript })
+ */
+type UseDemoOpts = {
+  defaultOpen?: boolean;
+  copy?: UseCopierOpts;
+  githubUrlPrefix?: string;
+  codeSandboxUrlPrefix?: string;
+  stackBlitzPrefix?: string;
+  initialVariant?: string;
+  initialTransform?: string;
+};
+/**
+ * Helper to create HTML form element with hidden inputs
+ */
+export declare function addHiddenInput(form: HTMLFormElement, name: string, value: string): void;
+/**
+ * Generic function to create and submit a form for opening online demo platforms
+ * This function creates HTML elements and should be used in browser contexts
+ */
+export declare function openWithForm({
+  url,
+  formData,
+  method,
+  target
+}: {
+  url: string;
+  formData: Record<string, string>;
+  method?: string;
+  target?: string;
+}): void;
+export declare function useDemo<T extends {} = {}>(contentProps: ContentProps<T>, opts?: UseDemoOpts): {
+  component: string | number | bigint | true | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null;
+  ref: React.RefObject<HTMLDivElement | null>;
+  resetFocus: () => void;
+  openStackBlitz: () => void;
+  openCodeSandbox: () => void;
+  name: string | undefined;
+  slug: string | undefined;
+  variants: string[];
+  selectedVariant: string;
+  selectVariant: React.Dispatch<React.SetStateAction<string>>;
+  files: Array<{
+    name: string;
+    slug?: string;
+    component: React.ReactNode;
+  }>;
+  selectedFile: React.ReactNode;
+  selectedFileName: string | undefined;
+  selectFileName: (fileName: string) => void;
+  expanded: boolean;
+  expand: () => void;
+  setExpanded: React.Dispatch<React.SetStateAction<boolean>>;
+  copy: (event: React.MouseEvent<HTMLButtonElement>) => Promise<void>;
+  availableTransforms: string[];
+  selectedTransform: string | null | undefined;
+  selectTransform: (transformName: string | null) => void;
+  setSource?: (source: string) => void;
+  userProps: T & {
+    name?: string;
+    slug?: string;
+  };
+};
+export {};

package/useDemo/useDemo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDemo.d.ts","sourceRoot":"","sources":["../../src/useDemo/useDemo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAQ7D;;;;;;;;;;;;;GAaG;AAEH,KAAK,WAAW,GAAG;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,IAAI,CAAC,EAAE,aAAa,CAAC;IACrB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC;AAEF;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAMvF;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,EAC3B,GAAG,EACH,QAAQ,EACR,MAAe,EACf,MAAiB,GAClB,EAAE;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB,GAAG,IAAI,CAaP;AAGD,wBAAgB,OAAO,CAAC,CAAC,SAAS,EAAE,GAAG,EAAE,EAAE,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,WAAW;;;;;;;;;;;;;YAxDnD,CAAC;;;;;;;;;;;;;;;;;;EA4KzC"}

package/useDemo/useDemo.js

@@ -0,0 +1,174 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import kebabCase from 'kebab-case';
+import { useCode } from "../useCode/index.js";
+import { CodeHighlighterContext } from "../CodeHighlighter/CodeHighlighterContext.js";
+import { createStackBlitz } from "./createStackBlitz.js";
+import { createCodeSandbox } from "./createCodeSandbox.js";
+import { exportVariant } from "./exportVariant.js";
+import { exportVariantAsCra } from "./exportVariantAsCra.js";
+import { flattenVariant } from "./flattenVariant.js";
+
+/**
+ * Demo templates use the exportVariant/exportVariantAsCra with flattenVariant pattern:
+ *
+ * For StackBlitz:
+ * const { exported: exportedVariant, entrypoint } = exportVariant(variantCode);
+ * const flattenedFiles = flattenVariant(exportedVariant);
+ * createStackBlitzDemo({ title, description, flattenedFiles, useTypescript, initialFile: entrypoint })
+ *
+ * For CodeSandbox:
+ * const { exported: craExport, entrypoint } = exportVariantAsCra(variantCode, { title, description, useTypescript });
+ * const flattenedFiles = flattenVariant(craExport);
+ * createCodeSandboxDemo({ title, description, flattenedFiles, useTypescript, initialFile: entrypoint })
+ * createCodeSandboxDemo({ title, description, flattenedFiles, useTypescript })
+ */
+
+/**
+ * Helper to create HTML form element with hidden inputs
+ */
+export function addHiddenInput(form, name, value) {
+  var input = document.createElement('input');
+  input.type = 'hidden';
+  input.name = name;
+  input.value = value;
+  form.appendChild(input);
+}
+
+/**
+ * Generic function to create and submit a form for opening online demo platforms
+ * This function creates HTML elements and should be used in browser contexts
+ */
+export function openWithForm(_ref) {
+  var url = _ref.url,
+    formData = _ref.formData,
+    _ref$method = _ref.method,
+    method = _ref$method === void 0 ? 'POST' : _ref$method,
+    _ref$target = _ref.target,
+    target = _ref$target === void 0 ? '_blank' : _ref$target;
+  var form = document.createElement('form');
+  form.method = method;
+  form.target = target;
+  form.action = url;
+  Object.entries(formData).forEach(function (_ref2) {
+    var _ref3 = _slicedToArray(_ref2, 2),
+      name = _ref3[0],
+      value = _ref3[1];
+    addHiddenInput(form, name, value);
+  });
+  document.body.appendChild(form);
+  form.submit();
+  document.body.removeChild(form);
+}
+
+// TODO: take initialVariant and initialTransforms as parameters
+export function useDemo(contentProps, opts) {
+  var codeResult = useCode(contentProps, opts);
+
+  // Get context to access components if available (using React.useContext to avoid import conflicts)
+  var context = React.useContext(CodeHighlighterContext);
+  var slug = React.useMemo(function () {
+    return contentProps.slug || (contentProps.name ? kebabCase(contentProps.name, false) : undefined);
+  }, [contentProps.slug, contentProps.name]);
+
+  // Get the effective components object - context overrides contentProps
+  var effectiveComponents = React.useMemo(function () {
+    return (context == null ? void 0 : context.components) || contentProps.components || {};
+  }, [context == null ? void 0 : context.components, contentProps.components]);
+
+  // Get the component for the current variant
+  var component = React.useMemo(function () {
+    return effectiveComponents[codeResult.selectedVariant] || null;
+  }, [effectiveComponents, codeResult.selectedVariant]);
+
+  // Demo-specific ref and focus management
+  var ref = React.useRef(null);
+  var resetFocus = React.useCallback(function () {
+    var _ref$current;
+    (_ref$current = ref.current) == null || _ref$current.focus();
+  }, []);
+
+  // Get the effective code - context overrides contentProps if available
+  var effectiveCode = React.useMemo(function () {
+    return (context == null ? void 0 : context.code) || contentProps.code || {};
+  }, [context == null ? void 0 : context.code, contentProps.code]);
+
+  // Create StackBlitz demo callback
+  var openStackBlitz = React.useCallback(function () {
+    // Get the current variant code
+    var variantCode = effectiveCode[codeResult.selectedVariant];
+    if (!variantCode || typeof variantCode === 'string') {
+      console.warn('No valid variant code available for StackBlitz demo');
+      return;
+    }
+    var title = contentProps.name || 'Demo';
+    var description = "".concat(title, " demo");
+
+    // Determine if we should use TypeScript based on whether 'js' transform is NOT applied
+    // If 'js' transform is applied, it means we're showing the JS version of TS code
+    var useTypescript = codeResult.selectedTransform !== 'js';
+
+    // Export variant with additional configuration files
+    var _exportVariant = exportVariant(variantCode, {
+        title: title,
+        description: description,
+        useTypescript: useTypescript
+      }),
+      exported = _exportVariant.exported,
+      rootFile = _exportVariant.rootFile;
+
+    // Flatten the variant to get a flat file structure
+    var flattenedFiles = flattenVariant(exported);
+    var stackBlitzDemo = createStackBlitz({
+      title: title,
+      description: description,
+      flattenedFiles: flattenedFiles,
+      rootFile: rootFile
+    });
+    openWithForm(stackBlitzDemo);
+  }, [effectiveCode, codeResult.selectedVariant, codeResult.selectedTransform, contentProps.name]);
+
+  // Create CodeSandbox demo callback
+  var openCodeSandbox = React.useCallback(function () {
+    // Get the current variant code
+    var variantCode = effectiveCode[codeResult.selectedVariant];
+    if (!variantCode || typeof variantCode === 'string') {
+      console.warn('No valid variant code available for CodeSandbox demo');
+      return;
+    }
+    var title = contentProps.name || 'Demo';
+    var description = "".concat(title, " demo");
+
+    // Determine if we should use TypeScript based on whether 'js' transform is NOT applied
+    // If 'js' transform is applied, it means we're showing the JS version of TS code
+    var useTypescript = codeResult.selectedTransform !== 'js';
+
+    // Export variant as CRA template with additional configuration files
+    var _exportVariantAsCra = exportVariantAsCra(variantCode, {
+        title: title,
+        description: description,
+        useTypescript: useTypescript
+      }),
+      craExport = _exportVariantAsCra.exported,
+      rootFile = _exportVariantAsCra.rootFile;
+
+    // Flatten the variant to get a flat file structure
+    var flattenedFiles = flattenVariant(craExport);
+    var codeSandboxDemo = createCodeSandbox({
+      flattenedFiles: flattenedFiles,
+      rootFile: rootFile
+    });
+    openWithForm(codeSandboxDemo);
+  }, [effectiveCode, codeResult.selectedVariant, codeResult.selectedTransform, contentProps.name]);
+  return _objectSpread(_objectSpread({}, codeResult), {}, {
+    // Demo-specific additions
+    component: component,
+    ref: ref,
+    resetFocus: resetFocus,
+    openStackBlitz: openStackBlitz,
+    openCodeSandbox: openCodeSandbox,
+    name: contentProps.name,
+    slug: slug
+  });
+}

package/useLocalStorageState/index.d.ts

@@ -0,0 +1,2 @@
+import useLocalStorageState from "./useLocalStorageState.js";
+export default useLocalStorageState;

package/useLocalStorageState/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/useLocalStorageState/index.ts"],"names":[],"mappings":"AAAA,OAAO,oBAAoB,MAAM,wBAAwB,CAAC;AAE1D,eAAe,oBAAoB,CAAC"}

package/useLocalStorageState/index.js

@@ -0,0 +1,2 @@
+import useLocalStorageState from "./useLocalStorageState.js";
+export default useLocalStorageState;

package/useLocalStorageState/useLocalStorageState.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+type Initializer = () => string | null;
+type UseStorageStateHookResult = [string | null, React.Dispatch<React.SetStateAction<string | null>>];
+/**
+ * Sync state to local storage so that it persists through a page refresh. Usage is
+ * similar to useState except we pass in a storage key so that we can default
+ * to that value on page load instead of the specified initial value.
+ *
+ * Since the storage API isn't available in server-rendering environments, we
+ * return null during SSR and hydration.
+ */
+declare function useLocalStorageStateBrowser(key: string | null, initializer?: string | null | Initializer): UseStorageStateHookResult;
+declare const _default: typeof useLocalStorageStateBrowser;
+export default _default;

package/useLocalStorageState/useLocalStorageState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalStorageState.d.ts","sourceRoot":"","sources":["../../src/useLocalStorageState/useLocalStorageState.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAwF/B,KAAK,WAAW,GAAG,MAAM,MAAM,GAAG,IAAI,CAAC;AAEvC,KAAK,yBAAyB,GAAG;IAC/B,MAAM,GAAG,IAAI;IACb,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,cAAc,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CACpD,CAAC;AAQF;;;;;;;GAOG;AACH,iBAAS,2BAA2B,CAClC,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,WAAW,GAAE,MAAM,GAAG,IAAI,GAAG,WAAkB,GAC9C,yBAAyB,CAoC3B;;AAED,wBAEgC"}

package/useLocalStorageState/useLocalStorageState.js

@@ -0,0 +1,128 @@
+'use client';
+
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+
+/**
+ * Copied from https://github.com/mui/material-ui/blob/9dfc2b12f3fc5c41071da5e10b0088fb04045a26/packages/mui-utils/src/useLocalStorageState/useLocalStorageState.ts
+ */
+
+// storage events only work across tabs, we'll use an event emitter to announce within the current tab
+var currentTabChangeListeners = new Map();
+function onCurrentTabStorageChange(key, handler) {
+  var listeners = currentTabChangeListeners.get(key);
+  if (!listeners) {
+    listeners = new Set();
+    currentTabChangeListeners.set(key, listeners);
+  }
+  listeners.add(handler);
+}
+function offCurrentTabStorageChange(key, handler) {
+  var listeners = currentTabChangeListeners.get(key);
+  if (!listeners) {
+    return;
+  }
+  listeners["delete"](handler);
+  if (listeners.size === 0) {
+    currentTabChangeListeners["delete"](key);
+  }
+}
+function emitCurrentTabStorageChange(key) {
+  var listeners = currentTabChangeListeners.get(key);
+  if (listeners) {
+    listeners.forEach(function (listener) {
+      return listener();
+    });
+  }
+}
+function subscribe(area, key, callback) {
+  if (!key) {
+    return function () {};
+  }
+  var storageHandler = function storageHandler(event) {
+    if (event.storageArea === area && event.key === key) {
+      callback();
+    }
+  };
+  window.addEventListener('storage', storageHandler);
+  onCurrentTabStorageChange(key, callback);
+  return function () {
+    window.removeEventListener('storage', storageHandler);
+    offCurrentTabStorageChange(key, callback);
+  };
+}
+function getSnapshot(area, key) {
+  if (!key) {
+    return null;
+  }
+  try {
+    return area.getItem(key);
+  } catch (_unused) {
+    // ignore
+    // See https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API#feature-detecting_localstorage
+    return null;
+  }
+}
+function setValue(area, key, value) {
+  if (!key) {
+    return;
+  }
+  try {
+    if (value === null) {
+      area.removeItem(key);
+    } else {
+      area.setItem(key, String(value));
+    }
+  } catch (_unused2) {
+    // ignore
+    // See https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API#feature-detecting_localstorage
+    return;
+  }
+  emitCurrentTabStorageChange(key);
+}
+var serverValue = [null, function () {}];
+function useLocalStorageStateServer() {
+  return serverValue;
+}
+
+/**
+ * Sync state to local storage so that it persists through a page refresh. Usage is
+ * similar to useState except we pass in a storage key so that we can default
+ * to that value on page load instead of the specified initial value.
+ *
+ * Since the storage API isn't available in server-rendering environments, we
+ * return null during SSR and hydration.
+ */
+function useLocalStorageStateBrowser(key) {
+  var initializer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+  var _React$useState = React.useState(initializer),
+    _React$useState2 = _slicedToArray(_React$useState, 1),
+    initialValue = _React$useState2[0];
+  var area = window.localStorage;
+  var subscribeKey = React.useCallback(function (callback) {
+    return subscribe(area, key, callback);
+  }, [area, key]);
+  var getKeySnapshot = React.useCallback(function () {
+    var _getSnapshot;
+    return (_getSnapshot = getSnapshot(area, key)) != null ? _getSnapshot : initialValue;
+  }, [area, initialValue, key]);
+
+  // Start with null for the hydration, and then switch to the actual value.
+  var getKeyServerSnapshot = function getKeyServerSnapshot() {
+    return null;
+  };
+  var storedValue = React.useSyncExternalStore(subscribeKey, getKeySnapshot, getKeyServerSnapshot);
+  var setStoredValue = React.useCallback(function (value) {
+    var valueToStore = value instanceof Function ? value(storedValue) : value;
+    setValue(area, key, valueToStore);
+  }, [area, key, storedValue]);
+  var _React$useState3 = React.useState(initialValue),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    nonStoredValue = _React$useState4[0],
+    setNonStoredValue = _React$useState4[1];
+  if (!key) {
+    return [nonStoredValue, setNonStoredValue];
+  }
+  return [storedValue, setStoredValue];
+}
+export default typeof window === 'undefined' ? useLocalStorageStateServer : useLocalStorageStateBrowser;

package/useOnHydrate/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/useOnHydrate/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/useOnHydrate/useOnHydrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnHydrate.d.ts","sourceRoot":"","sources":["../../src/useOnHydrate/useOnHydrate.ts"],"names":[],"mappings":"AAEA,wBAAgB,YAAY,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,WAYjD"}

package/useOnIdle/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/useOnIdle/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC"}

package/useOnIdle/useOnIdle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnIdle.d.ts","sourceRoot":"","sources":["../../src/useOnIdle/useOnIdle.ts"],"names":[],"mappings":"AAEA,wBAAgB,SAAS,CAAC,QAAQ,CAAC,EAAE,MAAM,IAAI,EAAE,OAAO,SAAO,WAkC9D"}

package/useUrlHashState/index.d.ts

@@ -0,0 +1 @@
+export * from "./useUrlHashState.js";

package/useUrlHashState/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/useUrlHashState/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/useUrlHashState/index.js

@@ -0,0 +1 @@
+export * from "./useUrlHashState.js";

package/useUrlHashState/useUrlHashState.d.ts

@@ -0,0 +1,50 @@
+export interface UseUrlHashStateOptions {
+  /**
+   * Whether to automatically read the hash on mount
+   * @default true
+   */
+  readOnMount?: boolean;
+  /**
+   * Whether to automatically watch for hash changes
+   * @default true
+   */
+  watchChanges?: boolean;
+  /**
+   * Custom hash parser function
+   * @default (hash) => hash.slice(1) // Remove the '#'
+   */
+  parseHash?: (hash: string) => string;
+  /**
+   * Custom hash formatter function
+   * @default (value) => value
+   */
+  formatHash?: (value: string) => string;
+}
+export interface UseUrlHashStateResult {
+  /**
+   * Current hash value (without the '#')
+   */
+  hash: string | null;
+  /**
+   * Set a new hash value (will update the URL)
+   * @param value - New hash value
+   * @param replace - Whether to use replaceState instead of pushState
+   */
+  setHash: (value: string | null, replace?: boolean) => void;
+  /**
+   * Whether the initial hash has been processed
+   */
+  hasProcessedInitialHash: boolean;
+  /**
+   * Whether the user has explicitly interacted with the hash
+   */
+  hasUserInteraction: boolean;
+  /**
+   * Mark that user has interacted with the hash
+   */
+  markUserInteraction: () => void;
+}
+/**
+ * Hook for managing URL hash state with SSR support
+ */
+export declare function useUrlHashState(options?: UseUrlHashStateOptions): UseUrlHashStateResult;

package/useUrlHashState/useUrlHashState.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useUrlHashState.d.ts","sourceRoot":"","sources":["../../src/useUrlHashState/useUrlHashState.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IAEtB;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,MAAM,CAAC;IAErC;;;OAGG;IACH,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;CACxC;AAED,MAAM,WAAW,qBAAqB;IACpC;;OAEG;IACH,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAEpB;;;;OAIG;IACH,OAAO,EAAE,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;IAE3D;;OAEG;IACH,uBAAuB,EAAE,OAAO,CAAC;IAEjC;;OAEG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAE5B;;OAEG;IACH,mBAAmB,EAAE,MAAM,IAAI,CAAC;CACjC;AAKD;;GAEG;AACH,wBAAgB,eAAe,CAAC,OAAO,GAAE,sBAA2B,GAAG,qBAAqB,CAkG3F"}

package/useUrlHashState/useUrlHashState.js

@@ -0,0 +1,113 @@
+'use client';
+
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+var defaultParseHash = function defaultParseHash(hash) {
+  return hash.slice(1);
+}; // Remove the '#'
+var defaultFormatHash = function defaultFormatHash(value) {
+  return value;
+};
+
+/**
+ * Hook for managing URL hash state with SSR support
+ */
+export function useUrlHashState() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options$readOnMount = options.readOnMount,
+    readOnMount = _options$readOnMount === void 0 ? true : _options$readOnMount,
+    _options$watchChanges = options.watchChanges,
+    watchChanges = _options$watchChanges === void 0 ? true : _options$watchChanges,
+    _options$parseHash = options.parseHash,
+    parseHash = _options$parseHash === void 0 ? defaultParseHash : _options$parseHash,
+    _options$formatHash = options.formatHash,
+    formatHash = _options$formatHash === void 0 ? defaultFormatHash : _options$formatHash;
+  var _React$useState = React.useState(null),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    hash = _React$useState2[0],
+    setHashState = _React$useState2[1];
+  var _React$useState3 = React.useState(false),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    hasProcessedInitialHash = _React$useState4[0],
+    setHasProcessedInitialHash = _React$useState4[1];
+  var _React$useState5 = React.useState(false),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    hasUserInteraction = _React$useState6[0],
+    setHasUserInteraction = _React$useState6[1];
+
+  // Read hash from URL
+  var readHash = React.useCallback(function () {
+    if (typeof window === 'undefined') {
+      return null;
+    }
+    var currentHash = window.location.hash;
+    if (!currentHash) {
+      return null;
+    }
+    return parseHash(currentHash);
+  }, [parseHash]);
+
+  // Set hash in URL and state
+  var setHash = React.useCallback(function (value) {
+    var replace = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    if (typeof window === 'undefined') {
+      return;
+    }
+    var formattedValue = value ? formatHash(value) : '';
+    var newUrl = formattedValue ? "".concat(window.location.pathname).concat(window.location.search, "#").concat(formattedValue) : "".concat(window.location.pathname).concat(window.location.search);
+
+    // Special case: if value is an empty string (not null), include the hash
+    if (value === '') {
+      var newUrlWithEmptyHash = "".concat(window.location.pathname).concat(window.location.search, "#");
+      if (replace) {
+        window.history.replaceState(null, '', newUrlWithEmptyHash);
+      } else {
+        window.history.pushState(null, '', newUrlWithEmptyHash);
+      }
+    } else if (replace) {
+      window.history.replaceState(null, '', newUrl);
+    } else {
+      window.history.pushState(null, '', newUrl);
+    }
+    setHashState(value);
+  }, [formatHash]);
+
+  // Mark user interaction
+  var markUserInteraction = React.useCallback(function () {
+    setHasUserInteraction(true);
+  }, []);
+
+  // Handle hash changes from browser navigation
+  var handleHashChange = React.useCallback(function () {
+    var newHash = readHash();
+    setHashState(newHash);
+  }, [readHash]);
+
+  // Read initial hash on mount
+  React.useEffect(function () {
+    if (!readOnMount || hasProcessedInitialHash) {
+      return;
+    }
+    var initialHash = readHash();
+    setHashState(initialHash);
+    setHasProcessedInitialHash(true);
+  }, [readOnMount, readHash, hasProcessedInitialHash]);
+
+  // Watch for hash changes
+  React.useEffect(function () {
+    if (!watchChanges || typeof window === 'undefined') {
+      return undefined;
+    }
+    window.addEventListener('hashchange', handleHashChange);
+    return function () {
+      window.removeEventListener('hashchange', handleHashChange);
+    };
+  }, [watchChanges, handleHashChange]);
+  return {
+    hash: hash,
+    setHash: setHash,
+    hasProcessedInitialHash: hasProcessedInitialHash,
+    hasUserInteraction: hasUserInteraction,
+    markUserInteraction: markUserInteraction
+  };
+}

package/build/CodeControllerContext/CodeControllerContext.js

@@ -1,21 +0,0 @@
-"use strict";
-'use client';
-
-var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard")["default"];
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CodeControllerContext = void 0;
-exports.useControlledCode = useControlledCode;
-var React = _interopRequireWildcard(require("react"));
-var CodeControllerContext = exports.CodeControllerContext = /*#__PURE__*/React.createContext(undefined);
-function useControlledCode() {
-  var context = React.useContext(CodeControllerContext);
-  return {
-    controlledCode: context == null ? void 0 : context.code,
-    controlledSelection: context == null ? void 0 : context.selection,
-    controlledSetCode: context == null ? void 0 : context.setCode,
-    controlledSetSelection: context == null ? void 0 : context.setSelection,
-    controlledComponents: context == null ? void 0 : context.components
-  };
-}

package/build/CodeControllerContext/index.js

@@ -1,16 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-var _CodeControllerContext = require("./CodeControllerContext");
-Object.keys(_CodeControllerContext).forEach(function (key) {
-  if (key === "default" || key === "__esModule") return;
-  if (key in exports && exports[key] === _CodeControllerContext[key]) return;
-  Object.defineProperty(exports, key, {
-    enumerable: true,
-    get: function get() {
-      return _CodeControllerContext[key];
-    }
-  });
-});

package/build/CodeHighlighter/CodeHighlighter.d.ts

@@ -1,2 +0,0 @@
-import type { CodeHighlighterProps } from "./types.js";
-export declare function CodeHighlighter(props: CodeHighlighterProps): import("react/jsx-runtime").JSX.Element;