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

package/src/editor/lib/markdown.ts

@@ -0,0 +1,71 @@
+export function renderMarkdown(src: string): string {
+  const lines = src.split("\n");
+  let html = "";
+  let inCode = false;
+  let inList = false;
+  let para: string[] = [];
+
+  const esc = (s: string) =>
+    s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  const inline = (s: string) =>
+    esc(s)
+      .replace(/!\[([^\]]*)\]\(([^)]+)\)/g, '<img alt="$1" src="$2" />')
+      .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>')
+      .replace(/`([^`]+)`/g, "<code>$1</code>")
+      .replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>")
+      .replace(/\*([^*]+)\*/g, "<em>$1</em>");
+
+  const flushPara = () => {
+    if (para.length) {
+      html += `<p>${para.map(inline).join(" ")}</p>`;
+      para = [];
+    }
+  };
+  const closeList = () => {
+    if (inList) {
+      html += "</ul>";
+      inList = false;
+    }
+  };
+
+  for (const raw of lines) {
+    const line = raw.trimEnd();
+    if (/^```/.test(line)) {
+      flushPara();
+      closeList();
+      html += inCode ? "</code></pre>" : "<pre><code>";
+      inCode = !inCode;
+      continue;
+    }
+    if (inCode) {
+      html += esc(raw) + "\n";
+      continue;
+    }
+    if (/^#{1,6}\s/.test(line)) {
+      flushPara();
+      closeList();
+      const level = line.match(/^#+/)![0].length;
+      html += `<h${level}>${inline(line.replace(/^#+\s*/, ""))}</h${level}>`;
+      continue;
+    }
+    if (/^[-*]\s+/.test(line)) {
+      flushPara();
+      if (!inList) {
+        html += "<ul>";
+        inList = true;
+      }
+      html += `<li>${inline(line.replace(/^[-*]\s+/, ""))}</li>`;
+      continue;
+    }
+    if (line === "") {
+      flushPara();
+      closeList();
+      continue;
+    }
+    para.push(line);
+  }
+  flushPara();
+  closeList();
+  if (inCode) html += "</code></pre>";
+  return html;
+}

package/src/editor/lib/media-library.ts

@@ -0,0 +1,39 @@
+import { mediaMetadata } from "../../media-types";
+
+export interface MediaAsset {
+  url: string;
+  name: string;
+  type?: string;
+  size?: number;
+  modified?: string;
+  title?: string;
+  description?: string;
+  alt?: string;
+  author?: string;
+}
+
+export function assetFile(url: string): string {
+  return decodeURIComponent(url.split("/").pop() ?? "");
+}
+
+export function modifiedMonth(value?: string): string {
+  if (!value || !Number.isFinite(Date.parse(value))) return "";
+  return new Date(value).toISOString().slice(0, 7);
+}
+
+const CURATED = new Set(['Images', 'Audio', 'Video', 'Documents', 'Spreadsheets', 'Archives']);
+export function filterMedia(assets: MediaAsset[], search: string, type: string, month: string): MediaAsset[] {
+  return assets.filter(asset => asset.name.toLowerCase().includes(search.trim().toLowerCase())
+    && (!type || asset.type === type || assetCategory(asset) === type) && (!month || modifiedMonth(asset.modified) === month));
+}
+function assetCategory(asset: MediaAsset): string {
+  const category = mediaMetadata(asset.name)?.category ?? '';
+  if (!category) return 'Other';
+  return CURATED.has(category) ? category : 'Other';
+}
+
+export function mediaSize(size?: number): string {
+  if (typeof size !== "number" || !Number.isFinite(size) || size < 0) return "—";
+  if (size < 1024) return `${size} B`;
+  return size < 1024 * 1024 ? `${Number((size / 1024).toFixed(1))} KB` : `${Number((size / (1024 * 1024)).toFixed(1))} MB`;
+}

package/src/editor/lib/menu-tree.ts

