content-query 0.0.2 → 0.1.0

package/dist/loaders.mjs

@@ -0,0 +1,85 @@
+import { o as builtinPath, s as builtinSymbol } from "./validation-BvvjSUFc.mjs";
+import { i as groupDiagnostics, n as contentError, r as describeCause, t as ContentError } from "./errors-C8lWyiy2.mjs";
+import { a as populateStore, i as recordData, n as coerceIdentity, r as parseData, t as glob } from "./glob-DJmebCMM.mjs";
+import { t as assertServerOnly } from "./server-only-CIE-FHx0.mjs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/loaders/file.ts
+/** Declares a multi-entry data file with typed source paths and record keys, plus an optional parser. */
+function file(filename, options = {}) {
+	if (typeof filename !== "string" || !filename) throw new TypeError("file() requires a filename.");
+	const descriptor = {
+		kind: "file",
+		filename,
+		options
+	};
+	return {
+		[builtinSymbol]: descriptor,
+		name: "content-query/file",
+		async load(context) {
+			await populateStore(context, await loadFile(descriptor, fileURLToPath(context.config.root), context.signal ?? new AbortController().signal));
+		}
+	};
+}
+/** Captures a complete multi-entry data source without applying collection validation. */
+async function loadFile(descriptor, root, signal) {
+	const resolved = builtinPath(descriptor, root);
+	let parsed;
+	try {
+		const text = await readFile(resolved, {
+			encoding: "utf8",
+			signal
+		});
+		parsed = descriptor.options.parser ? await descriptor.options.parser(text) : parseData(text, resolved);
+	} catch (cause) {
+		signal.throwIfAborted();
+		throw contentError(cause, {
+			code: "source-error",
+			source: resolved,
+			message: `Could not load "${descriptor.filename}": ${describeCause(cause)}`,
+			cause
+		});
+	}
+	const array = Array.isArray(parsed);
+	if (!array && (!parsed || typeof parsed !== "object")) throw new ContentError({
+		code: "source-error",
+		source: resolved,
+		message: `"${descriptor.filename}" must parse to an array or keyed record.`
+	});
+	const diagnostics = [];
+	const entries = Object.entries(parsed).flatMap(([key, value]) => {
+		if (!array && key === "$schema" && typeof value === "string") return [];
+		const source = `${resolved}#${key}`;
+		try {
+			const data = recordData(value);
+			const identity = array ? data.id ?? data.slug : key;
+			if (identity == null || coerceIdentity(identity) === "") throw new Error("Array entries require a nonempty id or slug.");
+			const { id: _transportId, ...metadata } = data;
+			return [{
+				id: coerceIdentity(identity),
+				data: metadata,
+				source: array ? source : `${resolved}#${coerceIdentity(identity)}`,
+				sourceData: {
+					filePath: path.relative(root, resolved).split(path.sep).join("/"),
+					key
+				}
+			}];
+		} catch (cause) {
+			diagnostics.push({
+				code: "source-error",
+				source,
+				message: `Invalid entry "${key}" in "${descriptor.filename}": ${describeCause(cause)}`,
+				cause
+			});
+			return [];
+		}
+	});
+	if (diagnostics.length) throw groupDiagnostics(diagnostics);
+	return entries;
+}
+//#endregion
+//#region src/loaders.ts
+assertServerOnly();
+//#endregion
+export { file, glob };

package/dist/markdown-CZBL4Ux_.mjs

