@rigel-cms/rigel 0.0.0-stage → 0.1.0-beta.1

package/src/env.d.ts

@@ -0,0 +1,22 @@
+declare module "virtual:rigel-manifest" {
+  import type { CopyPage, ManifestCollection } from "@rigel-cms/rigel/content";
+  export const pages: CopyPage[];
+  export const collections: ManifestCollection[];
+  export const documents: import("@rigel-cms/rigel/content").ContentDocument[];
+  export const menus: import("@rigel-cms/rigel/content").Manifest["menus"];
+  const manifest: import("@rigel-cms/rigel/content").Manifest;
+  export default manifest;
+}
+
+declare module "virtual:rigel-content" {
+  import type { ContentDocument } from "@rigel-cms/rigel/content";
+  export const documents: ContentDocument[];
+  export function getDocument(id: string): ContentDocument | undefined;
+  export function derefDocument(value: unknown): ContentDocument | undefined;
+}
+
+declare module "virtual:rigel-config" {
+  import type { RigelConfig } from "@rigel-cms/rigel";
+  const config: Pick<RigelConfig, "copyDir" | "backend" | "demo" | "collections" | "menus" | "mediaDir" | "schema"> & { publicDir?: string; root?: string };
+  export default config;
+}

package/src/index.ts

@@ -0,0 +1,128 @@
+import type { AstroIntegration } from "astro";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { lstat, readFile } from "node:fs/promises";
+import { mediaMetadata, safeMediaName } from "./media-types";
+import { mediaDirectory } from "./routes/media-files";
+import { parseConfig, type RigelConfig } from "./config";
+import { rigelManifestPlugin } from "./vite/manifest-plugin";
+import { svelte } from "@sveltejs/vite-plugin-svelte";
+
+export function rigel(options: Partial<RigelConfig> = {}): AstroIntegration {
+  let cfg: RigelConfig;
+  return {
+    name: "rigel",
+    hooks: {
+      "astro:config:setup": ({ injectRoute, injectScript, updateConfig, command, config }) => {
+        cfg = parseConfig(options);
+        if (cfg.menus && command === "dev") injectScript("page", `if (import.meta.hot) import.meta.hot.on("rigel:menus-updated", () => { if (!/^\\/rigel(?:\\/|$)/.test(location.pathname)) location.reload(); });`);
+        if (cfg.schema && command === "dev") injectScript("page", `if (import.meta.hot) import.meta.hot.on("rigel:content-updated", () => { if (!/^\\/rigel(?:\\/|$)/.test(location.pathname)) location.reload(); });`);
+        if (cfg.collections?.length && command === "dev") injectScript("page", `if (import.meta.hot) import.meta.hot.on("rigel:collections-updated", () => { if (!/^\\/rigel(?:\\/|$)/.test(location.pathname)) location.reload(); });`);
+
+
+        updateConfig({
+          vite: {
+            plugins: [rigelManifestPlugin(cfg, config.publicDir, config.root), svelte(), {
+              name: "rigel-svelte-environment",
+              enforce: "pre",
+              configEnvironment(name) {
+                if (name !== "client") return { optimizeDeps: { exclude: ["svelte"] } };
+              },
+            }, {
+              name: "rigel-media-headers",
+              configureServer(server) {
+                const prefix = `/${cfg.mediaDir ?? "rigel-media"}/`;
+                server.middlewares.use(async (request, response, next) => {
+                  let pathname: string;
+                  try { pathname = decodeURIComponent(new URL(request.url ?? "/", "http://localhost").pathname); } catch { return next(); }
+                  if (!pathname.startsWith(prefix)) return next();
+                  try {
+                    const parts = pathname.slice(prefix.length).split("/");
+                    const filename = parts.pop()!;
+                    if (!safeMediaName(filename) || !parts.every(part => /^[a-zA-Z0-9_-][a-zA-Z0-9_. -]*$/.test(part))) throw new Error();
+                    let directory = await mediaDirectory(config.publicDir.href, cfg.mediaDir);
+                    for (const part of parts) {
+                      directory = path.join(directory, part);
+                      const info = await lstat(directory);
+                      if (!info.isDirectory() || info.isSymbolicLink()) throw new Error();
+                    }
+                    const file = path.join(directory, filename), info = await lstat(file);
+                    if (!info.isFile() || info.isSymbolicLink()) throw new Error();
+                    const metadata = mediaMetadata(filename)!;
+                    response.setHeader("Content-Type", metadata.type);
+                    response.setHeader("X-Content-Type-Options", "nosniff");
+                    response.setHeader("Content-Disposition", `${metadata.category === "Images" ? "inline" : "attachment"}; filename="${filename}"`);
+                    response.end(request.method === "HEAD" ? undefined : await readFile(file));
+                  } catch { response.statusCode = 404; response.end("Not found"); }
+                });
+              },
+            }],
+            ...(cfg.backend === "local" && command === "dev" ? {
+              server: { watch: { ignored: [(file: string) =>
+                path.dirname(file) === path.resolve(fileURLToPath(config.publicDir), cfg.mediaDir ?? "rigel-media")
+                && /^[a-f0-9]{64}\.[a-z0-9]+$/.test(path.basename(file))
+              ] } },
+            } : {}),
+          },
+        });
+
+        injectRoute({
+          pattern: "/rigel",
+          entrypoint: "@rigel-cms/rigel/routes/rigel-page.astro",
+          prerender: true,
+        });
+        injectRoute({
+          pattern: "/rigel/manifest.json",
+          entrypoint: "@rigel-cms/rigel/routes/manifest.json.ts",
+          prerender: true,
+        });
+        injectRoute({ pattern: "/rigel/media.json", entrypoint: "@rigel-cms/rigel/routes/media.json.ts", prerender: true });
+        if (cfg.backend === "local" && command === "dev") {
+          injectRoute({
+            pattern: `/${cfg.mediaDir ?? "rigel-media"}/[filename]`,
+            entrypoint: "@rigel-cms/rigel/routes/local-media.ts",
+            prerender: false,
+          });
+          injectRoute({
+            pattern: "/rigel/api/local/media",
+            entrypoint: "@rigel-cms/rigel/routes/local-media.ts",
+            prerender: false,
+          });
+          injectRoute({
+            pattern: "/rigel/api/local/save",
+            entrypoint: "@rigel-cms/rigel/routes/local-api.ts",
+            prerender: false,
+          });
+          injectRoute({
+            pattern: "/rigel/api/local/[collection]/[slug]",
+            entrypoint: "@rigel-cms/rigel/routes/local-post.ts",
+            prerender: false,
+          });
+          if (cfg.menus) injectRoute({
+            pattern: "/rigel/api/local/menus/[slug]",
+            entrypoint: "@rigel-cms/rigel/routes/local-menu.ts",
+            prerender: false,
+          });
+          if (cfg.schema) injectRoute({
+            pattern: "/rigel/api/local/documents/[id]",
+            entrypoint: "@rigel-cms/rigel/routes/local-documents.ts",
+            prerender: false,
+          });
+        }
+      },
+    },
+  };
+}
+
+export { validateMenu } from "./manifest/menu";
+export type { MenuItem, MenuDocument } from "./manifest/menu";
+export { defineCopy } from "./manifest/types";
+export type { CopyField, CopyGroup, CopyPage, Manifest, CollectionField } from "./manifest/types";
+export type { RigelConfig, CollectionConfig } from "./config";
+export type { ReferenceOption } from "./manifest/references";
+export type { SidebarEntry, SidebarTarget, SidebarIconName } from "./manifest/navigation";
+export { defineSchema, defineDocument, defineObject, defineField } from "./schema/types";
+export type { Schema, DocumentDef, ObjectDef, FieldDef, ContentDocument } from "./schema/types";
+export { validateSchema, validateDocument, SchemaError } from "./schema/validate";
+export { resolvePath, setPath, newKey, newDocumentFromTemplate, regenerateKeys, pageRoute } from "./schema/paths";
+export { buildDocumentIndex, deref, referencedIds } from "./schema/docs";

