@riebeckite/core 0.0.31 → 0.0.32

package/dist/client.d.ts

@@ -1,2 +1,4 @@
+export type { ClientCleanup, ClientInitializer, ClientInitializerContext, ClientLifecycleErrorContext, ClientLifecycleMount, ClientLifecycleOptions, ClientLifecycleScope, ClientResourceScope, } from "./src/client_lifecycle.js";
+export { ClientLifecycle } from "./src/client_lifecycle.js";
 export type { ForceGraphLayoutOptions, ForceLayoutGuardOptions, GraphEdge, GraphLayoutNode, LinkableGraphNode, RadialGraphLayoutOptions, } from "./src/content/graph_layout.js";
 export { buildGraphEdges, FORCE_LAYOUT_CONFIRM_NODE_COUNT, layoutForceGraph, layoutRadialGraph, shouldGuardForceLayout, } from "./src/content/graph_layout.js";

package/dist/client.js

@@ -1,3 +1,179 @@
+// src/client_lifecycle.ts
+var ClientLifecycle = class {
+  mounted = /* @__PURE__ */ new Map();
+  scopes = /* @__PURE__ */ new Map();
+  onError;
+  constructor(options = {}) {
+    this.onError = options.onError ?? defaultErrorReporter;
+  }
+  mount(mount) {
+    const scoped = this.scoped(mount.scope);
+    const current = scoped.get(mount.name);
+    if (current) {
+      if (current.root === mount.root) return current.ready;
+      throw new Error(
+        `Client initializer "${mount.name}" is already mounted in ${mount.scope} scope.`
+      );
+    }
+    const scope = this.scopeState(mount.scope);
+    const resources = new InitializerResources(
+      scope.controller,
+      (error) => this.report(error, {
+        scope: mount.scope,
+        name: mount.name,
+        phase: "cleanup"
+      })
+    );
+    const cleanup = this.initialize(mount, resources);
+    const ready = cleanup.then(() => void 0);
+    const mounted = { root: mount.root, resources, cleanup, ready };
+    scoped.set(mount.name, mounted);
+    return ready;
+  }
+  async unmount(scope) {
+    const scoped = this.mounted.get(scope);
+    const state = this.scopes.get(scope);
+    this.mounted.delete(scope);
+    this.scopes.delete(scope);
+    state?.controller.abort();
+    if (!scoped) return;
+    await Promise.all(
+      [...scoped.entries()].map(
+        ([name, mounted]) => this.cleanupMounted(scope, name, mounted)
+      )
+    );
+  }
+  async dispose() {
+    await Promise.all([this.unmount("page"), this.unmount("app")]);
+  }
+  scoped(scope) {
+    let scoped = this.mounted.get(scope);
+    if (!scoped) {
+      scoped = /* @__PURE__ */ new Map();
+      this.mounted.set(scope, scoped);
+    }
+    return scoped;
+  }
+  scopeState(scope) {
+    let state = this.scopes.get(scope);
+    if (!state) {
+      state = { controller: new AbortController() };
+      this.scopes.set(scope, state);
+    }
+    return state;
+  }
+  async initialize(mount, resources) {
+    try {
+      const result = await mount.initialize({
+        root: mount.root,
+        signal: resources.signal,
+        scope: resources,
+        config: mount.config
+      });
+      return typeof result === "function" ? result : void 0;
+    } catch (error) {
+      await resources.dispose();
+      this.report(error, {
+        scope: mount.scope,
+        name: mount.name,
+        phase: "initialize"
+      });
+      return void 0;
+    }
+  }
+  async cleanupMounted(scope, name, mounted) {
+    const [cleanup] = await Promise.all([
+      mounted.cleanup,
+      mounted.resources.dispose()
+    ]);
+    try {
+      await cleanup?.();
+    } catch (error) {
+      this.report(error, { scope, name, phase: "cleanup" });
+    }
+  }
+  report(error, context) {
+    try {
+      this.onError(error, context);
+    } catch {
+      return;
+    }
+  }
+};
+var InitializerResources = class {
+  constructor(controller, report) {
+    this.controller = controller;
+    this.report = report;
+  }
+  controller;
+  report;
+  cleanups = [];
+  listeners = [];
+  timers = /* @__PURE__ */ new Set();
+  intervals = /* @__PURE__ */ new Set();
+  disposed = false;
+  get signal() {
+    return this.controller.signal;
+  }
+  on(target, type, listener, options) {
+    if (this.disposed || this.signal.aborted) return;
+    target.addEventListener(type, listener, {
+      ...options,
+      signal: this.signal
+    });
+    this.listeners.push({ target, type, listener, options });
+  }
+  timeout(callback, delay = 0) {
+    if (this.disposed || this.signal.aborted) return;
+    const timer = setTimeout(() => {
+      this.timers.delete(timer);
+      if (!this.disposed && !this.signal.aborted) callback();
+    }, delay);
+    this.timers.add(timer);
+  }
+  interval(callback, delay = 0) {
+    if (this.disposed || this.signal.aborted) return;
+    const interval = setInterval(() => {
+      if (!this.disposed && !this.signal.aborted) callback();
+    }, delay);
+    this.intervals.add(interval);
+  }
+  cleanup(cleanup) {
+    if (this.disposed) {
+      void this.run(cleanup);
+      return;
+    }
+    this.cleanups.push(cleanup);
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    for (const { target, type, listener, options } of this.listeners) {
+      target.removeEventListener(type, listener, options);
+    }
+    this.listeners.length = 0;
+    for (const timer of this.timers) clearTimeout(timer);
+    for (const interval of this.intervals) clearInterval(interval);
+    this.timers.clear();
+    this.intervals.clear();
+    const cleanups = this.cleanups.splice(0).reverse();
+    await Promise.all(cleanups.map((cleanup) => this.run(cleanup)));
+  }
+  async run(cleanup) {
+    try {
+      await cleanup();
+    } catch (error) {
+      this.report(error);
+    }
+  }
+};
+function defaultErrorReporter(error, context) {
+  console.error(
+    `[riebeckite] Client initializer ${context.phase} failed: ${context.name}`,
+    error
+  );
+}
+
 // src/content/graph_layout.ts
 var FORCE_LAYOUT_CONFIRM_NODE_COUNT = 500;
 function shouldGuardForceLayout(options) {
@@ -176,6 +352,7 @@ function clampFinite(value, min, max) {
   return clamp(value, min, max);
 }
 export {
+  ClientLifecycle,
   FORCE_LAYOUT_CONFIRM_NODE_COUNT,
   buildGraphEdges,
   layoutForceGraph,

package/dist/index.d.ts

@@ -47,6 +47,7 @@ export { PluginDependencyError, type PluginDependencyErrorKind, } from "./src/pl
 export { PluginHookError } from "./src/plugin/plugin_lifecycle.js";
 export type { CreatePluginMemoOptions, PluginMemo, } from "./src/plugin/plugin_memo.js";
 export { createPluginMemo, stableStringify, } from "./src/plugin/plugin_memo.js";
+export { PluginRuntime } from "./src/plugin/plugin_runtime.js";
 export { resolveBuildOutputDirectory, resolveManagedStateRoot, } from "./src/project/project_layout.js";
 export type { ConfigValidationIssue, PluginOptionsValidator, } from "./src/types/config_validation.js";
 export type { ContentAsset, ContentFileMetadata, ContentLink, ContentLinkKind, ContentLocationInput, ContentManifest, ContentManifestEntry, ContentManifestPluginClientEntry, ContentPublicLocation, ContentRedirect, FolderLocation, PluginPageRoute, } from "./src/types/content_manifest.js";
@@ -73,7 +74,7 @@ export type { PostContent, PostFrontmatter } from "./src/types/post_content.js";
 export type { PublishFrontmatter, PublishStrategy, } from "./src/types/publish_strategy.js";
 export { isPublishable } from "./src/types/publish_strategy.js";
 export type { ResolvedRiebeckiteConfig } from "./src/types/resolved_riebeckite_config.js";
-export type { RiebeckiteConfig } from "./src/types/riebeckite_config.js";
+export type { RiebeckiteConfig, SpaConfig, } from "./src/types/riebeckite_config.js";
 export type { SiteConfig } from "./src/types/site_config.js";
 export type { RiebeckiteTheme, ThemeArticleLayoutPreset, ThemeAttributes, ThemeColorMode, ThemeConfig, ThemeDesignTokens, ThemeInput, ThemeStyle, ThemeTypographyPreset, } from "./src/types/theme_config.js";
 export { defineTheme } from "./src/types/theme_config.js";

package/dist/index.js

@@ -20,6 +20,7 @@ function validateConfigIssues(config) {
   validateSite(value.site, issues);
   validateContent(value.content, issues);
   validateCache(value.cache, issues);
+  validateSpa(value.spa, issues);
   validateTheme(value.theme, issues);
   validatePlugins(value.plugins, issues);
   return issues;
@@ -103,6 +104,12 @@ function validateCache(value, issues) {
   validateOptionalBoolean(value.enabled, "cache.enabled", issues);
   validateOptionalString(value.directory, "cache.directory", issues);
 }
+function validateSpa(value, issues) {
+  if (value === void 0 || typeof value === "boolean" || isRecord(value)) {
+    return;
+  }
+  issues.push({ path: "spa", message: "Expected a boolean or an object." });
+}
 function validateTheme(value, issues) {
   if (value === void 0) return;
   if (!isRecord(value)) {
@@ -680,6 +687,7 @@ function isConfigModuleWrapper(value) {
 function resolveConfig(config) {
   validateConfig(config);
   const theme = resolveThemeConfig(config.theme);
+  const spa = resolveSpaConfig(config.spa);
   return {
     site: {
       title: config.site?.title ?? "",
@@ -708,9 +716,14 @@ function resolveConfig(config) {
     cache: {
       enabled: config.cache?.enabled ?? true,
       directory: config.cache?.directory ?? ""
-    }
+    },
+    ...spa === void 0 ? {} : { spa }
   };
 }
+function resolveSpaConfig(spa) {
+  if (spa === void 0 || spa === false) return void 0;
+  return spa === true ? {} : spa;
+}
 function resolveThemeConfig(themeInput) {
   const theme = themeInput ? isRiebeckiteTheme(themeInput) ? { name: themeInput.name, ...themeInput.config } : themeInput : void 0;
   const styles = themeInput ? isRiebeckiteTheme(themeInput) ? themeInput.styles ?? [] : [defaultThemeStyle] : [defaultThemeStyle];
@@ -2519,6 +2532,34 @@ function rejectInternalRiebeckitePath(normalized, input) {
 }
 
 // src/pipeline.ts
+function isPluginTable(node) {
+  const className = node.properties?.className;
+  const names = Array.isArray(className) ? className : [className];
+  return names.some(
+    (name) => typeof name === "string" && (name.startsWith("rb-") || name.startsWith("rr-"))
+  );
+}
+function wrapMarkdownTables() {
+  return (tree) => {
+    wrapTableChildren(tree);
+  };
+}
+function wrapTableChildren(parent) {
+  if (!parent.children) return;
+  parent.children = parent.children.map((child) => {
+    const node = child;
+    if (node.type === "element" && node.tagName === "table" && !isPluginTable(node)) {
+      return {
+        type: "element",
+        tagName: "div",
+        properties: { className: ["rb-table-scroll"] },
+        children: [child]
+      };
+    }
+    wrapTableChildren(node);
+    return child;
+  });
+}
 var Pipeline = class {
   constructor(contentIndex, permalinks, getMarkdownBySlug, options = {}, isBuildTime = false) {
     this.contentIndex = contentIndex;
@@ -2694,6 +2735,7 @@ var Pipeline = class {
         }
       });
     }
+    this.use(processor, wrapMarkdownTables);
     this.use(processor, rehypeSlug);
     this.use(processor, rehypeKatex, { output: "mathml", strict: false });
     this.use(processor, rehypeFormat);
@@ -2903,12 +2945,14 @@ function createStyleAsset(pluginName, moduleSpecifier) {
     moduleSpecifier
   };
 }
-function createClientEntry(pluginName, moduleSpecifier, exportName, publicConfig) {
+function createClientEntry(pluginName, moduleSpecifier, exportName, publicConfig, scope, initializerArguments) {
   return {
     pluginName,
     moduleSpecifier,
     ...exportName === void 0 ? {} : { exportName },
-    ...publicConfig === void 0 ? {} : { publicConfig }
+    ...publicConfig === void 0 ? {} : { publicConfig },
+    ...scope === void 0 ? {} : { scope },
+    ...initializerArguments === void 0 ? {} : { initializerArguments }
   };
 }
 function serializePublicClientConfig(value) {
@@ -3423,7 +3467,8 @@ var PluginPageResolver = class {
         const context = {
           ...this.options.createContext(contentIndex),
           manifest,
-          pathname: pagePathname
+          pathname: pagePathname,
+          renderMarkdown: this.options.renderMarkdown
         };
         const page = await pageType.resolve(
           this.options.createPluginContext(plugin, context)
@@ -3478,7 +3523,8 @@ var PluginPageResolver = class {
           const context = {
             ...this.options.createContext(contentIndex),
             manifest,
-            pathname
+            pathname,
+            renderMarkdown: this.options.renderMarkdown
           };
           const dependencies = pageType.outputDependencies ? typeof pageType.outputDependencies === "function" ? await pageType.outputDependencies(
             this.options.createPluginContext(plugin, context)
@@ -3618,7 +3664,13 @@ var PluginRuntime = class {
     this.pageResolver = new PluginPageResolver({
       plugins: () => this.plugins(),
       createContext: (contentIndex) => this.createContext(contentIndex),
-      createPluginContext: (plugin, context) => this.createPluginContext(plugin, context)
+      createPluginContext: (plugin, context) => this.createPluginContext(plugin, context),
+      renderMarkdown: async (markdown) => {
+        if (!this.pageMarkdownRenderer) {
+          throw new Error("Plugin page Markdown renderer is unavailable.");
+        }
+        return await this.pageMarkdownRenderer(markdown);
+      }
     });
     this.manifestHooks = new ManifestHookRunner({
       plugins: () => this.plugins(),
@@ -3641,9 +3693,13 @@ var PluginRuntime = class {
   externalDependenciesResolved = false;
   pageResolver;
   manifestHooks;
+  pageMarkdownRenderer = null;
   getDiagnostics() {
     return this.diagnostics;
   }
+  setPageMarkdownRenderer(renderer) {
+    this.pageMarkdownRenderer = renderer;
+  }
   getManifestHookMetrics() {
     return this.manifestHooks.getMetrics();
   }
@@ -5641,6 +5697,12 @@ var ContentManager = class {
     this.contentIndexBuilder = new ContentIndexBuilder(this.source);
     this.manifestAssembler = new ManifestAssembler(this.contentCache);
     this.pluginRuntime = new PluginRuntime(this.pipelineOptions);
+    this.pluginRuntime.setPageMarkdownRenderer(async (markdown) => {
+      if (!this.pipeline) {
+        throw new Error("Markdown pipeline is unavailable for plugin pages.");
+      }
+      return (await this.pipeline.execute(markdown)).html;
+    });
     const buildStatePath = resolveContentBuildStatePath(
       pipelineOptions.config,
       typeof content === "string" ? content : void 0
@@ -6847,6 +6909,7 @@ export {
   Pipeline,
   PluginDependencyError,
   PluginHookError,
+  PluginRuntime,
   SinkTracer,
   attachErrorPath,
   attachmentUrl,

package/dist/src/client_lifecycle.d.ts

@@ -0,0 +1,45 @@
+export type ClientLifecycleScope = "app" | "page";
+export type ClientCleanup = () => void | Promise<void>;
+export type ClientResourceScope = {
+    readonly signal: AbortSignal;
+    on(target: EventTarget, type: string, listener: EventListenerOrEventListenerObject, options?: Omit<AddEventListenerOptions, "signal">): void;
+    timeout(callback: () => void, delay?: number): void;
+    interval(callback: () => void, delay?: number): void;
+    cleanup(cleanup: ClientCleanup): void;
+};
+export type ClientInitializerContext<TRoot, TConfig> = {
+    root: TRoot;
+    signal: AbortSignal;
+    scope: ClientResourceScope;
+    config: TConfig;
+};
+export type ClientInitializer<TRoot, TConfig> = (context: ClientInitializerContext<TRoot, TConfig>) => undefined | ClientCleanup | Promise<undefined | ClientCleanup>;
+export type ClientLifecycleErrorContext = {
+    scope: ClientLifecycleScope;
+    name: string;
+    phase: "initialize" | "cleanup";
+};
+export type ClientLifecycleOptions = {
+    onError?: (error: unknown, context: ClientLifecycleErrorContext) => void;
+};
+export type ClientLifecycleMount<TRoot, TConfig> = {
+    scope: ClientLifecycleScope;
+    name: string;
+    root: TRoot;
+    config: TConfig;
+    initialize: ClientInitializer<TRoot, TConfig>;
+};
+export declare class ClientLifecycle<TRoot> {
+    private readonly mounted;
+    private readonly scopes;
+    private readonly onError;
+    constructor(options?: ClientLifecycleOptions);
+    mount<TConfig>(mount: ClientLifecycleMount<TRoot, TConfig>): Promise<void>;
+    unmount(scope: ClientLifecycleScope): Promise<void>;
+    dispose(): Promise<void>;
+    private scoped;
+    private scopeState;
+    private initialize;
+    private cleanupMounted;
+    private report;
+}

package/dist/src/plugin/plugin_pages.d.ts

@@ -7,6 +7,7 @@ type PluginPageResolverOptions = {
     readonly plugins: () => readonly RiebeckitePlugin[];
     readonly createContext: (contentIndex: Map<string, string>) => PluginContextBase;
     readonly createPluginContext: <TContext extends PluginContextBase>(plugin: RiebeckitePlugin, context: TContext) => PluginContextWithCache<TContext>;
+    readonly renderMarkdown: (markdown: string) => Promise<string>;
 };
 export declare class PluginPageResolver {
     private readonly options;

package/dist/src/plugin/plugin_runtime.d.ts

@@ -25,8 +25,10 @@ export declare class PluginRuntime {
     private externalDependenciesResolved;
     private readonly pageResolver;
     private readonly manifestHooks;
+    private pageMarkdownRenderer;
     constructor(pipelineOptions?: PipelineOptions);
     getDiagnostics(): Diagnostic[];
+    setPageMarkdownRenderer(renderer: (markdown: string) => Promise<string>): void;
     getManifestHookMetrics(): ManifestHookMetrics;
     getNoChangeFastPathBlockReason(previousCache: readonly ManifestHookCacheEntry[], pipelineFingerprint: string | undefined): string | undefined;
     getManifestHookCache(): readonly ManifestHookCacheEntry[];

package/dist/src/types/plugin_asset.d.ts

@@ -1,3 +1,4 @@
+import type { ClientLifecycleScope } from "../client_lifecycle.js";
 import type { JsonValue } from "./json_value.js";
 export type PluginAssetKind = "style" | "script";
 export type PluginAsset = {
@@ -9,6 +10,8 @@ export type PluginClientEntry<TPublicConfig extends JsonValue = JsonValue> = {
     pluginName: string;
     moduleSpecifier: string;
     exportName?: string;
+    scope?: ClientLifecycleScope;
+    initializerArguments?: ClientInitializerArguments;
     /**
      * Configuration intentionally made available to this browser entry.
      *
@@ -18,8 +21,9 @@ export type PluginClientEntry<TPublicConfig extends JsonValue = JsonValue> = {
      */
     publicConfig?: TPublicConfig;
 };
+export type ClientInitializerArguments = "config" | "root" | "context";
 export declare function createStyleAsset(pluginName: string, moduleSpecifier: string): PluginAsset;
-export declare function createClientEntry<TPublicConfig extends JsonValue>(pluginName: string, moduleSpecifier: string, exportName?: string, publicConfig?: TPublicConfig): PluginClientEntry<TPublicConfig>;
+export declare function createClientEntry<TPublicConfig extends JsonValue>(pluginName: string, moduleSpecifier: string, exportName?: string, publicConfig?: TPublicConfig, scope?: ClientLifecycleScope, initializerArguments?: ClientInitializerArguments): PluginClientEntry<TPublicConfig>;
 /**
  * Serializes explicitly registered client configuration for code generation.
  * Rejecting non-JSON values prevents generated client modules from silently

package/dist/src/types/plugin_context.d.ts

@@ -59,6 +59,7 @@ export type PluginRenderTarget = {
     label: string;
     url: string;
     embed: boolean;
+    fragment?: string;
 };
 export type PluginRenderContext = PluginContext & PluginRenderTarget;
 export type PluginContentRenderer = {
@@ -72,6 +73,7 @@ export type PluginRenderInput = {
     label: string;
     url: string;
     embed: boolean;
+    fragment?: string;
 };
 export type PluginGeneratedHtml = {
     /** Output-relative path of the generated HTML file (e.g. "index.html"). */

package/dist/src/types/plugin_page.d.ts

@@ -26,6 +26,7 @@ export type PluginPageContext = PluginContext & {
     manifest: ContentManifest;
     /** Request pathname, normalized to an absolute path. */
     pathname: string;
+    renderMarkdown(markdown: string): Promise<string>;
 };
 export type PluginPageType = {
     /** Globally unique, stable page type identifier. */

package/dist/src/types/resolved_riebeckite_config.d.ts

@@ -1,6 +1,7 @@
 import type { ContentSource } from "../content/content_source.js";
 import type { RiebeckitePlugin } from "./plugin.js";
 import type { PublishStrategy } from "./publish_strategy.js";
+import type { SpaConfig } from "./riebeckite_config.js";
 import type { SiteConfig } from "./site_config.js";
 import type { ThemeConfig, ThemeStyle } from "./theme_config.js";
 export type ResolvedRiebeckiteConfig = {
@@ -38,4 +39,5 @@ export type ResolvedRiebeckiteConfig = {
         enabled: boolean;
         directory: string;
     };
+    spa?: SpaConfig;
 };

package/dist/src/types/riebeckite_config.d.ts

@@ -3,6 +3,11 @@ import type { PluginInput } from "./plugin.js";
 import type { PublishStrategy } from "./publish_strategy.js";
 import type { SiteConfig } from "./site_config.js";
 import type { ThemeInput } from "./theme_config.js";
+export type SpaConfig = {
+    prefetch?: false | "hover";
+    scrollRestoration?: boolean;
+    viewTransitions?: boolean;
+};
 export interface RiebeckiteConfig {
     site: SiteConfig;
     content?: {
@@ -19,4 +24,5 @@ export interface RiebeckiteConfig {
         enabled?: boolean;
         directory?: string;
     };
+    spa?: boolean | SpaConfig;
 }

package/dist/src/types/theme_config.d.ts

@@ -7,6 +7,9 @@ export type ThemeDesignTokens = {
         ink?: string;
         muted?: string;
         accent?: string;
+        link?: string;
+        focus?: string;
+        selected?: string;
         border?: string;
         borderStrong?: string;
         surface?: string;
@@ -15,6 +18,8 @@ export type ThemeDesignTokens = {
         danger?: string;
         success?: string;
         codeBackground?: string;
+        codeInk?: string;
+        codeInline?: string;
     };
     typography?: {
         bodyFont?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@riebeckite/core",
-  "version": "0.0.31",
+  "version": "0.0.32",
   "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
@@ -49,7 +49,7 @@
   },
   "devDependencies": {
     "tsx": "^4.22.4",
-    "@riebeckite/test": "0.0.31"
+    "@riebeckite/test": "0.0.32"
   },
   "repository": {
     "type": "git",