@@ -0,0 +1,54 @@
+import { t as BananaSlug } from "./github-slugger-BCAkwEOL.mjs";
+import { t as src_default } from "./dist-BQGVLZyl.mjs";
+//#region src/runtime/markdown.ts
+let highlighting;
+let highlighter;
+const markdown = new src_default({
+	html: true,
+	linkify: true
+});
+markdown.renderer.rules.fence = async (allTokens, index) => {
+	const token = allTokens[index];
+	const requested = token.info.trim().split(/\s+/)[0] || "text";
+	const { bundledLanguages, createHighlighter } = await (highlighting ??= import("shiki"));
+	const language = Object.hasOwn(bundledLanguages, requested) ? requested : "text";
+	highlighter ??= import("@shikijs/engine-javascript").then(({ createJavaScriptRegexEngine }) => createHighlighter({
+		engine: createJavaScriptRegexEngine(),
+		themes: ["github-light", "github-dark"],
+		langs: []
+	}));
+	const instance = await highlighter;
+	if (language !== "text" && !instance.getLoadedLanguages().includes(language)) await instance.loadLanguage(language);
+	return `<div class="language-${language}">${instance.codeToHtml(token.content, {
+		lang: language,
+		themes: {
+			light: "github-light",
+			dark: "github-dark"
+		},
+		defaultColor: "light"
+	})}</div>\n`;
+};
+/** Compiles captured Markdown using only library-owned, portable processing code. */
+async function renderMarkdown(body) {
+	const slugger = new BananaSlug();
+	const tokens = markdown.parse(body, {});
+	const headings = [];
+	for (let index = 0; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (token.type !== "heading_open") continue;
+		const text = (tokens[index + 1]?.children ?? []).map((child) => child.type === "text" || child.type === "code_inline" || child.type === "image" ? child.content : child.type === "softbreak" || child.type === "hardbreak" ? " " : "").join("");
+		const slug = slugger.slug(text);
+		token.attrSet("id", slug);
+		headings.push({
+			depth: Number(token.tag.slice(1)),
+			slug,
+			text
+		});
+	}
+	return {
+		html: await markdown.renderer.renderAsync(tokens, markdown.options, {}),
+		headings
+	};
+}
+//#endregion
+export { renderMarkdown as t };

package/dist/next.d.mts

@@ -0,0 +1,21 @@
+import { t as BuildContentOptions } from "./build-DSyoRxkZ.mjs";
+import { NextConfig } from "next";
+
+//#region src/integrations/next/plugin.d.ts
+/** Content locations for Next.js; the adapter chooses generated storage and the watch lifecycle. */
+type NextContentOptions = Pick<BuildContentOptions, "config" | "outDir">;
+type ConfigContext = {
+  defaultConfig: NextConfig;
+};
+type ConfigInput = NextConfig | Promise<NextConfig> | ((phase: string, context: ConfigContext) => NextConfig | Promise<NextConfig>);
+/**
+ * Builds content before Next compiles, retaining one managed watcher during `next dev`.
+ * Import the generated server entry from Server Components; Next's HMR observes its updates.
+ * Next's detached telemetry helper evaluates configuration without starting content sessions.
+ * @param nextConfig Existing object, promise, or phase-aware Next.js configuration.
+ * @param options Optional content configuration file and generated output directory.
+ * @returns An asynchronous Next.js configuration function that owns the content lifecycle.
+ */
+declare function withContentQuery(nextConfig?: ConfigInput, options?: NextContentOptions): (phase: string, context: ConfigContext) => Promise<NextConfig>;
+//#endregion
+export { type NextContentOptions, withContentQuery };

package/dist/next.mjs

