@devframes/service-shiki 0.9.0

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-PRESENT Anthony Fu <https://github.com/antfu>
+
+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/index.d.mts

@@ -0,0 +1,68 @@
+import { DevframeServiceDefinition } from "devframe/types";
+import { codeToHast, codeToTokens } from "shiki";
+//#region src/index.d.ts
+declare const SHIKI_SERVICE_PACKAGE = "@devframes/service-shiki";
+declare const SHIKI_SERVICE_SCOPE = "devframes:service:shiki";
+/** Dual light/dark theme pair, rendered via Shiki's dual-theme CSS variables. */
+interface ShikiThemes {
+  light: string;
+  dark: string;
+}
+/** Defaults matching the `@antfu/design` light/dark surfaces. */
+declare const SHIKI_DEFAULT_THEMES: ShikiThemes;
+interface ShikiServiceOptions {
+  /**
+   * Theme pair every request uses unless it carries its own. On merge, the
+   * later installer's pair wins.
+   */
+  themes?: ShikiThemes;
+  /**
+   * Languages to eagerly load at setup (others load on demand, per request).
+   * Merged as a union across installers.
+   */
+  langs?: string[];
+}
+interface ShikiHighlightInput {
+  code: string;
+  /** Language id; unknown ids degrade to plain text instead of throwing. */
+  lang?: string;
+  /** Per-request theme override. */
+  themes?: ShikiThemes;
+}
+type ShikiHast = Awaited<ReturnType<typeof codeToHast>>;
+type ShikiTokens = Awaited<ReturnType<typeof codeToTokens>>;
+interface ShikiServiceApi {
+  /** Highlight to HTML (dual-theme: light values inline, dark via `--shiki-dark` vars). */
+  highlight: (input: ShikiHighlightInput) => Promise<{
+    html: string;
+  }>;
+  /** Highlight to a HAST tree, for surfaces that render their own DOM. */
+  codeToHast: (input: ShikiHighlightInput) => Promise<ShikiHast>;
+  /** Highlight to themed tokens, for line-oriented renderers (e.g. diff views). */
+  codeToTokens: (input: ShikiHighlightInput) => Promise<ShikiTokens>;
+}
+declare module 'devframe' {
+  interface DevframeRpcServerFunctions {
+    'devframes:service:shiki:highlight': (input: ShikiHighlightInput) => Promise<{
+      html: string;
+    }>;
+    'devframes:service:shiki:code-to-hast': (input: ShikiHighlightInput) => Promise<ShikiHast>;
+    'devframes:service:shiki:code-to-tokens': (input: ShikiHighlightInput) => Promise<ShikiTokens>;
+  }
+  interface DevframeServicesRegistry {
+    '@devframes/service-shiki': ShikiServiceApi;
+  }
+  interface DevframeServicesScopeRegistry {
+    '@devframes/service-shiki': 'devframes:service:shiki';
+  }
+}
+/**
+ * The Shiki wire service — server-side syntax highlighting shared by every
+ * plugin on the host, so client bundles stop shipping their own grammars and
+ * themes. Shiki itself loads lazily on first use; results are LRU-cached per
+ * `(code, lang, themes)` and every RPC function is `cacheable` on the client
+ * side too.
+ */
+declare function createShikiService(options?: ShikiServiceOptions): DevframeServiceDefinition<ShikiServiceApi, ShikiServiceOptions>;
+//#endregion
+export { SHIKI_DEFAULT_THEMES, SHIKI_SERVICE_PACKAGE, SHIKI_SERVICE_SCOPE, ShikiHast, ShikiHighlightInput, ShikiServiceApi, ShikiServiceOptions, ShikiThemes, ShikiTokens, createShikiService, createShikiService as default };

package/dist/index.mjs