@@ -0,0 +1,37 @@
+import type { MenuItem } from "../../manifest/menu";
+
+export function menuRows(items: MenuItem[], parentId: string | null = null, depth = 1): { item: MenuItem; parentId: string | null; depth: number; previous?: string; next?: string }[] {
+  return items.flatMap((item, index) => [
+    { item, parentId, depth, previous: items[index - 1]?.id, next: items[index + 1]?.id },
+    ...menuRows(item.children, item.id, depth + 1),
+  ]);
+}
+
+export function editMenuItem(items: MenuItem[], id: string, update: (item: MenuItem) => MenuItem | null): MenuItem[] {
+  return items.flatMap((item) => {
+    if (item.id === id) { const next = update(item); return next ? [next] : []; }
+    return [{ ...item, children: editMenuItem(item.children, id, update) }];
+  });
+}
+
+export function moveMenuItem(items: MenuItem[], id: string, targetId: string | null, position: "before" | "after" | "inside", maxDepth: number): MenuItem[] {
+  const source = menuRows(items).find((row) => row.item.id === id)?.item;
+  if (!source) throw new Error("Menu item not found");
+  if (targetId && menuRows([source]).some((row) => row.item.id === targetId)) throw new Error("An item cannot be moved into itself or its children");
+  const next = editMenuItem(items, id, () => null);
+  let found = targetId === null;
+  function insert(list: MenuItem[]): MenuItem[] {
+    return list.flatMap((item) => {
+      if (item.id === targetId) {
+        found = true;
+        if (position === "inside") return [{ ...item, children: [...item.children, source!] }];
+        return position === "before" ? [source!, item] : [item, source!];
+      }
+      return [{ ...item, children: insert(item.children) }];
+    });
+  }
+  const result = targetId === null ? [...next, source] : insert(next);
+  if (!found) throw new Error("Drop target no longer exists");
+  if (menuRows(result).some((row) => row.depth > maxDepth)) throw new Error(`This move exceeds the ${maxDepth}-level limit`);
+  return result;
+}

package/src/editor/lib/rich-markdown.ts

@@ -0,0 +1,30 @@
+import MarkdownIt from "markdown-it";
+import { MarkdownParser, defaultMarkdownParser, defaultMarkdownSerializer, schema } from "prosemirror-markdown";
+import type { Node } from "prosemirror-model";
+
+const tokenizer = new MarkdownIt({ html: true });
+const parser = new MarkdownParser(schema, tokenizer, defaultMarkdownParser.tokens);
+export { schema };
+export const serializeMarkdown = (doc: Node) => defaultMarkdownSerializer.serialize(doc);
+
+export function safeMarkdownUrl(url: string): boolean {
+  return !/[\s\u0000-\u001f\u007f\\]/.test(url) && !url.startsWith("//") && (!/^[a-z][a-z\d+.-]*:/i.test(url) || /^(https?:|mailto:)/i.test(url));
+}
+
+export function parseVisualMarkdown(source: string): Node | null {
+  try {
+    const env: { references?: unknown } = {};
+    tokenizer.parse(source, env);
+    if (env.references) return null;
+    const doc = parser.parse(source);
+    let safe = true;
+    doc.descendants(node => {
+      if (node.type.name === "image" && !safeMarkdownUrl(node.attrs.src)) safe = false;
+      if (node.marks.some(mark => mark.type.name === "link" && !safeMarkdownUrl(mark.attrs.href))) safe = false;
+    });
+    if (!safe || tokenizer.render(source) !== tokenizer.render(serializeMarkdown(doc))) return null;
+    return doc;
+  } catch {
+    return null;
+  }
+}

package/src/editor/lib/schema-edit.ts

