@treeseed/core 0.1.2

package/dist/vendor/starlight/utils/path.js

@@ -0,0 +1,52 @@
+function ensureLeadingSlash(href) {
+  if (href[0] !== "/") href = "/" + href;
+  return href;
+}
+function ensureTrailingSlash(href) {
+  if (href[href.length - 1] !== "/") href += "/";
+  return href;
+}
+function ensureLeadingAndTrailingSlashes(href) {
+  href = ensureLeadingSlash(href);
+  href = ensureTrailingSlash(href);
+  return href;
+}
+function stripLeadingSlash(href) {
+  if (href[0] === "/") href = href.slice(1);
+  return href;
+}
+function stripTrailingSlash(href) {
+  if (href[href.length - 1] === "/") href = href.slice(0, -1);
+  return href;
+}
+function stripLeadingAndTrailingSlashes(href) {
+  href = stripLeadingSlash(href);
+  href = stripTrailingSlash(href);
+  return href;
+}
+function stripHtmlExtension(path) {
+  const pathWithoutTrailingSlash = stripTrailingSlash(path);
+  return pathWithoutTrailingSlash.endsWith(".html") ? pathWithoutTrailingSlash.slice(0, -5) : path;
+}
+function ensureHtmlExtension(path) {
+  path = stripLeadingAndTrailingSlashes(path);
+  if (!path.endsWith(".html")) {
+    path = path ? path + ".html" : "/index.html";
+  }
+  return ensureLeadingSlash(path);
+}
+function stripExtension(path) {
+  const periodIndex = path.lastIndexOf(".");
+  return path.slice(0, periodIndex > -1 ? periodIndex : void 0);
+}
+export {
+  ensureHtmlExtension,
+  ensureLeadingAndTrailingSlashes,
+  ensureLeadingSlash,
+  ensureTrailingSlash,
+  stripExtension,
+  stripHtmlExtension,
+  stripLeadingAndTrailingSlashes,
+  stripLeadingSlash,
+  stripTrailingSlash
+};

package/dist/vendor/starlight/utils/plugins.js

