content-query 0.0.2 → 0.2.0

package/dist/vite.d.mts

@@ -0,0 +1,6 @@
+import { t as BuildContentOptions } from "./build-DfKd2bpf.mjs";
+import { Plugin } from "vite";
+//#region src/integrations/vite/plugin.d.ts
+/** Integrates in-memory content with Vite; opt into generated storage for standalone artifacts. */
+export declare function contentQuery(options?: Omit<BuildContentOptions, "watch">): Plugin;
+//#endregion

package/dist/vite.mjs

@@ -0,0 +1,296 @@
+import { a as sessionInternals, i as resolveConfigPath, l as virtualDeclarations, o as withinDirectory, r as configCandidates, s as writeChanged, t as buildAtRoot, u as revisionModules } from "./build-Dxz7P1ur.mjs";
+import { n as serializeContentError } from "./diagnostics-Cu94mZhl.mjs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { realpathSync } from "node:fs";
+const preparedFacade = "content-query:prepared-server";
+const clientModule = "\0content-query:client.js";
+const virtualPrefix = "\0content-query:";
+/** Provides a client-safe subscription without exposing the content runtime or registry. */
+function devClient(development) {
+	if (!development) return "export function onContentUpdate() { return () => {}; }";
+	return `const listeners = new Set();
+let pending = false;
+let refreshing = false;
+async function refresh() {
+ pending = true;
+ if (refreshing) return;
+ refreshing = true;
+ try {
+  while (pending) {
+   pending = false;
+   try {
+    await Promise.all([...listeners].map(callback => Promise.resolve().then(callback)));
+    if (typeof document !== "undefined") {
+     for (const overlay of document.querySelectorAll("vite-error-overlay")) {
+      if (overlay.shadowRoot?.querySelector(".plugin")?.textContent.trim() === "[plugin:content-query]") overlay.close();
+     }
+    }
+   } catch (error) {
+    console.error("[content-query] Could not refresh page data", error);
+   }
+  }
+ } finally { refreshing = false; }
+}
+if (import.meta.hot) {
+ import.meta.hot.on("content-query:update", refresh);
+ import.meta.hot.on("vite:ws:connect", () => { if (listeners.size) import.meta.hot.send("content-query:subscribe"); });
+ import.meta.hot.dispose(() => { listeners.clear(); import.meta.hot.send("content-query:unsubscribe"); });
+}
+export function onContentUpdate(callback) {
+ listeners.add(callback);
+ import.meta.hot?.send("content-query:subscribe");
+ return () => {
+  listeners.delete(callback);
+  if (!listeners.size) import.meta.hot?.send("content-query:unsubscribe");
+ };
+}`;
+}
+/** Encodes a complete prepared revision or its contextual development error for isolated runtimes. */
+async function preparedModules(state) {
+	const revision = state.revision;
+	const error = state.error;
+	let next;
+	if (error) {
+		const serialized = serializeContentError(error);
+		next = /* @__PURE__ */ new Map([["server.js", `import { restoreContentError } from "content-query/internal"; export const revision = undefined; export const registry = JSON.parse(${JSON.stringify(JSON.stringify(state.registry ?? {}))}); export const error = restoreContentError(${JSON.stringify(serialized)});`]]);
+	} else {
+		next = await revisionModules(revision, { payloadChunkBytes: 131072 });
+		next.set("server.js", next.get("server.js").replaceAll("createArtifactRuntime", "createArtifactRevision").replace("export const content =", "export const revision =") + "\nexport const registry = revision.registry; export const error = undefined;\n");
+	}
+	return next;
+}
+/** Creates the stable facade that accepts revision updates in host and isolated dev runtimes. */
+function devFacade(bridgeKey) {
+	return `import { createLiveRuntime } from "content-query/internal";
+import * as prepared from ${JSON.stringify(preparedFacade)};
+const live = createLiveRuntime(prepared);
+export const content = globalThis[Symbol.for("content-query.dev-sessions")]?.get(${JSON.stringify(bridgeKey)})?.content ?? live.content;
+if (import.meta.hot) {
+ const apply = next => { if (next) live.update(next); };
+ import.meta.hot.accept(${JSON.stringify(preparedFacade)}, apply);
+ // Module runners unwrap virtual IDs in update messages. Register that form too.
+ const hot = import.meta.hot;
+ hot.accept(${JSON.stringify(`${virtualPrefix}prepared-server.js`)}, apply);
+}`;
+}
+//#endregion
+//#region src/integrations/vite/client-boundary.ts
+/** Locates this installed package, so application paths named "content-query" never match it. */
+function packageDirectory() {
+	try {
+		return path.dirname(realpathSync(createRequire(import.meta.url).resolve("content-query/package.json")));
+	} catch {
+		return;
+	}
+}
+const installed = packageDirectory();
+/** Detects the consuming environment before any server module is loaded. */
+function clientEnvironment(context, config, ssr) {
+	const environment = context.environment;
+	return environment?.config?.consumer ? environment.config.consumer === "client" : environment?.name ? environment.name === "client" : !ssr && !config.build.ssr;
+}
+/** Resolves physical paths without relying on a server entry's import spelling. */
+function physicalPath(source, config, importer) {
+	const cleaned = source.split("?")[0];
+	return cleaned.startsWith(".") ? path.resolve(importer ? path.dirname(importer) : config.root, cleaned) : path.isAbsolute(cleaned) ? cleaned : "";
+}
+/** Identifies build/runtime dependencies that must never enter a client graph. */
+function forbidden(source, config, options, importer) {
+	if (source === "content-query:client" || source === "\0content-query:client.js") return false;
+	if (source.startsWith("content-query:") || source.startsWith("virtual:content-query/") || source.startsWith("\0content-query:") || /^content-query(?:\/|$)/.test(source)) return true;
+	const filename = physicalPath(source, config, importer).replace(/\\/g, "/");
+	if (!filename) return false;
+	const configPaths = configCandidates(config.root, options.config).map((filename) => filename.replace(/\\/g, "/"));
+	const outputPath = path.resolve(config.root, options.outDir ?? "./.content-query").replace(/\\/g, "/");
+	return configPaths.includes(filename) || filename.startsWith(`${outputPath}/`) || filename.includes("/node_modules/content-query/") || installed !== void 0 && ["dist", "src"].some((directory) => withinDirectory(path.join(installed, directory), filename));
+}
+//#endregion
+//#region src/integrations/vite/plugin.ts
+const bridgeSymbol = Symbol.for("content-query.dev-sessions");
+/** Integrates in-memory content with Vite; opt into generated storage for standalone artifacts. */
+function contentQuery(options = {}) {
+	let config;
+	let building = false;
+	let server;
+	let session;
+	let starting;
+	let modules = /* @__PURE__ */ new Map();
+	let deliveredRevision;
+	let deliveredError;
+	let encoding;
+	const bridgeKey = randomUUID();
+	const refreshClients = /* @__PURE__ */ new WeakSet();
+	/** Publishes type-only facade binding without importing configuration in executable code. */
+	async function writeTypes(configPath) {
+		const directory = path.join(config.root, ".content-query");
+		await writeChanged(path.join(directory, "types.d.ts"), virtualDeclarations(directory, configPath));
+	}
+	/** Notifies the host after atomic publication or a recoverable preparation failure. */
+	async function refreshModules(state) {
+		const revision = state.revision;
+		const error = state.error;
+		if (deliveredRevision === revision && deliveredError === error && modules.size) return;
+		if (!encoding || encoding.revision !== revision || encoding.error !== error) encoding = {
+			revision,
+			error,
+			pending: preparedModules(state)
+		};
+		const current = encoding;
+		try {
+			const next = await current.pending;
+			if (state.revision !== revision || state.error !== error) {
+				await refreshModules(state);
+				return;
+			}
+			if (deliveredRevision === revision && deliveredError === error && modules.size) return;
+			modules = new Map([...modules, ...next]);
+			deliveredRevision = revision;
+			deliveredError = error;
+		} finally {
+			if (encoding === current) encoding = void 0;
+		}
+	}
+	/** Notifies every host environment after portable state modules are ready. */
+	async function changed(state) {
+		await refreshModules(state);
+		if (!server) return;
+		for (const environment of Object.values(server.environments)) {
+			const boundary = environment.moduleGraph.getModuleById(`${virtualPrefix}server.js`);
+			const prepared = environment.moduleGraph.getModuleById(`${virtualPrefix}prepared-server.js`);
+			for (const module of environment.moduleGraph.idToModuleMap.values()) if (module.id === `content-query:prepared-server.js`) environment.moduleGraph.invalidateModule(module);
+			if (boundary && prepared) environment.hot.send({
+				type: "update",
+				updates: [{
+					type: "js-update",
+					timestamp: Date.now(),
+					path: boundary.url,
+					acceptedPath: prepared.url,
+					explicitImportRequired: false,
+					isWithinCircularImport: false
+				}]
+			});
+		}
+		if (state.error) server.ws.send({
+			type: "error",
+			err: {
+				message: state.error.message,
+				stack: state.error.stack ?? "",
+				plugin: "content-query"
+			}
+		});
+		else {
+			server.ws.send({
+				type: "custom",
+				event: "content-query:update",
+				data: {}
+			});
+			for (const client of server.ws.clients) if (!refreshClients.has(client)) client.send({ type: "full-reload" });
+		}
+	}
+	/** Reports rejected host notifications instead of leaving a detached promise unhandled. */
+	function deliveryFailed(cause) {
+		const message = `[content-query] Could not deliver prepared content: ${cause instanceof Error ? cause.message : String(cause)}`;
+		config.logger.error(message);
+		try {
+			server?.ws.send({
+				type: "error",
+				err: {
+					message,
+					stack: cause instanceof Error ? cause.stack ?? "" : "",
+					plugin: "content-query"
+				}
+			});
+		} catch {}
+	}
+	/** Starts exactly one host-owned preparation/watch session. */
+	async function ensureSession() {
+		starting ??= resolveConfigPath(config.root, options.config).then(async (configPath) => {
+			const prepared = await buildAtRoot(config.root, {
+				...options,
+				backend: options.backend ?? "in-memory",
+				config: configPath,
+				watch: !building && !config.isProduction && config.command === "serve" && config.server.watch !== null
+			}, (state) => {
+				if (config.command === "serve") changed(state).catch(deliveryFailed);
+			});
+			session = prepared;
+			try {
+				if (config.command === "serve") {
+					const global = globalThis;
+					global[bridgeSymbol] ??= /* @__PURE__ */ new Map();
+					global[bridgeSymbol].set(bridgeKey, prepared);
+					await refreshModules(sessionInternals(prepared).state);
+				}
+				await writeTypes(configPath);
+			} catch (cause) {
+				await prepared.dispose();
+				globalThis[bridgeSymbol]?.delete(bridgeKey);
+				throw cause;
+			}
+			return prepared;
+		});
+		return starting;
+	}
+	return {
+		name: "content-query",
+		enforce: "pre",
+		configResolved(resolved) {
+			config = resolved;
+			building ||= resolved.command === "build";
+			if (resolved.server.watch !== null) {
+				const ignored = resolved.server.watch?.ignored;
+				const output = path.resolve(resolved.root, options.outDir ?? "./.content-query");
+				resolved.server.watch = {
+					...resolved.server.watch,
+					ignored: [...ignored === void 0 ? [] : Array.isArray(ignored) ? ignored : [ignored], (filename) => withinDirectory(output, path.resolve(filename))]
+				};
+			}
+		},
+		configureServer(viteServer) {
+			server = viteServer;
+			server.ws.on("content-query:subscribe", (_data, client) => refreshClients.add(client));
+			server.ws.on("content-query:unsubscribe", (_data, client) => refreshClients.delete(client));
+			ensureSession().catch(() => {});
+		},
+		async buildStart() {
+			if (config.command === "build" && clientEnvironment(this, config)) return;
+			const prepared = await ensureSession();
+			if (config.command === "build") modules = await revisionModules(sessionInternals(prepared).state.revision, { payloadChunkBytes: 131072 });
+		},
+		resolveId(source, importer, resolveOptions) {
+			if (clientEnvironment(this, config, resolveOptions.ssr) && forbidden(source, config, options, importer)) this.error(`[content-query] Server-only import "${source}" is reachable from a client module${importer ? `: ${importer}` : "."}`);
+			if (source === "content-query:server") return `${virtualPrefix}server.js`;
+			if (source === "content-query:client") return clientModule;
+			if (source === "content-query:prepared-server") return `${virtualPrefix}prepared-server.js`;
+			if (source.startsWith("\0content-query:")) return source;
+			if (source.startsWith(".") && importer?.startsWith("\0content-query:")) return `${virtualPrefix}${path.posix.normalize(path.posix.join(path.posix.dirname(importer.slice(15)), source))}`;
+			if (physicalPath(source, config, importer) === path.resolve(config.root, options.outDir ?? "./.content-query", "server.js")) return `${virtualPrefix}server.js`;
+		},
+		async load(id, loadOptions) {
+			if (id === "\0content-query:client.js") return devClient(config.command === "serve");
+			if (!id.startsWith("\0content-query:")) return;
+			if (clientEnvironment(this, config, loadOptions?.ssr)) this.error("[content-query] Content runtime cannot be loaded by the client.");
+			await ensureSession();
+			if (config.command === "serve") {
+				await refreshModules(sessionInternals(session).state);
+				if (id === `content-query:server.js`) return devFacade(bridgeKey);
+				if (id === `content-query:prepared-server.js`) return modules.get("server.js");
+				return modules.get(id.slice(15));
+			}
+			return modules.get(id.slice(15));
+		},
+		transform(_code, id, transformOptions) {
+			if (clientEnvironment(this, config, transformOptions?.ssr) && forbidden(id, config, options)) this.error(`[content-query] Server-only module is reachable from the client: ${id}`);
+		},
+		async closeBundle() {
+			server = void 0;
+			await starting?.catch(() => void 0);
+			await session?.dispose();
+			globalThis[bridgeSymbol]?.delete(bridgeKey);
+		}
+	};
+}
+//#endregion
+export { contentQuery };

