@barodoc/core 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Barocss
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/chunk-JQRBNHRZ.js

@@ -0,0 +1,103 @@
+// src/config/schema.ts
+import { z } from "zod";
+var navItemSchema = z.object({
+  group: z.string(),
+  pages: z.array(z.string())
+}).passthrough();
+var i18nConfigSchema = z.object({
+  defaultLocale: z.string(),
+  locales: z.array(z.string()),
+  labels: z.record(z.string()).optional()
+}).optional();
+var themeColorsSchema = z.object({
+  primary: z.string().optional(),
+  background: z.string().optional(),
+  backgroundDark: z.string().optional(),
+  text: z.string().optional(),
+  textDark: z.string().optional(),
+  border: z.string().optional(),
+  borderDark: z.string().optional()
+}).optional();
+var themeConfigSchema = z.object({
+  colors: themeColorsSchema,
+  fonts: z.object({
+    heading: z.string().optional(),
+    body: z.string().optional(),
+    code: z.string().optional()
+  }).optional(),
+  radius: z.string().optional()
+}).optional();
+var topbarSchema = z.object({
+  github: z.string().optional(),
+  discord: z.string().optional(),
+  twitter: z.string().optional()
+}).optional();
+var searchSchema = z.object({
+  enabled: z.boolean().optional()
+}).optional();
+var barodocConfigSchema = z.object({
+  name: z.string(),
+  logo: z.string().optional(),
+  favicon: z.string().optional(),
+  theme: themeConfigSchema,
+  i18n: i18nConfigSchema,
+  navigation: z.array(navItemSchema),
+  topbar: topbarSchema,
+  search: searchSchema,
+  customCss: z.array(z.string()).optional()
+});
+
+// src/config/loader.ts
+import fs from "fs";
+import path from "path";
+async function loadConfig(configPath, root) {
+  const absolutePath = path.isAbsolute(configPath) ? configPath : path.resolve(root, configPath);
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`Barodoc config not found: ${absolutePath}`);
+  }
+  const content = fs.readFileSync(absolutePath, "utf-8");
+  const rawConfig = JSON.parse(content);
+  const result = barodocConfigSchema.safeParse(rawConfig);
+  if (!result.success) {
+    const errors = result.error.errors.map((e) => `  - ${e.path.join(".")}: ${e.message}`).join("\n");
+    throw new Error(`Invalid barodoc.config.json:
+${errors}`);
+  }
+  const config = result.data;
+  if (!config.i18n) {
+    config.i18n = {
+      defaultLocale: "en",
+      locales: ["en"]
+    };
+  }
+  if (!config.search) {
+    config.search = { enabled: true };
+  }
+  return {
+    ...config,
+    _resolved: true,
+    _configPath: absolutePath
+  };
+}
+function getConfigDefaults() {
+  return {
+    i18n: {
+      defaultLocale: "en",
+      locales: ["en"]
+    },
+    search: {
+      enabled: true
+    },
+    theme: {
+      colors: {
+        primary: "#0070f3"
+      }
+    }
+  };
+}
+
+export {
+  barodocConfigSchema,
+  loadConfig,
+  getConfigDefaults
+};

package/dist/chunk-QMKA7OJU.js

