@apleasantview/eleventy-plugin-baseline 0.1.0-next.32 → 0.1.0-next.39

package/modules/multilang/index.js

@@ -0,0 +1,149 @@
+import { I18nPlugin } from '@11ty/eleventy';
+import { DeepCopy } from '@11ty/eleventy-utils';
+import { normalizeLanguages } from '../../core/utils/helpers.js';
+import i18nTranslationsFor from './filters/i18n-translations-for.js';
+import i18nTranslationIn from './filters/i18n-translation-in.js';
+import i18nDefaultTranslation from './filters/i18n-default-translation.js';
+
+/**
+ * Multilang (module)
+ *
+ * Language infrastructure. Normalises language config, builds translation
+ * relationships, attaches per-page locale data, and exposes cross-language
+ * lookup filters. Active only when options.multilingual is true and both
+ * defaultLanguage and at least one languages entry are set; otherwise the
+ * module exits early.
+ *
+ * Architecture layer:
+ *   module
+ *
+ * System role:
+ *   Wraps Eleventy's I18nPlugin and feeds the translation-map store that
+ *   head reads at transform-time. Sitemap reuses the same normalised
+ *   language map.
+ *
+ * Lifecycle:
+ *   build-time   → normalise languages, attach I18nPlugin, register filters
+ *                  and computed page.locale
+ *   cascade-time → translationsMap and translations collections build the
+ *                  per-translationKey map and write it to the store
+ *
+ * Why this exists:
+ *   I18nPlugin handles locale-aware routing but not translation
+ *   relationships. Head needs a transform-time-readable hreflang map; the
+ *   collection populates it once and the store carries it across the
+ *   lifecycle boundary.
+ *
+ * Scope:
+ *   Owns language normalisation, page.locale computation, the translations
+ *   and translationsMap collections, and the i18n filters
+ *   (i18nTranslationsFor, i18nTranslationIn, i18nDefaultTranslation).
+ *   Does not own URL routing (I18nPlugin) or hreflang rendering (head).
+ *
+ * Data flow:
+ *   settings.languages + page.lang/translationKey → normalisation +
+ *   I18nPlugin → collections + computed page.locale + translation-map
+ *   store → head, sitemap
+ *
+ * @param {import("@11ty/eleventy/src/UserConfig.js").default} eleventyConfig
+ * @param {Object} moduleContext
+ */
+export function multilangCore(eleventyConfig, moduleContext) {
+	const { state, runtime, log } = moduleContext;
+	const { settings, options } = state;
+
+	// --- Language normalization ---
+	// Accept languages as array or object; normalize to object map.
+	// Drives collection building, locale data, and sitemap-core language config.
+	const normalizeLanguageCode = (lang) => (lang || '').toLowerCase().trim();
+	const defaultLanguage = normalizeLanguageCode(settings.defaultLanguage);
+	const languages = normalizeLanguages(settings, log);
+	const hasLanguages = languages && Object.keys(languages).length > 0;
+
+	const isMultilingual = options.multilang === true && defaultLanguage && hasLanguages;
+
+	if (!isMultilingual) {
+		log.info('inactive: requires options.multilingual + settings.defaultLanguage + languages');
+		return;
+	}
+
+	// Register Eleventy's built-in I18nPlugin for locale-aware URL resolution.
+	eleventyConfig.addPlugin(I18nPlugin, {
+		defaultLanguage: defaultLanguage,
+		errorMode: 'allow-fallback'
+	});
+
+	// Computed locale data: every page gets a page.locale object with its
+	// resolved lang, translationKey, and whether it's the default language.
+	eleventyConfig.addGlobalData('eleventyComputed.page.locale', () => {
+		return (data) => {
+			const translationKey = data.translationKey;
+			const lang = normalizeLanguageCode(data.lang || data.language || defaultLanguage);
+			const isDefaultLang = lang === defaultLanguage;
+
+			return {
+				translationKey,
+				lang,
+				isDefaultLang
+			};
+		};
+	});
+
+	// Build a set of allowed language codes for validation during collection building.
+	const allowedLanguages = new Set(Object.keys(languages).map(normalizeLanguageCode));
+
+	// Build both the map (keyed by translationKey → lang) and the flat list.
+	// Shared logic for both collections — called once per collection registration.
+	const buildTranslations = (collection) => {
+		const map = {};
+		const list = [];
+
+		for (const page of collection.getAll()) {
+			const translationKey = page.data.translationKey;
+			if (!translationKey) continue;
+
+			const lang = page.data.lang || page.data.language || defaultLanguage;
+			if (!lang) continue;
+
+			if (allowedLanguages.size && !allowedLanguages.has(lang)) {
+				log.info(`Unknown lang "${lang}" in ${page.inputPath}`);
+				continue;
+			}
+
+			const locale = { locale: { translationKey, lang, isDefaultLang: lang === defaultLanguage } };
+			const safeCopy = DeepCopy(page, locale);
+			list.push(safeCopy);
+
+			if (!map[translationKey]) map[translationKey] = {};
+			map[translationKey][lang] = {
+				title: page.data.title,
+				url: page.url,
+				lang,
+				isDefaultLang: lang === defaultLanguage,
+				data: page.data
+			};
+		}
+
+		return { map, list };
+	};
+
+	// --- Collections ---
+
+	// Map form: translationsMap[translationKey][lang] → page metadata.
+	eleventyConfig.addCollection('translationsMap', (collection) => {
+		const map = buildTranslations(collection).map;
+		runtime.translationMap.set(map);
+		return map;
+	});
+
+	// Flat list: all translatable pages with locale data attached.
+	eleventyConfig.addCollection('translations', (collection) => {
+		return buildTranslations(collection).list;
+	});
+
+	// --- Filters ---
+	// Relational helpers for cross-language lookups in templates.
+	eleventyConfig.addFilter('i18nTranslationsFor', i18nTranslationsFor);
+	eleventyConfig.addFilter('i18nTranslationIn', i18nTranslationIn);
+	eleventyConfig.addFilter('i18nDefaultTranslation', i18nDefaultTranslation);
+}