package/src/manifest/frontmatter.ts

@@ -0,0 +1,56 @@
+type MarkdownPost = { slug: string; frontmatter: Record<string, unknown>; body: string };
+
+export function parseFrontmatter(raw: string): MarkdownPost {
+  const m = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  const fm = m ? parseYamlFlat(m[1]) : {};
+  const body = m ? m[2] : raw;
+  return {
+    slug: String(fm.slug ?? ""),
+    frontmatter: fm,
+    body: body.replace(/\r\n/g, "\n"),
+  };
+}
+
+export function serializeFrontmatter(post: MarkdownPost): string {
+  const lines = Object.entries(post.frontmatter).map(([k, v]) => {
+    if (Array.isArray(v))
+      return `${k}: [${v.map((x) => JSON.stringify(String(x))).join(", ")}]`;
+    if (typeof v === "boolean") return `${k}: ${v}`;
+    return `${k}: ${JSON.stringify(String(v))}`;
+  });
+  return `---\n${lines.join("\n")}\n---\n${post.body.replace(/\n+$/, "")}\n`;
+}
+
+function parseYamlFlat(src: string): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const line of src.split("\n")) {
+    if (!line.trim() || line.startsWith("#")) continue;
+    const i = line.indexOf(":");
+    if (i < 0) continue;
+    const key = line.slice(0, i).trim();
+    let v: unknown = line.slice(i + 1).trim();
+    if (typeof v === "string" && v.startsWith("[") && v.endsWith("]")) {
+      v = v
+        .slice(1, -1)
+        .split(",")
+        .map((s) => unquote(s.trim()))
+        .filter(Boolean);
+    } else if (v === "true" || v === "false") {
+      v = v === "true";
+    } else {
+      v = unquote(v as string);
+    }
+    out[key] = v;
+  }
+  return out;
+}
+
+function unquote(s: string): string {
+  if (
+    (s.startsWith('"') && s.endsWith('"')) ||
+    (s.startsWith("'") && s.endsWith("'"))
+  ) {
+    return s.slice(1, -1);
+  }
+  return s;
+}

