@morphemecms/cms 0.5.0 → 0.7.0

package/src/fileTagFilter.mjs

@@ -0,0 +1,44 @@
+// Filer's filter by tag (Gallery in Media.tsx): each file's own tags from its record, the tags the filter offers (only those some file has), and the files with a tag.
+// Pure, so node --test can run it. Uses the StoredRecord type from fileRecords.mjs.
+/**
+ * @typedef {import('./fileRecords.mjs').StoredRecord} StoredRecord
+ */
+
+/**
+ * The tags of each file, keyed by file address (src). Records with no tags are left out.
+ * @param {StoredRecord[]} records
+ * @returns {Map<string, string[]>}
+ */
+export function tagIndex(records) {
+  const index = new Map();
+  for (const stored of records) {
+    if (stored.record.categories.length > 0) index.set(stored.record.src, [...stored.record.categories]);
+  }
+  return index;
+}
+
+/**
+ * The filter's choices: the tags (in their order) that some file in the index has, plus the chosen tag when it is among the tags.
+ * @template {{ value: string; label: string }} O
+ * @param {Map<string, string[]>} index
+ * @param {O[]} tags
+ * @param {string} chosen
+ * @returns {O[]}
+ */
+export function tagFilterOptions(index, tags, chosen) {
+  const used = new Set();
+  for (const list of index.values()) for (const tag of list) used.add(tag);
+  return tags.filter((option) => used.has(option.value) || option.value === chosen);
+}
+
+/**
+ * The files that have a tag, in their order. With an empty tag, all files are kept.
+ * @param {string[]} srcs
+ * @param {Map<string, string[]>} index
+ * @param {string} tag
+ * @returns {string[]}
+ */
+export function withTag(srcs, index, tag) {
+  if (tag === '') return srcs;
+  return srcs.filter((src) => index.get(src)?.includes(tag) === true);
+}

package/src/fileTagFilter.test.mjs

@@ -0,0 +1,57 @@
+// Tests for src/fileTagFilter.mjs. Run: node --test packages/editor/src/*.test.mjs
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { tagFilterOptions, tagIndex, withTag } from './fileTagFilter.mjs';
+
+/**
+ * A stored record for a file address, with its tags and removed tags.
+ * @param {string} src
+ * @param {string[]} categories
+ * @param {string[]} removed
+ * @returns {import('./fileRecords.mjs').StoredRecord}
+ */
+const rec = (src, categories, removed) => ({
+  path: `src/data/files/${src.slice(1, -5)}.json`,
+  oid: 'oid',
+  record: { src, categories, removed },
+});
+
+const TAGS = [
+  { value: 'design', label: 'Design' },
+  { value: 'seo', label: 'SEO' },
+];
+
+test('tagIndex maps a file address to its tags', () => {
+  const index = tagIndex([rec('/a.webp', ['seo'], []), rec('/b.webp', [], ['seo'])]);
+  assert.deepEqual(index, new Map([['/a.webp', ['seo']]]));
+});
+
+test('tagFilterOptions gives only the tags some file has', () => {
+  const index = new Map([['/a.webp', ['seo']]]);
+  assert.deepEqual(tagFilterOptions(index, TAGS, ''), [{ value: 'seo', label: 'SEO' }]);
+});
+
+test('tagFilterOptions adds the chosen tag when it is among the tags', () => {
+  const index = new Map([['/a.webp', ['seo']]]);
+  assert.deepEqual(tagFilterOptions(index, TAGS, 'design'), TAGS);
+});
+
+test('tagFilterOptions leaves out a chosen tag that is not among the tags', () => {
+  const index = new Map([['/a.webp', ['seo']]]);
+  assert.deepEqual(tagFilterOptions(index, TAGS, 'gone'), [{ value: 'seo', label: 'SEO' }]);
+});
+
+test('withTag keeps only the files with the tag', () => {
+  const index = new Map([['/a.webp', ['seo']]]);
+  assert.deepEqual(withTag(['/a.webp', '/b.webp'], index, 'seo'), ['/a.webp']);
+});
+
+test('withTag keeps every file when the tag is empty', () => {
+  const index = new Map([['/a.webp', ['seo']]]);
+  assert.deepEqual(withTag(['/a.webp', '/b.webp'], index, ''), ['/a.webp', '/b.webp']);
+});
+
+test('withTag gives an empty list when no file has the tag', () => {
+  const index = new Map([['/a.webp', ['seo']]]);
+  assert.deepEqual(withTag(['/b.webp'], index, 'seo'), []);
+});

