@epilot/zenith-react 0.2.0-next.1 → 0.2.0-next.4

package/codemods/radix-to-base-ui.ts

@@ -0,0 +1,389 @@
+/**
+ * Zenith: Radix → Base UI consumer codemod, one transform for every family whose Base UI port
+ * changed the public API (DECISIONS.md D12: only overlay dismissal interceptors left the surface).
+ *
+ *   bunx jscodeshift@17.3.0 --parser=tsx -t node_modules/@epilot/zenith-react/codemods/radix-to-base-ui.ts <paths>
+ *
+ * Rules:
+ * 1. The dismissal interceptors Radix took on an overlay's content part (`OVERLAYS` below lists
+ *    which, per part) move into the enclosing root's `onOpenChange`, keyed on Base UI's
+ *    `eventDetails.reason`. A handler that calls `preventDefault()` keeps the overlay open via
+ *    `eventDetails.cancel()`, as it did under Radix. Radix's AlertDialogContent never let an outside
+ *    press through, and its Select and Tooltip content never took the focus and interact handlers,
+ *    so those parts list fewer props. FieldComboboxContent takes PopoverContent's props, so the
+ *    same rule moves them to the enclosing FieldCombobox.
+ * 2. A DropdownMenu item's `onSelect` that calls `preventDefault()` to keep the menu open is
+ *    reported: the menu closes regardless under Base UI, and the place to cancel it is the root's
+ *    `onOpenChange` (`eventDetails.reason === "item-press"`), which needs to know which item was
+ *    chosen.
+ * 3. Anything it cannot rewrite safely gets a `TODO(zenith-base-ui)` comment and is reported.
+ *
+ * Every other prop (`forceMount`, `loop`, `onCloseAutoFocus`, `sticky`, `position` and the other
+ * placement props, `value=""` for no selection) stays as it is: the wrappers still take them and
+ * translate them for Base UI.
+ */
+import type {
+  API,
+  ArrowFunctionExpression,
+  ASTPath,
+  BinaryExpression,
+  Collection,
+  ExpressionStatement,
+  FileInfo,
+  FunctionExpression,
+  IfStatement,
+  JSXAttribute,
+  JSXElement,
+  JSXFragment,
+  LogicalExpression,
+  Options,
+  VariableDeclaration,
+} from "jscodeshift"
+
+const ZENITH = "@epilot/zenith-react"
+
+const DISMISS_REASONS: Record<string, string[]> = {
+  onEscapeKeyDown: ["escape-key"],
+  onPointerDownOutside: ["outside-press"],
+  onInteractOutside: ["outside-press", "focus-out"],
+  onFocusOutside: ["focus-out"],
+}
+
+const ALL_DISMISSALS = Object.keys(DISMISS_REASONS)
+
+/** Each content part, the root whose `onOpenChange` takes over its handlers, and which it took. */
+const OVERLAYS = [
+  { content: "DialogContent", root: "Dialog", props: ALL_DISMISSALS },
+  {
+    content: "AlertDialogContent",
+    root: "AlertDialog",
+    props: ["onEscapeKeyDown", "onFocusOutside"],
+  },
+  { content: "DrawerContent", root: "Drawer", props: ALL_DISMISSALS },
+  { content: "PopoverContent", root: "Popover", props: ALL_DISMISSALS },
+  {
+    content: "FieldComboboxContent",
+    root: "FieldCombobox",
+    props: ALL_DISMISSALS,
+  },
+  {
+    content: "DropdownMenuContent",
+    root: "DropdownMenu",
+    props: ALL_DISMISSALS,
+  },
+  {
+    content: "DropdownMenuSubContent",
+    root: "DropdownMenuSub",
+    props: ALL_DISMISSALS,
+  },
+  {
+    content: "SelectContent",
+    root: "Select",
+    props: ["onEscapeKeyDown", "onPointerDownOutside"],
+  },
+  {
+    content: "TooltipContent",
+    root: "Tooltip",
+    props: ["onEscapeKeyDown", "onPointerDownOutside"],
+  },
+]
+
+const MENU_ITEMS = [
+  "DropdownMenuItem",
+  "DropdownMenuCheckboxItem",
+  "DropdownMenuRadioItem",
+]
+
+const TODO = "TODO(zenith-base-ui)"
+
+export const parser = "tsx"
+
+export default function transform(file: FileInfo, api: API, options: Options) {
+  const j = api.jscodeshift
+  const root = j(file.source)
+  const local = zenithLocalNames(j, root)
+  const overlays = OVERLAYS.filter(({ content }) => local[content]).map(
+    (overlay) => ({
+      ...overlay,
+      localContent: local[overlay.content],
+      localRoot: local[overlay.root],
+    })
+  )
+  const items = new Set(MENU_ITEMS.map((name) => local[name]).filter(Boolean))
+  if (overlays.length === 0 && items.size === 0) return undefined
+
+  let changed = false
+  const todos: string[] = []
+
+  const elementName = (el: JSXElement) => {
+    const name = el.openingElement.name
+    return name.type === "JSXIdentifier" ? name.name : undefined
+  }
+  const attrsOf = (el: JSXElement) =>
+    el.openingElement.attributes!.filter(
+      (a): a is JSXAttribute => a.type === "JSXAttribute"
+    )
+  const attr = (el: JSXElement, name: string) =>
+    attrsOf(el).find((a) => a.name.name === name)
+  const removeAttr = (el: JSXElement, node: JSXAttribute) => {
+    el.openingElement.attributes = el.openingElement.attributes!.filter(
+      (a) => a !== node
+    )
+  }
+  const addTodo = (path: ASTPath<JSXElement>, message: string) => {
+    const line = path.node.loc?.start.line
+    todos.push(`${file.path}:${line ?? "?"} ${message}`)
+    const text = `${TODO}: ${message}`
+    // A rerun over already-migrated output reports the place again but does not stack a
+    // second copy of the same comment.
+    const parent = path.parent?.node as JSXElement | JSXFragment | undefined
+    if (parent?.type === "JSXElement" || parent?.type === "JSXFragment") {
+      // Among JSX children a bare comment renders as text, so it goes in braces before the element.
+      const siblings = parent.children ?? []
+      const index = siblings.indexOf(path.node)
+      const before = siblings[index - 1]
+      const beforeThat = siblings[index - 2]
+      if (
+        beforeThat?.type === "JSXExpressionContainer" &&
+        j(beforeThat).toSource().includes(text)
+      )
+        return
+      const indent =
+        before?.type === "JSXText"
+          ? (/\n([ \t]*)$/.exec(before.value)?.[1] ?? "")
+          : ""
+      const empty = j.jsxEmptyExpression()
+      ;(empty as { comments?: unknown[] }).comments = [
+        j.commentBlock(` ${text} `, false, true),
+      ]
+      siblings.splice(
+        index,
+        0,
+        j.jsxExpressionContainer(empty),
+        j.jsxText(`\n${indent}`)
+      )
+      return
+    }
+    // The parser hands a leading comment to the element itself, the transform to its opening tag.
+    const existing = [
+      ...(path.node.comments ?? []),
+      ...(path.node.openingElement.comments ?? []),
+    ]
+    if (existing.some((c) => String(c.value).includes(text))) return
+    const comment = j.commentBlock(` ${text} `, true, false)
+    path.node.openingElement.comments = [
+      ...(path.node.openingElement.comments ?? []),
+      comment,
+    ]
+  }
+
+  // Rule 1: dismissal interceptors move to the root's onOpenChange.
+  for (const overlay of overlays)
+    root
+      .find(j.JSXElement)
+      .filter((p) => elementName(p.node) === overlay.localContent)
+      .forEach((contentPath) => {
+        const handlers = overlay.props
+          .map((prop) => ({ prop, node: attr(contentPath.node, prop) }))
+          .filter((h): h is { prop: string; node: JSXAttribute } => !!h.node)
+        if (handlers.length === 0) return
+
+        const rootPath = closestElement(
+          contentPath,
+          (el) => !!overlay.localRoot && elementName(el) === overlay.localRoot
+        )
+        const values = handlers.map((h) => h.node.value)
+        if (
+          !rootPath ||
+          values.some((v) => v?.type !== "JSXExpressionContainer")
+        ) {
+          addTodo(
+            contentPath,
+            `${handlers.map((h) => h.prop).join(", ")} ${handlers.length > 1 ? "are" : "is"} ` +
+              `not on ${overlay.content} any more; handle eventDetails.reason in the ${overlay.root}'s onOpenChange`
+          )
+          return
+        }
+
+        // Each handler is evaluated once per dismissal, in Radix's order, on the native event.
+        const checks: IfStatement[] = []
+        for (const h of handlers) {
+          const value = (h.node.value as unknown as { expression: never })
+            .expression
+          const reasons = DISMISS_REASONS[h.prop]
+          const comparisons: Array<BinaryExpression | LogicalExpression> =
+            reasons.map((reason) =>
+              j.binaryExpression(
+                "===",
+                j.memberExpression(
+                  j.identifier("eventDetails"),
+                  j.identifier("reason")
+                ),
+                j.stringLiteral(reason)
+              )
+            )
+          const test = comparisons.reduce((a, b) =>
+            j.logicalExpression("||", a, b)
+          )
+          checks.push(
+            j.ifStatement(test, j.expressionStatement(callHandler(j, value)))
+          )
+          removeAttr(contentPath.node, h.node)
+        }
+
+        const dismissal: Array<VariableDeclaration | IfStatement> = [
+          j.variableDeclaration("const", [
+            j.variableDeclarator(
+              j.identifier("wasPrevented"),
+              eventField(j, "defaultPrevented")
+            ),
+          ]),
+          ...checks,
+          j.ifStatement(
+            j.logicalExpression(
+              "&&",
+              j.unaryExpression("!", j.identifier("wasPrevented")),
+              eventField(j, "defaultPrevented")
+            ),
+            j.returnStatement(
+              j.callExpression(
+                j.memberExpression(
+                  j.identifier("eventDetails"),
+                  j.identifier("cancel")
+                ),
+                []
+              )
+            )
+          ),
+        ]
+
+        const rootEl = rootPath.node
+        const existing = attr(rootEl, "onOpenChange")
+        const expression =
+          existing?.value?.type === "JSXExpressionContainer"
+            ? existing.value.expression
+            : undefined
+
+        let next: ArrowFunctionExpression | FunctionExpression
+        if (
+          expression &&
+          (expression.type === "ArrowFunctionExpression" ||
+            expression.type === "FunctionExpression") &&
+          expression.params.length <= 1
+        ) {
+          // Reuse the caller's own callback: add the details parameter and prepend the checks.
+          next = expression
+          if (next.params.length === 0) next.params.push(j.identifier("_open"))
+          next.params.push(j.identifier("eventDetails"))
+          const body =
+            next.body.type === "BlockStatement"
+              ? next.body.body
+              : [j.expressionStatement(next.body)]
+          next.body = j.blockStatement([...dismissal, ...body])
+          if (next.type === "ArrowFunctionExpression") next.expression = false
+        } else {
+          const forward: ExpressionStatement[] =
+            expression && expression.type !== "JSXEmptyExpression"
+              ? [
+                  j.expressionStatement(
+                    j.optionalCallExpression(
+                      expression,
+                      [j.identifier("open")],
+                      true
+                    )
+                  ),
+                ]
+              : []
+          next = j.arrowFunctionExpression(
+            [
+              j.identifier(forward.length ? "open" : "_open"),
+              j.identifier("eventDetails"),
+            ],
+            j.blockStatement([...dismissal, ...forward])
+          )
+        }
+
+        const replacement = j.jsxAttribute(
+          j.jsxIdentifier("onOpenChange"),
+          j.jsxExpressionContainer(next)
+        )
+        if (existing) {
+          rootEl.openingElement.attributes =
+            rootEl.openingElement.attributes!.map((a) =>
+              a === existing ? replacement : a
+            )
+        } else {
+          rootEl.openingElement.attributes!.push(replacement)
+        }
+        changed = true
+      })
+
+  // Rule 2: onSelect can no longer keep the menu open.
+  root
+    .find(j.JSXElement)
+    .filter((p) => items.has(elementName(p.node) ?? ""))
+    .forEach((itemPath) => {
+      const onSelect = attr(itemPath.node, "onSelect")
+      if (!onSelect || !j(onSelect).toSource().includes("preventDefault"))
+        return
+      addTodo(
+        itemPath,
+        "onSelect's preventDefault() no longer keeps the menu open; cancel it in the DropdownMenu's onOpenChange when eventDetails.reason is \"item-press\""
+      )
+    })
+
+  for (const todo of todos) api.report(todo)
+  if (todos.length) changed = true
+
+  return changed
+    ? root.toSource({ quote: options.quote ?? "single" })
+    : undefined
+}
+
+function zenithLocalNames(j: API["jscodeshift"], root: Collection) {
+  const names: Record<string, string> = {}
+  root.find(j.ImportDeclaration, { source: { value: ZENITH } }).forEach((p) => {
+    for (const s of p.node.specifiers ?? []) {
+      if (s.type !== "ImportSpecifier") continue
+      names[String(s.imported.name)] = String(s.local?.name ?? s.imported.name)
+    }
+  })
+  return names
+}
+
+function closestElement(
+  path: ASTPath<JSXElement>,
+  match: (el: JSXElement) => boolean
+): ASTPath<JSXElement> | undefined {
+  let current = path.parent as ASTPath | null
+  while (current) {
+    if (
+      current.node.type === "JSXElement" &&
+      match(current.node as JSXElement)
+    ) {
+      return current as ASTPath<JSXElement>
+    }
+    current = current.parent
+  }
+  return undefined
+}
+
+function eventField(j: API["jscodeshift"], field: string) {
+  return j.memberExpression(
+    j.memberExpression(j.identifier("eventDetails"), j.identifier("event")),
+    j.identifier(field)
+  )
+}
+
+function callHandler(j: API["jscodeshift"], handler: never) {
+  const event = j.memberExpression(
+    j.identifier("eventDetails"),
+    j.identifier("event")
+  )
+  const h = handler as { type: string; params?: unknown[] }
+  // An inline function is always defined; a reference may be undefined (a conditional handler).
+  // An inline function that ignores the event is called without it, so the output typechecks.
+  return h.type === "ArrowFunctionExpression" || h.type === "FunctionExpression"
+    ? j.callExpression(handler, h.params?.length ? [event] : [])
+    : j.optionalCallExpression(handler, [event], true)
+}

