Changeset b406d25 in Klonkt

Timestamp:

08/09/2026 07:57:50 AM (4 weeks ago)

Author:

Robin <roboburr@…>

Branches:

main

Children:

b2adc20

Parents:

d7e72b8

Message:

Het type volgt de muziek, en de regel staat nog maar op een plek (shaer-cyg)

Robins regel zegt dat de post de soort van zijn muziek overneemt bij een enkele
insluiting. Dat deed hij nog niet: je koos het type zelf en de afleiding draaide
alleen bij de migratie. Nu verspringt de balk mee zodra je een playlist invoegt,
en zie je wat je aan het maken bent in plaats van het zelf bij te houden.

DE REGEL VERHUIST NAAR assets/js/shared/post-music-type.js. Hij wordt nu op twee
plaatsen gebruikt -- de server leidt het type van bestaande posts ermee af, de
editor laat het live volgen -- en dat MOET dezelfde regel zijn. Twee kopieen
zouden niet luidruchtig kapotgaan maar stil uit elkaar lopen: de editor zegt
album, de server zegt playlist, en niemand merkt het. De browser kan alleen bij
/assets en de server kan overal bij, dus staat hij daar en importeert
services/music hem. De module is puur: geen db, geen DOM, geen fetch -- wie hem
gebruikt levert zelf een opzoeker voor de soort van een playlist.

DRIE DINGEN DIE HIJ MET RUST LAAT. Klik je zelf een type aan, dan wint die
keuze en wordt er daarna niets meer voor je omgezet. Foto en Video zijn een
bewuste andere keuze over dezelfde post en worden nooit overschreven. En bij het
OPENEN van een post gebeurt er niets: de eerste afleiding wordt alleen als
ijkpunt onthouden, anders zou een oude post van type veranderen door hem te
bekijken.

De editor leidt af uit precies de tekst die straks wordt opgeslagen (chips terug
naar shortcodes via serializeChips), zodat hij niet iets anders ziet dan de
server. Zonder de playlist-soorten leidt de regel niets af in plaats van te
gokken.

Co-Authored-By: Claude Opus 5 <noreply@…>

Location:

src

Files:

• assets/js/mod/post-edit.js (modified) (4 diffs)
• assets/js/shared/post-music-type.js (added)
• services/music/index.js (modified) (3 diffs)

src/assets/js/mod/post-edit.js

@@ -6 +6 @@
 
 import { pageData, esc, makeSweeper } from './lib.js';
+// Dezelfde regel die de server gebruikt -- zie shared/post-music-type.js voor
+// waarom hij daar staat en niet twee keer.
+import { afleidenUitInsluitingen } from '../shared/post-music-type.js';
 
 // De oude inline scripts draaiden bij ELKE render; een module draait zijn
@@ -791 +794 @@
     }
     updateCharCount();
-  }
+    volgMuziek();
+  }
+
+  // Wordt hieronder gevuld door het typeblok. Zolang dat er niet is (of de
+  // gebruiker het type zelf koos) gebeurt er niets -- insertChip mag daar niet
+  // op stuklopen.
+  let volgMuziek = () => {};
 
   // ── Embed insert: paste a platform URL -> [[embed:url]]-chip that becomes
@@ -972 +981 @@
     const seg = card.querySelector('.pe-typeseg');
     const panels = card.querySelectorAll('.pe-type-panel');
