@ankhorage/zora 25.5.0 → 25.6.0

package/web-dist/chunks/Accordion-q8exgc3h.js

@@ -0,0 +1,515 @@
+'use client';
+import {
+  getVisibleGridItems,
+  constrainViewport,
+  panViewport,
+  revealWorldRect,
+  worldToViewport,
+  zoomViewportAt
+} from "./Accordion-ebghcyzj.js";
+import {
+  require_cjs
+} from "./Accordion-xgpzh4wq.js";
+import {
+  __toESM
+} from "./Accordion-nh0cs9hq.js";
+
+// src/features/grid-view/adapters/inbound/GridView.tsx
+var import_react_native = __toESM(require_cjs(), 1);
+import React from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function GridView2({
+  items,
+  contentWidth,
+  contentHeight,
+  width,
+  height,
+  viewport: controlledViewport,
+  defaultViewport,
+  viewportConstraints,
+  zoomLimits,
+  zoom = 1,
+  overscanPixels = 160,
+  focusedItemId,
+  revealPaddingPixels = 8,
+  interactionPolicy,
+  onViewportChange,
+  onVisibleItemIdsChange,
+  renderItem,
+  testID
+}) {
+  const [uncontrolledViewport, setUncontrolledViewport] = React.useState(() => createInitialViewport(width, height, zoom, defaultViewport));
+  const horizontalScrollRef = React.useRef(null);
+  const verticalScrollRef = React.useRef(null);
+  const gridRef = React.useRef(null);
+  const scrollPositionRef = React.useRef({ x: 0, y: 0 });
+  const pinchGestureRef = React.useRef(undefined);
+  const pinchMeasurementRef = React.useRef(0);
+  const pinchSessionRef = React.useRef(0);
+  const viewportOriginRef = React.useRef({ x: 0, y: 0 });
+  const focusRevealProposalRef = React.useRef(undefined);
+  const focusRevealViewportRef = React.useRef(undefined);
+  const [isPinching, setIsPinching] = React.useState(false);
+  const constraints = React.useMemo(() => viewportConstraints ?? createContentConstraints(contentWidth, contentHeight), [contentHeight, contentWidth, viewportConstraints]);
+  const sourceViewport = controlledViewport ?? uncontrolledViewport;
+  const viewport = React.useMemo(() => constrainViewport({ ...sourceViewport, height, width }, constraints), [constraints, height, sourceViewport, width]);
+  const viewportRef = React.useRef(viewport);
+  const visibleItems = React.useMemo(() => getVisibleGridItems(items, viewport, overscanPixels), [items, overscanPixels, viewport]);
+  const viewportVisibleIds = React.useMemo(() => getVisibleGridItems(visibleItems, viewport).map((item) => item.id), [viewport, visibleItems]);
+  const focusedItem = items.find((item) => item.id === focusedItemId);
+  const focusedItemHeight = focusedItem?.height;
+  const focusedItemIdForReveal = focusedItem?.id;
+  const focusedItemWidth = focusedItem?.width;
+  const focusedItemX = focusedItem?.x;
+  const focusedItemY = focusedItem?.y;
+  const previousVisibleIdsRef = React.useRef([]);
+  const uncontrolled = controlledViewport === undefined;
+  const interactive = interactionPolicy !== "passive";
+  const publish = React.useCallback((nextViewport) => {
+    if (areViewportsEqual(viewportRef.current, nextViewport))
+      return;
+    viewportRef.current = nextViewport;
+    if (uncontrolled)
+      setUncontrolledViewport(nextViewport);
+    onViewportChange?.(nextViewport);
+  }, [onViewportChange, uncontrolled]);
+  const publishRef = React.useRef(publish);
+  const pan = (displacement) => publish(panViewport(viewportRef.current, displacement, constraints));
+  const zoomAt = (focalPoint, factor) => publish(zoomViewportAt(viewportRef.current, focalPoint, {
+    pixelsPerUnitX: viewportRef.current.pixelsPerUnitX * factor,
+    pixelsPerUnitY: viewportRef.current.pixelsPerUnitY * factor
+  }, zoomLimits, constraints));
+  React.useEffect(() => {
+    viewportRef.current = viewport;
+  }, [viewport]);
+  React.useEffect(() => {
+    publishRef.current = publish;
+  }, [publish]);
+  const refreshViewportOrigin = React.useCallback(() => {
+    gridRef.current?.measureInWindow((x, y) => {
+      viewportOriginRef.current = { x, y };
+    });
+  }, []);
+  const measurePinchGesture = React.useCallback((touches, session, onMeasured) => {
+    const measurement = pinchMeasurementRef.current + 1;
+    pinchMeasurementRef.current = measurement;
+    gridRef.current?.measureInWindow((x, y) => {
+      if (measurement !== pinchMeasurementRef.current || session !== pinchSessionRef.current) {
+        return;
+      }
+      viewportOriginRef.current = { x, y };
+      onMeasured(getPinchGesture(touches, width, height, { x, y }));
+    });
+  }, [height, width]);
+  React.useLayoutEffect(() => {
+    refreshViewportOrigin();
+  }, [height, refreshViewportOrigin, width]);
+  React.useEffect(() => () => {
+    pinchMeasurementRef.current += 1;
+    pinchSessionRef.current += 1;
+  }, []);
+  React.useEffect(() => {
+    if (!onVisibleItemIdsChange)
+      return;
+    const previous = previousVisibleIdsRef.current;
+    if (previous.length === viewportVisibleIds.length && previous.every((id, index) => id === viewportVisibleIds.at(index))) {
+      return;
+    }
+    previousVisibleIdsRef.current = viewportVisibleIds;
+    onVisibleItemIdsChange(viewportVisibleIds);
+  }, [onVisibleItemIdsChange, viewportVisibleIds]);
+  React.useEffect(() => {
+    const position = createScrollMapping(viewport, constraints);
+    const nextPosition = {
+      x: position.horizontal.position,
+      y: position.vertical.position
+    };
+    if (areScrollPositionsEqual(scrollPositionRef.current, nextPosition))
+      return;
+    scrollPositionRef.current = nextPosition;
+    const animated = focusRevealViewportRef.current !== undefined && areViewportsEqual(viewport, focusRevealViewportRef.current);
+    horizontalScrollRef.current?.scrollTo({ animated, x: nextPosition.x });
+    verticalScrollRef.current?.scrollTo({ animated, y: nextPosition.y });
+    if (animated)
+      focusRevealViewportRef.current = undefined;
+  }, [constraints, viewport]);
+  React.useEffect(() => {
+    if (focusedItemHeight === undefined || focusedItemIdForReveal === undefined || focusedItemWidth === undefined || focusedItemX === undefined || focusedItemY === undefined) {
+      focusRevealProposalRef.current = undefined;
+      return;
+    }
+    const sourceViewport = viewportRef.current;
+    const revealed = revealWorldRect(sourceViewport, {
+      height: focusedItemHeight,
+      width: focusedItemWidth,
+      x: focusedItemX,
+      y: focusedItemY
+    }, revealPaddingPixels, constraints);
+    if (isRepeatedControlledFocusRevealProposal({
+      controlled: !uncontrolled,
+      focusedItemId: focusedItemIdForReveal,
+      previous: focusRevealProposalRef.current,
+      sourceViewport,
+      viewport: revealed
+    })) {
+      return;
+    }
+    focusRevealProposalRef.current = {
+      focusedItemId: focusedItemIdForReveal,
+      sourceViewport,
+      viewport: revealed
+    };
+    focusRevealViewportRef.current = areViewportsEqual(sourceViewport, revealed) ? undefined : revealed;
+    publishRef.current(revealed);
+  }, [
+    constraints,
+    focusedItemHeight,
+    focusedItemIdForReveal,
+    focusedItemWidth,
+    focusedItemX,
+    focusedItemY,
+    revealPaddingPixels,
+    uncontrolled
+  ]);
+  const scrollMapping = createScrollMapping(viewport, constraints);
+  const syncScrollPosition = () => {
+    const nextMapping = createScrollMapping(viewportRef.current, constraints);
+    const nextPosition = {
+      x: nextMapping.horizontal.position,
+      y: nextMapping.vertical.position
+    };
+    scrollPositionRef.current = nextPosition;
+    horizontalScrollRef.current?.scrollTo({ animated: false, x: nextPosition.x });
+    verticalScrollRef.current?.scrollTo({ animated: false, y: nextPosition.y });
+  };
+  return /* @__PURE__ */ jsxs(import_react_native.View, {
+    ref: gridRef,
+    accessibilityLabel: "Interactive grid viewport",
+    onLayout: refreshViewportOrigin,
+    onTouchEnd: () => {
+      const wasPinching = pinchGestureRef.current !== undefined;
+      pinchMeasurementRef.current += 1;
+      pinchSessionRef.current += 1;
+      pinchGestureRef.current = undefined;
+      setIsPinching(false);
+      if (wasPinching)
+        syncScrollPosition();
+    },
+    onTouchCancel: () => {
+      const wasPinching = pinchGestureRef.current !== undefined;
+      pinchMeasurementRef.current += 1;
+      pinchSessionRef.current += 1;
+      pinchGestureRef.current = undefined;
+      setIsPinching(false);
+      if (wasPinching)
+        syncScrollPosition();
+    },
+    onTouchMove: (event) => {
+      if (!interactive)
+        return;
+      measurePinchGesture([...event.nativeEvent.touches], pinchSessionRef.current, (pinch) => {
+        const previous = pinchGestureRef.current;
+        pinchGestureRef.current = pinch;
+        setIsPinching(pinch !== undefined);
+        if (!pinch || !previous)
+          return;
+        zoomAt(pinch.focalPoint, pinch.distance / previous.distance);
+      });
+    },
+    onTouchStart: (event) => {
+      const session = pinchSessionRef.current + 1;
+      pinchSessionRef.current = session;
+      measurePinchGesture([...event.nativeEvent.touches], session, (pinch) => {
+        pinchGestureRef.current = pinch;
+        setIsPinching(pinch !== undefined);
+      });
+    },
+    style: { height, overflow: "hidden", width },
+    testID,
+    children: [
+      /* @__PURE__ */ jsx(import_react_native.ScrollView, {
+        ref: horizontalScrollRef,
+        testID: testID ? `${testID}-horizontal-scroll` : undefined,
+        horizontal: true,
+        scrollEnabled: interactive && !isPinching,
+        scrollEventThrottle: 16,
+        showsHorizontalScrollIndicator: true,
+        style: { height, width },
+        onScroll: (event) => {
+          if (pinchGestureRef.current)
+            return;
+          const { x } = event.nativeEvent.contentOffset;
+          const displacement = x - scrollPositionRef.current.x;
+          scrollPositionRef.current = { ...scrollPositionRef.current, x };
+          if (displacement !== 0)
+            pan({ x: -displacement, y: 0 });
+        },
+        children: /* @__PURE__ */ jsx(import_react_native.ScrollView, {
+          ref: verticalScrollRef,
+          testID: testID ? `${testID}-vertical-scroll` : undefined,
+          scrollEnabled: interactive && !isPinching,
+          scrollEventThrottle: 16,
+          showsVerticalScrollIndicator: true,
+          style: { height, width: scrollMapping.horizontal.contentSize },
+          onScroll: (event) => {
+            if (pinchGestureRef.current)
+              return;
+            const { y } = event.nativeEvent.contentOffset;
+            const displacement = y - scrollPositionRef.current.y;
+            scrollPositionRef.current = { ...scrollPositionRef.current, y };
+            if (displacement !== 0)
+              pan({ x: 0, y: -displacement });
+          },
+          children: /* @__PURE__ */ jsx(import_react_native.View, {
+            style: {
+              height: scrollMapping.vertical.contentSize,
+              width: scrollMapping.horizontal.contentSize
+            },
+            children: visibleItems.map((item) => {
+              const position = worldToViewport({ x: item.x, y: item.y }, { ...viewport, offsetX: 0, offsetY: 0 });
+              return /* @__PURE__ */ jsx(import_react_native.View, {
+                style: {
+                  height: item.height * viewport.pixelsPerUnitY,
+                  left: position.x + scrollMapping.horizontal.origin,
+                  position: "absolute",
+                  top: position.y + scrollMapping.vertical.origin,
+                  width: item.width * viewport.pixelsPerUnitX
+                },
+                children: renderItem(item)
+              }, item.id);
+            })
+          })
+        })
+      }),
+      interactive ? /* @__PURE__ */ jsxs(import_react_native.View, {
+        accessibilityLabel: "Viewport controls",
+        style: controlsStyle,
+        children: [
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Pan left",
+            accessibilityRole: "button",
+            onPress: () => pan({ x: 48, y: 0 }),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "←"
+            })
+          }),
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Pan right",
+            accessibilityRole: "button",
+            onPress: () => pan({ x: -48, y: 0 }),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "→"
+            })
+          }),
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Pan up",
+            accessibilityRole: "button",
+            onPress: () => pan({ x: 0, y: 48 }),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "↑"
+            })
+          }),
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Pan down",
+            accessibilityRole: "button",
+            onPress: () => pan({ x: 0, y: -48 }),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "↓"
+            })
+          }),
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Zoom in",
+            accessibilityRole: "button",
+            onPress: () => zoomAt({ x: width / 2, y: height / 2 }, 1.2),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "+"
+            })
+          }),
+          /* @__PURE__ */ jsx(import_react_native.Pressable, {
+            accessibilityLabel: "Zoom out",
+            accessibilityRole: "button",
+            onPress: () => zoomAt({ x: width / 2, y: height / 2 }, 1 / 1.2),
+            children: /* @__PURE__ */ jsx(import_react_native.Text, {
+              children: "−"
+            })
+          })
+        ]
+      }) : null
+    ]
+  });
+}
+var controlsStyle = { bottom: 8, gap: 4, position: "absolute", right: 8 };
+function createInitialViewport(width, height, zoom, viewport) {
+  return {
+    height,
+    offsetX: viewport?.offsetX ?? 0,
+    offsetY: viewport?.offsetY ?? 0,
+    pixelsPerUnitX: viewport?.pixelsPerUnitX ?? zoom,
+    pixelsPerUnitY: viewport?.pixelsPerUnitY ?? zoom,
+    width
+  };
+}
+function createContentConstraints(contentWidth, contentHeight) {
+  return { world: { height: contentHeight, width: contentWidth, x: 0, y: 0 } };
+}
+function createScrollMapping(viewport, constraints) {
+  const horizontalMinimum = constrainViewport({ ...viewport, offsetX: -Number.MAX_SAFE_INTEGER }, constraints).offsetX;
+  const horizontalMaximum = constrainViewport({ ...viewport, offsetX: Number.MAX_SAFE_INTEGER }, constraints).offsetX;
+  const verticalMinimum = constrainViewport({ ...viewport, offsetY: -Number.MAX_SAFE_INTEGER }, constraints).offsetY;
+  const verticalMaximum = constrainViewport({ ...viewport, offsetY: Number.MAX_SAFE_INTEGER }, constraints).offsetY;
+  return {
+    horizontal: createScrollAxisMapping({
+      maximum: horizontalMaximum,
+      minimum: horizontalMinimum,
+      offset: viewport.offsetX,
+      scale: viewport.pixelsPerUnitX,
+      viewportSize: viewport.width
+    }),
+    vertical: createScrollAxisMapping({
+      maximum: verticalMaximum,
+      minimum: verticalMinimum,
+      offset: viewport.offsetY,
+      scale: viewport.pixelsPerUnitY,
+      viewportSize: viewport.height
+    })
+  };
+}
+function createScrollAxisMapping({
+  maximum,
+  minimum,
+  offset,
+  scale,
+  viewportSize
+}) {
+  const range = (maximum - minimum) * scale;
+  return {
+    contentSize: viewportSize + range,
+    origin: -minimum * scale,
+    position: (offset - minimum) * scale
+  };
+}
+function areViewportsEqual(left, right) {
+  return left.width === right.width && left.height === right.height && left.offsetX === right.offsetX && left.offsetY === right.offsetY && left.pixelsPerUnitX === right.pixelsPerUnitX && left.pixelsPerUnitY === right.pixelsPerUnitY;
+}
+function areScrollPositionsEqual(left, right) {
+  return left.x === right.x && left.y === right.y;
+}
+function isRepeatedControlledFocusRevealProposal({
+  controlled,
+  focusedItemId,
+  previous,
+  sourceViewport,
+  viewport
+}) {
+  return controlled && focusedItemId !== undefined && previous?.focusedItemId === focusedItemId && areViewportsEqual(previous.sourceViewport, sourceViewport) && areViewportsEqual(previous.viewport, viewport);
+}
+function getPinchGesture(touches, width, height, viewportOrigin) {
+  const [first, second] = touches;
+  if (!first || !second)
+    return;
+  const deltaX = second.pageX - first.pageX;
+  const deltaY = second.pageY - first.pageY;
+  const distance = Math.hypot(deltaX, deltaY);
+  if (!Number.isFinite(distance) || distance === 0)
+    return;
+  return {
+    distance,
+    focalPoint: {
+      x: Math.min(width, Math.max(0, (first.pageX + second.pageX) / 2 - viewportOrigin.x)),
+      y: Math.min(height, Math.max(0, (first.pageY + second.pageY) / 2 - viewportOrigin.y))
+    }
+  };
+}
+
+// src/features/grid-view/adapters/inbound/TileGrid.tsx
+var import_react_native2 = __toESM(require_cjs(), 1);
+import React2 from "react";
+
+// src/features/grid-view/application/layoutTileGrid.ts
+function layoutTileGrid(items, viewportWidth, tileSize, gap, zoom = 1) {
+  if (![viewportWidth, tileSize, gap, zoom].every(Number.isFinite) || viewportWidth < 0 || tileSize <= 0 || gap < 0 || zoom <= 0) {
+    throw new RangeError("Tile layout requires finite, nonnegative dimensions and positive scales.");
+  }
+  const columns = Math.max(1, Math.floor((viewportWidth / zoom + gap) / (tileSize + gap)));
+  const rows = Math.ceil(items.length / columns);
+  return {
+    columns,
+    width: columns * (tileSize + gap) - gap,
+    height: Math.max(0, rows * (tileSize + gap) - gap),
+    items: items.map((item, index) => ({
+      id: item.id,
+      x: index % columns * (tileSize + gap),
+      y: Math.floor(index / columns) * (tileSize + gap),
+      width: tileSize,
+      height: tileSize
+    }))
+  };
+}
+
+// src/features/grid-view/adapters/inbound/TileGrid.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function TileGrid2({
+  items,
+  width,
+  height = 440,
+  tileSize = 120,
+  gap = 12,
+  zoom = 1,
+  viewport,
+  defaultViewport,
+  viewportConstraints,
+  zoomLimits,
+  overscanPixels,
+  focusedItemId,
+  revealPaddingPixels,
+  onColumnsChange,
+  onViewportChange,
+  onVisibleItemIdsChange,
+  renderItem,
+  interactionPolicy,
+  testID
+}) {
+  const [measuredWidth, setMeasuredWidth] = React2.useState(0);
+  const [uncontrolledPixelsPerUnitX, setUncontrolledPixelsPerUnitX] = React2.useState(() => defaultViewport?.pixelsPerUnitX ?? zoom);
+  const resolvedWidth = width ?? measuredWidth;
+  const pixelsPerUnitX = viewport?.pixelsPerUnitX ?? uncontrolledPixelsPerUnitX;
+  const layout = React2.useMemo(() => layoutTileGrid(items, resolvedWidth, tileSize, gap, pixelsPerUnitX), [gap, items, pixelsPerUnitX, resolvedWidth, tileSize]);
+  const itemLookup = React2.useMemo(() => new Map(items.map((item) => [item.id, item])), [items]);
+  React2.useEffect(() => {
+    if (resolvedWidth > 0)
+      onColumnsChange?.(layout.columns);
+  }, [layout.columns, onColumnsChange, resolvedWidth]);
+  const handleViewportChange = React2.useCallback((nextViewport) => {
+    if (viewport === undefined)
+      setUncontrolledPixelsPerUnitX(nextViewport.pixelsPerUnitX);
+    onViewportChange?.(nextViewport);
+  }, [onViewportChange, viewport]);
+  return /* @__PURE__ */ jsx2(import_react_native2.View, {
+    onLayout: (event) => setMeasuredWidth(event.nativeEvent.layout.width),
+    style: { width, height, overflow: "hidden" },
+    testID,
+    children: resolvedWidth > 0 ? /* @__PURE__ */ jsx2(GridView2, {
+      contentHeight: layout.height,
+      contentWidth: Math.max(resolvedWidth / pixelsPerUnitX, layout.width),
+      defaultViewport,
+      height,
+      focusedItemId,
+      interactionPolicy,
+      items: layout.items,
+      onVisibleItemIdsChange,
+      onViewportChange: handleViewportChange,
+      overscanPixels,
+      renderItem: (item) => {
+        const source = itemLookup.get(item.id);
+        return source ? renderItem(source) : null;
+      },
+      revealPaddingPixels,
+      width: resolvedWidth,
+      viewport,
+      viewportConstraints,
+      zoomLimits,
+      zoom
+    }) : null
+  });
+}
+export { GridView2, TileGrid2 };

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

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

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

