@treeseed/core 0.1.2

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

@@ -0,0 +1,70 @@
+import config from "virtual:starlight/user-config";
+import { slugToLocale as getLocaleFromSlug } from "../integrations/shared/slugToLocale.js";
+import { BuiltInDefaultLocale } from "./i18n.js";
+import { stripTrailingSlash } from "./path.js";
+function slugToLocale(slug) {
+  return getLocaleFromSlug(slug, config);
+}
+function slugToLocaleData(slug) {
+  const locale = slugToLocale(slug);
+  return { dir: localeToDir(locale), lang: localeToLang(locale), locale };
+}
+function localeToLang(locale) {
+  const lang = locale ? config.locales?.[locale]?.lang : config.locales?.root?.lang;
+  const defaultLang = config.defaultLocale?.lang || config.defaultLocale?.locale;
+  return lang || defaultLang || BuiltInDefaultLocale.lang;
+}
+function localeToDir(locale) {
+  const dir = locale ? config.locales?.[locale]?.dir : config.locales?.root?.dir;
+  return dir || config.defaultLocale.dir;
+}
+function slugToParam(slug) {
+  return slug === "index" || slug === "" || slug === "/" ? void 0 : (slug.endsWith("/index") ? slug.slice(0, -6) : slug).normalize();
+}
+function slugToPathname(slug) {
+  const param = slugToParam(slug);
+  return param ? "/" + param + "/" : "/";
+}
+function localizedSlug(slug, locale) {
+  const slugLocale = slugToLocale(slug);
+  if (slugLocale === locale) return slug;
+  locale = locale || "";
+  if (slugLocale === slug) return locale;
+  if (slugLocale) {
+    return stripTrailingSlash(slug.replace(slugLocale + "/", locale ? locale + "/" : ""));
+  }
+  return slug ? locale + "/" + slug : locale;
+}
+function localizedId(id, locale) {
+  const idLocale = slugToLocale(id);
+  if (idLocale) {
+    return id.replace(idLocale + "/", locale ? locale + "/" : "");
+  } else if (locale) {
+    return locale + "/" + id;
+  } else {
+    return id;
+  }
+}
+function urlToSlug(url) {
+  let pathname = url.pathname;
+  const base = stripTrailingSlash(import.meta.env.BASE_URL);
+  if (pathname.startsWith(base)) pathname = pathname.replace(base, "");
+  const segments = pathname.split("/");
+  const htmlExt = ".html";
+  if (segments.at(-1) === "index.html") {
+    segments.pop();
+  } else if (segments.at(-1)?.endsWith(htmlExt)) {
+    const last = segments.pop();
+    if (last) segments.push(last.slice(0, -1 * htmlExt.length));
+  }
+  return segments.filter(Boolean).join("/");
+}
+export {
+  localeToLang,
+  localizedId,
+  localizedSlug,
+  slugToLocaleData,
+  slugToParam,
+  slugToPathname,
+  urlToSlug
+};

package/dist/vendor/starlight/utils/starlight-page.js

