@abraca/nuxt 0.2.0 → 1.5.0

package/dist/runtime/composables/useSpaces.js

@@ -0,0 +1,85 @@
+import { ref, computed } from "vue";
+import { useRoute } from "#imports";
+import { useAbracadabra } from "./useAbracadabra.js";
+const loading = ref(false);
+const error = ref(null);
+export function useSpaces() {
+  const abra = useAbracadabra();
+  const spaces = computed(() => abra.currentServerSpaces.value ?? []);
+  const spacesEnabled = computed(() => abra.currentServerSpacesEnabled.value ?? false);
+  const currentSpace = computed(() => {
+    const route = useRoute();
+    const docId = route.params.docId;
+    if (!docId) return spaces.value[0] ?? null;
+    return spaces.value.find((s) => s.doc_id === docId) ?? null;
+  });
+  async function refresh() {
+    loading.value = true;
+    error.value = null;
+    try {
+      await abra.refreshSpaces();
+    } catch (e) {
+      error.value = e.message ?? "Failed to refresh spaces";
+    } finally {
+      loading.value = false;
+    }
+  }
+  async function create(opts) {
+    error.value = null;
+    try {
+      return await abra.createSpace(opts);
+    } catch (e) {
+      error.value = e.message ?? "Failed to create space";
+      throw e;
+    }
+  }
+  async function update(id, opts) {
+    error.value = null;
+    try {
+      return await abra.updateSpace(id, opts);
+    } catch (e) {
+      error.value = e.message ?? "Failed to update space";
+      throw e;
+    }
+  }
+  async function remove(id) {
+    error.value = null;
+    try {
+      await abra.deleteSpace(id);
+    } catch (e) {
+      error.value = e.message ?? "Failed to delete space";
+      throw e;
+    }
+  }
+  async function switchTo(spaceDocId) {
+    error.value = null;
+    try {
+      await abra.switchSpace(abra.currentServerUrl.value, spaceDocId);
+    } catch (e) {
+      error.value = e.message ?? "Failed to switch space";
+      throw e;
+    }
+  }
+  return {
+    /** All spaces on the current server. */
+    spaces,
+    /** Whether the current server supports spaces. */
+    spacesEnabled,
+    /** The currently active space. */
+    currentSpace,
+    /** Whether space operations are in progress. */
+    loading,
+    /** Last error message. */
+    error,
+    /** Refresh spaces list from server. */
+    refresh,
+    /** Create a new space. */
+    create,
+    /** Update an existing space. */
+    update,
+    /** Delete a space. */
+    remove,
+    /** Switch to a different space. */
+    switchTo
+  };
+}

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

@@ -0,0 +1,16 @@
+export declare function useSpatialCamera(setLocalState: (state: Record<string, unknown>) => void, isFollowing?: () => boolean): {
+    cameraRef: import("vue").Ref<any, any>;
+    cameraPosition: import("vue").ComputedRef<[number, number, number]>;
+    cameraTarget: import("vue").ComputedRef<[number, number, number]>;
+    controlMode: import("vue").Ref<"orbit" | "fly", "orbit" | "fly">;
+    azimuth: import("vue").Ref<number, number>;
+    elevation: import("vue").Ref<number, number>;
+    distance: import("vue").Ref<number, number>;
+    focusOn: (worldPos: [number, number, number]) => void;
+    broadcastCamera: () => void;
+    applyCameraState: (position: [number, number, number], target: [number, number, number]) => void;
+    onCanvasPointerDown: (ev: PointerEvent) => void;
+    onCanvasPointerMove: (ev: PointerEvent) => void;
+    onCanvasPointerUp: () => void;
+    onCanvasWheel: (ev: WheelEvent) => void;
+};

package/dist/runtime/composables/useSpatialCamera.js