@@ -1,5 +1,5 @@
 'use client';
-import"../../chunks/Accordion-gxj5qbpr.js";
+import"../../chunks/Accordion-q8exgc3h.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-d6azgz09.js";
+} from "../../chunks/Accordion-f43jba23.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-gxj5qbpr.js";
+import"../../chunks/Accordion-q8exgc3h.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-d6azgz09.js";
+} from "../../chunks/Accordion-f43jba23.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-7qfd4cb4.js";
+} from "../../chunks/Accordion-szar8dt5.js";
 import"../../chunks/Accordion-srjya6dz.js";
 import"../../chunks/Accordion-xgpzh4wq.js";
 export {

package/web-dist/components/grid-ruler/GridRuler.js

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

package/web-dist/components/grid-view/GridView.js

@@ -2,7 +2,7 @@
 import {
   GridView2,
   TileGrid2
-} from "../../chunks/Accordion-gxj5qbpr.js";
+} from "../../chunks/Accordion-q8exgc3h.js";
 import"../../chunks/Accordion-xgpzh4wq.js";
 export {
   GridView2 as GridView,

package/web-dist/components/media-explorer/MediaExplorer.js

@@ -1,5 +1,5 @@
 'use client';
-import"../../chunks/Accordion-gxj5qbpr.js";
+import"../../chunks/Accordion-q8exgc3h.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-d6azgz09.js";
+} from "../../chunks/Accordion-f43jba23.js";
 import"../../chunks/Accordion-bff0p3x4.js";
 import"../../chunks/Accordion-srjya6dz.js";
 import"../../chunks/Accordion-184r2r82.js";

