@heroui/agent 0.2.0-beta.1

package/dist/chunk-TOOT6SZ2.js

@@ -0,0 +1,74 @@
+import {
+  mergeClassNames
+} from "./chunk-3FG5NRTX.js";
+
+// ../agent-ui/src/components/display-information/card/card.tsx
+import { createContext, useContext } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var CardVariantContext = createContext(void 0);
+function CardVariantProvider({ children, variant }) {
+  return /* @__PURE__ */ jsx(CardVariantContext, { value: variant, children });
+}
+function Card({
+  actions,
+  children,
+  className,
+  "data-component-kind": componentKind,
+  description,
+  footer,
+  legend,
+  title,
+  variant
+}) {
+  const inheritedVariant = useContext(CardVariantContext);
+  const hasHeader = title != null || description != null || legend != null || actions != null;
+  const resolvedVariant = inheritedVariant ?? variant ?? "surface";
+  return /* @__PURE__ */ jsxs(
+    "section",
+    {
+      className: mergeClassNames("aui-card", className),
+      "data-component-kind": componentKind,
+      "data-has-footer": footer != null,
+      "data-has-header": hasHeader,
+      "data-slot": "agent-ui-card",
+      "data-variant": resolvedVariant,
+      children: [
+        hasHeader ? /* @__PURE__ */ jsxs(
+          "header",
+          {
+            className: "aui-card__header",
+            "data-has-actions": actions != null,
+            "data-slot": "agent-ui-card-header",
+            children: [
+              /* @__PURE__ */ jsxs("span", { className: "aui-card__heading", "data-slot": "agent-ui-card-heading", children: [
+                title != null ? /* @__PURE__ */ jsx("span", { className: "aui-card__title", "data-slot": "agent-ui-card-title", children: title }) : null,
+                description != null ? /* @__PURE__ */ jsx("span", { className: "aui-card__description", "data-slot": "agent-ui-card-description", children: description }) : null
+              ] }),
+              actions != null ? /* @__PURE__ */ jsx("span", { className: "aui-card__actions", "data-slot": "agent-ui-card-actions", children: actions }) : null,
+              legend
+            ]
+          }
+        ) : null,
+        /* @__PURE__ */ jsx("div", { className: "aui-card__content", "data-slot": "agent-ui-card-content", children }),
+        footer != null ? /* @__PURE__ */ jsx("footer", { className: "aui-card__footer", "data-slot": "agent-ui-card-footer", children: footer }) : null
+      ]
+    }
+  );
+}
+
+// ../agent-ui/src/utils/overlay-portal.ts
+function resolveOverlayPortalContainer(node) {
+  if (!node) return void 0;
+  const overlayRoot = node.closest("[data-agent-overlay-root], dialog");
+  if (overlayRoot) {
+    return overlayRoot.querySelector("[data-agent-overlay-portal]") ?? overlayRoot;
+  }
+  const root = node.getRootNode();
+  return typeof ShadowRoot !== "undefined" && root instanceof ShadowRoot ? root : void 0;
+}
+
+export {
+  CardVariantProvider,
+  Card,
+  resolveOverlayPortalContainer
+};

package/dist/chunk-VJA52U5P.js

