@brumaombra/ui-vintage 0.1.0

package/dist/DatePicker.vue_vue_type_script_setup_true_lang-D8mev2ha.js

@@ -0,0 +1,92 @@
+import { defineComponent, ref, computed, openBlock, createBlock, unref, withCtx, createVNode, normalizeClass, createTextVNode, toDisplayString } from "vue";
+import { $ as $14e0f24ef4ac5c92$export$d0bdf45af03a6ea3, l as $14e0f24ef4ac5c92$export$aa8b41735afcabd2, m as $fb18d541ea1ad717$export$ad991b66133851cf, _ as _sfc_main$5 } from "./CalendarPrevButton.vue_vue_type_script_setup_true_lang-C-WnFnvj.js";
+import { c as cn } from "./utils-Bz4m9VPB.js";
+import { Button as _sfc_main$3 } from "./button.js";
+import { _ as _sfc_main$1, b as _sfc_main$2, a as _sfc_main$4 } from "./PopoverTrigger.vue_vue_type_script_setup_true_lang-KTcg6Jnl.js";
+import { c as createLucideIcon } from "./createLucideIcon-CCMB2vDW.js";
+/**
+ * @license lucide-vue-next v1.0.0 - ISC
+ *
+ * This source code is licensed under the ISC license.
+ * See the LICENSE file in the root directory of this source tree.
+ */
+const Calendar = createLucideIcon("calendar", [
+  ["path", { d: "M8 2v4", key: "1cmpym" }],
+  ["path", { d: "M16 2v4", key: "4m81vk" }],
+  ["rect", { width: "18", height: "18", x: "3", y: "4", rx: "2", key: "1hopcy" }],
+  ["path", { d: "M3 10h18", key: "8toen8" }]
+]);
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "DatePicker",
+  props: {
+    defaultValue: {},
+    modelValue: {},
+    placeholder: { default: "Pick a date" },
+    disabled: { type: Boolean, default: false },
+    class: {},
+    contentClass: {}
+  },
+  emits: ["update:modelValue"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const internalDate = ref(props.defaultValue);
+    const isControlled = computed(() => props.modelValue !== void 0);
+    const date = computed({
+      get: () => isControlled.value ? props.modelValue : internalDate.value,
+      set: (value) => {
+        if (!isControlled.value)
+          internalDate.value = value;
+        emits("update:modelValue", value);
+      }
+    });
+    const defaultPlaceholder = computed(() => date.value ?? $14e0f24ef4ac5c92$export$d0bdf45af03a6ea3($14e0f24ef4ac5c92$export$aa8b41735afcabd2()));
+    const formatter = new $fb18d541ea1ad717$export$ad991b66133851cf("en-US", {
+      dateStyle: "long"
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), null, {
+        default: withCtx(({ close }) => [
+          createVNode(unref(_sfc_main$2), { "as-child": "" }, {
+            default: withCtx(() => [
+              createVNode(unref(_sfc_main$3), {
+                variant: "outline",
+                disabled: _ctx.disabled,
+                class: normalizeClass(unref(cn)("w-[240px] justify-start text-left font-normal", !date.value && "text-muted-foreground", props.class))
+              }, {
+                default: withCtx(() => [
+                  createVNode(unref(Calendar), { class: "size-4" }),
+                  createTextVNode(" " + toDisplayString(date.value ? unref(formatter).format(date.value.toDate(unref($14e0f24ef4ac5c92$export$aa8b41735afcabd2)())) : _ctx.placeholder), 1)
+                ]),
+                _: 1
+              }, 8, ["disabled", "class"])
+            ]),
+            _: 1
+          }),
+          createVNode(unref(_sfc_main$4), {
+            class: normalizeClass(unref(cn)("w-auto p-0", props.contentClass)),
+            align: "start"
+          }, {
+            default: withCtx(() => [
+              createVNode(unref(_sfc_main$5), {
+                modelValue: date.value,
+                "onUpdate:modelValue": [
+                  _cache[0] || (_cache[0] = ($event) => date.value = $event),
+                  close
+                ],
+                "default-placeholder": defaultPlaceholder.value,
+                layout: "month-and-year",
+                "initial-focus": ""
+              }, null, 8, ["modelValue", "default-placeholder", "onUpdate:modelValue"])
+            ]),
+            _: 2
+          }, 1032, ["class"])
+        ]),
+        _: 1
+      });
+    };
+  }
+});
+export {
+  _sfc_main as _
+};

