@oprt/react 0.0.0-stage → 0.2.0

package/dist/AttachmentPreview/AttachmentPreview.js

@@ -0,0 +1,145 @@
+"use client";
+
+// src/AttachmentPreview/AttachmentPreview.tsx
+import { forwardRef, useRef, useState } from "react";
+import { cva } from "class-variance-authority";
+import clsx from "clsx";
+import { Button } from "../Button/Button.js";
+import { ByteCountLabel } from "../_internal/bytes.js";
+import { joinIds, usePartIds } from "../_internal/fieldIds.js";
+import { useMergedRefs } from "../_internal/mergeRefs.js";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var previewStyles = cva(
+  "flex min-w-0 flex-col gap-2u border border-oprt-border bg-oprt-surface-1 p-2u font-sans text-oprt-base normal-case text-oprt-text"
+);
+var PREVIEW_HEIGHT = "max-h-[var(--oprt-preview-max-height,60vh)]";
+function safeImageSource(src) {
+  if (!src || src.trim() !== src || Array.from(src).some(
+    (character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127
+  ))
+    return false;
+  if (src.startsWith("data:"))
+    return /^data:image\/(?:png|jpeg|gif|webp|avif|bmp);base64,[a-z0-9+/=]+$/i.test(src);
+  try {
+    return ["https:", "http:", "blob:"].includes(
+      new URL(src, "https://operator.invalid/").protocol
+    );
+  } catch {
+    return false;
+  }
+}
+var AttachmentPreview = forwardRef(
+  ({
+    label,
+    attachment,
+    preview,
+    disabled = false,
+    onDownload,
+    onRemove,
+    className,
+    "aria-labelledby": labelledBy,
+    ...props
+  }, ref) => {
+    const root = useRef(null);
+    const mergedRef = useMergedRefs(root, ref);
+    const ids = usePartIds(["label"], {
+      id: props.id,
+      readRendered: () => root.current?.getAttribute("data-oprt-ids")
+    });
+    const imageKey = `${attachment.id}\0${preview.kind === "image" ? preview.src : ""}`;
+    const [imageState, setImageState] = useState({ key: imageKey, failed: false });
+    if (imageState.key !== imageKey) setImageState({ key: imageKey, failed: false });
+    const imageError = preview.kind === "image" ? !safeImageSource(preview.src) ? "Image preview source is not supported." : imageState.key === imageKey && imageState.failed ? "Image preview could not be loaded." : null : null;
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ...props,
+        ref: mergedRef,
+        role: "region",
+        "data-oprt-ids": ids.base,
+        "aria-labelledby": joinIds(ids.label, labelledBy),
+        className: clsx(previewStyles(), className),
+        children: [
+          /* @__PURE__ */ jsx(
+            "h3",
+            {
+              id: ids.label,
+              className: "m-0 oprt-wrap-anywhere font-medium uppercase tracking-oprt-sm",
+              children: label
+            }
+          ),
+          /* @__PURE__ */ jsx("p", { className: "m-0 oprt-wrap-anywhere", children: attachment.name }),
+          /* @__PURE__ */ jsxs("p", { className: "m-0 text-oprt-text-dim", children: [
+            /* @__PURE__ */ jsx(ByteCountLabel, { value: attachment.sizeBytes }),
+            attachment.mediaType && /* @__PURE__ */ jsxs(Fragment, { children: [
+              " ",
+              "\xB7 ",
+              /* @__PURE__ */ jsx("span", { className: "oprt-wrap-anywhere", children: attachment.mediaType })
+            ] })
+          ] }),
+          preview.kind === "image" && (imageError ? /* @__PURE__ */ jsx("p", { role: "status", className: "m-0 text-oprt-error", children: imageError }) : /* @__PURE__ */ jsx(
+            "img",
+            {
+              src: preview.src,
+              alt: preview.alt,
+              onError: () => setImageState(
+                (current) => current.key === imageKey ? { key: imageKey, failed: true } : current
+              ),
+              className: clsx(PREVIEW_HEIGHT, "max-w-full self-start object-contain")
+            },
+            imageKey
+          )),
+          preview.kind === "text" && /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(
+              "pre",
+              {
+                role: "region",
+                className: clsx(
+                  PREVIEW_HEIGHT,
+                  "m-0 overflow-auto whitespace-pre-wrap oprt-wrap-anywhere font-mono outline-hidden focus-visible:shadow-oprt-focus"
+                ),
+                tabIndex: 0,
+                "aria-label": `Text preview of ${attachment.name}`,
+                children: preview.text.slice(0, 16384)
+              }
+            ),
+            preview.text.length > 16384 && /* @__PURE__ */ jsx("p", { className: "m-0 text-oprt-text-dim", children: "Preview truncated to 16,384 characters." })
+          ] }),
+          preview.kind === "unavailable" && /* @__PURE__ */ jsx("p", { className: "m-0 oprt-wrap-anywhere text-oprt-text-dim", children: preview.message }),
+          (onDownload || onRemove) && /* @__PURE__ */ jsxs("div", { className: "flex flex-wrap gap-1u", children: [
+            onDownload && /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "secondary",
+                size: "sm",
+                disabled,
+                "aria-label": `Download ${attachment.name}`,
+                onClick: () => {
+                  if (!disabled) onDownload(attachment.id);
+                },
+                children: "Download"
+              }
+            ),
+            onRemove && /* @__PURE__ */ jsx(
+              Button,
+              {
+                variant: "tertiary",
+                size: "sm",
+                disabled,
+                "aria-label": `Remove ${attachment.name}`,
+                onClick: () => {
+                  if (!disabled) onRemove(attachment.id);
+                },
+                children: "Remove"
+              }
+            )
+          ] })
+        ]
+      }
+    );
+  }
+);
+AttachmentPreview.displayName = "AttachmentPreview";
+export {
+  AttachmentPreview
+};