package/src/manifest/loader.ts

@@ -0,0 +1,14 @@
+import type { CopyPage, Manifest } from "./types";
+
+export function loadManifest(modules: CopyPage[]): Manifest {
+  const pages = [...modules].sort((a, b) => a.slug.localeCompare(b.slug));
+  for (const page of pages) {
+    if (!page.slug || !page.groups?.length)
+      throw new Error(`Copy module ${page.label || "?"} missing slug or groups`);
+    for (const group of page.groups) {
+      if (!group.id || !group.fields?.length)
+        throw new Error(`Group ${group.id || "?"} in ${page.slug} missing id or fields`);
+    }
+  }
+  return { pages };
+}

package/src/manifest/menu.ts

@@ -0,0 +1,46 @@
+export interface MenuItem {
+  id: string;
+  label: string;
+  url: string;
+  newTab?: boolean;
+  children: MenuItem[];
+}
+
+export interface MenuDocument {
+  slug: string;
+  title: string;
+  items: MenuItem[];
+}
+
+export const MENU_SLUG = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+export function validateMenu(value: unknown, maxDepth: number): MenuDocument {
+  if (!Number.isInteger(maxDepth) || maxDepth < 1 || maxDepth > 10)
+    throw new Error("Menu maxDepth must be an integer from 1 to 10");
+  const object = (v: unknown): v is Record<string, unknown> =>
+    v !== null && typeof v === "object" && !Array.isArray(v);
+  const text = (v: unknown): v is string => typeof v === "string" && v.trim().length > 0;
+  if (!object(value) || typeof value.slug !== "string" || !MENU_SLUG.test(value.slug) || !text(value.title) || !Array.isArray(value.items))
+    throw new Error("Menu requires a lowercase alphanumeric-hyphen slug, title, and items array");
+  const ids = new Set<string>();
+  function items(values: unknown[], depth: number): MenuItem[] {
+    return values.map((item) => {
+      if (depth > maxDepth) throw new Error(`Menu exceeds maximum depth ${maxDepth}`);
+      if (!object(item) || !text(item.id) || !text(item.label) || !text(item.url) || !Array.isArray(item.children))
+        throw new Error("Menu items require nonempty id, label, url, and children array");
+      if (ids.has(item.id)) throw new Error(`Duplicate menu item id: ${item.id}`);
+      ids.add(item.id);
+      if (item.newTab !== undefined && typeof item.newTab !== "boolean") throw new Error("Menu item newTab must be a boolean");
+      const url = item.url;
+      if (url !== url.trim() || /[\u0000-\u0020\u007f\\]/.test(url) || url.startsWith("//"))
+        throw new Error("Unsafe menu URL");
+      let parsed: URL;
+      try { parsed = new URL(url, "https://rigel.invalid/"); }
+      catch { throw new Error("Invalid menu URL"); }
+      if (!["http:", "https:", "mailto:", "tel:"].includes(parsed.protocol))
+        throw new Error("Unsafe menu URL protocol");
+      return { id: item.id, label: item.label, url, ...(item.newTab === undefined ? {} : { newTab: item.newTab }), children: items(item.children, depth + 1) };
+    });
+  }
+  return { slug: value.slug, title: value.title, items: items(value.items, 1) };
+}

