content-query 0.4.0 → 0.5.1

package/dist/vite.d.mts

@@ -1,4 +1,4 @@
-import { a as ContentSourceEvent, o as ContentSourceSnapshot, t as BuildContentOptions } from "./build-DL1GzmRy.mjs";
+import { a as ContentSourceEvent, o as ContentSourceSnapshot, t as BuildContentOptions } from "./build-Aoi7Unm0.mjs";
 import { Plugin } from "vite";
 //#region src/integrations/vite/plugin.d.ts
 /** Public, format-neutral hooks for integrations sharing this plugin's preparation session. */

package/dist/vite.mjs

@@ -1,9 +1,13 @@
-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-CcqIpkes.mjs";
+import { I as collectionNames } from "./operators-D-w1-gDg.mjs";
+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-CIw4yWs9.mjs";
 import { n as serializeContentError } from "./diagnostics-DmUZtrJ6.mjs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { randomUUID } from "node:crypto";
 import { realpathSync } from "node:fs";
+//#region src/integrations/vite/modules.ts
+/** Collection facades are `content-query:collections/<export name>`. */
+const collectionPrefix = "content-query:collections/";
 const preparedFacade = "content-query:prepared-server";
 const clientModule = "\0content-query:client.js";
 const virtualPrefix = "\0content-query:";