package/web-dist/components/spatial-grid/SpatialGrid.js

@@ -1,7 +1,7 @@
 'use client';
 import {
   GridView2
-} from "../../chunks/Accordion-gxj5qbpr.js";
+} from "../../chunks/Accordion-q8exgc3h.js";
 import {
   require_cjs
 } from "../../chunks/Accordion-xgpzh4wq.js";

package/web-dist/components/tile-grid/TileGrid.js

@@ -2,7 +2,7 @@
 import {
   GridView2,
   TileGrid2
-} from "../../chunks/Accordion-gxj5qbpr.js";
+} from "../../chunks/Accordion-q8exgc3h.js";
 import"../../chunks/Accordion-xgpzh4wq.js";
 export {
   GridView2 as GridView,

package/web-dist/components/time-grid/TimeGrid.js

@@ -1,11 +1,11 @@
 'use client';
 import {
   GridView2
-} from "../../chunks/Accordion-gxj5qbpr.js";
+} from "../../chunks/Accordion-q8exgc3h.js";
 import {
   getLaneIntervalPlacement,
   getVisibleLaneIntervals
-} from "../../chunks/Accordion-0my2z6qe.js";
+} from "../../chunks/Accordion-ebghcyzj.js";
 import {
   require_cjs
 } from "../../chunks/Accordion-xgpzh4wq.js";

package/web-dist/components/uploader/Uploader.js

@@ -25,7 +25,7 @@ import {
 import {
   Text3
 } from "../../chunks/Accordion-9w8wg9mf.js";
-import"../../chunks/Accordion-gxj5qbpr.js";
+import"../../chunks/Accordion-q8exgc3h.js";
 import {
   Icon2
 } from "../../chunks/Accordion-b96evb46.js";
@@ -34,7 +34,7 @@ import {
 } from "../../chunks/Accordion-a4cma5b6.js";
 import {
   Explorer2
-} from "../../chunks/Accordion-d6azgz09.js";
+} from "../../chunks/Accordion-f43jba23.js";
 import"../../chunks/Accordion-40tenzcg.js";
 import"../../chunks/Accordion-45nc4bte.js";
 import {