package/src/manifest/navigation.ts

@@ -0,0 +1,94 @@
+import type { Manifest } from "./types";
+
+export type Selection =
+  | { kind: "media" }
+  | { kind: "menus" }
+  | { kind: "menu"; slug: string }
+  | { kind: "pages"; category?: string }
+  | { kind: "page"; slug: string }
+  | { kind: "documents"; type: string }
+  | { kind: "document"; type: string; id: string }
+  | { kind: "collection"; name: string }
+  | { kind: "post"; collection: string; slug: string };
+
+export type SidebarTarget = Exclude<Selection, { kind: "post" } | { kind: "menu" }>;
+export const SIDEBAR_ICONS = ["files", "file-text", "newspaper", "megaphone", "images", "squares-four", "list", "layout", "sidebar-simple", "magnifying-glass", "house", "users", "user", "gear", "globe", "folder", "folders", "book-open", "calendar", "tag", "heart", "shopping-bag", "chart-bar", "pencil-simple", "square-half"] as const;
+export type SidebarIconName = typeof SIDEBAR_ICONS[number];
+export function isSidebarIconPath(value: unknown): value is string {
+  return typeof value === "string" && /^\/(?!\/)[\w./-]+\.svg$/i.test(value) && !value.split("/").some(part => part === "." || part === "..");
+}
+export type SidebarEntry =
+  | { kind: "heading"; label: string }
+  | { kind: "separator" }
+  | { kind: "link"; target: SidebarTarget; label?: string; icon?: string };
+export type SidebarLink = { kind: "link"; target: SidebarTarget; label: string; icon?: string };
+export type SidebarNode = Exclude<SidebarEntry, { kind: "link" }> | SidebarLink;
+export function navigationKey(target: Selection): string {
+  return JSON.stringify([target.kind, "category" in target ? target.category : null, "name" in target ? target.name : null, "slug" in target ? target.slug : null, "type" in target ? target.type : null, "id" in target ? target.id : null, "collection" in target ? target.collection : null]);
+}
+
+export function buildSidebar(manifest: Manifest): SidebarNode[] {
+  const link = (target: SidebarTarget, label: string): SidebarLink => ({ kind: "link", target, label });
+  const types = manifest.schema?.documents ?? [];
+  const pageTypes = types.filter(type => !type.shared);
+  const pages = manifest.pages.filter(page => !page.shared);
+  const categories = [...new Set(pages.map(page => page.category).filter((category): category is string => !!category))].sort();
+  const defaults: SidebarNode[] = [
+    { kind: "heading", label: "Website" },
+    link({ kind: "pages" }, "Pages"),
+    ...(manifest.collections ?? []).map(collection => link({ kind: "collection", name: collection.name }, collection.label)),
+    ...categories.map(category => link({ kind: "pages", category }, category)),
+    ...pageTypes.slice(1).map(type => link({ kind: "documents", type: type.name }, type.title)),
+    { kind: "heading", label: "Shared content" },
+    ...types.filter(type => type.shared && !type.singleton).map(type => link({ kind: "documents", type: type.name }, type.title)),
+    ...manifest.pages.filter(page => page.shared).map(page => link({ kind: "page", slug: page.slug }, page.label)),
+    ...(manifest.menus ? [link({ kind: "menus" }, "Menus")] : []),
+    { kind: "heading", label: "Assets" },
+    link({ kind: "media" }, "Media"),
+    ...(types.some(type => type.shared && type.singleton) ? [{ kind: "separator" } as SidebarNode] : []),
+    ...types.filter(type => type.shared && type.singleton).map(type => {
+      const doc = manifest.documents?.find(doc => doc.type === type.name);
+      return doc ? { ...link({ kind: "document", type: type.name, id: doc.id }, type.title), icon: "gear" } : link({ kind: "documents", type: type.name }, type.title);
+    }),
+  ];
+  if (!manifest.sidebar) return defaults;
+  const available = new Map(defaults.filter((node): node is SidebarLink => node.kind === "link").map(node => [navigationKey(node.target), node]));
+  for (const page of manifest.pages) available.set(navigationKey({ kind: "page", slug: page.slug }), link({ kind: "page", slug: page.slug }, page.label));
+  for (const doc of manifest.documents ?? []) {
+    const target: SidebarTarget = { kind: "document", type: doc.type, id: doc.id };
+    const key = navigationKey(target);
+    if (!available.has(key)) available.set(key, link(target, String(doc.data.title ?? doc.data.name ?? doc.slug)));
+  }
+  const nodes: SidebarNode[] = [];
+  const used = new Set<string>();
+  for (const entry of manifest.sidebar) {
+    if (entry.kind !== "link") { nodes.push(entry); continue; }
+    const key = navigationKey(entry.target);
+    const item = available.get(key);
+    if (!item || used.has(key)) continue;
+    used.add(key);
+    nodes.push({ ...item, label: entry.label ?? item.label, ...(entry.icon ? { icon: entry.icon } : {}) });
+  }
+  const remaining = defaults.filter((node): node is SidebarLink => node.kind === "link" && !used.has(navigationKey(node.target)));
+  if (remaining.length) nodes.push({ kind: "heading", label: "More content" }, ...remaining);
+  return nodes;
+}
+
+export function validateSidebar(value: unknown): void {
+  const fail = () => { throw new Error("rigel: sidebar requires headings, separators or links with valid content targets"); };
+  if (!Array.isArray(value)) fail();
+  for (const entry of value as unknown[]) {
+    if (!entry || typeof entry !== "object") fail();
+    const item = entry as Record<string, unknown>;
+    if (item.kind === "separator") continue;
+    if (item.label !== undefined && (typeof item.label !== "string" || !item.label.trim())) fail();
+    if (item.kind === "heading") { if (!item.label) fail(); continue; }
+    if (item.kind !== "link" || !item.target || typeof item.target !== "object") fail();
+    if (item.icon !== undefined && !SIDEBAR_ICONS.includes(item.icon as SidebarIconName) && !isSidebarIconPath(item.icon)) fail();
+    const target = item.target as Record<string, unknown>;
+    const fields: Record<string, string[]> = { media: [], menus: [], pages: [], page: ["slug"], collection: ["name"], documents: ["type"], document: ["type", "id"] };
+    if (typeof target.kind !== "string" || !Object.hasOwn(fields, target.kind)) fail();
+    for (const key of fields[target.kind as string]) if (typeof target[key] !== "string" || !String(target[key]).trim()) fail();
+    if (target.category !== undefined && (target.kind !== "pages" || typeof target.category !== "string" || !target.category.trim())) fail();
+  }
+}