package/dist/AttachmentPreview/AttachmentPreview.manifest.js

@@ -0,0 +1,42 @@
+// src/AttachmentPreview/AttachmentPreview.manifest.ts
+var AttachmentPreviewManifest = {
+  AttachmentPreview: {
+    description: "Named attachment metadata with an escaped text preview, safe image source or readable fallback.",
+    props: {
+      label: { type: "string", required: true },
+      attachment: {
+        type: "node",
+        required: true,
+        description: "AttachmentMetadata object: stable id, name, sizeBytes, optional mediaType. No file reads or persistence are performed."
+      },
+      preview: {
+        type: "node",
+        required: true,
+        description: "AttachmentPreviewContent: {kind:'image',src,alt}, {kind:'text',text} or {kind:'unavailable',message}. Text is escaped and limited to 16,384 displayed characters. Images permit relative/http/https/blob sources and base64 PNG/JPEG/GIF/WebP/AVIF/BMP data URLs; decoding failures remain readable. No HTML or document iframe rendering."
+      },
+      disabled: {
+        type: "boolean",
+        default: false,
+        description: "Disables download/remove actions while preserving the preview."
+      },
+      onDownload: {
+        type: "function",
+        description: "Requests a download by attachment ID. Invocation does not prove a file was saved."
+      },
+      onRemove: {
+        type: "function",
+        description: "Requests removal by attachment ID. The caller owns replacement and focus if removing the entire preview."
+      },
+      className: {
+        type: "string",
+        description: "Classes for the root. Set --oprt-preview-max-height here to change the image and text preview cap from its 60vh default, for example [--oprt-preview-max-height:24rem]."
+      }
+    },
+    composable_with: ["FileUpload", "UploadQueue", "Dialog"],
+    never_inside: ["Button"],
+    example: '<AttachmentPreview label="Equipment file" attachment={attachment} preview={{kind:"text",text:csvPreview}} onDownload={requestDownload} />'
+  }
+};
+export {
+  AttachmentPreviewManifest
+};

package/dist/AttachmentPreview/index.js

@@ -0,0 +1,9 @@
+// src/AttachmentPreview/index.ts
+import {
+  AttachmentPreview
+} from "./AttachmentPreview.js";
+import { AttachmentPreviewManifest } from "./AttachmentPreview.manifest.js";
+export {
+  AttachmentPreview,
+  AttachmentPreviewManifest
+};

package/dist/Avatar/Avatar.js