+    let handmatig = false;   // heeft de gebruiker het type zelf aangeklikt?
 
     function applyType(tt) {
@@ -989 +999 @@
     seg.addEventListener('click', (e) => {
       const btn = e.target.closest('.pe-typeseg-btn');
-      if (btn) applyType(btn.dataset.type);
+      if (!btn) return;
+      handmatig = true;          // jouw klik wint vanaf nu van de afleiding
+      applyType(btn.dataset.type);
     });
     applyType(typeInput.value || 'post');
+
+    // ── Het type volgt de muziek (shaer-cyg) ──────────────────────
+    //
+    // Robins regel: de post neemt de soort van zijn muziek over als hij precies
+    // EEN muzikale eenheid bevat. Dus zodra je een playlist invoegt verspringt
+    // de balk mee, en zie je wat je aan het maken bent in plaats van het zelf te
+    // moeten bijhouden.
+    //
+    // TWEE DINGEN DIE HIJ MET RUST LAAT. Klik je zelf een type aan, dan wint die
+    // keuze -- daarna wordt er niets meer voor je omgezet. En Foto en Video zijn
+    // een bewuste andere keuze over dezelfde post, dus die overschrijft hij
+    // nooit, ook niet als er muziek in staat.
+    //
+    // Bij het OPENEN van een post gebeurt er niets: de eerste afleiding wordt
+    // alleen als ijkpunt onthouden. Anders zou een oude post van type veranderen
+    // door hem te bekijken.
+    const VOLGBAAR = new Set(['post', 'album', 'playlist', 'audio']);
+    const kindVan = new Map();
+    let vorigeAfleiding = null;
+
+    const soortenGeladen = fetch('/admin/playlists/api/list', { credentials: 'same-origin' })
+      .then((r) => r.json())
+      .then((j) => {
+        if (j && j.ok && Array.isArray(j.playlists)) {
+          for (const p of j.playlists) kindVan.set(p.id, p.kind === 'playlist' ? 'playlist' : 'album');
+        }
+      })
+      // Zonder de soorten leidt de regel niets af (elke playlist is dan
+      // 'onbekend'), en dat is beter dan een gok die als keuze oogt.
+      .catch(() => {})
+      .then(() => { vorigeAfleiding = afleidenNu(); });
+
+    function afleidenNu() {
+      // Precies de tekst die straks wordt opgeslagen: chips terug naar
+      // shortcodes. Zo leidt de editor af uit wat de server ook zal zien.
+      const clone = editor.cloneNode(true);
+      serializeChips(clone);
+      const r = afleidenUitInsluitingen(clone.innerHTML, (id) => kindVan.get(id) || null);
+      return r ? r.type : null;
+    }
+
+    volgMuziek = async () => {
+      await soortenGeladen;
+      const nu = afleidenNu();
+      if (nu === vorigeAfleiding) return;    // de muziek is niet van soort veranderd
+      vorigeAfleiding = nu;
+      if (handmatig || !nu) return;
+      if (!VOLGBAAR.has(typeInput.value)) return;
+      applyType(nu);
+    };
+
+    // Ook getypte of geplakte shortcodes tellen, niet alleen de knoppen.
+    let tik = null;
+    editor.addEventListener('input', () => {
+      clearTimeout(tik);
+      tik = setTimeout(volgMuziek, 300);
+    });
 
     // Video URL → [[embed:url]] chip

src/services/music/index.js

@@ -15 +15 @@
 import db from '../../config/database.js';
 import { AP_CONTEXT, PUBLIC, actorId, noteId, safeUrl, guessMediaType } from '../ap-core.js';
+import { afleidenUitInsluitingen } from '../../assets/js/shared/post-music-type.js';
 
 // m.size hoort erbij voor de RSS-enclosure: die eist een lengte in bytes.
@@ -333 +334 @@
 }
 
