forgepress 0.0.0 → 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,105 @@
+import { Entry, EntryMeta, EntryRef, EntryStatus, ForgePressEntry, ForgePressOutput, ForgePressSchema, ForgePressSchemaRegistry, OutputMeta, OutputOf, RegisteredSchema, SchemaLocale } from "./_chunks/entry.mjs";
+import { OutputCollection, OutputEntry, OutputIndex, OutputManifest } from "./_chunks/types.mjs";
+import { ForgePressConfig, OutputConfig } from "./_chunks/config.mjs";
+export declare function defineForgePressConfig(config: ForgePressConfig): ForgePressConfig;
+type Operator = 'eq' | 'ne' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'contains';
+type CollectionName<TSchema extends ForgePressSchema> = keyof TSchema['collections'] & string;
+type Fields<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = TSchema['collections'][TName]['fields'];
+type FieldName<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = keyof Fields<TSchema, TName> & string;
+type Simplify<TValue> = { [TKey in keyof TValue]: TValue[TKey]; } & {};
+type Kind<TField> = TField extends {
+  type: 'number';
+} ? 'number' : TField extends {
+  type: 'text' | 'richtext';
+} ? 'text' : TField extends {
+  type: 'relation';
+  multiple: true;
+} ? 'links' : TField extends {
+  type: 'relation';
+} ? 'link' : TField extends {
+  type: 'dynamic';
+} ? 'links' : 'none';
+type KindOf<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>, TKey> = TKey extends 'id' ? 'text' : TKey extends 'createdAt' | 'updatedAt' ? 'date' : TKey extends FieldName<TSchema, TName> ? Kind<Fields<TSchema, TName>[TKey]> : 'none';
+interface Operands {
+  text: {
+    eq: string;
+    ne: string;
+    in: readonly string[];
+    contains: string;
+  };
+  number: {
+    eq: number;
+    ne: number;
+    gt: number;
+    gte: number;
+    lt: number;
+    lte: number;
+    in: readonly number[];
+  };
+  date: {
+    eq: string;
+    ne: string;
+    gt: string;
+    gte: string;
+    lt: string;
+    lte: string;
+    in: readonly string[];
+  };
+  link: {
+    eq: string;
+    ne: string;
+    in: readonly string[];
+  };
+  links: {
+    contains: string;
+  };
+  none: Record<never, never>;
+}
+type Keys<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = 'id' | 'createdAt' | 'updatedAt' | FieldName<TSchema, TName>;
+type OperatorOf<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>, TKey> = keyof Operands[KindOf<TSchema, TName, TKey>] & Operator;
+type Operand<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>, TKey, TOperator> = TOperator extends keyof Operands[KindOf<TSchema, TName, TKey>] ? Operands[KindOf<TSchema, TName, TKey>][TOperator] : never;
+type Filterable<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = { [TKey in Keys<TSchema, TName>]: [OperatorOf<TSchema, TName, TKey>] extends [never] ? never : TKey; }[Keys<TSchema, TName>];
+type Comparable<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = { [TKey in Keys<TSchema, TName>]: 'eq' extends OperatorOf<TSchema, TName, TKey> ? TKey : never; }[Keys<TSchema, TName>];
+type Sortable<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = { [TKey in Keys<TSchema, TName>]: KindOf<TSchema, TName, TKey> extends 'text' | 'number' | 'date' | 'link' ? TKey : never; }[Keys<TSchema, TName>];
+type Linkable<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>> = { [TKey in FieldName<TSchema, TName>]: Fields<TSchema, TName>[TKey] extends {
+  type: 'relation' | 'dynamic';
+} ? TKey : never; }[FieldName<TSchema, TName>];
+type LinkedBlock<TSchema extends ForgePressSchema, TTarget> = TTarget extends CollectionName<TSchema> ? {
+  collection: TTarget;
+  id: string;
+  entry: OutputOf<TSchema, TTarget>;
+} : never;
+type Linked<TSchema extends ForgePressSchema, TField> = TField extends {
+  type: 'relation';
+  collection: infer TTarget extends CollectionName<TSchema>;
+} ? TField extends {
+  multiple: true;
+} ? OutputOf<TSchema, TTarget>[] : OutputOf<TSchema, TTarget> : TField extends {
+  type: 'dynamic';
+  collections: readonly (infer TTarget)[];
+} ? LinkedBlock<TSchema, TTarget>[] : never;
+type WithLinked<TResult, TKey extends keyof TResult, TValue> = Simplify<Omit<TResult, TKey> & (Record<never, never> extends Pick<TResult, TKey> ? { [TField in TKey]?: TValue; } : { [TField in TKey]: TValue; })>;
+type SiteLocale<TSchema extends ForgePressSchema> = [SchemaLocale<TSchema>] extends [never] ? string : SchemaLocale<TSchema>;
+interface QueryBuilder<TSchema extends ForgePressSchema, TName extends CollectionName<TSchema>, TResult> extends Promise<TResult[]> {
+  where: {
+    <TKey extends Comparable<TSchema, TName>>(field: TKey, value: Operand<TSchema, TName, TKey, 'eq'>): QueryBuilder<TSchema, TName, TResult>;
+    <TKey extends Filterable<TSchema, TName>, TOperator extends OperatorOf<TSchema, TName, TKey>>(field: TKey, operator: TOperator, value: Operand<TSchema, TName, TKey, TOperator>): QueryBuilder<TSchema, TName, TResult>;
+  };
+  sort: (field: Sortable<TSchema, TName>, direction?: 'asc' | 'desc') => QueryBuilder<TSchema, TName, TResult>;
+  limit: (count: number) => QueryBuilder<TSchema, TName, TResult>;
+  offset: (count: number) => QueryBuilder<TSchema, TName, TResult>;
+  locale: (locale: SiteLocale<TSchema>) => QueryBuilder<TSchema, TName, TResult>;
+  with: <TKey extends Linkable<TSchema, TName> & keyof TResult>(field: TKey) => QueryBuilder<TSchema, TName, WithLinked<TResult, TKey, Linked<TSchema, Fields<TSchema, TName>[TKey]>>>;
+  pick: <TKey extends keyof TResult & string>(...fields: TKey[]) => QueryBuilder<TSchema, TName, Simplify<Pick<TResult, TKey>>>;
+  first: () => Promise<TResult | undefined>;
+}
+type Query<TSchema extends ForgePressSchema> = <TName extends CollectionName<TSchema>>(collection: TName) => QueryBuilder<TSchema, TName, OutputOf<TSchema, TName>>;
+interface ClientOptions {
+  url?: string;
+}
+interface Client<TSchema extends ForgePressSchema = RegisteredSchema> {
+  query: Query<TSchema>;
+}
+export declare function createClient<TSchema extends ForgePressSchema = RegisteredSchema>(options?: ClientOptions): Client<TSchema>;
+export declare const query: Query<RegisteredSchema>;
+export type { Client, ClientOptions, Entry, EntryMeta, EntryRef, EntryStatus, ForgePressConfig, ForgePressEntry, ForgePressOutput, ForgePressSchema, ForgePressSchemaRegistry, LinkedBlock, Operator, OutputCollection, OutputConfig, OutputEntry, OutputIndex, OutputManifest, OutputMeta, QueryBuilder };

