@ankhorage/zora 25.3.0 → 25.5.0

package/src/features/time-grid/adapters/inbound/TimeGrid.tsx

@@ -0,0 +1,197 @@
+import { getLaneIntervalPlacement, type GridViewport } from '@ankhorage/grid-view';
+import React from 'react';
+import { Pressable, View } from 'react-native';
+
+import type { TimeGridProps } from '../../../../types/time-grid';
+import { GridView } from '../../../grid-view/public';
+import { resolveTimeGridNextFocusId } from '../../application/resolveTimeGridNextFocusId';
+import { resolveTimeGridVisibleIntervals } from '../../application/resolveTimeGridVisibleIntervals';
+import { TimeGridKeyboardProxy } from './TimeGridKeyboardProxy';
+
+/*** Presents virtualized variable-height interval lanes through ZORA's shared GridView renderer. */
+export function TimeGrid({
+  contentWidth,
+  focusedIntervalId,
+  height,
+  interactionPolicy,
+  intervals,
+  lanes,
+  onFocusedIntervalIdChange,
+  onIntervalPress,
+  onViewportChange,
+  onVisibleIntervalIdsChange,
+  overscanPixels,
+  renderInterval,
+  renderLaneLabel,
+  revealPaddingPixels,
+  selectedIntervalIds = [],
+  testID,
+  width,
+  zoom,
+}: TimeGridProps) {
+  const scale = Math.max(0.01, zoom ?? 1);
+  const [scrollOffsets, setScrollOffsets] = React.useState(() => ({
+    offsetX: 0,
+    offsetY: 0,
+  }));
+  const viewport = React.useMemo<GridViewport>(
+    () => ({
+      ...scrollOffsets,
+      height,
+      pixelsPerUnitX: scale,
+      pixelsPerUnitY: scale,
+      width,
+    }),
+    [height, scale, scrollOffsets, width],
+  );
+  const intervalById = React.useMemo(
+    () => new Map(intervals.map((interval) => [interval.id, interval])),
+    [intervals],
+  );
+  const selectedIds = React.useMemo(() => new Set(selectedIntervalIds), [selectedIntervalIds]);
+  const contentHeight = React.useMemo(
+    () => lanes.reduce((total, lane) => total + lane.height, 0),
+    [lanes],
+  );
+  const visibleIntervals = React.useMemo(
+    () => resolveTimeGridVisibleIntervals(lanes, intervals, viewport, overscanPixels),
+    [intervals, lanes, overscanPixels, viewport],
+  );
+  const focusedPlacement = React.useMemo(() => {
+    const focusedInterval = intervals.find((interval) => interval.id === focusedIntervalId);
+    return focusedInterval ? getLaneIntervalPlacement(lanes, focusedInterval) : undefined;
+  }, [focusedIntervalId, intervals, lanes]);
+  const gridItems = React.useMemo(
+    () =>
+      focusedPlacement && !visibleIntervals.some((interval) => interval.id === focusedPlacement.id)
+        ? [...visibleIntervals, focusedPlacement]
+        : visibleIntervals,
+    [focusedPlacement, visibleIntervals],
+  );
+  const labelIntervals = React.useMemo(
+    () =>
+      lanes.map((lane) => ({
+        extent: contentWidth,
+        id: `lane-label-${lane.id}`,
+        laneId: lane.id,
+        start: 0,
+      })),
+    [contentWidth, lanes],
+  );
+  const visibleLabels = React.useMemo(
+    () => resolveTimeGridVisibleIntervals(lanes, labelIntervals, viewport, overscanPixels),
+    [labelIntervals, lanes, overscanPixels, viewport],
+  );
+
+  const handleViewportChange = React.useCallback(
+    (nextViewport: GridViewport) => {
+      setScrollOffsets((current) =>
+        current.offsetX === nextViewport.offsetX && current.offsetY === nextViewport.offsetY
+          ? current
+          : { offsetX: nextViewport.offsetX, offsetY: nextViewport.offsetY },
+      );
+      onViewportChange?.(nextViewport);
+    },
+    [onViewportChange],
+  );
+
+  const resolveNextFocusId = React.useCallback(
+    (intervalId: string, direction: 'down' | 'left' | 'right' | 'up') => {
+      const allIntervals = resolveTimeGridVisibleIntervals(lanes, intervals, {
+        height: contentHeight,
+        offsetX: 0,
+        offsetY: 0,
+        pixelsPerUnitX: 1,
+        pixelsPerUnitY: 1,
+        width: contentWidth,
+      });
+      return resolveTimeGridNextFocusId(allIntervals, intervalId, direction);
+    },
+    [contentHeight, contentWidth, intervals, lanes],
+  );
+
+  return (
+    <View style={{ flexDirection: 'row', height, width }} testID={testID}>
+      {renderLaneLabel ? (
+        <View
+          accessibilityElementsHidden
+          pointerEvents="none"
+          style={{ height, overflow: 'hidden' }}
+        >
+          {visibleLabels.map((placement) => {
+            const lane = lanes[placement.laneIndex];
+            if (!lane) return null;
+            return (
+              <View
+                key={lane.id}
+                style={{
+                  height: placement.height * scale,
+                  position: 'absolute',
+                  top: (placement.y - viewport.offsetY) * scale,
+                }}
+                testID={testID === undefined ? undefined : `${testID}-lane-label-${lane.id}`}
+              >
+                {renderLaneLabel(lane)}
+              </View>
+            );
+          })}
+        </View>
+      ) : null}
+      <GridView
+        contentHeight={contentHeight}
+        contentWidth={contentWidth}
+        focusedItemId={focusedIntervalId}
+        height={height}
+        interactionPolicy={interactionPolicy}
+        items={gridItems}
+        onViewportChange={handleViewportChange}
+        onVisibleItemIdsChange={onVisibleIntervalIdsChange}
+        overscanPixels={overscanPixels}
+        renderItem={(placement) => {
+          const interval = intervalById.get(placement.id);
+          if (!interval) return null;
+          const selected = selectedIds.has(interval.id);
+          return (
+            <TimeGridKeyboardProxy
+              onKeyDown={(key) => {
+                const direction = resolveKeyboardDirection(key);
+                const nextId =
+                  direction === undefined ? undefined : resolveNextFocusId(interval.id, direction);
+                if (!nextId) return false;
+                onFocusedIntervalIdChange?.(nextId);
+                return true;
+              }}
+            >
+              <Pressable
+                accessibilityLabel={`Interval ${interval.id}`}
+                accessibilityRole="button"
+                disabled={interactionPolicy === 'passive'}
+                onPress={() => {
+                  onFocusedIntervalIdChange?.(interval.id);
+                  onIntervalPress?.(interval);
+                }}
+                style={{ flex: 1 }}
+                testID={testID === undefined ? undefined : `${testID}-interval-${interval.id}`}
+              >
+                {renderInterval(interval, selected)}
+              </Pressable>
+            </TimeGridKeyboardProxy>
+          );
+        }}
+        revealPaddingPixels={revealPaddingPixels}
+        testID={testID === undefined ? undefined : `${testID}-viewport`}
+        width={width}
+        zoom={zoom}
+      />
+    </View>
+  );
+}
+
+/*** Maps desktop arrow keys to the platform-neutral interval navigation directions. */
+function resolveKeyboardDirection(key: string): 'down' | 'left' | 'right' | 'up' | undefined {
+  if (key === 'ArrowDown') return 'down';
+  if (key === 'ArrowLeft') return 'left';
+  if (key === 'ArrowRight') return 'right';
+  if (key === 'ArrowUp') return 'up';
+  return undefined;
+}