@@ -0,0 +1,142 @@
+import { c as contentDeclarations, i as resolveConfigPath, t as buildAtRoot } from "./build-C5ef0kkR.mjs";
+import { n as serializeContentError } from "./diagnostics-Dol6ANtq.mjs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { PHASE_DEVELOPMENT_SERVER, PHASE_PRODUCTION_BUILD } from "next/constants.js";
+//#region src/integrations/next/publication.ts
+/** Switches a development entry synchronously so error delivery cannot race a later publication. */
+function writeEntry(filename, source) {
+	try {
+		if (readFileSync(filename, "utf8") === source) return;
+	} catch {}
+	mkdirSync(path.dirname(filename), { recursive: true });
+	const temporary = `${filename}.tmp-${process.pid}-${randomUUID()}`;
+	try {
+		writeFileSync(temporary, source);
+		renameSync(temporary, filename);
+	} finally {
+		rmSync(temporary, { force: true });
+	}
+}
+/** Publishes fresh runtime imports and optionally prunes previous runs after a successful build. */
+function publishDevelopment(outDir, config, state, { prune = false } = {}) {
+	if (!state.error) {
+		if (!state.revision) return;
+		const entry = path.join(outDir, "server.js");
+		const filename = `next-dev-${randomUUID()}.js`;
+		const runtime = path.join(outDir, filename);
+		writeEntry(runtime, readFileSync(entry, "utf8"));
+		writeEntry(entry, `export { content } from ${JSON.stringify(`./${filename}`)};\n`);
+		if (prune) pruneDevelopmentEntries(outDir, filename);
+		return runtime;
+	}
+	writeEntry(path.join(outDir, "package.json"), "{\"type\":\"module\",\"private\":true}\n");
+	writeEntry(path.join(outDir, "server.d.ts"), contentDeclarations(outDir, config));
+	writeEntry(path.join(outDir, "server.js"), `import { restoreContentError } from "content-query/internal";\nthrow restoreContentError(${JSON.stringify(serializeContentError(state.error))});\nexport const content = undefined;\n`);
+}
+/** Removes owned runtime entries from previous runs, preserving the current facade's target. */
+function pruneDevelopmentEntries(outDir, keep) {
+	for (const filename of readdirSync(outDir)) if (filename !== keep && /^next-dev-[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}\.js$/.test(filename)) rmSync(path.join(outDir, filename), { force: true });
+}
+//#endregion
+//#region src/integrations/next/plugin.ts
+const ownerSymbol = Symbol.for("content-query.next-sessions");
+const global = globalThis;
+const owner = global[ownerSymbol] ??= { entries: /* @__PURE__ */ new Map() };
+/** Removes signal listeners when this adapter no longer owns any development sessions. */
+function unobserveShutdown() {
+	if (owner.entries.size === 0 && owner.shutdown) {
+		process.removeListener("SIGINT", owner.shutdown);
+		process.removeListener("SIGTERM", owner.shutdown);
+		owner.shutdown = void 0;
+	}
+}
+/** Registers one process-level cleanup while Next retains ownership of process termination. */
+function observeShutdown() {
+	if (owner.shutdown) return;
+	owner.shutdown = () => {
+		const entries = [...owner.entries.values()];
+		owner.entries.clear();
+		unobserveShutdown();
+		Promise.allSettled(entries.map(async (entry) => (await entry.ready).dispose())).then((results) => {
+			for (const result of results) if (result.status === "rejected") console.error("[content-query] Could not close Next.js content session", result.reason);
+		});
+	};
+	process.once("SIGINT", owner.shutdown);
+	process.once("SIGTERM", owner.shutdown);
+}
+/** Closes a previous development session before a production build in the same process. */
+async function stopDevelopment(root) {
+	const entry = owner.entries.get(root);
+	if (entry) {
+		owner.entries.delete(root);
+		unobserveShutdown();
+		await (await entry.ready).dispose();
+	}
+}
+/** Reuses a pending session and serializes replacement when content locations change. */
+async function startDevelopment(root, options) {
+	const config = await resolveConfigPath(root, options.config);
+	const outDir = path.resolve(root, options.outDir ?? "./.content-query");
+	const key = JSON.stringify([config, outDir]);
+	const previous = owner.entries.get(root);
+	if (previous?.key === key) {
+		await previous.ready;
+		return;
+	}
+	const entry = {
+		key,
+		ready: Promise.resolve().then(async () => {
+			if (previous) await (await previous.ready).dispose();
+			let firstPublication = true;
+			return buildAtRoot(root, {
+				config,
+				outDir,
+				backend: "generated",
+				watch: true
+			}, (state) => {
+				if (publishDevelopment(outDir, config, state, { prune: firstPublication })) firstPublication = false;
+			});
+		})
+	};
+	owner.entries.set(root, entry);
+	observeShutdown();
+	try {
+		await entry.ready;
+	} catch (cause) {
+		if (owner.entries.get(root) === entry) {
+			owner.entries.delete(root);
+			unobserveShutdown();
+		}
+		throw cause;
+	}
+}
+/**
+* Builds content before Next compiles, retaining one managed watcher during `next dev`.
+* Import the generated server entry from Server Components; Next's HMR observes its updates.
+* Next's detached telemetry helper evaluates configuration without starting content sessions.
+* @param nextConfig Existing object, promise, or phase-aware Next.js configuration.
+* @param options Optional content configuration file and generated output directory.
+* @returns An asynchronous Next.js configuration function that owns the content lifecycle.
+*/
+function withContentQuery(nextConfig = {}, options = {}) {
+	const root = process.cwd();
+	return async (phase, context) => {
+		const config = await (typeof nextConfig === "function" ? nextConfig(phase, context) : nextConfig);
+		if (process.argv[1]?.replaceAll("\\", "/").endsWith("/telemetry/detached-flush.js")) return config;
+		if (phase === PHASE_DEVELOPMENT_SERVER) await startDevelopment(root, options);
+		else if (phase === PHASE_PRODUCTION_BUILD) {
+			await stopDevelopment(root);
+			await (await buildAtRoot(root, {
+				...options,
+				backend: "generated",
+				watch: false
+			})).dispose();
+			pruneDevelopmentEntries(path.resolve(root, options.outDir ?? "./.content-query"));
+		}
+		return config;
+	};
+}
+//#endregion
+export { withContentQuery };