@@ -0,0 +1,110 @@
+import { cloneJson, newKey, regenerateKeys, setPath } from "../../schema/paths";
+import { isPlainObject, objectDef } from "../../schema/validate";
+import type { ContentDocument, DocumentDef, FieldDef, Schema } from "../../schema/types";
+
+export interface SelectedField {
+  docId: string;
+  path: string;
+  sectionKey?: string;
+}
+
+export function sectionList(values: Record<string, unknown>): Record<string, unknown>[] {
+  return Array.isArray(values.sections) ? (values.sections as Record<string, unknown>[]) : [];
+}
+
+export function sectionTypeDef(schema: Schema, type: unknown) {
+  return schema.objects.find((object) => object.name === type && object.type === "section");
+}
+
+export function sectionLabel(schema: Schema, type: unknown): string {
+  return sectionTypeDef(schema, type)?.title ?? String(type ?? "Section");
+}
+
+export function fieldForPath(schema: Schema, docType: DocumentDef, values: Record<string, unknown>, path: string): FieldDef | null {
+  if (!path) return null;
+  if (path.startsWith("sections.")) {
+    const [scope, key, ...rest] = path.split(".");
+    if (scope !== "sections" || !key) return null;
+    const section = sectionList(values).find((entry) => entry._key === key);
+    const def = section ? sectionTypeDef(schema, section._type) : undefined;
+    return def ? lookupField(schema, def.fields, rest) : null;
+  }
+  return lookupField(schema, docType.fields, path.split("."));
+}
+
+function lookupField(schema: Schema, fields: FieldDef[], segments: string[]): FieldDef | null {
+  let list = fields;
+  for (let index = 0; index < segments.length; index++) {
+    const field = list.find((entry) => entry.key === segments[index]);
+    if (!field) return null;
+    if (index === segments.length - 1) return field;
+    if (field.type === "object") {
+      list = field.of ? objectDef(schema, field.of).fields : field.fields ?? [];
+      continue;
+    }
+    if (field.type === "array") {
+      index++;
+      if (index >= segments.length) return null;
+      const item = field.items?.find((entry) => entry.type === "object");
+      if (!item || item.type !== "object") return null;
+      list = item.name ? objectDef(schema, item.name).fields : item.fields ?? [];
+      continue;
+    }
+    return null;
+  }
+  return null;
+}
+
+export function itemFields(schema: Schema, field: FieldDef): FieldDef[] {
+  const item = field.items?.find((entry) => entry.type === "object");
+  if (!item || item.type !== "object") return [];
+  return item.name ? objectDef(schema, item.name).fields : item.fields ?? [];
+}
+
+export function objectFields(schema: Schema, field: FieldDef): FieldDef[] {
+  return field.of ? objectDef(schema, field.of).fields : field.fields ?? [];
+}
+
+export function defaultValue(field: FieldDef): unknown {
+  if (field.initialValue !== undefined) return regenerateKeys(cloneJson(field.initialValue));
+  if (field.type === "array") return [];
+  if (field.type === "boolean") return false;
+  if (field.type === "number") return 0;
+  if (field.type === "color") return "#000000";
+  if (field.type === "object") return {};
+  if (field.type === "reference") return undefined;
+  return "";
+}
+
+export function blankItem(fields: FieldDef[]): Record<string, unknown> {
+  const item: Record<string, unknown> = { _key: newKey() };
+  for (const field of fields) {
+    const value = defaultValue(field);
+    if (value !== undefined) item[field.key] = value;
+  }
+  return item;
+}
+
+export function moveItem(list: unknown[], index: number, delta: number): unknown[] {
+  const next = [...list];
+  const target = index + delta;
+  if (target < 0 || target >= next.length) return next;
+  [next[index], next[target]] = [next[target], next[index]];
+  return next;
+}
+
+export function duplicateItem(list: unknown[], index: number): unknown[] {
+  const item = list[index];
+  const copy = isPlainObject(item) ? regenerateKeys(cloneJson(item)) : item;
+  return [...list.slice(0, index + 1), copy, ...list.slice(index + 1)];
+}
+
+export function replaceAt(values: Record<string, unknown>, path: string, value: unknown): Record<string, unknown> {
+  const next = cloneJson(values);
+  if (!setPath(next, path, value)) return values;
+  return next;
+}
+
+export function referenceOptions(documents: ContentDocument[], to: string[]) {
+  return documents.filter((doc) => to.includes(doc.type));
+}

package/src/editor/lib/settings.ts