@@ -0,0 +1,61 @@
+// src/i18n/utils.ts
+function getLocaleFromPath(path, i18n) {
+  const segments = path.split("/").filter(Boolean);
+  const firstSegment = segments[0];
+  if (firstSegment && i18n.locales.includes(firstSegment)) {
+    return firstSegment;
+  }
+  return i18n.defaultLocale;
+}
+function removeLocaleFromPath(path, i18n) {
+  const segments = path.split("/").filter(Boolean);
+  const firstSegment = segments[0];
+  if (firstSegment && i18n.locales.includes(firstSegment)) {
+    return "/" + segments.slice(1).join("/");
+  }
+  return path;
+}
+function getLocalizedPath(path, locale, i18n) {
+  const cleanPath = removeLocaleFromPath(path, i18n);
+  if (locale === i18n.defaultLocale) {
+    return cleanPath;
+  }
+  return `/${locale}${cleanPath}`;
+}
+function getLocalizedNavGroup(item, locale, defaultLocale) {
+  if (locale === defaultLocale) {
+    return item.group;
+  }
+  const localizedKey = `group:${locale}`;
+  return item[localizedKey] || item.group;
+}
+function getLocaleLabel(locale, labels) {
+  if (labels && labels[locale]) {
+    return labels[locale];
+  }
+  const defaultLabels = {
+    en: "English",
+    ko: "\uD55C\uAD6D\uC5B4",
+    ja: "\u65E5\u672C\u8A9E",
+    zh: "\u4E2D\u6587",
+    es: "Espa\xF1ol",
+    fr: "Fran\xE7ais",
+    de: "Deutsch"
+  };
+  return defaultLabels[locale] || locale.toUpperCase();
+}
+function getAllLocalePaths(basePath, i18n) {
+  return i18n.locales.map((locale) => ({
+    locale,
+    path: getLocalizedPath(basePath, locale, i18n)
+  }));
+}
+
+export {
+  getLocaleFromPath,
+  removeLocaleFromPath,
+  getLocalizedPath,
+  getLocalizedNavGroup,
+  getLocaleLabel,
+  getAllLocalePaths
+};

package/dist/chunk-UICDSNBG.js

@@ -0,0 +1,68 @@
+// src/plugins/loader.ts
+async function loadPlugins(pluginConfigs, context) {
+  const resolved = [];
+  for (const config of pluginConfigs) {
+    const [name, options] = Array.isArray(config) ? config : [config, void 0];
+    try {
+      const pluginModule = await import(
+        /* @vite-ignore */
+        name
+      );
+      const pluginFactory = pluginModule.default || pluginModule;
+      if (typeof pluginFactory !== "function") {
+        throw new Error(`Plugin ${name} does not export a factory function`);
+      }
+      const plugin = options ? pluginFactory(options) : pluginFactory();
+      resolved.push({
+        name,
+        plugin,
+        options
+      });
+    } catch (error) {
+      console.warn(`Failed to load plugin ${name}:`, error);
+    }
+  }
+  return resolved;
+}
+async function runHook(plugins, hookName, ...args) {
+  for (const { plugin, name } of plugins) {
+    const hook = plugin.hooks?.[hookName];
+    if (hook) {
+      try {
+        await hook(...args);
+      } catch (error) {
+        console.error(`Error in plugin ${name} hook ${hookName}:`, error);
+      }
+    }
+  }
+}
+async function runConfigHook(plugins, config, context) {
+  let result = config;
+  for (const { plugin, name } of plugins) {
+    const hook = plugin.hooks?.["config:loaded"];
+    if (hook) {
+      try {
+        result = await hook(result, context);
+      } catch (error) {
+        console.error(`Error in plugin ${name} config:loaded hook:`, error);
+      }
+    }
+  }
+  return result;
+}
+function getPluginIntegrations(plugins, context) {
+  return plugins.filter((p) => p.plugin.astroIntegration).map((p) => p.plugin.astroIntegration(context));
+}
+
+// src/plugins/index.ts
+function definePlugin(factory) {
+  return factory;
+}
+
+export {
+  loadPlugins,
+  runHook,
+  runConfigHook,
+  getPluginIntegrations,
+  definePlugin
+};

package/dist/config/index.d.ts

