forgepress 0.0.0 → 0.0.2

package/dist/_chunks/preview.mjs

@@ -0,0 +1,248 @@
+import { once } from "./once.mjs";
+import { overlayContent } from "./overlay.mjs";
+import { errorMessage } from "./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();
+		}
+	};
+}
+function readLocal(key) {
+	try {
+		return localStorage.getItem(key);
+	} catch {
+		return null;
+	}
+}
+function readLocalJson(key) {
+	const text = readLocal(key);
+	try {
+		return text ? JSON.parse(text) : void 0;
+	} catch {
+		return;
+	}
+}
+function writeLocal(key, value) {
+	try {
+		if (value === void 0) localStorage.removeItem(key);
+		else localStorage.setItem(key, value);
+	} catch {}
+}
+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 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() {
+	return readLocalJson(SETTINGS_KEY);
+}
+function previewEnabled() {
+	return readLocal(OFF_KEY) === null;
+}
+function previewing() {
+	return typeof window !== "undefined" && previewEnabled() && readLocal(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;
+	writeLocal(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: once(() => import("./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/_chunks/project.d.mts

@@ -0,0 +1,7 @@
+import { MediaConfig } from "./types.mjs";
+import "./resolve.mjs";
+export interface Options {
+  root?: string;
+  write?: boolean;
+  media?: MediaConfig;
+}

package/dist/_chunks/reader.mjs

@@ -0,0 +1,19 @@
+import { once } from "./once.mjs";
+import { readText } from "./files.mjs";
+import { join } from "node:path";
+import process from "node:process";
+const OUTPUT_VARIABLE = "FORGEPRESS_OUTPUT";
+function diskReader(dir) {
+	return async (path) => {
+		const text = await readText(join(await dir(), path));
+		return text === void 0 ? void 0 : JSON.parse(text);
+	};
+}
+async function locate() {
+	const known = process.env[OUTPUT_VARIABLE];
+	if (known) return known;
+	const { locateOutput } = await import("./locate.mjs");
+	return locateOutput(process.cwd());
+}
+const reader = diskReader(once(locate));
+export { OUTPUT_VARIABLE, diskReader, reader };