@@ -0,0 +1,103 @@
+import { readStorage, writeStorage } from "./storage";
+import type { StockKeys } from "./images";
+
+export interface RigelUserPref {
+  sidebarCollapsed?: boolean;
+  editorExperience?: "sidebar" | "inline";
+  previewSplit: number;
+  mediaView: "grid" | "list";
+}
+
+export interface RigelSettings {
+  theme: "system" | "light" | "dark";
+  language: "en" | "es" | "ru";
+
+  devMode: boolean;
+  highContrast: boolean;
+
+  apiKeys: StockKeys;
+  userPref: RigelUserPref;
+}
+
+const prefs = (theme: "system" | "light" | "dark" = "system", language: "en" | "es" | "ru" = "en"): Pick<RigelSettings, "theme" | "language" | "devMode" | "highContrast"> => ({
+  theme, language, devMode: false, highContrast: false,
+});
+
+const DEFAULTS: RigelSettings = {
+  ...prefs(),
+  apiKeys: {},
+  userPref: { previewSplit: 0.5, mediaView: "grid", sidebarCollapsed: false, editorExperience: "sidebar" },
+};
+
+const PROVIDERS = ["pexels", "pixabay", "unsplash"] as const;
+
+export function getSettings(): RigelSettings {
+  try {
+    const saved = JSON.parse(readStorage("settings") ?? "{}");
+    const legacyKeys = readLegacyKeys();
+    const keys = Object.fromEntries(PROVIDERS.filter((key) => typeof saved?.apiKeys?.[key] === "string").map((key) => [key, saved.apiKeys[key]]));
+    const mergedKeys = { ...legacyKeys, ...keys };
+    const legacyPref = readLegacyPref();
+    return {
+      theme: ["system", "light", "dark"].includes(saved?.theme) ? saved.theme : DEFAULTS.theme,
+      language: ["en", "es", "ru"].includes(saved?.language) ? saved.language : DEFAULTS.language,
+      devMode: typeof saved?.devMode === "boolean" ? saved.devMode : DEFAULTS.devMode,
+      highContrast: typeof saved?.highContrast === "boolean" ? saved.highContrast : DEFAULTS.highContrast,
+      apiKeys: mergedKeys,
+      userPref: {
+        sidebarCollapsed: saved?.userPref?.sidebarCollapsed === true,
+        editorExperience: saved?.userPref?.editorExperience === "inline" ? "inline" : "sidebar",
+        previewSplit: typeof saved?.userPref?.previewSplit === "number" && Number.isFinite(saved.userPref.previewSplit) && saved.userPref.previewSplit >= 0.2 && saved.userPref.previewSplit <= 0.8
+          ? saved.userPref.previewSplit
+          : typeof saved?.previewSplit === "number" && Number.isFinite(saved.previewSplit) && saved.previewSplit >= 0.2 && saved.previewSplit <= 0.8
+            ? saved.previewSplit
+            : DEFAULTS.userPref.previewSplit,
+        mediaView: ["grid", "list"].includes(saved?.userPref?.mediaView) ? saved.userPref.mediaView
+          : legacyPref.mediaView ?? DEFAULTS.userPref.mediaView,
+      },
+    };
+  } catch {
+    return { ...DEFAULTS, apiKeys: readLegacyKeys(), userPref: { ...DEFAULTS.userPref, ...readLegacyPref() } };
+  }
+}
+
+function readLegacyKeys(): StockKeys {
+  try {
+    const value = JSON.parse(readStorage("keys") ?? "{}");
+    if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+    return Object.fromEntries(PROVIDERS.filter((key) => typeof value[key] === "string").map((key) => [key, value[key]]));
+  } catch {
+    return {};
+  }
+}
+
+function readLegacyPref(): Partial<RigelUserPref> {
+  try {
+    const value = JSON.parse(readStorage("mediaView") ?? "null");
+    return value === "grid" || value === "list" ? { mediaView: value } : {};
+  } catch {
+    return {};
+  }
+}
+
+export function setSettings(s: Partial<RigelSettings>) {
+  const next = { ...getSettings(), ...s, userPref: { ...getSettings().userPref, ...s.userPref } };
+  writeStorage("settings", next);
+  clearLegacy();
+  localStorage.removeItem("rigel.user");
+}
+
+function clearLegacy() {
+  for (const name of ["keys", "mediaView"] as const) {
+    localStorage.removeItem(`rigelcms.${name}`);
+    localStorage.removeItem(`rigel.${name}`);
+  }
+}
+
+export function getKeys(): StockKeys {
+  return getSettings().apiKeys;
+}
+
+export function setKeys(keys: StockKeys) {
+  setSettings({ apiKeys: keys });
+}

package/src/editor/lib/slugify.ts

@@ -0,0 +1,10 @@
+export function slugify(input: string): string {
+  return input
+    .normalize("NFKD")
+    .replace(/[̀-ͯ]/g, "") // combining marks → strip (é→e)
+    .toLowerCase()
+    .trim()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .replace(/-{2,}/g, "-");
+}

package/src/editor/lib/storage.ts

@@ -0,0 +1,17 @@
+export function readStorage(name: "settings" | "keys" | "mediaView"): string | null {
+  return localStorage.getItem(`rigelcms.${name}`) ?? localStorage.getItem(`rigel.${name}`);
+}
+
+export function writeStorage(name: "settings" | "keys" | "mediaView", value: unknown) {
+  localStorage.setItem(`rigelcms.${name}`, JSON.stringify(value));
+  localStorage.removeItem(`rigel.${name}`);
+}
+
+export function eraseData() {
+  const keys = Array.from({ length: localStorage.length }, (_, i) => localStorage.key(i));
+  for (const key of keys) {
+    if (key && (key.startsWith("rigelcms.") || ["rigel.settings", "rigel.keys", "rigel.user"].includes(key))) {
+      localStorage.removeItem(key);
+    }
+  }
+}

package/src/editor/lib/store.svelte.ts

@@ -0,0 +1,33 @@
+export function createCopyStore<T>(initial: T) {
+  let snapshot = JSON.stringify(initial);
+  let draft = $state<T>(initial);
+
+  const dirty = $derived(JSON.stringify(draft) !== snapshot);
+
+  function touch(next: T) {
+    draft = next;
+  }
+
+  function commit() {
+    snapshot = JSON.stringify(draft);
+  }
+
+  function reset(next: T) {
+    snapshot = JSON.stringify(next);
+    draft = next;
+  }
+
+  return {
+    get draft() {
+      return draft;
+    },
+    get dirty() {
+      return dirty;
+    },
+    touch,
+    commit,
+    reset,
+  };
+}
+
+export type CopyStore<T> = ReturnType<typeof createCopyStore<T>>;

package/src/editor/main.ts

@@ -0,0 +1,9 @@
+import { mount } from "svelte";
+import App from "./App.svelte";
+import "./styles.css";
+
+const target = document.getElementById("rigel");
+if (target) {
+  import.meta.hot?.send("rigel:editor-ready");
+  mount(App, { target });
+}