dsh-lifecard 0.2.2 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/lib/client.js CHANGED
@@ -1212,6 +1212,10 @@ function LifeCardTab(props) {
1212
1212
  // 首页那几个按钮是「从头开始」的意思:上一次打开的是谁,到这一页就作废。
1213
1213
  // 不这样清,刚看完某人的卡再回首页点「整理 N 份材料」,那一页会默默
1214
1214
  // 还选着刚才那个人。
1215
+ // 书那一屏(BookView)自己知道手头有没有没存的正文和剧本。顶栏的返回和换门
1216
+ // 都在外面这一层,直接切屏的话那一屏就卸载了,谁也来不及问一句——
1217
+ // 人写了一段正文点顶上那个返回,字就没了,屏幕上连个提示都没有。
1218
+ // 所以 BookView 挂载时把「先收好再走」这个函数放在这里,外面切屏前先调它。
1215
1219
  const go = useCallback((next) => {
1216
1220
  // 离开那一屏就把带过去的东西清掉:不留着上一次的「整理谁」「读哪一份材料」,
1217
1221
  // 也不留着「这张建议卡属于谁」。以前 pendingAbout 只写不清——点过一次
@@ -1394,6 +1398,27 @@ function LifeCardTab(props) {
1394
1398
  // 会把后面每一个槽都错开一格。
1395
1399
  const [handoff, setHandoff] = useState(null)
1396
1400
  const [chatsNote, setChatsNote] = useState(null)
1401
+ // 书那一屏(BookView)自己知道手头有没有没存的正文和剧本。顶栏的返回和换门
1402
+ // 都在外面这一层,直接切屏的话那一屏就卸载了,谁也来不及问一句。
1403
+ // 所以 BookView 挂载时把「先收好再走」这个函数放在这里,切屏前先调它。
1404
+ //
1405
+ // 这三个 hook 必须排在 App 所有 hook 的最后:测试(render-all、doors-test)
1406
+ // 是按序号把预置状态摆进 hookStore 的,插在中间会把后面每个槽位都顶歪。
1407
+ const bookFlush = useRef(null)
1408
+ // 手头干净时同步返回 true:切屏不该为了「没东西要存」多等一帧。
1409
+ // 真有没存的东西才返回一个 promise,那时候等一下是对的。
1410
+ const leaveBook = useCallback(() => {
1411
+ const f = bookFlush.current
1412
+ if (typeof f !== 'function') return true
1413
+ return f()
1414
+ }, [])
1415
+ // 顶栏返回、换门都走这里:先请那一屏把没存的收好,收好了再走。
1416
+ const leaveThen = useCallback((next) => {
1417
+ const r = leaveBook()
1418
+ if (r === true) { next(); return }
1419
+ Promise.resolve(r).then((ok) => { if (ok === true) next() }).catch(() => null)
1420
+ }, [leaveBook])
1421
+
1397
1422
  const startInterview = useCallback((opts) => {
1398
1423
  const started = openInterviewSession(opts === undefined || opts === null ? {} : opts)
1399
1424
  const settle = (result) => {
@@ -1636,7 +1661,15 @@ function LifeCardTab(props) {
1636
1661
  // 顶部返回一律当成「回首页」:上次打开的是谁、刚才点的是哪份材料、
1637
1662
  // 看的是哪本世界书,到这里都作废。不这样清,从 A 的卡退回来再点别人的
1638
1663
  // 材料,分析页会默默还认着 A,读出来的东西全记到 A 名下。
1639
- canBack ? h('button', { className: 'lc-btn ghost sm', onClick: () => { go(VIEWS.home); setError(null); setProposal(null); setActiveWorld(null) }, title: '回到列表', type: 'button' }, h(Icon, { name: 'back', size: 14 })) : null,
1664
+ canBack ? h('button', {
1665
+ className: 'lc-btn ghost sm',
1666
+ onClick: () => {
1667
+ // 先问这一屏有没有没存的东西(书那一屏会自己存);存不上就留在原地。
1668
+ leaveThen(() => { go(VIEWS.home); setError(null); setProposal(null); setActiveWorld(null) })
1669
+ },
1670
+ title: '回到列表',
1671
+ type: 'button',
1672
+ }, h(Icon, { name: 'back', size: 14 })) : null,
1640
1673
  h('div', { className: 'lc-grow lc-ellipsis' },
1641
1674
  h('div', { className: 'lc-title lc-ellipsis' }, titles[view] ?? 'Life Cards'),
1642
1675
  mode === 'real' && view !== VIEWS.doors
@@ -1651,7 +1684,10 @@ function LifeCardTab(props) {
1651
1684
  ? null
1652
1685
  : h('button', {
1653
1686
  className: 'lc-btn ghost sm',
1654
- onClick: () => { setView(VIEWS.doors); setError(null); setProposal(null); setActiveWorld(null); setActiveCard(null) },
1687
+ onClick: () => {
1688
+ // 换门也是离开这一屏,一样先把没存的收好。
1689
+ leaveThen(() => { setView(VIEWS.doors); setError(null); setProposal(null); setActiveWorld(null); setActiveCard(null) })
1690
+ },
1655
1691
  title: '换成另一扇门',
1656
1692
  type: 'button',
1657
1693
  }, '换门'),
@@ -1846,6 +1882,7 @@ function LifeCardTab(props) {
1846
1882
  return h(BookView, {
1847
1883
  bookId: String(activeBook?.id ?? ''),
1848
1884
  flash,
1885
+ flushRef: bookFlush,
1849
1886
  onBack: () => { setActiveBook(null); setView(VIEWS.novel) },
1850
1887
  })
1851
1888
  case VIEWS.doctor:
@@ -3401,7 +3438,7 @@ function copyText(text) {
3401
3438
  }
3402
3439
  }
3403
3440
 
3404
- function BookView({ bookId, onBack, flash }) {
3441
+ function BookView({ bookId, onBack, flash, flushRef }) {
3405
3442
  const [book, setBook] = useState(null)
3406
3443
  const [outline, setOutline] = useState(null)
3407
3444
  const [chapterIndex, setChapterIndex] = useState(0)
@@ -3415,8 +3452,24 @@ function BookView({ bookId, onBack, flash }) {
3415
3452
  const [outlineText, setOutlineText] = useState('')
3416
3453
  // 这一章的正文有没有还没存下的改动。切章之前必须先处理,否则写的东西会没。
3417
3454
  const [bodyDirty, setBodyDirty] = useState(false)
3418
-
3419
- const load = async (want) => {
3455
+ // 「改成剧本」。排在所有 hook 最后:上面那些槽位有测试按序号摆状态,
3456
+ // 插在中间会让它们集体错位。
3457
+ const [scriptText, setScriptText] = useState('')
3458
+ const [scriptReport, setScriptReport] = useState('')
3459
+ // 剧本有没有改了没存的。和正文的 bodyDirty 一个道理:切章之前得拦一下,
3460
+ // 否则人手改的那几场会静静消失,而且没有任何提示。
3461
+ const [scriptDirty, setScriptDirty] = useState(false)
3462
+ // 改剧本这一节的错误单独放:全页那个 err 在最底下,一节剧本三百多像素高,
3463
+ // 报错落在屏幕外,人只会觉得「点了没反应」。
3464
+ const [scriptErr, setScriptErr] = useState(null)
3465
+ // 这本书哪几章已经改出过剧本。后台一直有这个清单(`novel.script.list`),
3466
+ // 界面从来没调过——于是「哪一章改过」只存在于文件夹里。
3467
+ const [scripted, setScripted] = useState([])
3468
+ // 这一章的正文有没有真正读到。读失败(网络、后台报错、文件被占住)时不能让人
3469
+ // 接着在空框里写字再按「存好这一章」——那会把空白写进另一章的文件,一整章原稿就没了。
3470
+ const [chapterBroken, setChapterBroken] = useState(false)
3471
+
3472
+ const load = async (want, opts) => {
3420
3473
  setErr(null)
3421
3474
  try {
3422
3475
  const r = await call('novel.get', { id: bookId })
@@ -3424,19 +3477,145 @@ function BookView({ bookId, onBack, flash }) {
3424
3477
  setBook(r)
3425
3478
  const o = await call('novel.outline.get', { id: bookId })
3426
3479
  if (o?.ok === true) { setOutline(o); setOutlineText(String(o.text ?? '')) }
3480
+ // 哪几章已经改出过剧本(画章列表上的小标记用)。拿不到就算了,不是要紧事。
3481
+ const scripts = await call('novel.script.list', { id: bookId }).catch(() => null)
3482
+ setScripted(scripts?.ok === true && Array.isArray(scripts.scripts)
3483
+ ? scripts.scripts.map((x) => Number(x.index))
3484
+ : [])
3427
3485
  // 默认打开:有章节就打开最后一章,没有就从第一章开始
3428
3486
  const target = Number(want) > 0 ? Number(want) : (r.chapters.length === 0 ? 1 : r.chapters[r.chapters.length - 1].index)
3487
+ // 先翻章再改章号:翻章被拦下时,章号不能已经跑到新的一章去。
3488
+ const opened = await openChapter(target, opts)
3489
+ if (opened === 'error') {
3490
+ // 出错时章号也得跟标题对上:以前这里直接返回、章号停在旧值(初值是 0),
3491
+ // 屏幕上写着「写第 0 章」,点存就被后台当成「接在最后一章后面」,凭空多一章。
3492
+ // 正文没读到,存的动作已经按 chapterBroken 禁掉了。
3493
+ setChapterIndex(target)
3494
+ return
3495
+ }
3496
+ // 被拦下,或者这中间又有人点了别的章:什么都不改。
3497
+ if (opened !== true) return
3429
3498
  setChapterIndex(target)
3430
- await openChapter(target)
3431
3499
  } catch (e) { setErr(humanizeError(e)) }
3500
+ // 上一本书那份剧本没存上:现在才说,说了才算数。
3501
+ if (carryErr.current !== null) { setErr(String(carryErr.current)); carryErr.current = null }
3432
3502
  }
3433
3503
 
3434
- const openChapter = async (index) => {
3435
- setErr(null); setReview(null); setDraft(null)
3504
+ // 剧本改了没存,要走之前先替人存好。
3505
+ //
3506
+ // 这里以前弹的是「回去就没了」,可组件卸载那一刻又偷偷存了一份——弹窗说不要,
3507
+ // 实际存了,人点了「好」以为自己放弃成功,其实没有。现在只剩一种立场:真存。
3508
+ // 存成了说一句「先替你存好了」;存不上才问要不要放弃这一份。
3509
+ const settleScript = async (why) => {
3510
+ if (scriptDirty !== true || scriptText.trim() === '') return true
3511
+ const myBook = bookId
3512
+ const myIndex = chapterIndex
3513
+ const sent = scriptText
3514
+ setBusy('scriptSave'); setScriptErr(null)
3515
+ try {
3516
+ const r = await call('novel.script.save', { id: myBook, index: myIndex, text: sent })
3517
+ if (r?.ok === true) {
3518
+ setScriptDirty(false)
3519
+ setScripted((old) => (old.includes(myIndex) ? old : [...old, myIndex].sort((a, b) => a - b)))
3520
+ flash?.(`第 ${myIndex} 章的剧本先替你存好了`)
3521
+ return true
3522
+ }
3523
+ setScriptErr(r?.error ?? '这一份剧本没存上')
3524
+ } catch (e) { setScriptErr(humanizeError(e)) } finally { setBusy('') }
3525
+ // 存不上:只剩「放弃这一份」和「留下」两条路,问清了再走。
3526
+ const go = typeof window !== 'undefined' && typeof window.confirm === 'function'
3527
+ ? window.confirm(`第 ${myIndex} 章这份剧本没存上。\n\n${why}的话这一份就没了。还走吗?`)
3528
+ : true
3529
+ return go === true
3530
+ }
3531
+
3532
+ // 改剧本也要对号:点了「把这一章改成剧本」之后又翻章、又换书,
3533
+ // 草稿晚回来会落进现在这一章的框里,人一按「存好这份剧本」,
3534
+ // 第 5 章的内容就写成第 6 章的文件。换书之后更糟:A 书的稿子会存成 B 书的。
3535
+ // 所以草稿出发前记下「哪本书、哪一章」,回来对不上就整份丢掉。
3536
+ const scriptTicket = useRef(0)
3537
+
3538
+ // 每翻一次章就加一,回来的东西先对一下号。
3539
+ // 手快连点两章(或者网络慢)时,前一章的剧本会在后一章之后才回来,
3540
+ // 落在框里就成了「标题是第 3 章,剧本是第 2 章的」——这种错对不上账,人只会觉得插件疯了。
3541
+ const chapterTicket = useRef(0)
3542
+ // 框里此刻摆的是第几章、还有没有一章正在读。
3543
+ // 不能用 chapterIndex 判「点的就是我现在这一章」:章号要等读完才前进,
3544
+ // 人点第 2 章、它还在路上时,chapterIndex 还停在旧值(比如 3)。
3545
+ // 这时候再点第 3 章,会被当成「点的是自己这一章」而什么都不做,
3546
+ // 于是框里留着第 2 章的正文、章号写着第 3 章。
3547
+ const loadedRef = useRef(0)
3548
+ const pullingRef = useRef(0)
3549
+
3550
+ /**
3551
+ * 翻到某一章。
3552
+ *
3553
+ * `opts.sameChapter` 是给「刚把这一章存好、要重读一遍」用的:那时候没换章,
3554
+ * 不该弹「剧本还没存,换过去就没了」——人点了「好」,手改的剧本反倒没了。
3555
+ * 带上它就别去动剧本框,剧本跟正文是两份东西,各存各的。
3556
+ *
3557
+ * 返回 true 表示框里已经是这一章;返回 'stale' 表示这中间又有人点了别的章,
3558
+ * 这一次的结果该整份丢掉,调用方也不许再改章号。
3559
+ */
3560
+ const openChapter = async (index, opts) => {
3561
+ const sameChapter = opts !== undefined && opts !== null && opts.sameChapter === true
3562
+ // `settled`:调用方已经把要存的存过了(换书那一段),这里不许再拦一次。
3563
+ // 不然人会看到一个「第 2 章改出来的剧本还没存」的框,说的却是上一本书的章,
3564
+ // 点「取消」也照换不误——那框就是个摆设。
3565
+ const settled = opts !== undefined && opts !== null && opts.settled === true
3566
+ // 改过剧本还没存就切章,得先说一声。同一章重读不算切章。
3567
+ if (settled !== true && sameChapter !== true && (await settleScript('换过去')) !== true) return false
3568
+ const mine = ++chapterTicket.current
3569
+ pullingRef.current = Number(index)
3570
+ // 换章 / 换书了:还在路上的剧本草稿一律作废。
3571
+ scriptTicket.current += 1
3572
+ setErr(null); setReview(null); setDraft(null); setScriptErr(null)
3573
+ if (sameChapter !== true) { setScriptText(''); setScriptReport(''); setScriptDirty(false) }
3436
3574
  try {
3437
3575
  const r = await call('novel.chapter.get', { id: bookId, index })
3438
- setBody(r?.ok === true ? String(r.body ?? '') : '')
3439
- } catch (e) { setErr(humanizeError(e)) }
3576
+ if (mine !== chapterTicket.current) return 'stale'
3577
+ if (r?.ok !== true) {
3578
+ // 后台说这一章读不出来(文件被占住、内容坏了):不能当「这一章是空的」处理。
3579
+ // 当真当成空的话,人会在空框里写一段,再按「存好这一章」,
3580
+ // 存进去的是**这一章**的文件,原来那一份就被盖掉了。
3581
+ // 章号照旧前进——屏幕上的标题得跟点的那一章对上。
3582
+ setBody('')
3583
+ setChapterBroken(true)
3584
+ setErr(String(r?.error ?? '这一章没读出来。'))
3585
+ loadedRef.current = Number(index)
3586
+ pullingRef.current = 0
3587
+ return true
3588
+ }
3589
+ setBody(String(r.body ?? ''))
3590
+ setChapterBroken(false)
3591
+ if (sameChapter === true) return true
3592
+ // 这一章以前改过剧本没有——改过就直接摆出来,不用再问一次。
3593
+ const s = await call('novel.script.get', { id: bookId, index })
3594
+ if (mine !== chapterTicket.current) return 'stale'
3595
+ if (s?.ok === true) {
3596
+ if (String(s.text ?? '').trim() !== '') {
3597
+ setScriptText(String(s.text))
3598
+ setScriptReport(String(s.report ?? ''))
3599
+ }
3600
+ } else {
3601
+ // 剧本读坏了不能当没这回事:框不渲染、章列表还挂着「有剧本」,
3602
+ // 人只会以为自己改的东西没了,而且屏幕上没有一句话。
3603
+ setScriptErr(String(s?.error ?? '这一章的剧本读不出来。'))
3604
+ }
3605
+ setChapterBroken(false)
3606
+ loadedRef.current = Number(index)
3607
+ pullingRef.current = 0
3608
+ return true
3609
+ } catch (e) {
3610
+ if (mine === chapterTicket.current) {
3611
+ pullingRef.current = 0
3612
+ setErr(humanizeError(e))
3613
+ // 正文没读到:把这一章标成「别动」。以前这里直接返回,章号停在旧值,
3614
+ // 人点「存好这一章」就把眼下这个空框写进**另一章**的文件,原稿就没了。
3615
+ setChapterBroken(true)
3616
+ }
3617
+ return 'error'
3618
+ }
3440
3619
  }
3441
3620
 
3442
3621
  // 切章之前先把没存的正文收好。存不上就留在这一章,别让人以为写进去了。
@@ -3452,9 +3631,15 @@ function BookView({ bookId, onBack, flash }) {
3452
3631
  }
3453
3632
 
3454
3633
  const goChapter = async (index) => {
3634
+ // 点的是自己正待着的这一章:不用重读。以前会照样重读一遍,
3635
+ // 手改的剧本会因为一次「换过去」被磁盘上那一份换掉。
3636
+ // 但票号还是要往前走一步:刚才点过别的章、它那份还在路上,
3637
+ // 此刻也该作废——不然它回来照样落进这一章的框。
3638
+ if (Number(index) === Number(loadedRef.current) && pullingRef.current === 0) return
3455
3639
  if ((await keepBody()) !== true) return
3640
+ // 剧本那边没存就被拦下时,章号也不能跟着变——否则标题写着新章、框里还是旧章。
3641
+ if ((await openChapter(index)) !== true) return
3456
3642
  setChapterIndex(index)
3457
- await openChapter(index)
3458
3643
  }
3459
3644
 
3460
3645
  /**
@@ -3465,22 +3650,143 @@ function BookView({ bookId, onBack, flash }) {
3465
3650
  */
3466
3651
  const removeChapter = async (c) => {
3467
3652
  const n = Number(c?.index ?? 0)
3653
+ // 有剧本的章,确认框里得说清剧本也一起没:那一份是人花了一次 AI 改出来的。
3654
+ const extra = scripted.includes(n)
3655
+ ? '这一章改出来的剧本也一起删。'
3656
+ : ''
3468
3657
  const ok = typeof window !== 'undefined' && typeof window.confirm === 'function'
3469
- ? window.confirm(`把第 ${n} 章删掉?\n\n这一章的正文一起删,删了就真没了。别的章不受影响;大纲里那一行还在,你可以重写。`)
3658
+ ? window.confirm(`把第 ${n} 章删掉?\n\n这一章的正文一起删,删了就真没了。${extra}别的章不受影响;大纲里那一行还在,你可以重写。`)
3470
3659
  : true
3471
3660
  if (ok !== true) return
3661
+ // 删的是**这一章**时,它上面那份没存的剧本才跟着作废。
3662
+ // 删别的章却去清当前章的状态,等于把人家正在写的正文和剧本一起抹了——
3663
+ // 以前就是这样:停在第 2 章写了一大段,顺手删掉第 1 章,第 2 章写的全没了,
3664
+ // 正文连问都没问一句。
3665
+ const deletingCurrent = n === chapterIndex
3666
+ if (deletingCurrent !== true) {
3667
+ // 删别的章:当前章该存的先存好,别让它被下面的重读顺手丢掉。
3668
+ if ((await keepBody()) !== true) return
3669
+ // 剧本也替它存回去。这里不问「走不走」——人没打算走,只是在删别的章;
3670
+ // 问了也只有一个正确答案,反倒把「删第 1 章」这件事拦下来。
3671
+ if (scriptDirty === true && scriptText.trim() !== '') {
3672
+ let saved = false
3673
+ try {
3674
+ const r = await call('novel.script.save', { id: bookId, index: chapterIndex, text: scriptText })
3675
+ if (r?.ok === true) { saved = true; setScriptDirty(false) }
3676
+ else setErr(r?.error ?? '这一章的剧本没存上,先别删')
3677
+ } catch (e) { setErr(humanizeError(e)) }
3678
+ // 存不上就别删:这一删,下面那次重读会把框里东西换掉,手改的就真没了。
3679
+ if (saved !== true) return
3680
+ }
3681
+ }
3472
3682
  setErr(null)
3473
- setBodyDirty(false)
3474
3683
  try {
3475
3684
  const r = await call('novel.chapter.delete', { id: bookId, index: n })
3476
3685
  if (r?.ok !== true) { setErr(r?.error ?? '这一章没删掉'); return }
3686
+ // 删成功了才清当前章的状态。以前这两行写在删之前:后台一报错就 return,
3687
+ // 清空却已经生效,手写的正文和剧本在屏幕上没了、磁盘上也没存过。
3688
+ if (deletingCurrent === true) {
3689
+ setBodyDirty(false)
3690
+ setScriptText(''); setScriptReport(''); setScriptDirty(false)
3691
+ setScriptErr(null)
3692
+ }
3693
+ setScripted((old) => old.filter((x) => x !== n))
3477
3694
  flash?.(`删掉了第 ${n} 章`)
3478
- // 重新读一遍这本书:章列表少一条,正文换成还在的那一章。
3479
- await load(n > 1 ? n - 1 : 0)
3695
+ // 重新读一遍这本书:章列表少一条。
3696
+ // 删的不是当前章时留在原地重读(人可能正写着),删的就是当前章才往前挪。
3697
+ // 挪的时候给 0:让 load 自己落到「现在还存在的最后一章」。
3698
+ // 以前传 n-1,而 n-1 可能刚在上一步被删掉,屏幕就停在一个没有的章号上。
3699
+ if (deletingCurrent === true) await load(0, { sameChapter: false })
3700
+ else await load(chapterIndex, { sameChapter: true })
3480
3701
  } catch (e) { setErr(humanizeError(e)) }
3481
3702
  }
3482
3703
 
3483
- useEffect(() => { load(0) }, [bookId])
3704
+ // 上一本是哪本。换书时要在下面那个 effect 里认出「这是换了一本」。
3705
+ const lastBookId = useRef('')
3706
+ // 换书时替上一本存剧本,存失败了要报,可紧接着的 load() 会把 err 清掉。
3707
+ // 先存在这里,等 load 读完了再摆到屏幕上。
3708
+ const carryErr = useRef(null)
3709
+ // 换书(从书架再点一本进来)时组件不卸载、只是 bookId 变了:
3710
+ // 上一本改了没存的剧本会留在框里,跟着新书一起显示,看着像这本书的剧本;
3711
+ // 反过来,它也会被静悄悄丢掉。所以换书这一刻先替上一本存回去。
3712
+ // 注意此刻 scriptText / scriptDirty / chapterIndex 还是上一本的值(下面才清),
3713
+ // 正好用得上——晚了就没了。
3714
+ useEffect(() => {
3715
+ const before = lastBookId.current
3716
+ if (before !== '' && before !== bookId) {
3717
+ // 换书了:上一本还在路上的剧本草稿作废,不许它落进新书的框里。
3718
+ scriptTicket.current += 1
3719
+ // 上一本没存的剧本替它存回**原来那本**(不是新这本)。
3720
+ // 存的时候顺手报一下成没成:失败还得让新书那边看得见,
3721
+ // 不然人会以为「点了一下就都存好了」。
3722
+ if (scriptDirty === true && scriptText.trim() !== '') {
3723
+ const oldId = before
3724
+ const oldIndex = chapterIndex
3725
+ const oldText = scriptText
3726
+ // 先把这一刻的「哪本书、哪一章、什么内容」定下来,卸载兜底那份也一起作废:
3727
+ // 不然同一份稿会同时写进上一本和下一本。
3728
+ leaveRef.current = { id: oldId, index: oldIndex, text: oldText, dirty: true, taken: true }
3729
+ call('novel.script.save', { id: oldId, index: oldIndex, text: oldText })
3730
+ .then((r) => {
3731
+ // 提示要能活过紧接着的那次 load(load 开头会清 err):
3732
+ // 失败时先用一个不会被清掉的位置接着,等读完再摆出来。
3733
+ if (r?.ok === true) flash?.(`上一本书第 ${oldIndex} 章的剧本替你存好了`)
3734
+ else carryErr.current = String(r?.error ?? '上一本书的剧本没存上')
3735
+ })
3736
+ .catch(() => { carryErr.current = '上一本书的剧本没存上' })
3737
+ }
3738
+ }
3739
+ lastBookId.current = String(bookId ?? '')
3740
+ setScriptText(''); setScriptReport(''); setScriptDirty(false)
3741
+ setBody(''); setDraft(null); setReview(null); setBodyDirty(false)
3742
+ load(0, { settled: true })
3743
+ }, [bookId])
3744
+
3745
+ // 离开这一屏时(点顶上那个返回、换门、切到别的页)组件直接卸载,
3746
+ // 没有第二次机会弹窗问「剧本还没存,现在走吗」——上面那个 effect 只在换书时跑。
3747
+ // 所以卸载这一刻自己把没存的剧本收好:人没按「存好这份剧本」,
3748
+ // 不等于想把它丢掉。
3749
+ // `taken` 是给换书那一段用的:那一份已经有人存了,卸载兜底不许再存一遍,
3750
+ // 更不许把 A 书的内容写成 B 书的(id 与 text 配不上对时就是这么串过去的)。
3751
+ const leaveRef = useRef({ id: '', index: 0, text: '', dirty: false, taken: false })
3752
+ leaveRef.current = {
3753
+ id: bookId, index: chapterIndex, text: scriptText, dirty: scriptDirty,
3754
+ // 每帧重写的只是「当前值」,taken 只在换书那一刻被置上;
3755
+ // 置上之后要一直有效到这一帧结束,所以从上一帧继承。
3756
+ taken: leaveRef.current.taken === true && leaveRef.current.id === bookId ? true : false,
3757
+ }
3758
+ // 正文和剧本是两份东西,可离开这一屏时都得收好。以前只兜了剧本:
3759
+ // 写完一段正文点顶上的返回,字就没了,而且屏幕上不会有一句话。
3760
+ const bodyLeaveRef = useRef({ id: '', index: 0, body: '', dirty: false })
3761
+ bodyLeaveRef.current = { id: bookId, index: chapterIndex, body, dirty: bodyDirty }
3762
+ useEffect(() => () => {
3763
+ const now = leaveRef.current
3764
+ if (now.taken !== true && now.dirty === true && String(now.text).trim() !== '') {
3765
+ // 这一份已经没地方报错了(组件都卸载了),只能尽量存住。
3766
+ // 真正的「存不上怎么办」已经在 settleScript 里问过人了。
3767
+ call('novel.script.save', { id: now.id, index: now.index, text: now.text }).catch(() => null)
3768
+ }
3769
+ const nb = bodyLeaveRef.current
3770
+ if (nb.dirty === true && String(nb.body).trim() !== '') {
3771
+ call('novel.chapter.save', { id: nb.id, index: nb.index, body: nb.body }).catch(() => null)
3772
+ }
3773
+ }, [])
3774
+
3775
+ // 外面那一层(顶栏返回、换门)没法知道这一屏手头有没有没存的东西。
3776
+ // 把「先收好再走」放在它给的槽里:切屏前先调,收不上就留在这一屏。
3777
+ useEffect(() => {
3778
+ if (flushRef === undefined || flushRef === null) return
3779
+ flushRef.current = () => {
3780
+ // 什么都没改:同步放行,外面那一层就不用等一帧。
3781
+ if (bodyDirty !== true && scriptDirty !== true) return true
3782
+ return (async () => {
3783
+ const bodyOk = await keepBody()
3784
+ if (bodyOk !== true) return false
3785
+ return settleScript('换到别处')
3786
+ })()
3787
+ }
3788
+ return () => { flushRef.current = null }
3789
+ })
3484
3790
 
3485
3791
  const doPlan = async () => {
3486
3792
  setBusy('plan'); setErr(null)
@@ -3530,7 +3836,8 @@ function BookView({ bookId, onBack, flash }) {
3530
3836
  if (r?.ok !== true) { setErr(r?.error ?? '没存上'); return }
3531
3837
  setBody(merged); setDraft(null); setBodyDirty(false)
3532
3838
  flash?.(`第 ${chapterIndex} 章存好了`)
3533
- await load(chapterIndex)
3839
+ // 同一章重读:别碰剧本框,也别弹「剧本还没存」。
3840
+ await load(chapterIndex, { sameChapter: true })
3534
3841
  } catch (e) { setErr(humanizeError(e)) } finally { setBusy('') }
3535
3842
  }
3536
3843
 
@@ -3541,7 +3848,7 @@ function BookView({ bookId, onBack, flash }) {
3541
3848
  if (r?.ok !== true) { setErr(r?.error ?? '没存上'); return }
3542
3849
  setBodyDirty(false)
3543
3850
  flash?.(`第 ${chapterIndex} 章存好了`)
3544
- await load(chapterIndex)
3851
+ await load(chapterIndex, { sameChapter: true })
3545
3852
  } catch (e) { setErr(humanizeError(e)) } finally { setBusy('') }
3546
3853
  }
3547
3854
 
@@ -3557,6 +3864,119 @@ function BookView({ bookId, onBack, flash }) {
3557
3864
  } catch (e) { setErr(humanizeError(e)) } finally { setBusy('') }
3558
3865
  }
3559
3866
 
3867
+ /**
3868
+ * 把这一章改成剧本。
3869
+ *
3870
+ * 改的是**存下来的那一版**:正文有没存的改动先存一次,不然后台改的是旧稿,
3871
+ * 用户盯着屏幕会以为它漏掉了刚写的那几句。
3872
+ */
3873
+ // 连点两下会真发两次(AI 那一侧是要花钱的)。按钮的 disabled 要等一次 await
3874
+ // 之后才置位,同一帧里的两次点击都赶在它前面。所以用一个同步的锁挡。
3875
+ const scriptLock = useRef(false)
3876
+
3877
+ const doScript = async () => {
3878
+ if (scriptLock.current === true) return
3879
+ if (body.trim() === '') { setScriptErr('这一章还空着,没什么可改的。'); return }
3880
+ // 框里已经有一份、而且改过没存:点「重改一份」会把它整份盖掉。
3881
+ // 不先问一句,人点错一次就是白改。
3882
+ if (scriptDirty === true && scriptText.trim() !== '') {
3883
+ const go = typeof window !== 'undefined' && typeof window.confirm === 'function'
3884
+ ? window.confirm(`第 ${chapterIndex} 章这份剧本改了还没存,重改一次会把它整份盖掉。\n\n继续吗?`)
3885
+ : true
3886
+ if (go !== true) return
3887
+ }
3888
+ scriptLock.current = true
3889
+ if ((await keepBody()) !== true) { scriptLock.current = false; return }
3890
+ // 出发前记下是哪本书的哪一章:回来要是对不上,说明人已经翻到别处了。
3891
+ const wantBook = bookId
3892
+ const wantIndex = chapterIndex
3893
+ const mine = ++scriptTicket.current
3894
+ setBusy('script'); setErr(null); setScriptErr(null)
3895
+ try {
3896
+ const r = await call('novel.script.draft', { id: wantBook, index: wantIndex })
3897
+ if (mine !== scriptTicket.current) return
3898
+ if (r?.ok !== true) { setScriptErr(r?.error ?? '这次没改成。再点一次试试。'); return }
3899
+ setScriptText(String(r.text ?? ''))
3900
+ setScriptReport(String(r.report ?? ''))
3901
+ // 改出来但还没落盘,所以算「没存」:这时候切章要拦。
3902
+ setScriptDirty(true)
3903
+ } catch (e) { if (mine === scriptTicket.current) setScriptErr(humanizeError(e)) } finally {
3904
+ // 无条件复位。以前这里要票号还对得上才复位:人趁 AI 还在想的时候翻了章,
3905
+ // 票号一过就永远不复位,整页五个按钮从此全禁用,只有退出这本书才恢复。
3906
+ scriptLock.current = false
3907
+ setBusy('')
3908
+ }
3909
+ }
3910
+
3911
+ const saveScript = async () => {
3912
+ if (scriptLock.current === true) return
3913
+ if (scriptText.trim() === '') { setScriptErr('剧本还是空的,没什么可存的。'); return }
3914
+ // 记下这一次到底存的是哪一份:回来时框里的字已经不是这一份了,
3915
+ // 就不能把「还没存」这个标记清掉,否则那几个字会被当成已存、然后默默丢掉。
3916
+ const sent = scriptText
3917
+ // 还要记下是哪本书的哪一章:人可能趁这次保存还在路上就翻了章、换了书。
3918
+ // 那时候这个回包属于上一章,一个字都不能往现在这一章身上贴
3919
+ // (以前会清掉现在这一章的「还没存」、把上一章的报告摆到这一章里)。
3920
+ const myBook = bookId
3921
+ const myIndex = chapterIndex
3922
+ scriptLock.current = true
3923
+ setBusy('scriptSave'); setErr(null); setScriptErr(null)
3924
+ try {
3925
+ const r = await call('novel.script.save', { id: myBook, index: myIndex, text: sent })
3926
+ if (myBook !== bookId || myIndex !== chapterIndex) return
3927
+ if (r?.ok !== true) { setScriptErr(r?.error ?? '没存上。这一份还在框里,再点一次就行。'); return }
3928
+ setScriptReport(String(r.report ?? ''))
3929
+ // 章列表上那个「有剧本」的小标记:存好之后立刻挂上,
3930
+ // 不然得退出这本书再进来才看得见,人会以为自己没存上。
3931
+ setScripted((old) => (old.includes(myIndex) ? old : [...old, myIndex].sort((a, b) => a - b)))
3932
+ if (scriptText === sent) {
3933
+ setScriptDirty(false)
3934
+ flash?.(`第 ${myIndex} 章的剧本存好了`)
3935
+ } else {
3936
+ // 存的过程中又改了:这一版还没存,标记留着,按钮上说出来。
3937
+ setScriptDirty(true)
3938
+ flash?.('存好了。存的时候你又改了,新改的这一版还没存')
3939
+ }
3940
+ } catch (e) { if (myBook === bookId && myIndex === chapterIndex) setScriptErr(humanizeError(e)) } finally {
3941
+ scriptLock.current = false
3942
+ setBusy('')
3943
+ }
3944
+ }
3945
+
3946
+ /**
3947
+ * 删掉这一章的剧本。
3948
+ *
3949
+ * 只删改编出来的那份,章节正文一点不动——所以这里说的「删」和删章不是一回事,
3950
+ * 提示语里要把这件事说清,否则有人会以为连这一章一起删了。
3951
+ */
3952
+ const removeScript = async () => {
3953
+ if (scriptLock.current === true) return
3954
+ const myIndex = chapterIndex
3955
+ // 手改过还没存的部分会跟着一起没,这句得说在确认框里。
3956
+ const unsaved = scriptDirty === true && scriptText.trim() !== ''
3957
+ ? '\n\n框里手改过、还没存的那部分也一起没。'
3958
+ : ''
3959
+ const ok = typeof window !== 'undefined' && typeof window.confirm === 'function'
3960
+ ? window.confirm(`把第 ${myIndex} 章改出来的剧本删掉?\n\n只删这份剧本,小说正文不动。想再要一份,可以重新改一次。${unsaved}`)
3961
+ : true
3962
+ if (ok !== true) return
3963
+ const myBook = bookId
3964
+ scriptLock.current = true
3965
+ setBusy('scriptDelete'); setErr(null); setScriptErr(null)
3966
+ try {
3967
+ const r = await call('novel.script.delete', { id: myBook, index: myIndex })
3968
+ // 这一回包只属于那一章:人要是在等的时候翻到别处,
3969
+ // 现在框里的东西是那一章的新内容,一个字都不能清。
3970
+ if (myBook !== bookId || myIndex !== chapterIndex) return
3971
+ if (r?.ok !== true) { setScriptErr(r?.error ?? '这份剧本没删掉'); return }
3972
+ setScriptText(''); setScriptReport(''); setScriptDirty(false)
3973
+ setScripted((old) => old.filter((n) => n !== myIndex))
3974
+ flash?.(`删掉了第 ${myIndex} 章的剧本`)
3975
+ } catch (e) {
3976
+ if (myBook === bookId && myIndex === chapterIndex) setScriptErr(humanizeError(e))
3977
+ } finally { scriptLock.current = false; setBusy('') }
3978
+ }
3979
+
3560
3980
  if (book === null) {
3561
3981
  return h('div', { className: 'lc-pad lc-stack' },
3562
3982
  h(Btn, { size: 'sm', icon: 'back', onClick: onBack }, '回书架'),
@@ -3571,7 +3991,13 @@ function BookView({ bookId, onBack, flash }) {
3571
3991
 
3572
3992
  return h('div', { className: 'lc-pad lc-stack', style: { gap: 12 } },
3573
3993
  h('div', { className: 'lc-row' },
3574
- h(Btn, { size: 'sm', icon: 'back', onClick: async () => { if ((await keepBody()) === true) onBack() } }, '回书架'),
3994
+ h(Btn, { size: 'sm', icon: 'back', onClick: async () => {
3995
+ // 先替人存,存不上才问「还走吗」。以前这里是「回去就没了」+ 卸载时偷偷存,
3996
+ // 说的话和做的事对不上。
3997
+ if ((await keepBody()) !== true) return
3998
+ if ((await settleScript('回去')) !== true) return
3999
+ onBack()
4000
+ } }, '回书架'),
3575
4001
  h('div', { className: 'lc-grow lc-ellipsis', style: { fontWeight: 700, fontSize: 16.5 } }, `《${title}》`),
3576
4002
  h('span', { className: 'lc-meta' }, `${chapters.length} 章`),
3577
4003
  ),
@@ -3635,6 +4061,10 @@ function BookView({ bookId, onBack, flash }) {
3635
4061
  tone: Number(c.index) === Number(chapterIndex) ? 'primary' : undefined,
3636
4062
  onClick: () => { goChapter(Number(c.index)) },
3637
4063
  }, `第 ${c.index} 章${String(c.title ?? '').trim() === '' ? '' : ` · ${String(c.title).slice(0, 16)}`}`),
4064
+ // 这一章改过剧本:给一个小标记。不然只有翻进去才知道自己改没改过。
4065
+ scripted.includes(Number(c.index))
4066
+ ? h('span', { className: 'lc-meta', title: '这一章已经有一份剧本' }, '有剧本')
4067
+ : null,
3638
4068
  h('div', { className: 'lc-grow' }),
3639
4069
  h(Btn, { size: 'sm', ghost: true, icon: 'trash', onClick: () => removeChapter(c) }, '删掉这一章'),
3640
4070
  )),
@@ -3681,18 +4111,29 @@ function BookView({ bookId, onBack, flash }) {
3681
4111
  h('div', { className: 'lc-sec' },
3682
4112
  h('div', { className: 'lc-row' },
3683
4113
  h('div', { className: 'lc-grow' }, h('span', { style: { fontWeight: 650 } }, '正文')),
3684
- h('span', { className: 'lc-meta' }, `${body.length} 字`),
4114
+ // 正文改了没存也得说出来。剧本那边一直有这行标记,正文没有:
4115
+ // 人写完一段直接去点顶上的返回,屏幕上没有任何东西拦过他一眼。
4116
+ h('span', { className: 'lc-meta' },
4117
+ bodyDirty ? `${body.length} 字 · 还没存` : `${body.length} 字`),
3685
4118
  ),
4119
+ // 这一章的正文没读到(后台报错、文件被占住):框锁成只读,并当场说清。
4120
+ // 让它能改的话,人会在空框里写一段,再按「存好这一章」,
4121
+ // 存进去的是**另一章**的文件,那一章的原稿就没了。
4122
+ chapterBroken === true
4123
+ ? h(Note, { tone: 'err', icon: 'warning' },
4124
+ '这一章没读出来,所以先锁住了。退出这本书再进来一次;还是不行,就用访达看一眼那个文件夹还在不在。')
4125
+ : null,
3686
4126
  h('textarea', {
3687
4127
  className: 'lc-textarea',
3688
4128
  value: body,
3689
4129
  spellCheck: false,
4130
+ readOnly: chapterBroken === true,
3690
4131
  placeholder: '这一章还空着。让 AI 写一段,或者自己动手。',
3691
4132
  style: { minHeight: 260, marginTop: 6, lineHeight: 1.85 },
3692
4133
  onChange: (e) => { setBody(e.target.value); setBodyDirty(true) },
3693
4134
  }),
3694
4135
  h('div', { className: 'lc-row' },
3695
- h(Btn, { size: 'sm', tone: 'primary', icon: 'check', disabled: busy !== '', onClick: saveBody }, busy === 'save' ? '正在存…' : '存好这一章'),
4136
+ h(Btn, { size: 'sm', tone: 'primary', icon: 'check', disabled: busy !== '' || chapterBroken === true, onClick: saveBody }, busy === 'save' ? '正在存…' : '存好这一章'),
3696
4137
  h(Btn, { size: 'sm', icon: 'doctor', disabled: busy !== '' || body.trim() === '', onClick: doReview },
3697
4138
  busy === 'review' ? '正在挑毛病…' : '挑挑毛病'),
3698
4139
  h('div', { className: 'lc-grow' }),
@@ -3709,6 +4150,67 @@ function BookView({ bookId, onBack, flash }) {
3709
4150
  ),
3710
4151
  ),
3711
4152
 
4153
+ // ── 改成剧本 ──
4154
+ // 用户丢来一份《小说改剧本》,要的就是这一件事:章写完了,能不能变成能拍的东西。
4155
+ // 放在正文下面而不是单独一屏:改剧本看的永远是「这一章」,跟正文分开会让人
4156
+ // 在两屏之间来回确认自己改的是哪一章。
4157
+ h('div', { className: 'lc-sec' },
4158
+ h('div', { className: 'lc-row' },
4159
+ h('div', { className: 'lc-grow' }, h('span', { style: { fontWeight: 650 } }, '改成剧本')),
4160
+ h(Btn, { size: 'sm', tone: 'analyze', icon: 'spark', disabled: busy !== '' || body.trim() === '' || chapterBroken === true, onClick: doScript },
4161
+ busy === 'script' ? '正在改…' : (scriptText.trim() === '' ? '把这一章改成剧本' : '重改一份')),
4162
+ ),
4163
+ h('div', { className: 'lc-meta', style: { marginTop: 4, lineHeight: 1.7 } },
4164
+ // 先说「不会动正文」:人第一眼最怕的是自己的小说被改掉。
4165
+ '只读这一章的正文,小说一个字都不动;改出来的剧本单独存一份。',
4166
+ h('br'),
4167
+ '改出来的是能配音、能拍的剧本:切成一场一场,叙述变成 △ 动作,人物的话变成台词。',
4168
+ h('br'),
4169
+ '小说里那些拍不出来的东西(他心里一沉、命运的齿轮),改的时候会被丢下。'),
4170
+ scriptReport === ''
4171
+ ? null
4172
+ : h('div', {
4173
+ className: 'lc-meta',
4174
+ style: {
4175
+ marginTop: 6, whiteSpace: 'pre-wrap', lineHeight: 1.8,
4176
+ padding: '8px 10px', borderRadius: 8, background: 'var(--lc-analyze-soft)',
4177
+ },
4178
+ }, scriptReport),
4179
+ // 框里有字、或者改过还没存、或者有报告——都得把框和按钮摆出来。
4180
+ // 以前只判「有字」:人把框里的字全删掉,存/删两个按钮跟着一起消失,
4181
+ // 想清空清不掉、想删也删不了,还以为点了没反应。
4182
+ scriptText === '' && scriptDirty !== true && scriptReport === ''
4183
+ ? null
4184
+ : h('div', { className: 'lc-stack', style: { marginTop: 6 } },
4185
+ h('textarea', {
4186
+ className: 'lc-textarea',
4187
+ value: scriptText,
4188
+ spellCheck: false,
4189
+ // 正在存 / 正在重改 / 正在删的时候都不让改:
4190
+ // 改了的字会在回包那一刻被当成「已存」清掉标记,或者被 AI 那一版整份盖掉。
4191
+ readOnly: busy === 'scriptSave' || busy === 'script' || busy === 'scriptDelete',
4192
+ style: { minHeight: 300, lineHeight: 1.8 },
4193
+ onChange: (e) => { setScriptText(e.target.value); setScriptDirty(true) },
4194
+ }),
4195
+ h('div', { className: 'lc-row' },
4196
+ h(Btn, { size: 'sm', tone: 'primary', icon: 'check', disabled: busy !== '' || scriptText.trim() === '', onClick: saveScript },
4197
+ busy === 'scriptSave' ? '正在存…' : '存好这份剧本'),
4198
+ // 「删掉这份」写全:不写清是剧本,人会以为删的是小说正文。
4199
+ h(Btn, { size: 'sm', ghost: true, icon: 'trash', disabled: busy !== '', onClick: removeScript }, '删掉这份剧本'),
4200
+ h('div', { className: 'lc-grow' }),
4201
+ // 字数去掉空白再数:报告里、存好之后的回执里都是这个口径,
4202
+ // 这里多算的空格和换行只会让人以为「存完少了几十个字」。
4203
+ h('span', { className: 'lc-meta' },
4204
+ scriptDirty
4205
+ ? `${scriptText.replace(/\s/g, '').length} 字 · 还没存`
4206
+ : `${scriptText.replace(/\s/g, '').length} 字`),
4207
+ ),
4208
+ ),
4209
+ // 这一节的报错就摆在这一节里。放全页最底下等于没报——
4210
+ // 剧本框本身就三百像素高,报错落到屏幕外,人只会觉得「点了没反应」。
4211
+ scriptErr === null ? null : h(Note, { tone: 'err', icon: 'warning' }, scriptErr),
4212
+ ),
4213
+
3712
4214
  err === null ? null : h(Note, { tone: 'err', icon: 'warning' }, err),
3713
4215
  )
3714
4216
  }
@@ -7341,6 +7843,9 @@ const inject = ['slots']
7341
7843
  // 测试专用口子:这两条路要等宿主服务就绪(ctx.inject)才分得清,
7342
7844
  // 假宿主里造不出 inject,所以允许测试直接把两个服务塞进来。
7343
7845
  exports.__openInterviewSession = openInterviewSession;
7846
+ // 测试专用口子:写小说那一页只有从根部点进去才会出现,而它的换书逻辑
7847
+ // (bookId 变了但组件不卸载)在假根部里绕太远,直接渲染这个组件最省事。
7848
+ exports.__BookView = BookView;
7344
7849
  exports.__setHostServices = (remote, ui) => {
7345
7850
  REMOTE_SESSION = remote === undefined ? null : remote;
7346
7851
  UI_WORKSPACE = ui === undefined ? null : ui;