feat: initial make-space full-stack release with weighted multi-provider LLM and Dockerfile

This commit is contained in:
dahyeon committed 2026-11-04 20:49:24 +09:00
commit 37b323c9ac
55 files changed
+17087

No files matched your search

+300
View File
@@ -0,0 +1,300 @@
use crate::{
discovery::DiscoveryState, get_place_view, scene_bridge, trigger_reanalyze, ui_bridge,
workspace::WorkspaceView, Icon,
};
use domain::JobEvent;
use leptos::prelude::*;
use leptos_router::hooks::{use_params_map, use_query_map};
pub(crate) fn return_destination(value: Option<&str>) -> String {
match value {
Some("/recent") => "/recent".into(),
Some(value)
if (value == "/" || value.starts_with("/?q="))
&& value.len() <= 4096
&& !value.contains(['\r', '\n', '#']) =>
{
value.into()
}
_ => "/".into(),
}
}
#[component]
pub(crate) fn PlacePage() -> impl IntoView {
let params = use_params_map();
view! { {move || {
let id = params.read().get("id").unwrap_or_default();
view! { <PlaceDetail place_id=id/> }
}} }
}
#[component]
fn PlaceDetail(place_id: String) -> impl IntoView {
let discovery = use_context::<DiscoveryState>();
let query = use_query_map();
let initial_job = query.read_untracked().get("job");
let id = StoredValue::new(place_id);
let active_job = RwSignal::new(initial_job);
let events = RwSignal::new(Vec::<JobEvent>::new());
let settled_jobs = RwSignal::new(Vec::<String>::new());
let refresh_tick = RwSignal::new(0u32);
let pending = RwSignal::new(false);
let analysis_error = RwSignal::new(None::<&'static str>);
let copy_status = RwSignal::new(String::new());
let back = Memo::new(move |_| return_destination(query.read().get("from").as_deref()));
let place_res = Resource::new(
move || refresh_tick.get(),
move |_| get_place_view(id.get_value()),
);
Effect::new(move |_| {
if let Some(Ok(Some(place))) = place_res.get() {
if active_job.get_untracked().is_none() {
if let Some(job) = place.running_job {
if !settled_jobs.get_untracked().contains(&job) {
active_job.set(Some(job));
}
}
}
}
});
Effect::new(move |_| {
let Some(job) = active_job.get() else {
return;
};
events.set(Vec::new());
analysis_error.set(None);
let subscribed_job = job.clone();
let subscription = scene_bridge::subscribe_job_events(&job, move |event| {
let terminal = event.is_terminal();
let succeeded = matches!(event, JobEvent::Done { .. });
if matches!(event, JobEvent::Error { .. }) {
analysis_error.set(Some("분석을 완료하지 못했습니다. 다시 시도해 주세요."));
}
events.update(|all| all.push(event));
if terminal {
settled_jobs.update(|all| all.push(subscribed_job.clone()));
active_job.set(None);
ui_bridge::clear_job_query();
if succeeded {
if let Some(state) = discovery {
state.invalidate_recent();
}
refresh_tick.update(|n| *n += 1);
}
}
});
#[cfg(feature = "hydrate")]
if subscription.is_none() {
analysis_error.set(Some(
"분석 진행 상태에 연결하지 못했습니다. 다시 시도해 주세요.",
));
settled_jobs.update(|all| all.push(job));
active_job.set(None);
}
on_cleanup(move || {
if let Some(handle) = subscription {
scene_bridge::close_job_events(handle);
}
});
});
let analyze = Action::new(move |_: &()| async move {
if pending.get_untracked() || active_job.get_untracked().is_some() {
return;
}
pending.set(true);
analysis_error.set(None);
ui_bridge::close_menu("place-menu");
match trigger_reanalyze(id.get_value()).await {
Ok(job) => {
if let Some(state) = discovery {
state.invalidate_recent();
}
active_job.set(Some(job));
}
Err(_) => analysis_error.set(Some(
"분석을 시작하지 못했습니다. 잠시 후 다시 시도해 주세요.",
)),
}
pending.set(false);
});
view! {
<div class="place-page">
<Transition fallback=|| view! { <div class="loading-box" role="status">"장소를 불러오는 중…"</div> }>
{move || place_res.get().map(|result| match result {
Ok(Some(place)) => {
let address = if place.place.road_address.is_empty() { place.place.address.clone() } else { place.place.road_address.clone() };
let copy_address = address.clone();
let parcel_address = (!place.place.road_address.is_empty()
&& !place.place.address.is_empty()
&& place.place.address != place.place.road_address)
.then(|| place.place.address.clone());
let has_layout = place.layout.is_some();
view! {
<header class="place-header">
<a class="back-link icon-button" href=move || back.get()
aria-label=move || if back.get() == "/recent" { "분석 완료 목록으로 돌아가기" } else { "검색 결과로 돌아가기" }
on:click=move |_| { if let Some(state) = discovery { if back.get().starts_with("/?q=") { state.search_href.set(back.get()); } } }>
<Icon name="back"/>
</a>
<div class="place-title-row"><h1>{place.place.name.clone()}</h1></div>
<details class="place-menu" id="place-menu">
<summary class="icon-button" aria-label="장소 메뉴"><Icon name="more"/></summary>
<div class="place-menu-content">
<p class="menu-category">{place.place.category.clone()}</p>
<p class="place-addr">{address}</p>
<button type="button" class="menu-action" on:click=move |_| {
ui_bridge::copy_text(&copy_address, move |ok| copy_status.set(if ok { "주소를 복사했습니다." } else { "주소를 복사하지 못했습니다. 위 주소를 길게 눌러 복사해 주세요." }.into()));
}><Icon name="copy"/>"주소 복사"</button>
{parcel_address.map(|address| {
let copy_parcel = address.clone();
view! {
<p class="place-addr"><span class="address-kind">"지번 "</span>{address}</p>
<button type="button" class="menu-action" on:click=move |_| {
ui_bridge::copy_text(&copy_parcel, move |ok| copy_status.set(if ok { "지번 주소를 복사했습니다." } else { "주소를 복사하지 못했습니다. 위 주소를 길게 눌러 복사해 주세요." }.into()));
}><Icon name="copy"/>"지번 주소 복사"</button>
}
})}
<p class="copy-status" role="status">{move || copy_status.get()}</p>
{(!place.place.phone.is_empty()).then(|| view! { <a class="menu-action" href=format!("tel:{}", place.place.phone)>"전화 "{place.place.phone.clone()}</a> })}
{(!place.place.place_url.is_empty()).then(|| view! { <a class="menu-action" href=place.place.place_url.clone() target="_blank" rel="noreferrer">"장소 원문 보기"<Icon name="external"/></a> })}
<button type="button" class="menu-action" disabled=move || pending.get() || active_job.get().is_some()
on:click=move |_| { analyze.dispatch(()); }><Icon name="refresh"/>{move || if pending.get() { "분석 요청 중…" } else if active_job.get().is_some() { "분석 진행 중" } else if has_layout { "다시 분석" } else { "분석 시작" }}</button>
</div>
</details>
</header>
{move || analysis_error.get().map(|message| view! {
<div class="alert-error analysis-error" role="alert"><p>{message}</p>
<button type="button" class="btn-secondary" disabled=move || pending.get() || active_job.get().is_some() on:click=move |_| { analyze.dispatch(()); }>"다시 시도"</button>
</div>
})}
{move || active_job.get().is_some().then(|| view! { <ProgressPanel events=events/> })}
{match place.layout.clone() {
Some(layout) => view! { <WorkspaceView layout=layout photos=place.photos.clone()/> }.into_any(),
None => view! {
<Show when=move || active_job.get().is_none() fallback=|| view! {
<div class="analysis-placeholder"><p>"분석이 끝나면 공간 배치와 사진이 표시됩니다."</p><a href="/recent">"분석 완료된 장소 보기"</a></div>
}>
<div class="recent-empty">
<h2>"아직 공간 정보가 없습니다."</h2>
<p>"장소 사진을 분석하면 공간 배치와 좌석 정보를 확인할 수 있습니다."</p>
<button type="button" class="btn-primary" disabled=move || pending.get() on:click=move |_| { analyze.dispatch(()); }>{move || if pending.get() { "요청 중…" } else { "분석 시작" }}</button>
</div>
</Show>
}.into_any(),
}}
}.into_any()
},
Ok(None) => view! { <div class="recent-empty"><h1>"장소를 찾을 수 없습니다."</h1><a href=move || back.get() class="btn-primary">"목록으로 돌아가기"</a></div> }.into_any(),
Err(_) => view! { <div class="alert-error" role="alert"><p>"장소를 불러오지 못했습니다."</p><button type="button" class="btn-secondary" on:click=move |_| refresh_tick.update(|n| *n += 1)>"다시 시도"</button><a href=move || back.get() class="btn-secondary">"목록으로 돌아가기"</a></div> }.into_any(),
})}
</Transition>
</div>
}
}
fn progress_phase(events: &[JobEvent]) -> usize {
if events
.iter()
.any(|event| matches!(event, JobEvent::Done { .. }))
{
2
} else if events.iter().any(|event| {
matches!(
event,
JobEvent::Classified { .. }
| JobEvent::FloorsDetected { .. }
| JobEvent::LayoutDraft { .. }
)
}) {
1
} else {
0
}
}
fn progress_detail(event: &JobEvent) -> Option<String> {
match event {
JobEvent::PlaceResolved { .. } => Some("장소를 확인했습니다.".into()),
JobEvent::SourceDone {
source,
photos,
error,
..
} => Some(if error.is_some() {
format!("{}의 일부 자료를 가져오지 못했습니다.", source.label())
} else {
format!("{} 사진 {}장을 확인했습니다.", source.label(), photos)
}),
JobEvent::PhotosStored { stored, .. } => Some(format!("사진 {}장을 준비했습니다.", stored)),
JobEvent::Classified {
interior, exterior, ..
} => Some(format!(
"실내 사진 {}장 · 외관 사진 {}장을 확인했습니다.",
interior, exterior
)),
JobEvent::FloorsDetected { floors } => {
Some(format!("{}개 층 후보를 검토하고 있습니다.", floors.len()))
}
JobEvent::LayoutDraft { .. } => {
Some("사진을 바탕으로 공간 배치를 구성하고 있습니다.".into())
}
_ => None,
}
}
#[component]
fn ProgressPanel(events: RwSignal<Vec<JobEvent>>) -> impl IntoView {
view! {
<section class="progress-panel" aria-label="분석 진행 상태">
<div class="progress-head" role="status" aria-live="polite"><span class="spinner"></span><strong>{move || if progress_phase(&events.get()) == 0 { "사진과 리뷰를 확인하고 있습니다" } else { "공간 배치를 구성하고 있습니다" }}</strong></div>
<ol class="progress-steps">{["자료 수집", "공간 분석", "완료"].into_iter().enumerate().map(|(index, label)| view! {
<li class=move || { if progress_phase(&events.get()) > index { "complete" } else { "" } } aria-current=move || (progress_phase(&events.get()) == index).then_some("step")>{label}</li>
}).collect_view()}</ol>
<details class="progress-details"><summary>"진행 내용"</summary><ul>{move || events.get().iter().filter_map(progress_detail).map(|message| view! { <li>{message}</li> }).collect_view()}</ul></details>
</section>
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn return_paths_stay_in_known_local_views() {
assert_eq!(return_destination(Some("/recent")), "/recent");
assert_eq!(
return_destination(Some("/?q=%EC%84%B1%EC%88%98")),
"/?q=%EC%84%B1%EC%88%98"
);
for value in [
"//evil.example",
"https://evil.example",
"/place/x",
"/?q=x\n",
"/?q=x#photo",
] {
assert_eq!(return_destination(Some(value)), "/");
}
}
#[test]
fn phases_follow_actual_events_without_inventing_percentage() {
assert_eq!(progress_phase(&[]), 0);
assert_eq!(progress_phase(&[JobEvent::LayoutDraft { attempt: 2 }]), 1);
assert_eq!(
progress_phase(&[JobEvent::Done {
place_id: "x".into()
}]),
2
);
assert_eq!(
progress_detail(&JobEvent::Log {
message: "internal p_123".into()
}),
None
);
}
}
+549
View File
@@ -0,0 +1,549 @@
//! Search and saved-analysis discovery. State belongs to the app so opening a
//! place does not discard the list that led to it.
use crate::{encode_path_segment, get_recent_places, search_places, select_place, Icon};
use domain::{PlaceCandidate, RecentPlace};
use leptos::prelude::*;
use leptos_router::hooks::{use_location, use_navigate, use_query_map};
#[derive(Clone, Copy)]
pub(crate) struct DiscoveryState {
pub draft: RwSignal<String>,
pub search_href: RwSignal<String>,
applied_query: RwSignal<String>,
cached_search: RwSignal<Option<(String, Vec<PlaceCandidate>)>>,
cached_recent: RwSignal<Option<Vec<RecentPlace>>>,
restore_search: RwSignal<bool>,
restore_recent: RwSignal<bool>,
reuse_recent: RwSignal<bool>,
}
impl Default for DiscoveryState {
fn default() -> Self {
Self {
draft: RwSignal::new(String::new()),
search_href: RwSignal::new("/".to_string()),
applied_query: RwSignal::new(String::new()),
cached_search: RwSignal::new(None),
cached_recent: RwSignal::new(None),
restore_search: RwSignal::new(false),
restore_recent: RwSignal::new(false),
reuse_recent: RwSignal::new(false),
}
}
}
impl DiscoveryState {
/// Set the return intent before routing starts; disposal can run after the
/// destination's first effect and is too late as the only signal source.
pub(crate) fn remember_scroll(self, pathname: &str) {
crate::ui_bridge::save_scroll(pathname);
match pathname {
"/" => self.restore_search.set(true),
"/recent" => self.restore_recent.set(true),
_ => {}
}
}
/// Call when an analysis starts or finishes so returning to its source list
/// does not reuse a snapshot from before the analysis.
pub(crate) fn invalidate_recent(self) {
self.cached_recent.set(None);
}
}
/// RFC 3986 query component encoding; in particular, nested return URLs must
/// encode their `?`, `&`, `+`, and `=` delimiters instead of becoming parameters.
pub(crate) fn encode_query_component(value: &str) -> String {
use std::fmt::Write;
value.bytes().fold(String::new(), |mut encoded, byte| {
if byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.' | b'~') {
encoded.push(byte as char);
} else {
let _ = write!(encoded, "%{byte:02X}");
}
encoded
})
}
pub(crate) fn search_href(query: &str) -> String {
let query = query.trim();
if query.is_empty() {
"/".to_string()
} else {
format!("/?q={}", encode_query_component(query))
}
}
#[component]
pub(crate) fn HomePage() -> impl IntoView {
let state = expect_context::<DiscoveryState>();
// An outgoing click sets the app's return intent before native link
// navigation runs. Only the next mounted page may consume that intent.
let (restore_on_entry, set_restore_on_entry) = signal(state.restore_search.get_untracked());
let params = use_query_map();
let location = use_location();
let location_search = location.search;
let pathname = location.pathname;
let initial_query = params
.get_untracked()
.get("q")
.unwrap_or_default()
.trim()
.to_string();
if state.applied_query.get_untracked() != initial_query {
state.draft.set(initial_query.clone());
state.applied_query.set(initial_query.clone());
}
state.search_href.set(search_href(&initial_query));
// Topbar records the actual position before navigation. Only mark it here:
// saving during disposal can overwrite it after the router scrolls to top.
#[cfg(feature = "hydrate")]
on_cleanup(move || state.restore_search.set(true));
let submitted = Memo::new(move |_| {
params
.read()
.get("q")
.unwrap_or_default()
.trim()
.to_string()
});
let (refresh, set_refresh) = signal(0u32);
let (selecting, set_selecting) = signal(Option::<String>::None);
let (selection_error, set_selection_error) = signal(false);
let (last_selection, set_last_selection) = signal(Option::<PlaceCandidate>::None);
let (search_pending, set_search_pending) = signal(false);
let navigate = use_navigate();
Effect::new(move |_| {
let query = submitted.get();
// Do not replace an unsubmitted draft when returning from a place.
if state.applied_query.get_untracked() != query {
state.draft.set(query.clone());
state.applied_query.set(query.clone());
}
state.search_href.set(search_href(&query));
});
let search_res = Resource::new(
move || (submitted.get(), refresh.get()),
move |(query, refresh)| async move {
if query.trim().is_empty() {
return Ok(Vec::new());
}
if refresh == 0 {
if let Some((cached_query, list)) = state.cached_search.get_untracked() {
if cached_query == query {
return Ok(list);
}
}
}
let result = search_places(query.clone()).await;
if let Ok(list) = &result {
state.cached_search.set(Some((query, list.clone())));
}
result
},
);
// The existing API provides up to 50 positively identified analyses. An
// absent ID is intentionally left unlabelled, rather than called "new".
let analyzed_res = Resource::new(
|| (),
move |_| async move {
// Refresh these small status summaries on each visit. An analysis
// may have completed while this search route was not mounted.
let result = get_recent_places().await;
if let Ok(list) = &result {
state.cached_recent.set(Some(list.clone()));
}
result
},
);
Effect::new(move |_| {
// The ready-status resource is also read inside the results Transition.
// Cached results alone do not mean its DOM has enough height to restore.
if pathname.get() == "/"
&& matches!(search_res.get(), Some(Ok(_)))
&& analyzed_res.get().is_some()
&& !search_pending.get()
&& restore_on_entry.get()
{
let search = location_search.get_untracked();
let destination = if search.is_empty() {
"/".into()
} else {
format!("/?{search}")
};
crate::ui_bridge::restore_scroll(&destination);
set_restore_on_entry.set(false);
state.restore_search.set(false);
}
});
let nav_select = navigate.clone();
let pick_action = Action::new(move |candidate: &PlaceCandidate| {
let candidate = candidate.clone();
let nav = nav_select.clone();
let from = search_href(&submitted.get_untracked());
async move {
set_selecting.set(Some(candidate.place_id()));
set_last_selection.set(Some(candidate.clone()));
set_selection_error.set(false);
match select_place(candidate, false).await {
Ok((place_id, job)) => {
state.remember_scroll("/");
let mut href = format!(
"/place/{}?from={}",
encode_path_segment(&place_id),
encode_query_component(&from)
);
if let Some(job_id) = job {
state.invalidate_recent();
href.push_str("&job=");
href.push_str(&encode_query_component(&job_id));
}
nav(&href, Default::default());
}
Err(_) => {
set_selection_error.set(true);
set_selecting.set(None);
}
}
}
});
let nav_submit = navigate.clone();
let submit = move || {
let query = state.draft.get_untracked().trim().to_string();
if query.is_empty() || selecting.get_untracked().is_some() {
return;
}
state.draft.set(query.clone());
state.search_href.set(search_href(&query));
state.restore_search.set(false);
set_selection_error.set(false);
crate::ui_bridge::blur_active();
if submitted.get_untracked() == query {
set_refresh.update(|tick| *tick += 1);
} else {
set_refresh.set(0);
nav_submit(&search_href(&query), Default::default());
}
};
view! {
<div class="home-wrap discovery-home" data-has-results=move || (!submitted.get().is_empty()).to_string()>
<div class="search-column">
<Show when=move || submitted.get().is_empty()>
<div class="page-heading discovery-intro">
<h1>"장소 검색"</h1>
<p>"상호명 또는 주소를 입력하세요."</p>
</div>
</Show>
<section class="search-panel" aria-label="장소 검색 입력">
<form class="search-bar" role="search" on:submit=move |ev| {
ev.prevent_default();
submit();
}>
<div class="search-field">
<Icon name="search"/>
<input
id="place-search-input"
type="search" name="q" enterkeyhint="search"
autocapitalize="none" autocomplete="off" spellcheck="false"
aria-label="상호명 또는 주소" class="search-input"
placeholder="상호명 또는 주소"
prop:value=move || state.draft.get()
on:input=move |ev| state.draft.set(event_target_value(&ev))
/>
<Show when=move || !state.draft.get().is_empty()>
<button type="button" class="search-clear" aria-label="검색어 지우기"
on:click=move |_| { state.draft.set(String::new()); crate::ui_bridge::focus_search(); }>
<Icon name="close"/>
</button>
</Show>
</div>
<button type="submit" class="btn-primary"
disabled=move || state.draft.get().trim().is_empty() || selecting.get().is_some()>"검색"</button>
</form>
<Show when=move || submitted.get().is_empty()>
<div class="quick-row">
<span class="quick-label">"검색 예시"</span>
{["성수 대림창고", "어니언 성수", "블루보틀 성수"].into_iter().map(|query| {
let nav = navigate.clone();
view! {
<button type="button" class="chip" on:click=move |_| {
state.draft.set(query.to_string());
state.search_href.set(search_href(query));
state.restore_search.set(false);
set_selection_error.set(false);
set_refresh.set(0);
crate::ui_bridge::blur_active();
nav(&search_href(query), Default::default());
}>{query}</button>
}
}).collect_view()}
</div>
</Show>
</section>
</div>
<div class="results-column">
<Show when=move || selection_error.get()>
<div class="alert-error retry-row" role="alert">
<p>"장소를 열지 못했습니다. 잠시 후 다시 시도해 주세요."</p>
<button type="button" class="btn-secondary" disabled=move || selecting.get().is_some()
on:click=move |_| { if let Some(candidate) = last_selection.get() { pick_action.dispatch(candidate); } }>"다시 시도"</button>
</div>
</Show>
<section class="search-results" aria-label="장소 검색 결과" aria-busy=move || search_pending.get().to_string()>
<Show when=move || !submitted.get().trim().is_empty()>
<div class="results-heading">
<h1 class="results-title">"검색 결과"</h1>
<span class="results-count" role="status" aria-live="polite">
<Suspense fallback=|| "검색 중…">
{move || if search_pending.get() { "검색 중…".to_string() } else {
search_res.get().and_then(Result::ok).map(|list| format!("{}개", list.len())).unwrap_or_default()
}}
</Suspense>
</span>
</div>
<Show when=move || state.draft.get().trim() != submitted.get()>
<p class="applied-query">{move || format!("‘{}’ 검색 결과입니다. 변경한 검색어는 검색을 눌러 적용하세요.", submitted.get())}</p>
</Show>
</Show>
<Transition set_pending=set_search_pending fallback=move || view! {
<div class="loading-box" role="status"><span class="spinner"></span>"장소를 찾는 중…"</div>
}>
{move || search_res.get().map(|result| match result {
Ok(list) if list.is_empty() && !submitted.get().trim().is_empty() => view! {
<div class="empty-box">
<p>"검색 결과가 없습니다."</p>
<p>"지점명이나 도로명 주소로 다시 검색해 주세요."</p>
</div>
}.into_any(),
Ok(list) => view! {
<div class="candidate-list">
{list.into_iter().map(|candidate| {
let place_id = candidate.place_id();
let selecting_id = place_id.clone();
let ready_id = place_id.clone();
let status_id = place_id.clone();
let address = if candidate.road_address.is_empty() { candidate.address.clone() } else { candidate.road_address.clone() };
let aria_name = format!("{} · {} 공간 보기", candidate.name, address);
let for_click = candidate.clone();
view! {
<button type="button" class="candidate-row" aria-label=aria_name
disabled=move || selecting.get().is_some() || search_pending.get()
aria-busy=move || (selecting.get().as_deref() == Some(selecting_id.as_str())).to_string()
on:click=move |_| { pick_action.dispatch(for_click.clone()); }>
<span class="candidate-copy">
<span class="candidate-title-line"><span class="candidate-name">{candidate.name}</span></span>
<span class="candidate-category">{candidate.category}</span>
<span class="candidate-addr">{address}</span>
<span class="candidate-state">
<Show when=move || analyzed_res.get().and_then(Result::ok).is_some_and(|places| places.iter().any(|entry| entry.place.id == ready_id))>
<span class="candidate-status">"분석 완료"</span>
</Show>
{move || (selecting.get().as_deref() == Some(status_id.as_str())).then_some("장소를 여는 중…")}
</span>
</span>
<span class="candidate-arrow" aria-hidden="true">"›"</span>
</button>
}
}).collect_view()}
</div>
}.into_any(),
Err(_) => view! {
<div class="alert-error retry-row" role="alert">
<p>"검색 결과를 불러오지 못했습니다. 연결을 확인하고 다시 시도해 주세요."</p>
<button type="button" class="btn-secondary" on:click=move |_| set_refresh.update(|tick| *tick += 1)>"다시 시도"</button>
</div>
}.into_any(),
})}
</Transition>
</section>
<details class="discovery-help" id="how-it-works">
<summary>"이용 방법"</summary>
<ol>
<li>"장소를 검색하고 목록에서 선택합니다."</li>
<li>"분석된 공간의 층별 구조와 좌석 배치를 확인합니다."</li>
<li>"사진 핀이나 구역을 눌러 해당 사진을 봅니다."</li>
</ol>
<p>"사진과 리뷰로 추정한 결과로, 실제 배치와 다를 수 있습니다."</p>
</details>
</div>
</div>
}
}
#[component]
pub(crate) fn RecentPlacesPage() -> impl IntoView {
let state = expect_context::<DiscoveryState>();
let (restore_on_entry, set_restore_on_entry) = signal(state.restore_recent.get_untracked());
let reuse_on_entry = state.reuse_recent.get_untracked();
let pathname = use_location().pathname;
#[cfg(feature = "hydrate")]
on_cleanup(move || state.restore_recent.set(true));
let (refresh, set_refresh) = signal(0u32);
let (pending, set_pending) = signal(false);
let recent_res = Resource::new(
move || refresh.get(),
move |refresh| async move {
// Keep order only for a direct detail round trip. A tab visit must
// refresh the shared list even when its scroll position is restored.
if refresh == 0 && reuse_on_entry {
if let Some(list) = state.cached_recent.get_untracked() {
return Ok(list);
}
}
let result = get_recent_places().await;
if let Ok(list) = &result {
state.cached_recent.set(Some(list.clone()));
}
result
},
);
Effect::new(move |_| {
if pathname.get() == "/recent"
&& matches!(recent_res.get(), Some(Ok(_)))
&& !pending.get()
&& restore_on_entry.get()
{
crate::ui_bridge::restore_scroll("/recent");
set_restore_on_entry.set(false);
state.restore_recent.set(false);
state.reuse_recent.set(false);
}
});
view! {
<div class="recent-page">
<div class="recent-heading">
<div class="page-heading">
<h1>"분석 완료"
<span class="recent-title-count" role="status" aria-live="polite">
<Suspense fallback=|| ()>
{move || recent_res.get().and_then(Result::ok).map(|places| format!(" {}", places.len()))}
</Suspense>
</span>
</h1>
<p>"공용 목록 · 최근 열어본 순"</p>
</div>
<button type="button" class="btn-secondary recent-refresh" disabled=move || pending.get()
aria-label=move || if pending.get() { "분석 완료 목록 새로고침 중" } else { "분석 완료 목록 새로고침" }
on:click=move |_| set_refresh.update(|tick| *tick += 1)>
<Icon name="refresh"/>
<span>{move || if pending.get() { "새로고침 중" } else { "새로고침" }}</span>
</button>
</div>
<section aria-label="분석 완료된 장소" aria-busy=move || pending.get().to_string()>
<Transition set_pending=set_pending fallback=|| view! {
<div class="loading-box" role="status"><span class="spinner"></span>"장소를 불러오는 중…"</div>
}>
{move || recent_res.get().map(|result| match result {
Ok(places) if places.is_empty() => view! {
<div class="recent-empty">
<h2>"아직 분석이 완료된 장소가 없습니다."</h2>
<p>"장소를 검색하고 분석을 마치면 여기에서 다시 볼 수 있습니다."</p>
<a href=move || state.search_href.get() class="btn-primary">"장소 검색"</a>
</div>
}.into_any(),
Ok(places) => {
let count = places.len();
view! {
<div class="recent-grid">
{places.into_iter().map(|entry| {
let place = entry.place;
let address = if place.road_address.is_empty() { place.address } else { place.road_address };
let floor_count = entry.floor_labels.len();
let analyzed_date = format_analysis_date(&entry.analyzed_at);
let aria_name = format!("{} · {} 공간 보기", place.name, address);
view! {
<a href=format!("/place/{}?from=%2Frecent", encode_path_segment(&place.id))
class="candidate-row recent-card"
aria-label=aria_name
on:click=move |_| {
state.remember_scroll("/recent");
state.reuse_recent.set(true);
}>
<span class="candidate-copy">
<span class="candidate-name">{place.name}</span>
<span class="candidate-category">{place.category}</span>
<span class="candidate-addr">{address}</span>
<span class="recent-meta">
{(floor_count > 0).then(|| view! { <span>{format!("추정 {}개 층", floor_count)}</span> })}
{(entry.seat_estimate > 0).then(|| view! { <span>{format!("약 {}석", entry.seat_estimate)}</span> })}
</span>
{analyzed_date.map(|date| view! { <span class="recent-date">{format!("분석 {date}")}</span> })}
</span>
<span class="candidate-arrow" aria-hidden="true">"›"</span>
</a>
}
}).collect_view()}
</div>
{(count == 50).then(|| view! { <p class="page-footnote">"최근 50개 장소를 표시합니다."</p> })}
}.into_any()
},
Err(_) => view! {
<div class="alert-error retry-row" role="alert">
<p>"장소 목록을 불러오지 못했습니다."</p>
<button type="button" class="btn-secondary" on:click=move |_| set_refresh.update(|tick| *tick += 1)>"다시 시도"</button>
</div>
}.into_any(),
})}
</Transition>
</section>
</div>
}
}
/// Display the supplied ISO calendar date without guessing the user's timezone.
/// Invalid/unknown timestamps are omitted rather than shown as a made-up date.
fn format_analysis_date(value: &str) -> Option<String> {
let date = value.get(..10)?;
let bytes = date.as_bytes();
if bytes[4] != b'-'
|| bytes[7] != b'-'
|| !bytes
.iter()
.enumerate()
.all(|(i, byte)| i == 4 || i == 7 || byte.is_ascii_digit())
{
return None;
}
let month = date[5..7].parse::<u8>().ok()?;
let day = date[8..10].parse::<u8>().ok()?;
if !(1..=12).contains(&month) || !(1..=31).contains(&day) {
return None;
}
Some(date.replace('-', "."))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn nested_return_url_encodes_delimiters_and_unicode() {
let search = search_href(" 카페 A&B+점 ");
assert_eq!(search, "/?q=%EC%B9%B4%ED%8E%98%20A%26B%2B%EC%A0%90");
let from = encode_query_component(&search);
assert!(from.starts_with("%2F%3Fq%3D"));
assert!(!from.contains('&'));
assert!(!from.contains('+'));
assert!(from.contains("%2526"));
assert_eq!(search_href(" "), "/");
}
#[test]
fn analysis_dates_handle_short_and_non_ascii_inputs() {
assert_eq!(
format_analysis_date("2026-11-04T09:00:00Z"),
Some("2026.11.04".to_string())
);
assert_eq!(format_analysis_date("미확인"), None);
assert_eq!(format_analysis_date("2026-99-12T09:00:00Z"), None);
assert_eq!(format_analysis_date(""), None);
}
}
+183
View File
@@ -0,0 +1,183 @@
#![recursion_limit = "256"]
mod detail;
mod discovery;
pub mod scene_bridge;
pub mod ui_bridge;
mod workspace;
use detail::PlacePage;
use discovery::{DiscoveryState, HomePage, RecentPlacesPage};
use domain::{PlaceCandidate, PlaceView, RecentPlace};
use leptos::prelude::*;
use leptos_meta::{provide_meta_context, MetaTags, Stylesheet, Title};
use leptos_router::components::{Route, Router, Routes};
use leptos_router::hooks::use_location;
use leptos_router::path;
/// HTML shell rendered on the server (`ssr`), including the ES-module import map for Three.js.
pub fn shell(options: LeptosOptions) -> impl IntoView {
let import_map = r#"{
"imports": {
"three": "/vendor/three/three.module.js",
"three/addons/controls/OrbitControls.js": "/vendor/three/OrbitControls.js"
}
}"#;
view! {
<!DOCTYPE html>
<html lang="ko">
<head>
<meta charset="utf-8"/>
<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover"/>
<meta name="theme-color" content="#f0f1f3"/>
<script type="importmap" inner_html=import_map></script>
<AutoReload options=options.clone()/>
<HydrationScripts options/>
<MetaTags/>
</head>
<body>
<App/>
</body>
</html>
}
}
// ============================================================================
// Server Functions
// ============================================================================
#[cfg(feature = "ssr")]
fn pipeline_ctx() -> Result<pipeline::Pipeline, ServerFnError> {
use_context::<pipeline::Pipeline>()
.ok_or_else(|| ServerFnError::new("Pipeline context missing"))
}
#[server(SearchPlaces, "/api")]
pub async fn search_places(query: String) -> Result<Vec<PlaceCandidate>, ServerFnError> {
let pl = pipeline_ctx()?;
pl.search_places(&query)
.await
.map_err(|e| ServerFnError::new(e.to_string()))
}
#[server(SelectPlace, "/api")]
pub async fn select_place(
candidate: PlaceCandidate,
force: bool,
) -> Result<(String, Option<String>), ServerFnError> {
let pl = pipeline_ctx()?;
pl.select_or_analyze(candidate, force)
.await
.map_err(|e| ServerFnError::new(e.to_string()))
}
#[server(GetPlaceView, "/api")]
pub async fn get_place_view(place_id: String) -> Result<Option<PlaceView>, ServerFnError> {
let pl = pipeline_ctx()?;
pl.get_place_view(&place_id)
.await
.map_err(|e| ServerFnError::new(e.to_string()))
}
#[server(TriggerReanalyze, "/api")]
pub async fn trigger_reanalyze(place_id: String) -> Result<String, ServerFnError> {
let pl = pipeline_ctx()?;
pl.reanalyze(&place_id)
.await
.map_err(|e| ServerFnError::new(e.to_string()))
}
#[server(GetRecentPlaces, "/api")]
pub async fn get_recent_places() -> Result<Vec<RecentPlace>, ServerFnError> {
pipeline_ctx()?
.recent_places()
.await
.map_err(|e| ServerFnError::new(e.to_string()))
}
// ============================================================================
// Root App & Router
// ============================================================================
#[component]
pub fn App() -> impl IntoView {
provide_meta_context();
provide_context(DiscoveryState::default());
view! {
<Stylesheet id="leptos" href="/pkg/make-space.css"/>
<Title text="Make-Space"/>
<Router>
<div class="app-shell">
<Topbar/>
<main class="main-body" id="main-content">
<Routes fallback=|| view! { <div class="empty-box">"페이지를 찾을 수 없습니다."</div> }>
<Route path=path!("") view=HomePage/>
<Route path=path!("/recent") view=RecentPlacesPage/>
<Route path=path!("/place/:id") view=PlacePage/>
</Routes>
</main>
</div>
</Router>
}
}
#[component]
fn Topbar() -> impl IntoView {
let pathname = use_location().pathname;
let state = expect_context::<DiscoveryState>();
view! {
<a class="skip-link" href="#main-content">"본문으로 이동"</a>
<Show when=move || !pathname.get().starts_with("/place/")>
<header class="topbar">
<a href=move || state.search_href.get() class="brand" aria-label="Make-Space 장소 검색" on:click=move |_| state.remember_scroll(&pathname.get())>
<span class="brand-mark"><Icon name="cube"/></span>
<span class="brand-title">"Make-Space"</span>
</a>
<nav class="topbar-nav" aria-label="주 메뉴">
<a href=move || state.search_href.get() on:click=move |_| state.remember_scroll(&pathname.get()) aria-current=move || (pathname.get() == "/").then_some("page")>"검색"</a>
<a href="/recent" on:click=move |_| state.remember_scroll(&pathname.get()) aria-current=move || (pathname.get() == "/recent").then_some("page")>"분석 완료"</a>
</nav>
</header>
</Show>
}
}
#[component]
fn Icon(name: &'static str) -> impl IntoView {
let path = match name {
"search" => "M21 21l-4.4-4.4M19 10.5a8.5 8.5 0 1 1-17 0 8.5 8.5 0 0 1 17 0",
"cube" => "m12 3 9 5v9l-9 5-9-5V8l9-5Zm0 10 9-5M12 13 3 8m9 5v9M7.5 5.5l9 5",
"layers" => "m12 3 10 5-10 5L2 8l10-5ZM2 12l10 5 10-5M2 16l10 5 10-5",
"info" => "M12 11v6m0-10v.01M22 12a10 10 0 1 1-20 0 10 10 0 0 1 20 0",
"back" => "M20 12H4m6-6-6 6 6 6",
"photo" => "M4 3h16a1 1 0 0 1 1 1v16a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1V4a1 1 0 0 1 1-1ZM3 16l5-5 4 4 4-6 5 7M8 7h.01",
"refresh" => "M20 7v5h-5M4 17v-5h5M5.3 7a8 8 0 0 1 13.2-1L20 9M4 15l1.5 3A8 8 0 0 0 18.7 17",
"close" => "m6 6 12 12M6 18 18 6",
"more" => "M5 12h.01M12 12h.01M19 12h.01",
"copy" => "M9 9h12v12H9zM15 9V3H3v12h6",
"external" => "M14 3h7v7m0-7L10 14M10 3H3v18h18v-7",
"chevron" => "m9 6 6 6-6 6",
"expand" => "M8 3H3v5m13-5h5v5M3 16v5h5m13-5v5h-5",
"plus" => "M12 5v14M5 12h14",
"minus" => "M5 12h14",
_ => "M5 12l4 4L19 6",
};
view! {
<svg class="icon" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
<path d=path/>
</svg>
}
}
fn encode_path_segment(value: &str) -> String {
value.bytes().fold(String::new(), |mut encoded, byte| {
if byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_' | b'.' | b'~' | b':') {
encoded.push(byte as char);
} else {
use std::fmt::Write;
let _ = write!(encoded, "%{byte:02X}");
}
encoded
})
}
+274
View File
@@ -0,0 +1,274 @@
//! Browser-only bridges (`hydrate` feature):
//! 1. `wasm-bindgen` bindings to `/js/scene.js` (Three.js renderer)
//! 2. `EventSource` SSE subscriber for `/api/jobs/:id/events`
//!
//! JS closures and `EventSource` objects are kept in a `thread_local!` table and referenced by `u32`
//! so handles are `Copy + Send + Sync` and work directly with Leptos `on_cleanup`.
use domain::JobEvent;
#[cfg(feature = "hydrate")]
mod imp {
use super::*;
use std::cell::{Cell, RefCell};
use std::collections::HashMap;
use std::rc::Rc;
use wasm_bindgen::closure::Closure;
use wasm_bindgen::prelude::*;
use wasm_bindgen::JsCast;
#[wasm_bindgen(module = "/js/scene.js")]
extern "C" {
#[wasm_bindgen(catch, js_name = mountScene)]
fn js_mount_scene(
canvas: &web_sys::HtmlCanvasElement,
layout_json: &str,
on_zone_select: &js_sys::Function,
) -> Result<u32, JsValue>;
#[wasm_bindgen(js_name = setFloor)]
fn js_set_floor(handle: u32, level: i32);
#[wasm_bindgen(js_name = setViewMode)]
fn js_set_view_mode(handle: u32, mode: &str);
#[wasm_bindgen(js_name = resetScene)]
fn js_reset_scene(handle: u32);
#[wasm_bindgen(js_name = zoomScene)]
fn js_zoom_scene(handle: u32, delta: f64);
#[wasm_bindgen(js_name = highlightZone)]
fn js_highlight_zone(handle: u32, label: &str, photo_ids_json: &str);
#[wasm_bindgen(js_name = disposeScene)]
fn js_dispose_scene(handle: u32);
}
struct SseEntry {
es: web_sys::EventSource,
_on_msg: Closure<dyn FnMut(web_sys::MessageEvent)>,
_on_error: Closure<dyn FnMut(web_sys::Event)>,
}
struct SceneWatch {
canvas: web_sys::HtmlCanvasElement,
callback: Closure<dyn FnMut(web_sys::Event)>,
}
thread_local! {
static SCENE_CBS: RefCell<HashMap<u32, Closure<dyn FnMut(String, String)>>> = RefCell::new(HashMap::new());
static SSE_MAP: RefCell<HashMap<u32, SseEntry>> = RefCell::new(HashMap::new());
static NEXT_SSE_ID: RefCell<u32> = const { RefCell::new(1) };
static SCENE_WATCHES: RefCell<HashMap<u32, SceneWatch>> = RefCell::new(HashMap::new());
static NEXT_WATCH_ID: Cell<u32> = const { Cell::new(1) };
}
pub fn mount_scene(
canvas: web_sys::HtmlCanvasElement,
layout_json: &str,
mut on_select: impl FnMut(String, Vec<String>) + 'static,
) -> u32 {
let cb = Closure::wrap(Box::new(move |label: String, ids_json: String| {
let ids: Vec<String> = serde_json::from_str(&ids_json).unwrap_or_default();
on_select(label, ids);
}) as Box<dyn FnMut(String, String)>);
let id = js_mount_scene(&canvas, layout_json, cb.as_ref().unchecked_ref()).unwrap_or(0);
if id != 0 {
SCENE_CBS.with(|m| {
m.borrow_mut().insert(id, cb);
});
}
id
}
pub fn set_floor(handle: u32, level: i32) {
js_set_floor(handle, level);
}
pub fn set_view_mode(handle: u32, mode: &str) {
js_set_view_mode(handle, mode);
}
pub fn reset_scene(handle: u32) {
js_reset_scene(handle);
}
/// Positive deltas zoom in; negative deltas zoom out.
pub fn zoom_scene(handle: u32, delta: f64) {
js_zoom_scene(handle, delta);
}
pub fn highlight_zone(handle: u32, label: &str, photo_ids: &[String]) {
let ids_json = serde_json::to_string(photo_ids).unwrap_or_else(|_| "[]".to_string());
js_highlight_zone(handle, label, &ids_json);
}
/// Observe initial mount failures and later context loss without replacing the canvas.
pub fn watch_scene(
canvas: web_sys::HtmlCanvasElement,
mut on_state: impl FnMut(Option<String>) + 'static,
) -> Option<u32> {
let read_error = |canvas: &web_sys::HtmlCanvasElement| {
canvas
.get_attribute("data-scene-error")
.filter(|message| !message.is_empty())
};
on_state(read_error(&canvas));
let observed_canvas = canvas.clone();
let callback = Closure::wrap(Box::new(move |_: web_sys::Event| {
on_state(read_error(&observed_canvas));
}) as Box<dyn FnMut(web_sys::Event)>);
canvas
.add_event_listener_with_callback("scene-error", callback.as_ref().unchecked_ref())
.ok()?;
if canvas
.add_event_listener_with_callback("scene-ready", callback.as_ref().unchecked_ref())
.is_err()
{
let _ = canvas.remove_event_listener_with_callback(
"scene-error",
callback.as_ref().unchecked_ref(),
);
return None;
}
let id = NEXT_WATCH_ID.with(|next| {
let id = next.get();
next.set(id + 1);
id
});
SCENE_WATCHES.with(|watches| {
watches
.borrow_mut()
.insert(id, SceneWatch { canvas, callback });
});
Some(id)
}
pub fn unwatch_scene(id: u32) {
SCENE_WATCHES.with(|watches| {
if let Some(watch) = watches.borrow_mut().remove(&id) {
let _ = watch.canvas.remove_event_listener_with_callback(
"scene-error",
watch.callback.as_ref().unchecked_ref(),
);
let _ = watch.canvas.remove_event_listener_with_callback(
"scene-ready",
watch.callback.as_ref().unchecked_ref(),
);
}
});
}
pub fn dispose_scene(handle: u32) {
js_dispose_scene(handle);
SCENE_CBS.with(|m| {
m.borrow_mut().remove(&handle);
});
}
pub fn subscribe_job_events(
job_id: &str,
mut on_event: impl FnMut(JobEvent) + 'static,
) -> Option<u32> {
let url = format!("/api/jobs/{job_id}/events");
let es = match web_sys::EventSource::new(&url) {
Ok(es) => es,
Err(_) => {
on_event(JobEvent::Error {
message:
"분석 진행 상태에 연결할 수 없습니다. 연결을 확인하고 다시 시도해 주세요."
.to_string(),
});
return None;
}
};
let on_event = Rc::new(RefCell::new(on_event));
let failures = Rc::new(Cell::new(0_u8));
let terminal = Rc::new(Cell::new(false));
let es_clone = es.clone();
let message_callback = on_event.clone();
let message_failures = failures.clone();
let message_terminal = terminal.clone();
let on_msg = Closure::wrap(Box::new(move |e: web_sys::MessageEvent| {
if message_terminal.get() {
return;
}
if let Some(txt) = e.data().as_string() {
if let Ok(ev) = serde_json::from_str::<JobEvent>(&txt) {
message_failures.set(0);
let done = ev.is_terminal();
if done {
message_terminal.set(true);
es_clone.set_onmessage(None);
es_clone.set_onerror(None);
es_clone.close();
}
(message_callback.borrow_mut())(ev);
}
}
}) as Box<dyn FnMut(web_sys::MessageEvent)>);
let error_es = es.clone();
let on_error = Closure::wrap(Box::new(move |_: web_sys::Event| {
if terminal.get() {
return;
}
failures.set(failures.get().saturating_add(1));
// EventSource handles a short transient disconnect itself. Bound reconnect attempts
// so a permanently unavailable stream cannot leave the UI in a loading state.
if error_es.ready_state() == web_sys::EventSource::CLOSED || failures.get() >= 4 {
terminal.set(true);
error_es.set_onmessage(None);
error_es.set_onerror(None);
error_es.close();
(on_event.borrow_mut())(JobEvent::Error {
message: "분석 상태 연결이 끊겼습니다. 잠시 후 결과를 새로고침해 주세요."
.to_string(),
});
}
}) as Box<dyn FnMut(web_sys::Event)>);
es.set_onmessage(Some(on_msg.as_ref().unchecked_ref()));
es.set_onerror(Some(on_error.as_ref().unchecked_ref()));
let id = NEXT_SSE_ID.with(|n| {
let mut b = n.borrow_mut();
let v = *b;
*b += 1;
v
});
SSE_MAP.with(|m| {
m.borrow_mut().insert(
id,
SseEntry {
es,
_on_msg: on_msg,
_on_error: on_error,
},
);
});
Some(id)
}
pub fn close_job_events(id: u32) {
SSE_MAP.with(|m| {
if let Some(entry) = m.borrow_mut().remove(&id) {
entry.es.set_onmessage(None);
entry.es.set_onerror(None);
entry.es.close();
}
});
}
}
#[cfg(feature = "hydrate")]
pub use imp::*;
#[cfg(not(feature = "hydrate"))]
pub fn subscribe_job_events(
_job_id: &str,
_on_event: impl FnMut(JobEvent) + 'static,
) -> Option<u32> {
None
}
#[cfg(not(feature = "hydrate"))]
pub fn close_job_events(_id: u32) {}
+124
View File
@@ -0,0 +1,124 @@
//! UI-only browser operations; SSR uses inert counterparts.
#[cfg(feature = "hydrate")]
mod imp {
use std::{cell::RefCell, collections::HashMap};
use wasm_bindgen::{closure::Closure, prelude::*, JsCast};
#[wasm_bindgen(module = "/js/ui.js")]
extern "C" {
#[wasm_bindgen(js_name = saveScroll)]
fn js_save_scroll(key: &str);
#[wasm_bindgen(js_name = restoreScroll)]
fn js_restore_scroll(key: &str);
#[wasm_bindgen(js_name = focusSearch)]
fn js_focus_search();
#[wasm_bindgen(js_name = blurActive)]
fn js_blur_active();
#[wasm_bindgen(js_name = closeMenu)]
fn js_close_menu(id: &str);
#[wasm_bindgen(js_name = clearJobQuery)]
fn js_clear_job_query();
#[wasm_bindgen(js_name = revealSelectedPhoto)]
fn js_reveal_selected_photo();
#[wasm_bindgen(js_name = isCompact)]
fn js_is_compact() -> bool;
#[wasm_bindgen(js_name = watchCompact)]
fn js_watch_compact(callback: &js_sys::Function) -> u32;
#[wasm_bindgen(js_name = releaseWatch)]
fn js_release_watch(handle: u32);
#[wasm_bindgen(js_name = openDialog)]
fn js_open_dialog(id: &str, callback: &js_sys::Function) -> u32;
#[wasm_bindgen(js_name = closeDialog)]
fn js_close_dialog(id: &str);
#[wasm_bindgen(js_name = releaseDialog)]
fn js_release_dialog(handle: u32);
#[wasm_bindgen(js_name = copyText)]
fn js_copy_text(value: &str, callback: &js_sys::Function);
}
thread_local! {
static DIALOG_CALLBACKS: RefCell<HashMap<u32, Closure<dyn FnMut()>>> = RefCell::new(HashMap::new());
static WATCH_CALLBACKS: RefCell<HashMap<u32, Closure<dyn FnMut(bool)>>> = RefCell::new(HashMap::new());
}
pub fn save_scroll(key: &str) {
js_save_scroll(key);
}
pub fn restore_scroll(key: &str) {
js_restore_scroll(key);
}
pub fn focus_search() {
js_focus_search();
}
pub fn blur_active() {
js_blur_active();
}
pub fn close_menu(id: &str) {
js_close_menu(id);
}
pub fn clear_job_query() {
js_clear_job_query();
}
pub fn reveal_selected_photo() {
js_reveal_selected_photo();
}
pub fn is_compact() -> bool {
js_is_compact()
}
pub fn watch_compact(callback: impl FnMut(bool) + 'static) -> Option<u32> {
let cb = Closure::wrap(Box::new(callback) as Box<dyn FnMut(bool)>);
let id = js_watch_compact(cb.as_ref().unchecked_ref());
WATCH_CALLBACKS.with(|map| map.borrow_mut().insert(id, cb));
Some(id)
}
pub fn release_watch(handle: u32) {
js_release_watch(handle);
WATCH_CALLBACKS.with(|map| map.borrow_mut().remove(&handle));
}
pub fn open_dialog(id: &str, callback: impl FnMut() + 'static) -> Option<u32> {
let cb = Closure::wrap(Box::new(callback) as Box<dyn FnMut()>);
let handle = js_open_dialog(id, cb.as_ref().unchecked_ref());
if handle == 0 {
return None;
}
DIALOG_CALLBACKS.with(|map| map.borrow_mut().insert(handle, cb));
Some(handle)
}
pub fn close_dialog(id: &str) {
js_close_dialog(id);
}
pub fn release_dialog(handle: u32) {
js_release_dialog(handle);
DIALOG_CALLBACKS.with(|map| map.borrow_mut().remove(&handle));
}
pub fn copy_text(value: &str, callback: impl FnOnce(bool) + 'static) {
let cb = Closure::once_into_js(callback);
js_copy_text(value, cb.unchecked_ref());
}
}
#[cfg(feature = "hydrate")]
pub use imp::*;
#[cfg(not(feature = "hydrate"))]
mod imp_ssr {
pub fn save_scroll(_: &str) {}
pub fn restore_scroll(_: &str) {}
pub fn focus_search() {}
pub fn blur_active() {}
pub fn close_menu(_: &str) {}
pub fn clear_job_query() {}
pub fn reveal_selected_photo() {}
pub fn is_compact() -> bool {
false
}
pub fn watch_compact(_: impl FnMut(bool) + 'static) -> Option<u32> {
None
}
pub fn release_watch(_: u32) {}
pub fn open_dialog(_: &str, _: impl FnMut() + 'static) -> Option<u32> {
None
}
pub fn close_dialog(_: &str) {}
pub fn release_dialog(_: u32) {}
pub fn copy_text(_: &str, _: impl FnOnce(bool) + 'static) {}
}
#[cfg(not(feature = "hydrate"))]
pub use imp_ssr::*;
+849
View File
@@ -0,0 +1,849 @@
//! The responsive place workspace keeps the scene and its selection mounted across widths.
use crate::Icon;
#[cfg(feature = "hydrate")]
use crate::{scene_bridge, ui_bridge};
use domain::{Floor, Layout, PhotoKind, PhotoSummary, Tri, ROOFTOP_LEVEL};
use leptos::prelude::*;
#[derive(Clone, Debug)]
struct PhotoSelection {
title: String,
photos: Vec<PhotoSummary>,
zone: Option<(i32, String)>,
}
fn short_floor_label(floor: &Floor) -> String {
let base = match floor.level {
ROOFTOP_LEVEL => "옥상".to_string(),
n if n < 0 => format!("B{}", n.unsigned_abs()),
0 => "층 미확인".to_string(),
n => format!("{n}층"),
};
if floor_is_uncertain(floor) {
format!("{base}(추정)")
} else {
base
}
}
fn floor_is_uncertain(floor: &Floor) -> bool {
let uncertain = |text: &str| {
[
"임시",
"추정",
"미확인",
"확인되지",
"확인 안",
"불명",
"가정",
"가능성",
"알 수 없",
"증거 없",
]
.iter()
.any(|word| text.contains(word))
};
if uncertain(&floor.label) {
return true;
}
floor.notes.split(['.', '。', '\n', ';']).any(|sentence| {
// Uncertain window positions or room dimensions do not make the floor number uncertain.
let floor_assignment = sentence.contains('층')
&& [
"촬영",
"배정",
"층수",
"층 위치",
"층 정보",
"어느 층",
"실제 층",
"층인지",
"상층",
]
.iter()
.any(|word| sentence.contains(word));
floor_assignment && uncertain(sentence)
})
}
/// Replace implementation IDs without removing the surrounding evidence or warnings.
fn readable_evidence(text: &str, photos: &[PhotoSummary]) -> String {
let mut out = String::with_capacity(text.len());
let mut rest = text;
while !rest.is_empty() {
if rest.starts_with("p_") {
let end = rest
.find(|c: char| !(c.is_ascii_alphanumeric() || c == '_' || c == '-'))
.unwrap_or(rest.len());
let token = &rest[..end];
if token.len() > 2 {
if let Some(photo) = photos.iter().find(|p| p.id == token) {
out.push_str(&format!("{} 참고 사진", photo.source.label()));
} else {
out.push_str("참고 사진");
}
rest = &rest[end..];
continue;
}
}
let ch = rest.chars().next().expect("nonempty text");
out.push(ch);
rest = &rest[ch.len_utf8()..];
}
out
}
fn unique_text(items: Vec<String>, photos: &[PhotoSummary]) -> Vec<String> {
let mut seen = std::collections::HashSet::new();
items
.into_iter()
.map(|s| readable_evidence(s.trim(), photos))
.filter(|s| !s.is_empty())
.filter(|s| {
let key: String = s
.chars()
.filter(|c| !c.is_whitespace() && !matches!(c, '·' | ',' | '.' | '-'))
.flat_map(char::to_lowercase)
.collect();
seen.insert(key)
})
.collect()
}
fn brief(text: &str, max: usize) -> String {
if text.chars().count() <= max {
text.to_string()
} else {
format!("{}…", text.chars().take(max).collect::<String>().trim_end())
}
}
fn photo_caption(photo: &PhotoSummary) -> String {
if !photo.description.trim().is_empty() {
photo.description.clone()
} else if !photo.caption.trim().is_empty() {
photo.caption.clone()
} else {
match photo.kind {
Some(PhotoKind::Exterior) => "건물 외관 사진".to_string(),
Some(PhotoKind::Interior) => "공간 내부 사진".to_string(),
_ => "공간 확인에 사용된 사진".to_string(),
}
}
}
fn source_url(photo: &PhotoSummary) -> Option<String> {
(photo.page_url.starts_with("https://") || photo.page_url.starts_with("http://"))
.then(|| photo.page_url.clone())
}
fn accessibility_label(value: Tri) -> &'static str {
match value {
Tri::Unknown => "미확인",
Tri::Likely => "있을 가능성 · 확인 필요",
Tri::Yes => "있음",
Tri::No => "없음",
}
}
#[component]
fn PhotoImage(
photo: PhotoSummary,
#[prop(default = "lazy")] loading: &'static str,
) -> impl IntoView {
let (failed, set_failed) = signal(false);
let alt = brief(&photo_caption(&photo), 120);
view! {
<div class="image-shell">
<img
src=format!("/api/photos/{}", photo.id)
alt=alt
loading=loading
decoding="async"
hidden=move || failed.get()
on:error=move |_| set_failed.set(true)
/>
<span class="image-fallback" hidden=move || !failed.get()>
<Icon name="photo"/>"사진을 불러오지 못했습니다."
</span>
</div>
}
}
#[component]
fn PhotoCaption(photo: PhotoSummary) -> impl IntoView {
let caption = photo_caption(&photo);
let has_more = caption.chars().count() > 90;
view! {
<div class="photo-caption">
<p>{brief(&caption, 90)}</p>
{has_more.then(|| view! {
<details class="photo-description">
<summary>"설명 더 보기"</summary>
<p>{caption}</p>
</details>
})}
{match source_url(&photo) {
Some(url) => view! {
<a class="photo-source" href=url target="_blank" rel="noopener noreferrer">
{format!("원문 보기 · {}", photo.source.label())}
<span class="sr-only">" (새 탭)"</span>
</a>
}.into_any(),
None => view! { <span class="photo-source">{photo.source.label()}</span> }.into_any(),
}}
</div>
}
}
#[component]
pub(crate) fn WorkspaceView(layout: Layout, photos: Vec<PhotoSummary>) -> impl IntoView {
let (active_floor, set_active_floor) = signal(0i32);
let (view_mode, set_view_mode) = signal("iso");
let (mobile_panel, set_mobile_panel) = signal("layout");
let (scene_interactive, set_scene_interactive) = signal(false);
let (scene_error, set_scene_error) = signal(Option::<String>::None);
let (scene_retry, set_scene_retry) = signal(0u32);
let (scene_fullscreen, set_scene_fullscreen) = signal(false);
let (selection, set_selection) = signal(Option::<PhotoSelection>::None);
let (photo_index, set_photo_index) = signal(0usize);
let (photo_open, set_photo_open) = signal(false);
let canvas_ref = NodeRef::<leptos::html::Canvas>::new();
let clean_photos = photos
.iter()
.cloned()
.map(|mut p| {
p.description = readable_evidence(&p.description, &photos);
p.caption = readable_evidence(&p.caption, &photos);
p
})
.collect::<Vec<_>>();
let photo_store = StoredValue::new(clean_photos.clone());
let floor_store = StoredValue::new(layout.floors.clone());
let interior_photos = clean_photos
.iter()
.filter(|p| {
matches!(
p.kind,
Some(PhotoKind::Interior | PhotoKind::Exterior) | None
)
})
.cloned()
.collect::<Vec<_>>();
let gallery_store = StoredValue::new(interior_photos.clone());
let choose_zone = Callback::new(move |(level, label, ids): (i32, String, Vec<String>)| {
let photos = photo_store.with_value(|all| {
all.iter()
.filter(|p| ids.contains(&p.id))
.cloned()
.collect::<Vec<_>>()
});
set_selection.set(Some(PhotoSelection {
title: label.clone(),
photos,
zone: Some((level, label)),
}));
set_photo_index.set(0);
#[cfg(feature = "hydrate")]
{
if ui_bridge::is_compact() || scene_fullscreen.get_untracked() {
set_photo_open.set(true);
} else {
ui_bridge::reveal_selected_photo();
}
}
});
let choose_floor = Callback::new(move |level: i32| {
set_active_floor.set(level);
let keep = selection.with_untracked(|current| {
current
.as_ref()
.and_then(|s| s.zone.as_ref())
.is_none_or(|(selected_level, _)| level == 0 || *selected_level == level)
});
if !keep {
set_selection.set(None);
set_photo_open.set(false);
}
});
let show_gallery = Callback::new(move |index: usize| {
set_selection.set(Some(PhotoSelection {
title: "공간 사진".into(),
photos: gallery_store.get_value(),
zone: None,
}));
set_photo_index.set(index);
set_photo_open.set(true);
});
#[cfg(feature = "hydrate")]
let (scene_id, set_scene_id) = signal(Option::<u32>::None);
#[cfg(feature = "hydrate")]
{
let layout_json = serde_json::to_string(&layout).unwrap_or_default();
Effect::new(move |_| {
let _ = scene_retry.get();
let Some(canvas) = canvas_ref.get() else {
return;
};
set_scene_error.set(None);
let id = scene_bridge::mount_scene(canvas.clone(), &layout_json, move |label, ids| {
let level = floor_store.with_value(|floors| {
floors
.iter()
.filter(|f| {
active_floor.get_untracked() == 0
|| f.level == active_floor.get_untracked()
})
.find(|f| {
f.zones
.iter()
.any(|z| z.label == label && z.evidence_photos == ids)
})
.or_else(|| {
floors
.iter()
.find(|f| f.zones.iter().any(|z| z.label == label))
})
.map_or(0, |f| f.level)
});
choose_zone.run((level, label, ids));
});
if id == 0 {
set_scene_error.set(Some("공간 화면을 불러오지 못했습니다.".into()));
set_scene_id.set(None);
} else {
set_scene_id.set(Some(id));
// These are untracked so changing a control does not recreate the renderer.
scene_bridge::set_floor(id, active_floor.get_untracked());
scene_bridge::set_view_mode(id, view_mode.get_untracked());
}
let watch = scene_bridge::watch_scene(canvas, move |error| set_scene_error.set(error));
on_cleanup(move || {
if let Some(watch) = watch {
scene_bridge::unwatch_scene(watch);
}
if id != 0 {
scene_bridge::dispose_scene(id);
}
});
});
Effect::new(move |_| {
let level = active_floor.get();
if let Some(id) = scene_id.get() {
scene_bridge::set_floor(id, level);
}
});
Effect::new(move |_| {
let mode = view_mode.get();
if let Some(id) = scene_id.get() {
scene_bridge::set_view_mode(id, mode);
}
});
Effect::new(move |_| {
let current = selection.get();
if let Some(id) = scene_id.get() {
if let Some(s) = current.filter(|s| s.zone.is_some()) {
let ids = s.photos.iter().map(|p| p.id.clone()).collect::<Vec<_>>();
scene_bridge::highlight_zone(id, &s.title, &ids);
} else {
scene_bridge::highlight_zone(id, "", &[]);
}
}
});
let photo_handle = StoredValue::new(None::<u32>);
Effect::new(move |_| {
if photo_open.get() {
if photo_handle.get_value().is_none() {
let handle = ui_bridge::open_dialog("space-photo-dialog", move || {
set_photo_open.set(false)
});
photo_handle.set_value(handle);
}
} else if let Some(handle) = photo_handle.get_value() {
ui_bridge::close_dialog("space-photo-dialog");
ui_bridge::release_dialog(handle);
photo_handle.set_value(None);
}
});
let scene_handle = StoredValue::new(None::<u32>);
Effect::new(move |_| {
if scene_fullscreen.get() {
if scene_handle.get_value().is_none() {
let handle = ui_bridge::open_dialog("space-scene-dialog", move || {
set_scene_fullscreen.set(false)
});
scene_handle.set_value(handle);
}
} else if let Some(handle) = scene_handle.get_value() {
ui_bridge::close_dialog("space-scene-dialog");
ui_bridge::release_dialog(handle);
scene_handle.set_value(None);
}
});
let resize_watch = ui_bridge::watch_compact(move |compact| {
if !compact
&& !scene_fullscreen.get_untracked()
&& selection.with_untracked(|s| s.as_ref().is_some_and(|s| s.zone.is_some()))
{
set_photo_open.set(false);
}
});
on_cleanup(move || {
if let Some(handle) = photo_handle.get_value() {
ui_bridge::release_dialog(handle);
}
if let Some(handle) = scene_handle.get_value() {
ui_bridge::release_dialog(handle);
}
if let Some(handle) = resize_watch {
ui_bridge::release_watch(handle);
}
});
}
#[cfg(not(feature = "hydrate"))]
let _ = (
scene_retry,
set_scene_error,
photo_open,
scene_fullscreen,
floor_store,
);
let floors_for_tabs = layout.floors.clone();
let floors_for_notes = layout.floors.clone();
let many_floors = floors_for_tabs.len() > 4;
let caveats = unique_text(layout.summary.caveats.clone(), &photos);
let all_evidence = format!(
"{} {}",
caveats.join(" "),
layout
.floors
.iter()
.map(|f| f.notes.as_str())
.collect::<Vec<_>>()
.join(" ")
);
let uncertain_branch = [
"다른 지점",
"타 지점",
"타지점",
"지점 혼",
"지점 불일치",
"지점이 불명",
]
.iter()
.any(|s| all_evidence.contains(s));
let uncertain_floor = layout.floors.iter().any(floor_is_uncertain);
let warning = match (uncertain_branch, uncertain_floor) {
(true, true) => "층·지점 정보 확인 필요 · 추정 배치",
(true, false) => "지점 정보 확인 필요 · 추정 배치",
(false, true) => "층 정보 확인 필요 · 추정 배치",
(false, false) => "사진·리뷰로 추정한 배치",
};
let seat_types = unique_text(layout.summary.seat_types.clone(), &photos);
let highlights = unique_text(layout.summary.highlights.clone(), &photos);
let more_highlights = highlights.iter().skip(3).cloned().collect::<Vec<_>>();
let brief_highlights = highlights.iter().take(3).cloned().collect::<Vec<_>>();
let floor_count = layout.floors.len();
let floor_summary = layout
.floors
.iter()
.map(short_floor_label)
.collect::<Vec<_>>()
.join(" · ");
let confidence = if layout.confidence.is_finite() {
format!(
"분석 모델이 보고한 신뢰도 {:.0}%",
layout.confidence.clamp(0.0, 1.0) * 100.0
)
} else {
"분석 모델 신뢰도 미제공".into()
};
let gallery_total = interior_photos.len();
view! {
<div class="workspace-switcher" role="group" aria-label="공간 보기">
<button type="button" aria-controls="layout-panel"
aria-pressed=move || (mobile_panel.get() == "layout").to_string()
on:click=move |_| set_mobile_panel.set("layout")>"공간 배치"</button>
<button type="button" aria-controls="info-panel"
aria-pressed=move || (mobile_panel.get() == "info").to_string()
on:click=move |_| { set_mobile_panel.set("info"); set_scene_interactive.set(false); }>"공간 정보"</button>
</div>
<p class="workspace-warning"><Icon name="info"/>{warning}</p>
<div class="workspace-grid" data-mobile-panel=move || mobile_panel.get()>
<section class="viewport-col" id="layout-panel" aria-label="공간 배치">
<div class="viewport-toolbar">
{if many_floors {
view! {
<label class="floor-select-label"><span class="sr-only">"표시할 층"</span>
<select class="floor-select" prop:value=move || active_floor.get().to_string()
on:change=move |ev| choose_floor.run(event_target_value(&ev).parse().unwrap_or(0))>
<option value="0">"전체 층"</option>
{floors_for_tabs.iter().map(|f| view! {
<option value=f.level.to_string()>{short_floor_label(f)}</option>
}).collect_view()}
</select>
</label>
}.into_any()
} else {
view! {
<div class="floor-tabs" role="group" aria-label="표시할 층">
<button type="button" class="tab" aria-pressed=move || (active_floor.get() == 0).to_string()
on:click=move |_| choose_floor.run(0)>"전체"</button>
{floors_for_tabs.iter().map(|f| {
let level = f.level;
view! {
<button type="button" class="tab" aria-pressed=move || (active_floor.get() == level).to_string()
on:click=move |_| choose_floor.run(level)>{short_floor_label(f)}</button>
}
}).collect_view()}
</div>
}.into_any()
}}
<div class="view-modes" role="group" aria-label="보기 방식">
<button type="button" class="tab" aria-pressed=move || (view_mode.get() == "iso").to_string()
on:click=move |_| set_view_mode.set("iso")>"3D"</button>
<button type="button" class="tab" aria-pressed=move || (view_mode.get() == "plan").to_string()
on:click=move |_| set_view_mode.set("plan")>"평면도"</button>
</div>
</div>
<dialog id="space-scene-dialog" class="scene-dialog" open data-inline-dialog="true"
role=move || if scene_fullscreen.get() { "dialog" } else { "region" }
aria-label="공간 배치 화면">
<div class="scene-dialog-header" hidden=move || !scene_fullscreen.get()>
<strong>{move || if view_mode.get() == "plan" { "평면도" } else { "3D 공간" }}</strong>
<button type="button" class="btn-close" on:click=move |_| set_scene_fullscreen.set(false)>"전체 화면 닫기"<Icon name="close"/></button>
</div>
<div class="canvas-holder" data-scene-failed=move || scene_error.get().is_some().to_string()>
<canvas node_ref=canvas_ref class="scene-canvas"
data-interactive=move || scene_interactive.get().to_string()
aria-label=move || if view_mode.get() == "plan" {
"층별 평면도. 아래 구역 버튼에서도 사진을 확인할 수 있습니다."
} else {
"층별 3D 공간. 아래 구역 버튼에서도 사진을 확인할 수 있습니다."
}></canvas>
<div class="scene-tools" role="group" aria-label="공간 화면 조절" hidden=move || scene_error.get().is_some()>
<button type="button" class="scene-tool" aria-label="확대" title="확대" on:click=move |_| {
#[cfg(feature = "hydrate")]
if let Some(id) = scene_id.get_untracked() { scene_bridge::zoom_scene(id, 1.0); }
}>"+"</button>
<button type="button" class="scene-tool" aria-label="축소" title="축소" on:click=move |_| {
#[cfg(feature = "hydrate")]
if let Some(id) = scene_id.get_untracked() { scene_bridge::zoom_scene(id, -1.0); }
}>"−"</button>
<button type="button" class="scene-tool" aria-label="시점 초기화" title="시점 초기화" on:click=move |_| {
#[cfg(feature = "hydrate")]
if let Some(id) = scene_id.get_untracked() { scene_bridge::reset_scene(id); }
}><Icon name="refresh"/></button>
<button type="button" class="scene-tool scene-expand" aria-label=move || if scene_fullscreen.get() { "전체 화면 닫기" } else { "전체 화면 보기" }
on:click=move |_| set_scene_fullscreen.update(|open| *open = !*open)>
{move || if scene_fullscreen.get() { "축소 보기" } else { "전체 화면" }}
</button>
</div>
<button type="button" class="scene-interaction-toggle"
hidden=move || scene_error.get().is_some()
aria-pressed=move || scene_interactive.get().to_string()
on:click=move |_| set_scene_interactive.update(|active| *active = !*active)>
{move || if scene_interactive.get() { "조작 종료" } else if view_mode.get() == "plan" { "이동·확대" } else { "회전·확대" }}
</button>
<div class="canvas-hint" hidden=move || scene_error.get().is_some()>
<span class="hint-pointer">{move || if view_mode.get() == "plan" {
"드래그로 이동 · 휠로 확대 · 핀으로 사진"
} else { "드래그로 회전 · 휠로 확대 · 핀으로 사진" }}</span>
<span class="hint-touch">{move || match (scene_interactive.get(), view_mode.get()) {
(true, "plan") => "한 손가락 이동 · 두 손가락 확대",
(true, _) => "한 손가락 회전 · 두 손가락 확대·이동",
(false, _) if scene_fullscreen.get() => "핀을 누르면 사진 · 조작 버튼으로 이동·확대",
(false, _) => "핀을 누르면 사진 · 위아래로 화면 스크롤",
}}</span>
</div>
{move || scene_error.get().map(|_| view! {
<div class="scene-failure" role="status">
<strong>"공간 화면을 불러오지 못했습니다."</strong>
<p>"사진과 공간 정보는 계속 확인할 수 있습니다."</p>
<div>
<button type="button" class="btn-secondary" on:click=move |_| set_scene_retry.update(|n| *n += 1)>"다시 불러오기"</button>
<button type="button" class="btn-secondary" on:click=move |_| {
set_scene_fullscreen.set(false);
set_mobile_panel.set("info");
}>"공간 정보 보기"</button>
</div>
</div>
})}
</div>
</dialog>
{move || selection.get().map(|s| view! {
<button type="button" class="selected-zone-mobile" on:click=move |_| set_photo_open.set(true)>
<Icon name="photo"/>
<span>{format!("{} · 사진 {}장", brief(&s.title, 24), s.photos.len())}</span>
<span>"보기"</span>
</button>
})}
<div class="floor-notes" aria-label="층별 구역">
{floors_for_notes.into_iter().map(|floor| {
let level = floor.level;
let notes = readable_evidence(&floor.notes, &photos);
let original_label = readable_evidence(&floor.label, &photos);
let short_label = short_floor_label(&floor);
let show_original = original_label != short_label && original_label != format!("{}F", level);
view! {
<section class="floor-note-card" hidden=move || active_floor.get() != 0 && active_floor.get() != level>
<div class="floor-note-head">
<h3>{short_label}</h3>
<span>{format!("약 {:.0}m × {:.0}m", floor.width_m, floor.depth_m)}</span>
</div>
<div class="zone-chips">
{floor.zones.into_iter().map(|zone| {
let label = zone.label.clone();
let label_for_selected = label.clone();
let ids = zone.evidence_photos;
let has_photos = clean_photos.iter().any(|p| ids.contains(&p.id));
if has_photos {
view! {
<button type="button" class="zone-chip"
aria-pressed=move || selection.with(|s| s.as_ref().and_then(|s| s.zone.as_ref()).is_some_and(|(l, name)| *l == level && name == &label_for_selected)).to_string()
on:click=move |_| choose_zone.run((level, label.clone(), ids.clone()))>
{zone.label}<Icon name="photo"/>
</button>
}.into_any()
} else {
view! { <span class="zone-empty">{zone.label}<span>"사진 없음"</span></span> }.into_any()
}
}).collect_view()}
</div>
{(!notes.is_empty() || show_original).then(|| view! {
<details class="summary-details floor-details">
<summary>"층 정보와 추정 근거"</summary>
{show_original.then(|| view! { <p>{original_label}</p> })}
{(!notes.is_empty()).then(|| view! { <p>{notes}</p> })}
<p class="confidence-explanation">{format!("분석 모델이 보고한 층 신뢰도 {:.0}%. 실제 정확도를 검증한 확률은 아닙니다.", floor.confidence.clamp(0.0, 1.0) * 100.0)}</p>
</details>
})}
</section>
}
}).collect_view()}
</div>
</section>
<aside class="summary-col" id="info-panel" aria-label="공간 정보">
{move || selection.get().map(|s| {
let total = s.photos.len();
let selected_photos = StoredValue::new(s.photos.clone());
view! {
<section class="summary-card selected-zone-panel" aria-label="선택한 구역 사진">
<div class="pin-drawer-head">
<h3>{s.title.clone()}</h3>
<button type="button" class="btn-close" aria-label="선택한 사진 닫기" on:click=move |_| set_selection.set(None)><Icon name="close"/></button>
</div>
<p class="photo-count">{format!("사진 {}장", total)}</p>
<button type="button" class="selected-photo-preview" aria-label="선택한 사진 크게 보기" hidden=total == 0 on:click=move |_| set_photo_open.set(true)>
{move || selected_photos.with_value(|photos| photos.get(photo_index.get()).cloned()).map(|p| view! { <PhotoImage photo=p loading="eager"/> })}
</button>
{move || selected_photos.with_value(|photos| photos.get(photo_index.get()).cloned()).map(|p| view! { <PhotoCaption photo=p/> })}
{(total > 1).then(|| view! {
<div class="photo-navigation">
<button type="button" class="btn-secondary" disabled=move || photo_index.get() == 0 on:click=move |_| set_photo_index.update(|n| *n = n.saturating_sub(1))>"이전"</button>
<span>{move || format!("{} / {}", photo_index.get() + 1, total)}</span>
<button type="button" class="btn-secondary" disabled=move || { photo_index.get() + 1 >= total } on:click=move |_| set_photo_index.update(|n| *n = (*n + 1).min(total.saturating_sub(1)))>"다음"</button>
</div>
})}
{(total == 0).then(|| view! { <p class="photo-empty">"이 구역에 연결된 사진이 없습니다."</p> })}
</section>
}
})}
<section class="summary-card">
<h3>"공간 정보"</h3>
<div class="metric-grid">
<div class="metric"><span class="metric-label">"추정 면적"</span>
<strong class="metric-val">{if layout.summary.area_pyeong_max > 0.0 {
format!("약 {:.0}~{:.0}평", layout.summary.area_pyeong_min, layout.summary.area_pyeong_max)
} else { "미확인".into() }}</strong>
</div>
<div class="metric"><span class="metric-label">"추정 좌석 수"</span>
<strong class="metric-val">{if layout.summary.seat_estimate > 0 {
format!("약 {}석", layout.summary.seat_estimate)
} else { "미확인".into() }}</strong>
</div>
</div>
<div class="summary-floor-count"><strong>{format!("추정 {}개 층", floor_count)}</strong><span>{floor_summary}</span></div>
<div class="summary-section">
<h4>"확인할 정보"</h4>
<p class="evidence-warning">{warning}"입니다. 실제 배치와 다를 수 있습니다."</p>
<details class="summary-details">
<summary>"참고사항과 분석 근거"</summary>
{(!caveats.is_empty()).then(|| view! {
<ul class="bullet-list">{caveats.into_iter().map(|c| view! { <li>{c}</li> }).collect_view()}</ul>
})}
<p>{confidence}</p>
<p class="confidence-explanation">"이 수치는 분석 모델의 자체 평가입니다. 현장 실측으로 보정한 정확도나 실제 배치가 맞을 확률이 아닙니다."</p>
</details>
</div>
{(!seat_types.is_empty()).then(|| view! {
<div class="summary-section"><h4>"좌석 구성 · 전체 층"</h4>
<div class="tag-row">{seat_types.into_iter().map(|s| view! { <span class="badge">{s}</span> }).collect_view()}</div>
</div>
})}
<div class="summary-section">
<h4>"접근성"</h4>
<dl class="fact-list">
<div><dt>"엘리베이터"</dt><dd>{accessibility_label(layout.summary.accessibility.elevator)}</dd></div>
<div><dt>"무단차 출입구"</dt><dd>{accessibility_label(layout.summary.accessibility.step_free_entrance)}</dd></div>
</dl>
<p class="accessibility-note">"미확인은 시설이 없다는 뜻이 아닙니다. 방문 전 장소에 확인해 주세요."</p>
</div>
{(!brief_highlights.is_empty()).then(|| view! {
<div class="summary-section"><h4>"공간 특징"</h4>
<ul class="bullet-list">{brief_highlights.into_iter().map(|h| view! { <li>{brief(&h, 100)}</li> }).collect_view()}</ul>
{(!more_highlights.is_empty() || highlights.iter().any(|h| h.chars().count() > 100)).then(|| view! {
<details class="summary-details"><summary>"특징 전체 보기"</summary>
<ul class="bullet-list">{highlights.into_iter().map(|h| view! { <li>{h}</li> }).collect_view()}</ul>
</details>
})}
</div>
})}
</section>
{(gallery_total > 0).then(|| view! {
<section class="summary-card gallery-card">
<div class="gallery-heading"><h3>"공간 사진"</h3><span>{format!("{}장", gallery_total)}</span></div>
<div class="gallery-grid">
{interior_photos.into_iter().take(6).enumerate().map(|(index, photo)| {
let source = photo.source.label();
view! {
<button type="button" class="gallery-item" aria-label=format!("공간 사진 {} 크게 보기", index + 1)
on:click=move |_| show_gallery.run(index)>
<PhotoImage photo=photo/>
<span class="gallery-source">{source}</span>
</button>
}
}).collect_view()}
</div>
{(gallery_total > 6).then(|| view! {
<button type="button" class="gallery-all btn-secondary" on:click=move |_| show_gallery.run(0)>{format!("사진 {}장 모두 보기", gallery_total)}</button>
})}
</section>
})}
</aside>
</div>
<dialog id="space-photo-dialog" class="photo-dialog" aria-labelledby="space-photo-title"
on:keydown=move |ev| {
if ev.key() == "ArrowLeft" {
ev.prevent_default();
set_photo_index.update(|n| *n = n.saturating_sub(1));
}
if ev.key() == "ArrowRight" {
ev.prevent_default();
let count = selection.with_untracked(|s| s.as_ref().map_or(0, |s| s.photos.len()));
set_photo_index.update(|n| *n = (*n + 1).min(count.saturating_sub(1)));
}
}>
<div class="dialog-header">
<h2 id="space-photo-title">{move || selection.get().map_or_else(|| "공간 사진".into(), |s| s.title)}</h2>
<button type="button" class="btn-close" aria-label="사진 닫기" on:click=move |_| set_photo_open.set(false)>"닫기"<Icon name="close"/></button>
</div>
<div class="photo-dialog-body">
{move || selection.get().map(|s| {
let total = s.photos.len();
let selected_photos = StoredValue::new(s.photos.clone());
view! {
{move || selected_photos.with_value(|photos| photos.get(photo_index.get()).cloned()).map(|photo| view! {
<div class="photo-viewer"><PhotoImage photo=photo.clone() loading="eager"/></div>
<PhotoCaption photo=photo/>
})}
{(total > 0).then(|| view! {
<div class="photo-navigation">
<button type="button" class="btn-secondary" aria-label="이전 사진" disabled=move || photo_index.get() == 0
on:click=move |_| set_photo_index.update(|n| *n = n.saturating_sub(1))>"이전"</button>
<span role="status" aria-live="polite">{move || format!("{} / {}", photo_index.get() + 1, total)}</span>
<button type="button" class="btn-secondary" aria-label="다음 사진" disabled=move || { photo_index.get() + 1 >= total }
on:click=move |_| set_photo_index.update(|n| *n = (*n + 1).min(total.saturating_sub(1)))>"다음"</button>
</div>
})}
{(total > 1).then(|| view! {
<div class="photo-thumbnails" role="group" aria-label="사진 선택">
{s.photos.into_iter().enumerate().map(|(i, photo)| view! {
<button type="button" aria-label=format!("{}번째 사진", i + 1) aria-pressed=move || (i == photo_index.get()).to_string()
on:click=move |_| set_photo_index.set(i)><PhotoImage photo=photo/></button>
}).collect_view()}
</div>
})}
{(total == 0).then(|| view! { <p class="photo-empty">"이 구역에 연결된 사진이 없습니다."</p> })}
}
})}
</div>
</dialog>
}
}
#[cfg(test)]
mod tests {
use super::*;
fn floor(label: &str, notes: &str, level: i32) -> Floor {
Floor {
level,
label: label.into(),
confidence: 0.5,
width_m: 10.0,
depth_m: 8.0,
openings: vec![],
zones: vec![],
verticals: vec![],
notes: notes.into(),
}
}
#[test]
fn floor_labels_distinguish_assignment_from_dimension_uncertainty() {
assert_eq!(
short_floor_label(&floor("1층", "치수와 방위는 가정입니다.", 1)),
"1층"
);
assert_eq!(
short_floor_label(&floor("상층 좌석 공간 · 2층으로 임시 배정", "", 2)),
"2층(추정)"
);
assert_eq!(
short_floor_label(&floor("2층", "사진의 촬영 층은 미확인입니다.", 2)),
"2층(추정)"
);
assert_eq!(short_floor_label(&floor("지하", "", -1)), "B1");
assert_eq!(
short_floor_label(&floor("루프탑", "", ROOFTOP_LEVEL)),
"옥상"
);
}
#[test]
fn evidence_ids_are_replaced_without_losing_caveats() {
let text = "p_ab123, p_other: 다른 지점 사진일 가능성이 있어 층은 미확인.";
assert_eq!(
readable_evidence(text, &[]),
"참고 사진, 참고 사진: 다른 지점 사진일 가능성이 있어 층은 미확인."
);
}
#[test]
fn equivalent_tags_are_not_repeated() {
assert_eq!(
unique_text(
vec!["바 좌석".into(), "바좌석".into(), "소파".into(), "".into()],
&[]
),
vec!["바 좌석", "소파"]
);
}
}