@@ -0,0 +1,137 @@
+// ../agent-ui/src/components/display-information/map/map-utils.ts
+var MAX_MERCATOR_LATITUDE = 85.051129;
+var TILE_SIZE = 256;
+var TILE_RADIUS_X = 3;
+var TILE_RADIUS_Y = 2;
+function getMapSelectionCenter(locations, selectedLocationId, fallback) {
+  const selectedLocation = locations.find((location) => location.id === selectedLocationId);
+  return selectedLocation ? { latitude: selectedLocation.latitude, longitude: selectedLocation.longitude } : fallback;
+}
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+function project({ latitude, longitude }, zoom) {
+  const scale = TILE_SIZE * 2 ** zoom;
+  const clampedLatitude = clamp(latitude, -MAX_MERCATOR_LATITUDE, MAX_MERCATOR_LATITUDE);
+  const latitudeRadians = clampedLatitude * Math.PI / 180;
+  const sinLatitude = Math.sin(latitudeRadians);
+  return {
+    x: (longitude + 180) / 360 * scale,
+    y: (0.5 - Math.log((1 + sinLatitude) / (1 - sinLatitude)) / (4 * Math.PI)) * scale
+  };
+}
+function wrapWorldDelta(delta, worldSize) {
+  if (delta > worldSize / 2) return delta - worldSize;
+  if (delta < -worldSize / 2) return delta + worldSize;
+  return delta;
+}
+function resolveLongitudeCenter(locations) {
+  if (locations.length === 1) return locations[0].longitude;
+  const longitudes = locations.map((location) => (location.longitude + 360) % 360).sort((first, second) => first - second);
+  let largestGap = -1;
+  let arcStart = longitudes[0];
+  for (let index = 0; index < longitudes.length; index += 1) {
+    const current = longitudes[index];
+    const next = index === longitudes.length - 1 ? longitudes[0] + 360 : longitudes[index + 1];
+    const gap = next - current;
+    if (gap > largestGap) {
+      largestGap = gap;
+      arcStart = next % 360;
+    }
+  }
+  const center = (arcStart + (360 - largestGap) / 2) % 360;
+  return center > 180 ? center - 360 : center;
+}
+function resolveCenter(locations, center) {
+  if (center) return center;
+  let minLatitude = locations[0].latitude;
+  let maxLatitude = locations[0].latitude;
+  for (const location of locations.slice(1)) {
+    minLatitude = Math.min(minLatitude, location.latitude);
+    maxLatitude = Math.max(maxLatitude, location.latitude);
+  }
+  return {
+    latitude: (minLatitude + maxLatitude) / 2,
+    longitude: resolveLongitudeCenter(locations)
+  };
+}
+function resolveZoom(locations, center, zoom, maximumZoom) {
+  if (zoom !== void 0) return clamp(zoom, 1, maximumZoom);
+  if (locations.length === 1) return Math.min(14, maximumZoom);
+  for (let candidate = Math.min(16, maximumZoom); candidate >= 2; candidate -= 1) {
+    const centerPoint = project(center, candidate);
+    const worldSize = TILE_SIZE * 2 ** candidate;
+    const first = project(locations[0], candidate);
+    const firstX = wrapWorldDelta(first.x - centerPoint.x, worldSize);
+    const firstY = first.y - centerPoint.y;
+    let minX = firstX;
+    let maxX = firstX;
+    let minY = firstY;
+    let maxY = firstY;
+    for (const location of locations.slice(1)) {
+      const point = project(location, candidate);
+      const pointX = wrapWorldDelta(point.x - centerPoint.x, worldSize);
+      const pointY = point.y - centerPoint.y;
+      minX = Math.min(minX, pointX);
+      maxX = Math.max(maxX, pointX);
+      minY = Math.min(minY, pointY);
+      maxY = Math.max(maxY, pointY);
+    }
+    if (maxX - minX <= 420 && maxY - minY <= 190) return candidate;
+  }
+  return Math.min(2, maximumZoom);
+}
+function createMapLayout(component, maximumZoom = 18) {
+  maximumZoom = Number.isFinite(maximumZoom) ? clamp(Math.floor(maximumZoom), 1, 18) : 18;
+  const center = resolveCenter(component.locations, component.viewport?.center);
+  const zoom = resolveZoom(component.locations, center, component.viewport?.zoom, maximumZoom);
+  const centerPoint = project(center, zoom);
+  const centerTileX = Math.floor(centerPoint.x / TILE_SIZE);
+  const centerTileY = Math.floor(centerPoint.y / TILE_SIZE);
+  const tileCount = 2 ** zoom;
+  const tiles = [];
+  for (let y = centerTileY - TILE_RADIUS_Y; y <= centerTileY + TILE_RADIUS_Y; y += 1) {
+    if (y < 0 || y >= tileCount) continue;
+    for (let x = centerTileX - TILE_RADIUS_X; x <= centerTileX + TILE_RADIUS_X; x += 1) {
+      const wrappedX = (x % tileCount + tileCount) % tileCount;
+      tiles.push({
+        key: `${zoom}-${x}-${y}`,
+        x: x * TILE_SIZE - centerPoint.x,
+        xIndex: wrappedX,
+        y: y * TILE_SIZE - centerPoint.y,
+        yIndex: y,
+        zoom
+      });
+    }
+  }
+  return {
+    center,
+    points: component.locations.map((location) => {
+      const point = project(location, zoom);
+      const worldSize = TILE_SIZE * 2 ** zoom;
+      return {
+        id: location.id,
+        x: wrapWorldDelta(point.x - centerPoint.x, worldSize),
+        y: point.y - centerPoint.y
+      };
+    }),
+    tiles,
+    zoom
+  };
+}
+function getInitialMapLocationId(component) {
+  if (component.initialLocationId && component.locations.some((location) => location.id === component.initialLocationId)) {
+    return component.initialLocationId;
+  }
+  let best = component.locations[0];
+  for (const location of component.locations.slice(1)) {
+    if ((location.relevance ?? -1) > (best.relevance ?? -1)) best = location;
+  }
+  return best.id;
+}
+
+export {
+  getMapSelectionCenter,
+  createMapLayout,
+  getInitialMapLocationId
+};