-// ── Welk soort muzikale uitgave is deze post? (shaer-cyg) ─────────────────
-
-/**
- * Het type van een BESTAANDE post afleiden uit de muziek die erin staat.
+// ── Welk soort muzikale uitgave is deze post? (shaer-cyg) ─────────────
+
+/**
+ * Het type van een post afleiden uit de muziek die erin staat.
+ *
+ * DE REGEL ZELF staat in assets/js/shared/post-music-type.js, want de editor
+ * gebruikt hem ook -- daar volgt het type live mee terwijl je schrijft. Twee
+ * kopieen zouden stil uit elkaar lopen, dus is er er een. Hier komt alleen het
+ * stuk bij dat de server kan en de browser niet: de gekozen soort van een
+ * playlist opzoeken.
  *
  * WAARVOOR DIT WEL EN NIET IS (Robins afbakening, 9-8). Nieuwe posts krijgen
  * hun type uit de keuze: album of playlist wordt gekozen als de playlist wordt
- * gemaakt, en de post neemt dat over. Deze functie is er voor wat er al staat --
- * de posts met type=audio uit de tijd voor die keuze bestond. Daarmee is de
- * vraag "wie wint, de keuze of de afleiding?" geen vraag meer: ze komen elkaar
- * niet tegen. De afleiding draait eenmalig, de keuze draait daarna.
- *
- * DE REGEL GAAT OVER IDENTITEIT, NIET OVER TELLEN (Robins herformulering, 9-8):
- * een post neemt het type van zijn muziek over als hij precies EEN muzikale
- * eenheid bevat. Zijn het er meer, dan is de post een post die naar muziek
- * verwijst, en houden de collecties hun eigen identiteit.
- *
- *   losse track(s)                -> playlist   metadata van de post geleend
- *   een collectie                 -> die soort  metadata van de post geleend
- *   een collectie + losse tracks  -> album      de losse zijn BONUS-TRACKS
- *   twee of meer collecties       -> post       NIETS geleend
- *
- * Waarom de lening bij de laatste vervalt: die bestaat omdat een collectie soms
- * dun is -- geen eigen hoes, geen eigen titel. Bij twee is de post niet meer de
- * drager van EEN identiteit, en vervalt de reden vanzelf. Dezelfde regel zet
- * zichzelf uit.
- *
- * EEN COLLECTIE IS EEN PLAYLIST OF EEN ALBUM-INSLUITING. Robins regel noemde
- * alleen playlists, maar [[album:naam]] groepeert net zo goed tracks en is
- * letterlijk een album; hem als losse tracks tellen zou een albumpost tot
- * playlist maken. Telt hij straks anders, dan is dat hier een regel.
- *
- * WIE KIEST ALBUM OF PLAYLIST: dat gebeurt wanneer de PLAYLIST wordt gemaakt,
- * en die keuze staat al in playlists.kind. Bij een enkele insluiting neemt de
- * post dus die soort over -- een post om een album is een album, ook al heet de
- * shortcode [[playlist:...]]. De soort van een playlist wordt hier dus
- * OPGEZOCHT en niet afgeleid.
- *
- * EN ALS WE HET NIET WETEN: een gewone post met insluitingen die de post als
- * context hebben. Dat is geen noodgreep maar de rustende toestand -- tracks
- * wijzen met `context` toch al terug naar hun post, dus er gaat niets verloren
- * als het label 'post' wordt.
+ * gemaakt, en de post neemt dat over. Op de server is dit vooral voor wat er al
+ * staat -- de posts met type=audio uit de tijd voor die keuze bestond.
  *
  * @param {string} content   de HTML/tekst van de post
@@ -380 +354 @@
  */
 export function postMusicType(content, siteId) {
-  const c = String(content || '');
-  const uniek = (re) => [...new Set([...c.matchAll(re)].map((m) => m[1].trim()))];
-
-  // Dezelfde patronen als de renderer in AudioEmbedService: wat daar niet
-  // insluit, telt hier niet mee. Anders zou een shortcode die niets oplevert
-  // wel het type van de post kunnen bepalen.
-  const playlists = uniek(/\[\[playlist:([a-z0-9][a-z0-9-]*)\]\]/gi);
-  const albums    = uniek(/\[\[album:([^\]]+)\]\]/g);
-  const tracks    = uniek(/\[\[track:([A-Za-z0-9_-]+)\]\]/g);
-
-  if (!playlists.length && !albums.length && !tracks.length) return null;
-
-  // De soort van een playlist is een gegeven, geen afleiding.
-  let onbekend = [];
-  const uitPlaylists = playlists.map((id) => {
-    const kind = playlistKind(id, siteId);
-    if (!kind) { onbekend.push(id); return null; }
-    return { soort: kind, id };
-  }).filter(Boolean);
-
-  const collecties = [
-    ...uitPlaylists,
-    ...albums.map((naam) => ({ soort: 'album', naam })),
-  ];
-
-  // Onbekende situatie -> gewone post. De insluitingen blijven staan en houden
-  // de post als context; alleen het label wordt niet verzonnen.
-  if (onbekend.length) {
-    return { type: 'post', collecties, tracks, bonus: [], onbekend, leentMetadata: false };
-  }
-
-  if (!collecties.length) {
-    // Ook EEN losse track wordt een playlist: naar buiten toe is er dan altijd
-    // een collectie om naar te wijzen. Hoe Klonkt dat toont is een aparte vraag.
-    return { type: 'playlist', collectie: null, tracks, bonus: [], leentMetadata: true };
-  }
-
-  if (collecties.length === 1) {
-    const c0 = collecties[0];
-    // Losse tracks naast een collectie zijn geen rommelrestje maar bonus-tracks,
-    // en dat maakt het geheel een album.
-    if (tracks.length) return { type: 'album', collectie: c0, tracks: [], bonus: tracks, leentMetadata: true };
-    return { type: c0.soort, collectie: c0, tracks: [], bonus: [], leentMetadata: true };
-  }
-
-  return { type: 'post', collecties, tracks, bonus: [], leentMetadata: false };
+  return afleidenUitInsluitingen(content, (id) => playlistKind(id, siteId));
 }