package/dist/_virtual/_zenith-runtime-family_accordion.js

@@ -0,0 +1,7 @@
+import { servedFamily as o } from "../renderer/served.js";
+import { accordion as r } from "@epilot/zenith-runtime/v1";
+const c = o("accordion", r), n = c.Accordion;
+export {
+  n as Accordion
+};
+//# sourceMappingURL=_zenith-runtime-family_accordion.js.map

package/dist/_virtual/_zenith-runtime-family_accordion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_accordion.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_alert-dialog.js

@@ -0,0 +1,7 @@
+import { servedFamily as o } from "../renderer/served.js";
+import { alertDialog as r } from "@epilot/zenith-runtime/v1";
+const e = o("alertDialog", r), a = e.AlertDialog;
+export {
+  a as AlertDialog
+};
+//# sourceMappingURL=_zenith-runtime-family_alert-dialog.js.map

package/dist/_virtual/_zenith-runtime-family_alert-dialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_alert-dialog.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_avatar.js

@@ -0,0 +1,7 @@
+import { servedFamily as a } from "../renderer/served.js";
+import { avatar as r } from "@epilot/zenith-runtime/v1";
+const t = a("avatar", r), e = t.Avatar;
+export {
+  e as Avatar
+};
+//# sourceMappingURL=_zenith-runtime-family_avatar.js.map

