@codepress/blog 0.0.0-stage → 0.1.0

package/dist/cli.js

@@ -0,0 +1,440 @@
+#!/usr/bin/env node
+
+// src/cli/bin.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+
+// src/cli/init.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+var USAGE = `Usage: npx @codepress/blog init --site <slug> [options]
+
+Adds a CodePress blog to the Next.js project in the current directory.
+
+Options:
+  --site <slug>        The CodePress content site to read posts from (required)
+  --base-url <url>     The site's public origin, e.g. https://acme.com
+                       (default: process.env.NEXT_PUBLIC_SITE_URL at runtime)
+  --base-path <path>   Where the blog is mounted (default: /blog)
+  --api-base <url>     The CodePress API root (default: https://api.codepress.dev/v1)
+  --revalidate <secs>  Seconds between ISR regenerations (default: 60)
+  --router <app|pages> Which router to use (default: detected)
+  --force              Overwrite the files init writes when they already exist.
+                       A /blog route served by another file (the other router,
+                       a route group, pages/blog.tsx) still stops init: move or
+                       delete it first.
+  --cwd <dir>          The project directory (default: the current directory)
+  -h, --help           Show this help
+`;
+var SITE_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var PATH_SEGMENT = /^[a-z0-9]+(?:[-_][a-z0-9]+)*$/;
+var CONFIG_BASENAME = "codepress-blog";
+var InitError = class extends Error {
+};
+function readPackageJson(root) {
+  const file = path.join(root, "package.json");
+  if (!existsSync(file)) throw new InitError(`No package.json in ${root}.`);
+  return JSON.parse(readFileSync(file, "utf8"));
+}
+function isDirectory(file) {
+  return existsSync(file) && statSync(file).isDirectory();
+}
+function detectLayout(root, forced) {
+  const pkg = readPackageJson(root);
+  const deps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies
+  };
+  if (!deps.next) {
+    throw new InitError(
+      `${root} is not a Next.js project: package.json has no "next" dependency.`
+    );
+  }
+  const find = (name) => [path.join(root, name), path.join(root, "src", name)].find(isDirectory);
+  const app = find("app");
+  const pages = find("pages");
+  if (forced && forced !== "app" && forced !== "pages") {
+    throw new InitError(`--router must be "app" or "pages", not "${forced}".`);
+  }
+  const router = forced ?? (app ? "app" : pages ? "pages" : void 0);
+  if (!router) {
+    throw new InitError(
+      `No app/ or pages/ directory found in ${root} (or its src/).`
+    );
+  }
+  const routesDir = (router === "app" ? app : pages) ?? path.join(root, router);
+  const allRoutesDirs = ["app", "pages"].flatMap(
+    (name) => [path.join(root, name), path.join(root, "src", name)].filter(isDirectory).map((dir) => ({ dir, router: name }))
+  );
+  return {
+    root,
+    router,
+    routesDir,
+    allRoutesDirs,
+    configDir: path.dirname(routesDir),
+    typescript: existsSync(path.join(root, "tsconfig.json"))
+  };
+}
+var BLOG_ROUTE_KEYS = /* @__PURE__ */ new Set(["", "[]", "feed.xml", "sitemap.xml"]);
+function routeKey(segments) {
+  if (segments.some((segment) => segment.startsWith("[[..."))) return "*";
+  return segments.map((segment) => segment.startsWith("[") ? "[]" : segment).join("/");
+}
+function existingRoutes(dir, router, basePath) {
+  const found = [];
+  const segments = basePath.split("/").filter(Boolean);
+  const walk = (current, url) => {
+    for (const entry of readdirSync(current)) {
+      const full = path.join(current, entry);
+      if (isDirectory(full)) {
+        if (entry === "node_modules") continue;
+        const invisible = /^\(.*\)$/.test(entry) || entry.startsWith("@");
+        walk(full, invisible ? url : [...url, entry]);
+        continue;
+      }
+      if (!/\.(mdx?|[cm]?[jt]sx?)$/.test(entry)) continue;
+      const routeUrl = router === "app" ? /^(page|route)\.[cm]?[jt]sx?$|^page\.mdx?$/.test(entry) ? url : null : [...url, entry.replace(/\.[^.]+$/, "")].filter(
+        (s, i, all) => !(s === "index" && i === all.length - 1)
+      );
+      if (!routeUrl) continue;
+      if (segments.every((segment, index) => routeUrl[index] === segment)) {
+        found.push({
+          file: full,
+          key: routeKey(routeUrl.slice(segments.length))
+        });
+      }
+    }
+  };
+  walk(dir, []);
+  return found;
+}
+function classifyConflicts(layout, basePath, files) {
+  const overwrite = [];
+  const migrate = [];
+  const other = [];
+  const relative = (file) => path.relative(layout.root, file);
+  for (const { dir, router } of layout.allRoutesDirs) {
+    for (const route of existingRoutes(dir, router, basePath)) {
+      if (files.has(route.file)) overwrite.push(relative(route.file));
+      else if (route.key === "*" || BLOG_ROUTE_KEYS.has(route.key))
+        migrate.push(relative(route.file));
+      else other.push(relative(route.file));
+    }
+  }
+  for (const file of files.keys()) {
+    const name = relative(file);
+    if (existsSync(file) && !overwrite.includes(name)) overwrite.push(name);
+  }
+  return { overwrite, migrate, other };
+}
+function importPath(fromFile, toFile) {
+  const relative = path.relative(path.dirname(fromFile), toFile).replace(/\\/g, "/").replace(/\.[jt]sx?$/, "");
+  return relative.startsWith(".") ? relative : `./${relative}`;
+}
+function configSource(layout, options) {
+  const module = layout.router === "app" ? "@codepress/blog/next" : "@codepress/blog/next/pages";
+  const lines = [
+    `  site: ${JSON.stringify(options.site)},`,
+    options.baseUrl ? `  baseUrl: ${JSON.stringify(options.baseUrl)},` : `  baseUrl: process.env.NEXT_PUBLIC_SITE_URL ?? "http://localhost:3000",`,
+    `  basePath: ${JSON.stringify(options.basePath)},`,
+    ...options.apiBase ? [`  apiBase: ${JSON.stringify(options.apiBase)},`] : [],
+    `  revalidate: ${options.revalidate},`
+  ];
+  const typed = layout.typescript;
+  return `// Written by \`npx @codepress/blog init\`. Posts come from the CodePress
+// content site ${JSON.stringify(options.site)}; see https://www.npmjs.com/package/@codepress/blog.
+${typed ? `import type { BlogConfig } from "${module}";
+
+` : ""}export const blogConfig${typed ? ": BlogConfig" : ""} = {
+${lines.join("\n")}
+};
+`;
+}
+function routeFiles(layout, options, configFile) {
+  const ext = layout.typescript ? "tsx" : "jsx";
+  const codeExt = layout.typescript ? "ts" : "js";
+  const base = path.join(
+    layout.routesDir,
+    ...options.basePath.split("/").filter(Boolean)
+  );
+  const files = /* @__PURE__ */ new Map();
+  const add = (file, body) => files.set(file, body(importPath(file, configFile)));
+  const css = `import "@codepress/blog/blog.css";
+`;
+  const r = options.revalidate;
+  if (layout.router === "app") {
+    add(
+      path.join(base, `page.${ext}`),
+      (config) => `${css}import { createAppBlog } from "@codepress/blog/next";
+import { blogConfig } from "${config}";
+
+const blog = createAppBlog(blogConfig);
+
+export const revalidate = ${r};
+export const generateMetadata = blog.generateIndexMetadata;
+export default blog.IndexPage;
+`
+    );
+    add(
+      path.join(base, "[slug]", `page.${ext}`),
+      (config) => `${css}import { createAppBlog } from "@codepress/blog/next";
+import { blogConfig } from "${config}";
+
+const blog = createAppBlog(blogConfig);
+
+export const revalidate = ${r};
+export const dynamicParams = true;
+export const generateStaticParams = blog.generateStaticParams;
+export const generateMetadata = blog.generatePostMetadata;
+export default blog.PostPage;
+`
+    );
+    add(
+      path.join(base, "feed.xml", `route.${codeExt}`),
+      (config) => `import { createAppBlogRoutes } from "@codepress/blog/next/routes";
+import { blogConfig } from "${config}";
+
+export const revalidate = ${r};
+export const GET = createAppBlogRoutes(blogConfig).feed;
+`
+    );
+    add(
+      path.join(base, "sitemap.xml", `route.${codeExt}`),
+      (config) => `import { createAppBlogRoutes } from "@codepress/blog/next/routes";
+import { blogConfig } from "${config}";
+
+export const revalidate = ${r};
+export const GET = createAppBlogRoutes(blogConfig).sitemap;
+`
+    );
+  } else {
+    add(
+      path.join(base, `index.${ext}`),
+      (config) => `${css}import { createPagesBlog } from "@codepress/blog/next/pages";
+import { blogConfig } from "${config}";
+
+const blog = createPagesBlog(blogConfig);
+
+export const getStaticProps = blog.getIndexStaticProps;
+export default blog.IndexPage;
+`
+    );
+    add(
+      path.join(base, `[slug].${ext}`),
+      (config) => `${css}import { createPagesBlog } from "@codepress/blog/next/pages";
+import { blogConfig } from "${config}";
+
+const blog = createPagesBlog(blogConfig);
+
+export const getStaticPaths = blog.getPostStaticPaths;
+export const getStaticProps = blog.getPostStaticProps;
+export default blog.PostPage;
+`
+    );
+    add(
+      path.join(base, `feed.xml.${ext}`),
+      (config) => `import { createPagesBlog } from "@codepress/blog/next/pages";
+import { blogConfig } from "${config}";
+
+const blog = createPagesBlog(blogConfig);
+
+export const getServerSideProps = blog.getFeedServerSideProps;
+export default blog.EmptyPage;
+`
+    );
+    add(
+      path.join(base, `sitemap.xml.${ext}`),
+      (config) => `import { createPagesBlog } from "@codepress/blog/next/pages";
+import { blogConfig } from "${config}";
+
+const blog = createPagesBlog(blogConfig);
+
+export const getServerSideProps = blog.getSitemapServerSideProps;
+export default blog.EmptyPage;
+`
+    );
+  }
+  return files;
+}
+function parseOptions(argv) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    allowPositionals: true,
+    options: {
+      site: { type: "string" },
+      "base-url": { type: "string" },
+      "base-path": { type: "string", default: "/blog" },
+      "api-base": { type: "string" },
+      revalidate: { type: "string", default: "60" },
+      router: { type: "string" },
+      force: { type: "boolean", default: false },
+      cwd: { type: "string" },
+      help: { type: "boolean", short: "h", default: false }
+    }
+  });
+  return { values, positionals };
+}
+function validate(values) {
+  const site = values.site;
+  if (!site || !SITE_PATTERN.test(site)) {
+    throw new InitError(
+      "--site <slug> is required: lowercase letters, digits and hyphens."
+    );
+  }
+  const segments = (values["base-path"] ?? "/blog").split("/").filter(Boolean);
+  if (segments.length === 0 || !segments.every((segment) => PATH_SEGMENT.test(segment))) {
+    throw new InitError(
+      `--base-path must be a path such as /blog, not "${values["base-path"]}".`
+    );
+  }
+  for (const [flag, value] of [
+    ["--base-url", values["base-url"]],
+    ["--api-base", values["api-base"]]
+  ]) {
+    if (value !== void 0 && !/^https?:\/\/[^/]/.test(value)) {
+      throw new InitError(`${flag} must be an http(s) URL, not "${value}".`);
+    }
+  }
+  const revalidate = Number(values.revalidate);
+  if (!Number.isInteger(revalidate) || revalidate < 1) {
+    throw new InitError(
+      `--revalidate must be a whole number of seconds, not "${values.revalidate}".`
+    );
+  }
+  return {
+    site,
+    baseUrl: values["base-url"]?.replace(/\/+$/, ""),
+    basePath: `/${segments.join("/")}`,
+    apiBase: values["api-base"],
+    revalidate
+  };
+}
+function writeFile(file, content) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  writeFileSync(file, content);
+}
+function runInit(argv, {
+  version: version2,
+  cwd = process.cwd(),
+  io = { log: console.log, error: console.error }
+}) {
+  try {
+    const { values, positionals } = parseOptions(argv);
+    if (values.help) {
+      io.log(USAGE);
+      return 0;
+    }
+    if (positionals.length > 0)
+      throw new InitError(`Unexpected argument "${positionals[0]}".`);
+    const options = validate(values);
+    const layout = detectLayout(
+      path.resolve(cwd, values.cwd ?? "."),
+      values.router
+    );
+    const configFile = path.join(
+      layout.configDir,
+      `${CONFIG_BASENAME}.${layout.typescript ? "ts" : "js"}`
+    );
+    const files = routeFiles(layout, options, configFile);
+    files.set(configFile, configSource(layout, options));
+    const { overwrite, migrate, other } = classifyConflicts(
+      layout,
+      options.basePath,
+      files
+    );
+    if (migrate.length > 0 || !values.force && overwrite.length + other.length > 0) {
+      io.error(`${options.basePath} already exists; nothing was changed.`);
+      if (migrate.length > 0) {
+        io.error(
+          `These files serve ${options.basePath} URLs that init writes, from a different path. Move or delete them first; --force does not remove them:`
+        );
+        for (const file of migrate) io.error(`  ${file}`);
+      }
+      if (overwrite.length > 0) {
+        io.error(
+          values.force ? "--force would overwrite:" : "Re-run with --force to overwrite:"
+        );
+        for (const file of overwrite) io.error(`  ${file}`);
+      }
+      if (other.length > 0) {
+        io.error(
+          values.force ? `--force would keep these other ${options.basePath} routes:` : `Other ${options.basePath} routes (--force keeps them):`
+        );
+        for (const file of other) io.error(`  ${file}`);
+      }
+      return 1;
+    }
+    const pkgFile = path.join(layout.root, "package.json");
+    const pkg = readPackageJson(layout.root);
+    const dependencies = {
+      ...pkg.dependencies
+    };
+    const dependencyChanged = !dependencies["@codepress/blog"];
+    if (dependencyChanged) {
+      dependencies["@codepress/blog"] = `^${version2}`;
+      pkg.dependencies = Object.fromEntries(
+        Object.entries(dependencies).sort(([a], [b]) => a.localeCompare(b))
+      );
+    }
+    io.log(
+      `Adding a CodePress blog at ${options.basePath} (${layout.router === "app" ? "App" : "Pages"} Router):`
+    );
+    for (const [file, content] of files) {
+      const verb = existsSync(file) ? "overwrote" : "created";
+      writeFile(file, content);
+      io.log(`  ${verb} ${path.relative(layout.root, file)}`);
+    }
+    for (const file of other) io.log(`  kept ${file}`);
+    if (dependencyChanged) {
+      writeFileSync(pkgFile, `${JSON.stringify(pkg, null, 2)}
+`);
+      io.log(`  added @codepress/blog@^${version2} to package.json`);
+    }
+    io.log("");
+    io.log(
+      "The pages render inside your root layout and import @codepress/blog/blog.css."
+    );
+    if (dependencyChanged)
+      io.log("Next: install dependencies (npm install, pnpm install or yarn).");
+    if (!options.baseUrl) {
+      io.log(
+        "Set NEXT_PUBLIC_SITE_URL to your site's origin, or edit baseUrl in the config, so feed and canonical links are absolute."
+      );
+    }
+    return 0;
+  } catch (error) {
+    if (error instanceof InitError || error.code?.startsWith("ERR_PARSE_ARGS")) {
+      io.error(error.message);
+      io.error("");
+      io.error(USAGE);
+      return 1;
+    }
+    throw error;
+  }
+}
+function runCli(argv, options) {
+  const [command, ...rest] = argv;
+  if (command === "init") return runInit(rest, options);
+  const io = options.io ?? { log: console.log, error: console.error };
+  if (command === void 0 || command === "-h" || command === "--help") {
+    io.log(USAGE);
+    return command === void 0 ? 1 : 0;
+  }
+  io.error(`Unknown command "${command}".
+
+${USAGE}`);
+  return 1;
+}
+
+// src/cli/bin.ts
+var { version } = JSON.parse(
+  readFileSync2(new URL("../package.json", import.meta.url), "utf8")
+);
+process.exitCode = runCli(process.argv.slice(2), { version });

package/dist/content-source.d.ts

@@ -0,0 +1,31 @@
+import { type PostMeta } from "./registry.js";
+export interface PostSummary {
+    slug: string;
+    meta: PostMeta;
+}
+export interface Post extends PostSummary {
+    /** Sanitized body HTML. */
+    html: string;
+}
+/** Where posts come from. Pages depend on this interface only. */
+export interface ContentSource {
+    /** Published posts, newest first. */
+    listPosts(): Promise<PostSummary[]>;
+    getPost(slug: string): Promise<Post | null>;
+}
+export interface HttpContentSourceOptions {
+    /** The CodePress API root including `/v1`, for example `https://api.codepress.dev/v1`. */
+    apiBase: string;
+    /** The content site's slug. */
+    site: string;
+    /** Timeout for each request. Defaults to 10 seconds. */
+    timeoutMs?: number;
+}
+/**
+ * Reads a content site's published posts from the CodePress read API
+ * (`GET {apiBase}/content-sites/{site}/posts[/{slug}]`), which serves sanitized
+ * posts. A 404 is "no such post" (an empty blog for the list); any other
+ * failure throws, so during ISR regeneration the last good page keeps being
+ * served instead of being replaced with a 404.
+ */
+export declare function createHttpContentSource({ apiBase, site, timeoutMs, }: HttpContentSourceOptions): ContentSource;