package/modules/navigator/index.js

@@ -0,0 +1,140 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import debug from './utils/debug.js';
+import { optionsSchema } from './schema.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Navigator (module)
+ *
+ * Debug surface. Exposes Eleventy and Baseline runtime state to templates so
+ * developers can inspect data shape, scope contents, and lifecycle output
+ * without leaving the page.
+ *
+ * Architecture layer:
+ *   module
+ *
+ * System role:
+ *   Read-only window into the runtime substrate. Pulls snapshots from the
+ *   page-context registry and content-map store via the module context;
+ *   does not write back.
+ *
+ * Lifecycle:
+ *   build-time   → register Nunjucks globals, debug filters, and the
+ *                  optional virtual debug page
+ *   cascade-time → eleventyComputed `_snapshot` resolves contentMap and
+ *                  pageContext on each page
+ *
+ * Why this exists:
+ *   Render-time inspection of cascade state has no built-in surface.
+ *   Centralising globals and filters under a debug-only module keeps the
+ *   inspection vocabulary stable and out of feature modules.
+ *
+ * Scope:
+ *   Owns the `_runtime` and `_ctx` Nunjucks globals, computed `_snapshot`,
+ *   debug filters (`_inspect`, `_json`, `_keys`), and the optional virtual
+ *   page at /navigator-core.html.
+ *   Does not own the data it surfaces (page-context registry, content-map
+ *   store).
+ *
+ * Data flow:
+ *   snapshots (contentMap, pageContext) + this.ctx → globals + computed
+ *   `_snapshot` + virtual page → developer
+ *
+ * Note: `_snapshot.contentMap` is null on the navigator template itself
+ * because it renders before `eleventy.contentMap` fires. Read `_snapshot`
+ * from any ordinary page for a populated contentMap.
+ *
+ * @param {import("@11ty/eleventy").UserConfig} eleventyConfig
+ * @param {Object} moduleContext
+ * @param {Object} moduleContext.state - Resolved plugin state.
+ * @param {Object} moduleContext.snapshots - Thunks: { contentMap, pageContext }.
+ */
+export function navigatorCore(eleventyConfig, moduleContext) {
+	const { state, snapshots, log, env } = moduleContext;
+	const { settings, options } = state;
+
+	// Structural-only options check: log on mismatch, do not throw.
+	const parsed = optionsSchema.safeParse(options.navigator);
+	if (!parsed.success) {
+		for (const issue of parsed.error.issues) {
+			log.info('options:', `${issue.path.join('.')} — ${issue.message}`);
+		}
+	}
+
+	// Boolean shorthand activates the virtual page; object form lets users tune.
+	const navigatorOpts = options.navigator && typeof options.navigator === 'object' ? options.navigator : {};
+	const renderTemplate = env.mode === 'development' ?? navigatorOpts.template ?? Boolean(options.navigator);
+	const inspectorDepth = navigatorOpts.inspectorDepth ?? 4;
+
+	eleventyConfig.addGlobalData('eleventyComputed._snapshot', () => {
+		return () => ({
+			contentMap: snapshots.contentMap(),
+			pageContext: snapshots.pageContext()
+		});
+	});
+
+	/**
+	 * Nunjucks Global: _runtime
+	 *
+	 * Exposes internal Nunjucks runtime state:
+	 * - env  → environment instance
+	 * - ctx  → current render context
+	 * - globals → registered global values
+	 */
+	eleventyConfig.addNunjucksGlobal('_runtime', function () {
+		return {
+			env: this.env,
+			ctx: this.ctx,
+			globals: this.env?.globals
+		};
+	});
+
+	/**
+	 * Nunjucks Global: _ctx
+	 *
+	 * Direct reference to the template execution context.
+	 * Useful for debugging data shape at render time.
+	 */
+	eleventyConfig.addNunjucksGlobal('_ctx', function () {
+		return this.ctx;
+	});
+
+	/**
+	 * Virtual Debug Template
+	 *
+	 * Registers a synthetic Eleventy page that dumps runtime context.
+	 * This is only enabled when explicitly configured via options.
+	 */
+	if (renderTemplate) {
+		const templatePath = path.join(__dirname, './templates/navigator-core.html');
+		const virtualTemplateContent = fs.readFileSync(templatePath, 'utf-8');
+
+		eleventyConfig.addTemplate('navigator-core.html', virtualTemplateContent, {
+			permalink: '/navigator-core.html',
+			title: 'Navigator Core',
+			description: 'Eleventy + Baseline internals',
+			layout: null,
+			eleventyExcludeFromCollections: true,
+			_internal: false,
+
+			// Debug control surface
+			inspectorDepth
+		});
+
+		log.info('Navigator template registered at /navigator-core.html');
+	}
+
+	/**
+	 * Debug Filters
+	 *
+	 * Lightweight helpers for inspecting values in templates.
+	 * These are intentionally prefixed to avoid collisions.
+	 */
+	eleventyConfig.addFilter('_inspect', debug.inspect);
+	eleventyConfig.addFilter('_json', debug.json);
+	eleventyConfig.addFilter('_keys', debug.keys);
+}