package/src/manifest/references.ts

@@ -0,0 +1,39 @@
+import type { CollectionField } from "./types";
+import type { ContentDocument } from "../schema/types";
+
+export interface ReferenceOption {
+  value: string;
+  label: string;
+  description?: string;
+  photo?: string;
+  email?: string;
+  url?: string;
+}
+
+export function referenceOptions(field: CollectionField, documents: ContentDocument[] = []): ReferenceOption[] {
+  if (field.options) return field.options;
+  return documents.filter(doc => doc.type === field.to).map(doc => ({
+    value: doc.id,
+    label: String(doc.data.name ?? doc.data.title ?? doc.slug),
+    ...Object.fromEntries(["description", "photo", "email", "url"].filter(key => typeof doc.data[key] === "string").map(key => [key, doc.data[key]])),
+  }));
+}
+
+export function referenceLabel(value: unknown, options: ReferenceOption[]): string {
+  return (Array.isArray(value) ? value : [value]).filter(Boolean).map(id => options.find(option => option.value === id)?.label ?? `Unavailable (${String(id)})`).join(", ");
+}
+
+export function collectionPreviewValues(fields: CollectionField[], values: Record<string, unknown>, documents: ContentDocument[]): Record<string, unknown> {
+  return { ...values, ...Object.fromEntries(fields.filter(field => field.type === "reference").map(field => [field.key, referenceLabel(values[field.key], referenceOptions(field, documents))])) };
+}
+
+export function validateCollectionReferences(fields: CollectionField[], values: Record<string, unknown>, documents: ContentDocument[]): void {
+  for (const field of fields.filter(field => field.type === "reference")) {
+    const value = values[field.key];
+    if (value === undefined) continue;
+    if (field.multiple ? !Array.isArray(value) : typeof value !== "string") throw new Error(`${field.label}: expected ${field.multiple ? "an array of references" : "one reference"}`);
+    const selected = field.multiple ? value as unknown[] : value === "" ? [] : [value];
+    const options = referenceOptions(field, documents);
+    if (new Set(selected).size !== selected.length || selected.some(id => typeof id !== "string" || !options.some(option => option.value === id))) throw new Error(`${field.label}: select existing entries only`);
+  }
+}