package/src/features/time-grid/adapters/inbound/TimeGridKeyboardProxy.native.tsx

@@ -0,0 +1,11 @@
+import type React from 'react';
+
+/*** Preserves native activation and touch interaction where DOM arrow-key events do not exist. */
+export function TimeGridKeyboardProxy({ children }: TimeGridKeyboardProxyProps) {
+  return <>{children}</>;
+}
+
+interface TimeGridKeyboardProxyProps {
+  readonly children: React.ReactNode;
+  readonly onKeyDown: (key: string) => boolean;
+}

package/src/features/time-grid/adapters/inbound/TimeGridKeyboardProxy.tsx

@@ -0,0 +1,11 @@
+import type React from 'react';
+
+/*** Provides the native fallback type surface; React Native Web resolves the DOM adapter at runtime. */
+export function TimeGridKeyboardProxy({ children }: TimeGridKeyboardProxyProps) {
+  return <>{children}</>;
+}
+
+interface TimeGridKeyboardProxyProps {
+  readonly children: React.ReactNode;
+  readonly onKeyDown: (key: string) => boolean;
+}

package/src/features/time-grid/adapters/inbound/TimeGridKeyboardProxy.web.tsx

@@ -0,0 +1,20 @@
+import type React from 'react';
+
+/*** Bridges DOM arrow keys into portable interval focus navigation on React Native Web. */
+export function TimeGridKeyboardProxy({ children, onKeyDown }: TimeGridKeyboardProxyProps) {
+  return (
+    <div
+      onKeyDown={(event) => {
+        if (onKeyDown(event.key)) event.preventDefault();
+      }}
+      style={{ display: 'flex', flex: 1 }}
+    >
+      {children}
+    </div>
+  );
+}
+
+interface TimeGridKeyboardProxyProps {
+  readonly children: React.ReactNode;
+  readonly onKeyDown: (key: string) => boolean;
+}

