@riebeckite/honox 0.0.1

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+export type { ResolvedContentRoute } from "./src/content_route.js";
+export { contentRouteSsgParams, resolveContentRoute, ssgEnumerableHandler, } from "./src/content_route.js";
+export { mountRiebeckiteEndpoints } from "./src/endpoints.js";

package/dist/server.js

@@ -0,0 +1,131 @@
+// src/content_route.ts
+function resolveContentRoute(manifest, pathname) {
+  const path = normalizeRequestPath(pathname);
+  const entry = manifest.byPermalink.get(path);
+  if (entry) return { kind: "content", entry };
+  const redirect = manifest.redirects.get(path);
+  if (!redirect) return null;
+  const target = manifest.bySlug.get(redirect.slug);
+  if (!target) return null;
+  return {
+    kind: "redirect",
+    location: target.permalink,
+    status: redirect.status
+  };
+}
+function contentRouteSsgParams(routePath, params) {
+  return async (c, next) => {
+    if (c.req.path !== routePath || !isDynamicRoute(routePath)) {
+      await next();
+      return;
+    }
+    c.req.raw.ssgParams = typeof params === "function" ? await params(c) : params;
+    return c.notFound();
+  };
+}
+function ssgEnumerableHandler(handler) {
+  const enumerable = (...args) => Reflect.apply(handler, void 0, args);
+  return enumerable;
+}
+function isDynamicRoute(path) {
+  return path.split("/").some((segment) => segment.startsWith(":") || segment.includes("*"));
+}
+function normalizeRequestPath(pathname) {
+  const trailingSlash = pathname.length > 1 && pathname.endsWith("/");
+  const segments = pathname.split("/").filter(Boolean).map(decodeSegment);
+  const path = `/${segments.join("/")}`;
+  return trailingSlash ? `${path}/` : path;
+}
+function decodeSegment(segment) {
+  try {
+    return decodeURIComponent(segment);
+  } catch {
+    return segment;
+  }
+}
+
+// src/endpoints.ts
+function mountRiebeckiteEndpoints(app, options) {
+  const endpoints = collectPluginEndpoints(options.config);
+  for (const endpoint of endpoints) {
+    app.get(endpoint.path, async (context) => {
+      const manifest = await options.content.getManifest();
+      const response = await endpoint.handler({
+        config: options.config,
+        manifest
+      });
+      return toHonoResponse(context, response);
+    });
+  }
+}
+function collectPluginEndpoints(config) {
+  const endpoints = config.plugins.flatMap(
+    (plugin) => (plugin.endpoints ?? []).map((endpoint) => ({
+      endpoint,
+      pluginName: plugin.name
+    }))
+  );
+  const registeredKeys = /* @__PURE__ */ new Map();
+  for (const { endpoint, pluginName } of endpoints) {
+    validateEndpointPath(endpoint.path);
+    const method = endpoint.method ?? "GET";
+    const key = `${method} ${endpoint.path}`;
+    const owner = registeredKeys.get(key);
+    if (owner) {
+      throw new Error(
+        `Duplicate Riebeckite plugin endpoint detected: ${key} is declared by both "${owner}" and "${pluginName}".`
+      );
+    }
+    registeredKeys.set(key, pluginName);
+  }
+  return endpoints.map(({ endpoint }) => endpoint);
+}
+function validateEndpointPath(path) {
+  if (!path.startsWith("/")) {
+    throw new Error(
+      `Invalid Riebeckite plugin endpoint path: "${path}" must start with "/".`
+    );
+  }
+  if (path.length === 1 || path.includes("?") || path.includes("#")) {
+    throw new Error(
+      `Invalid Riebeckite plugin endpoint path: "${path}" must be a static path without query or hash.`
+    );
+  }
+  if (/\s/.test(path) || path.includes("//") || path.includes(":")) {
+    throw new Error(
+      `Invalid Riebeckite plugin endpoint path: "${path}" contains unsupported dynamic or malformed segments.`
+    );
+  }
+  if (path === "/assets" || path.startsWith("/assets/")) {
+    throw new Error(
+      `Invalid Riebeckite plugin endpoint path: "${path}" conflicts with the static assets namespace.`
+    );
+  }
+}
+function toHonoResponse(context, response) {
+  const status = response.status ?? 200;
+  if ("json" in response) {
+    return context.json(response.json, status, response.headers);
+  }
+  if (response.body === void 0) {
+    return context.body("", status, response.headers);
+  }
+  const contentType = findHeader(response.headers, "content-type");
+  if (contentType?.startsWith("text/")) {
+    return context.text(response.body, status, response.headers);
+  }
+  return context.body(response.body, status, response.headers);
+}
+function findHeader(headers, name) {
+  if (!headers) return void 0;
+  const key = Object.keys(headers).find(
+    (header) => header.toLowerCase() === name.toLowerCase()
+  );
+  return key ? headers[key] : void 0;
+}
+export {
+  contentRouteSsgParams,
+  mountRiebeckiteEndpoints,
+  resolveContentRoute,
+  ssgEnumerableHandler
+};

