feat(commands): split & join by sentences

Author: stdword

src/app.ts

@@ -1,10 +1,11 @@
 import { BlockEntity, SettingSchemaDesc } from '@logseq/libs/dist/LSPlugin.user'
 
 import {
-    ICON, editNextBlockCommand, editPreviousBlockCommand, joinBlocksCommand,
+    ICON, editNextBlockCommand, editPreviousBlockCommand, joinAsSentences_Map, joinBlocksCommand,
     joinViaCommas_Attach,
     joinViaNewLines_Attach,
     joinViaNewLines_Map,
+    joinViaSpaces_Attach,
     lastChildBlockCommand, magicJoinCommand, magicSplit,
     moveToBottomOfSiblingsCommand,
     moveToTopOfSiblingsCommand,
@@ -13,7 +14,7 @@ import {
     parentBlockCommand,
     previousSiblingBlockCommand,
     reverseBlocksCommand, shuffleBlocksCommand, sortBlocksCommand, splitBlocksCommand,
-    splitByLines, splitByWords, toggleAutoHeadingCommand,
+    splitByLines, splitBySentences, splitByWords, toggleAutoHeadingCommand,
 } from './commands'
 import { getChosenBlocks, p, scrollToBlock } from './utils'
 
@@ -150,24 +151,33 @@ async function main() {
         keybinding: {},
     }, (e) => splitBlocksCommand(magicSplit, setting_storeChildBlocksIn(), true) )
 
+    logseq.App.registerCommandPalette({
+        label: ICON + ' Split by sentences', key: 'mc-5-split-7-by-sentences',
+        // @ts-expect-error
+        keybinding: {},
+    }, (e) => splitBlocksCommand(splitBySentences, setting_storeChildBlocksIn()))
+    logseq.App.registerCommandPalette({
+        label: ICON + ' Split by sentences (with nested)', key: 'mc-5-split-8-by-sentences-nested',
+        // @ts-expect-error
+        keybinding: {},
+    }, (e) => splitBlocksCommand(
+        splitBySentences, setting_storeChildBlocksIn(), true))
+
 
     // Joining
     logseq.App.registerCommandPalette({
         label: ICON + ' Join via spaces', key: 'mc-6-join-1-spaces',
         // @ts-expect-error
         keybinding: {},
-    }, (e) => joinBlocksCommand(
-        false,
-        (content, level, children) => (content ? content + ' ' : '') + children.join(' '),
-    ))
+    }, (e) => joinBlocksCommand(false, joinViaSpaces_Attach))
 
     logseq.App.registerCommandPalette({
-        label: ICON + ' Join selected together via commas (with respect to root block)', key: 'mc-6-join-2-commas',
+        label: ICON + ' Join together via commas (with respect to root block)', key: 'mc-6-join-2-commas',
         // @ts-expect-error
         keybinding: {},
     }, (e) => joinBlocksCommand(false, joinViaCommas_Attach))
     logseq.App.registerCommandPalette({
-        label: ICON + ' Join selected independently via commas (with respect to root block)', key: 'mc-6-join-3-commas-independently',
+        label: ICON + ' Join independently via commas (with respect to root block)', key: 'mc-6-join-3-commas-independently',
         // @ts-expect-error
         keybinding: {},
     }, (e) => joinBlocksCommand(true, joinViaCommas_Attach))
@@ -184,16 +194,28 @@ async function main() {
     }, (e) => joinBlocksCommand(false, joinViaNewLines_Attach, joinViaNewLines_Map))
 
     logseq.App.registerCommandPalette({
-        label: ICON + ' Magic Join selected together', key: 'mc-6-join-6-magic',
+        label: ICON + ' Magic Join', key: 'mc-6-join-6-magic',
         // @ts-expect-error
         keybinding: {},
     }, (e) => magicJoinCommand(false))
     logseq.App.registerCommandPalette({
-        label: ICON + ' Magic Join selected independently', key: 'mc-6-join-7-magic-independently',
+        label: ICON + ' Magic Join (independently)', key: 'mc-6-join-7-magic-independently',
         // @ts-expect-error
         keybinding: {},
     }, (e) => magicJoinCommand(true))
 