@@ -0,0 +1,175 @@
+import { ref, computed, onMounted, onBeforeUnmount } from "vue";
+export function useSpatialCamera(setLocalState, isFollowing = () => false) {
+  const azimuth = ref(Math.PI / 4);
+  const elevation = ref(Math.PI / 6);
+  const distance = ref(12);
+  const targetX = ref(0);
+  const targetY = ref(0);
+  const targetZ = ref(0);
+  const controlMode = ref("orbit");
+  const isDragging = ref(false);
+  const dragButton = ref(0);
+  let lastPX = 0;
+  let lastPY = 0;
+  let focusAnim = null;
+  const keysDown = /* @__PURE__ */ new Set();
+  const cameraPosition = computed(() => {
+    const el = Math.max(0.05, Math.min(Math.PI / 2 - 0.05, elevation.value));
+    const x = targetX.value + distance.value * Math.cos(el) * Math.sin(azimuth.value);
+    const y = targetY.value + distance.value * Math.sin(el);
+    const z = targetZ.value + distance.value * Math.cos(el) * Math.cos(azimuth.value);
+    return [x, y, z];
+  });
+  const cameraTarget = computed(() => [
+    targetX.value,
+    targetY.value,
+    targetZ.value
+  ]);
+  const cameraRef = ref(null);
+  function onCanvasPointerDown(ev) {
+    isDragging.value = true;
+    dragButton.value = ev.button;
+    lastPX = ev.clientX;
+    lastPY = ev.clientY;
+  }
+  function onCanvasPointerMove(ev) {
+    if (!isDragging.value) return;
+    const dx = ev.clientX - lastPX;
+    const dy = ev.clientY - lastPY;
+    lastPX = ev.clientX;
+    lastPY = ev.clientY;
+    if (dragButton.value === 0 && !ev.shiftKey) {
+      azimuth.value -= dx * 5e-3;
+      elevation.value += dy * 5e-3;
+      elevation.value = Math.max(0.05, Math.min(Math.PI / 2 - 0.05, elevation.value));
+    } else {
+      const panSpeed = 5e-3 * distance.value;
+      const sinA = Math.sin(azimuth.value);
+      const cosA = Math.cos(azimuth.value);
+      targetX.value += -cosA * dx * panSpeed;
+      targetZ.value += sinA * dx * panSpeed;
+      targetY.value += dy * panSpeed;
+    }
+    broadcastCamera();
+  }
+  function onCanvasPointerUp() {
+    isDragging.value = false;
+    broadcastCamera();
+  }
+  function onCanvasWheel(ev) {
+    ev.preventDefault();
+    distance.value *= 1 + ev.deltaY * 1e-3;
+    distance.value = Math.max(1, Math.min(200, distance.value));
+    broadcastCamera();
+  }
+  function focusOn(worldPos) {
+    focusAnim = {
+      start: performance.now(),
+      fromX: targetX.value,
+      fromY: targetY.value,
+      fromZ: targetZ.value,
+      toX: worldPos[0],
+      toY: worldPos[1],
+      toZ: worldPos[2]
+    };
+  }
+  function onKeyDown(ev) {
+    if (controlMode.value !== "fly") return;
+    keysDown.add(ev.key.toLowerCase());
+  }
+  function onKeyUp(ev) {
+    keysDown.delete(ev.key.toLowerCase());
+  }
+  let rafId = 0;
+  function tick() {
+    rafId = requestAnimationFrame(tick);
+    if (focusAnim) {
+      const t = Math.min(1, (performance.now() - focusAnim.start) / 500);
+      const ease = t * (2 - t);
+      targetX.value = focusAnim.fromX + (focusAnim.toX - focusAnim.fromX) * ease;
+      targetY.value = focusAnim.fromY + (focusAnim.toY - focusAnim.fromY) * ease;
+      targetZ.value = focusAnim.fromZ + (focusAnim.toZ - focusAnim.fromZ) * ease;
+      if (t >= 1) focusAnim = null;
+      broadcastCamera();
+    }
+    if (controlMode.value === "fly") {
+      const speed = 0.15;
+      const sinA = Math.sin(azimuth.value);
+      const cosA = Math.cos(azimuth.value);
+      if (keysDown.has("w")) {
+        targetX.value -= sinA * speed;
+        targetZ.value -= cosA * speed;
+      }
+      if (keysDown.has("s")) {
+        targetX.value += sinA * speed;
+        targetZ.value += cosA * speed;
+      }
+      if (keysDown.has("a")) {
+        targetX.value -= cosA * speed;
+        targetZ.value += sinA * speed;
+      }
+      if (keysDown.has("d")) {
+        targetX.value += cosA * speed;
+        targetZ.value -= sinA * speed;
+      }
+      if (keysDown.has(" ")) targetY.value += speed;
+      if (keysDown.has("shift")) targetY.value -= speed;
+      if (keysDown.size > 0) broadcastCamera();
+    }
+  }
+  let lastBroadcast = 0;
+  function broadcastCamera() {
+    if (isFollowing()) return;
+    const now = Date.now();
+    if (now - lastBroadcast < 80) return;
+    lastBroadcast = now;
+    setLocalState({
+      spatial: {
+        camera: {
+          position: cameraPosition.value,
+          target: cameraTarget.value,
+          timestamp: now
+        }
+      }
+    });
+  }
+  function applyCameraState(position, target) {
+    targetX.value = target[0];
+    targetY.value = target[1];
+    targetZ.value = target[2];
+    const dx = position[0] - target[0];
+    const dy = position[1] - target[1];
+    const dz = position[2] - target[2];
+    distance.value = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (distance.value > 1e-3) {
+      elevation.value = Math.asin(dy / distance.value);
+      azimuth.value = Math.atan2(dx, dz);
+    }
+  }
+  onMounted(() => {
+    rafId = requestAnimationFrame(tick);
+    window.addEventListener("keydown", onKeyDown);
+    window.addEventListener("keyup", onKeyUp);
+  });
+  onBeforeUnmount(() => {
+    cancelAnimationFrame(rafId);
+    window.removeEventListener("keydown", onKeyDown);
+    window.removeEventListener("keyup", onKeyUp);
+  });
+  return {
+    cameraRef,
+    cameraPosition,
+    cameraTarget,
+    controlMode,
+    azimuth,
+    elevation,
+    distance,
+    focusOn,
+    broadcastCamera,
+    applyCameraState,
+    onCanvasPointerDown,
+    onCanvasPointerMove,
+    onCanvasPointerUp,
+    onCanvasWheel
+  };
+}

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