package/dist/src/asset_entries.d.ts

@@ -0,0 +1,6 @@
+import { type ResolvedRiebeckiteConfig } from "@riebeckite/core";
+export type GeneratedAssetPaths = {
+    pluginStyles: string;
+    themeStyles: string;
+};
+export declare function writeRiebeckiteAssetEntries(config: ResolvedRiebeckiteConfig, paths: GeneratedAssetPaths): void;

package/dist/src/client_module.d.ts

@@ -0,0 +1,3 @@
+import type { ResolvedRiebeckiteConfig } from "@riebeckite/core";
+import type { Plugin } from "vite";
+export declare function riebeckiteClientModule(getConfig: () => ResolvedRiebeckiteConfig): Plugin;

package/dist/src/config_loader.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedRiebeckiteConfig } from "@riebeckite/core";
+export type RiebeckiteConfigLoaderOptions = {
+    configRoot: string;
+    configFile?: string;
+    workspaceRoot?: string;
+};
+export declare function loadRiebeckiteConfig(options: RiebeckiteConfigLoaderOptions): Promise<ResolvedRiebeckiteConfig>;
+export declare function resolveHonoxConfig(config: ResolvedRiebeckiteConfig, appRoot: string): ResolvedRiebeckiteConfig;

package/dist/src/content_route.d.ts

@@ -0,0 +1,33 @@
+import type { ContentManifest, ContentManifestEntry } from "@riebeckite/core";
+import type { Context, Handler, MiddlewareHandler } from "hono";
+export type ResolvedContentRoute = {
+    kind: "content";
+    entry: ContentManifestEntry;
+} | {
+    kind: "redirect";
+    location: string;
+    status: 301 | 302 | 307 | 308;
+} | null;
+export declare function resolveContentRoute(manifest: ContentManifest, pathname: string): ResolvedContentRoute;
+type SsgParams = Record<string, string>[];
+/**
+ * SSG parameter middleware for a catch-all content route.
+ *
+ * `ssgParams` from `hono/ssg` decides whether to emit params only from the
+ * request path. When a shallow catch-all (for example `/:slug{.+}`) is
+ * registered before a deeper one (`/tags/:slug{.+}`), the shallow route
+ * captures the enumeration request of the deeper route and injects its own
+ * params. This helper responds only to the enumeration request that belongs to
+ * `routePath`, so sibling catch-all routes can enumerate their own params.
+ */
+export declare function contentRouteSsgParams(routePath: string, params: SsgParams | ((c: Context) => SsgParams | Promise<SsgParams>)): MiddlewareHandler;
+/**
+ * Make a route handler visible to Hono's SSG route enumeration.
+ *
+ * `toSSG` skips any route whose final handler is a middleware, which Hono
+ * detects with `handler.length > 1`. A catch-all content route sometimes needs
+ * `next()` to defer to a more specific route, so wrapping the handler in a
+ * rest-parameter function keeps `length === 0` while preserving `(c, next)`.
+ */
+export declare function ssgEnumerableHandler<H extends Handler<any, any, any>>(handler: H): H;
+export {};

package/dist/src/endpoints.d.ts

