@ankhorage/zora 25.4.0 → 25.6.0

package/src/types/grid-view.ts

@@ -1,4 +1,9 @@
-import type { GridRectItem, GridViewport } from '@ankhorage/grid-view';
+import type {
+  GridRectItem,
+  GridViewport,
+  GridViewportConstraints,
+  GridZoomLimits,
+} from '@ankhorage/grid-view';
 import type React from 'react';
 
 import type { ZoraBaseProps } from './base';
@@ -10,6 +15,20 @@ export interface GridViewProps extends ZoraBaseProps {
   contentHeight: number;
   width: number;
   height: number;
+  /**
+   * Canonical controlled world viewport. Supplying this value makes `onViewportChange`
+   * report interaction proposals without mutating renderer-owned state.
+   */
+  viewport?: GridViewport;
+  /** Initial world position and independent axis scales for uncontrolled rendering. */
+  defaultViewport?: Partial<
+    Pick<GridViewport, 'offsetX' | 'offsetY' | 'pixelsPerUnitX' | 'pixelsPerUnitY'>
+  >;
+  /** Finite world bounds and optional overscroll for panning and focused-item reveal. */
+  viewportConstraints?: GridViewportConstraints;
+  /** Independent X/Y scale limits applied to focal-point zoom interactions. */
+  zoomLimits?: GridZoomLimits;
+  /** @deprecated Use `defaultViewport` for new code. */
   zoom?: number;
   overscanPixels?: number;
   /** Stable item identity that must be scrolled into view without duplicating viewport geometry. */
@@ -34,11 +53,18 @@ export interface TileGridProps extends ZoraBaseProps {
   tileSize?: number;
   gap?: number;
   zoom?: number;
+  viewport?: GridViewport;
+  defaultViewport?: Partial<
+    Pick<GridViewport, 'offsetX' | 'offsetY' | 'pixelsPerUnitX' | 'pixelsPerUnitY'>
+  >;
+  viewportConstraints?: GridViewportConstraints;
+  zoomLimits?: GridZoomLimits;
   overscanPixels?: number;
   focusedItemId?: string;
   revealPaddingPixels?: number;
   /** Reports the same measured column count used to position tiles. */
   onColumnsChange?: (columns: number) => void;
+  onViewportChange?: (viewport: GridViewport) => void;
   onVisibleItemIdsChange?: (ids: readonly string[]) => void;
   renderItem: (item: TileGridItem) => React.ReactNode;
 }

package/src/types/time-grid.ts

@@ -0,0 +1,33 @@
+import type { GridLane, GridLaneInterval, GridViewport } from '@ankhorage/grid-view';
+import type React from 'react';
+
+import type { ZoraBaseProps } from './base';
+
+/** An ordered, variable-height track rendered by the generic TimeGrid. */
+export type TimeGridLane = GridLane;
+
+/** A stable world-space interval rendered by the generic TimeGrid. */
+export type TimeGridInterval = GridLaneInterval;
+
+/**
+ * Code API for virtualized interval lanes. Domain adapters map dates, PPQ ticks, and other units
+ * to numeric world coordinates before reaching this boundary.
+ */
+export interface TimeGridProps extends ZoraBaseProps {
+  readonly lanes: readonly TimeGridLane[];
+  readonly intervals: readonly TimeGridInterval[];
+  readonly contentWidth: number;
+  readonly width: number;
+  readonly height: number;
+  readonly zoom?: number;
+  readonly overscanPixels?: number;
+  readonly focusedIntervalId?: string;
+  readonly onFocusedIntervalIdChange?: (id: string) => void;
+  readonly revealPaddingPixels?: number;
+  readonly selectedIntervalIds?: readonly string[];
+  readonly onIntervalPress?: (interval: TimeGridInterval) => void;
+  readonly onViewportChange?: (viewport: GridViewport) => void;
+  readonly onVisibleIntervalIdsChange?: (ids: readonly string[]) => void;
+  readonly renderInterval: (interval: TimeGridInterval, selected: boolean) => React.ReactNode;
+  readonly renderLaneLabel?: (lane: TimeGridLane) => React.ReactNode;
+}

package/web-dist/chunks/{Accordion-r2w86rwv.js → Accordion-ebghcyzj.js}

@@ -47,6 +47,68 @@ function getVisibleGridItems(items, viewport, overscanPixels = 0) {
   return items.filter((item) => item.x <= bounds.x + bounds.width && item.x + item.width >= bounds.x && item.y <= bounds.y + bounds.height && item.y + item.height >= bounds.y);
 }
 
+// node_modules/@ankhorage/grid-view/dist/features/layout/createGridAxisMetrics.js
+function createGridAxisMetrics(entries) {
+  const indexes = new Map;
+  const offsets = [];
+  const sizes = [];
+  let offset = 0;
+  entries.forEach((entry, index) => {
+    if (!entry.id || indexes.has(entry.id)) {
+      throw new RangeError("Layout axis entries require unique nonempty IDs.");
+    }
+    if (!Number.isFinite(entry.size) || entry.size <= 0) {
+      throw new RangeError("Layout axis entry sizes must be finite positive numbers.");
+    }
+    const end = offset + entry.size;
+    if (!Number.isFinite(end)) {
+      throw new RangeError("Layout axis cumulative world coordinates must be finite.");
+    }
+    indexes.set(entry.id, index);
+    offsets.push(offset);
+    sizes.push(entry.size);
+    offset = end;
+  });
+  return { indexes, offsets, sizes };
+}
+
+// node_modules/@ankhorage/grid-view/dist/features/layout/utils/readGridAxisMetric.js
+function readGridAxisMetric(values, index) {
+  const value = values.at(index);
+  if (value === undefined) {
+    throw new RangeError("Layout axis metric indexes must reference an existing entry.");
+  }
+  return value;
+}
+
+// node_modules/@ankhorage/grid-view/dist/features/layout/utils/resolveLaneIntervalPlacement.js
+function resolveLaneIntervalPlacement(interval, lanes) {
+  if (!interval.id || !Number.isFinite(interval.start) || !Number.isFinite(interval.extent) || interval.extent <= 0) {
+    throw new RangeError("Lane intervals require an ID, finite start, and positive extent.");
+  }
+  if (!Number.isFinite(interval.start + interval.extent)) {
+    throw new RangeError("Lane interval end coordinates must be finite.");
+  }
+  const laneIndex = lanes.indexes.get(interval.laneId);
+  if (laneIndex === undefined) {
+    throw new RangeError("Lane intervals must reference an existing lane.");
+  }
+  return {
+    ...interval,
+    laneIndex,
+    x: interval.start,
+    y: readGridAxisMetric(lanes.offsets, laneIndex),
+    width: interval.extent,
+    height: readGridAxisMetric(lanes.sizes, laneIndex)
+  };
+}
+
+// node_modules/@ankhorage/grid-view/dist/features/layout/getLaneIntervalPlacement.js
+function getLaneIntervalPlacement(lanes, interval) {
+  const laneMetrics = createGridAxisMetrics(lanes.map(({ id, height }) => ({ id, size: height })));
+  return resolveLaneIntervalPlacement(interval, laneMetrics);
+}
+
 // node_modules/@ankhorage/grid-view/dist/features/viewport/constrainViewport.js
 function constrainViewport(viewport, constraints) {
   assertValidViewport(viewport);
@@ -81,6 +143,18 @@ function isAlignment(value) {
   return value === "start" || value === "center" || value === "end";
 }
 
+// node_modules/@ankhorage/grid-view/dist/features/viewport/panViewport.js
+function panViewport(viewport, displacement, constraints) {
+  if (![displacement.x, displacement.y].every(Number.isFinite)) {
+    throw new RangeError("Pan displacement must be finite.");
+  }
+  return constrainViewport({
+    ...viewport,
+    offsetX: viewport.offsetX - displacement.x / viewport.pixelsPerUnitX,
+    offsetY: viewport.offsetY - displacement.y / viewport.pixelsPerUnitY
+  }, constraints);
+}
+
 // node_modules/@ankhorage/grid-view/dist/features/viewport/revealWorldRect.js
 function revealWorldRect(viewport, rect, paddingPixels = 0, constraints) {
   validateRevealInput(viewport, rect, paddingPixels);
@@ -130,6 +204,34 @@ function worldToViewport(point, viewport) {
   };
 }
 
+// node_modules/@ankhorage/grid-view/dist/features/viewport/zoomViewportAt.js
+function zoomViewportAt(viewport, focalPoint, nextScale, limits = {}, constraints) {
+  if (![focalPoint.x, focalPoint.y, nextScale.pixelsPerUnitX, nextScale.pixelsPerUnitY].every(Number.isFinite)) {
+    throw new RangeError("Focal points and scales must be finite.");
+  }
+  const focalWorld = viewportToWorld(focalPoint, viewport);
+  const x = constrainScale(nextScale.pixelsPerUnitX, limits.minX, limits.maxX);
+  const y = constrainScale(nextScale.pixelsPerUnitY, limits.minY, limits.maxY);
+  return constrainViewport({
+    ...viewport,
+    pixelsPerUnitX: x,
+    pixelsPerUnitY: y,
+    offsetX: focalWorld.x - focalPoint.x / x,
+    offsetY: focalWorld.y - focalPoint.y / y
+  }, constraints);
+}
+function constrainScale(scale, minimum, maximum) {
+  const min = minimum ?? Number.EPSILON;
+  const max = maximum ?? Infinity;
+  if (!Number.isFinite(min) || min <= 0 || maximum !== undefined && (!Number.isFinite(max) || max <= 0 || min > max)) {
+    throw new RangeError("Zoom limits must be finite positive ranges.");
+  }
+  if (scale <= 0) {
+    throw new RangeError("Viewport scales must be positive.");
+  }
+  return Math.max(min, Math.min(max, scale));
+}
+
 // node_modules/@ankhorage/grid-view/dist/features/axes/getAxisCategoryTicks.js
 function getAxisCategoryTicks(viewport, axis, categories) {
   const bounds = getVisibleWorldBounds(viewport);
@@ -206,4 +308,26 @@ function adaptiveStep(minimum) {
   const multiplier = [1, 2, 5, 10].find((candidate) => candidate * magnitude >= minimum) ?? 10;
   return multiplier * magnitude;
 }
-export { getAxisCategoryTicks, getAxisTicks, getVisibleGridItems, revealWorldRect, worldToViewport };
+// node_modules/@ankhorage/grid-view/dist/features/layout/getVisibleLaneIntervals.js
+function getVisibleLaneIntervals(lanes, intervals, viewport, overscanPixels = 0) {
+  const laneMetrics = createGridAxisMetrics(lanes.map(({ id, height }) => ({ id, size: height })));
+  const bounds = getVisibleWorldBounds(viewport, overscanPixels);
+  validateUniqueIds(intervals);
+  return intervals.flatMap((interval) => {
+    const placement = resolveLaneIntervalPlacement(interval, laneMetrics);
+    return intersects(placement.x, placement.width, bounds.x, bounds.width) && intersects(placement.y, placement.height, bounds.y, bounds.height) ? [placement] : [];
+  });
+}
+function validateUniqueIds(intervals) {
+  const ids = new Set;
+  intervals.forEach(({ id }) => {
+    if (ids.has(id)) {
+      throw new RangeError("Lane intervals require unique IDs.");
+    }
+    ids.add(id);
+  });
+}
+function intersects(firstStart, firstExtent, secondStart, secondExtent) {
+  return firstStart <= secondStart + secondExtent && firstStart + firstExtent >= secondStart;
+}
+export { getAxisCategoryTicks, getAxisTicks, getVisibleGridItems, getLaneIntervalPlacement, getVisibleLaneIntervals, constrainViewport, panViewport, revealWorldRect, worldToViewport, zoomViewportAt };

package/web-dist/chunks/{Accordion-s3d6g59s.js → Accordion-f43jba23.js}

@@ -1,7 +1,7 @@
 'use client';
 import {
   TileGrid2
-} from "./Accordion-nxsda1my.js";
+} from "./Accordion-q8exgc3h.js";
 import {
   withZoraThemeScope
 } from "./Accordion-42jfy1a1.js";