package/modules/navigator/schema.js

@@ -0,0 +1,13 @@
+import * as z from 'zod';
+
+// Structural schema for the `options.navigator` slice. Accepts boolean
+// shorthand or object form; permissive on unknown keys, typed on the keys
+// the module reads. Non-throwing at the call site.
+
+export const optionsSchema = z.union([
+	z.boolean(),
+	z.looseObject({
+		template: z.boolean().optional(),
+		inspectorDepth: z.number().int().min(0).optional()
+	})
+]).optional();

package/modules/{navigator-core → navigator}/templates/navigator-core.html

@@ -4,7 +4,7 @@ permalink: /navigator-core.html
 ---
 
 <!DOCTYPE html>
-<html lang="{{ lang | default(site.defaultLanguage) }}">
+<html lang="{{ lang | default(settings.defaultLanguage) }}">
 
 <head>
 	<baseline-head></baseline-head>
@@ -28,9 +28,9 @@ permalink: /navigator-core.html
 	</a>
 	<header>
 		<div class="_navigator__wrapper">
-			<h1>{{ site.title }} Navigator</h1>
+			<h1>{{ settings.title }} Navigator</h1>
 			<div>
-				<p>{{ site.tagline }}</p>
+				<p>{{ settings.tagline }}</p>
 			</div>
 		</div>
 	</header>
@@ -38,11 +38,17 @@ permalink: /navigator-core.html
 		<div class="_navigator__wrapper">
 			<p><a id="go-back" href=""><span style="vertical-align: text-bottom;">&#8592;</span>&nbsp;Go back</a></p>
 			<h2><u>Navigator</u></h2>