package/dist/_virtual/_zenith-runtime-family_avatar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_avatar.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_button.js

@@ -0,0 +1,7 @@
+import { servedFamily as t } from "../renderer/served.js";
+import { button as o } from "@epilot/zenith-runtime/v1";
+const r = t("button", o), m = r.Button;
+export {
+  m as Button
+};
+//# sourceMappingURL=_zenith-runtime-family_button.js.map

package/dist/_virtual/_zenith-runtime-family_button.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_button.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_checkbox.js

@@ -0,0 +1,7 @@
+import { servedFamily as o } from "../renderer/served.js";
+import { checkbox as e } from "@epilot/zenith-runtime/v1";
+const c = o("checkbox", e), t = c.Checkbox;
+export {
+  t as Checkbox
+};
+//# sourceMappingURL=_zenith-runtime-family_checkbox.js.map

package/dist/_virtual/_zenith-runtime-family_checkbox.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_checkbox.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_csp-provider.js

@@ -0,0 +1,7 @@
+import { servedFamily as r } from "../renderer/served.js";
+import { cspProvider as o } from "@epilot/zenith-runtime/v1";
+const e = r("cspProvider", o), s = e.CSPProvider;
+export {
+  s as CSPProvider
+};
+//# sourceMappingURL=_zenith-runtime-family_csp-provider.js.map

