@abraca/nuxt 0.3.0 → 1.5.0

package/dist/runtime/composables/useTableView.d.ts

@@ -0,0 +1,29 @@
+import type { TreeEntry, DocPageMeta, TableColumnDef } from './useChildTree.js';
+export declare function useTableView(tree: {
+    childrenOf: (parentId: string | null) => TreeEntry[];
+    updateMeta: (id: string, patch: Record<string, unknown>) => void;
+    treeMap: any;
+}, tableDocId: string): {
+    tableMeta: import("vue").ComputedRef<DocPageMeta>;
+    explicitMode: import("vue").ComputedRef<"flat" | "hierarchy" | undefined>;
+    detectedMode: import("vue").ComputedRef<"flat" | "hierarchy">;
+    effectiveMode: import("vue").ComputedRef<"flat" | "hierarchy">;
+    setMode: (mode: "hierarchy" | "flat" | undefined) => void;
+    columnDefs: import("vue").ComputedRef<TableColumnDef[]>;
+    addColumn: (def: TableColumnDef) => void;
+    removeColumn: (columnId: string) => void;
+    renameColumn: (columnId: string, label: string) => void;
+    updateColumn: (columnId: string, patch: Partial<TableColumnDef>) => void;
+    columnOrder: import("vue").ComputedRef<string[]>;
+    setColumnOrder: (order: string[]) => void;
+    columnWidths: import("vue").ComputedRef<Record<string, number>>;
+    setColumnWidth: (columnId: string, width: number) => void;
+    sortKey: import("vue").ComputedRef<string | undefined>;
+    sortDir: import("vue").ComputedRef<"asc" | "desc">;
+    setSort: (key: string | undefined, dir?: "asc" | "desc") => void;
+    toggleSort: (key: string) => void;
+    detectMetaKeys: (children: TreeEntry[]) => string[];
+    inferColumnType: (entries: TreeEntry[], metaKey: string) => string;
+    sortEntries: (items: TreeEntry[], key: string, dir: "asc" | "desc") => TreeEntry[];
+    updateTableMeta: (patch: Partial<DocPageMeta>) => void;
+};

package/dist/runtime/composables/useTableView.js

