@waterwx/dsh-novel-forge 0.1.0

package/src/client/sidebar-entry.ts

@@ -0,0 +1,122 @@
+/**
+ * Sidebar entry injection — mirrors the family plugins' DOM-level pattern:
+ * the shell exposes no external slot, so the entry row is injected after the
+ * sibling plugin entries and self-heals via MutationObserver.
+ */
+import type { PanelController } from './panel/controller.ts'
+import { tt } from './panel/helpers.ts'
+import css from './panel/panel.module.css'
+
+/** Stable data attribute identifying the injected entry row. */
+export const ENTRY_SELECTOR = '[data-dsh-novelforge-entry]'
+
+/** Inline icon: an open book / writing glyph. */
+const ICON = '<svg viewBox="0 0 16 16" width="14" height="14" fill="none" stroke="currentColor" stroke-width="1.3" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M2.5 3.5h4a2 2 0 0 1 2 2v7a2 2 0 0 0-2-2h-4z"/><path d="M13.5 3.5h-4a2 2 0 0 0-2 2v7a2 2 0 0 1 2-2h4z"/><path d="M8 5.5v7"/></svg>'
+
+/** Find the sidebar shell root element. */
+function sidebarRoot(): HTMLElement | undefined {
+  const column = document.querySelector<HTMLElement>('[data-pane="sidebar"], [class*="sidebarCol"]')
+  if (column === null) return undefined
+  const logoOwner = column.querySelector<HTMLElement>('[class*="logoRow"]')?.parentElement
+  return logoOwner ?? (column.firstElementChild as HTMLElement | undefined)
+}
+
+/** The New Session button (nested in the logo row on current shells). */
+function newSessionButton(root: HTMLElement): HTMLButtonElement | undefined {
+  const nested = root.querySelector<HTMLButtonElement>('button[class*="newSession"]')
+  if (nested !== null) return nested
+  for (const child of root.children) {
+    if (child.tagName === 'BUTTON') return child as HTMLButtonElement
+  }
+  return undefined
+}
+
+/** Build the entry row (a detached button; insert once the shell is up). */
+function createEntry(controller: PanelController): HTMLButtonElement {
+  const entry = document.createElement('button')
+  entry.type = 'button'
+  entry.dataset.dshNovelforgeEntry = 'true'
+  entry.className = css.entry
+  entry.setAttribute('aria-label', tt('entry.label'))
+  entry.setAttribute('title', tt('entry.tooltip'))
+  entry.innerHTML = '<span class="' + css.entryIcon + '">' + ICON + '</span><span class="' + css.entryLabel + '">' + tt('entry.label') + '</span>'
+  entry.addEventListener('click', () => { controller.toggle() })
+  return entry
+}
+
+/** Re-insert the entry after the sibling plugin entry block. */
+function placeEntry(root: HTMLElement, entry: HTMLButtonElement): boolean {
+  const button = newSessionButton(root)
+  if (button === undefined) return false
+  if (entry.parentElement !== root) {
+    const row = button.closest('[class*="logoRow"]')
+    const base = (row !== null && row.parentElement === root) ? row : button
+    const family = Array.from(root.children).filter(
+      (el): el is HTMLElement => el instanceof HTMLElement && el.matches('[data-dsh-taskboard-entry], [data-dsh-ssh-entry], [data-dsh-novelforge-entry]'),
+    )
+    const last = family.length > 0 ? family[family.length - 1] : undefined
+    const anchor = last !== undefined ? last.nextElementSibling : base.nextElementSibling
+    root.insertBefore(entry, anchor)
+  }
+  return true
+}
+
+/**
+ * Mount the sidebar entry, waiting for the shell and self-healing on
+ * re-renders.
+ */
+export function mountSidebarEntry(controller: PanelController): () => void {
+  const entry = createEntry(controller)
+  let root: HTMLElement | undefined
+  let placed = false
+
+  const tryPlace = (): void => {
+    if (root !== undefined && !root.isConnected) {
+      rootObserver.disconnect()
+      root = undefined
+      placed = false
+    }
+    if (placed) {
+      if (document.body.contains(entry)) return
+      rootObserver.disconnect()
+      root = undefined
+      placed = false
+    }
+    root ??= sidebarRoot()
+    if (root === undefined) return
+    placed = placeEntry(root, entry)
+    if (placed) {
+      rootObserver.observe(root, { childList: true, subtree: true })
+    }
+  }
+
+  const waitObserver = new MutationObserver(() => { tryPlace() })
+  waitObserver.observe(document.body, { childList: true, subtree: true })
+
+  const rootObserver = new MutationObserver(() => {
+    if (root === undefined || !root.isConnected) {
+      placed = false
+      tryPlace()
+      return
+    }
+    if (!root.contains(entry)) {
+      placed = placeEntry(root, entry)
+    }
+  })
+
+  const syncActive = () => {
+    if (controller.getSnapshot().panelOpen) entry.dataset.active = 'true'
+    else delete entry.dataset.active
+  }
+  const unsubscribe = controller.subscribe(syncActive)
+  syncActive()
+
+  tryPlace()
+
+  return () => {
+    waitObserver.disconnect()
+    rootObserver.disconnect()
+    unsubscribe()
+    entry.remove()
+  }
+}

