@morphemecms/cms 0.0.0-stage → 0.1.0

package/defaults/rules.ts

@@ -0,0 +1,450 @@
+// The site's own rules for the editor: the lists the fields that pick something choose from (a page, a
+// post, a tag, a testimonial), the prices and testimonials the blocks show, and why an entry cannot be
+// deleted (something on the site uses it). The messages are shown in the editor's language (siteText,
+// texts.ts).
+import type { RepoFile } from '../src/github';
+import type { Option, PageState, TestimonialRow } from '../src/fields';
+import type { Status } from '../src/FormFrame';
+import { blocksIn } from '../lib/blocks.mjs';
+import { readFields, splitFrontmatter } from '../src/frontmatter.mjs';
+import { siteText } from '../src/i18n';
+import { byText, fixedName, slugOf, type Collection, type Relation } from '../src/schema';
+import { collections } from '@site/collections';
+import { config } from '@site/config';
+import { opensOf } from '@site/opens';
+import { differentPages, standardPages, standardPaths } from '@site/standardPages';
+
+const fm = (file: RepoFile) => readFields(splitFrontmatter(file.text).yaml);
+// A page's address: `path`, or /<file name>/ for pages made in the editor.
+const pagePath = (f: RepoFile) => String(fm(f).path ?? `/${slugOf(f.path, config.folders.pages)}/`);
+const isPage = (f: RepoFile) => f.path.startsWith(`${config.folders.pages}/`) && f.path.endsWith('.md');
+// The addresses of the standard pages, by their key ("Indstillinger" › "Udseende" › "Standardsider", standardPages.ts).
+const standardOf = (files: { path: string; text: string }[]) => standardPaths(files.find((f) => f.path === config.standardPages)?.text);
+// The page that is a standard page (the front page: 'front'), if it is there.
+const standardFile = (files: RepoFile[], key: string) => {
+  const path = standardOf(files)[key];
+  return path ? files.find((f) => isPage(f) && pagePath(f) === path) : undefined;
+};
+// Where a page is shown: the front page at /, the blog page at /blog/, the others at their own address.
+const shownAt = (path: string, files: { path: string; text: string }[]) => {
+  const paths = standardOf(files);
+  return standardPages.find((p) => p.at && paths[p.key] === path)?.at ?? path;
+};
+const json = (file: RepoFile) => JSON.parse(file.text) as Record<string, unknown>;
+const byLabel = (a: Option, b: Option) => byText(a.label, b.label);
+// A page's or post's status (packages/editor/lib/status.mjs), for the filter of the sheet it is picked in (usePickTools).
+const stateOf = (f: RepoFile): PageState => {
+  const s = fm(f).status;
+  return s === 'draft' || s === 'unlisted' || s === 'scheduled' ? s : 'published';
+};
+// The addresses the menu (config.menu) links to, at every level, without a part of a page (#…).
+type MenuEntry = { href: string; children?: MenuEntry[] };
+function menuAddresses(files: RepoFile[]): Set<string> {
+  let entries: MenuEntry[] = [];
+  try {
+    entries = JSON.parse(files.find((f) => f.path === config.menu)?.text ?? '{}').items ?? [];
+  } catch {}
+  const all = (e: MenuEntry[]): string[] => e.flatMap((x) => [String(x.href ?? '').replace(/#.*/, ''), ...all(x.children ?? [])]);
+  return new Set(all(entries));
+}
+
+// The choices for the fields that pick a page, a post, a category or a testimonial.
+export function relationsOf(files: RepoFile[]): Record<Relation, Option[]> {
+  const inFolder = (folder: string, ext: string) => files.filter((f) => f.path.startsWith(`${folder}/`) && f.path.endsWith(ext));
+  // A standard page is in the menu by its own address or where it is shown (the front page at /, the blog page at /blog/).
+  const menu = menuAddresses(files);
+  const page = (f: RepoFile): Option => ({
+    value: pagePath(f),
+    label: String(fm(f).title),
+    state: stateOf(f),
+    inMenu: menu.has(pagePath(f)) || menu.has(shownAt(pagePath(f), files)),
+  });
+  return {
+    // Pages are stored by their address: `path`, or /<file name>/ for pages made in the editor.
+    pages: inFolder(config.folders.pages, '.md').map(page).sort(byLabel),
+    // The pages that can be a standard page ("Indstillinger" › "Udseende" › "Standardsider"): those on the site, not a
+    // draft, one waiting for its time or a new version of a page (/ny/).
+    standardPages: inFolder(config.folders.pages, '.md')
+      .filter((f) => !['draft', 'scheduled'].includes(String(fm(f).status ?? '')) && !pagePath(f).startsWith('/ny/'))
+      .map(page)
+      .sort(byLabel),
+    // The front page (/) and the blog (/blog/), whichever pages they are, the blog by its page's title.
+    fixed: [
+      { value: '/', label: siteText('Forside'), inMenu: menu.has('/') },
+      {
+        value: '/blog/',
+        label: String((standardFile(files, 'blog') && fm(standardFile(files, 'blog')!).title) || siteText('Blog')),
+        inMenu: menu.has('/blog/'),
+      },
+    ],
+    blog: inFolder(config.folders.blog, '.md')
+      .map((f) => ({
+        value: slugOf(f.path, config.folders.blog),
+        label: String(fm(f).title),
+        state: stateOf(f),
+        date: String(fm(f).date ?? ''),
+      }))
+      .sort(byLabel),
+    categories: inFolder('src/data/categories', '.json')
+      .map((f) => ({ value: slugOf(f.path, 'src/data/categories'), label: String(json(f).name) }))
+      .sort(byLabel),
+    testimonials: inFolder('src/data/testimonials', '.json')
+      .map((f) => ({ value: slugOf(f.path, 'src/data/testimonials'), label: String(json(f).name) }))
+      .sort(byLabel),
+    // The promotions turned on that a button can open ("Knapper": "Åbn promovering", opens.ts), by what opens with
+    // the promotion's name ("Bookingarket (Calendly bookingark)"), where they are shown (a button offers those on its
+    // page) and the button's text: a pop-up's heading, or that of the target it stands for ("Book en tid").
+    promotions: inFolder('src/data/popups', '.json')
+      .flatMap((f) => {
+        const d = json(f);
+        const opens = opensOf(d.type ? String(d.type) : undefined);
+        if (!opens || d.enabled === false) return [];
+        const name = String(d.heading ?? d.name ?? '');
+        return [
+          {
+            value: slugOf(f.path, 'src/data/popups'),
+            label: siteText('{hvad} ({navn})', { hvad: siteText(opens.label), navn: name }),
+            on: { everywhere: d.where === 'all', pages: d.where !== 'tags' && Array.isArray(d.pages) ? d.pages.map(String) : [] },
+            ...(opens.as ? { as: opens.as } : { text: String(d.heading ?? '') }),
+          },
+        ];
+      })
+      .sort(byLabel),
+    // The PDFs in "Filer", by their address on the site (/filer/<name>.pdf), named by their file name.
+    files: inFolder(config.folders.files, '.pdf')
+      .map((f) => ({ value: f.path.replace(/^public/, ''), label: f.path.split('/').pop()! }))
+      .sort(byLabel),
+  };
+}
+
+const frontPage = (files: RepoFile[]) => ({
+  to: standardFile(files, 'front')?.path ?? config.standardPages,
+  text: siteText('Rediger forsiden'),
+});
+
+// Where a button that opens a promotion is: a page (`path`), the shared buttons (on any page: neither), or an action bar
+// (`bar`: the pages it is shown on, or none for every page or the posts with its tags).
+type Opener = { file: string; title: string; path?: string; bar?: { pages?: string[] } };
+
+// The buttons that open a promotion ("Knapper": "Åbn promovering", the button's `open`), where they are: the page with
+// the block (its file, title and the address it is shown at: the front page's /), the shared buttons
+// ("Standardblokke" › "Knapper", on any page: no address), or an action bar ("Promovering").
+function openersOf(slug: string, files: { path: string; text: string }[]): Opener[] {
+  const opens = (items: unknown) =>
+    Array.isArray(items) &&
+    items.some(
+      (b) =>
+        (b as Record<string, unknown>)?.type !== 'text' &&
+        (b as Record<string, unknown>)?.to === 'promotion' &&
+        (b as Record<string, unknown>).open === slug,
+    );
+  const found: Opener[] = [];
+  for (const f of files) {
+    if (f.path.startsWith(`${config.folders.pages}/`) && f.path.endsWith('.md')) {
+      // Also a "Knapper" block in a block's text (a "Banner"'s), where its quotes are written as &quot;.
+      if (!/data-block=(?:"|\\&quot;)buttons/.test(f.text)) continue;
+      const d = fm(f as RepoFile);
+      if (
+        blocksIn(f.text, true).some((b: { type: string; props: Record<string, unknown> }) => b.type === 'buttons' && opens(b.props.items))
+      )
+        found.push({ file: f.path, title: String(d.title ?? ''), path: shownAt(pagePath(f as RepoFile), files) });
+    } else if (f.path.startsWith('src/data/popups/') && f.path.endsWith('.json')) {
+      const d = json(f as RepoFile);
+      if (d.type === 'bookingbar' && d.enabled !== false && opens(d.buttons))
+        found.push({
+          file: f.path,
+          title: siteText('Handlingslinje'),
+          bar: { pages: d.where === 'all' || d.where === 'tags' ? undefined : Array.isArray(d.pages) ? d.pages.map(String) : [] },
+        });
+    } else if (f.path === config.blockTexts) {
+      if (opens((json(f as RepoFile).buttons as Record<string, unknown> | undefined)?.items))
+        found.push({ file: 'blokke/buttons', title: siteText('Standardknapper') });
+    }
+  }
+  return found;
+}
+
+// Whether a promotion as it is (or is about to be saved) is shown where a button opens it: turned on, of a kind a button
+// can open, and on every page, or on the button's page (the shared buttons are on any page), or on every page the
+// action bar is on.
+function shownFor(d: Record<string, unknown>, at: Opener) {
+  if (d.enabled === false || !opensOf(d.type ? String(d.type) : undefined)) return false;
+  if (d.where === 'all') return true;
+  const pages = d.where !== 'tags' && Array.isArray(d.pages) ? d.pages.map(String) : [];
+  if (at.bar) return !!at.bar.pages && at.bar.pages.every((p) => pages.includes(p));
+  return !!at.path && pages.includes(at.path);
+}
+
+const openerText = (at: Opener) =>
+  at.bar
+    ? siteText(
+        'En knap i handlingslinjen åbner promoveringen, så den skal være slået til og vises alle steder, hvor linjen vises. Ret knappen først.',
+      )
+    : at.path
+      ? siteText('En knap på siden "{side}" åbner promoveringen, så den skal være slået til og vises dér. Ret knappen først.', {
+          side: at.title,
+        })
+      : siteText('Standardknapperne åbner promoveringen, så den skal være slået til og vises på alle sider. Ret dem først.');
+const openerEdit = (at: Opener) => ({
+  to: at.file,
+  text: siteText(at.bar ? 'Rediger handlingslinjen' : at.path ? 'Rediger siden' : 'Rediger standardknapperne'),
+});
+
+/** Why a promotion cannot be saved like this (turned off, or no longer shown on a page where a button opens it,
+ * "Knapper": "Åbn promovering"), with a link to the button, or the standard pages (the same page twice, or a page
+ * without the block it must have, with a link to it), or null. Before it is saved (DataForm.tsx; the standard pages in
+ * CompanyForm.tsx, without a collection). */
+export function keptBy(collection: Collection | null, path: string, data: Record<string, unknown>, files: RepoFile[]): Status {
+  if (path === config.standardPages) return standardKept(data, files);
+  if (collection?.kind !== 'folder' || collection.id !== 'popups') return null;
+  const at = openersOf(slugOf(path, collection.folder), files).find((o) => !shownFor(data, o));
+  return at ? { text: openerText(at), error: true, edit: openerEdit(at) } : null;
+}
+
+// The standard pages as they are about to be saved: different pages (the cookie policy may be the privacy policy), each
+// with the block it must have.
+function standardKept(data: Record<string, unknown>, files: RepoFile[]): Status {
+  const chosen = standardPages.map((p) => ({ ...p, path: String(data[p.key] ?? '') })).filter((p) => p.path);
+  if (!differentPages(Object.fromEntries(chosen.map((p) => [p.key, p.path]))))
+    return { text: siteText('Standardsiderne skal være forskellige sider.'), error: true };
+  for (const p of chosen) {
+    const page = files.find((f) => isPage(f) && pagePath(f) === p.path);
+    if (!p.needs || !page || blocksIn(page.text).some((b: { type: string }) => b.type === p.needs!.type)) continue;
+    return {
+      text: siteText('Siden "{side}" har ikke blokken {blok}, som {hvad} skal have. Sæt den ind på siden først.', {
+        side: String(fm(page).title),
+        blok: siteText(p.needs.label),
+        hvad: siteText(p.the).toLowerCase(),
+      }),
+      error: true,
+      edit: { to: page.path, text: siteText('Rediger siden') },
+    };
+  }
+  return null;
+}
+
+/** What is wrong on the site by its own rules, a line for each, before it is built (checkSite.ts): a standard page that
+ * is not a page on the site, or the same page twice, and a button that opens a promotion that is gone, turned off or not
+ * shown on its page. */
+export function siteProblems(files: { path: string; text: string }[]): string[] {
+  const problems: string[] = [];
+  // The standard pages are pages on the site ("Indstillinger" › "Udseende" › "Standardsider"), different ones (but for
+  // the cookie policy, which may be the privacy policy).
+  if (files.some((f) => f.path === config.standardPages)) {
+    for (const p of standardPages) {
+      const page = standardFile(files as RepoFile[], p.key);
+      if (!page || ['draft', 'scheduled'].includes(String(fm(page).status ?? '')))
+        problems.push(`${config.standardPages}: ${siteText('{side} skal være en side, der er udgivet.', { side: siteText(p.the) })}`);
+    }
+    if (!differentPages(standardOf(files)))
+      problems.push(`${config.standardPages}: ${siteText('Standardsiderne skal være forskellige sider.')}`);
+  }
+  const promotions = files.filter((f) => f.path.startsWith('src/data/popups/') && f.path.endsWith('.json'));
+  const slugs = new Set<string>();
+  for (const f of files) for (const m of f.text.matchAll(/(?:&quot;|")open(?:&quot;|"):\s*(?:&quot;|")([^"&]+)/g)) slugs.add(m[1]);
+  for (const slug of slugs) {
+    const file = promotions.find((f) => slugOf(f.path, 'src/data/popups') === slug);
+    for (const at of openersOf(slug, files)) {
+      if (file && shownFor(json(file as RepoFile), at)) continue;
+      problems.push(
+        `${at.file.startsWith('blokke/') ? config.blockTexts : at.file}: ${
+          file ? openerText(at) : siteText('En knap åbner promoveringen "{navn}", som ikke findes.', { navn: slug })
+        }`,
+      );
+    }
+  }
+  return problems;
+}
+
+// The tags a promotion is shown on the posts of (Promovering, "Vises på": "Blogindlæg med tags").
+const promotionTags = (d: Record<string, unknown>): string[] => (d.where === 'tags' && Array.isArray(d.tags) ? d.tags.map(String) : []);
+
+// Why an entry cannot be deleted (something on the site uses it), with a link to where, or null.
+export function usedBy(collection: Collection, file: RepoFile, files: RepoFile[]): Status {
+  if (collection.kind === 'files') return null;
+  const slug = slugOf(file.path, collection.folder);
+  // A promotion a button opens ("Knapper": "Åbn promovering").
+  if (collection.id === 'popups') {
+    const [at] = openersOf(slug, files);
+    if (at)
+      return {
+        text: at.bar
+          ? siteText('En knap i handlingslinjen åbner promoveringen. Ret knappen først.')
+          : at.path
+            ? siteText('En knap på siden "{side}" åbner promoveringen. Ret knappen først.', { side: at.title })
+            : siteText('Standardknapperne åbner promoveringen. Ret dem først.'),
+        error: true,
+        edit: openerEdit(at),
+      };
+  }
+  const home = standardFile(files, 'front');
+  const front = Object.fromEntries(
+    (home ? (blocksIn(home.text) as { type: string; props: Record<string, unknown> }[]) : []).map((b) => [b.type, b.props]),
+  );
+  if (collection.id === 'kategorier') {
+    const posts = files.filter(
+      (f) => f.path.startsWith(`${config.folders.blog}/`) && ((fm(f).categories as string[]) ?? []).includes(slug),
+    );
+    if (posts.length)
+      return {
+        text:
+          posts.length === 1
+            ? siteText('Tagget bruges på et blogindlæg. Fjern det fra det først.')
+            : siteText('Tagget bruges på {antal} blogindlæg. Fjern det fra dem først.', { antal: posts.length }),
+        error: true,
+      };
+    const quotes = files.filter(
+      (f) => f.path.startsWith('src/data/testimonials/') && ((json(f).categories as string[] | undefined) ?? []).includes(slug),
+    );
+    if (quotes.length)
+      return {
+        text:
+          quotes.length === 1
+            ? siteText('Tagget bruges på en udtalelse. Fjern det fra den først.')
+            : siteText('Tagget bruges på {antal} udtalelser. Fjern det fra dem først.', { antal: quotes.length }),
+        error: true,
+      };
+    // A promotion shown on the posts with the tag (Promovering, "Blogindlæg med tags").
+    const promotion = files.find(
+      (f) => f.path.startsWith('src/data/popups/') && f.path.endsWith('.json') && promotionTags(json(f)).includes(slug),
+    );
+    if (promotion) {
+      const d = json(promotion);
+      return {
+        text: siteText('Tagget bruges i promoveringen "{navn}". Fjern det fra den først.', { navn: String(d.heading ?? d.name ?? '') }),
+        error: true,
+        edit: { to: promotion.path, text: siteText('Rediger promoveringen') },
+      };
+    }
+    const fp = front.posts as Record<string, unknown> | undefined;
+    if ((fp?.categories as string[] | undefined)?.includes(slug) || fp?.link === slug)
+      return {
+        text: siteText('Tagget vælger indlæggene på forsiden under "Fra bloggen". Vælg et andet først.'),
+        error: true,
+        edit: frontPage(files),
+      };
+  }
+  if (collection.id === 'blog' && ((front.posts as Record<string, unknown>)?.picked as string[])?.includes(slug))
+    return {
+      text: siteText('Indlægget er valgt til forsiden under "Fra bloggen". Vælg et andet først.'),
+      error: true,
+      edit: frontPage(files),
+    };
+  // A "Blogindlæg" block in a page that picks the post (its props are in the text).
+  if (collection.id === 'blog') {
+    const page = files.find(
+      (f) =>
+        f.path.startsWith(`${config.folders.pages}/`) && f.text.includes('data-block="posts"') && f.text.includes(`&quot;${slug}&quot;`),
+    );
+    if (page)
+      return {
+        text: siteText('Indlægget er valgt i en blok med blogindlæg på siden "{side}". Vælg et andet først.', {
+          side: String(fm(page).title),
+        }),
+        error: true,
+        edit: { to: page.path, text: siteText('Rediger siden') },
+      };
+  }
+  // Any other place under "Bruges på" (usesOf): a "Blogindlæg" or "Udtalelser" block that picks the tag, on a
+  // page or in a post.
+  if (collection.id === 'kategorier') {
+    const use = usesOf(collection, files)(file)[0];
+    if (use) {
+      const post = use.path.startsWith(`${config.folders.blog}/`);
+      return {
+        text: siteText(
+          post
+            ? 'Tagget er valgt i en blok i blogindlægget "{side}". Vælg et andet først.'
+            : 'Tagget er valgt i en blok på siden "{side}". Vælg et andet først.',
+          { side: use.name },
+        ),
+        error: true,
+        edit: { to: use.path, text: siteText(post ? 'Rediger indlægget' : 'Rediger siden') },
+      };
+    }
+  }
+  return null;
+}
+
+// What a file that uses something is called: a page's or post's title, a setting's name, an entry's
+// as its list shows it.
+function nameOf(file: RepoFile): string {
+  for (const c of collections)
+    if (c.kind === 'files') {
+      const own = c.files.find((f) => f.file === file.path);
+      if (own) return fixedName({ ...own, label: siteText(own.label) }, file.text);
+    } else if (c.kind === 'folder' && file.path.startsWith(`${c.folder}/`) && file.path.endsWith('.json'))
+      return c.summary(json(file)) || siteText(c.label);
+  return String(fm(file).title ?? file.path);
+}
+
+export type Use = { path: string; name: string };
+
+// The places on the site that use an entry, by the entry's file, each once (the tag's "Bruges på", DataForm.tsx,
+// and the number at it in its list, Library.tsx); [] for none. For a tag: the blog posts, testimonials and
+// promotions that have it, and the pages and posts with a "Blogindlæg" or "Udtalelser" block that
+// picks it (its tags, or the tag "Alle indlæg" goes to). Made once for the whole list.
+export function usesOf(collection: Collection, files: RepoFile[]): (file: RepoFile) => Use[] {
+  if (collection.kind === 'files' || collection.id !== 'kategorier') return () => [];
+  const uses = tagUses(files);
+  return (file) =>
+    [...(uses.get(slugOf(file.path, collection.folder))?.values() ?? [])]
+      .map((f) => ({ path: f.path, name: nameOf(f) }))
+      .sort((a, b) => byText(a.name, b.name));
+}
+
+// The files that use each tag (usesOf), by the tag, each file once.
+function tagUses(files: RepoFile[]): Map<string, Map<string, RepoFile>> {
+  const uses = new Map<string, Map<string, RepoFile>>();
+  const add = (f: RepoFile, slugs: unknown) => {
+    for (const slug of Array.isArray(slugs) ? slugs.map(String) : []) {
+      if (!uses.has(slug)) uses.set(slug, new Map());
+      uses.get(slug)!.set(f.path, f);
+    }
+  };
+  const block = (f: RepoFile, type: unknown, props: Record<string, unknown>) => {
+    if (type === 'posts' || type === 'testimonials')
+      add(f, [...(Array.isArray(props.categories) ? props.categories : []), ...(props.link ? [props.link] : [])]);
+  };
+  const inFolder = (f: RepoFile, folder: string, ext: string) => f.path.startsWith(`${folder}/`) && f.path.endsWith(ext);
+  for (const f of files) {
+    if (inFolder(f, config.folders.blog, '.md') || inFolder(f, config.folders.pages, '.md')) {
+      if (inFolder(f, config.folders.blog, '.md')) add(f, fm(f).categories);
+      for (const b of blocksIn(f.text) as { type: string; props: Record<string, unknown> }[]) block(f, b.type, b.props);
+    } else if (inFolder(f, 'src/data/testimonials', '.json')) add(f, json(f).categories);
+    else if (inFolder(f, 'src/data/popups', '.json')) add(f, promotionTags(json(f)));
+  }
+  return uses;
+}
+
+// The number at the right of an entry in the list of a part, by the entry's file, or null for none
+// (Library.tsx): at each tag, the number of places that use it (usesOf).
+export function countsOf(collection: Collection, files: RepoFile[]): (file: RepoFile) => number | null {
+  if (collection.kind === 'files' || collection.id !== 'kategorier') return () => null;
+  const uses = tagUses(files);
+  return (file) => uses.get(slugOf(file.path, collection.folder))?.size ?? 0;
+}
+
+// The testimonials, in their order on the site, for the cards and previews of the blocks.
+export const testimonialsOf = (files: RepoFile[]) =>
+  files
+    .filter((f) => f.path.startsWith('src/data/testimonials/') && f.path.endsWith('.json'))
+    .map((f) => ({ ...(json(f) as TestimonialRow & { order?: number }), slug: slugOf(f.path, 'src/data/testimonials') }))
+    .sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+
+/** What is at an address, as said in a message: "forsiden", 'siden "Om mig" (/om-mig/)',
+ * or the address (where a redirect sends to, App.tsx). */
+export function whatIsAt(address: string, relations: Record<Relation, Option[]>): string {
+  const base = address.split('#')[0];
+  if (base === '/') return siteText('forsiden');
+  if (base === '/blog/') return siteText('bloggen');
+  const page = [...relations.fixed, ...relations.pages].find((o) => o.value === base);
+  if (page) return siteText('siden "{navn}" ({adresse})', { navn: page.label, adresse: address });
+  const post = relations.blog.find((o) => `/${o.value}/` === base);
+  if (post) return siteText('blogindlægget "{navn}" ({adresse})', { navn: post.label, adresse: address });
+  const tag = relations.categories.find((o) => `/blog/kategori/${o.value}/` === base);
+  if (tag) return siteText('tagget "{navn}" på bloggen ({adresse})', { navn: tag.label, adresse: address });
+  if (base.startsWith(config.folders.media.replace(/^public/, '') + '/'))
+    return siteText('billedet {navn}', { navn: base.split('/').pop()! });
+  return address;
+}

package/defaults/schema.ts

@@ -0,0 +1,16 @@
+// What the structured data (schema.org JSON-LD, packages/editor/site/schema.ts) says of a site beyond its contact
+// details, when the site's src/site/schema.ts does not say more: a local business in the country of the site's
+// language, without terms, an area, offers or a person behind it. Only facts that are on the site; no ratings or reviews.
+import { config } from '@site/config';
+import type { SiteSchema } from '../site/schema';
+
+export const schema: SiteSchema = {
+  ids: { business: 'virksomhed', person: 'person' },
+  businessType: 'LocalBusiness',
+  country: config.locale.split('-')[1] ?? 'DK',
+  terms: {},
+  areaServed: [],
+  offers: null,
+  person: null,
+  aboutPath: config.aboutPath ?? null,
+};

package/defaults/sitedata.ts

@@ -0,0 +1,129 @@
+// What the previews of the blocks (src/apps/<app>/blocks/, previews.tsx) show from elsewhere on the site, from the files
+// as the editor has them now: the pages (their titles and texts, for the topics and the services),
+// the blog posts, the phone, e-mail and address (contact.json), the payment details (payment.json) and
+// the texts of the "Book en tid" box (booking.json), the settings of the apps (src/apps/) and the cookie list.
+import type { RepoFile } from '../src/github';
+import type { StandardSiteData } from '../src/standard/site';
+import { categoryOf } from '../lib/cookieCategories.mjs';
+import { readFields, splitFrontmatter } from '../src/frontmatter.mjs';
+import { readingMinutes } from '../site/format';
+import { stateOf } from '../lib/status.mjs';
+import { blockTexts } from '../site/site';
+import { config } from '@site/config';
+
+export type SitePage = { path: string; title: string; body: string };
+export type SitePost = {
+  slug: string;
+  title: string;
+  date: Date;
+  image?: string;
+  imageAlt?: string;
+  description?: string;
+  categories: string[];
+  minutes: number;
+};
+export type SiteData = {
+  pages: SitePage[];
+  /** The posts on the blog (only published ones, packages/editor/lib/status.mjs), newest first. */
+  posts: SitePost[];
+  contact: { name: string; role: string; phone: string; email: string; street: string; city: string };
+  /** The bank details, and what else the site keeps in payment.json (a site's other ways to pay). */
+  payment: { bank: string; reg: string; account: string } & Record<string, string>;
+  booking: { heading: string; text: string };
+  /** The labels of the buttons "Book en tid" and "Ring …" (booking.json). */
+  labels: { book: string; call: string };
+  /** The texts every copy of a block has (its shared.ts, saved in blocks.json). */
+  blocks: BlockTexts;
+  /** The texts of the buttons of "Knapper" that go elsewhere than a page (config.buttonTargets). */
+  buttons: StandardSiteData['buttons'];
+  /** The tags not shown on the blog ("Blogkategori" off, packages/editor/site/categories.ts). */
+  tagsOffBlog: string[];
+  /** The settings of the apps as saved (config.apps.settings), by the app's id; an app's blocks put
+   * them over those in its settings.ts. */
+  apps: Record<string, Record<string, unknown>>;
+  /** The ids of the apps installed (config.apps.installed). */
+  installed: string[];
+  /** The cookie list ("Cookies", config.cookieList). */
+  cookies: StandardSiteData['cookies'];
+};
+
+export type BlockTexts = typeof blockTexts;
+
+const text = (v: unknown) => (v == null ? '' : String(v));
+
+export function siteOf(files: RepoFile[]): SiteData {
+  const md = (folder: string) =>
+    files
+      .filter((f) => f.path.startsWith(`${folder}/`) && f.path.endsWith('.md'))
+      .map((f) => {
+        const { yaml, body } = splitFrontmatter(f.text);
+        return { file: f.path.slice(folder.length + 1, -3), data: readFields(yaml) as Record<string, unknown>, body };
+      });
+  const json = (path: string) => {
+    const file = files.find((f) => f.path === path);
+    return (file ? JSON.parse(file.text) : {}) as Record<string, any>;
+  };
+  const contact = json('src/data/contact.json');
+  const payment: Record<string, unknown> = json('src/data/payment.json') ?? {};
+  const booking = json('src/data/booking.json');
+  return {
+    pages: md('src/content/pages').map(({ file, data, body }) => ({
+      path: text(data.path) || `/${file.replace(/\/index$/, '')}/`,
+      title: text(data.title),
+      body,
+    })),
+    posts: md('src/content/blog')
+      .filter(({ data }) => stateOf(data) === 'published')
+      .map(({ file, data, body }) => ({
+        slug: file,
+        title: text(data.title),
+        date: new Date(text(data.date)),
+        image: text(data.image) || undefined,
+        imageAlt: (data.imageDecorative !== true && text(data.imageAlt)) || undefined,
+        description: text(data.description) || undefined,
+        categories: Array.isArray(data.categories) ? data.categories.map(String) : [],
+        minutes: readingMinutes(body),
+      }))
+      .sort((a, b) => b.date.valueOf() - a.date.valueOf()),
+    contact: {
+      name: text(contact.name),
+      role: text(contact.role),
+      phone: text(contact.phone),
+      email: text(contact.email),
+      street: text(contact.street),
+      city: text(contact.city),
+    },
+    payment: {
+      ...Object.fromEntries(Object.entries(payment).map(([k, v]) => [k, text(v)])),
+      bank: text(payment.bank),
+      reg: text(payment.reg),
+      account: text(payment.account),
+    },
+    booking: { heading: text(booking.heading), text: text(booking.text) },
+    labels: { book: text(booking.book), call: text(booking.call) },
+    tagsOffBlog: files
+      .filter((f) => f.path.startsWith('src/data/categories/') && f.path.endsWith('.json') && JSON.parse(f.text).blogCategory === false)
+      .map((f) => f.path.slice('src/data/categories/'.length, -'.json'.length)),
+    apps: Object.fromEntries(
+      files
+        .filter((f) => f.path.startsWith(`${config.apps.settings}/`) && f.path.endsWith('.json'))
+        .map((f) => [f.path.slice(config.apps.settings.length + 1, -'.json'.length), json(f.path)]),
+    ),
+    installed: ((json(config.apps.installed).installed ?? []) as unknown[]).map(String),
+    cookies: files
+      .filter((f) => f.path.startsWith(`${config.cookieList}/`) && f.path.endsWith('.json'))
+      .map((f) => json(f.path))
+      .map((c) => ({
+        name: text(c.name),
+        provider: text(c.provider),
+        purpose: text(c.purpose) || undefined,
+        lasts: text(c.lasts) || undefined,
+        category: categoryOf(c),
+      })),
+    buttons: { booking: { text: text(booking.book) }, phone: { text: text(booking.call), after: text(contact.phone) } },
+    // As the file has them now, each text falling back on the site's (a text not in the file yet).
+    blocks: Object.fromEntries(
+      Object.entries(blockTexts).map(([block, texts]) => [block, { ...texts, ...(json(config.blockTexts)[block] ?? {}) }]),
+    ) as BlockTexts,
+  };
+}