@ox-content/vite-plugin 2.2.0 → 2.4.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 ubugeeei
+
+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.cjs

@@ -14,6 +14,7 @@ let rehype_stringify = require("rehype-stringify");
 rehype_stringify = require_chunk.__toESM(rehype_stringify);
 let shiki = require("shiki");
 let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path);
 let fs = require("fs");
 fs = require_chunk.__toESM(fs);
 let node_crypto = require("node:crypto");
@@ -22,7 +23,9 @@ fs_promises = require_chunk.__toESM(fs_promises);
 let glob = require("glob");
 let crypto = require("crypto");
 crypto = require_chunk.__toESM(crypto);
+let node_module = require("node:module");
 let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_chunk.__toESM(node_fs_promises);
 //#region src/environment.ts
 /**
 * Creates the Markdown processing environment configuration.
@@ -7520,11 +7523,22 @@ function renderDetailsControlsHtml(targetSelector) {
 <button type="button" class="ox-api-controls__button" data-ox-api-toggle="collapse">Close all</button>
 </div>`;
 }
+function normalizeDocFilePath(filePath) {
+	const normalized = filePath.replace(/\\/g, "/");
+	return normalized.match(/(?:^|\/)((?:npm|packages|crates|src)\/.+)$/)?.[1] ?? normalized.replace(/^\/+/, "");
+}
 function buildDocsData(docs) {
 	return {
 		version: 1,
 		generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-		modules: docs
+		modules: docs.map((doc) => ({
+			...doc,
+			file: normalizeDocFilePath(doc.file),
+			entries: doc.entries.map((entry) => ({
+				...entry,
+				file: normalizeDocFilePath(entry.file)
+			}))
+		}))
 	};
 }
 /**
@@ -8054,7 +8068,7 @@ async function writeDocs(docs, outDir, extractedDocs, options) {
 * @returns Absolute GitHub URL to source code
 */
 function generateSourceHref(filePath, githubUrl, lineNumber, endLineNumber) {
-	return `${githubUrl}/blob/main/${filePath.replace(/^.*?\/(npm|packages|crates|src)\//, "$1/")}${lineNumber ? endLineNumber && endLineNumber > lineNumber ? `#L${lineNumber}-L${endLineNumber}` : `#L${lineNumber}` : ""}`;
+	return `${githubUrl}/blob/main/${normalizeDocFilePath(filePath)}${lineNumber ? endLineNumber && endLineNumber > lineNumber ? `#L${lineNumber}-L${endLineNumber}` : `#L${lineNumber}` : ""}`;
 }
 function generateSourceLink(filePath, githubUrl, lineNumber, endLineNumber) {
 	return `**[Source](${generateSourceHref(filePath, githubUrl, lineNumber, endLineNumber)})**`;
@@ -12135,6 +12149,358 @@ function walkDir(dir, pattern, callback) {
 	}
 }
 //#endregion