@@ -0,0 +1,87 @@
+"use client";
+
+// src/Avatar/Avatar.tsx
+import { cva } from "class-variance-authority";
+import { forwardRef, useCallback, useEffect, useState } from "react";
+import clsx from "clsx";
+import { User } from "@oprt/icons";
+import { AvatarManifest } from "./Avatar.manifest.js";
+import { devValidate } from "../_internal/devValidate.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+var rootStyles = cva(
+  // shrink-0: the root clips its content (overflow-hidden), so as a flex item its automatic minimum
+  // size is zero and a long neighbor in a no-wrap row would squeeze it into a sliver.
+  "inline-flex shrink-0 items-center justify-center overflow-hidden bg-oprt-surface-2 border border-oprt-border align-middle",
+  {
+    variants: {
+      size: {
+        sm: "h-oprt-sm w-oprt-sm",
+        md: "h-oprt-md w-oprt-md",
+        lg: "h-oprt-lg w-oprt-lg"
+      }
+    },
+    defaultVariants: { size: "md" }
+  }
+);
+var glyphSize = { sm: 12, md: 16, lg: 20 };
+var firstCharacter = (word) => Array.from(word)[0] ?? "";
+function getInitials(name) {
+  return name.trim().split(/\s+/).filter(Boolean).slice(0, 2).map((word) => firstCharacter(firstCharacter(word).toUpperCase())).join("");
+}
+var Avatar = forwardRef((allProps, ref) => {
+  const { className, size, name, src, alt, delayMs, ...props } = allProps;
+  const initials = getInitials(name);
+  const [load, setLoad] = useState(null);
+  const status = load !== null && load.src === src ? load.status : "idle";
+  const [fallbackReady, setFallbackReady] = useState(delayMs === void 0);
+  useEffect(() => {
+    if (delayMs === void 0) {
+      setFallbackReady(true);
+      return;
+    }
+    setFallbackReady(false);
+    const t = setTimeout(() => setFallbackReady(true), delayMs);
+    return () => clearTimeout(t);
+  }, [delayMs, src]);
+  const imgRef = useCallback(
+    (node) => {
+      if (node?.complete && node.naturalWidth > 0) setLoad({ src, status: "loaded" });
+    },
+    [src]
+  );
+  if (process.env.NODE_ENV !== "production") {
+    devValidate("Avatar", AvatarManifest.Avatar.props, { ...allProps });
+  }
+  const showImage = src !== void 0 && status === "loaded";
+  const showFallback = !showImage && (fallbackReady || status === "error");
+  const label = alt ?? name;
+  const named = label.trim() !== "";
+  const resolvedSize = size ?? "md";
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      ref,
+      className: clsx(rootStyles({ size: resolvedSize }), className),
+      ...named ? { role: "img", "aria-label": label } : { "aria-hidden": true },
+      ...props,
+      children: [
+        src !== void 0 && status !== "error" && /* @__PURE__ */ jsx(
+          "img",
+          {
+            ref: imgRef,
+            className: clsx("h-full w-full object-cover", !showImage && "hidden"),
+            src,
+            alt: "",
+            onLoad: () => setLoad({ src, status: "loaded" }),
+            onError: () => setLoad({ src, status: "error" })
+          }
+        ),
+        showFallback && (initials !== "" ? /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: "font-mono text-oprt-base text-oprt-text", children: initials }) : /* @__PURE__ */ jsx(User, { "aria-hidden": "true", size: glyphSize[resolvedSize], className: "text-oprt-text-dim" }))
+      ]
+    }
+  );
+});
+Avatar.displayName = "Avatar";
+export {
+  Avatar
+};

package/dist/Avatar/Avatar.manifest.js

@@ -0,0 +1,25 @@
+// src/Avatar/Avatar.manifest.ts
+var AvatarManifest = {
+  Avatar: {
+    description: "Square, initials-based avatar. Renders monospace initials from the name, or an image when src is provided. It is named once, at its root, by alt or by name, and keeps its size in a crowded row.",
+    props: {
+      name: { type: "string", required: true },
+      src: { type: "string" },
+      alt: {
+        type: "string",
+        description: "Accessible name of the avatar. Defaults to name. An empty string hides the avatar from assistive technology, for one beside a visible name."
+      },
+      size: { type: "enum", values: ["sm", "md", "lg"], default: "md" },
+      delayMs: {
+        type: "number",
+        description: "Milliseconds to hold back the initials while an image loads. The initials show at once if the image fails."
+      }
+    },
+    composable_with: ["Card", "Sidebar", "DataTable"],
+    never_inside: ["Badge"],
+    example: '<Avatar name="Ada Lovelace" />'
+  }
+};
+export {
+  AvatarManifest
+};