package/dist/operators-BQpLfJlx.mjs

@@ -0,0 +1,173 @@
+import { a as invalidQuery } from "./errors-C8lWyiy2.mjs";
+import { c as isScalar, i as detach } from "./values-B7lo_2_x.mjs";
+//#region src/query/operators.ts
+/** Builds a checked, backend-independent predicate instead of a per-entry callback. */
+function predicate(operator, field, value) {
+	if (!field || typeof field.name !== "string" || !field.name) invalidQuery("A filter must reference a query field.");
+	if ([
+		"in-array",
+		"not-in-array",
+		"array-contains-any",
+		"array-contains-all",
+		"array-contained"
+	].includes(operator)) {
+		if (!Array.isArray(value) || !value.every(isScalar)) invalidQuery("Choice arguments must be arrays of scalar values.");
+	} else if ([
+		"contains",
+		"starts-with",
+		"ends-with",
+		"like",
+		"ilike"
+	].includes(operator)) {
+		if (typeof value !== "string") invalidQuery("String predicates require a string argument.");
+	} else if (!operator.startsWith("is-") && !isScalar(value)) invalidQuery("This predicate requires a scalar argument.");
+	if ([
+		"gt",
+		"gte",
+		"lt",
+		"lte"
+	].includes(operator) && (value == null || typeof value === "boolean")) invalidQuery("Range predicates require a string, number, bigint, or date.");
+	return {
+		kind: "predicate",
+		operator,
+		field: field.name,
+		value: detach(value)
+	};
+}
+/** Matches a scalar using strict value/date equality. */
+function eq(field, value) {
+	return predicate("eq", field, value);
+}
+/** Negates scalar equality. */
+function ne(field, value) {
+	return predicate("ne", field, value);
+}
+/** Matches values greater than the supplied scalar. */
+function gt(field, value) {
+	return predicate("gt", field, value);
+}
+/** Matches values greater than or equal to the supplied scalar. */
+function gte(field, value) {
+	return predicate("gte", field, value);
+}
+/** Matches values less than the supplied scalar. */
+function lt(field, value) {
+	return predicate("lt", field, value);
+}
+/** Matches values less than or equal to the supplied scalar. */
+function lte(field, value) {
+	return predicate("lte", field, value);
+}
+/** Matches one of a list of scalar choices. */
+function inArray(field, values) {
+	return predicate("in-array", field, values);
+}
+/** Matches none of a list of scalar choices. */
+function notInArray(field, values) {
+	return predicate("not-in-array", field, values);
+}
+/** Matches a literal substring, without SQL wildcard interpretation. */
+function contains(field, value) {
+	return predicate("contains", field, value);
+}
+/** Matches a literal string prefix. */
+function startsWith(field, value) {
+	return predicate("starts-with", field, value);
+}
+/** Matches a literal string suffix. */
+function endsWith(field, value) {
+	return predicate("ends-with", field, value);
+}
+/** Tests scalar membership in an array, ignoring holes. */
+function arrayContains(field, value) {
+	return predicate("array-contains", field, value);
+}
+/** Tests whether any candidate belongs to an existing scalar array. */
+function arrayContainsAny(field, values) {
+	return predicate("array-contains-any", field, values);
+}
+/** Tests whether every candidate belongs to an existing scalar array. */
+function arrayContainsAll(field, values) {
+	return predicate("array-contains-all", field, values);
+}
+/** Checks explicit null independently from undefined and absence. */
+function isNull(field) {
+	return predicate("is-null", field);
+}
+/** Checks undefined, including a missing property. */
+function isUndefined(field) {
+	return predicate("is-undefined", field);
+}
+/** Checks own-property absence before projection. */
+function isMissing(field) {
+	return predicate("is-missing", field);
+}
+/** Requires all child predicates; an empty conjunction is true. */
+function and(...expressions) {
+	expressions.forEach(validateExpression);
+	return {
+		kind: "and",
+		expressions
+	};
+}
+/** Requires any child predicate; an empty disjunction is false. */
+function or(...expressions) {
+	expressions.forEach(validateExpression);
+	return {
+		kind: "or",
+		expressions
+	};
+}
+/** Negates a predicate's boolean result. */
+function not(expression) {
+	validateExpression(expression);
+	return {
+		kind: "not",
+		expressions: [expression]
+	};
+}
+/** Checks the shape of expression trees even when TypeScript was bypassed. */
+function validateExpression(expression) {
+	if (!expression || typeof expression !== "object") invalidQuery("where() must return a structured expression.");
+	if (expression.kind === "predicate") {
+		if (![
+			"eq",
+			"ne",
+			"gt",
+			"gte",
+			"lt",
+			"lte",
+			"in-array",
+			"not-in-array",
+			"contains",
+			"starts-with",
+			"ends-with",
+			"like",
+			"ilike",
+			"array-contains",
+			"array-contains-any",
+			"array-contains-all",
+			"array-contained",
+			"is-null",
+			"is-undefined",
+			"is-missing"
+		].includes(expression.operator)) invalidQuery("Unknown filter operator.");
+		predicate(expression.operator, { name: expression.field }, expression.value);
+	} else if (expression.kind === "relation") {
+		if ([
+			expression.collection,
+			expression.field,
+			expression.target
+		].some((name) => typeof name !== "string" || !name)) invalidQuery("Relationship filters require registered collection and relationship names.");
+		validateExpression(expression.expression);
+	} else if ([
+		"and",
+		"or",
+		"not"
+	].includes(expression.kind) && Array.isArray(expression.expressions)) {
+		if (expression.kind === "not" && expression.expressions.length !== 1) invalidQuery("not() requires one expression.");
+		expression.expressions.forEach(validateExpression);
+	} else invalidQuery("Invalid expression structure.");
+}
+//#endregion
+export { not as _, contains as a, startsWith as b, gt as c, isMissing as d, isNull as f, ne as g, lte as h, arrayContainsAny as i, gte as l, lt as m, arrayContains as n, endsWith as o, isUndefined as p, arrayContainsAll as r, eq as s, and as t, inArray as u, notInArray as v, validateExpression as x, or as y };