@@ -0,0 +1,15 @@
+import type { ContentManager, ResolvedRiebeckiteConfig } from "@riebeckite/core";
+export type RiebeckiteEndpointMountOptions = {
+    config: ResolvedRiebeckiteConfig;
+    content: ContentManager;
+};
+type HonoLikeApp = {
+    get(path: string, handler: (context: HonoLikeContext) => Promise<unknown>): void;
+};
+type HonoLikeContext = {
+    json(body: unknown, status?: number, headers?: Record<string, string>): unknown;
+    body(body: string, status?: number, headers?: Record<string, string>): unknown;
+    text(body: string, status?: number, headers?: Record<string, string>): unknown;
+};
+export declare function mountRiebeckiteEndpoints(app: HonoLikeApp, options: RiebeckiteEndpointMountOptions): void;
+export {};

package/dist/src/scaffold/index.d.ts

@@ -0,0 +1,17 @@
+export type ScaffoldSiteOptions = {
+    readonly targetDirectory: string;
+    readonly name?: string;
+    readonly siteTitle?: string;
+    readonly description?: string;
+    readonly baseUrl?: string;
+    readonly locale?: string;
+    readonly overwrite?: boolean;
+};
+export type ScaffoldSiteResult = {
+    readonly targetDirectory: string;
+    readonly files: readonly string[];
+};
+export declare class ScaffoldSiteError extends Error {
+    constructor(message: string);
+}
+export declare function scaffoldRiebeckiteSite(options: ScaffoldSiteOptions): Promise<ScaffoldSiteResult>;

package/dist/src/scaffold/templates.d.ts

@@ -0,0 +1,12 @@
+export type SiteTemplateVariables = {
+    readonly name: string;
+    readonly title: string;
+    readonly description: string;
+    readonly baseUrl: string;
+    readonly locale: string;
+};
+export type SiteTemplateFile = {
+    readonly path: string;
+    readonly content: string;
+};
+export declare function siteTemplateFiles(variables: SiteTemplateVariables): readonly SiteTemplateFile[];

package/dist/src/ssg.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from "vite";
+import { type RiebeckiteSsgOptions } from "./ssg_plugin.js";
+/**
+ * Root-relative SSG entry for a Riebeckite site. HonoX keeps the server entry
+ * at `app/server.ts`, so sites do not need to compute an absolute path.
+ */
+export declare const defaultSsgEntry = "./app/server.ts";
+export declare function riebeckiteSsgExtensionMap(): Record<string, string>;
+/**
+ * Higher-level SSG factory that hides Riebeckite's internal entry and
+ * extension-map defaults. Use `riebeckiteSsg` directly when full control is
+ * required; this wrapper only fills in the values a normal site never sets.
+ */
+export declare function createRiebeckiteSsg(options?: RiebeckiteSsgOptions): Plugin;

package/dist/src/ssg_plugin.d.ts

@@ -0,0 +1,10 @@
+import { toSSG } from "hono/ssg";
+import { type Plugin } from "vite";
+type ToSsgOptions = NonNullable<Parameters<typeof toSSG>[2]>;
+export type RiebeckiteSsgOptions = {
+    entry?: string;
+    plugins?: ToSsgOptions["plugins"];
+    extensionMap?: Record<string, string>;
+};
+export declare function riebeckiteSsg(options?: RiebeckiteSsgOptions): Plugin;
+export {};

package/dist/src/ui/primitives.d.ts