@@ -0,0 +1,123 @@
+import { z } from "astro/zod";
+import project from "virtual:starlight/project-context";
+import config from "virtual:starlight/user-config";
+import { getCollectionPathFromRoot } from "./collection.js";
+import { parseWithFriendlyErrors, parseAsyncWithFriendlyErrors } from "./error-map.js";
+import { stripLeadingAndTrailingSlashes } from "./path.js";
+import {
+  getSiteTitle,
+  getSiteTitleHref,
+  getToC
+} from "./routing/data.js";
+import { slugToLocaleData, urlToSlug } from "./slugs.js";
+import { getPrevNextLinks, getSidebar, getSidebarFromConfig } from "./navigation.js";
+import { docsSchema } from "../schema.js";
+import { SidebarItemSchema } from "../schemas/sidebar.js";
+import { getHead } from "./head.js";
+const StarlightPageFrontmatterSchema = async (context) => {
+  const userDocsSchema = await getUserDocsSchema();
+  const schema = typeof userDocsSchema === "function" ? userDocsSchema(context) : userDocsSchema;
+  return schema.transform((frontmatter) => {
+    const { editUrl, sidebar, ...others } = frontmatter;
+    const pageEditUrl = editUrl === void 0 || editUrl === true ? false : editUrl;
+    return { ...others, editUrl: pageEditUrl };
+  });
+};
+const validateSidebarProp = (sidebarProp) => {
+  return parseWithFriendlyErrors(
+    SidebarItemSchema.array().optional(),
+    sidebarProp,
+    "Invalid sidebar prop passed to the `<StarlightPage/>` component."
+  );
+};
+async function generateStarlightPageRouteData({
+  props,
+  context
+}) {
+  const { frontmatter, ...routeProps } = props;
+  const { url } = context;
+  const slug = urlToSlug(url);
+  const pageFrontmatter = await getStarlightPageFrontmatter(frontmatter);
+  const id = project.legacyCollections ? `${stripLeadingAndTrailingSlashes(slug)}.md` : slug;
+  const localeData = slugToLocaleData(slug);
+  const sidebar = props.sidebar ? getSidebarFromConfig(validateSidebarProp(props.sidebar), url.pathname, localeData.locale) : getSidebar(url.pathname, localeData.locale);
+  const headings = props.headings ?? [];
+  const pageDocsEntry = {
+    id,
+    slug,
+    body: "",
+    collection: "docs",
+    filePath: `${getCollectionPathFromRoot("docs", project)}/${stripLeadingAndTrailingSlashes(slug)}.md`,
+    data: {
+      ...pageFrontmatter,
+      sidebar: {
+        attrs: {},
+        hidden: false
+      }
+    }
+  };
+  const entry = pageDocsEntry;
+  const entryMeta = {
+    dir: props.dir ?? localeData.dir,
+    lang: props.lang ?? localeData.lang,
+    locale: localeData.locale
+  };
+  const editUrl = pageFrontmatter.editUrl ? new URL(pageFrontmatter.editUrl) : void 0;
+  const lastUpdated = pageFrontmatter.lastUpdated instanceof Date ? pageFrontmatter.lastUpdated : void 0;
+  const pageProps = {
+    ...routeProps,
+    ...localeData,
+    entry,
+    entryMeta,
+    headings,
+    id,
+    locale: localeData.locale,
+    slug
+  };
+  const siteTitle = getSiteTitle(localeData.lang);
+  const routeData = {
+    ...routeProps,
+    ...localeData,
+    id,
+    editUrl,
+    entry,
+    entryMeta,
+    hasSidebar: props.hasSidebar ?? entry.data.template !== "splash",
+    head: getHead(pageProps, context, siteTitle),
+    headings,
+    lastUpdated,
+    pagination: getPrevNextLinks(sidebar, config.pagination, entry.data),
+    sidebar,
+    siteTitle,
+    siteTitleHref: getSiteTitleHref(localeData.locale),
+    slug,
+    toc: getToC(pageProps)
+  };
+  return routeData;
+}
+async function getStarlightPageFrontmatter(frontmatter) {
+  const schema = await StarlightPageFrontmatterSchema({
+    image: (() => (
+      // Mock validator for ImageMetadata.
+      // https://github.com/withastro/astro/blob/cf993bc263b58502096f00d383266cd179f331af/packages/astro/src/assets/types.ts#L32
+      // It uses a custom validation approach because imported SVGs have a type of `function` as
+      // well as containing the metadata properties and this ensures we handle those correctly.
+      z.custom(
+        (value) => value && (typeof value === "function" || typeof value === "object") && "src" in value && "width" in value && "height" in value && "format" in value,
+        "Invalid image passed to `<StarlightPage>` component. Expected imported `ImageMetadata` object."
+      )
+    ))
+  });
+  return parseAsyncWithFriendlyErrors(
+    schema,
+    frontmatter,
+    "Invalid frontmatter props passed to the `<StarlightPage/>` component."
+  );
+}
+async function getUserDocsSchema() {
+  const userCollections = (await import("virtual:starlight/collection-config")).collections;
+  return userCollections?.docs?.schema ?? docsSchema();
+}
+export {
+  generateStarlightPageRouteData
+};