@@ -0,0 +1,355 @@
+import { AstroError } from "astro/errors";
+import { z } from "astro/zod";
+import { parseWithFriendlyErrors } from "../utils/error-map.js";
+import {
+  StarlightConfigSchema
+} from "../utils/user-config.js";
+import { createTranslationSystemFromFs } from "./translations-fs.js";
+import { absolutePathToLang as getAbsolutePathFromLang } from "../integrations/shared/absolutePathToLang.js";
+import { getCollectionPosixPath } from "./collection-fs.js";
+async function runPlugins(starlightUserConfig, pluginsUserConfig, context) {
+  let userConfig = starlightUserConfig;
+  let starlightConfig = parseWithFriendlyErrors(
+    StarlightConfigSchema,
+    userConfig,
+    "Invalid config passed to starlight integration"
+  );
+  const pluginsConfig = parseWithFriendlyErrors(
+    starlightPluginsConfigSchema,
+    pluginsUserConfig,
+    "Invalid plugins config passed to starlight integration"
+  );
+  const pluginTranslations = {};
+  const routeMiddlewareConfigs = [];
+  for (const {
+    hooks: { "i18n:setup": i18nSetup }
+  } of pluginsConfig) {
+    if (i18nSetup) {
+      await i18nSetup({
+        injectTranslations(translations) {
+          for (const [locale, localeTranslations] of Object.entries(translations)) {
+            pluginTranslations[locale] ??= {};
+            Object.assign(pluginTranslations[locale], localeTranslations);
+          }
+        }
+      });
+    }
+  }
+  const useTranslations = await createTranslationSystemFromFs(
+    starlightConfig,
+    context.config,
+    pluginTranslations
+  );
+  function absolutePathToLang(path) {
+    return getAbsolutePathFromLang(path, {
+      docsPath: getCollectionPosixPath("docs", context.config.srcDir),
+      starlightConfig
+    });
+  }
+  const integrations = [];
+  for (const {
+    name,
+    hooks: { "config:setup": configSetup, setup: deprecatedSetup }
+  } of pluginsConfig) {
+    const setup = configSetup ?? deprecatedSetup;
+    await setup({
+      config: pluginsUserConfig ? { ...userConfig, plugins: pluginsUserConfig } : userConfig,
+      updateConfig(newConfig) {
+        if ("plugins" in newConfig) {
+          throw new AstroError(
+            `The \`${name}\` plugin tried to update the \`plugins\` config key which is not supported.`
+          );
+        }
+        if ("routeMiddleware" in newConfig) {
+          throw new AstroError(
+            `The \`${name}\` plugin tried to update the \`routeMiddleware\` config key which is not supported.`,
+            "Use the `addRouteMiddleware()` utility instead.\nSee https://starlight.astro.build/reference/plugins/#addroutemiddleware for more details."
+          );
+        }
+        const mergedUserConfig = { ...userConfig, ...newConfig };
+        const mergedConfig = parseWithFriendlyErrors(
+          StarlightConfigSchema,
+          mergedUserConfig,
+          `Invalid config update provided by the '${name}' plugin`
+        );
+        userConfig = mergedUserConfig;
+        starlightConfig = mergedConfig;
+      },
+      addIntegration(integration) {
+        integrations.push(integration);
+      },
+      addRouteMiddleware(middlewareConfig) {
+        routeMiddlewareConfigs.push(middlewareConfig);
+      },
+      astroConfig: {
+        ...context.config,
+        integrations: [...context.config.integrations, ...integrations]
+      },
+      command: context.command,
+      isRestart: context.isRestart,
+      logger: context.logger.fork(name),
+      useTranslations,
+      absolutePathToLang
+    });
+  }
+  applyPluginMiddleware(routeMiddlewareConfigs, starlightConfig);
+  return { integrations, starlightConfig, pluginTranslations, useTranslations, absolutePathToLang };
+}
+function applyPluginMiddleware(routeMiddlewareConfigs, starlightConfig) {
+  const middlewareBuckets = routeMiddlewareConfigs.reduce(
+    (buckets, { entrypoint, order = "default" }) => {
+      buckets[order].push(entrypoint);
+      return buckets;
+    },
+    { pre: [], default: [], post: [] }
+  );
+  starlightConfig.routeMiddleware.unshift(...middlewareBuckets.pre);
+  starlightConfig.routeMiddleware.push(...middlewareBuckets.default, ...middlewareBuckets.post);
+}
+function injectPluginTranslationsTypes(translations, injectTypes) {
+  const allKeys = /* @__PURE__ */ new Set();
+  for (const localeTranslations of Object.values(translations)) {
+    for (const key of Object.keys(localeTranslations)) {
+      allKeys.add(key);
+    }
+  }
+  if (allKeys.size === 0) return;
+  injectTypes({
+    filename: "i18n-plugins.d.ts",
+    content: `declare namespace StarlightApp {
+	type PluginUIStringKeys = {
+		${[...allKeys].map((key) => `'${key}': string;`).join("\n		")}
+	};
+	interface I18n extends PluginUIStringKeys {}
+}`
+  });
+}
+const astroIntegrationSchema = z.object({
+  name: z.string(),
+  hooks: z.object({}).passthrough().default({})
+});
+const routeMiddlewareConfigSchema = z.object({
+  entrypoint: z.string(),
+  order: z.enum(["pre", "post", "default"]).default("default")
+});
+const baseStarlightPluginSchema = z.object({
+  /** Name of the Starlight plugin. */
+  name: z.string()
+});
+const configSetupHookSchema = z.function(
+  z.tuple([
+    z.object({
+      /**
+       * A read-only copy of the user-supplied Starlight configuration.
+       *
+       * Note that this configuration may have been updated by other plugins configured
+       * before this one.
+       */
+      config: z.any(),
+      /**
+       * A callback function to update the user-supplied Starlight configuration.
+       *
+       * You only need to provide the configuration values that you want to update but no deep
+       * merge is performed.
+       *
+       * @example
+       * {
+       * 	name: 'My Starlight Plugin',
+       *	hooks: {
+       * 		'config:setup'({ updateConfig }) {
+       * 			updateConfig({
+       * 				description: 'Custom description',
+       * 			});
+       * 		}
+       *	}
+       * }
+       */
+      updateConfig: z.function(
+        z.tuple([
+          z.record(z.any())
+        ]),
+        z.void()
+      ),
+      /**
+       * A callback function to add an Astro integration required by this plugin.
+       *
+       * @see https://docs.astro.build/en/reference/integrations-reference/
+       *
+       * @example
+       * {
+       * 	name: 'My Starlight Plugin',
+       * 	hooks: {
+       * 		'config:setup'({ addIntegration }) {
+       * 			addIntegration({
+       * 				name: 'My Plugin Astro Integration',
+       * 				hooks: {
+       * 					'astro:config:setup': () => {
+       * 						// …
+       * 					},
+       * 				},
+       * 			});
+       * 		}
+       * 	}
+       * }
+       */
+      addIntegration: z.function(z.tuple([astroIntegrationSchema]), z.void()),
+      /**
+       * A callback function to register additional route middleware handlers.
+       *
+       * If the order of execution is important, a plugin can use the `order` option to enforce
+       * running first or last.
+       *
+       * @example
+       * {
+       * 	name: 'My Starlight Plugin',
+       * 	hooks: {
+       * 		setup({ addRouteMiddleware }) {
+       * 			addRouteMiddleware({ entrypoint: '@me/my-plugin/route-middleware' });
+       * 		},
+       * 	},
+       * }
+       */
+      addRouteMiddleware: z.function(z.tuple([routeMiddlewareConfigSchema]), z.void()),
+      /**
+       * A read-only copy of the user-supplied Astro configuration.
+       *
+       * Note that this configuration is resolved before any other integrations have run.
+       *
+       * @see https://docs.astro.build/en/reference/integrations-reference/#config-option
+       */
+      astroConfig: z.any(),
+      /**
+       * The command used to run Starlight.
+       *
+       * @see https://docs.astro.build/en/reference/integrations-reference/#command-option
+       */
+      command: z.any(),
+      /**
+       * `false` when the dev server starts, `true` when a reload is triggered.
+       *
+       * @see https://docs.astro.build/en/reference/integrations-reference/#isrestart-option
+       */
+      isRestart: z.any(),
+      /**
+       * An instance of the Astro integration logger with all logged messages prefixed with the
+       * plugin name.
+       *
+       * @see https://docs.astro.build/en/reference/integrations-reference/#astrointegrationlogger
+       */
+      logger: z.any(),
+      /**
+       * A callback function to generate a utility function to access UI strings for a given
+       * language.
+       *
+       * @see https://starlight.astro.build/guides/i18n/#using-ui-translations
+       *
+       * @example
+       * {
+       * 	name: 'My Starlight Plugin',
+       *	hooks: {
+       * 		'config:setup'({ useTranslations, logger }) {
+       * 			const t = useTranslations('en');
+       * 			logger.info(t('builtWithStarlight.label'));
+       * 		  // ^ Logs 'Built with Starlight' to the console.
+       * 		}
+       *	}
+       * }
+       */
+      useTranslations: z.any(),
+      /**
+       * A callback function to get the language for a given absolute file path. The returned
+       * language can be used with the `useTranslations` helper to get UI strings for that
+       * language.
+       *
+       * This can be particularly useful in remark or rehype plugins to get the language for
+       * the current file being processed and use it to get the appropriate UI strings for that
+       * language.
+       *
+       * @example
+       * {
+       * 	name: 'My Starlight Plugin',
+       *	hooks: {
+       * 		'config:setup'({ absolutePathToLang, useTranslations, logger }) {
+       * 			const lang = absolutePathToLang('/absolute/path/to/project/src/content/docs/fr/index.mdx');
+       * 			const t = useTranslations(lang);
+       * 			logger.info(t('aside.tip'));
+       * 		  // ^ Logs 'Astuce' to the console.
+       * 		}
+       *	}
+       * }
+       */
+      absolutePathToLang: z.function(z.tuple([z.string()]), z.string())
+    })
+  ]),
+  z.union([z.void(), z.promise(z.void())])
+).optional();
+const starlightPluginSchema = baseStarlightPluginSchema.extend({
+  /** The different hooks available to the plugin. */
+  hooks: z.object({
+    /**
+     * Plugin internationalization setup function allowing to inject translations strings for the
+     * plugin in various locales. These translations will be available in the `config:setup` hook
+     * and plugin UI.
+     */
+    "i18n:setup": z.function(
+      z.tuple([
+        z.object({
+          /**
+           * A callback function to add or update translations strings.
+           *
+           * @see https://starlight.astro.build/guides/i18n/#extend-translation-schema
+           *
+           * @example
+           * {
+           * 	name: 'My Starlight Plugin',
+           * 	hooks: {
+           * 		'i18n:setup'({ injectTranslations }) {
+           * 			injectTranslations({
+           * 				en: {
+           * 					'myPlugin.doThing': 'Do the thing',
+           * 				},
+           * 				fr: {
+           * 					'myPlugin.doThing': 'Faire le truc',
+           * 				},
+           * 			});
+           * 		}
+           * 	}
+           * }
+           */
+          injectTranslations: z.function(
+            z.tuple([z.record(z.string(), z.record(z.string(), z.string()))]),
+            z.void()
+          )
+        })
+      ]),
+      z.union([z.void(), z.promise(z.void())])
+    ).optional(),
+    /**
+     * Plugin configuration setup function called with an object containing various values that
+     * can be used by the plugin to interact with Starlight.
+     */
+    "config:setup": configSetupHookSchema,
+    /**
+     * @deprecated Use the `config:setup` hook instead as `setup` will be removed in a future
+     * version.
+     */
+    setup: configSetupHookSchema
+  })
+}).superRefine((plugin, ctx) => {
+  if (!plugin.hooks["config:setup"] && !plugin.hooks.setup) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "A plugin must define at least a `config:setup` hook."
+    });
+  } else if (plugin.hooks["config:setup"] && plugin.hooks.setup) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "A plugin cannot define both a `config:setup` and `setup` hook. As `setup` is deprecated and will be removed in a future version, consider using `config:setup` instead."
+    });
+  }
+});
+const starlightPluginsConfigSchema = z.array(starlightPluginSchema).default([]);
+export {
+  injectPluginTranslationsTypes,
+  runPlugins
+};