package/src/fileTags.d.mts

@@ -0,0 +1,56 @@
+/**
+ * A record with no tags for a file.
+ * @param {string} src
+ * @returns {FileRecord}
+ */
+export function emptyRecord(src: string): FileRecord;
+/**
+ * The tags of a file: its own tags first, then the page's tags that were not removed from it.
+ * @param {FileRecord | undefined} record
+ * @param {string[]} pageTags
+ * @returns {string[]}
+ */
+export function tagsFor(record: FileRecord | undefined, pageTags: string[]): string[];
+/**
+ * The record with a tag added; the tag leaves `removed`.
+ * @param {FileRecord | undefined} record
+ * @param {string} src
+ * @param {string} tag
+ * @returns {FileRecord}
+ */
+export function addTag(record: FileRecord | undefined, src: string, tag: string): FileRecord;
+/**
+ * The record with a tag removed; the tag goes to `removed`.
+ * @param {FileRecord | undefined} record
+ * @param {string} src
+ * @param {string} tag
+ * @returns {FileRecord}
+ */
+export function removeTag(record: FileRecord | undefined, src: string, tag: string): FileRecord;
+/**
+ * The record with exactly these tags, in this order. Tags that leave are removed; tags that arrive are added.
+ * @param {FileRecord | undefined} record
+ * @param {string} src
+ * @param {string[]} next
+ * @returns {FileRecord}
+ */
+export function setTags(record: FileRecord | undefined, src: string, next: string[]): FileRecord;
+/**
+ * The record with its tags set to the page's tags (those not removed); `removed` is kept.
+ * @param {FileRecord | undefined} record
+ * @param {string} src
+ * @param {string[]} pageTags
+ * @returns {FileRecord}
+ */
+export function inherit(record: FileRecord | undefined, src: string, pageTags: string[]): FileRecord;
+/**
+ * True when the record holds no tags and no removed tags.
+ * @param {FileRecord} record
+ * @returns {boolean}
+ */
+export function isEmpty(record: FileRecord): boolean;
+export type FileRecord = {
+    src: string;
+    categories: string[];
+    removed: string[];
+};

package/src/fileTags.mjs