package/dist/editor/BlogEditor.d.ts

@@ -0,0 +1,37 @@
+import type { DraftClient, DraftFile } from "./client.js";
+import { type BlogEditorTimings } from "./config.js";
+import type { BlogEditorHeader } from "./header.js";
+/** A database site's revision, as the save status names it; null for a git site. */
+export declare function revisionOf(draft: DraftFile): {
+    revision: number | null;
+} | null;
+export interface BlogEditorProps {
+    site: string;
+    slug: string;
+    /** The draft API, carrying the host's auth. */
+    client: DraftClient;
+    canPublish: boolean;
+    /** Overrides of the autosave, poll and publish-notice timings. */
+    timings?: Partial<BlogEditorTimings>;
+    /** The reading column's classes; defaults to a 720px column. */
+    column?: string;
+    /** The host page's header the toolbar pins below. */
+    header?: BlogEditorHeader;
+    /** Opens or hides the "Ask CodePress" chat; the mount owns the panel so it survives editor reloads. */
+    onAsk?: () => void;
+    /** Without a panel, Ask CodePress opens this page in a new tab. */
+    askHref?: string | null;
+    /** The CodePress agent's mark on the Ask CodePress button. */
+    askIconSrc?: string;
+    /** The Ask CodePress panel is showing. */
+    askOpen?: boolean;
+    /** Where "Edit design" opens; without it the link is not shown. */
+    designHref?: string | null;
+    /** A database site's revision history, which its saved status links to. */
+    historyHref?: string | null;
+    onExit: () => void;
+    onPublished: () => void;
+    onDiscarded: () => void;
+}
+/** The in-place editor for one post; loaded lazily, only for people who can edit. */
+export default function BlogEditor({ timings: timingOverrides, column, ...props }: BlogEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/editor/BlogEditorMount.d.ts

@@ -0,0 +1,64 @@
+import { type ReactNode } from "react";
+import { type BlogEditorAuth } from "./client.js";
+import { type BlogEditorTimings } from "./config.js";
+import type { BlogEditorHeader } from "./header.js";
+/** What the host's Ask CodePress panel is given. */
+export interface AskPanelProps {
+    site: string;
+    slug: string;
+    /** The site's organization: the chat runs in it. */
+    organizationId: string;
+    open: boolean;
+    onClose: () => void;
+}
+/** What a host's Edit design link is built from: the site's owner and repository. */
+export interface DesignLinkContext {
+    slug: string;
+    organizationSlug: string;
+    repository: string;
+}
+export interface BlogEditorMountProps {
+    /** The content site's slug. */
+    site: string;
+    slug: string;
+    /** The CodePress API root, `…/v1`. */
+    apiBase: string;
+    auth: BlogEditorAuth;
+    /** A post that does not exist yet: open the editor straight away. */
+    isNew?: boolean;
+    /** The host page's header the toolbar pins below. */
+    header?: BlogEditorHeader;
+    /** The reading column's classes; defaults to a 720px column. */
+    column?: string;
+    /** The CodePress app's origin, for its links and the agent's mark; empty when this page is on it. */
+    appUrl?: string;
+    timings?: Partial<BlogEditorTimings>;
+    onEditingChange?: (editing: boolean) => void;
+    /** After a publish; the default reloads the page. */
+    onPublished?: (slug: string) => void;
+    /** A new post was closed or discarded, so there is no reader page to return to. */
+    onLeave?: () => void;
+    slots?: {
+        /** An Ask CodePress chat beside the editor; kept mounted (hidden) once opened. */
+        askPanel?: (props: AskPanelProps) => ReactNode;
+        /** Where Edit design opens; defaults to the CodePress Design page for the site's repository. */
+        designLink?: (context: DesignLinkContext) => string;
+    };
+    actions?: {
+        /** Where Ask CodePress goes without a panel; defaults to the post in the site's App page. */
+        askCodePress?: {
+            href: string;
+        };
+    };
+}
+/**
+ * The site's App page in CodePress, opened on a post. `tab` picks the page's
+ * History; without the organization it is the dashboard.
+ */
+export declare function appPageUrl(appUrl: string, organizationSlug: string | null | undefined, site: string, slug: string, tab?: "history"): string;
+/**
+ * Asks the backend what the caller may do and shows an Edit button only when
+ * the answer is `can_edit`; everyone else gets nothing and never downloads the
+ * editor.
+ */
+export declare function BlogEditorMount({ site, slug, apiBase, auth, isNew, header, column, appUrl, timings, onEditingChange, onPublished, onLeave, slots, actions, }: BlogEditorMountProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/editor/DocumentActions.d.ts

@@ -0,0 +1,39 @@
+export type Status = "idle" | "dirty" | "saving" | "saved" | "conflict" | "rejected" | "invalid" | "error";
+export declare const STATUS_LABEL: Record<Status, string>;
+/** A database site's draft: no pull request, a revision count instead. */
+export interface DbRevision {
+    revision: number | null;
+}
+/** What the status says: a database site names the revision a save made. */
+export declare function statusLabel(status: Status, db: DbRevision | null): string;
+export interface DocumentActionsProps {
+    status: Status;
+    prUrl: string | null;
+    /** Set for a database site, whose draft has no pull request, only a history. */
+    db?: DbRevision | null;
+    /** Where a database site's revision history is. */
+    historyHref?: string | null;
+    /** Where Edit design opens; null when the site has no connected repository. */
+    designHref: string | null;
+    /** Opens or hides the Ask CodePress panel; absent when the mount cannot host it. */
+    onAsk?: () => void;
+    /** Without a panel, Ask CodePress opens this page (the post in the CodePress app) in a new tab. */
+    askHref?: string | null;
+    /** The CodePress agent's mark. */
+    askIconSrc?: string;
+    askOpen: boolean;
+    canPublish: boolean;
+    busy: null | "publishing" | "discarding";
+    publishDisabled: boolean;
+    confirmDiscard: boolean;
+    onConfirmDiscardChange: (open: boolean) => void;
+    onDiscard: () => void;
+    onDone: () => void;
+    onPublish: () => void;
+}
+/**
+ * The right-hand side of the toolbar: where the draft stands and what can be
+ * done with it. Below `xl` the secondary actions move into a More menu so the
+ * row never wraps.
+ */
+export declare function DocumentActions({ status, prUrl, db, historyHref, designHref, onAsk, askHref, askIconSrc, askOpen, canPublish, busy, publishDisabled, confirmDiscard, onConfirmDiscardChange, onDiscard, onDone, onPublish, }: DocumentActionsProps): import("react/jsx-runtime").JSX.Element;

package/dist/editor/EditDesignLink.d.ts

@@ -0,0 +1,30 @@
+import type { ComponentPropsWithRef, ReactNode } from "react";
+/** Where a site's posts are edited: the org that owns the site and its repository. */
+export interface DesignTarget {
+    organizationSlug: string;
+    repository: string;
+}
+/** The target from the site's `/me` answer, or null when the site has no connected repository. */
+export declare function designTargetOf(capabilities: {
+    organization_slug?: string | null;
+    repository_full_name?: string | null;
+}): DesignTarget | null;
+/**
+ * The dashboard's Design page (the Live Dev Server) of the organization that
+ * owns the site, opened on the site's repository at the post's route. The
+ * organization comes from the backend, not from the caller's organization list:
+ * someone in several organizations must land in the one where the repository is
+ * connected. The preview runs on an isolated origin inside the dashboard, so
+ * nothing from the preview runtime is ever loaded on this site. `appUrl` is the
+ * CodePress app's origin; empty means this page is on it.
+ */
+export declare function designUrl({ organizationSlug, repository }: DesignTarget, slug: string, appUrl?: string): string;
+/**
+ * Renders nothing without a link: without the owning organization and its
+ * repository there is no Design page to open, and the dashboard's entry point
+ * would pick the caller's first organization, which may not own the site.
+ */
+export declare function EditDesignLink({ href, children, ...rest }: {
+    href: string | null;
+    children?: ReactNode;
+} & Omit<ComponentPropsWithRef<"a">, "href" | "target" | "rel">): import("react/jsx-runtime").JSX.Element | null;

package/dist/editor/NewPostForm.d.ts

@@ -0,0 +1,10 @@
+/** Whether `slug` can address a new post: the schema's slug rules, and not a reserved route. */
+export declare function isValidNewSlug(slug: string): boolean;
+export interface NewPostFormProps {
+    /** Called with a valid slug when the author starts writing. */
+    onStart: (slug: string) => void;
+    /** Shown before the slug field: where posts live on the site. */
+    prefix?: string;
+}
+/** Start a post: choose its address, then write it in the editor. */
+export declare function NewPostForm({ onStart, prefix }: NewPostFormProps): import("react/jsx-runtime").JSX.Element;

package/dist/editor/SlashMenu.d.ts

@@ -0,0 +1,5 @@
+import type { SlashState } from "./slash-command.js";
+/** The `/` menu, drawn under the caret while the slash command is active. */
+export declare function SlashMenu({ state }: {
+    state: SlashState | null;
+}): import("react/jsx-runtime").JSX.Element | null;