@@ -51,24 +55,38 @@ export function onContentUpdate(callback) {
 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 /* @__PURE__ */ new Map([["prepared-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)});`]]);
 	}
-	return next;
+	return revisionModules(revision, {
+		payloadChunkBytes: 131072,
+		preparedEntry: true
+	});
 }
-/** 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;
+/** Picks a module-local binding that cannot shadow the facade's export name. */
+function binding(base, exportName) {
+	return base === exportName ? `${base}_` : base;
+}
+/**
+* Creates one collection's stable facade, which accepts revision updates in host and isolated
+* development runtimes.
+*
+* @param bridgeKey - Identifies the plugin's host session for runtimes in the same process.
+* @param name - The collection's name.
+* @param exportName - The facade's export name.
+* @returns The facade module source.
+*/
+function devFacade(bridgeKey, name, exportName) {
+	const runtime = binding("runtime", exportName);
+	const prepared = binding("prepared", exportName);
+	const live = binding("live", exportName);
+	return `import * as ${runtime} from "content-query/internal";
+import * as ${prepared} from ${JSON.stringify(preparedFacade)};
+const ${live} = ${runtime}.createLiveCollection(${prepared}, ${JSON.stringify(name)});
+export const ${exportName} = globalThis[Symbol.for("content-query.dev-sessions")]?.get(${JSON.stringify(bridgeKey)})?.collections[${JSON.stringify(name)}] ?? ${live}.collection;
 if (import.meta.hot) {
- const apply = next => { if (next) live.update(next); };
+ 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;
@@ -109,6 +127,8 @@ function forbidden(source, config, options, importer) {
 //#endregion
 //#region src/integrations/vite/plugin.ts
 const bridgeSymbol = Symbol.for("content-query.dev-sessions");
+/** Matches a collection facade's virtual ID and captures its export name. */
+const facadeModule = /^\0content-query:collections\/([^/]+)\/server\.js$/;
 /** Integrates in-memory content with Vite; opt into generated storage for standalone artifacts. */
 function contentQuery(options = {}) {
 	let config;
@@ -123,10 +143,18 @@ function contentQuery(options = {}) {
 	const bridgeKey = randomUUID();
 	const refreshClients = /* @__PURE__ */ new WeakSet();
 	const sourceListeners = /* @__PURE__ */ new Set();
-	/** Publishes type-only facade binding without importing configuration in executable code. */
-	async function writeTypes(configPath) {
+	let configFile;
+	/** Publishes type-only facade bindings without importing configuration in executable code. */
+	async function writeTypes(registry) {
+		if (!configFile || !registry) return;
 		const directory = path.join(config.root, ".content-query");
-		await writeChanged(path.join(directory, "types.d.ts"), virtualDeclarations(directory, configPath));
+		await writeChanged(path.join(directory, "types.d.ts"), virtualDeclarations(directory, configFile, collectionNames(registry)));
+	}
+	/** Maps a collection facade's export name back to its collection, or undefined when unknown. */
+	function collectionOf(exportName) {
+		const state = session && sessionInternals(session).state;
+		const registry = state?.revision?.registry ?? state?.registry ?? {};
+		for (const [name, generated] of collectionNames(registry)) if (generated.exportName === exportName) return name;
 	}
 	/** Notifies the host after atomic publication or a recoverable preparation failure. */
 	async function refreshModules(state) {
@@ -156,21 +184,24 @@ function contentQuery(options = {}) {
 	/** Notifies every host environment after portable state modules are ready. */
 	async function changed(state) {
 		await refreshModules(state);
+		await writeTypes(state.revision?.registry ?? state.registry).catch(deliveryFailed);
 		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({
+			const boundaries = [...environment.moduleGraph.idToModuleMap.values()].filter((module) => facadeModule.test(module.id ?? ""));
+			if (prepared) environment.moduleGraph.invalidateModule(prepared);
+			const timestamp = Date.now();
+			const updates = prepared ? boundaries.map((boundary) => ({
+				type: "js-update",
+				timestamp,
+				path: boundary.url,
+				acceptedPath: prepared.url,
+				explicitImportRequired: false,
+				isWithinCircularImport: false
+			})) : [];
+			if (updates.length) environment.hot.send({
 				type: "update",
-				updates: [{
-					type: "js-update",
-					timestamp: Date.now(),
-					path: boundary.url,
-					acceptedPath: prepared.url,
-					explicitImportRequired: false,
-					isWithinCircularImport: false
-				}]
+				updates
 			});
 		}
 		if (state.error) server.ws.send({
@@ -232,7 +263,9 @@ function contentQuery(options = {}) {
 					global[bridgeSymbol].set(bridgeKey, prepared);
 					await refreshModules(sessionInternals(prepared).state);
 				}
-				await writeTypes(configPath);
+				configFile = configPath;
+				const state = sessionInternals(prepared).state;
+				await writeTypes(state.revision?.registry ?? state.registry);
 			} catch (cause) {
 				await prepared.dispose();
 				globalThis[bridgeSymbol]?.delete(bridgeKey);
@@ -283,25 +316,34 @@ function contentQuery(options = {}) {
 		},
 		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.startsWith("content-query:collections/")) return `${virtualPrefix}collections/${source.slice(26)}/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`;
+			const physical = physicalPath(source, config, importer);
+			const entries = path.resolve(config.root, options.outDir ?? "./.content-query", "collections");
+			const relative = physical ? path.relative(entries, physical).replace(/\\/g, "/") : "";
+			if (/^[^/.][^/]*\/server\.js$/.test(relative)) return `${virtualPrefix}collections/${relative}`;
 		},
 		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();
+			const facade = facadeModule.exec(id)?.[1];
+			/** Reports an import of a collection that the configuration does not define. */
+			const unknown = (exportName) => this.error(`[content-query] "${collectionPrefix}${exportName}" does not match a collection in content-query.config.`);
 			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");
+				if (facade !== void 0) {
+					const name = collectionOf(facade);
+					return name === void 0 ? unknown(facade) : devFacade(bridgeKey, name, facade);
+				}
 				return modules.get(id.slice(15));
 			}
-			return modules.get(id.slice(15));
+			const code = modules.get(id.slice(15));
+			return facade !== void 0 && code === void 0 ? unknown(facade) : code;
 		},
 		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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "content-query",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "description": "Typed, framework-independent content collections, queries, and rendering.",
   "homepage": "https://github.com/yangshun/content-query#readme",
   "bugs": {

package/dist/content-CwTKqRs9.d.mts

@@ -1,134 +0,0 @@
-import { n as ContentRenderResult } from "./types-Dh-Sydyw.mjs";
-import { _ as RelationshipsOf, g as Relationship, h as QueryData, i as CollectionRegistry } from "./types-DbFfF6JE.mjs";
-import { b as QueryRegistry, n as RelationalQueries, t as RelationalCountOptions, u as Query, y as QueryPlan } from "./relational-types-C8xJtLG5.mjs";
-import { i as QueryStyleMember, n as QueryStyle, r as QueryStyleDisabled, t as MembersOf } from "./query-style-eXENQJ0O.mjs";
-//#region src/shared/errors.d.ts
-type ContentErrorCode = "variant-not-found" | "not-renderable" | "source-error" | "validation-error" | "duplicate-id" | "invalid-reference" | "invalid-query" | "artifact-error" | "render-error";
-type ContentDiagnostic = {
-  code: ContentErrorCode;
-  message: string;
-  operation?: string;
-  collection?: string;
-  id?: string;
-  source?: string;
-  path?: readonly PropertyKey[];
-  /** The custom payload being resolved or loaded. */
-  payload?: string;
-  /** The payload's variant combination, with keys in sorted order. */
-  variant?: Readonly<Record<string, string>>;
-  issues?: readonly unknown[];
-  cause?: unknown;
-};
-/** A contextual library failure; inspect code and diagnostics instead of message text. */
-declare class ContentError extends Error {
-  /** Recognizes contextual errors across preparation and separately bundled loader modules. */
-  static [Symbol.hasInstance](value: unknown): boolean;
-  readonly code: ContentErrorCode;
-  readonly operation?: string;
-  readonly collection?: string;
-  readonly id?: string;
-  readonly source?: string;
-  readonly path?: readonly PropertyKey[];
-  readonly payload?: string;
-  readonly variant?: Readonly<Record<string, string>>;
-  readonly issues?: readonly unknown[];
-  readonly diagnostics: readonly ContentDiagnostic[];
-  /** Creates one failure or a grouped report preserving individual causes and issues. */
-  constructor(options: ContentDiagnostic & {
-    diagnostics?: readonly ContentDiagnostic[];
-  });
-}
-//#endregion
-//#region src/collection/registry-types.d.ts
-type Scalar = string | number | bigint | boolean | Date;
-type Element<Value> = NonNullable<Value> extends readonly (infer Item)[] ? NonNullable<Item> : NonNullable<Value>;
-type Compatible<Left, Right> = NonNullable<Left> extends readonly unknown[] ? NonNullable<Right> extends readonly unknown[] ? false : ScalarCompatible<Left, Right> : ScalarCompatible<Left, Right>;
-type ScalarCompatible<Left, Right> = [Element<Left> | Element<Right>] extends [Scalar] ? [Element<Left>] extends [never] ? true : [Element<Right>] extends [never] ? true : [Extract<Element<Left>, Element<Right>> | Extract<Element<Right>, Element<Left>>] extends [never] ? false : true : false;
-type CheckRelation<Registry extends CollectionRegistry, Name extends keyof Registry, Link extends Relationship> = Link["collection"] extends keyof Registry ? Link["from"] extends keyof QueryData<Registry[Name]> ? Link["to"] extends keyof QueryData<Registry[Link["collection"]]> ? Compatible<QueryData<Registry[Name]>[Link["from"]], QueryData<Registry[Link["collection"]]>[Link["to"]]> extends true ? never : "incompatible-relationship-fields" : "unknown-target-field" : "unknown-source-field" : "unknown-target-collection";
-/** Registry-level relationship checks require the complete inferred collection map. */
-type InvalidRelationships<Registry extends CollectionRegistry> = { [Name in keyof Registry]: { [Link in keyof RelationshipsOf<Registry[Name]>]: RelationshipsOf<Registry[Name]>[Link] extends Relationship ? CheckRelation<Registry, Name, RelationshipsOf<Registry[Name]>[Link]> : "invalid-relationship"; }[keyof RelationshipsOf<Registry[Name]>]; }[keyof Registry];
-//#endregion
-//#region src/runtime/revision.d.ts
-type QueryRecord = Record<string, unknown> & {
-  id: string;
-};
-/** Custom payload loaders by payload name, entry ID, and canonical variant key. */
-type CustomPayloadTable = ReadonlyMap<string, ReadonlyMap<string, ReadonlyMap<string, () => Promise<unknown>>>>;
-/** The built-in side payload shared by an entry's `_body` and `_rendered` payloads. */
-type BuiltinPayload = {
-  body?: string;
-  rendered?: ContentRenderResult;
-  markdown?: string;
-};
-type PreparedCollection = {
-  records: readonly QueryRecord[];
-  relationships: Record<string, Relationship>;
-  /** Lazy built-in payloads, present only for entries with a body or rendered output. */
-  builtins: ReadonlyMap<string, () => Promise<BuiltinPayload>>;
-  /**
-   * Lazy custom payloads by payload name, entry ID, and canonical variant key. A missing variant
-   * key means the entry has no such combination.
-   */
-  payloads?: CustomPayloadTable;
-  sources?: ReadonlyMap<string, string | undefined>;
-};
-type PreparedRevision = {
-  registry: QueryRegistry;
-  collections: Record<string, PreparedCollection>;
-  relations: Map<string, Map<string, readonly QueryRecord[]>>;
-  active: number;
-  /** Built-in payloads keyed by collection and ID; custom payloads also by name and variant. */
-  payloadCache: Map<string, Promise<unknown>>;
-  renderCache: Map<string, Promise<ContentRenderResult>>;
-  renderMarkdown?: (body: string) => Promise<ContentRenderResult>;
-  /** The only query style this revision's configuration allows; absent allows both. */
-  queryStyle?: QueryStyle;
-  execute?: (plan: QueryPlan, terminal: "all" | "first" | "count", requests: PayloadRequest[]) => Promise<unknown>;
-};
-/** A projected row awaiting the payloads its query scope requested. */
-type PayloadRequest = {
-  target: Record<string, unknown>;
-  collection: string;
-  id: string;
-  payloads: NonNullable<QueryPlan["payloads"]>;
-};
-type ContentState = {
-  revision?: PreparedRevision;
-  registry?: QueryRegistry;
-  error?: ContentError;
-};
-//#endregion
-//#region src/runtime/content.d.ts
-type ContentMethods<Registry extends CollectionRegistry = {}> = {
-  /**
-   * Starts a fluent query over one collection. Nothing is selected until `select()`, `with()`,
-   * `withPayload()`, or `selectAdjacent()` requests data, not even `id`.
-   */
-  from<Name extends keyof Registry & string>(collection: Name): Query<Registry, Name>;
-  /** Collection-scoped relational queries with typed columns, relationships, payloads, and filters. */
-  readonly query: RelationalQueries<Registry>;
-  /** Counts matching entries before pagination, like the fluent count terminal. */
-  count<Name extends keyof Registry & string>(collection: Name, options?: RelationalCountOptions<Registry, Name>): Promise<number>;
-};
-/**
- * Root members outside the allowed style. Property access reports the message type directly; a
- * call reports it as the required `this` type, whatever arguments it passes.
- */
-type DisabledMembers<Style extends QueryStyle> = { readonly [Member in Exclude<QueryStyleMember, MembersOf<Style>>]: ContentMethods[Member] extends ((...arguments_: never) => unknown) ? (this: QueryStyleDisabled<Member, Style>, ...arguments_: readonly unknown[]) => never : QueryStyleDisabled<Member, Style>; };
-/**
- * The generated `content` export. `Style` narrows the root query APIs to the `queryStyle` exported
- * by content-query.config; the default allows both fluent and relational queries.
- *
- * The gate avoids a conditional on `Style`: a conditional on a generic `Style` would make
- * `ContentSession<Registry>` invariant in `Registry` and break assignment to wider sessions.
- */
-type Content<Registry extends CollectionRegistry = {}, Style extends QueryStyle = QueryStyle> = InvalidRelationships<Registry> extends never ? Pick<ContentMethods<Registry>, MembersOf<Style>> & DisabledMembers<Style> : {
-  readonly invalidRelationships: InvalidRelationships<Registry>;
-};
-/** Keeps dev builders live across host-delivered revisions while pinning active operations. */
-declare function createLiveRuntime(initial: ContentState): {
-  content: Pick<ContentMethods<CollectionRegistry>, "from" | "query" | "count"> & DisabledMembers<QueryStyle>;
-  update(next: ContentState): void;
-};
-//#endregion
-export { ContentDiagnostic as a, InvalidRelationships as i, createLiveRuntime as n, ContentError as o, PreparedRevision as r, ContentErrorCode as s, Content as t };

package/dist/query-style-eXENQJ0O.d.mts

@@ -1,22 +0,0 @@
-//#region src/runtime/query-style.d.ts
-/** Query APIs an application can allow through `queryStyle` in content-query.config. */
-type QueryStyle = "fluent" | "relational";
-/**
- * Root `content` members that start each query style. Every other query API hangs off these
- * members, so gating them gates payloads, relationships, and adjacency as well.
- */
-declare const queryStyleMembers: {
-  readonly fluent: readonly ["from"];
-  readonly relational: readonly ["query", "count"];
-};
-/** A root `content` member that belongs to exactly one query style. */
-type QueryStyleMember = (typeof queryStyleMembers)[QueryStyle][number];
-/** Root members that start a query in the given style. */
-type MembersOf<Style extends QueryStyle> = (typeof queryStyleMembers)[Style][number];
-/**
- * Describes a disabled root member in the type error itself, for example:
- * `content.from is unavailable because content-query.config sets queryStyle to "relational".`
- */
-type QueryStyleDisabled<Member extends QueryStyleMember, Style extends QueryStyle> = `content.${Member} is unavailable because content-query.config sets queryStyle to "${Style}".`;
-//#endregion
-export { QueryStyleMember as i, QueryStyle as n, QueryStyleDisabled as r, MembersOf as t };