-			{% for key, value in _navigator() %}
+			<details>
+				<summary><strong>Page Context</strong></summary>
+				<pre>
+					{{- _snapshot.pageContext | _inspect({ depth: null }) -}}
+				</pre>
+			</details>
+			{% for key, value in _runtime() %}
 			<details>
 				<summary><strong>{{ key }}</strong></summary>
 				{% if value | isString %}
-				<pre>{{ value | safe }}</pre>
+				<pre>{{ value }}</pre>
 				{% else %}
 				<pre>{{ value | _inspect({ depth: inspectorDepth }) }}</pre>
 				{% endif %}
@@ -56,9 +62,9 @@ permalink: /navigator-core.html
 			history.back();
 		});
 	</script>
+	<footer>
+		<div class="_navigator__wrapper"><small>Navigator Core — Eleventy Plugin Baseline</small></div>
+	</footer>
 </body>
-<footer>
-	<div class="_navigator__wrapper"><small>Navigator Core — Eleventy Plugin Baseline</small></div>
-</footer>
 
 </html>

package/modules/navigator/utils/debug.js

@@ -0,0 +1,41 @@
+import { inspect as utilInspect } from 'node:util';
+
+// Adapted from pdehaan - https://github.com/pdehaan/eleventy-plugin-debug
+const debugOptions = { space: 0 };
+
+/**
+ * Pretty-print an object using Node's util.inspect.
+ * @param {*} obj - Value to inspect.
+ * @param {Object} [options={}] - Options forwarded to util.inspect.
+ * @returns {string}
+ */
+function inspect(obj, options = {}) {
+	return utilInspect(obj, {
+		depth: 4,
+		maxArrayLength: 10,
+		breakLength: 80,
+		compact: true,
+		...options
+	});
+}
+
+/**
+ * Serialize an object to JSON.
+ * @param {*} obj - Value to serialize.
+ * @param {number} [space] - Indentation level (default 0, compact).
+ * @returns {string}
+ */
+function json(obj, space = debugOptions.space) {
+	return JSON.stringify(obj, null, space);
+}
+
+/**
+ * Return an object's own keys, sorted alphabetically.
+ * @param {Object} obj
+ * @returns {string[]}
+ */
+function keys(obj) {
+	return Object.keys(obj).sort();
+}
+
+export default { inspect, json, keys };

package/modules/sitemap/index.js

