@conduction/docusaurus-preset 3.27.2 → 3.28.0

package/README.md

@@ -22,6 +22,7 @@ A few non-negotiables encoded by the package CSS and worth knowing about:
 - **Brand-default footer** — three-column link grid + Conduction-tells (KvK, BTW, address). Per-property override: pass `footer: { links: [...] }` to swap columns and inherit the brand copyright unchanged. Spread `baseFooterLinks()` to keep one or two brand columns alongside site-specific ones.
 - **Sensible defaults** — `trailingSlash`, `onBrokenLinks: 'warn'`, `respectPrefersColorScheme`, dark-mode brand mapping.
 - **AI-crawler baseline** — Organization + WebSite JSON-LD on every page, `SoftwareApplication` JSON-LD from `<DetailHero>`, `FAQPage` JSON-LD from `<FAQ>`, default `og:image` + Twitter card meta, sitemap options, and a `postBuild` plugin that emits `robots.txt` when the site does not ship its own. See the AI baseline section below for the validator and content requirements.
+- **AI content disclosure** — opt-in `ai:` frontmatter key (`generated` / `modified` / `assisted`) renders the official EU Article-50 mark + a factual, no-compliance-claim line at the top of a doc or blog page. See the AI content disclosure section below.
 
 ## Usage
 
@@ -274,6 +275,39 @@ Failure-tolerant: timeouts or 5xx responses log a warning and let the deploy con
 
 Docusaurus defaults to `{Page} | {Site}`, which produces `OpenRegister | OpenRegister` on per-app homepages. Override per page via frontmatter `title:` for now; a `titleFormat` option may land in a future release.
 
