/* 프로젝트 관리(아사나식) 모듈 — 프론트엔드.
* 두 페이지에서 공용:
* - index.html (홈): 새 프로젝트 모달
* - project.html: 달력/타임라인/보드/리스트 뷰 + 업무 CRUD + 서브/멤버 관리
* 의존: FullCalendar(전역), vis(전역). 둘 다 project.html 에서만 로드.
*/
(function () {
"use strict";
// ── 공용 fetch ─────────────────────────────────────────────
const navigationSavers = [];
let navigationWrites = 0;
// 오른쪽 회의록을 바꾸기 전에 입력 칸 저장을 끝낸다. 실패하면 기존 화면을 유지한다.
window.PJFlushForNavigation = async function () {
if (document.activeElement && document.activeElement.blur) document.activeElement.blur();
await Promise.all(navigationSavers.map(function (flush) { return flush(); }));
if (navigationWrites) throw new Error("저장 중입니다. 저장이 끝난 뒤 다시 이동해 주세요.");
};
// extra.keepalive — 페이지를 떠나는 중에도 요청을 보내 달라고 브라우저에 부탁(보장은 아님, createFieldSaver 참고)
async function api(method, url, body, extra) {
const writing = method !== "GET";
if (writing) navigationWrites++;
try {
const opts = { method, headers: { "Content-Type": "application/json" } };
if (body !== undefined) opts.body = JSON.stringify(body);
if (extra && extra.keepalive) opts.keepalive = true;
const res = await fetch(url, opts);
if (!res.ok) {
let msg = res.statusText, detail = null;
try { detail = (await res.json()).detail; } catch (_) {}
if (typeof detail === "string") msg = detail;
else if (detail && detail.message) msg = detail.message;
const err = new Error(msg);
err.status = res.status; // 403(권한 없음)·404 를 일시 오류와 구분하려고
err.detail = detail;
throw err;
}
if (res.status === 204) return null;
return await res.json();
} finally { if (writing) navigationWrites--; }
}
function el(id) { return document.getElementById(id); }
// 한글 등 입력기 조합 중의 Enter(조합 확정)인지 — 이때는 전송·추가를 하지 않는다. 크롬·엣지는
// isComposing, 사파리·예전 브라우저는 keyCode 229 로 알려 준다. 조합이 끝난 뒤의 Enter 만 제출.
function isImeEnter(e) {
return !!(e && (e.isComposing || e.keyCode === 229));
}
// 댓글 한 건을 가리키는 임시 번호 — 같은 댓글을 다시 보내도(응답 유실·연타) 서버가 한 번만 만든다.
function newClientToken() {
try { if (window.crypto && crypto.randomUUID) return crypto.randomUUID(); } catch (_) {}
return Date.now().toString(36) + "-" + Math.random().toString(36).slice(2, 12);
}
// ── 확인/알림/입력 창 — 브라우저 기본 창 대신 공용 창(erp-dialog.js). 프로젝트
// 관리 화면의 창 제목은 전부 "KSN 프로그램". 이 파일 안의 alert/confirm/prompt 는
// 아래 함수가 가린다 — confirm/prompt 는 Promise 라서 쓰는 곳은 await 한다.
window.ERP_DIALOG_TITLE = "KSN 프로그램";
function alert(msg) {
if (window.erpAlert) window.erpAlert(msg); else window.alert(msg);
}
function confirm(msg, opts) {
return window.erpConfirm ? window.erpConfirm(msg, opts) : Promise.resolve(window.confirm(msg));
}
function prompt(msg, def) {
return window.erpPrompt ? window.erpPrompt(msg, def) : Promise.resolve(window.prompt(msg, def));
}
// 화면 배율 토글(_help_btn.html, html.pj-ui-scale) — 켜면 .erp-app 을 0.75 로 줄여
// 2880×1620·200%(CSS 화면 1440px 폭)에서도 1920×1080 기준 화면처럼 보이게 한다.
// 팝업은 body 에 붙어 배율 밖이라 좌표를 그대로 쓰면 되고, 배율 안에서 마우스
// 거리로 크기를 바꾸는 곳(작업 창 너비)만 이 값으로 나눈다. CSS --pj-z 와 같은 값.
const UI_ZOOM = 0.75;
function uiZoom() { return document.documentElement.classList.contains("pj-ui-scale") ? UI_ZOOM : 1; }
function openModal(m) { if (m) m.hidden = false; }
function closeModal(m) { if (m) m.hidden = true; }
// 업무 편집 팝업 전용 — 아사나처럼 오른쪽에서 슬라이드로 열고 닫는다.
// hidden 을 먼저 풀고 reflow 를 강제한 뒤 .pj-panel-open 을 붙여야
// transform 트랜지션이 (display:none 상태에서 곧장) 걸린다. 닫을 때는
// transitionend 를 기다렸다가 hidden 을 다시 세운다(이벤트가 안 오는
// 경우를 대비해 타임아웃도 같이 건다).
function openSlidePanel(m) {
if (!m) return;
m.hidden = false;
void m.offsetWidth;
m.classList.add("pj-panel-open");
}
function closeSlidePanel(m) {
if (!m || m.hidden) return;
m.classList.remove("pj-panel-open");
const card = m.querySelector(".pj-task-modal-card");
let done = false;
function finish() { if (done) return; done = true; m.hidden = true; }
if (card) {
card.addEventListener("transitionend", function onEnd(e) {
if (e.target !== card || e.propertyName !== "transform") return;
card.removeEventListener("transitionend", onEnd);
finish();
});
setTimeout(finish, 320);
} else finish();
}
function wireModalClose(modal) {
if (!modal) return;
modal.addEventListener("click", function (e) {
if (e.target === modal || e.target.closest("[data-close]")) closeModal(modal);
});
}
// ── 토스트 알림 — alert() 대신 쓰는 비차단 피드백 ──
let toastEl = null, toastTimer = null;
function showToast(msg, type) {
if (!toastEl) {
toastEl = document.createElement("div");
toastEl.className = "erp-toast";
toastEl.setAttribute("role", "status");
toastEl.setAttribute("aria-live", "polite");
document.body.appendChild(toastEl);
}
toastEl.textContent = msg;
toastEl.dataset.type = type || "info";
toastEl.dataset.visible = "true";
clearTimeout(toastTimer);
toastTimer = setTimeout(function () { toastEl.dataset.visible = "false"; }, 2400);
}
// ── 우클릭 컨텍스트 메뉴 — 하나만 열리는 공용 컴포넌트.
// openDayPopover(아래)의 위치잡기/외부클릭 닫기 방식을 그대로 따르되, 앵커
// 엘리먼트 대신 클릭 좌표(clientX/Y) 기준으로 뷰포트에 클램프한다.
let ctxMenuEl = null, ctxMenuOpts = null;
function closeContextMenu(opts) {
if (!ctxMenuEl) return;
const menu = ctxMenuEl, o = ctxMenuOpts || {};
// 메뉴 안에 포커스가 있었으면(키보드로 다루던 중) 연 버튼으로 포커스를 돌려준다
const hadFocus = menu.contains(document.activeElement);
menu.remove();
ctxMenuEl = null;
ctxMenuOpts = null;
document.removeEventListener("mousedown", onCtxDocDown, true);
document.removeEventListener("keydown", onCtxKeyDown, true);
window.removeEventListener("scroll", onCtxScroll, true);
window.removeEventListener("resize", onCtxScroll, true);
if (o.onClose) o.onClose(opts || {});
if (o.returnFocus && (hadFocus || (opts && opts.focus)) && document.contains(o.returnFocus)) {
try { o.returnFocus.focus({ preventScroll: true }); } catch (_) { o.returnFocus.focus(); }
}
}
function onCtxScroll() { closeContextMenu(); }
function onCtxDocDown(e) {
if (ctxMenuEl && !ctxMenuEl.contains(e.target)) closeContextMenu({ target: e.target });
}
function onCtxKeyDown(e) {
if (e.key === "Escape") { e.preventDefault(); e.stopPropagation(); closeContextMenu({ focus: true }); }
}
// items: [{label, danger?, onClick} | null(구분선)]
// opts(선택): returnFocus = 닫으면 포커스를 돌려줄 요소(메뉴 버튼), focusFirst = 열자마자 첫 항목에 포커스(키보드로 연 경우),
// onClose = 닫힐 때(메뉴 버튼 aria-expanded 되돌리기). 메뉴 안: ↑↓·Home·End 이동, Esc 닫기, Tab 닫기.
// 우클릭 메뉴 왼쪽 아이콘(Material Symbols) — item.icon 에 넣는다
function menuIcon(name) { return '"; }
function showContextMenu(x, y, items, opts) {
closeContextMenu();
opts = opts || {};
const menu = document.createElement("div");
menu.className = "pj-ctxmenu";
menu.setAttribute("role", "menu");
if (opts.label) menu.setAttribute("aria-label", opts.label);
menu.tabIndex = -1;
items.forEach(function (item) {
if (!item) {
const sep = document.createElement("div");
sep.className = "pj-ctxmenu-sep";
menu.appendChild(sep);
return;
}
const b = document.createElement("button");
b.type = "button";
b.className = "pj-ctxmenu-item" + (item.danger ? " is-danger" : "") + (item.checked ? " is-checked" : "");
// item.icon(HTML) — 담당자 메뉴의 아바타 등. item.checked — 현재 값 표시(오른쪽 ✓).
if (item.icon || item.checked) {
b.innerHTML = (item.icon ? '" : "") +
'' +
(item.checked ? '' : "");
b.querySelector(".pj-ctxmenu-label").textContent = item.label;
} else {
b.textContent = item.label;
}
b.setAttribute("role", item.checked !== undefined ? "menuitemcheckbox" : "menuitem");
if (item.checked !== undefined) b.setAttribute("aria-checked", item.checked ? "true" : "false");
b.tabIndex = -1;
b.addEventListener("click", function () { closeContextMenu({ focus: true }); item.onClick(); });
menu.appendChild(b);
});
menu.addEventListener("keydown", function (e) {
const list = Array.from(menu.querySelectorAll(".pj-ctxmenu-item"));
const i = list.indexOf(document.activeElement);
let j = -1;
if (e.key === "ArrowDown") j = i < 0 ? 0 : (i + 1) % list.length;
else if (e.key === "ArrowUp") j = i <= 0 ? list.length - 1 : i - 1;
else if (e.key === "Home") j = 0;
else if (e.key === "End") j = list.length - 1;
else if (e.key === "Tab") { e.preventDefault(); closeContextMenu({ focus: true }); return; }
if (j < 0 || !list.length) return;
e.preventDefault();
list[j].focus();
});
document.body.appendChild(menu);
ctxMenuEl = menu;
ctxMenuOpts = opts;
let left = window.scrollX + x;
let top = window.scrollY + y;
left = Math.min(left, window.scrollX + document.documentElement.clientWidth - menu.offsetWidth - 8);
top = Math.min(top, window.scrollY + document.documentElement.clientHeight - menu.offsetHeight - 8);
menu.style.left = Math.max(8, left) + "px";
menu.style.top = Math.max(8, top) + "px";
if (opts.returnFocus) {
// 메뉴 버튼으로 연 메뉴 — 첫 항목(키보드) 또는 메뉴 자체(마우스·터치)에 포커스를 줘 ↑↓·Esc 가 바로 먹게
const first = menu.querySelector(".pj-ctxmenu-item");
if (opts.focusFirst && first) first.focus(); else menu.focus();
}
setTimeout(function () {
if (ctxMenuEl !== menu) return; // 그 사이 닫혔으면 문서 리스너를 남기지 않는다
document.addEventListener("mousedown", onCtxDocDown, true);
document.addEventListener("keydown", onCtxKeyDown, true);
window.addEventListener("scroll", onCtxScroll, true);
window.addEventListener("resize", onCtxScroll, true);
}, 0);
}
// ── 칸별 자동 저장(목표 표·주간 회의록 공용) ─────────────────────────────
// · 저장 완료 기준(saved)은 "성공한 요청에 실어 보낸 값"만이다 — 응답이 올 때 바뀌어 있는 화면 값을 저장됐다고 보지 않는다.
// · 같은 칸의 요청은 한 줄로 세운다(앞 요청이 끝나야 다음 요청을 보냄) — 서버에 닿는 순서 = 보낸 순서라, 늦게 끝난 옛 요청이
// 최신 값을 덮지 않는다(응답만 무시하는 게 아니라 쓰기 자체를 차례대로). 다음 요청은 보낼 때의 최신 초안을 읽어서,
// 진행 중에 새로 입력한 글·숫자도 뒤이어 저장된다.
// · 실패하면 초안과 dirty 를 그대로 두고 칸에 실패 표시(cfg.onFail) — 다음 입력·칸 떠남·Enter·flushAll 이 다시 보낸다.
// · flushAll() 은 대기 타이머뿐 아니라 진행 중 요청까지 기다리고, 하나라도 실패하면 reject(구조 변경·표 교체를 멈추게).
// · 초안 백업(cfg.draftKey) — 입력할 때마다 localStorage 에 {base(서버에 저장된 값), draft}, 저장되면 지운다. 다음에 열 때
// 서버 값이 base 그대로면 초안을 되살려 다시 저장하고, 서버 값이 바뀌었으면 되살리지 않는다(다른 곳의 수정을 덮지 않게).
// · 페이지 떠남(onBeforeUnload): 진행 중 요청이 없는 dirty 칸은 keepalive 로 한 번 더 보낸다 — 브라우저가 끝까지 보낸다는
// 보장은 없어서 초안 백업이 함께 남는다. 실패했던 칸·진행 중 요청이 있는 칸·cfg.unload === "warn"(숫자 칸) 이 남아 있으면
// 브라우저 이탈 경고를 띄운다.
const DRAFT_PREFIX = "pj_draft:";
const DRAFT_TTL_MS = 14 * 24 * 3600 * 1000;
(function purgeOldDrafts() {
try {
const now = Date.now(), old = [];
for (let i = 0; i < localStorage.length; i++) {
const k = localStorage.key(i);
if (!k || k.indexOf(DRAFT_PREFIX) !== 0) continue;
let d = null;
try { d = JSON.parse(localStorage.getItem(k)); } catch (_) {}
if (!d || now - (d.at || 0) > DRAFT_TTL_MS) old.push(k);
}
old.forEach(function (k) { localStorage.removeItem(k); });
} catch (_) {}
})();
function createFieldSaver(cfg) {
const delay = cfg.delay == null ? 800 : cfg.delay;
const states = new Map(); // 칸 → {saved, chain, busy, timer, failed}
const alive = cfg.alive || function (f) { return document.contains(f); };
function noop() {}
function writeDraft(f, s) {
const k = cfg.draftKey && cfg.draftKey(f);
if (!k) return;
try {
const v = cfg.read(f);
if (v === s.saved) localStorage.removeItem(DRAFT_PREFIX + k);
else localStorage.setItem(DRAFT_PREFIX + k, JSON.stringify({ base: s.saved, draft: v, at: Date.now() }));
} catch (_) {}
}
// 칸 등록 — initial = 서버가 그려 준 값. 남은 초안이 있으면 되살린다: "restored" | "conflict" | null
function track(f, initial) {
const s = { saved: initial, chain: Promise.resolve(), busy: 0, timer: null, failed: false };
states.set(f, s);
const k = cfg.draftKey && cfg.draftKey(f);
if (!k) return null;
let d = null;
try { d = JSON.parse(localStorage.getItem(DRAFT_PREFIX + k) || "null"); } catch (_) {}
if (!d || typeof d.draft !== "string") return null;
if (d.draft === initial) { try { localStorage.removeItem(DRAFT_PREFIX + k); } catch (_) {} return null; }
if (d.base !== initial) { try { localStorage.removeItem(DRAFT_PREFIX + k); } catch (_) {} return "conflict"; }
if (cfg.write) cfg.write(f, d.draft);
queue(f);
return "restored";
}
function queue(f) {
const s = states.get(f);
if (!s) return;
clearTimeout(s.timer);
s.timer = setTimeout(function () { s.timer = null; flush(f).catch(noop); }, delay);
writeDraft(f, s);
}
function flush(f, opts) {
const s = states.get(f);
if (!s) return Promise.resolve(true);
clearTimeout(s.timer);
s.timer = null;
const run = async function () {
const v = cfg.read(f);
if (v === s.saved) {
if (s.failed) { s.failed = false; if (cfg.onClear) cfg.onClear(f); }
writeDraft(f, s);
return true;
}
let res;
try {
res = await cfg.send(f, v, opts || {});
} catch (err) {
s.failed = true;
writeDraft(f, s);
if (cfg.onFail) cfg.onFail(f, err);
throw err;
}
s.saved = v; // 이 요청에 실어 보낸 값만 저장됨으로
s.failed = false;
if (cfg.onSaved) {
const ns = cfg.onSaved(f, v, res, cfg.read(f) === v); // 마지막 인자: 요청 뒤 초안이 그대로인가
if (typeof ns === "string") s.saved = ns; // 서버 표기(쉼표 등)로 칸을 바꿨으면 그 값이 기준
}
writeDraft(f, s);
return true;
};
s.busy++;
// 앞 요청이 없으면 지금 바로(동기적으로 fetch 까지) — 페이지 떠날 때 keepalive 가 그 자리에서 나가게
const p = s.busy === 1 ? run() : s.chain.then(run, run);
s.chain = p.then(noop, noop).then(function () { s.busy--; });
return p;
}
function isDirty(f) {
const s = states.get(f);
return !!s && (s.busy > 0 || !!s.timer || cfg.read(f) !== s.saved);
}
function each(fn) { states.forEach(function (s, f) { if (alive(f)) fn(s, f); }); }
function anyDirty() { let d = false; each(function (s, f) { if (isDirty(f)) d = true; }); return d; }
function flushAll() {
const list = [];
each(function (s, f) { if (isDirty(f)) list.push(flush(f)); });
return Promise.allSettled(list).then(function (rs) {
const bad = rs.filter(function (r) { return r.status === "rejected"; });
if (!bad.length) return true;
const err = new Error("저장하지 못한 칸이 " + bad.length + "개 있어 멈췄습니다(입력한 내용은 그대로) — " +
((bad[0].reason && bad[0].reason.message) || "저장 실패"));
err.cause = bad[0].reason;
throw err;
});
}
function prune() { states.forEach(function (s, f) { if (!alive(f)) { clearTimeout(s.timer); states.delete(f); } }); }
function onBeforeUnload(e) {
let warn = false;
each(function (s, f) {
const dirty = cfg.read(f) !== s.saved;
if (!dirty && !s.busy) return;
writeDraft(f, s);
if (cfg.unload === "warn" || s.busy > 0 || s.failed) warn = true;
if (dirty && s.busy === 0 && cfg.unload !== "warn") flush(f, { keepalive: true }).catch(noop);
});
if (warn && e) { e.preventDefault(); e.returnValue = ""; }
return warn;
}
navigationSavers.push(flushAll);
return {
track: track, queue: queue, flush: flush, flushAll: flushAll, isDirty: isDirty, anyDirty: anyDirty,
prune: prune, onBeforeUnload: onBeforeUnload,
savedOf: function (f) { const s = states.get(f); return s ? s.saved : undefined; },
failedOf: function (f) { const s = states.get(f); return !!(s && s.failed); },
acceptSaved: function (f, value) {
const s = states.get(f);
if (!s) return;
clearTimeout(s.timer); s.timer = null; s.saved = value; s.failed = false;
writeDraft(f, s);
if (cfg.onClear) cfg.onClear(f);
},
};
}
// 저장 실패 표시 — 칸 빨간 테두리 + 안내(입력한 내용은 지우지 않는다)
function markSaveFailed(node, err) {
if (node) {
node.classList.remove("is-saved");
node.classList.add("is-save-failed");
node.dataset.tip = "저장 실패 — 입력한 내용은 그대로 있습니다. 다시 입력하거나 칸을 떠나면(Enter) 다시 저장합니다.";
}
showToast("저장 실패(입력한 내용은 그대로, 칸을 떠나면 다시 시도): " + (err && err.message || ""), "error");
}
function clearSaveFailed(node) {
if (!node || !node.classList.contains("is-save-failed")) return;
node.classList.remove("is-save-failed");
delete node.dataset.tip;
}
// ── 클립보드 복사 ── navigator.clipboard 는 https(보안 컨텍스트)에서만
// 동작한다 — 사내 IP로 http 접속하는 경우를 위해 임시 textarea 로 한 번 더
// 시도한다. 둘 다 실패하면 false 를 돌려 호출 쪽이 주소를 직접 보여준다.
async function copyToClipboard(text) {
try {
if (navigator.clipboard && window.isSecureContext) {
await navigator.clipboard.writeText(text);
return true;
}
} catch (_) { /* 아래 폴백으로 */ }
try {
const ta = document.createElement("textarea");
ta.value = text;
ta.setAttribute("readonly", "");
ta.style.position = "fixed";
ta.style.top = "-1000px";
document.body.appendChild(ta);
ta.select();
const ok = document.execCommand("copy");
ta.remove();
return ok;
} catch (_) { return false; }
}
// 업무 퍼머링크(/project/t/{id})를 클립보드로. 우클릭 메뉴/공유 버튼 공용.
async function shareTaskLink(taskId) {
const url = location.origin + "/project/t/" + taskId;
if (await copyToClipboard(url)) showToast("작업 링크를 복사했습니다.");
else prompt("아래 주소를 복사하세요.", url);
}
// ── 날짜 표기 'YYYY-MM-DD' → 'mm/dd(요일)' — 서버 _fmt_date_kr 과 동일 규칙 ──
function fmtDateKr(dstr) {
if (!dstr) return "";
const d = new Date(String(dstr).slice(0, 10) + "T00:00:00");
if (isNaN(d.getTime())) return dstr;
const mm = String(d.getMonth() + 1).padStart(2, "0");
const dd = String(d.getDate()).padStart(2, "0");
const wd = ["월", "화", "수", "목", "금", "토", "일"][(d.getDay() + 6) % 7];
return mm + "/" + dd + "(" + wd + ")";
}
// ── 마감일 표기(아사나처럼) — 어제(빨강) / 오늘·내일(초록) / 그 밖엔 mm/dd(요일),
// 지난 날짜는 빨강. 완료된 작업은 오늘·내일 초록만 빼고, 지난 마감일 빨강은 그대로. 반환 {text, cls}.
function isoOf(d) {
return d.getFullYear() + "-" + String(d.getMonth() + 1).padStart(2, "0") + "-" + String(d.getDate()).padStart(2, "0");
}
// 업무 기준 "오늘" = 한국시간(Asia/Seoul, 서머타임 없음 → UTC+9 고정) 날짜. 브라우저가 해외
// 시간대여도, 한국 오전(UTC 로는 전날)이어도 서버(today_kst)·마감 알림과 같은 날짜를 쓴다.
// 예전 대시보드는 toISOString()(UTC) 날짜라 한국 00~09시에 지연 수가 달랐다.
function kstTodayIso(nowMs) {
const ms = (nowMs == null ? Date.now() : nowMs) + 9 * 3600000;
return new Date(ms).toISOString().slice(0, 10);
}
function isoToday() { return kstTodayIso(); }
function dayDiff(iso, baseIso) {
const a = new Date(String(iso).slice(0, 10) + "T00:00:00"), b = new Date(baseIso + "T00:00:00");
return Math.round((a - b) / 86400000);
}
function dueInfo(iso, done) {
if (!iso) return null;
const diff = dayDiff(iso, isoToday());
let text, cls = "";
if (diff === 0) { text = "오늘"; cls = "is-soon"; }
else if (diff === 1) { text = "내일"; cls = "is-soon"; }
else if (diff === -1) { text = "어제"; cls = "is-overdue"; }
else { text = fmtDateKr(iso); if (diff < 0) cls = "is-overdue"; }
if (done && cls !== "is-overdue") cls = "";
return { text: text, cls: cls };
}
// 마감일 칸 말풍선 — 지난 날짜(빨강)면 "마감일 지남", 아니면 "마감일 변경".
function dueTip(di) { return di && di.cls === "is-overdue" ? "마감일 지남" : "마감일 변경"; }
// ── 아사나식 날짜 팝업 — 마감일(과 선택적으로 시작일)을 월 달력에서 고른다.
// opts: { start, due, allowStart, onChange(patch) }. 날짜를 누를 때마다
// onChange({due_date[, start_date]}) 로 바로 저장하고, 마감일을 고르면 팝업을
// 닫는다(시작일을 고른 땐 마감일을 이어서 고르게 열어 둠). 바깥 클릭·Esc 로 닫힘. "지우기" = 둘 다 비우고 닫기. 앵커 아래(자리가
// 없으면 위)에 뜨고 꼬리가 앵커를 가리킨다. 한 번에 하나만.
let datePopEl = null, datePopCleanup = null;
function closeDatePopover() {
if (datePopCleanup) datePopCleanup();
datePopCleanup = null;
if (datePopEl) { datePopEl.remove(); datePopEl = null; }
}
// 직접 입력 해석 — 2026-09-30 / 2026.9.30 / 9/30 / 9월 30일 / 0930.
// 빈 값 = "" (지우기), 해석 불가 = null.
function parseTypedDate(text, baseIso) {
const v = String(text || "").trim().replace(/\s+/g, "");
if (!v) return "";
let m = v.match(/^(\d{4})[-./년](\d{1,2})[-./월](\d{1,2})[.일]?$/);
let y, mo, d;
if (m) { y = +m[1]; mo = +m[2]; d = +m[3]; }
else if ((m = v.match(/^(\d{1,2})[-./월](\d{1,2})[.일]?$/))) { y = +baseIso.slice(0, 4); mo = +m[1]; d = +m[2]; }
else if ((m = v.match(/^(\d{2})(\d{2})$/))) { y = +baseIso.slice(0, 4); mo = +m[1]; d = +m[2]; }
else return null;
const dt = new Date(y, mo - 1, d);
if (dt.getFullYear() !== y || dt.getMonth() !== mo - 1 || dt.getDate() !== d) return null;
return isoOf(dt);
}
function fmtFieldDate(iso) {
if (!iso) return "";
const d = new Date(iso + "T00:00:00");
const same = d.getFullYear() === new Date().getFullYear();
return (same ? "" : d.getFullYear() + "년 ") + (d.getMonth() + 1) + "월 " + d.getDate() + "일";
}
const HOLIDAY_SHORT = { "부처님오신날": "석가탄신일", "추석·개천절": "추석" };
function pageHolidays() {
try { return JSON.parse((el("pj-data") || {}).textContent || "{}").holidays || {}; } catch (_) { return {}; }
}
function openDatePopover(anchor, opts) {
closeDatePopover();
const today = isoToday();
let start = opts.start ? String(opts.start).slice(0, 10) : "";
let due = opts.due ? String(opts.due).slice(0, 10) : "";
let showStart = !!(opts.allowStart && start);
let active = "due";
const base = new Date((due || start || today) + "T00:00:00");
let viewY = base.getFullYear(), viewM = base.getMonth();
// 공휴일 표 — 공용 사이드바가 넘긴 것(모든 프로젝트 화면), 없으면 프로젝트 화면 데이터.
const holidays = window.PJ_HOLIDAYS || pageHolidays();
const pop = document.createElement("div");
pop.className = "pj-datepop";
document.body.appendChild(pop);
datePopEl = pop;
function emit() {
const patch = { due_date: due || null };
if (opts.allowStart) patch.start_date = start || null;
if (opts.onChange) opts.onChange(patch);
}
function field(kind, val, ph) {
return '';
}
function render() {
const first = new Date(viewY, viewM, 1);
const gridStart = new Date(viewY, viewM, 1 - first.getDay());
let days = "";
for (let i = 0; i < 42; i++) {
const d = new Date(gridStart.getFullYear(), gridStart.getMonth(), gridStart.getDate() + i);
const iso = isoOf(d);
const cls = ["pj-dp-day"];
if (d.getMonth() !== viewM) cls.push("is-out");
// 일요일·공휴일(국경일·대체공휴일 포함) = 빨강, 토요일 = 파랑. 공휴일 이름은 말풍선.
const holName = holidays[iso] || "";
if (d.getDay() === 0 || holName) cls.push("is-sun");
else if (d.getDay() === 6) cls.push("is-sat");
if (iso === today) cls.push("is-today");
if (iso === due || (showStart && iso === start)) cls.push("is-selected");
if (showStart && start && due && iso > start && iso < due) cls.push("is-inrange");
// 공휴일은 숫자 밑에 이름. 칸이 좁아 5글자 안쪽으로 줄인다(전체 이름은 말풍선).
if (holName) cls.push("has-hol");
const holShort = /\s대체$/.test(holName) ? "대체휴일" : (HOLIDAY_SHORT[holName] || holName);
days += '";
}
pop.innerHTML =
'
' +
(opts.allowStart
? (showStart ? field("start", start, "시작일") : '')
: "") +
field("due", due, "마감일") +
"
" +
'' +
'' +
'' + viewY + "년 " + (viewM + 1) + "월" +
'' +
"
" +
'' +
["일", "월", "화", "수", "목", "금", "토"].map(function (w, i) {
return '' + w + "";
}).join("") +
days +
"
" +
'";
wire();
}
// 날짜 하나 고르기 — 시작일 칸이 활성이면 시작일(그 뒤 마감일로 넘어감),
// 아니면 마감일. 시작일 > 마감일이 되지 않게 맞춘다.
// 마감일을 고르면 저장하고 팝업을 닫는다. 시작일을 고른 때는 이어서
// 마감일을 고르도록 열어 둔다.
function pick(iso) {
if (active === "start") {
start = iso;
if (due && due < iso) due = iso;
active = "due";
render();
emit();
return;
}
due = iso;
if (start && start > iso) start = iso;
emit();
closeDatePopover();
}
function wire() {
pop.querySelectorAll(".pj-dp-day").forEach(function (b) {
b.addEventListener("click", function () { pick(b.dataset.iso); });
});
pop.querySelectorAll(".pj-dp-navbtn").forEach(function (b) {
b.addEventListener("click", function () {
viewM += +b.dataset.nav;
if (viewM < 0) { viewM = 11; viewY--; } else if (viewM > 11) { viewM = 0; viewY++; }
render();
});
});
const add = pop.querySelector(".pj-dp-addstart");
if (add) add.addEventListener("click", function () {
showStart = true; active = "start"; render(); focusActive();
});
pop.querySelectorAll(".pj-dp-field").forEach(function (inp) {
inp.addEventListener("focus", function () {
active = inp.dataset.kind;
pop.querySelectorAll(".pj-dp-field").forEach(function (x) { x.classList.toggle("is-active", x === inp); });
});
function commit() {
const kind = inp.dataset.kind;
const cur = kind === "start" ? start : due;
const parsed = parseTypedDate(inp.value, today);
if (parsed === null || parsed === cur) { inp.value = fmtFieldDate(cur); return; }
if (!parsed) {
if (kind === "start") { start = ""; showStart = false; } else due = "";
render(); emit(); return;
}
active = kind;
const d = new Date(parsed + "T00:00:00");
viewY = d.getFullYear(); viewM = d.getMonth();
pick(parsed);
}
inp.addEventListener("keydown", function (e) {
if (e.isComposing) return;
if (e.key === "Enter") { e.preventDefault(); commit(); }
});
inp.addEventListener("change", commit);
});
pop.querySelector(".pj-dp-today").addEventListener("click", function () {
const d = new Date(); viewY = d.getFullYear(); viewM = d.getMonth();
pick(today);
});
pop.querySelector(".pj-dp-clear").addEventListener("click", function () {
start = ""; due = ""; emit(); closeDatePopover();
});
}
function focusActive() {
const f = pop.querySelector('.pj-dp-field[data-kind="' + active + '"]');
if (f) f.focus();
}
function place() {
const r = anchor.getBoundingClientRect();
const vw = document.documentElement.clientWidth, vh = document.documentElement.clientHeight;
const w = pop.offsetWidth, h = pop.offsetHeight;
const ax = r.left + r.width / 2;
const left = Math.min(Math.max(8, ax - w / 2), vw - w - 8);
const below = r.bottom + 10 + h <= vh - 8 || r.top - 10 - h < 8;
pop.classList.toggle("is-above", !below);
pop.style.left = left + "px";
pop.style.top = (below ? r.bottom + 10 : r.top - 10 - h) + "px";
pop.style.setProperty("--pj-dp-tail", Math.min(Math.max(ax - left, 16), w - 16) + "px");
}
function onDown(e) {
if (pop.contains(e.target) || anchor.contains(e.target)) return;
closeDatePopover();
}
function onKey(e) { if (e.key === "Escape") { e.stopPropagation(); closeDatePopover(); } }
render();
place();
setTimeout(function () {
// 그 사이에 이미 닫혔으면 걸지 않는다 — 안 그러면 닫힌 팝업의 Esc 처리가
// 문서에 남아 이후 모든 Esc 를 삼킨다(정리 함수는 이미 지나갔으므로).
if (datePopEl !== pop) return;
document.addEventListener("mousedown", onDown, true);
document.addEventListener("keydown", onKey, true);
}, 0);
window.addEventListener("resize", closeDatePopover);
datePopCleanup = function () {
document.removeEventListener("mousedown", onDown, true);
document.removeEventListener("keydown", onKey, true);
window.removeEventListener("resize", closeDatePopover);
};
focusActive();
}
// ── 를 아사나식 날짜 버튼으로 — 브라우저 기본 달력 대신
// 위 openDatePopover 를 연다. input 은 숨겨 값 저장소로 그대로 두므로 기존
// 코드의 input.value 읽기/쓰기와 change 이벤트가 그대로 동작한다(value 쓰기를
// 가로채 버튼 글자도 따라 바뀐다 — enhanceAssigneeSelect 와 같은 방식).
// opts.startInput 을 주면 시작일·마감일을 버튼 하나로(팝업의 "+ 시작일").
function enhanceDateInput(input, opts) {
if (!input || input.dataset.pjDate) return;
opts = opts || {};
const startInput = opts.startInput || null;
const inputs = startInput ? [startInput, input] : [input];
const btn = document.createElement("button");
btn.type = "button";
btn.className = "pj-date-btn";
input.after(btn);
const desc = Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value");
inputs.forEach(function (inp) {
inp.dataset.pjDate = "1";
inp.style.display = "none";
Object.defineProperty(inp, "value", {
configurable: true,
get: function () { return desc.get.call(this); },
set: function (v) { desc.set.call(this, v); sync(); },
});
});
function label(iso) { const di = dueInfo(iso, false); return di ? di.text : ""; }
function sync() {
const due = input.value, start = startInput ? startInput.value : "";
const text = start && due ? label(start) + " – " + label(due)
: start ? label(start) + " –" : label(due);
const di = dueInfo(due, false);
// opts.iconOnly — 날짜가 없으면 글자 없이 점선 원 달력 아이콘만(아사나), 있으면 아이콘 + 날짜.
if (opts.iconOnly && !text) {
btn.innerHTML = DUE_EMPTY_ICON_SVG;
} else {
btn.innerHTML = 'calendar_month' +
'';
btn.querySelector(".pj-date-btn-text").textContent = text || (opts.placeholder || "날짜 선택");
}
btn.classList.toggle("is-icon-only", !!opts.iconOnly && !text);
btn.classList.toggle("is-empty", !text);
btn.classList.toggle("is-overdue", !!di && di.cls === "is-overdue");
btn.title = text ? "날짜 변경" : "날짜 지정";
}
function set(inp, v) {
if ((inp.value || "") === (v || "")) return;
inp.value = v || "";
inp.dispatchEvent(new Event("input", { bubbles: true }));
inp.dispatchEvent(new Event("change", { bubbles: true }));
}
btn.addEventListener("click", function (e) {
e.preventDefault();
e.stopPropagation();
openDatePopover(btn, {
start: startInput ? startInput.value : "", due: input.value, allowStart: !!startInput,
onChange: function (patch) {
if (startInput) set(startInput, patch.start_date);
set(input, patch.due_date);
},
});
});
sync();
}
// ── 탭 그룹(뷰 탭/스코프 토글, 둘 다 .pj-view-tabs 마크업 공유)에 슬라이드
// 하이라이트를 붙인다 — is-active 를 단순 배경색 대신, 실제 위치가 움직이는
// 절대배치 요소 하나로 표현한다. 탭 클릭·초기 렌더·리사이즈마다 위치 재계산.
function initTabSlider(container) {
if (!container || container.dataset.pjSlider) return null;
container.dataset.pjSlider = "1";
const hl = document.createElement("div");
hl.className = "pj-tab-highlight";
container.insertBefore(hl, container.firstChild);
function move(animate) {
const active = container.querySelector(".pj-tab.is-active");
if (!active) { hl.style.opacity = "0"; return; }
hl.style.opacity = "1";
if (!animate) hl.classList.add("pj-no-anim");
hl.style.width = active.offsetWidth + "px";
hl.style.height = active.offsetHeight + "px";
hl.style.transform = "translateX(" + active.offsetLeft + "px)";
if (!animate) {
// 강제 리플로우로 즉시 반영시킨 뒤 트랜지션을 다시 켠다(다음 클릭부터 애니메이션).
void hl.offsetWidth;
hl.classList.remove("pj-no-anim");
}
}
move(false);
container.addEventListener("click", function (e) {
if (e.target.closest(".pj-tab")) requestAnimationFrame(function () { move(true); });
});
window.addEventListener("resize", function () { move(false); });
return move;
}
// "#RRGGBB" → "rgba(r,g,b,alpha)" — 세션 헤더 배경처럼 색은 유지한 채
// 투명도만 입혀야 할 때 쓴다.
function hexToRgba(hex, alpha) {
const h = String(hex || "").replace("#", "");
const full = h.length === 3 ? h.split("").map(function (c) { return c + c; }).join("") : h;
const r = parseInt(full.substr(0, 2), 16);
const g = parseInt(full.substr(2, 2), 16);
const b = parseInt(full.substr(4, 2), 16);
if (isNaN(r) || isNaN(g) || isNaN(b)) return hex;
return "rgba(" + r + "," + g + "," + b + "," + alpha + ")";
}
// 밝은 색인지 — 아사나 16색에는 연노랑·하늘·연분홍처럼 흰 글자가 안 보이는 색이 있어
// 그 위에서는 글자·아이콘을 어둡게 쓴다. alpha/바탕색을 주면 비쳐 보이는 실제 색으로 판단.
function isLightColor(hex, alpha, overHex) {
function rgb(h) {
h = String(h || "").replace("#", "");
if (h.length === 3) h = h.split("").map(function (c) { return c + c; }).join("");
return [parseInt(h.substr(0, 2), 16), parseInt(h.substr(2, 2), 16), parseInt(h.substr(4, 2), 16)];
}
const c = rgb(hex);
if (c.some(isNaN)) return false;
const a = alpha == null ? 1 : alpha, o = rgb(overHex || "#ffffff");
const m = c.map(function (v, i) { return v * a + o[i] * (1 - a); });
return (0.299 * m[0] + 0.587 * m[1] + 0.114 * m[2]) / 255 > 0.72;
}
// 멤버 선택 후보 카드(아이콘 위 / 이름 가운데 / 체크박스 아래) — 새 프로젝트
// 모달(홈·프로젝트 페이지)과 멤버 배정 모달 3곳이 전부 이 함수 하나를 쓴다.
// /api/assignable-users 응답의 avatar 필드를 그대로 쓰므로 페이지별
// avatars 맵(홈 페이지엔 없음)에 기대지 않는다.
function memberPickHtml(u) {
const icon = u.avatar
? '
'
: 'account_circle';
return '";
}
// 페이지 공용 아바타 맵 — 채팅/멤버 팝업은 여러 화면 공용 코드라 화면별
// init 안의 avatarHtml 을 못 본다. 페이지 데이터(#pj-data 또는
// #pj-mytasks-data)의 avatars 를 한 번 읽고, 전체 멤버 목록을 받으면 거기
// 들어있는 사진도 보탠다(수신함처럼 페이지 데이터가 없는 화면용).
let pageAvatars = null;
function pageAvatarUrl(email) {
if (pageAvatars === null) {
pageAvatars = {};
["pj-data", "pj-mytasks-data"].forEach(function (id) {
try {
const d = el(id);
if (d) Object.assign(pageAvatars, JSON.parse(d.textContent).avatars || {});
} catch (_) {}
});
}
return email ? pageAvatars[String(email).toLowerCase()] || "" : "";
}
function rememberAvatars(users) {
pageAvatarUrl(""); // 맵 초기화 보장
(users || []).forEach(function (u) {
if (u.avatar && !pageAvatars[u.email.toLowerCase()]) pageAvatars[u.email.toLowerCase()] = u.avatar;
});
}
// ── 업무 삭제 — 확인 창 + 요청을 한 곳에서. 세부 업무가 있으면 "세부 업무 N개까지
// 함께 삭제"를 분명히 묻는다. 지운 업무는 휴지통(3개월 보관, 관리자만 복구)으로
// 간다(project_db 010 — 미적용이면 서버가 예전처럼 영구 삭제, 토스트로 구분).
// subCount 를 모르면(null) 서버에서 세부 업무 수를 받아 확인한다.
async function confirmTaskDelete(taskId, title, subCount) {
let n = subCount;
if (n == null) {
try {
const res = await api("GET", "/project/api/tasks/" + taskId);
n = ((res && res.task && res.task.subtasks) || []).length;
if (!title && res && res.task) title = res.task.title;
} catch (_) { n = 0; }
}
const name = title ? "'" + title + "' " : "이 ";
const tail = "\n\n삭제한 작업은 휴지통에 3개월 보관되며, 관리자가 복구할 수 있습니다.";
const msg = n > 0
? name + "작업에 세부 작업이 " + n + "개 있습니다.\n세부 작업까지 모두 삭제할까요?" + tail
: name + "작업을 삭제할까요?" + tail;
const opts = { okText: n > 0 ? "세부 작업까지 삭제" : "삭제", cancelText: "취소" };
return await confirm(msg, opts);
}
async function deleteTaskRequest(taskId) {
const res = await api("DELETE", "/project/api/tasks/" + taskId);
showToast(res && res.trash ? "휴지통으로 옮겼습니다 (3개월 보관)" : "삭제했습니다");
return res;
}
// ── 담당자 고르기 — 어디서 배정하든 항상 "아이콘 + 이름" 메뉴(아사나처럼).
// 미지정 = 점선 원 사람 아이콘.
const EMPTY_PERSON_SVG =
'";
// 마감일 미지정 아이콘(아사나 모양: 점선 원 안의 달력) — 보드 카드·세부 작업 줄 공용.
const DUE_EMPTY_ICON_SVG =
'";
// 아사나의 세부 업무 아이콘(위 노드 하나에서 두 갈래로 뻗은 노드) — 보드 카드·
// 타임라인·작업 창 세부 작업 줄 공용.
const SUBTASK_ICON_SVG =
'";
// 세부 작업 줄에 붙는 "N ⑂" — 그 세부 작업에도 세부 작업이 있을 때만(아사나).
function nestedSubsHtml(sub, cls) {
const n = (sub && sub.subtask_total) || 0;
if (!n) return "";
return '' + n + SUBTASK_ICON_SVG + "";
}
// 세부 작업 줄의 댓글(말풍선 + 개수)·설명(줄글) 아이콘 — "N ⑂" 와 같은 모양.
const COMMENT_ICON_SVG =
'";
const DESC_ICON_SVG =
'";
// 설명이 비어 있지 않은지 — 태그· ·공백만 있으면 없음, 이미지만 있어도 있음.
// 보드 카드 표지 — 설명 HTML 의 첫 이미지 주소(template 로 읽어 이미지를 불러오지 않음). 같은 설명은 캐시.
// 우리 첨부 주소(/project/…)·http(s)·data:image 만.
const coverCache = new Map();
function cardCoverSrc(html) {
const s = String(html || "");
if (!/
500) coverCache.clear();
coverCache.set(s, src);
return src;
}
function hasDescription(html) {
const s = String(html || "");
if (/
]*>/g, "").replace(/ | /g, " ").trim();
}
// 세부 작업 줄 제목 옆 아이콘 묶음 — 세부 작업 "N ⑂" · 댓글 "N 💬" · 설명(있을 때만).
function subMetaHtml(sub, cls) {
let h = nestedSubsHtml(sub, cls);
const nc = (sub && sub.comment_count) || 0;
if (nc) h += '' + nc + COMMENT_ICON_SVG + "";
if (sub && hasDescription(sub.description)) {
h += '' + DESC_ICON_SVG + "";
}
return h;
}
function personIconHtml(email) {
if (!email) return '' + EMPTY_PERSON_SVG + "";
const url = pageAvatarUrl(email);
return url
? '
'
: 'account_circle';
}
// emails 후보 중 하나를 고르는 메뉴 항목들(맨 앞 "(미지정)"). cur = 현재 담당자.
function assigneeMenuItems(emails, cur, onPick) {
const c = String(cur || "").toLowerCase();
const items = [{ label: "담당자 없음", icon: personIconHtml(""), checked: !c, onClick: function () { onPick(""); } }];
emails.forEach(function (e) {
items.push({
label: idOf(e), icon: personIconHtml(e), checked: String(e).toLowerCase() === c,
onClick: function () { onPick(e); },
});
});
return items;
}
//