package/src/docx.ts

@@ -0,0 +1,83 @@
+/**
+ * docx outline extraction: a .docx is a zip whose word/document.xml holds the
+ * body text in <w:t> runs inside <w:p> paragraphs. We unzip with fflate and
+ * walk the XML with a tiny tokenizer — no heavyweight XML/DOM dependency.
+ */
+
+import { readFileSync } from 'node:fs'
+import { unzipSync, strFromU8 } from 'fflate'
+
+/** Decode the handful of XML entities docx bodies actually use. */
+function decodeEntities(text: string): string {
+  return text
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&amp;/g, '&')
+    .replace(/&nbsp;/g, ' ')
+}
+
+/**
+ * Extract plain text from a docx buffer: one line per <w:p> paragraph, with
+ * <w:tab>/<w:br> preserved as whitespace. Tables and nested structures are
+ * flattened in document order (their paragraphs are just <w:p> too).
+ * @param buffer - the raw .docx bytes.
+ * @returns the body text.
+ */
+export function extractDocxText(buffer: Uint8Array): string {
+  let files: ReturnType<typeof unzipSync>
+  try {
+    files = unzipSync(buffer)
+  } catch (error) {
+    throw new Error(`not a valid docx (zip open failed): ${(error as Error).message}`)
+  }
+  const document = files['word/document.xml']
+  if (document === undefined) {
+    throw new Error('not a valid docx (word/document.xml missing)')
+  }
+  const xml = strFromU8(document)
+
+  const paragraphs: string[] = []
+  // Split on paragraph boundaries; keep the segment text of each.
+  const parts = xml.split(/<w:p\b[^>]*>/)
+  for (let i = 1; i < parts.length; i++) {
+    const segment = parts[i]!
+    // Runs <w:t ...>…</w:t>; also honor <w:tab/> and <w:br/> as spaces.
+    const runs: string[] = []
+    const runRe = /<w:t(?:\s[^>]*)?>([\s\S]*?)<\/w:t>|<w:tab\b[^>]*\/>|<w:br\b[^>]*\/>/g
+    for (const match of segment.matchAll(runRe)) {
+      if (match[0].startsWith('<w:tab')) {
+        runs.push('\t')
+      } else if (match[0].startsWith('<w:br')) {
+        runs.push('\n')
+      } else {
+        runs.push(decodeEntities(match[1] ?? ''))
+      }
+    }
+    const line = runs.join('').replace(/\u00a0/g, ' ').trimEnd()
+    paragraphs.push(line)
+  }
+
+  // Collapse 3+ blank lines and trim.
+  const text = paragraphs.join('\n').replace(/\n{3,}/g, '\n\n').trim()
+  if (text.length === 0) {
+    throw new Error('docx contains no extractable text')
+  }
+  return text
+}
+
+/**
+ * Read and extract a docx outline from disk.
+ * @param path - absolute path to the .docx file.
+ * @returns the extracted outline text.
+ */
+export function readOutlineFromDocx(path: string): string {
+  let buffer: Buffer
+  try {
+    buffer = readFileSync(path)
+  } catch (error) {
+    throw new Error(`cannot read outline file "${path}": ${(error as Error).message}`)
+  }
+  return extractDocxText(new Uint8Array(buffer))
+}