npm - @mui/internal-docs-infra - Versions diffs - 0.1.1-alpha.1 → 0.1.1-alpha.10 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (286) hide show

package/useDemo/exportVariant.js ADDED Viewed

@@ -0,0 +1,320 @@
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+/**
+ * Export variant functionality to add extra files like package.json, tsconfig, etc.
+ * Users can pass configuration options that vary the output here.
+ */
+import { externalsToPackages } from "../pipeline/loaderUtils/index.js";
+import { getFileNameFromUrl } from "../pipeline/loaderUtils/getFileNameFromUrl.js";
+import { createPathContext } from "./examineVariant.js";
+/**
+ * Extract filename from URL or return undefined if not available
+ */
+export function getFilenameFromVariant(variantCode) {
+  if (variantCode.fileName) {
+    return variantCode.fileName;
+  }
+  if (variantCode.url) {
+    var _getFileNameFromUrl = getFileNameFromUrl(variantCode.url),
+      fileName = _getFileNameFromUrl.fileName;
+    return fileName || undefined;
+  }
+  return undefined;
+}
+/**
+ * Generate a unique entrypoint filename that doesn't conflict with existing files
+ */
+export function generateEntrypointFilename(existingFiles, sourceFilename, useTypescript) {
+  var pathPrefix = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : '';
+  var ext = useTypescript ? 'tsx' : 'jsx';
+  var candidates = ["".concat(pathPrefix, "index.").concat(ext), "".concat(pathPrefix, "entrypoint.").concat(ext), "".concat(pathPrefix, "main.").concat(ext)];
+  // If we have a source filename, also try variations
+  if (sourceFilename) {
+    var baseName = sourceFilename.replace(/\.[^.]*$/, '');
+    candidates.push("".concat(pathPrefix).concat(baseName, "-entry.").concat(ext));
+  }
+  for (var _i = 0, _candidates = candidates; _i < _candidates.length; _i++) {
+    var candidate = _candidates[_i];
+    if (candidate !== "".concat(pathPrefix).concat(sourceFilename) && !existingFiles[candidate]) {
+      return candidate;
+    }
+  }
+  // Generate with hash if all candidates are taken
+  var hash = Math.random().toString(36).substring(2, 8);
+  return "".concat(pathPrefix, "entrypoint-").concat(hash, ".").concat(ext);
+}
+/**
+ * Generate the relative import path from entrypoint to source file
+ */
+export function getRelativeImportPath(sourceFilename) {
+  if (!sourceFilename) {
+    return './App'; // Default fallback
+  }
+  // Remove extension for import
+  var baseName = sourceFilename.replace(/\.[^.]*$/, '');
+  return "./".concat(baseName);
+}
+/**
+ * Default HTML template function for Vite-based demos
+ */
+export function defaultHtmlTemplate(_ref) {
+  var language = _ref.language,
+    title = _ref.title,
+    description = _ref.description,
+    head = _ref.head,
+    entrypoint = _ref.entrypoint;
+  return "<!doctype html>\n<html lang=\"".concat(language, "\">\n  <head>\n    <meta charset=\"UTF-8\" />\n    <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\" />\n    <title>").concat(title, "</title>\n    <meta name=\"description\" content=\"").concat(description, "\" />").concat(head ? "\n    ".concat(head) : '', "\n  </head>\n  <body>\n    <div id=\"root\"></div>").concat(entrypoint ? "\n    <script type=\"module\" src=\"".concat(entrypoint, "\"></script>") : '', "\n  </body>\n</html>");
+}
+/**
+ * Export a VariantCode with additional configuration files
+ * Returns an object with the exported VariantCode and rootPath path
+ */
+export function exportVariant(variantCode) {
+  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _config$title = config.title,
+    title = _config$title === void 0 ? 'Demo' : _config$title,
+    _config$description = config.description,
+    description = _config$description === void 0 ? 'Demo created with Vite' : _config$description,
+    _config$htmlPrefix = config.htmlPrefix,
+    htmlPrefix = _config$htmlPrefix === void 0 ? '' : _config$htmlPrefix,
+    _config$frameworkHand = config.frameworkHandlesEntrypoint,
+    frameworkHandlesEntrypoint = _config$frameworkHand === void 0 ? false : _config$frameworkHand,
+    htmlTemplate = config.htmlTemplate,
+    headTemplate = config.headTemplate,
+    rootIndexTemplate = config.rootIndexTemplate,
+    _config$dependencies = config.dependencies,
+    dependencies = _config$dependencies === void 0 ? {} : _config$dependencies,
+    _config$devDependenci = config.devDependencies,
+    devDependencies = _config$devDependenci === void 0 ? {} : _config$devDependenci,
+    _config$scripts = config.scripts,
+    scripts = _config$scripts === void 0 ? {} : _config$scripts,
+    packageType = config.packageType,
+    _config$packageJsonFi = config.packageJsonFields,
+    packageJsonFields = _config$packageJsonFi === void 0 ? {} : _config$packageJsonFi,
+    _config$tsconfigOptio = config.tsconfigOptions,
+    tsconfigOptions = _config$tsconfigOptio === void 0 ? {} : _config$tsconfigOptio,
+    _config$useTypescript = config.useTypescript,
+    useTypescript = _config$useTypescript === void 0 ? false : _config$useTypescript,
+    _config$extraMetadata = config.extraMetadataFiles,
+    extraMetadataFiles = _config$extraMetadata === void 0 ? {} : _config$extraMetadata,
+    _config$frameworkFile = config.frameworkFiles,
+    frameworkFiles = _config$frameworkFile === void 0 ? {} : _config$frameworkFile;
+  // If packageType is explicitly provided (even as undefined), use that value
+  var finalPackageType;
+  if ('packageType' in config) {
+    finalPackageType = packageType;
+  } else {
+    finalPackageType = !Object.keys(frameworkFiles).length ? 'module' : undefined;
+  }
+  // Get existing extraFiles and source filename
+  var existingExtraFiles = variantCode.extraFiles || {};
+  var sourceFilename = getFilenameFromVariant(variantCode);
+  // Get path context to calculate proper URLs
+  var pathContext = createPathContext(variantCode);
+  // Calculate the correct prefix for metadata files based on path depth
+  var metadataPrefix = '../'.repeat(pathContext.maxBackNavigation + 1);
+  // Generate unique entrypoint filename
+  var entrypointFilename = generateEntrypointFilename(existingExtraFiles, sourceFilename, useTypescript);
+  // Calculate the entrypoint URL relative to the root
+  var entrypoint = "/src/".concat(pathContext.pathInwardFromRoot).concat(entrypointFilename);
+  // Get relative import path for the main component
+  var rootFile = "src/".concat(pathContext.pathInwardFromRoot).concat(sourceFilename);
+  var importPath = getRelativeImportPath(sourceFilename);
+  var importString = variantCode.namedExport ? "import { ".concat(variantCode.namedExport, " as App } from '").concat(importPath, "';") : "import App from '".concat(importPath, "';");
+  // Create new extraFiles object
+  var newExtraFiles = _objectSpread({}, existingExtraFiles);
+  // Add framework-specific files (if any)
+  for (var _i2 = 0, _Object$entries = Object.entries(frameworkFiles); _i2 < _Object$entries.length; _i2++) {
+    var _fileData$metadata;
+    var _Object$entries$_i = _slicedToArray(_Object$entries[_i2], 2),
+      fileName = _Object$entries$_i[0],
+      fileData = _Object$entries$_i[1];
+    newExtraFiles[fileName] = {
+      source: fileData.source,
+      metadata: (_fileData$metadata = fileData.metadata) != null ? _fileData$metadata : true
+    };
+  }
+  // Check if we're using a framework (has framework files)
+  var isFramework = frameworkFiles && Object.keys(frameworkFiles).length > 0;
+  var externalPackages = externalsToPackages(variantCode.externals || []);
+  var variantDeps = Object.keys(externalPackages).reduce(function (acc, pkg) {
+    acc[pkg] = 'latest';
+    return acc;
+  }, {});
+  // Generate package.json (always)
+  var packageJson = _objectSpread(_objectSpread({
+    "private": true,
+    name: title.toLowerCase().replace(/[^a-z0-9]/g, '-'),
+    version: '0.0.0',
+    description: description
+  }, finalPackageType && {
+    type: finalPackageType
+  }), {}, {
+    // Add type if specified
+    scripts: _objectSpread(_objectSpread({}, !isFramework && {
+      dev: 'vite',
+      build: 'vite build',
+      preview: 'vite preview'
+    }), scripts),
+    dependencies: _objectSpread(_objectSpread({
+      react: 'latest',
+      'react-dom': 'latest'
+    }, variantDeps), dependencies),
+    devDependencies: _objectSpread(_objectSpread(_objectSpread({}, !isFramework && {
+      '@vitejs/plugin-react': 'latest',
+      vite: 'latest'
+    }), useTypescript && {
+      typescript: 'latest',
+      '@types/react': 'latest',
+      '@types/react-dom': 'latest'
+    }), devDependencies)
+  }, packageJsonFields);
+  newExtraFiles["".concat(metadataPrefix, "package.json")] = {
+    source: JSON.stringify(packageJson, null, 2),
+    metadata: true
+  };
+  // Generate entrypoint and HTML files unless framework handles them
+  if (!frameworkHandlesEntrypoint) {
+    // Add index.html (with configurable prefix for different frameworks)
+    var headContent = headTemplate ? headTemplate({
+      sourcePrefix: '/src',
+      assetPrefix: ''
+    }) : undefined;
+    var htmlContent = htmlTemplate ? htmlTemplate({
+      language: 'en',
+      title: title,
+      description: description,
+      head: headContent,
+      entrypoint: entrypoint
+    }) : defaultHtmlTemplate({
+      language: 'en',
+      title: title,
+      description: description,
+      head: headContent,
+      entrypoint: entrypoint
+    });
+    var htmlFilePath = htmlPrefix ? "".concat(metadataPrefix).concat(htmlPrefix, "index.html") : "".concat(metadataPrefix, "index.html");
+    newExtraFiles[htmlFilePath] = {
+      source: htmlContent,
+      metadata: true
+    };
+    // Create entrypoint file that imports the main component
+    var defaultEntrypointContent = "import * as React from 'react';\nimport * as ReactDOM from 'react-dom/client';\n".concat(importString, "\n\nReactDOM.createRoot(document.getElementById('root')").concat(useTypescript ? '!' : '', ").render(\n  <React.StrictMode>\n    <App />\n  </React.StrictMode>\n);");
+    var entrypointContent = rootIndexTemplate ? rootIndexTemplate({
+      importString: importString,
+      useTypescript: useTypescript
+    }) : defaultEntrypointContent;
+    newExtraFiles[entrypointFilename] = {
+      source: entrypointContent,
+      metadata: false
+    };
+  }
+  // Add Vite config file only if no framework files (Vite-specific)
+  if (!isFramework) {
+    var viteConfigContent = "import { defineConfig } from 'vite';\nimport react from '@vitejs/plugin-react';\nimport { externalsToPackages } from '../loaderUtils/externalsToPackages';\n\n// https://vitejs.dev/config/\nexport default defineConfig({\n  plugins: [react()],\n  define: { 'process.env': {} },\n});";
+    newExtraFiles["".concat(metadataPrefix, "vite.config.").concat(useTypescript ? 'ts' : 'js')] = {
+      source: viteConfigContent,
+      metadata: true
+    };
+  }
+  // Add TypeScript configuration if requested (up one directory, metadata: true)
+  if (useTypescript) {
+    // Check if frameworkFiles already includes a tsconfig
+    var hasFrameworkTsConfig = frameworkFiles && Object.keys(frameworkFiles).some(function (fileName) {
+      return fileName.includes('tsconfig.json') && !fileName.includes('tsconfig.node.json');
+    });
+    if (!hasFrameworkTsConfig) {
+      // Main tsconfig.json (default Vite config)
+      var defaultTsConfig = _objectSpread({
+        compilerOptions: _objectSpread({
+          target: 'ES2020',
+          useDefineForClassFields: true,
+          lib: ['ES2020', 'DOM', 'DOM.Iterable'],
+          module: 'ESNext',
+          skipLibCheck: true,
+          moduleResolution: 'bundler',
+          allowImportingTsExtensions: true,
+          resolveJsonModule: true,
+          isolatedModules: true,
+          noEmit: true,
+          jsx: 'react-jsx',
+          strict: true,
+          noUnusedLocals: true,
+          noUnusedParameters: true,
+          noFallthroughCasesInSwitch: true
+        }, tsconfigOptions),
+        include: ['src']
+      }, !isFramework && {
+        references: [{
+          path: './tsconfig.node.json'
+        }]
+      });
+      newExtraFiles["".concat(metadataPrefix, "tsconfig.json")] = {
+        source: JSON.stringify(defaultTsConfig, null, 2),
+        metadata: true
+      };
+    }
+    // Only add tsconfig.node.json for Vite (not for framework files)
+    if (!isFramework) {
+      // Node tsconfig for Vite config
+      var nodeTsConfig = {
+        compilerOptions: {
+          composite: true,
+          skipLibCheck: true,
+          module: 'ESNext',
+          moduleResolution: 'bundler',
+          allowSyntheticDefaultImports: true
+        },
+        include: ['vite.config.ts']
+      };
+      newExtraFiles["".concat(metadataPrefix, "tsconfig.node.json")] = {
+        source: JSON.stringify(nodeTsConfig, null, 2),
+        metadata: true
+      };
+    }
+  }
+  // Add custom metadata files (respect metadata flag)
+  for (var _i3 = 0, _Object$entries2 = Object.entries(extraMetadataFiles); _i3 < _Object$entries2.length; _i3++) {
+    var _fileData$metadata2;
+    var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i3], 2),
+      _fileName = _Object$entries2$_i[0],
+      _fileData = _Object$entries2$_i[1];
+    newExtraFiles["".concat(metadataPrefix).concat(_fileName)] = {
+      source: _fileData.source,
+      metadata: (_fileData$metadata2 = _fileData.metadata) != null ? _fileData$metadata2 : true
+    };
+  }
+  // Return new VariantCode with updated extraFiles
+  return {
+    exported: _objectSpread(_objectSpread({}, variantCode), {}, {
+      extraFiles: newExtraFiles
+    }),
+    rootFile: rootFile
+  };
+}