package/dist/Avatar/index.js

@@ -0,0 +1,7 @@
+// src/Avatar/index.ts
+import { Avatar } from "./Avatar.js";
+import { AvatarManifest } from "./Avatar.manifest.js";
+export {
+  Avatar,
+  AvatarManifest
+};

package/dist/Badge/Badge.js

@@ -0,0 +1,124 @@
+"use client";
+
+// src/Badge/Badge.tsx
+import { cva } from "class-variance-authority";
+import { Children, forwardRef } from "react";
+import clsx from "clsx";
+import { BadgeManifest } from "./Badge.manifest.js";
+import { devValidate } from "../_internal/devValidate.js";
+import { jsx, jsxs } from "react/jsx-runtime";
+var badgeStyles = cva(
+  // items-start: an indicator is aligned with the label's first line, not centered against all of it.
+  "inline-flex w-fit items-start align-middle gap-0.5u font-sans uppercase bg-transparent [&_svg]:shrink-0 [&_code]:normal-case [&_code]:tracking-normal [&_kbd]:normal-case [&_kbd]:tracking-normal",
+  {
+    variants: {
+      variant: {
+        success: "text-oprt-success border-oprt-success/40",
+        warning: "text-oprt-warning border-oprt-warning/40",
+        error: "text-oprt-error border-oprt-error/40",
+        info: "text-oprt-info border-oprt-info/40",
+        neutral: "text-oprt-text-dim border-oprt-border"
+      },
+      appearance: {
+        // A status is never cut off and never spills out of a narrow container: a label that does
+        // not fit wraps (long tokens break anywhere) and the badge grows with it, its lines centered
+        // like a one-line label. A one-line badge keeps its exact height (the compound variants).
+        // It never shrinks: squeezed beside a long sibling in a row that does not wrap, a short
+        // status such as LIVE would break mid-word. `max-w-full` keeps it inside its container.
+        // The centering has no specificity, as Button's has, so a caller's `text-left` wins.
+        outlined: "min-w-0 max-w-full shrink-0 whitespace-normal oprt-wrap-anywhere [:where(&)]:text-center border",
+        text: "min-w-0 max-w-full shrink whitespace-normal oprt-wrap-anywhere border-0 p-0"
+      },
+      size: {
+        sm: "text-oprt-sm font-medium tracking-oprt-sm",
+        md: "text-oprt-base font-medium tracking-oprt-caps"
+      }
+    },
+    compoundVariants: [
+      // Only outlined passive labels have a minimum height and inline padding. The vertical padding
+      // is what is left of the height around one 16px line and the 2px of border (1px at sm and
+      // 3px at md), so a one-line badge is exactly 20px or 24px and a wrapped one still has room.
+      {
+        appearance: "outlined",
+        size: "sm",
+        class: "min-h-oprt-badge-sm px-1u py-[calc((var(--oprt-badge-height-sm)-2px-var(--oprt-line-sm))/2)]"
+      },
+      {
+        appearance: "outlined",
+        size: "md",
+        class: "min-h-oprt-badge-md px-1u py-[calc((var(--oprt-badge-height-md)-2px-var(--oprt-line-base))/2)]"
+      }
+    ],
+    defaultVariants: { variant: "neutral", appearance: "outlined", size: "sm" }
+  }
+);
+var dotStyles = cva("inline-block shrink-0 self-start mt-0.5u w-1u h-1u", {
+  variants: {
+    variant: {
+      success: "bg-oprt-success",
+      warning: "bg-oprt-warning",
+      error: "bg-oprt-error",
+      info: "bg-oprt-info",
+      neutral: "bg-oprt-text-dim"
+    }
+  },
+  defaultVariants: { variant: "neutral" }
+});
+var iconBoxStyles = cva("flex shrink-0 items-center", {
+  variants: {
+    size: {
+      sm: "h-[var(--oprt-line-sm)]",
+      md: "h-[var(--oprt-line-base)]"
+    }
+  },
+  defaultVariants: { size: "sm" }
+});
+var Badge = forwardRef((allProps, ref) => {
+  const {
+    className,
+    variant = "neutral",
+    appearance = "outlined",
+    size,
+    indicator = "none",
+    icon,
+    children,
+    ...props
+  } = allProps;
+  if (process.env.NODE_ENV !== "production") {
+    devValidate("Badge", BadgeManifest.Badge.props, { ...allProps });
+  }
+  const resolved = {
+    variant: variant ?? void 0,
+    appearance: appearance ?? void 0,
+    size: size ?? void 0
+  };
+  const composite = Children.toArray(children).some(
+    (child) => typeof child !== "string" && typeof child !== "number"
+  );
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      ref,
+      "data-oprt-badge": "",
+      "data-appearance": appearance ?? "outlined",
+      className: clsx(badgeStyles(resolved), className),
+      ...props,
+      children: [
+        indicator === "dot" && /* @__PURE__ */ jsx(
+          "span",
+          {
+            "data-oprt-badge-dot": "",
+            "aria-hidden": "true",
+            className: dotStyles({ variant: resolved.variant })
+          }
+        ),
+        indicator === "icon" && /* @__PURE__ */ jsx("span", { "data-oprt-badge-icon": "", className: iconBoxStyles({ size: resolved.size }), children: icon }),
+        composite ? /* @__PURE__ */ jsx("span", { "data-oprt-badge-label": "", className: "min-w-0", children }) : children
+      ]
+    }
+  );
+});
+Badge.displayName = "Badge";
+export {
+  Badge
+};