package/src/manifest/seo.ts

@@ -0,0 +1,15 @@
+import type { CollectionField } from "./types";
+
+export const SEO_FIELDS = [
+  { key: "metaTitle", label: "SEO title", type: "string" },
+  { key: "description", label: "SEO description", type: "text" },
+  { key: "ogImage", label: "Social image", type: "image" },
+] satisfies CollectionField[];
+
+export function isSeoField(key: string): boolean {
+  return key === "metaTitle" || key === "description" || key === "ogImage";
+}
+
+export function withSeoFields<T extends { key: string }>(fields: T[]): (T | typeof SEO_FIELDS[number])[] {
+  return [...fields, ...SEO_FIELDS.filter(field => !fields.some(existing => existing.key === field.key)).map(field => ({ ...field }))];
+}

package/src/manifest/types.ts

@@ -0,0 +1,75 @@
+import type { MenuDocument } from "./menu";
+
+export type CopyField =
+  | { key: string; type: "string"; label: string; placeholder?: string }
+  | { key: string; type: "text"; label: string }
+  | { key: string; type: "markdown"; label: string }
+  | { key: string; type: "image"; label: string }
+  | { key: string; type: "list"; label: string; item: { fields: CopyField[] } };
+
+export interface CopyGroup {
+  id: string;
+  label: string;
+  fields: CopyField[];
+}
+
+export interface CopyPage {
+  slug: string;
+  label: string;
+  shared?: boolean;
+  category?: string;
+  groups: CopyGroup[];
+  values: Record<string, Record<string, unknown>>;
+}
+
+export interface GitHubBackendConfig {
+  repo: string;
+  branch: string;
+  publishBranch: string;
+  repoRoot: string;
+  authOrigin: string;
+  appSlug: string;
+  copyDir: string;
+  collections: { name: string; folder: string }[];
+  menus?: { folder: string; maxDepth: number };
+}
+
+export interface Manifest {
+  backend?: "github";
+  github?: GitHubBackendConfig;
+  sidebar?: import("./navigation").SidebarEntry[];
+  preview?: import("../preview").PreviewConfig;
+  pages: CopyPage[];
+  collections?: ManifestCollection[];
+  menus?: { maxDepth: number; entries: MenuDocument[] };
+  schema?: import("../schema/types").Schema;
+  documents?: import("../schema/types").ContentDocument[];
+}
+
+export interface CollectionField {
+  key: string;
+  label: string;
+  type: "string" | "text" | "boolean" | "date" | "tags" | "markdown" | "image" | "reference";
+  to?: string;
+  multiple?: boolean;
+  options?: import("./references").ReferenceOption[];
+}
+
+export interface CollectionPost {
+  slug: string;
+  frontmatter: Record<string, unknown>;
+  body: import("../article-body").ArticleBody;
+}
+
+export interface ManifestCollection {
+  name: string;
+  label: string;
+  listTitle?: string;
+  fields: CollectionField[];
+  columns?: string[];
+  posts: CollectionPost[];
+}
+
+export function defineCopy(page: CopyPage): CopyPage {
+  return page;
+}