@@ -0,0 +1,100 @@
+// The tags of one file in Filer and how they change: its own tags and the tags removed from it.
+// A page's tags reach the file only when it is inserted (tagsFor). Pure; used by fileRecords.mjs and MediaTags.tsx.
+/**
+ * @typedef {{ src: string; categories: string[]; removed: string[] }} FileRecord
+ */
+
+/** @param {unknown[]} list */
+const unique = (list) => [...new Set(list.map(String))];
+
+/**
+ * A record with no tags for a file.
+ * @param {string} src
+ * @returns {FileRecord}
+ */
+export function emptyRecord(src) {
+  return { src, categories: [], removed: [] };
+}
+
+/**
+ * The tags of a file: its own tags first, then the page's tags that were not removed from it.
+ * @param {FileRecord | undefined} record
+ * @param {string[]} pageTags
+ * @returns {string[]}
+ */
+export function tagsFor(record, pageTags) {
+  const removed = record?.removed ?? [];
+  const out = unique(record?.categories ?? []);
+  for (const tag of unique(pageTags)) {
+    if (!removed.includes(tag) && !out.includes(tag)) out.push(tag);
+  }
+  return out;
+}
+
+/**
+ * The record with a tag added; the tag leaves `removed`.
+ * @param {FileRecord | undefined} record
+ * @param {string} src
+ * @param {string} tag
+ * @returns {FileRecord}
+ */
+export function addTag(record, src, tag) {
+  const categories = record?.categories ?? [];
+  return {
+    src,
+    categories: categories.includes(tag) ? [...categories] : [...categories, tag],
+    removed: (record?.removed ?? []).filter((t) => t !== tag),
+  };
+}
+
+/**
+ * The record with a tag removed; the tag goes to `removed`.
+ * @param {FileRecord | undefined} record
+ * @param {string} src
+ * @param {string} tag
+ * @returns {FileRecord}
+ */
+export function removeTag(record, src, tag) {
+  const removed = record?.removed ?? [];
+  return {
+    src,
+    categories: (record?.categories ?? []).filter((t) => t !== tag),
+    removed: removed.includes(tag) ? [...removed] : [...removed, tag],
+  };
+}
+
+/**
+ * The record with exactly these tags, in this order. Tags that leave are removed; tags that arrive are added.
+ * @param {FileRecord | undefined} record
+ * @param {string} src
+ * @param {string[]} next
+ * @returns {FileRecord}
+ */
+export function setTags(record, src, next) {
+  let current = record ?? emptyRecord(src);
+  for (const tag of current.categories) {
+    if (!next.includes(tag)) current = removeTag(current, src, tag);
+  }
+  for (const tag of next) current = addTag(current, src, tag);
+  return { src, categories: unique(next), removed: [...current.removed] };
+}
+
+/**
+ * The record with its tags set to the page's tags (those not removed); `removed` is kept.
+ * @param {FileRecord | undefined} record
+ * @param {string} src
+ * @param {string[]} pageTags
+ * @returns {FileRecord}
+ */
+export function inherit(record, src, pageTags) {
+  return { src, categories: tagsFor(record, pageTags), removed: [...(record?.removed ?? [])] };
+}
+
+/**
+ * True when the record holds no tags and no removed tags.
+ * @param {FileRecord} record
+ * @returns {boolean}
+ */
+export function isEmpty(record) {
+  return record.categories.length === 0 && record.removed.length === 0;
+}

package/src/fileTags.test.mjs