package/dist/Badge/Badge.manifest.js

@@ -0,0 +1,41 @@
+// src/Badge/Badge.manifest.ts
+var BadgeManifest = {
+  Badge: {
+    description: "Read-only uppercase status display with outlined and text appearances. Use meaningful status wording so color is not the only cue; dots and icons are optional. A status never truncates: a label that does not fit wraps, long tokens break anywhere, and the badge grows with it. An outlined badge keeps its width, so a short status is never squeezed into a broken word beside a long sibling, and is never wider than its container; a text badge can shrink with its layout. Code and kbd retain their casing; wrap other case-sensitive names or IDs in a child with normal-case tracking-normal.",
+    props: {
+      variant: {
+        type: "enum",
+        values: ["success", "warning", "error", "info", "neutral"],
+        default: "neutral"
+      },
+      appearance: {
+        type: "enum",
+        values: ["outlined", "text"],
+        default: "outlined",
+        description: "Outlined adds a border, padding, and a minimum label height for standalone summaries: exactly that height for one line, and it grows when the label wraps, its lines centered. Text removes the box and wraps within available width for dense tables, lists, and metadata."
+      },
+      size: {
+        type: "enum",
+        values: ["sm", "md"],
+        default: "sm",
+        description: "Typography size. One-line outlined labels are 20px (sm) or 24px (md) high with 8px inline padding. Text labels have no minimum height or padding. Explicit indicators use a 4px gap and align with the label's first line. Use Button or Toggle for actions."
+      },
+      indicator: {
+        type: "enum",
+        values: ["dot", "icon", "none"],
+        default: "none",
+        description: "Optional decorative indicator for either appearance and every variant. Defaults to none; meaningful visible status text supplies the non-color cue."
+      },
+      icon: {
+        type: "node",
+        description: "ReactNode rendered when indicator='icon'. Decorative; mark with aria-hidden."
+      }
+    },
+    composable_with: ["DataTable", "Card", "Toolbar", "Sidebar"],
+    never_inside: ["Badge", "Button"],
+    example: '<Badge variant="success" indicator="dot">ONLINE</Badge>'
+  }
+};
+export {
+  BadgeManifest
+};

package/dist/Badge/index.js

@@ -0,0 +1,7 @@
+// src/Badge/index.ts
+import { Badge } from "./Badge.js";
+import { BadgeManifest } from "./Badge.manifest.js";
+export {
+  Badge,
+  BadgeManifest
+};

package/dist/Breadcrumb/Breadcrumb.js