package/src/media-types.ts

@@ -0,0 +1,21 @@
+export const MEDIA_TYPES: Record<string, { type: string; category: string }> = {};
+for (const [category, entries] of Object.entries({
+  Images: { jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', webp: 'image/webp', gif: 'image/gif', avif: 'image/avif' },
+  Audio: { mp3: 'audio/mpeg', wav: 'audio/wav', ogg: 'audio/ogg', m4a: 'audio/mp4' },
+  Video: { mp4: 'video/mp4', webm: 'video/webm', mov: 'video/quicktime' },
+  Documents: { pdf: 'application/pdf', doc: 'application/msword', docx: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', rtf: 'application/rtf', odt: 'application/vnd.oasis.opendocument.text', ppt: 'application/vnd.ms-powerpoint', pptx: 'application/vnd.openxmlformats-officedocument.presentationml.presentation' },
+  Spreadsheets: { xls: 'application/vnd.ms-excel', xlsx: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', csv: 'text/csv', ods: 'application/vnd.oasis.opendocument.spreadsheet' },
+  Archives: { zip: 'application/zip', gz: 'application/gzip', tar: 'application/x-tar', '7z': 'application/x-7z-compressed', rar: 'application/vnd.rar' },
+})) for (const [extension, type] of Object.entries(entries)) MEDIA_TYPES[extension] = { type, category };
+
+export const MEDIA_CATEGORIES = ['Images', 'Audio', 'Video', 'Documents', 'Spreadsheets', 'Archives', 'Other'];
+export function mediaMetadata(name: string) {
+  const extension = name.split('.').pop()?.toLowerCase() ?? '';
+  return Object.hasOwn(MEDIA_TYPES, extension) ? { ...MEDIA_TYPES[extension], extension } : undefined;
+}
+export function safeMediaName(name: string) {
+  return /^[a-zA-Z0-9_-][a-zA-Z0-9_. -]*$/.test(name) && !!mediaMetadata(name);
+}
+export function mediaAccept(imagesOnly = false) {
+  return Object.keys(MEDIA_TYPES).filter(ext => !imagesOnly || MEDIA_TYPES[ext].category === 'Images').map(ext => '.' + ext).join(',');
+}

package/src/preview-urls.ts

@@ -0,0 +1,3 @@
+export function safePreviewUrl(value: string, image = false): boolean {
+  return !!value && !/[ \t\r\n\f\v\u0000-\u001f\u007f\\]/.test(value) && !value.startsWith("//") && (!/^[a-z][a-z\d+.-]*:/i.test(value) || (image ? /^https?:/i : /^(https?:|mailto:)/i).test(value));
+}