@@ -0,0 +1,127 @@
+// Tests for src/fileTags.mjs. Run: node --test packages/editor/src/*.test.mjs
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { addTag, emptyRecord, inherit, isEmpty, removeTag, setTags, tagsFor } from './fileTags.mjs';
+
+const S = '/images/uploads/2026/10/andromeda.webp';
+
+/** Fails when a record has a slug in both lists. @param {{ categories: string[]; removed: string[] }} r */
+const assertInvariant = (r) => {
+  for (const tag of r.categories) assert.ok(!r.removed.includes(tag), `${tag} is in both lists`);
+};
+
+/** A record that cannot be changed, lists included. @param {{ src: string; categories: string[]; removed: string[] }} r */
+const frozen = (r) => Object.freeze({ src: r.src, categories: Object.freeze([...r.categories]), removed: Object.freeze([...r.removed]) });
+
+test('emptyRecord has no tags', () => {
+  assert.deepEqual(emptyRecord(S), { src: S, categories: [], removed: [] });
+});
+
+test('tagsFor gives the page tags for a file without a record', () => {
+  assert.deepEqual(tagsFor(undefined, ['a', 'b']), ['a', 'b']);
+});
+
+test('tagsFor gives the record tags first, then the page tags', () => {
+  assert.deepEqual(tagsFor({ src: S, categories: ['x'], removed: [] }, ['a']), ['x', 'a']);
+});
+
+test('tagsFor does not repeat a tag the record already has', () => {
+  assert.deepEqual(tagsFor({ src: S, categories: ['a'], removed: [] }, ['a', 'b']), ['a', 'b']);
+});
+
+test('tagsFor leaves out a page tag the owner removed', () => {
+  assert.deepEqual(tagsFor({ src: S, categories: [], removed: ['a'] }, ['a', 'b']), ['b']);
+});
+
+test('tagsFor keeps the record tags even when the page has them removed', () => {
+  assert.deepEqual(tagsFor({ src: S, categories: ['x'], removed: ['a'] }, []), ['x']);
+});
+
+test('tagsFor gives each page tag once', () => {
+  assert.deepEqual(tagsFor(undefined, ['a', 'a']), ['a']);
+});
+
+test('addTag creates a record for a file without one', () => {
+  assert.deepEqual(addTag(undefined, S, 'seo'), { src: S, categories: ['seo'], removed: [] });
+});
+
+test('addTag takes a tag out of removed', () => {
+  assert.deepEqual(addTag({ src: S, categories: ['a'], removed: ['seo'] }, S, 'seo'), {
+    src: S,
+    categories: ['a', 'seo'],
+    removed: [],
+  });
+});
+
+test('addTag does nothing to a tag the file already has', () => {
+  assert.deepEqual(addTag({ src: S, categories: ['a'], removed: [] }, S, 'a'), { src: S, categories: ['a'], removed: [] });
+});
+
+test('removeTag moves a tag to removed', () => {
+  assert.deepEqual(removeTag({ src: S, categories: ['a', 'b'], removed: [] }, S, 'a'), {
+    src: S,
+    categories: ['b'],
+    removed: ['a'],
+  });
+});
+
+test('removeTag creates a record for a file without one', () => {
+  assert.deepEqual(removeTag(undefined, S, 'a'), { src: S, categories: [], removed: ['a'] });
+});
+
+test('removeTag does not repeat a tag already removed', () => {
+  assert.deepEqual(removeTag({ src: S, categories: [], removed: ['a'] }, S, 'a'), { src: S, categories: [], removed: ['a'] });
+});
+
+test('setTags moves the tags that left to removed and keeps the order of the new list', () => {
+  assert.deepEqual(setTags({ src: S, categories: ['a', 'b'], removed: ['c'] }, S, ['b', 'c']), {
+    src: S,
+    categories: ['b', 'c'],
+    removed: ['a'],
+  });
+});
+
+test('setTags with no tags on a file without a record gives an empty record', () => {
+  assert.deepEqual(setTags(undefined, S, []), { src: S, categories: [], removed: [] });
+});
+
+test('inherit adds the page tags that were not removed and keeps removed', () => {
+  assert.deepEqual(inherit({ src: S, categories: ['x'], removed: ['a'] }, S, ['a', 'b']), {
+    src: S,
+    categories: ['x', 'b'],
+    removed: ['a'],
+  });
+});
+
+test('inherit gives the page tags to a file without a record', () => {
+  assert.deepEqual(inherit(undefined, S, ['a']), { src: S, categories: ['a'], removed: [] });
+});
+
+test('isEmpty is true for a record with no tags and nothing removed', () => {
+  assert.equal(isEmpty({ src: S, categories: [], removed: [] }), true);
+});
+
+test('isEmpty is false for a record with only a removed tag', () => {
+  assert.equal(isEmpty({ src: S, categories: [], removed: ['a'] }), false);
+});
+
+test('every record result keeps categories and removed apart', () => {
+  assertInvariant(addTag({ src: S, categories: ['a'], removed: ['seo'] }, S, 'seo'));
+  assertInvariant(addTag(undefined, S, 'seo'));
+  assertInvariant(removeTag({ src: S, categories: ['a', 'b'], removed: [] }, S, 'a'));
+  assertInvariant(removeTag(undefined, S, 'a'));
+  assertInvariant(setTags({ src: S, categories: ['a', 'b'], removed: ['c'] }, S, ['b', 'c']));
+  assertInvariant(setTags(undefined, S, []));
+  assertInvariant(inherit({ src: S, categories: ['x'], removed: ['a'] }, S, ['a', 'b']));
+  assertInvariant(inherit(undefined, S, ['a']));
+});
+
+test('no function changes a frozen input record', () => {
+  const record = frozen({ src: S, categories: ['a', 'b'], removed: ['c'] });
+  assert.doesNotThrow(() => addTag(record, S, 'd'));
+  assert.doesNotThrow(() => removeTag(record, S, 'a'));
+  assert.doesNotThrow(() => setTags(record, S, ['b', 'c']));
+  assert.doesNotThrow(() => inherit(record, S, ['c', 'e']));
+  assert.doesNotThrow(() => tagsFor(record, ['c', 'e']));
+  assert.deepEqual(record, { src: S, categories: ['a', 'b'], removed: ['c'] });
+});

package/src/firstHeading.d.mts

