diff --git a/Incido Development Plan.txt b/Incido Development Plan.txt index f4e54f7..780cad7 100644 --- a/Incido Development Plan.txt +++ b/Incido Development Plan.txt @@ -370,6 +370,8 @@ A short reference for AI assistants: | Version | Date | Notes | |---------|------|-------| +| 0.4.1.0 | 2026-09-23 | **Feature release — colour filters + auto-saved drafts, plus Trash & editor polish.** **1. Colour filters.** The drawer gains a horizontal five-swatch strip (Blue / Green / Amber / Red / Purple) between Favorites and Drafts — no labels, the colours are self-explanatory; selecting a swatch shows ONLY **active** notes of that colour (tagged and untagged eligible, trashed never — same rules as Favorites / Untagged), search narrows within the colour, re-tapping the selected swatch returns to Home. `NoteFilter` gains `ByColor` (+ `color:` route parsing in `App.kt`); the repository gains `observeByColor` / `searchByColor` reusing the shared `decorate()` / `matchingNoteIds()` trash-exclusion path. **2. Auto-saved drafts.** New notes persist as drafts while being written: `Note.isDraft` (indexed ObjectBox property; mirrored in `BackupNote`, defaulted false for older backups), `NoteFilter.Drafts` (+ `drafts` route + drawer row) with repository `observeDrafts` / `searchDrafts`; `NoteEditorViewModel` runs a debounced signature-driven autosave with `flushDraft()` on back-navigation / dispose; drafts appear ONLY in the Drafts view until saved (then Home) or trashed (then Trash); an untitled draft is labelled by kind — "Task List — (draft)", "Shopping List — (draft)" — on cards and the editor bar via `NoteType.displayName` + `Note.UNTITLED` (display-only; stored content untouched). **3. Empty Trash.** Trash view shows a `DeleteForever` top-bar action whenever it holds notes, gated by a confirmation `AlertDialog`; `deleteAllTrashed()` cascades note rows + hashtag xrefs + attachment rows exactly like `delete()`. **4. Editor row rebuild.** `EditorLineField` unified on one `BasicTextField` with a hand-drawn 2 dp underline — the old two-branch design mixed M3 `TextField`'s 56 dp min container with compact fields, producing double-height rows; `ChecklistItemRow` moved `Alignment.Top`→`Alignment.CenterVertically` so checkbox / delete / +/- controls ride centred beside wrapping labels. versionCode 35→36, versionName "0.4.0.0"→"0.4.1.0", SettingsViewModel.APP_VERSION bumped in lockstep, README current-release line, PREVIOUS_HISTORY.md section, and the in-app What's New dialog (ReleaseNotes.RECENT — v0.3.7.0 drops off the 5-entry tail). | +| 0.4.0.0 | 2026-09-18 | **Feature release — in-app import of 3rd-party notes.** Settings → Backup & Restore gains an "Import 3rd Party Notes" button that reads a Carnet / QuickNote `.zip` export (a single archive bundling one `.sqd` per note, where each `.sqd` is itself a zip of index.html + metadata.json + optional data/ attachments) and imports every note directly on-device — no pre-conversion step. Rich-text bodies are flattened to plain text; colours, keywords (imported as tags) and links carry over; to-do lists become native checklists; image attachments are imported (auto-generated preview thumbnails are skipped). Import is additive with per-note fault isolation, and imported notes get fresh IDs. New `CarnetImporter` in `composeApp/data/backup` + entry point in the Settings screen/view model. versionCode 34→35, versionName "0.3.8.1"→"0.4.0.0", SettingsViewModel.APP_VERSION bumped in lockstep, README current-release line, PREVIOUS_HISTORY.md section, and the in-app What's New dialog (ReleaseNotes.RECENT — v0.3.6.0 drops off the 5-entry tail). | | 0.3.8.1 | 2026-09-17 | **Emergency hotfix — rebuild / re-release of v0.3.8.0. Zero app-code changes; release-pipeline fix only.** **1. Why.** The release job had been failing to publish reliably. `.gitea/workflows/release.yml` now addresses the Gitea API as `http://192.168.8.17:3000/api/v1/repos/nick/incido` (LAN, direct) instead of the Cloudflare-fronted `https://git.trevena.info/...`, which was the source of the mid-upload 524 origin timeouts that 4a28f4f could only retry around. **2. Signing key rotated — INSTALLED BUILDS CANNOT UPDATE IN PLACE.** The job ran on a runner whose `/var/lib/gitea-runner/work` cache held no `release.jks`, so the mint-if-absent branch (release.yml) generated a NEW certificate; Android rejects an APK whose signing cert differs from the installed one, so v0.3.8.1 must be uninstalled before it will install. Because `allowBackup="false"` (AndroidManifest) keeps notes out of Android's cloud/D2D restore, an uninstall DESTROYS the user's notes — so the release notes lead with "export a backup first" (Settings → Backup → Export, plus Settings → Security → Export encryption key when encryption is on), then uninstall → install → restore. **Follow-up worth doing:** copy the original `release.jks` onto the runner at `/var/lib/gitea-runner/work/release.jks` to restore in-place upgrades and stop the rotation; until then every release repeats this. **3. Lockstep (§11.1).** versionCode 33→34, versionName "0.3.8.0"→"0.3.8.1", SettingsViewModel.APP_VERSION bumped, README current-release line + reinstall warning, PREVIOUS_HISTORY.md section (feeds the release description + `Incido-0.3.8.1-changes.md` asset), and the in-app What's New dialog (ReleaseNotes.RECENT — v0.3.5.1 drops off the 5-entry tail). | | 0.3.8.0 | 2026-09-16 | **Feature release — task lists, shopping lists, hashtag-autocomplete fix** (closes §6.1 "Checklists / to-do items within notes" + "Grocery list with running price total"). **1. Note types.** New `NoteType` enum in `:core/domain` (TEXT / TASK_LIST / SHOPPING_LIST) carried by `Note.type` and an additive `NoteEntity.typeKey` Short column (ObjectBox auto-migrates; old rows = TEXT). List bodies persist as GitHub-flavoured `- [ ] item` lines (`Note.splitListContent` / `serializeListContent`), so content stays the single source of truth: full-text search, AES-GCM field encryption, share-into, the v0.2 inline checklist card summaries, and Trash all keep working untouched. **2. Task-list editor.** Checklist button next to the # tag button in the editor's bottom action row converts the note into editable rows (Checkbox + item text + remove, "+ Add item", first non-checkbox line kept as the title field); tapping the active button reverts to plain text. Active mode tints primary. Cards already showed "- [ ]" open/done counts; shopping cards now show a basket icon instead of the checkbox glyph. **3. Shopping list + running total.** Same mechanism with two structured fields per row: a read-only **quantity picker (1–9)** (`ExposedDropdownMenuBox` — no keyboard ever opens) and a **POS-style price field** (`KeyboardType.Number`; every digit typed is a cent — the field stores the RAW digits verbatim (e.g. `199` = $1.99) so mid-field cursor placement behaves like a normal text field and can never scramble the amount, with a non-editable `$` prefix; the total bar renders dollars). A sticky `ShoppingTotalBar` stays pinned above the rows — always visible, updated live — summing `qty × price` of CHECKED (= in-basket) items in **integer cents** (no binary-float drift). Storage puts both values in an explicit end-of-line marker `- [x] Eggs {q12 p2.40}`, so the PRODUCT TEXT IS NEVER SCANNED FOR NUMBERS ("Battery AA 3", "Poster 50 x 60" stay pure product names); hand-typed §6.1 shapes (`Milk 3.50`, `Eggs 12 x 2.40`) still import once into the structured fields on conversion (decimals required on the legacy forms to avoid exactly that ambiguity). Converting to a task list folds values back into plain text tokens (`Eggs 12 x 2.40`) so nothing is lost across mode switches. **4. Add-tag suggestions repaired.** The autocomplete collector in `NoteEditorViewModel.init` was `tagInputFlow.collect { pool.collect { … } }` over infinite ObjectBox callbackFlows — the outer lambda suspended in the inner collect forever, keystrokes never re-queried, and `openAddTagSheet()` zeroed the list, so the sheet only ever offered "+ Create". Rebuilt on `flatMapLatest` over `tagInputFlow` (sheet opens showing every existing tag most-used-first, filters live per keystroke). **5. Backups** round-trip the new type via defaulted `BackupNote.noteType` ("TEXT") — pre-v0.3.8.0 files import unchanged, `ignoreUnknownKeys` covers older readers; encrypted backups reuse the same shape. ViewModel: `isDirty` gains the type axis; list edits keep `content` synchronised with the row serialisation so save/preview/canSave gates need no changes. versionCode 32→33, versionName "0.3.7.1"→"0.3.8.0", SettingsViewModel.APP_VERSION bumped in lockstep. | | 0.3.7.1 | 2026-08-30 | **Maintenance release — UI polish + one bug fix.** **1. Editor top bar decluttered.** The Add/Edit `TopAppBar` carried six right-side actions (camera, attach, tag, favourite, save, overflow), which crowded the title on narrow screens. Camera / Attach file / Add tag move to a Keep-style bottom action row (hairline `HorizontalDivider` above it; rides above the nav bar / keyboard via the existing IME insets). The top bar is now back + "New note" / "Edit note" title (`maxLines = 1`, ellipsis) + favourite + save + overflow (Move to Trash when editing) — always fits, and matches the §5.2 spec. **2. Image-viewer false failure fixed.** `ImageViewerScreen` checked `bitmap == null` in a `LaunchedEffect` before the async load finished, so a "Couldn't decode image attachment" toast fired on every persisted image open. Replaced with a `loadFailed` state set only after the byte load / decode genuinely fails; the placeholder switches from "Loading…" to "Couldn't load image" (toast removed). **3. Search QoL.** The list search field auto-focuses on open (`FocusRequester` + `LaunchedEffect(state.isSearchActive)`) and gains a trailing clear (✕) button while the query is non-empty. **4. Drawer tag-list overflow fixed.** The scrollable "Recent tags" column in `IncidoDrawer` had no height cap, so long tag lists could overflow the sheet bottom; it now takes `weight(1f)` and scrolls within the remaining height. Dead `_ignored` workaround val removed. **5. Add-tag sheet autofocus.** The sheet's input field is focused on open so the keyboard is already up. Also small hygiene: unused `persistedBytes` param dropped from `AttachmentStrip`; fully-qualified `Spacer` / `Image` / `Column` / `Dispatchers` references replaced with imports. **6. New flat app icon.** `incido_flat_icon.png` (1024×1024, squircle + shield + pen nib, transparent corners) replaces the v0.3.3.8 artwork: LANCZOS-downscaled into `drawable-{mdpi…xxxhdpi}/ic_launcher_foreground.png` (108/162/216/324/432 px, full 108dp canvas — the artwork's fill colour matches the background layer so the squircle edges blend seamlessly) and legacy `mipmap-{mdpi…xxxhdpi}/ic_launcher{,_round}.png` (48/72/96/144/192 px); `ic_launcher_background` re-tinted `#010435` → `#352999`. versionCode 31→32, versionName "0.3.7.0"→"0.3.7.1", SettingsViewModel.APP_VERSION bumped in lockstep. | diff --git a/PREVIOUS_HISTORY.md b/PREVIOUS_HISTORY.md index 3dcc8c8..0fefdf2 100644 --- a/PREVIOUS_HISTORY.md +++ b/PREVIOUS_HISTORY.md @@ -8,6 +8,17 @@ Current downloads ship **with their own notes**: every release on the [Releases --- +## v0.4.1.0 — 2026-09-23 + +New in this release: **colour filters**, **auto-saved drafts** and an **Empty Trash** button — plus a steadier editor. + +- **Colour filters in the drawer.** A horizontal strip of five swatches — Blue, Green, Amber, Red and Purple — sits right under Favorites. Tap a swatch and the list shows ONLY your notes in that colour: untagged colour notes appear, tagged ones appear too, and a trashed note of that colour is never shown — the filter follows the same rules as Favorites and Untagged. Tap the selected swatch again to return to Home. +- Search works inside colour views as well: whatever you type narrows the selected colour's notes, exactly like search does on Favorites. +- **Auto-saved drafts.** A brand-new note now saves itself as a draft while you type — no save button needed, no lost work. If you back out or close the app before finishing, the note waits in the new Drafts row in the navigation drawer; open it again and you are exactly where you left off. +- A draft never gets in your way: it stays out of Home, Favorites, tag views and search until you save the note, and an untitled draft introduces itself by its kind — "Task List — (draft)", "Shopping List — (draft)" — on its card and in the editor's title bar. Drafts ride along in encrypted backups, so a restore brings them back too. +- **Empty Trash.** The Trash view gains an Empty Trash button whenever it holds notes. One tap — confirmed by a dialog first — permanently deletes every trashed note, attachments included. +- **Steadier editor rows.** The to-do and shopping-list editors now render title, item and quantity fields at one even, underlined row height, so rows sit evenly instead of the tall/short mix before. Long task labels wrap inside their row instead of stretching it, and the checkbox, delete and +/- controls stay centred alongside however many lines the label takes. + ## v0.4.0.0 — 2026-09-18 New in this release: **Import 3rd Party Notes**. Settings → Backup & Restore now has an "Import 3rd Party Notes" button that ingests a Carnet / QuickNote `.zip` export — a single archive bundling one `.sqd` per note — straight on-device, with no pre-conversion step. Rich-text bodies are flattened to plain text; note colours, keywords (imported as tags) and links carry over; to-do lists become native checklists; and image attachments are imported (auto-generated preview thumbnails are skipped). Import is additive — existing notes are preserved and imported notes get fresh IDs. diff --git a/README.md b/README.md index f9b963d..5d91c81 100644 --- a/README.md +++ b/README.md @@ -6,18 +6,19 @@ Incido is a privacy-first, on-device note-taking application for Android. All data stays on your device by default — no accounts, no cloud, no trackers. -This repository contains the **v0.4.0.0** release: a single-user, offline +This repository contains the **v0.4.1.0** release: a single-user, offline note app with hashtags, favourites, task lists, shopping lists with a -running total, colour-coded notes, photo and file attachments, -share-into from other apps and the web, importing notes from third-party -apps (Carnet / QuickNote `.zip` exports) directly on-device, Trash (soft -delete with Restore / permanent delete), at-rest AES-256-GCM encryption -with screenshot blocking, PIN / biometric lock, encrypted backup and -restore, and an exportable encryption key for device migrations. The -architecture is multi-module Android today and is structured so iOS / -Desktop ports can happen later without UI rewrites. +running total, colour-coded notes with per-colour swatch filters, +auto-saved drafts, photo and file attachments, share-into from other +apps and the web, importing notes from third-party apps (Carnet / +QuickNote `.zip` exports) directly on-device, Trash (soft delete with +Restore / permanent delete / one-tap Empty Trash), at-rest +AES-256-GCM encryption with screenshot blocking, PIN / biometric lock, +encrypted backup and restore, and an exportable encryption key for +device migrations. The architecture is multi-module Android today and is +structured so iOS / Desktop ports can happen later without UI rewrites. -**Current release:** v0.4.0.0 — full release notes ship **on its entry on +**Current release:** v0.4.1.0 — full release notes ship **on its entry on the [Releases page](https://git.trevena.info/nick/incido/releases)**. > **Upgrading from v0.3.8.0 or earlier?** Releases are signed with a **new CI @@ -174,13 +175,16 @@ After the first push: ``` [ ] Launch app — "Incido" title centred, hamburger top-left -[ ] Tap hamburger → drawer slides in with Home / Favorites / Untagged + divider + Recent tags +[ ] Tap hamburger → drawer slides in with Home / Favorites / colour-swatch strip (Blue·Green·Amber·Red·Purple) / Drafts / Untagged / Trash / Settings + divider + Recent tags [ ] Tap "Favorites" → list shows only starred notes [ ] Tap "Untagged" → list shows only notes with zero hashtags +[ ] Tap a colour swatch (e.g. Blue) → list shows only ACTIVE notes of that colour; untagged ones appear, trashed ones never; search narrows within the colour; tapping the selected swatch again returns to Home +[ ] Start a new note, type, then back out without saving → it lands under "Drafts"; an untitled draft is titled "Task List — (draft)" / "Shopping List — (draft)"; reopening it restores the content; saving it moves it to Home [ ] Tap a recent hashtag → list filters to that tag [ ] Tap "Trash" → list shows only soft-deleted notes [ ] Delete a note → it disappears from Home/search/tag/Favorites and appears in Trash [ ] Trash card overflow → "Restore" returns the note; "Delete permanently" destroys it +[ ] Trash holds notes → "Empty Trash" (∞-forever icon) appears in the top bar → confirm dialog → everything in Trash is permanently deleted [ ] Tap "Home" → back to all active notes [ ] Open a note → chip row above text field shows current tags (empty placeholder if none) [ ] Tap "#" icon → sheet opens, type "wo" → suggestions filter diff --git a/app/build.gradle.kts b/app/build.gradle.kts index e7308f8..051d5e6 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -28,20 +28,24 @@ android { applicationId = "org.incido.app" minSdk = 26 targetSdk = 35 - // v0.4.0.0: MINOR feature release — in-app import of 3rd-party - // notes. Settings → Backup & Restore gains an "Import 3rd Party - // Notes" button that reads a Carnet / QuickNote `.zip` export (a - // single archive bundling one `.sqd` per note, where each `.sqd` is - // itself a zip of index.html + metadata.json + optional data/ - // attachments) and imports every note directly on-device — no - // pre-conversion step. Rich-text bodies are flattened to plain text; - // colours, keywords (as tags) and links carry over; to-do lists - // become native checklists; image attachments are imported (auto- - // generated preview thumbnails are skipped). Import is additive with - // per-note fault isolation. - // - versionCode monotonic +1 from v0.3.8.1 (34). - versionCode = 35 - versionName = "0.4.0.0" + // v0.4.1.0: FEATURE release — colour filters + auto-saved + // drafts, plus Trash & editor polish. The drawer gains a + // five-swatch strip (Blue / Green / Amber / Red / Purple) under + // Favorites: a swatch shows ONLY active notes of that colour + // (untagged included, trashed never), search narrows within it, + // re-tapping returns Home (NoteFilter.ByColor + observeByColor / + // searchByColor on the shared decorate() / matchingNoteIds() + // path). New notes autosave as drafts: Note.isDraft (indexed + // ObjectBox property, carried in backups), a "drafts" route + + // drawer row, and a debounced autosave with flush-on-exit; + // untitled drafts title themselves by kind ("Shopping List — + // (draft)"). Trash gains an Empty Trash button (deleteAllTrashed + // cascade incl. attachments, confirmed by dialog); editor fields + // are rebuilt as uniform-height underlined rows with centred + // checkbox / +/- controls. + // - versionCode monotonic +1 from v0.4.0.0 (35). + versionCode = 36 + versionName = "0.4.1.0" } // --- Signing --- diff --git a/composeApp/src/main/kotlin/org/incido/compose/App.kt b/composeApp/src/main/kotlin/org/incido/compose/App.kt index ee2010a..e89e0a2 100644 --- a/composeApp/src/main/kotlin/org/incido/compose/App.kt +++ b/composeApp/src/main/kotlin/org/incido/compose/App.kt @@ -40,6 +40,7 @@ import org.incido.compose.ui.settings.auth.PinChangeScreen import org.incido.compose.ui.settings.auth.PinEntryScreen import org.incido.compose.ui.settings.auth.PinSetupScreen import org.incido.compose.ui.theme.IncidoTheme +import org.incido.domain.model.NoteColor import org.incido.domain.model.NoteFilter import org.incido.domain.repository.NoteRepository @@ -61,8 +62,13 @@ private fun String.toNoteFilter(): NoteFilter = when { this == "home" -> NoteFilter.Home this == "favorites" -> NoteFilter.Favorites this == "untagged" -> NoteFilter.Untagged + this == "drafts" -> NoteFilter.Drafts this == "trash" -> NoteFilter.Trash startsWith("tag:") -> NoteFilter.ByTag(this.removePrefix("tag:")) + startsWith("color:") -> NoteColor.values() + .firstOrNull { it.name == this.removePrefix("color:") } + ?.let { NoteFilter.ByColor(it) } + ?: NoteFilter.Home else -> NoteFilter.Home } diff --git a/composeApp/src/main/kotlin/org/incido/compose/data/backup/BackupCodec.kt b/composeApp/src/main/kotlin/org/incido/compose/data/backup/BackupCodec.kt index 8bc3b1b..19f2499 100644 --- a/composeApp/src/main/kotlin/org/incido/compose/data/backup/BackupCodec.kt +++ b/composeApp/src/main/kotlin/org/incido/compose/data/backup/BackupCodec.kt @@ -126,6 +126,8 @@ data class BackupNote( val attachments: List = emptyList(), /** Preserve soft-delete state; defaults to false for older backups. */ val isTrashed: Boolean = false, + /** Preserve draft state; defaults to false for older backups. */ + val isDraft: Boolean = false, /** * v0.3.8.0 — serialised as the [org.incido.domain.model.NoteType] * enum name ("TEXT" / "TASK_LIST" / "SHOPPING_LIST"). Defaulted so @@ -163,6 +165,7 @@ private suspend fun Note.toBackup(repository: NoteRepository): BackupNote { isFavorite = isFavorite, color = color.name, isTrashed = isTrashed, + isDraft = isDraft, noteType = type.name, hashtags = hashtags, attachments = backups, @@ -180,6 +183,7 @@ private fun Note.toBackup(): BackupNote = BackupNote( isFavorite = isFavorite, color = color.name, isTrashed = isTrashed, + isDraft = isDraft, noteType = type.name, hashtags = hashtags, attachments = emptyList(), @@ -193,6 +197,7 @@ private fun BackupNote.toDomain(): Note = Note( isFavorite = isFavorite, color = runCatching { NoteColor.valueOf(color) }.getOrDefault(NoteColor.NONE), isTrashed = isTrashed, + isDraft = isDraft, type = runCatching { NoteType.valueOf(noteType) }.getOrDefault(NoteType.TEXT), hashtags = hashtags, // Attachments are inserted separately by importSnapshot so they diff --git a/composeApp/src/main/kotlin/org/incido/compose/data/settings/ReleaseNotes.kt b/composeApp/src/main/kotlin/org/incido/compose/data/settings/ReleaseNotes.kt index 1169720..4c7e589 100644 --- a/composeApp/src/main/kotlin/org/incido/compose/data/settings/ReleaseNotes.kt +++ b/composeApp/src/main/kotlin/org/incido/compose/data/settings/ReleaseNotes.kt @@ -25,6 +25,35 @@ object ReleaseNotes { * Append a new entry on top each release. */ val RECENT: List = listOf( + ReleaseNote( + version = "0.4.1.0", + date = "2026-09-23", + bullets = listOf( + "Colour filters in the drawer: a strip of five swatches " + + "\u2014 Blue, Green, Amber, Red, Purple \u2014 sits " + + "right under Favorites. Tap one and the list shows " + + "ONLY notes of that colour; tap it again for Home.", + "Colour views follow the Favorites / Untagged rules: " + + "trashed notes never show, untagged ones do, and " + + "search narrows within the selected colour.", + "Auto-saved drafts: a new note saves itself while you " + + "type, so nothing is ever lost \u2014 an unfinished " + + "note waits in the new Drafts drawer row, and opening " + + "it again picks up exactly where you stopped.", + "An untitled draft names itself after its kind \u2014 " + + "\"Task List \u2014 (draft)\", \"Shopping List \u2014 " + + "(draft)\" \u2014 on its card and in the editor bar. " + + "Drafts survive encrypted backup and restore too.", + "Empty Trash: a one-tap button appears whenever the " + + "Trash holds notes \u2014 a confirmation dialog " + + "stands between that tap and permanently deleting " + + "every trashed note, attachments included.", + "Editor rows rebuilt: title, item and quantity fields " + + "share one even underlined height, long checklist " + + "labels wrap instead of stretching the row, and " + + "checkbox / +/- controls stay centred alongside.", + ), + ), ReleaseNote( version = "0.4.0.0", date = "2026-09-18", @@ -113,19 +142,6 @@ object ReleaseNotes { "and pen-nib artwork.", ), ), - ReleaseNote( - version = "0.3.7.0", - date = "2026-08-20", - bullets = listOf( - "Trash / soft delete. Deleting a note now moves it to a new " + - "Trash section in the navigation drawer instead of " + - "destroying it immediately \u2014 it disappears from Home, " + - "Favorites, Untagged, tag views, and ordinary search.", - "Inside Trash, each note's menu offers Restore (puts it back " + - "where it was) or Delete permanently (destroys it for " + - "good, including attachments).", - ), - ), - // v0.4.0.0 push drops v0.3.6.0 off the "5 most recent" tail. + // v0.4.1.0 push drops v0.3.7.0 off the "5 most recent" tail. ) } diff --git a/composeApp/src/main/kotlin/org/incido/compose/ui/drawer/IncidoDrawer.kt b/composeApp/src/main/kotlin/org/incido/compose/ui/drawer/IncidoDrawer.kt index 98f92b6..c1e33eb 100644 --- a/composeApp/src/main/kotlin/org/incido/compose/ui/drawer/IncidoDrawer.kt +++ b/composeApp/src/main/kotlin/org/incido/compose/ui/drawer/IncidoDrawer.kt @@ -1,8 +1,15 @@ package org.incido.compose.ui.drawer +import androidx.compose.foundation.background +import androidx.compose.foundation.border +import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height import androidx.compose.foundation.layout.padding @@ -11,7 +18,9 @@ import androidx.compose.foundation.verticalScroll import androidx.compose.material.icons.Icons import androidx.compose.material.icons.filled.Home import androidx.compose.material.icons.filled.LabelOff +import androidx.compose.material.icons.filled.Check import androidx.compose.material.icons.filled.Delete +import androidx.compose.material.icons.filled.Drafts import androidx.compose.material.icons.filled.Settings import androidx.compose.material.icons.filled.Star import androidx.compose.material.icons.filled.Tag @@ -25,17 +34,24 @@ import androidx.compose.material3.NavigationDrawerItemDefaults import androidx.compose.material3.Text import androidx.compose.runtime.Composable import androidx.compose.runtime.getValue +import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.clip +import androidx.compose.ui.graphics.Color import androidx.compose.ui.text.font.FontWeight import androidx.compose.ui.unit.dp import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel +import org.incido.compose.ui.theme.AllNoteColors +import org.incido.compose.ui.theme.toComposeColor import org.incido.domain.model.HashtagUsage +import org.incido.domain.model.NoteColor import org.incido.domain.model.NoteFilter /** - * Left-side navigation drawer. Top section has five fixed entries - * (Home / Favorites / Untagged / Trash / Settings); a `HorizontalDivider`; then + * Left-side navigation drawer. Top section has the fixed entries + * (Home / Favorites / the colour-swatch strip / Drafts / Untagged / + * Trash / Settings); a `HorizontalDivider`; then * a live scrollable list of the user's most-recently-used hashtags. * * Tapping a filter entry calls [onSelectFilter]; tapping Settings @@ -44,6 +60,16 @@ import org.incido.domain.model.NoteFilter * * v0.3.2.0 — Settings is a new entry directly underneath "Untagged" * with its own divider for visual separation. + * + * Colour filters sit between "Favorites" and "Drafts" as one + * horizontal strip of swatches — the colours are self-explanatory, so + * there are no labels. Selecting one shows ONLY active notes of that + * colour — trashed notes never appear, untagged ones do (see + * NoteFilter.ByColor); tapping the selected swatch again returns to + * Home. + * + * "Drafts" lists auto-saved new notes (see Note.isDraft) — a new note + * is persisted automatically while it is being written. */ @OptIn(ExperimentalMaterial3Api::class) @Composable @@ -82,6 +108,64 @@ fun IncidoDrawer( onClick = { onSelectFilter(NoteFilter.Favorites) }, icon = { Icon(Icons.Filled.Star, contentDescription = null) }, ) + // Colour filters: one horizontal strip of swatches under + // Favorites (NONE is not offered; the colours are + // self-explanatory, so there are no labels). Each shows + // ONLY active notes of that colour — trashed notes never + // appear, untagged ones do. Tapping the selected swatch + // again returns to Home. + Row( + modifier = Modifier + .fillMaxWidth() + .padding(vertical = 6.dp), + horizontalArrangement = Arrangement.spacedBy( + space = 14.dp, + alignment = Alignment.CenterHorizontally, + ), + ) { + AllNoteColors.filter { it != NoteColor.NONE }.forEach { color -> + val selected = currentFilter == NoteFilter.ByColor(color) + Box( + modifier = Modifier + .size(30.dp) + .clip(CircleShape) + .background(color.toComposeColor()) + .then( + if (selected) { + Modifier.border( + width = 3.dp, + color = MaterialTheme.colorScheme.onSurface, + shape = CircleShape, + ) + } else { + Modifier + }, + ) + .clickable { + onSelectFilter( + if (selected) NoteFilter.Home + else NoteFilter.ByColor(color), + ) + }, + contentAlignment = Alignment.Center, + ) { + if (selected) { + Icon( + Icons.Filled.Check, + contentDescription = "${color.label} filter selected", + modifier = Modifier.size(16.dp), + tint = Color.White, + ) + } + } + } + } + NavigationDrawerItem( + label = { Text("Drafts") }, + selected = currentFilter == NoteFilter.Drafts, + onClick = { onSelectFilter(NoteFilter.Drafts) }, + icon = { Icon(Icons.Filled.Drafts, contentDescription = null) }, + ) NavigationDrawerItem( label = { Text("Untagged") }, selected = currentFilter == NoteFilter.Untagged, diff --git a/composeApp/src/main/kotlin/org/incido/compose/ui/editor/NoteEditorScreen.kt b/composeApp/src/main/kotlin/org/incido/compose/ui/editor/NoteEditorScreen.kt index 3d4326b..a264db7 100644 --- a/composeApp/src/main/kotlin/org/incido/compose/ui/editor/NoteEditorScreen.kt +++ b/composeApp/src/main/kotlin/org/incido/compose/ui/editor/NoteEditorScreen.kt @@ -24,7 +24,6 @@ import androidx.compose.foundation.layout.WindowInsets import androidx.compose.foundation.layout.fillMaxSize import androidx.compose.foundation.layout.fillMaxWidth import androidx.compose.foundation.layout.height -import androidx.compose.foundation.layout.heightIn import androidx.compose.foundation.layout.ime import androidx.compose.foundation.layout.padding import androidx.compose.foundation.layout.size @@ -37,6 +36,8 @@ import androidx.compose.foundation.lazy.items import androidx.compose.foundation.lazy.itemsIndexed import androidx.compose.foundation.shape.CircleShape import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.text.BasicTextField +import androidx.compose.foundation.text.KeyboardActions import androidx.compose.foundation.text.KeyboardOptions import androidx.compose.material.icons.Icons import androidx.compose.material.icons.automirrored.filled.ArrowBack @@ -71,12 +72,11 @@ import androidx.compose.material3.SnackbarHostState import androidx.compose.material3.SuggestionChip import androidx.compose.material3.Surface import androidx.compose.material3.Text -import androidx.compose.material3.TextField -import androidx.compose.material3.TextFieldDefaults import androidx.compose.material3.TextButton import androidx.compose.material3.TopAppBar import androidx.compose.material3.rememberModalBottomSheetState import androidx.compose.runtime.Composable +import androidx.compose.runtime.DisposableEffect import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue import androidx.compose.runtime.mutableStateOf @@ -88,10 +88,14 @@ import androidx.compose.runtime.setValue import androidx.compose.ui.Alignment import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip +import androidx.compose.ui.draw.drawBehind import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester import androidx.compose.ui.focus.onFocusEvent +import androidx.compose.ui.geometry.Offset +import androidx.compose.ui.geometry.Size import androidx.compose.ui.graphics.Color +import androidx.compose.ui.graphics.SolidColor import androidx.compose.ui.graphics.asImageBitmap import androidx.compose.ui.graphics.painter.BitmapPainter import androidx.compose.ui.layout.ContentScale @@ -271,11 +275,25 @@ fun NoteEditorScreen( } fun tryClose() { + // Drafts (new notes and draft editing) autosave every edit, so + // leaving is always lossless: flush any in-flight change and pop + // — no "Discard changes?" prompt. + if (viewModel.isDraftFlow) { + viewModel.flushDraft() + onClose() + return + } if (isDirty()) showDiscardDialog = true else onClose() } BackHandler(enabled = true) { tryClose() } + // Any other exit path (rotation, nav teardown) also flushes pending + // draft edits immediately. + DisposableEffect(viewModel) { + onDispose { viewModel.flushDraft() } + } + if (showDiscardDialog) { AlertDialog( onDismissRequest = { showDiscardDialog = false }, @@ -308,7 +326,11 @@ fun NoteEditorScreen( TopAppBar( title = { Text( - text = if (state.isEditing) "Edit note" else "New note", + text = when { + state.isDraft -> draftBarTitle(state) + state.isEditing -> "Edit note" + else -> "New note" + }, maxLines = 1, overflow = TextOverflow.Ellipsis, ) @@ -428,6 +450,7 @@ fun NoteEditorScreen( onItemCostChange = viewModel::setItemCost, onRemoveItem = viewModel::removeListItem, onAddItem = viewModel::addListItem, + onAddItemAfter = viewModel::addListItemAfter, ) } @@ -996,7 +1019,12 @@ private fun ChecklistEditorBody( onItemCostChange: (Int, String) -> Unit, onRemoveItem: (Int) -> Unit, onAddItem: () -> Unit, + onAddItemAfter: (Int) -> Unit, ) { + // Enter/Return in a task/product row inserts the next row and moves + // the cursor into it. The nonce re-fires the new row's focus effect + // even when the same index is targeted repeatedly. + var focusTarget by remember { mutableStateOf(-1 to 0L) } LazyColumn(modifier = modifier.fillMaxWidth()) { item { // Title / preamble. Kept as plain lines above the checkbox @@ -1015,10 +1043,19 @@ private fun ChecklistEditorBody( .padding(horizontal = 16.dp, vertical = 4.dp), ) } + if (isShopping) { + item { ShoppingColumnHeader() } + } itemsIndexed(items) { index, item -> ChecklistItemRow( item = item, isShopping = isShopping, + focusOnCompose = focusTarget.first == index, + focusNonce = focusTarget.second, + onAddAfter = { + onAddItemAfter(index) + focusTarget = (index + 1) to focusTarget.second + 1 + }, onToggle = { checked -> onToggleItem(index, checked) }, onTextChange = { text -> onItemTextChange(index, text) }, onQuantityChange = { qty -> onItemQuantityChange(index, qty) }, @@ -1040,21 +1077,80 @@ private fun ChecklistEditorBody( } } -/** One row: `[ ]` · Product · Qty picker · per-item price · remove. */ +/** + * Small "Product / Amnt. / Price" label line above the shopping rows. + * Mirrors [ChecklistItemRow]'s column geometry (checkbox spacer + + * weighted product + fixed qty/price widths) so the labels sit over + * their columns and the fields themselves stay uncluttered. + */ +@Composable +private fun ShoppingColumnHeader() { + val labelStyle = MaterialTheme.typography.labelSmall + val labelColor = MaterialTheme.colorScheme.onSurfaceVariant + Row( + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 8.dp), + ) { + Spacer(Modifier.size(48.dp)) // checkbox column + Text( + "Product", + style = labelStyle, + color = labelColor, + modifier = Modifier + .weight(1f) + .padding(start = 16.dp, top = 16.dp), + ) + Spacer(Modifier.size(6.dp)) + Text( + "Amnt.", + style = labelStyle, + color = labelColor, + modifier = Modifier + .width(44.dp) + .padding(start = 4.dp, top = 16.dp), + ) + Spacer(Modifier.size(6.dp)) + Text( + "Price", + style = labelStyle, + color = labelColor, + modifier = Modifier + .width(56.dp) + .padding(start = 4.dp, top = 16.dp), + ) + Spacer(Modifier.size(48.dp)) // remove-button column + } +} + +/** One row: `[ ]` · Product (grows multi-line) · Qty · price · remove. */ @Composable private fun ChecklistItemRow( item: ChecklistItem, isShopping: Boolean, + focusOnCompose: Boolean, + focusNonce: Long, + onAddAfter: () -> Unit, onToggle: (Boolean) -> Unit, onTextChange: (String) -> Unit, onQuantityChange: (String) -> Unit, onCostChange: (String) -> Unit, onRemove: () -> Unit, ) { + // Enter on the row above lands the cursor here (see [focusOnCompose] + // in ChecklistEditorBody — the target is always a freshly inserted + // row, so focusing on first composition is enough). + val textFocus = remember { FocusRequester() } + LaunchedEffect(focusNonce) { + if (focusOnCompose) textFocus.requestFocus() + } Row( modifier = Modifier .fillMaxWidth() .padding(horizontal = 8.dp), + // Controls hug the field's vertical centre, so the checkbox, + // quantity / price columns and the remove ✕ travel with the + // row as a long entry wraps onto extra lines. verticalAlignment = Alignment.CenterVertically, ) { Checkbox(checked = item.checked, onCheckedChange = onToggle) @@ -1065,24 +1161,32 @@ private fun ChecklistItemRow( EditorLineField( value = item.text, onValueChange = onTextChange, - placeholder = if (isShopping) "Product" else "Task", + // Shopping rows are labelled by the ShoppingColumnHeader + // above, so the fields stay empty-clean; plain task rows keep + // their single "Task" hint. + placeholder = if (isShopping) "" else "Task", keyboardOptions = KeyboardOptions( capitalization = KeyboardCapitalization.Sentences, imeAction = ImeAction.Next, ), + // Enter/Return (IME "Next") creates the following row and + // moves the cursor there instead of tabbing sideways. + keyboardActions = KeyboardActions(onNext = { onAddAfter() }), + // Long text wraps onto more lines (field grows downward) + // instead of scrolling sideways out of view. + singleLine = false, + maxLines = 6, + fieldModifier = Modifier.focusRequester(textFocus), modifier = Modifier.weight(1f), ) if (isShopping) { Spacer(Modifier.size(6.dp)) - // Free-text quantity line (replaced the 1–9 dropdown, whose - // digit never fit its box). Blank means quantity 1: while - // focused an empty line shows the "Quan." hint; on focus + // Free-text quantity line. Blank means quantity 1: on focus // loss it settles on "1" — display-only, storage keeps the // blank default so {q1} never enters the saved text. EditorLineField( value = item.quantity, onValueChange = onQuantityChange, - placeholder = "Quan.", keyboardOptions = KeyboardOptions( keyboardType = KeyboardType.Number, imeAction = ImeAction.Next, @@ -1090,7 +1194,8 @@ private fun ChecklistItemRow( formatUnfocused = { digits -> if (digits.isEmpty()) "1" else digits }, - modifier = Modifier.width(72.dp), + compact = true, + modifier = Modifier.width(44.dp), ) Spacer(Modifier.size(6.dp)) // Supermarket-style cents entry: while focused the line shows @@ -1100,7 +1205,6 @@ private fun ChecklistItemRow( EditorLineField( value = item.cost, onValueChange = onCostChange, - placeholder = "Price", keyboardOptions = KeyboardOptions( keyboardType = KeyboardType.Number, imeAction = ImeAction.Next, @@ -1108,7 +1212,8 @@ private fun ChecklistItemRow( formatUnfocused = { digits -> if (digits.isEmpty()) "" else "$" + Note.amountFromPriceDigits(digits) }, - modifier = Modifier.width(110.dp), + compact = true, + modifier = Modifier.width(56.dp), ) } IconButton(onClick = onRemove) { @@ -1130,6 +1235,21 @@ private fun ChecklistItemRow( private fun editorFieldStyle(): TextStyle = MaterialTheme.typography.bodyMedium.copy(fontSize = 13.sp, lineHeight = 18.sp) +/** + * Top-bar label while a draft session is live. A draft that already + * carries a title just says "Draft"; one with NO title names itself + * after its kind — "Task List - (draft)", "Shopping List - (draft)" — + * mirroring the Drafts card title so both surfaces agree. (TEXT drafts + * take their title from the first content line, so they always land in + * the "Draft" branch.) + */ +private fun draftBarTitle(state: NoteEditorUiState): String { + val titleSource = + if (state.type == NoteType.TEXT) state.content else state.listHeader + val hasTitle = titleSource.lineSequence().any { it.isNotBlank() } + return if (hasTitle) "Draft" else "${state.type.displayName} - (draft)" +} + /** * v0.3.8.0 — one plain underlined editing line, shared by every editable * field in the editor (title, task/product, quantity, price). Replaces @@ -1147,7 +1267,11 @@ private fun EditorLineField( onValueChange: (String) -> Unit, placeholder: String = "", keyboardOptions: KeyboardOptions = KeyboardOptions.Default, + keyboardActions: KeyboardActions = KeyboardActions.Default, formatUnfocused: ((String) -> String)? = null, + singleLine: Boolean = true, + maxLines: Int = 1, + compact: Boolean = false, fieldModifier: Modifier = Modifier, modifier: Modifier = Modifier, ) { @@ -1156,43 +1280,65 @@ private fun EditorLineField( var focused by remember { mutableStateOf(false) } val displayed = if (focused || formatUnfocused == null) value else formatUnfocused(value) - Row( - modifier = modifier.heightIn(min = 44.dp), - verticalAlignment = Alignment.CenterVertically, - ) { - // Material 3 filled TextField with fully transparent containers: - // what remains visible is just the text line and the 2 dp bottom - // indicator — exactly the "one line per field" look, for free. - TextField( - value = displayed, - onValueChange = onValueChange, - singleLine = true, - placeholder = { - Text( - text = placeholder, - style = fieldStyle, - color = hintColor, - maxLines = 1, - ) - }, - textStyle = fieldStyle.copy( - color = MaterialTheme.colorScheme.onSurface, - ), - keyboardOptions = keyboardOptions, - colors = TextFieldDefaults.colors( - focusedContainerColor = Color.Transparent, - unfocusedContainerColor = Color.Transparent, - disabledContainerColor = Color.Transparent, - errorContainerColor = Color.Transparent, - focusedIndicatorColor = MaterialTheme.colorScheme.primary, - unfocusedIndicatorColor = MaterialTheme.colorScheme.outlineVariant, - cursorColor = MaterialTheme.colorScheme.primary, - ), - modifier = fieldModifier - .weight(1f) - .onFocusEvent { focused = it.isFocused }, - ) + // v0.4.x: EVERY field — product/task text, quantity, price, header — + // is one content-hugging BasicTextField with a hand-drawn 2 dp + // bottom rule (the [compact] flag no longer changes rendering). The + // Material 3 TextField's baked-in 56 dp minimum container made even + // an empty field look double-height and pinned the row's checkbox / + // price controls to the top edge; now a single line of text is a + // single line of field, and singleLine = false fields grow + // line-by-line up to [maxLines] as the entry wraps. + val indicatorColor = if (focused) { + MaterialTheme.colorScheme.primary + } else { + MaterialTheme.colorScheme.outlineVariant } + BasicTextField( + value = displayed, + onValueChange = onValueChange, + singleLine = singleLine, + maxLines = maxLines, + textStyle = fieldStyle.copy(color = MaterialTheme.colorScheme.onSurface), + keyboardOptions = keyboardOptions, + keyboardActions = keyboardActions, + cursorBrush = SolidColor(MaterialTheme.colorScheme.primary), + decorationBox = { innerTextField -> + // The 10 / 4 dp block gives a slim underlined line a comfy + // tap target; the rule below lands on the block's bottom + // edge, so it always sits 4 dp under the LAST text line — + // one line or six. + Box( + modifier = Modifier.padding(top = 10.dp, bottom = 4.dp), + contentAlignment = Alignment.CenterStart, + ) { + if (displayed.isEmpty() && placeholder.isNotEmpty()) { + Text( + text = placeholder, + style = fieldStyle, + color = hintColor, + maxLines = 1, + ) + } + innerTextField() + } + }, + // NOTE: the caller's [modifier] (weight(1f) for the product + // column, fixed 44/56.dp for quantity/price) MUST stay in the + // chain — dropping it lets fillMaxWidth() win the Row and + // swallow the neighbouring columns. + modifier = fieldModifier + .then(modifier) + .fillMaxWidth() + .padding(bottom = 2.dp) + .drawBehind { + drawRect( + color = indicatorColor, + topLeft = Offset(0f, size.height - 2.dp.toPx()), + size = Size(size.width, 2.dp.toPx()), + ) + } + .onFocusEvent { focused = it.isFocused }, + ) } // --------------------------------------------------------------------- diff --git a/composeApp/src/main/kotlin/org/incido/compose/ui/editor/NoteEditorViewModel.kt b/composeApp/src/main/kotlin/org/incido/compose/ui/editor/NoteEditorViewModel.kt index cbb8905..81b5e65 100644 --- a/composeApp/src/main/kotlin/org/incido/compose/ui/editor/NoteEditorViewModel.kt +++ b/composeApp/src/main/kotlin/org/incido/compose/ui/editor/NoteEditorViewModel.kt @@ -8,11 +8,15 @@ import androidx.lifecycle.viewmodel.initializer import androidx.lifecycle.viewmodel.viewModelFactory import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.FlowPreview import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.SharingStarted import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.debounce +import kotlinx.coroutines.flow.distinctUntilChanged import kotlinx.coroutines.flow.flatMapLatest +import kotlinx.coroutines.flow.map import kotlinx.coroutines.flow.stateIn import kotlinx.coroutines.flow.update import kotlinx.coroutines.launch @@ -95,6 +99,9 @@ data class NoteEditorUiState( /** `true` when editing an existing note (existing != null). */ val isEditing: Boolean get() = existing != null + /** `true` while this note is an auto-saved draft (see Note.isDraft). */ + val isDraft: Boolean get() = existing?.isDraft == true + /** `true` when there's still room to add another tag. */ val canAddMoreTags: Boolean get() = hashtags.size < MAX_TAGS @@ -145,7 +152,7 @@ data class PendingAttachment( val isImage: Boolean get() = mimeType.startsWith("image/") } -@OptIn(ExperimentalCoroutinesApi::class) +@OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class) class NoteEditorViewModel( private val repository: NoteRepository, private val noteId: Long?, @@ -209,6 +216,36 @@ class NoteEditorViewModel( */ private var nextPendingTempId: Long = -System.currentTimeMillis() + /** + * Draft autosave. A NEW note (or one still flagged as a draft) is + * persisted automatically: every edit lands in the DB ~400 ms after + * the last keystroke (coalesced so typing doesn't write per char), + * and [flushDraft] forces an immediate write whenever the editor + * closes or disposes. A crash can therefore only ever lose the last + * few keystrokes — never a whole draft. + */ + private val draftAutosave = noteId == null || noteId == 0L + + /** True while this session autosaves: brand-new notes and draft editing. */ + val isDraftFlow: Boolean + get() = draftAutosave || _state.value.isDraft + + private var draftPersistInProgress = false + + init { + // Signature-driven debounced autosave: whenever anything a draft + // persists changes, write the draft row shortly after. + viewModelScope.launch { + _state + .map { s -> + listOf(s.content, s.isFavorite, s.color, s.type, s.hashtags) + } + .distinctUntilChanged() + .debounce(DRAFT_AUTOSAVE_DEBOUNCE_MS) + .collect { persistDraftNow() } + } + } + init { // Tag autocomplete — re-query on every keystroke (debounced upstream // would be nice but ObjectBox is plenty fast for this size). @@ -294,6 +331,10 @@ class NoteEditorViewModel( initialHashtags = note.hashtags initialType = note.type } + // Draft echoes: emissions caused by our own autosave + // must not clobber in-progress edits mid-typing — + // the local state is authoritative while drafting. + if (note != null && note.isDraft && !firstLoad) return@collect // Parse list rows once on first load; later DB // emissions must not clobber in-progress edits. val listSeed: Pair>? = @@ -459,6 +500,20 @@ class NoteEditorViewModel( } } + /** + * Insert a blank row right after [index] (or append it on the last + * row). Driven by Enter/Return in the task/product field so the + * writer flows downward into a fresh row instead of tabbing sideways. + */ + fun addListItemAfter(index: Int) { + _state.update { s -> + if (s.type == NoteType.TEXT) return@update s + if (index !in s.items.indices) return@update s + val updated = s.items.toMutableList().also { it.add(index + 1, ChecklistItem("")) } + s.withListEdits(items = updated) + } + } + fun removeListItem(index: Int) { _state.update { s -> if (index !in s.items.indices) return@update s @@ -587,17 +642,74 @@ class NoteEditorViewModel( // ---- save ---- + /** + * Force-write the current draft state to the DB right now — used + * when the editor closes / disposes so pending edits never sit in + * the debounce window. No-op for non-draft sessions and blank + * content (see [persistDraftNow]). + */ + fun flushDraft() { + viewModelScope.launch { persistDraftNow() } + } + + /** Write the draft row if this session is in the draft lifecycle. */ + private suspend fun persistDraftNow() { + val current = _state.value + if (current.isLoading || current.isSaving) return + if (draftPersistInProgress) return + val baseNote = current.existing + if (baseNote != null && !baseNote.isDraft) return // already published + if (!draftAutosave && baseNote?.isDraft != true) return + if (current.content.isBlank()) return + draftPersistInProgress = true + try { + val now = System.currentTimeMillis() + val draft = baseNote?.copy( + content = current.content, + isFavorite = current.isFavorite, + color = current.color, + type = current.type, + isDraft = true, + ) ?: Note( + content = current.content, + createdAt = now, + updatedAt = now, + isFavorite = current.isFavorite, + color = current.color, + type = current.type, + isDraft = true, + ) + val previous = baseNote?.hashtags.orEmpty().toSet() + val currentSet = current.hashtags.toSet() + val saved = repository.saveNoteWithHashtags( + note = draft, + hashtagsToAdd = currentSet - previous, + hashtagsToRemove = previous - currentSet, + ) + // Adopt the persisted row so every later write updates the + // SAME note — one draft per editing session. + _state.update { + it.copy(existing = saved.copy(isDraft = true, hashtags = current.hashtags)) + } + } finally { + draftPersistInProgress = false + } + } + fun save(onDone: () -> Unit) { val current = _state.value if (!current.canSave) return _state.update { it.copy(isSaving = true) } viewModelScope.launch { val baseNote = current.existing + // An explicit Save PUBLISHES the note: a draft row loses + // its flag here and joins the normal views for good. val toPersist = baseNote?.copy( content = current.content, isFavorite = current.isFavorite, color = current.color, type = current.type, + isDraft = false, ) ?: Note( content = current.content, createdAt = System.currentTimeMillis(), @@ -643,6 +755,9 @@ class NoteEditorViewModel( } companion object { + /** Typing-pause before a draft autosave fires (ms). */ + const val DRAFT_AUTOSAVE_DEBOUNCE_MS = 400L + fun factory( noteId: Long?, initialSharedText: String? = null, diff --git a/composeApp/src/main/kotlin/org/incido/compose/ui/notelist/NoteListScreen.kt b/composeApp/src/main/kotlin/org/incido/compose/ui/notelist/NoteListScreen.kt index 89ebc93..f9eb31b 100644 --- a/composeApp/src/main/kotlin/org/incido/compose/ui/notelist/NoteListScreen.kt +++ b/composeApp/src/main/kotlin/org/incido/compose/ui/notelist/NoteListScreen.kt @@ -29,6 +29,7 @@ import androidx.compose.material.icons.filled.AttachFile import androidx.compose.material.icons.filled.CheckBox import androidx.compose.material.icons.filled.Close import androidx.compose.material.icons.filled.Delete +import androidx.compose.material.icons.filled.DeleteForever import androidx.compose.material.icons.filled.Lock import androidx.compose.material.icons.filled.Menu import androidx.compose.material.icons.filled.MoreVert @@ -38,6 +39,7 @@ import androidx.compose.material.icons.filled.Search import androidx.compose.material.icons.filled.ShoppingBasket import androidx.compose.material.icons.filled.Star import androidx.compose.material.icons.outlined.StarOutline +import androidx.compose.material3.AlertDialog import androidx.compose.material3.Card import androidx.compose.material3.CardDefaults import androidx.compose.material3.CenterAlignedTopAppBar @@ -51,6 +53,7 @@ import androidx.compose.material3.MaterialTheme import androidx.compose.material3.OutlinedTextField import androidx.compose.material3.Scaffold import androidx.compose.material3.Text +import androidx.compose.material3.TextButton import androidx.compose.runtime.Composable import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.getValue @@ -127,6 +130,7 @@ fun NoteListScreen( ) { val state by viewModel.uiState.collectAsStateWithLifecycle() var localQuery by remember { mutableStateOf("") } + var showEmptyTrashDialog by remember { mutableStateOf(false) } val searchFocusRequester = remember { FocusRequester() } LaunchedEffect(filterMode) { viewModel.setFilter(filterMode) } @@ -139,6 +143,36 @@ fun NoteListScreen( } } + // "Empty Trash" confirmation. The whole trash goes, attachments + // included — say so plainly before the one tap that does it. + if (showEmptyTrashDialog) { + AlertDialog( + onDismissRequest = { showEmptyTrashDialog = false }, + title = { Text("Empty Trash?") }, + text = { + Text( + "Every note in the Trash, including attachments, will be " + + "permanently deleted. This cannot be undone.", + ) + }, + confirmButton = { + TextButton( + onClick = { + showEmptyTrashDialog = false + viewModel.emptyTrash() + }, + ) { + Text("Empty Trash", color = MaterialTheme.colorScheme.error) + } + }, + dismissButton = { + TextButton(onClick = { showEmptyTrashDialog = false }) { + Text("Cancel") + } + }, + ) + } + Scaffold( topBar = { CenterAlignedTopAppBar( @@ -162,6 +196,17 @@ fun NoteListScreen( Icon(Icons.Default.Search, contentDescription = "Search notes") } } + // Trash view gains an "Empty Trash" button whenever it + // holds something; the destructive action is confirmed + // through a dialog before anything is touched. + if (filterMode == NoteFilter.Trash && state.notes.isNotEmpty()) { + IconButton(onClick = { showEmptyTrashDialog = true }) { + Icon( + Icons.Default.DeleteForever, + contentDescription = "Empty trash", + ) + } + } }, ) }, @@ -234,8 +279,10 @@ private fun screenTitle(filter: NoteFilter): String = when (filter) { NoteFilter.Home -> "Incido" NoteFilter.Favorites -> "Favorites" NoteFilter.Untagged -> "Untagged" + NoteFilter.Drafts -> "Drafts" NoteFilter.Trash -> "Trash" is NoteFilter.ByTag -> "#${filter.hashtag}" + is NoteFilter.ByColor -> filter.color.label } @Composable @@ -244,8 +291,10 @@ private fun EmptyState(filterMode: NoteFilter) { NoteFilter.Home -> "No notes yet. Tap + to start." NoteFilter.Favorites -> "No favourites yet. Tap ⭐ on a card to add one." NoteFilter.Untagged -> "All notes are tagged. 🎉" + NoteFilter.Drafts -> "No drafts yet. Start typing a new note and it lands here." NoteFilter.Trash -> "Trash is empty." is NoteFilter.ByTag -> "No notes tagged #${filterMode.hashtag} yet." + is NoteFilter.ByColor -> "No " + filterMode.color.label.lowercase() + " notes yet. Pick a colour in the editor." } Box( modifier = Modifier @@ -265,7 +314,9 @@ private fun EmptyState(filterMode: NoteFilter) { private fun NoResultsState(filterMode: NoteFilter) { val message = when (filterMode) { NoteFilter.Home -> "No matching notes." + NoteFilter.Drafts -> "No drafts match your search." NoteFilter.Trash -> "No notes in Trash match your search." + is NoteFilter.ByColor -> "No matching notes of this colour." else -> "Nothing here." } Box( @@ -395,6 +446,14 @@ private fun NoteCard( // text. The checkbox state lives in the summary row below instead. val (title, body) = if (note.type == NoteType.TEXT) Note.titleAndBody(note.content) else Note.cardPresentation(note.content, note.type) + // Drafts with no title introduce themselves by kind — "Shopping + // List - (draft)" beats a bare "Untitled" in the Drafts view. The + // stored content is untouched; this is display-only, so typing a + // real title (or publishing) reverts the card to normal instantly. + val displayTitle = + if (note.isDraft && title == Note.UNTITLED) + "${note.type.displayName} - (draft)" + else title val bodyPreview = Note.bodyPreview(body) val checklistSummary = Note.checklistSummary(note.content) val noteColor = note.color @@ -508,7 +567,7 @@ private fun NoteCard( verticalAlignment = Alignment.CenterVertically, ) { Text( - text = title, + text = displayTitle, style = MaterialTheme.typography.titleMedium, color = titleColor, maxLines = 1, diff --git a/composeApp/src/main/kotlin/org/incido/compose/ui/notelist/NoteListViewModel.kt b/composeApp/src/main/kotlin/org/incido/compose/ui/notelist/NoteListViewModel.kt index 583e35d..fb95b94 100644 --- a/composeApp/src/main/kotlin/org/incido/compose/ui/notelist/NoteListViewModel.kt +++ b/composeApp/src/main/kotlin/org/incido/compose/ui/notelist/NoteListViewModel.kt @@ -44,7 +44,8 @@ data class NoteListUiState( ) { val isEmpty: Boolean get() = !isLoading && notes.isEmpty() && !isSearchActive && - (filter == NoteFilter.Home || filter == NoteFilter.Trash) + (filter == NoteFilter.Home || filter == NoteFilter.Trash || + filter == NoteFilter.Drafts) val noResults: Boolean get() = !isLoading && notes.isEmpty() && !isEmpty } @@ -73,8 +74,11 @@ class NoteListViewModel( NoteFilter.Home -> if (q.isBlank()) repository.observeAll() else repository.search(q) NoteFilter.Favorites -> if (q.isBlank()) repository.observeFavorites() else repository.searchFavorites(q) NoteFilter.Untagged -> if (q.isBlank()) repository.observeUntagged() else repository.searchUntagged(q) + NoteFilter.Drafts -> if (q.isBlank()) repository.observeDrafts() else repository.searchDrafts(q) NoteFilter.Trash -> if (q.isBlank()) repository.observeTrashed() else repository.searchTrashed(q) is NoteFilter.ByTag -> repository.observeNotesForHashtag(f.hashtag) + is NoteFilter.ByColor -> + if (q.isBlank()) repository.observeByColor(f.color) else repository.searchByColor(q, f.color) } } @@ -156,6 +160,11 @@ class NoteListViewModel( viewModelScope.launch { repository.delete(id) } } + /** "Empty Trash": permanently destroy every note in the Trash. */ + fun emptyTrash() { + viewModelScope.launch { repository.deleteAllTrashed() } + } + /** Restore a note from Trash. */ fun restore(id: Long) { viewModelScope.launch { repository.restore(id) } diff --git a/composeApp/src/main/kotlin/org/incido/compose/ui/settings/SettingsViewModel.kt b/composeApp/src/main/kotlin/org/incido/compose/ui/settings/SettingsViewModel.kt index 32fc012..30cbca2 100644 --- a/composeApp/src/main/kotlin/org/incido/compose/ui/settings/SettingsViewModel.kt +++ b/composeApp/src/main/kotlin/org/incido/compose/ui/settings/SettingsViewModel.kt @@ -354,7 +354,7 @@ class SettingsViewModel( /** The version string baked into backup payloads and shown on * the About card. Mirrors `app/build.gradle.kts` `versionName` * — if you bump one, bump both. */ - const val APP_VERSION = "0.4.0.0" + const val APP_VERSION = "0.4.1.0" val Factory: ViewModelProvider.Factory = viewModelFactory { initializer { diff --git a/core/data/src/main/kotlin/org/incido/data/entity/NoteEntity.kt b/core/data/src/main/kotlin/org/incido/data/entity/NoteEntity.kt index dbe2dad..5f7e329 100644 --- a/core/data/src/main/kotlin/org/incido/data/entity/NoteEntity.kt +++ b/core/data/src/main/kotlin/org/incido/data/entity/NoteEntity.kt @@ -43,6 +43,8 @@ data class NoteEntity( @Index var isTrashed: Boolean = false, /** v0.3.8.0 — [org.incido.domain.model.NoteType] storage key (0 text, 1 task, 2 shopping). */ var typeKey: Short = 0, + /** True while a new note is being drafted; only the Drafts view shows these rows. */ + @Index var isDraft: Boolean = false, ) { override fun equals(other: Any?): Boolean { if (this === other) return true @@ -57,6 +59,7 @@ data class NoteEntity( if (cipherVersion != other.cipherVersion) return false if (!contentBlob.contentEquals(other.contentBlob)) return false if (typeKey != other.typeKey) return false + if (isDraft != other.isDraft) return false return true } @@ -71,6 +74,7 @@ data class NoteEntity( result = 31 * result + cipherVersion.hashCode() result = 31 * result + contentBlob.contentHashCode() result = 31 * result + typeKey.hashCode() + result = 31 * result + isDraft.hashCode() return result } } @@ -84,6 +88,7 @@ internal fun NoteEntity.toDomain(): Note = Note( color = NoteColor.fromStorageKey(colorKey), isTrashed = isTrashed, type = NoteType.fromStorageKey(typeKey), + isDraft = isDraft, ) internal fun Note.toEntity(): NoteEntity = NoteEntity( @@ -95,4 +100,5 @@ internal fun Note.toEntity(): NoteEntity = NoteEntity( colorKey = color.storageKey, isTrashed = isTrashed, typeKey = type.storageKey, + isDraft = isDraft, ) diff --git a/core/data/src/main/kotlin/org/incido/data/repository/NoteRepositoryImpl.kt b/core/data/src/main/kotlin/org/incido/data/repository/NoteRepositoryImpl.kt index d211aec..9113b23 100644 --- a/core/data/src/main/kotlin/org/incido/data/repository/NoteRepositoryImpl.kt +++ b/core/data/src/main/kotlin/org/incido/data/repository/NoteRepositoryImpl.kt @@ -34,6 +34,7 @@ import org.incido.domain.model.Hashtag import org.incido.domain.model.HashtagUsage import org.incido.domain.model.Note import org.incido.domain.model.NoteAttachment +import org.incido.domain.model.NoteColor import org.incido.domain.model.NoteType import org.incido.domain.repository.NoteRepository @@ -119,6 +120,45 @@ class NoteRepositoryImpl( awaitClose { sub.cancel() } }.flowOn(Dispatchers.Default) + override fun observeDrafts(): Flow> = callbackFlow { + trySend(snapshotDrafts()) + val sub = noteBox.query() + .equal(NoteEntity_.isDraft, true) + .build() + .subscribe() + .observer { trySend(snapshotDrafts()) } + awaitClose { sub.cancel() } + }.flowOn(Dispatchers.Default) + + override fun searchDrafts(query: String): Flow> = callbackFlow { + trySend(snapshotDraftsSearch(query)) + val sub = noteBox.query().build().subscribe().observer { + trySend(snapshotDraftsSearch(query)) + } + awaitClose { sub.cancel() } + }.flowOn(Dispatchers.Default) + + override fun observeByColor(color: NoteColor): Flow> = callbackFlow { + trySend(snapshotByColor(color)) + // Kotlin stubs expose only equal(Property, Long) for integer + // columns — widen the Short storage key (ObjectBox integer + // columns are width-agnostic, so the match is exact). + val sub = noteBox.query() + .equal(NoteEntity_.colorKey, color.storageKey.toLong()) + .build() + .subscribe() + .observer { trySend(snapshotByColor(color)) } + awaitClose { sub.cancel() } + }.flowOn(Dispatchers.Default) + + override fun searchByColor(query: String, color: NoteColor): Flow> = callbackFlow { + trySend(snapshotByColorSearch(query, color)) + val sub = noteBox.query().build().subscribe().observer { + trySend(snapshotByColorSearch(query, color)) + } + awaitClose { sub.cancel() } + }.flowOn(Dispatchers.Default) + override fun observeNotesForHashtag(name: String): Flow> = callbackFlow { trySend(snapshotForHashtag(name)) val sub = noteBox.query().build().subscribe().observer { trySend(snapshotForHashtag(name)) } @@ -318,6 +358,7 @@ class NoteRepositoryImpl( private fun contentMatchingNoteIds( query: String, includeTrashed: Boolean = false, + includeDrafts: Boolean = false, ): List { val q = query.trim() if (q.isEmpty()) return emptyList() @@ -332,13 +373,15 @@ class NoteRepositoryImpl( noteBox.all.filter { toReadable(it).content.lowercase().contains(needle) } } return candidates - .filter { it.isTrashed == includeTrashed } + .filter { + it.isTrashed == includeTrashed && (includeDrafts || !it.isDraft) + } .map { it.id } } - /** IDs of rows eligible for all active-note queries. */ + /** IDs of rows eligible for all active-note queries (never trashed, never drafts). */ private fun activeNoteIds(): Set = - noteBox.all.filter { !it.isTrashed }.mapTo(HashSet()) { it.id } + noteBox.all.filter { !it.isTrashed && !it.isDraft }.mapTo(HashSet()) { it.id } /** IDs of tags currently used by at least one active note. */ private fun activeTagIds(): Set { @@ -374,7 +417,7 @@ class NoteRepositoryImpl( .build() .find() .mapNotNull { ref -> noteBox.get(ref.noteId) } - .filter { it.isTrashed == includeTrashed } + .filter { it.isTrashed == includeTrashed && !it.isDraft } .map { it.id } } @@ -453,11 +496,47 @@ class NoteRepositoryImpl( } } + /** + * "Empty Trash": permanently delete every trashed row with the + * exact same cascade as [delete] — note row, hashtag cross-links, + * and attachment rows (their blobs live inside the attachment + * entities, so removing the row frees them too). + */ + override suspend fun deleteAllTrashed() { + val trashedIds: LongArray = noteBox.query() + .equal(NoteEntity_.isTrashed, true) + .build() + .find() + .map { it.id } + .toLongArray() + if (trashedIds.isEmpty()) return + noteBox.remove(*trashedIds) + trashedIds.forEach { id -> + val orphanXrefs: List = xrefBox.query() + .equal(NoteHashtagCrossRef_.noteId, id) + .build() + .find() + if (orphanXrefs.isNotEmpty()) { + xrefBox.remove(*orphanXrefs.map { it.id }.toLongArray()) + } + val orphanAttachments: List = attachmentBox.query() + .equal(NoteAttachmentEntity_.noteId, id) + .build() + .find() + if (orphanAttachments.isNotEmpty()) { + attachmentBox.remove(*orphanAttachments.map { it.id }.toLongArray()) + } + } + } + /** Soft-delete only changes state; the row, links, and blobs remain intact. */ override suspend fun softDelete(id: Long) { val entity = noteBox.get(id) ?: return if (entity.isTrashed) return entity.isTrashed = true + // A trashed draft comes back as a normal note on Restore — the + // draft lifecycle ends the moment it moves to Trash. + entity.isDraft = false // `put` is intentional here: content may be ciphertext already, // so do not pass it through toWritable and encrypt the ciphertext a // second time. Only the additive flag is changing. @@ -603,11 +682,15 @@ class NoteRepositoryImpl( private fun decorate( entities: List, includeTrashed: Boolean? = false, + includeDrafts: Boolean = false, ): List { val tags = hashtagsByNoteId() val attachments = attachmentsByNoteId() return entities - .filter { includeTrashed == null || it.isTrashed == includeTrashed } + .filter { + (includeTrashed == null || it.isTrashed == includeTrashed) && + (includeDrafts || !it.isDraft) + } .sortedWith( compareByDescending { it.isFavorite } .thenByDescending { it.updatedAt }, @@ -636,7 +719,8 @@ class NoteRepositoryImpl( private fun snapshotAll(): List = decorate(noteBox.all) - private fun snapshotAllIncludingTrashed(): List = decorate(noteBox.all, includeTrashed = null) + private fun snapshotAllIncludingTrashed(): List = + decorate(noteBox.all, includeTrashed = null, includeDrafts = true) private fun snapshotSearch(query: String): List { val allIds = matchingNoteIds(query, includeTrashed = false) @@ -661,6 +745,66 @@ class NoteRepositoryImpl( return decorate(trashedEntities, includeTrashed = true) } + private fun snapshotDrafts(): List { + val draftEntities: List = noteBox.query() + .equal(NoteEntity_.isDraft, true) + .build() + .find() + return decorate(draftEntities, includeTrashed = null, includeDrafts = true) + } + + /** + * Content search restricted to drafts (tag-name matches are not + * folded in, mirroring the plain-text scope of the Drafts view). + */ + private fun snapshotDraftsSearch(query: String): List { + val q = query.trim() + if (q.isEmpty()) return snapshotDrafts() + val draftIds: Set = noteBox.query() + .equal(NoteEntity_.isDraft, true) + .build() + .find() + .mapTo(HashSet()) { it.id } + val matches: List = contentMatchingNoteIds( + q, + includeTrashed = false, + includeDrafts = true, + ).filter { it in draftIds } + val entities: List = matches.mapNotNull { noteBox.get(it) } + return decorate(entities, includeTrashed = null, includeDrafts = true) + } + + /** + * Active notes of one accent colour. The colour query already + * excludes nothing on trash state, so `decorate` (default + * `includeTrashed = false`) drops trashed rows exactly like + * [snapshotFavorites] / [snapshotUntagged] do. + */ + private fun snapshotByColor(color: NoteColor): List { + val colorEntities: List = noteBox.query() + .equal(NoteEntity_.colorKey, color.storageKey.toLong()) + .build() + .find() + return decorate(colorEntities) + } + + /** + * Context-aware search across notes of [color] only. Blank [query] + * degrades to [snapshotByColor]. Otherwise runs the same content + + * hashtag-name matching as [snapshotFavoritesSearch] and intersects + * with the colour (never trashed rows — matchingNoteIds already + * excludes them via includeTrashed = false). + */ + private fun snapshotByColorSearch(query: String, color: NoteColor): List { + val q = query.trim() + if (q.isEmpty()) return snapshotByColor(color) + val allIds: Set = matchingNoteIds(q, includeTrashed = false) + if (allIds.isEmpty()) return emptyList() + val entities: List = allIds.mapNotNull { id -> noteBox.get(id) } + .filter { it.colorKey == color.storageKey } + return decorate(entities) + } + private fun snapshotUntagged(): List { val activeIds = activeNoteIds() val noteIdsWithTags: Set = xrefBox.all diff --git a/core/domain/src/main/kotlin/org/incido/domain/model/Note.kt b/core/domain/src/main/kotlin/org/incido/domain/model/Note.kt index e17686e..727da44 100644 --- a/core/domain/src/main/kotlin/org/incido/domain/model/Note.kt +++ b/core/domain/src/main/kotlin/org/incido/domain/model/Note.kt @@ -24,6 +24,14 @@ data class Note( val attachments: List = emptyList(), /** True only for notes moved to the Trash view; active-note queries exclude these rows. */ val isTrashed: Boolean = false, + /** + * True while a new note is being drafted. Drafts auto-save every + * edit and are visible only in the Drafts view — Home / Favorites / + * Untagged / tag / colour views / ordinary search / Trash all + * exclude them. Saving from the editor (or moving to Trash) clears + * the flag. + */ + val isDraft: Boolean = false, /** v0.3.8.0 — which editor surface opens this note (see [NoteType]). */ val type: NoteType = NoteType.TEXT, ) { @@ -31,7 +39,8 @@ data class Note( val firstImageAttachment: NoteAttachment? get() = attachments.firstOrNull { it.isImage } companion object { - private const val UNTITLED = "Untitled" + /** Shown when a note's content has no usable first line. */ + const val UNTITLED = "Untitled" /** * Splits [content] into a (title, body) pair. The title is the first diff --git a/core/domain/src/main/kotlin/org/incido/domain/model/NoteColor.kt b/core/domain/src/main/kotlin/org/incido/domain/model/NoteColor.kt index 8814855..313a81f 100644 --- a/core/domain/src/main/kotlin/org/incido/domain/model/NoteColor.kt +++ b/core/domain/src/main/kotlin/org/incido/domain/model/NoteColor.kt @@ -5,13 +5,13 @@ package org.incido.domain.model * Stored as a short (`SHORT`) in ObjectBox — additive-safe migration from * the v0.1 schema. */ -enum class NoteColor(val storageKey: Short) { - NONE(0), - BLUE(1), - GREEN(2), - AMBER(3), - RED(4), - PURPLE(5); +enum class NoteColor(val storageKey: Short, val label: String) { + NONE(0, "None"), + BLUE(1, "Blue"), + GREEN(2, "Green"), + AMBER(3, "Amber"), + RED(4, "Red"), + PURPLE(5, "Purple"); companion object { /** Convert from the stored [Short] back to the enum, defaulting to [NONE]. */ diff --git a/core/domain/src/main/kotlin/org/incido/domain/model/NoteFilter.kt b/core/domain/src/main/kotlin/org/incido/domain/model/NoteFilter.kt index aa0a942..9ab2951 100644 --- a/core/domain/src/main/kotlin/org/incido/domain/model/NoteFilter.kt +++ b/core/domain/src/main/kotlin/org/incido/domain/model/NoteFilter.kt @@ -9,21 +9,29 @@ package org.incido.domain.model * - [Favorites] — only notes with `isFavorite = true`; ordinary search is enabled. * - [Untagged] — only notes that have zero hashtags; ordinary search is enabled. * - [ByTag] — only notes tagged with [hashtag]; text search is not offered. + * - [ByColor] — active notes with accent colour [color]; ordinary search is + * enabled and narrows within the colour (like Favorites). + * - [Drafts] — auto-saved new notes; visible nowhere else until saved + * or trashed. Ordinary search is enabled. * - [Trash] — only notes moved out of the active list; no edit actions. */ sealed class NoteFilter { object Home : NoteFilter() object Favorites : NoteFilter() object Untagged : NoteFilter() + object Drafts : NoteFilter() object Trash : NoteFilter() data class ByTag(val hashtag: String) : NoteFilter() + data class ByColor(val color: NoteColor) : NoteFilter() /** Stable identifier used by the drawer for `selected` matching. */ fun key(): String = when (this) { Home -> "home" Favorites -> "favorites" Untagged -> "untagged" + Drafts -> "drafts" Trash -> "trash" is ByTag -> "tag:$hashtag" + is ByColor -> "color:${color.name}" } } diff --git a/core/domain/src/main/kotlin/org/incido/domain/model/NoteType.kt b/core/domain/src/main/kotlin/org/incido/domain/model/NoteType.kt index c932035..a555bcc 100644 --- a/core/domain/src/main/kotlin/org/incido/domain/model/NoteType.kt +++ b/core/domain/src/main/kotlin/org/incido/domain/model/NoteType.kt @@ -13,15 +13,15 @@ package org.incido.domain.model * Stored as a `Short` in ObjectBox — additive-safe migration from * the pre-v0.3.8.0 schema (rows without the column default to [TEXT]). */ -enum class NoteType(val storageKey: Short) { +enum class NoteType(val storageKey: Short, val displayName: String) { /** Free-form body edited in the plain multi-line field. */ - TEXT(0), + TEXT(0, "Text Note"), /** Editable checklist: checkbox + item text rows. */ - TASK_LIST(1), + TASK_LIST(1, "Task List"), /** Checklist plus a per-item cost (number pad) and a running total. */ - SHOPPING_LIST(2); + SHOPPING_LIST(2, "Shopping List"); companion object { /** Convert from the stored [Short] back to the enum, defaulting to [TEXT]. */ diff --git a/core/domain/src/main/kotlin/org/incido/domain/repository/NoteRepository.kt b/core/domain/src/main/kotlin/org/incido/domain/repository/NoteRepository.kt index f9c3024..6d2a5ff 100644 --- a/core/domain/src/main/kotlin/org/incido/domain/repository/NoteRepository.kt +++ b/core/domain/src/main/kotlin/org/incido/domain/repository/NoteRepository.kt @@ -3,6 +3,7 @@ package org.incido.domain.repository import kotlinx.coroutines.flow.Flow import org.incido.domain.model.HashtagUsage import org.incido.domain.model.Note +import org.incido.domain.model.NoteColor import org.incido.domain.model.NoteAttachment /** @@ -37,6 +38,13 @@ interface NoteRepository { /** Permanently delete a note by id. No-op if it doesn't exist. */ suspend fun delete(id: Long) + /** + * "Empty Trash": permanently delete EVERY trashed note in one go, + * with the same cascade as [delete] (row + hashtag links + + * attachment blobs). No-op when the Trash is already empty. + */ + suspend fun deleteAllTrashed() + /** Move a note to Trash without removing its row, tags, or attachments. */ suspend fun softDelete(id: Long) @@ -56,6 +64,35 @@ interface NoteRepository { /** Only notes in Trash, sorted by updatedAt DESC. */ fun observeTrashed(): Flow> + /** + * Only auto-saved draft notes (new notes the user hasn't saved yet), + * sorted favourites-first then newest-first. Drafts appear in no + * other view — see [Note.isDraft]. + */ + fun observeDrafts(): Flow> + + /** + * Context-aware content search across drafts only; blank [query] + * returns the same as [observeDrafts]. + */ + fun searchDrafts(query: String): Flow> + + /** + * Only **active** notes (never trashed) whose accent colour is + * [color], sorted favourites-first then newest-first. Tagged and + * untagged notes are both eligible — only the colour matters. + */ + fun observeByColor(color: NoteColor): Flow> + + /** + * Context-aware search across notes of [color] only — matches + * [Note.content] (contains, case-insensitive) AND any of the + * note's hashtags (case-insensitive equality), intersected with + * the colour and the active (non-trashed) set. Blank [query] + * returns the same as [observeByColor]. + */ + fun searchByColor(query: String, color: NoteColor): Flow> + /** * Context-aware search across **favourites only** — matches * [Note.content] (contains, case-insensitive) AND any of the note's