package/src/features/time-grid/application/resolveTimeGridNextFocusId.test.ts

@@ -0,0 +1,46 @@
+import { expect, test } from 'bun:test';
+
+import { resolveTimeGridNextFocusId } from './resolveTimeGridNextFocusId';
+
+const placements = [
+  {
+    extent: 4,
+    height: 20,
+    id: 'drums-a',
+    laneId: 'drums',
+    laneIndex: 0,
+    start: 2,
+    width: 4,
+    x: 2,
+    y: 0,
+  },
+  {
+    extent: 4,
+    height: 20,
+    id: 'drums-b',
+    laneId: 'drums',
+    laneIndex: 0,
+    start: 12,
+    width: 4,
+    x: 12,
+    y: 0,
+  },
+  {
+    extent: 4,
+    height: 20,
+    id: 'bass-a',
+    laneId: 'bass',
+    laneIndex: 1,
+    start: 3,
+    width: 4,
+    x: 3,
+    y: 20,
+  },
+] as const;
+
+test('moves keyboard focus by interval geometry without calendar or music semantics', () => {
+  expect(resolveTimeGridNextFocusId(placements, 'drums-a', 'right')).toBe('drums-b');
+  expect(resolveTimeGridNextFocusId(placements, 'drums-b', 'left')).toBe('drums-a');
+  expect(resolveTimeGridNextFocusId(placements, 'drums-a', 'down')).toBe('bass-a');
+  expect(resolveTimeGridNextFocusId(placements, 'bass-a', 'up')).toBe('drums-a');
+});

package/src/features/time-grid/application/resolveTimeGridNextFocusId.ts

@@ -0,0 +1,41 @@
+import type { GridLaneIntervalPlacement } from '@ankhorage/grid-view';
+
+/*** Resolves a neighboring interval for keyboard movement without attaching domain meaning to lanes. */
+export function resolveTimeGridNextFocusId(
+  placements: readonly GridLaneIntervalPlacement[],
+  focusedId: string,
+  direction: 'down' | 'left' | 'right' | 'up',
+): string | undefined {
+  const focused = placements.find((placement) => placement.id === focusedId);
+  if (!focused) return undefined;
+  const candidates = placements.filter((placement) => {
+    if (direction === 'left') return placement.laneId === focused.laneId && placement.x < focused.x;
+    if (direction === 'right')
+      return placement.laneId === focused.laneId && placement.x > focused.x;
+    if (direction === 'up') return placement.laneIndex < focused.laneIndex;
+    return placement.laneIndex > focused.laneIndex;
+  });
+  return candidates
+    .sort(
+      (first, second) =>
+        resolveFocusDistance(first, focused, direction) -
+        resolveFocusDistance(second, focused, direction),
+    )
+    .at(0)?.id;
+}
+
+/*** Measures nearby candidates by axis first and timeline/lane offset second. */
+function resolveFocusDistance(
+  candidate: GridLaneIntervalPlacement,
+  focused: GridLaneIntervalPlacement,
+  direction: 'down' | 'left' | 'right' | 'up',
+): number {
+  const horizontal = direction === 'left' || direction === 'right';
+  const primary = horizontal
+    ? Math.abs(candidate.x - focused.x)
+    : Math.abs(candidate.laneIndex - focused.laneIndex);
+  const secondary = horizontal
+    ? Math.abs(candidate.laneIndex - focused.laneIndex)
+    : Math.abs(candidate.x - focused.x);
+  return primary * 1_000_000 + secondary;
+}

package/src/features/time-grid/application/resolveTimeGridVisibleIntervals.test.ts

