dsh-paste-code-block 0.1.2 → 0.2.5

package/src/i18n.js

@@ -1,8 +1,8 @@
 /**
  * dsh-paste-code-block — locale dictionaries and label logic (pure, no DOM).
  *
- * Canonical source for the user-visible names of pasted blocks ("复制代码块N"
- * vs "Code block #N", etc.). The browser half (`client.js`) embeds its own
+ * Canonical source for the user-visible names of pasted blocks ("代码块 1"
+ * vs "Code #1", etc.). The browser half (`client.js`) embeds its own
  * copy of this logic because DSH's client module loader resolves *package
  * names*, not relative ESM files; this module is the single place where that
  * logic is unit-tested. **Keep `src/i18n.js` and the embedded copy in
@@ -19,8 +19,8 @@ export const NS = 'paste-code-block'
 
 /** Simplified Chinese dictionary (the key-set source of truth). */
 export const zh = {
-  'block.code': '复制代码块{n}',
-  'block.text': '复制文本块{n}',
+  'block.code': '代码块 {n}',
+  'block.text': '文本块 {n}',
   'detail.aria': '代码块详情',
   'slot.label': '粘贴代码块详情',
   'lines.one': '{count} 行',
@@ -34,12 +34,15 @@ export const zh = {
   'edit.aria': '编辑代码块内容',
   'error.stale': '代码块已失效，请重新粘贴',
   'error.remove': '无法删除该块，请重试',
+  'fold.code': '代码块',
+  'fold.text': '文本块',
+  'fold.aria': '展开或折叠该块',
 }
 
 /** English dictionary, key-identical to the Chinese source of truth. */
 export const en = {
-  'block.code': 'Code block #{n}',
-  'block.text': 'Text block #{n}',
+  'block.code': 'Code #{n}',
+  'block.text': 'Text #{n}',
   'detail.aria': 'Block details',
   'slot.label': 'Pasted block details',
   'lines.one': '{count} line',
@@ -53,11 +56,24 @@ export const en = {
   'edit.aria': 'Edit block content',
   'error.stale': 'This block is no longer valid — paste it again',
   'error.remove': 'Could not remove the block — please retry',
+  'fold.code': 'Code',
+  'fold.text': 'Text',
+  'fold.aria': 'Expand or collapse this block',
 }
 
 /** Shipped dictionaries keyed by locale id (mirrors DSH's built-in zh/en set). */
 export const dictionaries = { zh, en }
 
+/**
+ * Pre-0.1.3 chip labels ("复制代码块N" / "Code block #N" …). No longer
+ * rendered, but still recognized by `parseBlockLabel` so chips inserted by an
+ * older bundle keep resolving to their block after an in-place page refresh.
+ */
+export const legacyLabels = {
+  zh: { 'block.code': '复制代码块{n}', 'block.text': '复制文本块{n}' },
+  en: { 'block.code': 'Code block #{n}', 'block.text': 'Text block #{n}' },
+}
+
 /**
  * Standalone translator used only when no DSH locale service is present
  * (defensive fallback outside the standard web composition). English is the
@@ -82,21 +98,34 @@ export function detectBrowserLocale() {
   }
 }
 
-/** Build a block chip label from a translator: 复制代码块2 / Code block #2. */
+/** Build a block chip label from a translator: 代码块 2 / Code #2. */
 export function blockLabel(t, type, n) {
   return t(type === 'code' ? 'block.code' : 'block.text', { n })
 }
 
 /**
- * Recognize a rendered block label in ANY shipped locale and recover its
- * `{ type, n }` identity. This lets a chip click, an ✕ delete, and the
- * locale-switch retitling find the right block even when the chip was
- * inserted under a different language than the one currently active.
- * Returns null for anything that is not a block label.
+ * Build the title of a SENT-message fold card: `python · 128 行` /
+ * `Code · 128 lines`. `lang` (the fence info string) names code cards when
+ * present; text cards and untagged code cards fall back to the localized
+ * type name. Line count always renders, so users can gauge size while the
+ * card is collapsed.
+ */
+export function foldTitle(t, type, lang, lines) {
+  const meta = t(lines === 1 ? 'lines.one' : 'lines.other', { count: lines })
+  const name = type === 'code' ? (lang || t('fold.code')) : t('fold.text')
+  return `${name} · ${meta}`
+}
+
+/**
+ * Recognize a rendered block label in ANY shipped locale (or a pre-0.1.3
+ * legacy locale) and recover its `{ type, n }` identity. This lets a chip
+ * click, an ✕ delete, and the locale-switch retitling find the right block
+ * even when the chip was inserted under a different language than the one
+ * currently active. Returns null for anything that is not a block label.
  */
 export function parseBlockLabel(text) {
   if (!text) return null
-  for (const dict of [dictionaries.zh, dictionaries.en]) {
+  for (const dict of [dictionaries.zh, dictionaries.en, legacyLabels.zh, legacyLabels.en]) {
     for (const key of ['block.code', 'block.text']) {
       const pattern = new RegExp(
         '^' +

package/src/parse.js

@@ -99,4 +99,68 @@ export function countMarkdownSignals(text) {
 export function serializeBlock(block) {
   const lang = block.isCode ? (block.lang || '') : 'text'
   return `\n\`\`\`${lang}\n${block.content}\n\`\`\`\n`
+}
+
+/**
+ * Split a message text into ordered `prose` / `fence` segments using GFM-style
+ * fenced code blocks (``` or ~~~, opening fence indented at most 3 spaces,
+ * closing fence of >= the opening length and alone on its line).
+ *
+ * Used by the sent-message fold scanner (see design.md §12): a message the
+ * plugin serialized on send comes back as fenced text inside the user
+ * bubble, and this function locates the fences so each can be rendered as a
+ * collapsed card while the surrounding prose stays visible.
+ *
+ * Returns [] for empty input. Segments:
+ *  - { kind: 'prose', text }                          — verbatim lines between fences
+ *  - { kind: 'fence', lang, info, body, raw }         — complete, terminated fence
+ *      lang  = first word of the info string ('' when absent)
+ *      info  = trimmed info string
+ *      body  = content between the fence lines (no fences, verbatim)
+ *      raw   = the whole slice including both fence lines
+ * An unterminated opening fence (no matching close) is kept in the prose run
+ * — conservative: we never fold text we are not sure ended.
+ */
+export function splitFencedSegments(text) {
+  const src = String(text == null ? '' : text)
+  if (!src) return []
+  const lines = src.split(/\r?\n/)
+  const segments = []
+  const OPEN = /^ {0,3}(`{3,}|~{3,})(.*)$/
+  let proseStart = 0
+  let i = 0
+  const flushProse = (end) => {
+    if (end > proseStart) segments.push({ kind: 'prose', text: lines.slice(proseStart, end).join('\n') })
+  }
+  while (i < lines.length) {
+    const m = OPEN.exec(lines[i])
+    if (!m) { i += 1; continue }
+    const marker = m[1]
+    const ch = marker[0]
+    const info = m[2].trim()
+    // A ``` fence's info string may not contain backticks (GFM); if it does,
+    // this line is ordinary prose, not an opener.
+    if (ch === '`' && info.includes('`')) { i += 1; continue }
+    const closeRe = new RegExp('^ {0,3}' + (ch === '`' ? '`' : '~') + '{' + marker.length + ',}[ \\t]*$')
+    let j = i + 1
+    let closed = false
+    while (j < lines.length) {
+      if (closeRe.test(lines[j])) { closed = true; break }
+      j += 1
+    }
+    if (!closed) { i += 1; continue } // unterminated -> stays prose, keep scanning
+    flushProse(i)
+    const bodyLines = lines.slice(i + 1, j)
+    segments.push({
+      kind: 'fence',
+      lang: info ? info.split(/\s+/)[0] : '',
+      info,
+      body: bodyLines.join('\n'),
+      raw: lines.slice(i, j + 1).join('\n'),
+    })
+    i = j + 1
+    proseStart = i
+  }
+  flushProse(lines.length)
+  return segments
 }