package/dist/_virtual/_zenith-runtime-family_csp-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_csp-provider.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_dialog.js

@@ -0,0 +1,7 @@
+import { servedFamily as o } from "../renderer/served.js";
+import { dialog as i } from "@epilot/zenith-runtime/v1";
+const r = o("dialog", i), l = r.Dialog;
+export {
+  l as Dialog
+};
+//# sourceMappingURL=_zenith-runtime-family_dialog.js.map

package/dist/_virtual/_zenith-runtime-family_dialog.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_dialog.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_direction-provider.js

@@ -0,0 +1,8 @@
+import { servedFamily as i } from "../renderer/served.js";
+import { directionProvider as o } from "@epilot/zenith-runtime/v1";
+const r = i("directionProvider", o), d = r.DirectionProvider;
+r.useDirection;
+export {
+  d as DirectionProvider
+};
+//# sourceMappingURL=_zenith-runtime-family_direction-provider.js.map

package/dist/_virtual/_zenith-runtime-family_direction-provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_direction-provider.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;"}

package/dist/_virtual/_zenith-runtime-family_menu.js

@@ -0,0 +1,7 @@
+import { servedFamily as e } from "../renderer/served.js";
+import { menu as m } from "@epilot/zenith-runtime/v1";
+const o = e("menu", m), t = o.Menu;
+export {
+  t as Menu
+};
+//# sourceMappingURL=_zenith-runtime-family_menu.js.map