package/dist/vendor/starlight/utils/routing/data.js

@@ -0,0 +1,116 @@
+import project from "virtual:starlight/project-context";
+import config from "virtual:starlight/user-config";
+import { generateToC } from "../generateToC.js";
+import { getNewestCommitDate } from "virtual:starlight/git-info";
+import { getPrevNextLinks, getSidebar } from "../navigation.js";
+import { ensureTrailingSlash } from "../path.js";
+import { getRouteBySlugParam, normalizeCollectionEntry } from "../routing.js";
+import { formatPath } from "../format-path.js";
+import { useTranslations } from "../translations.js";
+import { BuiltInDefaultLocale } from "../i18n.js";
+import { getEntry } from "astro:content";
+import { getCollectionPathFromRoot } from "../collection.js";
+import { getHead } from "../head.js";
+async function getRoute(context) {
+  return "slug" in context.params && getRouteBySlugParam(context.params.slug) || await get404Route(context.locals);
+}
+function useRouteData(context, route, { Content, headings }) {
+  const routeData = generateRouteData({ props: { ...route, headings }, context });
+  return { ...routeData, Content };
+}
+function generateRouteData({
+  props,
+  context
+}) {
+  const { entry, locale, lang } = props;
+  const sidebar = getSidebar(context.url.pathname, locale);
+  const siteTitle = getSiteTitle(lang);
+  return {
+    ...props,
+    siteTitle,
+    siteTitleHref: getSiteTitleHref(locale),
+    sidebar,
+    hasSidebar: entry.data.template !== "splash",
+    pagination: getPrevNextLinks(sidebar, config.pagination, entry.data),
+    toc: getToC(props),
+    lastUpdated: getLastUpdated(props),
+    editUrl: getEditUrl(props),
+    head: getHead(props, context, siteTitle)
+  };
+}
+function getToC({ entry, lang, headings }) {
+  const tocConfig = entry.data.template === "splash" ? false : entry.data.tableOfContents !== void 0 ? entry.data.tableOfContents : config.tableOfContents;
+  if (!tocConfig) return;
+  const t = useTranslations(lang);
+  return {
+    ...tocConfig,
+    items: generateToC(headings, { ...tocConfig, title: t("tableOfContents.overview") })
+  };
+}
+function getLastUpdated({ entry }) {
+  const { lastUpdated: frontmatterLastUpdated } = entry.data;
+  const { lastUpdated: configLastUpdated } = config;
+  if (frontmatterLastUpdated ?? configLastUpdated) {
+    try {
+      return frontmatterLastUpdated instanceof Date ? frontmatterLastUpdated : getNewestCommitDate(entry.filePath);
+    } catch {
+      return void 0;
+    }
+  }
+  return void 0;
+}
+function getEditUrl({ entry }) {
+  const { editUrl } = entry.data;
+  if (editUrl === false) return;
+  let url;
+  if (typeof editUrl === "string") {
+    url = editUrl;
+  } else if (config.editLink.baseUrl) {
+    url = ensureTrailingSlash(config.editLink.baseUrl) + entry.filePath;
+  }
+  return url ? new URL(url) : void 0;
+}
+function getSiteTitle(lang) {
+  const defaultLang = config.defaultLocale.lang;
+  if (lang && config.title[lang]) {
+    return config.title[lang];
+  }
+  return config.title[defaultLang];
+}
+function getSiteTitleHref(locale) {
+  return formatPath(locale || "/");
+}
+async function get404Route(locals) {
+  const { lang = BuiltInDefaultLocale.lang, dir = BuiltInDefaultLocale.dir } = config.defaultLocale || {};
+  let locale = config.defaultLocale?.locale;
+  if (locale === "root") locale = void 0;
+  const entryMeta = { dir, lang, locale };
+  const fallbackEntry = {
+    slug: "404",
+    id: "404",
+    body: "",
+    collection: "docs",
+    data: {
+      title: "404",
+      template: "splash",
+      editUrl: false,
+      head: [],
+      hero: { tagline: locals.t("404.text"), actions: [] },
+      pagefind: false,
+      sidebar: { hidden: false, attrs: {} },
+      draft: false
+    },
+    filePath: `${getCollectionPathFromRoot("docs", project)}/404.md`
+  };
+  const userEntry = await getEntry("docs", "404");
+  const entry = userEntry ? normalizeCollectionEntry(userEntry) : fallbackEntry;
+  return { ...entryMeta, entryMeta, entry, id: entry.id, slug: entry.slug };
+}
+export {
+  generateRouteData,
+  getRoute,
+  getSiteTitle,
+  getSiteTitleHref,
+  getToC,
+  useRouteData
+};