@@ -0,0 +1,33 @@
+import { expect, test } from 'bun:test';
+
+import { resolveTimeGridVisibleIntervals } from './resolveTimeGridVisibleIntervals';
+
+test('culls sparse intervals across both time and lane axes', () => {
+  expect(
+    resolveTimeGridVisibleIntervals(
+      [
+        { height: 20, id: 'drums' },
+        { height: 40, id: 'bass' },
+        { height: 30, id: 'strings' },
+      ],
+      [
+        { extent: 4, id: 'intro', laneId: 'drums', start: 2 },
+        { extent: 4, id: 'verse', laneId: 'bass', start: 20 },
+        { extent: 4, id: 'outro', laneId: 'strings', start: 2 },
+      ],
+      { height: 45, offsetX: 0, offsetY: 0, pixelsPerUnitX: 1, pixelsPerUnitY: 1, width: 12 },
+    ),
+  ).toEqual([
+    {
+      extent: 4,
+      height: 20,
+      id: 'intro',
+      laneId: 'drums',
+      laneIndex: 0,
+      start: 2,
+      width: 4,
+      x: 2,
+      y: 0,
+    },
+  ]);
+});

package/src/features/time-grid/application/resolveTimeGridVisibleIntervals.ts

@@ -0,0 +1,13 @@
+import { getVisibleLaneIntervals, type GridViewport } from '@ankhorage/grid-view';
+
+import type { TimeGridInterval, TimeGridLane } from '../../../types/time-grid';
+
+/*** Resolves the ordered interval placements visible in both world-space axes. */
+export function resolveTimeGridVisibleIntervals(
+  lanes: readonly TimeGridLane[],
+  intervals: readonly TimeGridInterval[],
+  viewport: GridViewport,
+  overscanPixels?: number,
+) {
+  return getVisibleLaneIntervals(lanes, intervals, viewport, overscanPixels);
+}

package/src/features/time-grid/meta.ts

@@ -0,0 +1,12 @@
+import type { ZoraComponentMeta } from '../../types/authoring';
+
+/** TimeGrid remains code-only because interval and lane presentation require executable renderers. */
+export const timeGridMeta = {
+  name: 'TimeGrid',
+  category: 'foundation',
+  description: 'Virtualized variable-height world-space interval lanes for code-defined timelines.',
+  directManifestNode: false,
+  note: 'Requires executable interval and optional lane-label renderers; available through code APIs, not a serializable manifest node.',
+  allowedChildren: [],
+  props: {},
+} as const satisfies ZoraComponentMeta;

package/src/features/time-grid/public.ts

@@ -0,0 +1,4 @@
+export type { TimeGridInterval, TimeGridLane, TimeGridProps } from '../../types/time-grid';
+export { TimeGrid } from './adapters/inbound/TimeGrid';
+export { resolveTimeGridNextFocusId } from './application/resolveTimeGridNextFocusId';
+export { resolveTimeGridVisibleIntervals } from './application/resolveTimeGridVisibleIntervals';

package/src/index.ts

@@ -416,6 +416,12 @@ export {
   SkeletonText,
   type SkeletonTextProps,
 } from './features/skeleton/public';