package/dist/_virtual/_zenith-runtime-family_menu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_menu.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_merge-props.js

@@ -0,0 +1,11 @@
+import { servedFamily as r } from "../renderer/served.js";
+import { mergeProps as m } from "@epilot/zenith-runtime/v1";
+const e = r("mergeProps", m);
+e.makeEventPreventable;
+e.mergeClassNames;
+const p = e.mergeProps;
+e.mergePropsN;
+export {
+  p as mergeProps
+};
+//# sourceMappingURL=_zenith-runtime-family_merge-props.js.map

package/dist/_virtual/_zenith-runtime-family_merge-props.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_merge-props.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;"}

package/dist/_virtual/_zenith-runtime-family_popover.js

@@ -0,0 +1,7 @@
+import { servedFamily as o } from "../renderer/served.js";
+import { popover as r } from "@epilot/zenith-runtime/v1";
+const e = o("popover", r), m = e.Popover;
+export {
+  m as Popover
+};
+//# sourceMappingURL=_zenith-runtime-family_popover.js.map

package/dist/_virtual/_zenith-runtime-family_popover.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_popover.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_radio-group.js

@@ -0,0 +1,7 @@
+import { servedFamily as o } from "../renderer/served.js";
+import { radioGroup as r } from "@epilot/zenith-runtime/v1";
+const i = o("radioGroup", r), a = i.RadioGroup;
+export {
+  a as RadioGroup
+};
+//# sourceMappingURL=_zenith-runtime-family_radio-group.js.map

