@ckeditor/ckeditor5-dev-manual-server 56.2.1 → 56.4.0

package/dist/index.d.ts

@@ -3,7 +3,7 @@
 * For licensing, see LICENSE.md.
 */
 export { manualTestsPlugin } from "./manual-test-plugin/plugin.js";
-export type { ManualData } from "./manual-test-plugin/plugin.js";
+export type { ManualData, ManualTestsPluginOptions } from "./manual-test-plugin/plugin.js";
 export { refreshPlugin } from "./refresh-plugin/plugin.js";
 export { rawHtmlPlugin } from "./raw-plugin/plugin.js";
 export { stringifyValues } from "./utils.js";

package/dist/index.js

@@ -205,8 +205,8 @@ function loadRenderedInstructions(entry, workspaceRoot) {
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
 * For licensing, see LICENSE.md.
 */
-function createManualShellHtml({ entry, html, shellScriptPublicPath, shellTemplateFilePath, workspaceRoot }) {
-	const shellDocument = parse(readFileSync(shellTemplateFilePath, "utf8"));
+function createManualShellHtml({ catalogPublicPath = "/", entry, html, shellScriptPublicPath, shellTemplateFilePath, workspaceRoot }) {
+	const shellDocument = parse(readFileSync(shellTemplateFilePath, "utf8").replace("href=\"/\" title=\"Back to test index\"", `href="${catalogPublicPath}" title="Back to test index"`));
 	const shellHead = getRequiredElementByTagName$1(shellDocument, "head");
 	const shellBody = getRequiredElementByTagName$1(shellDocument, "body");
 	const shellTitle = getRequiredElementByTagName$1(shellHead, "title");
@@ -312,12 +312,15 @@ const MANUAL_CATALOG_FILE_PATH = resolve(MANUAL_THEME_ROOT, "catalog.html");
 const MANUAL_CATALOG_SCRIPT_FILE_PATH = resolve(MANUAL_THEME_ROOT, "catalog.ts");
 const MANUAL_SHELL_TEMPLATE_FILE_PATH = resolve(MANUAL_THEME_ROOT, "shell.html");
 const MANUAL_SHELL_SCRIPT_FILE_PATH = resolve(MANUAL_THEME_ROOT, "shell.ts");
-function manualTestsPlugin(manualTestPatterns) {
+function manualTestsPlugin(options) {
 	let workspaceRoot = process.cwd();
+	let base = "/";
+	const manualTestPatterns = options.paths;
 	const manualPagePatterns = manualTestPatterns.map(toManualPagePattern);
-	const manualPagesCache = cacheValue(() => collectManualPages(manualPagePatterns, workspaceRoot));
-	const manualStaticAssetsCache = cacheValue(() => collectManualStaticAssets(manualTestPatterns, workspaceRoot));
+	const includePackageNames = (options.include || []).filter(Boolean);
+	const manualPagesCache = cacheValue(() => filterManualPages(collectManualPages(manualPagePatterns, workspaceRoot), includePackageNames));
 	const getManualPages = manualPagesCache.get;
+	const manualStaticAssetsCache = cacheValue(() => collectManualStaticAssets(getManualStaticAssetPatterns(getManualPages(), manualTestPatterns, includePackageNames), workspaceRoot));
 	const getManualStaticAssets = manualStaticAssetsCache.get;
 	const invalidateManualFileCaches = () => {
 		manualPagesCache.invalidate();
@@ -326,14 +329,16 @@ function manualTestsPlugin(manualTestPatterns) {
 	const getManualPageEntryForFile = (filePath) => {
 		return getManualPages().get(toPublicSpecifier(relative(workspaceRoot, filePath)));
 	};
-	const getManualCatalogPublicPath = () => toPublicFilePath(MANUAL_CATALOG_FILE_PATH, workspaceRoot);
+	const getManualCatalogBuildInputFilePath = () => resolve(workspaceRoot, "index.html");
+	const getManualCatalogPublicPath = () => toPublicFilePath(getManualCatalogBuildInputFilePath(), workspaceRoot);
 	const getManualCatalogScriptPublicPath = () => toPublicFilePath(MANUAL_CATALOG_SCRIPT_FILE_PATH, workspaceRoot);
 	const getManualShellScriptPublicPath = () => toPublicFilePath(MANUAL_SHELL_SCRIPT_FILE_PATH, workspaceRoot);
-	const getManualBuildInputs = () => [MANUAL_CATALOG_FILE_PATH, ...[...getManualPages().values()].map((entry) => resolve(workspaceRoot, entry.htmlFilePath.slice(1)))];
+	const getManualCatalogClientPath = (entry) => toBaseCatalogPath(base, entry.htmlFilePath);
+	const getManualBuildInputs = () => [getManualCatalogBuildInputFilePath(), ...[...getManualPages().values()].map((entry) => resolve(workspaceRoot, entry.htmlFilePath.slice(1)))];
 	const resolvedVirtualModuleId = `\0${MANUAL_ENTRIES_VIRTUAL_ID}`;
 	const getClientEntries = () => [...getManualPages().values()].map((entry) => ({
 		displayName: entry.displayName,
-		href: entry.htmlFilePath,
+		href: toBasePublicPath(entry.htmlFilePath, base),
 		packageName: entry.packageName,
 		slug: entry.slug
 	}));
@@ -345,23 +350,23 @@ function manualTestsPlugin(manualTestPatterns) {
 		},
 		configResolved(config) {
 			workspaceRoot = config.root;
+			base = config.base || "/";
 			invalidateManualFileCaches();
 			config.build.rolldownOptions.input = getManualBuildInputs();
 		},
 		configureServer(server) {
 			const { memoryFiles } = server.environments.client;
 			useManualTestMiddlewares(server, getManualCatalogPublicPath, getManualStaticAssets);
-			useBundledDevManualHtmlSource(memoryFiles, getManualPages, getManualShellScriptPublicPath, () => workspaceRoot);
-		},
-		configurePreviewServer(server) {
-			useManualCatalogMiddleware(server, getManualCatalogPublicPath);
+			useBundledDevManualHtmlSource(memoryFiles, getManualPages, getManualShellScriptPublicPath, getManualCatalogClientPath, () => workspaceRoot);
 		},
 		resolveId(source) {
 			if (source == MANUAL_ENTRIES_VIRTUAL_ID) return resolvedVirtualModuleId;
+			if (isManualCatalogBuildInputSpecifier(source, getManualCatalogBuildInputFilePath(), workspaceRoot)) return getManualCatalogBuildInputFilePath();
 			return null;
 		},
 		load(id) {
 			if (id == resolvedVirtualModuleId) return `export const manualTestEntries = ${getManualEntriesJson()};`;
+			if (toPosixPath(id) == toPosixPath(getManualCatalogBuildInputFilePath())) return readFileSync(MANUAL_CATALOG_FILE_PATH, "utf8");
 			return null;
 		},
 		generateBundle() {
@@ -374,10 +379,11 @@ function manualTestsPlugin(manualTestPatterns) {
 		transformIndexHtml: {
 			order: "pre",
 			handler(html, context) {
-				if (toPosixPath(context.filename) == toPosixPath(MANUAL_CATALOG_FILE_PATH)) return html.replace("./catalog.ts", getManualCatalogScriptPublicPath());
+				if (isManualCatalogHtmlFile(context.filename, getManualCatalogBuildInputFilePath())) return html.replace("./catalog.ts", getManualCatalogScriptPublicPath());
 				const entry = getManualPageEntryForFile(context.filename);
 				if (!entry) return;
 				return createManualShellHtml({
+					catalogPublicPath: getManualCatalogClientPath(entry),
 					entry,
 					html,
 					shellScriptPublicPath: getManualShellScriptPublicPath(),
@@ -398,7 +404,7 @@ function useManualCatalogMiddleware(server, getManualCatalogPublicPath) {
 		next();
 	});
 }
-function useBundledDevManualHtmlSource(memoryFiles, getManualPages, getManualShellScriptPublicPath, getWorkspaceRoot) {
+function useBundledDevManualHtmlSource(memoryFiles, getManualPages, getManualShellScriptPublicPath, getManualCatalogClientPath, getWorkspaceRoot) {
 	if (!memoryFiles) return;
 	const getBundledFile = memoryFiles.get.bind(memoryFiles);
 	memoryFiles.get = (filePath) => {
@@ -409,6 +415,7 @@ function useBundledDevManualHtmlSource(memoryFiles, getManualPages, getManualShe
 		const shellScriptPublicPath = getManualShellScriptPublicPath();
 		const bundledHtml = getFileSource(file);
 		return { source: mergeBundledAssetTags(createManualShellHtml({
+			catalogPublicPath: getManualCatalogClientPath(entry),
 			entry,
 			html: readFileSync(resolve(workspaceRoot, stripLeadingSlash(entry.htmlFilePath)), "utf8"),
 			shellScriptPublicPath,
@@ -424,6 +431,38 @@ function toManualPagePattern(pattern) {
 	if (/\.(?:html|js|md|ts|\{[^}]*\})$/.test(pattern)) return pattern;
 	return `${pattern}.{html,js,md,ts}`;
 }
+function filterManualPages(manualPages, includePackageNames) {
+	if (includePackageNames.length == 0) return manualPages;
+	const normalizedIncludePackageNames = new Set(includePackageNames.map(normalizePackageName));
+	return new Map([...manualPages].filter(([, entry]) => normalizedIncludePackageNames.has(normalizePackageName(entry.packageName))));
+}
+function normalizePackageName(packageName) {
+	return packageName.replace(/^ckeditor5-/, "");
+}
+function getManualStaticAssetPatterns(manualPages, manualTestPatterns, includePackageNames) {
+	if (includePackageNames.length == 0) return manualTestPatterns;
+	return [...new Set([...manualPages.values()].map(getManualTestRootDirectory))].map((manualTestRootDirectory) => `${manualTestRootDirectory}/**/*`);
+}
+function getManualTestRootDirectory(entry) {
+	const htmlFilePath = stripLeadingSlash(entry.htmlFilePath);
+	const manualDirectoryIndex = htmlFilePath.indexOf("/tests/manual/");
+	return htmlFilePath.slice(0, manualDirectoryIndex + 14 - 1);
+}
+function isManualCatalogHtmlFile(filePath, catalogBuildInputFilePath) {
+	const normalizedFilePath = toPosixPath(filePath);
+	return normalizedFilePath == toPosixPath(MANUAL_CATALOG_FILE_PATH) || normalizedFilePath == toPosixPath(catalogBuildInputFilePath);
+}
+function isManualCatalogBuildInputSpecifier(source, catalogBuildInputFilePath, workspaceRoot) {
+	return toPosixPath(resolve(workspaceRoot, source)) == toPosixPath(catalogBuildInputFilePath);
+}
+function toBasePublicPath(publicPath, base) {
+	if (base == "" || base == "./") return `.${publicPath}`;
+	return `${base.replace(/\/$/, "")}${publicPath}`;
+}
+function toBaseCatalogPath(base, entryHtmlFilePath) {
+	if (base == "" || base == "./") return posix.relative(posix.dirname(stripLeadingSlash(entryHtmlFilePath)), "index.html");
+	return base;
+}
 function mergeBundledAssetTags(sourceHtml, bundledHtml, entry, shellScriptPublicPath) {
 	const sourceDocument = parse(sourceHtml);
 	const bundledDocument = parse(bundledHtml);

package/dist/manual-test-plugin/plugin.d.ts

@@ -4,4 +4,8 @@
 */
 import type { Plugin } from "vite";
 export type { ManualData } from "./types.js";
-export declare function manualTestsPlugin(manualTestPatterns: Array<string>): Plugin;
+export interface ManualTestsPluginOptions {
+	paths: Array<string>;
+	include?: Array<string>;
+}
+export declare function manualTestsPlugin(options: ManualTestsPluginOptions): Plugin;

package/dist/manual-test-plugin/shell-html.d.ts

@@ -4,10 +4,11 @@
 */
 import type { ManualPageEntry } from "./types.js";
 export interface CreateManualShellHtmlOptions {
+	catalogPublicPath?: string;
 	entry: ManualPageEntry;
 	html: string;
 	shellScriptPublicPath: string;
 	shellTemplateFilePath: string;
 	workspaceRoot: string;
 }
-export declare function createManualShellHtml({ entry, html, shellScriptPublicPath, shellTemplateFilePath, workspaceRoot }: CreateManualShellHtmlOptions): string;
+export declare function createManualShellHtml({ catalogPublicPath, entry, html, shellScriptPublicPath, shellTemplateFilePath, workspaceRoot }: CreateManualShellHtmlOptions): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckeditor/ckeditor5-dev-manual-server",
-  "version": "56.2.1",
+  "version": "56.4.0",
   "description": "Used to extend Vite to create a manual test server for CKEditor 5.",
   "keywords": [],
   "author": "CKSource (http://cksource.com/)",