void }) {
const [i, setI] = useState(0)
const ref = useRef(null)
const last = i === CARDS.length - 1
+ // Keep a stable ref so the focus-trap effect doesn't re-run on every App render.
+ const onCloseRef = useRef(onClose)
+ onCloseRef.current = onClose
// Focus-trap the modal: focus lands inside on mount, Tab cycles within, Escape
// closes. Focus returns to whatever was focused before on unmount.
@@ -26,7 +29,7 @@ export function IntroGuide({ onClose }: { onClose: () => void }) {
node?.focus()
const onKey = (e: KeyboardEvent) => {
if (e.key === 'Escape') {
- onClose()
+ onCloseRef.current()
return
}
if (e.key !== 'Tab') return
@@ -47,7 +50,7 @@ export function IntroGuide({ onClose }: { onClose: () => void }) {
window.removeEventListener('keydown', onKey)
prev?.focus?.()
}
- }, [onClose])
+ }, []) // onClose via ref — no re-run on App re-render
const key = CARDS[i]
const linkCls = 'underline decoration-hairline underline-offset-2 hover:text-ink'
diff --git a/src/MapView.tsx b/src/MapView.tsx
index 60d4a10..a6da3fa 100644
--- a/src/MapView.tsx
+++ b/src/MapView.tsx
@@ -16,8 +16,8 @@ import { gridCluster } from './domain/cluster'
import { NO_FILTERS, type Filters } from './domain/filters'
import { selectUpcoming, type DayChoice, type Upcoming } from './domain/ranking'
import { dayLabel, fmtTime, fmtWeekdayShort, samePragueDay } from './domain/format'
-import { massKey, type Aggregate } from './domain/feedback'
-import { aggregateFor, churchHasTags, divergentChips, loadAggregates, rankChurchTags } from './lib/feedbackStore'
+import { massKey } from './domain/feedback'
+import { aggregateFor, churchHasTags, divergentChips, hasAggregate, loadAggregates, rankChurchTags } from './lib/feedbackStore'
import { witnessPillsHtml } from './WitnessPills'
import { WITNESS_ENABLED } from './lib/flags'
import { t, churchCount, confirmedByPilgrims } from './i18n'
@@ -27,16 +27,6 @@ const CELL_PX = 64 // cluster grid; ~a finger-width of map
/** "8:30", not "08:30" — chips are read at a glance, the zero is noise. */
const chipTime = (d: Date) => fmtTime(d).replace(/^0/, '')
-/** Both directness tiers for the Mass a marker/popover shows: the specific slot
- * aggregate and the church-wide one (from the in-memory cache; empty until
- * loadAggregates fills it). */
-const witnessTiers = (church: Church, u: Upcoming): { slot?: Aggregate; church: Aggregate } => {
- const { slots, church: churchAgg } = aggregateFor(church.id)
- return { slot: slots.get(massKey(church.id, u.service, u.start)), church: churchAgg }
-}
-const hasWitness = (t: { slot?: Aggregate; church: Aggregate }): boolean =>
- (t.slot?.chips.length ?? 0) > 0 || t.church.chips.length > 0
-
/** A bare time on a pin reads as TODAY — on "hned" a church's next mass can be
* days out, so a not-today chip carries its weekday ("út 15:00") and greys. */
const chipIcon = (label: string, otherDay: boolean, witnessed: boolean) =>
@@ -73,6 +63,7 @@ export default function MapView({
onOpen,
onNavigate,
fill = false,
+ reloadKey = 0,
}: {
origin: { lat: number; lng: number }
churches: Church[] // the whole index — matching is the selector's job
@@ -83,6 +74,8 @@ export default function MapView({
onNavigate: (t: { name: string; lat: number; lng: number }) => void
/** Map mode: fill the parent column instead of the in-flow plate height. */
fill?: boolean
+ /** Bumped after an OTA refresh — clears stale shards so new church data is shown. */
+ reloadKey?: number
}) {
const divRef = useRef(null)
// The dog-ear fold cue on a chip reads as "something's here" but its meaning
@@ -103,13 +96,21 @@ export default function MapView({
onNavigateRef.current = onNavigate
const shardCache = useRef(new Map>>())
+ // Clear stale shards when new church data arrives (OTA refresh bumps reloadKey).
+ useEffect(() => { shardCache.current.clear() }, [reloadKey])
+
const loadShard = (cell: string) => {
let p = shardCache.current.get(cell)
if (!p) {
// via dataStore, not raw fetch — the map must see an OTA-refreshed registry too
p = loadData[0]>(`services/${cell}.json`)
- .catch(() => ({}))
.then(decodeShard)
+ .catch(() => {
+ // Don't cache failures — let the next pan retry rather than serving
+ // a permanently empty map for this cell.
+ shardCache.current.delete(cell)
+ return new Map()
+ })
shardCache.current.set(cell, p)
}
return p
@@ -285,24 +286,36 @@ export default function MapView({
// shards, so the popover line and the marker cue have data on first paint.
const [shards] = await Promise.all([
Promise.all(cells.map(loadShard)),
- WITNESS_ENABLED ? loadAggregates(visible.map((c) => c.id)) : Promise.resolve(),
+ // ponytail: cap at 500 to avoid HTTP 414 at country zoom
+ WITNESS_ENABLED ? loadAggregates(visible.slice(0, 500).map((c) => c.id)) : Promise.resolve(),
])
if (stale || seq !== renderSeq) return // a newer render superseded this one
const byId = new Map()
for (const shard of shards) for (const [id, s] of shard) byId.set(id, s)
const now = new Date()
// the SAME selector as the seznam — a chip on the map is a row in the list
+ // Skip when very many churches are visible: at country zoom everything clusters
+ // anyway. Cap raised to 500 so city-scale viewports (200–400 churches) still
+ // get chips and are not all faded. ponytail: upgrade to per-cluster matching
+ // if selectUpcoming becomes the bottleneck at this scale.
const matched = new Map()
- for (const u of selectUpcoming(now, origin, visible, byId, filters, cas, day, { limit: Infinity })) {
- if (!matched.has(u.church.id)) matched.set(u.church.id, u) // ordo: keep the day's earliest
+ if (visible.length <= 500) {
+ for (const u of selectUpcoming(now, origin, visible, byId, filters, cas, day, { limit: Infinity })) {
+ if (!matched.has(u.church.id)) matched.set(u.church.id, u) // ordo: keep the day's earliest
+ }
}
// Witness filter (Ohlasy poutníků): when tags are selected, the map shows
// only churches carrying ALL of them at slot- or church-tier. Aggregates
// are loaded for the visible set above, so we cluster over that filtered
// subset (the pan-invariant whole-index clustering resumes when off).
+ // M8: cluster ONLY over churches whose aggregates have been loaded so
+ // cluster membership is pan-invariant. Unloaded churches are rendered
+ // separately at reduced opacity so the user sees "not yet assessed" rather
+ // than "no witnesses" — the distinction is honest and survives panning.
const wt = WITNESS_ENABLED ? (filters.witnessTags ?? []) : []
+ const unknownChurches = wt.length ? churches.filter((c) => !hasAggregate(c.id)) : []
const clusterChurches = wt.length
- ? visible.filter((c) => churchHasTags(c.id, null, wt))
+ ? churches.filter((c) => hasAggregate(c.id) && churchHasTags(c.id, null, wt))
: churches
// Cluster over ALL churches, not just the viewport subset. Bucket
// membership must not depend on the pan: a grid cell straddling the
@@ -339,7 +352,8 @@ export default function MapView({
? `${fmtWeekdayShort(next.start)} ${chipTime(next.start)}`
: chipTime(next.start)
: ''
- const witnessed = WITNESS_ENABLED && Boolean(next) && hasWitness(witnessTiers(church, next!))
+ // the church tier folds every slot, so any witnessed slot shows here too
+ const witnessed = WITNESS_ENABLED && Boolean(next) && aggregateFor(church.id).church.chips.length > 0
if (witnessed) anyWitness = true
const marker = L.marker([church.lat, church.lng], {
icon: next ? chipIcon(label, otherDay, witnessed) : fadedIcon(),
@@ -359,18 +373,38 @@ export default function MapView({
title: churchCount(cl.items.length),
keyboard: false,
})
- .on('click', () => map.setView(latlng, Math.min(zoom + 2, 17)))
+ .on('click', () => map.setView(latlng, Math.max(Math.min(zoom + 2, 18), zoom)))
.addTo(layer)
}
}
+ // M8: render not-yet-loaded churches at half opacity so they read as
+ // "unknown / not yet assessed" rather than "confirmed: no witnesses".
+ for (const c of unknownChurches) {
+ if (!bounds.contains([c.lat, c.lng])) continue
+ L.marker([c.lat, c.lng], {
+ icon: fadedIcon(),
+ title: c.name,
+ keyboard: false,
+ opacity: 0.4,
+ })
+ .on('click', () => void openPopover(c))
+ .addTo(layer)
+ }
setWitnessShown(anyWitness) // React bails out if unchanged — deps exclude it, so no re-subscribe
}
- map.on('moveend', render) // zoom changes end in moveend too
+ // Debounce moveend so rapid panning doesn't fire a Supabase query every event.
+ let debounceTimer: ReturnType | null = null
+ const onMoveEnd = () => {
+ if (debounceTimer) clearTimeout(debounceTimer)
+ debounceTimer = setTimeout(() => void render(), 150)
+ }
+ map.on('moveend', onMoveEnd) // zoom changes end in moveend too
void render()
return () => {
stale = true
- map.off('moveend', render)
+ if (debounceTimer) clearTimeout(debounceTimer)
+ map.off('moveend', onMoveEnd)
}
// onOpen/onNavigate deliberately excluded — read via refs so an unstable
// callback identity can't re-run this effect off the moveend cycle.
diff --git a/src/WitnessPills.tsx b/src/WitnessPills.tsx
index 71318ff..3cd415f 100644
--- a/src/WitnessPills.tsx
+++ b/src/WitnessPills.tsx
@@ -8,7 +8,7 @@ import { WitnessIcon, witnessIconMarkup } from './domain/witnessIcons'
/** The one flag check: the TestFlight prototype build (VITE_WITNESS_PREVIEW=1)
* shows a per-tag count on each pill; production stays qualitative (no numbers,
* strongest tag rendered slightly stronger). */
-export const witnessShowCounts = (): boolean => import.meta.env.VITE_WITNESS_PREVIEW === '1'
+const witnessShowCounts = (): boolean => import.meta.env.VITE_WITNESS_PREVIEW === '1'
/** Label with the prototype-only per-tag count appended ("krásný zpěv · 3"). */
const pillLabel = (c: { id: string; count: number }, counts: boolean): string =>
diff --git a/src/domain/cities.test.ts b/src/domain/cities.test.ts
index 9e56e3e..7ee02ed 100644
--- a/src/domain/cities.test.ts
+++ b/src/domain/cities.test.ts
@@ -1,4 +1,4 @@
-import { aggregateCities, findCity, fold, normalizeCity, searchPlaces, slugify } from './cities'
+import { aggregateCities, findCity, searchPlaces } from './cities'
import type { Church } from './data'
const church = (id: string, city: string, lat = 50, lng = 14): Church => ({
@@ -11,29 +11,6 @@ const church = (id: string, city: string, lat = 50, lng = 14): Church => ({
cell: '50-14',
})
-describe('normalizeCity', () => {
- it('Praha districts collapse to Praha', () => {
- expect(normalizeCity('Praha 1')).toBe('Praha')
- expect(normalizeCity('Praha 22')).toBe('Praha')
- })
- it('"quarter, municipality" keeps the municipality', () => {
- expect(normalizeCity('Brno-město, Brno')).toBe('Brno')
- expect(normalizeCity('Kukleny, Hradec Králové')).toBe('Hradec Králové')
- expect(normalizeCity('České Budějovice 3, České Budějovice')).toBe('České Budějovice')
- })
- it('plain names pass through', () => {
- expect(normalizeCity('Frýdek-Místek')).toBe('Frýdek-Místek')
- })
-})
-
-describe('slugify', () => {
- it('strips diacritics and spaces', () => {
- expect(slugify('Ústí nad Labem')).toBe('usti-nad-labem')
- expect(slugify('Žďár nad Sázavou')).toBe('zdar-nad-sazavou')
- expect(slugify('Frýdek-Místek')).toBe('frydek-mistek')
- })
-})
-
describe('aggregateCities / findCity', () => {
const index = [
church('1', 'Praha 1', 50.08, 14.42),
@@ -57,6 +34,19 @@ describe('aggregateCities / findCity', () => {
expect(findCity(index, 'brno')?.name).toBe('Brno')
expect(findCity(index, 'nowhere')).toBeUndefined()
})
+ it('slug collision resolution is stable regardless of church counts (M11)', () => {
+ // "Skřipov" and "Skřípov" both fold to "skripov". Whichever has more churches
+ // should not affect the slug assignment — it's name-ordered so it never drifts.
+ const makeIdx = (skipovCount: number, skripovCount: number) => [
+ ...Array.from({ length: skipovCount }, (_, i) => church(`s${i}`, 'Skřipov', 49.8, 17.6)),
+ ...Array.from({ length: skripovCount }, (_, i) => church(`r${i}`, 'Skřípov', 49.5, 17.4)),
+ ]
+ const slugsA = aggregateCities(makeIdx(5, 1)).map((c) => [c.name, c.slug])
+ const slugsB = aggregateCities(makeIdx(1, 5)).map((c) => [c.name, c.slug])
+ // Slug assignments must be identical regardless of which town has more churches.
+ const toMap = (pairs: [string, string][]) => Object.fromEntries(pairs)
+ expect(toMap(slugsA as [string,string][])).toEqual(toMap(slugsB as [string,string][]))
+ })
})
describe('searchPlaces — unified church + city typeahead', () => {
@@ -78,11 +68,6 @@ describe('searchPlaces — unified church + city typeahead', () => {
]
const cities = aggregateCities(index)
- it('fold strips Czech diacritics both sides', () => {
- expect(fold('České Budějovice')).toBe('ceske budejovice')
- expect(fold('Týnem')).toBe('tynem')
- })
-
it('finds cities diacritics-insensitively ("ceske" → České Budějovice)', () => {
const r = searchPlaces(cities, index, 'ceske')
expect(r[0]).toMatchObject({ kind: 'city', name: 'České Budějovice' })
diff --git a/src/domain/cities.ts b/src/domain/cities.ts
index d17f098..671392d 100644
--- a/src/domain/cities.ts
+++ b/src/domain/cities.ts
@@ -3,20 +3,20 @@
// Imported by the app AND by scripts/prerender.mjs (node runs the .ts directly).
import type { Church } from './data'
-export function normalizeCity(raw: string): string {
+function normalizeCity(raw: string): string {
const city = raw.includes(',') ? raw.slice(raw.lastIndexOf(',') + 1).trim() : raw.trim()
return /^Praha \d+$/.test(city) ? 'Praha' : city
}
/** Diacritics-insensitive fold: 'České' → 'ceske' (both sides of every match). */
-export function fold(s: string): string {
+function fold(s: string): string {
return s
.normalize('NFD')
.replace(/[̀-ͯ]/g, '')
.toLowerCase()
}
-export function slugify(name: string): string {
+function slugify(name: string): string {
return fold(name)
.replace(/[^a-z0-9]+/g, '-')
.replace(/^-|-$/g, '')
@@ -33,26 +33,75 @@ export interface City {
/** All municipalities with their churches and centroid, largest first. */
export function aggregateCities(index: Church[]): City[] {
- const byName = new Map()
+ // Step 1: group by (name, cell) so same-named towns in different regions stay separate.
+ const byKey = new Map()
for (const c of index) {
const name = normalizeCity(c.city)
if (!name) continue
- const list = byName.get(name)
+ const key = `${name}|${c.cell}`
+ const list = byKey.get(key)
if (list) list.push(c)
- else byName.set(name, [c])
+ else byKey.set(key, [c])
+ }
+
+ // Step 2: merge groups with the same name whose centroids are within 0.5° lat × 0.5° lng.
+ // ponytail: 0.5° ≈ 55 km — covers any Czech municipality crossing a 1° cell boundary
+ // (e.g. Praha straddles 49°N/50°N) while keeping same-named towns in different regions
+ // separate (Jestřebí near Česká Lípa vs Znojmo are ~160 km apart).
+ type MGroup = { name: string; cell: string; churches: Church[]; lat: number; lng: number }
+ const groups: MGroup[] = []
+ for (const [key, churches] of byKey) {
+ const sep = key.lastIndexOf('|')
+ const name = key.slice(0, sep)
+ const cell = key.slice(sep + 1)
+ const lat = churches.reduce((s, c) => s + c.lat, 0) / churches.length
+ const lng = churches.reduce((s, c) => s + c.lng, 0) / churches.length
+ const near = groups.find(
+ (g) => g.name === name && Math.abs(g.lat - lat) < 0.5 && Math.abs(g.lng - lng) < 0.5,
+ )
+ if (near) {
+ const prevLen = near.churches.length
+ near.churches.push(...churches)
+ // Update centroid and keep cell of the larger sub-group for potential slug disambiguation.
+ near.lat = near.churches.reduce((s, c) => s + c.lat, 0) / near.churches.length
+ near.lng = near.churches.reduce((s, c) => s + c.lng, 0) / near.churches.length
+ if (churches.length > prevLen) near.cell = cell
+ } else {
+ groups.push({ name, cell, churches, lat, lng })
+ }
+ }
+
+ // Step 3: slug assignment — cell suffix for same-name groups, then numeric suffix
+ // for distinct municipalities whose names produce the same slug after diacritics strip.
+ const nameCounts = new Map()
+ for (const { name } of groups) {
+ nameCounts.set(name, (nameCounts.get(name) ?? 0) + 1)
}
const out: City[] = []
- for (const [name, churches] of byName) {
- out.push({
- name,
- slug: slugify(name),
- count: churches.length,
- lat: churches.reduce((s, c) => s + c.lat, 0) / churches.length,
- lng: churches.reduce((s, c) => s + c.lng, 0) / churches.length,
- churches,
- })
+ for (const { name, cell, churches, lat, lng } of groups) {
+ const baseSlug = slugify(name)
+ const slug = (nameCounts.get(name) ?? 1) > 1 ? `${baseSlug}-${cell.replace('-', '')}` : baseSlug
+ out.push({ name, slug, count: churches.length, lat, lng, churches })
}
out.sort((a, b) => b.count - a.count || a.name.localeCompare(b.name, 'cs'))
+
+ // Resolve any remaining slug collisions (e.g. "Skřipov" vs "Skřípov" → same base slug).
+ // Assign suffixes in name order (stable), not count order, so a data refresh that
+ // changes church counts doesn't repoint an existing /mesto// URL.
+ const slugGroups = new Map()
+ for (const city of out) {
+ const g = slugGroups.get(city.slug)
+ if (g) g.push(city)
+ else slugGroups.set(city.slug, [city])
+ }
+ for (const group of slugGroups.values()) {
+ if (group.length <= 1) continue
+ // Sort by name for a stable assignment; lat as tiebreaker for same-name edge cases.
+ group.sort((a, b) => a.name.localeCompare(b.name, 'cs') || (a.lat - b.lat))
+ group.forEach((city, i) => {
+ if (i > 0) city.slug = `${city.slug}-${i + 1}`
+ })
+ }
return out
}
diff --git a/src/domain/data.ts b/src/domain/data.ts
index f78b985..6bd9561 100644
--- a/src/domain/data.ts
+++ b/src/domain/data.ts
@@ -48,7 +48,7 @@ export interface ChurchServices {
// ponytail: registry type is free text; confession comes as "svátost smíření"
// (case varies). Trim + case-insensitive exact match keeps note-mentions of
// confession — which live in a Mass row's note, not its type — untouched.
-export const isConfession = (type: string): boolean => /^svátost smíření$/i.test(type.trim())
+const isConfession = (type: string): boolean => /^svátost smíření$/i.test(type.trim())
/** services/.json value shape (compact keys). */
interface ShardEntry {
diff --git a/src/domain/feedback.ts b/src/domain/feedback.ts
index b9d624f..a448ccd 100644
--- a/src/domain/feedback.ts
+++ b/src/domain/feedback.ts
@@ -2,7 +2,7 @@
// aggregates by Mass. docs/PILGRIM-WITNESS-PLAN.md: positive-only witness chips,
// no scale, no opposite — a wall with no way to say anything unkind.
-import { pragueToday } from './occurrences'
+import { pragueIsoDate, pragueToday } from './occurrences'
export interface Chip {
/** Stable ascii id (stored, aggregated). */
@@ -94,12 +94,6 @@ function pragueIsoWeekday(when: Date): number {
return dow === 0 ? 7 : dow
}
-/** ISO date ("YYYY-MM-DD") of an instant on the Prague wall clock. */
-function pragueIsoDate(when: Date): string {
- const { y, m, d } = pragueToday(when)
- return `${y}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')}`
-}
-
/**
* Stable grouping key for a Mass. Regular masses group by weekday+time+rite+lang
* slot (so every Sunday 09:00 ordinary-form Czech is one profile, and a Latin
@@ -115,7 +109,7 @@ export function massKey(churchId: string, service: MassRef, attendedDate: Date):
/** The write-path occurrence fields for a Mass attended on `attendedDate`. */
export function occurrenceOf(service: MassRef, attendedDate: Date): Occurrence {
return {
- weekday: service.date ? pragueIsoWeekday(new Date(`${service.date}T${service.time}`)) : pragueIsoWeekday(attendedDate),
+ weekday: service.date ? pragueIsoWeekday(new Date(`${service.date}T12:00:00Z`)) : pragueIsoWeekday(attendedDate),
time: service.time,
rite: riteOf(service),
lang: service.lang,
diff --git a/src/domain/filters.ts b/src/domain/filters.ts
index 9e62164..bb30928 100644
--- a/src/domain/filters.ts
+++ b/src/domain/filters.ts
@@ -31,7 +31,7 @@ export const MAX_KM_OPTIONS = [2, 5, 10] as const
// ponytail: registry types are free text; "mass" = anything named mše/liturgie.
const isMass = (type: string) => /mše|liturgi/i.test(type)
-export const serviceMatches =
+const serviceMatches =
(f: Filters, cas: string | null = null) =>
(s: Service | ExtraService): boolean =>
(!f.lang || s.lang === f.lang) &&
diff --git a/src/domain/format.ts b/src/domain/format.ts
index d0fcc23..b787ce9 100644
--- a/src/domain/format.ts
+++ b/src/domain/format.ts
@@ -3,7 +3,8 @@
// load, so a runtime language change (or a test flipping navigator.language)
// takes effect on the next format call.
-import { lang, locale } from '../i18n'
+import { lang, locale, t } from '../i18n'
+import { pragueIsoDate } from './occurrences'
const TZ = 'Europe/Prague'
@@ -72,8 +73,6 @@ const timeFmt = new Intl.DateTimeFormat('cs-CZ', {
})
export const fmtTime = (d: Date): string => timeFmt.format(d)
-const dateKeyFmt = new Intl.DateTimeFormat('en-CA', { timeZone: TZ }) // YYYY-MM-DD
-
// One cache, keyed by "kind:locale" — Intl.DateTimeFormat construction isn't
// free, and locale() can flip mid-session (a test, or a live language change).
const fmtCache = new Map()
@@ -128,16 +127,15 @@ export function fmtDateCz(iso: string): string {
}
export function dayLabel(now: Date, start: Date): string {
- const key = dateKeyFmt.format(start)
- if (key === dateKeyFmt.format(now)) return lang() === 'cs' ? 'dnes' : 'today'
- if (key === dateKeyFmt.format(new Date(now.getTime() + 86_400_000)))
- return lang() === 'cs' ? 'zítra' : 'tomorrow'
+ const key = pragueIsoDate(start)
+ if (key === pragueIsoDate(now)) return t('day_today')
+ if (key === pragueIsoDate(new Date(now.getTime() + 86_400_000))) return t('day_tomorrow')
return weekdayFmt().format(start).toLowerCase()
}
/** Same Prague calendar day? (The map chip's "is this actually today" check.) */
export function samePragueDay(a: Date, b: Date): boolean {
- return dateKeyFmt.format(a) === dateKeyFmt.format(b)
+ return pragueIsoDate(a) === pragueIsoDate(b)
}
const weekdayShortFmt = () => cachedFmt('weekdayShort', { timeZone: TZ, weekday: 'short' })
diff --git a/src/domain/ics.ts b/src/domain/ics.ts
index e2a7b37..ee09725 100644
--- a/src/domain/ics.ts
+++ b/src/domain/ics.ts
@@ -2,7 +2,7 @@
// an RRULE; times are Prague wall clock via TZID + an explicit VTIMEZONE so
// every client agrees across DST.
import type { Church, ExtraService, Service } from './data'
-import { nextOccurrences, pragueToday } from './occurrences'
+import { nextOccurrences, pragueIsoDate } from './occurrences'
const BYDAY: Record = { 1: 'MO', 2: 'TU', 3: 'WE', 4: 'TH', 5: 'FR', 6: 'SA', 7: 'SU' }
@@ -36,14 +36,11 @@ const pad = (n: number) => String(n).padStart(2, '0')
/** VEVENT text for one service of a church, or null when the service has no
* upcoming occurrence (past one-off, unparsable time). */
export function buildICS(church: Church, service: Service | ExtraService, now: Date): string | null {
- const spec =
- 'days' in service ? { days: service.days, time: service.time } : { date: service.date, time: service.time }
- const first = nextOccurrences(spec, now, 8)[0]
+ const first = nextOccurrences(service, now, 8)[0]
if (!first) return null
- const w = pragueToday(first)
- const [hh, mm] = service.time.split(':').map(Number)
- const dtstart = `${w.y}${pad(w.m)}${pad(w.d)}T${pad(hh)}${pad(mm)}00`
+ const [hh, mm] = service.time.split(/\s/)[0].split(':').map(Number)
+ const dtstart = `${pragueIsoDate(first).replace(/-/g, '')}T${pad(hh)}${pad(mm)}00`
const type = service.type || 'bohoslužba'
const summary = `${type.charAt(0).toUpperCase()}${type.slice(1)} — ${church.name}`
const url = `https://bohosluzby.dravec.org/kostel/${church.id}/`
diff --git a/src/domain/liturgical.ts b/src/domain/liturgical.ts
index bdabf5d..b8ba5d5 100644
--- a/src/domain/liturgical.ts
+++ b/src/domain/liturgical.ts
@@ -13,6 +13,8 @@
// Ordinary = the rest
// Fixed-date CZ solemnities override the running season's color.
+import { pragueToday } from './occurrences'
+
export type Season = 'advent' | 'christmas' | 'lent' | 'easter' | 'ordinary'
export type LiturgicalColor = 'green' | 'violet' | 'gold' | 'red'
@@ -83,7 +85,8 @@ export function liturgicalDay(year: number, month: number, day: number): Liturgi
// Advent: 4th Sunday before 25 Dec (the Sunday in the 27 Nov – 3 Dec window).
const christmas = utc(year, 12, 25)
- const advent1 = christmas - dow(christmas) * DAY - 21 * DAY
+ // Use (dow || 7) so a Sunday Christmas steps back to the previous Sunday first.
+ const advent1 = christmas - (dow(christmas) || 7) * DAY - 21 * DAY
if (t >= christmas) return { season: 'christmas', color: 'gold', feast: fixed?.feast }
if (t === advent1 - 7 * DAY) return { season: 'ordinary', color: 'gold', feast: 'Ježíše Krista Krále' }
if (t >= advent1) return { season: 'advent', color: fixed?.color ?? 'violet', feast: fixed?.feast }
@@ -93,14 +96,8 @@ export function liturgicalDay(year: number, month: number, day: number): Liturgi
/** Today's liturgical color in Prague (used for the --season accent). */
export function currentLiturgicalDay(now: Date = new Date()): LiturgicalDay {
- const p = new Intl.DateTimeFormat('en-CA', {
- timeZone: 'Europe/Prague',
- year: 'numeric',
- month: 'numeric',
- day: 'numeric',
- }).formatToParts(now)
- const get = (type: string) => Number(p.find((x) => x.type === type)?.value)
- return liturgicalDay(get('year'), get('month'), get('day'))
+ const { y, m, d } = pragueToday(now)
+ return liturgicalDay(y, m, d)
}
// ---- "verify the times" advisory season -----------------------------------
@@ -111,14 +108,7 @@ export function currentLiturgicalDay(now: Date = new Date()): LiturgicalDay {
export type VerifySeason = 'summer' | 'advent' | 'christmas' | 'lent' | 'easter' | null
export function verifySeason(now: Date = new Date()): VerifySeason {
- const p = new Intl.DateTimeFormat('en-CA', {
- timeZone: 'Europe/Prague',
- year: 'numeric',
- month: 'numeric',
- day: 'numeric',
- }).formatToParts(now)
- const get = (type: string) => Number(p.find((x) => x.type === type)?.value)
- const [year, month, day] = [get('year'), get('month'), get('day')]
+ const { y: year, m: month, d: day } = pragueToday(now)
// CZ school summer holidays — the single biggest schedule-shuffle window
if (month === 7 || month === 8) return 'summer'
const lit = liturgicalDay(year, month, day)
diff --git a/src/domain/notes.test.ts b/src/domain/notes.test.ts
index e914f24..0e337fe 100644
--- a/src/domain/notes.test.ts
+++ b/src/domain/notes.test.ts
@@ -41,6 +41,41 @@ describe('month exclusions (kromě/mimo/vyjma)', () => {
})
})
+describe('AND-combination of inclusion segments (M1)', () => {
+ it('ve školním roce, 1. sobota v měsíci — both conditions must hold', () => {
+ const note = 've školním roce, 1. sobota v měsíci'
+ expect(runs(note, '2026-07-04')).toBe(false) // 1st Saturday of July — not school year
+ expect(runs(note, '2026-09-05')).toBe(true) // 1st Saturday of September — in school year
+ expect(runs(note, '2026-09-12')).toBe(false) // 2nd Saturday — not 1st Sat
+ expect(noteUncertain(note)).toBe(false)
+ })
+})
+
+describe('OR-combination of same-kind inclusion segments (H2)', () => {
+ it('"v červenci, v srpnu" means July OR August, not July AND August', () => {
+ const note = 'v červenci, v srpnu'
+ expect(runs(note, '2026-07-15')).toBe(true) // July
+ expect(runs(note, '2026-08-15')).toBe(true) // August
+ expect(runs(note, '2026-06-15')).toBe(false) // June
+ expect(noteUncertain(note)).toBe(false)
+ })
+ it('"1. sobota, 3. sobota" means 1st OR 3rd Saturday', () => {
+ const note = '1. sobota v měsíci, 3. sobota v měsíci'
+ expect(runs(note, '2026-07-04')).toBe(true) // 1st Saturday
+ expect(runs(note, '2026-07-18')).toBe(true) // 3rd Saturday
+ expect(runs(note, '2026-07-11')).toBe(false) // 2nd Saturday
+ expect(runs(note, '2026-07-05')).toBe(true) // Sunday — not governed
+ expect(noteUncertain(note)).toBe(false)
+ })
+ it('cross-kind is still AND: "v červenci, 1. sobota v měsíci" = July AND 1st Sat', () => {
+ const note = 'v červenci, 1. sobota v měsíci'
+ expect(runs(note, '2026-07-04')).toBe(true) // 1st Saturday of July
+ expect(runs(note, '2026-07-11')).toBe(false) // 2nd Saturday of July
+ expect(runs(note, '2026-09-05')).toBe(false) // 1st Saturday outside July
+ expect(noteUncertain(note)).toBe(false)
+ })
+})
+
describe('summer holidays and school year', () => {
it.each([
'kromě letních prázdnin',
@@ -83,6 +118,17 @@ describe('month ranges (období od … do …)', () => {
expect(runs('období od července do konce srpna', '2026-08-31')).toBe(true)
expect(runs('období od července do konce srpna', '2026-09-01')).toBe(false)
})
+ it('od konce června do září: starts at end of June, not June 1 (M2)', () => {
+ expect(runs('od konce června do září', '2026-06-30')).toBe(true) // last day of June
+ expect(runs('od konce června do září', '2026-06-05')).toBe(false) // before end of June
+ expect(runs('od konce června do září', '2026-07-15')).toBe(true) // inside range
+ expect(runs('od konce června do září', '2026-10-01')).toBe(false) // after September
+ })
+ it('do konce února includes Feb 29 in leap years (M2)', () => {
+ expect(runs('od ledna do konce února', '2024-02-29')).toBe(true) // leap year Feb 29
+ expect(runs('od ledna do konce února', '2024-02-28')).toBe(true)
+ expect(runs('od ledna do konce února', '2024-03-01')).toBe(false) // after range
+ })
})
describe('summer/winter time (DST)', () => {
@@ -130,6 +176,16 @@ describe('nth weekday of month', () => {
expect(runs('kromě 1. soboty v měsíci', '2026-07-11')).toBe(true)
expect(runs('kromě poslední neděle v měsíci', '2026-07-26')).toBe(false)
})
+ it('comma-joined ordinals "1., 3. sobota v měsíci" — both treated as one multi-nth predicate (H1)', () => {
+ // "1., 3. sobota v měsíci" means 1st OR 3rd Saturday; the comma is an ordinal
+ // conjunction, not a segment separator.
+ const note = '1., 3. sobota v měsíci'
+ expect(runs(note, '2026-07-04')).toBe(true) // 1st Saturday
+ expect(runs(note, '2026-07-18')).toBe(true) // 3rd Saturday
+ expect(runs(note, '2026-07-11')).toBe(false) // 2nd Saturday
+ expect(runs(note, '2026-07-05')).toBe(true) // Sunday — note doesn't govern it
+ expect(noteUncertain(note)).toBe(false)
+ })
})
describe('week-of-month and parity', () => {
@@ -160,6 +216,14 @@ describe('advent', () => {
expect(runs('kromě adventu a letních prázdnin', '2026-12-06')).toBe(false)
expect(runs('kromě adventu a letních prázdnin', '2026-10-06')).toBe(true)
})
+ it('exclusion + schedule: exclusion is not cancelled by a schedule predicate (H1)', () => {
+ // "kromě července a srpna, 1. sobota v měsíci" — should exclude July even on 1st Saturdays
+ const note = 'kromě července a srpna, 1. sobota v měsíci'
+ expect(runs(note, '2026-07-04')).toBe(false) // 1st Saturday of July — excluded
+ expect(runs(note, '2026-08-01')).toBe(false) // 1st Saturday of August — excluded
+ expect(runs(note, '2026-09-05')).toBe(true) // 1st Saturday of September — runs
+ expect(runs(note, '2026-09-12')).toBe(false) // 2nd Saturday of September — not 1st Sat
+ })
})
describe('conditional-in-months', () => {
@@ -198,6 +262,22 @@ describe('long-tail variants', () => {
})
})
+describe('CONDITIONAL catches missing patterns (M3)', () => {
+ it('ordinal weekday without "v měsíci" is flagged uncertain', () => {
+ expect(noteUncertain('1. neděle')).toBe(true)
+ expect(noteUncertain('2. a 4. neděle')).toBe(true)
+ expect(runs('1. neděle', '2026-07-06')).toBe(true) // kept, not silently dropped
+ })
+ it('sudou/lichou weekday is flagged uncertain', () => {
+ expect(noteUncertain('sudou neděli')).toBe(true)
+ expect(noteUncertain('lichou sobotu')).toBe(true)
+ })
+ it('seasonal patterns not in parser are flagged uncertain', () => {
+ expect(noteUncertain('v zimě')).toBe(true)
+ expect(noteUncertain('od Velikonoc do Dušiček')).toBe(true)
+ })
+})
+
describe('uncertain notes: kept, flagged', () => {
it.each([
'1x za 14 dní',
diff --git a/src/domain/notes.ts b/src/domain/notes.ts
index 09e9466..c7168ea 100644
--- a/src/domain/notes.ts
+++ b/src/domain/notes.ts
@@ -11,6 +11,7 @@
// feedback card surfaces them.
import { liturgicalDay } from './liturgical'
+import { pragueToday } from './occurrences'
export interface NoteRule {
/** true = may run on that Prague calendar date; false = provably does not. */
@@ -122,33 +123,55 @@ function parseOrdinals(s: string): (number | 'last')[] | null {
}
/** Positive-inclusion object after "kromě/mimo/vyjma" or "pouze v": months,
- * prázdniny, advent, nth weekday — or an " a "-joined union of those. */
-function parseInclusion(s: string): Pred | null {
+ * prázdniny, advent, nth weekday — or an " a "-joined union of those.
+ * negated=true is used by the except branch so the correct predicate is built
+ * in one call; notably nthWeekday returns true for non-target weekdays (a
+ * "governs only wd" sentinel) so not(nthWeekday) would wrongly exclude them. */
+function parseInclusion(s: string, negated = false): Pred | null {
const months = parseMonthSet(s)
- if (months) return (_y, m) => months.has(m)
- if (/^(?:období\s+|dobu\s+|doby\s+)?(?:letní(?:ch)?\s+|hlavní(?:ch)?\s+)?prázdnin(?:y|ách)?$/.test(s)) return julyAugust
- if (/^adventu?$/.test(s)) return advent
- if (/^(?:dobu\s+|doby\s+|období\s+)?postní(?:\s+dob[uy])?$/.test(s) || s === 'postu') return lent
+ if (months) {
+ const pos: Pred = (_y, m) => months.has(m)
+ return negated ? not(pos) : pos
+ }
+ if (/^(?:období\s+|dobu\s+|doby\s+)?(?:letní(?:ch)?\s+|hlavní(?:ch)?\s+)?prázdnin(?:y|ách)?$/.test(s))
+ return negated ? not(julyAugust) : julyAugust
+ if (/^adventu?$/.test(s)) return negated ? not(advent) : advent
+ if (/^(?:dobu\s+|doby\s+|období\s+)?postní(?:\s+dob[uy])?$/.test(s) || s === 'postu')
+ return negated ? not(lent) : lent
const nth = new RegExp(`^(${ORDINAL_RE}(?:\\s*(?:,|\\s+a\\s+)\\s*${ORDINAL_RE})*)\\s+(${WEEKDAY_RE})(?:\\s+v\\s+měsíci)?$`).exec(s)
if (nth) {
const ords = parseOrdinals(nth[1])
- if (ords) return nthWeekday(ords, WEEKDAY[nth[2]])
+ const wd = WEEKDAY[nth[2]]
+ if (ords) {
+ if (negated) {
+ // "kromě Nth wd": exclude only that specific occurrence; pass all other days including other weekdays
+ return (y, m, d) => isoDow(y, m, d) !== wd || !ords.some((o) => o === 'last' ? d + 7 > daysInMonth(y, m) : Math.ceil(d / 7) === o)
+ }
+ return nthWeekday(ords, wd)
+ }
}
- // union: "adventu a letních prázdnin"
+ // union: "adventu a letních prázdnin" — De Morgan: not(A or B) = not(A) and not(B)
const parts = s.split(/\s+a\s+/)
if (parts.length > 1) {
- const preds = parts.map((p) => parseInclusion(p.trim()))
+ const preds = parts.map((p) => parseInclusion(p.trim(), negated))
if (preds.every((p): p is Pred => p !== null))
- return (y, m, d) => preds.some((p) => p(y, m, d))
+ return negated
+ ? (y, m, d) => (preds as Pred[]).every((p) => p(y, m, d))
+ : (y, m, d) => (preds as Pred[]).some((p) => p(y, m, d))
}
return null
}
/** "od X do Y" boundary → [month, day] (day defaults per edge). */
function parseBound(s: string, edge: 'from' | 'to'): [number, number] | null {
+ const konce = /^kon(?:ce|ec)\s+/.test(s)
const t = s.replace(/^kon(?:ce|ec)\s+/, '').trim()
const m = MONTH[t]
- if (m) return [m, edge === 'from' ? 1 : 31]
+ // For 'to' edge: return 31 — a sentinel always ≥ the real last day, so
+ // Feb 29 in a leap year passes the range check (M2). For 'from' edge with
+ // konce: use daysInMonth with non-leap 2023; all non-Feb months are exact
+ // and Feb 'from' uses day 28 which still includes Feb 29 (k≥228).
+ if (m) return [m, konce && edge === 'from' ? daysInMonth(2023, m) : edge === 'from' ? 1 : 31]
const dm = /^(\d{1,2})\.\s*(\d{1,2})\.?$/.exec(t)
if (dm) return [Number(dm[2]), Number(dm[1])]
return null
@@ -166,8 +189,7 @@ function parseSegment(seg: string): Pred | 'none' | null {
if (/^(?:pouze\s+|jen\s+)?(?:v\s+)?(?:období\s+|době\s+)?letní(?:ho|m)?\s+(?:čas[eu]?|období)$/.test(s)) return summerTime
if (/^(?:pouze\s+|jen\s+)?(?:v\s+)?(?:období\s+|době\s+)?zimní(?:ho|m)?\s+(?:čas[eu]?|období)$/.test(s)) return not(summerTime)
- // school year / holidays
- if (/školní(?:m|ho)?\s+ro[ck]/.test(s)) return schoolYear
+ // school year / holidays — checked AFTER negation so "kromě … školního roku" hits except first
if (/^(?:pouze\s+|jen\s+)?(?:o|v|během)\s+(?:době\s+|období\s+)?(?:letních\s+)?prázdnin(?:ách)?$/.test(s)) return julyAugust
// advent ("v adventu rorátní" = a rorate mass — advent-only by definition)
@@ -176,10 +198,9 @@ function parseSegment(seg: string): Pred | 'none' | null {
// kromě/mimo/vyjma
const except = /^(?:kromě|mimo|vyjma|s výjimkou)\s+(.+)$/.exec(s)
- if (except) {
- const inc = parseInclusion(except[1])
- return inc ? not(inc) : null
- }
+ if (except) return parseInclusion(except[1], true)
+
+ if (/školní(?:m|ho)?\s+ro[ck]/.test(s)) return schoolYear
// (období) od X do Y
const range = /^(?:(?:v\s+)?období\s+)?od\s+(.+?)\s+do\s+(.+)$/.exec(s)
@@ -225,7 +246,10 @@ function parseSegment(seg: string): Pred | 'none' | null {
// nth weekday: "1. sobota v měsíci", "2. a 4. neděle v měsíci", "pouze první sobota…",
// with an optional prose prefix before "pouze" ("Mše sv. je sloužena pouze 1. sobotu v měsíci")
- const nthRe = new RegExp(`(?:^|^.*\\s)(?:vždy\\s+)?(?:pouze|jen)\\s+(${ORDINAL_RE}(?:\\s*(?:,|\\s+a\\s+)\\s*${ORDINAL_RE})*)\\s+(${WEEKDAY_RE})(?:\\s+v\\s+měsíci)?$`).exec(s) ??
+ // Guard: skip when the prefix prose contains negation ("nekoná se pouze…" means the opposite).
+ const nthRe = (!NEGATION.test(s)
+ ? new RegExp(`(?:^|^.*\\s)(?:vždy\\s+)?(?:pouze|jen)\\s+(${ORDINAL_RE}(?:\\s*(?:,|\\s+a\\s+)\\s*${ORDINAL_RE})*)\\s+(${WEEKDAY_RE})(?:\\s+v\\s+měsíci)?$`).exec(s)
+ : null) ??
new RegExp(`^(?:1x\\s+za\\s+měsíc\\s+)?(${ORDINAL_RE}(?:\\s*(?:,|\\s+a\\s+)\\s*${ORDINAL_RE})*)\\s+(${WEEKDAY_RE})\\s+v\\s+měsíci$`).exec(s)
if (nthRe) {
const ords = parseOrdinals(nthRe[1])
@@ -250,13 +274,29 @@ function parseSegment(seg: string): Pred | 'none' | null {
// Descriptive segments ("pro děti", "s nedělní platností", "č/p") pass silently.
const CONDITIONAL = new RegExp(
// 'svát(?:ek|k|c)' not bare 'svát' — "svátost smíření" is not a feast condition
- `krom|mimo|vyjma|výjimk|pouze|\\bjen\\b|nepravidel|není|nejsou|nekoná|neslouž|nebývá|odpadá|období|prázdnin|čas|týd(?:en|n)|měsíc|advent|postní|škol|sud[ýé]|lich[ýé]|svát(?:ek|k|c)|ohlášen|\\d+\\s*[x×]|${MONTH_RE}`,
+ // WEEKDAY_RE catches ordinal-weekday without "v měsíci" ("1. neděle", "sudou neděli") (M3)
+ // zim|velikono|dušič catch "v zimě", "od Velikonoc do Dušiček" (M3)
+ `krom|mimo|vyjma|výjimk|pouze|\\bjen\\b|nepravidel|není|nejsou|nekoná|neslouž|nebývá|odpadá|období|prázdnin|čas|týd(?:en|n)|měsíc|advent|postní|škol|sud[ýé]|lich[ýé]|svát(?:ek|k|c)|ohlášen|\\d+\\s*[x×]|${MONTH_RE}|${WEEKDAY_RE}|zim|velikono|dušič`,
)
// Frequency markers that a sibling segment makes concrete ("1x za měsíc, 1. týden v měsíci").
const FREQUENCY = /^(?:1x\s+(?:za\s+měsíc|měsíčně|za\s+14\s+dní|za\s+2\s+týdny)|každých\s+14\s+dní)$/
const cache = new Map()
+// Segments that contribute exclusion predicates — ANDed so each exclusion stacks.
+const EXCL_SEG = /^(?:kromě|mimo|vyjma|s\s+výjimkou)\s+/
+
+// H2: classify an inclusion segment so same-kind segments can be OR'd.
+// "v červenci, v srpnu" → both 'month' → OR → July or August.
+// "ve školním roce, 1. sobota" → 'other' + 'weekday' → AND across kinds.
+function segKind(seg: string): string {
+ const s = seg.replace(/\.$/, '').trim()
+ const onlyMonths = /^(?:pouze\s+|jen\s+)?v(?:e)?\s+(.+)$/.exec(s)
+ if (onlyMonths && parseMonthSet(onlyMonths[1])) return 'month'
+ if (new RegExp(WEEKDAY_RE).test(s)) return 'weekday'
+ if (/^(?:(?:v\s+)?období\s+)?od\s+.+\s+do\s+/.test(s)) return 'range'
+ return 'other'
+}
export function parseNote(note: string): NoteRule {
const trimmed = note.trim()
@@ -266,8 +306,16 @@ export function parseNote(note: string): NoteRule {
// split sentences (". " before an uppercase letter) and comma/semicolon segments;
// the lookbehind spares ordinals ("1. sobotu") and abbreviations ("posl. týden")
+ //
+ // H1: protect "1., 3. sobota v měsíci" style ordinal lists from the generic
+ // comma split — replace internal commas with " a " so the phrase stays one segment.
+ const multiNthRe = new RegExp(
+ `(${ORDINAL_RE}(?:\\s*,\\s*${ORDINAL_RE})+)(\\s+(?:${WEEKDAY_RE})(?:\\s+v\\s+měsíci)?)`,
+ 'gi',
+ )
const segs = trimmed
.split(/(?<=\p{Ll}{3})\.\s+(?=\p{Lu})/u)
+ .map((s) => s.replace(multiNthRe, (_, ords: string, wd: string) => ords.replace(/\s*,\s*/g, ' a ') + wd))
.flatMap((s) => s.split(/\s*[,;]\s*/))
.map((s) => s.trim().toLowerCase())
.filter(Boolean)
@@ -286,13 +334,53 @@ export function parseNote(note: string): NoteRule {
// school-year exclusion but can't read segment 2 — applying the exclusion
// would hide the real summer mass. Degrade to kept-uncertain (runs, flagged);
// showing a flagged row beats silently dropping a mass the note half-explains.
- const rule: NoteRule =
- preds.length === 0 || uncertain
- ? { runsOn: ALWAYS.runsOn, uncertain }
- : { runsOn: (y, m, d) => preds.every((p) => p(y, m, d)), uncertain }
+ let rule: NoteRule
+ if (preds.length === 0 || uncertain) {
+ rule = { runsOn: ALWAYS.runsOn, uncertain }
+ } else {
+ // Exclusion segs (kromě/mimo/vyjma) are ANDed — each exclusion must hold.
+ // Inclusion segs: same-kind segs are OR'd (alternatives), different kinds AND'd (H2).
+ // "v červenci, v srpnu" → OR (both month kind). "ve školním roce, 1. sobota" → AND.
+ const excls: Pred[] = []
+ const incls: Pred[] = []
+ const inclSegs: string[] = []
+ parsed.forEach((p, i) => {
+ if (typeof p !== 'function') return
+ if (EXCL_SEG.test(segs[i])) excls.push(p)
+ else { incls.push(p); inclSegs.push(segs[i]) }
+ })
+ // Group inclusions by kind; OR within group, AND across groups.
+ const kindGroups = new Map()
+ incls.forEach((p, i) => {
+ const k = segKind(inclSegs[i])
+ const arr = kindGroups.get(k) ?? []
+ arr.push(p)
+ kindGroups.set(k, arr)
+ })
+ const inclPred: Pred =
+ kindGroups.size === 0
+ ? () => true
+ : (y, m, d) => [...kindGroups.values()].every((group) => group.some((p) => p(y, m, d)))
+ const runsOn: Pred =
+ excls.length === 0
+ ? inclPred
+ : incls.length === 0
+ ? (y, m, d) => excls.every((p) => p(y, m, d))
+ : (y, m, d) => inclPred(y, m, d) && excls.every((p) => p(y, m, d))
+ rule = { runsOn, uncertain }
+ }
cache.set(trimmed, rule)
return rule
}
/** Should this note be rendered as a warning rubric? */
export const noteUncertain = (note: string): boolean => parseNote(note).uncertain
+
+/** Note-aware occurrence check: does the note allow the Prague calendar day
+ * `start` falls on? No note → yes. (parseNote is memoized, so this is cheap
+ * to call once per occurrence.) */
+export const noteRunsOn = (note: string | undefined, start: Date): boolean => {
+ if (!note) return true
+ const w = pragueToday(start)
+ return parseNote(note).runsOn(w.y, w.m, w.d)
+}
diff --git a/src/domain/occurrences.ts b/src/domain/occurrences.ts
index 1d5d0bc..633896b 100644
--- a/src/domain/occurrences.ts
+++ b/src/domain/occurrences.ts
@@ -52,6 +52,12 @@ export function pragueToday(now: Date): { y: number; m: number; d: number } {
return { y, m, d }
}
+/** ISO date ("YYYY-MM-DD") of an instant on the Prague wall clock. */
+export function pragueIsoDate(when: Date): string {
+ const { y, m, d } = pragueToday(when)
+ return `${y}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')}`
+}
+
/** Minutes since midnight on the Prague wall clock. */
export function pragueMinutes(now: Date): number {
const { hh, mm } = pragueWall(now)
diff --git a/src/domain/ranking.ts b/src/domain/ranking.ts
index a6ebb71..12eac05 100644
--- a/src/domain/ranking.ts
+++ b/src/domain/ranking.ts
@@ -9,21 +9,14 @@
// not as a hard cutoff.
import { haversineKm } from './distance'
-import { nextOccurrences, pragueToday } from './occurrences'
-import { parseNote } from './notes'
+import { nextOccurrences, pragueIsoDate, pragueToday } from './occurrences'
+import { noteRunsOn } from './notes'
import { applyFilters, type Filters } from './filters'
import type { Church, ChurchServices, Service, ExtraService } from './data'
/** Day-picker choice: 'now' = soonest, time then distance; 0–6 = today + offset's full ordo. */
export type DayChoice = 'now' | number
-/** Note-aware occurrence check: skip dates the note provably excludes. */
-const runsOn = (service: Service | ExtraService, start: Date): boolean => {
- if (!service.note) return true
- const w = pragueToday(start)
- return parseNote(service.note).runsOn(w.y, w.m, w.d)
-}
-
export interface Upcoming {
church: Church
distanceKm: number
@@ -52,16 +45,16 @@ export function rankUpcoming(
const distanceKm = haversineKm(origin.lat, origin.lng, church.lat, church.lng)
let best: Upcoming | null = null
- const consider = (service: Service | ExtraService, spec: Parameters[0]) => {
- for (const start of nextOccurrences(spec, now, horizonDays)) {
- if (!runsOn(service, start)) continue // "kromě července a srpna" — don't lie in July
+ const consider = (service: Service | ExtraService) => {
+ for (const start of nextOccurrences(service, now, horizonDays)) {
+ if (!noteRunsOn(service.note, start)) continue // "kromě července a srpna" — don't lie in July
if (!best || start < best.start)
best = { church, distanceKm, start, service, updated: svc.updated }
break // occurrences are sorted; the first running one is this service's best
}
}
- for (const s of svc.regular) consider(s, { days: s.days, time: s.time })
- for (const x of svc.extra) consider(x, { date: x.date, time: x.time })
+ for (const s of svc.regular) consider(s)
+ for (const x of svc.extra) consider(x)
if (best) out.push(best)
}
out.sort((a, b) => a.start.getTime() - b.start.getTime() || a.distanceKm - b.distanceKm)
@@ -81,26 +74,23 @@ export function ordoForDay(
servicesById: ReadonlyMap,
): Upcoming[] {
const today = pragueToday(now)
- const target = new Date(Date.UTC(today.y, today.m - 1, today.d) + dayOffset * 86_400_000)
- const onTarget = (d: Date): boolean => {
- const w = pragueToday(d)
- return (
- w.y === target.getUTCFullYear() && w.m === target.getUTCMonth() + 1 && w.d === target.getUTCDate()
- )
- }
+ const targetIso = new Date(Date.UTC(today.y, today.m - 1, today.d) + dayOffset * 86_400_000)
+ .toISOString()
+ .slice(0, 10)
+ const onTarget = (d: Date): boolean => pragueIsoDate(d) === targetIso
const out: Upcoming[] = []
for (const church of churches) {
const svc = servicesById.get(church.id)
if (!svc) continue
const distanceKm = haversineKm(origin.lat, origin.lng, church.lat, church.lng)
- const consider = (service: Service | ExtraService, spec: Parameters[0]) => {
- for (const start of nextOccurrences(spec, now, dayOffset + 1)) {
- if (onTarget(start) && runsOn(service, start))
+ const consider = (service: Service | ExtraService) => {
+ for (const start of nextOccurrences(service, now, dayOffset + 1)) {
+ if (onTarget(start) && noteRunsOn(service.note, start))
out.push({ church, distanceKm, start, service, updated: svc.updated })
}
}
- for (const s of svc.regular) consider(s, { days: s.days, time: s.time })
- for (const x of svc.extra) consider(x, { date: x.date, time: x.time })
+ for (const s of svc.regular) consider(s)
+ for (const x of svc.extra) consider(x)
}
out.sort((a, b) => a.start.getTime() - b.start.getTime() || a.distanceKm - b.distanceKm)
return out
diff --git a/src/domain/timeband.ts b/src/domain/timeband.ts
index e365bc6..2b593fb 100644
--- a/src/domain/timeband.ts
+++ b/src/domain/timeband.ts
@@ -33,7 +33,7 @@ export function bandLabel(band: Band): string {
return (lang() === 'cs' ? BAND_LABEL_CS : BAND_LABEL_EN)[band]
}
-export const AROUND_MIN = 90
+const AROUND_MIN = 90
/** Minutes since midnight; prefix-tolerant like occurrences' parser
* (registry times can carry suffixes), strict about the digits themselves. */
diff --git a/src/i18n.ts b/src/i18n.ts
index b7ea3d5..b43b171 100644
--- a/src/i18n.ts
+++ b/src/i18n.ts
@@ -33,6 +33,7 @@ export const cs = {
picking_title: 'Jiná obec nebo kostel',
nothing_nearby_title: 'V okolí nic nenacházím',
data_error: 'Data se nepodařilo načíst. Zkuste to prosím znovu.',
+ partial_data: 'Část dat se nepodařila načíst — zobrazeny jsou dostupné bohoslužby.',
// ---- the hero list ----
nearest_services: 'Nejbližší bohoslužby',
@@ -239,6 +240,7 @@ export const en: Record = {
picking_title: 'A different town or church',
nothing_nearby_title: 'Nothing nearby',
data_error: "Couldn't load data. Please try again.",
+ partial_data: 'Some data failed to load — showing available services.',
nearest_services: 'Nearest services',
last_known_suffix: 'last known',
@@ -462,12 +464,6 @@ export function reminderScheduledMsg(min: number): string {
return lang() === 'cs' ? `✓ připomeneme ${min} min předem` : `✓ we'll remind you ${min} min before`
}
-/** " · ověřeno 2016" / " · verified 2016" — the list row's stale-data marker. */
-export function verifiedYear(iso: string): string {
- const y = iso.slice(0, 4)
- return lang() === 'cs' ? `ověřeno ${y}` : `verified ${y}`
-}
-
/** Season-window advisory: one banner over the list (and in the route sheet)
* during the windows when parishes actually shuffle schedules. */
export function verifyBanner(season: 'summer' | 'advent' | 'christmas' | 'lent' | 'easter'): string {
diff --git a/src/lib/dataStore.ts b/src/lib/dataStore.ts
index 5ddbc71..c3b1735 100644
--- a/src/lib/dataStore.ts
+++ b/src/lib/dataStore.ts
@@ -17,6 +17,10 @@ const ASOF_KEY = 'data_asof'
export interface DataVersion {
/** ISO date the registry was scraped, e.g. "2026-07-03". Also the "as of" label. */
generated: string
+ /** ISO datetime the snapshot was published, e.g. "2026-07-03T14:05:00.000Z".
+ * Used for freshness comparison so same-day re-publishes reach native clients.
+ * Absent in snapshots emitted before this field was added; falls back to `generated`. */
+ timestamp?: string
/** church count — powers the shrunken-payload sanity gate. */
churches: number
}
@@ -27,6 +31,9 @@ export interface RefreshResult {
}
let cacheReady: boolean | null = null
+/** Held during the OTA write phase; loadData awaits it so no concurrent call
+ * sees a mixed (bundled index + cached shards) state (M4). */
+let refreshLock: Promise | null = null
async function readCache(path: string): Promise {
if (!isNative) return null
@@ -54,12 +61,34 @@ async function writeCache(path: string, text: string): Promise {
async function ready(): Promise {
if (!isNative) return false
- if (cacheReady === null) cacheReady = (await readCache('version.json')) !== null
+ if (cacheReady === null) {
+ const cached = await readCache('version.json')
+ if (!cached) { cacheReady = false; return false }
+ // Bypass cache when the bundled snapshot is newer (new app release).
+ const bundled = await fetch('/data/version.json')
+ .then((r) => (r.ok ? (r.json() as Promise) : null))
+ .catch(() => null)
+ let cachedParsed: DataVersion | undefined
+ try { cachedParsed = JSON.parse(cached) as DataVersion } catch { /* corrupt */ }
+ if (!cachedParsed?.generated) { cacheReady = false; return false }
+ // Use timestamp when available so a same-day re-publish of the bundled snapshot
+ // (new app release with updated data) correctly supersedes the OTA cache.
+ const cachedKey = cachedParsed.timestamp ?? cachedParsed.generated
+ const bundledKey = bundled ? (bundled.timestamp ?? bundled.generated) : undefined
+ cacheReady = !bundledKey || bundledKey <= cachedKey
+ // When the bundled snapshot is newer, the stored asOf is stale — clear it
+ // so the footer shows the honest bundled date and refreshData re-checks the
+ // remote instead of skipping because remoteKey ≤ stale-asOf (M5).
+ if (!cacheReady) {
+ try { localStorage.removeItem(ASOF_KEY) } catch { /* private mode */ }
+ }
+ }
return cacheReady
}
/** Load a /data/ JSON from the freshest available source: cache → bundled. */
export async function loadData(path: string): Promise {
+ if (refreshLock) await refreshLock
if (await ready()) {
const cached = await readCache(path)
if (cached) return JSON.parse(cached) as T
@@ -107,21 +136,25 @@ export async function refreshData(onDownloading?: () => void): Promise('version.json').catch(() => null)
- asOf = bundled?.generated ?? null
+ // Store timestamp when available so subsequent remote comparisons detect same-day updates;
+ // fall back to generated (date string) for older snapshots without a timestamp field.
+ asOf = bundled ? (bundled.timestamp ?? bundled.generated) : null
if (asOf) setAsOf(asOf)
}
if (!isNative) {
- const v = await fetch('/data/version.json')
- .then((r) => (r.ok ? (r.json() as Promise) : null))
- .catch(() => null)
+ const v = await loadData('version.json').catch(() => null)
return { asOf: v?.generated ?? asOf, updated: false }
}
const remote = await fetchText(`${REMOTE}/data/version.json`)
.then((t) => JSON.parse(t) as DataVersion)
.catch(() => null)
- if (!remote?.generated || (asOf && remote.generated <= asOf)) return { asOf, updated: false }
+ if (!remote?.generated) return { asOf, updated: false }
+ // Use timestamp for comparison when available so same-day re-publishes reach clients.
+ // Lexicographic order works for both date-only strings and ISO timestamps.
+ const remoteKey = remote.timestamp ?? remote.generated
+ if (asOf && remoteKey <= asOf) return { asOf, updated: false }
try {
onDownloading?.() // a real payload download is starting — light the indicator
@@ -137,11 +170,30 @@ export async function refreshData(onDownloading?: () => void): Promise [c, await fetchText(`${REMOTE}/data/services/${c}.json`)] as const),
)
- for (const [c, text] of shards) await writeCache(`services/${c}.json`, text)
- await writeCache('churches.json', churchesText)
- await writeCache('version.json', JSON.stringify(remote)) // marker, written last
- cacheReady = true
- setAsOf(remote.generated)
+ // Hold refreshLock for the entire write phase so concurrent loadData calls
+ // wait instead of reading a mixed (bundled index + partially-written shards)
+ // state (M4).
+ let resolveRefreshLock!: () => void
+ refreshLock = new Promise((r) => { resolveRefreshLock = r })
+ try {
+ // Delete the version marker before ANY shard write so a partial failure
+ // leaves no valid sentinel — ready() returns false and loadData falls back
+ // to bundled. Without this, a crash between shard writes but before
+ // version.json would leave a stale version.json pointing at a mixed cache.
+ try {
+ await Filesystem.deleteFile({ path: `${CACHE}/version.json`, directory: Directory.Data })
+ } catch { /* absent on first install */ }
+ cacheReady = null
+ for (const [c, text] of shards) await writeCache(`services/${c}.json`, text)
+ await writeCache('churches.json', churchesText)
+ await writeCache('version.json', JSON.stringify(remote)) // marker, written last
+ cacheReady = true // only set after ALL writes succeed
+ // Store timestamp as asOf when available so subsequent comparisons detect same-day updates.
+ setAsOf(remote.timestamp ?? remote.generated)
+ } finally {
+ refreshLock = null
+ resolveRefreshLock()
+ }
return { asOf: remote.generated, updated: true }
} catch {
return { asOf, updated: false } // keep the old snapshot on any failure
diff --git a/src/lib/feedbackLedger.ts b/src/lib/feedbackLedger.ts
index e552613..a6a3275 100644
--- a/src/lib/feedbackLedger.ts
+++ b/src/lib/feedbackLedger.ts
@@ -47,7 +47,7 @@ export function recordExpectedAttendance(entry: Omit):
write(list)
}
-export function isNeverAsk(): boolean {
+function isNeverAsk(): boolean {
try {
return localStorage.getItem(NEVER_ASK_KEY) === '1'
} catch {
diff --git a/src/lib/feedbackStore.supabase.test.ts b/src/lib/feedbackStore.supabase.test.ts
index 776bd79..291895c 100644
--- a/src/lib/feedbackStore.supabase.test.ts
+++ b/src/lib/feedbackStore.supabase.test.ts
@@ -17,10 +17,12 @@ vi.mock('./supabase', () => ({
from: (table: string) => ({
select: () => ({
eq: (_col: string, status: string) => ({
- in: (_c2: string, ids: string[]) => {
- h.query = { table, status, ids }
- return Promise.resolve({ data: h.rows, error: null })
- },
+ in: (_c2: string, ids: string[]) => ({
+ limit: (_n: number) => {
+ h.query = { table, status, ids }
+ return Promise.resolve({ data: h.rows, error: null })
+ },
+ }),
}),
}),
}),
diff --git a/src/lib/feedbackStore.test.ts b/src/lib/feedbackStore.test.ts
index 56c4637..76f666e 100644
--- a/src/lib/feedbackStore.test.ts
+++ b/src/lib/feedbackStore.test.ts
@@ -46,7 +46,7 @@ describe('aggregateFor', () => {
sub('c1|w7|09:30', ['hluboky_prozitek'])
const agg = (await aggAfterLoad('c1')).get('c1|w7|09:30')!
expect(agg.chips.some((c) => c.id === 'krasny_zpev')).toBe(false)
- expect(CORROBORATION_MIN).toBe(1) // local prototype value
+ expect(CORROBORATION_MIN).toBeGreaterThanOrEqual(1) // prototype: 1; prod default: 3
})
it('keeps masses and churches separate; ignores other churches', async () => {
diff --git a/src/lib/feedbackStore.ts b/src/lib/feedbackStore.ts
index f081bc1..9409682 100644
--- a/src/lib/feedbackStore.ts
+++ b/src/lib/feedbackStore.ts
@@ -8,10 +8,16 @@ import { supabase } from './supabase'
import { resolveIds } from '../platform/flywheel-client'
// A tag appears on the detail page only after this many independent witnesses.
-// Prod value is 3 (a single device publishes nothing). Local prototype uses 1
-// so the owner sees their own submissions while toying.
-// TODO(prod): set CORROBORATION_MIN = 3
-export const CORROBORATION_MIN = 1
+// Prototype/preview builds (VITE_WITNESS_PREVIEW=1) use 1 so the owner sees
+// their own submission while toying; all other builds require 3.
+// VITE_CORROBORATION_ONE=1 is a separate test/dev override that keeps min=1
+// without enabling the full WITNESS_ENABLED flag (set in vite.config test.env).
+// ponytail: single-expression guard; upgrade to env-config if more tiers needed
+export const CORROBORATION_MIN =
+ import.meta.env.VITE_WITNESS_PREVIEW === '1' ||
+ import.meta.env.VITE_CORROBORATION_ONE === '1'
+ ? 1
+ : 3
const STORE_KEY = 'bohosluzby:massFeedback'
const SUGGEST_KEY = 'bohosluzby:tagSuggestions'
@@ -56,25 +62,37 @@ export interface ChurchAggregate {
// In-memory rollup cache, filled by loadAggregates(), read synchronously by
// aggregateFor(). Empty until a load resolves for that church.
const cache = new Map()
+// ponytail: generation counter — discard any loadAggregates response that
+// started before the most-recently-started call (prevents a slow pre-submit
+// fetch from overwriting a fast post-submit refresh).
+let loadGen = 0
interface Tally {
devices: Set
- counts: Map
+ /** chip id → set of deviceIds that submitted it; deduplicated so one device
+ * can't single-handedly reach CORROBORATION_MIN by submitting repeatedly. */
+ chipDevices: Map>
}
-const emptyTally = (): Tally => ({ devices: new Set(), counts: new Map() })
+const emptyTally = (): Tally => ({ devices: new Set(), chipDevices: new Map() })
const bump = (a: Tally, r: Row) => {
a.devices.add(r.deviceId)
- for (const id of r.chips) a.counts.set(id, (a.counts.get(id) ?? 0) + 1)
+ for (const id of r.chips) {
+ const devSet = a.chipDevices.get(id) ?? new Set()
+ devSet.add(r.deviceId)
+ a.chipDevices.set(id, devSet)
+ }
}
+/** Locked display order of the chips — the tie-breaker when counts match. */
+const CHIP_ORDER = new Map(WITNESS_CHIPS.map((c, i) => [c.id, i]))
+
/** A Tally → Aggregate: chips over the corroboration floor, ordered by frequency
* (most-mentioned first; ties keep the locked display order for stability). */
function roll(key: string, a: Tally): Aggregate {
- const order = new Map(WITNESS_CHIPS.map((c, i) => [c.id, i]))
const chips = WITNESS_CHIPS.map((c) => c.id)
- .filter((id) => (a.counts.get(id) ?? 0) >= CORROBORATION_MIN)
- .map((id) => ({ id, count: a.counts.get(id)! }))
- .sort((x, y) => y.count - x.count || order.get(x.id)! - order.get(y.id)!)
+ .filter((id) => (a.chipDevices.get(id)?.size ?? 0) >= CORROBORATION_MIN)
+ .map((id) => ({ id, count: a.chipDevices.get(id)!.size }))
+ .sort((x, y) => y.count - x.count || CHIP_ORDER.get(x.id)! - CHIP_ORDER.get(y.id)!)
return { massKey: key, witnesses: a.devices.size, chips }
}
@@ -108,6 +126,7 @@ function aggregate(rows: Row[]): Map {
export async function loadAggregates(churchIds: string[]): Promise {
const ids = [...new Set(churchIds)].filter(Boolean)
if (ids.length === 0) return
+ const gen = ++loadGen // capture before any await
let rows: Row[]
if (supabase) {
const { data, error } = await supabase
@@ -115,7 +134,11 @@ export async function loadAggregates(churchIds: string[]): Promise {
.select('church_id,mass_key,device_id,chips')
.eq('status', 'visible')
.in('church_id', ids)
+ // ponytail: 1000 row cap; add cursor pagination when a single viewport
+ // regularly exceeds this (≈333 churches × 3 submissions each).
+ .limit(1000)
if (error) return // leave the cache as-is; the UI just shows no line
+ if (gen !== loadGen) return // a newer call started while we awaited; discard
rows = (data ?? []).map((d) => ({
churchId: d.church_id as string,
massKey: d.mass_key as string,
@@ -169,8 +192,12 @@ export function submitFeedback(submission: MassFeedback): void {
},
})
.then(
- () => void loadAggregates([row.churchId]), // refresh the church after a submit
- () => {},
+ ({ error }) => {
+ // functions.invoke resolves (not rejects) even on function errors;
+ // only refresh when the submit actually landed in the DB.
+ if (!error) void loadAggregates([row.churchId])
+ },
+ () => {}, // network-level rejection: localStorage record remains as-is
)
} else {
void loadAggregates([row.churchId])
@@ -183,6 +210,12 @@ export function aggregateFor(churchId: string): ChurchAggregate {
return cache.get(churchId) ?? emptyChurchAggregate(churchId)
}
+/** True iff loadAggregates has settled for this church (even if it has no witnesses).
+ * M8: lets the map distinguish "no witnesses loaded yet" from "no witnesses exist". */
+export function hasAggregate(churchId: string): boolean {
+ return cache.has(churchId)
+}
+
/** Rank a church's chips by corroboration × distinctiveness and keep the top
* `max`. Distinctiveness down-weights a tag that is common across all currently
* loaded churches, so "rodinná atmosféra" everywhere counts for less than a tag
@@ -199,10 +232,9 @@ export function rankDistinctive(
if (corpus.length < 2) return target.slice(0, max)
const prevalence = new Map()
for (const chips of corpus) for (const c of chips) prevalence.set(c.id, (prevalence.get(c.id) ?? 0) + 1)
- const order = new Map(WITNESS_CHIPS.map((c, i) => [c.id, i]))
const weight = (c: { id: string; count: number }) => c.count / (1 + (prevalence.get(c.id) ?? 0))
return [...target]
- .sort((a, b) => weight(b) - weight(a) || b.count - a.count || order.get(a.id)! - order.get(b.id)!)
+ .sort((a, b) => weight(b) - weight(a) || b.count - a.count || CHIP_ORDER.get(a.id)! - CHIP_ORDER.get(b.id)!)
.slice(0, max)
}
diff --git a/src/lib/geo.ts b/src/lib/geo.ts
index 93cbfa0..fbdefdf 100644
--- a/src/lib/geo.ts
+++ b/src/lib/geo.ts
@@ -45,10 +45,12 @@ export async function getPermissionState(): Promise {
export async function getCurrentPosition(
opts: { timeout?: number; maximumAge?: number; deadlineMs?: number } = {},
): Promise {
- const deadline = new Promise((resolve) =>
- setTimeout(() => resolve({ coords: null, error: 'deadline' }), opts.deadlineMs ?? 10_000),
- )
+ let deadlineTimer: ReturnType
+ const deadline = new Promise((resolve) => {
+ deadlineTimer = setTimeout(() => resolve({ coords: null, error: 'deadline' }), opts.deadlineMs ?? 10_000)
+ })
const result = await Promise.race([deadline, read(opts)])
+ clearTimeout(deadlineTimer!)
if (result.error) {
// fire-and-forget telemetry: which failure class do real devices hit?
try {
diff --git a/src/lib/native-actions.ts b/src/lib/native-actions.ts
index f7abf2f..744df36 100644
--- a/src/lib/native-actions.ts
+++ b/src/lib/native-actions.ts
@@ -2,8 +2,8 @@ import { isNative } from './native'
import { reminderTitle, t } from '../i18n'
import type { Church, ExtraService, Service } from '../domain/data'
import { buildICS } from '../domain/ics'
-import { nextReminderAt, pragueToday } from '../domain/occurrences'
-import { parseNote } from '../domain/notes'
+import { nextReminderAt } from '../domain/occurrences'
+import { noteRunsOn } from '../domain/notes'
import { recordExpectedAttendance } from './feedbackLedger'
import { massKey, occurrenceOf } from '../domain/feedback'
@@ -12,9 +12,6 @@ export const REMINDER_LEAD_MIN = 30
type AnyService = Service | ExtraService
-const specOf = (s: AnyService) =>
- 'days' in s ? { days: s.days, time: s.time } : { date: s.date, time: s.time }
-
const icsName = (church: Church, s: AnyService) =>
`bohosluzby-${church.id}-${s.time.replace(':', '')}.ics`
@@ -70,11 +67,9 @@ export type ReminderResult = 'scheduled' | 'denied' | 'no-upcoming' | 'unsupport
* scheduling a reminder for a mass that provably doesn't happen.
*/
export function reminderTimeFor(service: AnyService, now: Date): Date | null {
- const rule = parseNote(service.note)
- return nextReminderAt(specOf(service), now, REMINDER_LEAD_MIN, 366, (start) => {
- const w = pragueToday(start)
- return rule.runsOn(w.y, w.m, w.d)
- })
+ return nextReminderAt(service, now, REMINDER_LEAD_MIN, 366, (start) =>
+ noteRunsOn(service.note, start),
+ )
}
/**
@@ -130,7 +125,7 @@ export async function scheduleMassReminder(
}
/** Light impact on native taps; silent no-op on web. */
-export async function tapFeedback(): Promise {
+async function tapFeedback(): Promise {
if (!isNative) return
try {
const { Haptics, ImpactStyle } = await import('@capacitor/haptics')
diff --git a/vite.config.ts b/vite.config.ts
index 7f2664d..32ab5bb 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -65,5 +65,8 @@ export default defineConfig({
setupFiles: ['./vitest.setup.ts'],
css: true,
include: ['src/**/*.{test,spec}.{ts,tsx}', 'data/**/*.test.mjs'],
+ // VITE_CORROBORATION_ONE=1 keeps CORROBORATION_MIN=1 in tests (prototype semantics)
+ // without enabling WITNESS_ENABLED (that's gated on VITE_WITNESS_PREVIEW/ENABLED).
+ env: { VITE_CORROBORATION_ONE: '1' },
},
})
|
+ {t('partial_data')} +
+ )} {!dataError && route.view === 'church' && index && ({t('nothing_nearby_title')}
@@ -909,6 +914,7 @@ export default function App() { onChange={updateFilters} langs={langs} onReset={resetAll} + clockTick={clockTick} /> {/* not on a live fix (offline / last-known / picked city): search is the main CTA — a visible input-shaped button, not a buried "změnit" link */} @@ -949,6 +955,7 @@ export default function App() { onOpen={openChurch} onNavigate={setNavTarget} fill={mapMode} + reloadKey={reloadKey} /> @@ -970,7 +977,7 @@ export default function App() { onNavigate={setNavTarget} /> {/* the cap is honest: another page of the ordo instead of "evening ends at 18:00" */} - {day === 'now' && rows.length >= listLimit && ( + {(day === 'now' || witnessTags.length > 0) && rows.length >= listLimit && (
- {seasonLabel(season.season)}
+ {t(`season_${season.season}`)}
{' · '}
{lang() === 'cs' ? 'Data: rejstřík' : 'Data: registry'}{' '}
@@ -1057,8 +1064,8 @@ export default function App() {
// The day rubric of the ordo, as a picker: which page are you reading?
// Active day is set in rubric red — day labels are rubrics in a missal.
-function DayPicker({ day, onChange }: { day: DayChoice; onChange: (d: DayChoice) => void }) {
- const options = useMemo(() => dayOptions(new Date()), [])
+function DayPicker({ day, onChange, clockTick = 0 }: { day: DayChoice; onChange: (d: DayChoice) => void; clockTick?: number }) {
+ const options = useMemo(() => dayOptions(new Date()), [clockTick])
// a bookmarked ?den= must not hide its own chip off-screen
const activeRef = useRef {t('day_group').toLowerCase()} {t('rubric_when')} {
- const { y, m, d } = pragueToday(new Date())
- return `${y}-${String(m).padStart(2, '0')}-${String(d).padStart(2, '0')}`
-}
+const isoToday = (): string => pragueIsoDate(new Date())
/** Per-service actions: add to calendar (native share sheet / web download) and,
* on native only, schedule a local reminder before the next occurrence. */
@@ -306,6 +303,8 @@ export function ChurchDetail({
const [failed, setFailed] = useState(false)
const [navOpen, setNavOpen] = useState(false)
const [photo, setPhoto] = useState
{t('photo_credit_prefix')}{' '}
- {[photo.credit.split(' (')[0].trim(), photo.license, 'Wikimedia Commons']
+ {[heroPhoto.credit.split(' (')[0].trim(), heroPhoto.license, 'Wikimedia Commons']
.filter(Boolean)
.join(' · ')}
@@ -786,16 +784,9 @@ function ServiceRow({
// Uncertain notes never mute either — they already print loud instead.
const pausedNow = (() => {
if (!s.note) return false
- const rule = parseNote(s.note)
- if (rule.uncertain) return false
- const upcoming = nextOccurrences({ days: s.days, time: s.time }, new Date(), 35)
- return (
- upcoming.length > 0 &&
- upcoming.every((start) => {
- const w = pragueToday(start)
- return !rule.runsOn(w.y, w.m, w.d)
- })
- )
+ if (noteUncertain(s.note)) return false
+ const upcoming = nextOccurrences(s, new Date(), 35)
+ return upcoming.length > 0 && upcoming.every((start) => !noteRunsOn(s.note, start))
})()
return (