4d:I[707087,["/_next/static/immutable/chunks/2985g-hklwiee.js","/_next/static/immutable/chunks/0qkc3dps_9x_i.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3thksmxn95rly.js","/_next/static/immutable/chunks/2ocpj6i2oorb_.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/0agonoz1szsjm.js","/_next/static/immutable/chunks/1r51enyhosz-u.js","/_next/static/immutable/chunks/0krdn-21gkgjt.js","/_next/static/immutable/chunks/3qfn9_v7pj_rb.js","/_next/static/immutable/chunks/0w75qangey2ys.js","/_next/static/immutable/chunks/13f5hjswluuex.js","/_next/static/immutable/chunks/0a8eymjz3e95j.js"],"RegistryDependencies"] 4e:I[512940,["/_next/static/immutable/chunks/2985g-hklwiee.js","/_next/static/immutable/chunks/0qkc3dps_9x_i.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3thksmxn95rly.js","/_next/static/immutable/chunks/2ocpj6i2oorb_.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/0agonoz1szsjm.js","/_next/static/immutable/chunks/1r51enyhosz-u.js","/_next/static/immutable/chunks/0krdn-21gkgjt.js","/_next/static/immutable/chunks/3qfn9_v7pj_rb.js","/_next/static/immutable/chunks/0w75qangey2ys.js","/_next/static/immutable/chunks/13f5hjswluuex.js","/_next/static/immutable/chunks/0a8eymjz3e95j.js"],"Installation"] 4f:I[314491,["/_next/static/immutable/chunks/2985g-hklwiee.js","/_next/static/immutable/chunks/0qkc3dps_9x_i.js","/_next/static/immutable/chunks/2nvof3-29tvc3.js","/_next/static/immutable/chunks/3thksmxn95rly.js","/_next/static/immutable/chunks/2ocpj6i2oorb_.js","/_next/static/immutable/chunks/3tjobt77z_9dj.js","/_next/static/immutable/chunks/0agonoz1szsjm.js","/_next/static/immutable/chunks/1r51enyhosz-u.js","/_next/static/immutable/chunks/0krdn-21gkgjt.js","/_next/static/immutable/chunks/3qfn9_v7pj_rb.js","/_next/static/immutable/chunks/0w75qangey2ys.js","/_next/static/immutable/chunks/13f5hjswluuex.js","/_next/static/immutable/chunks/0a8eymjz3e95j.js"],"FilesView"] 50:T953,// The editing feature slice for event-calendar (P3 feature-slicing — // `@ilinxa/event-calendar-editing`). Import `calendarEditing` and pass it to // `` (or // ``) to enable // drag/resize/create/clipboard/keyboard editing. See the base package's // `editing?: CalendarEditExtension` prop (`@ilinxa/event-calendar`). import { CalendarEditProvider } from "./provider"; import type { CalendarEditExtension } from "../../hooks/use-calendar-edit-extension"; export const calendarEditing: CalendarEditExtension = { Provider: CalendarEditProvider, }; // Edit-surface components (Tier B/C) — for advanced à-la-carte composition; // the assembly + default parts wire these in automatically via `edit.components`. export { CalendarQuickComposer } from "./parts/calendar-quick-composer"; export { CalendarEventContextMenu } from "./parts/calendar-context-menu"; export { CalendarEventEditorOverlay, CalendarRenameField, EventEditorPanel, } from "./parts/calendar-edit-overlays"; // Cross-surface task clipboard (the unified family envelope, hosted in // task-card) — moved off the base barrel with the rest of the editing // surface (v0.3); a read-only base install has no copy/paste UI to serve. export { TASK_CLIPBOARD_KIND, TASK_CLIPBOARD_VERSION, serializeTasks, parseTasks, reassignTaskIds, writeTasksToClipboardEvent, readTasksFromClipboardEvent, } from "../../../task-card/lib/clipboard"; export type { TaskClipboardEnvelope } from "../../../task-card/lib/clipboard"; // Edit-only public types (still DEFINED in the base package's `types.ts` — // `CalendarProps`'s edit-prop fields reference them — but re-exported from // here instead of the base barrel, since a read-only base consumer never // needs to name them). export type { CalendarSnap, CalendarEditAction, CalendarComposerTarget, CalendarQuickComposerRenderer, } from "../../types"; export type { TaskItemAddedEvent, TaskItemRemovedEvent, TaskItemMovedEvent, TaskFieldEditedEvent, TaskStatusChangedEvent, } from "../../types"; // The injection seam's types, re-exported for convenience (also available // from the base barrel). export type { CalendarEditExtension, CalendarEditProps, CalendarEditContextValue, } from "../../hooks/use-calendar-edit-extension"; 51:T3293,"use client"; /** * The editing feature's Provider — the implementation `event-calendar`'s * `editing?: CalendarEditExtension` prop wires in. Mounted by * `EventCalendarRoot` (base) only when BOTH `editable` and `editing` are set. * * Reads the base calendar context (`useCalendar()`) for the fields the edit * state machine and gestures need (occurrences / view / focusDate / * scrollToHour / selectedId / select / statusOptions) — it is rendered INSIDE * `CalendarContext.Provider`, so this resolves. Runs the `useCalendarEdit` * state machine, builds the `@dnd-kit` sensors + `onDragEnd` (day-granular * drag-to-reschedule), the cross-surface clipboard effect, the focus-restore * effect (F-11), and the `handleEventKey` / `handleDayEnterKey` / * `handleMethods` glue the base Root's keyboard router + imperative handle * delegate to — then supplies the whole `CalendarEditContextValue` * (dispatchers + transient UI state + the `components`/`gestures` records the * base parts render through) via `CalendarEditContext`, wrapped in the * `DndContext`. Mounts nothing visual itself. */ import { useCallback, useEffect, useMemo, useRef } from "react"; import type { KeyboardEvent, ReactNode } from "react"; import { DndContext, PointerSensor, useSensor, useSensors } from "@dnd-kit/core"; import type { DragEndEvent } from "@dnd-kit/core"; import { addDays, differenceInCalendarDays, startOfDay } from "date-fns"; import { useCalendar } from "../../hooks/use-calendar-context"; import { CalendarEditContext } from "../../hooks/use-calendar-edit-extension"; import type { CalendarEditContextValue, CalendarEditProps, } from "../../hooks/use-calendar-edit-extension"; import { coveredDays } from "../../lib/segments"; import { snapStepMs } from "./lib/edit-mutations"; import { useCalendarEdit } from "./hooks/use-calendar-edit"; import { useCalendarClipboard } from "./lib/clipboard-effect"; import { createTimeGridGestures, BandDropCell } from "./lib/time-grid-gestures"; import { DraggableEventWrap } from "./parts/calendar-edit-affordances"; import { DroppableDayCell } from "./parts/droppable-day-cell"; import { CalendarEventContextMenu } from "./parts/calendar-context-menu"; import { CalendarEventEditorOverlay, CalendarRenameField, EventEditorPanel, } from "./parts/calendar-edit-overlays"; import { CalendarQuickComposer } from "./parts/calendar-quick-composer"; import type { CalendarOccurrence, TaskItem } from "../../types"; const COMPONENTS: CalendarEditContextValue["components"] = { DraggableEventWrap, DroppableDayCell, BandDropCell, EventContextMenu: CalendarEventContextMenu, EditOverlays: CalendarEventEditorOverlay, RenameField: CalendarRenameField, QuickComposer: CalendarQuickComposer, EventEditorPanel, }; export function CalendarEditProvider({ editProps, children, }: { editProps: CalendarEditProps; children: ReactNode; }) { const base = useCalendar(); const { data, onChange, onTaskReschedule, onItemAdded, onItemRemoved, onItemMoved, onFieldEdited, onStatusChanged, permissions, canMoveItem, canResizeItem, canDeleteItem, canCreateChild, canEditItem, onPermissionDenied, snap, quickCompose, onExternalDrop, renderQuickComposer, rootRef, } = editProps; const edit = useCalendarEdit({ data, editable: true, snap, statusOptions: base.statusOptions, select: base.select, onChange, onTaskReschedule, onItemAdded, onItemRemoved, onItemMoved, onFieldEdited, onStatusChanged, permissions, canMoveItem, canResizeItem, canDeleteItem, canCreateChild, canEditItem, onPermissionDenied, }); const { can, getItem, rescheduleItem, createItem, pasteTasks, deleteItem, renameItemAction, changeStatus, changePriority, applyEditedSubtree, editingId, openEditor, closeEditor, renamingId, beginRename, endRename, composerTarget, openComposer, closeComposer, resizePreview, setResizePreview, } = edit; // Restore-focus target for keyboard-opened transients (editor / rename / // composer) — F-11. const restoreFocusRef = useRef(null); // ── @dnd-kit sensors + day-granular drag-to-reschedule ── const sensors = useSensors( useSensor(PointerSensor, { activationConstraint: { distance: 5 } }), ); const onDragEnd = useCallback( (e: DragEndEvent) => { const occ = e.active.data.current?.occ as CalendarOccurrence | undefined; const targetDayMs = e.over?.data.current?.dayMs as number | undefined; if (!occ || targetDayMs == null) return; const sourceDayMs = startOfDay(occ.startMs).getTime(); const deltaDays = differenceInCalendarDays( new Date(targetDayMs), new Date(sourceDayMs), ); if (deltaDays === 0) return; const newStart = addDays(new Date(occ.startMs), deltaDays).getTime(); const hasSpan = occ.endMs > occ.startMs; const newEnd = hasSpan ? addDays(new Date(occ.endMs), deltaDays).getTime() : undefined; rescheduleItem( occ.id, { startMs: newStart, endMs: newEnd, allDay: occ.allDay }, "move", ); }, [rescheduleItem], ); // ── cross-surface clipboard (copy/cut/paste) ── useCalendarClipboard({ rootRef, editable: true, selectedId: base.selectedId, getItem, deleteItem, pasteTasks, occurrences: base.occurrences, view: base.view, focusDate: base.focusDate, scrollToHour: base.scrollToHour, editingId, renamingId, composerTarget, }); // ── focus restore (F-11): after a keyboard-opened transient closes ── useEffect(() => { if (editingId || renamingId || composerTarget) return; const target = restoreFocusRef.current; if (!target) return; restoreFocusRef.current = null; const raf = requestAnimationFrame(() => { const sel = target.startsWith("day:") ? `[data-day-ms="${target.slice(4)}"]` : `[data-occ-id="${target}"]`; (rootRef.current?.querySelector(sel) as HTMLElement | null)?.focus(); }); return () => cancelAnimationFrame(raf); }, [editingId, renamingId, composerTarget, rootRef]); // ── quick-create routing (drag/dblclick over empty time-grid space) ── const requestCreate = useCallback( (win: { startMs: number; endMs?: number; allDay: boolean }, x: number, y: number) => { if (quickCompose) { openComposer({ date: new Date(win.startMs), allDay: win.allDay, defaultEnd: new Date(win.endMs ?? win.startMs), x, y, }); } else { createItem(null, undefined, win); } }, [quickCompose, openComposer, createItem], ); const gestures = useMemo( () => createTimeGridGestures({ snap, reschedule: rescheduleItem, setPreview: setResizePreview, requestCreate, }), [snap, rescheduleItem, setResizePreview, requestCreate], ); // ── event-focused keyboard editing (moves/resizes/delete/edit/rename) ── const handleEventKey = useCallback( (e: KeyboardEvent, id: string): boolean => { const occ = base.occurrences.find((o) => o.id === id); if (!occ) return false; const timed = (base.view === "week" || base.view === "day") && !occ.allDay; const stepMs = snapStepMs(snap) || 900_000; const hasSpan = occ.endMs > occ.startMs; // Day-granular ←/→ moves shift by CALENDAR days via `addDays` — the same // math as the pointer drop path, DST-safe where a raw MS_PER_DAY add is a // silent no-op across the fall-back day (v0.2.4). Timed moves in the time // grid shift by the snap step. const shiftMs = (ms: number, dir: number) => timed ? ms + dir * stepMs : addDays(new Date(ms), dir).getTime(); // Resize the END by one unit. All-day events resize in whole days against // the exclusive-end convention (same `addDays` midnight math as the drag // grip, so keyboard and pointer agree — no off-by-one, no DST drift) and // never collapse past their start; milestones are points in time and // aren't resizable. const resizeEnd = (dir: number) => { if (occ.kind === "milestone") return; if (occ.allDay) { const cov = coveredDays(occ); const curEnd = startOfDay(addDays(new Date(cov.lastMs), 1)).getTime(); const minEnd = startOfDay(addDays(new Date(cov.firstMs), 1)).getTime(); rescheduleItem( id, { endMs: Math.max(minEnd, addDays(new Date(curEnd), dir).getTime()), allDay: true, }, "resize", ); } else { const base2 = hasSpan ? occ.endMs : occ.startMs; rescheduleItem( id, { endMs: base2 + dir * stepMs, allDay: false }, "resize", ); } }; switch (e.key) { case "ArrowLeft": case "ArrowRight": { const dir = e.key === "ArrowRight" ? 1 : -1; if (e.shiftKey) { resizeEnd(dir); } else { rescheduleItem( id, { startMs: shiftMs(occ.startMs, dir), endMs: hasSpan ? shiftMs(occ.endMs, dir) : undefined, allDay: occ.allDay, }, "move", ); } e.preventDefault(); return true; } case "ArrowUp": case "ArrowDown": { if (!timed || !e.shiftKey) return false; // resize-only, time grid only resizeEnd(e.key === "ArrowDown" ? 1 : -1); e.preventDefault(); return true; } case "Delete": case "Backspace": deleteItem(id); e.preventDefault(); return true; case "Enter": restoreFocusRef.current = id; openEditor(id); e.preventDefault(); return true; case "F2": restoreFocusRef.current = id; beginRename(id); e.preventDefault(); return true; default: return false; } }, [base.occurrences, base.view, snap, rescheduleItem, deleteItem, openEditor, beginRename], ); const handleDayEnterKey = useCallback( (dayMs: number) => { const d = startOfDay(new Date(dayMs)); restoreFocusRef.current = `day:${dayMs}`; openComposer({ date: d, allDay: true, defaultEnd: d }); }, [openComposer], ); const handleMethods = useMemo( () => ({ addTask: (date: Date, item?: Partial) => createItem(null, item, { startMs: startOfDay(date).getTime(), allDay: true }), deleteTask: (id: string) => deleteItem(id), editTask: (id: string) => openEditor(id), beginRename: (id: string) => beginRename(id), openQuickComposer: (date: Date, allDay = true) => openComposer({ date: startOfDay(date), allDay, defaultEnd: allDay ? startOfDay(date) : new Date(date.getTime() + 3_600_000), }), }), [createItem, deleteItem, openEditor, beginRename, openComposer], ); const value = useMemo( () => ({ editable: true, snap, quickCompose, permissions, can, getItem, rescheduleItem, createItem, deleteItem, renameItemAction, changeStatus, changePriority, applyEditedSubtree, editingId, openEditor, closeEditor, renamingId, beginRename, endRename, composerTarget, openComposer, closeComposer, resizePreview, setResizePreview, onExternalDrop, renderQuickComposer, components: COMPONENTS, gestures, handleEventKey, handleDayEnterKey, handleMethods, }), [ snap, quickCompose, permissions, can, getItem, rescheduleItem, createItem, deleteItem, renameItemAction, changeStatus, changePriority, applyEditedSubtree, editingId, openEditor, closeEditor, renamingId, beginRename, endRename, composerTarget, openComposer, closeComposer, resizePreview, setResizePreview, onExternalDrop, renderQuickComposer, gestures, handleEventKey, handleDayEnterKey, handleMethods, ], ); return ( {children} ); } 52:T44af,"use client"; /** * The calendar editing state machine (v0.2.0) — the date-grid sibling of gantt's * `use-gantt-edit.ts`. Owns the transient edit-UI targets (detail-editor + * inline-rename + quick-composer) and the mutation dispatchers. Every dispatcher * is a single chokepoint: re-check permission (veto-before-dispatch), compute the * NEXT forest from `data` via the pure `edit-mutations`, fire the typed * task-card-shaped event, then `onChange(next)`. No internal copy of `data` * — the controlled consumer echoes. When `editable` is false, `can()` returns * false so every dispatcher no-ops (the v1 read-only guarantee). * * Deltas vs gantt: no group-move (calendar renders a parent's own window, so a * parent moves alone via `setWindow`); reschedule is all-day aware (ms + allDay, * not ISO strings); create seeds `startAt`/`expireAt` from the gesture window; * `changePriority` is added (mutate + onChange only — "priority" is not a * `TaskEditableField`, so no typed field event, matching the card). */ import { useCallback, useMemo, useState } from "react"; import type { CalendarComposerTarget, CalendarEditAction, CalendarSnap, TaskEditableField, TaskFieldEditedEvent, TaskItem, TaskItemAddedEvent, TaskItemMovedEvent, TaskItemRemovedEvent, TaskPermissionReason, TaskPermissionRule, TaskPermissions, TaskStatusChangedEvent, TaskStatusOption, } from "../../../types"; import { addItem, buildIndex, formatDateValue, isAncestor, moveItem, removeItem, renameItem, setWindow, } from "../lib/edit-mutations"; import { evalCalendarPermission } from "../lib/edit-permissions"; import { reassignTaskIds } from "../../../../task-card/lib/clipboard"; import { parseDateValue } from "../../../lib/classify"; type Args = { data: TaskItem[]; editable: boolean; snap: CalendarSnap; statusOptions?: TaskStatusOption[]; /** Select a node (newly created events auto-select). */ select?: (id: string | null) => void; onChange?: (data: TaskItem[]) => void; onTaskReschedule?: (next: { itemId: string; startAt: string; expireAt?: string; }) => void; onItemAdded?: (e: TaskItemAddedEvent) => void; onItemRemoved?: (e: TaskItemRemovedEvent) => void; onItemMoved?: (e: TaskItemMovedEvent) => void; onFieldEdited?: (e: TaskFieldEditedEvent) => void; onStatusChanged?: (e: TaskStatusChangedEvent) => void; permissions?: TaskPermissions; canMoveItem?: (id: string) => boolean; canResizeItem?: (id: string) => boolean; canDeleteItem?: (id: string) => boolean; canCreateChild?: (id: string) => boolean; canEditItem?: (id: string) => boolean; onPermissionDenied?: ( action: keyof TaskPermissionRule, itemId: string, reason: TaskPermissionReason, ) => void; }; const ACTION_RULE: Record = { move: "drag", resize: "drag", delete: "remove", create: "addChildren", editDetails: "edit", }; function freshId(): string { if (typeof crypto !== "undefined" && "randomUUID" in crypto) { return `cal-${crypto.randomUUID()}`; } return `cal-${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`; } export function useCalendarEdit(args: Args) { const { data, editable, snap, statusOptions, select, onChange, onTaskReschedule, onItemAdded, onItemRemoved, onItemMoved, onFieldEdited, onStatusChanged, permissions, canMoveItem, canResizeItem, canDeleteItem, canCreateChild, canEditItem, onPermissionDenied, } = args; const index = useMemo(() => buildIndex(data), [data]); const [editingId, setEditingId] = useState(null); const [renamingId, setRenamingId] = useState(null); const [composerTarget, setComposerTarget] = useState(null); // Live drag/resize preview — the renderers show this geometry mid-gesture; the // mutation commits only on release. Cleared when null. const [resizePreview, setResizePreview] = useState<{ id: string; startMs: number; endMs: number; } | null>(null); const getItem = useCallback( (id: string): TaskItem | undefined => index.get(id)?.item, [index], ); const predicateFor = useCallback( (action: CalendarEditAction): ((id: string) => boolean) | undefined => { switch (action) { case "move": return canMoveItem; case "resize": return canResizeItem; case "delete": return canDeleteItem; case "create": return canCreateChild; case "editDetails": return canEditItem; } }, [canMoveItem, canResizeItem, canDeleteItem, canCreateChild, canEditItem], ); const can = useCallback( (action: CalendarEditAction, item: TaskItem): boolean => { if (!editable) return false; const level = index.get(item.id)?.level ?? 1; if (!evalCalendarPermission(permissions, action, item, level)) return false; const pred = predicateFor(action); if (pred && !pred(item.id)) return false; return true; }, [editable, index, permissions, predicateFor], ); /** Guard a dispatch: return the item if allowed, else report denial + null. */ const guard = useCallback( (action: CalendarEditAction, id: string): TaskItem | null => { const item = index.get(id)?.item; if (!item) return null; if (can(action, item)) return item; const reason: TaskPermissionReason = item.locked ? "locked" : predicateFor(action)?.(id) === false ? "predicate" : "default"; onPermissionDenied?.(ACTION_RULE[action], id, reason); return null; }, [index, can, predicateFor, onPermissionDenied], ); const rescheduleItem = useCallback( ( id: string, patch: { startMs?: number; endMs?: number; allDay: boolean }, kind: "move" | "resize", ) => { const item = guard(kind, id); if (!item) return; const next = setWindow(data, id, patch); if (next === data) return; const updated = buildIndex(next).get(id)?.item; if (!updated) return; // Fire field events gated on the patch touching the key AND the instant // really changing — compare by parsed ms (date-only goes floating-local), // so a format-only rewrite (e.g. `+03:00` → `Z`) doesn't emit a phantom. if (patch.startMs != null) { const oldMs = parseDateValue(item.startAt ?? item.setAt).ms; const newMs = parseDateValue(updated.startAt ?? updated.setAt).ms; if (Number.isFinite(newMs) && newMs !== oldMs) { onFieldEdited?.({ itemId: id, key: "startAt", oldValue: item.startAt, newValue: updated.startAt, }); } } if (patch.endMs != null) { const oldMs = parseDateValue(item.expireAt ?? "").ms; const newMs = parseDateValue(updated.expireAt ?? "").ms; if (Number.isFinite(newMs) && newMs !== oldMs) { onFieldEdited?.({ itemId: id, key: "expireAt", oldValue: item.expireAt, newValue: updated.expireAt, }); } } onTaskReschedule?.({ itemId: id, startAt: updated.startAt ?? updated.setAt, expireAt: updated.expireAt, }); onChange?.(next); }, [data, guard, onFieldEdited, onTaskReschedule, onChange], ); const createItem = useCallback( ( parentId: string | null, seed: Partial | undefined, window: { startMs: number; endMs?: number; allDay: boolean }, opts?: { openEditor?: boolean }, ) => { // Root create gates on `editable` only; child create gates the PARENT's // addChildren rule. if (!editable) return; if (parentId != null && !guard("create", parentId)) return; const nowIso = new Date().toISOString(); const item: TaskItem = { id: seed?.id ?? freshId(), name: seed?.name ?? "New event", status: seed?.status ?? statusOptions?.[0]?.value ?? "todo", active: seed?.active ?? true, setAt: seed?.setAt ?? nowIso, ...seed, startAt: formatDateValue(window.startMs, window.allDay), }; if (window.endMs != null && Number.isFinite(window.endMs)) { item.expireAt = formatDateValue(window.endMs, window.allDay); } const next = addItem(data, parentId, item); onItemAdded?.({ parentId: parentId ?? "", item }); onChange?.(next); select?.(item.id); // auto-select the new event (opens the inspector on it) setComposerTarget(null); if (opts?.openEditor) setEditingId(item.id); // "More options" → full editor }, [editable, guard, statusOptions, data, onItemAdded, onChange, select], ); /** * Paste tasks from the cross-surface clipboard at a target window. Each root is * re-id'd (no collision with the source), its dates are rewritten from the * TARGET window (so paste lands where focus is AND converts all-day⇄timed by * the target), then inserted. One `onChange` for the whole paste (one undo * step); root-create gates on `editable`, child-paste on the parent's rule. */ const pasteTasks = useCallback( ( items: TaskItem[], window: { startMs: number; endMs?: number; allDay: boolean }, parentId: string | null = null, ) => { if (!editable || items.length === 0) return; if (parentId != null && !guard("create", parentId)) return; let next = data; const created: TaskItem[] = []; for (const raw of items) { // Re-id the (typed `TaskItem`) source, then the TARGET window overrides the // dates — so the paste lands where focus is AND converts all-day⇄timed. const root: TaskItem = { ...reassignTaskIds(raw), startAt: formatDateValue(window.startMs, window.allDay), }; if (window.endMs != null && Number.isFinite(window.endMs)) { root.expireAt = formatDateValue(window.endMs, window.allDay); } else { delete root.expireAt; } if (root.duration != null) delete root.duration; // canonicalize to expireAt-driven next = addItem(next, parentId, root); created.push(root); } if (next === data) return; created.forEach((item) => onItemAdded?.({ parentId: parentId ?? "", item }), ); onChange?.(next); select?.(created[created.length - 1]?.id ?? null); }, [editable, guard, data, onItemAdded, onChange, select], ); const deleteItem = useCallback( (id: string) => { if (!guard("delete", id)) return; const { next, removed, parentId } = removeItem(data, id); if (!removed) return; onItemRemoved?.({ itemId: id, removed, parentId: parentId ?? "" }); onChange?.(next); if (editingId === id) setEditingId(null); if (renamingId === id) setRenamingId(null); }, [data, guard, onItemRemoved, onChange, editingId, renamingId], ); const renameItemAction = useCallback( (id: string, name: string) => { const item = guard("editDetails", id); if (!item || name === item.name) return; const next = renameItem(data, id, name); onFieldEdited?.({ itemId: id, key: "name", oldValue: item.name, newValue: name, }); onChange?.(next); }, [data, guard, onFieldEdited, onChange], ); /** Reserved reparent path (not wired by any v0.2.0 gesture; see plan §1). */ const moveItemAction = useCallback( (id: string, newParentId: string | null, newIndex: number) => { const item = guard("move", id); if (!item) return; if ( newParentId != null && (newParentId === id || isAncestor(data, id, newParentId)) ) return; const from = index.get(id); let targetIndex = newIndex; if ( from && (from.parentId ?? null) === newParentId && from.index < newIndex ) { targetIndex = newIndex - 1; } const next = moveItem(data, id, newParentId, targetIndex); if (next === data) return; onItemMoved?.({ itemId: id, oldParentId: from?.parentId ?? "", newParentId: newParentId ?? "", oldIndex: from?.index ?? 0, newIndex: targetIndex, }); onChange?.(next); }, [data, guard, index, onItemMoved, onChange], ); const changeStatus = useCallback( (id: string, status: string) => { const item = guard("editDetails", id); if (!item || status === item.status) return; const apply = (items: TaskItem[]): TaskItem[] => items.map((it) => it.id === id ? { ...it, status } : it.children?.length ? { ...it, children: apply(it.children) } : it, ); onStatusChanged?.({ itemId: id, oldStatus: item.status, newStatus: status, }); onFieldEdited?.({ itemId: id, key: "status", oldValue: item.status, newValue: status, }); onChange?.(apply(data)); }, [data, guard, onStatusChanged, onFieldEdited, onChange], ); const changePriority = useCallback( (id: string, priority: string) => { const item = guard("editDetails", id); if (!item || priority === item.priority) return; // "priority" is not a `TaskEditableField`, so no typed field event — the // forest echo carries it (parity with the card, which doesn't emit one). const apply = (items: TaskItem[]): TaskItem[] => items.map((it) => it.id === id ? { ...it, priority } : it.children?.length ? { ...it, children: apply(it.children) } : it, ); onChange?.(apply(data)); }, [data, guard, onChange], ); /** Splice an edited subtree (same root id) from the embedded card back in. */ const applyEditedSubtree = useCallback( (nextItem: TaskItem) => { const prev = index.get(nextItem.id)?.item; if (!prev) { // Deleted (another path) while its editor was open — splicing an absent // id would echo the UNCHANGED forest, silently dropping the edit. Drop // the stale edit and close instead. setEditingId(null); return; } const apply = (items: TaskItem[]): TaskItem[] => items.map((it) => it.id === nextItem.id ? nextItem : it.children?.length ? { ...it, children: apply(it.children) } : it, ); const forest = apply(data); // Emit a granular field event per changed editable field, so a consumer // persisting via `onFieldEdited` sees modal / inspector detail-editor edits // too — not only the consolidated forest echo (A1, v0.2.2). The embedded // card's own granular events are not wired (EventEditorPanel passes only // `onChange`), so there is no double-fire. `priority` is intentionally // excluded — it is not a `TaskEditableField`, so it persists via `onChange` // only (parity with `changePriority`). const FIELDS: TaskEditableField[] = [ "name", "description", "status", "active", "setAt", "startAt", "expireAt", "duration", ]; for (const key of FIELDS) { const oldValue = prev[key]; const newValue = nextItem[key]; if (!Object.is(oldValue, newValue)) { onFieldEdited?.({ itemId: nextItem.id, key, oldValue, newValue }); } } if (prev.status !== nextItem.status) { onStatusChanged?.({ itemId: nextItem.id, oldStatus: prev.status, newStatus: nextItem.status, }); } onChange?.(forest); }, [data, index, onFieldEdited, onStatusChanged, onChange], ); const openEditor = useCallback( (id: string) => { if (!guard("editDetails", id)) return; setRenamingId(null); // editor + rename are mutually exclusive transients // Select the item too: the inspector hosts the editor keyed on selection, // so opening the editor (context-menu / Enter) without selecting first // would otherwise be a no-op when the inspector is mounted. select?.(id); setEditingId(id); }, [guard, select], ); const closeEditor = useCallback(() => setEditingId(null), []); const beginRename = useCallback( (id: string) => { if (!guard("editDetails", id)) return; setEditingId(null); // mutually exclusive with the editor setRenamingId(id); }, [guard], ); const endRename = useCallback(() => setRenamingId(null), []); const openComposer = useCallback( (target: CalendarComposerTarget) => { if (editable) setComposerTarget(target); }, [editable], ); const closeComposer = useCallback(() => setComposerTarget(null), []); return { editable, snap, can, getItem, rescheduleItem, createItem, pasteTasks, deleteItem, renameItemAction, moveItemAction, changeStatus, changePriority, applyEditedSubtree, editingId, openEditor, closeEditor, renamingId, beginRename, endRename, composerTarget, openComposer, closeComposer, resizePreview, setResizePreview, }; } 53:T21c7,/** * Pure forest mutations over `TaskItem[]` — the editing layer (v0.2.0). * * The array analogue of task-card's reducer mutations and the date-grid * sibling of gantt's `lib/edit-mutations.ts`: every function returns a NEW forest * with structural sharing and NEVER mutates in place, so the controlled consumer * can diff/echo and stack undo for free. Framework-free; Vitest-ready. Hierarchy * is nested `children` (no parentId on TaskItem), so the index here is what * callers use to locate a splice point. * * Calendar-specific delta vs gantt: `setWindow` is **all-day aware**. Where gantt * always serializes via `new Date(ms).toISOString()`, the calendar must write a * bare `YYYY-MM-DD` (from LOCAL fields) for all-day items so the value round-trips * through `classify.ts`'s floating-local `parseDateValue` without the UTC * off-by-one. `formatDateValue` is the inverse of `parseDateValue`. */ import type { CalendarSnap, TaskItem } from "../../../types"; import { parseDateValue } from "../../../lib/classify"; /** Minimum timed span (ms) so a resize/drag can't collapse a block to zero. */ export const MIN_DURATION_MS = 60_000; /** Snap increment (ms) for a `CalendarSnap`. `"off"` → 0 (no snap). */ export function snapStepMs(snap: CalendarSnap): number { if (typeof snap === "number") return Math.max(0, snap); switch (snap) { case "off": return 0; case "minute": return 60_000; case "5min": return 300_000; case "15min": return 900_000; case "30min": return 1_800_000; case "hour": return 3_600_000; case "day": return 86_400_000; default: return 900_000; // "15min" fallback } } /** Round `ms` to the nearest `step` relative to `originMs` (e.g. the day start). */ export function snapToStep(ms: number, originMs: number, step: number): number { if (step <= 0 || !Number.isFinite(ms)) return ms; return originMs + Math.round((ms - originMs) / step) * step; } /** * Inverse of `classify.ts`'s `parseDateValue`: * - all-day → bare `YYYY-MM-DD` built from LOCAL Y/M/D (NEVER `toISOString`, * which is UTC and renders a day early in negative-UTC offsets). * - timed → full ISO timestamp. * Returns "" for a non-finite ms so callers never emit `new Date(NaN).toISOString()`. */ export function formatDateValue(ms: number, allDay: boolean): string { if (!Number.isFinite(ms)) return ""; if (allDay) { const d = new Date(ms); const p = (n: number) => String(n).padStart(2, "0"); return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`; } return new Date(ms).toISOString(); } export type ForestNodeInfo = { item: TaskItem; parentId: string | null; index: number; /** 1 = root. */ level: number; }; /** Flat `id → { item, parentId, index, level }` over the whole forest. */ export function buildIndex(data: TaskItem[]): Map { const map = new Map(); const walk = (items: TaskItem[], parentId: string | null, level: number) => { items.forEach((item, index) => { map.set(item.id, { item, parentId, index, level }); if (item.children?.length) walk(item.children, item.id, level + 1); }); }; walk(data, null, 1); return map; } /** Replace the matching item via `fn`; returns the same ref when nothing changed. */ function replace( data: TaskItem[], id: string, fn: (item: TaskItem) => TaskItem, ): TaskItem[] { let changed = false; const next = data.map((item) => { if (item.id === id) { changed = true; return fn(item); } if (item.children?.length) { const kids = replace(item.children, id, fn); if (kids !== item.children) { changed = true; return { ...item, children: kids }; } } return item; }); return changed ? next : data; } export function renameItem( data: TaskItem[], id: string, name: string, ): TaskItem[] { return replace(data, id, (item) => ({ ...item, name })); } /** * Apply a calendar window patch (reschedule / resize / all-day⇄timed convert). * * Takes epoch **ms + an `allDay` flag** (not ISO strings — the geometry layer * hands it numbers and the formatter decides the serialization). The calendar * canonicalizes to a `startAt` + `expireAt` pair: when an `endMs` is written, a * pre-existing `duration` is dropped (an explicit end is clearer than a duration * for a calendar event, and avoids a stale duration shadowing the new expireAt). * Enforces `end ≥ start + MIN_DURATION_MS` for timed only (all-day spans are * day-quantized and need no ms floor). Non-finite ms leave the field untouched * rather than emitting `new Date(NaN).toISOString()`. */ export function setWindow( data: TaskItem[], id: string, patch: { startMs?: number; endMs?: number; allDay: boolean }, ): TaskItem[] { return replace(data, id, (item) => { const next: TaskItem = { ...item }; if (patch.startMs != null && Number.isFinite(patch.startMs)) { let startMs = patch.startMs; // Start-side mirror of the end clamp below (defense in depth — the // gesture layer clamps its commit too, v0.2.4): a timed start-only patch // may not cross the item's existing end, else the persisted window // inverts (startAt > expireAt). When the patch also carries an endMs the // end clamp below owns the invariant instead. if (!patch.allDay && patch.endMs == null) { const endMs = parseDateValue(next.expireAt ?? "").ms; if (Number.isFinite(endMs) && startMs > endMs - MIN_DURATION_MS) { startMs = endMs - MIN_DURATION_MS; } } next.startAt = formatDateValue(startMs, patch.allDay); } if (patch.endMs != null) { const startMs = patch.startMs != null && Number.isFinite(patch.startMs) ? patch.startMs : parseDateValue(next.startAt ?? next.setAt).ms; let endMs = patch.endMs; if ( !patch.allDay && Number.isFinite(startMs) && Number.isFinite(endMs) && endMs < startMs + MIN_DURATION_MS ) { endMs = startMs + MIN_DURATION_MS; } if (Number.isFinite(endMs)) { next.expireAt = formatDateValue(endMs, patch.allDay); if (next.duration != null) delete next.duration; // canonicalize to expireAt-driven } } return next; }); } /** True when `maybeAncestorId` is an ancestor of `id` (circular-drop guard). */ export function isAncestor( data: TaskItem[], maybeAncestorId: string, id: string, ): boolean { const idx = buildIndex(data); let cur = idx.get(id)?.parentId ?? null; while (cur != null) { if (cur === maybeAncestorId) return true; cur = idx.get(cur)?.parentId ?? null; } return false; } /** Insert `item` under `parentId` (null = root) at `index` (default = append). */ export function addItem( data: TaskItem[], parentId: string | null, item: TaskItem, index?: number, ): TaskItem[] { if (parentId == null) { const next = [...data]; next.splice(index ?? next.length, 0, item); return next; } return replace(data, parentId, (parent) => { const kids = parent.children ? [...parent.children] : []; kids.splice(index ?? kids.length, 0, item); return { ...parent, children: kids }; }); } /** Remove an item; returns the new forest + the removed subtree + its old parent. */ export function removeItem( data: TaskItem[], id: string, ): { next: TaskItem[]; removed: TaskItem | null; parentId: string | null } { const info = buildIndex(data).get(id); if (!info) return { next: data, removed: null, parentId: null }; const prune = (items: TaskItem[]): TaskItem[] => items .filter((it) => it.id !== id) .map((it) => it.children?.length ? { ...it, children: prune(it.children) } : it, ); return { next: prune(data), removed: info.item, parentId: info.parentId }; } /** * Move an item to `newParentId` (null = root) at `newIndex`. The caller guards * circular drops (`isAncestor`); `newIndex` is interpreted against the target * parent's children AFTER the source has been removed (task-tree semantics). * Reserved for the v0.2.0 "drop-onto-an-event-to-nest" path (not wired by any * gesture this version — calendar's "move" is reschedule, not reparent). */ export function moveItem( data: TaskItem[], id: string, newParentId: string | null, newIndex: number, ): TaskItem[] { const { next: pruned, removed } = removeItem(data, id); if (!removed) return data; return addItem(pruned, newParentId, removed, newIndex); } 54:T6e0,/** * Calendar edit-permission resolver. Mirrors gantt's `lib/edit-permissions.ts` * (itself mirroring task-tree): maps the calendar's edit actions onto * task-card's `TaskPermissionRule` keys and resolves against the shared * `TaskPermissions` matrix (+ `item.locked`). One matrix shape across card / tree * / gantt / calendar = one mental model for consumers. Framework-free; Vitest-ready. */ import type { CalendarEditAction, TaskItem, TaskPermissionRule, TaskPermissions, } from "../../../types"; /** Calendar actions piggy-back on the most natural existing rule key. */ const ACTION_TO_RULE: Record = { move: "drag", resize: "drag", delete: "remove", create: "addChildren", editDetails: "edit", }; /** * Effective allow/deny for one action on `item` at `level` (1 = root). Hard lock * (`item.locked`) denies everything. Lookup order byItem → byLevel → default, * then a `true` fallback; `inherit !== false` ascends on undefined keys. */ export function evalCalendarPermission( permissions: TaskPermissions | undefined, action: CalendarEditAction, item: TaskItem, level: number, ): boolean { if (item.locked) return false; if (!permissions) return true; const key = ACTION_TO_RULE[action]; const inherit = permissions.inherit !== false; const byItem = permissions.byItem?.[item.id]?.[key]; if (byItem !== undefined) return byItem; if (!inherit && permissions.byItem?.[item.id]) return true; const byLevel = permissions.byLevel?.[level]?.[key]; if (byLevel !== undefined) return byLevel; if (!inherit && permissions.byLevel?.[level]) return true; const def = permissions.default?.[key]; if (def !== undefined) return def; return true; } 55:T9b6,/** * Paste-target resolution — extracted from the pre-split `calendar-root.tsx` * (features-editing split, v0.3). Pure; framework-free. */ import { startOfDay } from "date-fns"; import { parseDateValue } from "../../../lib/classify"; import type { CalendarOccurrence, CalendarView, TaskItem } from "../../../types"; /** Duration (ms) of a task from its dates; 0 when it has no real span. */ export function itemDurationMs(it: TaskItem): number { const startMs = parseDateValue(it.startAt ?? it.setAt).ms; const endMs = it.expireAt ? parseDateValue(it.expireAt).ms : NaN; return Number.isFinite(startMs) && Number.isFinite(endMs) && endMs > startMs ? endMs - startMs : 0; } /** * Where a paste lands. The TARGET decides all-day vs timed (so paste also * converts): a focused day-cell → that day, all-day; a focused event → its * day + all-day-ness; otherwise the current focus date (timed in week/day at * `scrollToHour`, else all-day). Duration is carried from the copied item. */ export function resolvePasteWindow( items: TaskItem[], opts: { activeEl: Element | null; occurrences: CalendarOccurrence[]; view: CalendarView; focusDate: Date; scrollToHour: number; }, ): { startMs: number; endMs?: number; allDay: boolean } { const { activeEl, occurrences, view, focusDate, scrollToHour } = opts; const dur = itemDurationMs(items[0]); const dayEl = activeEl?.closest?.("[data-day-ms]") as HTMLElement | null; if (dayEl) { const startMs = Number(dayEl.getAttribute("data-day-ms")); return { startMs, endMs: dur > 0 ? startMs + dur : undefined, allDay: true }; } const occEl = activeEl?.closest?.("[data-occ-id]") as HTMLElement | null; if (occEl) { const occ = occurrences.find( (o) => o.id === occEl.getAttribute("data-occ-id"), ); if (occ) { const span = occ.endMs > occ.startMs ? occ.endMs - occ.startMs : 0; const length = dur > 0 ? dur : span; return { startMs: occ.startMs, endMs: length > 0 ? occ.startMs + length : undefined, allDay: occ.allDay, }; } } const base = startOfDay(focusDate).getTime(); if (view === "week" || view === "day") { const startMs = base + Math.max(0, Math.min(23, scrollToHour)) * 3_600_000; return { startMs, endMs: dur > 0 ? startMs + dur : startMs + 3_600_000, allDay: false, }; } return { startMs: base, endMs: dur > 0 ? base + dur : undefined, allDay: true }; } 56:T1044,"use client"; /** * Cross-surface clipboard (copy/cut/paste `TaskItem`s through the OS * clipboard — the shared `ilinxa/task` envelope; foreign text is ignored). * Extracted from the pre-split `calendar-root.tsx` MIXED host (features-editing * split, v0.3) as a hook. Document-level so it fires regardless of which * focused element the UA targets; gated on the calendar containing focus, * skipped over text inputs (so the composer / rename keep native text * copy/paste). An open editor / rename / composer owns the clipboard (it may * hold non-input controls), so this defers to native copy/paste while one is up. */ import { useEffect } from "react"; import type { RefObject } from "react"; import { readTasksFromClipboardEvent, writeTasksToClipboardEvent, } from "../../../../task-card/lib/clipboard"; import { resolvePasteWindow } from "./paste-window"; import type { CalendarComposerTarget, CalendarOccurrence, CalendarView, TaskItem, } from "../../../types"; type Args = { rootRef: RefObject; editable: boolean; selectedId: string | null; getItem: (id: string) => TaskItem | undefined; deleteItem: (id: string) => void; pasteTasks: ( items: TaskItem[], window: { startMs: number; endMs?: number; allDay: boolean }, ) => void; occurrences: CalendarOccurrence[]; view: CalendarView; focusDate: Date; scrollToHour: number; editingId: string | null; renamingId: string | null; composerTarget: CalendarComposerTarget | null; }; export function useCalendarClipboard(args: Args) { const { rootRef, editable, selectedId, getItem, deleteItem, pasteTasks, occurrences, view, focusDate, scrollToHour, editingId, renamingId, composerTarget, } = args; useEffect(() => { if (!editable) return; const owns = () => { const active = document.activeElement; return !!rootRef.current && !!active && rootRef.current.contains(active); }; const overText = () => { const el = document.activeElement as HTMLElement | null; return ( el?.tagName === "INPUT" || el?.tagName === "TEXTAREA" || el?.isContentEditable === true ); }; const busy = () => editingId != null || renamingId != null || composerTarget != null; const targetId = (): string | null => { const active = document.activeElement as HTMLElement | null; const occId = active ?.closest?.("[data-occ-id]") ?.getAttribute("data-occ-id"); return occId ?? selectedId ?? null; }; const onCopy = (e: ClipboardEvent) => { if (!owns() || overText() || busy()) return; const id = targetId(); const item = id ? getItem(id) : undefined; if (!item) return; writeTasksToClipboardEvent(e, [item], "event-calendar"); e.preventDefault(); }; const onCut = (e: ClipboardEvent) => { if (!owns() || overText() || busy()) return; const id = targetId(); const item = id ? getItem(id) : undefined; if (!item) return; writeTasksToClipboardEvent(e, [item], "event-calendar"); deleteItem(item.id); e.preventDefault(); }; const onPaste = (e: ClipboardEvent) => { if (!owns() || overText() || busy()) return; const items = readTasksFromClipboardEvent(e); if (!items) return; pasteTasks( items, resolvePasteWindow(items, { activeEl: document.activeElement, occurrences, view, focusDate, scrollToHour, }), ); e.preventDefault(); }; document.addEventListener("copy", onCopy); document.addEventListener("cut", onCut); document.addEventListener("paste", onPaste); return () => { document.removeEventListener("copy", onCopy); document.removeEventListener("cut", onCut); document.removeEventListener("paste", onPaste); }; }, [ rootRef, editable, selectedId, getItem, deleteItem, pasteTasks, occurrences, view, focusDate, scrollToHour, editingId, renamingId, composerTarget, ]); } 57:T2a51,"use client"; /** * Time-grid native-pointer edit gestures (drag-move / drag-resize / draw-to- * create / double-click-create) + the all-day band's droppable create cell. * Extracted from the pre-split `calendar-time-grid.tsx` MIXED host * (features-editing split, v0.3) — moved verbatim except `snap` / the live * dispatchers / `quickCompose` routing are now closed over via * `createTimeGridGestures(deps)` (called once by the Provider) instead of * threaded through every call site, so the base time-grid's call sites shrink * to `edit.gestures.(event, refs…)`. */ import { startOfDay } from "date-fns"; import { useDroppable } from "@dnd-kit/core"; import { cn } from "@/lib/utils"; import { snapStepMs, snapToStep } from "./edit-mutations"; import { useCalendarEditContext } from "../../../hooks/use-calendar-edit-extension"; import type { CalendarGestures } from "../../../hooks/use-calendar-edit-extension"; import type { CalendarSnap } from "../../../types"; const HOUR_PX = 48; const DAY_PX = HOUR_PX * 24; const MS_PER_DAY = 86_400_000; const COL_MS = (clientY: number, rect: DOMRect, dayStartMs: number, step: number) => snapToStep(dayStartMs + ((clientY - rect.top) / rect.height) * MS_PER_DAY, dayStartMs, step); type RescheduleFn = ( id: string, patch: { startMs?: number; endMs?: number; allDay: boolean }, kind: "move" | "resize", ) => void; type SetPreviewFn = ( p: { id: string; startMs: number; endMs: number } | null, ) => void; type RequestCreateFn = ( win: { startMs: number; endMs?: number; allDay: boolean }, x: number, y: number, ) => void; /** Build the time-grid gesture handlers, closing over the live edit * dispatchers — base call sites pass only the per-gesture event + refs. */ export function createTimeGridGestures(deps: { snap: CalendarSnap; reschedule: RescheduleFn; setPreview: SetPreviewFn; requestCreate: RequestCreateFn; }): CalendarGestures { const { snap, reschedule, setPreview, requestCreate } = deps; /** Drag a timed block: vertical = time (delta), horizontal = day (target column). */ const startTimedMove: CalendarGestures["startTimedMove"] = ( e, occ, gridRef, columns, suppressClick, gestureCleanup, ) => { if (e.button !== 0) return; // No stopPropagation: the column's draw handler ignores block-origin // presses, and the context-menu trigger's long-press timer needs the // bubble (Radix cancels it on pointermove, so drags don't open the menu). const grid = gridRef.current; if (!grid) return; // Capture on the source block (gantt's pattern) so the gesture keeps // receiving events off-element and gets a proper pointercancel on // touch scroll-takeover (v0.2.4). e.currentTarget.setPointerCapture(e.pointerId); const pointerId = e.pointerId; const startX = e.clientX; const startY = e.clientY; // Wall-clock time-of-day (H/M/…), NOT an ms offset from local midnight — the // ms delta shifts the hour when the drop column crosses a DST transition (v0.2.4). const startDate = new Date(occ.startMs); const timeOfDay = startDate.getHours() * 3_600_000 + startDate.getMinutes() * 60_000 + startDate.getSeconds() * 1_000 + startDate.getMilliseconds(); const dur = occ.endMs - occ.startMs; const step = snapStepMs(snap); let moved = false; const onMove = (ev: PointerEvent) => { if ( !moved && (Math.abs(ev.clientX - startX) > 4 || Math.abs(ev.clientY - startY) > 4) ) moved = true; }; const onUp = (ev: PointerEvent) => { dispose(); if (!moved) return; // a click selects; only a real drag reschedules suppressClick.current = true; const rect = grid.getBoundingClientRect(); const n = columns.length; const col = Math.max( 0, Math.min(n - 1, Math.floor((ev.clientX - rect.left) / (rect.width / n))), ); const dyMs = ((ev.clientY - startY) / DAY_PX) * MS_PER_DAY; const targetDayStart = startOfDay(columns[col]).getTime(); const newStart = snapToStep(targetDayStart + timeOfDay + dyMs, targetDayStart, step); reschedule(occ.id, { startMs: newStart, endMs: newStart + dur, allDay: false }, "move"); }; // Abort (browser gesture takeover): tear down, commit nothing (v0.2.4). const onCancel = (ev: PointerEvent) => { if (ev.pointerId !== pointerId) return; dispose(); }; const dispose = () => { window.removeEventListener("pointermove", onMove); window.removeEventListener("pointerup", onUp); window.removeEventListener("pointercancel", onCancel); gestureCleanup.current = null; }; window.addEventListener("pointermove", onMove); window.addEventListener("pointerup", onUp); window.addEventListener("pointercancel", onCancel); gestureCleanup.current = dispose; }; /** Drag a block's top/bottom edge: set start/end time (snapped). Updates the * live preview each move; commits on release. */ const startTimedResize: CalendarGestures["startTimedResize"] = ( e, occ, edge, colRef, dayStartMs, gestureCleanup, ) => { e.stopPropagation(); e.preventDefault(); const col = colRef.current; if (!col) return; e.currentTarget.setPointerCapture(e.pointerId); const pointerId = e.pointerId; const step = snapStepMs(snap); const MIN = 60_000; const tAt = (clientY: number) => { const rect = col.getBoundingClientRect(); return snapToStep( dayStartMs + ((clientY - rect.top) / rect.height) * MS_PER_DAY, dayStartMs, step, ); }; const onMove = (ev: PointerEvent) => { const t = tAt(ev.clientY); if (edge === "start") { setPreview({ id: occ.id, startMs: Math.min(t, occ.endMs - MIN), endMs: occ.endMs }); } else { setPreview({ id: occ.id, startMs: occ.startMs, endMs: Math.max(t, occ.startMs + MIN) }); } }; const onUp = (ev: PointerEvent) => { dispose(); const t = tAt(ev.clientY); // Commit the SAME clamped window the preview showed — a raw `t` dragged // past the opposite edge would persist an inverted startAt > expireAt (v0.2.4). if (edge === "start") reschedule(occ.id, { startMs: Math.min(t, occ.endMs - MIN), allDay: false }, "resize"); else reschedule(occ.id, { endMs: Math.max(t, occ.startMs + MIN), allDay: false }, "resize"); }; // Abort (browser gesture takeover): drop the preview, commit nothing (v0.2.4). const onCancel = (ev: PointerEvent) => { if (ev.pointerId !== pointerId) return; dispose(); }; const dispose = () => { window.removeEventListener("pointermove", onMove); window.removeEventListener("pointerup", onUp); window.removeEventListener("pointercancel", onCancel); setPreview(null); gestureCleanup.current = null; }; window.addEventListener("pointermove", onMove); window.addEventListener("pointerup", onUp); window.addEventListener("pointercancel", onCancel); gestureCleanup.current = dispose; }; /** Drag across an empty column → create a timed event spanning the range. A * single click does NOT create (that's a double-click); only a real drag does. */ const startDraw: CalendarGestures["startDraw"] = ( e, colRef, dayStartMs, gestureCleanup, ) => { if (e.button !== 0) return; const col = colRef.current; if (!col) return; e.currentTarget.setPointerCapture(e.pointerId); const pointerId = e.pointerId; const step = snapStepMs(snap) || 900_000; const startMs = COL_MS(e.clientY, col.getBoundingClientRect(), dayStartMs, step); const startY = e.clientY; let moved = false; const onMove = (ev: PointerEvent) => { if (!moved && Math.abs(ev.clientY - startY) > 4) moved = true; }; const onUp = (ev: PointerEvent) => { dispose(); if (!moved) return; // a click selects/deselects; only a drag creates const endMs = COL_MS(ev.clientY, col.getBoundingClientRect(), dayStartMs, step); const lo = Math.min(startMs, endMs); let hi = Math.max(startMs, endMs); if (hi <= lo) hi = lo + (step || 900_000); requestCreate({ startMs: lo, endMs: hi, allDay: false }, ev.clientX, ev.clientY); }; // Abort (browser gesture takeover): tear down, create nothing (v0.2.4). const onCancel = (ev: PointerEvent) => { if (ev.pointerId !== pointerId) return; dispose(); }; const dispose = () => { window.removeEventListener("pointermove", onMove); window.removeEventListener("pointerup", onUp); window.removeEventListener("pointercancel", onCancel); gestureCleanup.current = null; }; window.addEventListener("pointermove", onMove); window.addEventListener("pointerup", onUp); window.addEventListener("pointercancel", onCancel); gestureCleanup.current = dispose; }; /** Double-click an empty slot → create a default 1-hour timed event there. */ const createAtDoubleClick: CalendarGestures["createAtDoubleClick"] = ( e, colRef, dayStartMs, ) => { if ((e.target as HTMLElement).closest("button")) return; // not on an event const col = colRef.current; if (!col) return; const step = snapStepMs(snap) || 900_000; const startMs = COL_MS(e.clientY, col.getBoundingClientRect(), dayStartMs, step); requestCreate( { startMs, endMs: startMs + 3_600_000, allDay: false }, e.clientX, e.clientY, ); }; return { startTimedMove, startTimedResize, startDraw, createAtDoubleClick }; } /** Editable droppable + click-create cell beneath the all-day band overlay * (Tier B — editing feature). Reads the edit context directly: only ever * mounted via `edit.components.BandDropCell`, i.e. inside the extension's * own Provider. */ export function BandDropCell({ day }: { day: Date }) { const edit = useCalendarEditContext(); const dayMs = startOfDay(day).getTime(); const { setNodeRef, isOver } = useDroppable({ id: `band:${dayMs}`, data: { dayMs }, }); return (