@@ -0,0 +1,211 @@
+import { z } from 'zod';
+import { R as ResolvedBarodocConfig, a as BarodocConfig } from '../types-DaMSwPOk.js';
+import 'astro';
+
+declare const barodocConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    logo: z.ZodOptional<z.ZodString>;
+    favicon: z.ZodOptional<z.ZodString>;
+    theme: z.ZodOptional<z.ZodObject<{
+        colors: z.ZodOptional<z.ZodObject<{
+            primary: z.ZodOptional<z.ZodString>;
+            background: z.ZodOptional<z.ZodString>;
+            backgroundDark: z.ZodOptional<z.ZodString>;
+            text: z.ZodOptional<z.ZodString>;
+            textDark: z.ZodOptional<z.ZodString>;
+            border: z.ZodOptional<z.ZodString>;
+            borderDark: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            primary?: string | undefined;
+            background?: string | undefined;
+            backgroundDark?: string | undefined;
+            text?: string | undefined;
+            textDark?: string | undefined;
+            border?: string | undefined;
+            borderDark?: string | undefined;
+        }, {
+            primary?: string | undefined;
+            background?: string | undefined;
+            backgroundDark?: string | undefined;
+            text?: string | undefined;
+            textDark?: string | undefined;
+            border?: string | undefined;
+            borderDark?: string | undefined;
+        }>>;
+        fonts: z.ZodOptional<z.ZodObject<{
+            heading: z.ZodOptional<z.ZodString>;
+            body: z.ZodOptional<z.ZodString>;
+            code: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            code?: string | undefined;
+            heading?: string | undefined;
+            body?: string | undefined;
+        }, {
+            code?: string | undefined;
+            heading?: string | undefined;
+            body?: string | undefined;
+        }>>;
+        radius: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        colors?: {
+            primary?: string | undefined;
+            background?: string | undefined;
+            backgroundDark?: string | undefined;
+            text?: string | undefined;
+            textDark?: string | undefined;
+            border?: string | undefined;
+            borderDark?: string | undefined;
+        } | undefined;
+        fonts?: {
+            code?: string | undefined;
+            heading?: string | undefined;
+            body?: string | undefined;
+        } | undefined;
+        radius?: string | undefined;
+    }, {
+        colors?: {
+            primary?: string | undefined;
+            background?: string | undefined;
+            backgroundDark?: string | undefined;
+            text?: string | undefined;
+            textDark?: string | undefined;
+            border?: string | undefined;
+            borderDark?: string | undefined;
+        } | undefined;
+        fonts?: {
+            code?: string | undefined;
+            heading?: string | undefined;
+            body?: string | undefined;
+        } | undefined;
+        radius?: string | undefined;
+    }>>;
+    i18n: z.ZodOptional<z.ZodObject<{
+        defaultLocale: z.ZodString;
+        locales: z.ZodArray<z.ZodString, "many">;
+        labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        defaultLocale: string;
+        locales: string[];
+        labels?: Record<string, string> | undefined;
+    }, {
+        defaultLocale: string;
+        locales: string[];
+        labels?: Record<string, string> | undefined;
+    }>>;
+    navigation: z.ZodArray<z.ZodObject<{
+        group: z.ZodString;
+        pages: z.ZodArray<z.ZodString, "many">;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        group: z.ZodString;
+        pages: z.ZodArray<z.ZodString, "many">;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        group: z.ZodString;
+        pages: z.ZodArray<z.ZodString, "many">;
+    }, z.ZodTypeAny, "passthrough">>, "many">;
+    topbar: z.ZodOptional<z.ZodObject<{
+        github: z.ZodOptional<z.ZodString>;
+        discord: z.ZodOptional<z.ZodString>;
+        twitter: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        github?: string | undefined;
+        discord?: string | undefined;
+        twitter?: string | undefined;
+    }, {
+        github?: string | undefined;
+        discord?: string | undefined;
+        twitter?: string | undefined;
+    }>>;
+    search: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+    customCss: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    navigation: z.objectOutputType<{
+        group: z.ZodString;
+        pages: z.ZodArray<z.ZodString, "many">;
+    }, z.ZodTypeAny, "passthrough">[];
+    logo?: string | undefined;
+    favicon?: string | undefined;
+    theme?: {
+        colors?: {
+            primary?: string | undefined;
+            background?: string | undefined;
+            backgroundDark?: string | undefined;
+            text?: string | undefined;
+            textDark?: string | undefined;
+            border?: string | undefined;
+            borderDark?: string | undefined;
+        } | undefined;
+        fonts?: {
+            code?: string | undefined;
+            heading?: string | undefined;
+            body?: string | undefined;
+        } | undefined;
+        radius?: string | undefined;
+    } | undefined;
+    i18n?: {
+        defaultLocale: string;
+        locales: string[];
+        labels?: Record<string, string> | undefined;
+    } | undefined;
+    topbar?: {
+        github?: string | undefined;
+        discord?: string | undefined;
+        twitter?: string | undefined;
+    } | undefined;
+    search?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    customCss?: string[] | undefined;
+}, {
+    name: string;
+    navigation: z.objectInputType<{
+        group: z.ZodString;
+        pages: z.ZodArray<z.ZodString, "many">;
+    }, z.ZodTypeAny, "passthrough">[];
+    logo?: string | undefined;
+    favicon?: string | undefined;
+    theme?: {
+        colors?: {
+            primary?: string | undefined;
+            background?: string | undefined;
+            backgroundDark?: string | undefined;
+            text?: string | undefined;
+            textDark?: string | undefined;
+            border?: string | undefined;
+            borderDark?: string | undefined;
+        } | undefined;
+        fonts?: {
+            code?: string | undefined;
+            heading?: string | undefined;
+            body?: string | undefined;
+        } | undefined;
+        radius?: string | undefined;
+    } | undefined;
+    i18n?: {
+        defaultLocale: string;
+        locales: string[];
+        labels?: Record<string, string> | undefined;
+    } | undefined;
+    topbar?: {
+        github?: string | undefined;
+        discord?: string | undefined;
+        twitter?: string | undefined;
+    } | undefined;
+    search?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+    customCss?: string[] | undefined;
+}>;
+type BarodocConfigInput = z.input<typeof barodocConfigSchema>;
+type BarodocConfigOutput = z.output<typeof barodocConfigSchema>;
+
+declare function loadConfig(configPath: string, root: string): Promise<ResolvedBarodocConfig>;
+declare function getConfigDefaults(): Partial<BarodocConfig>;
+
+export { type BarodocConfigInput, type BarodocConfigOutput, barodocConfigSchema, getConfigDefaults, loadConfig };