@@ -0,0 +1,121 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { normalizeLanguages } from '../../core/utils/helpers.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * Sitemap (module)
+ *
+ * Sitemap generation and per-page sitemap metadata. Layers on Eleventy
+ * collections rather than rendering independently. In multilingual mode it
+ * partitions per-language sitemaps and emits a sitemap index; otherwise it
+ * emits a single flat sitemap.
+ *
+ * Architecture layer:
+ *   module
+ *
+ * System role:
+ *   Reads the same normalised language map as multilang (via
+ *   core/utils/helpers.js) and emits virtual templates that Eleventy
+ *   renders to XML. Pages opt out via `noindex` in the cascade.
+ *
+ * Lifecycle:
+ *   build-time   → register virtual sitemap templates (single, per-lang,
+ *                  or index)
+ *   cascade-time → eleventyComputed `page.sitemap` resolves ignore /
+ *                  changefreq / priority on each page
+ *
+ * Why this exists:
+ *   Eleventy has no built-in sitemap. Multilingual sites also need
+ *   partitioning plus an index, which only makes sense once language config
+ *   is normalised the same way multilang sees it.
+ *
+ * Scope:
+ *   Owns computed page.sitemap and the virtual sitemap templates
+ *   (single-language /sitemap.xml, or per-lang /{lang}/sitemap.xml plus a
+ *   /sitemap.xml index).
+ *   Does not own language normalisation (core/utils/helpers.js) or noindex
+ *   propagation through the cascade.
+ *
+ * Data flow:
+ *   settings.languages + page data → computed page.sitemap + virtual
+ *   templates → /sitemap.xml or per-language + index
+ *
+ * @param {import("@11ty/eleventy").UserConfig} eleventyConfig
+ * @param {Object} moduleContext
+ */
+export function sitemapCore(eleventyConfig, moduleContext) {
+	const { state, log } = moduleContext;
+	const { settings, options } = state;
+
+	// --- Language normalization ---
+	// Accept languages as array or object; normalize to object map.
+	// Drives collection building, locale data, and sitemap-core language config.
+	const normalizeLanguageCode = (lang) => (lang || '').toLowerCase().trim();
+	const defaultLanguage = normalizeLanguageCode(settings.defaultLanguage);
+	const languages = normalizeLanguages(settings, log);
+	const hasLanguages = languages && Object.keys(languages).length > 0;
+	const isMultilingual = options.multilang === true && defaultLanguage && hasLanguages;
+
+	// Computed sitemap data: every page gets a page.sitemap object.
+	// Pages set noindex in frontmatter or site data to be excluded.
+	eleventyConfig.addGlobalData('eleventyComputed.page.sitemap', () => {
+		return (data) => ({
+			ignore: data.noindex ?? data.page?.noindex ?? data.settings?.noindex ?? false,
+			changefreq: '',
+			priority: -1
+		});
+	});
+
+	// --- Virtual sitemap templates ---
+	// Read template sources synchronously (same constraint as navigator-core).
+	// In multilingual mode: one sitemap per language + a sitemap index.
+	// In single-language mode: one flat sitemap at /sitemap.xml.
+	// Activation gate lives in the composition root via features.sitemap;
+	// the module is only registered when enabled.
+	const templatePath = path.join(__dirname, './templates/sitemap-core.html');
+	const indexTemplatePath = path.join(__dirname, './templates/sitemap-index.html');
+	const baseContent = fs.readFileSync(templatePath, 'utf-8');
+	const indexContent = fs.readFileSync(indexTemplatePath, 'utf-8');
+
+	const langKeys = Object.keys(languages || {});
+	const multilingual = isMultilingual;
+
+	if (multilingual && langKeys.length > 1) {
+		for (const lang of langKeys) {
+			eleventyConfig.addTemplate(`_baseline/sitemap-core-${lang}.html`, baseContent, {
+				permalink: `${lang}/sitemap.xml`,
+				title: '',
+				description: '',
+				layout: null,
+				eleventyExcludeFromCollections: true,
+				isMultilingual: multilingual,
+				sitemapLang: lang,
+				_internal: true
+			});
+		}
+
+		eleventyConfig.addTemplate('_baseline/sitemap-index.html', indexContent, {
+			permalink: '/sitemap.xml',
+			title: '',
+			description: '',
+			layout: null,
+			eleventyExcludeFromCollections: true,
+			isMultilingual: multilingual,
+			languages: languages,
+			_internal: true
+		});
+	} else {
+		eleventyConfig.addTemplate('_baseline/sitemap-core.html', baseContent, {
+			permalink: '/sitemap.xml',
+			title: '',
+			description: '',
+			layout: null,
+			eleventyExcludeFromCollections: true,
+			_internal: true
+		});
+	}
+}

package/modules/sitemap/templates/sitemap-core.html

@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8" standalone="yes"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9" xmlns:xhtml="http://www.w3.org/1999/xhtml">
+{%- if not settings.noindex %}
+{%- for item in collections.all %}
+{%- if not item.data.eleventyExcludeFromCollections and (not item.data.sitemap or item.data.sitemap.ignore != true) and item.data.noindex != true %}
+{%- set pageLang = item.data.lang or settings.defaultLanguage %}
+{%- if (not isMultilingual) or (not sitemapLang) or (pageLang == sitemapLang) %}
+{%- set absoluteUrl = item.url | htmlBaseUrl %}
+{%- set lastmod = item.data.sitemap and item.data.sitemap.lastmod or item.date %}
+<url>
+<loc>{{ absoluteUrl }}</loc>
+{%- if lastmod %}
+<lastmod>{{ date.toUTCISO(lastmod) }}</lastmod>
+{%- endif %}
+{%- if item.data.sitemap and item.data.sitemap.changefreq %}
+<changefreq>{{ item.data.sitemap.changefreq }}</changefreq>
+{%- endif %}
+{%- if item.data.sitemap and item.data.sitemap.priority is defined %}
+<priority>{{ item.data.sitemap.priority }}</priority>
+{%- endif %}
+{%- if item.data.translationKey and collections.translationsMap and collections.translationsMap[item.data.translationKey] %}
+{%- for language, entry in collections.translationsMap[item.data.translationKey] %}
+<xhtml:link rel="alternate" hreflang="{{ entry.lang }}" href="{{ entry.url | htmlBaseUrl }}" />
+{%- if entry.isDefaultLang %}
+<xhtml:link rel="alternate" hreflang="x-default" href="{{ entry.url | htmlBaseUrl }}" />
+{%- endif %}
+{%- endfor %}
+{%- endif %}
+</url>
+{%- endif %}
+{%- endif %}
+{%- endfor %}
+{%- endif %}
+</urlset>

