pandorga 1.2.1

data/studio-app/src/lib/document.js

@@ -0,0 +1,207 @@
+/**
+ * Front matter + body serialization helpers.
+ */
+
+import yaml from "js-yaml";
+
+export function splitDocument(raw) {
+  const text = String(raw || "");
+  if (!text.startsWith("---")) {
+    return { fmLines: [], fm: {}, body: text, hasFm: false };
+  }
+  const end = text.indexOf("\n---", 3);
+  if (end < 0) return { fmLines: [], fm: {}, body: text, hasFm: false };
+  const rawFm = text.slice(4, end).replace(/^\r?\n/, "");
+  const afterClose = text.slice(end + 4);
+  const blankAfterFm = /^\r?\n\r?\n/.test(afterClose);
+  const body = afterClose.replace(/^(?:\r?\n)+/, "");
+  const fmLines = rawFm.split(/\r?\n/);
+  const fm = parseFrontMatter(rawFm);
+  return { fmLines, fm, body, hasFm: true, rawFm, blankAfterFm };
+}
+
+function parseFrontMatter(rawFm) {
+  try {
+    const doc = yaml.load(rawFm, { schema: yaml.JSON_SCHEMA });
+    if (doc && typeof doc === "object" && !Array.isArray(doc)) return doc;
+  } catch {
+    /* fall through to the line parser */
+  }
+  const fm = {};
+  for (const line of String(rawFm || "").split(/\r?\n/)) {
+    const m = line.match(/^([A-Za-z0-9_]+):\s*(.*)$/);
+    if (!m) continue;
+    let v = m[2];
+    if (v === "true") v = true;
+    else if (v === "false") v = false;
+    else if (
+      (v.startsWith('"') && v.endsWith('"')) ||
+      (v.startsWith("'") && v.endsWith("'"))
+    ) {
+      v = v.slice(1, -1);
+    }
+    fm[m[1]] = v;
+  }
+  return fm;
+}
+
+function yamlScalar(value) {
+  if (value === true || value === false) return String(value);
+  if (typeof value === "number") return String(value);
+  if (value == null) return '""';
+  const s = String(value);
+  if (s === "") return '""';
+  if (/^(true|false|null|yes|no|~)$/i.test(s)) return JSON.stringify(s);
+  if (/[:#&*!|>%@`]/.test(s) || /^[\s\-?]|:\s|\s$/.test(s) || /[\n"']/.test(s)) {
+    return JSON.stringify(s);
+  }
+  return s;
+}
+
+function isEmptyFm(value) {
+  if (value === "" || value == null) return true;
+  if (Array.isArray(value) && value.length === 0) return true;
+  return false;
+}
+
+function sameFmValue(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+function topLevelSpans(rawFm) {
+  const lines = String(rawFm || "").replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n");
+  const spans = [];
+  let i = 0;
+  while (i < lines.length) {
+    if (lines[i].trim() === "") {
+      i++;
+      continue;
+    }
+    const m = lines[i].match(/^([A-Za-z0-9_]+):\s*(.*)$/);
+    if (!m) {
+      i++;
+      continue;
+    }
+    const start = i;
+    i++;
+    while (i < lines.length) {
+      const nxt = lines[i];
+      if (nxt === "") {
+        const after = lines[i + 1];
+        if (after == null || /^[A-Za-z0-9_]+:\s*/.test(after)) break;
+        i++;
+        continue;
+      }
+      if (/^\s/.test(nxt)) {
+        i++;
+        continue;
+      }
+      break;
+    }
+    spans.push({ key: m[1], lines: lines.slice(start, i) });
+  }
+  return spans;
+}
+
+function formatKeyLines(key, value) {
+  if (Array.isArray(value) && value.every((v) => v == null || typeof v !== "object")) {
+    return [`${key}:`, ...value.map((v) => `  - ${yamlScalar(v)}`)];
+  }
+  if (value && typeof value === "object") {
+    const dumped = yaml.dump(
+      { [key]: value },
+      { schema: yaml.JSON_SCHEMA, lineWidth: -1, noRefs: true }
+    );
+    return dumped.replace(/\n$/, "").split("\n");
+  }
+  return [`${key}: ${yamlScalar(value)}`];
+}
+
+function frontMatterChanged(original, fields) {
+  const next = { ...original };
+  for (const [key, val] of Object.entries(fields || {})) {
+    if (isEmptyFm(val)) {
+      if (!isEmptyFm(original[key])) delete next[key];
+    } else {
+      next[key] = val;
+    }
+  }
+  const keys = new Set([...Object.keys(original), ...Object.keys(next)]);
+  for (const key of keys) {
+    if (!sameFmValue(original[key], next[key])) return true;
+  }
+  return false;
+}
+
+function rebuildFrontMatter(rawFm, fields) {
+  const original = parseFrontMatter(rawFm);
+  const next = { ...original };
+  for (const [key, val] of Object.entries(fields || {})) {
+    if (isEmptyFm(val)) {
+      if (!isEmptyFm(original[key])) delete next[key];
+    } else {
+      next[key] = val;
+    }
+  }
+  const originalKeys = Object.keys(original);
+  const nextKeys = Object.keys(next);
+  const unchanged =
+    originalKeys.length === nextKeys.length &&
+    nextKeys.every((key) => sameFmValue(original[key], next[key]));
+  if (unchanged) return String(rawFm || "").replace(/\n$/, "");
+
+  const spans = topLevelSpans(rawFm);
+  const used = new Set();
+  const out = [];
+  for (const span of spans) {
+    if (!Object.prototype.hasOwnProperty.call(next, span.key)) continue;
+    used.add(span.key);
+    if (sameFmValue(original[span.key], next[span.key])) out.push(...span.lines);
+    else out.push(...formatKeyLines(span.key, next[span.key]));
+  }
+  for (const [key, val] of Object.entries(next)) {
+    if (used.has(key)) continue;
+    out.push(...formatKeyLines(key, val));
+  }
+  return out.join("\n");
+}
+
+/**
+ * Rebuild file content from original FM lines, overlaying edited scalar fields
+ * and replacing the body. Preserves unknown YAML structure where possible.
+ */
+export function rebuildDocument(originalRaw, { fields, body, format }) {
+  if (format === "raw") {
+    return body.endsWith("\n") ? body : body + "\n";
+  }
+  if (format === "yaml") {
+    // YAML collections use dumpYaml / structured editors in main.js — not this path.
+    return body.endsWith("\n") ? body : body + "\n";
+  }
+
+  const split = splitDocument(originalRaw);
+  const { rawFm, hasFm, blankAfterFm } = split;
+  const bodyNorm = String(body || "").replace(/^(?:\r?\n)+/, "");
+  if (
+    hasFm &&
+    !frontMatterChanged(split.fm, fields) &&
+    bodyNorm === String(split.body || "").replace(/^(?:\r?\n)+/, "")
+  ) {
+    return originalRaw;
+  }
+  const out = ["---"];
+  if (hasFm) {
+    const fmText = rebuildFrontMatter(rawFm, fields);
+    if (fmText) out.push(fmText);
+  } else {
+    for (const [key, val] of Object.entries(fields || {})) {
+      if (isEmptyFm(val)) continue;
+      out.push(...formatKeyLines(key, val));
+    }
+  }
+  out.push("---");
+  const bodyText = String(body || "").replace(/^(?:\r?\n)+/, "");
+  const withNl = bodyText.endsWith("\n") ? bodyText : bodyText + "\n";
+  const gap = blankAfterFm ? "\n\n" : "\n";
+  return out.join("\n") + gap + withNl;
+}

data/studio-app/src/lib/list-controls.js

@@ -0,0 +1,317 @@
+/**
+ * Modular search + sort + pagination for Studio collection entry lists.
+ * Sort / page-size options are config-driven; render code only looks up by id.
+ */
+
+function cmpStr(a, b, dir = 1) {
+  return (
+    String(a || "").localeCompare(String(b || ""), undefined, {
+      sensitivity: "base",
+      numeric: true,
+    }) * dir
+  );
+}
+
+/** Empty dates sink to the end for both newest-first and oldest-first. */
+function cmpDate(a, b, dir = 1) {
+  const aa = String(a || "");
+  const bb = String(b || "");
+  if (!aa && !bb) return 0;
+  if (!aa) return 1;
+  if (!bb) return -1;
+  return aa.localeCompare(bb) * dir;
+}
+
+/** @typedef {{ id: string, label: string, compare: (a: object, b: object) => number }} ListSortOption */
+
+/** @type {ListSortOption[]} */
+export const LIST_SORT_OPTIONS = [
+  {
+    id: "date-desc",
+    label: "Date | newest first",
+    compare: (a, b) =>
+      cmpDate(a.date, b.date, -1) || cmpStr(a.title || a.name, b.title || b.name),
+  },
+  {
+    id: "date-asc",
+    label: "Date | oldest first",
+    compare: (a, b) =>
+      cmpDate(a.date, b.date, 1) || cmpStr(a.title || a.name, b.title || b.name),
+  },
+  {
+    id: "title-asc",
+    label: "Title | A–Z",
+    compare: (a, b) => cmpStr(a.title || a.name, b.title || b.name, 1),
+  },
+  {
+    id: "title-desc",
+    label: "Title | Z–A",
+    compare: (a, b) => cmpStr(a.title || a.name, b.title || b.name, -1),
+  },
+  {
+    id: "path-asc",
+    label: "Path | A–Z",
+    compare: (a, b) => cmpStr(a.path || a.name, b.path || b.name, 1),
+  },
+  {
+    id: "path-desc",
+    label: "Path | Z–A",
+    compare: (a, b) => cmpStr(a.path || a.name, b.path || b.name, -1),
+  },
+  {
+    id: "key-asc",
+    label: "Key | A–Z",
+    compare: (a, b) => cmpStr(a.key || a.name, b.key || b.name, 1),
+  },
+];
+
+export const DEFAULT_SORT_ID = "date-desc";
+
+/** @typedef {{ id: string, label: string, size: number | null }} ListPageSizeOption */
+
+/** `size: null` means ALL (no slice). */
+export const LIST_PAGE_SIZE_OPTIONS = [
+  { id: "10", label: "10", size: 10 },
+  { id: "20", label: "20", size: 20 },
+  { id: "30", label: "30", size: 30 },
+  { id: "all", label: "ALL", size: null },
+];
+
+export const DEFAULT_PAGE_SIZE_ID = "10";
+
+const LS_SORT_PREFIX = "studio-list-sort:";
+const LS_PAGE_SIZE_PREFIX = "studio-list-page-size:";
+
+export function sortOptionById(id) {
+  return LIST_SORT_OPTIONS.find((o) => o.id === id) || LIST_SORT_OPTIONS[0];
+}
+
+export function pageSizeOptionById(id) {
+  return (
+    LIST_PAGE_SIZE_OPTIONS.find((o) => o.id === id) || LIST_PAGE_SIZE_OPTIONS[0]
+  );
+}
+
+/** Normalize peeked tags (array, legacy string, or absent) to a string list. */
+export function itemTags(item) {
+  const raw = item?.tags;
+  if (Array.isArray(raw)) {
+    return raw.map((t) => String(t == null ? "" : t).trim()).filter(Boolean);
+  }
+  if (typeof raw === "string" && raw.trim()) return [raw.trim()];
+  return [];
+}
+
+export function filterItems(items, query) {
+  const q = String(query || "").trim().toLowerCase();
+  if (!q) return items.slice();
+  return items.filter((item) => {
+    const hay = [
+      item.title,
+      item.name,
+      item.key,
+      item.path,
+      item.date,
+      itemTags(item).join(" "),
+    ]
+      .filter(Boolean)
+      .join("\n")
+      .toLowerCase();
+    return hay.includes(q);
+  });
+}
+
+export function filterItemsByTag(items, tag) {
+  const tagQ = String(tag || "").trim().toLowerCase();
+  if (!tagQ) return items.slice();
+  return items.filter((item) =>
+    itemTags(item).some((t) => t.toLowerCase() === tagQ)
+  );
+}
+
+/** Distinct tags across items, sorted case-insensitively. */
+export function collectDistinctTags(items) {
+  const seen = new Map();
+  for (const item of items || []) {
+    for (const tag of itemTags(item)) {
+      const key = tag.toLowerCase();
+      if (!seen.has(key)) seen.set(key, tag);
+    }
+  }
+  return [...seen.values()].sort((a, b) =>
+    a.localeCompare(b, undefined, { sensitivity: "base" })
+  );
+}
+
+export function applyListControls(
+  items,
+  { query = "", sortId = DEFAULT_SORT_ID, tag = "" } = {}
+) {
+  const filtered = filterItemsByTag(filterItems(items, query), tag);
+  const opt = sortOptionById(sortId);
+  return filtered.sort((a, b) => opt.compare(a, b));
+}
+
+/**
+ * Slice a filtered+sorted list into a page.
+ * @returns {{ items: object[], page: number, pageCount: number, pageSize: number | null, total: number, from: number, to: number }}
+ */
+export function paginateItems(
+  items,
+  { pageSizeId = DEFAULT_PAGE_SIZE_ID, page = 1 } = {}
+) {
+  const opt = pageSizeOptionById(pageSizeId);
+  const total = items.length;
+  const size = opt.size;
+
+  if (size == null || size <= 0) {
+    return {
+      items: items.slice(),
+      page: 1,
+      pageCount: 1,
+      pageSize: null,
+      total,
+      from: total ? 1 : 0,
+      to: total,
+    };
+  }
+
+  const pageCount = Math.max(1, Math.ceil(total / size));
+  const safePage = Math.min(Math.max(1, Number(page) || 1), pageCount);
+  const start = (safePage - 1) * size;
+  const slice = items.slice(start, start + size);
+  return {
+    items: slice,
+    page: safePage,
+    pageCount,
+    pageSize: size,
+    total,
+    from: total ? start + 1 : 0,
+    to: start + slice.length,
+  };
+}
+
+export function loadSortPreference(collectionName, fallback = DEFAULT_SORT_ID) {
+  try {
+    const v = localStorage.getItem(LS_SORT_PREFIX + collectionName);
+    if (v && LIST_SORT_OPTIONS.some((o) => o.id === v)) return v;
+  } catch {
+    /* private mode / blocked storage */
+  }
+  return fallback;
+}
+
+export function saveSortPreference(collectionName, sortId) {
+  try {
+    localStorage.setItem(LS_SORT_PREFIX + collectionName, sortId);
+  } catch {
+    /* ignore */
+  }
+}
+
+export function loadPageSizePreference(
+  collectionName,
+  fallback = DEFAULT_PAGE_SIZE_ID
+) {
+  try {
+    const v = localStorage.getItem(LS_PAGE_SIZE_PREFIX + collectionName);
+    if (v && LIST_PAGE_SIZE_OPTIONS.some((o) => o.id === v)) return v;
+  } catch {
+    /* private mode / blocked storage */
+  }
+  return fallback;
+}
+
+export function savePageSizePreference(collectionName, pageSizeId) {
+  try {
+    localStorage.setItem(LS_PAGE_SIZE_PREFIX + collectionName, pageSizeId);
+  } catch {
+    /* ignore */
+  }
+}
+
+/**
+ * Default ledger-meta field lists when schema view.list_meta_fields is absent.
+ * Values are tree-item keys (peekMeta / yaml-only listing). Missing values skip.
+ * Filename (basename + ext) is always appended by formatEntryListMeta — do not list it here.
+ */
+export const DEFAULT_LIST_META_FIELDS = {
+  posts: ["date"],
+  articles: ["date"],
+  resources: ["category", "type", "language"],
+  bibliography: ["key"],
+  products: ["company", "start_date", "end_date"],
+  projects: ["status", "start_date", "end_date"],
+  jobs: ["company", "engagement", "start", "end"],
+};
+
+/** Fields that mean "filename" — reserved; always forced as the last segment. */
+const FILENAME_FIELD_ALIASES = new Set(["name", "filename"]);
+
+function basenameFromPath(path) {
+  const parts = String(path || "")
+    .split("/")
+    .filter(Boolean);
+  return parts.length ? parts[parts.length - 1] : "";
+}
+
+function formatMetaFieldValue(field, item) {
+  if (field === "path") {
+    const p = String(item.path || "")
+      .split("/")
+      .filter(Boolean)
+      .join(" | ");
+    return p || "";
+  }
+  const raw = item?.[field];
+  if (raw == null) return "";
+  if (Array.isArray(raw)) {
+    return raw
+      .map((v) => String(v == null ? "" : v).trim())
+      .filter(Boolean)
+      .join(", ");
+  }
+  return String(raw).trim();
+}
+
+/**
+ * Resolve configured list-meta fields for a collection.
+ * @param {{ name?: string, listMetaFields?: string[] | null } | null | undefined} collection
+ * @returns {string[]}
+ */
+export function listMetaFieldsFor(collection) {
+  if (Array.isArray(collection?.listMetaFields) && collection.listMetaFields.length) {
+    return collection.listMetaFields.map(String);
+  }
+  const name = collection?.name;
+  if (name && DEFAULT_LIST_META_FIELDS[name]) {
+    return DEFAULT_LIST_META_FIELDS[name].slice();
+  }
+  return [];
+}
+
+/**
+ * Build the ledger-meta line: configured fields joined by ` | `, filename always last.
+ * Skips empty/missing fields. Does not invent data.
+ * @param {object} item tree list item
+ * @param {{ name?: string, listMetaFields?: string[] | null } | string[] | null | undefined} collectionOrFields
+ */
+export function formatEntryListMeta(item, collectionOrFields) {
+  const fields = Array.isArray(collectionOrFields)
+    ? collectionOrFields.map(String)
+    : listMetaFieldsFor(collectionOrFields);
+
+  const parts = [];
+  for (const field of fields) {
+    if (FILENAME_FIELD_ALIASES.has(field)) continue;
+    const value = formatMetaFieldValue(field, item);
+    if (value) parts.push(value);
+  }
+
+  const filename =
+    String(item?.name || "").trim() || basenameFromPath(item?.path);
+  if (filename && parts[parts.length - 1] !== filename) {
+    parts.push(filename);
+  }
+  return parts.join(" | ");
+}

data/studio-app/src/lib/schema.js

@@ -0,0 +1,66 @@
+import yaml from "js-yaml";
+
+/** Load schema from the committed studio/schema.yml (same-origin in prod). */
+export async function loadSchema() {
+  for (const url of ["/studio/schema.yml", "./schema.yml"]) {
+    try {
+      const res = await fetch(url, { cache: "no-store" });
+      if (res.ok) {
+        const text = await res.text();
+        return normalizeSchema(yaml.load(text));
+      }
+    } catch {
+      /* try next */
+    }
+  }
+  throw new Error("Could not load studio/schema.yml");
+}
+
+function normalizeSchema(raw) {
+  const groups = [];
+  const collections = [];
+
+  function walk(nodes, groupLabel) {
+    for (const entry of nodes || []) {
+      if (!entry || typeof entry !== "object") continue;
+      if (entry.type === "group") {
+        groups.push({ name: entry.name, label: entry.label || entry.name });
+        walk(entry.items, entry.label || entry.name);
+      } else if (entry.type === "collection" || entry.type === "file") {
+        const view = entry.view || {};
+        collections.push({
+          name: entry.name,
+          label: entry.label || entry.name,
+          group: groupLabel || "Content",
+          type: entry.type,
+          path: entry.path,
+          format: entry.format || "yaml-frontmatter",
+          filename: entry.filename,
+          root_key: entry.root_key || null,
+          description: entry.description || "",
+          list: !!entry.list,
+          fields: entry.fields || [],
+          view,
+          /** @type {string[] | null} */
+          listMetaFields: Array.isArray(view.list_meta_fields)
+            ? view.list_meta_fields.map(String)
+            : null,
+          operations: entry.operations || { delete: false },
+        });
+      }
+    }
+  }
+
+  walk(raw?.content, null);
+  return { media: raw?.media || {}, groups, collections, raw };
+}
+
+export function fieldIsBody(field) {
+  const name = String(field?.name || "");
+  return (
+    field?.component === "markdown_body" ||
+    name === "body" ||
+    name.startsWith("body_") ||
+    (name === "description" && field?.component === "markdown_body")
+  );
+}

data/studio-app/src/lib/yaml-doc.js

@@ -0,0 +1,100 @@
+import yaml from "js-yaml";
+
+/** js-yaml dump options shared by Studio YAML saves. */
+export const YAML_DUMP_OPTS = {
+  lineWidth: 100,
+  noRefs: true,
+  sortKeys: false,
+};
+
+/**
+ * How a schema collection should be edited in Studio.
+ * @returns {"list"|"map"|"source"|null}
+ *   - list: root is a YAML sequence of objects (Profile contacts/education/…)
+ *   - map: root (or root_key subtree) is an object with schema fields
+ *   - source: free-form YAML — monospace editor only
+ *   - null: not a YAML collection
+ */
+export function yamlEditKind(collection) {
+  if (!collection || collection.format !== "yaml") return null;
+  if (collection.list) return "list";
+  if (collection.root_key) return "map";
+  if ((collection.fields || []).length) return "map";
+  return "source";
+}
+
+export function dumpYaml(value) {
+  const text = yaml.dump(value ?? null, YAML_DUMP_OPTS);
+  return text.endsWith("\n") ? text : text + "\n";
+}
+
+export function loadYaml(content) {
+  try {
+    return yaml.load(content);
+  } catch (err) {
+    const error = new Error(err?.message || "Invalid YAML");
+    error.cause = err;
+    throw error;
+  }
+}
+
+/** Build an empty list item from schema field defs (defaults when set). */
+export function emptyItemFromFields(fields) {
+  const item = {};
+  for (const field of fields || []) {
+    if (!field?.name || field.hidden) continue;
+    if (Object.prototype.hasOwnProperty.call(field, "default")) {
+      item[field.name] = structuredCloneSafe(field.default);
+    } else if (field.list) {
+      item[field.name] = [];
+    } else if (field.type === "boolean") {
+      item[field.name] = false;
+    } else {
+      item[field.name] = "";
+    }
+  }
+  return item;
+}
+
+function structuredCloneSafe(value) {
+  if (value == null || typeof value !== "object") return value;
+  try {
+    return structuredClone(value);
+  } catch {
+    return JSON.parse(JSON.stringify(value));
+  }
+}
+
+/**
+ * Drop empty optional scalars/arrays from a map before dump, keeping unknown keys.
+ * Empty string / null / undefined / [] are omitted for known schema fields.
+ */
+export function pruneEmptyFields(doc, fields) {
+  if (!doc || typeof doc !== "object" || Array.isArray(doc)) return doc;
+  const known = new Set((fields || []).map((f) => f.name).filter(Boolean));
+  const out = { ...doc };
+  for (const key of Object.keys(out)) {
+    if (!known.has(key)) continue;
+    const val = out[key];
+    if (val === "" || val == null) {
+      delete out[key];
+    } else if (Array.isArray(val) && val.length === 0) {
+      delete out[key];
+    }
+  }
+  return out;
+}
+
+/** Normalize a loaded YAML root into a list of plain objects. */
+export function asObjectList(doc) {
+  if (!Array.isArray(doc)) return [];
+  return doc.map((item) =>
+    item && typeof item === "object" && !Array.isArray(item) ? { ...item } : {}
+  );
+}
+
+/** Normalize a loaded YAML root into a plain object map. */
+export function asObjectMap(doc) {
+  if (doc && typeof doc === "object" && !Array.isArray(doc)) return { ...doc };
+  return {};
+}