package/dist/config/index.js

@@ -0,0 +1,10 @@
+import {
+  barodocConfigSchema,
+  getConfigDefaults,
+  loadConfig
+} from "../chunk-JQRBNHRZ.js";
+export {
+  barodocConfigSchema,
+  getConfigDefaults,
+  loadConfig
+};

package/dist/i18n/index.d.ts

@@ -0,0 +1,14 @@
+import { b as BarodocI18nConfig, c as BarodocNavItem } from '../types-DaMSwPOk.js';
+import 'astro';
+
+declare function getLocaleFromPath(path: string, i18n: BarodocI18nConfig): string;
+declare function removeLocaleFromPath(path: string, i18n: BarodocI18nConfig): string;
+declare function getLocalizedPath(path: string, locale: string, i18n: BarodocI18nConfig): string;
+declare function getLocalizedNavGroup(item: BarodocNavItem, locale: string, defaultLocale: string): string;
+declare function getLocaleLabel(locale: string, labels?: Record<string, string>): string;
+declare function getAllLocalePaths(basePath: string, i18n: BarodocI18nConfig): Array<{
+    locale: string;
+    path: string;
+}>;
+
+export { getAllLocalePaths, getLocaleFromPath, getLocaleLabel, getLocalizedNavGroup, getLocalizedPath, removeLocaleFromPath };

package/dist/i18n/index.js