package/dist/vendor/starlight/utils/translations-fs.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import yaml from "js-yaml";
+import { createTranslationSystem } from "./createTranslationSystem.js";
+const contentCollectionFileExtensions = [".json", ".yaml", ".yml"];
+async function createTranslationSystemFromFs(opts, { srcDir }, pluginTranslations = {}) {
+  const userTranslations = {};
+  try {
+    const i18nDir = new URL("content/i18n/", srcDir);
+    const files = fs.readdirSync(i18nDir, "utf-8");
+    for (const file of files) {
+      const filePath = path.parse(file);
+      if (!contentCollectionFileExtensions.includes(filePath.ext)) continue;
+      const id = filePath.name;
+      const url = new URL(filePath.base, i18nDir);
+      const content = fs.readFileSync(new URL(file, i18nDir), "utf-8");
+      const data = filePath.ext === ".json" ? JSON.parse(content) : yaml.load(content, { filename: fileURLToPath(url) });
+      userTranslations[id] = data;
+    }
+  } catch (e) {
+    if (e instanceof Error && "code" in e && e.code === "ENOENT") {
+    } else {
+      throw e;
+    }
+  }
+  return createTranslationSystem(opts, userTranslations, pluginTranslations);
+}
+export {
+  createTranslationSystemFromFs
+};

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

@@ -0,0 +1,31 @@
+import { getCollection } from "astro:content";
+import config from "virtual:starlight/user-config";
+import project from "virtual:starlight/project-context";
+import pluginTranslations from "virtual:starlight/plugin-translations";
+import { createTranslationSystem } from "./createTranslationSystem.js";
+import { getCollectionPathFromRoot } from "./collection.js";
+import { stripExtension, stripLeadingSlash } from "./path.js";
+const i18nCollectionPathFromRoot = getCollectionPathFromRoot("i18n", project);
+async function loadTranslations() {
+  const warn = console.warn;
+  console.warn = () => {
+  };
+  const userTranslations = Object.fromEntries(
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore — may be a type error in projects without an i18n collection
+    (await getCollection("i18n")).map(({ id, data, filePath }) => {
+      const lang = project.legacyCollections || !filePath ? id : stripExtension(stripLeadingSlash(filePath.replace(i18nCollectionPathFromRoot, "")));
+      return [lang, data];
+    })
+  );
+  console.warn = warn;
+  return userTranslations;
+}
+const useTranslations = await createTranslationSystem(
+  config,
+  await loadTranslations(),
+  pluginTranslations
+);
+export {
+  useTranslations
+};

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

@@ -0,0 +1,5 @@
+const HTTPProtocolRegEx = /^https?:\/\//;
+const isAbsoluteUrl = (link) => HTTPProtocolRegEx.test(link);
+export {
+  isAbsoluteUrl
+};

package/dist/vendor/starlight/utils/user-config.js

