@ox-content/vite-plugin 2.74.0 → 2.75.1

package/dist/index.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk.cjs");
+const require_interop = require("./interop.cjs");
 const require_napi = require("./napi.cjs");
 const require_mermaid = require("./mermaid.cjs");
 const require_tabs = require("./tabs.cjs");
@@ -117,6 +118,8 @@ function createMarkdownEnvironment(options) {
 /**
 * Syntax highlighting with Shiki via rehype.
 */
+const rehypeParse$1 = require_interop.interopDefault(rehype_parse.default);
+const rehypeStringify$1 = require_interop.interopDefault(rehype_stringify.default);
 const BUILTIN_LANGS = [
 	"javascript",
 	"typescript",
@@ -195,7 +198,7 @@ function rehypeShikiHighlight(options) {
 					lang,
 					theme: themeName
 				});
-				const parsed = (0, unified.unified)().use(rehype_parse.default, { fragment: true }).parse(highlighted);
+				const parsed = (0, unified.unified)().use(rehypeParse$1, { fragment: true }).parse(highlighted);
 				if (parsed.children[0]?.type === "element") {
 					const highlightedPre = parsed.children[0];
 					highlightedPre.properties ??= {};
@@ -217,7 +220,7 @@ function rehypeShikiHighlight(options) {
 					lang,
 					theme: themeName
 				});
-				const parsed = (0, unified.unified)().use(rehype_parse.default, { fragment: true }).parse(highlighted);
+				const parsed = (0, unified.unified)().use(rehypeParse$1, { fragment: true }).parse(highlighted);
 				if (parsed.children[0]?.type === "element") {
 					const highlightedCode = parsed.children[0].children.find((child) => child.type === "element" && child.tagName === "code");
 					if (highlightedCode) {
@@ -273,10 +276,10 @@ function normalizeClassName(className) {
 * Apply syntax highlighting to HTML using Shiki.
 */
 async function highlightCode(html, theme = "github-dark", langs = []) {
-	const result = await (0, unified.unified)().use(rehype_parse.default, { fragment: true }).use(rehypeShikiHighlight, {
+	const result = await (0, unified.unified)().use(rehypeParse$1, { fragment: true }).use(rehypeShikiHighlight, {
 		theme,
 		langs
-	}).use(rehype_stringify.default).process(html);
+	}).use(rehypeStringify$1).process(html);
 	return String(result);
 }
 //#endregion
@@ -1667,6 +1670,8 @@ async function renderSinglePage(entry, templateFn, templateSource, options, cach
 * Detects <Island> components in HTML and transforms them
 * into hydration-ready elements with data attributes.
 */
+const rehypeParse = require_interop.interopDefault(rehype_parse.default);
+const rehypeStringify = require_interop.interopDefault(rehype_stringify.default);
 /**
 * Get element attribute value.
 */
@@ -1797,7 +1802,7 @@ function rehypeIslands(collectedIslands) {
 */
 async function transformIslands(html) {
 	const islands = [];
-	const result = await (0, unified.unified)().use(rehype_parse.default, { fragment: true }).use(rehypeIslands, islands).use(rehype_stringify.default).process(html);
+	const result = await (0, unified.unified)().use(rehypeParse, { fragment: true }).use(rehypeIslands, islands).use(rehypeStringify).process(html);
 	return {
 		html: String(result),
 		islands
@@ -3040,6 +3045,314 @@ function generateI18nModule(options, root) {
 	throw new Error("[ox-content:i18n] @ox-content/napi does not expose generateI18nModule. Please rebuild the NAPI package.");
 }
 //#endregion
+//#region src/collections-runtime.ts
+const runtime = String.raw`
+function getValue(row, field) {
+  if (field in row) return row[field];
+  return String(field)
+    .split(".")
+    .reduce((value, key) => (value == null ? undefined : value[key]), row);
+}
+
+function normalizePath(value) {
+  const path = String(value || "/");
+  if (path === "/") return path;
+  return path.startsWith("/") ? path.replace(/\/+$/, "") : "/" + path.replace(/\/+$/, "");
+}
+
+function likePattern(value) {
+  const escaped = String(value).replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+  return new RegExp("^" + escaped.replace(/%/g, ".*").replace(/_/g, ".") + "$", "i");
+}
+
+function compare(left, right) {
+  if (left == null && right == null) return 0;
+  if (left == null) return -1;
+  if (right == null) return 1;
+  if (typeof left === "number" && typeof right === "number") return left - right;
+  if (left instanceof Date || right instanceof Date) {
+    return new Date(left).getTime() - new Date(right).getTime();
+  }
+  return String(left).localeCompare(String(right), undefined, {
+    numeric: true,
+    sensitivity: "base",
+  });
+}
+
+function createPredicate(field, operator, value) {
+  let op = String(operator ?? "=").toUpperCase();
+  let expected = value;
+  if (arguments.length === 2) {
+    op = "=";
+    expected = operator;
+  }
+
+  return (row) => {
+    const actual = getValue(row, field);
+    switch (op) {
+      case "=":
+      case "==":
+        return actual === expected;
+      case "!=":
+      case "<>":
+        return actual !== expected;
+      case ">":
+        return compare(actual, expected) > 0;
+      case ">=":
+        return compare(actual, expected) >= 0;
+      case "<":
+        return compare(actual, expected) < 0;
+      case "<=":
+        return compare(actual, expected) <= 0;
+      case "IN":
+        return Array.isArray(expected) && expected.includes(actual);
+      case "NOT IN":
+        return Array.isArray(expected) && !expected.includes(actual);
+      case "BETWEEN":
+        return Array.isArray(expected) && expected.length >= 2
+          ? compare(actual, expected[0]) >= 0 && compare(actual, expected[1]) <= 0
+          : false;
+      case "NOT BETWEEN":
+        return Array.isArray(expected) && expected.length >= 2
+          ? compare(actual, expected[0]) < 0 || compare(actual, expected[1]) > 0
+          : false;
+      case "IS NULL":
+        return actual == null;
+      case "IS NOT NULL":
+        return actual != null;
+      case "LIKE":
+        return likePattern(expected).test(String(actual ?? ""));
+      case "NOT LIKE":
+        return !likePattern(expected).test(String(actual ?? ""));
+      default:
+        throw new Error("Unsupported collection query operator: " + op);
+    }
+  };
+}
+
+class QueryGroup {
+  constructor(rows) {
+    this.rows = rows;
+    this.conditions = [];
+  }
+
+  where(field, operator, value) {
+    const test =
+      arguments.length === 2
+        ? createPredicate(field, operator)
+        : createPredicate(field, operator, value);
+    this.conditions.push({ join: "and", test });
+    return this;
+  }
+
+  andWhere(factory) {
+    const group = new QueryGroup(this.rows);
+    factory(group);
+    this.conditions.push({ join: "and", test: (row) => group.test(row) });
+    return this;
+  }
+
+  orWhere(factory) {
+    const group = new QueryGroup(this.rows);
+    factory(group);
+    this.conditions.push({ join: "or", test: (row) => group.test(row) });
+    return this;
+  }
+
+  test(row) {
+    let matched = true;
+    for (const condition of this.conditions) {
+      matched =
+        condition.join === "or" ? matched || condition.test(row) : matched && condition.test(row);
+    }
+    return matched;
+  }
+}
+
+class CollectionQueryBuilder extends QueryGroup {
+  constructor(rows) {
+    super(rows);
+    this.orders = [];
+    this.selected = undefined;
+    this.offset = 0;
+    this.max = undefined;
+  }
+
+  path(path) {
+    return this.where("path", "=", normalizePath(path));
+  }
+
+  select(...fields) {
+    this.selected = fields;
+    return this;
+  }
+
+  order(field, direction = "ASC") {
+    this.orders.push({ field, direction: String(direction).toUpperCase() });
+    return this;
+  }
+
+  limit(limit) {
+    this.max = Math.max(0, Number(limit) || 0);
+    return this;
+  }
+
+  skip(skip) {
+    this.offset = Math.max(0, Number(skip) || 0);
+    return this;
+  }
+
+  materialize() {
+    let rows = this.conditions.length ? this.rows.filter((row) => this.test(row)) : this.rows;
+    if (this.orders.length) {
+      rows = [...rows].sort((left, right) => {
+        for (const order of this.orders) {
+          const result = compare(getValue(left, order.field), getValue(right, order.field));
+          if (result !== 0) return order.direction === "DESC" ? -result : result;
+        }
+        return 0;
+      });
+    }
+    if (this.offset || this.max !== undefined) {
+      rows = rows.slice(this.offset, this.max === undefined ? undefined : this.offset + this.max);
+    }
+    if (!this.selected) return rows;
+    return rows.map((row) => {
+      const selected = {};
+      for (const field of this.selected) selected[field] = getValue(row, field);
+      return selected;
+    });
+  }
+
+  async all() {
+    return this.materialize();
+  }
+
+  async first() {
+    return this.materialize()[0] ?? null;
+  }
+
+  async count() {
+    return this.conditions.length
+      ? this.rows.filter((row) => this.test(row)).length
+      : this.rows.length;
+  }
+}
+
+export function getCollection(name) {
+  return collections[name] ? [...collections[name]] : [];
+}
+
+export function queryCollection(name) {
+  return new CollectionQueryBuilder(collections[name] || []);
+}
+
+export const collectionNames = Object.keys(collections);
+export { CollectionQueryBuilder };
+export default { collections, collectionNames, getCollection, queryCollection };
+`;
+function generateCollectionsModule(manifest) {
+	return `const collections = ${JSON.stringify(manifest.collections)};\n${runtime}`;
+}
+//#endregion
+//#region src/collections.ts
+const DEFAULT_COLLECTION_NAME = "content";
+const DEFAULT_COLLECTION_SOURCE = "**/*";
+function defineCollection(collection) {
+	return collection;
+}
+function defineCollections(collections) {
+	return collections;
+}
+function resolveCollectionsOptions(options) {
+	if (options === false) return {
+		enabled: false,
+		collections: {}
+	};
+	const source = options === true || options === void 0 ? defaultCollections() : options;
+	const collections = {};
+	for (const [name, value] of Object.entries(source)) {
+		const collection = normalizeCollectionOptions(value);
+		collections[name] = {
+			name,
+			source: normalizeSourcePatterns(collection.source),
+			include: [...new Set(collection.include ?? [])]
+		};
+	}
+	return {
+		enabled: true,
+		collections
+	};
+}
+async function buildCollectionManifest(root, options) {
+	if (!options.collections.enabled) return { collections: {} };
+	return parseCollectionManifest((await require_napi.importNapiModule()).buildCollectionManifest({
+		srcDir: node_path.resolve(root, options.srcDir),
+		extensions: [...options.extensions],
+		frontmatter: options.frontmatter,
+		collections: Object.values(options.collections.collections).map((collection) => ({
+			name: collection.name,
+			source: collection.source,
+			include: collection.include
+		})),
+		transformOptions: createNativeTransformOptions(options)
+	}));
+}
+async function generateCollectionsVirtualModule(root, options) {
+	return generateCollectionsModule(await buildCollectionManifest(root, options));
+}
+function normalizeCollectionOptions(options) {
+	if (typeof options === "string" || Array.isArray(options)) return { source: options };
+	return options;
+}
+function normalizeSourcePatterns(source) {
+	return (Array.isArray(source) ? source : [source ?? DEFAULT_COLLECTION_SOURCE]).map((value) => value || DEFAULT_COLLECTION_SOURCE);
+}
+function parseCollectionManifest(json) {
+	const value = JSON.parse(json);
+	if (!value || typeof value !== "object" || !("collections" in value)) throw new Error("[ox-content] Native collection manifest returned an invalid payload.");
+	return value;
+}
+function createNativeTransformOptions(options) {
+	return {
+		gfm: options.gfm,
+		footnotes: options.footnotes,
+		taskLists: options.taskLists,
+		tables: options.tables,
+		strikethrough: options.strikethrough,
+		frontmatter: options.frontmatter,
+		tocMaxDepth: options.tocMaxDepth,
+		codeAnnotations: options.codeAnnotations?.enabled ?? false,
+		codeAnnotationMetaKey: options.codeAnnotations?.metaKey ?? "annotate",
+		codeAnnotationSyntax: options.codeAnnotations?.notation ?? "attribute",
+		codeAnnotationDefaultLineNumbers: options.codeAnnotations?.defaultLineNumbers ?? false,
+		wikiLinks: options.wikiLinks?.enabled ? {
+			enabled: true,
+			baseUrl: options.wikiLinks.baseUrl
+		} : void 0,
+		emojiShortcodes: options.emojiShortcodes?.enabled ? {
+			enabled: true,
+			custom: options.emojiShortcodes.custom
+		} : void 0,
+		attributes: options.attrs?.enabled ? { enabled: true } : void 0,
+		cjkEmphasis: options.cjkEmphasis ?? false,
+		codeImports: options.codeImports?.enabled ? {
+			enabled: true,
+			rootDir: options.codeImports.rootDir
+		} : void 0,
+		editThisPage: options.editThisPage?.enabled ? {
+			enabled: true,
+			repoUrl: options.editThisPage.repoUrl,
+			branch: options.editThisPage.branch,
+			rootDir: options.editThisPage.rootDir,
+			label: options.editThisPage.label
+		} : void 0
+	};
+}
+function defaultCollections() {
+	return { [DEFAULT_COLLECTION_NAME]: { source: DEFAULT_COLLECTION_SOURCE } };
+}
+//#endregion
 //#region src/incremental.ts
 function toNativeParserOptions(options = {}) {
 	return {
@@ -3193,6 +3506,10 @@ function createFrameworkMarkdownOptions(options) {
 			placeholder: "Search...",
 			hotkey: "k"
 		},
+		collections: {
+			enabled: false,
+			collections: {}
+		},
 		embeds: {
 			github: options.embeds?.github ?? {},
 			openGraph: options.embeds?.openGraph ?? {},
@@ -4560,6 +4877,7 @@ function oxContent(options = {}) {
 		createEnvironmentPlugin(resolvedOptions),
 		createDocsPlugin(resolvedOptions, getRoot),
 		createSsgPlugin(resolvedOptions, getRoot, ssgDevCache),
+		createCollectionsPlugin(resolvedOptions, getRoot),
 		createSearchPlugin(resolvedOptions, getRoot)
 	];
 	if (resolvedOptions.i18n) plugins.push(createI18nPlugin(resolvedOptions));
@@ -4588,12 +4906,12 @@ function createMainPlugin(resolvedOptions, setConfig) {
 			});
 		},
 		resolveId(id) {
-			if (id.startsWith("virtual:ox-content/")) return "\0" + id;
+			if (id === "virtual:ox-content/config" || id === "virtual:ox-content/runtime") return "\0" + id;
 			if (isMarkdownFilePath(id, resolvedOptions.extensions)) return id;
 			return null;
 		},
 		async load(id) {
-			if (id.startsWith("\0virtual:ox-content/")) return generateVirtualModule(id.slice(20), resolvedOptions);
+			if (id === "\0virtual:ox-content/config" || id === "\0virtual:ox-content/runtime") return generateVirtualModule(id.slice(20), resolvedOptions);
 			return null;
 		},
 		async transform(code, id) {
@@ -4615,6 +4933,37 @@ function createMainPlugin(resolvedOptions, setConfig) {
 		}
 	};
 }
+function createCollectionsPlugin(resolvedOptions, getRoot) {
+	const moduleId = "\0virtual:ox-content/collections";
+	let moduleCode;
+	const invalidate = (devServer) => {
+		moduleCode = void 0;
+		const mod = devServer.moduleGraph.getModuleById(moduleId);
+		if (mod) {
+			devServer.moduleGraph.invalidateModule(mod);
+			devServer.ws.send({ type: "full-reload" });
+		}
+	};
+	return {
+		name: "ox-content:collections",
+		resolveId(id) {
+			return id === "virtual:ox-content/collections" ? moduleId : null;
+		},
+		async load(id) {
+			if (id !== moduleId) return null;
+			moduleCode ??= generateCollectionsVirtualModule(getRoot(), resolvedOptions);
+			return moduleCode;
+		},
+		configureServer(devServer) {
+			if (!resolvedOptions.collections.enabled) return;
+			const srcDir = path.resolve(getRoot(), resolvedOptions.srcDir);
+			devServer.watcher.add(srcDir);
+			devServer.watcher.on("all", (_event, file) => {
+				if (file.startsWith(srcDir) && isMarkdownFilePath(file, resolvedOptions.extensions)) invalidate(devServer);
+			});
+		}
+	};
+}
 function createEnvironmentPlugin(resolvedOptions) {
 	return {
 		name: "ox-content:environment",
@@ -4768,6 +5117,7 @@ function resolveOptions(options) {
 		transformers: options.transformers ?? [],
 		docs: resolveDocsOptions(options.docs),
 		search: resolveSearchOptions(options.search),
+		collections: resolveCollectionsOptions(options.collections),
 		ogViewer: options.ogViewer ?? true,
 		embeds: resolveBuiltinEmbedOptions(options.embeds),
 		i18n: resolveI18nOptions(options.i18n)
@@ -5030,6 +5380,7 @@ exports.DocsTestRunError = DocsTestRunError;
 exports.Fragment = Fragment;
 exports.IncrementalMarkdownParser = IncrementalMarkdownParser;
 exports.IncrementalMarkdownRenderer = IncrementalMarkdownRenderer;
+exports.buildCollectionManifest = buildCollectionManifest;
 exports.buildSearchIndex = buildSearchIndex;
 exports.buildSsg = buildSsg;
 exports.clearRenderContext = clearRenderContext;
@@ -5046,6 +5397,8 @@ exports.createIncrementalMarkdownRenderer = createIncrementalMarkdownRenderer;
 exports.createMarkdownEnvironment = createMarkdownEnvironment;
 exports.createTheme = createTheme;
 exports.defaultTheme = require_vitepress.defaultTheme;
+exports.defineCollection = defineCollection;
+exports.defineCollections = defineCollections;
 exports.defineTheme = require_vitepress.defineTheme;
 exports.each = each;
 exports.escapeSvelteMarkup = escapeSvelteMarkup;
@@ -5058,6 +5411,7 @@ exports.fetchGitHubSource = require_github.fetchGitHubSource;
 exports.fetchOgpData = require_ogp.fetchOgpData;
 exports.fetchRepoData = require_github.fetchRepoData;
 exports.fromVitePressConfig = require_vitepress.fromVitePressConfig;
+exports.generateCollectionsVirtualModule = generateCollectionsVirtualModule;
 exports.generateFrontmatterTypes = generateFrontmatterTypes;
 exports.generateHydrationScript = generateHydrationScript;
 exports.generateMarkdown = generateMarkdown;
@@ -5098,6 +5452,7 @@ exports.renderMarkdownStream = renderMarkdownStream;
 exports.renderPage = renderPage;
 exports.renderToString = renderToString;
 exports.resolveBuiltinEmbedOptions = resolveBuiltinEmbedOptions;
+exports.resolveCollectionsOptions = resolveCollectionsOptions;
 exports.resolveDocsOptions = resolveDocsOptions;
 exports.resolveI18nOptions = resolveI18nOptions;
 exports.resolveOgImageOptions = resolveOgImageOptions;