@@ -0,0 +1,16 @@
+import {
+  getAllLocalePaths,
+  getLocaleFromPath,
+  getLocaleLabel,
+  getLocalizedNavGroup,
+  getLocalizedPath,
+  removeLocaleFromPath
+} from "../chunk-QMKA7OJU.js";
+export {
+  getAllLocalePaths,
+  getLocaleFromPath,
+  getLocaleLabel,
+  getLocalizedNavGroup,
+  getLocalizedPath,
+  removeLocaleFromPath
+};

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { AstroIntegration } from 'astro';
+import { B as BarodocOptions } from './types-DaMSwPOk.js';
+export { a as BarodocConfig, b as BarodocI18nConfig, c as BarodocNavItem, d as BarodocPlugin, e as BarodocPluginFactory, f as BarodocPluginHooks, g as BarodocThemeColors, h as BarodocThemeConfig, i as BuildContext, C as ContentContext, P as PluginConfig, j as PluginContext, R as ResolvedBarodocConfig, k as ResolvedPlugin, T as ThemeExport } from './types-DaMSwPOk.js';
+export { barodocConfigSchema, loadConfig } from './config/index.js';
+export { getLocaleFromPath, getLocaleLabel, getLocalizedNavGroup, getLocalizedPath, removeLocaleFromPath } from './i18n/index.js';
+export { definePlugin, getPluginIntegrations, loadPlugins, runConfigHook, runHook } from './plugins/index.js';
+import 'zod';
+
+declare function barodoc(options: BarodocOptions): AstroIntegration;
+
+export { BarodocOptions, barodoc as default };

package/dist/index.js

@@ -0,0 +1,100 @@
+import {
+  barodocConfigSchema,
+  loadConfig
+} from "./chunk-JQRBNHRZ.js";
+import {
+  getLocaleFromPath,
+  getLocaleLabel,
+  getLocalizedNavGroup,
+  getLocalizedPath,
+  removeLocaleFromPath
+} from "./chunk-QMKA7OJU.js";
+import {
+  definePlugin,
+  getPluginIntegrations,
+  loadPlugins,
+  runConfigHook,
+  runHook
+} from "./chunk-UICDSNBG.js";
+
+// src/integration.ts
+var VIRTUAL_CONFIG_ID = "virtual:barodoc/config";
+var VIRTUAL_I18N_ID = "virtual:barodoc/i18n";
+function resolveVirtualId(id) {
+  return `\0${id}`;
+}
+function createVirtualModulesPlugin(config) {
+  return {
+    name: "barodoc:virtual-modules",
+    resolveId(id) {
+      if (id === VIRTUAL_CONFIG_ID || id === VIRTUAL_I18N_ID) {
+        return resolveVirtualId(id);
+      }
+      return void 0;
+    },
+    load(id) {
+      if (id === resolveVirtualId(VIRTUAL_CONFIG_ID)) {
+        return `export default ${JSON.stringify(config)};`;
+      }
+      if (id === resolveVirtualId(VIRTUAL_I18N_ID)) {
+        return `
+          export const i18n = ${JSON.stringify(config.i18n)};
+          export const defaultLocale = "${config.i18n?.defaultLocale || "en"}";
+          export const locales = ${JSON.stringify(config.i18n?.locales || ["en"])};
+        `;
+      }
+      return void 0;
+    }
+  };
+}
+function barodoc(options) {
+  const configPath = options.config || "barodoc.config.json";
+  let resolvedConfig;
+  return {
+    name: "@barodoc/core",
+    hooks: {
+      "astro:config:setup": async ({
+        config,
+        updateConfig,
+        logger
+      }) => {
+        logger.info("Loading Barodoc configuration...");
+        const rootPath = config.root instanceof URL ? config.root.pathname : String(config.root);
+        resolvedConfig = await loadConfig(configPath, rootPath);
+        logger.info(`Loaded config: ${resolvedConfig.name}`);
+        const i18nConfig = resolvedConfig.i18n || {
+          defaultLocale: "en",
+          locales: ["en"]
+        };
+        const themeIntegration = options.theme.integration();
+        updateConfig({
+          vite: {
+            plugins: [createVirtualModulesPlugin(resolvedConfig)]
+          },
+          integrations: [themeIntegration]
+        });
+        logger.info(
+          `i18n configured: ${i18nConfig.locales.length} locale(s)`
+        );
+      },
+      "astro:config:done": ({ logger }) => {
+        logger.info("Barodoc setup complete");
+      }
+    }
+  };
+}
+export {
+  barodocConfigSchema,
+  barodoc as default,
+  definePlugin,
+  getLocaleFromPath,
+  getLocaleLabel,
+  getLocalizedNavGroup,
+  getLocalizedPath,
+  getPluginIntegrations,
+  loadConfig,
+  loadPlugins,
+  removeLocaleFromPath,
+  runConfigHook,
+  runHook
+};