package/dist/_virtual/_zenith-runtime-family_radio-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_radio-group.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_radio.js

@@ -0,0 +1,7 @@
+import { servedFamily as o } from "../renderer/served.js";
+import { radio as r } from "@epilot/zenith-runtime/v1";
+const i = o("radio", r), e = i.Radio;
+export {
+  e as Radio
+};
+//# sourceMappingURL=_zenith-runtime-family_radio.js.map

package/dist/_virtual/_zenith-runtime-family_radio.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_radio.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_scroll-area.js

@@ -0,0 +1,7 @@
+import { servedFamily as r } from "../renderer/served.js";
+import { scrollArea as o } from "@epilot/zenith-runtime/v1";
+const e = r("scrollArea", o), s = e.ScrollArea;
+export {
+  s as ScrollArea
+};
+//# sourceMappingURL=_zenith-runtime-family_scroll-area.js.map

package/dist/_virtual/_zenith-runtime-family_scroll-area.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_scroll-area.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_select.js

@@ -0,0 +1,7 @@
+import { servedFamily as e } from "../renderer/served.js";
+import { select as t } from "@epilot/zenith-runtime/v1";
+const o = e("select", t), s = o.Select;
+export {
+  s as Select
+};
+//# sourceMappingURL=_zenith-runtime-family_select.js.map

package/dist/_virtual/_zenith-runtime-family_select.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_select.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_separator.js

@@ -0,0 +1,7 @@
+import { servedFamily as r } from "../renderer/served.js";
+import { separator as o } from "@epilot/zenith-runtime/v1";
+const a = r("separator", o), p = a.Separator;
+export {
+  p as Separator
+};
+//# sourceMappingURL=_zenith-runtime-family_separator.js.map

package/dist/_virtual/_zenith-runtime-family_separator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_separator.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_switch.js

@@ -0,0 +1,7 @@
+import { servedFamily as t } from "../renderer/served.js";
+import { switch as i } from "@epilot/zenith-runtime/v1";
+const s = t("switch", i), r = s.Switch;
+export {
+  r as Switch
+};
+//# sourceMappingURL=_zenith-runtime-family_switch.js.map

package/dist/_virtual/_zenith-runtime-family_switch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_switch.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_tabs.js

@@ -0,0 +1,7 @@
+import { servedFamily as s } from "../renderer/served.js";
+import { tabs as o } from "@epilot/zenith-runtime/v1";
+const r = s("tabs", o), e = r.Tabs;
+export {
+  e as Tabs
+};
+//# sourceMappingURL=_zenith-runtime-family_tabs.js.map

package/dist/_virtual/_zenith-runtime-family_tabs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_tabs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_toast.js

@@ -0,0 +1,7 @@
+import { servedFamily as o } from "../renderer/served.js";
+import { toast as t } from "@epilot/zenith-runtime/v1";
+const s = o("toast", t), e = s.Toast;
+export {
+  e as Toast
+};
+//# sourceMappingURL=_zenith-runtime-family_toast.js.map

package/dist/_virtual/_zenith-runtime-family_toast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_toast.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_toggle-group.js

@@ -0,0 +1,7 @@
+import { servedFamily as o } from "../renderer/served.js";
+import { toggleGroup as r } from "@epilot/zenith-runtime/v1";
+const e = o("toggleGroup", r), t = e.ToggleGroup;
+export {
+  t as ToggleGroup
+};
+//# sourceMappingURL=_zenith-runtime-family_toggle-group.js.map

package/dist/_virtual/_zenith-runtime-family_toggle-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_toggle-group.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/_virtual/_zenith-runtime-family_toggle.js

@@ -0,0 +1,7 @@
+import { servedFamily as o } from "../renderer/served.js";
+import { toggle as e } from "@epilot/zenith-runtime/v1";
+const g = o("toggle", e), l = g.Toggle;
+export {
+  l as Toggle
+};
+//# sourceMappingURL=_zenith-runtime-family_toggle.js.map

package/dist/_virtual/_zenith-runtime-family_toggle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_zenith-runtime-family_toggle.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}