{ if (edit.quickCompose) { edit.openComposer({ date: new Date(dayMs), allDay: true, defaultEnd: new Date(dayMs), x: e.clientX, y: e.clientY, }); } else { edit.createItem(null, undefined, { startMs: dayMs, allDay: true }); } }} className={cn( "min-h-7 cursor-pointer border-l border-border first:border-l-0", isOver && "bg-primary/10", )} /> ); } 58:T16d9,"use client"; /** * Shared editable affordances for the DAY-GRANULAR surfaces — the month grid and * the week/day all-day band. Both make events @dnd-kit draggables (drops resolve * in the editing Provider's `onDragEnd` by whole calendar days) and add edge-resize * grips (native pointer, clientX → column → day) + a hover-delete. The continuous * TIME grid uses its own native-pointer layer (see `lib/time-grid-gestures.tsx`). */ import type { PointerEvent as ReactPointerEvent, ReactNode, RefObject, } from "react"; import { useEffect, useRef } from "react"; import { addDays, startOfDay } from "date-fns"; import { useDraggable } from "@dnd-kit/core"; import { CSS } from "@dnd-kit/utilities"; import { cn } from "@/lib/utils"; import { useCalendarEditContext } from "../../../hooks/use-calendar-edit-extension"; import { coveredDays } from "../../../lib/segments"; import { CalendarEventContextMenu } from "./calendar-context-menu"; import type { CalendarOccurrence } from "../../../types"; /** Edge grip on an all-day bar → native-pointer DAY resize (clientX → column). */ export function DayResizeGrip({ edge, occ, containerRef, cols, }: { edge: "start" | "end"; occ: CalendarOccurrence; containerRef: RefObject; cols: Date[]; }) { const { rescheduleItem, setResizePreview } = useCalendarEditContext(); // Active gesture teardown — run on unmount so a mid-gesture removal can't // leak window listeners or let a later, unrelated pointerup commit (v0.2.4). const gestureCleanup = useRef<(() => void) | null>(null); useEffect(() => () => gestureCleanup.current?.(), []); const colAt = (clientX: number): number => { const el = containerRef.current; if (!el) return 0; const r = el.getBoundingClientRect(); return Math.max( 0, Math.min(cols.length - 1, Math.floor((clientX - r.left) / (r.width / cols.length))), ); }; const onPointerDown = (e: ReactPointerEvent) => { e.stopPropagation(); // keep the @dnd-kit drag sensor + draw out of it e.preventDefault(); // Capture on the grip (gantt's pattern) so the gesture keeps receiving // events off-element and gets a proper pointercancel on touch // scroll-takeover (v0.2.4). e.currentTarget.setPointerCapture(e.pointerId); const pointerId = e.pointerId; const span = coveredDays(occ); // Resolve the edit window (start ms or exclusive-end ms) for a target column. const windowAt = (clientX: number) => { const dayMs = startOfDay(cols[colAt(clientX)]).getTime(); if (edge === "start") { const startMs = Math.min(dayMs, startOfDay(span.lastMs).getTime()); return { startMs, endMs: occ.endMs }; } const lastDay = Math.max(dayMs, startOfDay(span.firstMs).getTime()); return { startMs: occ.startMs, endMs: startOfDay(addDays(new Date(lastDay), 1)).getTime(), }; }; const onMove = (ev: PointerEvent) => { const w = windowAt(ev.clientX); setResizePreview({ id: occ.id, startMs: w.startMs, endMs: w.endMs }); }; const onUp = (ev: PointerEvent) => { dispose(); const w = windowAt(ev.clientX); rescheduleItem( occ.id, edge === "start" ? { startMs: w.startMs, allDay: true } : { endMs: w.endMs, allDay: true }, "resize", ); }; // Abort (browser gesture takeover): drop the preview, commit nothing (v0.2.4). const onCancel = (ev: PointerEvent) => { if (ev.pointerId !== pointerId) return; dispose(); }; const dispose = () => { window.removeEventListener("pointermove", onMove); window.removeEventListener("pointerup", onUp); window.removeEventListener("pointercancel", onCancel); setResizePreview(null); gestureCleanup.current = null; }; window.addEventListener("pointermove", onMove); window.addEventListener("pointerup", onUp); window.addEventListener("pointercancel", onCancel); gestureCleanup.current = dispose; }; return ( ); } /** Editable wrapper around an all-day segment: @dnd-kit draggable + edge resize * (when `resizable`) + hover-delete. Used by the month grid and the all-day band. */ export function DraggableEventWrap({ occ, canDrag, resizable, containerRef, cols, children, }: { occ: CalendarOccurrence; canDrag: boolean; resizable: boolean; containerRef: RefObject; cols: Date[]; children: ReactNode; }) { const { attributes, listeners, setNodeRef, transform, isDragging } = useDraggable({ id: occ.id, data: { occ }, disabled: !canDrag }); return (

{children} {resizable ? ( <> ) : null}

); } 59:T1cb0,"use client"; /** * Editing overlays (Tier B — editing feature) mounted by the assembly via * `edit.components.EditOverlays` / `edit.components.RenameField`: * * - `CalendarEventEditorOverlay` — the detail editor on `editingId`. Surfaces * the same editor the inspector hosts inline, so the context-menu "Edit…" + * keyboard Enter work even without the inspector mounted. The assembly * mounts it only when `showInspector` is false (the inspector hosts it * inline → no double). * - `CalendarRenameField` — inline rename on `renamingId`. * * Both use the same centered modal shell as gantt's `GanttEditPopover` — a plain * backdrop button + panel (NOT the shadcn `dialog`/`popover` primitive), so the * task family stays consistent and it sidesteps the Radix/Base-UI `asChild` * divergence the v1 tooltip avoided the same way. Backdrop click + Esc close. * `EventEditorPanel` is the shared, prop-driven editor block reused by the * inspector so the lazy `` boundary is defined once. */ import { lazy, Suspense, useEffect, useRef } from "react"; import type { ReactNode } from "react"; import { Check } from "lucide-react"; import { Button } from "@/components/ui/button"; import { Input } from "@/components/ui/input"; import { cn } from "@/lib/utils"; import { useCalendar } from "../../../hooks/use-calendar-context"; import { useCalendarEditContext } from "../../../hooks/use-calendar-edit-extension"; import type { EventEditorPanelProps } from "../../../hooks/use-calendar-edit-extension"; const LazyTaskCard = lazy(() => import("../../../../task-card").then((m) => ({ default: m.TaskCard })), ); /** * Shared editor block (Tier C) — the lazy `` + a Done * button. Prop-driven (zero context); used inline by the inspector AND by the * centered editor overlay. */ export function EventEditorPanel({ item, statusOptions, priorityOptions, labelOptions, permissions, onChange, onDone, className, }: EventEditorPanelProps) { return (

Loading editor…

} > onChange(tree)} />

); } /** * Centered modal shell — a labelled backdrop button + a panel on top. Mirrors * `GanttEditPopover` (no shadcn `dialog`/`popover`; backdrop + Esc close). */ function OverlayShell({ label, onClose, className, children, }: { label: string; onClose: () => void; className?: string; children: ReactNode; }) { const contentRef = useRef(null); useEffect(() => { const onKey = (e: KeyboardEvent) => { if (e.key === "Escape") onClose(); }; window.addEventListener("keydown", onKey); // Move focus into the dialog on open so keyboard / screen-reader users land // inside it (a more specific control, e.g. the rename input, may refocus after). const raf = requestAnimationFrame(() => contentRef.current?.focus()); return () => { window.removeEventListener("keydown", onKey); cancelAnimationFrame(raf); }; }, [onClose]); return ( ); } /** * Centered detail-editor overlay (Tier B). Renders the shared editor on * `editingId` without requiring the inspector. Mounted by the assembly only when * `showInspector` is false. */ export function CalendarEventEditorOverlay() { const { occurrences, statusOptions, priorityOptions, labelOptions } = useCalendar(); const { permissions, editingId, applyEditedSubtree, closeEditor } = useCalendarEditContext(); const item = editingId ? (occurrences.find((o) => o.id === editingId)?.item ?? null) : null; if (!editingId || !item) return null; return ( ); } /** * Inline-rename popup (Tier B). Renders on `renamingId` — a title input prefilled * from the item. Enter commits, Esc / Cancel / backdrop aborts. */ export function CalendarRenameField() { const { occurrences } = useCalendar(); const { renamingId, renameItemAction, endRename } = useCalendarEditContext(); const item = renamingId ? (occurrences.find((o) => o.id === renamingId)?.item ?? null) : null; const inputRef = useRef(null); // Focus + select on open (rAF so the input is mounted; not a render-time read). useEffect(() => { if (!renamingId) return; const raf = requestAnimationFrame(() => { inputRef.current?.focus(); inputRef.current?.select(); }); return () => cancelAnimationFrame(raf); }, [renamingId]); if (!renamingId || !item) return null; const commit = () => { const value = inputRef.current?.value.trim(); if (value) renameItemAction(renamingId, value); endRename(); }; return (

Rename event { if (e.key === "Enter") { e.preventDefault(); commit(); } else if (e.key === "Escape") { e.preventDefault(); endRename(); } }} />

); } 5a:T126e,"use client"; /** * Quick-create composer (Tier B + Tier C — editing feature). When a create * gesture sets `composerTarget`, this floats a small title-entry popup at the * pointer: type a title + Enter to create, or "More options" to open the full * editor. Deliberately a plain fixed-position panel (NOT a Radix Popover) to * dodge the Base-UI `PopoverAnchor`/`asChild` divergence (the engagement-bar * lesson). Mounted via `edit.components.QuickComposer`; reads the edit context. */ import { useState } from "react"; import type { ReactNode } from "react"; import { format } from "date-fns"; import { Button } from "@/components/ui/button"; import { Input } from "@/components/ui/input"; import { useCalendarEditContext } from "../../../hooks/use-calendar-edit-extension"; import type { CalendarEditContextValue } from "../../../hooks/use-calendar-edit-extension"; import type { CalendarComposerTarget, TaskItem } from "../../../types"; function whenText(t: CalendarComposerTarget): string { if (t.allDay) return `${format(t.date, "EEE, MMM d")} · all day`; return `${format(t.date, "EEE, MMM d")} · ${format(t.date, "p")} – ${format( t.defaultEnd, "p", )}`; } function windowOf(t: CalendarComposerTarget) { const endMs = t.allDay && t.defaultEnd.getTime() === t.date.getTime() ? undefined : t.defaultEnd.getTime(); return { startMs: t.date.getTime(), endMs, allDay: t.allDay }; } function Floating({ x, y, onClose, children, }: { x: number; y: number; onClose: () => void; children: ReactNode; }) { return ( <>

); } function ComposerPopup({ target, onClose, onCreate, render, }: { target: CalendarComposerTarget; onClose: () => void; onCreate: CalendarEditContextValue["createItem"]; render?: CalendarEditContextValue["renderQuickComposer"]; }) { const [title, setTitle] = useState(""); const commit = (seed?: Partial) => onCreate( null, { name: title.trim() || "New event", ...seed }, windowOf(target), ); const openFull = () => onCreate(null, { name: title.trim() || "New event" }, windowOf(target), { openEditor: true, }); const vw = typeof window !== "undefined" ? window.innerWidth : 1024; const vh = typeof window !== "undefined" ? window.innerHeight : 768; const x = Math.max(8, Math.min(target.x ?? 80, vw - 272)); const y = Math.max(8, Math.min(target.y ?? 80, vh - 180)); if (render) { return ( {render({ date: target.date, allDay: target.allDay, defaultEnd: target.defaultEnd, commit, cancel: onClose, openFull, })} ); } return ( ); } export function CalendarQuickComposer() { const { composerTarget, closeComposer, createItem, renderQuickComposer } = useCalendarEditContext(); if (!composerTarget) return null; return ( ); } 5b:T1415,"use client"; /** * Right-click action menu (Tier B — editing feature). Wraps an event and * offers permission-gated Edit / Status / Priority / Delete. Every action * routes through the same `use-calendar-edit` dispatchers as the pointer * paths (single chokepoint). Only ever mounted via `edit.components. * EventContextMenu` — i.e. inside the extension's own Provider — so it needs * no `editable`-guard early-return (the read-only path never reaches this * component at all). Mirrors gantt's `GanttContextMenu` (same F-cross-13 * path-b trigger shape — see the trigger comment below). */ import type { ReactNode } from "react"; import { ContextMenu, ContextMenuContent, ContextMenuItem, ContextMenuSeparator, ContextMenuSub, ContextMenuSubContent, ContextMenuSubTrigger, ContextMenuTrigger, } from "@/components/ui/context-menu"; import { useCalendar } from "../../../hooks/use-calendar-context"; import { useCalendarEditContext } from "../../../hooks/use-calendar-edit-extension"; import { serializeTasks } from "../../../../task-card/lib/clipboard"; import type { TaskItem } from "../../../types"; export function CalendarEventContextMenu({ item, children, }: { item: TaskItem; children: ReactNode; }) { const base = useCalendar(); const edit = useCalendarEditContext(); const canEdit = edit.can("editDetails", item); const canDelete = edit.can("delete", item); const statusOptions = base.statusOptions ?? []; const priorityOptions = base.priorityOptions ?? []; const copy = () => { void navigator.clipboard ?.writeText(serializeTasks([item], "event-calendar")) .catch((err) => { if (process.env.NODE_ENV !== "production") { console.warn("[event-calendar] copy to clipboard failed:", err); } }); }; const cut = () => { // Don't delete-without-copy: if the clipboard is unavailable (insecure // context) the menu cut is a no-op (the keyboard Cut, which uses the sync // clipboard event, still works). The write is async — dispatch the delete // ONLY on fulfillment, so a denied/failed write never destroys the item // with nothing on the clipboard (v0.2.4). if (!navigator.clipboard) return; void navigator.clipboard .writeText(serializeTasks([item], "event-calendar")) .then(() => edit.deleteItem(item.id)) .catch((err: unknown) => { if (process.env.NODE_ENV !== "production") { console.warn( "[event-calendar] Cut aborted — clipboard write failed; item NOT deleted.", err, ); } }); }; return ( {/* F-cross-13 path-b: `asChild` is Radix-only (Base UI rejects it). The trigger renders its own wrapper element (a — non-button in both backends); `contents` makes it box-less so layout is untouched, and right-click / long-press bubble up from the child to the trigger's listeners — no prop injection into `children` needed. (v0.2.5) */} {children} {canEdit ? ( edit.openEditor(item.id)}> Edit… ) : null} {canEdit ? ( edit.beginRename(item.id)}> Rename ) : null} {canEdit && statusOptions.length > 0 ? ( Status {statusOptions.map((o) => ( edit.changeStatus(item.id, o.value)} > {o.label} ))} ) : null} {canEdit && priorityOptions.length > 0 ? ( Priority {priorityOptions.map((o) => ( edit.changePriority(item.id, o.value)} > {o.label} ))} ) : null} {canEdit ? : null} Copy {canDelete ? ( Cut ) : null} {canDelete ? ( <> edit.deleteItem(item.id)} > Delete ) : null} ); } 5c:T53f,"use client"; /** Editable droppable wrapper around a month day cell (Tier B — editing * feature). Extracted from the pre-split `calendar-month-view.tsx` MIXED * host (features-editing split, v0.3). */ import { startOfDay } from "date-fns"; import { useDroppable } from "@dnd-kit/core"; import { useCalendarEditContext } from "../../../hooks/use-calendar-edit-extension"; import type { DroppableDayCellProps } from "../../../hooks/use-calendar-edit-extension"; import { MonthDayCell } from "../../../parts/calendar-month-view"; export function DroppableDayCell(props: DroppableDayCellProps) { const edit = useCalendarEditContext(); const dayMs = startOfDay(props.day).getTime(); const { setNodeRef, isOver } = useDroppable({ id: `day:${dayMs}`, data: { dayMs }, }); return ( { const startMs = startOfDay(d).getTime(); if (edit.quickCompose) { edit.openComposer({ date: new Date(startMs), allDay: true, defaultEnd: new Date(startMs), x: e.clientX, y: e.clientY, }); } else { edit.createItem(null, undefined, { startMs, allDay: true }); } }} /> ); } 49:["$","div",null,{"className":"flex flex-col gap-12","children":[["$","div",null,{"className":"pt-10 flex flex-col gap-4","children":[["$","ul",null,{"className":"flex gap-2 flex-wrap","children":[["$","li","date-fns",{"children":["$","a",null,{"href":"https://www.npmjs.com/package/date-fns","target":"_blank","rel":"noopener noreferrer","className":"rounded-md border p-2 text-sm flex items-center gap-1 ","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"text-xs font-medium","children":"date-fns"}]]}]}],["$","li","lucide-react",{"children":["$","a",null,{"href":"https://www.npmjs.com/package/lucide-react","target":"_blank","rel":"noopener noreferrer","className":"rounded-md border p-2 text-sm flex items-center gap-1 ","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"text-xs font-medium","children":"lucide-react"}]]}]}],["$","li","@dnd-kit/core",{"children":["$","a",null,{"href":"https://www.npmjs.com/package/%40dnd-kit%2Fcore","target":"_blank","rel":"noopener noreferrer","className":"rounded-md border p-2 text-sm flex items-center gap-1 ","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"text-xs font-medium","children":"@dnd-kit/core"}]]}]}],["$","li","@dnd-kit/utilities",{"children":["$","a",null,{"href":"https://www.npmjs.com/package/%40dnd-kit%2Futilities","target":"_blank","rel":"noopener noreferrer","className":"rounded-md border p-2 text-sm flex items-center gap-1 ","children":[["$","svg",null,{"viewBox":"0 0 24 24","className":"size-3","children":["$","path",null,{"d":"M1.763 0C.786 0 0 .786 0 1.763v20.474C0 23.214.786 24 1.763 24h20.474c.977 0 1.763-.786 1.763-1.763V1.763C24 .786 23.214 0 22.237 0zM5.13 5.323l13.837.019-.009 13.836h-3.464l.01-10.382h-3.456L12.04 19.17H5.113z","fill":"currentColor"}]}],["$","span",null,{"className":"text-xs font-medium","children":"@dnd-kit/utilities"}]]}]}]]}],["$","$L4d",null,{"registryDependencies":["@ilinxa/event-calendar","@ilinxa/task-card","context-menu","input","button"]}]]}],["$","$L4e",null,{"sourceUrl":"https://ui.ilinxa.com/r/event-calendar-editing.json","proxyUrl":"https://shadcnregistry.com/r/ilinxa/event-calendar-editing","itemId":"@ilinxa/event-calendar-editing"}],["$","section",null,{"className":"flex flex-col gap-4","id":"files","children":[["$","h2",null,{"className":"text-lg md:text-2xl font-bold font-mono","children":"Files"}],["$","$L4f",null,{"files":[{"path":"src/registry/components/data/event-calendar/features/editing/index.ts","content":"$50","type":"registry:component","target":"components/event-calendar/features/editing/index.ts"},{"path":"src/registry/components/data/event-calendar/features/editing/provider.tsx","content":"$51","type":"registry:component","target":"components/event-calendar/features/editing/provider.tsx"},{"path":"src/registry/components/data/event-calendar/features/editing/hooks/use-calendar-edit.ts","content":"$52","type":"registry:component","target":"components/event-calendar/features/editing/hooks/use-calendar-edit.ts"},{"path":"src/registry/components/data/event-calendar/features/editing/lib/edit-mutations.ts","content":"$53","type":"registry:component","target":"components/event-calendar/features/editing/lib/edit-mutations.ts"},{"path":"src/registry/components/data/event-calendar/features/editing/lib/edit-permissions.ts","content":"$54","type":"registry:component","target":"components/event-calendar/features/editing/lib/edit-permissions.ts"},{"path":"src/registry/components/data/event-calendar/features/editing/lib/paste-window.ts","content":"$55","type":"registry:component","target":"components/event-calendar/features/editing/lib/paste-window.ts"},{"path":"src/registry/components/data/event-calendar/features/editing/lib/clipboard-effect.ts","content":"$56","type":"registry:component","target":"components/event-calendar/features/editing/lib/clipboard-effect.ts"},{"path":"src/registry/components/data/event-calendar/features/editing/lib/time-grid-gestures.tsx","content":"$57","type":"registry:component","target":"components/event-calendar/features/editing/lib/time-grid-gestures.tsx"},{"path":"src/registry/components/data/event-calendar/features/editing/parts/calendar-edit-affordances.tsx","content":"$58","type":"registry:component","target":"components/event-calendar/features/editing/parts/calendar-edit-affordances.tsx"},{"path":"src/registry/components/data/event-calendar/features/editing/parts/calendar-edit-overlays.tsx","content":"$59","type":"registry:component","target":"components/event-calendar/features/editing/parts/calendar-edit-overlays.tsx"},{"path":"src/registry/components/data/event-calendar/features/editing/parts/calendar-quick-composer.tsx","content":"$5a","type":"registry:component","target":"components/event-calendar/features/editing/parts/calendar-quick-composer.tsx"},{"path":"src/registry/components/data/event-calendar/features/editing/parts/calendar-context-menu.tsx","content":"$5b","type":"registry:component","target":"components/event-calendar/features/editing/parts/calendar-context-menu.tsx"},{"path":"src/registry/components/data/event-calendar/features/editing/parts/droppable-day-cell.tsx","content":"$5c","type":"registry:component","target":"components/event-calendar/features/editing/parts/droppable-day-cell.tsx"}]}]]}],"$L5d"]}]

Event Calendar — Editing

Installation

Files

components

Styles