package/dist/plugins/index.d.ts

@@ -0,0 +1,27 @@
+import { k as ResolvedPlugin, j as PluginContext, P as PluginConfig, R as ResolvedBarodocConfig, f as BarodocPluginHooks, d as BarodocPlugin } from '../types-DaMSwPOk.js';
+export { e as BarodocPluginFactory, i as BuildContext, C as ContentContext } from '../types-DaMSwPOk.js';
+import * as astro from 'astro';
+
+/**
+ * Load plugins from config
+ */
+declare function loadPlugins(pluginConfigs: PluginConfig[], context: PluginContext): Promise<ResolvedPlugin[]>;
+/**
+ * Run a specific hook for all plugins
+ */
+declare function runHook<K extends keyof BarodocPluginHooks>(plugins: ResolvedPlugin[], hookName: K, ...args: Parameters<NonNullable<BarodocPluginHooks[K]>>): Promise<void>;
+/**
+ * Run config:loaded hook and return modified config
+ */
+declare function runConfigHook(plugins: ResolvedPlugin[], config: ResolvedBarodocConfig, context: PluginContext): Promise<ResolvedBarodocConfig>;
+/**
+ * Get Astro integrations from plugins
+ */
+declare function getPluginIntegrations(plugins: ResolvedPlugin[], context: PluginContext): astro.AstroIntegration[];
+
+/**
+ * Helper to define a plugin with type safety
+ */
+declare function definePlugin<T = void>(factory: T extends void ? () => BarodocPlugin : (options: T) => BarodocPlugin): T extends void ? () => BarodocPlugin : (options: T) => BarodocPlugin;
+
+export { BarodocPlugin, BarodocPluginHooks, PluginConfig, PluginContext, ResolvedPlugin, definePlugin, getPluginIntegrations, loadPlugins, runConfigHook, runHook };

package/dist/plugins/index.js

@@ -0,0 +1,14 @@
+import {
+  definePlugin,
+  getPluginIntegrations,
+  loadPlugins,
+  runConfigHook,
+  runHook
+} from "../chunk-UICDSNBG.js";
+export {
+  definePlugin,
+  getPluginIntegrations,
+  loadPlugins,
+  runConfigHook,
+  runHook
+};

package/dist/types-DaMSwPOk.d.ts