+export type {
+  SpatialGridItem,
+  SpatialGridItemState,
+  SpatialGridProps,
+} from './features/spatial-grid/public';
+export { SpatialGrid } from './features/spatial-grid/public';
 export type { SurfaceProps, SurfaceVariant } from './features/surface/public';
 export { Surface } from './features/surface/public';
 export type {
@@ -478,6 +484,8 @@ export {
 } from './features/theme/colorModel';
 export * from './features/theme/public';
 export * from './features/theme/runtime';
+export type { TimeGridInterval, TimeGridLane, TimeGridProps } from './features/time-grid/public';
+export { resolveTimeGridVisibleIntervals, TimeGrid } from './features/time-grid/public';
 export {
   TimePicker,
   type TimePickerProps,

package/src/types/spatial-grid.ts

@@ -0,0 +1,44 @@
+import type { GridRectItem, GridViewport } from '@ankhorage/grid-view';
+import type React from 'react';
+
+import type { ZoraBaseProps } from './base';
+
+/** A free-positioned item retains the grid-view world rectangle and adds presentation policy. */
+export interface SpatialGridItem extends GridRectItem {
+  /** Higher values are painted and hit-tested above lower values; equal values preserve input order. */
+  readonly zIndex?: number;
+  /** Accessible name for the item; defaults to a stable ID-derived board-item name. */
+  readonly accessibilityLabel?: string;
+  /** Prevents selection and activation for this item while keeping it visible. */
+  readonly disabled?: boolean;
+}
+
+/** State supplied to the code-only item renderer. */
+export interface SpatialGridItemState {
+  readonly selected: boolean;
+  readonly focused: boolean;
+  readonly disabled: boolean;
+}
+
+/** Props for the virtualized, free-placement presentation over canonical GridView geometry. */
+export interface SpatialGridProps extends ZoraBaseProps {
+  readonly items: readonly SpatialGridItem[];
+  readonly contentWidth: number;
+  readonly contentHeight: number;
+  readonly width: number;
+  readonly height: number;
+  readonly zoom?: number;
+  readonly overscanPixels?: number;
+  readonly selectedItemId?: string;
+  readonly focusedItemId?: string;
+  readonly revealPaddingPixels?: number;
+  readonly disabled?: boolean;
+  /** Prevents selection and activation while retaining focus and viewport navigation. */
+  readonly readOnly?: boolean;
+  readonly onSelectionChange?: (id: string) => void;
+  readonly onActivation?: (id: string) => void;
+  readonly onFocusChange?: (id: string) => void;
+  readonly onViewportChange?: (viewport: GridViewport) => void;
+  readonly onVisibleItemIdsChange?: (ids: readonly string[]) => void;
+  readonly renderItem: (item: SpatialGridItem, state: SpatialGridItemState) => 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-e6ddpz5v.js → Accordion-0my2z6qe.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);
@@ -206,4 +268,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, revealWorldRect, worldToViewport };

package/web-dist/chunks/{Accordion-e9ewv367.js → Accordion-7qfd4cb4.js}

@@ -6,7 +6,7 @@ import {
   getAxisCategoryTicks,
   getAxisTicks,
   worldToViewport
-} from "./Accordion-e6ddpz5v.js";
+} from "./Accordion-0my2z6qe.js";
 import {
   useZoraTheme2
 } from "./Accordion-srjya6dz.js";

package/web-dist/chunks/{Accordion-689w7frk.js → Accordion-d6azgz09.js}

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

package/web-dist/chunks/{Accordion-q2z00p5r.js → Accordion-gxj5qbpr.js}

@@ -3,7 +3,7 @@ import {
   getVisibleGridItems,
   revealWorldRect,
   worldToViewport
-} from "./Accordion-e6ddpz5v.js";
+} from "./Accordion-0my2z6qe.js";
 import {
   require_cjs
 } from "./Accordion-xgpzh4wq.js";

package/web-dist/components/explorer/Explorer.js

@@ -1,5 +1,5 @@
 'use client';
-import"../../chunks/Accordion-q2z00p5r.js";
+import"../../chunks/Accordion-gxj5qbpr.js";
 import"../../chunks/Accordion-bfzeab9x.js";
 import"../../chunks/Accordion-6wrr910w.js";
 import"../../chunks/Accordion-8f0nekwe.js";
@@ -14,7 +14,7 @@ import {
   Explorer2,
   FileExplorer2,
   MediaExplorer2
-} from "../../chunks/Accordion-689w7frk.js";
+} from "../../chunks/Accordion-d6azgz09.js";
 import"../../chunks/Accordion-bff0p3x4.js";
 import"../../chunks/Accordion-srjya6dz.js";
 import"../../chunks/Accordion-184r2r82.js";

package/web-dist/components/file-explorer/FileExplorer.js

@@ -1,5 +1,5 @@
 'use client';
-import"../../chunks/Accordion-q2z00p5r.js";
+import"../../chunks/Accordion-gxj5qbpr.js";
 import"../../chunks/Accordion-bfzeab9x.js";
 import"../../chunks/Accordion-6wrr910w.js";
 import"../../chunks/Accordion-8f0nekwe.js";
@@ -14,7 +14,7 @@ import {
   Explorer2,
   FileExplorer2,
   MediaExplorer2
-} from "../../chunks/Accordion-689w7frk.js";
+} from "../../chunks/Accordion-d6azgz09.js";
 import"../../chunks/Accordion-bff0p3x4.js";
 import"../../chunks/Accordion-srjya6dz.js";
 import"../../chunks/Accordion-184r2r82.js";

package/web-dist/components/grid-line-overlay/GridLineOverlay.js

@@ -4,7 +4,7 @@ import"../../chunks/Accordion-42jfy1a1.js";
 import {
   GridLineOverlay2,
   GridRuler2
-} from "../../chunks/Accordion-e9ewv367.js";
+} from "../../chunks/Accordion-7qfd4cb4.js";
 import"../../chunks/Accordion-srjya6dz.js";
 import"../../chunks/Accordion-xgpzh4wq.js";
 export {