@apify/docusaurus-plugin-typedoc-api 4.4.12 → 5.0.0

package/lib/plugin/data.js

@@ -1,469 +1,431 @@
-'use strict';
-
-const _excluded = ["changelogPath", "readmePath"];
-function _objectWithoutProperties(e, t) { if (null == e) return {}; var o, r, i = _objectWithoutPropertiesLoose(e, t); if (Object.getOwnPropertySymbols) { var s = Object.getOwnPropertySymbols(e); for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]); } return i; }
-function _objectWithoutPropertiesLoose(r, e) { if (null == r) return {}; var t = {}; for (var n in r) if ({}.hasOwnProperty.call(r, n)) { if (e.includes(n)) continue; t[n] = r[n]; } return t; }
-function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
-function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-const childProcess = require('node:child_process');
-const fs = require('node:fs');
-const path = require('node:path');
-const TypeDoc = require('typedoc');
-const ts = require('typescript');
-const utils = require('@docusaurus/utils');
-const links = require('../utils/links.js');
-const reexports = require('../utils/reexports.js');
-const index = require('./python/index.js');
-const _0_23 = require('./structure/0.23.js');
-const url = require('./url.js');
-const _interopDefault = e => e && e.__esModule ? e : {
-  default: e
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
 };
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  const n = Object.create(null);
-  if (e) {
-    for (const k in e) {
-      if (k !== 'default') {
-        const d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: () => e[k]
-        });
-      }
-    }
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-const fs__default = /*#__PURE__*/_interopDefault(fs);
-const path__default = /*#__PURE__*/_interopDefault(path);
-const TypeDoc__namespace = /*#__PURE__*/_interopNamespace(TypeDoc);
-const ts__default = /*#__PURE__*/_interopDefault(ts);
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as TypeDoc from 'typedoc';
+import { ReflectionKind } from 'typedoc';
+import ts from 'typescript';
+import { normalizeUrl } from '@docusaurus/utils';
+import { injectGitRevision } from '../utils/links';
+import { injectReexports } from '../utils/reexports';
+import { processPythonDocs } from './python';
+import { migrateToVersion0230 } from './structure/0.23';
+import { getKindSlug, getPackageSlug, joinUrl } from './url';
 function shouldEmit(projectRoot, tsconfigPath) {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-  const _ts__default$default$ = ts__default.default.readConfigFile(tsconfigPath, name => fs__default.default.readFileSync(name, 'utf8')),
-    config = _ts__default$default$.config,
-    error = _ts__default$default$.error;
-  if (error) {
-    throw new Error(`Failed to load ${tsconfigPath}`);
-  }
-  const result = ts__default.default.parseJsonConfigFileContent(config, ts__default.default.sys, projectRoot, {}, tsconfigPath);
-  if (result.errors.length > 0) {
-    throw new Error(`Failed to parse ${tsconfigPath}`);
-  }
-  return result.projectReferences && result.projectReferences.length > 0 ? 'docs' : 'none';
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const { config, error } = ts.readConfigFile(tsconfigPath, (name) => fs.readFileSync(name, 'utf8'));
+    if (error) {
+        throw new Error(`Failed to load ${tsconfigPath}`);
+    }
+    const result = ts.parseJsonConfigFileContent(config, ts.sys, projectRoot, {}, tsconfigPath);
+    if (result.errors.length > 0) {
+        throw new Error(`Failed to parse ${tsconfigPath}`);
+    }
+    return result.projectReferences && result.projectReferences.length > 0 ? 'docs' : 'none';
 }