+    logseq.App.registerCommandPalette({
+        label: ICON + ' Join as sentences', key: 'mc-6-join-8-sentences',
+        // @ts-expect-error
+        keybinding: {},
+    }, (e) => joinBlocksCommand(false, joinViaSpaces_Attach, joinAsSentences_Map, {shouldHandleSingleBlock: true}))
+    logseq.App.registerCommandPalette({
+        label: ICON + ' Join as sentences (independently)', key: 'mc-6-join-9-sentences-independently',
+        // @ts-expect-error
+        keybinding: {},
+    }, (e) => joinBlocksCommand(true, joinViaSpaces_Attach, joinAsSentences_Map, {shouldHandleSingleBlock: true}))
+
+
 
     // Navigation
     logseq.App.registerCommandPalette({

src/commands.ts

@@ -387,6 +387,13 @@ export function splitByWords(text: string): IBatchBlock[] {
     return textBlocks.filter((tb) => !!tb).map((tb) => {return {content: tb}})
 }
 
+export function splitBySentences(text: string): IBatchBlock[] {
+    const textBlocks = text.split(/(?<=[.!?…])\s+/)
+    return textBlocks
+        .map((tb) => tb.endsWith('.') ? tb.slice(0, -1) : tb)
+        .map((tb) => {return {content: tb}})
+}
+
 export function magicSplit(text: string): IBatchBlock[] {
     // add special types of ordered lists for parser to recognize it
     // (1)  → 1)
@@ -554,6 +561,12 @@ export async function splitBlocksCommand(
 }
 
 
+export function joinAsSentences_Map(content, level): string {
+    if (content && /(?<![.!?…])$/.test(content))
+        content += '.'
+    return content
+}
+
 export function joinViaNewLines_Attach(content, level, children): string {
     const childrenContent = children.join('\n')
     if (!content)
@@ -577,10 +590,19 @@ export function joinViaCommas_Attach(content, level, children): string {
     return prefix + children.join(', ')
 }
 
+export function joinViaSpaces_Attach(content, level, children): string {
+    if (children.length === 0)
+        return content
+
+    const prefix = content ? content + ' ' : ''
+    return prefix + children.join(' ')
+}
+
 export async function joinBlocksCommand(
     independentMode: boolean,
     joinAttachCallback: (root: string, level: number, children: string[], block?: BlockEntity) => string,
     joinMapCallback?: (content: string, level: number, block: BlockEntity, parent?: BlockEntity) => string,
+    opts: {shouldHandleSingleBlock: boolean} = {shouldHandleSingleBlock: false},
 ) {
     let [ blocks, isSelectedState ] = await getChosenBlocks()
     if (blocks.length === 0)
@@ -598,9 +620,11 @@ export async function joinBlocksCommand(
 
     if (blocks.length === 0)
         return
-    if (blocks.length === 1)
-        if (!blocks[0].children || blocks[0].children.length === 0)
-            return  // nothing to join
+
+    // ensure .children always is array
+    for (const block of blocks)
+        if (!block.children)
+            block.children = []
 
     independentMode = independentMode || blocks.length === 1
 
@@ -641,6 +665,7 @@ export async function joinBlocksCommand(
     if (!noWarnings)
         return
 
+
     // check for properties
     for (const block of blocks) {
         const names = checkPropertyExistenceInTree(block as IBatchBlock, {skipRoot: independentMode})
@@ -684,15 +709,22 @@ export async function joinBlocksCommand(
 
     if (independentMode) {
         for (const block of blocks) {
-            if (!block.children || block.children.length === 0)
-                continue  // nothing to join
+            // fix tsc error: non-undefined
+            block.children = block.children!
+
+            if (block.children.length === 0) {
+                if (!opts.shouldHandleSingleBlock)
+                    continue  // nothing to join
+                else
+                    block.children = []  // ensure non-null
+            }
 
             const content = reduceTree(block as IBatchBlock, {startLevel: 0})
             const properties = PropertiesUtils.fromCamelCaseAll(block.properties)
 
-            if (block._rootHasReferences) {
+            if (block._rootHasReferences || block.children.length === 0) {
                 await logseq.Editor.updateBlock(block.uuid, content, {properties})
-                for (const child of block.children!)
+                for (const child of block.children)
                     await logseq.Editor.removeBlock((child as BlockEntity).uuid)
             } else {
                 await insertBatchBlockBefore(block, {content, properties})