fixup!

Author: avivkeller

src/generators/jsx-ast/utils/buildContent.mjs

@@ -9,7 +9,7 @@ import { SKIP, visit } from 'unist-util-visit';
 import { createJSXElement } from './ast.mjs';
 import { extractHeadings, extractTextContent } from './buildBarProps.mjs';
 import { enforceArray } from '../../../utils/array.mjs';
-import { extractPrimitives } from '../../../utils/misc.mjs';
+import { omitKeys } from '../../../utils/misc.mjs';
 import { JSX_IMPORTS } from '../../web/constants.mjs';
 import {
   STABILITY_LEVELS,
@@ -296,7 +296,8 @@ export const createDocumentLayout = (entries, metadata) =>
  * @returns {Promise<JSXContent>}
  */
 const buildContent = async (metadataEntries, head) => {
-  const metadata = extractPrimitives(head);
+  // The metadata is the heading without the node children
+  const metadata = omitKeys(head, ['content', 'heading', 'stability']);
 
   // Create root document AST with all layout components and processed content
   const root = createDocumentLayout(metadataEntries, metadata);

src/generators/web/types.d.ts

@@ -1,11 +1,13 @@
 import type { JSXContent } from '../jsx-ast/utils/buildContent.mjs';
 
+export type Configuration = {
+  templatePath: string;
+  title: string;
+  imports: Record<string, string>;
+  virtualImports: Record<string, string>;
+};
+
 export type Generator = GeneratorMetadata<
-  {
-    templatePath: string;
-    title: string;
-    imports: Record<string, string>;
-    virtualImports: Record<string, string>;
-  },
+  Configuration,
   Generate<Array<JSXContent>, AsyncGenerator<{ html: string; css: string }>>
 >;

src/generators/web/ui/types.d.ts

@@ -1,13 +1,27 @@
+import { GlobalConfiguration } from '../../../utils/configuration/types';
 import { MetadataEntry } from '../../metadata/types';
+import { Configuration } from '../types';
 
 declare global {
   const SERVER: boolean;
   const CLIENT: boolean;
 }
 
 declare module '#theme/config' {
-  export const title: string;
-  export const repository: string;
+  // From global configuration
+  export const repository: GlobalConfiguration['repository'];
+  export const input: GlobalConfiguration['input'];
+  export const ignore: GlobalConfiguration['ignore'];
+  export const output: GlobalConfiguration['output'];
+  export const minify: GlobalConfiguration['minify'];
+  export const baseURL: GlobalConfiguration['baseURL'];
+  export const ref: GlobalConfiguration['ref'];
+
+  // From web configuration
+  export const templatePath: Configuration['templatePath'];
+  export const title: Configuration['title'];
+
+  // From config generation
   export const version: string;
   export const versions: Array<{
     url: string;
@@ -16,7 +30,7 @@ declare module '#theme/config' {
   }>;
   export const editURL: string;
   export const pages: Array<[string, string]>;
-  export const languageDisplayNameMap: Map<string, string>;
+  export const languageDisplayNameMap: Map<string[], string>;
 }
 
 // Omit Primitives from Metadata

src/generators/web/utils/config.mjs

@@ -5,6 +5,7 @@ import { LANGS } from '@node-core/rehype-shiki';
 import getConfig from '../../../utils/configuration/index.mjs';
 import { populate } from '../../../utils/configuration/templates.mjs';
 import { getVersionFromSemVer } from '../../../utils/generators.mjs';
+import { omitKeys } from '../../../utils/misc.mjs';
 import { getSortedHeadNodes } from '../../jsx-ast/utils/getSortedHeadNodes.mjs';
 
 /**
@@ -79,10 +80,10 @@ export default function createConfigSource(input) {
   const pageURL = populate(config.pageURL, config);
 
   const exports = {
-    ...Object.fromEntries(
-      Object.entries(config).filter(
-        ([, v]) => v === null || typeof v !== 'object'
-      )
+    ...omitKeys(
+      config,
+      // These are keys that are large, and not needed by components, so we ignore them
+      ['changelog', 'index', 'imports', 'virtualImport']
     ),
     version,
     versions: buildVersionEntries(config.changelog, pageURL),

src/utils/__tests__/misc.test.mjs

@@ -3,7 +3,7 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
 
-import { lazy, isPlainObject, extractPrimitives, deepMerge } from '../misc.mjs';
+import { lazy, isPlainObject, omitKeys, deepMerge } from '../misc.mjs';
 
 describe('lazy', () => {
   it('should call the function only once and cache the result', () => {
@@ -38,52 +38,31 @@ describe('isPlainObject', () => {
   });
 });
 
-describe('extractPrimitives', () => {
-  it('should keep string, number, boolean, and null values', () => {
-    const obj = { a: 'hello', b: 42, c: true, d: null };
-    assert.deepStrictEqual(extractPrimitives(obj), {
-      a: 'hello',
-      b: 42,
-      c: true,
-      d: null,
-    });
-  });
-
-  it('should remove object and function values', () => {
-    const obj = {
-      name: 'test',
-      nested: { foo: 'bar' },
-      fn: () => {},
-      count: 5,
-    };
-    const result = extractPrimitives(obj);
-    assert.deepStrictEqual(result, { name: 'test', count: 5 });
+describe('omitKeys', () => {
+  it('should return all properties when no keys are excluded', () => {
+    const obj = { a: 'hello', b: 42, c: true };
+    assert.deepStrictEqual(omitKeys(obj), { a: 'hello', b: 42, c: true });
   });
 
-  it('should keep arrays of primitives', () => {
-    const obj = { tags: ['a', 'b'], name: 'test' };
-    assert.deepStrictEqual(extractPrimitives(obj), {
-      tags: ['a', 'b'],
-      name: 'test',
-    });
+  it('should omit specified keys', () => {
+    const obj = { a: 1, b: 2, c: 3 };
+    assert.deepStrictEqual(omitKeys(obj, ['a', 'c']), { b: 2 });
   });
 
-  it('should remove arrays containing objects', () => {
-    const obj = { items: [{ id: 1 }], name: 'test' };
-    assert.deepStrictEqual(extractPrimitives(obj), { name: 'test' });
+  it('should ignore keys that do not exist', () => {
+    const obj = { a: 1, b: 2 };
+    assert.deepStrictEqual(omitKeys(obj, ['z']), { a: 1, b: 2 });
   });
 
-  it('should keep undefined values', () => {
-    const obj = { a: undefined, b: 'yes' };
-    const result = extractPrimitives(obj);
-    assert.strictEqual('a' in result, true);
-    assert.strictEqual(result.a, undefined);
-    assert.strictEqual(result.b, 'yes');
+  it('should return an empty object when all keys are excluded', () => {
+    const obj = { a: 1, b: 2 };
+    assert.deepStrictEqual(omitKeys(obj, ['a', 'b']), {});
   });
 
-  it('should return an empty object when all values are non-primitive', () => {
-    const obj = { a: {}, b: [{ x: 1 }], c: () => {} };
-    assert.deepStrictEqual(extractPrimitives(obj), {});
+  it('should preserve any value type', () => {
+    const fn = () => {};
+    const obj = { a: fn, b: new Map(), c: null, d: [1, 2] };
+    assert.deepStrictEqual(omitKeys(obj, ['b']), { a: fn, c: null, d: [1, 2] });
   });
 });
 

src/utils/misc.mjs

@@ -20,15 +20,14 @@ export const isPlainObject = value =>
   value !== null && typeof value === 'object' && !Array.isArray(value);
 
 /**
- * Extracts all the primitives from an object
+ * Returns a shallow copy of `obj` without the specified keys.
+ * @param {Record<string, any>} obj
+ * @param {string[]} keys - Keys to exclude
+ * @returns {Record<string, any>}
  */
-export const extractPrimitives = obj =>
+export const omitKeys = (obj, keys = []) =>
   Object.fromEntries(
-    Object.entries(obj).filter(
-      ([, value]) =>
-        value !== Object(value) ||
-        (Array.isArray(value) && value.every(item => item !== Object(item)))
-    )
+    Object.entries(obj).filter(([key]) => !keys.includes(key))
   );
 
 /**