@@ -0,0 +1,6 @@
+export function topHeadings(doc: import("@milkdown/kit/prose/model").Node): {
+    node: import("@milkdown/kit/prose/model").Node;
+    pos: number;
+}[];
+/** @type {import('@milkdown/kit/utils').$Prose} */
+export const firstHeading: import("@milkdown/kit/utils").$Prose;

package/src/firstHeading.mjs

@@ -0,0 +1,37 @@
+// On a page the first heading of the text is its H1 by itself and no later heading is: a ProseMirror plugin for Milkdown
+// that, after a change to the text, sets the levels by headingLevels (lib/heading-levels.mjs). Exposes firstHeading, which
+// MarkdownEditor.tsx uses when it gets `h1` (pages), as the round-trip check does; topHeadings reads the headings. Only top-level headings count.
+import { $prose } from '@milkdown/kit/utils';
+import { Plugin } from '@milkdown/kit/prose/state';
+import { headingLevels } from '../lib/heading-levels.mjs';
+
+/** The top-level headings of a document, with their positions.
+ * @param {import('@milkdown/kit/prose/model').Node} doc
+ * @returns {{ node: import('@milkdown/kit/prose/model').Node, pos: number }[]} */
+export const topHeadings = (doc) => {
+  const found = [];
+  doc.forEach((node, pos) => void (node.type.name === 'heading' && found.push({ node, pos })));
+  return found;
+};
+
+/** @type {import('@milkdown/kit/utils').$Prose} */
+export const firstHeading = $prose(
+  () =>
+    new Plugin({
+      appendTransaction: (transactions, _before, state) => {
+        // Only after a change the user made: not when the page is only opened, where Milkdown's own steps (the heading ids,
+        // the free lines) change the document too, but are kept out of undo (addToHistory false).
+        if (!transactions.some((tr) => tr.docChanged && tr.getMeta('addToHistory') !== false)) return null;
+        const found = topHeadings(state.doc);
+        const levels = headingLevels(found.map(({ node }) => node.attrs.level));
+        let tr = null;
+        found.forEach(({ node, pos }, i) => {
+          if (node.attrs.level === levels[i]) return;
+          // The heading keeps its size, so the positions after it stay the same.
+          tr ??= state.tr;
+          tr.setNodeMarkup(pos, undefined, { ...node.attrs, level: levels[i] });
+        });
+        return tr;
+      },
+    }),
+);

package/src/i18n/da-DK/advanced.ts

