feat: Export depth options (Export first thought / Export subthoughts)

src/components/modals/Export.tsx

@@ -30,6 +30,7 @@ import * as selection from '../../device/selection'
 import globals from '../../globals'
 import documentSort from '../../selectors/documentSort'
 import exportContext, { exportFilter } from '../../selectors/exportContext'
+import { getChildrenRanked } from '../../selectors/getChildren'
 import getDescendantThoughtIds from '../../selectors/getDescendantThoughtIds'
 import hasMulticursor from '../../selectors/hasMulticursor'
 import simplifyPath from '../../selectors/simplifyPath'
@@ -296,6 +297,8 @@ const ModalExport: FC<{ simplePaths: SimplePath[] }> = ({ simplePaths }) => {
   const [shouldIncludeMetaAttributes, setShouldIncludeMetaAttributes] = useState(false)
   const [shouldIncludeArchived, setShouldIncludeArchived] = useState(false)
   const [shouldIncludeMarkdownFormatting, setShouldIncludeMarkdownFormatting] = useState(true)
+  const [shouldExportFirstThought, setShouldExportFirstThought] = useState(true)
+  const [shouldExportSubthoughts, setShouldExportSubthoughts] = useState(true)
   const [selected, setSelected] = useState(exportOptions[0])
   const [numDescendantsInState, setNumDescendantsInState] = useState<number | null>(null)
 
@@ -348,12 +351,20 @@ const ModalExport: FC<{ simplePaths: SimplePath[] }> = ({ simplePaths }) => {
       // Sort in document order. At this point, all thoughts are pulled and in state.
       const sortedPaths = documentSort(exportedState, simplePaths)
 
-      const exported = sortedPaths
-        .map(simplePath =>
-          exportContext(exportedState, head(simplePath), selected.type, {
+      // When shouldExportFirstThought is false, expand each selected path to its children's IDs.
+      // For single selection this skips the root thought; for multiple selection it skips the entire first level.
+      const exportIds = !shouldExportFirstThought
+        ? sortedPaths.flatMap(simplePath => getChildrenRanked(exportedState, head(simplePath)).map(child => child.id))
+        : sortedPaths.map(simplePath => head(simplePath))
+
+      const exported = exportIds
+        .map(thoughtId =>
+          exportContext(exportedState, thoughtId, selected.type, {
             excludeArchived: !shouldIncludeArchived,
             excludeMarkdownFormatting: !shouldIncludeMarkdownFormatting,
             excludeMeta: !shouldIncludeMetaAttributes,
+            // maxDepth 0 means only the thought itself with no children
+            maxDepth: !shouldExportSubthoughts ? 0 : undefined,
           }),
         )
         .join('\n')
@@ -396,23 +407,32 @@ const ModalExport: FC<{ simplePaths: SimplePath[] }> = ({ simplePaths }) => {
 
       // when exporting HTML, we have to do a full traversal since the numDescendants heuristic of counting the number of lines in the exported content does not work
       if (selected.type === 'text/html' && exportedState) {
-        setNumDescendantsInState(
-          getDescendantThoughtIds(exportedState, id, {
-            filterAndTraverse: thought => shouldIncludeMetaAttributes || thought.value !== '=note',
-            filterFunction: exportFilter({
-              excludeArchived: !shouldIncludeArchived,
-              excludeMeta: !shouldIncludeMetaAttributes,
-            }),
-          }).length,
-        )
+        // When subthoughts are excluded, there are no descendants by definition.
+        const numDescendants = !shouldExportSubthoughts
+          ? 0
+          : getDescendantThoughtIds(exportedState, id, {
+              filterAndTraverse: thought => shouldIncludeMetaAttributes || thought.value !== '=note',
+              filterFunction: exportFilter({
+                excludeArchived: !shouldIncludeArchived,
+                excludeMeta: !shouldIncludeMetaAttributes,
+              }),
+            }).length
+        setNumDescendantsInState(numDescendants)
       }
 
       if (!isPulling) {
         setExportContentFromCursor()
       }
     },
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [selected, shouldIncludeMetaAttributes, shouldIncludeArchived, shouldIncludeMarkdownFormatting],
+    [
+      selected,
+      shouldIncludeMetaAttributes,
+      shouldIncludeArchived,
+      shouldIncludeMarkdownFormatting,
+      shouldExportFirstThought,
+      shouldExportSubthoughts,
+    ],
   )
 
   useEffect(
@@ -551,9 +571,31 @@ const ModalExport: FC<{ simplePaths: SimplePath[] }> = ({ simplePaths }) => {
   /** Updates archived checkbox value when clicked and set the appropriate value in the selected option. */
   const onChangeFormattingCheckbox = () => setShouldIncludeMarkdownFormatting(!shouldIncludeMarkdownFormatting)
 
+  /** Toggles whether the first (top-level) thought is included in the export. */
+  const onChangeExportFirstThoughtCheckbox = () => setShouldExportFirstThought(!shouldExportFirstThought)
+
+  /** Toggles whether subthoughts (descendants) are included in the export. */
+  const onChangeExportSubthoughtsCheckbox = () => setShouldExportSubthoughts(!shouldExportSubthoughts)
+
   /** Created an array of objects so that we can just add object here to get multiple checkbox options created. */
   const advancedSettingsArray: AdvancedSetting[] = useMemo(
     () => [
+      {
+        id: 'exportFirstThought',
+        onChange: onChangeExportFirstThoughtCheckbox,
+        checked: shouldExportFirstThought,
+        title: 'Export first thought',
+        description:
+          'When checked, the top-level thought is included in the export. When unchecked, the first thought is skipped and only its descendants are exported. When multiple thoughts are selected, the entire first level is skipped.',
+      },
+      {
+        id: 'exportSubthoughts',
+        onChange: onChangeExportSubthoughtsCheckbox,
+        checked: shouldExportSubthoughts,
+        title: 'Export subthoughts',
+        description:
+          'When checked, all subthoughts are included in the export. When unchecked, only the top-level thoughts are exported without any descendants.',
+      },
       {
         id: 'meta',
         onChange: onChangeMetaCheckbox,
@@ -583,7 +625,13 @@ const ModalExport: FC<{ simplePaths: SimplePath[] }> = ({ simplePaths }) => {
     ],
 
     // eslint-disable-next-line react-hooks/exhaustive-deps
-    [shouldIncludeArchived, shouldIncludeMetaAttributes, shouldIncludeMarkdownFormatting],
+    [
+      shouldIncludeArchived,
+      shouldIncludeMetaAttributes,
+      shouldIncludeMarkdownFormatting,
+      shouldExportFirstThought,
+      shouldExportSubthoughts,
+    ],
   )
 
   return (

src/selectors/__tests__/exportContext.ts

@@ -241,3 +241,50 @@
     - b
     - c`)
 })
+
+it('maxDepth 0 exports only the root thought with no children', () => {
+  const text = `
+    - a
+      - b
+        - c
+  `
+
+  const steps = [importText({ text }), setCursor(['a'])]
+  const stateNew = reducerFlow(steps)(initialState())
+  const exported = exportContext(stateNew, ['a'], 'text/plain', { maxDepth: 0 })
+
+  expect(exported).toBe(`- a`)
+})
+
+it('maxDepth 1 exports the root thought and its direct children only', () => {
+  const text = `
+    - a
+      - b
+        - c
+      - d
+        - e
+  `
+
+  const steps = [importText({ text }), setCursor(['a'])]
+  const stateNew = reducerFlow(steps)(initialState())
+  const exported = exportContext(stateNew, ['a'], 'text/plain', { maxDepth: 1 })
+
+  expect(exported).toBe(`- a
+  - b
+  - d`)
+})
+
+it('maxDepth 0 exports only the root thought as HTML with no children', () => {
+  const text = `
+    - a
+      - b
+  `
+
+  const steps = [importText({ text }), setCursor(['a'])]
+  const stateNew = reducerFlow(steps)(initialState())
+  const exported = exportContext(stateNew, ['a'], 'text/html', { maxDepth: 0 })
+
+  expect(exported).toBe(`<ul>
+  <li>a  </li>
+</ul>`)
+})

src/selectors/exportContext.ts

@@ -40,14 +40,21 @@ interface Options {
   excludeMeta?: boolean
   /** Exclude archived thoughts. */
   excludeArchived?: boolean
+  /**
+   * Limits the export depth relative to the root thought.
+   * When set to 0, only the root thought is exported with no children.
+   * When set to 1, the root thought and its direct children are exported.
+   * When undefined, all descendants are exported (default).
+   */
+  maxDepth?: number
 }
 
 /** Exports the navigable subtree of the given context. */
 export const exportContext = (
   state: State,
   contextOrThoughtId: Context | ThoughtId,
   format: MimeType = 'text/html',
-  { indent = 0, title, excludeMarkdownFormatting, excludeMeta, excludeSrc, excludeArchived }: Options = {},
+  { indent = 0, title, excludeMarkdownFormatting, excludeMeta, excludeSrc, excludeArchived, maxDepth }: Options = {},
 ): string => {
   const linePostfix = format === 'text/html' ? (indent === 0 ? '  ' : '') + '</li>' : ''
   const tab0 = Array(indent).fill('').join('  ')
@@ -61,7 +68,9 @@ export const exportContext = (
   const context = Array.isArray(contextOrThoughtId) ? contextOrThoughtId : thoughtToContext(state, thoughtId!)
   const isNoteAndMetaExcluded = excludeMeta && head(context) === '=note'
 
-  const childrenFiltered = children.filter(exportFilter({ excludeArchived, excludeMeta }))
+  const childrenFiltered = (maxDepth !== undefined && maxDepth <= 0 ? [] : children).filter(
+    exportFilter({ excludeArchived, excludeMeta }),
+  )
 
   // Note: export single thought without bullet
   const linePrefix = format === 'text/html' ? '<li>' : '- '
@@ -74,6 +83,7 @@ export const exportContext = (
       excludeMeta,
       excludeArchived,
       excludeMarkdownFormatting,
+      maxDepth: maxDepth !== undefined ? maxDepth - 1 : undefined,
       indent: indent + (isNoteAndMetaExcluded ? 0 : format === 'text/html' ? (indent === 0 ? 3 : 2) : 1),
     })