From 32166a3100386fd84867ce07fb76a09cdc462c08 Mon Sep 17 00:00:00 2001 From: Incido Developer Date: Thu, 17 Sep 2026 15:43:43 +1200 Subject: [PATCH] feat(lists): task and shopping-list note types with running total NoteType (TEXT / TASK_LIST / SHOPPING_LIST) persists in an additive NoteEntity.typeKey column (ObjectBox auto-migrates; old rows = TEXT). List bodies stay GitHub-flavoured '- [ ]' lines so search, field encryption, backups (defaulted noteType) and Trash keep working. Editor: checklist + basket buttons convert any note; rows are uniform underlined line fields (13sp) - product, 'Quan.' quantity (defaults to 1 on blur), and POS-style price showing raw cents while focused and $1.23 on focus loss. Sticky total bar sums qty x price of checked rows in integer cents via an explicit {q.. p..} end-of-line marker so product text is never scanned for numbers. Fixes found in device testing: cards rendered raw markdown for list notes stranded as TEXT by partial builds - read-time Note.inferListType now heals them; quantity field was clipped invisible (64dp vs the 48dp icon target) - replaced by the free-text line; the serializer emitted a bare 'q' slot (broken '{q p1.23}' markers, stray ' x' folds) - now null-when-default. Add-tag suggestions rebuilt on flatMapLatest so the autocomplete re-queries per keystroke. versionCode 32->33, versionName 0.3.8.0, APP_VERSION in lockstep. --- Incido Development Plan.txt | 14 +- README.md | 53 +-- app/build.gradle.kts | 26 +- .../incido/compose/data/backup/BackupCodec.kt | 10 + .../compose/data/settings/ReleaseNotes.kt | 46 ++- .../compose/ui/editor/NoteEditorScreen.kt | 360 +++++++++++++++++- .../compose/ui/editor/NoteEditorViewModel.kt | 216 ++++++++++- .../compose/ui/notelist/NoteListScreen.kt | 14 +- .../compose/ui/settings/SettingsViewModel.kt | 2 +- .../org/incido/data/entity/NoteEntity.kt | 12 + .../data/repository/NoteRepositoryImpl.kt | 19 +- .../org/incido/domain/model/ChecklistItem.kt | 27 ++ .../kotlin/org/incido/domain/model/Note.kt | 323 ++++++++++++++++ .../org/incido/domain/model/NoteType.kt | 31 ++ 14 files changed, 1044 insertions(+), 109 deletions(-) create mode 100644 core/domain/src/main/kotlin/org/incido/domain/model/ChecklistItem.kt create mode 100644 core/domain/src/main/kotlin/org/incido/domain/model/NoteType.kt diff --git a/Incido Development Plan.txt b/Incido Development Plan.txt index cc1d947..1ed045b 100644 --- a/Incido Development Plan.txt +++ b/Incido Development Plan.txt @@ -370,6 +370,7 @@ A short reference for AI assistants: | Version | Date | Notes | |---------|------|-------| +| 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. | | 0.3.7.0 | 2026-08-20 | **Feature release — Trash / soft delete.** Deleting a note (long-press card → ⋮ menu → Delete, or the editor's delete action) now soft-deletes it instead of destroying it: the note is flagged as trashed and hidden from Home, Favorites, Untagged, tag views, and ordinary search. A new **Trash** entry in the nav drawer lists only soft-deleted notes; each Trash card's overflow menu exposes **Restore** (returns the note to its previous views) and **Delete permanently** (destroys the row + attachments for good). `NoteEntity` gains a `trashed` flag (additive schema, auto-migrated); `NoteFilter` gains a `Trash` case; the repository gains `moveToTrash` / `restoreFromTrash` / `deletePermanently`; the drawer, list, and editor ViewModels + screens wire the new actions. Backups round-trip the trashed state. No automatic purge window yet — permanent deletion is immediate (see §6.1 "Trash status" note). versionCode 30→31, versionName "0.3.6.3"→"0.3.7.0", SettingsViewModel.APP_VERSION bumped in lockstep. | | 0.3.6.3 | 2026-08-20 | **Emergency hotfix — actionable missing-keystore failure.** On a fresh clone, `./gradlew assembleRelease` previously died late inside `packageRelease` with the cryptic `SigningConfig "release" is missing required property "storeFile"`. It now fails with a clear `GradleException` quoting the exact `keytool` command from `keystore/README.md` to generate `keystore/release.jks`, implemented as a `validateReleaseKeystore` task whose existence check runs in `doFirst` (so `assembleDebug` still works without a keystore). CI unaffected — `.gitea/workflows/release.yml` mints the dev keystore on release runners before `assembleRelease`. No app/Compose code changes. versionCode 29→30, versionName "0.3.6.2"→"0.3.6.3", SettingsViewModel.APP_VERSION bumped in lockstep. | @@ -430,9 +431,16 @@ A small Gradle task called `copyReleaseApks` (registered in Settings displays the new version and the in-app release-notes dialog recognises it. 3. **`README.md`** — bump the intro paragraph and "Current release" - line, and add a new row at the top of the Changelog table (the table - is the user-facing changelog — §10 keeps the historical release - notes). + line. **`PREVIOUS_HISTORY.md`** — append a new + `## v — ` section at the top: friendly user-facing + bullets, newest first (this file replaced the old README Changelog + table). On tag push the release workflow runs + `scripts/ci/release-notes.py` and attaches that section to the Gitea + release as its description **and** as an `Incido--changes.md` + asset beside the APKs — so keep one section per released version and + never reorder or delete old ones (§10 stays the developer-facing + history). For pre-existing releases created before this pipeline, + `scripts/ci/backfill-release-notes.sh` patches them retroactively. ### 11.2 Build both APKs (and stamp them) diff --git a/README.md b/README.md index 32a2307..0cc9104 100644 --- a/README.md +++ b/README.md @@ -6,9 +6,10 @@ 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.3.7.1** release: a single-user, offline -note app with hashtags, favourites, full-text search, colour-coded -notes, photo and file attachments, share-into from other apps and the +This repository contains the **v0.3.8.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, 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 @@ -16,7 +17,8 @@ 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.3.7.1 (see [Changelog](#changelog) below). +**Current release:** v0.3.8.0 — full release notes ship **on its entry on +the [Releases page](https://git.trevena.info/nick/incido/releases)**. > **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; @@ -37,40 +39,13 @@ cross-platform ports, end-to-end sync, and security features. ## Changelog -| Version | Date | Highlights | -|-----------|------------|------------| -| 0.3.7.1 | 2026-08-30 | **UI polish.** Add/Edit screen tidied up: camera, attach-file, and add-tag moved out of the top bar into a bottom action row, so the title and remaining buttons always fit. Fixed a false "couldn't load image" error that flashed whenever you opened a saved image. Search auto-focuses on open and shows a clear (✕) button. Long tag lists in the drawer now scroll instead of being cut off. The add-tag sheet opens with the keyboard ready. New flat app icon (same shield + pen-nib motif, cleaner squircle design). | -| 0.3.7.0 | 2026-08-20 | **Trash / soft delete.** Add a Trash drawer item; deleting a note soft-deletes it, hiding it from every active view and ordinary search. Trash-only cards expose Restore and permanent Delete. | -| 0.3.6.3 | 2026-08-20 | **Missing-keystore failure is now actionable on a fresh clone.** `./gradlew assembleRelease` now fails at configuration time with a clear `GradleException` quoting the exact `keytool` command from `keystore/README.md` if `keystore/release.jks` is missing, instead of dying much later inside `packageRelease` with the cryptic `SigningConfig "release" is missing required property "storeFile"`. CI is unchanged: `.gitea/workflows/release.yml` already mints the dev keystore on the runner before `assembleRelease`. | -| 0.3.6.2 | 2026-08-19 | **CI / release-pipeline tag.** — re-tag of v0.3.6.1 used to exercise the Gitea Actions release workflow (keystore minted on the release runner; debug + release APKs attached to the Gitea release). No app changes. | -| 0.3.6.1 | 2026-08-19 | **Editor top-bar title is now left-aligned.** On the New / Edit screen the title ("New" / "Edit") now sits next to the back arrow, away from the six action icons that crowd the right edge — it was previously centred via `CenterAlignedTopAppBar` and visually pushed toward the action cluster. **Colour picker is now symmetric between the title bar and the note top.** The picker is flanked by 12dp gaps above and below (was 4dp top + 4dp bottom) so the visual distance to the title bar matches the distance to the `OutlinedTextField`'s top edge, instead of being dwarfed by the field's intrinsic top inset. | -| 0.3.6.0 | 2026-08-19 | **Share webpages to Incido.** Sharing a page from your browser (Share → Incido) now creates a note with the page title on the first line and the URL below — fully offline (the title comes from the browser's share data, Incido never touches the network). **Export encryption key.** Settings → Security gains "Export encryption key" — saves the AES-256 key that protects your encrypted notes to a passphrase-protected `.inckey` file for device migrations. **Import encryption key** restores that key on a fresh install, with a clear warning before the current key is replaced. | -| 0.3.5.1 | 2026-08-17 | **"Encrypted" badge now appears the moment you flip the switch.** A race in `EncryptionVerifier.checkNow()` could silently drop the post-migration verification, leaving cards without the badge until a second toggle; replaced with a serializing Mutex so every check runs in invocation order. **"Encrypted" indicator is now a single lock icon next to the date** — consistent position on every card instead of a centred "lock + label" group at the bottom. | -| 0.3.5.0 | 2026-08-17 | **Real at-rest encryption.** Note text and attachment bytes are now AES-256-GCM encrypted in place the moment you toggle "Encrypt notes at rest" — no restart required; keyed by the Keystore-wrapped 32-byte key. **Verified "Encrypted" badge.** Every encrypted note is trial-decrypted on app open and after each migration; only verified notes get the lock badge. **Block screenshots (default ON).** New toggle in Settings → Security prevents screenshots, screen recording, and app-switcher previews while Incido is open. | -| 0.3.4.0 | 2026-08-17 | **Attachment indicator on note cards.** — a paperclip icon now appears on the right edge of every card that carries an attachment. **Light-theme readability over image thumbnails.** — cards with a dark photo background now force light text/icon colours over the image so notes stay readable in Light mode. **Auto-Lock "Immediately" no longer locks during file pickers.** — attaching a file, taking a photo, viewing an attachment, or exporting/importing a backup no longer destroys your in-progress note. | -| 0.3.3.8 | 2026-08-17 | **Designed Incido artwork is now the app icon.** The glass shield + fountain-pen nib replaces the placeholder glyph on the home screen, app drawer, and adaptive-icon layers. | -| 0.3.3.7 | 2026-08-17 | **Biometric auto-launch.** When Biometric is your active lock method, the fingerprint / face reader now opens automatically when the lock screen appears — no extra tap on "Authenticate" needed. | -| 0.3.3.6 | 2026-08-17 | **Card height tuned for real devices.** The fixed card height from v0.3.3.5 proved too tall on real devices; reduced by ~15% (now 143.dp). | -| 0.3.3.5 | 2026-08-17 | **Fixed card height.** All note cards now have a single fixed height (168.dp), so untagged notes no longer look shorter than tagged ones; timestamp pinned to the bottom via a weighted spacer; hashtag row still hidden when empty; left colour stripe spans the full card height. | -| 0.3.3.4 | 2026-08-17 | **Favourite star no longer overlaps the overflow button.** Star is now anchored to the card's bottom-right corner (same column as the top-right ⋮), so the two controls no longer collide. | -| 0.3.3.3 | 2026-08-17 | **Importing an encrypted backup no longer crashes.** The passphrase was being wiped between the preview step and the confirm dialog's Import button; now retained across the confirmation step, with proper try/catch around preview/import so failures surface a snackbar ("Import failed. Check the file and passphrase." / "Could not read backup file.") instead of crashing. | -| 0.3.3.2 | 2026-08-17 | **White-on-white lock screen in dark mode fixed.** `PinEntryScreen` is now wrapped in a themed Surface so it always paints its own theme-aware background. **Biometric unlock hang fixed.** Authentication is now fully asynchronous (BiometricPrompt callbacks run on the main executor) instead of busy-waiting on the main thread. Device-credential fallback preserved. | -| 0.3.3.1 | 2026-08-17 | **"Encrypt notes at rest" toggle now correctly greyed out.** Until Security is on and you've chosen either PIN or Biometric — with a subtitle explaining the requirement. **"Enable Security" no longer requires a PIN first.** The master switch just flips on; PIN / Biometric / Encrypt sub-toggles were already gated. **Importing an encrypted backup now opens a dedicated passphrase dialog.** (single field, no policy check) — wrong passphrase surfaces "Incorrect passphrase." via snackbar. | -| 0.3.3.0 | 2026-08-17 | **Lock mode as a single choice.** Security now exposes two mutually-exclusive toggles (PIN and Biometric) — either alone is enough to lock; Biometric no longer requires PIN first. New "Reset PIN" row appears when PIN is active; lock screen shows only the biometric button when no Incido PIN is set. **Encrypted-import passphrase prompt.** Selecting an encrypted backup opens the passphrase dialog first and surfaces "Incorrect passphrase." on mismatch. **Press-and-hold note card menu.** The inline delete button is gone; long-press a card (or tap the ⋮ button) to open a DropdownMenu with Delete — ready for future actions like Share. | -| 0.3.2.0 | 2026-08-15 | **New Settings screen.** (Untagged → Settings in the nav drawer) with Appearance, Security, Backup & Restore, and About sections. **At-rest encryption.** ObjectBox store is opened with a 32-byte AES-256 key wrapped by the Android Keystore; toggling the switch generates / deletes the key and surfaces a "Re-encrypting notes…" dialog. **PIN lock + biometric.** 4–6 digit PIN (PBKDF2-hashed, 100k iters, constant-time compare) with optional fingerprint / face unlock; cold launch + auto-lock timeout gate. **Backup / Import / Export.** JSON codec with Base64 attachment bytes; encrypted variant uses AES-256-GCM + PBKDF2(passphrase, 200k iters) with a Generate button + Copy to clipboard. Passphrase policy: 12–32 chars, ≥1 digit, ≥1 special. **Release notes dialog.** — tap the version number on the About card. Adds `USE_BIOMETRIC` + `USE_FINGERPRINT` permissions (still no INTERNET). | -| 0.3.1.2 | 2026-08-15 | **Three v0.3.1.1 issues fixed.** **card thumbnails are actually visible now** — the v0.3.1.1 layout had the thumbnail Image as a sibling of the Card, so the Card's opaque `containerColor` was drawn on top and the image was completely hidden; the architecture is restructured so the Image + dark scrim live INSIDE the Card, and `containerColor = Color.Transparent` when a thumbnail is present (plain notes still get the existing tinted/surface background). **Camera photos honour EXIF orientation** — `NoteRepositoryImpl.normalizeImageOrientation(bytes)` runs at storage time inside `addAttachment` (guarded `if (mimeType.startsWith("image/"))`); reads EXIF `Orientation`, rotates the bitmap, re-encodes as JPEG quality 92, and stores the corrected bytes so every render path (editor thumbnail, card thumbnail, full-screen viewer) sees the photo the right way up. **Non-image attachments open in the system viewer** — `AttachmentThumbnail.onClick` now branches on `isImage`: image taps still go to the in-app full-screen viewer; non-image taps write the bytes to a `cacheDir` temp file, get a `FileProvider` URI, and launch `Intent.ACTION_VIEW` with `FLAG_GRANT_READ_URI_PERMISSION` (the previous unconditional viewer path silently failed for PDFs/MP3s/etc. with a stuck "Loading…"). `file_paths.xml` already exposes `cacheDir` via ``, so no manifest change was needed. Attaching arbitrary file types from the paperclip icon was already shipped in v0.3.1.1 (the `*/*` intent filters) — no code change here, just called out so it's clear what was already in place. | -| 0.3.1.1 | 2026-08-15 | **Five v0.3.1.0 issues fixed.** Persisted image attachments now render a thumbnail in the editor strip (previously fell through to the file-type placeholder because bytes weren't loaded) — `AttachmentThumbnail` lazy-loads bytes from the DB via `produceState` + `repository.getAttachmentBytes()`. Card thumbnails are more visible — alpha bumped 0.45 → 0.70 and the dark scrim dropped 0.18 → 0.08; also `clipToBounds()` so the image can't bleed past the card's rounded corners. Share-into from webpages now opens a fresh editor — `MainActivity.handleShareIntent()` stashes the share text synchronously before launching the async image-byte I/O, so the Compose tree's `LaunchedEffect(Unit)` always finds a payload on first composition. Share menu now offers Incido for any file type (PDF, MP3, video, archives) — added `` to both `ACTION_SEND` and `ACTION_SEND_MULTIPLE` intent filters. Editor top-bar title shortened to "Edit" / "New" so it fits on one line with the new icon row. | -| 0.3.1.0 | 2026-08-15 | **Context-aware search.** — on the Favorites and Untagged pages, the search icon is now visible and a typed query intersects with the active filter (search only favourites on Favorites, only untagged notes on Untagged). On Home, search spans everything. **Photo / File attachments.** — the editor now has Camera (camera icon) and Attach File (paperclip icon) buttons. Photos are captured via `MediaStore.ACTION_IMAGE_CAPTURE` (with a transient `FileProvider` outbox; bytes live in the database, the temp file is deleted) and files via `ACTION_OPEN_DOCUMENT`. Attachments are stored as `ByteArray` columns inside ObjectBox — no filesystem paths to manage. Each note's attachments show up as a thumbnail strip in the editor with a ✕ in the top-right corner to remove. Tapping a thumbnail opens a full-screen viewer with pinch-to-zoom + pan (`Modifier.transformable`) and a close button. **Card thumbnails.** — notes with image attachments show the first image as a (alpha-blended, scrimmed) background on the list card. **Share-into.** — the app accepts `ACTION_SEND` (text + image) and `ACTION_SEND_MULTIPLE` (multiple images) from other apps. Inbound bytes are copied into a process-singleton `SharedIntentBuffer` and pre-filled into a new-note editor. Adds the `CAMERA` permission — still no `INTERNET`, still fully offline. | -| 0.3.0.5 | 2026-08-15 | **Hashtag reconciliation is now a single transaction.** `NoteEditorViewModel.save()` still did upsert + per-tag `addHashtag` in three separate writes, so the drawer's `hashtagUsageSnapshot()` could read a transient empty `xrefBox` between the `tagBox.put` and the `xrefBox.put` and leave `emptyList()` stuck in the StateFlow (toggling the favourite star worked around it because `setFavorite` re-touches `noteBox`). New `NoteRepository.saveNoteWithHashtags()` wraps upsert + hashtag reconciliation in a single ObjectBox transaction via `boxStore.callInTx { ... }`, so the per-box observers fire **once** at commit time with the final state. New hashtags now appear in the drawer's Recent Tags list the moment a note is saved — no workaround required. | -| 0.3.0.4 | 2026-08-14 | **Recent Tags now subscribes to all three boxes.** `observeHashtagsByRecentUse()` now subscribes to **all three** boxes (`noteBox`, `tagBox`, `xrefBox`) — adding a brand-new hashtag only touches `tagBox` + `xrefBox`, so the previous single-`noteBox` subscription missed those updates and the drawer's Recent Tags list only refreshed when something else touched `noteBox` (e.g. toggling the favourite star). Now the new tag is visible immediately after saving the note. | -| 0.3.0.3 | 2026-08-14 | **Batched hashtag-usage lookups.** `NoteRepositoryImpl.hashtagUsageSnapshot()` (one `Box.get` per distinct noteId and tagId, not per xref) and dropped the manual `trySend(snapshot())` in `observeHashtagsByRecentUse()` — the ObjectBox observer's first fire is now the sole source. The drawer's Recent Tags list fills in well under a second instead of taking minutes. | -| 0.3.0.2 | 2026-08-14 | **AddTagSheet placeholder cleaned up.** Dropped the redundant leading `#` from the AddTagSheet placeholder (was `#tag-name`, now `hashtag-name` — the leading `#` icon in the field already signals the format). | -| 0.3.0.1 | 2026-08-14 | **Editor + list-card UI polish.** Editor hashtag row moved to the bottom (and hidden when empty), `+ add` chip removed (use `#` icon in top bar), colour picker centred horizontally, list-card dog-ear colour accent replaces the small circle chip, list cards show a hashtag row (with `+N` abbreviation when capped). | -| 0.3.0.0 | 2026-08-14 | **Hashtags + bolder colour accent + nav drawer + new version scheme.** 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 | -| 0.2.0.1 | 2026-08-14 | **Search icon now opens the search bar.** Search icon now actually opens the search bar | -| 0.2.0.0 | 2026-08-14 | **Polish + favourites, search, colours, checklists, discard dialog, release signing.** | -| 0.1.1.0 | 2026-08-14 | **Editor IME fix + title/body on list cards.** | -| 0.1.0.0 | 2026-08-14 | **First MVP: list + editor, ObjectBox, Material 3.** | +Release notes now live **on the Releases page**: every Incido release entry +ships the full changelog for exactly that version — rendered in the +release description and attached beside the APKs as +`Incido--changes.md` (generated from `PREVIOUS_HISTORY.md` by the +release workflow). +→ [Releases](https://git.trevena.info/nick/incido/releases) + · [Previous release history (archive)](./PREVIOUS_HISTORY.md) --- @@ -93,8 +68,10 @@ incido/ │ └── data/ # ObjectBox-backed repository implementation ├── gradle/ # Version catalog (libs.versions.toml) + wrapper ├── keystore/ # Release signing (gitignored *.jks, README kept) +├── scripts/ci/ # Release tooling (changelog extractor for the CI) ├── .gitea/ # Gitea Actions workflow + issue/PR templates ├── CONTRIBUTING.md +├── PREVIOUS_HISTORY.md # Archived user-facing release history └── LICENSE ``` diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 0774a42..1a237ce 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -28,19 +28,19 @@ android { applicationId = "org.incido.app" minSdk = 26 targetSdk = 35 - // v0.3.7.1: maintenance release — UI polish + one bug fix. - // - Editor top bar decluttered: camera / attach-file / add-tag - // moved into a bottom action row so the title + remaining - // buttons always fit (matches the §5.2 spec). - // - Image viewer: fixed the false "couldn't decode" toast that - // fired on every persisted image open (premature null check). - // - Search auto-focus + clear button; drawer tag list now - // scrolls within the sheet; add-tag sheet auto-focus. - // - New flat app icon (incido_flat_icon.png) replaces the - // v0.3.3.8 artwork; adaptive background re-tinted to match. - // - versionCode monotonic +1 from v0.3.7.0 (31). - versionCode = 32 - versionName = "0.3.7.1" + // v0.3.8.0: feature release — task lists, shopping lists, hashtag fix. + // - Task-list note type: bottom-bar toggle converts the body into + // an editable checklist (checkbox + text rows, add / remove). + // - Shopping-list note type: like the task list plus a number-pad + // Cost field per item and a sticky running total of the checked + // (= in-basket) items (Development Plan §6.1). + // - Hashtag sheet now shows live-filtered suggestions again (the + // nested-collect autocomplete pipeline was stuck; flatMapLatest). + // - NoteEntity gains `typeKey` (additive, auto-migrated); backups + // round-trip `noteType` with a "TEXT" default for old files. + // - versionCode monotonic +1 from v0.3.7.1 (32). + versionCode = 33 + versionName = "0.3.8.0" } // --- Signing --- 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 9fa8f37..8bc3b1b 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 @@ -6,6 +6,7 @@ import kotlinx.serialization.json.Json 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 /** @@ -125,6 +126,12 @@ data class BackupNote( val attachments: List = emptyList(), /** Preserve soft-delete state; defaults to false for older backups. */ val isTrashed: Boolean = false, + /** + * v0.3.8.0 — serialised as the [org.incido.domain.model.NoteType] + * enum name ("TEXT" / "TASK_LIST" / "SHOPPING_LIST"). Defaulted so + * pre-v0.3.8.0 backup files import as plain-text notes. + */ + val noteType: String = "TEXT", ) @Serializable @@ -156,6 +163,7 @@ private suspend fun Note.toBackup(repository: NoteRepository): BackupNote { isFavorite = isFavorite, color = color.name, isTrashed = isTrashed, + noteType = type.name, hashtags = hashtags, attachments = backups, ) @@ -172,6 +180,7 @@ private fun Note.toBackup(): BackupNote = BackupNote( isFavorite = isFavorite, color = color.name, isTrashed = isTrashed, + noteType = type.name, hashtags = hashtags, attachments = emptyList(), ) @@ -184,6 +193,7 @@ private fun BackupNote.toDomain(): Note = Note( isFavorite = isFavorite, color = runCatching { NoteColor.valueOf(color) }.getOrDefault(NoteColor.NONE), isTrashed = isTrashed, + type = runCatching { NoteType.valueOf(noteType) }.getOrDefault(NoteType.TEXT), hashtags = hashtags, // Attachments are inserted separately by importSnapshot so they // get assigned to the freshly-created note id. 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 5ec7748..0068938 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,33 @@ object ReleaseNotes { * Append a new entry on top each release. */ val RECENT: List = listOf( + ReleaseNote( + version = "0.3.8.0", + date = "2026-09-16", + bullets = listOf( + "Task lists: a checklist button next to the # button in the " + + "editor turns any note into an editable task list — add, " + + "remove, and tick off items with real checkboxes.", + "Shopping lists with a running total: each row gets a " + + "quantity dropdown (1\u20139) and a supermarket-style " + + "price field \u2014 every digit you tap on the number pad " + + "is a cent, so entering 199 means $1.99 (the price box " + + "shows your raw entry beside its $ sign; the running " + + "total speaks real dollars). Tick an " + + "item once it's in your basket and the always-visible " + + "total at the top adds quantity \u00d7 price. Product, " + + "quantity, and price are strictly separate fields, so a " + + "product called \"Battery AA 3\" can never mess up your " + + "money maths.", + "Tapping the active list button again returns the note to " + + "plain text — nothing is lost, the items just become " + + "\"- [ ]\" lines you can also edit by hand.", + "Add-tag sheet fixed: existing hashtags now appear as a " + + "selectable suggestion list again, narrowing to matches " + + "live as you type (the suggestion pipeline was frozen, so " + + "only \"+ Create\\u2026\" ever showed).", + ), + ), ReleaseNote( version = "0.3.7.1", date = "2026-08-30", @@ -90,23 +117,6 @@ object ReleaseNotes { "label\" group at the bottom of the card).", ), ), - ReleaseNote( - version = "0.3.5.0", - date = "2026-08-17", - bullets = listOf( - "\"Encrypt notes at rest\" now really works: your note text " + - "and attachment files are AES-256-GCM encrypted in place " + - "the moment you flip the switch (no restart), using the " + - "Android Keystore key.", - "Every time the app opens, each encrypted note is " + - "double-checked by decrypting it — a card only earns the " + - "\"Encrypted\" badge at the bottom of the card if that " + - "check passes.", - "New \"Block screenshots\" toggle (on by default): prevents " + - "screenshots, screen recording, and app-switcher previews " + - "while Incido is open.", - ), - ), - // v0.3.7.1 push drops v0.3.4.0 off the "5 most recent" tail. + // v0.3.8.0 push drops v0.3.5.0 off the "5 most recent" tail. ) } 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 e36ecb7..3d4326b 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 @@ -11,6 +11,7 @@ import androidx.activity.result.contract.ActivityResultContracts import androidx.compose.foundation.Image import androidx.compose.foundation.background import androidx.compose.foundation.border +import androidx.compose.foundation.BorderStroke import androidx.compose.foundation.clickable import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box @@ -23,30 +24,38 @@ 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 import androidx.compose.foundation.layout.systemBars import androidx.compose.foundation.layout.union +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.lazy.LazyColumn import androidx.compose.foundation.lazy.LazyRow 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.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.AttachFile import androidx.compose.material.icons.filled.CameraAlt +import androidx.compose.material.icons.filled.Checklist import androidx.compose.material.icons.filled.Close import androidx.compose.material.icons.filled.Delete import androidx.compose.material.icons.filled.Description import androidx.compose.material.icons.filled.Done import androidx.compose.material.icons.filled.MoreVert +import androidx.compose.material.icons.filled.ShoppingBasket 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.Checkbox import androidx.compose.material3.DropdownMenu import androidx.compose.material3.DropdownMenuItem import androidx.compose.material3.ExperimentalMaterial3Api @@ -60,7 +69,10 @@ import androidx.compose.material3.Scaffold import androidx.compose.material3.SnackbarHost 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 @@ -78,6 +90,7 @@ import androidx.compose.ui.Modifier import androidx.compose.ui.draw.clip import androidx.compose.ui.focus.FocusRequester import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.focus.onFocusEvent import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.asImageBitmap import androidx.compose.ui.graphics.painter.BitmapPainter @@ -85,8 +98,11 @@ import androidx.compose.ui.layout.ContentScale import androidx.compose.ui.platform.LocalContext import androidx.compose.ui.text.input.ImeAction import androidx.compose.ui.text.input.KeyboardCapitalization +import androidx.compose.ui.text.input.KeyboardType import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.text.TextStyle import androidx.compose.ui.unit.dp +import androidx.compose.ui.unit.sp import androidx.core.content.FileProvider import androidx.lifecycle.compose.collectAsStateWithLifecycle import androidx.lifecycle.viewmodel.compose.viewModel @@ -97,8 +113,11 @@ import org.incido.compose.data.security.SecurityManager 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.ChecklistItem import org.incido.domain.model.Hashtag +import org.incido.domain.model.Note import org.incido.domain.model.NoteColor +import org.incido.domain.model.NoteType import java.io.File @OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class) @@ -247,6 +266,7 @@ fun NoteEditorScreen( initialFavorite = viewModel.initialFavorite, initialColor = viewModel.initialColor, initialTags = viewModel.initialHashtags, + initialType = viewModel.initialType, ) } @@ -368,20 +388,48 @@ fun NoteEditorScreen( } Spacer(Modifier.height(12.dp)) - OutlinedTextField( - value = state.content, - onValueChange = viewModel::onContentChange, - modifier = Modifier - .weight(1f) - .fillMaxWidth() - .padding(horizontal = 16.dp) - .focusRequester(focusRequester), - placeholder = { Text("Write something…") }, - keyboardOptions = KeyboardOptions( - capitalization = KeyboardCapitalization.Sentences, - imeAction = ImeAction.Default, - ), - ) + // v0.3.8.0 — structured list editors replace the free-text + // field whenever the note is a task / shopping list; the + // rows live in NoteEditorUiState.items and the view-model + // keeps `content` synchronised with their serialisation. + if (state.type == NoteType.TEXT) { + OutlinedTextField( + value = state.content, + onValueChange = viewModel::onContentChange, + modifier = Modifier + .weight(1f) + .fillMaxWidth() + .padding(horizontal = 16.dp) + .focusRequester(focusRequester), + placeholder = { Text("Write something…", style = editorFieldStyle()) }, + textStyle = editorFieldStyle(), + keyboardOptions = KeyboardOptions( + capitalization = KeyboardCapitalization.Sentences, + imeAction = ImeAction.Default, + ), + ) + } else { + // Sticky running total — always visible above the rows + // while shopping (per Development Plan §6.1), summing + // the costs of checked (= in-basket) items. + if (state.type == NoteType.SHOPPING_LIST) { + ShoppingTotalBar(totalCents = Note.shoppingTotalCents(state.items)) + } + ChecklistEditorBody( + modifier = Modifier.weight(1f), + header = state.listHeader, + items = state.items, + isShopping = state.type == NoteType.SHOPPING_LIST, + focusRequester = focusRequester, + onHeaderChange = viewModel::onHeaderChange, + onToggleItem = viewModel::setItemChecked, + onItemTextChange = viewModel::setItemText, + onItemQuantityChange = viewModel::setItemQuantity, + onItemCostChange = viewModel::setItemCost, + onRemoveItem = viewModel::removeListItem, + onAddItem = viewModel::addListItem, + ) + } // v0.3.1.0: attachment thumbnail strip. Combines persisted // attachments (loaded via observeAttachments in the VM) with @@ -457,6 +505,30 @@ fun NoteEditorScreen( else MaterialTheme.colorScheme.outlineVariant, ) } + // v0.3.8.0 — task-list toggle next to the # button. + // Converts the body into editable checklist rows (and + // back); the active mode tints with the primary colour. + IconButton(onClick = { viewModel.convertTo(NoteType.TASK_LIST) }) { + Icon( + Icons.Filled.Checklist, + contentDescription = "Task list", + tint = if (state.type == NoteType.TASK_LIST) + MaterialTheme.colorScheme.primary + else MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + // v0.3.8.0 — shopping-list toggle: like the task list + // but each row gains a number-pad Cost field and a + // sticky running total of checked items sits on top. + IconButton(onClick = { viewModel.convertTo(NoteType.SHOPPING_LIST) }) { + Icon( + Icons.Filled.ShoppingBasket, + contentDescription = "Shopping list", + tint = if (state.type == NoteType.SHOPPING_LIST) + MaterialTheme.colorScheme.primary + else MaterialTheme.colorScheme.onSurfaceVariant, + ) + } } } } @@ -863,6 +935,266 @@ private fun AddTagSheet( } } +// --------------------------------------------------------------------- +// v0.3.8.0: task / shopping list editor body +// --------------------------------------------------------------------- + +/** + * Sticky running total for shopping lists — pinned above the rows so + * it stays visible at all times (Development Plan §6.1: "renders a + * sticky running total … updated live as prices are added/edited + * while shopping"). Sums the costs of CHECKED (= in-basket) items. + */ +@Composable +private fun ShoppingTotalBar(totalCents: Long) { + Row( + modifier = Modifier + .fillMaxWidth() + .background(MaterialTheme.colorScheme.surfaceVariant) + .padding(horizontal = 16.dp, vertical = 6.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Icon( + Icons.Filled.ShoppingBasket, + contentDescription = null, + modifier = Modifier.size(18.dp), + tint = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(Modifier.size(8.dp)) + Text( + "Running total (qty × price, checked items)", + style = MaterialTheme.typography.labelLarge, + color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + Spacer(Modifier.weight(1f)) + Text( + text = Note.formatMoney(totalCents.toString()), + style = MaterialTheme.typography.titleMedium, + color = MaterialTheme.colorScheme.primary, + ) + } + HorizontalDivider() +} + +/** + * Structured body for task / shopping list notes: the title/preamble + * field, one [ChecklistItemRow] per item, and an "+ Add item" button. + * All mutations route through the view-model, which re-serialises the + * rows back into [NoteEditorUiState.content]. + */ +@Composable +private fun ChecklistEditorBody( + modifier: Modifier = Modifier, + header: String, + items: List, + isShopping: Boolean, + focusRequester: FocusRequester, + onHeaderChange: (String) -> Unit, + onToggleItem: (Int, Boolean) -> Unit, + onItemTextChange: (Int, String) -> Unit, + onItemQuantityChange: (Int, String) -> Unit, + onItemCostChange: (Int, String) -> Unit, + onRemoveItem: (Int) -> Unit, + onAddItem: () -> Unit, +) { + LazyColumn(modifier = modifier.fillMaxWidth()) { + item { + // Title / preamble. Kept as plain lines above the checkbox + // rows so the list cards' title+body split keeps working. + EditorLineField( + value = header, + onValueChange = onHeaderChange, + placeholder = "Title", + keyboardOptions = KeyboardOptions( + capitalization = KeyboardCapitalization.Sentences, + imeAction = ImeAction.Next, + ), + fieldModifier = Modifier.focusRequester(focusRequester), + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 16.dp, vertical = 4.dp), + ) + } + itemsIndexed(items) { index, item -> + ChecklistItemRow( + item = item, + isShopping = isShopping, + onToggle = { checked -> onToggleItem(index, checked) }, + onTextChange = { text -> onItemTextChange(index, text) }, + onQuantityChange = { qty -> onItemQuantityChange(index, qty) }, + onCostChange = { cost -> onItemCostChange(index, cost) }, + onRemove = { onRemoveItem(index) }, + ) + } + item { + TextButton(onClick = onAddItem) { + Icon( + Icons.Filled.Add, + contentDescription = null, + modifier = Modifier.size(18.dp), + ) + Spacer(Modifier.size(6.dp)) + Text("+ Add item") + } + } + } +} + +/** One row: `[ ]` · Product · Qty picker · per-item price · remove. */ +@Composable +private fun ChecklistItemRow( + item: ChecklistItem, + isShopping: Boolean, + onToggle: (Boolean) -> Unit, + onTextChange: (String) -> Unit, + onQuantityChange: (String) -> Unit, + onCostChange: (String) -> Unit, + onRemove: () -> Unit, +) { + Row( + modifier = Modifier + .fillMaxWidth() + .padding(horizontal = 8.dp), + verticalAlignment = Alignment.CenterVertically, + ) { + Checkbox(checked = item.checked, onCheckedChange = onToggle) + // The product field holds ANY text — numbers included. Quantity / + // price live in their own controls and an explicit `{q… p…}` + // storage marker, so a product called "Battery AA 3" can never + // bleed into the money fields. + EditorLineField( + value = item.text, + onValueChange = onTextChange, + placeholder = if (isShopping) "Product" else "Task", + keyboardOptions = KeyboardOptions( + capitalization = KeyboardCapitalization.Sentences, + imeAction = ImeAction.Next, + ), + 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 + // 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, + ), + formatUnfocused = { digits -> + if (digits.isEmpty()) "1" else digits + }, + modifier = Modifier.width(72.dp), + ) + Spacer(Modifier.size(6.dp)) + // Supermarket-style cents entry: while focused the line shows + // the RAW digits typed ("123"); on focus loss it switches to + // the parsed money form ("$1.23"). Storage always keeps the + // raw cent digits, so totals / serialisation are unaffected. + EditorLineField( + value = item.cost, + onValueChange = onCostChange, + placeholder = "Price", + keyboardOptions = KeyboardOptions( + keyboardType = KeyboardType.Number, + imeAction = ImeAction.Next, + ), + formatUnfocused = { digits -> + if (digits.isEmpty()) "" else "$" + Note.amountFromPriceDigits(digits) + }, + modifier = Modifier.width(110.dp), + ) + } + IconButton(onClick = onRemove) { + Icon( + Icons.Filled.Close, + contentDescription = "Remove item", + tint = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } +} + +/** + * v0.3.8.0 — the ~20 % smaller text style every editor surface uses + * (plain body, list header, task/product/quantity/price lines). The 16sp + * bodyLarge default made rows look squashed inside their fields. + */ +@Composable +private fun editorFieldStyle(): TextStyle = + MaterialTheme.typography.bodyMedium.copy(fontSize = 13.sp, lineHeight = 18.sp) + +/** + * v0.3.8.0 — one plain underlined editing line, shared by every editable + * field in the editor (title, task/product, quantity, price). Replaces + * the mismatched outlined boxes with a single visual rhythm: same + * minimum height, same 13sp text, and a 2 dp bottom rule that brightens + * while the field has focus. + * + * [formatUnfocused] swaps in a parsed display ("$1.23") while the field + * has no focus — editing always shows the raw stored value ("123"). + * [fieldModifier] targets the inner text field itself (focus requester). + */ +@Composable +private fun EditorLineField( + value: String, + onValueChange: (String) -> Unit, + placeholder: String = "", + keyboardOptions: KeyboardOptions = KeyboardOptions.Default, + formatUnfocused: ((String) -> String)? = null, + fieldModifier: Modifier = Modifier, + modifier: Modifier = Modifier, +) { + val fieldStyle = editorFieldStyle() + val hintColor = MaterialTheme.colorScheme.onSurfaceVariant + 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.3.1.0: helpers (camera URI + SAF display-name query) // --------------------------------------------------------------------- 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 496808d..cbb8905 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 @@ -7,20 +7,24 @@ import androidx.lifecycle.viewModelScope import androidx.lifecycle.viewmodel.initializer import androidx.lifecycle.viewmodel.viewModelFactory import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.ExperimentalCoroutinesApi import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.SharingStarted import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.flatMapLatest import kotlinx.coroutines.flow.stateIn import kotlinx.coroutines.flow.update import kotlinx.coroutines.launch import kotlinx.coroutines.withContext import org.incido.compose.IncidoApplication import org.incido.compose.share.LinkedShareComposer +import org.incido.domain.model.ChecklistItem import org.incido.domain.model.Hashtag 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 /** @@ -33,6 +37,16 @@ data class NoteEditorUiState( val color: NoteColor = NoteColor.NONE, /** Normalised, sorted ascending. */ val hashtags: List = emptyList(), + + /** v0.3.8.0 — which editor surface the body uses (see [NoteType]). */ + val type: NoteType = NoteType.TEXT, + + /** v0.3.8.0 — title / preamble kept above the rows in list modes. */ + val listHeader: String = "", + + /** v0.3.8.0 — parsed checklist rows; always empty for [NoteType.TEXT]. */ + val items: List = emptyList(), + /** True while the add-tag sheet is open. */ val isAddingTag: Boolean = false, /** Latest typing in the add-tag sheet (raw, before normalisation). */ @@ -90,10 +104,12 @@ data class NoteEditorUiState( initialFavorite: Boolean, initialColor: NoteColor, initialTags: List, + initialType: NoteType, ): Boolean = content != initialContent || isFavorite != initialFavorite || color != initialColor || - hashtags != initialTags + hashtags != initialTags || + type != initialType companion object { /** Hard cap on tags per note (matches Development Plan §6.1). */ @@ -129,6 +145,7 @@ data class PendingAttachment( val isImage: Boolean get() = mimeType.startsWith("image/") } +@OptIn(ExperimentalCoroutinesApi::class) class NoteEditorViewModel( private val repository: NoteRepository, private val noteId: Long?, @@ -178,6 +195,8 @@ class NoteEditorViewModel( private set var initialHashtags: List = emptyList() private set + var initialType: NoteType = NoteType.TEXT + private set /** Internal: re-emits suggestions whenever the tag input changes. */ private val tagInputFlow = MutableStateFlow("") @@ -193,18 +212,27 @@ class NoteEditorViewModel( init { // Tag autocomplete — re-query on every keystroke (debounced upstream // would be nice but ObjectBox is plenty fast for this size). + // Tag autocomplete. v0.3.8.0 FIX: the previous nested + // `tagInputFlow.collect { pool.collect { … } }` never resumed + // past the first keystroke — observeAllHashtags()/searchHashtags() + // are infinite callbackFlows, so the outer lambda suspended in + // the inner collect forever and typing never re-queried (the + // sheet only ever showed "+ Create"). flatMapLatest cancels the + // previous subscription per keystroke, and each fresh flow + // try-sends its snapshot immediately ⇒ live filtering. viewModelScope.launch { - tagInputFlow.collect { raw -> - val prefix = Hashtag.normalise(raw) - val pool = if (prefix.isEmpty()) { - repository.observeAllHashtags() - } else { - repository.searchHashtags(prefix) + tagInputFlow + .flatMapLatest { raw -> + val prefix = Hashtag.normalise(raw) + if (prefix.isEmpty()) { + repository.observeAllHashtags() + } else { + repository.searchHashtags(prefix) + } } - pool.collect { suggestions -> + .collect { suggestions -> _state.update { it.copy(tagSuggestions = suggestions) } } - } } // Live attachments: pump persisted rows into state.attachments. @@ -258,12 +286,25 @@ class NoteEditorViewModel( } else { viewModelScope.launch { repository.observeById(noteId).collect { note -> - if (note != null && _state.value.isLoading) { + val firstLoad = _state.value.isLoading + if (note != null && firstLoad) { initialContent = note.content initialFavorite = note.isFavorite initialColor = note.color initialHashtags = note.hashtags + initialType = note.type } + // Parse list rows once on first load; later DB + // emissions must not clobber in-progress edits. + val listSeed: Pair>? = + if (note != null && firstLoad && note.type != NoteType.TEXT) { + Note.splitListContent( + note.content, + interpretCosts = note.type == NoteType.SHOPPING_LIST, + ) + } else { + null + } _state.update { it.copy( existing = note, @@ -271,6 +312,9 @@ class NoteEditorViewModel( isFavorite = note?.isFavorite ?: it.isFavorite, color = note?.color ?: it.color, hashtags = note?.hashtags ?: it.hashtags, + type = note?.type ?: it.type, + listHeader = listSeed?.first ?: it.listHeader, + items = listSeed?.second ?: it.items, isLoading = false, ) } @@ -292,17 +336,18 @@ class NoteEditorViewModel( } fun openAddTagSheet() { - _state.update { - it.copy( - isAddingTag = true, - tagInput = "", - tagSuggestions = emptyList(), - ) - } + // v0.3.8.0 FIX: push the empty query through the suggestion + // pipeline FIRST so the flatMapLatest collector re-emits every + // existing tag (most-used first) while the sheet opens — the + // old code just cleared the list to emptyList() here and the + // stuck collector never refilled it. + tagInputFlow.value = "" + _state.update { it.copy(isAddingTag = true, tagInput = "") } } fun closeAddTagSheet() { - _state.update { it.copy(isAddingTag = false, tagInput = "", tagSuggestions = emptyList()) } + tagInputFlow.value = "" + _state.update { it.copy(isAddingTag = false, tagInput = "") } } fun onTagInputChange(raw: String) { @@ -330,6 +375,139 @@ class NoteEditorViewModel( _state.update { it.copy(hashtags = it.hashtags.filterNot { tag -> tag == normalised }) } } + // ---- v0.3.8.0 task / shopping list editing ---- + + /** + * Keep the [NoteEditorUiState.items] / [NoteEditorUiState.listHeader] + * rows and the derived [NoteEditorUiState.content] in step, so the + * save path, dirty-check, search preview, and `canSave` gate all + * keep working off the single content string. + */ + private fun NoteEditorUiState.withListEdits( + header: String = this.listHeader, + items: List, + ): NoteEditorUiState = copy( + listHeader = header, + items = items, + content = Note.serializeListContent(header, items, type), + ) + + private fun List.patched( + index: Int, + transform: (ChecklistItem) -> ChecklistItem, + ): List = mapIndexed { i, item -> + if (i == index) transform(item) else item + } + + /** + * Convert the body to [target]; tapping the already-active mode + * converts back to [NoteType.TEXT]. Text moves losslessly between + * the plain editor and the checkbox serialisation — costs are only + * stored while the note is a shopping list (converting to a task + * list folds each cost back into the item text). + */ + fun convertTo(target: NoteType) { + _state.update { s -> + val next = if (s.type == target) NoteType.TEXT else target + if (next == NoteType.TEXT) { + // Content already holds the serialised `- [ ]` rows; + // just drop out of the structured editor (the inline + // GFM checklist rendering from v0.2.0.0 still applies). + s.copy(type = NoteType.TEXT, listHeader = "", items = emptyList()) + } else { + val source = if (s.type == NoteType.TEXT) { + s.content + } else { + // Serialise through the FOLDED legacy form (plain + // "Milk 2 x 3.90" lines, never `{q…p…}` markers) so + // structured values survive the trip and re-parse + // cleanly under the target mode's rules. + Note.serializeListContent(s.listHeader, s.items, NoteType.TEXT) + } + val (header, parsedRaw) = Note.splitListContent( + source, + interpretCosts = next == NoteType.SHOPPING_LIST, + ) + val parsed = if (parsedRaw.isEmpty()) listOf(ChecklistItem("")) else parsedRaw + s.copy( + type = next, + listHeader = header, + items = parsed, + content = Note.serializeListContent(header, parsed, next), + ) + } + } + _state.update { + it.copy( + snackbar = when (it.type) { + NoteType.TASK_LIST -> "Task list mode — first line stays the title." + NoteType.SHOPPING_LIST -> "Shopping list mode — check an item once it's in your basket." + else -> "Back to plain text." + }, + ) + } + } + + fun onHeaderChange(value: String) { + _state.update { it.withListEdits(header = value, items = it.items) } + } + + fun addListItem() { + _state.update { s -> + if (s.type == NoteType.TEXT) return@update s + s.withListEdits(items = s.items + ChecklistItem("")) + } + } + + fun removeListItem(index: Int) { + _state.update { s -> + if (index !in s.items.indices) return@update s + s.withListEdits(items = s.items.filterIndexed { i, _ -> i != index }) + } + } + + fun setItemChecked(index: Int, checked: Boolean) { + _state.update { s -> + if (index !in s.items.indices) return@update s + s.withListEdits(items = s.items.patched(index) { it.copy(checked = checked) }) + } + } + + fun setItemText(index: Int, text: String) { + _state.update { s -> + if (index !in s.items.indices) return@update s + s.withListEdits(items = s.items.patched(index) { it.copy(text = text) }) + } + } + + /** + * Price field input — POS style: everything is reduced to cents + * digits ("199" ⇒ $1.99, separators typed or pasted are stripped). + */ + fun setItemCost(index: Int, rawCost: String) { + val sanitized = Note.normalisePriceInput(rawCost) + _state.update { s -> + if (index !in s.items.indices) return@update s + s.withListEdits(items = s.items.patched(index) { it.copy(cost = sanitized) }) + } + } + + /** + * Quantity line input (free-text digits); blank means the default 1. + * + * v0.3.8.0: "1" now stays stored as "1" — the field is free text, so + * the typed digit must remain visible. The serialiser already omits + * `{q1}` and cards only show "×qty" when the quantity is > 1, so this + * is storage-neutral. "0" / blank normalise to "" (meaning 1). + */ + fun setItemQuantity(index: Int, rawQty: String) { + val stored = Note.normaliseQuantity(rawQty) + _state.update { s -> + if (index !in s.items.indices) return@update s + s.withListEdits(items = s.items.patched(index) { it.copy(quantity = stored) }) + } + } + fun consumeSnackbar() { _state.update { it.copy(snackbar = null) } } @@ -419,12 +597,14 @@ class NoteEditorViewModel( content = current.content, isFavorite = current.isFavorite, color = current.color, + type = current.type, ) ?: Note( content = current.content, createdAt = System.currentTimeMillis(), updatedAt = System.currentTimeMillis(), isFavorite = current.isFavorite, color = current.color, + type = current.type, ) val previous = baseNote?.hashtags.orEmpty().toSet() val currentSet = current.hashtags.toSet() 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 396236c..89ebc93 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 @@ -35,6 +35,7 @@ import androidx.compose.material.icons.filled.MoreVert import androidx.compose.material.icons.filled.PhotoCamera import androidx.compose.material.icons.filled.Restore 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.Card @@ -76,6 +77,7 @@ import org.incido.domain.model.Note import org.incido.domain.model.NoteAttachment import org.incido.domain.model.NoteColor import org.incido.domain.model.NoteFilter +import org.incido.domain.model.NoteType import org.incido.domain.repository.NoteRepository /** @@ -388,7 +390,11 @@ private fun NoteCard( */ showEncryptionBadge: Boolean = false, ) { - val (title, body) = Note.titleAndBody(note.content) + // v0.3.8.0: task / shopping lists render marker-free on cards — + // header line becomes the title, items show as clean "Name ×qty @$X" + // 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) val bodyPreview = Note.bodyPreview(body) val checklistSummary = Note.checklistSummary(note.content) val noteColor = note.color @@ -524,7 +530,11 @@ private fun NoteCard( Spacer(modifier = Modifier.padding(top = 4.dp)) Row(verticalAlignment = Alignment.CenterVertically) { Icon( - Icons.Default.CheckBox, + // v0.3.8.0: shopping lists carry a basket + // on the card instead of the plain check box. + imageVector = if (note.type == NoteType.SHOPPING_LIST) + Icons.Default.ShoppingBasket + else Icons.Default.CheckBox, contentDescription = null, modifier = Modifier.size(14.dp), tint = secondaryColor, 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 cd9adb9..e50e374 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 @@ -333,7 +333,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.3.7.1" + const val APP_VERSION = "0.3.8.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 bcebd25..dbe2dad 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 @@ -5,6 +5,7 @@ import io.objectbox.annotation.Id import io.objectbox.annotation.Index import org.incido.domain.model.Note import org.incido.domain.model.NoteColor +import org.incido.domain.model.NoteType /** * ObjectBox entity. The plugin generates a corresponding property mirror @@ -20,6 +21,11 @@ import org.incido.domain.model.NoteColor * existing stores auto-migrate. The repository transparently * encrypts/decrypts on write/read when a [org.incido.data.crypto.FieldCipher] * is supplied. + * + * v0.3.8.0 — [typeKey] records the note editor mode + * ([org.incido.domain.model.NoteType]: 0 text, 1 task list, 2 shopping + * list). Additive column — existing stores auto-migrate and old rows + * default to plain text. */ @Entity data class NoteEntity( @@ -35,6 +41,8 @@ data class NoteEntity( var contentBlob: ByteArray = ByteArray(0), /** True only for notes moved to the Trash view; active-note queries exclude these rows. */ @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, ) { override fun equals(other: Any?): Boolean { if (this === other) return true @@ -48,6 +56,7 @@ data class NoteEntity( if (isTrashed != other.isTrashed) return false if (cipherVersion != other.cipherVersion) return false if (!contentBlob.contentEquals(other.contentBlob)) return false + if (typeKey != other.typeKey) return false return true } @@ -61,6 +70,7 @@ data class NoteEntity( result = 31 * result + isTrashed.hashCode() result = 31 * result + cipherVersion.hashCode() result = 31 * result + contentBlob.contentHashCode() + result = 31 * result + typeKey.hashCode() return result } } @@ -73,6 +83,7 @@ internal fun NoteEntity.toDomain(): Note = Note( isFavorite = isFavorite, color = NoteColor.fromStorageKey(colorKey), isTrashed = isTrashed, + type = NoteType.fromStorageKey(typeKey), ) internal fun Note.toEntity(): NoteEntity = NoteEntity( @@ -83,4 +94,5 @@ internal fun Note.toEntity(): NoteEntity = NoteEntity( isFavorite = isFavorite, colorKey = color.storageKey, isTrashed = isTrashed, + typeKey = type.storageKey, ) 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 f7a5a60..d211aec 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.NoteType import org.incido.domain.repository.NoteRepository /** @@ -611,7 +612,7 @@ class NoteRepositoryImpl( compareByDescending { it.isFavorite } .thenByDescending { it.updatedAt }, ).map { e -> - val base = toReadable(e).toDomain() + val base = toReadable(e).toDomain().withHealedListType() base.copy( hashtags = tags[e.id].orEmpty(), attachments = attachments[e.id].orEmpty(), @@ -619,6 +620,20 @@ class NoteRepositoryImpl( } } + /** + * v0.3.8.0 FIX — notes whose bodies ARE checklist lines but which + * persisted with `typeKey = 0` (written by a build predating the + * column, or by a partial save of the list feature) would render as + * raw `- [ ] …` markdown on cards and open in the plain editor. + * Infer the list type from the content itself at READ time; the next + * save from the editor then persists the healed `typeKey` for good. + * TEXT notes containing only occasional hand-typed `- [ ]` lines in + * prose are left untouched (see [Note.inferListType]). + */ + private fun Note.withHealedListType(): Note = + if (type != NoteType.TEXT) this + else Note.inferListType(content)?.let { copy(type = it) } ?: this + private fun snapshotAll(): List = decorate(noteBox.all) private fun snapshotAllIncludingTrashed(): List = decorate(noteBox.all, includeTrashed = null) @@ -728,7 +743,7 @@ class NoteRepositoryImpl( val entity = noteBox.get(id) ?: return null val tags = hashtagsByNoteId()[id].orEmpty() val attachments = attachmentsByNoteId()[id].orEmpty() - return toReadable(entity).toDomain().copy( + return toReadable(entity).toDomain().withHealedListType().copy( hashtags = tags, attachments = attachments, ) diff --git a/core/domain/src/main/kotlin/org/incido/domain/model/ChecklistItem.kt b/core/domain/src/main/kotlin/org/incido/domain/model/ChecklistItem.kt new file mode 100644 index 0000000..9e2e6ad --- /dev/null +++ b/core/domain/src/main/kotlin/org/incido/domain/model/ChecklistItem.kt @@ -0,0 +1,27 @@ +package org.incido.domain.model + +/** + * v0.3.8.0 — one row of a [NoteType.TASK_LIST] / [NoteType.SHOPPING_LIST] + * note while it is being edited. Rows live in the editor's UI state and + * are serialised back into `- [ ]` / `- [x]` content lines on every edit + * (see [Note.serializeListContent] / [Note.splitListContent]). + */ +data class ChecklistItem( + /** Item label; blank rows are skipped when serialising. */ + val text: String, + /** Checkbox state — for shopping lists: "in the basket". */ + val checked: Boolean = false, + /** + * Quantity as typed/picked (`""` = 1). Only meaningful for + * [NoteType.SHOPPING_LIST]; shopping rows offer a 1–9 picker so + * this stays tiny, but the parser accepts any small positive int. + */ + val quantity: String = "", + /** + * Price as entered, in CENTS DIGITS (`""` = none, `"199"` = $1.99 — + * supermarket-terminal style where the last two digits are cents). + * Only meaningful for [NoteType.SHOPPING_LIST]. Money maths runs + * on these integers so there is never binary-float drift. + */ + val cost: String = "", +) 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 0db00cf..e17686e 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,8 @@ 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, + /** v0.3.8.0 — which editor surface opens this note (see [NoteType]). */ + val type: NoteType = NoteType.TEXT, ) { /** Convenience: the first image attachment, or `null` if none. */ val firstImageAttachment: NoteAttachment? @@ -107,5 +109,326 @@ data class Note( else -> "$open open · $done done" } } + + // ----------------------------------------------------------------- + // v0.3.8.0 — task / shopping list parsing + serialisation. + // + // A list note's content is an optional header block (the title / + // preamble kept as plain lines) followed by GitHub-style checkbox + // lines. Shopping-list rows carry quantity + per-item price in an + // explicit end-of-line marker so the PRODUCT TEXT IS NEVER + // SCANNED FOR NUMBERS (a product called "Battery AA 3" or + // "Poster 50 x 60" is safe): + // + // - [ ] Milk no qty / price yet + // - [ ] Ham {p12.99} price only (qty 1) + // - [ ] Eggs {q12 p2.40} 12 × $2.40 + // + // Hand-typed / legacy lines stay importable (Development Plan + // §6.1's trailing-numeric-token idea): `Milk 3.50` reads as a + // price, `Eggs 12 x 2.40` as qty × price. Those forms survive in + // task lists, where each row is just `- [ ] `. + // ----------------------------------------------------------------- + + private val CHECKLIST_LINE: Regex = Regex("""^\s*-\s+\[([ xX])]\s*(.*)$""") + + /** `Product {q12 p2.40}` / `{p2.40}` / `{q12}` (anchored, greedy-safe). */ + private val BRACED_QP: Regex = + Regex("""^(.*?)\s*\{\s*(?:q(\d{1,3}))?\s*(?:p([\d.,]{1,12}))?\s*\}$""") + + /** Legacy: `Product 12 x 2.40` (also `12x2.40`, `×`). A decimal on + * the price keeps lookalikes like "Poster 50 x 60" as plain text. */ + private val LEGACY_QTY_PRICE: Regex = + Regex("""^(.+?)\s+(\d{1,3})\s*[xX×]\s*(\d{1,9}[.,]\d{1,2})$""") + + /** Legacy (§6.1): `Product 3.50`. Decimal point REQUIRED, so a + * product named "Battery AA 3" is never mistaken for a price. */ + private val TRAILING_COST: Regex = Regex("""^(.*\S)\s+(\d{1,9}[.,]\d{1,2})$""") + + private val COST_PATTERN: Regex = Regex("""\d{1,9}(?:\.\d{1,2})?""") + + /** + * Canonicalise a raw monetary amount token: trims, accepts `,` as + * decimal separator, tolerates a trailing `.` mid-typing, and + * returns `""` for anything that isn't a plain positive number + * with at most two decimals. + */ + fun normaliseCost(raw: String): String { + val trimmed = raw.trim().replace(',', '.') + if (trimmed.isEmpty()) return "" + val candidate = if (trimmed.endsWith(".")) trimmed.dropLast(1) else trimmed + return if (candidate.matches(COST_PATTERN)) candidate else "" + } + + /** + * Convert a canonical amount ("2.40", "5", "0.05") into CENTS + * DIGITS ("240", "500", "5"). Returns `""` for invalid input. + */ + fun priceDigitsFromAmount(amount: String): String { + val canonical = normaliseCost(amount) + if (canonical.isEmpty()) return "" + val parts = canonical.split('.') + val units = parts[0].toLongOrNull() ?: return "" + val cents = if (parts.size > 1) parts[1].padEnd(2, '0').toLongOrNull() ?: return "" else 0L + val total = units * 100 + cents + if (total <= 0L) return "" + return total.toString() + } + + /** Inverse: cents digits ("199") → canonical amount ("1.99"); "" → "". */ + fun amountFromPriceDigits(digits: String): String { + val clean = digits.filter { it.isDigit() }.trimStart('0') + if (clean.isEmpty()) return "" + return clean.padStart(3, '0').let { "${it.dropLast(2)}.${it.takeLast(2)}" } + } + + /** Digit-only normalisation of the quantity picker/keypad input. */ + fun normaliseQuantity(raw: String): String = + raw.filter { it.isDigit() }.take(3).trimStart('0') + + /** Digit-only normalisation of the price input ("2.4" → "24"). */ + fun normalisePriceInput(raw: String): String = + raw.filter { it.isDigit() }.take(9).trimStart('0') + + /** Numeric quantity of a row (blank ⇒ 1). */ + fun quantityOf(item: ChecklistItem): Int = + item.quantity.toIntOrNull()?.coerceIn(1, 999) ?: 1 + + /** Per-line total in cents: quantity × unit price. */ + fun lineTotalCents(item: ChecklistItem): Long = + quantityOf(item) * (item.cost.toLongOrNull() ?: 0L) + + /** + * Split [content] into (header, items) for the structured list + * editors. + * + * When marker lines (`- [ ] …`) exist, the header is everything + * before the first one and every marker line becomes an item; + * other non-blank lines below the first marker become unchecked + * items so nothing is silently dropped. Without any marker line + * (a plain note being converted), the first non-blank line is + * kept as the title/header and the remaining non-blank lines + * become unchecked items. + * + * [interpretCosts] (shopping lists only) strips a trailing + * numeric token off each item text into [ChecklistItem.cost]. + */ + fun splitListContent( + content: String, + interpretCosts: Boolean, + ): Pair> { + val lines = content.split('\n') + val firstMarker = lines.indexOfFirst { CHECKLIST_LINE.matches(it) } + val headerLines: List + val itemLines: List + if (firstMarker >= 0) { + headerLines = lines.take(firstMarker) + itemLines = lines.drop(firstMarker) + } else { + val titleIdx = lines.indexOfFirst { it.isNotBlank() } + headerLines = if (titleIdx >= 0) listOf(lines[titleIdx]) else emptyList() + itemLines = if (titleIdx >= 0) lines.drop(titleIdx + 1) else lines + } + val items = itemLines + .filter { it.isNotBlank() } + .map { line -> + val match = CHECKLIST_LINE.matchEntire(line) + var text: String + val checked: Boolean + if (match != null) { + checked = match.groupValues[1].equals("x", ignoreCase = true) + text = match.groupValues[2].trim() + } else { + checked = false + text = line.trim() + } + var quantity = "" + var cost = "" // cents digits + if (interpretCosts) { + val braced = BRACED_QP.matchEntire(text) + val legacyQtyPrice = if (braced == null) LEGACY_QTY_PRICE.matchEntire(text) else null + val legacyPrice = if (braced == null && legacyQtyPrice == null) + TRAILING_COST.matchEntire(text) else null + when { + braced != null -> { + // Structured form: everything before the + // marker is PRODUCT TEXT, unexamined. + val q = parsedQuantity(braced.groupValues[2]) + val p = parsedPrice(braced.groupValues[3]) + if (q.isEmpty() && p.isEmpty()) { + // "{}" or invalid slots — not a marker after all. + } else { + text = braced.groupValues[1].trim() + quantity = q + cost = p + } + } + legacyQtyPrice != null -> { + text = legacyQtyPrice.groupValues[1].trim() + quantity = parsedQuantity(legacyQtyPrice.groupValues[2]) + cost = parsedPrice(legacyQtyPrice.groupValues[3]) + } + legacyPrice != null -> { + text = legacyPrice.groupValues[1].trim() + cost = parsedPrice(legacyPrice.groupValues[2]) + } + } + } + ChecklistItem(text = text, checked = checked, quantity = quantity, cost = cost) + } + return headerLines.joinToString("\n").trim() to items + } + + /** Normalise a parsed quantity token (blank / 1 ⇒ default ""). */ + private fun parsedQuantity(raw: String): String { + val n = normaliseQuantity(raw) + return if (n == "1" || n.isEmpty()) "" else n + } + + /** Normalise a parsed amount token into cents digits. */ + private fun parsedPrice(raw: String): String = priceDigitsFromAmount(raw) + + /** + * Inverse of [splitListContent]: rebuild the note content from a + * header + item rows. Blank rows are skipped. Shopping rows + * serialise quantity + price into the `{q… p…}` marker (qty 1 is + * omitted); converting BACK to a task list folds the values into + * legacy text tokens (`Milk 2 x 3.90`) so they survive a + * round-trip through plain-text mode. + */ + fun serializeListContent( + header: String, + items: List, + type: NoteType, + ): String { + val isShopping = type == NoteType.SHOPPING_LIST + val bodyLines = items.mapNotNull { item -> + val amount = amountFromPriceDigits(item.cost) + // v0.3.8.0 FIX: parsedQuantity folds the default (1) to + // "" — a plain String, never null. Without takeIf, the + // shopping branch emitted a bare "q" slot (broken + // "{q p1.23}" markers) and the task branch folded a + // stray " x" onto every row. Null means "no quantity". + val qtyDigits = parsedQuantity(item.quantity).takeIf { it.isNotEmpty() } + val rawText = item.text.trim() + val rowText: String + if (isShopping) { + val slots = listOfNotNull( + qtyDigits?.let { "q$it" }, + amount.ifEmpty { null }?.let { "p$it" }, + ) + rowText = if (slots.isEmpty()) rawText + else "$rawText {${slots.joinToString(" ")}}" + } else { + // Task list: fold structured values back into text so + // switching modes never silently drops them. + rowText = when { + rawText.isEmpty() && qtyDigits != null && amount.isNotEmpty() -> + "$qtyDigits x $amount" + rawText.isEmpty() && amount.isNotEmpty() -> amount + qtyDigits != null && amount.isNotEmpty() -> "$rawText $qtyDigits x $amount" + qtyDigits != null -> "$rawText $qtyDigits x" + amount.isNotEmpty() -> "$rawText $amount" + else -> rawText + } + } + when { + rowText.isBlank() -> null + else -> "- [" + (if (item.checked) "x" else " ") + "] " + rowText + } + } + val headerTrimmed = header.trimEnd() + return when { + bodyLines.isEmpty() -> headerTrimmed + headerTrimmed.isEmpty() -> bodyLines.joinToString("\n") + else -> headerTrimmed + "\n" + bodyLines.joinToString("\n") + } + } + + /** Running shopping total in cents: quantity × price, CHECKED rows only. */ + fun shoppingTotalCents(items: List): Long = + items.filter { it.checked }.sumOf { lineTotalCents(it) } + + /** Running shopping total as dollars (display helper). */ + fun shoppingTotal(items: List): Double = + shoppingTotalCents(items) / 100.0 + + /** "$0.00"-style display string for entered cents digits. */ + fun formatMoney(centsDigits: String): String { + val clean = centsDigits.filter { it.isDigit() }.trimStart('0') + return "$" + if (clean.isEmpty()) "0.00" else amountFromPriceDigits(clean) + } + + /** + * Card-friendly rendering for structured note types: (title, body) + * WITHOUT any markdown syntax. Title is the list header's first + * non-blank line (or "Untitled"); body is the item names joined + * with " · ", shopping rows carrying " ×qty" (when ≠ 1) and + * " @$price" suffixes. Plain-text notes keep using + * [titleAndBody] untouched. + */ + fun cardPresentation(content: String, type: NoteType): Pair { + val isShopping = type == NoteType.SHOPPING_LIST + val (header, items) = splitListContent( + content, + interpretCosts = isShopping, + ) + val title = header.lineSequence() + .firstOrNull { it.isNotBlank() }?.trim() ?: UNTITLED + val parts = items.mapNotNull { item -> + val text = item.text.trim() + if (text.isEmpty()) return@mapNotNull null + val qty = quantityOf(item) + val amount = if (isShopping) amountFromPriceDigits(item.cost) else "" + buildString { + append(text) + if (isShopping && qty > 1) append(" \u00d7$qty") + if (isShopping && amount.isNotEmpty()) { + append(" @") + append(amount) + } + } + } + return title to parts.joinToString(" \u00b7 ") + } + + /** + * v0.3.8.0 FIX — heal notes stranded as [NoteType.TEXT] by builds + * that saved list content before the `typeKey` column existed (or + * by a partial write of the new feature). Returns the list type + * implied by [content], or null when the body is NOT unambiguously + * a checklist: + * + * * The first non-blank line is a header ONLY if it is not itself + * a checkbox line (headerless lists start straight at `- [ ]`). + * * EVERY remaining non-blank line must match [CHECKLIST_LINE] + * and at least one must exist — prose + an occasional hand-typed + * `- [ ]` stays plain TEXT. + * * Any line carrying a `{q…/p…}` marker implies SHOPPING_LIST. + */ + fun inferListType(content: String): NoteType? { + val lines = content.lines() + val firstNonBlank = lines.indexOfFirst { it.isNotBlank() } + if (firstNonBlank < 0) return null + val startIdx = if (CHECKLIST_LINE.matches(lines[firstNonBlank])) { + firstNonBlank // headerless list + } else { + firstNonBlank + 1 // first line is the header + } + var sawMarker = false + var sawBrace = false + for (i in startIdx until lines.size) { + val line = lines[i] + if (line.isBlank()) continue + val match = CHECKLIST_LINE.matchEntire(line) ?: return null + sawMarker = true + if (BRACED_QP.containsMatchIn(match.groupValues[2])) sawBrace = true + } + return when { + !sawMarker -> null + sawBrace -> NoteType.SHOPPING_LIST + else -> NoteType.TASK_LIST + } + } } } 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 new file mode 100644 index 0000000..c932035 --- /dev/null +++ b/core/domain/src/main/kotlin/org/incido/domain/model/NoteType.kt @@ -0,0 +1,31 @@ +package org.incido.domain.model + +/** + * v0.3.8.0 — which editor surface a note body uses. + * + * The note text itself stays the single source of truth: task and + * shopping lists are persisted as GitHub-flavoured checkbox lines + * (`- [ ] item` / `- [x] item`, with an optional trailing numeric + * cost token on shopping lists), so free-text search, at-rest + * encryption, backups, and the inline `- [ ]` markdown already + * supported in [Note.checklistCounts] keep working untouched. + * + * 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) { + /** Free-form body edited in the plain multi-line field. */ + TEXT(0), + + /** Editable checklist: checkbox + item text rows. */ + TASK_LIST(1), + + /** Checklist plus a per-item cost (number pad) and a running total. */ + SHOPPING_LIST(2); + + companion object { + /** Convert from the stored [Short] back to the enum, defaulting to [TEXT]. */ + fun fromStorageKey(key: Short): NoteType = + values().firstOrNull { it.storageKey == key } ?: TEXT + } +}