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

+41
View File
@@ -0,0 +1,41 @@
[package]
name = "app"
edition.workspace = true
version.workspace = true
[lib]
crate-type = ["rlib"]
[dependencies]
domain = { workspace = true }
leptos = { workspace = true }
leptos_meta = { workspace = true }
leptos_router = { workspace = true }
serde = { workspace = true }
serde_json = { workspace = true }
# hydrate-only
wasm-bindgen = { workspace = true, optional = true }
js-sys = { workspace = true, optional = true }
web-sys = { workspace = true, optional = true, features = ["EventSource", "MessageEvent", "HtmlCanvasElement", "Event"] }
# ssr-only
leptos_axum = { workspace = true, optional = true }
pipeline = { workspace = true, optional = true }
storage = { workspace = true, optional = true }
providers = { workspace = true, optional = true }
tracing = { workspace = true, optional = true }
[features]
default = []
hydrate = ["leptos/hydrate", "dep:wasm-bindgen", "dep:js-sys", "dep:web-sys"]
ssr = [
"leptos/ssr",
"leptos_meta/ssr",
"leptos_router/ssr",
"dep:leptos_axum",
"dep:pipeline",
"dep:storage",
"dep:providers",
"dep:tracing",
]
+787
View File
@@ -0,0 +1,787 @@
import * as THREE from "three";
import { OrbitControls } from "three/addons/controls/OrbitControls.js";
const FLOOR_HEIGHT = 3.6;
const WALL_HEIGHT = 2.6;
const WALL_THICK = 0.16;
// sRGB equivalents of the Aurora light canvas and blue action palette.
const SCENE_COLORS = {
background: 0xeff0f2,
gridMajor: 0xd6d9df,
gridMinor: 0xe3e5e9,
accent: 0x235cc7,
};
const ZONE_COLORS = {
seating: 0xe8dfd1,
counter: 0xd4a373,
bar: 0xc89f81,
kitchen: 0xb7b7a4,
restroom: 0xa8dadc,
terrace: 0xccd5ae,
entrance: 0xf4e285,
other: 0xdedbd2,
};
const scenes = new Map();
let nextId = 1;
function floorIndex(floors, level) {
const sorted = [...floors].sort((a, b) => a.level - b.level);
const idx = sorted.findIndex((f) => f.level === level);
return idx >= 0 ? idx : 0;
}
function createScene(canvas, layoutJson, onZoneSelect, cleanup) {
const layout = JSON.parse(layoutJson);
if (!layout || !Array.isArray(layout.floors)) throw new Error("Invalid floor layout");
const coarsePointer = window.matchMedia("(pointer: coarse)");
const originalTouchAction = canvas.style.touchAction;
const renderer = new THREE.WebGLRenderer({ canvas, antialias: true, alpha: false });
cleanup.push(() => renderer.dispose());
renderer.shadowMap.enabled = true;
renderer.shadowMap.type = THREE.PCFSoftShadowMap;
renderer.setClearColor(SCENE_COLORS.background, 1);
const scene = new THREE.Scene();
cleanup.push(() => disposeSceneObjects(scene));
scene.fog = new THREE.FogExp2(SCENE_COLORS.background, 0.015);
const camera = new THREE.PerspectiveCamera(42, 1, 0.1, 200);
const controls = new OrbitControls(camera, canvas);
cleanup.push(() => { controls.dispose(); canvas.style.touchAction = originalTouchAction; });
const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)");
controls.enableDamping = !reducedMotion.matches;
controls.dampingFactor = 0.08;
controls.maxPolarAngle = Math.PI * 0.48;
const hemi = new THREE.HemisphereLight(0xffffff, 0xaab0ba, 1.05);
scene.add(hemi);
const dir = new THREE.DirectionalLight(0xffffff, 1.25);
dir.position.set(16, 28, 18);
dir.castShadow = true;
dir.shadow.mapSize.set(2048, 2048);
dir.shadow.camera.near = 1;
dir.shadow.camera.far = 90;
const d = 24;
dir.shadow.camera.left = -d;
dir.shadow.camera.right = d;
dir.shadow.camera.top = d;
dir.shadow.camera.bottom = -d;
scene.add(dir);
const groundGrid = new THREE.GridHelper(60, 60, SCENE_COLORS.gridMajor, SCENE_COLORS.gridMinor);
groundGrid.position.y = -0.08;
scene.add(groundGrid);
const floorGroups = new Map();
const pinMeshes = [];
const floors = layout.floors || [];
floors.forEach((floor) => {
const idx = floorIndex(floors, floor.level);
const yBase = idx * FLOOR_HEIGHT;
const group = buildFloorGroup(floor, yBase, pinMeshes);
scene.add(group);
floorGroups.set(floor.level, { group, yBase, floor });
});
const maxW = Math.max(10, ...floors.map((f) => f.width_m || 10));
const maxD = Math.max(10, ...floors.map((f) => f.depth_m || 10));
const span = Math.max(maxW, maxD);
camera.position.set(span * 1.15, span * 1.05, span * 1.25);
controls.target.set(0, (floors.length - 1) * FLOOR_HEIGHT * 0.35, 0);
controls.update();
let hasSize = false;
let visible = true;
let contextLost = false;
let disposed = false;
let raf = 0;
let st;
const requestFrame = () => {
if (!disposed && !contextLost && !document.hidden && visible && hasSize && !raf) {
raf = requestAnimationFrame(animate);
}
};
let pixelRatio = 0;
const resize = () => {
const rect = canvas.getBoundingClientRect();
const w = rect.width;
const h = rect.height;
hasSize = w > 0 && h > 0;
if (!hasSize) return;
const nextPixelRatio = Math.min(window.devicePixelRatio || 1, coarsePointer.matches ? 1.5 : 2);
if (nextPixelRatio !== pixelRatio) {
renderer.setPixelRatio(nextPixelRatio);
pixelRatio = nextPixelRatio;
}
renderer.setSize(w, h, false);
camera.aspect = w / h;
// Leave room around the model on portrait and near-square phone viewports.
camera.fov = (2 * Math.atan(Math.tan((42 * Math.PI) / 360) / Math.min(1, camera.aspect / 1.15)) * 180) / Math.PI;
camera.updateProjectionMatrix();
requestFrame();
};
resize();
const ro = new ResizeObserver(resize);
cleanup.push(() => ro.disconnect());
ro.observe(canvas);
window.addEventListener("resize", resize);
cleanup.push(() => window.removeEventListener("resize", resize));
const raycaster = new THREE.Raycaster();
const pointer = new THREE.Vector2();
const activePointers = new Set();
let downPos = null;
const syncInteraction = () => {
downPos = null;
controls.enabled = !coarsePointer.matches || canvas.dataset.interactive === "true";
// OrbitControls sets this to "none" in its constructor, so apply the page-scroll mode afterward.
canvas.style.touchAction = controls.enabled ? "none" : "pan-y";
};
syncInteraction();
const interactionObserver = new MutationObserver(syncInteraction);
cleanup.push(() => interactionObserver.disconnect());
interactionObserver.observe(canvas, { attributes: true, attributeFilter: ["data-interactive"] });
const onPointerModeChange = () => {
syncInteraction();
resize();
};
coarsePointer.addEventListener("change", onPointerModeChange);
cleanup.push(() => coarsePointer.removeEventListener("change", onPointerModeChange));
const onActivePointerDown = (e) => {
activePointers.add(e.pointerId);
if (activePointers.size > 1) downPos = null;
};
const onPointerDown = (e) => {
activePointers.add(e.pointerId);
// Pins remain tappable in page-scroll mode; only orbit gestures require opt-in.
if (activePointers.size !== 1 || e.isPrimary === false || e.button !== 0) {
downPos = null;
return;
}
downPos = { pointerId: e.pointerId, x: e.clientX, y: e.clientY, at: performance.now() };
};
const onPointerMove = (e) => {
if (downPos?.pointerId === e.pointerId && Math.hypot(e.clientX - downPos.x, e.clientY - downPos.y) > 6) {
downPos = null;
}
};
const onPointerUp = (e) => {
const wasOnlyPointer = activePointers.size === 1 && activePointers.has(e.pointerId);
activePointers.delete(e.pointerId);
const tap = downPos;
downPos = null;
if (!wasOnlyPointer || tap?.pointerId !== e.pointerId || performance.now() - tap.at > 800) return;
if (Math.hypot(e.clientX - tap.x, e.clientY - tap.y) > 6) return;
const rect = canvas.getBoundingClientRect();
if (rect.width <= 0 || rect.height <= 0) return;
if (e.clientX < rect.left || e.clientX > rect.right || e.clientY < rect.top || e.clientY > rect.bottom) return;
pointer.x = ((e.clientX - rect.left) / rect.width) * 2 - 1;
pointer.y = -((e.clientY - rect.top) / rect.height) * 2 + 1;
raycaster.setFromCamera(pointer, camera);
const selectablePins = pinMeshes.filter((pin) => {
if (st.activeLevel !== 0 && pin.userData.floorLevel !== st.activeLevel) return false;
for (let parent = pin; parent; parent = parent.parent) {
if (!parent.visible) return false;
}
return true;
});
const hits = raycaster.intersectObjects(selectablePins, true);
let obj = hits[0]?.object;
// The decorative pin is small; use a 44px minimum tap target around its visible center.
if (!obj) {
let distance = 22;
const projected = new THREE.Vector3();
for (const pin of selectablePins) {
pin.getWorldPosition(projected);
projected.project(camera);
if (projected.z < -1 || projected.z > 1) continue;
const x = rect.left + (projected.x + 1) * rect.width / 2;
const y = rect.top + (1 - projected.y) * rect.height / 2;
const candidateDistance = Math.hypot(e.clientX - x, e.clientY - y);
if (candidateDistance < distance) {
distance = candidateDistance;
obj = pin;
}
}
}
if (obj) {
while (obj && !obj.userData?.photoIds) {
obj = obj.parent;
}
if (obj && obj.userData?.photoIds && typeof onZoneSelect === "function") {
highlightZone(st.id, obj.userData.zoneLabel, JSON.stringify(obj.userData.photoIds));
onZoneSelect(obj.userData.zoneLabel || "구역", JSON.stringify(obj.userData.photoIds));
}
}
};
const onPointerCancel = (e) => {
activePointers.delete(e.pointerId);
downPos = null;
};
canvas.addEventListener("pointerdown", onPointerDown);
window.addEventListener("pointerdown", onActivePointerDown, true);
window.addEventListener("pointermove", onPointerMove, true);
canvas.addEventListener("lostpointercapture", onPointerCancel);
// Capture release/cancel even when a scrolling or dragged pointer leaves the canvas.
window.addEventListener("pointerup", onPointerUp, true);
window.addEventListener("pointercancel", onPointerCancel, true);
cleanup.push(() => {
canvas.removeEventListener("pointerdown", onPointerDown);
window.removeEventListener("pointerdown", onActivePointerDown, true);
window.removeEventListener("pointermove", onPointerMove, true);
canvas.removeEventListener("lostpointercapture", onPointerCancel);
window.removeEventListener("pointerup", onPointerUp, true);
window.removeEventListener("pointercancel", onPointerCancel, true);
});
function animate() {
raf = 0;
if (disposed || contextLost || document.hidden || !visible || !hasSize) return;
const t = performance.now() / 1000;
pinMeshes.forEach((pin, i) => {
pin.position.y = pin.userData.baseY + (reducedMotion.matches ? 0 : Math.sin(t * 2.6 + i) * 0.08);
pin.rotation.y = reducedMotion.matches ? 0 : t * 1.1 + i;
});
controls.update();
renderer.render(scene, camera);
if (!reducedMotion.matches) requestFrame();
}
const stopFrame = () => {
cancelAnimationFrame(raf);
raf = 0;
};
const onVisibilityChange = () => document.hidden ? stopFrame() : requestFrame();
document.addEventListener("visibilitychange", onVisibilityChange);
cleanup.push(() => { disposed = true; stopFrame(); document.removeEventListener("visibilitychange", onVisibilityChange); });
const intersectionObserver = new IntersectionObserver(([entry]) => {
visible = entry.isIntersecting;
visible ? requestFrame() : stopFrame();
});
intersectionObserver.observe(canvas);
cleanup.push(() => intersectionObserver.disconnect());
const onMotionChange = () => {
controls.enableDamping = !reducedMotion.matches;
requestFrame();
};
reducedMotion.addEventListener("change", onMotionChange);
controls.addEventListener("change", requestFrame);
cleanup.push(() => { reducedMotion.removeEventListener("change", onMotionChange); controls.removeEventListener("change", requestFrame); });
const onContextLost = (event) => {
event.preventDefault();
contextLost = true;
stopFrame();
reportSceneState(canvas, "공간 화면이 중단됐습니다. 잠시 후 다시 시도해 주세요.");
};
const onContextRestored = () => {
contextLost = false;
resize();
requestFrame();
reportSceneState(canvas, null);
};
canvas.addEventListener("webglcontextlost", onContextLost);
canvas.addEventListener("webglcontextrestored", onContextRestored);
cleanup.push(() => { canvas.removeEventListener("webglcontextlost", onContextLost); canvas.removeEventListener("webglcontextrestored", onContextRestored); });
const id = nextId++;
st = {
id,
renderer,
scene,
camera,
controls,
floorGroups,
pinMeshes,
ro,
interactionObserver,
coarsePointer,
onPointerModeChange,
resize,
requestFrame,
reducedMotion,
onMotionChange,
intersectionObserver,
onVisibilityChange,
onContextLost,
onContextRestored,
stopAnimation: () => {
disposed = true;
stopFrame();
},
canvas,
originalTouchAction,
onPointerDown,
onActivePointerDown,
onPointerMove,
onPointerUp,
onPointerCancel,
span,
activeLevel: 0,
viewMode: "3d",
};
scenes.set(id, st);
resetScene(id);
reportSceneState(canvas, null);
requestFrame();
return id;
}
function reportSceneState(canvas, message) {
canvas.dataset.sceneError = message || "";
canvas.dispatchEvent(new Event(message ? "scene-error" : "scene-ready", { bubbles: true }));
}
export function mountScene(canvas, layoutJson, onZoneSelect) {
const cleanup = [];
try {
return createScene(canvas, layoutJson, onZoneSelect, cleanup);
} catch (error) {
cleanup.reverse().forEach((dispose) => { try { dispose(); } catch { /* Finish the remaining cleanup. */ } });
console.warn("Space viewer could not start", error?.message);
reportSceneState(canvas, "공간 화면을 열 수 없습니다. 아래 정보와 사진을 확인하거나 다시 시도해 주세요.");
return 0;
}
}
export function setFloor(handle, level) {
const st = scenes.get(handle);
if (!st) return;
if (level !== 0 && !st.floorGroups.has(level)) return;
const previousY = floorTarget(st);
st.activeLevel = level;
const offsetY = floorTarget(st) - previousY;
st.camera.position.y += offsetY;
st.controls.target.y += offsetY;
st.floorGroups.forEach(({ group, yBase }, fLevel) => {
if (level === 0) {
group.visible = true;
setGroupOpacity(group, 1.0);
} else if (fLevel === level) {
group.visible = true;
setGroupOpacity(group, 1.0);
} else if (fLevel < level) {
group.visible = st.viewMode !== "plan";
setGroupOpacity(group, 0.18);
} else {
group.visible = false;
}
});
st.controls.update();
st.requestFrame();
}
function floorTarget(st) {
return st.floorGroups.get(st.activeLevel)?.yBase ?? Math.max(0, st.floorGroups.size - 1) * FLOOR_HEIGHT * 0.35;
}
export function setViewMode(handle, mode) {
const st = scenes.get(handle);
if (!st) return;
st.viewMode = mode === "plan" ? "plan" : "3d";
const plan = st.viewMode === "plan";
st.controls.enableRotate = !plan;
st.controls.minPolarAngle = 0;
st.controls.maxPolarAngle = plan ? 0 : Math.PI * 0.48;
st.controls.screenSpacePanning = true;
st.controls.mouseButtons.LEFT = plan ? THREE.MOUSE.PAN : THREE.MOUSE.ROTATE;
st.controls.touches.ONE = plan ? THREE.TOUCH.PAN : THREE.TOUCH.ROTATE;
st.controls.touches.TWO = THREE.TOUCH.DOLLY_PAN;
setFloor(handle, st.activeLevel);
resetScene(handle);
}
export function resetScene(handle) {
const st = scenes.get(handle);
if (!st) return;
const yTarget = floorTarget(st);
const s = st.span;
// Flush accumulated damping so reset and view changes do not inherit a prior gesture.
const damping = st.controls.enableDamping;
st.controls.enableDamping = false;
st.controls.update();
st.controls.enableDamping = damping;
st.controls.minDistance = Math.max(2, s * 0.18);
st.controls.maxDistance = s * 5;
if (st.viewMode === "plan") {
st.camera.position.set(0, yTarget + s * 1.65, 0.01);
st.controls.target.set(0, yTarget, 0);
} else {
st.camera.position.set(s * 1.15, yTarget + s * 1.0, s * 1.25);
st.controls.target.set(0, yTarget + 0.4, 0);
}
st.controls.update();
st.requestFrame();
}
export function zoomScene(handle, delta) {
const st = scenes.get(handle);
if (!st || !Number.isFinite(delta)) return;
const offset = st.camera.position.clone().sub(st.controls.target);
const distance = THREE.MathUtils.clamp(offset.length() * Math.exp(-delta * 0.18), st.controls.minDistance, st.controls.maxDistance);
st.camera.position.copy(st.controls.target).add(offset.setLength(distance));
st.controls.update();
st.requestFrame();
}
export function highlightZone(handle, label, photoIdsJson) {
const st = scenes.get(handle);
if (!st) return;
let photoIds = [];
try { photoIds = JSON.parse(photoIdsJson); } catch { /* An empty selection simply clears emphasis. */ }
st.scene.traverse((obj) => {
if (!obj.userData.zoneSurface) return;
const selected = Boolean(label) && obj.userData.zoneLabel === label &&
(!photoIds.length || obj.userData.photoIds.some((id) => photoIds.includes(id)));
obj.material.emissive.setHex(selected ? SCENE_COLORS.accent : 0x000000);
obj.material.emissiveIntensity = selected ? 0.23 : 0;
});
st.pinMeshes.forEach((pin) => {
const selected = Boolean(label) && pin.userData.zoneLabel === label &&
(!photoIds.length || pin.userData.photoIds.some((id) => photoIds.includes(id)));
pin.scale.setScalar(selected ? 1.4 : 1);
});
st.requestFrame();
}
export function disposeScene(handle) {
const st = scenes.get(handle);
if (!st) return;
st.stopAnimation();
st.ro.disconnect();
st.intersectionObserver.disconnect();
st.interactionObserver.disconnect();
st.coarsePointer.removeEventListener("change", st.onPointerModeChange);
st.reducedMotion.removeEventListener("change", st.onMotionChange);
document.removeEventListener("visibilitychange", st.onVisibilityChange);
window.removeEventListener("resize", st.resize);
st.canvas.removeEventListener("pointerdown", st.onPointerDown);
window.removeEventListener("pointerdown", st.onActivePointerDown, true);
window.removeEventListener("pointermove", st.onPointerMove, true);
st.canvas.removeEventListener("lostpointercapture", st.onPointerCancel);
window.removeEventListener("pointerup", st.onPointerUp, true);
window.removeEventListener("pointercancel", st.onPointerCancel, true);
st.canvas.removeEventListener("webglcontextlost", st.onContextLost);
st.canvas.removeEventListener("webglcontextrestored", st.onContextRestored);
st.controls.removeEventListener("change", st.requestFrame);
st.controls.dispose();
st.canvas.style.touchAction = st.originalTouchAction;
disposeSceneObjects(st.scene);
st.renderer.dispose();
scenes.delete(handle);
}
function disposeSceneObjects(scene) {
const geometries = new Set();
const materials = new Set();
scene.traverse((obj) => {
if (obj.geometry) geometries.add(obj.geometry);
if (obj.material) (Array.isArray(obj.material) ? obj.material : [obj.material]).forEach((m) => materials.add(m));
if (obj.shadow) obj.shadow.dispose();
});
geometries.forEach((geometry) => geometry.dispose());
materials.forEach((material) => material.dispose());
}
function setGroupOpacity(group, opacity) {
group.traverse((obj) => {
if (obj.isMesh && obj.material) {
const mats = Array.isArray(obj.material) ? obj.material : [obj.material];
mats.forEach((m) => {
if (m.userData.baseOpacity === undefined) {
m.userData.baseOpacity = m.opacity ?? 1.0;
m.userData.wasTransparent = m.transparent ?? false;
}
if (opacity < 0.99) {
m.transparent = true;
m.opacity = m.userData.baseOpacity * opacity;
} else {
m.transparent = m.userData.wasTransparent;
m.opacity = m.userData.baseOpacity;
}
});
}
});
}
// Convert floor local (x east 0..W, y north 0..D) into Three.js world (x east -W/2..W/2, z south -D/2..D/2)
// Note: local y=0 is SOUTH (front/entrance), which maps to z = +D/2 in Three.js so south faces the viewer.
function toWorldXZ(floor, lx, ly) {
return [lx - floor.width_m / 2, floor.depth_m / 2 - ly];
}
function buildFloorGroup(floor, yBase, pinMeshes) {
const group = new THREE.Group();
group.position.y = yBase;
const W = floor.width_m || 10;
const D = floor.depth_m || 10;
// Floor slab
const slabGeo = new THREE.BoxGeometry(W, 0.14, D);
const slabMat = new THREE.MeshStandardMaterial({ color: 0xf3ede2, roughness: 0.85 });
const slab = new THREE.Mesh(slabGeo, slabMat);
slab.position.y = -0.07;
slab.receiveShadow = true;
group.add(slab);
// Subtle perimeter walls (low cutaway height on South/East so interior is easy to see)
buildWalls(group, floor);
// Zones + furniture + pins
(floor.zones || []).forEach((zone) => {
const zg = buildZone(floor, zone, pinMeshes);
group.add(zg);
});
// Verticals (stairs / elevator)
(floor.verticals || []).forEach((v) => {
group.add(buildVertical(floor, v));
});
return group;
}
function buildWalls(group, floor) {
const W = floor.width_m;
const D = floor.depth_m;
const wallMat = new THREE.MeshStandardMaterial({ color: 0xd8d2c5, roughness: 0.75 });
const glassMat = new THREE.MeshStandardMaterial({
color: 0x8ecae6,
transparent: true,
opacity: 0.32,
roughness: 0.2,
});
const doorMat = new THREE.MeshStandardMaterial({ color: 0xe76f51, roughness: 0.6 });
// Back walls (North & West) full height; front walls (South & East) cutaway 0.9m so camera sees inside
const north = new THREE.Mesh(new THREE.BoxGeometry(W, WALL_HEIGHT, WALL_THICK), wallMat.clone());
north.position.set(0, WALL_HEIGHT / 2, -D / 2);
north.castShadow = true;
group.add(north);
const west = new THREE.Mesh(new THREE.BoxGeometry(WALL_THICK, WALL_HEIGHT, D), wallMat.clone());
west.position.set(-W / 2, WALL_HEIGHT / 2, 0);
west.castShadow = true;
group.add(west);
const lowH = 0.65;
const south = new THREE.Mesh(new THREE.BoxGeometry(W, lowH, WALL_THICK), wallMat.clone());
south.position.set(0, lowH / 2, D / 2);
group.add(south);
const east = new THREE.Mesh(new THREE.BoxGeometry(WALL_THICK, lowH, D), wallMat.clone());
east.position.set(W / 2, lowH / 2, 0);
group.add(east);
// Render openings (windows as glass panels, entrances as welcome mats + arch)
(floor.openings || []).forEach((op) => {
const len = Math.max(0.9, op.length_m || 1.5);
const off = op.offset_m || 1.0;
const isWindow = op.kind === "window";
const h = isWindow ? 1.5 : 2.1;
const yCenter = isWindow ? 1.3 : h / 2;
const mat = isWindow ? glassMat.clone() : doorMat.clone();
let mesh;
if (op.wall === "south" || op.wall === "north") {
mesh = new THREE.Mesh(new THREE.BoxGeometry(len, h, WALL_THICK * 1.3), mat);
const x = -W / 2 + off + len / 2;
const z = op.wall === "south" ? D / 2 : -D / 2;
mesh.position.set(x, yCenter, z);
} else {
mesh = new THREE.Mesh(new THREE.BoxGeometry(WALL_THICK * 1.3, h, len), mat);
const z = D / 2 - (off + len / 2);
const x = op.wall === "east" ? W / 2 : -W / 2;
mesh.position.set(x, yCenter, z);
}
group.add(mesh);
});
}
function buildZone(floor, zone, pinMeshes) {
const g = new THREE.Group();
const [wx, wz] = toWorldXZ(floor, zone.x + zone.w / 2, zone.y + zone.d / 2);
g.position.set(wx, 0.02, wz);
const color = ZONE_COLORS[zone.kind] || ZONE_COLORS.other;
const pad = new THREE.Mesh(
new THREE.BoxGeometry(Math.max(0.8, zone.w - 0.12), 0.04, Math.max(0.8, zone.d - 0.12)),
new THREE.MeshStandardMaterial({ color, roughness: 0.9 })
);
pad.receiveShadow = true;
pad.userData = { zoneSurface: true, zoneLabel: zone.label || zone.kind, photoIds: zone.evidence_photos || [] };
g.add(pad);
// Place furniture groups inside the zone
(zone.furniture || []).forEach((fg) => {
populateFurniture(g, zone.w, zone.d, fg);
});
// If this zone has evidence photos, place a glowing interactive pin above it
if (zone.evidence_photos && zone.evidence_photos.length > 0) {
const pin = buildPin(zone.label || zone.kind, zone.evidence_photos);
pin.position.set(0, 1.65, 0);
pin.userData.baseY = 1.65;
pin.userData.floorLevel = floor.level;
g.add(pin);
pinMeshes.push(pin);
}
return g;
}
function populateFurniture(zoneGroup, zw, zd, fg) {
const count = Math.min(24, Math.max(1, fg.count || 1));
const cols = Math.max(1, Math.ceil(Math.sqrt(count * (zw / Math.max(1, zd)))));
const rows = Math.max(1, Math.ceil(count / cols));
const cellW = (zw * 0.82) / cols;
const cellD = (zd * 0.82) / rows;
for (let i = 0; i < count; i++) {
const r = Math.floor(i / cols);
const c = i % cols;
const x = -zw * 0.41 + (c + 0.5) * cellW;
const z = -zd * 0.41 + (r + 0.5) * cellD;
const item = buildFurnitureMesh(fg.kind, cellW, cellD);
item.position.set(x, 0.02, z);
zoneGroup.add(item);
}
}
function buildFurnitureMesh(kind, cellW, cellD) {
const g = new THREE.Group();
const wood = new THREE.MeshStandardMaterial({ color: 0x8b5e3c, roughness: 0.7 });
const darkWood = new THREE.MeshStandardMaterial({ color: 0x5c3d28, roughness: 0.75 });
const chairMat = new THREE.MeshStandardMaterial({ color: 0x3d405b, roughness: 0.8 });
const sofaMat = new THREE.MeshStandardMaterial({ color: 0x6b705c, roughness: 0.85 });
const metal = new THREE.MeshStandardMaterial({ color: 0xadb5bd, metalness: 0.5, roughness: 0.4 });
const leaf = new THREE.MeshStandardMaterial({ color: 0x52b788, roughness: 0.8 });
if (kind === "counter_bar") {
const w = Math.min(2.6, Math.max(1.2, cellW * 0.9));
const d = Math.min(1.0, Math.max(0.65, cellD * 0.6));
const body = new THREE.Mesh(new THREE.BoxGeometry(w, 0.95, d), darkWood);
body.position.y = 0.475;
body.castShadow = true;
g.add(body);
const machine = new THREE.Mesh(new THREE.BoxGeometry(0.45, 0.35, 0.35), metal);
machine.position.set(-w * 0.2, 1.12, 0);
g.add(machine);
return g;
}
if (kind === "bar_seat") {
const stool = new THREE.Mesh(new THREE.CylinderGeometry(0.2, 0.2, 0.68, 12), chairMat);
stool.position.y = 0.34;
stool.castShadow = true;
g.add(stool);
return g;
}
if (kind === "sofa") {
const seat = new THREE.Mesh(new THREE.BoxGeometry(1.3, 0.42, 0.65), sofaMat);
seat.position.y = 0.21;
seat.castShadow = true;
const back = new THREE.Mesh(new THREE.BoxGeometry(1.3, 0.45, 0.16), sofaMat);
back.position.set(0, 0.55, -0.24);
g.add(seat, back);
return g;
}
if (kind === "plant") {
const pot = new THREE.Mesh(new THREE.CylinderGeometry(0.22, 0.16, 0.36, 12), darkWood);
pot.position.y = 0.18;
const crown = new THREE.Mesh(new THREE.SphereGeometry(0.36, 12, 10), leaf);
crown.position.y = 0.62;
crown.castShadow = true;
g.add(pot, crown);
return g;
}
// Tables (table2, table4, table6, communal_table)
const isLarge = kind === "table6" || kind === "communal_table";
const isFour = kind === "table4";
const tw = isLarge ? 1.5 : isFour ? 0.95 : 0.68;
const td = isLarge ? 0.8 : 0.68;
const top = new THREE.Mesh(new THREE.BoxGeometry(tw, 0.06, td), wood);
top.position.y = 0.72;
top.castShadow = true;
const leg = new THREE.Mesh(new THREE.CylinderGeometry(0.06, 0.08, 0.7, 10), metal);
leg.position.y = 0.35;
g.add(top, leg);
const chairOffsets = isLarge
? [
[-0.45, -0.52],
[0, -0.52],
[0.45, -0.52],
[-0.45, 0.52],
[0, 0.52],
[0.45, 0.52],
]
: isFour
? [
[-0.24, -0.48],
[0.24, -0.48],
[-0.24, 0.48],
[0.24, 0.48],
]
: [
[0, -0.46],
[0, 0.46],
];
chairOffsets.forEach(([cx, cz]) => {
const ch = new THREE.Mesh(new THREE.BoxGeometry(0.32, 0.44, 0.32), chairMat);
ch.position.set(cx, 0.22, cz);
ch.castShadow = true;
g.add(ch);
});
return g;
}
function buildVertical(floor, v) {
const g = new THREE.Group();
const [wx, wz] = toWorldXZ(floor, v.x + v.w / 2, v.y + v.d / 2);
g.position.set(wx, 0, wz);
const mat = new THREE.MeshStandardMaterial({ color: 0xadb5bd, roughness: 0.6 });
if (v.kind === "elevator") {
const box = new THREE.Mesh(new THREE.BoxGeometry(v.w, WALL_HEIGHT, v.d), mat);
box.position.y = WALL_HEIGHT / 2;
g.add(box);
} else {
const steps = 8;
for (let i = 0; i < steps; i++) {
const sh = ((i + 1) / steps) * (WALL_HEIGHT * 0.85);
const step = new THREE.Mesh(new THREE.BoxGeometry(v.w, sh, v.d / steps), mat);
step.position.set(0, sh / 2, -v.d / 2 + ((i + 0.5) * v.d) / steps);
step.castShadow = true;
g.add(step);
}
}
return g;
}
function buildPin(zoneLabel, photoIds) {
const g = new THREE.Group();
g.userData = { zoneLabel, photoIds };
const headMat = new THREE.MeshStandardMaterial({
color: SCENE_COLORS.accent,
emissive: SCENE_COLORS.accent,
emissiveIntensity: 0.18,
roughness: 0.3,
});
const head = new THREE.Mesh(new THREE.OctahedronGeometry(0.24, 0), headMat);
head.position.y = 0.2;
const stem = new THREE.Mesh(
new THREE.CylinderGeometry(0.03, 0.03, 0.35, 8),
new THREE.MeshBasicMaterial({ color: SCENE_COLORS.accent })
);
g.add(head, stem);
return g;
}
+184
View File
@@ -0,0 +1,184 @@
import assert from "node:assert/strict";
import { readFile } from "node:fs/promises";
import vm from "node:vm";
import { test } from "node:test";
import * as Three from "../../public/vendor/three/three.module.js";
// Exercise real scene geometry/camera math with a minimal rendering boundary. No DOM or GPU
// is required: these tests cover gesture arbitration and view state, not WebGL rendering.
const source = (await readFile(new URL("./scene.js", import.meta.url), "utf8"))
.replace(/^import .*;\r?\n/gm, "")
.replace(/^export /gm, "");
class Surface extends EventTarget {
style = { touchAction: "" };
dataset = {};
hidden = false;
getBoundingClientRect() { return { left: 0, top: 0, right: 390, bottom: 460, width: 390, height: 460 }; }
}
function setup({ reduced = false } = {}) {
const window = new Surface();
const document = new Surface();
const canvas = new Surface();
const frames = new Map();
let nextFrame = 1;
let failRenderer = false;
class Renderer {
shadowMap = {};
setClearColor() {}
setPixelRatio() {}
setSize() {}
constructor() { if (failRenderer) throw new Error("GPU unavailable"); }
render(scene, camera) { scene.updateMatrixWorld(true); camera.updateMatrixWorld(true); }
dispose() { this.disposed = true; }
}
class Controls extends Three.EventDispatcher {
target = new Three.Vector3();
mouseButtons = {};
touches = {};
minDistance = 0;
maxDistance = Infinity;
update() {}
dispose() { this.disposed = true; }
}
class Observer { observe() {} disconnect() { this.disconnected = true; } }
window.matchMedia = (query) => Object.assign(new Surface(), {
matches: query === "(pointer: coarse)" || (query.includes("reduced-motion") && reduced),
});
window.devicePixelRatio = 1;
const context = vm.createContext({
THREE: { ...Three, WebGLRenderer: Renderer }, OrbitControls: Controls,
window, document, Event, performance, console: { warn() {} },
ResizeObserver: Observer, MutationObserver: Observer, IntersectionObserver: Observer,
requestAnimationFrame(callback) { const id = nextFrame++; frames.set(id, callback); return id; },
cancelAnimationFrame(id) { frames.delete(id); },
});
vm.runInContext(`${source}\nthis.api = {mountScene,setFloor,setViewMode,resetScene,zoomScene,highlightZone,disposeScene,scenes};`, context);
const api = context.api;
const selected = [];
const layout = JSON.stringify({ floors: [1, 2].map((level) => ({
level, width_m: 10, depth_m: 10, openings: [], verticals: [],
zones: [{ label: `층${level}`, kind: "seating", x: 1, y: 1, w: 4, d: 4, furniture: [], evidence_photos: [`p${level}`] }],
})) });
const mount = () => api.mountScene(canvas, layout, (label) => selected.push(label));
const handle = mount();
const st = api.scenes.get(handle);
const frame = () => {
const batch = [...frames.values()];
frames.clear();
batch.forEach((callback) => callback());
};
frame();
function point(pin = st.pinMeshes[0]) {
st.scene.updateMatrixWorld(true);
st.camera.lookAt(st.controls.target);
st.camera.updateMatrixWorld(true);
const v = pin.getWorldPosition(new Three.Vector3()).project(st.camera);
return { x: (v.x + 1) * 195, y: (1 - v.y) * 230 };
}
function pointer(target, type, { id = 1, x, y, primary = true } = {}) {
const event = new Event(type, { cancelable: true });
Object.assign(event, { pointerId: id, clientX: x, clientY: y, isPrimary: primary, button: 0 });
target.dispatchEvent(event);
}
return { api, canvas, window, document, selected, handle, st, frame, point, pointer, frames, mount, fail: () => { failRenderer = true; } };
}
test("photo pins work while page scrolling is enabled", () => {
const t = setup();
assert.equal(t.canvas.style.touchAction, "pan-y");
assert.equal(t.st.controls.enabled, false);
t.api.setFloor(t.handle, 1);
const p = t.point();
t.pointer(t.canvas, "pointerdown", p);
t.pointer(t.window, "pointerup", p);
assert.deepEqual(t.selected, ["층1"]);
t.api.disposeScene(t.handle);
});
test("scroll, cancelled, and multi-touch gestures cannot select a pin", () => {
const t = setup();
const p = t.point();
t.pointer(t.canvas, "pointerdown", p);
t.pointer(t.window, "pointermove", { x: p.x, y: p.y + 12 });
t.pointer(t.window, "pointerup", p);
t.pointer(t.canvas, "pointerdown", p);
t.pointer(t.window, "pointercancel", p);
t.pointer(t.window, "pointerup", p);
t.pointer(t.canvas, "pointerdown", p);
t.pointer(t.canvas, "pointerdown", { ...p, id: 2, primary: false });
t.pointer(t.window, "pointerup", { ...p, id: 2, primary: false });
t.pointer(t.window, "pointerup", p);
t.pointer(t.canvas, "pointerdown", p);
t.pointer(t.window, "pointerdown", { ...p, id: 2, primary: false });
t.pointer(t.window, "pointerup", p);
t.pointer(t.window, "pointerup", { ...p, id: 2, primary: false });
assert.deepEqual(t.selected, []);
t.api.disposeScene(t.handle);
});
test("plan mode locks rotation and floor changes preserve its zoom and orientation", () => {
const t = setup();
t.api.setFloor(t.handle, 1);
t.api.setViewMode(t.handle, "plan");
assert.equal(t.st.controls.enableRotate, false);
assert.equal(t.st.controls.maxPolarAngle, 0);
assert.equal(t.st.controls.touches.ONE, Three.TOUCH.PAN);
t.api.zoomScene(t.handle, 1);
const offset = t.st.camera.position.clone().sub(t.st.controls.target);
t.api.setFloor(t.handle, 2);
assert.ok(offset.distanceTo(t.st.camera.position.clone().sub(t.st.controls.target)) < 1e-10);
assert.equal(t.st.floorGroups.get(1).group.visible, false);
t.api.setViewMode(t.handle, "3d");
assert.equal(t.st.controls.enableRotate, true);
assert.equal(t.st.floorGroups.get(1).group.visible, true);
assert.equal(t.st.activeLevel, 2);
t.api.disposeScene(t.handle);
});
test("reduced motion renders on demand and freezes decorative pins", () => {
const t = setup({ reduced: true });
assert.equal(t.st.controls.enableDamping, false);
assert.equal(t.frames.size, 0);
assert.ok(t.st.pinMeshes.every((pin) => pin.rotation.y === 0 && pin.position.y === pin.userData.baseY));
t.api.zoomScene(t.handle, 1);
assert.equal(t.frames.size, 1);
t.frame();
assert.equal(t.frames.size, 0);
t.api.disposeScene(t.handle);
});
test("context loss reports a recoverable state and disposal cancels work", () => {
const t = setup();
let errors = 0;
let ready = 0;
t.canvas.addEventListener("scene-error", () => errors++);
t.canvas.addEventListener("scene-ready", () => ready++);
const lost = new Event("webglcontextlost", { cancelable: true });
t.canvas.dispatchEvent(lost);
assert.equal(lost.defaultPrevented, true);
assert.equal(errors, 1);
assert.ok(t.canvas.dataset.sceneError);
assert.equal(t.frames.size, 0);
t.canvas.dispatchEvent(new Event("webglcontextrestored"));
assert.equal(ready, 1);
assert.equal(t.canvas.dataset.sceneError, "");
t.api.disposeScene(t.handle);
assert.equal(t.api.scenes.size, 0);
assert.equal(t.frames.size, 0);
assert.equal(t.st.renderer.disposed, true);
assert.equal(t.st.controls.disposed, true);
assert.equal(t.canvas.style.touchAction, "");
t.canvas.dispatchEvent(new Event("webglcontextlost", { cancelable: true }));
assert.equal(errors, 1);
});
test("unavailable WebGL returns an explicit failure handle instead of throwing", () => {
const t = setup();
t.api.disposeScene(t.handle);
t.fail();
assert.equal(t.mount(), 0);
assert.ok(t.canvas.dataset.sceneError);
assert.equal(t.api.scenes.size, 0);
});
+186
View File
@@ -0,0 +1,186 @@
// Small browser-only interactions shared by the hydrated views.
const scrollPositions = new Map();
const dialogs = new Map();
const watchers = new Map();
let nextHandle = 1;
let scrollLock = null;
let restoreGeneration = 0;
export function saveScroll(key) {
restoreGeneration += 1;
scrollPositions.set(key, window.scrollY);
}
export function restoreScroll(destination) {
const target = new URL(destination, location.href);
const top = scrollPositions.get(target.pathname) || 0;
const route = target.pathname + target.search;
const previousRoute = location.pathname + location.search;
const generation = ++restoreGeneration;
let attempts = 0;
const afterCommit = () => {
if (generation !== restoreGeneration) return;
const currentRoute = location.pathname + location.search;
// Leptos constructs the destination before committing the browser URL.
// Wait for that commit, but abandon a canceled or superseded navigation.
if (currentRoute !== route) {
if (currentRoute === previousRoute && ++attempts < 60) requestAnimationFrame(afterCommit);
return;
}
requestAnimationFrame(() => {
if (generation === restoreGeneration && location.pathname + location.search === route) {
window.scrollTo({ top, behavior: "instant" });
}
});
};
requestAnimationFrame(afterCommit);
}
export function focusSearch() {
document.querySelector('input[name="q"]')?.focus({ preventScroll: true });
}
export function blurActive() {
if (document.activeElement instanceof HTMLElement) document.activeElement.blur();
}
export function closeMenu(id) { document.getElementById(id)?.removeAttribute("open"); }
export function clearJobQuery() {
const url = new URL(location.href);
if (url.searchParams.has("job")) {
url.searchParams.delete("job");
history.replaceState(history.state, "", url);
}
}
export function revealSelectedPhoto() {
requestAnimationFrame(() => {
if (isCompact() || document.querySelector('dialog:modal')) return;
const panel = document.getElementById('info-panel');
if (panel) panel.scrollTop = 0;
panel?.querySelector('.selected-zone-panel')?.scrollIntoView({ block: 'nearest', behavior: 'instant' });
});
}
export function isCompact() {
return matchMedia("(max-width: 639px), (max-height: 499px)").matches;
}
export function watchCompact(onChange) {
const handle = nextHandle++;
const media = matchMedia("(max-width: 639px), (max-height: 499px)");
const listener = () => onChange(media.matches);
media.addEventListener("change", listener);
watchers.set(handle, { media, listener });
listener();
return handle;
}
export function releaseWatch(handle) {
const watcher = watchers.get(handle);
if (watcher) watcher.media.removeEventListener("change", watcher.listener);
watchers.delete(handle);
}
function unlockScroll() {
if (scrollLock && ![...dialogs.values()].some(record => !record.finished)) {
document.documentElement.style.overflow = scrollLock.html;
document.body.style.overflow = scrollLock.body;
scrollLock = null;
}
}
function finishDialog(record, notify = true) {
if (record.finished) return;
record.finished = true;
record.dialog.removeEventListener("cancel", record.cancel);
record.dialog.removeEventListener("close", record.closed);
record.dialog.removeEventListener("click", record.backdrop);
record.dialog.removeAttribute("aria-modal");
if (record.dialog.open) record.dialog.close();
if (record.inline && record.dialog.isConnected) record.dialog.show();
unlockScroll();
if (location.pathname + location.search === record.route) {
window.scrollTo({ top: record.scrollY, behavior: "instant" });
if (record.focus?.isConnected) record.focus.focus({ preventScroll: true });
}
if (notify) queueMicrotask(() => {
if (dialogs.get(record.handle) === record) record.onClose();
});
}
function requestClose(record) {
if (record.finished || record.pending) return;
if (history.state?.spaceOverlay === record.token) {
record.pending = true;
history.back();
} else {
finishDialog(record);
}
}
window.addEventListener("popstate", () => {
for (const record of [...dialogs.values()].reverse()) {
if (!record.finished && history.state?.spaceOverlay !== record.token) finishDialog(record);
else if (!record.finished) break;
}
});
export function openDialog(id, onClose) {
const dialog = document.getElementById(id);
if (!(dialog instanceof HTMLDialogElement)) return 0;
const existing = [...dialogs.values()].find(record => record.dialog === dialog && !record.finished);
if (existing) {
// The Rust bridge replaces its stored Closure for a reused handle.
existing.onClose = onClose;
return existing.handle;
}
const handle = nextHandle++;
const record = {
handle, dialog, onClose, token: `space-${handle}-${Date.now()}`,
focus: document.activeElement instanceof HTMLElement ? document.activeElement : null,
inline: dialog.hasAttribute("data-inline-dialog"),
scrollY: window.scrollY, route: location.pathname + location.search,
finished: false, pending: false,
};
record.cancel = event => { event.preventDefault(); requestClose(record); };
record.closed = () => {
// close() before showModal() queues an event; ignore it while the new modal is open.
if (!dialog.open && !record.finished) requestClose(record);
};
record.backdrop = event => {
if (event.target !== dialog) return;
const rect = dialog.getBoundingClientRect();
if (event.clientX < rect.left || event.clientX > rect.right || event.clientY < rect.top || event.clientY > rect.bottom) requestClose(record);
};
if (!scrollLock) {
scrollLock = { html: document.documentElement.style.overflow, body: document.body.style.overflow };
document.documentElement.style.overflow = "hidden";
document.body.style.overflow = "hidden";
}
dialogs.set(handle, record);
if (dialog.open) dialog.close();
try {
dialog.showModal();
} catch {
dialogs.delete(handle);
if (record.inline && dialog.isConnected) dialog.show();
unlockScroll();
return 0;
}
dialog.setAttribute("aria-modal", "true");
dialog.addEventListener("cancel", record.cancel);
dialog.addEventListener("close", record.closed);
dialog.addEventListener("click", record.backdrop);
history.pushState({ ...history.state, spaceOverlay: record.token }, "");
const focusTarget = dialog.querySelector("[autofocus], button:not([disabled]), [href], [tabindex='0']");
focusTarget?.focus({ preventScroll: true });
return handle;
}
export function closeDialog(id) {
const record = [...dialogs.values()].reverse().find(entry => entry.dialog.id === id && !entry.finished);
if (record) requestClose(record);
}
export function releaseDialog(handle) {
const record = dialogs.get(handle);
if (!record) return;
// Route disposal must not initiate a second navigation. Explicit close consumes history.
finishDialog(record, false);
dialogs.delete(handle);
}
export function copyText(value, onResult) {
if (!navigator.clipboard?.writeText) { onResult(false); return; }
navigator.clipboard.writeText(value).then(() => onResult(true), () => onResult(false));
}
+306
View File
@@ -0,0 +1,306 @@
import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import test from "node:test";
import vm from "node:vm";
const source = readFileSync(new URL("./ui.js", import.meta.url), "utf8");
// The fake environment models asynchronous close/popstate delivery deliberately:
// it catches lifetime mistakes hidden by a synchronous history.back() stub.
function setup() {
const tasks = [];
const microtasks = [];
const frames = [];
const elements = new Map();
const scrollCalls = [];
const document = {
activeElement: null,
documentElement: { style: { overflow: "auto" } },
body: { style: { overflow: "" } },
getElementById: id => elements.get(id),
querySelector: () => null,
};
class Element extends EventTarget {
isConnected = true;
focusCount = 0;
focus() { this.focusCount += 1; document.activeElement = this; }
blur() { if (document.activeElement === this) document.activeElement = null; }
}
class Dialog extends Element {
constructor(id, { inline = false } = {}) {
super();
this.id = id;
this.open = inline;
this.modal = false;
this.attributes = new Map(inline ? [["data-inline-dialog", "true"]] : []);
this.firstButton = new Element();
elements.set(id, this);
}
hasAttribute(name) { return this.attributes.has(name); }
setAttribute(name, value) { this.attributes.set(name, value); }
removeAttribute(name) { this.attributes.delete(name); }
querySelector() { return this.firstButton; }
show() { this.open = true; this.modal = false; }
showModal() {
if (this.open) throw new Error("A nonmodal dialog must be closed first");
this.open = true;
this.modal = true;
}
close() {
if (!this.open) return;
this.open = false;
this.modal = false;
tasks.push(() => this.dispatchEvent(new Event("close")));
}
getBoundingClientRect() { return { left: 10, top: 10, right: 300, bottom: 500 }; }
}
const window = new EventTarget();
window.scrollY = 340;
window.scrollTo = options => {
window.scrollY = options.top;
scrollCalls.push(options.top);
};
const location = new URL("http://localhost/place/kakao:123?from=%2Frecent");
const entries = [{ router: "base" }];
let historyIndex = 0;
const history = {
backCalls: 0,
get state() { return entries[historyIndex]; },
pushState(state) {
entries.splice(historyIndex + 1);
entries.push(state);
historyIndex += 1;
},
replaceState(state) { entries[historyIndex] = state; },
back() {
this.backCalls += 1;
tasks.push(() => {
if (historyIndex === 0) return;
historyIndex -= 1;
window.dispatchEvent(new Event("popstate"));
});
},
};
const context = {
window, document, location, history, URL, Event,
HTMLElement: Element, HTMLDialogElement: Dialog,
navigator: {},
queueMicrotask: callback => microtasks.push(callback),
requestAnimationFrame: callback => frames.push(callback),
matchMedia: () => Object.assign(new EventTarget(), { matches: false }),
};
const exports = ["saveScroll", "restoreScroll", "openDialog", "closeDialog", "releaseDialog"];
const api = vm.runInNewContext(
`${source.replace(/^export /gm, "")}\n({ ${exports.join(", ")} })`,
context,
{ filename: "ui.js" },
);
function flush() {
while (tasks.length || microtasks.length) {
while (microtasks.length) microtasks.shift()();
if (tasks.length) tasks.shift()();
}
}
function flushFrames() {
while (frames.length) frames.shift()();
}
function nextFrame() { frames.shift()?.(); }
return { api, Dialog, Element, document, window, location, history, entries, scrollCalls, flush, flushFrames, nextFrame };
}
test("nested modal close consumes only the inner history entry and retains the outer scroll lock", () => {
const env = setup();
const { api, document, history, flush } = env;
const opener = new env.Element();
opener.focus();
const scene = new env.Dialog("scene", { inline: true });
const photo = new env.Dialog("photo");
let sceneClosed = 0;
let photoClosed = 0;
api.openDialog("scene", () => sceneClosed++);
const innerOpener = new env.Element();
innerOpener.focus();
api.openDialog("photo", () => photoClosed++);
api.closeDialog("photo");
assert.equal(photo.open, true, "close is pending its history traversal");
flush();
assert.equal(photo.open, false);
assert.equal(photoClosed, 1);
assert.equal(sceneClosed, 0);
assert.equal(scene.open, true);
assert.equal(scene.modal, true);
assert.equal(document.body.style.overflow, "hidden");
assert.equal(document.activeElement, innerOpener);
assert.equal(history.state.spaceOverlay, env.entries[1].spaceOverlay);
api.closeDialog("scene");
flush();
assert.equal(sceneClosed, 1);
assert.equal(scene.open, true, "the inline canvas remains rendered");
assert.equal(scene.modal, false);
assert.equal(document.body.style.overflow, "");
assert.equal(document.documentElement.style.overflow, "auto");
assert.equal(document.activeElement, opener);
assert.equal(history.backCalls, 2);
});
test("the queued close event from promoting an inline dialog does not dismiss its modal", () => {
const env = setup();
const dialog = new env.Dialog("scene", { inline: true });
let closed = 0;
env.api.openDialog("scene", () => closed++);
env.flush();
assert.equal(dialog.modal, true);
assert.equal(dialog.open, true);
assert.equal(closed, 0);
assert.equal(env.history.backCalls, 0);
const cancel = new Event("cancel", { cancelable: true });
dialog.dispatchEvent(cancel);
assert.equal(cancel.defaultPrevented, true);
env.flush();
assert.equal(dialog.open, true);
assert.equal(dialog.modal, false);
assert.equal(closed, 1);
});
test("reopening an already open dialog replaces the callback without adding history", () => {
const env = setup();
new env.Dialog("photo");
let oldCalls = 0;
let newCalls = 0;
const first = env.api.openDialog("photo", () => oldCalls++);
const second = env.api.openDialog("photo", () => newCalls++);
assert.equal(second, first);
assert.equal(env.entries.length, 2);
env.api.closeDialog("photo");
env.flush();
assert.equal(oldCalls, 0, "the old Rust Closure can safely be dropped");
assert.equal(newCalls, 1);
});
test("component release restores inline content without navigating history or notifying disposed state", () => {
const env = setup();
const scene = new env.Dialog("scene", { inline: true });
let closed = 0;
const handle = env.api.openDialog("scene", () => closed++);
// The URL can still be the old route while a router disposes its component.
env.api.releaseDialog(handle);
env.flush();
assert.equal(env.history.backCalls, 0);
assert.equal(scene.open, true);
assert.equal(scene.modal, false);
assert.equal(env.document.body.style.overflow, "");
assert.equal(closed, 0);
});
test("close followed by immediate release cannot call a dropped callback after popstate", () => {
const env = setup();
const photo = new env.Dialog("photo");
const handle = env.api.openDialog("photo", () => assert.fail("disposed callback invoked"));
env.api.closeDialog("photo");
env.api.releaseDialog(handle);
env.flush();
assert.equal(env.history.backCalls, 1);
assert.equal(photo.open, false);
assert.equal(env.document.body.style.overflow, "");
});
test("browser back closes nested dialogs from top to bottom", () => {
const env = setup();
const scene = new env.Dialog("scene", { inline: true });
const photo = new env.Dialog("photo");
const notifications = [];
env.api.openDialog("scene", () => notifications.push("scene"));
env.api.openDialog("photo", () => notifications.push("photo"));
env.history.back();
env.flush();
assert.deepEqual(notifications, ["photo"]);
assert.equal(photo.open, false);
assert.equal(scene.modal, true);
env.history.back();
env.flush();
assert.deepEqual(notifications, ["photo", "scene"]);
assert.equal(scene.open, true);
assert.equal(scene.modal, false);
});
test("native dialog close still consumes overlay history once", () => {
const env = setup();
const photo = new env.Dialog("photo");
let closed = 0;
env.api.openDialog("photo", () => closed++);
photo.close();
env.flush();
assert.equal(env.history.backCalls, 1);
assert.equal(closed, 1);
assert.equal(env.document.body.style.overflow, "");
});
test("a deferred search scroll restore cannot affect a different query on the same route", () => {
const env = setup();
env.location.pathname = "/";
env.location.search = "?q=first";
env.window.scrollY = 620;
env.api.saveScroll("/");
env.window.scrollY = 0;
env.api.restoreScroll("/?q=first");
env.location.search = "?q=second";
env.flushFrames();
assert.deepEqual(env.scrollCalls, []);
env.location.search = "?q=first";
env.api.restoreScroll("/?q=first");
env.flushFrames();
assert.deepEqual(env.scrollCalls, [620]);
});
test("search restoration waits for the router's destination URL commit", () => {
const env = setup();
env.location.pathname = "/";
env.location.search = "?q=first";
env.window.scrollY = 89;
env.api.saveScroll("/");
env.location.pathname = "/recent";
env.location.search = "";
env.window.scrollY = 0;
// The new Home component exists while browser location still says /recent.
env.api.restoreScroll("/?q=first");
env.nextFrame();
assert.deepEqual(env.scrollCalls, []);
env.location.pathname = "/";
env.location.search = "?q=first";
env.flushFrames();
assert.deepEqual(env.scrollCalls, [89]);
});
test("a newer navigation cancels a pending restoration before its URL commits", () => {
const env = setup();
env.window.scrollY = 89;
env.api.saveScroll("/");
env.location.pathname = "/recent";
env.location.search = "";
env.api.restoreScroll("/?q=first");
env.nextFrame();
env.api.saveScroll("/recent");
env.location.pathname = "/";
env.location.search = "?q=first";
env.flushFrames();
assert.deepEqual(env.scrollCalls, []);
});
test("releasing a dialog after route change does not restore focus or scroll into the old page", () => {
const env = setup();
const opener = new env.Element();
opener.focus();
new env.Dialog("photo");
const handle = env.api.openDialog("photo", () => assert.fail("disposed callback invoked"));
env.location.pathname = "/recent";
env.location.search = "";
env.api.releaseDialog(handle);
env.flush();
assert.equal(opener.focusCount, 1);
assert.deepEqual(env.scrollCalls, []);
assert.equal(env.history.backCalls, 0);
});
+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!["바 좌석", "소파"]
);
}
}