@@ -0,0 +1,255 @@
+import { z } from "astro/zod";
+import { parse as bcpParse, stringify as bcpStringify } from "bcp-47";
+import { ComponentConfigSchema } from "../schemas/components.js";
+import { ExpressiveCodeSchema } from "../schemas/expressiveCode.js";
+import { FaviconSchema } from "../schemas/favicon.js";
+import { HeadConfigSchema } from "../schemas/head.js";
+import { LogoConfigSchema } from "../schemas/logo.js";
+import { PagefindConfigDefaults, PagefindConfigSchema } from "../schemas/pagefind.js";
+import { SidebarItemSchema } from "../schemas/sidebar.js";
+import { TitleConfigSchema, TitleTransformConfigSchema } from "../schemas/site-title.js";
+import { SocialLinksSchema } from "../schemas/social.js";
+import { TableOfContentsSchema } from "../schemas/tableOfContents.js";
+import { BuiltInDefaultLocale } from "./i18n.js";
+const LocaleSchema = z.object({
+  /** The label for this language to show in UI, e.g. `"English"`, `"العربية"`, or `"简体中文"`. */
+  label: z.string().describe(
+    'The label for this language to show in UI, e.g. `"English"`, `"\u0627\u0644\u0639\u0631\u0628\u064A\u0629"`, or `"\u7B80\u4F53\u4E2D\u6587"`.'
+  ),
+  /** The BCP-47 tag for this language, e.g. `"en"`, `"ar"`, or `"zh-CN"`. */
+  lang: z.string().optional().describe('The BCP-47 tag for this language, e.g. `"en"`, `"ar"`, or `"zh-CN"`.'),
+  /** The writing direction of this language; `"ltr"` for left-to-right (the default) or `"rtl"` for right-to-left. */
+  dir: z.enum(["rtl", "ltr"]).optional().default("ltr").describe(
+    'The writing direction of this language; `"ltr"` for left-to-right (the default) or `"rtl"` for right-to-left.'
+  )
+});
+const UserConfigSchema = z.object({
+  /** Title for your website. Will be used in metadata and as browser tab title. */
+  title: TitleConfigSchema(),
+  /** Description metadata for your website. Can be used in page metadata. */
+  description: z.string().optional().describe("Description metadata for your website. Can be used in page metadata."),
+  /** Set a logo image to show in the navigation bar alongside or instead of the site title. */
+  logo: LogoConfigSchema(),
+  /**
+   * Optional details about the social media accounts for this site.
+   *
+   * @example
+   * social: [
+   *   { icon: 'codeberg', label: 'Codeberg', href: 'https://codeberg.org/knut' },
+   *   { icon: 'discord', label: 'Discord', href: 'https://astro.build/chat' },
+   *   { icon: 'github', label: 'GitHub', href: 'https://github.com/withastro' },
+   *   { icon: 'gitlab', label: 'GitLab', href: 'https://gitlab.com/delucis' },
+   *   { icon: 'mastodon', label: 'Mastodon', href: 'https://m.webtoo.ls/@astro' },
+   * ]
+   */
+  social: SocialLinksSchema(),
+  /** The tagline for your website. */
+  tagline: z.string().optional().describe("The tagline for your website."),
+  /** Configure the defaults for the table of contents on each page. */
+  tableOfContents: TableOfContentsSchema(),
+  /** Enable and configure “Edit this page” links. */
+  editLink: z.object({
+    /** Set the base URL for edit links. The final link will be `baseUrl` + the current page path. */
+    baseUrl: z.string().url().optional()
+  }).optional().default({}),
+  /** Configure locales for internationalization (i18n). */
+  locales: z.object({
+    /** Configure a “root” locale to serve a default language from `/`. */
+    root: LocaleSchema.required({ lang: true }).optional()
+  }).catchall(LocaleSchema).transform((locales, ctx) => {
+    for (const key in locales) {
+      const locale = locales[key];
+      let lang = locale.lang || key;
+      const schema = bcpParse(lang, { forgiving: true });
+      schema.region = schema.region?.toUpperCase();
+      const normalizedLang = bcpStringify(schema);
+      if (!normalizedLang) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          message: `Could not validate language tag "${lang}" at locales.${key}.lang.`
+        });
+        return z.NEVER;
+      }
+      if (normalizedLang !== lang) {
+        console.warn(
+          `Warning: using "${normalizedLang}" language tag for locales.${key}.lang instead of "${lang}".`
+        );
+        lang = normalizedLang;
+      }
+      locale.lang = lang;
+    }
+    return locales;
+  }).optional().describe("Configure locales for internationalization (i18n)."),
+  /**
+   * Specify the default language for this site.
+   *
+   * The default locale will be used to provide fallback content where translations are missing.
+   */
+  defaultLocale: z.string().optional(),
+  /** Configure your site’s sidebar navigation items. */
+  sidebar: SidebarItemSchema.array().optional(),
+  /**
+   * Add extra tags to your site’s `<head>`.
+   *
+   * Can also be set for a single page in a page’s frontmatter.
+   *
+   * @example
+   * // Add Fathom analytics to your site
+   * starlight({
+   *  head: [
+   *    {
+   *      tag: 'script',
+   *      attrs: {
+   *        src: 'https://cdn.usefathom.com/script.js',
+   *        'data-site': 'MY-FATHOM-ID',
+   *        defer: true,
+   *      },
+   *    },
+   *  ],
+   * })
+   */
+  head: HeadConfigSchema({ source: "config" }),
+  /**
+   * Provide CSS files to customize the look and feel of your Starlight site.
+   *
+   * Supports local CSS files relative to the root of your project,
+   * e.g. `'/src/custom.css'`, and CSS you installed as an npm
+   * module, e.g. `'@fontsource/roboto'`.
+   *
+   * @example
+   * starlight({
+   *  customCss: ['/src/custom-styles.css', '@fontsource/roboto'],
+   * })
+   */
+  customCss: z.string().array().optional().default([]).superRefine((paths, ctx) => {
+    const invalidPathRegex = /^\.?\/public\/.+$/;
+    const invalidPaths = paths.filter((path) => invalidPathRegex.test(path));
+    if (invalidPaths.length > 0) {
+      ctx.addIssue({
+        code: "custom",
+        message: `These paths in your Starlight \`customCss\` config are invalid: ${invalidPaths.map((path) => `\`"${path}"\``).join(", ")}
+
+CSS files specified in \`customCss\` should be in the \`src/\` directory, not the \`public/\` directory.
+
+You should move these CSS files into the \`src/\` directory and update the path in \`customCss\` to match.`
+      });
+    }
+  }),
+  /** Define if the last update date should be visible in the page footer. */
+  lastUpdated: z.boolean().default(false).describe("Define if the last update date should be visible in the page footer."),
+  /** Define if the previous and next page links should be visible in the page footer. */
+  pagination: z.boolean().default(true).describe("Define if the previous and next page links should be visible in the page footer."),
+  /** The default favicon for your site which should be a path to an image in the `public/` directory. */
+  favicon: FaviconSchema(),
+  /**
+   * Define how code blocks are rendered by passing options to Expressive Code,
+   * or disable the integration by passing `false`.
+   */
+  expressiveCode: ExpressiveCodeSchema(),
+  /**
+   * Configure Starlight’s default site search provider Pagefind. Set to `false` to disable indexing
+   * your site with Pagefind, which will also hide the default search UI if in use.
+   */
+  pagefind: z.boolean().transform((val) => val && PagefindConfigDefaults()).or(PagefindConfigSchema()).optional(),
+  /** Specify paths to components that should override Starlight’s default components */
+  components: ComponentConfigSchema(),
+  /** Will be used as title delimiter in the generated `<title>` tag. */
+  titleDelimiter: z.string().default("|").describe("Will be used as title delimiter in the generated `<title>` tag."),
+  /** Disable Starlight's default 404 page. */
+  disable404Route: z.boolean().default(false).describe("Disable Starlight's default 404 page."),
+  /**
+   * Define whether Starlight pages should be prerendered or not.
+   * Defaults to always prerender Starlight pages, even when the project is
+   * set to "server" output mode.
+   */
+  prerender: z.boolean().default(true),
+  /** Enable displaying a “Built with Starlight” link in your site’s footer. */
+  credits: z.boolean().default(false).describe("Enable displaying a \u201CBuilt with Starlight\u201D link in your site\u2019s footer."),
+  /** Add middleware to process Starlight’s route data for each page. */
+  routeMiddleware: z.string().transform((string) => [string]).or(z.string().array()).default([]).superRefine((middlewares, ctx) => {
+    const invalidPathRegex = /^\.?\/src\/middleware(?:\/index)?\.[jt]s$/;
+    const invalidPaths = middlewares.filter((middleware) => invalidPathRegex.test(middleware));
+    for (const invalidPath of invalidPaths) {
+      ctx.addIssue({
+        code: "custom",
+        message: `The \`"${invalidPath}"\` path in your Starlight \`routeMiddleware\` config conflicts with Astro\u2019s middleware locations.
+
+You should rename \`${invalidPath}\` to something else like \`./src/starlightRouteData.ts\` and update the \`routeMiddleware\` file path to match.
+
+- More about Starlight route middleware: https://starlight.astro.build/guides/route-data/#how-to-customize-route-data
+- More about Astro middleware: https://docs.astro.build/en/guides/middleware/`
+      });
+    }
+  }).describe("Add middleware to process Starlight\u2019s route data for each page."),
+  /** Configure features that impact Starlight’s Markdown processing. */
+  markdown: z.object({
+    /** Define whether headings in content should be rendered with clickable anchor links. Default: `true`. */
+    headingLinks: z.boolean().default(true).describe(
+      "Define whether headings in content should be rendered with clickable anchor links. Default: `true`."
+    ),
+    /**
+     * Define additional directories where files should be processed by Starlight’s Markdown pipeline.
+     *
+     * Supports local directories relative to the root of your project, e.g. './src/data/comments/'.
+     * Content of the `docs` content collection is always processed by Starlight’s Markdown pipeline.
+     */
+    processedDirs: z.string().array().default([]).describe(
+      "Define additional directories where files should be processed by Starlight\u2019s Markdown pipeline. Default: `[]`."
+    )
+  }).default({}).describe("Configure features that impact Starlight\u2019s Markdown processing.")
+});
+const StarlightConfigSchema = UserConfigSchema.strict().transform((config) => ({
+  ...config,
+  // Pagefind only defaults to true if prerender is also true.
+  pagefind: typeof config.pagefind === "undefined" ? config.prerender && PagefindConfigDefaults() : config.pagefind
+})).refine((config) => !(!config.prerender && config.pagefind), {
+  message: "Pagefind search is not supported with prerendering disabled."
+}).transform(({ title, locales, defaultLocale, ...config }, ctx) => {
+  const configuredLocales = Object.keys(locales ?? {});
+  if (locales !== void 0 && (configuredLocales.length > 1 || configuredLocales.length === 1 && locales.root === void 0)) {
+    const defaultLocaleConfig2 = locales[defaultLocale || "root"];
+    if (!defaultLocaleConfig2) {
+      const availableLocales = configuredLocales.map((l) => `"${l}"`).join(", ");
+      ctx.addIssue({
+        code: "custom",
+        message: "Could not determine the default locale. Please make sure `defaultLocale` in your Starlight config is one of " + availableLocales
+      });
+      return z.NEVER;
+    }
+    const TitleSchema2 = TitleTransformConfigSchema(defaultLocaleConfig2.lang);
+    const parsedTitle2 = TitleSchema2.parse(title);
+    return {
+      ...config,
+      title: parsedTitle2,
+      /** Flag indicating if this site has multiple locales set up. */
+      isMultilingual: configuredLocales.length > 1,
+      /** Flag indicating if the Starlight built-in default locale is used. */
+      isUsingBuiltInDefaultLocale: false,
+      /** Full locale object for this site’s default language. */
+      defaultLocale: { ...defaultLocaleConfig2, locale: defaultLocale },
+      locales
+    };
+  }
+  const defaultLocaleConfig = {
+    label: BuiltInDefaultLocale.label,
+    lang: BuiltInDefaultLocale.lang,
+    dir: BuiltInDefaultLocale.dir,
+    locale: void 0,
+    ...locales?.root
+  };
+  const TitleSchema = TitleTransformConfigSchema(defaultLocaleConfig.lang);
+  const parsedTitle = TitleSchema.parse(title);
+  return {
+    ...config,
+    title: parsedTitle,
+    /** Flag indicating if this site has multiple locales set up. */
+    isMultilingual: false,
+    /** Flag indicating if the Starlight built-in default locale is used. */
+    isUsingBuiltInDefaultLocale: locales?.root === void 0,
+    defaultLocale: defaultLocaleConfig,
+    locales: void 0
+  };
+});
+export {
+  StarlightConfigSchema
+};

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

@@ -0,0 +1,22 @@
+import config from "virtual:starlight/user-config";
+import { logos } from "virtual:starlight/user-images";
+function validateLogoImports() {
+  if (config.logo) {
+    let err;
+    if ("src" in config.logo) {
+      if (!logos.dark || !logos.light) {
+        err = `Could not resolve logo import for "${config.logo.src}" (logo.src)`;
+      }
+    } else {
+      if (!logos.dark) {
+        err = `Could not resolve logo import for "${config.logo.dark}" (logo.dark)`;
+      } else if (!logos.light) {
+        err = `Could not resolve logo import for "${config.logo.light}" (logo.light)`;
+      }
+    }
+    if (err) throw new Error(err);
+  }
+}
+export {
+  validateLogoImports
+};