package/package.json

@@ -1,13 +1,95 @@
 {
   "name": "content-query",
-  "version": "0.0.2",
-  "description": "",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+  "version": "0.2.0",
+  "description": "Typed, framework-independent content collections, queries, and rendering.",
+  "homepage": "https://github.com/yangshun/content-query#readme",
+  "bugs": {
+    "url": "https://github.com/yangshun/content-query/issues"
+  },
+  "license": "MIT",
+  "author": "Yangshun Tay",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yangshun/content-query.git",
+    "directory": "packages/content-query"
+  },
+  "bin": {
+    "content-query": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./build": "./dist/build.mjs",
+    "./cli": "./dist/cli.mjs",
+    "./computed": "./dist/computed.mjs",
+    "./internal": "./dist/internal.mjs",
+    "./internal/markdown": "./dist/internal/markdown.mjs",
+    "./loaders": "./dist/loaders.mjs",
+    "./next": "./dist/next.mjs",
+    "./query": "./dist/query.mjs",
+    "./runtime": "./dist/runtime.mjs",
+    "./schema": "./dist/schema.mjs",
+    "./vite": "./dist/vite.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@shikijs/engine-javascript": "^4.5.0",
+    "@standard-schema/spec": "^1.1.0",
+    "cac": "^7.1.0",
+    "chokidar": "^5.0.0",
+    "devalue": "6.0.2",
+    "fflate": "^0.8.3",
+    "github-slugger": "^2.0.0",
+    "gray-matter": "^4.0.3",
+    "htmlparser2": "^12.0.0",
+    "jiti": "^2.7.0",
+    "markdown-exit": "^1.3.0",
+    "picomatch": "^4.0.4",
+    "reading-time": "^1.5.0",
+    "shiki": "^4.5.0",
+    "smol-toml": "^1.4.2",
+    "tinyglobby": "^0.2.17",
+    "yaml": "^2.9.1",
+    "zod": "^4.3.6"
   },
-  "keywords": [],
-  "author": "",
-  "license": "ISC",
-  "packageManager": "pnpm@10.28.1"
-}
+  "devDependencies": {
+    "@ascorbic/csv-loader": "^2.0.3",
+    "@types/node": "^25.5.0",
+    "@types/picomatch": "^4.0.3",
+    "astro": "7.4.0",
+    "next": "16.4.2",
+    "tsrs": "0.18.0-ts7.1.0-dev.20260929",
+    "typescript": "npm:@typescript/typescript6@6.0.2",
+    "vite-plus": "1.3.0"
+  },
+  "peerDependencies": {
+    "next": "^16.0.0",
+    "vite": "^8.0.0"
+  },
+  "peerDependenciesMeta": {
+    "next": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22.12.0"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch --no-clean",
+    "check": "vp check && vp run typecheck",
+    "typecheck": "tsrs --noEmit",
+    "test": "vp test"
+  }
+}