@@ -0,0 +1,151 @@
+import { AstroIntegration } from 'astro';
+
+/**
+ * Plugin hook context
+ */
+interface PluginContext {
+    config: ResolvedBarodocConfig;
+    root: string;
+    mode: "development" | "production";
+}
+/**
+ * Content transformation context
+ */
+interface ContentContext {
+    filePath: string;
+    content: string;
+    frontmatter: Record<string, unknown>;
+}
+/**
+ * Build context
+ */
+interface BuildContext {
+    outDir: string;
+    pages: string[];
+}
+/**
+ * Plugin hooks
+ */
+interface BarodocPluginHooks {
+    /**
+     * Called after config is loaded
+     * Can modify the config
+     */
+    "config:loaded"?: (config: ResolvedBarodocConfig, context: PluginContext) => ResolvedBarodocConfig | Promise<ResolvedBarodocConfig>;
+    /**
+     * Called for each content file
+     * Can transform content
+     */
+    "content:transform"?: (context: ContentContext) => ContentContext | Promise<ContentContext>;
+    /**
+     * Called before build starts
+     */
+    "build:start"?: (context: PluginContext) => void | Promise<void>;
+    /**
+     * Called after build completes
+     */
+    "build:done"?: (buildContext: BuildContext, context: PluginContext) => void | Promise<void>;
+}
+/**
+ * Barodoc plugin definition
+ */
+interface BarodocPlugin {
+    /**
+     * Plugin name (should be unique)
+     */
+    name: string;
+    /**
+     * Plugin hooks
+     */
+    hooks?: BarodocPluginHooks;
+    /**
+     * Astro integration to add
+     */
+    astroIntegration?: (context: PluginContext) => AstroIntegration;
+}
+/**
+ * Plugin factory function
+ */
+type BarodocPluginFactory<T = void> = T extends void ? () => BarodocPlugin : (options: T) => BarodocPlugin;
+/**
+ * Plugin configuration in barodoc.config.json
+ * Can be:
+ * - string: plugin name (e.g., "@barodoc/plugin-sitemap")
+ * - [string, object]: plugin with options (e.g., ["@barodoc/plugin-analytics", { id: "G-XXX" }])
+ */
+type PluginConfig = string | [string, Record<string, unknown>];
+/**
+ * Resolved plugin with options
+ */
+interface ResolvedPlugin {
+    name: string;
+    plugin: BarodocPlugin;
+    options?: Record<string, unknown>;
+}
+
+interface BarodocNavItem {
+    group: string;
+    "group:ko"?: string;
+    "group:ja"?: string;
+    [key: `group:${string}`]: string | undefined;
+    pages: string[];
+}
+interface BarodocI18nConfig {
+    defaultLocale: string;
+    locales: string[];
+    labels?: Record<string, string>;
+}
+interface BarodocThemeColors {
+    primary?: string;
+    background?: string;
+    backgroundDark?: string;
+    text?: string;
+    textDark?: string;
+    border?: string;
+    borderDark?: string;
+}
+interface BarodocThemeConfig {
+    colors?: BarodocThemeColors;
+    fonts?: {
+        heading?: string;
+        body?: string;
+        code?: string;
+    };
+    radius?: string;
+}
+interface BarodocConfig {
+    name: string;
+    logo?: string;
+    favicon?: string;
+    theme?: BarodocThemeConfig;
+    i18n?: BarodocI18nConfig;
+    navigation: BarodocNavItem[];
+    topbar?: {
+        github?: string;
+        discord?: string;
+        twitter?: string;
+    };
+    search?: {
+        enabled?: boolean;
+    };
+    plugins?: PluginConfig[];
+    customCss?: string[];
+}
+interface ThemeExport {
+    name: string;
+    integration: () => AstroIntegration;
+    pages?: Record<string, () => Promise<unknown>>;
+    layouts?: Record<string, () => Promise<unknown>>;
+    components?: Record<string, () => Promise<unknown>>;
+    styles?: string[];
+}
+interface BarodocOptions {
+    config?: string;
+    theme: ThemeExport;
+}
+interface ResolvedBarodocConfig extends BarodocConfig {
+    _resolved: true;
+    _configPath: string;
+}
+
+export type { BarodocOptions as B, ContentContext as C, PluginConfig as P, ResolvedBarodocConfig as R, ThemeExport as T, BarodocConfig as a, BarodocI18nConfig as b, BarodocNavItem as c, BarodocPlugin as d, BarodocPluginFactory as e, BarodocPluginHooks as f, BarodocThemeColors as g, BarodocThemeConfig as h, BuildContext as i, PluginContext as j, ResolvedPlugin as k };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@barodoc/core",
+  "version": "0.0.1",
+  "description": "Core integration for Barodoc documentation framework",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./config": {
+      "types": "./dist/config/index.d.ts",
+      "import": "./dist/config/index.js"
+    },
+    "./i18n": {
+      "types": "./dist/i18n/index.d.ts",
+      "import": "./dist/i18n/index.js"
+    },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.ts",
+      "import": "./dist/plugins/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "zod": "^3.24.0"
+  },
+  "peerDependencies": {
+    "astro": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "astro": "^5.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0"
+  },
+  "keywords": [
+    "astro",
+    "astro-integration",
+    "documentation",
+    "barodoc"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/barocss/barodoc.git",
+    "directory": "packages/core"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch"
+  }
+}