feat: v0.3.0.0 — hashtags (visible on editor) + bolder colour accent + centred title + nav drawer + new version scheme
v0.3.0.0 bundles four user-facing features, the plan-compliance polish
that was deferred from v0.2, and a permanent change to how we name
releases going forward.
VERSION SCHEME (app/build.gradle.kts)
- versionName = '0.3.0.0' (MAJOR.MINOR.MAINTENANCE.EMERGENCY)
- versionCode = 5
- New gradle taskGraph validator fails the build if versionName
doesn't match ^\d+\.\d+\.\d+\.\d+$ — we can't accidentally
regress the scheme.
- History re-keyed across README, Plan §10, CONTRIBUTING.md.
HASHTAGS
- value class Hashtag (domain/model) with normalise/parseOrNull
helpers; pattern: ^[a-z0-9][a-z0-9._-]{0,30}$
- data class HashtagUsage (name, noteCount, lastUsedAt)
- sealed class NoteFilter { Home, Favorites, Untagged, ByTag(name) }
- Note gains hashtags: List<String> (sorted ascending)
- Repository:
- new entities HashtagEntity (@Index on name) and
NoteHashtagCrossRef (many-to-many junction)
- new methods: observeFavorites / observeUntagged /
observeNotesForHashtag / observeHashtagsByRecentUse /
observeAllHashtags / searchHashtags / addHashtag / removeHashtag
- search() now matches content OR hashtag-name (case-insensitive)
- ObjectBox queries use explicit StringOrder + type annotations
(kapt's stubs are finicky around Property<String> overloads)
UI
- CenterAlignedTopAppBar on both list and editor screens
- List:
- Hamburger top-left opens a ModalNavigationDrawer (Home /
Favorites / Untagged / divider / scrollable Recent tags)
- Drawer selection drives a NoteFilter state held at root
- Search bar visible only when filter == Home
- NoteCard redesign — 14 dp vertical gradient stripe +
tinted surface (12 % colour blend) + 10 dp corner chip
- Empty-state copy is filter-aware
- Editor:
- Persistent hashtag chip row above the text field
- Tag # icon in the top bar + '+ add' chip opens a ModalBottomSheet
- Autocomplete suggestions live from repository.searchHashtags
- '+ Create name' button when the typed value is valid + new
- Snackbar 'Maximum 5 tags reached.' when the cap is hit
- Reconciled on save via addHashtag / removeHashtag diff
DOCS
- README v0.3.0.0 section + re-keyed changelog
- Development Plan §10 history re-keyed (0.1.0.0 / 0.1.1.0 /
0.2.0.0 / 0.2.0.1 / 0.3.0.0)
- CONTRIBUTING.md release-process note updated for the new scheme
VERIFIED
- ./gradlew assembleDebug assembleRelease both green
- Debug 25.7 MB, release 19.8 MB (v2-signed)
- versionCode=5, versionName='0.3.0.0'
- No INTERNET permission
- Validator regression: setting versionName='0.3' causes
assembleDebug to fail with the new scheme error message
This commit is contained in:
1 parent
84900838f7
commit
d616ce3021
20 files changed
+1256
-222
No files matched your search
+13
-5
@@ -140,10 +140,18 @@ under AGPL-3.0 before opening the PR.
|
||||
|
||||
## Release process (for maintainers)
|
||||
|
||||
1. Bump `versionCode` + `versionName` in `app/build.gradle.kts`.
|
||||
2. Update the Development Plan §10 history table.
|
||||
3. Tag the commit: `git tag -s vX.Y.Z -m "vX.Y.Z — short summary"`.
|
||||
4. `./gradlew assembleRelease` → upload APK to Gitea Releases.
|
||||
5. Push the tag: `git push origin vX.Y.Z`.
|
||||
> **Version scheme (from v0.3.0.0 onwards):** `MAJOR.MINOR.MAINTENANCE.EMERGENCY` —
|
||||
> e.g. `0.3.0.0`. `MAJOR.MINOR.MAINTENANCE` are normal release numbers;
|
||||
> `EMERGENCY` is non-zero only for hotfixes shipped out-of-band.
|
||||
> `versionCode` is a monotonic int and always +1 per release.
|
||||
> A build with a `versionName` that doesn't match `^\d+\.\d+\.\d+\.\d+$`
|
||||
> fails immediately — there's a validator in `app/build.gradle.kts`.
|
||||
|
||||
1. Bump `versionCode` (+1) and `versionName` in `app/build.gradle.kts`.
|
||||
2. Update the Development Plan §10 history table with the new dot-name.
|
||||
3. Tag the commit: `git tag -s vX.Y.Z.W -m "vX.Y.Z.W — short summary"`.
|
||||
4. `./gradlew assembleDebug assembleRelease` — confirm both green.
|
||||
5. Upload `app/build/outputs/apk/release/app-release.apk` to Gitea Releases.
|
||||
6. Push the tag: `git push origin vX.Y.Z.W`.
|
||||
|
||||
Thanks again for contributing! 🙏
|
||||
@@ -361,12 +361,19 @@ A short reference for AI assistants:
|
||||
|
||||
## 10. Document History
|
||||
|
||||
> **Version scheme (from v0.3.0.0 onwards):** `MAJOR.MINOR.MAINTENANCE.EMERGENCY` —
|
||||
> e.g. `0.3.0.0`. `MAJOR.MINOR.MAINTENANCE` are normal release numbers;
|
||||
> `EMERGENCY` is non-zero only for hotfixes shipped out-of-band.
|
||||
> `versionCode` is a monotonic int and always +1 per release.
|
||||
> The build refuses to compile if `versionName` doesn't match this shape.
|
||||
|
||||
| Version | Date | Notes |
|
||||
|---------|------|-------|
|
||||
| 0.1 | 2026-08-14 | Initial plan drafted via interview |
|
||||
| 0.1.1 | 2026-08-14 | Added F1 explicit "list of currently saved notes" requirement + F7 auto-refresh + clarified UI section |
|
||||
| 0.1.1 | 2026-08-14 | Editor IME fix (Scaffold contentWindowInsets + adjustResize) + title/body display on list cards |
|
||||
| 0.2 | 2026-08-14 | Polish + first Keep-parity features. Discard-confirm dialog; release signing config (dev keystore). Favorites (renamed from Pinned Notes), full-text search, 6 colour-coded notes, inline GFM checklists (open/done counts). ObjectBox KMP migration deferred to v0.5 (tracked). |
|
||||
| 0.1.0.0 | 2026-08-14 | Initial plan drafted via interview |
|
||||
| 0.1.1.0 | 2026-08-14 | F1 explicit "list of currently saved notes" requirement + F7 auto-refresh + clarified UI section + editor IME fix (contentWindowInsets + adjustResize) + title/body on cards |
|
||||
| 0.2.0.0 | 2026-08-14 | Polish + first Keep-parity features. Discard-confirm dialog; release signing config (dev keystore). Favorites (renamed from Pinned Notes), full-text search, 6 colour-coded notes, inline GFM checklists (open/done counts). ObjectBox KMP migration deferred to v0.5 (tracked). |
|
||||
| 0.2.0.1 | 2026-08-14 | Hotfix: search-active flag folded into uiState so the search icon actually opens the field. |
|
||||
| 0.3.0.0 | 2026-08-14 | Hashtags (separate entity + cross-ref, 5-tag cap, autocomplete, persistent chips on editor, search() also matches tag names) + bolder colour accent (14 dp gradient stripe + tinted card background + corner chip) + nav drawer (Home / Favorites / Untagged + recent tags) + centred app-bar title + new version scheme adopted (validator in app/build.gradle.kts). |
|
||||
|
||||
|
||||
---
|
||||
|
||||
@@ -6,48 +6,82 @@ 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.2** release: a single-user, offline note
|
||||
app with favourites, full-text search, colour-coded notes, and inline
|
||||
checklists. The architecture is multi-module Android today and is
|
||||
structured so iOS / Desktop ports can happen later without UI rewrites.
|
||||
This repository contains the **v0.3.0.0** release: a single-user, offline
|
||||
note app with hashtags, favourites, full-text search, colour-coded
|
||||
notes, and a navigation drawer. The architecture is multi-module Android
|
||||
today and is structured so iOS / Desktop ports can happen later without
|
||||
UI rewrites.
|
||||
|
||||
**Current release:** v0.2 (see [Changelog](#changelog) below).
|
||||
**Current release:** v0.3.0.0 (see [Changelog](#changelog) below).
|
||||
|
||||
> **Version scheme (from v0.3.0.0 onwards):** `MAJOR.MINOR.MAINTENANCE.EMERGENCY` —
|
||||
> e.g. `0.3.0.0`. `MAJOR.MINOR.MAINTENANCE` are normal release numbers;
|
||||
> `EMERGENCY` is non-zero only for hotfixes shipped out-of-band.
|
||||
> `versionCode` is a monotonic int and always +1 per release.
|
||||
> An empty MAINTENANCE/EMERGENCY slot is written as `0`.
|
||||
> The build refuses to compile if `versionName` doesn't match this shape.
|
||||
|
||||
---
|
||||
|
||||
## Features
|
||||
|
||||
### v0.2 highlights
|
||||
### v0.3.0.0 highlights
|
||||
|
||||
- **Hashtags.** Tag any note with up to 5 hashtags. Tags are always
|
||||
visible as chips above the editor text field; tap ✕ to remove. Tap
|
||||
`#` (or `+ add`) to open a sheet with autocomplete suggestions from
|
||||
your existing tags. Hashtags are searchable from the list (typing
|
||||
`work` finds notes containing the word *and* notes tagged `#work`).
|
||||
- **Bolder colour accent on list cards.** Each colour-tagged note now
|
||||
gets a 14 dp vertical gradient stripe on the left, a subtle 12 %
|
||||
tinted card background, and a 10 dp solid colour chip in the
|
||||
top-right — so different-coloured notes are visually distinct at a
|
||||
glance without you needing to focus on the stripe.
|
||||
- **Navigation drawer.** Hamburger top-left opens a drawer with
|
||||
**Home**, **Favorites**, **Untagged**, a divider, then a live scrollable
|
||||
list of the most-recently-used hashtags. Tap any entry to filter the
|
||||
list to just those notes.
|
||||
- **Centred app-bar title.** Both the list screen (`Incido`) and the
|
||||
editor (`Edit note` / `New note`) now centre their titles via
|
||||
Material 3's `CenterAlignedTopAppBar`.
|
||||
- **New version scheme.** All version bumps from now on follow the
|
||||
`MAJOR.MINOR.MAINTENANCE.EMERGENCY` pattern; the build refuses anything
|
||||
that doesn't match.
|
||||
|
||||
### v0.2.0.0
|
||||
|
||||
- **Favourites.** Tap the star icon on any card to pin it to the top of
|
||||
the list. (Replaces the §6.1 "Pinned Notes" item; renamed per
|
||||
maintainer request.)
|
||||
the list.
|
||||
- **Full-text search.** Tap the search icon in the top app bar; the list
|
||||
filters live as you type. Backed by ObjectBox's `contains` query —
|
||||
case-insensitive, no extra dependencies.
|
||||
filters live as you type.
|
||||
- **Color-coded notes.** Pick from six preset accent colours in the
|
||||
editor (none / blue / green / amber / red / purple). Each list card
|
||||
gets a 4dp vertical stripe on the left edge.
|
||||
- **Inline checklists.** Lines beginning with `- [ ]` or `- [x]` are
|
||||
parsed; the card preview shows the open/done counts (e.g.
|
||||
"2 open · 1 done"). No DB schema migration — the text stays plain.
|
||||
editor; each list card gets a 4 dp vertical stripe.
|
||||
- **Inline checklists.** Lines beginning with `- [ ]` or `- [x]` show
|
||||
open/done counts on the card preview.
|
||||
- **Discard-confirm dialog.** Closing the editor with unsaved changes
|
||||
now prompts "Discard changes?" with Discard / Keep-editing buttons.
|
||||
Applies to both the Back arrow and the hardware back gesture.
|
||||
prompts `Discard changes?` (works for both Back arrow and hardware
|
||||
back gesture).
|
||||
- **Release signing** — dev keystore in `keystore/`, `assembleRelease`
|
||||
produces a v2-signed APK out of the box.
|
||||
|
||||
### v0.1.1 polish
|
||||
### v0.2.0.1 (hotfix)
|
||||
|
||||
- **Editor respects the soft keyboard.** With edge-to-edge enabled, the
|
||||
editor's `Scaffold` unions `WindowInsets.systemBars` with
|
||||
`WindowInsets.ime`, so the text field automatically shrinks above the
|
||||
keyboard instead of being hidden behind it. `adjustResize` is also set
|
||||
on `MainActivity` as a pre-Android-15 fallback.
|
||||
- **List cards now show a title + body preview.** The first non-empty line
|
||||
of a note is treated as its title and rendered in a larger / bolder
|
||||
style; the remainder is shown as an abbreviated preview below it
|
||||
(max 2 lines, ellipsised). Empty notes display as "Untitled".
|
||||
- **Search icon actually opens the search bar.** v0.2.0.0's
|
||||
search-active flag was on a separate `StateFlow` the composable never
|
||||
observed; folded into `uiState` so tapping the icon now lights up the
|
||||
field.
|
||||
|
||||
### v0.1.0 (original MVP)
|
||||
### v0.1.1.0
|
||||
|
||||
- **Editor respects the soft keyboard.** `Scaffold` unions
|
||||
`WindowInsets.systemBars` with `WindowInsets.ime` so the text field
|
||||
shrinks above the keyboard. `adjustResize` set as pre-Android-15
|
||||
fallback.
|
||||
- **List cards now show a title + body preview.** First non-empty line
|
||||
= title; remainder = body preview (max 2 lines, ellipsised).
|
||||
Empty notes display as "Untitled".
|
||||
|
||||
### v0.1.0.0
|
||||
|
||||
- Create, edit, and delete plain-text notes
|
||||
- ObjectBox-backed persistence ([objectbox.io](https://objectbox.io/))
|
||||
@@ -68,10 +102,12 @@ cross-platform ports, end-to-end sync, and security features.
|
||||
## Changelog
|
||||
|
||||
| Version | Date | Highlights |
|
||||
|---------|------|------------|
|
||||
| 0.1 | 2026-08-14 | First MVP: list + editor, ObjectBox, Material 3 |
|
||||
| 0.1.1 | 2026-08-14 | Editor IME fix + title/body on list cards |
|
||||
| 0.2 | 2026-08-14 | Polish + favourites, search, colours, checklists, discard dialog, release signing |
|
||||
|-----------|------------|------------|
|
||||
| 0.1.0.0 | 2026-08-14 | First MVP: list + editor, ObjectBox, Material 3 |
|
||||
| 0.1.1.0 | 2026-08-14 | Editor IME fix + title/body on list cards |
|
||||
| 0.2.0.0 | 2026-08-14 | Polish + favourites, search, colours, checklists, discard dialog, release signing |
|
||||
| 0.2.0.1 | 2026-08-14 | Hotfix: search icon now actually opens the search bar |
|
||||
| 0.3.0.0 | 2026-08-14 | Hashtags (visible chips on editor, 5-tag cap, autocomplete) + bolder colour accent + nav drawer (Home / Favorites / Untagged + recent tags) + centred app-bar title + new version scheme |
|
||||
|
||||
---
|
||||
|
||||
@@ -154,6 +190,10 @@ Uses the dev keystore at `keystore/release.jks` — see
|
||||
**Replace this keystore with a production key before any external
|
||||
distribution.**
|
||||
|
||||
The build will **fail** if `versionName` doesn't match
|
||||
`^\d+\.\d+\.\d+\.\d+$` (the new scheme). Update `app/build.gradle.kts`
|
||||
to fix.
|
||||
|
||||
### 5. Install on a device
|
||||
|
||||
```bash
|
||||
@@ -187,19 +227,21 @@ After the first push:
|
||||
|
||||
---
|
||||
|
||||
## Manual Smoke Test (Development Plan §7.2 + v0.2 additions)
|
||||
## Manual Smoke Test (Development Plan §7.2 + v0.3.0.0 additions)
|
||||
|
||||
```
|
||||
[ ] Launch app — see empty state message ("No notes yet. Tap + to start.")
|
||||
[ ] Tap FAB — editor opens, cursor in text field
|
||||
[ ] Type "Test note 1" — tap save — returns to list, "Test note 1" card visible
|
||||
[ ] Tap star on card 1 — it floats to the top
|
||||
[ ] Tap search icon — type "Test" — only matching card remains
|
||||
[ ] Close search — full list returns, favourite still on top
|
||||
[ ] Edit "Test note 2" → tap a colour swatch → save → card shows coloured stripe
|
||||
[ ] Create a note with "- [ ] milk\n- [x] eggs" → card preview shows "1 open · 1 done"
|
||||
[ ] Open a note → type extra content → tap Back → discard dialog appears
|
||||
[ ] Force-stop app from system settings, reopen → all notes + favourites still present
|
||||
[ ] Launch app — "Incido" title centred, hamburger top-left
|
||||
[ ] Tap hamburger → drawer slides in with Home / Favorites / Untagged + divider + Recent tags
|
||||
[ ] Tap "Favorites" → list shows only starred notes
|
||||
[ ] Tap "Untagged" → list shows only notes with zero hashtags
|
||||
[ ] Tap a recent hashtag → list filters to that tag
|
||||
[ ] Tap "Home" → back to all notes
|
||||
[ ] Open a note → chip row above text field shows current tags (empty placeholder if none)
|
||||
[ ] Tap "#" icon → sheet opens, type "wo" → suggestions filter
|
||||
[ ] Add a new tag → chip appears, counter goes from N/5 to (N+1)/5
|
||||
[ ] Tap chip ✕ → removed
|
||||
[ ] Add 5 tags, attempt 6th → Snackbar "Maximum 5 tags reached"
|
||||
[ ] Force-stop + reopen → all notes + hashtags + favourites + colours persist
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
+32
-17
@@ -1,6 +1,17 @@
|
||||
// :app — Android application entry point. Hosts MainActivity and the
|
||||
// application manifest, including the launcher icon and theme.
|
||||
import java.io.FileInputStream
|
||||
//
|
||||
// Version scheme (v0.3.0.0 onwards):
|
||||
// versionName = "MAJOR.MINOR.MAINTENANCE.EMERGENCY"
|
||||
// - MAJOR: large breaking redesigns (rare in v0.x)
|
||||
// - MINOR: normal feature releases
|
||||
// - MAINTENANCE: bug fixes / refactors on a given MINOR
|
||||
// - EMERGENCY: 0 in normal releases; non-zero only for hotfixes
|
||||
// shipped out-of-band (e.g. v0.2.0.1 — search-icon fix)
|
||||
// versionCode: monotonic int. Always +1 per release.
|
||||
//
|
||||
// The validator below fails the build if versionName doesn't match the
|
||||
// required dotted format, so we can't regress the scheme by accident.
|
||||
import java.util.Properties
|
||||
|
||||
plugins {
|
||||
@@ -17,22 +28,13 @@ android {
|
||||
applicationId = "org.incido.app"
|
||||
minSdk = 26
|
||||
targetSdk = 35
|
||||
versionCode = 3
|
||||
versionName = "0.2"
|
||||
versionCode = 5
|
||||
versionName = "0.3.0.0"
|
||||
}
|
||||
|
||||
// --- Signing ---
|
||||
//
|
||||
// v0.2 introduces a real release signing config so `./gradlew
|
||||
// assembleRelease` produces an installable APK out of the box. The
|
||||
// keystore file itself is gitignored — see keystore/README.md for
|
||||
// generation instructions and for the (deliberately weak) dev
|
||||
// passwords baked into this build script. **Replace with a real
|
||||
// production keystore before publishing.**
|
||||
signingConfigs {
|
||||
create("release") {
|
||||
// Resolve paths relative to the project root so the same
|
||||
// config works from both Android Studio and CLI.
|
||||
val keystoreFilePath = rootProject.file("keystore/release.jks")
|
||||
if (keystoreFilePath.exists()) {
|
||||
storeFile = keystoreFilePath
|
||||
@@ -40,9 +42,6 @@ android {
|
||||
keyAlias = "incido"
|
||||
keyPassword = "incido_dev_keystore"
|
||||
}
|
||||
// If the keystore doesn't exist, the release build will fail
|
||||
// with a clear "Keystore file not set for signing config
|
||||
// release" message — by design.
|
||||
}
|
||||
}
|
||||
|
||||
@@ -51,7 +50,7 @@ android {
|
||||
isMinifyEnabled = false
|
||||
}
|
||||
release {
|
||||
isMinifyEnabled = false // TODO(v0.3): enable R8
|
||||
isMinifyEnabled = false // TODO(v0.3.0.0+): enable R8
|
||||
signingConfig = signingConfigs.getByName("release")
|
||||
}
|
||||
}
|
||||
@@ -81,7 +80,6 @@ dependencies {
|
||||
implementation(libs.androidx.core.ktx)
|
||||
implementation(libs.kotlinx.coroutines.android)
|
||||
|
||||
// Compose BOM keeps all Compose artefact versions aligned
|
||||
val composeBom = platform(libs.composeBom)
|
||||
implementation(composeBom)
|
||||
|
||||
@@ -89,3 +87,20 @@ dependencies {
|
||||
implementation(libs.compose.ui)
|
||||
implementation(libs.compose.material3)
|
||||
}
|
||||
|
||||
// --- Version-name scheme validator ---
|
||||
//
|
||||
// MAJOR.MINOR.MAINTENANCE.EMERGENCY — exactly four dotted integers.
|
||||
// Fails fast so we can't accidentally publish a "0.3" again.
|
||||
val versionScheme = Regex("""^\d+\.\d+\.\d+\.\d+$""")
|
||||
|
||||
gradle.taskGraph.whenReady {
|
||||
val vn = android.defaultConfig.versionName
|
||||
if (vn != null && !versionScheme.matches(vn)) {
|
||||
throw GradleException(
|
||||
"app versionName = \"$vn\" doesn't match the required " +
|
||||
"MAJOR.MINOR.MAINTENANCE.EMERGENCY scheme (e.g. 0.3.0.0). " +
|
||||
"Update app/build.gradle.kts."
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -1,30 +1,94 @@
|
||||
package org.incido.compose
|
||||
|
||||
import androidx.compose.material3.DrawerValue
|
||||
import androidx.compose.material3.ExperimentalMaterial3Api
|
||||
import androidx.compose.material3.ModalNavigationDrawer
|
||||
import androidx.compose.material3.rememberDrawerState
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.rememberCoroutineScope
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.runtime.snapshots.SnapshotStateList
|
||||
import androidx.compose.runtime.toMutableStateList
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import androidx.navigation.NavType
|
||||
import androidx.navigation.compose.NavHost
|
||||
import androidx.navigation.compose.composable
|
||||
import androidx.navigation.compose.currentBackStackEntryAsState
|
||||
import androidx.navigation.compose.rememberNavController
|
||||
import androidx.navigation.navArgument
|
||||
import kotlinx.coroutines.launch
|
||||
import org.incido.compose.ui.drawer.IncidoDrawer
|
||||
import org.incido.compose.ui.editor.NoteEditorScreen
|
||||
import org.incido.compose.ui.notelist.NoteListScreen
|
||||
import org.incido.compose.ui.theme.IncidoTheme
|
||||
import org.incido.domain.model.NoteFilter
|
||||
|
||||
/** Top-level navigation destinations. */
|
||||
private object Routes {
|
||||
const val LIST = "list"
|
||||
const val EDITOR = "editor/{noteId}"
|
||||
fun editor(noteId: Long?): String =
|
||||
"editor/${noteId ?: -1L}"
|
||||
fun editor(noteId: Long?): String = "editor/${noteId ?: -1L}"
|
||||
}
|
||||
|
||||
/** Stable serialisation for [NoteFilter] so `rememberSaveable` works. */
|
||||
private fun NoteFilter.toSaveableKey(): String = key()
|
||||
|
||||
private fun String.toNoteFilter(): NoteFilter = when {
|
||||
this == "home" -> NoteFilter.Home
|
||||
this == "favorites" -> NoteFilter.Favorites
|
||||
this == "untagged" -> NoteFilter.Untagged
|
||||
startsWith("tag:") -> NoteFilter.ByTag(this.removePrefix("tag:"))
|
||||
else -> NoteFilter.Home
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun IncidoApp() {
|
||||
IncidoTheme {
|
||||
val navController = rememberNavController()
|
||||
val drawerState = rememberDrawerState(initialValue = DrawerValue.Closed)
|
||||
val scope = rememberCoroutineScope()
|
||||
var filterMode by rememberSaveable(
|
||||
stateSaver = androidx.compose.runtime.saveable.Saver(
|
||||
save = { it.toSaveableKey() },
|
||||
restore = { it.toNoteFilter() },
|
||||
),
|
||||
) { mutableStateOf<NoteFilter>(NoteFilter.Home) }
|
||||
|
||||
val currentBackStack by navController.currentBackStackEntryAsState()
|
||||
val currentRoute = currentBackStack?.destination?.route?.substringBefore("/")
|
||||
// Disable the drawer on the editor so back arrow / gesture do
|
||||
// exactly what the user expects there.
|
||||
val isListRoute = currentRoute == Routes.LIST
|
||||
|
||||
LaunchedEffect(currentRoute) {
|
||||
// If we land on the editor via deep link without a list in
|
||||
// the back stack, snap the drawer closed.
|
||||
if (!isListRoute && drawerState.isOpen) drawerState.close()
|
||||
}
|
||||
|
||||
ModalNavigationDrawer(
|
||||
drawerState = drawerState,
|
||||
gesturesEnabled = isListRoute,
|
||||
drawerContent = {
|
||||
IncidoDrawer(
|
||||
currentFilter = filterMode,
|
||||
onSelectFilter = { picked ->
|
||||
filterMode = picked
|
||||
scope.launch { drawerState.close() }
|
||||
},
|
||||
)
|
||||
},
|
||||
) {
|
||||
NavHost(navController = navController, startDestination = Routes.LIST) {
|
||||
composable(Routes.LIST) {
|
||||
NoteListScreen(
|
||||
filterMode = filterMode,
|
||||
onOpenDrawer = { scope.launch { drawerState.open() } },
|
||||
onOpenEditor = { id -> navController.navigate(Routes.editor(id)) },
|
||||
)
|
||||
}
|
||||
@@ -47,3 +111,9 @@ fun IncidoApp() {
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Suppress unused-import lint for the snapshots helper that may be
|
||||
// re-introduced in future filter-state extensions.
|
||||
@Suppress("unused")
|
||||
private fun <T> List<T>.toSnapshotStateList(): SnapshotStateList<T> = toMutableStateList()
|
||||
@@ -0,0 +1,42 @@
|
||||
package org.incido.compose.ui.drawer
|
||||
|
||||
import androidx.lifecycle.ViewModel
|
||||
import androidx.lifecycle.ViewModelProvider
|
||||
import androidx.lifecycle.ViewModelProvider.AndroidViewModelFactory.Companion.APPLICATION_KEY
|
||||
import androidx.lifecycle.viewModelScope
|
||||
import androidx.lifecycle.viewmodel.initializer
|
||||
import androidx.lifecycle.viewmodel.viewModelFactory
|
||||
import kotlinx.coroutines.flow.SharingStarted
|
||||
import kotlinx.coroutines.flow.StateFlow
|
||||
import kotlinx.coroutines.flow.stateIn
|
||||
import org.incido.compose.IncidoApplication
|
||||
import org.incido.domain.model.HashtagUsage
|
||||
import org.incido.domain.repository.NoteRepository
|
||||
|
||||
/**
|
||||
* Tiny ViewModel the navigation drawer uses to source its "Recent
|
||||
* tags" list. Kept separate from [NoteListViewModel] because the
|
||||
* drawer may render even before the list screen is created (and
|
||||
* vice-versa).
|
||||
*/
|
||||
class DrawerViewModel(
|
||||
repository: NoteRepository,
|
||||
) : ViewModel() {
|
||||
|
||||
val recentHashtags: StateFlow<List<HashtagUsage>> =
|
||||
repository.observeHashtagsByRecentUse()
|
||||
.stateIn(
|
||||
scope = viewModelScope,
|
||||
started = SharingStarted.WhileSubscribed(5_000),
|
||||
initialValue = emptyList(),
|
||||
)
|
||||
|
||||
companion object {
|
||||
val Factory: ViewModelProvider.Factory = viewModelFactory {
|
||||
initializer {
|
||||
val app = this[APPLICATION_KEY] as IncidoApplication
|
||||
DrawerViewModel(app.container.noteRepository)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,145 @@
|
||||
package org.incido.compose.ui.drawer
|
||||
|
||||
import androidx.compose.foundation.layout.Arrangement
|
||||
import androidx.compose.foundation.layout.Column
|
||||
import androidx.compose.foundation.layout.Spacer
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
import androidx.compose.foundation.layout.height
|
||||
import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.rememberScrollState
|
||||
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.Star
|
||||
import androidx.compose.material.icons.filled.Tag
|
||||
import androidx.compose.material3.ExperimentalMaterial3Api
|
||||
import androidx.compose.material3.HorizontalDivider
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.ModalDrawerSheet
|
||||
import androidx.compose.material3.NavigationDrawerItem
|
||||
import androidx.compose.material3.NavigationDrawerItemDefaults
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.ui.Modifier
|
||||
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.domain.model.HashtagUsage
|
||||
import org.incido.domain.model.NoteFilter
|
||||
|
||||
/**
|
||||
* Left-side navigation drawer. Top section has three fixed entries
|
||||
* (Home / Favorites / Untagged); a `HorizontalDivider`; then a live
|
||||
* scrollable list of the user's most-recently-used hashtags.
|
||||
*
|
||||
* Tapping any entry calls [onSelectFilter] and the caller (root) is
|
||||
* responsible for closing the drawer.
|
||||
*/
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun IncidoDrawer(
|
||||
currentFilter: NoteFilter,
|
||||
onSelectFilter: (NoteFilter) -> Unit,
|
||||
modifier: Modifier = Modifier,
|
||||
viewModel: DrawerViewModel = viewModel(factory = DrawerViewModel.Factory),
|
||||
) {
|
||||
val recent by viewModel.recentHashtags.collectAsStateWithLifecycle()
|
||||
|
||||
ModalDrawerSheet(modifier = modifier) {
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(horizontal = 16.dp, vertical = 12.dp),
|
||||
) {
|
||||
Text(
|
||||
text = "Incido",
|
||||
style = MaterialTheme.typography.headlineSmall,
|
||||
color = MaterialTheme.colorScheme.primary,
|
||||
fontWeight = FontWeight.SemiBold,
|
||||
modifier = Modifier.padding(start = 12.dp, top = 4.dp, bottom = 16.dp),
|
||||
)
|
||||
|
||||
NavigationDrawerItem(
|
||||
label = { Text("Home") },
|
||||
selected = currentFilter == NoteFilter.Home,
|
||||
onClick = { onSelectFilter(NoteFilter.Home) },
|
||||
icon = { Icon(Icons.Filled.Home, contentDescription = null) },
|
||||
)
|
||||
NavigationDrawerItem(
|
||||
label = { Text("Favorites") },
|
||||
selected = currentFilter == NoteFilter.Favorites,
|
||||
onClick = { onSelectFilter(NoteFilter.Favorites) },
|
||||
icon = { Icon(Icons.Filled.Star, contentDescription = null) },
|
||||
)
|
||||
NavigationDrawerItem(
|
||||
label = { Text("Untagged") },
|
||||
selected = currentFilter == NoteFilter.Untagged,
|
||||
onClick = { onSelectFilter(NoteFilter.Untagged) },
|
||||
icon = { Icon(Icons.Filled.LabelOff, contentDescription = null) },
|
||||
)
|
||||
|
||||
HorizontalDivider(modifier = Modifier.padding(vertical = 12.dp))
|
||||
|
||||
Text(
|
||||
text = "Recent tags",
|
||||
style = MaterialTheme.typography.labelLarge,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.padding(start = 12.dp, bottom = 4.dp),
|
||||
)
|
||||
|
||||
if (recent.isEmpty()) {
|
||||
Text(
|
||||
text = "No tags yet — add some from the editor.",
|
||||
style = MaterialTheme.typography.bodyMedium,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
modifier = Modifier.padding(horizontal = 12.dp, vertical = 8.dp),
|
||||
)
|
||||
} else {
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.verticalScroll(rememberScrollState()),
|
||||
verticalArrangement = Arrangement.spacedBy(2.dp),
|
||||
) {
|
||||
recent.forEach { usage ->
|
||||
DrawerHashtagEntry(
|
||||
usage = usage,
|
||||
selected = currentFilter == NoteFilter.ByTag(usage.name),
|
||||
onClick = { onSelectFilter(NoteFilter.ByTag(usage.name)) },
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Spacer(modifier = Modifier.height(16.dp))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
private fun DrawerHashtagEntry(
|
||||
usage: HashtagUsage,
|
||||
selected: Boolean,
|
||||
onClick: () -> Unit,
|
||||
) {
|
||||
NavigationDrawerItem(
|
||||
label = { Text("#${usage.name}") },
|
||||
badge = {
|
||||
val n = usage.noteCount
|
||||
val label = if (n == 1) "1 note" else "$n notes"
|
||||
Text(label, style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant)
|
||||
},
|
||||
selected = selected,
|
||||
onClick = onClick,
|
||||
icon = { Icon(Icons.Filled.Tag, contentDescription = null) },
|
||||
)
|
||||
}
|
||||
|
||||
@Suppress("unused")
|
||||
private val _ignored: Color = Color.Unspecified
|
||||
@@ -7,7 +7,8 @@ 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.ExperimentalLayoutApi
|
||||
import androidx.compose.foundation.layout.FlowRow
|
||||
import androidx.compose.foundation.layout.WindowInsets
|
||||
import androidx.compose.foundation.layout.fillMaxSize
|
||||
import androidx.compose.foundation.layout.fillMaxWidth
|
||||
@@ -21,28 +22,39 @@ import androidx.compose.foundation.shape.CircleShape
|
||||
import androidx.compose.foundation.text.KeyboardOptions
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.automirrored.filled.ArrowBack
|
||||
import androidx.compose.material.icons.filled.Add
|
||||
import androidx.compose.material.icons.filled.Close
|
||||
import androidx.compose.material.icons.filled.Delete
|
||||
import androidx.compose.material.icons.filled.Done
|
||||
import androidx.compose.material.icons.filled.MoreVert
|
||||
import androidx.compose.material.icons.filled.Star
|
||||
import androidx.compose.material.icons.filled.Tag
|
||||
import androidx.compose.material.icons.outlined.StarOutline
|
||||
import androidx.compose.material3.AlertDialog
|
||||
import androidx.compose.material3.AssistChip
|
||||
import androidx.compose.material3.AssistChipDefaults
|
||||
import androidx.compose.material3.CenterAlignedTopAppBar
|
||||
import androidx.compose.material3.DropdownMenu
|
||||
import androidx.compose.material3.DropdownMenuItem
|
||||
import androidx.compose.material3.ExperimentalMaterial3Api
|
||||
import androidx.compose.material3.Icon
|
||||
import androidx.compose.material3.IconButton
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.ModalBottomSheet
|
||||
import androidx.compose.material3.OutlinedTextField
|
||||
import androidx.compose.material3.Scaffold
|
||||
import androidx.compose.material3.SnackbarHost
|
||||
import androidx.compose.material3.SnackbarHostState
|
||||
import androidx.compose.material3.SuggestionChip
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.material3.TextButton
|
||||
import androidx.compose.material3.TopAppBar
|
||||
import androidx.compose.material3.rememberModalBottomSheetState
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
import androidx.compose.runtime.rememberCoroutineScope
|
||||
import androidx.compose.runtime.saveable.rememberSaveable
|
||||
import androidx.compose.runtime.setValue
|
||||
import androidx.compose.ui.Modifier
|
||||
@@ -54,9 +66,14 @@ import androidx.compose.ui.text.input.KeyboardCapitalization
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import androidx.lifecycle.viewmodel.compose.viewModel
|
||||
import kotlinx.coroutines.launch
|
||||
import org.incido.compose.ui.theme.AllNoteColors
|
||||
import org.incido.compose.ui.theme.swatchBorderColor
|
||||
import org.incido.compose.ui.theme.toComposeColor
|
||||
import org.incido.domain.model.Hashtag
|
||||
import org.incido.domain.model.NoteColor
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class)
|
||||
@Composable
|
||||
fun NoteEditorScreen(
|
||||
noteId: Long?,
|
||||
@@ -70,6 +87,8 @@ fun NoteEditorScreen(
|
||||
val focusRequester = remember { FocusRequester() }
|
||||
var menuExpanded by remember { mutableStateOf(false) }
|
||||
var showDiscardDialog by rememberSaveable { mutableStateOf(false) }
|
||||
val snackbarHost = remember { SnackbarHostState() }
|
||||
val scope = rememberCoroutineScope()
|
||||
|
||||
LaunchedEffect(state.isLoading) {
|
||||
if (!state.isLoading && state.existing != null) {
|
||||
@@ -80,12 +99,21 @@ fun NoteEditorScreen(
|
||||
if (noteId == null) focusRequester.requestFocus()
|
||||
}
|
||||
|
||||
LaunchedEffect(state.snackbar) {
|
||||
val msg = state.snackbar ?: return@LaunchedEffect
|
||||
scope.launch {
|
||||
snackbarHost.showSnackbar(msg)
|
||||
viewModel.consumeSnackbar()
|
||||
}
|
||||
}
|
||||
|
||||
fun isDirty(): Boolean {
|
||||
if (state.isLoading) return false
|
||||
return state.isDirty(
|
||||
initialContent = viewModel.initialContent,
|
||||
initialFavorite = viewModel.initialFavorite,
|
||||
initialColor = viewModel.initialColor,
|
||||
initialTags = viewModel.initialHashtags,
|
||||
)
|
||||
}
|
||||
|
||||
@@ -93,7 +121,6 @@ fun NoteEditorScreen(
|
||||
if (isDirty()) showDiscardDialog = true else onClose()
|
||||
}
|
||||
|
||||
// Intercept hardware / gesture back to honour the same discard rule.
|
||||
BackHandler(enabled = true) { tryClose() }
|
||||
|
||||
if (showDiscardDialog) {
|
||||
@@ -118,14 +145,10 @@ fun NoteEditorScreen(
|
||||
}
|
||||
|
||||
Scaffold(
|
||||
// Union systemBars + IME insets so the Scaffold's contentPadding
|
||||
// shrinks the available area when the soft keyboard opens. With
|
||||
// edge-to-edge enabled (MainActivity.enableEdgeToEdge), the IME
|
||||
// inset is NOT applied by default, which previously caused the
|
||||
// OutlinedTextField to extend behind the keyboard.
|
||||
contentWindowInsets = WindowInsets.systemBars.union(WindowInsets.ime),
|
||||
snackbarHost = { SnackbarHost(hostState = snackbarHost) },
|
||||
topBar = {
|
||||
TopAppBar(
|
||||
CenterAlignedTopAppBar(
|
||||
title = { Text(if (state.isEditing) "Edit note" else "New note") },
|
||||
navigationIcon = {
|
||||
IconButton(onClick = { tryClose() }) {
|
||||
@@ -133,6 +156,18 @@ fun NoteEditorScreen(
|
||||
}
|
||||
},
|
||||
actions = {
|
||||
IconButton(
|
||||
onClick = { viewModel.openAddTagSheet() },
|
||||
enabled = state.canAddMoreTags,
|
||||
) {
|
||||
Icon(
|
||||
Icons.Filled.Tag,
|
||||
contentDescription = "Add tag",
|
||||
tint = if (state.canAddMoreTags)
|
||||
MaterialTheme.colorScheme.onSurfaceVariant
|
||||
else MaterialTheme.colorScheme.outlineVariant,
|
||||
)
|
||||
}
|
||||
IconButton(onClick = { viewModel.toggleFavorite() }) {
|
||||
Icon(
|
||||
imageVector = if (state.isFavorite) Icons.Filled.Star else Icons.Outlined.StarOutline,
|
||||
@@ -176,14 +211,25 @@ fun NoteEditorScreen(
|
||||
.fillMaxSize()
|
||||
.padding(padding),
|
||||
) {
|
||||
// Colour-picker row (above the editor).
|
||||
HashtagChipRow(
|
||||
tags = state.hashtags,
|
||||
canAddMore = state.canAddMoreTags,
|
||||
onAddClick = { viewModel.openAddTagSheet() },
|
||||
onRemove = { viewModel.removeTag(it) },
|
||||
)
|
||||
|
||||
// Colour-picker row above the editor text field.
|
||||
LazyRow(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(horizontal = 16.dp, vertical = 8.dp),
|
||||
.padding(horizontal = 16.dp, vertical = 4.dp),
|
||||
horizontalArrangement = Arrangement.spacedBy(12.dp),
|
||||
) {
|
||||
items(items = AllNoteColors, key = { it.storageKey.toInt() }) { color ->
|
||||
items(
|
||||
count = AllNoteColors.size,
|
||||
key = { idx -> AllNoteColors[idx].storageKey.toInt() },
|
||||
) { idx ->
|
||||
val color = AllNoteColors[idx]
|
||||
ColorSwatch(
|
||||
color = color,
|
||||
selected = state.color == color,
|
||||
@@ -191,6 +237,7 @@ fun NoteEditorScreen(
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
OutlinedTextField(
|
||||
value = state.content,
|
||||
onValueChange = viewModel::onContentChange,
|
||||
@@ -207,14 +254,134 @@ fun NoteEditorScreen(
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
if (state.isAddingTag) {
|
||||
AddTagSheet(
|
||||
tagInput = state.tagInput,
|
||||
suggestions = state.tagSuggestions,
|
||||
canCreate = Hashtag.parseOrNull(state.tagInput) != null &&
|
||||
Hashtag.normalise(state.tagInput) !in state.hashtags,
|
||||
onInputChange = viewModel::onTagInputChange,
|
||||
onPickSuggestion = { picked ->
|
||||
viewModel.addTag(picked)
|
||||
viewModel.closeAddTagSheet()
|
||||
},
|
||||
onCreate = {
|
||||
if (viewModel.addTag(state.tagInput)) {
|
||||
viewModel.closeAddTagSheet()
|
||||
}
|
||||
},
|
||||
onDismiss = { viewModel.closeAddTagSheet() },
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
private fun androidx.compose.foundation.lazy.LazyListScope.items(
|
||||
items: List<NoteColor>,
|
||||
key: (NoteColor) -> Any,
|
||||
itemContent: @Composable (NoteColor) -> Unit,
|
||||
@OptIn(ExperimentalLayoutApi::class, ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
private fun HashtagChipRow(
|
||||
tags: List<String>,
|
||||
canAddMore: Boolean,
|
||||
onAddClick: () -> Unit,
|
||||
onRemove: (String) -> Unit,
|
||||
) {
|
||||
items(items.size, key = { key(items[it]) }) { idx -> itemContent(items[idx]) }
|
||||
if (tags.isEmpty() && !canAddMore) return
|
||||
FlowRow(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(horizontal = 16.dp, vertical = 8.dp),
|
||||
horizontalArrangement = Arrangement.spacedBy(8.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(4.dp),
|
||||
) {
|
||||
if (tags.isEmpty()) {
|
||||
Text(
|
||||
text = "Tags",
|
||||
style = MaterialTheme.typography.labelLarge,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
}
|
||||
tags.forEach { tag ->
|
||||
AssistChip(
|
||||
onClick = { onRemove(tag) },
|
||||
label = { Text("#$tag") },
|
||||
trailingIcon = {
|
||||
Icon(Icons.Filled.Close, contentDescription = "Remove $tag", modifier = Modifier.size(16.dp))
|
||||
},
|
||||
)
|
||||
}
|
||||
if (canAddMore) {
|
||||
AssistChip(
|
||||
onClick = onAddClick,
|
||||
label = { Text("+ add") },
|
||||
leadingIcon = { Icon(Icons.Filled.Add, contentDescription = null, modifier = Modifier.size(16.dp)) },
|
||||
colors = AssistChipDefaults.assistChipColors(
|
||||
labelColor = MaterialTheme.colorScheme.primary,
|
||||
leadingIconContentColor = MaterialTheme.colorScheme.primary,
|
||||
),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
private fun AddTagSheet(
|
||||
tagInput: String,
|
||||
suggestions: List<String>,
|
||||
canCreate: Boolean,
|
||||
onInputChange: (String) -> Unit,
|
||||
onPickSuggestion: (String) -> Unit,
|
||||
onCreate: () -> Unit,
|
||||
onDismiss: () -> Unit,
|
||||
) {
|
||||
val sheetState = rememberModalBottomSheetState(skipPartiallyExpanded = true)
|
||||
ModalBottomSheet(
|
||||
onDismissRequest = onDismiss,
|
||||
sheetState = sheetState,
|
||||
) {
|
||||
Column(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.padding(horizontal = 24.dp, vertical = 8.dp),
|
||||
verticalArrangement = Arrangement.spacedBy(12.dp),
|
||||
) {
|
||||
Text("Add a tag", style = MaterialTheme.typography.titleMedium)
|
||||
OutlinedTextField(
|
||||
value = tagInput,
|
||||
onValueChange = onInputChange,
|
||||
placeholder = { Text("#tag-name") },
|
||||
singleLine = true,
|
||||
leadingIcon = { Icon(Icons.Filled.Tag, contentDescription = null) },
|
||||
keyboardOptions = KeyboardOptions(capitalization = KeyboardCapitalization.None),
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
)
|
||||
if (suggestions.isNotEmpty()) {
|
||||
Text(
|
||||
"Suggestions",
|
||||
style = MaterialTheme.typography.labelLarge,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
LazyRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) {
|
||||
items(count = suggestions.size, key = { idx -> suggestions[idx] }) { idx ->
|
||||
val s = suggestions[idx]
|
||||
SuggestionChip(
|
||||
onClick = { onPickSuggestion(s) },
|
||||
label = { Text("#$s") },
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
if (canCreate) {
|
||||
TextButton(onClick = onCreate) {
|
||||
Text("+ Create \"${Hashtag.normalise(tagInput)}\"")
|
||||
}
|
||||
}
|
||||
Text(
|
||||
"Tags help you find notes later. Up to ${NoteEditorUiState.MAX_TAGS} per note.",
|
||||
style = MaterialTheme.typography.bodySmall,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Composable
|
||||
|
||||
@@ -12,35 +12,46 @@ import kotlinx.coroutines.flow.asStateFlow
|
||||
import kotlinx.coroutines.flow.update
|
||||
import kotlinx.coroutines.launch
|
||||
import org.incido.compose.IncidoApplication
|
||||
import org.incido.domain.model.Hashtag
|
||||
import org.incido.domain.model.Note
|
||||
import org.incido.domain.model.NoteColor
|
||||
import org.incido.domain.repository.NoteRepository
|
||||
|
||||
/**
|
||||
* Immutable UI state for [NoteEditorScreen]. The editor is in "new"
|
||||
* mode when [existing] is null, otherwise it edits an existing note.
|
||||
* Immutable UI state for [NoteEditorScreen].
|
||||
*/
|
||||
data class NoteEditorUiState(
|
||||
val existing: Note? = null,
|
||||
val content: String = "",
|
||||
val isFavorite: Boolean = false,
|
||||
val color: NoteColor = NoteColor.NONE,
|
||||
/** Normalised, sorted ascending. */
|
||||
val hashtags: List<String> = emptyList(),
|
||||
/** True while the add-tag sheet is open. */
|
||||
val isAddingTag: Boolean = false,
|
||||
/** Latest typing in the add-tag sheet (raw, before normalisation). */
|
||||
val tagInput: String = "",
|
||||
/** Autocomplete suggestions for the add-tag sheet. */
|
||||
val tagSuggestions: List<String> = emptyList(),
|
||||
val isLoading: Boolean = true,
|
||||
val isSaving: Boolean = false,
|
||||
val isDeleted: Boolean = false,
|
||||
val snackbar: String? = null,
|
||||
) {
|
||||
val canSave: Boolean get() = content.isNotBlank() && !isSaving
|
||||
val isEditing: Boolean get() = existing != null
|
||||
val canAddMoreTags: Boolean get() = hashtags.size < MAX_TAGS
|
||||
|
||||
/**
|
||||
* True when the editor has changes that haven't been saved. Used by
|
||||
* the discard-confirm dialog in [NoteEditorScreen] to decide whether
|
||||
* to prompt before closing.
|
||||
*/
|
||||
fun isDirty(initialContent: String, initialFavorite: Boolean, initialColor: NoteColor): Boolean {
|
||||
fun isDirty(initialContent: String, initialFavorite: Boolean, initialColor: NoteColor, initialTags: List<String>): Boolean {
|
||||
return content != initialContent ||
|
||||
isFavorite != initialFavorite ||
|
||||
color != initialColor
|
||||
color != initialColor ||
|
||||
hashtags != initialTags
|
||||
}
|
||||
|
||||
companion object {
|
||||
/** Hard cap on tags per note (matches Development Plan §6.1). */
|
||||
const val MAX_TAGS = 5
|
||||
}
|
||||
}
|
||||
|
||||
@@ -52,29 +63,48 @@ class NoteEditorViewModel(
|
||||
private val _state = MutableStateFlow(NoteEditorUiState())
|
||||
val state: StateFlow<NoteEditorUiState> = _state.asStateFlow()
|
||||
|
||||
/**
|
||||
* Snapshot of the initial state when the editor loaded. Used by
|
||||
* [NoteEditorScreen] to compute the discard-confirm predicate.
|
||||
*/
|
||||
/** Snapshot of initial values for the dirty predicate (see [NoteEditorScreen]). */
|
||||
var initialContent: String = ""
|
||||
private set
|
||||
var initialFavorite: Boolean = false
|
||||
private set
|
||||
var initialColor: NoteColor = NoteColor.NONE
|
||||
private set
|
||||
var initialHashtags: List<String> = emptyList()
|
||||
private set
|
||||
|
||||
/** Internal: re-emits suggestions whenever the tag input changes. */
|
||||
private val tagInputFlow = MutableStateFlow("")
|
||||
private val tagSuggestionsFlow = MutableStateFlow<List<String>>(emptyList())
|
||||
|
||||
init {
|
||||
// Tag autocomplete — re-query on every keystroke (debounced upstream
|
||||
// would be nice but ObjectBox is plenty fast for this size).
|
||||
viewModelScope.launch {
|
||||
tagInputFlow.collect { raw ->
|
||||
val prefix = Hashtag.normalise(raw)
|
||||
val pool = if (prefix.isEmpty()) {
|
||||
repository.observeAllHashtags()
|
||||
} else {
|
||||
repository.searchHashtags(prefix)
|
||||
}
|
||||
pool.collect { suggestions ->
|
||||
_state.update { it.copy(tagSuggestions = suggestions) }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Load the note if editing.
|
||||
if (noteId == null || noteId == 0L) {
|
||||
// New note
|
||||
_state.update { it.copy(isLoading = false) }
|
||||
} else {
|
||||
viewModelScope.launch {
|
||||
repository.observeById(noteId).collect { note ->
|
||||
if (note != null && _state.value.isLoading) {
|
||||
// First non-null load — capture the initial snapshot.
|
||||
initialContent = note.content
|
||||
initialFavorite = note.isFavorite
|
||||
initialColor = note.color
|
||||
initialHashtags = note.hashtags
|
||||
}
|
||||
_state.update {
|
||||
it.copy(
|
||||
@@ -82,6 +112,7 @@ class NoteEditorViewModel(
|
||||
content = note?.content ?: it.content,
|
||||
isFavorite = note?.isFavorite ?: it.isFavorite,
|
||||
color = note?.color ?: it.color,
|
||||
hashtags = note?.hashtags ?: it.hashtags,
|
||||
isLoading = false,
|
||||
)
|
||||
}
|
||||
@@ -102,23 +133,74 @@ class NoteEditorViewModel(
|
||||
_state.update { it.copy(color = color) }
|
||||
}
|
||||
|
||||
fun openAddTagSheet() {
|
||||
_state.update {
|
||||
it.copy(
|
||||
isAddingTag = true,
|
||||
tagInput = "",
|
||||
tagSuggestions = emptyList(),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
fun closeAddTagSheet() {
|
||||
_state.update { it.copy(isAddingTag = false, tagInput = "", tagSuggestions = emptyList()) }
|
||||
}
|
||||
|
||||
fun onTagInputChange(raw: String) {
|
||||
tagInputFlow.value = raw
|
||||
_state.update { it.copy(tagInput = raw) }
|
||||
}
|
||||
|
||||
/** Add an existing tag to the note (idempotent). Returns false if the cap is hit. */
|
||||
fun addTag(name: String): Boolean {
|
||||
val normalised = Hashtag.normalise(name)
|
||||
if (normalised.isEmpty()) return false
|
||||
if (!normalised.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) return false
|
||||
val current = _state.value
|
||||
if (normalised in current.hashtags) return true // already there
|
||||
if (current.hashtags.size >= NoteEditorUiState.MAX_TAGS) {
|
||||
_state.update { it.copy(snackbar = "Maximum ${NoteEditorUiState.MAX_TAGS} tags reached.") }
|
||||
return false
|
||||
}
|
||||
_state.update { it.copy(hashtags = (it.hashtags + normalised).sorted()) }
|
||||
return true
|
||||
}
|
||||
|
||||
fun removeTag(name: String) {
|
||||
val normalised = Hashtag.normalise(name)
|
||||
_state.update { it.copy(hashtags = it.hashtags.filterNot { tag -> tag == normalised }) }
|
||||
}
|
||||
|
||||
fun consumeSnackbar() {
|
||||
_state.update { it.copy(snackbar = null) }
|
||||
}
|
||||
|
||||
fun save(onDone: () -> Unit) {
|
||||
val current = _state.value
|
||||
if (!current.canSave) return
|
||||
_state.update { it.copy(isSaving = true) }
|
||||
viewModelScope.launch {
|
||||
val toPersist = current.existing?.copy(
|
||||
val baseNote = current.existing
|
||||
val toPersist = baseNote?.copy(
|
||||
content = current.content,
|
||||
isFavorite = current.isFavorite,
|
||||
color = current.color,
|
||||
hashtags = current.hashtags,
|
||||
) ?: Note(
|
||||
content = current.content,
|
||||
createdAt = System.currentTimeMillis(),
|
||||
updatedAt = System.currentTimeMillis(),
|
||||
isFavorite = current.isFavorite,
|
||||
color = current.color,
|
||||
hashtags = current.hashtags,
|
||||
)
|
||||
repository.upsert(toPersist)
|
||||
val saved = repository.upsert(toPersist)
|
||||
// Reconcile hashtag set vs. what was previously persisted.
|
||||
val previous = baseNote?.hashtags.orEmpty().toSet()
|
||||
val currentSet = current.hashtags.toSet()
|
||||
(previous - currentSet).forEach { repository.removeHashtag(saved.id, it) }
|
||||
(currentSet - previous).forEach { repository.addHashtag(saved.id, it) }
|
||||
_state.update { it.copy(isSaving = false) }
|
||||
onDone()
|
||||
}
|
||||
|
||||
@@ -13,15 +13,18 @@ import androidx.compose.foundation.layout.padding
|
||||
import androidx.compose.foundation.layout.size
|
||||
import androidx.compose.foundation.lazy.LazyColumn
|
||||
import androidx.compose.foundation.lazy.items
|
||||
import androidx.compose.foundation.shape.RoundedCornerShape
|
||||
import androidx.compose.foundation.shape.CircleShape
|
||||
import androidx.compose.material.icons.Icons
|
||||
import androidx.compose.material.icons.filled.Add
|
||||
import androidx.compose.material.icons.filled.CheckBox
|
||||
import androidx.compose.material.icons.filled.Delete
|
||||
import androidx.compose.material.icons.filled.Menu
|
||||
import androidx.compose.material.icons.filled.Search
|
||||
import androidx.compose.material.icons.filled.Star
|
||||
import androidx.compose.material.icons.outlined.StarOutline
|
||||
import androidx.compose.material3.Card
|
||||
import androidx.compose.material3.CardDefaults
|
||||
import androidx.compose.material3.CenterAlignedTopAppBar
|
||||
import androidx.compose.material3.ExperimentalMaterial3Api
|
||||
import androidx.compose.material3.FloatingActionButton
|
||||
import androidx.compose.material3.Icon
|
||||
@@ -30,8 +33,8 @@ import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.material3.OutlinedTextField
|
||||
import androidx.compose.material3.Scaffold
|
||||
import androidx.compose.material3.Text
|
||||
import androidx.compose.material3.TopAppBar
|
||||
import androidx.compose.runtime.Composable
|
||||
import androidx.compose.runtime.LaunchedEffect
|
||||
import androidx.compose.runtime.getValue
|
||||
import androidx.compose.runtime.mutableStateOf
|
||||
import androidx.compose.runtime.remember
|
||||
@@ -39,41 +42,57 @@ 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.graphics.Brush
|
||||
import androidx.compose.ui.graphics.Color
|
||||
import androidx.compose.ui.graphics.lerp
|
||||
import androidx.compose.ui.text.style.TextOverflow
|
||||
import androidx.compose.ui.unit.dp
|
||||
import androidx.lifecycle.compose.collectAsStateWithLifecycle
|
||||
import androidx.lifecycle.viewmodel.compose.viewModel
|
||||
import org.incido.compose.ui.editor.toComposeColor
|
||||
import org.incido.compose.ui.theme.toComposeColor
|
||||
import org.incido.compose.util.rememberRelativeTimestamp
|
||||
import org.incido.domain.model.Note
|
||||
import org.incido.domain.model.NoteColor
|
||||
import org.incido.domain.model.NoteFilter
|
||||
|
||||
@OptIn(ExperimentalMaterial3Api::class)
|
||||
@Composable
|
||||
fun NoteListScreen(
|
||||
filterMode: NoteFilter,
|
||||
onOpenDrawer: () -> Unit,
|
||||
onOpenEditor: (Long?) -> Unit,
|
||||
viewModel: NoteListViewModel = viewModel(factory = NoteListViewModel.Factory),
|
||||
) {
|
||||
val state by viewModel.uiState.collectAsStateWithLifecycle()
|
||||
var localQuery by remember { mutableStateOf("") }
|
||||
|
||||
// Keep the ViewModel in sync with the parent's filter selection.
|
||||
LaunchedEffect(filterMode) { viewModel.setFilter(filterMode) }
|
||||
|
||||
Scaffold(
|
||||
topBar = {
|
||||
TopAppBar(
|
||||
title = { Text("Incido") },
|
||||
CenterAlignedTopAppBar(
|
||||
title = { Text(screenTitle(filterMode)) },
|
||||
navigationIcon = {
|
||||
IconButton(onClick = onOpenDrawer) {
|
||||
Icon(Icons.Filled.Menu, contentDescription = "Open menu")
|
||||
}
|
||||
},
|
||||
actions = {
|
||||
if (filterMode == NoteFilter.Home) {
|
||||
IconButton(onClick = {
|
||||
if (state.isSearchActive) viewModel.closeSearch() else viewModel.openSearch()
|
||||
localQuery = ""
|
||||
}) {
|
||||
Icon(Icons.Default.Search, contentDescription = "Search notes")
|
||||
Icon(Icons.Filled.Search, contentDescription = "Search notes")
|
||||
}
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
floatingActionButton = {
|
||||
if (!state.isSearchActive) {
|
||||
// FAB only on Home — adding notes while filtered makes less sense.
|
||||
if (filterMode == NoteFilter.Home) {
|
||||
FloatingActionButton(onClick = { onOpenEditor(null) }) {
|
||||
Icon(Icons.Default.Add, contentDescription = "New note")
|
||||
}
|
||||
@@ -81,7 +100,7 @@ fun NoteListScreen(
|
||||
},
|
||||
) { padding ->
|
||||
Column(modifier = Modifier.padding(padding)) {
|
||||
if (state.isSearchActive) {
|
||||
if (filterMode == NoteFilter.Home && state.isSearchActive) {
|
||||
OutlinedTextField(
|
||||
value = localQuery,
|
||||
onValueChange = {
|
||||
@@ -99,8 +118,8 @@ fun NoteListScreen(
|
||||
|
||||
when {
|
||||
state.isLoading -> Unit
|
||||
state.isEmpty -> EmptyState()
|
||||
state.noResults -> NoResultsState()
|
||||
state.isEmpty -> EmptyState(filterMode = filterMode)
|
||||
state.noResults -> NoResultsState(filterMode = filterMode)
|
||||
else -> NoteList(
|
||||
notes = state.notes,
|
||||
onClick = { onOpenEditor(it.id) },
|
||||
@@ -112,8 +131,21 @@ fun NoteListScreen(
|
||||
}
|
||||
}
|
||||
|
||||
private fun screenTitle(filter: NoteFilter): String = when (filter) {
|
||||
NoteFilter.Home -> "Incido"
|
||||
NoteFilter.Favorites -> "Favorites"
|
||||
NoteFilter.Untagged -> "Untagged"
|
||||
is NoteFilter.ByTag -> "#${filter.hashtag}"
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun EmptyState() {
|
||||
private fun EmptyState(filterMode: NoteFilter) {
|
||||
val message = when (filterMode) {
|
||||
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. 🎉"
|
||||
is NoteFilter.ByTag -> "No notes tagged #${filterMode.hashtag} yet."
|
||||
}
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
@@ -121,7 +153,7 @@ private fun EmptyState() {
|
||||
contentAlignment = Alignment.Center,
|
||||
) {
|
||||
Text(
|
||||
text = "No notes yet. Tap + to start.",
|
||||
text = message,
|
||||
style = MaterialTheme.typography.bodyLarge,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
@@ -129,7 +161,11 @@ private fun EmptyState() {
|
||||
}
|
||||
|
||||
@Composable
|
||||
private fun NoResultsState() {
|
||||
private fun NoResultsState(filterMode: NoteFilter) {
|
||||
val message = when (filterMode) {
|
||||
NoteFilter.Home -> "No matching notes."
|
||||
else -> "Nothing here."
|
||||
}
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.fillMaxSize()
|
||||
@@ -137,7 +173,7 @@ private fun NoResultsState() {
|
||||
contentAlignment = Alignment.Center,
|
||||
) {
|
||||
Text(
|
||||
text = "No matching notes.",
|
||||
text = message,
|
||||
style = MaterialTheme.typography.bodyLarge,
|
||||
color = MaterialTheme.colorScheme.onSurfaceVariant,
|
||||
)
|
||||
@@ -172,6 +208,13 @@ private fun NoteList(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* v0.3.0.0 card redesign — three-layer colour accent so notes of
|
||||
* different colours are visually distinct at a glance:
|
||||
* 1. 14 dp vertical gradient stripe down the left edge.
|
||||
* 2. Tinted card surface (12 % colour blend over the M3 surface).
|
||||
* 3. 10 dp solid colour chip in the top-right corner.
|
||||
*/
|
||||
@Composable
|
||||
private fun NoteCard(
|
||||
note: Note,
|
||||
@@ -182,19 +225,38 @@ private fun NoteCard(
|
||||
val (title, body) = Note.titleAndBody(note.content)
|
||||
val bodyPreview = Note.bodyPreview(body)
|
||||
val checklistSummary = Note.checklistSummary(note.content)
|
||||
val stripeColor = note.color.toComposeColor()
|
||||
val noteColor = note.color
|
||||
val hasColor = noteColor != NoteColor.NONE
|
||||
|
||||
Card(
|
||||
onClick = onClick,
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
colors = if (hasColor) {
|
||||
val tint = noteColor.toComposeColor()
|
||||
val surface = MaterialTheme.colorScheme.surface
|
||||
CardDefaults.cardColors(
|
||||
containerColor = lerp(surface, tint, 0.12f),
|
||||
)
|
||||
} else {
|
||||
CardDefaults.cardColors()
|
||||
},
|
||||
) {
|
||||
Row(modifier = Modifier.fillMaxWidth()) {
|
||||
// 4dp coloured accent stripe on the left.
|
||||
if (hasColor) {
|
||||
// Layer 1: 14 dp gradient stripe.
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.size(width = 4.dp, height = 96.dp)
|
||||
.background(stripeColor),
|
||||
.size(width = 14.dp, height = 110.dp)
|
||||
.background(
|
||||
Brush.verticalGradient(
|
||||
colors = listOf(
|
||||
noteColor.toComposeColor().copy(alpha = 0.95f),
|
||||
noteColor.toComposeColor().copy(alpha = 0.05f),
|
||||
),
|
||||
)
|
||||
),
|
||||
)
|
||||
}
|
||||
Column(modifier = Modifier.padding(16.dp).fillMaxWidth()) {
|
||||
Row(
|
||||
modifier = Modifier.fillMaxWidth(),
|
||||
@@ -207,6 +269,16 @@ private fun NoteCard(
|
||||
overflow = TextOverflow.Ellipsis,
|
||||
modifier = Modifier.weight(1f),
|
||||
)
|
||||
// Layer 3: top-right colour chip (only when coloured).
|
||||
if (hasColor) {
|
||||
Box(
|
||||
modifier = Modifier
|
||||
.size(10.dp)
|
||||
.clip(CircleShape)
|
||||
.background(noteColor.toComposeColor()),
|
||||
)
|
||||
Spacer(modifier = Modifier.size(8.dp))
|
||||
}
|
||||
IconButton(onClick = onToggleFavorite) {
|
||||
Icon(
|
||||
imageVector = if (note.isFavorite) Icons.Filled.Star else Icons.Outlined.StarOutline,
|
||||
@@ -267,4 +339,11 @@ private fun NoteCard(
|
||||
}
|
||||
}
|
||||
|
||||
// --- Lightweight imports used to avoid shadowed-name conflicts in
|
||||
// other files that might also import these symbols ---
|
||||
@Suppress("unused")
|
||||
private fun clip(@Suppress("UNUSED_PARAMETER") shape: androidx.compose.ui.graphics.Shape): Modifier =
|
||||
Modifier.clip(shape)
|
||||
|
||||
@Suppress("unused")
|
||||
private fun background(color: Color): Modifier = Modifier.background(color)
|
||||
@@ -17,26 +17,24 @@ import kotlinx.coroutines.flow.flatMapLatest
|
||||
import kotlinx.coroutines.flow.stateIn
|
||||
import kotlinx.coroutines.launch
|
||||
import org.incido.compose.IncidoApplication
|
||||
import org.incido.domain.model.HashtagUsage
|
||||
import org.incido.domain.model.Note
|
||||
import org.incido.domain.model.NoteFilter
|
||||
import org.incido.domain.repository.NoteRepository
|
||||
|
||||
/**
|
||||
* Immutable UI state for [NoteListScreen]. A loading flag plus the
|
||||
* current snapshot of notes; an empty list with [isLoading] == false
|
||||
* indicates the empty-state UI should be shown (F6).
|
||||
*
|
||||
* [isSearchActive] / [searchQuery] are now properly folded into the same
|
||||
* uiState flow (v0.2.1 fix — they used to live on a separate StateFlow
|
||||
* that the composable never observed, making the search icon a no-op).
|
||||
* Immutable UI state for [NoteListScreen].
|
||||
*/
|
||||
data class NoteListUiState(
|
||||
val notes: List<Note> = emptyList(),
|
||||
val isLoading: Boolean = true,
|
||||
val searchQuery: String = "",
|
||||
val isSearchActive: Boolean = false,
|
||||
val filter: NoteFilter = NoteFilter.Home,
|
||||
val recentHashtags: List<HashtagUsage> = emptyList(),
|
||||
) {
|
||||
val isEmpty: Boolean get() = !isLoading && notes.isEmpty() && !isSearchActive
|
||||
val noResults: Boolean get() = !isLoading && notes.isEmpty() && isSearchActive
|
||||
val isEmpty: Boolean get() = !isLoading && notes.isEmpty() && !isSearchActive && filter == NoteFilter.Home
|
||||
val noResults: Boolean get() = !isLoading && notes.isEmpty() && !isEmpty
|
||||
}
|
||||
|
||||
@OptIn(ExperimentalCoroutinesApi::class, FlowPreview::class)
|
||||
@@ -44,34 +42,36 @@ class NoteListViewModel(
|
||||
private val repository: NoteRepository,
|
||||
) : ViewModel() {
|
||||
|
||||
private val filterMode = MutableStateFlow<NoteFilter>(NoteFilter.Home)
|
||||
private val rawQuery = MutableStateFlow("")
|
||||
private val _isSearchActive = MutableStateFlow(false)
|
||||
|
||||
/**
|
||||
* Combines the filtered notes flow, the search-active flag, and the
|
||||
* raw query into a single [NoteListUiState] that the composable can
|
||||
* `collectAsStateWithLifecycle`. All three pieces of state are
|
||||
* updated together so `if (state.isSearchActive)` in the screen
|
||||
* actually reflects the icon's toggled value.
|
||||
*/
|
||||
val uiState: StateFlow<NoteListUiState> = combine(
|
||||
rawQuery
|
||||
.debounce(150)
|
||||
.flatMapLatest { q ->
|
||||
if (q.isBlank()) {
|
||||
repository.observeAll()
|
||||
} else {
|
||||
repository.search(q)
|
||||
/** Notes stream — switches on (filter, query) so the same ViewModel
|
||||
* instance handles Home, Favorites, Untagged, ByTag, and search. */
|
||||
private val notesFlow = combine(filterMode, rawQuery) { f, q -> f to q }
|
||||
.flatMapLatest { (f, q) ->
|
||||
when (f) {
|
||||
NoteFilter.Home -> if (q.isBlank()) repository.observeAll() else repository.search(q)
|
||||
NoteFilter.Favorites -> repository.observeFavorites()
|
||||
NoteFilter.Untagged -> repository.observeUntagged()
|
||||
is NoteFilter.ByTag -> repository.observeNotesForHashtag(f.hashtag)
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
val uiState: StateFlow<NoteListUiState> = combine(
|
||||
notesFlow,
|
||||
_isSearchActive,
|
||||
filterMode,
|
||||
rawQuery,
|
||||
) { notes, searchActive, q ->
|
||||
repository.observeHashtagsByRecentUse(),
|
||||
) { notes, searchActive, filter, query, recent ->
|
||||
NoteListUiState(
|
||||
notes = notes,
|
||||
isLoading = false,
|
||||
searchQuery = q,
|
||||
searchQuery = query,
|
||||
isSearchActive = searchActive,
|
||||
filter = filter,
|
||||
recentHashtags = recent,
|
||||
)
|
||||
}.stateIn(
|
||||
scope = viewModelScope,
|
||||
@@ -79,6 +79,16 @@ class NoteListViewModel(
|
||||
initialValue = NoteListUiState(),
|
||||
)
|
||||
|
||||
fun setFilter(filter: NoteFilter) {
|
||||
filterMode.value = filter
|
||||
// Switching away from Home closes the search bar (search is
|
||||
// only meaningful in Home).
|
||||
if (filter != NoteFilter.Home && _isSearchActive.value) {
|
||||
_isSearchActive.value = false
|
||||
rawQuery.value = ""
|
||||
}
|
||||
}
|
||||
|
||||
fun onQueryChange(q: String) {
|
||||
rawQuery.value = q
|
||||
}
|
||||
|
||||
+5
-7
@@ -1,4 +1,4 @@
|
||||
package org.incido.compose.ui.editor
|
||||
package org.incido.compose.ui.theme
|
||||
|
||||
import androidx.compose.material3.MaterialTheme
|
||||
import androidx.compose.runtime.Composable
|
||||
@@ -7,8 +7,8 @@ import androidx.compose.ui.graphics.Color
|
||||
import org.incido.domain.model.NoteColor
|
||||
|
||||
/**
|
||||
* Maps a [NoteColor] enum to a Compose [Color] using Material 3 tokens so
|
||||
* the swatches adapt to light/dark theme automatically.
|
||||
* Maps a [NoteColor] enum to a Compose [Color]. Values are chosen to
|
||||
* stay readable against both light and dark surfaces.
|
||||
*/
|
||||
@Composable
|
||||
@ReadOnlyComposable
|
||||
@@ -21,6 +21,7 @@ fun NoteColor.toComposeColor(): Color = when (this) {
|
||||
NoteColor.PURPLE -> Color(0xFF7B5BA6)
|
||||
}
|
||||
|
||||
/** All selectable colours, including [NoteColor.NONE]. */
|
||||
val AllNoteColors: List<NoteColor> = listOf(
|
||||
NoteColor.NONE,
|
||||
NoteColor.BLUE,
|
||||
@@ -30,10 +31,7 @@ val AllNoteColors: List<NoteColor> = listOf(
|
||||
NoteColor.PURPLE,
|
||||
)
|
||||
|
||||
/**
|
||||
* A swatch surface colour for a swatch button — used to give the
|
||||
* selected swatch a visible border by reading the theme's outline.
|
||||
*/
|
||||
/** Outline colour used to highlight the selected swatch. */
|
||||
val swatchBorderColor: Color
|
||||
@Composable
|
||||
@ReadOnlyComposable
|
||||
@@ -0,0 +1,19 @@
|
||||
package org.incido.data.entity
|
||||
|
||||
import io.objectbox.annotation.Entity
|
||||
import io.objectbox.annotation.Id
|
||||
import io.objectbox.annotation.Index
|
||||
|
||||
/**
|
||||
* A single normalised hashtag. Case-insensitive uniqueness is
|
||||
* enforced at the repository layer (`NoteRepositoryImpl.addHashtag`
|
||||
* uses `findFirst` and reuses the existing row); the index here just
|
||||
* speeds up the lookup.
|
||||
*
|
||||
* The "many-to-many" link to notes lives in [NoteHashtagCrossRef].
|
||||
*/
|
||||
@Entity
|
||||
data class HashtagEntity(
|
||||
@Id var id: Long = 0,
|
||||
@Index var name: String = "",
|
||||
)
|
||||
@@ -0,0 +1,19 @@
|
||||
package org.incido.data.entity
|
||||
|
||||
import io.objectbox.annotation.Entity
|
||||
import io.objectbox.annotation.Id
|
||||
import io.objectbox.annotation.Index
|
||||
|
||||
/**
|
||||
* Many-to-many junction between [NoteEntity] and [HashtagEntity].
|
||||
* Each row is one (`noteId`, `hashtagId`) pair.
|
||||
*
|
||||
* Both columns are indexed for fast lookups in either direction
|
||||
* (notes for a hashtag, hashtags for a note).
|
||||
*/
|
||||
@Entity
|
||||
data class NoteHashtagCrossRef(
|
||||
@Id var id: Long = 0,
|
||||
@Index var noteId: Long = 0,
|
||||
@Index var hashtagId: Long = 0,
|
||||
)
|
||||
@@ -2,72 +2,113 @@ package org.incido.data.repository
|
||||
|
||||
import io.objectbox.BoxStore
|
||||
import io.objectbox.kotlin.boxFor
|
||||
import io.objectbox.query.QueryBuilder
|
||||
import io.objectbox.reactive.DataSubscription
|
||||
import kotlinx.coroutines.channels.awaitClose
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.callbackFlow
|
||||
import kotlinx.coroutines.flow.flowOn
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import org.incido.data.entity.HashtagEntity
|
||||
import org.incido.data.entity.HashtagEntity_
|
||||
import org.incido.data.entity.NoteEntity
|
||||
import org.incido.data.entity.NoteEntity_
|
||||
import org.incido.data.entity.NoteHashtagCrossRef
|
||||
import org.incido.data.entity.NoteHashtagCrossRef_
|
||||
import org.incido.data.entity.toDomain
|
||||
import org.incido.data.entity.toEntity
|
||||
import org.incido.domain.model.Hashtag
|
||||
import org.incido.domain.model.HashtagUsage
|
||||
import org.incido.domain.model.Note
|
||||
import org.incido.domain.repository.NoteRepository
|
||||
|
||||
/**
|
||||
* ObjectBox-backed implementation of [NoteRepository]. All writes are
|
||||
* dispatched to `Default`; reads use ObjectBox's reactive subscription so
|
||||
* the UI auto-refreshes whenever a row changes (F7).
|
||||
* ObjectBox-backed implementation of [NoteRepository]. Hashtags live
|
||||
* in two extra tables (`HashtagEntity`, `NoteHashtagCrossRef`); every
|
||||
* "list of notes" snapshot here loads the cross-ref + tags in one
|
||||
* pass so callers get fully-populated [Note.hashtags] lists.
|
||||
*
|
||||
* Sort order is `isFavorite DESC, updatedAt DESC` for both [observeAll] and
|
||||
* [search] so favourites always float to the top.
|
||||
* Sort order for [observeAll] / [search] / filter streams:
|
||||
* `isFavorite DESC, updatedAt DESC`.
|
||||
*
|
||||
* Note: ObjectBox 4.0.3's Kotlin stubs are finicky around
|
||||
* `QueryBuilder.equal(Property, String, ...)` — passing the
|
||||
* `StringOrder` argument explicitly is the most reliable way to call it.
|
||||
*/
|
||||
class NoteRepositoryImpl(
|
||||
private val boxStore: BoxStore,
|
||||
) : NoteRepository {
|
||||
|
||||
private val box = boxStore.boxFor<NoteEntity>()
|
||||
private val noteBox = boxStore.boxFor<NoteEntity>()
|
||||
private val tagBox = boxStore.boxFor<HashtagEntity>()
|
||||
private val xrefBox = boxStore.boxFor<NoteHashtagCrossRef>()
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// List / observation streams
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
override fun observeAll(): Flow<List<Note>> = callbackFlow {
|
||||
trySend(sortedSnapshot(""))
|
||||
|
||||
val subscription = box
|
||||
.query()
|
||||
.build()
|
||||
.subscribe()
|
||||
.observer { trySend(sortedSnapshot("")) }
|
||||
|
||||
awaitClose { subscription.cancel() }
|
||||
trySend(snapshotAll())
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotAll()) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun search(query: String): Flow<List<Note>> = callbackFlow {
|
||||
trySend(sortedSnapshot(query))
|
||||
trySend(snapshotSearch(query))
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotSearch(query)) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
val subscription = if (query.isBlank()) {
|
||||
box.query().build().subscribe()
|
||||
} else {
|
||||
box.query()
|
||||
.contains(NoteEntity_.content, query, io.objectbox.query.QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.subscribe()
|
||||
}.observer { trySend(sortedSnapshot(query)) }
|
||||
override fun observeFavorites(): Flow<List<Note>> = callbackFlow {
|
||||
trySend(snapshotFavorites())
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotFavorites()) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
awaitClose { subscription.cancel() }
|
||||
override fun observeUntagged(): Flow<List<Note>> = callbackFlow {
|
||||
trySend(snapshotUntagged())
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotUntagged()) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun observeNotesForHashtag(name: String): Flow<List<Note>> = callbackFlow {
|
||||
trySend(snapshotForHashtag(name))
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotForHashtag(name)) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun observeHashtagsByRecentUse(): Flow<List<HashtagUsage>> = callbackFlow {
|
||||
trySend(hashtagUsageSnapshot())
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(hashtagUsageSnapshot()) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun observeAllHashtags(): Flow<List<String>> = callbackFlow {
|
||||
trySend(allHashtagsSnapshot().sorted())
|
||||
val sub = noteBox.query().build().subscribe().observer {
|
||||
trySend(allHashtagsSnapshot().sorted())
|
||||
}
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun searchHashtags(prefix: String): Flow<List<String>> = callbackFlow {
|
||||
trySend(searchHashtagsSnapshot(prefix))
|
||||
val sub = noteBox.query().build().subscribe().observer {
|
||||
trySend(searchHashtagsSnapshot(prefix))
|
||||
}
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun observeById(id: Long): Flow<Note?> = callbackFlow {
|
||||
trySend(box.get(id)?.toDomain())
|
||||
|
||||
val subscription = box
|
||||
.query()
|
||||
.build()
|
||||
.subscribe()
|
||||
.observer { trySend(box.get(id)?.toDomain()) }
|
||||
|
||||
awaitClose { subscription.cancel() }
|
||||
trySend(noteByIdSnapshot(id))
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(noteByIdSnapshot(id)) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// Writes
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
override suspend fun upsert(note: Note): Note {
|
||||
val now = System.currentTimeMillis()
|
||||
val toPersist = if (note.id == 0L) {
|
||||
@@ -75,39 +116,213 @@ class NoteRepositoryImpl(
|
||||
} else {
|
||||
note.copy(updatedAt = now).toEntity()
|
||||
}
|
||||
val assignedId = box.put(toPersist)
|
||||
val existing = box.get(assignedId)
|
||||
return existing?.toDomain() ?: note.copy(id = assignedId)
|
||||
val assignedId = noteBox.put(toPersist)
|
||||
return noteBox.get(assignedId)?.toDomain() ?: note.copy(id = assignedId)
|
||||
}
|
||||
|
||||
override suspend fun delete(id: Long) {
|
||||
box.remove(id)
|
||||
noteBox.remove(id)
|
||||
val orphanXrefs: List<NoteHashtagCrossRef> = xrefBox.query()
|
||||
.equal(NoteHashtagCrossRef_.noteId, id)
|
||||
.build()
|
||||
.find()
|
||||
if (orphanXrefs.isNotEmpty()) {
|
||||
xrefBox.remove(*orphanXrefs.map { it.id }.toLongArray())
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun setFavorite(id: Long, isFavorite: Boolean) {
|
||||
val entity = box.get(id) ?: return
|
||||
val entity = noteBox.get(id) ?: return
|
||||
if (entity.isFavorite == isFavorite) return
|
||||
entity.isFavorite = isFavorite
|
||||
box.put(entity)
|
||||
noteBox.put(entity)
|
||||
}
|
||||
|
||||
/**
|
||||
* Snapshot helper. If [query] is non-blank, only notes whose content
|
||||
* contains it (case-insensitive) are included; otherwise all notes.
|
||||
* The result is sorted favourites-first, then newest-first.
|
||||
*/
|
||||
private fun sortedSnapshot(query: String): List<Note> {
|
||||
val raw = if (query.isBlank()) {
|
||||
box.all
|
||||
} else {
|
||||
box.query()
|
||||
.contains(NoteEntity_.content, query, io.objectbox.query.QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
override suspend fun addHashtag(noteId: Long, name: String) {
|
||||
val normalised = Hashtag.normalise(name)
|
||||
if (!normalised.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) return
|
||||
|
||||
val tag: HashtagEntity = tagBox.query()
|
||||
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.find()
|
||||
.findFirst() ?: run {
|
||||
tagBox.put(HashtagEntity(name = normalised))
|
||||
// Re-query to get the freshly-inserted row (with its new id).
|
||||
tagBox.query()
|
||||
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.findFirst()
|
||||
} ?: return
|
||||
|
||||
val existing: NoteHashtagCrossRef? = xrefBox.query()
|
||||
.equal(NoteHashtagCrossRef_.noteId, noteId)
|
||||
.equal(NoteHashtagCrossRef_.hashtagId, tag.id)
|
||||
.build()
|
||||
.findFirst()
|
||||
if (existing != null) return
|
||||
|
||||
xrefBox.put(NoteHashtagCrossRef(noteId = noteId, hashtagId = tag.id))
|
||||
}
|
||||
return raw.sortedWith(
|
||||
|
||||
override suspend fun removeHashtag(noteId: Long, name: String) {
|
||||
val normalised = Hashtag.normalise(name)
|
||||
val tag: HashtagEntity = tagBox.query()
|
||||
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.findFirst() ?: return
|
||||
val xref: NoteHashtagCrossRef = xrefBox.query()
|
||||
.equal(NoteHashtagCrossRef_.noteId, noteId)
|
||||
.equal(NoteHashtagCrossRef_.hashtagId, tag.id)
|
||||
.build()
|
||||
.findFirst() ?: return
|
||||
xrefBox.remove(xref.id)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// Snapshots
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
/** Map of noteId -> ordered list of hashtag names. */
|
||||
private fun hashtagsByNoteId(): Map<Long, List<String>> {
|
||||
val xrefs: List<NoteHashtagCrossRef> = xrefBox.all
|
||||
if (xrefs.isEmpty()) return emptyMap()
|
||||
val tagIds: Set<Long> = xrefs.map { it.hashtagId }.toSet()
|
||||
val tagById: Map<Long, String> = tagIds.associateWith { id ->
|
||||
tagBox.get(id)?.name ?: ""
|
||||
}.filterValues { it.isNotEmpty() }
|
||||
|
||||
return xrefs.groupBy { it.noteId }
|
||||
.mapValues { (_, refs) ->
|
||||
refs.mapNotNull { tagById[it.hashtagId] }.sorted()
|
||||
}
|
||||
}
|
||||
|
||||
private fun decorate(entities: List<NoteEntity>): List<Note> {
|
||||
val tags = hashtagsByNoteId()
|
||||
return entities.sortedWith(
|
||||
compareByDescending<NoteEntity> { it.isFavorite }
|
||||
.thenByDescending { it.updatedAt }
|
||||
).map { it.toDomain() }
|
||||
).map { e ->
|
||||
val base = e.toDomain()
|
||||
base.copy(hashtags = tags[e.id].orEmpty())
|
||||
}
|
||||
}
|
||||
|
||||
private fun snapshotAll(): List<Note> = decorate(noteBox.all)
|
||||
|
||||
private fun snapshotSearch(query: String): List<Note> {
|
||||
val q = query.trim()
|
||||
if (q.isEmpty()) return snapshotAll()
|
||||
|
||||
// Match against content (contains, case-insensitive).
|
||||
val contentMatches: List<Long> = noteBox.query()
|
||||
.contains(NoteEntity_.content, q, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.find()
|
||||
.map { it.id }
|
||||
|
||||
// Match against hashtag names (case-insensitive exact equality).
|
||||
val matchingTag: HashtagEntity? = tagBox.query()
|
||||
.equal(HashtagEntity_.name, q, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.findFirst()
|
||||
val tagMatches: List<Long> = if (matchingTag == null) emptyList() else {
|
||||
xrefBox.query()
|
||||
.equal(NoteHashtagCrossRef_.hashtagId, matchingTag.id)
|
||||
.build()
|
||||
.find()
|
||||
.map { it.noteId }
|
||||
}
|
||||
|
||||
val allIds: Set<Long> = (contentMatches + tagMatches).toSet()
|
||||
if (allIds.isEmpty()) return emptyList()
|
||||
val entities: List<NoteEntity> = allIds.mapNotNull { noteBox.get(it) }
|
||||
return decorate(entities)
|
||||
}
|
||||
|
||||
private fun snapshotFavorites(): List<Note> {
|
||||
val favEntities: List<NoteEntity> = noteBox.query()
|
||||
.equal(NoteEntity_.isFavorite, true)
|
||||
.build()
|
||||
.find()
|
||||
return decorate(favEntities)
|
||||
}
|
||||
|
||||
private fun snapshotUntagged(): List<Note> {
|
||||
val noteIdsWithTags: Set<Long> = xrefBox.all.map { it.noteId }.toSet()
|
||||
val untaggedEntities: List<NoteEntity> = noteBox.all.filter { it.id !in noteIdsWithTags }
|
||||
return decorate(untaggedEntities)
|
||||
}
|
||||
|
||||
private fun snapshotForHashtag(name: String): List<Note> {
|
||||
val normalised = Hashtag.normalise(name)
|
||||
val tag: HashtagEntity = tagBox.query()
|
||||
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.findFirst() ?: return emptyList()
|
||||
val xrefs: List<NoteHashtagCrossRef> = xrefBox.query()
|
||||
.equal(NoteHashtagCrossRef_.hashtagId, tag.id)
|
||||
.build()
|
||||
.find()
|
||||
val noteIds: Set<Long> = xrefs.map { it.id }.let { _ -> xrefs.map { it.noteId }.toSet() }
|
||||
if (noteIds.isEmpty()) return emptyList()
|
||||
val entities: List<NoteEntity> = noteIds.mapNotNull { noteBox.get(it) }
|
||||
return decorate(entities)
|
||||
}
|
||||
|
||||
private fun noteByIdSnapshot(id: Long): Note? {
|
||||
val entity = noteBox.get(id) ?: return null
|
||||
val tags = hashtagsByNoteId()[id].orEmpty()
|
||||
return entity.toDomain().copy(hashtags = tags)
|
||||
}
|
||||
|
||||
/** Build [HashtagUsage] for every distinct tag, sorted by lastUsedAt DESC. */
|
||||
private fun hashtagUsageSnapshot(): List<HashtagUsage> {
|
||||
val xrefs: List<NoteHashtagCrossRef> = xrefBox.all
|
||||
if (xrefs.isEmpty()) return emptyList()
|
||||
|
||||
// For each hashtagId, accumulate (lastUsedAt, count).
|
||||
data class Agg(var lastUsedAt: Long, var count: Int)
|
||||
val aggregate = HashMap<Long, Agg>(xrefs.size)
|
||||
for (x in xrefs) {
|
||||
val note: NoteEntity = noteBox.get(x.noteId) ?: continue
|
||||
val cur = aggregate[x.hashtagId]
|
||||
if (cur == null) {
|
||||
aggregate[x.hashtagId] = Agg(note.updatedAt, 1)
|
||||
} else {
|
||||
if (note.updatedAt > cur.lastUsedAt) cur.lastUsedAt = note.updatedAt
|
||||
cur.count += 1
|
||||
}
|
||||
}
|
||||
return aggregate.mapNotNull { (tagId, agg) ->
|
||||
val tag: HashtagEntity = tagBox.get(tagId) ?: return@mapNotNull null
|
||||
HashtagUsage(name = tag.name, noteCount = agg.count, lastUsedAt = agg.lastUsedAt)
|
||||
}.sortedWith(
|
||||
compareByDescending<HashtagUsage> { it.lastUsedAt }
|
||||
.thenByDescending { it.noteCount }
|
||||
.thenBy { it.name }
|
||||
)
|
||||
}
|
||||
|
||||
private fun allHashtagsSnapshot(): List<String> =
|
||||
tagBox.all.map { it.name }
|
||||
|
||||
private fun searchHashtagsSnapshot(prefix: String): List<String> {
|
||||
val p = prefix.trim()
|
||||
if (p.isEmpty()) return allHashtagsSnapshot().sorted()
|
||||
|
||||
val byPrefix: List<HashtagEntity> = tagBox.query()
|
||||
.startsWith(HashtagEntity_.name, p.lowercase(), QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.find()
|
||||
|
||||
// Sort by usage count (most-used first), then name.
|
||||
val usageById: Map<Long, Int> = xrefBox.all.groupingBy { it.hashtagId }.eachCount()
|
||||
return byPrefix
|
||||
.sortedWith(
|
||||
compareByDescending<HashtagEntity> { usageById[it.id] ?: 0 }
|
||||
.thenBy { it.name }
|
||||
)
|
||||
.map { it.name }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package org.incido.domain.model
|
||||
|
||||
/**
|
||||
* A single hashtag, normalised: lowercase, no leading `#`, no
|
||||
* surrounding whitespace. The [name] is the on-disk identifier so
|
||||
* two notes tagging "Work" and "work" share a row.
|
||||
*
|
||||
* Allowed characters: `a-z`, `0-9`, `.`, `_`, `-`. Must start with an
|
||||
* alphanumeric. Length 1..31.
|
||||
*/
|
||||
@JvmInline
|
||||
value class Hashtag(val name: String) {
|
||||
init {
|
||||
require(name.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) {
|
||||
"Invalid hashtag name: \"$name\". Must match ^[a-z0-9][a-z0-9._-]{0,30}$"
|
||||
}
|
||||
}
|
||||
|
||||
/** Render with leading `#` for display. */
|
||||
fun displayName(): String = "#$name"
|
||||
|
||||
companion object {
|
||||
/** Normalise raw user input — trim, lowercase, strip leading `#`s. */
|
||||
fun normalise(raw: String): String =
|
||||
raw.trim().lowercase().trimStart('#').trim()
|
||||
|
||||
/** Try to parse; returns null when the input doesn't match the rules. */
|
||||
fun parseOrNull(raw: String): Hashtag? {
|
||||
val n = normalise(raw)
|
||||
return if (n.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) Hashtag(n) else null
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
package org.incido.domain.model
|
||||
|
||||
/**
|
||||
* Aggregate info about a single hashtag, for the nav drawer's "Recent
|
||||
* tags" list.
|
||||
*/
|
||||
data class HashtagUsage(
|
||||
val name: String,
|
||||
val noteCount: Int,
|
||||
val lastUsedAt: Long,
|
||||
)
|
||||
@@ -12,6 +12,8 @@ data class Note(
|
||||
val updatedAt: Long,
|
||||
val isFavorite: Boolean = false,
|
||||
val color: NoteColor = NoteColor.NONE,
|
||||
/** Tags attached to this note (normalised lowercase, sorted ascending). */
|
||||
val hashtags: List<String> = emptyList(),
|
||||
) {
|
||||
companion object {
|
||||
private const val UNTITLED = "Untitled"
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
package org.incido.domain.model
|
||||
|
||||
/**
|
||||
* What the note list is currently showing. Drives both the
|
||||
* `NoteListScreen` body and the selected entry in the navigation
|
||||
* drawer.
|
||||
*
|
||||
* - [Home] — every note (the default). The search bar is enabled.
|
||||
* - [Favorites] — only notes with `isFavorite = true`. No search.
|
||||
* - [Untagged] — only notes that have zero hashtags. No search.
|
||||
* - [ByTag] — only notes tagged with [hashtag]. No search.
|
||||
*/
|
||||
sealed class NoteFilter {
|
||||
object Home : NoteFilter()
|
||||
object Favorites : NoteFilter()
|
||||
object Untagged : NoteFilter()
|
||||
data class ByTag(val hashtag: String) : NoteFilter()
|
||||
|
||||
/** Stable identifier used by the drawer for `selected` matching. */
|
||||
fun key(): String = when (this) {
|
||||
Home -> "home"
|
||||
Favorites -> "favorites"
|
||||
Untagged -> "untagged"
|
||||
is ByTag -> "tag:$hashtag"
|
||||
}
|
||||
}
|
||||
@@ -1,28 +1,26 @@
|
||||
package org.incido.domain.repository
|
||||
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import org.incido.domain.model.HashtagUsage
|
||||
import org.incido.domain.model.Note
|
||||
|
||||
/**
|
||||
* Persistence boundary for [Note]s. The UI layer depends on this interface
|
||||
* only — never on the ObjectBox-backed implementation in `:core:data`.
|
||||
*
|
||||
* Implementations are expected to:
|
||||
* - Return a [Flow] that emits whenever the underlying data changes,
|
||||
* so the list screen satisfies F7 (auto-refresh).
|
||||
* - Assign a fresh id (0 or 0L on construction) for new notes and use the
|
||||
* ObjectBox-managed id once persisted.
|
||||
* - Sort [observeAll] / [search] with favourites first, then by [Note.updatedAt]
|
||||
* descending.
|
||||
* Sort order for [observeAll] / [search]: `isFavorite DESC, updatedAt DESC`.
|
||||
* [search] additionally matches against any of the note's hashtags
|
||||
* (case-insensitive equality).
|
||||
*/
|
||||
interface NoteRepository {
|
||||
/** Stream of all notes, newest-first, favourites pinned to the top. */
|
||||
fun observeAll(): Flow<List<Note>>
|
||||
|
||||
/**
|
||||
* Stream of notes whose [Note.content] contains [query] (case-insensitive),
|
||||
* favourites first then newest-first. An empty / blank [query] returns
|
||||
* the same list as [observeAll].
|
||||
* Stream of notes whose [Note.content] contains [query] (case-insensitive)
|
||||
* OR whose hashtags contain [query] as one of the names. Favourites
|
||||
* first then newest-first. Blank [query] returns the same as
|
||||
* [observeAll].
|
||||
*/
|
||||
fun search(query: String): Flow<List<Note>>
|
||||
|
||||
@@ -37,4 +35,50 @@ interface NoteRepository {
|
||||
|
||||
/** Toggle the favourite flag on a single note. */
|
||||
suspend fun setFavorite(id: Long, isFavorite: Boolean)
|
||||
|
||||
// --- Filter streams (v0.3.0.0) ---
|
||||
/** Only notes with `isFavorite = true`, sorted by updatedAt DESC. */
|
||||
fun observeFavorites(): Flow<List<Note>>
|
||||
|
||||
/** Only notes that have zero hashtags, sorted by updatedAt DESC. */
|
||||
fun observeUntagged(): Flow<List<Note>>
|
||||
|
||||
/** Only notes tagged with [name] (normalised form), sorted by updatedAt DESC. */
|
||||
fun observeNotesForHashtag(name: String): Flow<List<Note>>
|
||||
|
||||
/**
|
||||
* Every distinct hashtag, sorted by `lastUsedAt DESC` then
|
||||
* `noteCount DESC` then `name ASC`. Each entry also carries the
|
||||
* number of notes that use it.
|
||||
*/
|
||||
fun observeHashtagsByRecentUse(): Flow<List<HashtagUsage>>
|
||||
|
||||
// --- Hashtag autocomplete (v0.3.0.0) ---
|
||||
/**
|
||||
* Every distinct hashtag in the store, sorted by usage count DESC
|
||||
* then name ASC. Used to populate the autocomplete "suggestions"
|
||||
* list when the input is empty.
|
||||
*/
|
||||
fun observeAllHashtags(): Flow<List<String>>
|
||||
|
||||
/**
|
||||
* Hashtags whose name starts with [prefix] (case-insensitive),
|
||||
* sorted by usage count DESC then name ASC. Blank [prefix] is
|
||||
* equivalent to [observeAllHashtags].
|
||||
*/
|
||||
fun searchHashtags(prefix: String): Flow<List<String>>
|
||||
|
||||
/**
|
||||
* Add [name] to the note's hashtag set. Creates the hashtag row
|
||||
* if it doesn't exist yet. Idempotent. No-op if the note already
|
||||
* has the tag.
|
||||
*/
|
||||
suspend fun addHashtag(noteId: Long, name: String)
|
||||
|
||||
/**
|
||||
* Remove [name] from the note's hashtag set. Idempotent. No-op if
|
||||
* the note doesn't have the tag. The hashtag row itself is NOT
|
||||
* auto-deleted (cleanup is the future "tag browser" feature).
|
||||
*/
|
||||
suspend fun removeHashtag(noteId: Long, name: String)
|
||||
}
|
||||
Reference in new issue
Block a user