@@ -1,28 +1,43 @@
 import type { Messages } from '../en-US';
 
 export const advanced: Messages['advanced'] = {
-  r2Caching: 'R2-caching',
-  r2CachingHint: 'Workeren giver editoren hjemmesidens filer fra Cloudflare R2 og spørger kun GitHub om det, der er ændret.',
-  checking: 'Spørger Cloudflare, om R2 er klar.',
+  r2Caching: 'Hurtigere editor',
+  r2CachingHint: 'Editoren henter hjemmesidens filer hurtigere og spørger kun GitHub om det, der er ændret.',
+  checking: 'Tjekker, om Cloudflare er klar…',
   bucket: {
-    ready: (bucket, jurisdiction) => `Bucket'en ${bucket} er klar hos Cloudflare${jurisdiction ? ` i ${jurisdiction}` : ''}.`,
+    ready: (bucket, jurisdiction) => `Lageret ${bucket} er klar hos Cloudflare${jurisdiction ? ` i ${jurisdiction}` : ''}.`,
     'no-bucket': (bucket, jurisdiction) =>
-      `Kan slås til, når bucket'en ${bucket} er lavet under R2 hos Cloudflare${jurisdiction ? ` med jurisdiktionen ${jurisdiction}` : ''}.`,
+      `Kan slås til, når lageret ${bucket} er lavet under R2 hos Cloudflare${jurisdiction ? ` og ligger i ${jurisdiction}` : ''}.`,
     'no-r2': () => 'Kan slås til, når R2 er slået til hos Cloudflare.',
-    'no-key': () => 'Workeren har ingen nøgle til Cloudflare, så den kan ikke se, om R2 er slået til.',
-    refused: () => 'Cloudflare godtog ikke Workerens nøgle til R2.',
+    'no-key': () => 'Editoren har ingen nøgle til Cloudflare, så den kan ikke se, om R2 er slået til.',
+    refused: () => 'Cloudflare godtog ikke editorens nøgle til R2.',
     failed: () => 'Cloudflare svarede ikke på, om R2 er klar. Prøv igen senere.',
   },
+  builds: 'Opdatering af hjemmesiden',
+  fastContentBuilds: 'Hurtigere opdateringer af indhold',
+  fastContentBuildsHint: 'Hjemmesiden bliver opdateret hurtigere, når du kun har ændret indhold.',
+  paidBuilds: 'Workers Paid-plan',
+  paidBuildsHint: 'Slå til, når Cloudflare-kontoen har Workers Paid.',
+  plan: {
+    no: 'Kan slås til, når Cloudflare-kontoen har Workers Paid.',
+    'no-key': 'Editoren har ingen nøgle til Cloudflare, så den kan ikke se, om kontoen har Workers Paid.',
+    refused: 'Cloudflare lod ikke editorens nøgle læse kontoens plan. Nøglen skal have Billing: Read.',
+    failed: 'Cloudflare svarede ikke på, om kontoen har Workers Paid. Prøv igen senere.',
+  },
+  billing: 'Åbn betaling hos Cloudflare',
+  buildSettingsNotLoaded: (error) => `Indstillingerne for opdatering af hjemmesiden kunne ikke hentes: ${error}`,
   place: 'Placering',
-  placeHint: 'Kan kun skiftes, når R2-caching er slået fra.',
+  placeHint: 'Kan kun skiftes, når Hurtigere editor er slået fra.',
   placeAuto: 'Automatisk',
   onWhenBuilt: 'Slås til, når hjemmesiden er opdateret.',
   offWhenBuilt: 'Slås fra, når hjemmesiden er opdateret.',
-  loading: 'Henter Workerens indstillinger',
-  notLoaded: (error) => `Workerens indstillinger kunne ikke hentes: ${error}`,
-  noSettings: 'Hjemmesiden har ingen indstillinger til Workeren (wrangler.jsonc).',
-  noLine: 'Workerens indstillinger (wrangler.jsonc) har ingen linje til R2-caching.',
+  loading: 'Henter indstillingerne…',
+  notLoaded: (error) => `Indstillingerne kunne ikke hentes: ${error}`,
+  noSettings: 'Hjemmesiden har ingen indstillinger til editoren',
+  noLine: 'Hjemmesidens indstillinger har ingen plads til Hurtigere editor',
   r2CachingCommit: (on) => (on ? 'Editor: slå R2-caching til' : 'Editor: slå R2-caching fra'),
+  fastContentBuildsCommit: (on) => (on ? 'Editor: slå hurtig bygning af indhold til' : 'Editor: slå hurtig bygning af indhold fra'),
+  paidBuildsCommit: (on) => (on ? 'Editor: slå betalt bygning til' : 'Editor: slå betalt bygning fra'),
   placeCommit: (jurisdiction) =>
     jurisdiction ? `Editor: hold R2-cachingens bucket i ${jurisdiction}` : 'Editor: lad Cloudflare placere R2-cachingens bucket',
 };

package/src/i18n/da-DK/app.ts