package/dist/DialogClose-BNlqG4G2.js

@@ -0,0 +1,36 @@
+import { u as useForwardExpose } from "./useForwardExpose-CNVHwdF2.js";
+import { P as Primitive } from "./Primitive-D3IcFg81.js";
+import { i as injectDialogRootContext } from "./DialogTitle-DXj0nkXn.js";
+import { defineComponent, openBlock, createBlock, unref, mergeProps, withCtx, renderSlot } from "vue";
+var DialogClose_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogClose",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "button"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    useForwardExpose();
+    const rootContext = injectDialogRootContext();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), mergeProps(props, {
+        type: _ctx.as === "button" ? "button" : void 0,
+        onClick: _cache[0] || (_cache[0] = ($event) => unref(rootContext).onOpenChange(false))
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, ["type"]);
+    };
+  }
+});
+var DialogClose_default = DialogClose_vue_vue_type_script_setup_true_lang_default;
+export {
+  DialogClose_default as D
+};

package/dist/DialogTitle-DXj0nkXn.js

@@ -0,0 +1,522 @@
+import { c as createContext, b as useEmitAsProps } from "./useForwardPropsEmits-DmumnZO5.js";
+import { u as useForwardExpose } from "./useForwardExpose-CNVHwdF2.js";
+import { u as useId, D as DismissableLayer_default, P as Presence_default } from "./Teleport-CuUn4UkG.js";
+import { g as getActiveElement, F as FocusScope_default, a as useHideOthers, u as useBodyScrollLock } from "./FocusScope-C3mcVwsf.js";
+import { g as getOpenState } from "./utils-RRmyeqLm.js";
+import { defineComponent, ref, toRefs, renderSlot, unref, onMounted, openBlock, createBlock, withCtx, createVNode, mergeProps, createCommentVNode } from "vue";
+import { P as Primitive } from "./Primitive-D3IcFg81.js";
+import { u as useVModel } from "./index-C1_fxYhb.js";
+const [injectDialogRootContext, provideDialogRootContext] = createContext("DialogRoot");
+var DialogRoot_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  inheritAttrs: false,
+  __name: "DialogRoot",
+  props: {
+    open: {
+      type: Boolean,
+      required: false,
+      default: void 0
+    },
+    defaultOpen: {
+      type: Boolean,
+      required: false,
+      default: false
+    },
+    modal: {
+      type: Boolean,
+      required: false,
+      default: true
+    }
+  },
+  emits: ["update:open"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const open = useVModel(props, "open", emit, {
+      defaultValue: props.defaultOpen,
+      passive: props.open === void 0
+    });
+    const triggerElement = ref();
+    const contentElement = ref();
+    const { modal } = toRefs(props);
+    provideDialogRootContext({
+      open,
+      modal,
+      openModal: () => {
+        open.value = true;
+      },
+      onOpenChange: (value) => {
+        open.value = value;
+      },
+      onOpenToggle: () => {
+        open.value = !open.value;
+      },
+      contentId: "",
+      titleId: "",
+      descriptionId: "",
+      triggerElement,
+      contentElement
+    });
+    return (_ctx, _cache) => {
+      return renderSlot(_ctx.$slots, "default", {
+        open: unref(open),
+        close: () => open.value = false
+      });
+    };
+  }
+});
+var DialogRoot_default = DialogRoot_vue_vue_type_script_setup_true_lang_default;
+const DEFAULT_TITLE_NAME = "DialogTitle";
+const DEFAULT_CONTENT_NAME = "DialogContent";
+function useWarning({ titleName = DEFAULT_TITLE_NAME, contentName = DEFAULT_CONTENT_NAME, componentLink = "dialog.html#title", titleId, descriptionId, contentElement }) {
+  const TITLE_MESSAGE = `Warning: \`${contentName}\` requires a \`${titleName}\` for the component to be accessible for screen reader users.
+
+If you want to hide the \`${titleName}\`, you can wrap it with our VisuallyHidden component.
+
+For more information, see https://www.reka-ui.com/docs/components/${componentLink}`;
+  const DESCRIPTION_MESSAGE = `Warning: Missing \`Description\` or \`aria-describedby="undefined"\` for ${contentName}.`;
+  onMounted(() => {
+    var _a;
+    const hasTitle = document.getElementById(titleId);
+    if (!hasTitle) console.warn(TITLE_MESSAGE);
+    const describedById = (_a = contentElement.value) == null ? void 0 : _a.getAttribute("aria-describedby");
+    if (descriptionId && describedById) {
+      const hasDescription = document.getElementById(descriptionId);
+      if (!hasDescription) console.warn(DESCRIPTION_MESSAGE);
+    }
+  });
+}
+var DialogContentImpl_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogContentImpl",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    trapFocus: {
+      type: Boolean,
+      required: false
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "openAutoFocus",
+    "closeAutoFocus"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const rootContext = injectDialogRootContext();
+    const { forwardRef, currentElement: contentElement } = useForwardExpose();
+    rootContext.titleId || (rootContext.titleId = useId(void 0, "reka-dialog-title"));
+    rootContext.descriptionId || (rootContext.descriptionId = useId(void 0, "reka-dialog-description"));
+    onMounted(() => {
+      rootContext.contentElement = contentElement;
+      if (getActiveElement() !== document.body) rootContext.triggerElement.value = getActiveElement();
+    });
+    if (process.env.NODE_ENV !== "production") useWarning({
+      titleName: "DialogTitle",
+      contentName: "DialogContent",
+      componentLink: "dialog.html#title",
+      titleId: rootContext.titleId,
+      descriptionId: rootContext.descriptionId,
+      contentElement
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(FocusScope_default), {
+        "as-child": "",
+        loop: "",
+        trapped: props.trapFocus,
+        onMountAutoFocus: _cache[5] || (_cache[5] = ($event) => emits("openAutoFocus", $event)),
+        onUnmountAutoFocus: _cache[6] || (_cache[6] = ($event) => emits("closeAutoFocus", $event))
+      }, {
+        default: withCtx(() => [createVNode(unref(DismissableLayer_default), mergeProps({
+          id: unref(rootContext).contentId,
+          ref: unref(forwardRef),
+          as: _ctx.as,
+          "as-child": _ctx.asChild,
+          "disable-outside-pointer-events": _ctx.disableOutsidePointerEvents,
+          role: "dialog",
+          "aria-describedby": unref(rootContext).descriptionId,
+          "aria-labelledby": unref(rootContext).titleId,
+          "data-state": unref(getOpenState)(unref(rootContext).open.value)
+        }, _ctx.$attrs, {
+          onDismiss: _cache[0] || (_cache[0] = ($event) => unref(rootContext).onOpenChange(false)),
+          onEscapeKeyDown: _cache[1] || (_cache[1] = ($event) => emits("escapeKeyDown", $event)),
+          onFocusOutside: _cache[2] || (_cache[2] = ($event) => emits("focusOutside", $event)),
+          onInteractOutside: _cache[3] || (_cache[3] = ($event) => emits("interactOutside", $event)),
+          onPointerDownOutside: _cache[4] || (_cache[4] = ($event) => emits("pointerDownOutside", $event))
+        }), {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 16, [
+          "id",
+          "as",
+          "as-child",
+          "disable-outside-pointer-events",
+          "aria-describedby",
+          "aria-labelledby",
+          "data-state"
+        ])]),
+        _: 3
+      }, 8, ["trapped"]);
+    };
+  }
+});
+var DialogContentImpl_default = DialogContentImpl_vue_vue_type_script_setup_true_lang_default;
+var DialogContentModal_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogContentModal",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    trapFocus: {
+      type: Boolean,
+      required: false
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "openAutoFocus",
+    "closeAutoFocus"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const rootContext = injectDialogRootContext();
+    const emitsAsProps = useEmitAsProps(emits);
+    const { forwardRef, currentElement } = useForwardExpose();
+    useHideOthers(currentElement);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(DialogContentImpl_default, mergeProps({
+        ...props,
+        ...unref(emitsAsProps)
+      }, {
+        ref: unref(forwardRef),
+        "trap-focus": unref(rootContext).open.value,
+        "disable-outside-pointer-events": true,
+        onCloseAutoFocus: _cache[0] || (_cache[0] = (event) => {
+          var _a;
+          if (!event.defaultPrevented) {
+            event.preventDefault();
+            (_a = unref(rootContext).triggerElement.value) == null ? void 0 : _a.focus();
+          }
+        }),
+        onPointerDownOutside: _cache[1] || (_cache[1] = (event) => {
+          const originalEvent = event.detail.originalEvent;
+          const ctrlLeftClick = originalEvent.button === 0 && originalEvent.ctrlKey === true;
+          const isRightClick = originalEvent.button === 2 || ctrlLeftClick;
+          if (isRightClick) event.preventDefault();
+        }),
+        onFocusOutside: _cache[2] || (_cache[2] = (event) => {
+          event.preventDefault();
+        })
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, ["trap-focus"]);
+    };
+  }
+});
+var DialogContentModal_default = DialogContentModal_vue_vue_type_script_setup_true_lang_default;
+var DialogContentNonModal_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogContentNonModal",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    trapFocus: {
+      type: Boolean,
+      required: false
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "openAutoFocus",
+    "closeAutoFocus"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const emitsAsProps = useEmitAsProps(emits);
+    useForwardExpose();
+    const rootContext = injectDialogRootContext();
+    const hasInteractedOutsideRef = ref(false);
+    const hasPointerDownOutsideRef = ref(false);
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(DialogContentImpl_default, mergeProps({
+        ...props,
+        ...unref(emitsAsProps)
+      }, {
+        "trap-focus": false,
+        "disable-outside-pointer-events": false,
+        onCloseAutoFocus: _cache[0] || (_cache[0] = (event) => {
+          var _a;
+          if (!event.defaultPrevented) {
+            if (!hasInteractedOutsideRef.value) (_a = unref(rootContext).triggerElement.value) == null ? void 0 : _a.focus();
+            event.preventDefault();
+          }
+          hasInteractedOutsideRef.value = false;
+          hasPointerDownOutsideRef.value = false;
+        }),
+        onInteractOutside: _cache[1] || (_cache[1] = (event) => {
+          var _a;
+          if (!event.defaultPrevented) {
+            hasInteractedOutsideRef.value = true;
+            if (event.detail.originalEvent.type === "pointerdown") hasPointerDownOutsideRef.value = true;
+          }
+          const target = event.target;
+          const targetIsTrigger = (_a = unref(rootContext).triggerElement.value) == null ? void 0 : _a.contains(target);
+          if (targetIsTrigger) event.preventDefault();
+          if (event.detail.originalEvent.type === "focusin" && hasPointerDownOutsideRef.value) event.preventDefault();
+        })
+      }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+var DialogContentNonModal_default = DialogContentNonModal_vue_vue_type_script_setup_true_lang_default;
+var DialogContent_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogContent",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    disableOutsidePointerEvents: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  emits: [
+    "escapeKeyDown",
+    "pointerDownOutside",
+    "focusOutside",
+    "interactOutside",
+    "openAutoFocus",
+    "closeAutoFocus"
+  ],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const rootContext = injectDialogRootContext();
+    const emitsAsProps = useEmitAsProps(emits);
+    const { forwardRef } = useForwardExpose();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Presence_default), { present: _ctx.forceMount || unref(rootContext).open.value }, {
+        default: withCtx(() => [unref(rootContext).modal.value ? (openBlock(), createBlock(DialogContentModal_default, mergeProps({
+          key: 0,
+          ref: unref(forwardRef)
+        }, {
+          ...props,
+          ...unref(emitsAsProps),
+          ..._ctx.$attrs
+        }), {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 16)) : (openBlock(), createBlock(DialogContentNonModal_default, mergeProps({
+          key: 1,
+          ref: unref(forwardRef)
+        }, {
+          ...props,
+          ...unref(emitsAsProps),
+          ..._ctx.$attrs
+        }), {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 16))]),
+        _: 3
+      }, 8, ["present"]);
+    };
+  }
+});
+var DialogContent_default = DialogContent_vue_vue_type_script_setup_true_lang_default;
+var DialogDescription_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogDescription",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "p"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    useForwardExpose();
+    const rootContext = injectDialogRootContext();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), mergeProps(props, { id: unref(rootContext).descriptionId }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, ["id"]);
+    };
+  }
+});
+var DialogDescription_default = DialogDescription_vue_vue_type_script_setup_true_lang_default;
+var DialogOverlayImpl_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogOverlayImpl",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  setup(__props) {
+    const rootContext = injectDialogRootContext();
+    useBodyScrollLock(true);
+    useForwardExpose();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), {
+        as: _ctx.as,
+        "as-child": _ctx.asChild,
+        "data-state": unref(rootContext).open.value ? "open" : "closed",
+        style: { "pointer-events": "auto" }
+      }, {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 8, [
+        "as",
+        "as-child",
+        "data-state"
+      ]);
+    };
+  }
+});
+var DialogOverlayImpl_default = DialogOverlayImpl_vue_vue_type_script_setup_true_lang_default;
+var DialogOverlay_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogOverlay",
+  props: {
+    forceMount: {
+      type: Boolean,
+      required: false
+    },
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false
+    }
+  },
+  setup(__props) {
+    const rootContext = injectDialogRootContext();
+    const { forwardRef } = useForwardExpose();
+    return (_ctx, _cache) => {
+      var _a;
+      return ((_a = unref(rootContext)) == null ? void 0 : _a.modal.value) ? (openBlock(), createBlock(unref(Presence_default), {
+        key: 0,
+        present: _ctx.forceMount || unref(rootContext).open.value
+      }, {
+        default: withCtx(() => [createVNode(DialogOverlayImpl_default, mergeProps(_ctx.$attrs, {
+          ref: unref(forwardRef),
+          as: _ctx.as,
+          "as-child": _ctx.asChild
+        }), {
+          default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+          _: 3
+        }, 16, ["as", "as-child"])]),
+        _: 3
+      }, 8, ["present"])) : createCommentVNode("v-if", true);
+    };
+  }
+});
+var DialogOverlay_default = DialogOverlay_vue_vue_type_script_setup_true_lang_default;
+var DialogTitle_vue_vue_type_script_setup_true_lang_default = /* @__PURE__ */ defineComponent({
+  __name: "DialogTitle",
+  props: {
+    asChild: {
+      type: Boolean,
+      required: false
+    },
+    as: {
+      type: null,
+      required: false,
+      default: "h2"
+    }
+  },
+  setup(__props) {
+    const props = __props;
+    const rootContext = injectDialogRootContext();
+    useForwardExpose();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), mergeProps(props, { id: unref(rootContext).titleId }), {
+        default: withCtx(() => [renderSlot(_ctx.$slots, "default")]),
+        _: 3
+      }, 16, ["id"]);
+    };
+  }
+});
+var DialogTitle_default = DialogTitle_vue_vue_type_script_setup_true_lang_default;
+export {
+  DialogOverlay_default as D,
+  DialogContent_default as a,
+  DialogRoot_default as b,
+  DialogDescription_default as c,
+  DialogTitle_default as d,
+  injectDialogRootContext as i
+};