package/useDemo/exportVariantAsCra.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+/**
+ * Export VariantCode as Create React App template using exportVariant
+ * This is a general-purpose wrapper that creates CRA-compatible templates
+ * without library-specific dependencies
+ */
+import type { VariantCode } from "../CodeHighlighter/types.js";
+import { type ExportConfig } from "./exportVariant.js";
+/**
+ * Export a VariantCode as a Create React App template
+ * Returns an object with the exported VariantCode and entrypoint path
+ */
+export declare function exportVariantAsCra(variantCode: VariantCode, config?: ExportConfig): {
+  exported: VariantCode;
+  rootFile: string;
+};

package/useDemo/exportVariantAsCra.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"exportVariantAsCra.d.ts","sourceRoot":"","sources":["../../src/useDemo/exportVariantAsCra.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAiB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEnE;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,WAAW,EAAE,WAAW,EACxB,MAAM,GAAE,YAAiB,GACxB;IAAE,QAAQ,EAAE,WAAW,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAsC7C"}

package/useDemo/exportVariantAsCra.js ADDED Viewed

@@ -0,0 +1,56 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _objectWithoutProperties from "@babel/runtime/helpers/esm/objectWithoutProperties";
+var _excluded = ["title", "description", "scripts", "devDependencies"];
+/**
+ * Export VariantCode as Create React App template using exportVariant
+ * This is a general-purpose wrapper that creates CRA-compatible templates
+ * without library-specific dependencies
+ */
+import { exportVariant } from "./exportVariant.js";
+/**
+ * Export a VariantCode as a Create React App template
+ * Returns an object with the exported VariantCode and entrypoint path
+ */
+export function exportVariantAsCra(variantCode) {
+  var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _config$title = config.title,
+    title = _config$title === void 0 ? 'Demo' : _config$title,
+    _config$description = config.description,
+    description = _config$description === void 0 ? 'Demo created with Create React App' : _config$description,
+    _config$scripts = config.scripts,
+    scripts = _config$scripts === void 0 ? {} : _config$scripts,
+    _config$devDependenci = config.devDependencies,
+    devDependencies = _config$devDependenci === void 0 ? {} : _config$devDependenci,
+    otherConfig = _objectWithoutProperties(config, _excluded);
+  // Default CRA scripts
+  var craScripts = _objectSpread({
+    start: 'react-scripts start',
+    build: 'react-scripts build',
+    test: 'react-scripts test',
+    eject: 'react-scripts eject'
+  }, scripts);
+  // CRA only needs react-scripts, other deps are handled by exportVariant
+  var craDevDependencies = _objectSpread({
+    'react-scripts': 'latest'
+  }, devDependencies);
+  // Create export configuration for CRA
+  var exportConfig = _objectSpread({
+    title: title,
+    description: description,
+    htmlPrefix: 'public/',
+    packageType: undefined,
+    // CRA should not have 'type: module'
+    frameworkFiles: {},
+    // Prevent Vite-specific files from being generated
+    devDependencies: craDevDependencies,
+    scripts: craScripts
+  }, otherConfig);
+  // Use exportVariant to generate the final result
+  return exportVariant(variantCode, exportConfig);
+}

