update

Author: monapdx

assets/neo-butalist-blog-editor-github.png

@@ -20,10 +20,9 @@ import { deletePublishedPost } from './lib/deletePublishedPost'
 import { PublishValidationError } from './lib/publishTemplates'
 import { postHref, postRepoPath } from './lib/blogPaths'
 import {
-  buildOptimisticPublishedFile,
   filterVisiblePublishedPosts,
+  mergeRepoPublishedWithLocal,
   pruneRecentlyDeletedSlugs,
-  upsertPublishedPost,
   withoutDeletedPost,
 } from './lib/publishedPosts'
 import { PostTemplatePanel } from './components/PostTemplatePanel'
@@ -138,7 +137,7 @@ export default function App() {
           branch: githubSettings.branch?.trim() || 'main',
         })
         const sorted = [...files].sort((a, b) => a.name.localeCompare(b.name))
-        setPublishedFiles(sorted)
+        setPublishedFiles((current) => mergeRepoPublishedWithLocal(current, sorted))
         setRecentlyDeletedSlugs((prev) => pruneRecentlyDeletedSlugs(prev, sorted))
         return sorted
       } catch (err) {
@@ -414,29 +413,41 @@ export default function App() {
         const publishedDraftId = draftId
         const s = slug.trim() || slugify(title) || 'post'
         const path = postRepoPath(s)
+        const currentSlug = s
         const result = await publishPostAndIndex({
           form,
           path,
-          slug: s,
+          slug: currentSlug,
           title,
           content,
           excerpt,
           category,
           categoryClass: 'nb-bg-pink',
         })
+        console.log('Publish result:', result)
         setIndexHomeBanner(result.indexHomeBanner)
 
-        const publishedItem = buildOptimisticPublishedFile({
-          slug: result.slug,
-          title: result.title,
-          excerpt: result.excerpt,
-          category: result.category,
-          path: result.postPath,
-          url: result.url,
-          publishedAt: result.publishedAt,
+        const publishedPost = {
+          slug: result.slug || currentSlug,
+          title: result.title || title,
+          excerpt: result.excerpt ?? excerpt,
+          category: result.category ?? category,
+          path: result.postPath || result.path || postRepoPath(currentSlug),
+          url: result.url || postHref(currentSlug),
+          publishedAt: result.publishedAt || new Date().toISOString(),
+          name: `${result.slug || currentSlug}.html`,
+          sha: null,
+        }
+        console.log('Optimistic published post:', publishedPost)
+        console.log('Updating publishedPosts after publish')
+
+        setPublishedFiles((posts) => {
+          const withoutExisting = posts.filter(
+            (post) => post.slug !== publishedPost.slug && post.path !== publishedPost.path,
+          )
+          return [publishedPost, ...withoutExisting]
         })
-        setPublishedFiles((posts) => upsertPublishedPost(posts, publishedItem))
-        setRecentlyDeletedSlugs((prev) => prev.filter((deleted) => deleted !== result.slug))
+        setRecentlyDeletedSlugs((prev) => prev.filter((deleted) => deleted !== publishedPost.slug))
         setListTab('published')
 
         if (result.workflowWarning) pushToast(result.workflowWarning)

assets/published-sidebar.png

@@ -2,7 +2,9 @@ import { describe, expect, it } from 'vitest'
 import {
   buildOptimisticPublishedFile,
   filterVisiblePublishedPosts,
+  mergeRepoPublishedWithLocal,
   pruneRecentlyDeletedSlugs,
+  publishedEntrySlug,
   publishedFileSlug,
   upsertPublishedPost,
   withoutDeletedPost,
@@ -53,6 +55,22 @@ describe('publishedPosts helpers', () => {
     expect(next2[0].title).toBe('Old revised')
   })
 
+  it('filterVisiblePublishedPosts uses explicit slug on optimistic entries', () => {
+    const posts = [{ slug: 'x', name: 'wrong.html', path: 'blog/posts/x.html' }]
+    expect(filterVisiblePublishedPosts(posts, ['x'])).toHaveLength(0)
+    expect(publishedEntrySlug(posts[0])).toBe('x')
+  })
+
+  it('mergeRepoPublishedWithLocal keeps optimistic posts missing from repo API', () => {
+    const local = [
+      { slug: 'new', name: 'new.html', path: 'blog/posts/new.html', title: 'New', sha: null },
+      { slug: 'old', name: 'old.html', path: 'blog/posts/old.html', sha: 'abc' },
+    ]
+    const repo = [{ name: 'old.html', path: 'blog/posts/old.html', sha: 'abc' }]
+    const merged = mergeRepoPublishedWithLocal(local, repo)
+    expect(merged.map((p) => p.slug)).toEqual(['new', 'old'])
+  })
+
   it('pruneRecentlyDeletedSlugs drops slug when file is gone from repo list', () => {
     expect(pruneRecentlyDeletedSlugs(['gone', 'ghost'], [{ name: 'gone.html', path: 'blog/posts/gone.html' }])).toEqual([
       'gone',

src/App.jsx

@@ -147,6 +147,7 @@ export async function publishPostAndIndex({
     indexUpdateReason: indexResult.reason ?? 'Card inserted between BLOG_POSTS markers.',
     indexPath,
     postPath: path,
+    path,
     slug,
     title: safeTitle,
     excerpt: String(excerpt ?? '').trim(),

src/lib/__tests__/publishedPosts.test.js

@@ -5,10 +5,42 @@ export function publishedFileSlug(file) {
   return String(file?.name ?? '').replace(/\.html$/i, '') || ''
 }
 
+/** Slug for sidebar filtering (optimistic entries store slug explicitly). */
+export function publishedEntrySlug(post) {
+  const explicit = String(post?.slug ?? '').trim()
+  if (explicit) return explicit
+  return publishedFileSlug(post)
+}
+
 /** Sidebar list: hide posts the user just deleted until repo API confirms removal. */
 export function filterVisiblePublishedPosts(files, recentlyDeletedSlugs) {
   const blocked = new Set(recentlyDeletedSlugs)
-  return files.filter((post) => !blocked.has(publishedFileSlug(post)))
+  return files.filter((post) => !blocked.has(publishedEntrySlug(post)))
+}
+
+/**
+ * Merge GitHub contents API list with local optimistic entries not yet returned by the API.
+ * @param {Array<object>} localFiles
+ * @param {Array<{ name: string, path: string, sha?: string }>} repoFiles
+ */
+export function mergeRepoPublishedWithLocal(localFiles, repoFiles) {
+  const repoPaths = new Set(repoFiles.map((f) => f.path))
+  const pendingLocal = localFiles.filter((f) => f.path && !repoPaths.has(f.path))
+  const fromRepo = repoFiles.map((f) => {
+    const local = localFiles.find((l) => l.path === f.path)
+    return {
+      ...f,
+      slug: local?.slug ?? publishedFileSlug(f),
+      title: local?.title,
+      excerpt: local?.excerpt,
+      category: local?.category,
+      url: local?.url,
+      publishedAt: local?.publishedAt,
+    }
+  })
+  return [...pendingLocal, ...fromRepo].sort((a, b) =>
+    String(a.name ?? '').localeCompare(String(b.name ?? '')),
+  )
 }
 
 /**
@@ -66,7 +98,10 @@ export function buildOptimisticPublishedFile({
 /** Prepend or replace by slug/path (newest first). */
 export function upsertPublishedPost(files, item) {
   const withoutExisting = files.filter(
-    (post) => publishedFileSlug(post) !== item.slug && post.path !== item.path,
+    (post) =>
+      publishedEntrySlug(post) !== item.slug &&
+      post.path !== item.path &&
+      post.slug !== item.slug,
   )
   return [item, ...withoutExisting]
 }