package/dist/index.mjs

@@ -0,0 +1,247 @@
+import { isRecord, quote } from "./_chunks/value.mjs";
+import { entryKey } from "./_chunks/references.mjs";
+import { OUTPUT_INDEX } from "./_chunks/types.mjs";
+import { fetchReader } from "./_chunks/fetch.mjs";
+import { overlaid } from "./_chunks/overlay.mjs";
+import { reader } from "#content-reader";
+function defineForgePressConfig(config) {
+	return config;
+}
+function comparable(value) {
+	return isRecord(value) && typeof value.collection === "string" && typeof value.id === "string" ? value.id : value;
+}
+function compare(left, right) {
+	const first = comparable(left);
+	const second = comparable(right);
+	if (first === second) return 0;
+	if (first === void 0 || first === null) return -1;
+	if (second === void 0 || second === null) return 1;
+	return first < second ? -1 : 1;
+}
+function ranged(actual, value, accept) {
+	return actual !== void 0 && actual !== null && accept(compare(actual, value));
+}
+function matches(entry, { field, op, value }) {
+	const actual = entry[field];
+	switch (op) {
+		case "eq": return comparable(actual) === value;
+		case "ne": return comparable(actual) !== value;
+		case "gt": return ranged(actual, value, (order) => order > 0);
+		case "gte": return ranged(actual, value, (order) => order >= 0);
+		case "lt": return ranged(actual, value, (order) => order < 0);
+		case "lte": return ranged(actual, value, (order) => order <= 0);
+		case "in": return Array.isArray(value) && value.includes(comparable(actual));
+		case "contains": return Array.isArray(actual) ? actual.some((item) => comparable(item) === value) : typeof actual === "string" && typeof value === "string" && actual.includes(value);
+	}
+}
+function evaluate(entries, plan) {
+	let result = plan.where.length > 0 ? entries.filter((entry) => plan.where.every((clause) => matches(entry, clause))) : [...entries];
+	if (plan.sort.length > 0) result.sort((left, right) => {
+		for (const { field, dir } of plan.sort) {
+			const order = compare(left[field], right[field]);
+			if (order !== 0) return dir === "asc" ? order : -order;
+		}
+		return 0;
+	});
+	if (plan.offset > 0) result = result.slice(plan.offset);
+	if (plan.limit !== void 0) result = result.slice(0, plan.limit);
+	return result;
+}
+const META = [
+	"id",
+	"createdAt",
+	"updatedAt"
+];
+function refsOf(value) {
+	return (Array.isArray(value) ? value : [value]).filter((item) => isRecord(item) && typeof item.collection === "string" && typeof item.id === "string");
+}
+function listing(names) {
+	return names.map(quote).join(", ");
+}
+var Builder = class {
+	loader;
+	collection;
+	plan = {
+		where: [],
+		sort: [],
+		offset: 0,
+		with: []
+	};
+	chosen;
+	constructor(loader, collection) {
+		this.loader = loader;
+		this.collection = collection;
+	}
+	where(field, operatorOrValue, value) {
+		this.plan.where.push(arguments.length >= 3 ? {
+			field,
+			op: operatorOrValue,
+			value
+		} : {
+			field,
+			op: "eq",
+			value: operatorOrValue
+		});
+		return this;
+	}
+	sort(field, direction = "asc") {
+		this.plan.sort.push({
+			field,
+			dir: direction
+		});
+		return this;
+	}
+	limit(count) {
+		this.plan.limit = count;
+		return this;
+	}
+	offset(count) {
+		this.plan.offset = count;
+		return this;
+	}
+	locale(locale) {
+		this.chosen = locale;
+		return this;
+	}
+	with(field) {
+		if (!this.plan.with.includes(field)) this.plan.with.push(field);
+		return this;
+	}
+	pick(...fields) {
+		this.plan.pick = fields;
+		return this;
+	}
+	needsLocale(snapshot, reason) {
+		const example = snapshot.index.locales[0] ?? "en";
+		return /* @__PURE__ */ new Error(`[forgepress] ${reason}, so query(${quote(this.collection)}) needs .locale(), such as .locale(${quote(example)})`);
+	}
+	async select(snapshot, limit) {
+		const { index } = snapshot;
+		const { collection, chosen: locale, plan } = this;
+		const found = index.collections[collection];
+		if (!found) throw new Error(`[forgepress] the content output has no collection ${quote(collection)}`);
+		if (locale !== void 0 && !index.locales.includes(locale)) throw new Error(`[forgepress] ${quote(locale)} is not a locale of this site; ${index.locales.length > 0 ? `use ${listing(index.locales)}` : "it has none"}`);
+		if (found.localized && locale === void 0) throw this.needsLocale(snapshot, `${quote(collection)} is translated`);
+		const manifest = await snapshot.manifest(collection, locale);
+		const unlinked = plan.with.filter((field) => manifest.links[field] === void 0);
+		if (unlinked.length > 0) throw new Error(`[forgepress] .with() loads relation and dynamic fields, and ${listing(unlinked)} ${unlinked.length === 1 ? "is not one" : "are not"} in ${quote(collection)}`);
+		const listed = /* @__PURE__ */ new Set([...META, ...manifest.indexed]);
+		const unindexed = [...new Set([...plan.where, ...plan.sort].map((clause) => clause.field))].filter((field) => !listed.has(field));
+		if (unindexed.length > 0 && index.dev) console.warn(`[forgepress] query(${quote(collection)}) filters or sorts by ${listing(unindexed)}, which ${unindexed.length === 1 ? "is" : "are"} not indexed, so every entry is loaded. Add index: true to ${unindexed.length === 1 ? "the field" : "the fields"} in the schema`);
+		const selected = evaluate(unindexed.length > 0 ? await snapshot.entries(collection, locale, manifest.entries.map((entry) => entry.id)) : manifest.entries, limit === void 0 ? plan : {
+			...plan,
+			limit: Math.min(plan.limit ?? limit, limit)
+		});
+		const listedOnly = plan.pick !== void 0 && [...plan.pick, ...plan.with].every((field) => listed.has(field));
+		const rows = unindexed.length > 0 || listedOnly ? selected : await snapshot.entries(collection, locale, selected.map((entry) => entry.id));
+		const linked = plan.with.length > 0 ? await this.link(snapshot, manifest, rows) : rows;
+		const { pick } = plan;
+		const picked = pick === void 0 ? linked : linked.map((row) => Object.fromEntries(pick.filter((field) => row[field] !== void 0).map((field) => [field, row[field]])));
+		return structuredClone(picked);
+	}
+	async link(snapshot, manifest, rows) {
+		const { index } = snapshot;
+		const locale = this.chosen;
+		const wanted = /* @__PURE__ */ new Map();
+		for (const field of this.plan.with) for (const ref of rows.flatMap((row) => refsOf(row[field]))) {
+			if (index.collections[ref.collection]?.localized && locale === void 0) throw this.needsLocale(snapshot, `.with(${quote(field)}) loads ${quote(ref.collection)} entries, which are translated`);
+			wanted.set(ref.collection, (wanted.get(ref.collection) ?? /* @__PURE__ */ new Set()).add(ref.id));
+		}
+		const loaded = /* @__PURE__ */ new Map();
+		await Promise.all([...wanted].map(async ([collection, ids]) => {
+			for (const entry of await snapshot.entries(collection, locale, [...ids])) loaded.set(entryKey(collection, entry.id), entry);
+		}));
+		const find = (ref) => loaded.get(entryKey(ref.collection, ref.id));
+		return rows.map((row) => {
+			const next = { ...row };
+			for (const field of this.plan.with) {
+				const value = row[field];
+				if (value === void 0) continue;
+				if (manifest.links[field] === "dynamic") next[field] = refsOf(value).flatMap((ref) => [find(ref)].flatMap((entry) => entry ? [{
+					collection: ref.collection,
+					id: ref.id,
+					entry
+				}] : []));
+				else if (Array.isArray(value)) next[field] = refsOf(value).flatMap((ref) => find(ref) ?? []);
+				else next[field] = refsOf(value).map(find)[0];
+			}
+			return next;
+		});
+	}
+	execute(limit) {
+		return this.loader.run((snapshot) => this.select(snapshot, limit));
+	}
+	async first() {
+		return (await this.execute(1))[0];
+	}
+	then(onFulfilled, onRejected) {
+		return this.execute().then(onFulfilled, onRejected);
+	}
+	catch(onRejected) {
+		return this.execute().catch(onRejected);
+	}
+	finally(onFinally) {
+		return this.execute().finally(onFinally);
+	}
+	get [Symbol.toStringTag]() {
+		return "ForgePressQuery";
+	}
+};
+var MissingFile = class extends Error {};
+function manifestPath(index, collection, locale) {
+	const found = index.collections[collection];
+	if (!found) throw new Error(`[forgepress] the content output has no collection ${quote(collection)}`);
+	if (!found.localized) return found.manifest;
+	const path = locale === void 0 ? void 0 : found.manifests[locale];
+	if (path === void 0) throw new Error(`[forgepress] the content output has no ${quote(collection)} entries in locale ${quote(locale)}`);
+	return path;
+}
+function createLoader(read) {
+	const files = /* @__PURE__ */ new Map();
+	function file(path) {
+		let pending = files.get(path);
+		if (!pending) {
+			pending = read(path).then((value) => {
+				if (value === void 0) throw new MissingFile(path);
+				return value;
+			});
+			pending.catch(() => files.delete(path));
+			files.set(path, pending);
+		}
+		return pending;
+	}
+	async function snapshot() {
+		const index = await read(OUTPUT_INDEX);
+		if (index === void 0) throw new Error(`[forgepress] there is no content output yet: ${OUTPUT_INDEX} is missing. Run forgepress build, or start the dev server with the forgepress plugin`);
+		if (index.version !== 1) throw new Error(`[forgepress] the content output has format version ${quote(index.version)}, but this version of forgepress reads version 1`);
+		const manifest = (collection, locale) => file(manifestPath(index, collection, locale));
+		return {
+			index,
+			manifest,
+			entries: async (collection, locale, ids) => {
+				const { files: paths } = await manifest(collection, locale);
+				return Promise.all(ids.flatMap((id) => paths[id] === void 0 ? [] : [file(paths[id])]));
+			}
+		};
+	}
+	return { async run(task) {
+		try {
+			return await task(await snapshot());
+		} catch (error) {
+			if (!(error instanceof MissingFile)) throw error;
+		}
+		try {
+			return await task(await snapshot());
+		} catch (error) {
+			if (error instanceof MissingFile) throw new Error(`[forgepress] the content output links ${error.message}, but the file doesn't exist`);
+			throw error;
+		}
+	} };
+}
+function createClient(options = {}) {
+	const loader = createLoader(overlaid(options.url === void 0 ? reader : fetchReader(options.url)));
+	const query = (collection) => new Builder(loader, collection);
+	return { query };
+}
+const query = createClient().query;
+export { createClient, defineForgePressConfig, query };