@@ -0,0 +1,184 @@
+import { computed } from "vue";
+export function useTableView(tree, tableDocId) {
+  const tableMeta = computed(() => {
+    const entry = tree.treeMap.data?.[tableDocId] ?? tree.treeMap.get?.(tableDocId);
+    return entry?.meta ?? {};
+  });
+  const explicitMode = computed(() => tableMeta.value.tableMode);
+  const detectedMode = computed(() => {
+    const children = tree.childrenOf(null);
+    if (children.length === 0) return "flat";
+    const hasHierarchy = children.some((child) => tree.childrenOf(child.id).length > 0);
+    return hasHierarchy ? "hierarchy" : "flat";
+  });
+  const effectiveMode = computed(() => explicitMode.value ?? detectedMode.value);
+  function setMode(mode) {
+    updateTableMeta({ tableMode: mode });
+  }
+  const columnDefs = computed(() => tableMeta.value.tableColumns ?? []);
+  function addColumn(def) {
+    const current = [...columnDefs.value];
+    current.push(def);
+    updateTableMeta({ tableColumns: current });
+  }
+  function removeColumn(columnId) {
+    const current = columnDefs.value.filter((c) => c.id !== columnId);
+    updateTableMeta({ tableColumns: current });
+  }
+  function renameColumn(columnId, label) {
+    const current = columnDefs.value.map(
+      (c) => c.id === columnId ? { ...c, label } : c
+    );
+    updateTableMeta({ tableColumns: current });
+  }
+  function updateColumn(columnId, patch) {
+    const current = columnDefs.value.map(
+      (c) => c.id === columnId ? { ...c, ...patch } : c
+    );
+    updateTableMeta({ tableColumns: current });
+  }
+  const columnOrder = computed(() => tableMeta.value.tableColumnOrder ?? []);
+  function setColumnOrder(order) {
+    updateTableMeta({ tableColumnOrder: order });
+  }
+  const columnWidths = computed(() => tableMeta.value.tableColumnWidths ?? {});
+  function setColumnWidth(columnId, width) {
+    updateTableMeta({
+      tableColumnWidths: { ...columnWidths.value, [columnId]: Math.max(80, width) }
+    });
+  }
+  const sortKey = computed(() => tableMeta.value.tableSortKey);
+  const sortDir = computed(() => tableMeta.value.tableSortDir ?? "asc");
+  function setSort(key, dir) {
+    updateTableMeta({
+      tableSortKey: key,
+      tableSortDir: key ? dir ?? "asc" : void 0
+    });
+  }
+  function toggleSort(key) {
+    if (sortKey.value === key) {
+      if (sortDir.value === "asc") {
+        setSort(key, "desc");
+      } else {
+        setSort(void 0);
+      }
+    } else {
+      setSort(key, "asc");
+    }
+  }
+  function updateTableMeta(patch) {
+    tree.updateMeta(tableDocId, patch);
+  }
+  const INTERNAL_KEYS = /* @__PURE__ */ new Set([
+    "_metaFields",
+    "_metaInitialized",
+    "coverUploadId",
+    "coverDocId",
+    "coverMimeType",
+    "geoType",
+    "geoLat",
+    "geoLng",
+    "geoDescription",
+    "icon",
+    "color",
+    "deskX",
+    "deskY",
+    "deskZ",
+    "deskMode",
+    "deskScrollY",
+    "mmX",
+    "mmY",
+    "graphX",
+    "graphY",
+    "graphPinned",
+    "spX",
+    "spY",
+    "spZ",
+    "spRX",
+    "spRY",
+    "spRZ",
+    "spSX",
+    "spSY",
+    "spSZ",
+    "spShape",
+    "spOpacity",
+    "spModelUploadId",
+    "spModelDocId",
+    "tableMode",
+    "tableColumns",
+    "tableColumnOrder",
+    "tableColumnWidths",
+    "tableSortKey",
+    "tableSortDir"
+  ]);
+  const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  function detectMetaKeys(children) {
+    const keys = /* @__PURE__ */ new Set();
+    for (const child of children) {
+      if (!child.meta) continue;
+      for (const key of Object.keys(child.meta)) {
+        if (INTERNAL_KEYS.has(key)) continue;
+        if (UUID_RE.test(key)) continue;
+        keys.add(key);
+      }
+    }
+    return [...keys].sort();
+  }
+  function inferColumnType(entries, metaKey) {
+    for (const entry of entries) {
+      const val = entry.meta?.[metaKey];
+      if (val == null) continue;
+      if (typeof val === "boolean") return "toggle";
+      if (typeof val === "number") return "number";
+      if (Array.isArray(val)) return "tags";
+      if (typeof val === "string") {
+        if (/^\d{4}-\d{2}-\d{2}/.test(val)) return "date";
+        if (/^https?:\/\//.test(val)) return "url";
+        if (/^#[0-9a-f]{3,8}$/i.test(val)) return "color";
+      }
+    }
+    return "text";
+  }
+  function sortEntries(items, key, dir) {
+    const sorted = [...items].sort((a, b) => {
+      let aVal, bVal;
+      if (key === "__label") {
+        aVal = a.label;
+        bVal = b.label;
+      } else {
+        aVal = a.meta?.[key];
+        bVal = b.meta?.[key];
+      }
+      if (aVal == null && bVal == null) return 0;
+      if (aVal == null) return 1;
+      if (bVal == null) return -1;
+      if (typeof aVal === "number" && typeof bVal === "number") return aVal - bVal;
+      return String(aVal).localeCompare(String(bVal));
+    });
+    return dir === "desc" ? sorted.reverse() : sorted;
+  }
+  return {
+    tableMeta,
+    explicitMode,
+    detectedMode,
+    effectiveMode,
+    setMode,
+    columnDefs,
+    addColumn,
+    removeColumn,
+    renameColumn,
+    updateColumn,
+    columnOrder,
+    setColumnOrder,
+    columnWidths,
+    setColumnWidth,
+    sortKey,
+    sortDir,
+    setSort,
+    toggleSort,
+    detectMetaKeys,
+    inferColumnType,
+    sortEntries,
+    updateTableMeta
+  };
+}

package/dist/runtime/composables/useTimelineView.d.ts

@@ -0,0 +1,55 @@
+import type { Ref } from 'vue';
+export interface AxisLabel {
+    label: string;
+    offset: number;
+    tier: 'coarse' | 'fine';
+}
+export interface UseTimelineViewOptions {
+    containerRef: Ref<HTMLElement | null>;
+    scrollContainerRef?: Ref<HTMLElement | null>;
+    storedPixelsPerDay?: Ref<number | undefined>;
+    storedZoomLevel?: Ref<string | undefined>;
+    storedCenterDate?: Ref<string | undefined>;
+    entries?: Ref<Array<{
+        meta?: Record<string, unknown>;
+    }>>;
+    onViewChange?: (ppd: number, centerDate: string) => void;
+}
+declare function toDateStr(d: Date): string;
+export declare function useTimelineView(options: UseTimelineViewOptions): {
+    pixelsPerDay: Ref<number, number>;
+    centerDate: import("vue").ComputedRef<Date>;
+    containerWidth: Ref<number, number>;
+    isMobile: Ref<boolean, boolean>;
+    visibleDays: import("vue").ComputedRef<number>;
+    visibleStartDate: import("vue").ComputedRef<Date>;
+    visibleEndDate: import("vue").ComputedRef<Date>;
+    todayOffset: import("vue").ComputedRef<number>;
+    axisLabels: import("vue").ComputedRef<AxisLabel[]>;
+    dateToX: (dateStr: string) => number;
+    xToDate: (px: number) => Date;
+    spanWidth: (startStr: string, endStr: string) => number;
+    toDateStr: typeof toDateStr;
+    panByPixels: (dx: number) => void;
+    navigateTo: (date: Date) => void;
+    goToday: () => void;
+    fitToContent: () => boolean;
+    zoomIn: (anchorX?: number) => void;
+    zoomOut: (anchorX?: number) => void;
+    zoomAt: (factor: number, anchorX?: number) => void;
+    setViewport: (ppd: number, center: number) => void;
+    animateViewport: (targetPpd: number, targetCenter: number) => void;
+    onWheel: (e: WheelEvent) => void;
+    onTouchStart: (e: TouchEvent) => void;
+    onTouchMove: (e: TouchEvent) => void;
+    onTouchEnd: () => void;
+    onPanPointerDown: (e: PointerEvent) => void;
+    onPanPointerMove: (e: PointerEvent) => void;
+    onPanPointerUp: (e: PointerEvent) => void;
+    onKeydown: (e: KeyboardEvent) => void;
+    isBarVisible: (startStr: string | undefined, endStr: string | undefined) => boolean;
+    isMilestone: (entry: {
+        meta?: Record<string, unknown>;
+    }) => boolean;
+};
+export {};

package/dist/runtime/composables/useTimelineView.js

@@ -0,0 +1,434 @@
+import { ref, computed, onMounted, onBeforeUnmount } from "vue";
+const TIER_MILLENNIA = 5e-3;
+const TIER_CENTURIES = 0.05;
+const TIER_DECADES = 0.5;
+const TIER_YEARS = 2;
+const TIER_MONTHS = 10;
+const TIER_WEEKS = 30;
+const ZOOM_MIN = 5e-4;
+const ZOOM_MAX = 120;
+const ZOOM_WHEEL_FACTOR = 1.08;
+const PAN_KEYBOARD_PX = 100;
+const MS_PER_DAY = 24 * 60 * 60 * 1e3;
+function toDateStr(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  if (y < 0) return `-${String(-y).padStart(6, "0")}-${m}-${day}`;
+  if (y > 9999) return `+${String(y).padStart(6, "0")}-${m}-${day}`;
+  return `${String(y).padStart(4, "0")}-${m}-${day}`;
+}
+function clamp(v, min, max) {
+  return Math.max(min, Math.min(max, v));
+}
+export function useTimelineView(options) {
+  const { containerRef, scrollContainerRef, storedPixelsPerDay, storedZoomLevel, storedCenterDate, entries: entriesRef, onViewChange } = options;
+  const pixelsPerDay = ref(14);
+  const centerMs = ref(Date.now());
+  const centerDate = computed(() => new Date(centerMs.value));
+  const containerWidth = ref(800);
+  const isMobile = ref(false);
+  function migrateZoom() {
+    if (storedPixelsPerDay?.value && storedPixelsPerDay.value > 0) {
+      pixelsPerDay.value = storedPixelsPerDay.value;
+    } else if (storedZoomLevel?.value) {
+      const map = { week: 40, month: 14, quarter: 4 };
+      pixelsPerDay.value = map[storedZoomLevel.value] ?? 14;
+    }
+    if (storedCenterDate?.value) {
+      const d = new Date(storedCenterDate.value);
+      if (!Number.isNaN(d.getTime())) centerMs.value = d.getTime();
+    }
+  }
+  function fitToContent() {
+    const items = entriesRef?.value;
+    if (!items || items.length === 0) return false;
+    let minDate = Infinity;
+    let maxDate = -Infinity;
+    let hasAnyDate = false;
+    for (const item of items) {
+      const start = item.meta?.dateStart;
+      const end = item.meta?.dateEnd;
+      if (start) {
+        const t = new Date(start).getTime();
+        if (!Number.isNaN(t)) {
+          minDate = Math.min(minDate, t);
+          maxDate = Math.max(maxDate, t);
+          hasAnyDate = true;
+        }
+      }
+      if (end) {
+        const t = new Date(end).getTime();
+        if (!Number.isNaN(t)) {
+          minDate = Math.min(minDate, t);
+          maxDate = Math.max(maxDate, t);
+          hasAnyDate = true;
+        }
+      }
+    }
+    if (!hasAnyDate) return false;
+    const rangeDays = Math.max(7, (maxDate - minDate) / MS_PER_DAY);
+    const paddingDays = rangeDays * 0.1;
+    const totalDays = rangeDays + paddingDays * 2;
+    const width = containerWidth.value || 800;
+    const ppd = clamp(width / totalDays, ZOOM_MIN, ZOOM_MAX);
+    pixelsPerDay.value = ppd;
+    centerMs.value = (minDate + maxDate) / 2;
+    persistView();
+    return true;
+  }
+  let resizeObserver = null;
+  function measureContainer() {
+    const el = containerRef.value;
+    if (!el) return;
+    containerWidth.value = el.clientWidth;
+    isMobile.value = window.innerWidth < 640;
+  }
+  onMounted(() => {
+    migrateZoom();
+    measureContainer();
+    if (containerRef.value) {
+      resizeObserver = new ResizeObserver(measureContainer);
+      resizeObserver.observe(containerRef.value);
+    }
+    if (!storedCenterDate?.value && !storedPixelsPerDay?.value) {
+      if (!fitToContent()) {
+        centerMs.value = Date.now();
+      }
+    }
+  });
+  onBeforeUnmount(() => {
+    if (persistTimer) clearTimeout(persistTimer);
+    if (followFrameId !== null) cancelAnimationFrame(followFrameId);
+    resizeObserver?.disconnect();
+  });
+  const visibleDays = computed(() => containerWidth.value / pixelsPerDay.value);
+  const visibleStartDate = computed(
+    () => new Date(centerMs.value - containerWidth.value / pixelsPerDay.value / 2 * MS_PER_DAY)
+  );
+  const visibleEndDate = computed(
+    () => new Date(centerMs.value + containerWidth.value / pixelsPerDay.value / 2 * MS_PER_DAY)
+  );
+  function dateToX(dateStr) {
+    const d = new Date(dateStr);
+    const diffDays = (d.getTime() - visibleStartDate.value.getTime()) / MS_PER_DAY;
+    return diffDays * pixelsPerDay.value;
+  }
+  function xToDate(px) {
+    const ms = visibleStartDate.value.getTime() + px / pixelsPerDay.value * MS_PER_DAY;
+    return new Date(ms);
+  }
+  function spanWidth(startStr, endStr) {
+    const s = new Date(startStr);
+    const e = new Date(endStr);
+    const days = Math.max(1, Math.ceil((e.getTime() - s.getTime()) / MS_PER_DAY));
+    return days * pixelsPerDay.value;
+  }
+  const todayOffset = computed(() => dateToX(toDateStr(/* @__PURE__ */ new Date())));
+  function panByPixels(dx) {
+    centerMs.value -= dx / pixelsPerDay.value * MS_PER_DAY;
+    persistView();
+  }
+  function navigateTo(date) {
+    centerMs.value = date.getTime();
+    persistView();
+  }
+  function goToday() {
+    centerMs.value = Date.now();
+    persistView();
+  }
+  function zoomAt(factor, anchorX) {
+    const oldPpd = pixelsPerDay.value;
+    const newPpd = clamp(oldPpd * factor, ZOOM_MIN, ZOOM_MAX);
+    if (anchorX !== void 0) {
+      const halfW = containerWidth.value / 2;
+      const anchorMs = centerMs.value + (anchorX - halfW) / oldPpd * MS_PER_DAY;
+      pixelsPerDay.value = newPpd;
+      centerMs.value = anchorMs - (anchorX - halfW) / newPpd * MS_PER_DAY;
+    } else {
+      pixelsPerDay.value = newPpd;
+    }
+    persistView();
+  }
+  function zoomIn(anchorX) {
+    zoomAt(ZOOM_WHEEL_FACTOR, anchorX);
+  }
+  function zoomOut(anchorX) {
+    zoomAt(1 / ZOOM_WHEEL_FACTOR, anchorX);
+  }
+  let persistTimer = null;
+  function persistView() {
+    if (persistTimer) clearTimeout(persistTimer);
+    persistTimer = setTimeout(() => {
+      onViewChange?.(pixelsPerDay.value, toDateStr(centerDate.value));
+    }, 400);
+  }
+  function setViewport(ppd, center) {
+    pixelsPerDay.value = clamp(ppd, ZOOM_MIN, ZOOM_MAX);
+    centerMs.value = center;
+  }
+  const FOLLOW_TAU = 120;
+  let followFrameId = null;
+  let followTargetPpd = null;
+  let followTargetCenter = null;
+  let followLastTime = null;
+  function runFollowLoop(now) {
+    if (followTargetPpd === null || followTargetCenter === null) {
+      followFrameId = null;
+      return;
+    }
+    const dt = followLastTime !== null ? Math.min(now - followLastTime, 64) : 16;
+    followLastTime = now;
+    const factor = 1 - Math.exp(-dt / FOLLOW_TAU);
+    const logCur = Math.log(pixelsPerDay.value);
+    const logTarget = Math.log(followTargetPpd);
+    pixelsPerDay.value = Math.exp(logCur + (logTarget - logCur) * factor);
+    centerMs.value = centerMs.value + (followTargetCenter - centerMs.value) * factor;
+    const pxDiff = Math.abs(followTargetCenter - centerMs.value) / MS_PER_DAY * pixelsPerDay.value;
+    const zoomDone = Math.abs(logTarget - Math.log(pixelsPerDay.value)) < 5e-4;
+    const panDone = pxDiff < 0.5;
+    if (zoomDone && panDone) {
+      pixelsPerDay.value = followTargetPpd;
+      centerMs.value = followTargetCenter;
+      followTargetPpd = null;
+      followTargetCenter = null;
+      followFrameId = null;
+    } else {
+      followFrameId = requestAnimationFrame(runFollowLoop);
+    }
+  }
+  function animateViewport(targetPpd, targetCenter) {
+    followTargetPpd = clamp(targetPpd, ZOOM_MIN, ZOOM_MAX);
+    followTargetCenter = targetCenter;
+    if (followFrameId === null) {
+      followLastTime = null;
+      followFrameId = requestAnimationFrame(runFollowLoop);
+    }
+  }
+  function onWheel(e) {
+    const rect = containerRef.value?.getBoundingClientRect();
+    const anchorX = rect ? e.clientX - rect.left : void 0;
+    if (e.deltaY > 0) zoomOut(anchorX);
+    else zoomIn(anchorX);
+  }
+  let pinchStartDist = 0;
+  let pinchStartPpd = 0;
+  let pinchStartCenterMs = 0;
+  function onTouchStart(e) {
+    if (e.touches.length === 2) {
+      const dx = e.touches[1].clientX - e.touches[0].clientX;
+      const dy = e.touches[1].clientY - e.touches[0].clientY;
+      pinchStartDist = Math.hypot(dx, dy);
+      pinchStartPpd = pixelsPerDay.value;
+      pinchStartCenterMs = centerMs.value;
+    }
+  }
+  function onTouchMove(e) {
+    if (e.touches.length === 2 && pinchStartDist > 0) {
+      e.preventDefault();
+      const dx = e.touches[1].clientX - e.touches[0].clientX;
+      const dy = e.touches[1].clientY - e.touches[0].clientY;
+      const dist = Math.hypot(dx, dy);
+      const newPpd = clamp(pinchStartPpd * (dist / pinchStartDist), ZOOM_MIN, ZOOM_MAX);
+      const rect = containerRef.value?.getBoundingClientRect();
+      if (rect) {
+        const midX = (e.touches[0].clientX + e.touches[1].clientX) / 2 - rect.left;
+        const halfW = containerWidth.value / 2;
+        const anchorMsVal = pinchStartCenterMs + (midX - halfW) / pinchStartPpd * MS_PER_DAY;
+        pixelsPerDay.value = newPpd;
+        centerMs.value = anchorMsVal - (midX - halfW) / newPpd * MS_PER_DAY;
+      } else {
+        pixelsPerDay.value = newPpd;
+      }
+      persistView();
+    }
+  }
+  function onTouchEnd() {
+    pinchStartDist = 0;
+  }
+  let panStartX = 0;
+  let panStartY = 0;
+  let isPanning = false;
+  function onPanPointerDown(e) {
+    if (e.button !== 0) return;
+    const target = e.target;
+    if (target.closest("[data-bar-id], [data-milestone-id], [data-drag-id]")) return;
+    panStartX = e.clientX;
+    panStartY = e.clientY;
+    isPanning = true;
+    e.currentTarget?.setPointerCapture(e.pointerId);
+  }
+  function onPanPointerMove(e) {
+    if (!isPanning) return;
+    const dx = e.clientX - panStartX;
+    const dy = e.clientY - panStartY;
+    if (Math.abs(dx) > 2 || Math.abs(dy) > 2) {
+      if (Math.abs(dx) > 2) {
+        panByPixels(dx);
+        panStartX = e.clientX;
+      }
+      if (Math.abs(dy) > 2 && scrollContainerRef?.value) {
+        scrollContainerRef.value.scrollTop -= dy;
+        panStartY = e.clientY;
+      }
+    }
+  }
+  function onPanPointerUp(e) {
+    isPanning = false;
+    e.currentTarget?.releasePointerCapture(e.pointerId);
+  }
+  const axisLabels = computed(() => {
+    const ppd = pixelsPerDay.value;
+    const labels = [];
+    const start = visibleStartDate.value;
+    const end = visibleEndDate.value;
+    if (ppd < TIER_MILLENNIA) {
+      addYearTierLabels(labels, start, end, 1e3, "fine");
+    } else if (ppd < TIER_CENTURIES) {
+      addYearTierLabels(labels, start, end, 100, "fine");
+      addYearTierLabels(labels, start, end, 1e3, "coarse");
+    } else if (ppd < TIER_DECADES) {
+      addYearTierLabels(labels, start, end, 10, "fine");
+      addYearTierLabels(labels, start, end, 100, "coarse");
+    } else if (ppd < TIER_YEARS) {
+      addYearTierLabels(labels, start, end, 1, "fine");
+      addYearTierLabels(labels, start, end, 10, "coarse");
+    } else if (ppd < TIER_MONTHS) {
+      addMonthLabels(labels, start, end, "fine");
+      addYearTierLabels(labels, start, end, 1, "coarse");
+    } else if (ppd < TIER_WEEKS) {
+      addWeekLabels(labels, start, end, "fine");
+      addMonthLabels(labels, start, end, "coarse");
+    } else {
+      addDayLabels(labels, start, end, "fine");
+      addMonthLabels(labels, start, end, "coarse");
+    }
+    return labels;
+  });
+  function addYearTierLabels(labels, start, end, step, tier) {
+    const startYear = Math.floor(start.getFullYear() / step) * step;
+    const endYear = end.getFullYear();
+    for (let y = startYear; y <= endYear + step; y += step) {
+      const d = new Date(0, 0, 1);
+      d.setFullYear(y, 0, 1);
+      const offset = dateToX(toDateStr(d));
+      if (offset >= -200 && offset <= containerWidth.value + 200) {
+        labels.push({ label: String(y), offset, tier });
+      }
+    }
+  }
+  function addMonthLabels(labels, start, end, tier) {
+    const loc = typeof navigator !== "undefined" ? navigator.language : "en-US";
+    const d = new Date(start.getFullYear(), start.getMonth(), 1);
+    while (d <= end) {
+      const offset = dateToX(toDateStr(d));
+      if (offset >= -200 && offset <= containerWidth.value + 200) {
+        const fmt = tier === "coarse" ? { month: "long", year: "numeric" } : { month: "short" };
+        labels.push({ label: d.toLocaleDateString(loc, fmt), offset, tier });
+      }
+      d.setMonth(d.getMonth() + 1);
+    }
+  }
+  function addWeekLabels(labels, start, end, tier) {
+    const d = new Date(start);
+    d.setDate(d.getDate() - (d.getDay() + 6) % 7);
+    while (d <= end) {
+      const offset = dateToX(toDateStr(d));
+      if (offset >= -200 && offset <= containerWidth.value + 200) {
+        labels.push({ label: `W${isoWeekNumber(d)}`, offset, tier });
+      }
+      d.setDate(d.getDate() + 7);
+    }
+  }
+  function addDayLabels(labels, start, end, tier) {
+    const loc = typeof navigator !== "undefined" ? navigator.language : "en-US";
+    const d = new Date(start);
+    while (d <= end) {
+      const offset = dateToX(toDateStr(d));
+      if (offset >= -200 && offset <= containerWidth.value + 200) {
+        labels.push({
+          label: d.toLocaleDateString(loc, { weekday: "short", day: "numeric" }),
+          offset,
+          tier
+        });
+      }
+      d.setDate(d.getDate() + 1);
+    }
+  }
+  function isoWeekNumber(d) {
+    const date = new Date(d.getTime());
+    date.setHours(0, 0, 0, 0);
+    date.setDate(date.getDate() + 3 - (date.getDay() + 6) % 7);
+    const week1 = new Date(date.getFullYear(), 0, 4);
+    return 1 + Math.round(((date.getTime() - week1.getTime()) / 864e5 - 3 + (week1.getDay() + 6) % 7) / 7);
+  }
+  function isBarVisible(startStr, endStr) {
+    if (!startStr) return false;
+    const start = new Date(startStr);
+    const end = endStr ? new Date(endStr) : start;
+    return end >= visibleStartDate.value && start <= visibleEndDate.value;
+  }
+  function isMilestone(entry) {
+    return !entry.meta?.dateEnd || entry.meta.dateEnd === entry.meta.dateStart;
+  }
+  function onKeydown(e) {
+    if (e.target?.tagName === "INPUT" || e.target?.tagName === "TEXTAREA") return;
+    switch (e.key) {
+      case "ArrowLeft":
+        e.preventDefault();
+        panByPixels(PAN_KEYBOARD_PX);
+        break;
+      case "ArrowRight":
+        e.preventDefault();
+        panByPixels(-PAN_KEYBOARD_PX);
+        break;
+      case "+":
+      case "=":
+        e.preventDefault();
+        zoomIn();
+        break;
+      case "-":
+        e.preventDefault();
+        zoomOut();
+        break;
+      case "t":
+        e.preventDefault();
+        goToday();
+        break;
+    }
+  }
+  return {
+    pixelsPerDay,
+    centerDate,
+    containerWidth,
+    isMobile,
+    visibleDays,
+    visibleStartDate,
+    visibleEndDate,
+    todayOffset,
+    axisLabels,
+    dateToX,
+    xToDate,
+    spanWidth,
+    toDateStr,
+    panByPixels,
+    navigateTo,
+    goToday,
+    fitToContent,
+    zoomIn,
+    zoomOut,
+    zoomAt,
+    setViewport,
+    animateViewport,
+    onWheel,
+    onTouchStart,
+    onTouchMove,
+    onTouchEnd,
+    onPanPointerDown,
+    onPanPointerMove,
+    onPanPointerUp,
+    onKeydown,
+    isBarVisible,
+    isMilestone
+  };
+}