package/dist/vendor/starlight/utils/routing/index.js

@@ -0,0 +1,107 @@
+import { getCollection } from "astro:content";
+import config from "virtual:starlight/user-config";
+import project from "virtual:starlight/project-context";
+import { getCollectionPathFromRoot } from "../collection.js";
+import { localizedId, localizedSlug, slugToLocaleData, slugToParam } from "../slugs.js";
+import { validateLogoImports } from "../validateLogoImports.js";
+import { BuiltInDefaultLocale } from "../i18n.js";
+validateLogoImports();
+const normalizeIndexSlug = (slug) => slug === "index" ? "" : slug;
+function normalizeCollectionEntry(entry) {
+  const slug = normalizeIndexSlug(entry.slug ?? entry.id);
+  return {
+    ...entry,
+    // In a collection with a loader, the `id` is a slug and should be normalized.
+    id: entry.slug ? entry.id : slug,
+    // In a legacy collection, the `filePath` property doesn't exist.
+    filePath: entry.filePath ?? `${getCollectionPathFromRoot("docs", project)}/${entry.id}`,
+    // In a collection with a loader, the `slug` property is replaced by the `id`.
+    slug: normalizeIndexSlug(entry.slug ?? entry.id)
+  };
+}
+const docs = (await getCollection("docs", ({ data }) => {
+  return import.meta.env.MODE !== "production" || data.draft === false;
+}) ?? []).map(normalizeCollectionEntry);
+function getRoutes() {
+  const routes2 = docs.map((entry) => ({
+    entry,
+    slug: entry.slug,
+    id: entry.id,
+    entryMeta: slugToLocaleData(entry.slug),
+    ...slugToLocaleData(entry.slug)
+  }));
+  if (config.isMultilingual) {
+    const defaultLocaleDocs = getLocaleDocs(
+      config.defaultLocale?.locale === "root" ? void 0 : config.defaultLocale?.locale
+    );
+    for (const key in config.locales) {
+      if (key === config.defaultLocale.locale) continue;
+      const localeConfig = config.locales[key];
+      if (!localeConfig) continue;
+      const locale = key === "root" ? void 0 : key;
+      const localeDocs = getLocaleDocs(locale);
+      for (const fallback of defaultLocaleDocs) {
+        const slug = localizedSlug(fallback.slug, locale);
+        const id = project.legacyCollections ? localizedId(fallback.id, locale) : slug;
+        const doesNotNeedFallback = localeDocs.some((doc) => doc.slug === slug);
+        if (doesNotNeedFallback) continue;
+        routes2.push({
+          entry: fallback,
+          slug,
+          id,
+          isFallback: true,
+          lang: localeConfig.lang || BuiltInDefaultLocale.lang,
+          locale,
+          dir: localeConfig.dir,
+          entryMeta: slugToLocaleData(fallback.slug)
+        });
+      }
+    }
+  }
+  return routes2;
+}
+const routes = getRoutes();
+function getParamRouteMapping() {
+  const map = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    map.set(slugToParam(route.slug), route);
+  }
+  return map;
+}
+const routesBySlugParam = getParamRouteMapping();
+function getRouteBySlugParam(slugParam) {
+  return routesBySlugParam.get(slugParam?.replace(/\/$/, "") || void 0);
+}
+function getPaths() {
+  return routes.map((route) => ({
+    params: { slug: slugToParam(route.slug) },
+    props: route
+  }));
+}
+const paths = getPaths();
+function getLocaleRoutes(locale) {
+  return filterByLocale(routes, locale);
+}
+function getLocaleDocs(locale) {
+  return filterByLocale(docs, locale);
+}
+function filterByLocale(items, locale) {
+  if (config.locales) {
+    if (locale && locale in config.locales) {
+      return items.filter((i) => i.slug === locale || i.slug.startsWith(locale + "/"));
+    } else if (config.locales.root) {
+      const langKeys = Object.keys(config.locales).filter((k) => k !== "root");
+      const isLangIndex = new RegExp(`^(${langKeys.join("|")})$`);
+      const isLangDir = new RegExp(`^(${langKeys.join("|")})/`);
+      return items.filter((i) => !isLangIndex.test(i.slug) && !isLangDir.test(i.slug));
+    }
+  }
+  return items;
+}
+export {
+  getLocaleRoutes,
+  getRouteBySlugParam,
+  normalizeCollectionEntry,
+  paths,
+  routes
+};