@@ -0,0 +1,64 @@
+"use client";
+
+// src/Breadcrumb/Breadcrumb.tsx
+import { ChevronRight } from "@oprt/icons";
+import { forwardRef } from "react";
+import clsx from "clsx";
+import { jsx, jsxs } from "react/jsx-runtime";
+function currentIndex(items) {
+  const flagged = items.findIndex((item) => item.current === true);
+  if (flagged !== -1) return flagged;
+  const last = items.length - 1;
+  return items[last]?.current === false ? -1 : last;
+}
+var Breadcrumb = forwardRef(
+  ({ items, separator = /* @__PURE__ */ jsx(ChevronRight, { size: 12 }), className, ...props }, ref) => {
+    if (items.length === 0) return null;
+    const current = currentIndex(items);
+    return /* @__PURE__ */ jsx(
+      "nav",
+      {
+        ref,
+        "aria-label": "Breadcrumb",
+        className: clsx("font-sans normal-case", className),
+        ...props,
+        children: /* @__PURE__ */ jsx("ol", { className: "m-0 flex min-w-0 list-none flex-wrap items-center gap-1u p-0", children: items.map((it, i) => {
+          const last = i === items.length - 1;
+          const isCurrent = i === current;
+          return /* @__PURE__ */ jsxs("li", { className: "flex min-w-0 items-center gap-1u", children: [
+            isCurrent || !it.href ? /* @__PURE__ */ jsx(
+              "span",
+              {
+                "aria-current": isCurrent ? "page" : void 0,
+                className: clsx(
+                  "min-w-0 text-oprt-base oprt-wrap-anywhere",
+                  isCurrent ? "text-oprt-text" : "text-oprt-text-dim"
+                ),
+                children: it.label
+              }
+            ) : /* @__PURE__ */ jsx(
+              "a",
+              {
+                href: it.href,
+                className: "inline-flex min-h-3u min-w-3u items-center border border-transparent text-oprt-base font-medium text-oprt-text-dim no-underline oprt-wrap-anywhere hover:text-oprt-text focus-visible:border-oprt-border-focus focus-visible:shadow-oprt-focus focus-visible:outline-hidden",
+                children: it.label
+              }
+            ),
+            !last && /* @__PURE__ */ jsx(
+              "span",
+              {
+                "aria-hidden": "true",
+                className: "flex shrink-0 items-center text-oprt-text-muted",
+                children: separator
+              }
+            )
+          ] }, `${it.label}-${i}`);
+        }) })
+      }
+    );
+  }
+);
+Breadcrumb.displayName = "Breadcrumb";
+export {
+  Breadcrumb
+};

package/dist/Breadcrumb/Breadcrumb.manifest.js

@@ -0,0 +1,28 @@
+// src/Breadcrumb/Breadcrumb.manifest.ts
+var BreadcrumbManifest = {
+  Breadcrumb: {
+    description: "Self-contained navigation trail rendered from a flat array of items, with the final (or flagged) item marked as the current page.",
+    props: {
+      items: {
+        type: "array",
+        required: true,
+        items: {
+          label: "string",
+          href: "string (optional \u2014 omit to render plain text)",
+          current: "boolean (optional \u2014 defaults to true on the last item)"
+        },
+        description: "Ordered trail. Each entry: { label: string; href?: string; current?: boolean }. Exactly one item is current: the first that sets current:true, otherwise the last unless it sets current:false. Items after the current one keep their links. A trail that does not fit wraps onto more lines; an empty trail renders nothing."
+      },
+      separator: {
+        type: "node",
+        description: "ReactNode rendered between items (default: a small chevron-right SVG). Decorative; rendered aria-hidden. Pass a string like '/' for a slash separator."
+      }
+    },
+    composable_with: ["Card"],
+    never_inside: ["Breadcrumb"],
+    example: '<Breadcrumb items={[{label:"HOME",href:"/"},{label:"OPS",href:"/ops"},{label:"TRACK 7"}]} />'
+  }
+};
+export {
+  BreadcrumbManifest
+};

package/dist/Breadcrumb/index.js

@@ -0,0 +1,7 @@
+// src/Breadcrumb/index.ts
+import { Breadcrumb } from "./Breadcrumb.js";
+import { BreadcrumbManifest } from "./Breadcrumb.manifest.js";
+export {
+  Breadcrumb,
+  BreadcrumbManifest
+};