@epilot/zenith-react 0.2.0-next.3 → 0.2.0-next.5

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

@@ -0,0 +1,677 @@
+/**
+ * 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 { existsSync, readFileSync, statSync } from "node:fs"
+import { dirname, resolve } from "node:path"
+import type {
+  API,
+  ArrowFunctionExpression,
+  ASTPath,
+  BinaryExpression,
+  Collection,
+  ExpressionStatement,
+  FileInfo,
+  FunctionExpression,
+  IfStatement,
+  JSXAttribute,
+  JSXElement,
+  JSXFragment,
+  LogicalExpression,
+  Options,
+  VariableDeclaration,
+} from "jscodeshift"
+import { formatOutput } from "./format"
+
+type J = API["jscodeshift"]
+type Scope = ASTPath["scope"]
+/** Where a reference is looked up: the file's AST, its path (imports resolve against it) and depth. */
+type Lookup = { j: J; root: Collection; path: string; depth: number }
+
+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 async function transform(
+  file: FileInfo,
+  api: API,
+  options: Options
+): Promise<string | undefined> {
+  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)
+          )
+          const withEvent = handlerTakesEvent(
+            { j, root, path: file.path, depth: 0 },
+            contentPath.scope,
+            value
+          )
+          checks.push(
+            j.ifStatement(
+              test,
+              j.expressionStatement(callHandler(j, value, withEvent))
+            )
+          )
+          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
+    ? formatOutput(
+        root.toSource({ quote: options.quote ?? "single" }),
+        file.path
+      )
+    : 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: J, handler: never, withEvent: boolean) {
+  const h = handler as { type: string }
+  const args = withEvent
+    ? [j.memberExpression(j.identifier("eventDetails"), j.identifier("event"))]
+    : []
+  // An inline function is always defined; a reference may be undefined (a conditional handler).
+  return h.type === "ArrowFunctionExpression" || h.type === "FunctionExpression"
+    ? j.callExpression(handler, args)
+    : j.optionalCallExpression(handler, args, true)
+}
+
+/**
+ * Whether the handler is called with the event. A function that takes no parameter is called
+ * without it, so the output typechecks (TS2554): an inline function by its own parameters, a
+ * reference by the declaration it resolves to, in this file or in a relative import (a `const`
+ * or `function` declaration, `useCallback`, a type annotation, a destructured prop whose type is
+ * written in the file). A reference the file cannot explain (a package import, a member
+ * expression, a conditional) gets the event: an extra argument is harmless at runtime, and
+ * TypeScript reports the rare zero-parameter case.
+ */
+function handlerTakesEvent(
+  lookup: Lookup,
+  scope: Scope,
+  handler: { type: string; params?: unknown[]; name?: string }
+): boolean {
+  if (
+    handler.type === "ArrowFunctionExpression" ||
+    handler.type === "FunctionExpression"
+  )
+    return (handler.params?.length ?? 0) > 0
+  if (handler.type !== "Identifier" || !handler.name) return true
+  const arity = referenceArity(lookup, scope, handler.name)
+  return arity === undefined || arity > 0
+}
+
+const MAX_DEPTH = 8
+
+/** The number of parameters `name` is declared with, or undefined when the file does not say. */
+function referenceArity(
+  lookup: Lookup,
+  scope: Scope,
+  name: string
+): number | undefined {
+  if (lookup.depth > MAX_DEPTH) return undefined
+  const declaring = scope?.lookup(name)
+  const [binding] = declaring?.getBindings()[name] ?? []
+  return binding ? bindingArity(lookup, binding) : undefined
+}
+
+function bindingArity(lookup: Lookup, binding: ASTPath): number | undefined {
+  const { j } = lookup
+  const id = binding.node
+  const parent = binding.parent?.node
+  // `const close: () => void = …`, a parameter `close: () => void`
+  if (j.Identifier.check(id) && id.typeAnnotation) {
+    const arity = typeArity(lookup, id.typeAnnotation.typeAnnotation)
+    if (arity !== undefined) return arity
+  }
+  if (j.VariableDeclarator.check(parent) && binding.name === "id")
+    return parent.init
+      ? expressionArity(lookup, binding.parent.scope, parent.init)
+      : undefined
+  if (j.FunctionDeclaration.check(parent) && binding.name === "id")
+    return parent.params.length
+  if (
+    j.ImportSpecifier.check(parent) ||
+    j.ImportDefaultSpecifier.check(parent)
+  ) {
+    const declaration = binding.parent.parent?.node
+    if (!j.ImportDeclaration.check(declaration)) return undefined
+    const imported = j.ImportSpecifier.check(parent)
+      ? String(parent.imported.name)
+      : "default"
+    return importedArity(lookup, String(declaration.source.value), imported)
+  }
+  // `({ onClose }: { onClose: () => void }) => …`: the destructured prop's type
+  if (
+    (j.ObjectProperty.check(parent) || j.Property.check(parent)) &&
+    binding.name === "value"
+  ) {
+    const pattern = binding.parent.parent?.node
+    const key = parent.key
+    const keyName = j.Identifier.check(key)
+      ? key.name
+      : j.StringLiteral.check(key)
+        ? key.value
+        : undefined
+    if (
+      !j.ObjectPattern.check(pattern) ||
+      !pattern.typeAnnotation ||
+      keyName === undefined
+    )
+      return undefined
+    const members = typeMembers(lookup, pattern.typeAnnotation.typeAnnotation)
+    for (const member of members ?? []) {
+      const memberKey = (member as { key?: unknown }).key
+      const memberName = j.Identifier.check(memberKey)
+        ? memberKey.name
+        : j.StringLiteral.check(memberKey)
+          ? memberKey.value
+          : undefined
+      if (memberName !== keyName) continue
+      if (j.TSMethodSignature.check(member)) return member.parameters.length
+      if (j.TSPropertySignature.check(member))
+        return member.typeAnnotation
+          ? typeArity(lookup, member.typeAnnotation.typeAnnotation)
+          : undefined
+      return undefined
+    }
+  }
+  return undefined
+}
+
+function expressionArity(
+  lookup: Lookup,
+  scope: Scope,
+  expression: unknown
+): number | undefined {
+  const { j } = lookup
+  if (
+    j.ArrowFunctionExpression.check(expression) ||
+    j.FunctionExpression.check(expression)
+  )
+    return expression.params.length
+  if (j.Identifier.check(expression))
+    return referenceArity(
+      { ...lookup, depth: lookup.depth + 1 },
+      scope,
+      expression.name
+    )
+  if (j.TSAsExpression.check(expression))
+    return (
+      typeArity(lookup, expression.typeAnnotation) ??
+      expressionArity(lookup, scope, expression.expression)
+    )
+  if (j.TSNonNullExpression.check(expression))
+    return expressionArity(lookup, scope, expression.expression)
+  // `useCallback(() => …, [])`: the callback's own parameters
+  if (j.CallExpression.check(expression)) {
+    const { callee } = expression
+    const hook = j.Identifier.check(callee)
+      ? callee.name
+      : j.MemberExpression.check(callee) && j.Identifier.check(callee.property)
+        ? callee.property.name
+        : undefined
+    return hook === "useCallback"
+      ? expressionArity(lookup, scope, expression.arguments[0])
+      : undefined
+  }
+  return undefined
+}
+
+/** The parameter count of a function type, through unions with undefined and aliases in the file. */
+function typeArity(lookup: Lookup, type: unknown): number | undefined {
+  const { j, root } = lookup
+  if (j.TSFunctionType.check(type)) return type.parameters.length
+  if (j.TSParenthesizedType.check(type))
+    return typeArity(lookup, type.typeAnnotation)
+  if (j.TSUnionType.check(type)) {
+    const arities = type.types
+      .filter(
+        (t) => !j.TSUndefinedKeyword.check(t) && !j.TSNullKeyword.check(t)
+      )
+      .map((t) => typeArity(lookup, t))
+    return arities.length && arities.every((a) => a !== undefined)
+      ? Math.max(...(arities as number[]))
+      : undefined
+  }
+  if (
+    j.TSTypeReference.check(type) &&
+    j.Identifier.check(type.typeName) &&
+    !type.typeParameters &&
+    lookup.depth <= MAX_DEPTH
+  ) {
+    const alias = root
+      .find(j.TSTypeAliasDeclaration, { id: { name: type.typeName.name } })
+      .nodes()[0]
+    return alias
+      ? typeArity({ ...lookup, depth: lookup.depth + 1 }, alias.typeAnnotation)
+      : undefined
+  }
+  return undefined
+}
+
+/** The members of an object type written in the file: a literal, an alias, an interface, an intersection. */
+function typeMembers(lookup: Lookup, type: unknown): unknown[] | undefined {
+  const { j, root } = lookup
+  if (j.TSTypeLiteral.check(type)) return type.members
+  if (j.TSParenthesizedType.check(type))
+    return typeMembers(lookup, type.typeAnnotation)
+  // A member found in one part of an intersection is one of the property's overloads.
+  if (j.TSIntersectionType.check(type))
+    return type.types.flatMap((t) => typeMembers(lookup, t) ?? [])
+  if (
+    j.TSTypeReference.check(type) &&
+    j.Identifier.check(type.typeName) &&
+    !type.typeParameters &&
+    lookup.depth <= MAX_DEPTH
+  ) {
+    const name = type.typeName.name
+    const deeper = { ...lookup, depth: lookup.depth + 1 }
+    const alias = root
+      .find(j.TSTypeAliasDeclaration, { id: { name } })
+      .nodes()[0]
+    if (alias) return typeMembers(deeper, alias.typeAnnotation)
+    // An interface's own members; one inherited through `extends` stays unknown.
+    const iface = root
+      .find(j.TSInterfaceDeclaration, { id: { name } })
+      .nodes()[0]
+    return iface?.body.body
+  }
+  return undefined
+}
+
+const MODULE_SUFFIXES = [
+  "",
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  "/index.ts",
+  "/index.tsx",
+  "/index.js",
+]
+
+/** The arity of `imported` from a relative module, read from disk; a package import stays unknown. */
+function importedArity(
+  lookup: Lookup,
+  source: string,
+  imported: string
+): number | undefined {
+  if (!source.startsWith(".") || lookup.depth > MAX_DEPTH) return undefined
+  const base = resolve(dirname(lookup.path), source)
+  const file = MODULE_SUFFIXES.map((suffix) => base + suffix).find(
+    (candidate) => existsSync(candidate) && statSync(candidate).isFile()
+  )
+  if (!file) return undefined
+  const { j } = lookup
+  let root: Collection
+  try {
+    root = j(readFileSync(file, "utf8"))
+  } catch {
+    return undefined
+  }
+  const other: Lookup = { j, root, path: file, depth: lookup.depth + 1 }
+  const program = root.find(j.Program).paths()[0]
+  const local = (name: string) => referenceArity(other, program.scope, name)
+
+  if (imported === "default") {
+    const declaration = root
+      .find(j.ExportDefaultDeclaration)
+      .nodes()[0]?.declaration
+    if (j.Identifier.check(declaration)) return local(declaration.name)
+    if (j.FunctionDeclaration.check(declaration))
+      return declaration.params.length
+    return expressionArity(other, program.scope, declaration)
+  }
+  for (const node of root.find(j.ExportNamedDeclaration).nodes()) {
+    for (const specifier of node.specifiers ?? []) {
+      if (!j.ExportSpecifier.check(specifier)) continue
+      if (String(specifier.exported.name) !== imported) continue
+      const localName = String(specifier.local?.name ?? specifier.exported.name)
+      return node.source
+        ? importedArity(other, String(node.source.value), localName)
+        : local(localName)
+    }
+  }
+  // `export const close = …` and `export function close() {}` are program-scope bindings.
+  const own = local(imported)
+  if (own !== undefined) return own
+  for (const node of root.find(j.ExportAllDeclaration).nodes()) {
+    const through = importedArity(other, String(node.source.value), imported)
+    if (through !== undefined) return through
+  }
+  return undefined
+}

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":";;;"}