package/useDemo/flattenVariant.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+/**
+ * Flatten variant utility to convert a VariantCode into a flat files list
+ * Handles relative path resolution and metadata file scoping
+ */
+import type { VariantCode } from "../CodeHighlighter/types.js";
+export interface FlatFile {
+  source: string;
+  metadata?: boolean;
+}
+export interface FlattenedFiles {
+  [filePath: string]: FlatFile;
+}
+/**
+ * Flatten a VariantCode into a flat files structure
+ * Resolves relative paths and handles metadata file scoping
+ */
+export declare function flattenVariant(variant: VariantCode): FlattenedFiles;

package/useDemo/flattenVariant.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"flattenVariant.d.ts","sourceRoot":"","sources":["../../src/useDemo/flattenVariant.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAiB,MAAM,0BAA0B,CAAC;AAK3E,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC;CAC9B;AAiLD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,CA+BnE"}

package/useDemo/flattenVariant.js ADDED Viewed

@@ -0,0 +1,206 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+/**
+ * Flatten variant utility to convert a VariantCode into a flat files list
+ * Handles relative path resolution and metadata file scoping
+ */
+import { stringOrHastToString } from "../pipeline/hastUtils/index.js";
+import { getFileNameFromUrl } from "../pipeline/loaderUtils/getFileNameFromUrl.js";
+import { createPathContext } from "./examineVariant.js";
+/**
+ * Resolve a relative path from a base URL to get the target directory structure
+ */
+function resolveRelativePath(baseUrl, relativePath) {
+  var url = new URL(baseUrl);
+  var pathSegments = url.pathname.split('/').filter(Boolean);
+  pathSegments.pop(); // Remove filename to get directory
+  var relativeSegments = relativePath.split('/');
+  var _iterator = _createForOfIteratorHelper(relativeSegments),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var segment = _step.value;
+      if (segment === '..') {
+        pathSegments.pop();
+      } else if (segment !== '.' && segment !== '') {
+        pathSegments.push(segment);
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return pathSegments.join('/');
+}
+/**
+ * Process the main file and determine its final path
+ */
+function processMainFile(variant, context) {
+  var effectiveFileName = variant.fileName;
+  // If fileName is missing but we have a URL, derive it from the URL
+  if (!effectiveFileName && context.hasUrl) {
+    var _getFileNameFromUrl = getFileNameFromUrl(context.actualUrl),
+      fileName = _getFileNameFromUrl.fileName;
+    effectiveFileName = fileName;
+  }
+  if (!effectiveFileName || variant.source === undefined) {
+    return null;
+  }
+  var mainFilePath;
+  if (context.hasUrl && context.maxBackNavigation > 0) {
+    // URL with back navigation - calculate relative path from root level
+    // TypeScript knows context.actualUrl is defined when context.hasUrl is true
+    var urlObj = new URL(context.actualUrl);
+    var fullPath = urlObj.pathname.substring(1); // Remove leading slash
+    var relativePath = context.rootLevel ? fullPath.substring(context.rootLevel.length) : fullPath;
+    mainFilePath = relativePath.replace(/\/[^/]+$/, "/".concat(effectiveFileName));
+  } else if (context.hasUrl && variant.extraFiles && Object.keys(variant.extraFiles).length > 0) {
+    // URL with extra files but no back navigation
+    if (context.hasMetadata) {
+      // For metadata cases, preserve the full directory structure
+      mainFilePath = context.urlDirectory.length > 0 ? "".concat(context.urlDirectory.join('/'), "/").concat(effectiveFileName) : effectiveFileName;
+    } else {
+      // Check if all extra files are current directory references
+      var allCurrentDir = Object.keys(variant.extraFiles).every(function (path) {
+        return path.startsWith('./') || !path.startsWith('../') && !path.startsWith('.');
+      });
+      if (allCurrentDir) {
+        // For current directory references without metadata, flatten to root
+        mainFilePath = effectiveFileName;
+      } else {
+        // Use just the immediate parent directory
+        var lastSegment = context.urlDirectory[context.urlDirectory.length - 1];
+        mainFilePath = lastSegment ? "".concat(lastSegment, "/").concat(effectiveFileName) : effectiveFileName;
+      }
+    }
+  } else {
+    // Simple case - just use the filename
+    mainFilePath = effectiveFileName;
+  }
+  // Add src/ prefix if we have metadata
+  if (context.hasMetadata) {
+    // When there are metadata files, simplify the main file path
+    if (context.hasUrl && !context.maxBackNavigation) {
+      // No back navigation - just use the filename
+      mainFilePath = effectiveFileName;
+    }
+    mainFilePath = "src/".concat(mainFilePath);
+  }
+  return {
+    path: mainFilePath,
+    hasDirectory: mainFilePath.includes('/')
+  };
+}
+/**
+ * Process metadata files to determine their final paths
+ */
+function processMetadataFile(relativePath) {
+  // Extract everything after the back navigation, preserving directory structure
+  return relativePath.replace(/^(\.\.\/)+/, '');
+}
+/**
+ * Process extra file paths to determine their final paths
+ */
+function processExtraFilePath(relativePath, context, mainFile) {
+  if (relativePath.startsWith('./')) {
+    // Current directory reference - just remove the ./
+    return relativePath.substring(2);
+  }
+  if (relativePath.startsWith('../')) {
+    // Back navigation - resolve relative to URL or create synthetic paths
+    if (context.hasUrl) {
+      // TypeScript knows context.actualUrl is defined when context.hasUrl is true
+      var resolved = resolveRelativePath(context.actualUrl, relativePath);
+      if (context.rootLevel) {
+        var rootLevelClean = context.rootLevel.replace(/\/$/, '');
+        if (resolved.startsWith("".concat(rootLevelClean, "/"))) {
+          return resolved.substring(rootLevelClean.length + 1);
+        }
+        if (resolved === rootLevelClean) {
+          return relativePath.split('/').pop() || relativePath;
+        }
+        return resolved;
+      }
+      return resolved;
+    }
+    // Fallback: if somehow we don't have a URL (shouldn't happen anymore with synthetic URLs)
+    return relativePath.split('/').pop() || relativePath;
+  }
+  // Regular relative path (like 'dir/utils.ts')
+  if (context.hasUrl && !context.hasMetadata && mainFile != null && mainFile.hasDirectory) {
+    // Place relative to main file's directory if it has one
+    var lastSegment = context.urlDirectory[context.urlDirectory.length - 1];
+    return lastSegment ? "".concat(lastSegment, "/").concat(relativePath) : relativePath;
+  }
+  return relativePath;
+}
+/**
+ * Process an extra file to determine its final path
+ */
+function processExtraFile(relativePath, file, context, mainFile) {
+  var finalPath;
+  if (file.metadata) {
+    finalPath = processMetadataFile(relativePath);
+  } else {
+    finalPath = processExtraFilePath(relativePath, context, mainFile);
+    // Add src/ prefix if we have metadata (all paths are relative to main file)
+    if (context.hasMetadata) {
+      finalPath = "src/".concat(finalPath);
+    }
+  }
+  return finalPath;
+}
+/**
+ * Flatten a VariantCode into a flat files structure
+ * Resolves relative paths and handles metadata file scoping
+ */
+export function flattenVariant(variant) {
+  var result = {};
+  var context = createPathContext(variant);
+  // Process main file
+  var mainFile = processMainFile(variant, context);
+  if (mainFile && variant.source !== undefined) {
+    result[mainFile.path] = {
+      source: stringOrHastToString(variant.source)
+    };
+  }
+  // Process extra files
+  if (variant.extraFiles) {
+    for (var _i = 0, _Object$entries = Object.entries(variant.extraFiles); _i < _Object$entries.length; _i++) {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        relativePath = _Object$entries$_i[0],
+        fileContent = _Object$entries$_i[1];
+      var file = typeof fileContent === 'string' ? {
+        source: fileContent
+      } : fileContent;
+      // Skip files with no source content
+      if (!file.source && file.source !== '') {
+        continue;
+      }
+      var finalPath = processExtraFile(relativePath, file, context, mainFile);
+      result[finalPath] = _objectSpread({
+        source: stringOrHastToString(file.source || '')
+      }, file.metadata && {
+        metadata: file.metadata
+      });
+    }
+  }
+  return result;
+}

package/useDemo/index.d.ts CHANGED Viewed

@@ -1,39 +1,6 @@
-import * as React from 'react';
-import { UseCopierOpts } from "../useCopier/index.js";
-import { ContentProps } from "../CodeHighlighter/types.js";
-type UseDemoOpts = {
-  defaultOpen?: boolean;
-  copy?: UseCopierOpts;
-  githubUrlPrefix?: string;
-  codeSandboxUrlPrefix?: string;
-  stackBlitzPrefix?: string;
-  initialVariant?: string;
-  initialTransform?: string;
-};
-export declare function useDemo(contentProps: ContentProps, opts?: UseDemoOpts): {
-  name: string | undefined;
-  slug: string | undefined;
-  description: string | undefined;
-  component: React.ReactNode;
-  ref: React.RefObject<HTMLDivElement | null>;
-  variants: string[];
-  selectedVariant: string;
-  selectVariant: React.Dispatch<React.SetStateAction<string>>;
-  files: Array<{
-    name: string;
-    component: React.ReactNode;
-  }>;
-  selectedFile: React.ReactNode;
-  selectedFileName: string;
-  selectFileName: React.Dispatch<React.SetStateAction<string>>;
-  expanded: boolean;
-  expand: () => void;
-  setExpanded: React.Dispatch<React.SetStateAction<boolean>>;
-  resetFocus: () => void;
-  copy: (event: React.MouseEvent<HTMLButtonElement>) => Promise<void>;
-  copyDisabled: boolean;
-  availableTransforms: string[];
-  selectedTransform: string | null | undefined;
-  selectTransform: (transformName: string | null) => void;
-};
-export {};
+export * from "./useDemo.js";
+export * from "./createStackBlitz.js";
+export * from "./createCodeSandbox.js";
+export * from "./flattenVariant.js";
+export * from "./exportVariant.js";
+export * from "./exportVariantAsCra.js";

package/useDemo/index.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["~~../../../~~src/useDemo/index.ts"],"names":[],"mappings":"AAAA,~~OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAI/B,OAAO,EAAE,aAAa,EAAE,MAAM,~~cAAc,~~CAAC;AAC7C,OAAO,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAExD,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;AAGF~~,~~wBAAgB~~,~~OAAO,~~CAAC~~,YAAY,EAAE,YAAY,EAAE,IAAI,CAAC,EAAE,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;EAgBrE~~"}
1	+ {"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/useDemo/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,oBAAoB,CAAC;AACnC,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC"}