package/dist/preview/index.d.mts

@@ -0,0 +1,5 @@
+import "../_chunks/entry.mjs";
+import "../_chunks/config.mjs";
+export declare function previewing(): boolean;
+export declare function onPreviewChange(listener: () => void): () => void;
+export declare function enablePreview(): boolean;

package/dist/preview/index.mjs

@@ -0,0 +1,244 @@
+import { overlayContent } from "../_chunks/overlay.mjs";
+import { errorMessage } from "../_chunks/error.mjs";
+const TAG = "forgepress-preview";
+const HIDING = "forgepress-preview-hiding";
+const LABELS = {
+	loading: "Loading preview…",
+	ready: "Preview",
+	failed: "Preview unavailable"
+};
+const STYLE = `
+:host {
+  all: initial;
+  position: fixed;
+  left: 16px;
+  bottom: 16px;
+  z-index: 2147483647;
+}
+
+.badge {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  padding: 4px 4px 4px 12px;
+  border-radius: 999px;
+  background: #13110e;
+  color: #fffcf8;
+  font: 500 13px/20px ui-sans-serif, system-ui, sans-serif;
+  box-shadow: 0 4px 16px rgb(19 17 14 / 0.3);
+}
+
+.dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  background: #ffd27a;
+}
+
+[data-status="loading"] .dot {
+  animation: pulse 1s ease-in-out infinite;
+}
+
+[data-status="failed"] .dot {
+  background: #f87171;
+}
+
+button {
+  all: unset;
+  padding: 2px 10px;
+  border-radius: 999px;
+  color: #ffd27a;
+  cursor: pointer;
+}
+
+button:hover {
+  background: rgb(255 252 248 / 0.12);
+}
+
+button:focus-visible {
+  outline: 2px solid #ffd27a;
+  outline-offset: 2px;
+}
+
+@keyframes pulse {
+  50% {
+    opacity: 0.4;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  [data-status="loading"] .dot {
+    animation: none;
+  }
+}
+`;
+function createBadge(turnOff) {
+	let host;
+	let badge;
+	let label;
+	let latest;
+	function hideInEditor() {
+		if (document.getElementById(HIDING)) return;
+		const style = document.createElement("style");
+		style.id = HIDING;
+		style.textContent = `body:has([data-forgepress-editor]) > ${TAG} { display: none !important; }`;
+		document.head.append(style);
+	}
+	function mount() {
+		hideInEditor();
+		host = document.createElement(TAG);
+		badge = document.createElement("div");
+		label = document.createElement("span");
+		const root = host.attachShadow({ mode: "open" });
+		const style = document.createElement("style");
+		const dot = document.createElement("span");
+		const button = document.createElement("button");
+		style.textContent = STYLE;
+		badge.className = "badge";
+		badge.setAttribute("role", "status");
+		dot.className = "dot";
+		button.type = "button";
+		button.textContent = "Turn off";
+		button.setAttribute("aria-label", "Turn off preview");
+		button.addEventListener("click", turnOff);
+		badge.append(dot, label, button);
+		root.append(style, badge);
+		document.body.append(host);
+	}
+	function show(state) {
+		latest = state;
+		if (!document.body) {
+			document.addEventListener("DOMContentLoaded", () => latest && show(latest), { once: true });
+			return;
+		}
+		if (!host?.isConnected) mount();
+		badge.dataset.status = state.status;
+		label.textContent = LABELS[state.status];
+		badge.title = state.status === "failed" ? `${state.error}. The site shows published content.` : "";
+	}
+	return {
+		show,
+		hide: () => {
+			latest = void 0;
+			host?.remove();
+		}
+	};
+}
+const SETTINGS_KEY = "forgepress:preview";
+const OFF_KEY = "forgepress:preview:off";
+const CHANNEL = "forgepress:preview";
+const listeners = /* @__PURE__ */ new Set();
+let version = 0;
+let channel;
+let listening = false;
+function read$1(key) {
+	try {
+		return localStorage.getItem(key);
+	} catch {
+		return null;
+	}
+}
+function write(key, value) {
+	try {
+		if (value === void 0) localStorage.removeItem(key);
+		else localStorage.setItem(key, value);
+	} catch {}
+}
+function emit() {
+	version += 1;
+	for (const listener of [...listeners]) listener();
+}
+function listen() {
+	if (listening || typeof window === "undefined") return;
+	listening = true;
+	window.addEventListener("storage", (event) => {
+		if (event.key === null || event.key === SETTINGS_KEY || event.key === OFF_KEY) emit();
+	});
+	if (typeof BroadcastChannel !== "undefined") {
+		channel = new BroadcastChannel(CHANNEL);
+		channel.addEventListener("message", emit);
+	}
+}
+function previewSettings() {
+	const text = read$1(SETTINGS_KEY);
+	try {
+		return text ? JSON.parse(text) : void 0;
+	} catch {
+		return;
+	}
+}
+function previewEnabled() {
+	return read$1(OFF_KEY) === null;
+}
+function previewing() {
+	return typeof window !== "undefined" && previewEnabled() && read$1(SETTINGS_KEY) !== null;
+}
+function previewVersion() {
+	return version;
+}
+function onPreviewChange(listener) {
+	listen();
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+}
+function setPreviewEnabled(enabled) {
+	if (previewEnabled() === enabled) return;
+	write(OFF_KEY, enabled ? void 0 : "1");
+	emit();
+}
+let enabled = false;
+let snapshot;
+let selected;
+const badge = createBadge(() => setPreviewEnabled(false));
+function readerFor(settings) {
+	const key = JSON.stringify(settings);
+	if (selected?.key !== key) selected = {
+		key,
+		reader: import("../_chunks/reader2.mjs").then((module) => module.createPreviewReader(settings))
+	};
+	return selected.reader;
+}
+function load() {
+	const version = previewVersion();
+	if (snapshot?.version === version) return snapshot.files;
+	const settings = previewSettings();
+	const current = {
+		version,
+		files: (settings ? readerFor(settings).then((reader) => reader.build()) : Promise.reject(/* @__PURE__ */ new Error("[forgepress] sign in to the editor to preview unpublished content"))).then((files) => {
+			if (snapshot === current) badge.show({ status: "ready" });
+			return files;
+		}, (cause) => {
+			if (snapshot === current) badge.show({
+				status: "failed",
+				error: errorMessage(cause)
+			});
+		})
+	};
+	snapshot = current;
+	badge.show({ status: "loading" });
+	return current.files;
+}
+async function read(path, base) {
+	if (!previewing()) return base(path);
+	const files = await load();
+	if (!files) return base(path);
+	const text = files.get(path);
+	return text === void 0 ? void 0 : JSON.parse(text);
+}
+function refresh() {
+	if (previewing()) load();
+	else badge.hide();
+}
+function enablePreview() {
+	if (typeof window === "undefined") return false;
+	if (!enabled) {
+		enabled = true;
+		overlayContent(read);
+		onPreviewChange(refresh);
+		refresh();
+	}
+	return previewing();
+}
+export { enablePreview, onPreviewChange, previewing };

