forgepress 0.0.1 → 0.0.2

package/dist/unplugin.mjs

@@ -1,501 +1,2 @@
-import { isRecord } from "./_chunks/value.mjs";
-import { errorMessage } from "./_chunks/error.mjs";
-import { ENDPOINT, assetUrl, checkUpload, defaultPaths, isAssetName, isCollectionName, isEntryId, isMediaFile, mediaType, resolveMedia, sortAssets, sortByCreation, toAssetName } from "./_chunks/output.mjs";
-import { findRoot, loadConfig, resolveConfig } from "./_chunks/config.mjs";
-import { ContentError, META_KEYS, validateSchema } from "./_chunks/validate.mjs";
-import { buildOutput, outputDir, readEntryIds } from "./_chunks/output2.mjs";
-import { OUTPUT_VARIABLE } from "./_chunks/reader.mjs";
-import { parseEntry, parseSchema } from "./_chunks/parse.mjs";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import process from "node:process";
-import { createUnplugin } from "unplugin";
-import { createHash } from "node:crypto";
-import { Buffer } from "node:buffer";
-function createMediaStore(root, config) {
-	const media = resolveMedia(config);
-	const dir = join(root, media.dir);
-	async function describe(name) {
-		const info = await stat(join(dir, name));
-		return {
-			name,
-			url: assetUrl(media.url, name),
-			type: mediaType(name),
-			size: info.size,
-			modifiedAt: info.mtime.toISOString()
-		};
-	}
-	return {
-		async list() {
-			if (!existsSync(dir)) return [];
-			const files = (await readdir(dir)).filter(isMediaFile);
-			return sortAssets(await Promise.all(files.map(describe)));
-		},
-		async write({ name, data }) {
-			checkUpload(name, data.byteLength, media.maxSize);
-			const file = toAssetName(name, createHash("sha256").update(data).digest("hex"));
-			await mkdir(dir, { recursive: true });
-			await writeFile(join(dir, file), data);
-			return describe(file);
-		},
-		async remove(name) {
-			if (!isAssetName(name)) throw new Error(`[forgepress] "${name}" is not a valid asset name`);
-			await rm(join(dir, name), { force: true });
-		}
-	};
-}
-function createSource(start, paths = defaultPaths, options = {}) {
-	const rows = /* @__PURE__ */ new Map();
-	let root;
-	let schema;
-	const resolve = () => root ??= findRoot(start, paths.dir);
-	const visible = (row) => options.unpublished === true || row.status === "published";
-	async function read(collection, id) {
-		const file = paths.entry(collection, id);
-		return parseEntry(await readFile(join(resolve(), file), "utf8"), file);
-	}
-	async function load(collection) {
-		const ids = readEntryIds(join(resolve(), paths.collection(collection)));
-		return sortByCreation((await Promise.all(ids.map((id) => read(collection, id)))).filter(visible));
-	}
-	function all(collection) {
-		let pending = rows.get(collection);
-		if (!pending) {
-			pending = load(collection);
-			rows.set(collection, pending);
-		}
-		return pending;
-	}
-	return {
-		schema: () => schema ??= readFile(join(resolve(), paths.schema), "utf8").then((text) => parseSchema(text, paths.schema)),
-		list: all,
-		entry: async (collection, id) => {
-			if (!existsSync(join(resolve(), paths.entry(collection, id)))) return void 0;
-			const row = await read(collection, id);
-			return visible(row) ? row : void 0;
-		}
-	};
-}
-const IDENTIFIER = /^[A-Z_$][\w$]*$/i;
-const WIDTH = 80;
-const ESCAPES = {
-	"\\": "\\\\",
-	"'": "\\'",
-	"\n": "\\n",
-	"\r": "\\r",
-	"	": "\\t"
-};
-function style(config) {
-	return {
-		indent: " ".repeat(config?.indent ?? 2),
-		semi: config?.semi ? ";" : ""
-	};
-}
-function unsafe(code) {
-	return code < 32 || code >= 127 && code <= 159 || code === 8232 || code === 8233;
-}
-function string(value) {
-	let out = "";
-	for (const char of value) {
-		const escaped = ESCAPES[char];
-		const code = char.charCodeAt(0);
-		if (escaped !== void 0) out += escaped;
-		else if (unsafe(code)) out += `\\u${code.toString(16).padStart(4, "0")}`;
-		else out += char;
-	}
-	return `'${out}'`;
-}
-function key(value) {
-	return IDENTIFIER.test(value) ? value : string(value);
-}
-function storable(input) {
-	return input !== void 0 && input !== null && !(typeof input === "number" && !Number.isFinite(input));
-}
-function value(input, style, depth) {
-	if (typeof input === "string") return string(input);
-	if (typeof input === "number") return String(input);
-	if (typeof input === "boolean") return String(input);
-	const pad = style.indent.repeat(depth + 1);
-	const close = style.indent.repeat(depth);
-	if (Array.isArray(input)) {
-		const kept = input.filter(storable);
-		if (kept.length === 0) return "[]";
-		const items = kept.map((item) => value(item, style, depth + 1));
-		const inline = `[${items.join(", ")}]`;
-		if (kept.every((item) => typeof item !== "object") && close.length + inline.length <= WIDTH) return inline;
-		return `[\n${items.map((item) => `${pad}${item},`).join("\n")}\n${close}]`;
-	}
-	const entries = Object.entries(input).filter(([, item]) => storable(item));
-	if (entries.length === 0) return "{}";
-	return `{\n${entries.map(([name, item]) => `${pad}${key(name)}: ${value(item, style, depth + 1)},`).join("\n")}\n${close}}`;
-}
-function serializeSchema(schema, config) {
-	const current = style(config);
-	return [
-		`import type { ForgePressSchema } from 'forgepress'${current.semi}`,
-		"",
-		`export default ${value(schema, current, 0)} as const satisfies ForgePressSchema${current.semi}`,
-		""
-	].join("\n");
-}
-function ordered(row) {
-	const entries = Object.entries(row).filter(([, item]) => storable(item));
-	const rank = (name) => {
-		const index = META_KEYS.indexOf(name);
-		return index === -1 ? META_KEYS.length : index;
-	};
-	return entries.sort(([left], [right]) => rank(left) - rank(right));
-}
-function serializeEntry(collection, row, config) {
-	const current = style(config);
-	const body = ordered(row).map(([name, item]) => `${current.indent}${key(name)}: ${value(item, current, 1)},`).join("\n");
-	return [
-		`import type { ForgePressEntry } from 'forgepress'${current.semi}`,
-		"",
-		`export default {\n${body}\n} satisfies ForgePressEntry<${string(collection)}>${current.semi}`,
-		""
-	].join("\n");
-}
-function collectionName$1(collection) {
-	if (!isCollectionName(collection)) throw new Error(`[forgepress] ${JSON.stringify(collection)} is not a collection name`);
-	return collection;
-}
-function entryId$1(id) {
-	if (typeof id !== "string" || !isEntryId(id)) throw new Error(`[forgepress] ${JSON.stringify(id)} is not an entry id`);
-	return id;
-}
-function createWriter(root, paths = defaultPaths, config) {
-	const directory = (collection) => join(root, paths.collection(collectionName$1(collection)));
-	const file = (collection, id) => join(root, paths.entry(collectionName$1(collection), entryId$1(id)));
-	return {
-		async writeSchema(schema) {
-			await mkdir(join(root, paths.dir), { recursive: true });
-			await writeFile(join(root, paths.schema), serializeSchema(schema, config));
-		},
-		async writeEntry(collection, row) {
-			const target = file(collection, row.id);
-			await mkdir(directory(collection), { recursive: true });
-			await writeFile(target, serializeEntry(collection, row, config));
-		},
-		async removeEntry(collection, id) {
-			await rm(file(collection, id), { force: true });
-		},
-		async writeContent(collection, rows) {
-			const targets = rows.map((row) => [file(collection, row.id), serializeEntry(collection, row, config)]);
-			const kept = new Set(rows.map((row) => row.id));
-			await mkdir(directory(collection), { recursive: true });
-			const stale = readEntryIds(directory(collection)).filter((id) => !kept.has(id));
-			await Promise.all(stale.map((id) => rm(file(collection, id), { force: true })));
-			await Promise.all(targets.map(([target, text]) => writeFile(target, text)));
-		},
-		async removeCollection(collection) {
-			await rm(directory(collection), {
-				recursive: true,
-				force: true
-			});
-		}
-	};
-}
-var EndpointError = class extends Error {
-	status;
-	constructor(status, message) {
-		super(message);
-		this.name = "EndpointError";
-		this.status = status;
-	}
-};
-function sameOrigin(request) {
-	const site = request.headers["sec-fetch-site"];
-	if (site !== void 0) return site === "same-origin" || site === "none";
-	const { origin, host } = request.headers;
-	if (origin === void 0) return true;
-	try {
-		return new URL(origin).host === host;
-	} catch {
-		return false;
-	}
-}
-function missing(path) {
-	return new EndpointError(404, `there is no endpoint ${JSON.stringify(path)}`);
-}
-async function bytes(request) {
-	const chunks = [];
-	for await (const chunk of request) chunks.push(chunk);
-	return Buffer.concat(chunks);
-}
-async function body(request) {
-	const text = (await bytes(request)).toString("utf8");
-	try {
-		return JSON.parse(text);
-	} catch {
-		throw new EndpointError(400, "the request body is not valid JSON");
-	}
-}
-function json(response, payload) {
-	response.statusCode = 200;
-	response.setHeader("content-type", "application/json");
-	response.end(JSON.stringify(payload));
-}
-function done(response) {
-	response.statusCode = 204;
-	response.end();
-}
-function decode(value, path) {
-	try {
-		return decodeURIComponent(value);
-	} catch {
-		throw new EndpointError(400, `${JSON.stringify(path)} is not a valid path`);
-	}
-}
-function segments(path, prefix, count) {
-	const found = path.slice(prefix.length).split("/").filter(Boolean).map((segment) => decode(segment, path));
-	if (found.length > count) throw missing(path);
-	return found;
-}
-function collectionName(name) {
-	if (name === void 0 || !isCollectionName(name)) throw new EndpointError(400, `${JSON.stringify(name ?? "")} is not a collection name`);
-	return name;
-}
-function entryId(id) {
-	if (typeof id !== "string" || !isEntryId(id)) throw new EndpointError(400, `${JSON.stringify(id ?? "")} is not an entry id`);
-	return id;
-}
-function entry(value) {
-	if (!isRecord(value)) throw new EndpointError(400, "an entry has to be an object");
-	entryId(value.id);
-	return value;
-}
-async function media(config, root, path, request, response) {
-	const store = createMediaStore(root, config.media);
-	if (request.method === "GET") return json(response, await store.list());
-	const name = decode(path.slice(7), path);
-	if (request.method === "DELETE") {
-		if (!isAssetName(name)) throw new EndpointError(400, `${JSON.stringify(name)} is not an asset name`);
-		await store.remove(name);
-		return done(response);
-	}
-	if (!mediaType(name)) throw new EndpointError(400, `${JSON.stringify(name)} is not a supported media file`);
-	return json(response, await store.write({
-		name,
-		data: await bytes(request)
-	}));
-}
-async function read(config, root, path, response) {
-	const source = createSource(root, config.paths, { unpublished: true });
-	if (path === "/schema") return json(response, await source.schema());
-	if (path.startsWith("/content/")) {
-		const [collection = ""] = segments(path, "/content/", 1);
-		const schema = await source.schema();
-		return json(response, Object.hasOwn(schema.collections, collection) ? await source.list(collection) : []);
-	}
-	if (!path.startsWith("/entry/")) throw missing(path);
-	const [collection = "", id = ""] = segments(path, "/entry/", 2);
-	const schema = await source.schema();
-	const row = Object.hasOwn(schema.collections, collection) && isEntryId(id) ? await source.entry(collection, id) : void 0;
-	if (row) return json(response, row);
-	response.statusCode = 404;
-	response.end();
-}
-async function write(config, root, path, request, response) {
-	const writer = createWriter(root, config.paths, config.content);
-	const removing = request.method === "DELETE";
-	if (path === "/schema" && !removing) {
-		const schema = await body(request);
-		const issues = validateSchema(schema);
-		if (issues.length > 0) throw new EndpointError(400, `the schema is not valid:\n${issues.map((issue) => issue.message).join("\n")}`);
-		await writer.writeSchema(schema);
-	} else if (path.startsWith("/entry/")) {
-		const [name, id] = segments(path, "/entry/", 2);
-		const collection = collectionName(name);
-		if (removing) await writer.removeEntry(collection, entryId(id));
-		else {
-			const row = entry(await body(request));
-			if (row.id !== entryId(id)) throw new EndpointError(400, `the entry id ${JSON.stringify(row.id)} doesn't match the path`);
-			await writer.writeEntry(collection, row);
-		}
-	} else if (path.startsWith("/content/")) {
-		const [name] = segments(path, "/content/", 1);
-		const collection = collectionName(name);
-		if (removing) await writer.removeCollection(collection);
-		else {
-			const rows = await body(request);
-			if (!Array.isArray(rows)) throw new EndpointError(400, "the entries have to be a list");
-			await writer.writeContent(collection, rows.map(entry));
-		}
-	} else throw missing(path);
-	done(response);
-}
-async function handle(config, root, request, response) {
-	if (!sameOrigin(request)) throw new EndpointError(403, "the dev endpoint only accepts requests from pages on its own origin");
-	const path = (request.url ?? "").slice(ENDPOINT.length);
-	if (path === "/media" || path.startsWith("/media/")) return media(config, root, path, request, response);
-	if (request.method === "GET") return read(config, root, path, response);
-	return write(config, root, path, request, response);
-}
-function resolved(id) {
-	return `\0${id}`;
-}
-function generateSettings(local, config) {
-	return [
-		`export const local = ${local}`,
-		`export const provider = ${JSON.stringify(config.provider ?? null)}`,
-		`export const format = ${JSON.stringify(config.content ?? null)}`,
-		`export const contentPath = ${JSON.stringify(config.paths.dir)}`,
-		`export const media = ${JSON.stringify(config.media)}`,
-		""
-	].join("\n");
-}
-const TYPES = `// Generated by ForgePress. Do not edit.
-import type schema from './schema'
-
-declare module 'forgepress' {
-  interface ForgePressSchemaRegistry {
-    schema: typeof schema
-  }
-}
-
-export {}
-`;
-function writeTypes(root, config) {
-	const path = join(root, config.paths.types);
-	if ((existsSync(path) ? readFileSync(path, "utf8") : void 0) === TYPES) return;
-	mkdirSync(dirname(path), { recursive: true });
-	writeFileSync(path, TYPES);
-}
-function inside(parent, child) {
-	const path = relative(parent, child);
-	return path !== "" && path !== ".." && !path.startsWith(`..${sep}`) && !isAbsolute(path);
-}
-async function sendOutput(response, file) {
-	try {
-		const text = await readFile(file);
-		response.setHeader("Content-Type", "application/json");
-		response.setHeader("Cache-Control", "no-cache");
-		response.end(text);
-	} catch {
-		response.statusCode = 404;
-		response.end();
-	}
-}
-const unpluginFactory = (options) => {
-	let root = options?.root ? resolve(options.root) : findRoot(process.cwd());
-	let local = false;
-	let serving = false;
-	let publicDir = "";
-	let config;
-	async function load() {
-		const loaded = await loadConfig(root);
-		return resolveConfig({
-			...loaded,
-			media: {
-				...loaded?.media,
-				...options?.media
-			}
-		});
-	}
-	function resolve$1() {
-		config ??= load();
-		return config;
-	}
-	return {
-		name: "unplugin-forgepress",
-		vite: {
-			configResolved(resolvedConfig) {
-				root = options?.root ? resolve(resolvedConfig.root, options.root) : findRoot(resolvedConfig.root);
-				serving = resolvedConfig.command === "serve";
-				local = serving && options?.write !== false;
-				publicDir = resolvedConfig.publicDir ?? "";
-			},
-			async configureServer(server) {
-				const current = await resolve$1();
-				const { logger } = server.config;
-				const output = outputDir(root, current);
-				let reported = "";
-				process.env[OUTPUT_VARIABLE] = output;
-				let pending;
-				function report(issues) {
-					const message = issues.length > 0 ? new ContentError(issues).message : "";
-					if (message === reported) return;
-					if (message) logger.warn(`${message}\n[forgepress] the build fails until ${issues.length === 1 ? "this problem is" : "these problems are"} fixed`, { timestamp: true });
-					else logger.info("[forgepress] content problems are fixed", { timestamp: true });
-					reported = message;
-				}
-				async function refresh() {
-					try {
-						report((await buildOutput(root, current, { dev: true })).issues);
-					} catch (error) {
-						if (!(error instanceof ContentError)) throw error;
-						report(error.issues);
-					}
-				}
-				function reload() {
-					server.ws.send({ type: "full-reload" });
-				}
-				function schedule() {
-					clearTimeout(pending);
-					pending = setTimeout(() => {
-						refresh().catch((error) => logger.error(`[forgepress] could not write the content output: ${errorMessage(error)}`)).finally(reload);
-					}, 100);
-				}
-				const schemaFile = join(root, current.paths.schema);
-				const contentDir = join(root, current.paths.content);
-				function watch(file) {
-					if (file === schemaFile || file.startsWith(`${contentDir}${sep}`)) schedule();
-				}
-				server.watcher.add([schemaFile, contentDir]);
-				server.watcher.on("add", watch);
-				server.watcher.on("change", watch);
-				server.watcher.on("unlink", watch);
-				await refresh().catch((error) => logger.error(`[forgepress] could not write the content output: ${errorMessage(error)}`));
-				if (publicDir && inside(publicDir, output)) {
-					const prefix = `/${relative(publicDir, output).split(sep).join("/")}/`;
-					server.middlewares.use((request, response, next) => {
-						const path = decodeURIComponent(request.url?.split("?")[0] ?? "");
-						if (request.method !== "GET" && request.method !== "HEAD" || !path.startsWith(prefix)) return next();
-						const file = join(output, path.slice(prefix.length));
-						if (!inside(output, file)) {
-							response.statusCode = 404;
-							response.end();
-							return;
-						}
-						sendOutput(response, file);
-					});
-				}
-				if (options?.write === false) return;
-				server.middlewares.use((request, response, next) => {
-					const method = request.method ?? "";
-					if (!(method === "POST" || method === "DELETE" || method === "GET") || !request.url?.startsWith(`/__forgepress/`)) return next();
-					handle(current, root, request, response).then(() => {
-						if (method !== "GET") schedule();
-					}).catch((error) => {
-						response.statusCode = error instanceof EndpointError ? error.status : 500;
-						response.end(errorMessage(error));
-					});
-				});
-			}
-		},
-		async buildStart() {
-			const current = await resolve$1();
-			writeTypes(root, current);
-			if (serving) return;
-			process.env[OUTPUT_VARIABLE] = outputDir(root, current);
-			await buildOutput(root, current);
-		},
-		resolveId(id) {
-			if (id === "virtual:forgepress/settings") return resolved(id);
-		},
-		async load(id) {
-			if (id === resolved("virtual:forgepress/settings")) return generateSettings(local, await resolve$1());
-		}
-	};
-};
-const unplugin = /* #__PURE__ */ createUnplugin(unpluginFactory);
-const vitePlugin = unplugin.vite;
-const rollupPlugin = unplugin.rollup;
-const rolldownPlugin = unplugin.rolldown;
-const webpackPlugin = unplugin.webpack;
-const rspackPlugin = unplugin.rspack;
-const farmPlugin = unplugin.farm;
-const bunPlugin = unplugin.bun;
+import { bunPlugin, farmPlugin, rolldownPlugin, rollupPlugin, rspackPlugin, unplugin, unpluginFactory, vitePlugin, webpackPlugin } from "./_chunks/plugin.mjs";
 export { bunPlugin, unplugin as default, farmPlugin, rolldownPlugin, rollupPlugin, rspackPlugin, unplugin, unpluginFactory, vitePlugin, webpackPlugin };

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "forgepress",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Fully static, git based CMS.",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/freb97/forgepress.git"
+    "url": "git+https://github.com/forgepress-cms/forgepress.git"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/next/preview.mjs",
+    "./dist/next/reload.mjs"
+  ],
   "imports": {
     "#content-reader": {
       "node": "./dist/disk/reader.mjs",
@@ -24,6 +27,26 @@
       "types": "./dist/unplugin.d.mts",
       "default": "./dist/unplugin.mjs"
     },
+    "./nuxt": {
+      "types": "./dist/plugin/nuxt.d.mts",
+      "default": "./dist/plugin/nuxt.mjs"
+    },
+    "./next": {
+      "types": "./dist/plugin/next.d.mts",
+      "default": "./dist/plugin/next.mjs"
+    },
+    "./next/preview": {
+      "types": "./dist/next/preview.d.mts",
+      "default": "./dist/next/preview.mjs"
+    },
+    "./next/reload": {
+      "types": "./dist/next/reload.d.mts",
+      "default": "./dist/next/reload.mjs"
+    },
+    "./next/settings": {
+      "types": "./dist/next/settings.d.mts",
+      "default": "./dist/next/settings.mjs"
+    },
     "./editor": {
       "types": "./dist/editor/index.d.mts",
       "default": "./dist/editor/index.mjs"
@@ -31,6 +54,10 @@
     "./preview": {
       "types": "./dist/preview/index.d.mts",
       "default": "./dist/preview/index.mjs"
+    },
+    "./react": {
+      "types": "./dist/preview/react.d.mts",
+      "default": "./dist/preview/react.mjs"
     }
   },
   "types": "./dist/index.d.mts",
@@ -41,28 +68,62 @@
     "dist"
   ],
   "peerDependencies": {
+    "@nuxt/kit": "^4.0.0",
+    "@nuxt/schema": "^4.0.0",
+    "next": "^16.3.0",
+    "react": "^18.0.0 || ^19.0.0",
     "vue": "^3.5.0"
   },
   "peerDependenciesMeta": {
+    "@nuxt/kit": {
+      "optional": true
+    },
+    "@nuxt/schema": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
     "vue": {
       "optional": true
     }
   },
   "dependencies": {
-    "unplugin": "^3.0.0"
+    "citty": "^0.2.2",
+    "idb-keyval": "^6.3.0",
+    "jsonc-parser": "^3.3.1",
+    "oauth4webapi": "^3.8.8",
+    "perfect-debounce": "^2.1.0",
+    "unplugin": "^3.0.0",
+    "ws": "^8.21.3"
   },
   "devDependencies": {
     "@antfu/eslint-config": "^9.5.1",
     "@arethetypeswrong/cli": "^0.18.5",
-    "@iconify-json/lucide": "^1.2.131",
+    "@fontsource-variable/bricolage-grotesque": "^5.3.0",
+    "@iconify-json/hugeicons": "^1.2.34",
+    "@nuxt/kit": "^4.5.2",
+    "@nuxt/schema": "^4.5.2",
     "@nuxt/ui": "^4.11.1",
     "@tanstack/vue-table": "^8.21.3",
     "@types/node": "^24.0.0",
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@types/ws": "^8.18.1",
     "@vitejs/plugin-vue": "^6.0.8",
+    "@vueuse/core": "^14.4.0",
+    "diff": "^8.0.4",
     "eslint": "^10.10.0",
+    "fake-indexeddb": "^6.2.5",
     "happy-dom": "^20.14.3",
+    "next": "^16.3.5",
     "obuild": "^0.4.39",
     "publint": "^0.3.24",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
     "tailwindcss": "^4.3.3",
     "typescript": "^6.0.3",
     "vite": "^8.3.0",
@@ -72,13 +133,16 @@
   },
   "scripts": {
     "lint": "eslint .",
-    "typecheck": "vue-tsc --noEmit && pnpm --filter=playground-nuxt run typecheck",
+    "typecheck": "vue-tsc --noEmit && pnpm --filter=playground-nuxt run typecheck && pnpm --filter=playground-next run typecheck && pnpm --filter=docs run typecheck",
     "test": "vitest run",
     "test:watch": "vitest",
     "build": "obuild && pnpm run build:editor",
-    "build:editor": "vite build --config vite.editor.config.mjs",
-    "dev:editor": "vite build --config vite.editor.config.mjs --watch",
+    "build:editor": "vite build --config editor/vite.config.mjs",
+    "dev": "node --watch-path=src --watch-preserve-output scripts/build.mjs",
+    "dev:editor": "vite build --config editor/vite.config.mjs --watch",
     "dev:nuxt": "pnpm --filter=playground-nuxt run dev",
+    "dev:next": "pnpm --filter=playground-next run dev",
+    "dev:docs": "pnpm --filter=docs run dev",
     "check:package": "publint --strict && attw --pack . --profile esm-only"
   }
 }

package/dist/_chunks/config.d.mts

@@ -1,35 +0,0 @@
-type ProviderType = 'github' | 'gitlab' | 'forgejo';
-interface ProviderRepository {
-  owner: string;
-  name: string;
-  branch?: string;
-}
-interface ProviderConfig {
-  type: ProviderType;
-  repository: ProviderRepository;
-  base?: string;
-  url?: string;
-  clientId?: string;
-  scopes?: readonly string[];
-  redirectUri?: string;
-  commitMessage?: string;
-}
-interface ContentConfig {
-  indent?: number;
-  semi?: boolean;
-}
-export interface MediaConfig {
-  dir?: string;
-  url?: string;
-  maxSize?: number;
-}
-export interface OutputConfig {
-  dir?: string;
-}
-export interface ForgePressConfig {
-  path?: string;
-  provider?: ProviderConfig;
-  content?: ContentConfig;
-  media?: MediaConfig;
-  output?: OutputConfig;
-}