@unterberg/nivel 0.0.3 → 0.0.4

package/README.md

@@ -1,70 +1,33 @@
 # nivel engine
 
-docs builder proof of concept for generating vike-based documentation sites with a single docs graph as the source of truth.
+`@unterberg/nivel` is the docs runtime for this repo's Vike-based documentation sites.
 
-monorepo structure:
-
-- `packages/engine`: the reusable `@unterberg/nivel` package
-- `packages/consumer-test`: the reference consumer used to exercise the engine against real docs content, currently based on the [Telefunc docs](https://telefunc.com)
-
-## Alpha Status
-
-This project is an early proof of concept and should be expected to have rough edges. The main goal is to validate the core engine ideas and architecture, not to provide a polished general-purpose doc builder right now. Some specific things to keep in mind:
-
-- Expect breaking changes.
-- The public API is not stable yet. (blackbox)
-- The supported stack fixed currently to Vike + Vite + React.
-- `basePath` is currently fixed to `/docs`.
-- The consumer app in this repo is still the main integration example.
-
-If you need a polished general-purpose docpress replacement today, this is not that yet.
-
-## What It Does
-
-The engine currently owns the core docs runtime:
+It currently owns:
 
 - docs graph validation and resolution
 - generated Vike routes from MDX content
-- shared docs layout pieces such as navbar, sidebar, table of contents, pagination, and meta head wiring
+- docs layout primitives such as navbar, sidebar, table of contents, pagination, and meta head wiring
 - MDX setup with built-in docs components and code-block transforms
-- asset handling for engine-owned fonts and shared static assets
+- optional Algolia search wiring
+- engine-owned fonts and shared assets
 
-The intended split is:
+The supported stack is currently Vike + Vite + React. Expect breaking changes while the package is still alpha.
 
-- the engine owns behavior, runtime wiring, and reusable UI primitives
-- the consumer owns docs content, `docs/docs.graph.ts`, `pages/+docs.ts`, and brand/theme assets
-
-## Minimal Shape
-
-At the moment, a consumer looks roughly like this:
+## Public Helpers
 
 ```ts
-// pages/+docs.ts
-import { defineDocsConfig } from '@unterberg/nivel'
-import { docsGraph } from '../docs/docs.graph'
-
-export default defineDocsConfig({
-  siteTitle: 'My Docs',
-  basePath: '/docs',
-  graph: docsGraph,
-  algolia: {
-    appId: 'YOUR_APP_ID',
-    apiKey: 'YOUR_SEARCH_ONLY_API_KEY',
-    indexName: 'YOUR_INDEX_NAME',
-  },
-})
+import { defineDocsConfig, defineDocsGraph } from '@unterberg/nivel/config'
 ```
 
-```ts
-// docs/docs.graph.ts
-import { defineDocsGraph } from '@unterberg/nivel'
+Both helpers are identity functions. They are also re-exported from `@unterberg/nivel`, but the dedicated config entry keeps `pages/+docs.ts` and `docs/docs.graph.ts` on a lean config-time import path.
 
-export const docsGraph = defineDocsGraph({
+```ts
+const docsGraph = defineDocsGraph({
   items: [
     {
       kind: 'section',
       id: 'docs',
-      title: 'Documentation',
+      title: 'Docs',
       items: [
         {
           kind: 'page',
@@ -77,31 +40,71 @@ export const docsGraph = defineDocsGraph({
     },
   ],
 })
+
+export default defineDocsConfig({
+  siteTitle: 'My Docs',
+  siteDescription: 'Documentation site powered by @unterberg/nivel.',
+  basePath: '/docs',
+  graph: docsGraph,
+})
 ```
 
-Then the consumer wires:
+## Recommended Consumer Files
+
+A consumer should keep these files explicit and local:
 
-- `@unterberg/nivel/vike` into Vike config
-- `MetaHead` in global `+Head`
-- `AppLayout` in global `+Layout`
-- `nivel prepare` before dev/build/typecheck
-- `@import '@unterberg/nivel/tailwind-sources.css'` in the consumer Tailwind entry
+- hand-authored: `pages/+docs.ts`, `docs/docs.graph.ts`, docs content, brand assets, and consumer CSS/Tailwind/theme files
+- scaffolded once but still editable: `pages/+config.ts`, `pages/+Head.tsx`, `pages/+Layout.tsx`, `pages/+onCreateGlobalContext.ts`, `pages/+Wrapper.tsx`, and `global.d.ts`
 
-Algolia search is optional. When configured, `apiKey` must be a search-only public key because requests are made from the browser.
+Only `(nivel-generated)` stays engine-generated.
 
-## Current Limitations
+## Standard Vike Config
 
-- The package is still alpha and should be expected to change.
-- The supported stack is currently narrow: Vike + Vite + React.
-- `basePath` is currently fixed to `/docs`.
-- The package is still validated mainly through one real consumer, not a broad set of independent adopters.
-- The setup and examples are still catching up with the implementation, so the integration story is not fully polished yet.
+Use the helper from `@unterberg/nivel/vike` for the standard Vike setup:
 
-## Future Plans
+```ts
+// pages/+docs.ts
+import { defineDocsConfig } from '@unterberg/nivel/config'
+import { docsGraph } from '../docs/docs.graph'
+
+export default defineDocsConfig({
+  siteTitle: 'My Docs',
+  siteDescription: 'Documentation site powered by @unterberg/nivel.',
+  basePath: '/docs',
+  graph: docsGraph,
+})
+```
+
+```ts
+// pages/+config.ts
+import { createNivelVikeConfig } from '@unterberg/nivel/vike'
+import docsConfig from './+docs'
+
+export { config }
+
+const config = createNivelVikeConfig(docsConfig)
+```
+
+`createNivelVikeConfig()` owns the standard `title`, `description`, Vike React extension, default `data-theme`, `passToClient`, and `prerender` wiring. Consumers can still spread or override it locally if they need extra Vike config.
+
+## CLI
+
+`nivel prepare` generates docs pages from `pages/+docs.ts`.
+
+`nivel init` scaffolds the visible consumer shell files and updates the standard docs scripts in `package.json`.
+
+```bash
+nivel init
+nivel prepare
+```
+
+`nivel init` does not create or overwrite consumer CSS/Tailwind/theme files. Keep those hand-authored. Add the engine Tailwind helper manually in your stylesheet:
+
+```css
+@import '@unterberg/nivel/tailwind-sources.css';
+```
 
-- Continue hardening the engine/consumer split so docs behavior stays in `@unterberg/nivel` and the consumer remains thin.
-- Improve the package-level docs and examples so setup is easier to understand without reading the consumer app in detail.
-- Reduce hard-coded assumptions where it makes sense, starting with the areas that currently make the engine feel too tied to its first consumer.
+If you use Algolia, `apiKey` must be a search-only public key because requests are made from the browser.
 
 ## Commands
 

package/dist/{chunk-UDOIFPCZ.js → chunk-2EDJWL3U.js}

@@ -1,7 +1,3 @@
-import {
-  UniversalMdxProvider,
-  renderInlineMarkdown
-} from "./chunk-L6ZVB6XH.js";
 import {
   createHeadingSlugger,
   getActiveSectionByPathname,
@@ -10,6 +6,10 @@ import {
   isSamePagePathname,
   normalizeHeadingTitle
 } from "./chunk-D7IAGT53.js";
+import {
+  UniversalMdxProvider,
+  renderInlineMarkdown
+} from "./chunk-L6ZVB6XH.js";
 import {
   withSiteBaseUrl
 } from "./chunk-PYYPYIBD.js";
@@ -1535,4 +1535,4 @@ export {
   ProseContainer,
   DocsPage
 };
-//# sourceMappingURL=chunk-UDOIFPCZ.js.map
+//# sourceMappingURL=chunk-2EDJWL3U.js.map

package/dist/chunk-67GE3PJ6.js

@@ -0,0 +1,473 @@
+import {
+  extractDocHeadings,
+  getResolvedPageById,
+  resolveDocsConfig
+} from "./chunk-D7IAGT53.js";
+
+// src/runtime/node/codegen.ts
+import fs from "fs";
+import path from "path";
+var GENERATED_DIRNAME = "(nivel-generated)";
+var writeFileIfChanged = (filePath, source) => {
+  const current = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : null;
+  if (current === source) {
+    return;
+  }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, source);
+};
+var toPosix = (value) => value.split(path.sep).join(path.posix.sep);
+var getRelativeImportPath = (fromDirectory, toFile) => {
+  const relativePath = toPosix(path.relative(fromDirectory, toFile));
+  if (relativePath.startsWith(".")) {
+    return relativePath;
+  }
+  return `./${relativePath}`;
+};
+var serializeData = (data) => JSON.stringify(data, null, 2);
+var collectFiles = (directoryPath) => {
+  if (!fs.existsSync(directoryPath)) {
+    return [];
+  }
+  const entries = fs.readdirSync(directoryPath, { withFileTypes: true });
+  return entries.flatMap((entry) => {
+    const entryPath = path.join(directoryPath, entry.name);
+    return entry.isDirectory() ? collectFiles(entryPath) : [entryPath];
+  });
+};
+var removeEmptyDirectories = (directoryPath, rootPath) => {
+  if (!fs.existsSync(directoryPath)) {
+    return;
+  }
+  for (const entry of fs.readdirSync(directoryPath, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    removeEmptyDirectories(path.join(directoryPath, entry.name), rootPath);
+  }
+  if (directoryPath === rootPath) {
+    return;
+  }
+  if (fs.readdirSync(directoryPath).length === 0) {
+    fs.rmdirSync(directoryPath);
+  }
+};
+var getGeneratedPageSource = (contentImportPath) => {
+  return [
+    "import { DocsPage } from '@unterberg/nivel/client'",
+    `import Content from ${JSON.stringify(contentImportPath)}`,
+    "",
+    "const Page = () => {",
+    "  return <DocsPage Content={Content} />",
+    "}",
+    "",
+    "export default Page",
+    ""
+  ].join("\n");
+};
+var getGeneratedDataSource = (data) => {
+  return [
+    "import type { DocPageData } from '@unterberg/nivel'",
+    "",
+    `const data: DocPageData = ${serializeData(data)}`,
+    "",
+    "const pageData = () => {",
+    "  return data",
+    "}",
+    "",
+    "export default pageData",
+    ""
+  ].join("\n");
+};
+var getGeneratedGlobalContextSource = (data) => {
+  return [
+    "import type { DocsGlobalContextData } from '@unterberg/nivel'",
+    "",
+    `const docsGlobalContextData: DocsGlobalContextData = ${serializeData(data)}`,
+    "",
+    "export { docsGlobalContextData }",
+    ""
+  ].join("\n");
+};
+var getRouteString = (href) => {
+  if (href === "/") {
+    return href;
+  }
+  return href.replace(/\/+$/g, "");
+};
+var getGeneratedRouteSource = (href) => {
+  return [`export default ${JSON.stringify(getRouteString(href))}`, ""].join("\n");
+};
+var getGeneratedTextExport = (value) => {
+  return [`export default ${JSON.stringify(value)}`, ""].join("\n");
+};
+var toDocPageLinkData = (page) => {
+  if (!page) {
+    return null;
+  }
+  return {
+    id: page.id,
+    title: page.title,
+    href: page.href,
+    documentTitle: page.documentTitle
+  };
+};
+var getGeneratedPagesRoot = (rootDir) => path.join(rootDir, "pages", GENERATED_DIRNAME);
+var syncGeneratedDocsPages = (options) => {
+  const { rootDir, docsConfig } = options;
+  const resolved = resolveDocsConfig(docsConfig);
+  const generatedPagesRoot = getGeneratedPagesRoot(rootDir);
+  const docsRoot = path.join(rootDir, "docs");
+  const expectedFiles = /* @__PURE__ */ new Set();
+  const globalContextFilePath = path.join(generatedPagesRoot, "_docsGlobalContext.ts");
+  fs.mkdirSync(generatedPagesRoot, { recursive: true });
+  const globalContextData = {
+    siteTitle: resolved.siteTitle,
+    basePath: resolved.basePath,
+    theme: resolved.theme,
+    footer: resolved.footer,
+    brand: resolved.brand,
+    head: resolved.head,
+    partners: resolved.partners,
+    algolia: resolved.algolia,
+    pages: resolved.pages,
+    navbarItems: resolved.navbarItems,
+    sidebarSections: resolved.sections
+  };
+  writeFileIfChanged(globalContextFilePath, getGeneratedGlobalContextSource(globalContextData));
+  expectedFiles.add(globalContextFilePath);
+  for (const [pageIndex, page] of resolved.pages.entries()) {
+    const contentFilePath = path.join(docsRoot, page.source);
+    if (!fs.existsSync(contentFilePath)) {
+      throw new Error(`Docs page "${page.id}" points to missing source file: ${contentFilePath}`);
+    }
+    const pageSource = fs.readFileSync(contentFilePath, "utf8");
+    const data = {
+      page: getResolvedPageById(resolved, page.id),
+      headings: extractDocHeadings(pageSource),
+      previousPage: toDocPageLinkData(resolved.pages[pageIndex - 1]),
+      nextPage: toDocPageLinkData(resolved.pages[pageIndex + 1])
+    };
+    for (const routeHref of [page.href, ...page.aliasHrefs]) {
+      const routeSlug = routeHref.replace(/^\/docs\//, "").replace(/\/+$/g, "");
+      const pageDir = path.join(generatedPagesRoot, ...routeSlug.split("/"));
+      const contentImportPath = getRelativeImportPath(pageDir, contentFilePath);
+      const pageFilePath = path.join(pageDir, "+Page.tsx");
+      const dataFilePath = path.join(pageDir, "+data.ts");
+      const routeFilePath = path.join(pageDir, "+route.ts");
+      const titleFilePath = path.join(pageDir, "+title.ts");
+      writeFileIfChanged(pageFilePath, getGeneratedPageSource(contentImportPath));
+      writeFileIfChanged(dataFilePath, getGeneratedDataSource(data));
+      writeFileIfChanged(routeFilePath, getGeneratedRouteSource(routeHref));
+      writeFileIfChanged(titleFilePath, getGeneratedTextExport(page.documentTitle));
+      expectedFiles.add(pageFilePath);
+      expectedFiles.add(dataFilePath);
+      expectedFiles.add(routeFilePath);
+      expectedFiles.add(titleFilePath);
+      if (page.description) {
+        const descriptionFilePath = path.join(pageDir, "+description.ts");
+        writeFileIfChanged(descriptionFilePath, getGeneratedTextExport(page.description));
+        expectedFiles.add(descriptionFilePath);
+      }
+    }
+  }
+  for (const filePath of collectFiles(generatedPagesRoot)) {
+    if (expectedFiles.has(filePath)) {
+      continue;
+    }
+    fs.rmSync(filePath, { force: true });
+  }
+  removeEmptyDirectories(generatedPagesRoot, generatedPagesRoot);
+};
+var isDocsSourcePath = (filePath, rootDir) => {
+  const normalized = toPosix(filePath);
+  const docsRoot = toPosix(path.join(rootDir, "docs"));
+  const docsConfigPath = toPosix(path.join(rootDir, "pages", "+docs.ts"));
+  const generatedRoot = toPosix(getGeneratedPagesRoot(rootDir));
+  if (normalized.startsWith(generatedRoot)) {
+    return false;
+  }
+  return normalized === docsConfigPath || normalized.startsWith(`${docsRoot}/`);
+};
+
+// src/runtime/node/loadDocsConfig.ts
+import path2 from "path";
+var getDocsConfigModulePath = (rootDir) => {
+  return path2.join(rootDir, "pages", "+docs.ts");
+};
+var getDocsConfigFromLoadedModule = (loaded, modulePath) => {
+  const docsConfig = loaded.default;
+  if (!docsConfig) {
+    throw new Error(`Expected default export from ${modulePath}`);
+  }
+  return docsConfig;
+};
+var loadDocsConfig = async (options) => {
+  const modulePath = getDocsConfigModulePath(options.rootDir);
+  const loaded = await options.loadModule(modulePath);
+  return getDocsConfigFromLoadedModule(loaded, modulePath);
+};
+
+// src/runtime/node/scaffold.ts
+import fs2 from "fs";
+import path3 from "path";
+var MANAGED_SCRIPT_NAMES = ["generate:docs", "predev", "prebuild", "pretypecheck"];
+var REQUIRED_DEPENDENCIES = ["@unterberg/nivel", "react", "react-dom", "vike", "vike-react"];
+var REQUIRED_DEV_DEPENDENCIES = ["vite", "typescript", "@types/react", "@types/react-dom"];
+var getDocsConfigTemplate = () => {
+  return [
+    "import { defineDocsConfig } from '@unterberg/nivel/config'",
+    "import { docsGraph } from '../docs/docs.graph'",
+    "",
+    "const docsConfig = defineDocsConfig({",
+    "  graph: docsGraph,",
+    "  siteTitle: 'My Docs',",
+    "  siteDescription: 'Documentation site powered by @unterberg/nivel.',",
+    "  basePath: '/docs',",
+    "})",
+    "",
+    "export default docsConfig",
+    ""
+  ].join("\n");
+};
+var getDocsGraphTemplate = () => {
+  return [
+    "import { defineDocsGraph } from '@unterberg/nivel/config'",
+    "",
+    "export const docsGraph = defineDocsGraph({",
+    "  items: [",
+    "    {",
+    "      kind: 'section',",
+    "      id: 'docs',",
+    "      title: 'Docs',",
+    "      items: [",
+    "        {",
+    "          kind: 'page',",
+    "          id: 'gettingStarted',",
+    "          title: 'Getting Started',",
+    "          slug: 'getting-started',",
+    "          source: 'content/getting-started/content.mdx',",
+    "          description: 'Getting started with @unterberg/nivel.',",
+    "        },",
+    "      ],",
+    "    },",
+    "  ],",
+    "})",
+    ""
+  ].join("\n");
+};
+var getConfigTemplate = () => {
+  return [
+    "import { createNivelVikeConfig } from '@unterberg/nivel/vike'",
+    "import docsConfig from './+docs'",
+    "",
+    "export { config }",
+    "",
+    "const config = createNivelVikeConfig(docsConfig)",
+    ""
+  ].join("\n");
+};
+var getHeadTemplate = () => {
+  return [
+    "import { MetaHead } from '@unterberg/nivel/client'",
+    "",
+    "export const Head = () => {",
+    "  return <MetaHead />",
+    "}",
+    ""
+  ].join("\n");
+};
+var getLayoutTemplate = () => {
+  return [
+    "import { AppLayout } from '@unterberg/nivel/client'",
+    "import type { ReactNode } from 'react'",
+    "",
+    "const Layout = ({ children }: { children: ReactNode }) => {",
+    "  return <AppLayout>{children}</AppLayout>",
+    "}",
+    "",
+    "export default Layout",
+    ""
+  ].join("\n");
+};
+var getGlobalContextTemplate = () => {
+  return [
+    "import { docsGlobalContextData } from './(nivel-generated)/_docsGlobalContext'",
+    "",
+    "export const onCreateGlobalContext = (globalContext: { docs?: typeof docsGlobalContextData }) => {",
+    "  globalContext.docs = docsGlobalContextData",
+    "}",
+    ""
+  ].join("\n");
+};
+var getWrapperTemplate = () => {
+  return [
+    "import type { ReactNode } from 'react'",
+    "",
+    "const Wrapper = ({ children }: { children: ReactNode }) => {",
+    "  return <>{children}</>",
+    "}",
+    "",
+    "export default Wrapper",
+    ""
+  ].join("\n");
+};
+var getGlobalTypesTemplate = () => {
+  return [
+    "declare module '*.mdx' {",
+    "  import type { ComponentType } from 'react'",
+    "",
+    "  const MdxComponent: ComponentType",
+    "  export default MdxComponent",
+    "}",
+    "",
+    "declare module '*.css'",
+    "",
+    "declare global {",
+    "  namespace Vike {",
+    "    interface GlobalContext {",
+    "      docs: import('@unterberg/nivel').DocsGlobalContextData",
+    "    }",
+    "  }",
+    "}",
+    ""
+  ].join("\n");
+};
+var getManagedFileEntries = () => {
+  return [
+    ["pages/+docs.ts", getDocsConfigTemplate()],
+    ["docs/docs.graph.ts", getDocsGraphTemplate()],
+    ["pages/+config.ts", getConfigTemplate()],
+    ["pages/+Head.tsx", getHeadTemplate()],
+    ["pages/+Layout.tsx", getLayoutTemplate()],
+    ["pages/+onCreateGlobalContext.ts", getGlobalContextTemplate()],
+    ["pages/+Wrapper.tsx", getWrapperTemplate()],
+    ["global.d.ts", getGlobalTypesTemplate()]
+  ];
+};
+var getGenerateDocsRunner = (packageJson) => {
+  const packageManager = packageJson.packageManager?.trim() ?? "";
+  if (packageManager.startsWith("pnpm@")) {
+    return "pnpm generate:docs";
+  }
+  if (packageManager.startsWith("npm@")) {
+    return "npm run generate:docs";
+  }
+  return "npm run generate:docs";
+};
+var getManagedScripts = (packageJson) => {
+  const generateDocsRunner = getGenerateDocsRunner(packageJson);
+  return {
+    "generate:docs": "nivel prepare",
+    predev: generateDocsRunner,
+    prebuild: generateDocsRunner,
+    pretypecheck: generateDocsRunner
+  };
+};
+var writeFile = (filePath, source) => {
+  fs2.mkdirSync(path3.dirname(filePath), { recursive: true });
+  fs2.writeFileSync(filePath, source);
+};
+var writeManagedFile = (rootDir, relativeFilePath, source, force, result) => {
+  const filePath = path3.join(rootDir, relativeFilePath);
+  const exists = fs2.existsSync(filePath);
+  if (exists && !force) {
+    result.skippedFiles.push(relativeFilePath);
+    return;
+  }
+  writeFile(filePath, source);
+  if (exists) {
+    result.overwrittenFiles.push(relativeFilePath);
+    return;
+  }
+  result.createdFiles.push(relativeFilePath);
+};
+var readPackageJson = (rootDir) => {
+  const packageJsonPath = path3.join(rootDir, "package.json");
+  if (!fs2.existsSync(packageJsonPath)) {
+    throw new Error(`Expected package.json in ${rootDir}`);
+  }
+  return {
+    packageJson: JSON.parse(fs2.readFileSync(packageJsonPath, "utf8")),
+    packageJsonPath
+  };
+};
+var patchPackageScripts = (packageJson, packageJsonPath, result) => {
+  const scripts = { ...packageJson.scripts ?? {} };
+  const managedScripts = getManagedScripts(packageJson);
+  for (const scriptName of MANAGED_SCRIPT_NAMES) {
+    if (scripts[scriptName] === managedScripts[scriptName]) {
+      continue;
+    }
+    scripts[scriptName] = managedScripts[scriptName];
+    result.updatedScripts.push(scriptName);
+  }
+  const nextPackageJson = {
+    ...packageJson,
+    scripts
+  };
+  fs2.writeFileSync(packageJsonPath, `${JSON.stringify(nextPackageJson, null, 2)}
+`);
+};
+var getMissingDependencies = (packageJson) => {
+  const installed = /* @__PURE__ */ new Set([
+    ...Object.keys(packageJson.dependencies ?? {}),
+    ...Object.keys(packageJson.devDependencies ?? {})
+  ]);
+  return [...REQUIRED_DEPENDENCIES, ...REQUIRED_DEV_DEPENDENCIES].filter((packageName) => !installed.has(packageName));
+};
+var getInitSummary = (result) => {
+  const lines = ["Initialized nivel consumer scaffolding."];
+  if (result.createdFiles.length > 0) {
+    lines.push(`Created files: ${result.createdFiles.join(", ")}`);
+  }
+  if (result.overwrittenFiles.length > 0) {
+    lines.push(`Overwritten files: ${result.overwrittenFiles.join(", ")}`);
+  }
+  if (result.skippedFiles.length > 0) {
+    lines.push(`Skipped existing files: ${result.skippedFiles.join(", ")}`);
+  }
+  if (result.updatedScripts.length > 0) {
+    lines.push(`Updated package.json scripts: ${result.updatedScripts.join(", ")}`);
+  }
+  if (result.missingDependencies.length > 0) {
+    lines.push(`Missing dependencies: ${result.missingDependencies.join(", ")}`);
+    lines.push(
+      "Consumer CSS stays hand-authored. Add your stylesheet import manually, for example in pages/+Wrapper.tsx."
+    );
+  } else if (!result.allDependenciesPresent) {
+    lines.push("Dependency validation completed with warnings.");
+  } else {
+    lines.push("All required dependencies are already present.");
+  }
+  return `${lines.join("\n")}
+`;
+};
+var initConsumer = (options) => {
+  const result = {
+    allDependenciesPresent: true,
+    createdFiles: [],
+    missingDependencies: [],
+    overwrittenFiles: [],
+    skippedFiles: [],
+    updatedScripts: []
+  };
+  const { packageJson, packageJsonPath } = readPackageJson(options.rootDir);
+  for (const [relativeFilePath, source] of getManagedFileEntries()) {
+    writeManagedFile(options.rootDir, relativeFilePath, source, options.force, result);
+  }
+  patchPackageScripts(packageJson, packageJsonPath, result);
+  result.missingDependencies = getMissingDependencies(packageJson);
+  result.allDependenciesPresent = result.missingDependencies.length === 0;
+  return result;
+};
+
+export {
+  getGeneratedPagesRoot,
+  syncGeneratedDocsPages,
+  isDocsSourcePath,
+  loadDocsConfig,
+  getInitSummary,
+  initConsumer
+};
+//# sourceMappingURL=chunk-67GE3PJ6.js.map