@@ -2,10 +2,10 @@ import type { Messages } from '../en-US';
 
 export const app: Messages['app'] = {
   logIn: 'Log ind med GitHub',
-  loading: 'Henter hjemmesidens indhold',
+  loading: 'Henter hjemmesidens indhold…',
   cannotSave: (login) => `${login} har ikke adgang til at gemme. Log ind med en anden GitHub-konto under Konto.`,
   notFound: 'Findes ikke',
-  nothingAt: (route) => `Der er ikke noget på adressen ${route}.`,
+  nothingAt: (route) => `Der er ikke noget på adressen ${route}`,
   siteUpdated: (changes) => `Hjemmesiden er opdateret: ${changes}.`,
   siteNotUpdated: (changes) => `Hjemmesiden blev ikke opdateret (${changes}). Gendan den forrige version under Tidligere versioner.`,
   changes: {
@@ -35,8 +35,10 @@ export const app: Messages['app'] = {
     redirect: (from) => `videresendelse fra ${from}`,
     logo: 'logo',
     icon: 'ikon',
-    r2Caching: 'R2-caching',
+    r2Caching: 'hurtigere editor',
     place: 'placering',
+    fastContentBuilds: 'hurtigere opdateringer af indhold',
+    paidBuilds: 'Workers Paid-plan',
   },
   addressTaken: (address) => `Der findes allerede en side eller et blogindlæg med adressen ${address}.`,
   addressRedirects: (address, name) => `Adressen ${address} sender i dag besøgende videre til ${name}.`,
@@ -47,20 +49,20 @@ export const app: Messages['app'] = {
   lastSaved: (when) => `Sidst ændret ${when}`,
   notSavedYet: 'Ikke gemt endnu',
   unsavedTitle: 'Gem ændringerne?',
-  unsaved: 'Du har ændringer, der ikke er gemt.',
+  unsaved: 'Du har ændringer, der ikke er gemt',
   discard: 'Kassér',
   unsavedSheet: 'Du har ændringer, der ikke er gemt. Vil du beholde dem?',
   viewOnSite: 'Se på hjemmesiden',
   loggedOut: 'Du er blevet logget ud. Log ind igen.',
-  githubAnswered: (status) => `GitHub svarede ${status}.`,
+  githubAnswered: (status) => `GitHub svarede med fejl ${status}. Prøv igen.`,
   pictureNotLoaded: 'Billedet kunne ikke hentes fra GitHub. Tjek forbindelsen og prøv igen.',
   pictureNotWhole: 'Billedet kunne ikke hentes helt. Prøv igen.',
   changedElsewhere: 'Filen er ændret et andet sted. Kopiér din tekst, og genindlæs siden.',
   fileExists: 'Der findes allerede en fil med det navn. Prøv igen, eller vælg en anden titel.',
   pictureNotOpened: 'Billedet kunne ikke åbnes. Brug et JPEG-, PNG- eller WebP-billede.',
-  pictureNotReady: 'Billedet kunne ikke klargøres.',
+  pictureNotReady: 'Billedet kunne ikke klargøres',
   preparingPicture: 'Klargør billedet…',
-  invalidJson: 'Filen er ikke gyldig JSON.',
+  invalidJson: 'Filen er ikke gyldig JSON',
   blocksOff: 'Slået fra',
   block: 'Blok',
   appsInstalled: 'Installeret',

package/src/i18n/da-DK/apps.ts

@@ -12,7 +12,7 @@ export const apps: Messages['apps'] = {
   needsLoads: 'Henter fra andre adresser',
   needsSends: 'Sender formularer til andre adresser',
   needsServer: 'Har sin egen del af hjemmesidens server',
-  needsBuild: 'Laver sine egne filer, når hjemmesiden bygges',
+  needsBuild: 'Laver sine egne filer, når hjemmesiden opdateres',
   changes: { 'page-colors': 'Ændrer sidernes farver' },
   unknownHook: (places) => `Filen er ikke et sted, en app kan ændre hjemmesiden: ${places}.`,
   needsNothing: 'Ingen',
@@ -25,7 +25,7 @@ export const apps: Messages['apps'] = {
   developer: 'Udvikler',
   developerApps: 'Apps',
   appCount: (n) => (n === 1 ? '1 app' : `${n} apps`),
-  noDeveloper: 'Der er ingen apps fra den udvikler.',
+  noDeveloper: 'Der er ingen apps fra den udvikler',
   unknownScreenshot: (shows) =>
     `Billedet "${shows}" viser intet, appen har: blok:<type>, slags:<liste>:<variant>, liste:<id>, indstillinger eller side.`,
   noScreenshot: (file) => `${file} findes ikke. Tag billederne med npx morpheme app-screenshots.`,
@@ -35,24 +35,24 @@ export const apps: Messages['apps'] = {
   installing: 'Installerer…',
   uninstalling: 'Afinstallerer…',
   updating: 'Opdaterer…',
-  isInstalled: (app) => `${app} er installeret.`,
-  isUninstalled: (app) => `${app} er afinstalleret.`,
-  isInstalledSoon: (app) => `${app} er installeret og kan bruges, når hjemmesiden er bygget.`,
-  isUpdatedSoon: (app, version) => `${app} er opdateret til ${version} og virker sådan, når hjemmesiden er bygget.`,
+  isInstalled: (app) => `${app} er installeret`,
+  isUninstalled: (app) => `${app} er afinstalleret`,
+  isInstalledSoon: (app) => `${app} er installeret og kan bruges om et par minutter`,
+  isUpdatedSoon: (app, version) => `${app} er opdateret til ${version}. Hjemmesiden bruger den om et par minutter.`,
   askUninstall: (app) => `Afinstaller ${app}? Det, appen tilføjer, forsvinder fra editoren.`,
   activeOf: (block) => `Aktiveret: ${block}`,
   uninstallHint: 'Kan afinstalleres, fordi intet på hjemmesiden bruger appen.',
   used: 'Bruges på',
-  notUsed: 'Bruges ingen steder.',
+  notUsed: 'Bruges ingen steder',
   stuck: 'Appen bruges og kan ikke afinstalleres. Fjern den fra stederne ovenfor først.',
   blocks: 'Blokke',
   lists: 'Lister',
   settings: 'Indstillinger',
   find: 'Appstore',
   searchStore: 'Søg efter apps',
-  loadingStore: 'Henter apps',
-  storeFailed: 'Kunne ikke hente Appstore.',
-  noStore: 'Sitet har ingen Appstore.',
+  loadingStore: 'Henter apps…',
+  storeFailed: 'Kunne ikke hente Appstore',
+  noStore: 'Hjemmesiden har ingen Appstore',
   connectTitle: 'Hjemmesiden er ikke forbundet til Morpheme',
   connectText: 'Forbind den for at installere apps og temaer fra Appstore.',
   connect: 'Forbind til Morpheme',
@@ -60,8 +60,8 @@ export const apps: Messages['apps'] = {
   disconnect: 'Afbryd forbindelsen til Morpheme',
   disconnectAsk: 'Afbryd hjemmesidens forbindelse til Morpheme? Installerede apps og temaer bliver.',
   connectBusy: 'Mange hjemmesider forbinder lige nu. Prøv igen om en time.',
-  storeBroken: (app) => `${app} kunne ikke hentes rigtigt fra Appstore.`,
-  notInStore: 'Appen findes ikke i Appstore.',
+  storeBroken: (app) => `${app} kunne ikke hentes rigtigt fra Appstore`,
+  notInStore: 'Appen findes ikke i Appstore',
   categoryFilter: 'Kategori',
   allCategories: 'Alle kategorier',
   stateFilter: 'Status',
@@ -75,18 +75,18 @@ export const apps: Messages['apps'] = {
     design: 'Udseende',
   },
   version: (version) => `Version ${version}`,
-  pending: 'Installeres …',
-  pendingHint: 'Appen kan bruges, når hjemmesiden er bygget.',
+  pending: 'Installeres…',
+  pendingHint: 'Appen kan bruges om et par minutter.',
   updateFound: 'Opdatering findes',
   update: (version) => `Opdater til ${version}`,
   askUpdate: (app, version) => `Opdater ${app} til ${version}?`,
   overwrites: 'Det, der er rettet i filerne her, bliver overskrevet.',
   updateNow: 'Opdater',
-  autoUpdated: (app, version) => `${app} er opdateret til ${version}.`,
+  autoUpdated: (app, version) => `${app} er opdateret til ${version}`,
   whatsNew: 'Se, hvad der er nyt',
   breakingFound: (app, version) => `${app} ${version} findes. Den kan ødelægge noget, så den opdateres ikke af sig selv.`,
   breaking: 'Versionen har ændringer, der kan ødelægge noget.',
-  noneHere: 'Ingen installerede apps har indstillinger her.',
+  noneHere: 'Ingen installerede apps har indstillinger her',
   settingsOf: (app) => `indstillinger for ${app}`,
   missing: (id, folder) => `Appen "${id}" er installeret, men ${folder}/ findes ikke.`,
   commit: {