package/dist/query.d.mts

@@ -0,0 +1,45 @@
+import { a as RelationalWhere, c as Fields, d as Scalar, f as ScalarField, g as Expression, h as Where, i as RelationalQueryResult, l as Ordered, m as SelectionResult, n as RelationalQueries, o as Adjacent, p as Selection, r as RelationalQueryOptions, s as Field, t as RelationalCountOptions } from "./relational-types-DLniKi5S.mjs";
+
+//#region src/query/operators.d.ts
+/** Matches a scalar using strict value/date equality. */
+declare function eq<Value>(field: ScalarField<Value>, value: NoInfer<Value>): Expression;
+/** Negates scalar equality. */
+declare function ne<Value>(field: ScalarField<Value>, value: NoInfer<Value>): Expression;
+/** Matches values greater than the supplied scalar. */
+declare function gt<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
+/** Matches values greater than or equal to the supplied scalar. */
+declare function gte<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
+/** Matches values less than the supplied scalar. */
+declare function lt<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
+/** Matches values less than or equal to the supplied scalar. */
+declare function lte<Value>(field: Field<Value> & Ordered<Value>, value: NoInfer<NonNullable<Value>>): Expression;
+/** Matches one of a list of scalar choices. */
+declare function inArray<Value>(field: ScalarField<Value>, values: readonly NoInfer<Value>[]): Expression;
+/** Matches none of a list of scalar choices. */
+declare function notInArray<Value>(field: ScalarField<Value>, values: readonly NoInfer<Value>[]): Expression;
+/** Matches a literal substring, without SQL wildcard interpretation. */
+declare function contains<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
+/** Matches a literal string prefix. */
+declare function startsWith<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
+/** Matches a literal string suffix. */
+declare function endsWith<Value>(field: Field<Value> & (NonNullable<Value> extends string ? unknown : never), value: string): Expression;
+/** Tests scalar membership in an array, ignoring holes. */
+declare function arrayContains<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, value: NoInfer<Value>): Expression;
+/** Tests whether any candidate belongs to an existing scalar array. */
+declare function arrayContainsAny<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, values: readonly NoInfer<Value>[]): Expression;
+/** Tests whether every candidate belongs to an existing scalar array. */
+declare function arrayContainsAll<Value extends Scalar>(field: Field<readonly Value[] | null | undefined>, values: readonly NoInfer<Value>[]): Expression;
+/** Checks explicit null independently from undefined and absence. */
+declare function isNull<Value>(field: Field<Value>): Expression;
+/** Checks undefined, including a missing property. */
+declare function isUndefined<Value>(field: Field<Value>): Expression;
+/** Checks own-property absence before projection. */
+declare function isMissing<Value>(field: Field<Value>): Expression;
+/** Requires all child predicates; an empty conjunction is true. */
+declare function and(...expressions: Expression[]): Expression;
+/** Requires any child predicate; an empty disjunction is false. */
+declare function or(...expressions: Expression[]): Expression;
+/** Negates a predicate's boolean result. */
+declare function not(expression: Expression): Expression;
+//#endregion
+export { type Adjacent, type RelationalCountOptions as CountOptions, type Expression, type Field, type Fields, type RelationalQueryOptions as QueryOptions, type RelationalQueryOptions, type RelationalQueries, type RelationalQueryResult, type RelationalWhere, type Selection, type SelectionResult, type Where, and, arrayContains, arrayContainsAll, arrayContainsAny, contains, endsWith, eq, gt, gte, inArray, isMissing, isNull, isUndefined, lt, lte, ne, not, notInArray, or, startsWith };

package/dist/query.mjs

@@ -0,0 +1,2 @@
+import { _ as not, a as contains, b as startsWith, c as gt, d as isMissing, f as isNull, g as ne, h as lte, i as arrayContainsAny, l as gte, m as lt, n as arrayContains, o as endsWith, p as isUndefined, r as arrayContainsAll, s as eq, t as and, u as inArray, v as notInArray, y as or } from "./operators-BQpLfJlx.mjs";
+export { and, arrayContains, arrayContainsAll, arrayContainsAny, contains, endsWith, eq, gt, gte, inArray, isMissing, isNull, isUndefined, lt, lte, ne, not, notInArray, or, startsWith };