@@ -0,0 +1,48 @@
+export type PrimitiveChildren = unknown;
+export type PrimitiveProps = {
+    children?: PrimitiveChildren;
+    class?: string;
+    className?: string;
+};
+export type PrimitiveClassProps = {
+    class?: string;
+    className?: string;
+};
+export type ArticleProps = PrimitiveProps & {
+    "data-slot"?: string;
+};
+export type ArticleLayoutProps = PrimitiveProps & {
+    aside?: PrimitiveChildren;
+};
+export type ArticleHeaderProps = (PrimitiveClassProps & {
+    dangerouslySetInnerHTML: {
+        __html: string;
+    };
+    children?: never;
+}) | (PrimitiveClassProps & {
+    dangerouslySetInnerHTML?: never;
+    children?: PrimitiveChildren;
+});
+export type ArticleContentProps = (PrimitiveClassProps & {
+    html: string;
+    children?: never;
+    "data-slot"?: string;
+}) | (PrimitiveClassProps & {
+    html?: never;
+    children?: PrimitiveChildren;
+    "data-slot"?: string;
+});
+export type ArticleMetaProps = PrimitiveProps & {
+    label?: string;
+};
+export type SidebarProps = PrimitiveProps & {
+    label?: string;
+};
+export type ArticleFooterProps = PrimitiveProps;
+export declare function Article(props: ArticleProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+export declare function ArticleLayout(props: ArticleLayoutProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+export declare function ArticleHeader(props: ArticleHeaderProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+export declare function ArticleMeta(props: ArticleMetaProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+export declare function ArticleContent(props: ArticleContentProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+export declare function ArticleFooter(props: ArticleFooterProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;
+export declare function Sidebar(props: SidebarProps): import("hono/jsx/jsx-dev-runtime").JSX.Element;

package/dist/src/ui/primitives.js

@@ -0,0 +1,113 @@
+// src/ui/primitives.tsx
+import { jsx, jsxs } from "hono/jsx/jsx-runtime";
+function Article(props) {
+  return /* @__PURE__ */ jsx(
+    "article",
+    {
+      class: joinClassNames(
+        "article-shell rb-article",
+        props.class,
+        props.className
+      ),
+      "data-slot": props["data-slot"] ?? "article",
+      children: props.children
+    }
+  );
+}
+function ArticleLayout(props) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      class: joinClassNames(
+        "article-shell__layout rb-article-layout",
+        props.class,
+        props.className
+      ),
+      children: [
+        props.children,
+        props.aside
+      ]
+    }
+  );
+}
+function ArticleHeader(props) {
+  const className = joinClassNames(
+    "article-shell__lead rb-article-header",
+    props.class,
+    props.className
+  );
+  if (props.dangerouslySetInnerHTML !== void 0) {
+    return /* @__PURE__ */ jsx(
+      "header",
+      {
+        class: className,
+        dangerouslySetInnerHTML: props.dangerouslySetInnerHTML
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx("header", { class: className, children: props.children });
+}
+function ArticleMeta(props) {
+  return /* @__PURE__ */ jsx(
+    "aside",
+    {
+      class: joinClassNames(
+        "article-frontmatter rb-article-meta",
+        props.class,
+        props.className
+      ),
+      "aria-label": props.label ?? "Article metadata",
+      children: props.children
+    }
+  );
+}
+function ArticleContent(props) {
+  const className = joinClassNames(
+    "article-shell__body rb-article-body",
+    props.class,
+    props.className
+  );
+  const dataSlot = props["data-slot"] ?? "article-body";
+  if (props.html !== void 0) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        class: className,
+        "data-slot": dataSlot,
+        dangerouslySetInnerHTML: { __html: props.html }
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx("div", { class: className, "data-slot": dataSlot, children: props.children });
+}
+function ArticleFooter(props) {
+  return /* @__PURE__ */ jsx(
+    "footer",
+    {
+      class: joinClassNames("rb-article-footer", props.class, props.className),
+      children: props.children
+    }
+  );
+}
+function Sidebar(props) {
+  return /* @__PURE__ */ jsx(
+    "aside",
+    {
+      class: joinClassNames("rb-sidebar", props.class, props.className),
+      "aria-label": props.label,
+      children: props.children
+    }
+  );
+}
+function joinClassNames(...classNames) {
+  return classNames.filter(Boolean).join(" ");
+}
+export {
+  Article,
+  ArticleContent,
+  ArticleFooter,
+  ArticleHeader,
+  ArticleLayout,
+  ArticleMeta,
+  Sidebar
+};

package/dist/src/vite_plugin.d.ts

@@ -0,0 +1,31 @@
+import type { Plugin } from "vite";
+import type { RiebeckiteSsgOptions } from "./ssg_plugin.js";
+export type RiebeckiteIntegrationOptions = {
+    configRoot?: string;
+    workspaceRoot?: string;
+    appRoot?: string;
+    configFile?: string;
+};
+/**
+ * SSR externals Riebeckite's own runtime requires the application to leave
+ * external. These are internal to the integration: sites should not have to
+ * restate the Vite `environments.ssr.resolve.external` list.
+ */
+export declare const defaultSsrExternals: readonly ["extend", "debug", "node:fs/promises", "node:path", "parse-numeric-range", "slugify", "vfile-matter"];
+export type RiebeckiteViteOptions = RiebeckiteIntegrationOptions & {
+    /** Extra SSR externals appended after Riebeckite's defaults. */
+    ssrExternals?: readonly string[];
+    /** SSG overrides. A normal site does not need them. */
+    ssg?: RiebeckiteSsgOptions;
+};
+export declare function riebeckite(options?: RiebeckiteIntegrationOptions): Plugin[];
+/**
+ * Higher-level helper that registers the complete Riebeckite Vite integration
+ * without exposing internal Vite/HonoX/SSR details. A site only needs to add
+ * its own plugins (for example the HonoX plugin and its deployment build
+ * plugin) around this call.
+ *
+ * `riebeckite`, `riebeckiteSsg`, and `riebeckiteSsgExtensionMap` remain
+ * available for callers that need the lower-level pieces.
+ */
+export declare function riebeckiteVite(options?: RiebeckiteViteOptions): Plugin[];

package/dist/src/vite_runner.d.ts

@@ -0,0 +1,22 @@
+import type { ResolvedRiebeckiteConfig, Tracer } from "@riebeckite/core";
+import { type RiebeckiteConfigLoaderOptions } from "./config_loader.js";
+export type HonoxApplicationOptions = {
+    root: string;
+    tracer?: Tracer;
+};
+export type ResolvedHonoxApplication = {
+    config: ResolvedRiebeckiteConfig;
+    configRoot: string;
+    appRoot: string;
+    contentRoot: string;
+};
+export type ResolveHonoxApplicationOptions = RiebeckiteConfigLoaderOptions & {
+    appRoot?: string;
+};
+export declare function resolveHonoxApplicationRoot(configRoot: string): Promise<string>;
+export declare class HonoxApplicationRootError extends Error {
+    constructor(message: string);
+}
+export declare function resolveHonoxApplication(options: ResolveHonoxApplicationOptions): Promise<ResolvedHonoxApplication>;
+export declare function startHonoxDevServer(options: HonoxApplicationOptions): Promise<void>;
+export declare function buildHonoxApplication(options: HonoxApplicationOptions): Promise<void>;

package/dist/src/workspace_packages.d.ts

@@ -0,0 +1,16 @@
+export declare function createWorkspacePackageAliases(workspaceRoot: string): {
+    find: RegExp;
+    replacement: string;
+}[];
+export declare function workspacePackageResolver(workspaceRoot: string): {
+    name: string;
+    setup(buildApi: {
+        onResolve: (options: {
+            filter: RegExp;
+        }, callback: (args: {
+            path: string;
+        }) => {
+            path: string;
+        } | null) => void;
+    }): void;
+};

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@riebeckite/honox",
+  "version": "0.0.1",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "source": "./index.ts",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.js",
+      "source": "./server.ts",
+      "default": "./dist/server.js"
+    },
+    "./ui": {
+      "types": "./dist/src/ui/primitives.d.ts",
+      "import": "./dist/src/ui/primitives.js",
+      "source": "./src/ui/primitives.tsx",
+      "default": "./dist/src/ui/primitives.js"
+    }
+  },
+  "dependencies": {
+    "esbuild": "^0.28.2",
+    "hono": "^4.12.25",
+    "vite": "^8.0.9",
+    "@riebeckite/core": "0.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "README_ja.md",
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rerurate514/riebeckite.git",
+    "directory": "packages/integrations/honox"
+  },
+  "homepage": "https://github.com/Rerurate514/riebeckite#readme",
+  "bugs": {
+    "url": "https://github.com/Rerurate514/riebeckite/issues"
+  },
+  "description": "HonoX and Vite integration for building Riebeckite sites.",
+  "keywords": [
+    "riebeckite",
+    "honox",
+    "vite",
+    "static-site-generator"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "node ../../../scripts/build_package.mjs"
+  }
+}