@mui/internal-docs-infra 0.2.3-canary.9 → 0.3.1-canary.1

package/esm/useSearch/useSearch.js

@@ -0,0 +1,647 @@
+'use client';
+
+import _regenerator from "@babel/runtime/helpers/esm/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _extends from "@babel/runtime/helpers/esm/extends";
+import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
+import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
+import * as React from 'react';
+import { create, insertMultiple, search as oramaSearch } from '@orama/orama';
+import { pluginQPS } from '@orama/plugin-qps';
+import { stemmer, language } from '@orama/stemmers/english';
+import { stopwords as englishStopwords } from '@orama/stopwords/english';
+// https://github.com/oramasearch/orama/blob/main/packages/stopwords/lib/en.js
+// Removed words that might be meaningful in a software documentation context
+var stopWords = englishStopwords.filter(function (word) {
+  return word !== 'about' && word !== 'but' &&
+  // start of button
+  word !== 'for' &&
+  // part of form
+  word !== 'between' && word !== 'before' && word !== 'after' && word !== 'above' && word !== 'below' && word !== 'once' && word !== 'then' && word !== 'where' && word !== 'to' && word !== 'from' && word !== 'up' && word !== 'down' && word !== 'in' && word !== 'out' && word !== 'on' && word !== 'off' && word !== 'over' && word !== 'under';
+});
+
+/**
+ * Type for our search document structure
+ */
+
+/**
+ * Orama schema definition for our search document
+ */
+var searchSchema = {
+  type: 'string',
+  group: 'string',
+  title: 'string',
+  description: 'string',
+  slug: 'string',
+  sectionTitle: 'string',
+  prefix: 'string',
+  path: 'string',
+  keywords: 'string',
+  page: 'string',
+  pageKeywords: 'string',
+  sections: 'string',
+  subsections: 'string',
+  part: 'string',
+  "export": 'string',
+  props: 'string',
+  dataAttributes: 'string',
+  cssVariables: 'string',
+  section: 'string',
+  subsection: 'string'
+};
+
+/**
+ * Type for Orama search hit results
+ */
+
+/**
+ * Default function to flatten a sitemap page into search results
+ */
+function defaultFlattenPage(page, sectionData, includeCategoryInGroup, excludeSections, generateSlug) {
+  var _page$keywords;
+  var results = [];
+
+  // Extract top-level sections and all subsections with their slugs
+  // Re-slugify from titles using the provided slugify function to match actual page IDs
+  var sections = [];
+  var subsections = [];
+  if (page.sections) {
+    var _loop = function _loop() {
+      var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
+        originalSlug = _Object$entries$_i[0],
+        sectionInfo = _Object$entries$_i[1];
+      // Use generateSlug if provided, otherwise use the original slug from sitemap
+      var slug = generateSlug ? generateSlug(sectionInfo.title, []) : originalSlug;
+      sections.push({
+        title: sectionInfo.title,
+        slug: slug
+      });
+
+      // Subsections are all nested children (recursively)
+      if (sectionInfo.children && Object.keys(sectionInfo.children).length > 0) {
+        var _extractWithSlugs = function extractWithSlugs(hierarchy, parentSlugs, parentTitles) {
+          var items = [];
+          for (var _i2 = 0, _Object$entries2 = Object.entries(hierarchy); _i2 < _Object$entries2.length; _i2++) {
+            var _Object$entries2$_i = _slicedToArray(_Object$entries2[_i2], 2),
+              childOriginalSlug = _Object$entries2$_i[0],
+              childData = _Object$entries2$_i[1];
+            // Use generateSlug if provided, otherwise use the original slug from sitemap
+            // When generateSlug is provided, pass parent titles for context
+            // (e.g., for Releases pages: v1.0.0-rc.0-autocomplete)
+            var childSlug = generateSlug ? generateSlug(childData.title, parentTitles) : childOriginalSlug;
+            var currentSlugs = [].concat(_toConsumableArray(parentSlugs), [childSlug]);
+            var currentTitles = [].concat(_toConsumableArray(parentTitles), [childData.title]);
+            items.push({
+              title: childData.title,
+              slug: childSlug,
+              parentSlugs: currentSlugs,
+              parentTitles: currentTitles
+            });
+            if (childData.children && Object.keys(childData.children).length > 0) {
+              items.push.apply(items, _toConsumableArray(_extractWithSlugs(childData.children, currentSlugs, currentTitles)));
+            }
+          }
+          return items;
+        };
+        subsections.push.apply(subsections, _toConsumableArray(_extractWithSlugs(sectionInfo.children, [slug], [sectionInfo.title])));
+      }
+    };
+    // Top-level sections are the direct children
+    for (var _i = 0, _Object$entries = Object.entries(page.sections); _i < _Object$entries.length; _i++) {
+      _loop();
+    }
+  }
+  var flattened = {};
+  if ((_page$keywords = page.keywords) != null && _page$keywords.length) {
+    flattened.keywords = page.keywords.join(' ');
+  }
+  if (sections.length > 0) {
+    flattened.sections = sections.map(function (s) {
+      return s.title;
+    }).join(' ');
+  }
+  if (subsections.length > 0) {
+    flattened.subsections = subsections.map(function (s) {
+      return s.title;
+    }).join(' ');
+  }
+
+  // Add base page result
+  results.push(_extends(_extends({
+    type: 'page',
+    group: includeCategoryInGroup ? "".concat(sectionData.title, " Pages") : 'Pages',
+    page: page.title,
+    title: page.title,
+    slug: page.slug,
+    path: page.path,
+    description: page.description,
+    sectionTitle: sectionData.title,
+    prefix: sectionData.prefix
+  }, flattened.keywords ? {
+    keywords: flattened.keywords
+  } : {}), excludeSections ? {} : {
+    sections: flattened.sections,
+    subsections: flattened.subsections
+  }));
+
+  // Add entries for each part
+  if (page.parts && Object.keys(page.parts).length > 0) {
+    for (var _i3 = 0, _Object$entries3 = Object.entries(page.parts); _i3 < _Object$entries3.length; _i3++) {
+      var _Object$entries3$_i = _slicedToArray(_Object$entries3[_i3], 2),
+        partName = _Object$entries3$_i[0],
+        partData = _Object$entries3$_i[1];
+      results.push({
+        type: 'part',
+        group: 'API Reference',
+        part: partName,
+        "export": "".concat(page.slug, ".").concat(partName),
+        slug: partName.toLowerCase(),
+        path: page.path,
+        title: page.title ? "".concat(page.title, " \u2023 ").concat(partName) : partName,
+        description: page.description,
+        sectionTitle: sectionData.title,
+        prefix: sectionData.prefix,
+        props: partData.props ? partData.props.join(' ') : '',
+        dataAttributes: partData.dataAttributes ? partData.dataAttributes.join(' ') : '',
+        cssVariables: partData.cssVariables ? partData.cssVariables.join(' ') : '',
+        keywords: flattened.keywords
+      });
+    }
+  }
+
+  // Add entries for each export
+  if (page.exports && Object.keys(page.exports).length > 0) {
+    for (var _i4 = 0, _Object$entries4 = Object.entries(page.exports); _i4 < _Object$entries4.length; _i4++) {
+      var _Object$entries4$_i = _slicedToArray(_Object$entries4[_i4], 2),
+        exportName = _Object$entries4$_i[0],
+        exportData = _Object$entries4$_i[1];
+      // If export name matches page slug (case-insensitive), use #api-reference
+      var exportSlug = exportName.toLowerCase() === page.slug.toLowerCase() ? 'api-reference' : exportName.toLowerCase();
+      results.push({
+        type: 'export',
+        group: 'API Reference',
+        "export": exportSlug,
+        slug: page.slug,
+        path: page.path,
+        title: exportName,
+        description: page.description,
+        sectionTitle: sectionData.title,
+        prefix: sectionData.prefix,
+        props: exportData.props ? exportData.props.join(' ') : '',
+        dataAttributes: exportData.dataAttributes ? exportData.dataAttributes.join(' ') : '',
+        cssVariables: exportData.cssVariables ? exportData.cssVariables.join(' ') : '',
+        keywords: flattened.keywords
+      });
+    }
+  }
+
+  // Add entries for each section
+  for (var _i5 = 0, _sections = sections; _i5 < _sections.length; _i5++) {
+    var sectionItem = _sections[_i5];
+    results.push({
+      type: 'section',
+      group: 'Sections',
+      section: sectionItem.title,
+      slug: "".concat(page.slug, "#").concat(sectionItem.slug),
+      path: page.path,
+      title: page.title ? "".concat(page.title, " \u2023 ").concat(sectionItem.title) : sectionItem.title,
+      description: page.description,
+      sectionTitle: sectionData.title,
+      prefix: sectionData.prefix,
+      keywords: flattened.keywords
+    });
+  }
+
+  // Add entries for each subsection
+  for (var _i6 = 0, _subsections = subsections; _i6 < _subsections.length; _i6++) {
+    var subsectionItem = _subsections[_i6];
+    var fullTitle = subsectionItem.parentTitles.join(' ‣ ');
+    results.push({
+      type: 'subsection',
+      group: 'Sections',
+      subsection: fullTitle,
+      slug: "".concat(page.slug, "#").concat(subsectionItem.slug.toLowerCase()),
+      path: page.path,
+      title: page.title ? "".concat(page.title, " \u2023 ").concat(fullTitle) : fullTitle,
+      description: page.description,
+      sectionTitle: sectionData.title,
+      prefix: sectionData.prefix,
+      keywords: flattened.keywords
+    });
+  }
+  return results;
+}
+
+/**
+ * Default function to format search results
+ */
+function defaultFormatResult(hit) {
+  var base = {
+    id: hit.id,
+    title: hit.document.title,
+    description: hit.document.description,
+    slug: hit.document.slug,
+    sectionTitle: hit.document.sectionTitle,
+    prefix: hit.document.prefix,
+    path: hit.document.path,
+    score: hit.score,
+    keywords: hit.document.keywords
+  };
+  var type = hit.document.type;
+  if (type === 'part') {
+    return _extends(_extends({}, base), {}, {
+      type: 'part',
+      part: hit.document.part,
+      "export": hit.document["export"],
+      props: hit.document.props,
+      dataAttributes: hit.document.dataAttributes,
+      cssVariables: hit.document.cssVariables
+    });
+  }
+  if (type === 'export') {
+    return _extends(_extends({}, base), {}, {
+      type: 'export',
+      "export": hit.document["export"],
+      props: hit.document.props,
+      dataAttributes: hit.document.dataAttributes,
+      cssVariables: hit.document.cssVariables
+    });
+  }
+  if (type === 'section') {
+    return _extends(_extends({}, base), {}, {
+      type: 'section',
+      section: hit.document.section
+    });
+  }
+  if (type === 'subsection') {
+    return _extends(_extends({}, base), {}, {
+      type: 'subsection',
+      subsection: hit.document.subsection
+    });
+  }
+
+  // Default to page type
+  return _extends(_extends(_extends({}, base), {}, {
+    type: 'page',
+    page: hit.document.title
+  }, hit.document.sections ? {
+    sections: hit.document.sections
+  } : {}), hit.document.subsections ? {
+    subsections: hit.document.subsections
+  } : {});
+}
+export var defaultSearchBoost = {
+  type: 100,
+  group: 100,
+  slug: 2,
+  path: 2,
+  title: 2,
+  page: 10,
+  pageKeywords: 15,
+  description: 1.5,
+  part: 1.5,
+  "export": 1.3,
+  sectionTitle: 50,
+  section: 3,
+  subsection: 2.5,
+  props: 1.5,
+  dataAttributes: 1.5,
+  cssVariables: 1.5,
+  sections: 0.7,
+  subsections: 0.3,
+  keywords: 1.5
+};
+
+/**
+ * Hook for managing search functionality with Orama
+ *
+ * @param options Configuration options for search behavior
+ * @returns Search state and functions
+ */
+export function useSearch(options) {
+  var sitemapImport = options.sitemap,
+    maxDefaultResults = options.maxDefaultResults,
+    _options$tolerance = options.tolerance,
+    tolerance = _options$tolerance === void 0 ? 1 : _options$tolerance,
+    _options$limit = options.limit,
+    defaultLimit = _options$limit === void 0 ? 20 : _options$limit,
+    _options$boost = options.boost,
+    boost = _options$boost === void 0 ? defaultSearchBoost : _options$boost,
+    _options$enableStemmi = options.enableStemming,
+    enableStemming = _options$enableStemmi === void 0 ? true : _options$enableStemmi,
+    generateSlug = options.generateSlug,
+    _options$flattenPage = options.flattenPage,
+    flattenPage = _options$flattenPage === void 0 ? defaultFlattenPage : _options$flattenPage,
+    _options$formatResult = options.formatResult,
+    formatResult = _options$formatResult === void 0 ? defaultFormatResult : _options$formatResult;
+  var _React$useState = React.useState(null),
+    _React$useState2 = _slicedToArray(_React$useState, 2),
+    index = _React$useState2[0],
+    setIndex = _React$useState2[1];
+  var _React$useState3 = React.useState({
+      results: [],
+      count: 0,
+      elapsed: {
+        raw: 0,
+        formatted: '0ms'
+      }
+    }),
+    _React$useState4 = _slicedToArray(_React$useState3, 2),
+    defaultResults = _React$useState4[0],
+    setDefaultResults = _React$useState4[1];
+  var _React$useState5 = React.useState({
+      results: [],
+      count: 0,
+      elapsed: {
+        raw: 0,
+        formatted: '0ms'
+      }
+    }),
+    _React$useState6 = _slicedToArray(_React$useState5, 2),
+    results = _React$useState6[0],
+    setResults = _React$useState6[1];
+  React.useEffect(function () {
+    _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee() {
+      var _yield$sitemapImport, sitemap, searchIndex, pages, pageResultsByGroup, pageResultsCount, dummyDoc, pageResultsGrouped, defaultResultsValue;
+      return _regenerator().w(function (_context) {
+        while (1) switch (_context.n) {
+          case 0:
+            _context.n = 1;
+            return sitemapImport();
+          case 1:
+            _yield$sitemapImport = _context.v;
+            sitemap = _yield$sitemapImport.sitemap;
+            if (sitemap) {
+              _context.n = 2;
+              break;
+            }
+            console.error('Sitemap is undefined');
+            return _context.a(2);
+          case 2:
+            _context.n = 3;
+            return create({
+              schema: searchSchema,
+              components: enableStemming ? {
+                tokenizer: {
+                  stemming: true,
+                  language: language,
+                  stemmer: stemmer,
+                  stemmerSkipProperties: ['type', 'group', 'slug', 'sectionTitle', 'page', 'part', 'export', 'dataAttributes', 'cssVariables', 'props'],
+                  stopWords: stopWords
+                }
+              } : undefined,
+              plugins: [pluginQPS()]
+            });
+          case 3:
+            searchIndex = _context.v;
+            // Flatten the sitemap data structure to a single array of pages
+            pages = [];
+            pageResultsByGroup = {};
+            pageResultsCount = 0;
+            Object.entries(sitemap.data).forEach(function (_ref2) {
+              var _ref3 = _slicedToArray(_ref2, 2),
+                _sectionKey = _ref3[0],
+                sectionData = _ref3[1];
+              (sectionData.pages || []).forEach(function (page) {
+                var flattened = flattenPage(page, sectionData, options.includeCategoryInGroup || false, options.excludeSections, generateSlug);
+                pages.push.apply(pages, _toConsumableArray(flattened));
+
+                // Add the first result (page type) to default results, grouped by their group
+                if ((maxDefaultResults === undefined || pageResultsCount < maxDefaultResults) && flattened.length > 0) {
+                  var pageResult = flattened[0];
+                  var group = pageResult.group || 'Pages';
+                  if (!pageResultsByGroup[group]) {
+                    pageResultsByGroup[group] = [];
+                  }
+                  pageResultsByGroup[group].push(pageResult);
+                  pageResultsCount += 1;
+                }
+              });
+            });
+
+            // Insert a dummy document with all fields to ensure QPS plugin initializes stats for all properties.
+            // This is needed because QPS only creates stats for properties that have data inserted.
+            // Using empty strings ensures no false matches while still initializing the stats.
+            dummyDoc = {
+              type: '',
+              group: '',
+              title: '',
+              description: '',
+              slug: '',
+              sectionTitle: '',
+              prefix: '',
+              path: '',
+              keywords: '',
+              page: '',
+              pageKeywords: '',
+              sections: '',
+              subsections: '',
+              part: '',
+              "export": '',
+              props: '',
+              dataAttributes: '',
+              cssVariables: '',
+              section: '',
+              subsection: ''
+            };
+            _context.n = 4;
+            return insertMultiple(searchIndex, [dummyDoc].concat(pages));
+          case 4:
+            pageResultsGrouped = Object.entries(pageResultsByGroup).map(function (_ref4) {
+              var _ref5 = _slicedToArray(_ref4, 2),
+                group = _ref5[0],
+                items = _ref5[1];
+              return {
+                group: group,
+                items: items
+              };
+            });
+            defaultResultsValue = {
+              results: pageResultsGrouped,
+              count: pageResultsCount,
+              elapsed: {
+                raw: 0,
+                formatted: '0ms'
+              }
+            };
+            setIndex(searchIndex);
+            setDefaultResults(defaultResultsValue);
+            setResults(defaultResultsValue);
+          case 5:
+            return _context.a(2);
+        }
+      }, _callee);
+    }))();
+  }, [sitemapImport, maxDefaultResults, flattenPage, generateSlug, enableStemming, options.includeCategoryInGroup, options.excludeSections]);
+  var search = React.useCallback(/*#__PURE__*/function () {
+    var _ref6 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(value) {
+      var _ref7,
+        facets,
+        groupBy,
+        _ref7$limit,
+        limit,
+        where,
+        valueLower,
+        valueNormalized,
+        useCustomSort,
+        cache,
+        getDocProps,
+        searchResults,
+        count,
+        elapsed,
+        groupedResults,
+        formattedResults,
+        _args2 = arguments;
+      return _regenerator().w(function (_context2) {
+        while (1) switch (_context2.n) {
+          case 0:
+            _ref7 = _args2.length > 1 && _args2[1] !== undefined ? _args2[1] : {}, facets = _ref7.facets, groupBy = _ref7.groupBy, _ref7$limit = _ref7.limit, limit = _ref7$limit === void 0 ? defaultLimit : _ref7$limit, where = _ref7.where;
+            if (!(!index || !value.trim())) {
+              _context2.n = 1;
+              break;
+            }
+            setResults(defaultResults);
+            return _context2.a(2);
+          case 1:
+            valueLower = value.toLowerCase(); // Normalize for comparison: convert spaces/hyphens to a common format
+            valueNormalized = valueLower.replace(/[-\s]+/g, ' ').trim(); // For longer search terms, skip custom sorting and rely on Orama's scoring
+            // The overhead of checking exact/startsWith/contains isn't worth it
+            useCustomSort = valueLower.length <= 20; // Cache for computed document properties to avoid repeated string operations
+            cache = new Map();
+            getDocProps = function getDocProps(doc) {
+              var key = doc.slug; // Use slug as cache key since it's unique per document
+              var props = cache.get(key);
+              if (!props) {
+                var titleLower = doc.title.toLowerCase();
+                var slugLower = doc.slug.toLowerCase();
+                props = {
+                  titleLower: titleLower,
+                  slugLower: slugLower,
+                  slugNormalized: slugLower.replace(/-/g, ' ')
+                };
+                cache.set(key, props);
+              }
+              return props;
+            };
+            _context2.n = 2;
+            return oramaSearch(index, {
+              term: value,
+              facets: facets,
+              groupBy: groupBy,
+              where: where,
+              limit: limit,
+              tolerance: tolerance,
+              boost: boost,
+              sortBy: useCustomSort ? function (_ref8, _ref9) {
+                var _ref0 = _slicedToArray(_ref8, 3),
+                  _ = _ref0[0],
+                  aScore = _ref0[1],
+                  aDocument = _ref0[2];
+                var _ref1 = _slicedToArray(_ref9, 3),
+                  __ = _ref1[0],
+                  bScore = _ref1[1],
+                  bDocument = _ref1[2];
+                var a = getDocProps(aDocument);
+                var b = getDocProps(bDocument);
+
+                // Prioritize exact matches (short-circuit on first match)
+                var aExact = a.titleLower === valueLower || a.slugLower === valueLower || a.slugNormalized === valueNormalized;
+                var bExact = b.titleLower === valueLower || b.slugLower === valueLower || b.slugNormalized === valueNormalized;
+                if (aExact !== bExact) {
+                  return aExact ? -1 : 1;
+                }
+
+                // Then prioritize startsWith matches
+                var aStartsWith = a.titleLower.startsWith(valueLower) || a.slugNormalized.startsWith(valueNormalized);
+                var bStartsWith = b.titleLower.startsWith(valueLower) || b.slugNormalized.startsWith(valueNormalized);
+                if (aStartsWith !== bStartsWith) {
+                  return aStartsWith ? -1 : 1;
+                }
+
+                // Then prioritize contains matches
+                var aContains = a.titleLower.includes(valueLower) || a.slugNormalized.includes(valueNormalized);
+                var bContains = b.titleLower.includes(valueLower) || b.slugNormalized.includes(valueNormalized);
+                if (aContains !== bContains) {
+                  return aContains ? -1 : 1;
+                }
+
+                // Then sort by score descending
+                return bScore - aScore;
+              } : undefined
+            });
+          case 2:
+            searchResults = _context2.v;
+            count = searchResults.count;
+            elapsed = searchResults.elapsed;
+            if (!searchResults.groups) {
+              _context2.n = 3;
+              break;
+            }
+            groupedResults = searchResults.groups.map(function (group) {
+              return {
+                group: group.values.join(' '),
+                items: group.result.map(formatResult)
+              };
+            });
+            setResults({
+              results: groupedResults,
+              count: count,
+              elapsed: elapsed
+            });
+            return _context2.a(2);
+          case 3:
+            formattedResults = searchResults.hits.map(formatResult);
+            setResults({
+              results: [{
+                group: 'Default',
+                items: formattedResults
+              }],
+              count: count,
+              elapsed: elapsed
+            });
+          case 4:
+            return _context2.a(2);
+        }
+      }, _callee2);
+    }));
+    return function (_x) {
+      return _ref6.apply(this, arguments);
+    };
+  }(), [index, defaultLimit, defaultResults, tolerance, boost, formatResult]);
+
+  /**
+   * Build a URL from a search result
+   * Handles path normalization and hash fragments for different result types
+   */
+  var buildResultUrl = React.useCallback(function (result) {
+    var url = result.path.startsWith('./') ? "".concat(result.prefix).concat(result.path.replace(/^\.\//, '').replace(/\/page\.mdx$/, '')) : result.path;
+
+    // Add hash for non-page types
+    if ('type' in result && result.type !== 'page') {
+      var hash;
+      if (result.type === 'section' || result.type === 'subsection') {
+        // For sections and subsections, extract hash from the slug field
+        // which already contains the page slug + hash (e.g., "button#api-reference")
+        var hashIndex = result.slug.indexOf('#');
+        hash = hashIndex !== -1 ? result.slug.substring(hashIndex + 1) : '';
+      } else if (result.type === 'part') {
+        hash = result.part.toLowerCase();
+      } else if (result.type === 'export') {
+        hash = result["export"]; // already lowercase or api-reference
+      } else {
+        hash = '';
+      }
+      if (hash) {
+        url += "#".concat(hash);
+      }
+    }
+    return url;
+  }, []);
+  return {
+    results: results,
+    isReady: index !== null,
+    search: search,
+    defaultResults: defaultResults,
+    buildResultUrl: buildResultUrl
+  };
+}

package/esm/withDocsInfra/withDeploymentConfig.js

@@ -1,4 +1,5 @@
 import _extends from "@babel/runtime/helpers/esm/extends";
+import * as os from 'node:os';
 /**
  * See the docs of the Netlify environment variables:
  * https://docs.netlify.com/configure-builds/environment-variables/#build-metadata.
@@ -32,7 +33,8 @@ process.env.DEPLOY_ENV = DEPLOY_ENV;
 export function withDeploymentConfig(nextConfig) {
   return _extends(_extends({
     trailingSlash: true,
-    reactStrictMode: true
+    reactStrictMode: true,
+    productionBrowserSourceMaps: true
   }, nextConfig), {}, {
     env: _extends(_extends({
       // production | staging | pull-request | development
@@ -57,7 +59,7 @@ export function withDeploymentConfig(nextConfig) {
       scrollRestoration: true,
       workerThreads: false
     }, process.env.CI ? {
-      cpus: 2
+      cpus: process.env.NEXT_PARALLELISM ? parseInt(process.env.NEXT_PARALLELISM, 10) : os.availableParallelism()
     } : {}), nextConfig.experimental),
     eslint: _extends({
       ignoreDuringBuilds: true