@@ -0,0 +1,14 @@
+import type { Ref } from 'vue';
+import type { TreeEntry } from '../types.js';
+export declare function useSpatialDrag(tree: {
+    entries: Ref<TreeEntry[]>;
+    updateMeta: (id: string, meta: Record<string, unknown>) => void;
+}, selectedIds: Ref<Set<string>>, _cameraRef: Ref<any>, setLocalState: (state: Record<string, unknown>) => void, sceneSettings: {
+    data: Record<string, unknown>;
+}): {
+    draggingId: Ref<string | null, string | null>;
+    bindScene: (canvas: HTMLCanvasElement, sceneObj: any, cameraObj: any) => void;
+    onPointerDown: (ev: PointerEvent) => string | null;
+    onPointerMove: (ev: PointerEvent) => void;
+    onPointerUp: (_ev: PointerEvent) => void;
+};

package/dist/runtime/composables/useSpatialDrag.js

@@ -0,0 +1,137 @@
+import { ref, onMounted, onBeforeUnmount } from "vue";
+export function useSpatialDrag(tree, selectedIds, _cameraRef, setLocalState, sceneSettings) {
+  const draggingId = ref(null);
+  let canvasEl = null;
+  let scene = null;
+  let camera = null;
+  let isDragging = false;
+  let dragStartWorldX = 0;
+  let dragStartWorldZ = 0;
+  const dragEntryStartPositions = /* @__PURE__ */ new Map();
+  const keysDown = /* @__PURE__ */ new Set();
+  function onKeyDown(ev) {
+    keysDown.add(ev.key.toLowerCase());
+  }
+  function onKeyUp(ev) {
+    keysDown.delete(ev.key.toLowerCase());
+  }
+  onMounted(() => {
+    window.addEventListener("keydown", onKeyDown);
+    window.addEventListener("keyup", onKeyUp);
+  });
+  onBeforeUnmount(() => {
+    window.removeEventListener("keydown", onKeyDown);
+    window.removeEventListener("keyup", onKeyUp);
+  });
+  function bindScene(canvas, sceneObj, cameraObj) {
+    canvasEl = canvas;
+    scene = sceneObj;
+    camera = cameraObj;
+  }
+  function raycastEntryId(ev) {
+    if (!canvasEl || !scene || !camera) return null;
+    try {
+      const THREE = globalThis.__ABRACA_SHARED__?.three;
+      if (!THREE) return null;
+      const rect = canvasEl.getBoundingClientRect();
+      const pointer = new THREE.Vector2(
+        (ev.clientX - rect.left) / rect.width * 2 - 1,
+        -((ev.clientY - rect.top) / rect.height) * 2 + 1
+      );
+      const raycaster = new THREE.Raycaster();
+      raycaster.setFromCamera(pointer, camera);
+      const intersects = raycaster.intersectObjects(scene.children, true);
+      for (const hit of intersects) {
+        let obj = hit.object;
+        while (obj) {
+          if (obj.userData?.entryId) return obj.userData.entryId;
+          obj = obj.parent;
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  function getGroundIntersection(ev) {
+    if (!canvasEl || !camera) return null;
+    try {
+      const THREE = globalThis.__ABRACA_SHARED__?.three;
+      if (!THREE) return null;
+      const rect = canvasEl.getBoundingClientRect();
+      const pointer = new THREE.Vector2(
+        (ev.clientX - rect.left) / rect.width * 2 - 1,
+        -((ev.clientY - rect.top) / rect.height) * 2 + 1
+      );
+      const raycaster = new THREE.Raycaster();
+      raycaster.setFromCamera(pointer, camera);
+      const plane = new THREE.Plane(new THREE.Vector3(0, 1, 0), 0);
+      const target = new THREE.Vector3();
+      const hit = raycaster.ray.intersectPlane(plane, target);
+      return hit ? { x: target.x, z: target.z } : null;
+    } catch {
+      return null;
+    }
+  }
+  function onPointerDown(ev) {
+    if (ev.button !== 0) return null;
+    const hitId = raycastEntryId(ev);
+    if (!hitId) return null;
+    isDragging = true;
+    draggingId.value = hitId;
+    dragEntryStartPositions.clear();
+    const worldPos = getGroundIntersection(ev);
+    if (worldPos) {
+      dragStartWorldX = worldPos.x;
+      dragStartWorldZ = worldPos.z;
+    }
+    setLocalState({ spatial: { dragging: hitId } });
+    return hitId;
+  }
+  function onPointerMove(ev) {
+    if (!isDragging || !draggingId.value) return;
+    if (dragEntryStartPositions.size === 0) {
+      for (const id of selectedIds.value) {
+        const entry = tree.entries.value.find((e) => e.id === id);
+        if (entry) {
+          dragEntryStartPositions.set(id, {
+            x: entry.meta?.spX ?? 0,
+            y: entry.meta?.spY ?? 0,
+            z: entry.meta?.spZ ?? 0
+          });
+        }
+      }
+    }
+    const worldPos = getGroundIntersection(ev);
+    if (!worldPos) return;
+    let dx = worldPos.x - dragStartWorldX;
+    const dy = 0;
+    let dz = worldPos.z - dragStartWorldZ;
+    if (keysDown.has("x")) {
+      dz = 0;
+    }
+    if (keysDown.has("z")) {
+      dx = 0;
+    }
+    const snapSize = sceneSettings.data.snapSize || 0;
+    const snap = (v) => snapSize > 0 ? Math.round(v / snapSize) * snapSize : v;
+    for (const [id, start] of dragEntryStartPositions) {
+      const newX = snap(start.x + dx);
+      const newY = snap(start.y + dy);
+      const newZ = snap(start.z + dz);
+      tree.updateMeta(id, { spX: newX, spY: newY, spZ: newZ });
+    }
+  }
+  function onPointerUp(_ev) {
+    isDragging = false;
+    draggingId.value = null;
+    dragEntryStartPositions.clear();
+    setLocalState({ spatial: { dragging: null } });
+  }
+  return {
+    draggingId,
+    bindScene,
+    onPointerDown,
+    onPointerMove,
+    onPointerUp
+  };
+}

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 {};