-
 // Persist build state as a global, since the plugin is re-evaluated every hot reload.
 // Because of this, we can't use state in the plugin or module scope.
 if (!global.typedocBuild) {
-  global.typedocBuild = {
-    count: 0
-  };
+    global.typedocBuild = { count: 0 };
 }
 function getCurrentGitRef() {
-  try {
-    const result = childProcess.spawnSync('git', ['rev-parse', 'HEAD'], {
-      encoding: 'utf8'
-    });
-    if (result.status === 0) {
-      return result.stdout.trim();
+    try {
+        const result = spawnSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8' });
+        if (result.status === 0) {
+            return result.stdout.trim();
+        }
+        console.warn(`[@apify/docusaurus-plugin-typedoc-api]: Unable to get current git SHA:`, result.stderr.trim());
     }
-    console.warn(`[@apify/docusaurus-plugin-typedoc-api]: Unable to get current git SHA:`, result.stderr.trim());
-  } catch (error) {
-    console.warn(`[@apify/docusaurus-plugin-typedoc-api]: Error while getting current git SHA:`, error);
-  }
-  return undefined;
-}
-async function generateJson(projectRoot, entryPoints, outFile, options, context) {
-  /* eslint-disable sort-keys */
-  if (projectRoot && !path__default.default.isAbsolute(projectRoot)) {
-    projectRoot = path__default.default.join(context.siteDir, projectRoot);
-  }
-
-  // Running the TypeDoc compiler is pretty slow...
-  // We should only load on the 1st build, and use cache for subsequent reloads.
-  if (global.typedocBuild.count > 0 && fs__default.default.existsSync(outFile)) {
-    return true;
-  }
-  if (options.pathToCurrentVersionTypedocJSON) {
-    fs__default.default.copyFileSync(options.pathToCurrentVersionTypedocJSON, outFile);
-  }
-  if (Object.keys(options.pythonOptions).length > 0) {
-    if (!options.pythonOptions.pythonModulePath || !options.pythonOptions.moduleShortcutsPath) {
-      throw new Error('Python options are missing required fields');
+    catch (error) {
+        console.warn(`[@apify/docusaurus-plugin-typedoc-api]: Error while getting current git SHA:`, error);
     }
-    index.processPythonDocs({
-      moduleShortcutsPath: options.pythonOptions.moduleShortcutsPath,
-      outPath: outFile,
-      pythonModulePath: options.pythonOptions.pythonModulePath,
-      gitRevision: options.gitRefName
+    return undefined;
+}
+export function generateJson(projectRoot, entryPoints, outFile, options, context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        /* eslint-disable sort-keys */
+        if (projectRoot && !path.isAbsolute(projectRoot)) {
+            projectRoot = path.join(context.siteDir, projectRoot);
+        }
+        // Running the TypeDoc compiler is pretty slow...
+        // We should only load on the 1st build, and use cache for subsequent reloads.
+        if (global.typedocBuild.count > 0 && fs.existsSync(outFile)) {
+            return true;
+        }
+        if (options.pathToCurrentVersionTypedocJSON) {
+            fs.copyFileSync(options.pathToCurrentVersionTypedocJSON, outFile);
+        }
+        if (Object.keys(options.pythonOptions).length > 0) {
+            if (!options.pythonOptions.pythonModulePath ||
+                !options.pythonOptions.moduleShortcutsPath) {
+                throw new Error('Python options are missing required fields');
+            }
+            processPythonDocs({
+                moduleShortcutsPath: options.pythonOptions.moduleShortcutsPath,
+                outPath: outFile,
+                pythonModulePath: options.pythonOptions.pythonModulePath,
+                gitRevision: options.gitRefName,
+            });
+        }
+        else {
+            const tsconfig = path.join(projectRoot, (_a = options.tsconfigName) !== null && _a !== void 0 ? _a : 'tsconfig.json');
+            const app = yield TypeDoc.Application.bootstrapWithPlugins(Object.assign(Object.assign({ gitRevision: (_b = getCurrentGitRef()) !== null && _b !== void 0 ? _b : options.gitRefName, includeVersion: true, skipErrorChecking: true, 
+                // stripYamlFrontmatter: true,
+                // Only emit when using project references
+                emit: shouldEmit(projectRoot, tsconfig), 
+                // Only document the public API by default
+                excludeExternals: true, excludeInternal: true, excludePrivate: true, excludeProtected: true, 
+                // Enable verbose logging when debugging
+                logLevel: options.debug ? 'Verbose' : 'Info', inlineTags: [
+                    '@link',
+                    '@inheritDoc',
+                    '@label',
+                    '@linkcode',
+                    '@linkplain',
+                    '@apilink',
+                    '@doclink',
+                ] }, options.typedocOptions), { 
+                // Control how config and packages are detected
+                tsconfig, entryPoints: entryPoints.map((ep) => path.join(projectRoot, ep)), entryPointStrategy: 'expand', exclude: options.exclude, 
+                // We use a fake category title so that we can fallback to the parent group
+                defaultCategory: '__CATEGORY__' }), [new TypeDoc.TSConfigReader(), new TypeDoc.TypeDocReader()]);
+            const project = yield app.convert();
+            if (project) {
+                yield app.generateJson(project, outFile);
+                global.typedocBuild.count += 1;
+            }
+        }
+        if (options.reexports && options.reexports.length > 0) {
+            yield injectReexports(outFile, options.reexports);
+        }
+        const gitRefName = getCurrentGitRef();
+        if (gitRefName) {
+            injectGitRevision(outFile, gitRefName);
+        }
+        return true;
     });
-  } else {
-    const tsconfig = path__default.default.join(projectRoot, options.tsconfigName ?? 'tsconfig.json');
-    const app = await TypeDoc__namespace.Application.bootstrapWithPlugins(_objectSpread(_objectSpread({
-      gitRevision: getCurrentGitRef() ?? options.gitRefName,
-      includeVersion: true,
-      skipErrorChecking: true,
-      // stripYamlFrontmatter: true,
-      // Only emit when using project references
-      emit: shouldEmit(projectRoot, tsconfig),
-      // Only document the public API by default
-      excludeExternals: true,
-      excludeInternal: true,
-      excludePrivate: true,
-      excludeProtected: true,
-      // Enable verbose logging when debugging
-      logLevel: options.debug ? 'Verbose' : 'Info',
-      inlineTags: ['@link', '@inheritDoc', '@label', '@linkcode', '@linkplain', '@apilink', '@doclink']
-    }, options.typedocOptions), {}, {
-      // Control how config and packages are detected
-      tsconfig,
-      entryPoints: entryPoints.map(ep => path__default.default.join(projectRoot, ep)),
-      entryPointStrategy: 'expand',
-      exclude: options.exclude,
-      // We use a fake category title so that we can fallback to the parent group
-      defaultCategory: '__CATEGORY__'
-    }), [new TypeDoc__namespace.TSConfigReader(), new TypeDoc__namespace.TypeDocReader()]);
-    const project = await app.convert();
-    if (project) {
-      await app.generateJson(project, outFile);
-      global.typedocBuild.count += 1;
-    }
-  }
-  if (options.reexports && options.reexports.length > 0) {
-    await reexports.injectReexports(outFile, options.reexports);
-  }
-  const gitRefName = getCurrentGitRef();
-  if (gitRefName) {
-    links.injectGitRevision(outFile, gitRefName);
-  }
-  return true;
 }
-function createReflectionMap(items = []) {
-  const map = {};
-  items.forEach(item => {
-    // Add @reference categories to reflection.
-    const referenceCategories = {};
-    for (const tag of item.comment?.blockTags ?? []) {
-      if (tag.tag === '@reference' && tag.content.length >= 2 && tag.content[0].kind === 'text') {
-        const categoryName = tag.content[0].text.trim();
-        const ref = tag.content.find(t => t.tag === '@link');
-        if (ref && typeof ref.target === 'number') {
-          if (!(categoryName in referenceCategories)) {
-            referenceCategories[categoryName] = {
-              title: categoryName,
-              children: []
-            };
-          }
-          if (!referenceCategories[categoryName].children.includes(ref.target)) {
-            referenceCategories[categoryName].children.push(ref.target);
-          }
+export function createReflectionMap(items = []) {
+    const map = {};
+    items.forEach((item) => {
+        var _a, _b;
+        // Add @reference categories to reflection.
+        const referenceCategories = {};
+        for (const tag of (_b = (_a = item.comment) === null || _a === void 0 ? void 0 : _a.blockTags) !== null && _b !== void 0 ? _b : []) {
+            if (tag.tag === '@reference' && tag.content.length >= 2 && tag.content[0].kind === 'text') {
+                const categoryName = tag.content[0].text.trim();
+                const ref = tag.content.find((t) => t.tag === '@link');
+                if (ref && typeof ref.target === 'number') {
+                    if (!(categoryName in referenceCategories)) {
+                        referenceCategories[categoryName] = { title: categoryName, children: [] };
+                    }
+                    if (!referenceCategories[categoryName].children.includes(ref.target)) {
+                        referenceCategories[categoryName].children.push(ref.target);
+                    }
+                }
+            }
         }
-      }
-    }
-
-    // Update categories with reference categories.
-    if (!item.categories) {
-      item.categories = [];
-    }
-    for (const category of Object.values(referenceCategories)) {
-      if (category.children.length > 0) {
-        const index = item.categories.findIndex(c => c.title === category.title);
-        if (index === -1) {
-          item.categories.push(category);
+        // Update categories with reference categories.
+        if (!item.categories) {
+            item.categories = [];
         }
-      }
-    }
-
-    // Add item.
-    map[item.id] = item;
-  });
-  return map;
+        for (const category of Object.values(referenceCategories)) {
+            if (category.children.length > 0) {
+                const index = item.categories.findIndex((c) => c.title === category.title);
+                if (index === -1) {
+                    item.categories.push(category);
+                }
+            }
+        }
+        // Add item.
+        map[item.id] = item;
+    });
+    return map;
 }
-function loadPackageJsonAndDocs(initialDir, pkgFileName = 'package.json', readmeFileName = 'README.md', changelogFileName = 'CHANGELOG.md') {
-  let currentDir = initialDir;
-  let found = true;
-  while (!fs__default.default.existsSync(path__default.default.join(currentDir, pkgFileName))) {
-    if (currentDir === path__default.default.dirname(currentDir)) {
-      found = false;
-      break;
-    } else {
-      currentDir = path__default.default.dirname(currentDir);
+export function loadPackageJsonAndDocs(initialDir, pkgFileName = 'package.json', readmeFileName = 'README.md', changelogFileName = 'CHANGELOG.md') {
+    let currentDir = initialDir;
+    let found = true;
+    while (!fs.existsSync(path.join(currentDir, pkgFileName))) {
+        if (currentDir === path.dirname(currentDir)) {
+            found = false;
+            break;
+        }
+        else {
+            currentDir = path.dirname(currentDir);
+        }
     }
-  }
-  if (!found) {
-    // TODO: load the actual package information from pyproject.toml or similar
+    if (!found) {
+        // TODO: load the actual package information from pyproject.toml or similar
+        return {
+            packageJson: {
+                name: 'crawlee',
+                version: '1.0.0',
+            },
+            readmePath: '',
+            changelogPath: '',
+        };
+    }
+    const readmePath = path.join(currentDir, readmeFileName);
+    const changelogPath = path.join(currentDir, changelogFileName);
     return {
-      packageJson: {
-        name: 'crawlee',
-        version: '1.0.0'
-      },
-      readmePath: '',
-      changelogPath: ''
+        packageJson: JSON.parse(fs.readFileSync(path.join(currentDir, pkgFileName), 'utf8')),
+        readmePath: fs.existsSync(readmePath) ? readmePath : '',
+        changelogPath: fs.existsSync(changelogPath) ? changelogPath : '',
     };
-  }
-  const readmePath = path__default.default.join(currentDir, readmeFileName);
-  const changelogPath = path__default.default.join(currentDir, changelogFileName);
-  return {
-    packageJson: JSON.parse(fs__default.default.readFileSync(path__default.default.join(currentDir, pkgFileName), 'utf8')),
-    readmePath: fs__default.default.existsSync(readmePath) ? readmePath : '',
-    changelogPath: fs__default.default.existsSync(changelogPath) ? changelogPath : ''
-  };
 }
-function addMetadataToReflections(project, packageSlug, urlPrefix, options) {
-  const permalink = `/${url.joinUrl(urlPrefix, packageSlug)}`;
-  if (project.children) {
-    project.children = project.children.map(child => {
-      _0_23.migrateToVersion0230(child);
-      const kindSlugPart = url.getKindSlug(child);
-      const childSlug = kindSlugPart ? `/${kindSlugPart}/${child.name}` : `#${child.name}`;
-      const childPermalink = permalink + childSlug;
-
-      // We need to go another level deeper and only use fragments
-      if ((child.kind === TypeDoc.ReflectionKind.Namespace || options.python) && child.children) {
-        child.children = child.children.map(grandChild => _objectSpread(_objectSpread({}, grandChild), {}, {
-          permalink: utils.normalizeUrl([`${childPermalink}#${grandChild.name}`])
-        }));
-      }
-      return _objectSpread(_objectSpread({}, child), {}, {
-        permalink: utils.normalizeUrl([childPermalink])
-      });
-    });
-  }
-
-  // @ts-expect-error Not sure why this fails
-  return _objectSpread(_objectSpread({}, project), {}, {
-    permalink: utils.normalizeUrl([permalink])
-  });
+export function addMetadataToReflections(project, packageSlug, urlPrefix, options) {
+    const permalink = `/${joinUrl(urlPrefix, packageSlug)}`;
+    if (project.children) {
+        project.children = project.children.map((child) => {
+            migrateToVersion0230(child);
+            const kindSlugPart = getKindSlug(child);
+            const childSlug = kindSlugPart ? `/${kindSlugPart}/${child.name}` : `#${child.name}`;
+            const childPermalink = permalink + childSlug;
+            // We need to go another level deeper and only use fragments
+            if ((child.kind === ReflectionKind.Namespace || options.python) && child.children) {
+                child.children = child.children.map((grandChild) => (Object.assign(Object.assign({}, grandChild), { permalink: normalizeUrl([`${childPermalink}#${grandChild.name}`]) })));
+            }
+            return Object.assign(Object.assign({}, child), { permalink: normalizeUrl([childPermalink]) });
+        });
+    }
+    // @ts-expect-error Not sure why this fails
+    return Object.assign(Object.assign({}, project), { permalink: normalizeUrl([permalink]) });
 }
 function mergeReflections(base, next) {
-  if (Array.isArray(base.children) && Array.isArray(next.children)) {
-    base.children.push(...next.children);
-  }
-  if (Array.isArray(base.groups) && Array.isArray(next.groups)) {
-    next.groups.forEach(group => {
-      const baseGroup = base.groups?.find(g => g.title === group.title);
-      if (baseGroup) {
-        baseGroup.children?.push(...(group.children ?? []));
-      } else {
-        base.groups?.push(group);
-      }
-    });
-
-    // We can remove refs since were merging all reflections into one
-
-    base.groups = base.groups.filter(group => group.title !== 'References');
-  }
+    if (Array.isArray(base.children) && Array.isArray(next.children)) {
+        base.children.push(...next.children);
+    }
+    if (Array.isArray(base.groups) && Array.isArray(next.groups)) {
+        next.groups.forEach((group) => {
+            var _a, _b, _c, _d;
+            const baseGroup = (_a = base.groups) === null || _a === void 0 ? void 0 : _a.find((g) => g.title === group.title);
+            if (baseGroup) {
+                (_b = baseGroup.children) === null || _b === void 0 ? void 0 : _b.push(...((_c = group.children) !== null && _c !== void 0 ? _c : []));
+            }
+            else {
+                (_d = base.groups) === null || _d === void 0 ? void 0 : _d.push(group);
+            }
+        });
+        // We can remove refs since were merging all reflections into one
+        base.groups = base.groups.filter((group) => group.title !== 'References');
+    }
 }
 function sortReflectionGroups(reflections) {
-  reflections.forEach(reflection => {
-    const map = createReflectionMap(reflection.children);
-    const sort = (a, b) => map[a].name < map[b].name ? -1 : 1;
-    reflection.categories?.forEach(category => {
-      category.children?.sort(sort);
-    });
-    reflection.groups?.forEach(group => {
-      group.children?.sort(sort);
-      group.categories?.forEach(category => {
-        category.children?.sort(sort);
-      });
+    reflections.forEach((reflection) => {
+        var _a, _b;
+        const map = createReflectionMap(reflection.children);
+        const sort = (a, b) => (map[a].name < map[b].name ? -1 : 1);
+        (_a = reflection.categories) === null || _a === void 0 ? void 0 : _a.forEach((category) => {
+            var _a;
+            (_a = category.children) === null || _a === void 0 ? void 0 : _a.sort(sort);
+        });
+        (_b = reflection.groups) === null || _b === void 0 ? void 0 : _b.forEach((group) => {
+            var _a, _b;
+            (_a = group.children) === null || _a === void 0 ? void 0 : _a.sort(sort);
+            (_b = group.categories) === null || _b === void 0 ? void 0 : _b.forEach((category) => {
+                var _a;
+                (_a = category.children) === null || _a === void 0 ? void 0 : _a.sort(sort);
+            });
+        });
     });
-  });
 }
-function sourceFileMatchesEntryPoint(sourceFile, entryPoint, {
-  deep,
-  single
-}) {
-  // Single package
-  if (single) {
+function sourceFileMatchesEntryPoint(sourceFile, entryPoint, { deep, single }) {
+    // Single package
+    if (single) {
+        return (
+        // src/index.ts === src/index.ts
+        (!deep && sourceFile === entryPoint) ||
+            // index.ts === src/index.ts
+            (!deep && sourceFile === path.basename(entryPoint)) ||
+            // some/deep/file.ts === ...
+            deep);
+    }
+    // Multiple packages
     return (
-      // src/index.ts === src/index.ts
-      !deep && sourceFile === entryPoint ||
-      // index.ts === src/index.ts
-      !deep && sourceFile === path__default.default.basename(entryPoint) ||
-      // some/deep/file.ts === ...
-      deep
-    );
-  }
-
-  // Multiple packages
-  return (
     // packages/foo/src/index.ts === packages/foo/src/index.ts
     // foo/src/index.ts ~ packages/foo/src/index.ts
-    !deep && (sourceFile === entryPoint || entryPoint.endsWith(sourceFile)) ||
-    // packages/foo/src/some/deep/file.ts === packages/foo/src/
-    deep && sourceFile.startsWith(entryPoint)
-  );
+    (!deep && (sourceFile === entryPoint || entryPoint.endsWith(sourceFile))) ||
+        // packages/foo/src/some/deep/file.ts === packages/foo/src/
+        (deep && sourceFile.startsWith(entryPoint)));
 }
 function modContainsEntryPoint(mod, entry, meta) {
-  const relModSources = mod.sources ?? [];
-  const relModSourceFile = relModSources.find(sf => !!sf.fileName)?.fileName ?? '';
-  const relEntryPoint = url.joinUrl(meta.packagePath, entry.path);
-
-  // Monorepos of 1 package don't have sources, so use the child sources.
-  // They also don't use full paths like "package/src/index.ts" and simply use "index.ts",
-  // so account for those entry points also.
-  if (!relModSourceFile) {
-    const absEntryPoint = path__default.default.normalize(path__default.default.join(meta.packageRoot ?? '', entry.path ?? ''));
-    const relEntryPointName = path__default.default.basename(relEntryPoint);
-    const entryPointInSourceFiles = !!meta.allSourceFiles[absEntryPoint] || !!meta.allSourceFiles[relEntryPoint] || relEntryPointName.startsWith('index.') && !!meta.allSourceFiles[relEntryPointName];
-    if (entryPointInSourceFiles) {
-      return sourceFileMatchesEntryPoint(relEntryPoint, relEntryPoint, {
-        deep: meta.isUsingDeepImports,
-        single: meta.isSinglePackage
-      });
+    var _a, _b, _c, _d, _e;
+    const relModSources = (_a = mod.sources) !== null && _a !== void 0 ? _a : [];
+    const relModSourceFile = (_c = (_b = relModSources.find((sf) => !!sf.fileName)) === null || _b === void 0 ? void 0 : _b.fileName) !== null && _c !== void 0 ? _c : '';
+    const relEntryPoint = joinUrl(meta.packagePath, entry.path);
+    // Monorepos of 1 package don't have sources, so use the child sources.
+    // They also don't use full paths like "package/src/index.ts" and simply use "index.ts",
+    // so account for those entry points also.
+    if (!relModSourceFile) {
+        const absEntryPoint = path.normalize(path.join((_d = meta.packageRoot) !== null && _d !== void 0 ? _d : '', (_e = entry.path) !== null && _e !== void 0 ? _e : ''));
+        const relEntryPointName = path.basename(relEntryPoint);
+        const entryPointInSourceFiles = !!meta.allSourceFiles[absEntryPoint] ||
+            !!meta.allSourceFiles[relEntryPoint] ||
+            (relEntryPointName.startsWith('index.') && !!meta.allSourceFiles[relEntryPointName]);
+        if (entryPointInSourceFiles) {
+            return sourceFileMatchesEntryPoint(relEntryPoint, relEntryPoint, {
+                deep: meta.isUsingDeepImports,
+                single: meta.isSinglePackage,
+            });
+        }
     }
-  }
-  return sourceFileMatchesEntryPoint(relModSourceFile, relEntryPoint, {
-    deep: meta.isUsingDeepImports,
-    single: meta.isSinglePackage
-  });
+    return sourceFileMatchesEntryPoint(relModSourceFile, relEntryPoint, {
+        deep: meta.isUsingDeepImports,
+        single: meta.isSinglePackage,
+    });
 }
 function extractReflectionModules(project, isSinglePackage) {
-  const modules = [];
-  const inheritChildren = () => {
-    project.children?.forEach(child => {
-      if (child.kind === TypeDoc.ReflectionKind.Module) {
-        modules.push(child);
-      }
-    });
-  };
-
-  // Single packages are extremely difficult, as the TypeDoc structure is
-  // different for every kind of package entry point pattern
-  if (isSinglePackage) {
-    const hasNoModules = project.children?.every(child => child.kind !== TypeDoc.ReflectionKind.Module);
-    if (hasNoModules) {
-      // No "module" children:
-      //	- Polyrepos
-      //	- Monorepos with 1 package
-      modules.push(project);
-    } else {
-      // Has "module" children:
-      //	- Polyrepos with deep imports
-      //	- Polyrepos with multi-imports
-      //	- Monorepos
-      inheritChildren();
+    var _a;
+    const modules = [];
+    const inheritChildren = () => {
+        var _a;
+        (_a = project.children) === null || _a === void 0 ? void 0 : _a.forEach((child) => {
+            if (child.kind === ReflectionKind.Module) {
+                modules.push(child);
+            }
+        });
+    };
+    // Single packages are extremely difficult, as the TypeDoc structure is
+    // different for every kind of package entry point pattern
+    if (isSinglePackage) {
+        const hasNoModules = (_a = project.children) === null || _a === void 0 ? void 0 : _a.every((child) => child.kind !== ReflectionKind.Module);
+        if (hasNoModules) {
+            // No "module" children:
+            //	- Polyrepos
+            //	- Monorepos with 1 package
+            modules.push(project);
+        }
+        else {
+            // Has "module" children:
+            //	- Polyrepos with deep imports
+            //	- Polyrepos with multi-imports
+            //	- Monorepos
+            inheritChildren();
+        }
+        // Multiple packages are extremely simple, as every package is a module reflection
+        // as a child on the top-level project reflection
+    }
+    else {
+        inheritChildren();
     }
-
-    // Multiple packages are extremely simple, as every package is a module reflection
-    // as a child on the top-level project reflection
-  } else {
-    inheritChildren();
-  }
-  return modules;
+    return modules;
 }
 function buildSourceFileNameMap(project, modChildren) {
-  const map = {};
-  const cwd = process.cwd();
-  if (project.symbolIdMap) {
-    Object.values(project.symbolIdMap).forEach(symbol => {
-      // absolute
-      map[path__default.default.normalize(path__default.default.join(cwd, symbol.sourceFileName))] = true;
-    });
-  }
-  modChildren.forEach(child => {
-    child.sources?.forEach(sf => {
-      // relative
-      map[sf.fileName] = true;
+    const map = {};
+    const cwd = process.cwd();
+    if (project.symbolIdMap) {
+        Object.values(project.symbolIdMap).forEach((symbol) => {
+            // absolute
+            map[path.normalize(path.join(cwd, symbol.sourceFileName))] = true;
+        });
+    }
+    modChildren.forEach((child) => {
+        var _a;
+        (_a = child.sources) === null || _a === void 0 ? void 0 : _a.forEach((sf) => {
+            // relative
+            map[sf.fileName] = true;
+        });
     });
-  });
-  return map;
+    return map;
 }
-function flattenAndGroupPackages(packageConfigs, project, urlPrefix, options, context, versioned = false) {
-  const isSinglePackage = packageConfigs.length === 1;
-  const modules = extractReflectionModules(project, isSinglePackage);
-
-  // Loop through every TypeDoc module and group based on package and entry point
-  const packages = {};
-  const packagesWithDeepImports = [];
-  modules.forEach(mod => {
-    const allSourceFiles = buildSourceFileNameMap(project, mod.children ?? []);
-    packageConfigs.some(cfg => Object.entries(cfg.entryPoints).some(([importPath, entry]) => {
-      const isUsingDeepImports = !entry.path.match(/\.tsx?$/);
-      let packageRoot = cfg.packageRoot;
-      if (packageRoot && !path__default.default.isAbsolute(packageRoot)) {
-        packageRoot = path__default.default.join(context.siteDir, packageRoot);
-      }
-      if (!modContainsEntryPoint(mod, entry, {
-        allSourceFiles,
-        isSinglePackage,
-        isUsingDeepImports,
-        packagePath: cfg.packagePath,
-        packageRoot
-      })) {
-        return false;
-      }
-
-      // We have a matching entry point, so store the record
-      if (!packages[cfg.packagePath]) {
-        const _loadPackageJsonAndDo = loadPackageJsonAndDocs(path__default.default.join(options.projectRoot, cfg.packagePath), options.packageJsonName, options.readmeName, options.changelogName),
-          packageJson = _loadPackageJsonAndDo.packageJson,
-          readmePath = _loadPackageJsonAndDo.readmePath,
-          changelogPath = _loadPackageJsonAndDo.changelogPath;
-        packages[cfg.packagePath] = {
-          entryPoints: [],
-          packageName: versioned && cfg.packageName || packageJson.name,
-          packageVersion: versioned && cfg.packageVersion || packageJson.version,
-          readmePath,
-          changelogPath
-        };
-        cfg.packageName = packages[cfg.packagePath].packageName;
-        cfg.packageVersion = packages[cfg.packagePath].packageVersion;
-      }
-
-      // Add metadata to package and children reflections
-      const urlSlug = url.getPackageSlug(cfg, importPath, isSinglePackage);
-      const reflection = addMetadataToReflections(mod, urlSlug, urlPrefix, options);
-      const existingEntry = packages[cfg.packagePath].entryPoints.find(ep => ep.urlSlug === urlSlug);
-      if (existingEntry) {
-        if (isUsingDeepImports) {
-          mergeReflections(existingEntry.reflection, reflection);
-        } else {
-          // eslint-disable-next-line no-console
-          console.error(`Entry point ${urlSlug} already defined. How did you get here?`);
-        }
-      } else {
-        packages[cfg.packagePath].entryPoints.push({
-          index: importPath === 'index',
-          label: entry.label,
-          reflection,
-          urlSlug
-        });
-        if (isUsingDeepImports) {
-          packagesWithDeepImports.push(reflection);
-        }
-      }
-
-      // Update the reflection name since its useless
-      reflection.name = importPath === 'index' ? packages[cfg.packagePath].packageName : url.joinUrl(packages[cfg.packagePath].packageName, importPath);
-      return true;
-    }));
-  });
-
-  // Since we merged multiple reflections together, we'll need to sort groups manually
-  sortReflectionGroups(packagesWithDeepImports);
-
-  // Sort packages by name
-  return Object.values(packages).sort((a, b) => a.packageName.localeCompare(b.packageName));
+export function flattenAndGroupPackages(packageConfigs, project, urlPrefix, options, context, versioned = false) {
+    const isSinglePackage = packageConfigs.length === 1;
+    const modules = extractReflectionModules(project, isSinglePackage);
+    // Loop through every TypeDoc module and group based on package and entry point
+    const packages = {};
+    const packagesWithDeepImports = [];
+    modules.forEach((mod) => {
+        var _a;
+        const allSourceFiles = buildSourceFileNameMap(project, (_a = mod.children) !== null && _a !== void 0 ? _a : []);
+        packageConfigs.some((cfg) => Object.entries(cfg.entryPoints).some(([importPath, entry]) => {
+            const isUsingDeepImports = !entry.path.match(/\.tsx?$/);
+            let { packageRoot } = cfg;
+            if (packageRoot && !path.isAbsolute(packageRoot)) {
+                packageRoot = path.join(context.siteDir, packageRoot);
+            }
+            if (!modContainsEntryPoint(mod, entry, {
+                allSourceFiles,
+                isSinglePackage,
+                isUsingDeepImports,
+                packagePath: cfg.packagePath,
+                packageRoot,
+            })) {
+                return false;
+            }
+            // We have a matching entry point, so store the record
+            if (!packages[cfg.packagePath]) {
+                const { packageJson, readmePath, changelogPath } = loadPackageJsonAndDocs(path.join(options.projectRoot, cfg.packagePath), options.packageJsonName, options.readmeName, options.changelogName);
+                packages[cfg.packagePath] = {
+                    entryPoints: [],
+                    packageName: (versioned && cfg.packageName) || packageJson.name,
+                    packageVersion: (versioned && cfg.packageVersion) || packageJson.version,
+                    readmePath,
+                    changelogPath,
+                };
+                cfg.packageName = packages[cfg.packagePath].packageName;
+                cfg.packageVersion = packages[cfg.packagePath].packageVersion;
+            }
+            // Add metadata to package and children reflections
+            const urlSlug = getPackageSlug(cfg, importPath, isSinglePackage);
+            const reflection = addMetadataToReflections(mod, urlSlug, urlPrefix, options);
+            const existingEntry = packages[cfg.packagePath].entryPoints.find((ep) => ep.urlSlug === urlSlug);
+            if (existingEntry) {
+                if (isUsingDeepImports) {
+                    mergeReflections(existingEntry.reflection, reflection);
+                }
+                else {
+                    // eslint-disable-next-line no-console
+                    console.error(`Entry point ${urlSlug} already defined. How did you get here?`);
+                }
+            }
+            else {
+                packages[cfg.packagePath].entryPoints.push({
+                    index: importPath === 'index',
+                    label: entry.label,
+                    reflection,
+                    urlSlug,
+                });
+                if (isUsingDeepImports) {
+                    packagesWithDeepImports.push(reflection);
+                }
+            }
+            // Update the reflection name since its useless
+            reflection.name =
+                importPath === 'index'
+                    ? packages[cfg.packagePath].packageName
+                    : joinUrl(packages[cfg.packagePath].packageName, importPath);
+            return true;
+        }));
+    });
+    // Since we merged multiple reflections together, we'll need to sort groups manually
+    sortReflectionGroups(packagesWithDeepImports);
+    // Sort packages by name
+    return Object.values(packages).sort((a, b) => a.packageName.localeCompare(b.packageName));
 }
-function formatPackagesWithoutHostInfo(packages) {
-  return packages.map(_ref => {
-    let changelogPath = _ref.changelogPath,
-      readmePath = _ref.readmePath,
-      pkg = _objectWithoutProperties(_ref, _excluded);
-    return pkg;
-  });
+export function formatPackagesWithoutHostInfo(packages) {
+    return packages.map((_a) => {
+        var { changelogPath, readmePath } = _a, pkg = __rest(_a, ["changelogPath", "readmePath"]);
+        return pkg;
+    });
 }
-exports.addMetadataToReflections = addMetadataToReflections;
-exports.createReflectionMap = createReflectionMap;
-exports.flattenAndGroupPackages = flattenAndGroupPackages;
-exports.formatPackagesWithoutHostInfo = formatPackagesWithoutHostInfo;
-exports.generateJson = generateJson;
-exports.loadPackageJsonAndDocs = loadPackageJsonAndDocs;
-//# sourceMappingURL=data.js.map
+//# sourceMappingURL=data.js.map