@@ -0,0 +1,139 @@
+import { defineRpcFunction } from "devframe";
+import { hash } from "devframe/utils/hash";
+import { s } from "devframe/utils/simple-schema";
+//#region package.json
+var version = "0.9.0";
+//#endregion
+//#region src/index.ts
+const SHIKI_SERVICE_PACKAGE = "@devframes/service-shiki";
+const SHIKI_SERVICE_SCOPE = "devframes:service:shiki";
+/** Defaults matching the `@antfu/design` light/dark surfaces. */
+const SHIKI_DEFAULT_THEMES = {
+	light: "vitesse-light",
+	dark: "vitesse-dark"
+};
+/** Tiny insertion-order LRU — enough to absorb re-renders of the same code. */
+var Lru = class {
+	max;
+	map = /* @__PURE__ */ new Map();
+	constructor(max) {
+		this.max = max;
+	}
+	get(key) {
+		const value = this.map.get(key);
+		if (value !== void 0) {
+			this.map.delete(key);
+			this.map.set(key, value);
+		}
+		return value;
+	}
+	set(key, value) {
+		if (this.map.size >= this.max && !this.map.has(key)) this.map.delete(this.map.keys().next().value);
+		this.map.set(key, value);
+	}
+};
+const inputSchema = s.object({
+	code: s.string(),
+	lang: s.optional(s.string()),
+	themes: s.optional(s.object({
+		light: s.string(),
+		dark: s.string()
+	}))
+});
+/**
+* The Shiki wire service — server-side syntax highlighting shared by every
+* plugin on the host, so client bundles stop shipping their own grammars and
+* themes. Shiki itself loads lazily on first use; results are LRU-cached per
+* `(code, lang, themes)` and every RPC function is `cacheable` on the client
+* side too.
+*/
+function createShikiService(options) {
+	return {
+		package: SHIKI_SERVICE_PACKAGE,
+		version,
+		scope: SHIKI_SERVICE_SCOPE,
+		options,
+		setup(ctx, { options }) {
+			const defaultThemes = options?.themes ?? SHIKI_DEFAULT_THEMES;
+			let shikiPromise;
+			const shiki = () => shikiPromise ??= import("shiki").then(async (mod) => {
+				if (options?.langs?.length) await mod.getSingletonHighlighter({
+					langs: options.langs.filter((lang) => lang in mod.bundledLanguages),
+					themes: [defaultThemes.light, defaultThemes.dark]
+				});
+				return mod;
+			});
+			/** Unknown language ids degrade to plain text instead of throwing. */
+			async function resolveLang(lang) {
+				if (!lang) return "text";
+				return lang in (await shiki()).bundledLanguages || [
+					"text",
+					"plaintext",
+					"txt",
+					"plain",
+					"ansi"
+				].includes(lang) ? lang : "text";
+			}
+			const cache = new Lru(256);
+			function cached(kind, input, compute) {
+				const themes = input.themes ?? defaultThemes;
+				const key = hash([
+					kind,
+					input.lang,
+					themes,
+					input.code
+				]);
+				let result = cache.get(key);
+				if (!result) {
+					result = resolveLang(input.lang).then((lang) => compute(lang, themes));
+					cache.set(key, result);
+				}
+				return result;
+			}
+			const api = {
+				highlight: (input) => cached("html", input, async (lang, themes) => ({ html: await (await shiki()).codeToHtml(input.code, {
+					lang,
+					themes: { ...themes }
+				}) })),
+				codeToHast: (input) => cached("hast", input, async (lang, themes) => (await shiki()).codeToHast(input.code, {
+					lang,
+					themes: { ...themes }
+				})),
+				codeToTokens: (input) => cached("tokens", input, async (lang, themes) => (await shiki()).codeToTokens(input.code, {
+					lang,
+					themes: { ...themes }
+				}))
+			};
+			ctx.rpc.register(defineRpcFunction({
+				name: "highlight",
+				type: "query",
+				cacheable: true,
+				jsonSerializable: true,
+				args: [inputSchema],
+				returns: s.object({ html: s.string() }),
+				handler: (input) => api.highlight(input)
+			}));
+			ctx.rpc.register(defineRpcFunction({
+				name: "code-to-hast",
+				type: "query",
+				cacheable: true,
+				jsonSerializable: true,
+				args: [inputSchema],
+				returns: s.object({}),
+				handler: (input) => api.codeToHast(input)
+			}));
+			ctx.rpc.register(defineRpcFunction({
+				name: "code-to-tokens",
+				type: "query",
+				cacheable: true,
+				jsonSerializable: true,
+				args: [inputSchema],
+				returns: s.object({}),
+				handler: (input) => api.codeToTokens(input)
+			}));
+			return api;
+		}
+	};
+}
+//#endregion
+export { SHIKI_DEFAULT_THEMES, SHIKI_SERVICE_PACKAGE, SHIKI_SERVICE_SCOPE, createShikiService, createShikiService as default };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@devframes/service-shiki",
+  "type": "module",
+  "version": "0.9.0",
+  "description": "Devframe wire service that renders Shiki syntax highlighting on the server, so plugins stop re-bundling highlighters.",
+  "author": "Anthony Fu <anthonyfu117@hotmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/devframes/devframe#readme",
+  "repository": {
+    "directory": "services/shiki",
+    "type": "git",
+    "url": "git+https://github.com/devframes/devframe.git"
+  },
+  "bugs": "https://github.com/devframes/devframe/issues",
+  "keywords": [
+    "devframe",
+    "devframe-service",
+    "devtools",
+    "shiki",
+    "syntax-highlighting"
+  ],
+  "sideEffects": false,
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "devframe": "0.9.1"
+  },
+  "dependencies": {
+    "shiki": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "tsdown": "^0.22.14",
+    "vitest": "^4.1.10",
+    "devframe": "0.9.1"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "watch": "tsdown --watch",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  }
+}