package/dist/vendor/starlight/utils/routing/middleware.js

@@ -0,0 +1,40 @@
+import { klona } from "klona/lite";
+import { routeMiddleware } from "virtual:starlight/route-middleware";
+async function attachRouteDataAndRunMiddleware(context, routeData) {
+  context.locals.starlightRoute = klona(routeData);
+  const runner = new MiddlewareRunner(context, routeMiddleware);
+  await runner.run();
+}
+class MiddlewareRunnerStep {
+  #callback;
+  constructor(callback) {
+    this.#callback = callback;
+  }
+  async run(context, next) {
+    if (this.#callback) {
+      await this.#callback(context, next);
+      this.#callback = null;
+    }
+  }
+}
+class MiddlewareRunner {
+  #context;
+  #steps;
+  constructor(context, stack = []) {
+    this.#context = context;
+    this.#steps = stack.map((callback) => new MiddlewareRunnerStep(callback));
+  }
+  async #stepThrough(steps) {
+    let currentStep;
+    while (steps.length > 0) {
+      [currentStep, ...steps] = steps;
+      await currentStep.run(this.#context, async () => this.#stepThrough(steps));
+    }
+  }
+  async run() {
+    await this.#stepThrough(this.#steps);
+  }
+}
+export {
+  attachRouteDataAndRunMiddleware
+};

package/dist/vendor/starlight/utils/routing.js

@@ -0,0 +1 @@
+export * from './routing/index.js';