+//#region src/lint.ts
+const require$1 = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href);
+const SUPPORTED_MARKDOWN_LINT_LANGUAGES = [
+	"en",
+	"ja",
+	"zh",
+	"fr",
+	"de",
+	"pl"
+];
+const DEFAULT_LANGUAGES = ["en"];
+const DEFAULT_RULES = {
+	duplicateHeadings: true,
+	headingIncrement: true,
+	maxConsecutiveBlankLines: 1,
+	repeatedPunctuation: true,
+	repeatedWords: true,
+	spellcheck: true,
+	trailingSpaces: true
+};
+const DEFAULT_CSPELL_IMPORTS = {
+	de: "@cspell/dict-de-de/cspell-ext.json",
+	en: "@cspell/dict-en_us/cspell-ext.json",
+	fr: "@cspell/dict-fr-fr/cspell-ext.json",
+	pl: "@cspell/dict-pl_pl/cspell-ext.json"
+};
+let napiBinding;
+let cspellLibPromise;
+/**
+* Lints Markdown prose with the Rust-backed built-in rule engine.
+*/
+function lintMarkdown(source, options = {}) {
+	return lintMarkdownWithNormalizedOptions(source, normalizeLintOptions(options));
+}
+/**
+* Async Markdown linter that supports opt-in standard dictionaries.
+*/
+async function lintMarkdownAsync(source, options = {}) {
+	const normalizedOptions = normalizeLintOptions(options);
+	const [result] = await lintMarkdownDocumentsWithNormalizedOptions([source], normalizedOptions);
+	return result ?? createEmptyLintResult$1();
+}
+/**
+* Internal batched Markdown linting entry point used by file-based workflows.
+*/
+async function lintMarkdownDocumentsAsync(sources, options = {}) {
+	return lintMarkdownDocumentsWithNormalizedOptions(sources, normalizeLintOptions(options));
+}
+function lintMarkdownWithNormalizedOptions(source, normalizedOptions) {
+	if (normalizedOptions.dictionary.standard) throw new Error("[ox-content] lintMarkdownAsync is required when dictionary.standard is enabled.");
+	return stripMaskedDocument(loadNapiBindingSync().lintMarkdown(source, toNapiMarkdownLintOptions(normalizedOptions)));
+}
+async function lintMarkdownDocumentsWithNormalizedOptions(sources, normalizedOptions) {
+	if (sources.length === 0) return [];
+	const napi = loadNapiBindingSync();
+	const napiOptions = toNapiMarkdownLintOptions(normalizedOptions, Boolean(normalizedOptions.dictionary.standard));
+	const builtInResults = typeof napi.lintMarkdownDocuments === "function" ? napi.lintMarkdownDocuments(sources, napiOptions) : sources.map((source) => napi.lintMarkdown(source, napiOptions));
+	if (!normalizedOptions.rules.spellcheck || !normalizedOptions.dictionary.standard) return builtInResults.map(stripMaskedDocument);
+	const standardDiagnostics = await runStandardSpellcheckDocuments(builtInResults.map((result) => result.maskedDocument), normalizedOptions);
+	return builtInResults.map((result, index) => summarizeDiagnostics(sortDiagnostics(result.diagnostics.concat(standardDiagnostics[index] ?? []))));
+}
+function loadNapiBindingSync() {
+	if (napiBinding) return napiBinding;
+	if (napiBinding === null) throw new Error("[ox-content] @ox-content/napi is required for Markdown linting. Please ensure the NAPI module is built.");
+	try {
+		const loaded = require$1("@ox-content/napi");
+		napiBinding = loaded.default && typeof loaded.default === "object" ? {
+			...loaded.default,
+			...loaded
+		} : loaded;
+		return napiBinding;
+	} catch {
+		napiBinding = null;
+		throw new Error("[ox-content] @ox-content/napi is required for Markdown linting. Please ensure the NAPI module is built.");
+	}
+}
+function toNapiMarkdownLintOptions(options, disableBuiltinSpellcheck = false) {
+	return {
+		dictionary: {
+			byLanguage: Object.entries(options.dictionary.byLanguage ?? {}).map(([language, words]) => ({
+				language,
+				words
+			})),
+			ignoredWords: options.dictionary.ignoredWords,
+			words: options.dictionary.words
+		},
+		languages: options.languages,
+		rules: {
+			...options.rules,
+			spellcheck: disableBuiltinSpellcheck ? false : options.rules.spellcheck
+		}
+	};
+}
+function stripMaskedDocument(result) {
+	return {
+		diagnostics: result.diagnostics,
+		errorCount: result.errorCount,
+		infoCount: result.infoCount,
+		warningCount: result.warningCount
+	};
+}
+function normalizeLintOptions(options) {
+	const languages = options.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language)) ?? options.dictionary?.standard?.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language)) ?? [...DEFAULT_LANGUAGES];
+	const standard = normalizeStandardDictionaryOptions(options.dictionary?.standard, languages);
+	return {
+		dictionary: {
+			...options.dictionary,
+			standard
+		},
+		languages: [...new Set(languages)],
+		rules: {
+			duplicateHeadings: options.rules?.duplicateHeadings ?? DEFAULT_RULES.duplicateHeadings,
+			headingIncrement: options.rules?.headingIncrement ?? DEFAULT_RULES.headingIncrement,
+			maxConsecutiveBlankLines: options.rules?.maxConsecutiveBlankLines ?? DEFAULT_RULES.maxConsecutiveBlankLines,
+			repeatedPunctuation: options.rules?.repeatedPunctuation ?? DEFAULT_RULES.repeatedPunctuation,
+			repeatedWords: options.rules?.repeatedWords ?? DEFAULT_RULES.repeatedWords,
+			spellcheck: options.rules?.spellcheck ?? DEFAULT_RULES.spellcheck,
+			trailingSpaces: options.rules?.trailingSpaces ?? DEFAULT_RULES.trailingSpaces
+		}
+	};
+}
+function normalizeStandardDictionaryOptions(standard, fallbackLanguages) {
+	if (!standard) return false;
+	const languages = standard.languages?.filter((language) => SUPPORTED_MARKDOWN_LINT_LANGUAGES.includes(language)) ?? fallbackLanguages;
+	const customImports = standard.imports ?? [];
+	const missingPresetLanguages = languages.filter((language) => !DEFAULT_CSPELL_IMPORTS[language]);
+	if (missingPresetLanguages.length > 0 && customImports.length === 0) throw new Error(`[ox-content] No bundled standard dictionary preset exists for ${missingPresetLanguages.join(", ")}. Provide dictionary.standard.imports to enable those languages.`);
+	const imports = [...languages.map((language) => DEFAULT_CSPELL_IMPORTS[language]).filter((value) => Boolean(value)), ...customImports];
+	if (imports.length === 0) throw new Error("[ox-content] dictionary.standard requires at least one bundled preset language or custom import.");
+	return {
+		imports: [...new Set(imports)],
+		languages: [...new Set(languages)],
+		provider: standard.provider ?? "cspell",
+		resolveImportsRelativeTo: standard.resolveImportsRelativeTo ?? new URL(".", require("url").pathToFileURL(__filename).href)
+	};
+}
+async function runStandardSpellcheckDocuments(maskedDocuments, options) {
+	const standard = options.dictionary.standard;
+	if (!standard || maskedDocuments.length === 0) return maskedDocuments.map(() => []);
+	try {
+		const { spellCheckDocument } = await loadCspellLib();
+		const locale = standard.languages.join(",");
+		const settings = createStandardSpellcheckSettings(options, locale);
+		return Promise.all(maskedDocuments.map(async (maskedDocument, index) => {
+			if (maskedDocument.trim().length === 0) return [];
+			return (await spellCheckDocument({
+				languageId: "plaintext",
+				locale,
+				text: maskedDocument,
+				uri: `file:///ox-content-lint-${index}.md`
+			}, {
+				generateSuggestions: true,
+				noConfigSearch: true,
+				numSuggestions: 3,
+				resolveImportsRelativeTo: standard.resolveImportsRelativeTo
+			}, settings)).issues.map((issue) => mapStandardIssueToDiagnostic(issue, standard.languages));
+		}));
+	} catch (error) {
+		const imports = standard.imports.join(", ");
+		const message = imports.length > 0 ? `[ox-content] Failed to load standard dictionaries from ${imports}. Verify the imports and install the referenced CSpell packages.` : "[ox-content] Failed to load the configured standard dictionaries.";
+		throw new Error(message, { cause: error });
+	}
+}
+function createStandardSpellcheckSettings(options, locale) {
+	return {
+		import: options.dictionary.standard ? options.dictionary.standard.imports : [],
+		ignoreWords: options.dictionary.ignoredWords,
+		language: locale,
+		version: "0.2",
+		words: [...options.dictionary.words ?? [], ...Object.values(options.dictionary.byLanguage ?? {}).flat()]
+	};
+}
+async function loadCspellLib() {
+	cspellLibPromise ??= import("cspell-lib");
+	return cspellLibPromise;
+}
+function mapStandardIssueToDiagnostic(issue, languages) {
+	const line = issue.line.position.line + 1;
+	const column = issue.offset - issue.line.offset + 1;
+	return {
+		column,
+		endColumn: column + (issue.length ?? issue.text.length),
+		endLine: line,
+		language: inferStandardIssueLanguage(issue.text, languages),
+		line,
+		message: `Unknown word "${issue.text}".`,
+		ruleId: "spellcheck",
+		severity: "warning",
+		suggestions: issue.suggestions?.slice(0, 3)
+	};
+}
+function inferStandardIssueLanguage(word, languages) {
+	if (/[\p{Script=Hiragana}\p{Script=Katakana}]/u.test(word) && languages.includes("ja")) return "ja";
+	if (/[\p{Script=Han}]/u.test(word)) {
+		if (languages.includes("zh") && !languages.includes("ja")) return "zh";
+		if (languages.includes("ja") && !languages.includes("zh")) return "ja";
+	}
+	if (/[\p{Script=Latin}]/u.test(word)) {
+		const latinLanguages = languages.filter((language) => language !== "ja" && language !== "zh");
+		if (latinLanguages.length === 1) return latinLanguages[0];
+		return inferLatinLanguageFromCharacters(word, latinLanguages);
+	}
+}
+function inferLatinLanguageFromCharacters(word, languages) {
+	if (languages.includes("pl") && /[ąćęłńóśźż]/iu.test(word)) return "pl";
+	if (languages.includes("de") && /[äöüß]/iu.test(word)) return "de";
+	if (languages.includes("fr") && /[àâæçéèêëîïôœùûüÿ]/iu.test(word)) return "fr";
+}
+function summarizeDiagnostics(diagnostics) {
+	let errorCount = 0;
+	let warningCount = 0;
+	let infoCount = 0;
+	for (const diagnostic of diagnostics) if (diagnostic.severity === "error") errorCount += 1;
+	else if (diagnostic.severity === "warning") warningCount += 1;
+	else infoCount += 1;
+	return {
+		diagnostics,
+		errorCount,
+		infoCount,
+		warningCount
+	};
+}
+function createEmptyLintResult$1() {
+	return summarizeDiagnostics([]);
+}
+function sortDiagnostics(diagnostics) {
+	return [...diagnostics].sort((left, right) => {
+		if (left.line !== right.line) return left.line - right.line;
+		if (left.column !== right.column) return left.column - right.column;
+		return left.ruleId.localeCompare(right.ruleId);
+	});
+}
+//#endregion
+//#region src/lint-files.ts
+const DEFAULT_LINT_FILE_INCLUDE = ["**/*.md", "**/*.markdown"];
+const DEFAULT_LINT_FILE_EXCLUDE = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/dist/**"
+];
+/**
+* Returns true if the file path is included by the configured glob filters.
+*/
+function shouldLintMarkdownFile(filePath, options = {}) {
+	const resolvedOptions = resolveMarkdownLintFileOptions(options);
+	return shouldLintAbsoluteFile(node_path.resolve(resolvedOptions.cwd, filePath), resolvedOptions);
+}
+/**
+* Lints a single Markdown file using project-style include/exclude settings.
+*
+* If the file is filtered out by `include` / `exclude`, the returned result is
+* marked as `skipped` and contains no diagnostics.
+*/
+async function lintMarkdownFile(filePath, options = {}) {
+	const resolvedOptions = resolveMarkdownLintFileOptions(options);
+	return lintMarkdownFileWithResolvedOptions(node_path.resolve(resolvedOptions.cwd, filePath), resolvedOptions);
+}
+/**
+* Lints all Markdown files matched by the configured include/exclude patterns.
+*/
+async function lintMarkdownFiles(options = {}) {
+	const resolvedOptions = resolveMarkdownLintFileOptions(options);
+	const matchedFiles = await collectMarkdownLintFileEntries(resolvedOptions);
+	const results = await lintMarkdownDocumentsAsync(await Promise.all(matchedFiles.map((file) => node_fs_promises.readFile(file.filePath, "utf-8"))), resolvedOptions.lintOptions);
+	const files = matchedFiles.map((file, index) => ({
+		...results[index] ?? createEmptyLintResult(),
+		filePath: file.filePath,
+		relativePath: file.relativePath,
+		skipped: false
+	}));
+	const diagnostics = files.flatMap((fileResult) => fileResult.diagnostics.map((diagnostic) => ({
+		...diagnostic,
+		filePath: fileResult.filePath,
+		relativePath: fileResult.relativePath
+	})));
+	return {
+		checkedFileCount: files.length,
+		diagnostics,
+		errorCount: files.reduce((count, fileResult) => count + fileResult.errorCount, 0),
+		files,
+		infoCount: files.reduce((count, fileResult) => count + fileResult.infoCount, 0),
+		warningCount: files.reduce((count, fileResult) => count + fileResult.warningCount, 0)
+	};
+}
+function resolveMarkdownLintFileOptions(options) {
+	return {
+		cwd: node_path.resolve(options.cwd ?? process.cwd()),
+		exclude: [...new Set([...options.exclude ?? DEFAULT_LINT_FILE_EXCLUDE, ...options.ignore ?? []])],
+		include: [...new Set(options.include ?? DEFAULT_LINT_FILE_INCLUDE)],
+		lintOptions: {
+			dictionary: options.dictionary,
+			languages: options.languages,
+			rules: options.rules
+		}
+	};
+}
+async function lintMarkdownFileWithResolvedOptions(filePath, options) {
+	const absoluteFilePath = node_path.resolve(filePath);
+	const relativePath = normalizePath(node_path.relative(options.cwd, absoluteFilePath));
+	if (!shouldLintAbsoluteFile(absoluteFilePath, options)) return {
+		...createEmptyLintResult(),
+		filePath: absoluteFilePath,
+		relativePath,
+		skipped: true
+	};
+	return {
+		...await lintMarkdownAsync(await node_fs_promises.readFile(absoluteFilePath, "utf-8"), options.lintOptions),
+		filePath: absoluteFilePath,
+		relativePath,
+		skipped: false
+	};
+}
+async function collectMarkdownLintFileEntries(options) {
+	const files = /* @__PURE__ */ new Map();
+	for (const pattern of options.include) {
+		const matches = await (0, glob.glob)(pattern, {
+			absolute: true,
+			cwd: options.cwd,
+			ignore: options.exclude,
+			nodir: true
+		});
+		for (const filePath of matches) {
+			const absoluteFilePath = node_path.resolve(filePath);
+			if (shouldLintAbsoluteFile(absoluteFilePath, options)) files.set(absoluteFilePath, {
+				filePath: absoluteFilePath,
+				relativePath: normalizePath(node_path.relative(options.cwd, absoluteFilePath))
+			});
+		}
+	}
+	return [...files.values()].sort((left, right) => left.filePath.localeCompare(right.filePath));
+}
+function shouldLintAbsoluteFile(filePath, options) {
+	const absolutePath = normalizePath(node_path.resolve(filePath));
+	const relativePath = normalizePath(node_path.relative(options.cwd, absolutePath));
+	const matches = (patterns) => patterns.some((pattern) => {
+		const normalizedPattern = normalizePath(pattern);
+		return node_path.matchesGlob(relativePath, normalizedPattern) || node_path.matchesGlob(absolutePath, normalizedPattern);
+	});
+	return matches(options.include) && !matches(options.exclude);
+}
+function normalizePath(value) {
+	return value.split(node_path.sep).join("/");
+}
+function createEmptyLintResult() {
+	return {
+		diagnostics: [],
+		errorCount: 0,
+		infoCount: 0,
+		warningCount: 0
+	};
+}
+//#endregion
 //#region src/jsx-runtime.ts
 /**
 * Custom JSX Runtime for Static HTML Generation
@@ -12983,6 +13349,10 @@ exports.hasIslands = hasIslands;
 exports.inferType = inferType;
 exports.jsx = jsx;
 exports.jsxs = jsxs;
+exports.lintMarkdown = lintMarkdown;
+exports.lintMarkdownAsync = lintMarkdownAsync;
+exports.lintMarkdownFile = lintMarkdownFile;
+exports.lintMarkdownFiles = lintMarkdownFiles;
 exports.mergeThemes = mergeThemes;
 exports.mermaidClientScript = require_mermaid.mermaidClientScript;
 exports.oxContent = oxContent;
@@ -12999,6 +13369,7 @@ exports.resolveSearchOptions = resolveSearchOptions;
 exports.resolveSsgOptions = resolveSsgOptions;
 exports.resolveTheme = resolveTheme;
 exports.setRenderContext = setRenderContext;
+exports.shouldLintMarkdownFile = shouldLintMarkdownFile;
 exports.transformAllPlugins = transformAllPlugins;
 exports.transformGitHub = require_github.transformGitHub;
 exports.transformIslands = transformIslands;