package/dist/query/fetch.d.mts

@@ -0,0 +1,3 @@
+import { ContentReader } from "../_chunks/client.mjs";
+export declare function fetchReader(url: string): ContentReader;
+export declare const reader: ContentReader;

package/dist/query/fetch.mjs

@@ -0,0 +1,2 @@
+import { fetchReader, reader } from "../_chunks/fetch.mjs";
+export { fetchReader, reader };

package/dist/unplugin.d.mts

@@ -0,0 +1,18 @@
+import { MediaConfig } from "./_chunks/config.mjs";
+import { Plugin } from "./_chunks/libs/rolldown.mjs";
+import { UnpluginFactory } from "unplugin";
+export interface Options {
+  root?: string;
+  write?: boolean;
+  media?: MediaConfig;
+}
+export declare const unpluginFactory: UnpluginFactory<Options | undefined>;
+export declare const unplugin: import("unplugin").UnpluginInstance<Options | undefined, boolean>;
+export declare const vitePlugin: (options?: Options | undefined) => import("unplugin").VitePlugin<any> | import("unplugin").VitePlugin<any>[];
+export declare const rollupPlugin: (options?: Options | undefined) => import("unplugin").RollupPlugin<any> | import("unplugin").RollupPlugin<any>[];
+export declare const rolldownPlugin: (options?: Options | undefined) => Plugin<any> | Plugin<any>[];
+export declare const webpackPlugin: (options?: Options | undefined) => WebpackPluginInstance;
+export declare const rspackPlugin: (options?: Options | undefined) => RspackPluginInstance;
+export declare const farmPlugin: (options?: Options | undefined) => JsPlugin;
+export declare const bunPlugin: (options?: Options | undefined) => BunPlugin;
+export { unplugin as default };