+## AI content disclosure (EU AI Act Article 50)
+
+The EU AI Act's transparency tier (Article 50) obliges the discloser of AI-generated or AI-modified content to say so. On 2026-06-10 the European Commission published a set of icons for exactly this purpose, free to use without attribution. This preset vendors those icons and wires a strictly opt-in way to show them on a page.
+
+**Important:** using these icons does **not** by itself establish legal compliance with Article 50, and the Commission asks that non-signatories not use them in a way that implies adherence to the Code of Practice on Transparency of AI-Generated Content. The copy this preset ships states a fact about the page ("This page was generated with AI.") and nothing more — it never asserts compliance or Code-of-Practice adherence. See `static/img/ai-disclosure/PROVENANCE.md` for the icon source, licence, and per-mark meaning.
+
+**Frontmatter usage** — add an `ai:` key to a doc or blog post's frontmatter:
+
+```md
+---
+title: How we generate release notes
+ai: generated
+---
+```
+
+| Value | EU mark | Meaning |
+| --- | --- | --- |
+| `generated` | Fully AI-Generated | Entirely AI-produced, no human-authored elements or editorial control (prompting excluded) |
+| `modified` | Partially AI-Modified | Pre-existing human content partially altered with AI |
+| `assisted` | Basic | AI assisted the work, or a custom/interactive label is used |
+
+The banner renders at the top of the page, above the title. **Omitting `ai:` renders nothing** — there is no site-wide default, no directory inheritance, and no content inference; labelling a human-written page as AI-generated would publish a false authorship claim, which is the exact harm the disclosure regime exists to prevent. A misspelled or empty value (e.g. `ai: genrated`) emits a build-time warning naming the file, the bad value, and the three permitted values, and still renders no banner — it never falls back to a mark.
+
+**Inline MDX usage** — the same component the frontmatter key triggers is also exported directly, for a mark that belongs somewhere other than the page top (for example, beside a single AI-generated figure within an otherwise human-written page):
+
+```mdx
+import { AiDisclosure } from '@conduction/docusaurus-preset/components';
+
+<AiDisclosure kind="modified" />
+```
+
+**Theme-aware** — the mark automatically switches between the Commission's black and white treatments to match the reader's active colour mode, live, with no page reload. **Localised** — copy is available in all four of the preset's locales (nl default, en, de, fr) and renders in the page's active locale.
+
 ## Releasing
 
 Releases auto-publish on push to `main`, driven by [semantic-release](https://semantic-release.gitbook.io/) reading [conventional-commit](https://www.conventionalcommits.org/) messages. The [.github/workflows/publish-packages.yml](../.github/workflows/publish-packages.yml) workflow walks every commit since the last `@conduction/docusaurus-preset-v*` tag and decides what to ship:

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@conduction/docusaurus-preset",
-  "version": "3.27.2",
+  "version": "3.28.0",
   "scripts": {
-    "prepack": "node scripts/prepack-bundle-css.js"
+    "prepack": "node scripts/prepack-bundle-css.js",
+    "test": "node --test"
   },
   "bin": {
     "validate-ai-baseline": "./bin/validate-ai-baseline.mjs"

package/src/components/AiDisclosure/AiDisclosure.jsx

@@ -0,0 +1,82 @@
+/**
+ * <AiDisclosure />
+ *
+ * Renders one of the three official EU Article-50 marks (Basic,
+ * Partially AI-Modified, Fully AI-Generated) plus a short factual
+ * line of copy. This is the single rendering path for the feature:
+ * the `ai` frontmatter key (see the DocItem/Content and
+ * BlogPostItem/Content theme swizzles) resolves to the same component
+ * an author can drop inline in MDX, so the page-top banner and an
+ * inline mark can never drift apart (design.md D1).
+ *
+ * The copy states what happened to the page and stops there - it
+ * does not, and must not, claim EU AI Act compliance or Code-of-
+ * Practice adherence (see disclosure.js COPY and
+ * static/img/ai-disclosure/PROVENANCE.md). Do not hand-edit strings
+ * here; edit the COPY table in ./disclosure.js so the denylist test
+ * covers every value.
+ *
+ * Usage:
+ *
+ *   import { AiDisclosure } from '@conduction/docusaurus-preset/components';
+ *
+ *   <AiDisclosure kind="modified" />
+ *
+ * Props:
+ *   - kind: 'generated' | 'modified' | 'assisted'   (required)
+ *   - className: string
+ *
+ * An unrecognised `kind` warns via console.warn and renders nothing -
+ * it never falls back to a mark (spec: "An unrecognised value fails
+ * loudly and renders nothing").
+ */
+
+import React from 'react';
+import {useColorMode} from '@docusaurus/theme-common';
+import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
+import useBaseUrl from '@docusaurus/useBaseUrl';
+import styles from './AiDisclosure.module.css';
+import {isValidKind, getCopy, getViewBox, getIconPath, AI_KINDS} from './disclosure';
+
+export default function AiDisclosure({kind, className}) {
+  const {colorMode} = useColorMode();
+  const {i18n} = useDocusaurusContext();
+  const locale = (i18n && i18n.currentLocale) || 'en';
+
+  const isKindValid = isValidKind(kind);
+  // Dark-ink mark on light surfaces, light-ink mark on dark surfaces -
+  // the opaque treatments (not the transparent ones) so the mark
+  // reads correctly regardless of what sits behind the banner panel.
+  const treatment = colorMode === 'dark' ? 'white' : 'black';
+  // Served as a plain static file (static/img/ai-disclosure/), not a
+  // webpack `.svg` import - see disclosure.js's ICONS_BASE_PATH
+  // comment for why. useBaseUrl() must run unconditionally (React
+  // hooks rule), so it's called even when kind is invalid; the result
+  // is simply unused in that branch.
+  const iconPath = useBaseUrl(getIconPath(isKindValid ? kind : 'assisted', treatment));
+
+  if (!isKindValid) {
+    if (typeof console !== 'undefined') {
+      console.warn(
+        `[ai-content-disclosure] <AiDisclosure> received an unknown kind ${JSON.stringify(kind)}; ` +
+          `expected one of ${AI_KINDS.join(', ')}. Rendering nothing.`,
+      );
+    }
+    return null;
+  }
+
+  const {width, height} = getViewBox(kind);
+  const copy = getCopy(kind, locale);
+
+  return (
+    <div className={[styles.disclosure, className].filter(Boolean).join(' ')} role="note">
+      <img
+        src={iconPath}
+        alt=""
+        className={styles.mark}
+        style={{aspectRatio: `${width} / ${height}`}}
+      />
+      <p className={styles.copy}>{copy}</p>
+    </div>
+  );
+}

package/src/components/AiDisclosure/AiDisclosure.module.css

@@ -0,0 +1,35 @@
+/**
+ * <AiDisclosure /> styles. A neutral, low-emphasis notice - this is a
+ * factual disclosure, not a call to action, so it carries no KNVB
+ * orange (brand rule: orange is reserved for highlights/CTAs).
+ *
+ * Mark width is capped and height is left to `auto` so the inline
+ * `aspect-ratio` set per-kind in AiDisclosure.jsx (Basic 1:1, the two
+ * word-marks ~3:1) is what actually governs the rendered proportions.
+ */
+
+.disclosure {
+  display: flex;
+  align-items: center;
+  gap: var(--space-4);
+  padding: var(--space-3) var(--space-5);
+  margin: 0 0 var(--space-6);
+  background: var(--c-cobalt-50);
+  border: 1px solid var(--c-cobalt-100);
+  border-radius: var(--radius-md);
+}
+
+.mark {
+  display: block;
+  width: 96px;
+  max-width: 30%;
+  height: auto;
+  flex-shrink: 0;
+}
+
+.copy {
+  margin: 0;
+  font-size: 14px;
+  line-height: 1.5;
+  color: var(--c-cobalt-700);
+}

package/src/components/AiDisclosure/__tests__/AiDisclosure.render.test.js

@@ -0,0 +1,127 @@
+/**
+ * AiDisclosure.render.test.js — renders the real <AiDisclosure> JSX
+ * to static markup and asserts on the output, so a broken import path
+ * or a JSX mistake in AiDisclosure.jsx fails a test instead of only
+ * surfacing the first time a consuming site runs `docusaurus build`.
+ *
+ * Uses the same esbuild-bundle-then-renderToStaticMarkup technique as
+ * ../../../../scripts/build-kit.mjs (Rule 1: copy an existing pattern
+ * rather than inventing new test tooling). Docusaurus-only modules
+ * (`@docusaurus/theme-common`, `@docusaurus/useDocusaurusContext`,
+ * `@docusaurus/useBaseUrl`) are stubbed via esbuild plugins since this
+ * test runs outside an actual Docusaurus build; the useBaseUrl stub
+ * prefixes a fake `/base/` the same way the real hook prefixes a
+ * site's configured baseUrl, so the assertion is "the resolved icon
+ * path for this kind/treatment was passed through base-url
+ * resolution", not a snapshot of a real deployed URL.
+ *
+ * @spec openspec/changes/ai-content-disclosure/tasks.md#task-5.2
+ */
+
+'use strict';
+
+const test = require('node:test');
+const {after} = test;
+const assert = require('node:assert/strict');
+const path = require('node:path');
+const fs = require('node:fs/promises');
+const {build} = require('esbuild');
+const React = require('react');
+const {renderToStaticMarkup} = require('react-dom/server');
+
+const COMPONENT = path.resolve(__dirname, '..', 'AiDisclosure.jsx');
+
+const cssModuleStub = {
+  name: 'css-module-stub',
+  setup(b) {
+    b.onResolve({filter: /\.module\.css$/}, (args) => ({path: args.path, namespace: 'css-stub'}));
+    b.onLoad({filter: /.*/, namespace: 'css-stub'}, () => ({
+      contents: 'export default new Proxy({}, {get: (_, p) => p});',
+      loader: 'js',
+    }));
+  },
+};
+
+function docusaurusStub({colorMode, locale}) {
+  return {
+    name: 'docusaurus-stub',
+    setup(b) {
+      b.onResolve({filter: /^@docusaurus\/theme-common$/}, () => ({path: 'docusaurus-theme-common', namespace: 'docusaurus-stub'}));
+      b.onResolve({filter: /^@docusaurus\/useDocusaurusContext$/}, () => ({path: 'docusaurus-context', namespace: 'docusaurus-stub'}));
+      b.onResolve({filter: /^@docusaurus\/useBaseUrl$/}, () => ({path: 'docusaurus-base-url', namespace: 'docusaurus-stub'}));
+      b.onLoad({filter: /^docusaurus-theme-common$/, namespace: 'docusaurus-stub'}, () => ({
+        contents: `export function useColorMode() { return {colorMode: ${JSON.stringify(colorMode)}}; }`,
+        loader: 'js',
+      }));
+      b.onLoad({filter: /^docusaurus-context$/, namespace: 'docusaurus-stub'}, () => ({
+        contents: `export default function useDocusaurusContext() { return {i18n: {currentLocale: ${JSON.stringify(locale)}}}; }`,
+        loader: 'js',
+      }));
+      // Mirrors the real hook's job: prefix the site's baseUrl onto a
+      // base-relative static path.
+      b.onLoad({filter: /^docusaurus-base-url$/, namespace: 'docusaurus-stub'}, () => ({
+        contents: `export default function useBaseUrl(path) { return "/base/" + path; }`,
+        loader: 'js',
+      }));
+    },
+  };
+}
+
+// Bundle output must live under a directory that can `require('react')`
+// via normal node_modules walk-up (react is `external`, not bundled) -
+// os.tmpdir() has no node_modules ancestor, so we use a scratch dir
+// inside the package instead, mirroring build-kit.mjs's `.tmp-build-kit`.
+const PRESET_ROOT = path.resolve(__dirname, '..', '..', '..', '..');
+
+async function renderAiDisclosure(props, {colorMode = 'light', locale = 'en'} = {}) {
+  const scratchRoot = path.join(PRESET_ROOT, '.tmp-ai-disclosure-test');
+  await fs.mkdir(scratchRoot, {recursive: true});
+  const tmpDir = await fs.mkdtemp(path.join(scratchRoot, 'run-'));
+  const outFile = path.join(tmpDir, 'bundle.cjs');
+  try {
+    await build({
+      entryPoints: [COMPONENT],
+      outfile: outFile,
+      bundle: true,
+      format: 'cjs',
+      jsx: 'automatic',
+      jsxImportSource: 'react',
+      tsconfigRaw: {compilerOptions: {jsx: 'react-jsx', jsxImportSource: 'react'}},
+      platform: 'node',
+      external: ['react'],
+      plugins: [cssModuleStub, docusaurusStub({colorMode, locale})],
+      logLevel: 'warning',
+    });
+    delete require.cache[require.resolve(outFile)];
+    const mod = require(outFile);
+    const Component = mod.default;
+    return renderToStaticMarkup(React.createElement(Component, props));
+  } finally {
+    await fs.rm(tmpDir, {recursive: true, force: true});
+  }
+}
+
+test('renders the generated mark + English copy in light mode', async () => {
+  const html = await renderAiDisclosure({kind: 'generated'}, {colorMode: 'light', locale: 'en'});
+  assert.match(html, /\/base\/img\/ai-disclosure\/ai-generated-black\.svg/);
+  assert.match(html, /This page was generated with AI\./);
+});
+
+test('renders the white (light-ink-on-dark) treatment in dark mode', async () => {
+  const html = await renderAiDisclosure({kind: 'modified'}, {colorMode: 'dark', locale: 'en'});
+  assert.match(html, /\/base\/img\/ai-disclosure\/ai-modified-white\.svg/);
+});
+
+test('renders Dutch copy when the active locale is nl', async () => {
+  const html = await renderAiDisclosure({kind: 'assisted'}, {colorMode: 'light', locale: 'nl'});
+  assert.match(html, /Deze pagina is geschreven met hulp van AI\./);
+});
+
+test('renders nothing for an unrecognised kind', async () => {
+  const html = await renderAiDisclosure({kind: 'basic'}, {colorMode: 'light', locale: 'en'});
+  assert.equal(html, '');
+});
+
+after(async () => {
+  await fs.rm(path.join(PRESET_ROOT, '.tmp-ai-disclosure-test'), {recursive: true, force: true});
+});

package/src/components/AiDisclosure/__tests__/disclosure.test.js

@@ -0,0 +1,218 @@
+/**
+ * disclosure.test.js — unit tests for the ai-content-disclosure
+ * resolver, asset mapping, locale coverage, and no-compliance-claim
+ * copy denylist.
+ *
+ * Runs on Node's built-in test runner (no bundler, no React needed -
+ * see disclosure.js's header for why the pure logic lives apart from
+ * the JSX component). Run with `npm test` from docusaurus-preset/, or
+ * `node --test src` from the same directory.
+ *
+ * @spec openspec/changes/ai-content-disclosure/tasks.md#task-5.1
+ * @spec openspec/changes/ai-content-disclosure/tasks.md#task-5.2
+ * @spec openspec/changes/ai-content-disclosure/tasks.md#task-5.3
+ * @spec openspec/changes/ai-content-disclosure/tasks.md#task-5.4
+ */
+
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const {
+  AI_KINDS,
+  LOCALES,
+  VIEWBOX,
+  ICONS_BASE_PATH,
+  isValidKind,
+  resolveAiFrontmatter,
+  getIconFilename,
+  getIconPath,
+  getViewBox,
+  getCopy,
+} = require('../disclosure');
+
+// Icons are vendored as plain static files (not a webpack `.svg`
+// import - see disclosure.js's ICONS_BASE_PATH comment) so the tests
+// resolve them against static/img/ai-disclosure/ directly.
+const ICONS_DIR = path.resolve(__dirname, '..', '..', '..', '..', 'static', 'img', 'ai-disclosure');
+
+// -- 5.1: frontmatter resolver -- present / absent / misspelled / empty --
+
+test('resolver: present and valid resolves to the kind, no warning', () => {
+  for (const kind of AI_KINDS) {
+    const {kind: resolved, warning} = resolveAiFrontmatter(kind, 'docs/foo.md');
+    assert.equal(resolved, kind);
+    assert.equal(warning, null);
+  }
+});
+
+test('resolver: absent key resolves to no kind and no warning', () => {
+  const {kind, warning} = resolveAiFrontmatter(undefined, 'docs/foo.md');
+  assert.equal(kind, null);
+  assert.equal(warning, null);
+});
+
+test('resolver: misspelled value resolves to no kind and warns, naming file/value/permitted', () => {
+  const {kind, warning} = resolveAiFrontmatter('genrated', 'docs/foo.md');
+  assert.equal(kind, null);
+  assert.match(warning, /docs\/foo\.md/);
+  assert.match(warning, /genrated/);
+  for (const permitted of AI_KINDS) {
+    assert.match(warning, new RegExp(permitted));
+  }
+});
+
+test('resolver: empty value resolves to no kind and warns', () => {
+  const {kind, warning} = resolveAiFrontmatter('', 'docs/foo.md');
+  assert.equal(kind, null);
+  assert.ok(warning);
+  assert.match(warning, /docs\/foo\.md/);
+});
+
+test('resolver: never falls back to a mark for an unrecognised value', () => {
+  const {kind} = resolveAiFrontmatter('fully-generated', 'docs/foo.md');
+  assert.notEqual(kind, 'generated');
+  assert.equal(kind, null);
+});
+
+// -- 5.2: kind -> vendored-asset mapping + preserved aspect ratio --
+
+test('mapping: generated maps to an ai-generated-* asset', () => {
+  assert.equal(getIconFilename('generated', 'black'), 'ai-generated-black.svg');
+  assert.equal(getIconFilename('generated', 'white'), 'ai-generated-white.svg');
+});
+
+test('mapping: modified maps to an ai-modified-* asset', () => {
+  assert.equal(getIconFilename('modified', 'black'), 'ai-modified-black.svg');
+});
+
+test('mapping: assisted maps to the basic mark (neither ai-generated-* nor ai-modified-*)', () => {
+  const filename = getIconFilename('assisted', 'black');
+  assert.equal(filename, 'ai-black.svg');
+  assert.doesNotMatch(filename, /^ai-generated-/);
+  assert.doesNotMatch(filename, /^ai-modified-/);
+});
+
+test('mapping: every kind x treatment resolves to a file that actually exists on disk', () => {
+  const treatments = ['black', 'white', 'black-transparent', 'white-transparent'];
+  for (const kind of AI_KINDS) {
+    for (const treatment of treatments) {
+      const filename = getIconFilename(kind, treatment);
+      const filePath = path.join(ICONS_DIR, filename);
+      assert.ok(fs.existsSync(filePath), `expected vendored asset at ${filePath}`);
+    }
+  }
+});
+
+test('mapping: getIconPath is base-relative (no leading slash) so useBaseUrl can prefix it', () => {
+  const p = getIconPath('generated', 'black');
+  assert.equal(p, `${ICONS_BASE_PATH}/ai-generated-black.svg`);
+  assert.ok(!p.startsWith('/'));
+});
+
+test('aspect ratio: getViewBox matches the vendored SVG viewBox within 1% tolerance', () => {
+  for (const kind of AI_KINDS) {
+    const filename = getIconFilename(kind, 'black');
+    const svg = fs.readFileSync(path.join(ICONS_DIR, filename), 'utf8');
+    const match = svg.match(/viewBox="0 0 ([\d.]+) ([\d.]+)"/);
+    assert.ok(match, `${filename} has no parseable viewBox`);
+    const sourceRatio = Number(match[1]) / Number(match[2]);
+    const {width, height} = getViewBox(kind);
+    const declaredRatio = width / height;
+    const tolerance = sourceRatio * 0.01;
+    assert.ok(
+      Math.abs(sourceRatio - declaredRatio) <= tolerance,
+      `${kind}: source ratio ${sourceRatio} vs declared ${declaredRatio} (VIEWBOX=${JSON.stringify(VIEWBOX[kind])})`,
+    );
+  }
+});
+
+test('aspect ratio: the three marks are not forced into a uniform box', () => {
+  const ratios = AI_KINDS.map((kind) => {
+    const {width, height} = getViewBox(kind);
+    return width / height;
+  });
+  assert.ok(new Set(ratios.map((r) => r.toFixed(3))).size > 1, 'expected differing ratios across marks');
+});
+
+// -- 5.3: locale coverage --
+
+test('locale coverage: nl, en, de, fr all present, nl is the default', () => {
+  assert.deepEqual(new Set(LOCALES), new Set(['nl', 'en', 'de', 'fr']));
+});
+
+test('locale coverage: every locale has distinct, non-empty copy for all three kinds', () => {
+  for (const locale of LOCALES) {
+    const strings = AI_KINDS.map((kind) => getCopy(kind, locale));
+    for (const [i, s] of strings.entries()) {
+      assert.ok(typeof s === 'string' && s.trim().length > 0, `${locale}/${AI_KINDS[i]} missing or empty`);
+    }
+    assert.equal(new Set(strings).size, strings.length, `${locale}: two kinds share one string`);
+  }
+});
+
+test('locale coverage: no locale silently falls back to another locale\'s string', () => {
+  const seenAcrossLocales = new Map();
+  for (const locale of LOCALES) {
+    for (const kind of AI_KINDS) {
+      const s = getCopy(kind, locale);
+      const key = `${kind}:${s}`;
+      if (locale !== 'nl') {
+        // Same (kind, string) pair appearing under two different
+        // locales would mean one locale leaked another's copy.
+        assert.ok(!seenAcrossLocales.has(key) || seenAcrossLocales.get(key) === locale, `duplicate string across locales for ${key}`);
+      }
+      seenAcrossLocales.set(key, locale);
+    }
+  }
+});
+
+// -- 5.4: no compliance / Code-of-Practice claim, in any locale --
+
+const COMPLIANCE_DENYLIST = [
+  /compliant/i,
+  /compliance/i,
+  /conform/i,
+  /voldoet aan/i,
+  /naleving/i,
+  /in accordance with the ai act/i,
+  /in Übereinstimmung mit/i,
+  /conforme (à|au|aux)/i,
+  /code of practice/i,
+  /gedragscode/i,
+  /code de bonne pratique/i,
+  /verhaltenskodex/i,
+  /signatory/i,
+  /signataire/i,
+  /unterzeichner/i,
+];
+
+test('copy: no locale/kind combination contains a compliance or Code-of-Practice claim', () => {
+  const offenders = [];
+  for (const locale of LOCALES) {
+    for (const kind of AI_KINDS) {
+      const text = getCopy(kind, locale);
+      for (const pattern of COMPLIANCE_DENYLIST) {
+        if (pattern.test(text)) {
+          offenders.push(`${locale}/${kind}: "${text}" matched ${pattern}`);
+        }
+      }
+    }
+  }
+  assert.deepEqual(offenders, []);
+});
+
+// -- isValidKind guard used by the component for both frontmatter and inline props --
+
+test('isValidKind rejects anything outside the three permitted values', () => {
+  assert.equal(isValidKind('generated'), true);
+  assert.equal(isValidKind('modified'), true);
+  assert.equal(isValidKind('assisted'), true);
+  assert.equal(isValidKind('basic'), false);
+  assert.equal(isValidKind(''), false);
+  assert.equal(isValidKind(undefined), false);
+  assert.equal(isValidKind(null), false);
+});