package/modules/{sitemap-core → sitemap}/templates/sitemap-index.html

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8" standalone="yes"?>
 <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-{%- if not site.noindex %}
-{%- set langs = _baseline.languages or _i18n.languages %}
+{%- if not settings.noindex %}
+{%- set langs = languages %}
 {%- if langs %}
 {%- for lang, cfg in langs %}
 <sitemap>

package/modules.js

@@ -0,0 +1,6 @@
+// Modules barrel.
+export { assetsCore } from './modules/assets/index.js';
+export { headCore } from './modules/head/index.js';
+export { multilangCore } from './modules/multilang/index.js';
+export { navigatorCore } from './modules/navigator/index.js';
+export { sitemapCore } from './modules/sitemap/index.js';

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@apleasantview/eleventy-plugin-baseline",
-  "version": "0.1.0-next.32",
+  "version": "0.1.0-next.39",
   "description": "An experimental Swiss army knife toolkit for Eleventy",
   "type": "module",
-  "main": "eleventy.config.js",
   "exports": {
-    ".": "./eleventy.config.js",
+    ".": "./index.js",
     "./package.json": "./package.json"
   },
   "files": [
-    "eleventy.config.js",
+    "index.js",
+    "modules.js",
     "core/**",
     "modules/**",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "!**/__tests__/**",
+    "!**/*.test.js"
   ],
   "engines": {
     "node": ">=20"
@@ -38,14 +40,21 @@
     "@11ty/eleventy-img": "^6.0.4"
   },
   "dependencies": {
+    "@11ty/eleventy-utils": "^2.0.7",
+    "@rviscomi/capo.js": "^2.1.0",
     "cssnano": "^7.1.2",
     "dotenv": "^17.2.3",
     "esbuild": "0.27.0",
+    "kleur": "^4.1.5",
+    "luxon": "^3.7.2",
+    "markdown-it": "^14.1.1",
     "postcss": "^8.5.6",
     "postcss-import": "^16.1.1",
     "postcss-import-ext-glob": "^2.1.1",
     "postcss-load-config": "^6.0.1",
-    "postcss-preset-env": "^10.4.0"
+    "postcss-preset-env": "^10.4.0",
+    "slugify": "^1.6.6",
+    "zod": "^4.3.6"
   },
   "sideEffects": false
 }

package/core/debug.js

@@ -1,20 +0,0 @@
-import { inspect as utilInspect } from 'node:util';
-
-// Adapted from pdehaan - https://github.com/pdehaan/eleventy-plugin-debug
-const debugOptions = Object.assign({
-	space: 0
-});
-
-function inspect(obj, options = {}) {
-	return utilInspect(obj, options);
-}
-
-function json(obj, space = debugOptions.space) {
-	return JSON.stringify(obj, null, space);
-}
-
-function keys(obj) {
-	return Object.keys(obj).sort();
-}
-
-export default { inspect, json, keys };

package/core/filters.js

@@ -1,9 +0,0 @@
-import { markdownFilter } from './filters/markdown.js';
-import relatedPostsFilter from './filters/related-posts.js';
-import isStringFilter from './filters/isString.js';
-
-export default {
-	markdownFilter,
-	relatedPostsFilter,
-	isStringFilter
-};

package/core/globals.js

@@ -1,6 +0,0 @@
-import { registerDateGlobal } from './globals/date.js';
-
-/** @param {import("@11ty/eleventy").UserConfig} eleventyConfig */
-export default function registerGlobals(eleventyConfig) {
-	registerDateGlobal(eleventyConfig);
-}