@rupe/v-datepicker 1.0.0-alpha.0

package/dist/components/DatePicker/DatePickerRoot.vue.js

@@ -0,0 +1,169 @@
+import { defineComponent, toRefs, computed, ref, watch, createBlock, openBlock, unref, isRef, withCtx, renderSlot } from "vue";
+import { useVModel } from "../../node_modules/.pnpm/@vueuse_core@14.1.0_vue@3.5.26_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js";
+import { createContext } from "../../shared/createContext.js";
+import { getDefaultDate } from "../../shared/date/comparators.js";
+import { useDirection } from "../../shared/useDirection.js";
+import "../Primitive/Primitive.js";
+import "../Primitive/Slot.js";
+import _sfc_main$1 from "../Popover/PopoverRoot.vue.js";
+import "../Presence/Presence.js";
+import "../DismissableLayer/DismissableLayer.vue.js";
+const [injectDatePickerRootContext, provideDatePickerRootContext] = createContext("DatePickerRoot");
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  ...{
+    inheritAttrs: false
+  },
+  __name: "DatePickerRoot",
+  props: {
+    defaultValue: { default: void 0 },
+    defaultPlaceholder: {},
+    placeholder: { default: void 0 },
+    modelValue: {},
+    hourCycle: {},
+    step: {},
+    granularity: {},
+    hideTimeZone: { type: Boolean },
+    maxValue: {},
+    minValue: {},
+    locale: { default: "en" },
+    disabled: { type: Boolean, default: false },
+    readonly: { type: Boolean, default: false },
+    isDateUnavailable: { type: Function, default: void 0 },
+    id: {},
+    dir: {},
+    asChild: { type: Boolean },
+    as: {},
+    name: {},
+    required: { type: Boolean },
+    defaultOpen: { type: Boolean, default: false },
+    open: { type: Boolean, default: void 0 },
+    isDateDisabled: { type: Function, default: void 0 },
+    pagedNavigation: { type: Boolean, default: false },
+    weekStartsOn: { default: 0 },
+    weekdayFormat: { default: "narrow" },
+    fixedWeeks: { type: Boolean, default: false },
+    numberOfMonths: { default: 1 },
+    preventDeselect: { type: Boolean, default: false },
+    closeOnSelect: { type: Boolean, default: false }
+  },
+  emits: ["update:modelValue", "update:placeholder", "update:open"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const {
+      locale,
+      disabled,
+      readonly,
+      pagedNavigation,
+      weekStartsOn,
+      weekdayFormat,
+      fixedWeeks,
+      numberOfMonths,
+      preventDeselect,
+      isDateDisabled: propsIsDateDisabled,
+      isDateUnavailable: propsIsDateUnavailable,
+      defaultOpen,
+      id,
+      name,
+      required,
+      minValue,
+      maxValue,
+      granularity,
+      hideTimeZone,
+      hourCycle,
+      defaultValue,
+      dir: propDir,
+      step,
+      closeOnSelect
+    } = toRefs(props);
+    const dir = useDirection(propDir);
+    const modelValue = useVModel(props, "modelValue", emits, {
+      defaultValue: defaultValue.value,
+      passive: props.modelValue === void 0
+    });
+    const defaultDate = computed(
+      () => getDefaultDate({
+        defaultPlaceholder: props.placeholder,
+        granularity: props.granularity,
+        defaultValue: modelValue.value,
+        locale: props.locale
+      })
+    );
+    const placeholder = useVModel(props, "placeholder", emits, {
+      defaultValue: props.defaultPlaceholder ?? defaultDate.value.copy(),
+      passive: props.placeholder === void 0
+    });
+    const open = useVModel(props, "open", emits, {
+      defaultValue: defaultOpen.value,
+      passive: props.open === void 0
+    });
+    const dateFieldRef = ref();
+    watch(modelValue, (value) => {
+      if (value && value.compare(placeholder.value) !== 0) {
+        placeholder.value = value.copy();
+      }
+      if (closeOnSelect.value) {
+        open.value = false;
+      }
+    });
+    provideDatePickerRootContext({
+      isDateUnavailable: propsIsDateUnavailable.value,
+      isDateDisabled: propsIsDateDisabled.value,
+      locale,
+      disabled,
+      pagedNavigation,
+      weekStartsOn,
+      weekdayFormat,
+      fixedWeeks,
+      numberOfMonths,
+      readonly,
+      preventDeselect,
+      modelValue,
+      placeholder,
+      defaultOpen,
+      open,
+      id,
+      name,
+      required,
+      minValue,
+      maxValue,
+      granularity,
+      hideTimeZone,
+      hourCycle,
+      dateFieldRef,
+      dir,
+      step,
+      onDateChange(date) {
+        if (!date || !modelValue.value) {
+          modelValue.value = date?.copy() ?? void 0;
+        } else if (!preventDeselect.value && date && modelValue.value.compare(date) === 0) {
+          modelValue.value = void 0;
+        } else {
+          modelValue.value = date.copy();
+        }
+      },
+      onPlaceholderChange(date) {
+        placeholder.value = date.copy();
+      },
+      closeOnSelect
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), {
+        open: unref(open),
+        "onUpdate:open": _cache[0] || (_cache[0] = ($event) => isRef(open) ? open.value = $event : null),
+        "default-open": unref(defaultOpen)
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["open", "default-open"]);
+    };
+  }
+});
+export {
+  _sfc_main as default,
+  injectDatePickerRootContext,
+  provideDatePickerRootContext
+};
+//# sourceMappingURL=DatePickerRoot.vue.js.map

package/dist/components/DatePicker/DatePickerRoot.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatePickerRoot.vue.js","sources":["../../../src/components/DatePicker/DatePickerRoot.vue"],"sourcesContent":["<script lang=\"ts\">\nimport type { DateValue } from \"@internationalized/date\";\n\nimport type { Ref } from \"vue\";\nimport type { CalendarRootProps } from \"../Calendar\";\nimport type { DateFieldRootProps } from \"../DateField\";\nimport type { PopoverRootEmits, PopoverRootProps } from \"../Popover\";\nimport type { DateFieldRoot } from \"../DateField\";\nimport type { Matcher, WeekDayFormat } from \"../../date\";\nimport type { DateStep, Granularity, HourCycle } from \"../../shared/date\";\nimport type { Direction } from \"../../shared/types\";\nimport { computed, ref, toRefs, watch } from \"vue\";\nimport { createContext, useDirection } from \"../../shared\";\nimport { getDefaultDate } from \"../../shared/date\";\nimport { PopoverRoot } from \"../Popover\";\n\ntype DatePickerRootContext = {\n  id: Ref<string | undefined>;\n  name: Ref<string | undefined>;\n  minValue: Ref<DateValue | undefined>;\n  maxValue: Ref<DateValue | undefined>;\n  hourCycle: Ref<HourCycle | undefined>;\n  granularity: Ref<Granularity | undefined>;\n  hideTimeZone: Ref<boolean>;\n  required: Ref<boolean>;\n  locale: Ref<string>;\n  dateFieldRef: Ref<InstanceType<typeof DateFieldRoot> | undefined>;\n  modelValue: Ref<DateValue | undefined>;\n  placeholder: Ref<DateValue>;\n  pagedNavigation: Ref<boolean>;\n  preventDeselect: Ref<boolean>;\n  weekStartsOn: Ref<0 | 1 | 2 | 3 | 4 | 5 | 6>;\n  weekdayFormat: Ref<WeekDayFormat>;\n  fixedWeeks: Ref<boolean>;\n  numberOfMonths: Ref<number>;\n  disabled: Ref<boolean>;\n  readonly: Ref<boolean>;\n  isDateDisabled?: Matcher;\n  isDateUnavailable?: Matcher;\n  defaultOpen: Ref<boolean>;\n  open: Ref<boolean>;\n  onDateChange: (date: DateValue | undefined) => void;\n  onPlaceholderChange: (date: DateValue) => void;\n  dir: Ref<Direction>;\n  step: Ref<DateStep | undefined>;\n  closeOnSelect: Ref<boolean>;\n};\n\nexport type DatePickerRootProps = DateFieldRootProps &\n  PopoverRootProps &\n  Pick<\n    CalendarRootProps,\n    | \"isDateDisabled\"\n    | \"pagedNavigation\"\n    | \"weekStartsOn\"\n    | \"weekdayFormat\"\n    | \"fixedWeeks\"\n    | \"numberOfMonths\"\n    | \"preventDeselect\"\n  > & {\n    /** Whether or not to close the popover on date select */\n    closeOnSelect?: boolean;\n  };\n\nexport type DatePickerRootEmits = {\n  /** Event handler called whenever the model value changes */\n  \"update:modelValue\": [date: DateValue | undefined];\n  /** Event handler called whenever the placeholder value changes */\n  \"update:placeholder\": [date: DateValue];\n};\n\nexport const [injectDatePickerRootContext, provideDatePickerRootContext] =\n  createContext<DatePickerRootContext>(\"DatePickerRoot\");\n</script>\n\n<script setup lang=\"ts\">\nimport { useVModel } from \"@vueuse/core\";\n\ndefineOptions({\n  inheritAttrs: false,\n});\nconst props = withDefaults(defineProps<DatePickerRootProps>(), {\n  defaultValue: undefined,\n  defaultOpen: false,\n  open: undefined,\n  pagedNavigation: false,\n  preventDeselect: false,\n  weekStartsOn: 0,\n  weekdayFormat: \"narrow\",\n  fixedWeeks: false,\n  numberOfMonths: 1,\n  disabled: false,\n  readonly: false,\n  placeholder: undefined,\n  locale: \"en\",\n  isDateDisabled: undefined,\n  isDateUnavailable: undefined,\n  closeOnSelect: false,\n});\nconst emits = defineEmits<DatePickerRootEmits & PopoverRootEmits>();\nconst {\n  locale,\n  disabled,\n  readonly,\n  pagedNavigation,\n  weekStartsOn,\n  weekdayFormat,\n  fixedWeeks,\n  numberOfMonths,\n  preventDeselect,\n  isDateDisabled: propsIsDateDisabled,\n  isDateUnavailable: propsIsDateUnavailable,\n  defaultOpen,\n  id,\n  name,\n  required,\n  minValue,\n  maxValue,\n  granularity,\n  hideTimeZone,\n  hourCycle,\n  defaultValue,\n  dir: propDir,\n  step,\n  closeOnSelect,\n} = toRefs(props);\n\nconst dir = useDirection(propDir);\n\nconst modelValue = useVModel(props, \"modelValue\", emits, {\n  defaultValue: defaultValue.value,\n  passive: (props.modelValue === undefined) as false,\n}) as Ref<DateValue | undefined>;\n\nconst defaultDate = computed(() =>\n  getDefaultDate({\n    defaultPlaceholder: props.placeholder,\n    granularity: props.granularity,\n    defaultValue: modelValue.value,\n    locale: props.locale,\n  }),\n);\n\nconst placeholder = useVModel(props, \"placeholder\", emits, {\n  defaultValue: props.defaultPlaceholder ?? defaultDate.value.copy(),\n  passive: (props.placeholder === undefined) as false,\n}) as Ref<DateValue>;\n\nconst open = useVModel(props, \"open\", emits, {\n  defaultValue: defaultOpen.value,\n  passive: (props.open === undefined) as false,\n}) as Ref<boolean>;\n\nconst dateFieldRef = ref<InstanceType<typeof DateFieldRoot> | undefined>();\n\nwatch(modelValue, (value) => {\n  if (value && value.compare(placeholder.value) !== 0) {\n    placeholder.value = value.copy();\n  }\n  if (closeOnSelect.value) {\n    open.value = false;\n  }\n});\n\nprovideDatePickerRootContext({\n  isDateUnavailable: propsIsDateUnavailable.value,\n  isDateDisabled: propsIsDateDisabled.value,\n  locale,\n  disabled,\n  pagedNavigation,\n  weekStartsOn,\n  weekdayFormat,\n  fixedWeeks,\n  numberOfMonths,\n  readonly,\n  preventDeselect,\n  modelValue,\n  placeholder,\n  defaultOpen,\n  open,\n  id,\n  name,\n  required,\n  minValue,\n  maxValue,\n  granularity,\n  hideTimeZone,\n  hourCycle,\n  dateFieldRef,\n  dir,\n  step,\n  onDateChange(date: DateValue | undefined) {\n    if (!date || !modelValue.value) {\n      modelValue.value = date?.copy() ?? undefined;\n    } else if (\n      !preventDeselect.value &&\n      date &&\n      modelValue.value.compare(date) === 0\n    ) {\n      modelValue.value = undefined;\n    } else {\n      modelValue.value = date.copy();\n    }\n  },\n  onPlaceholderChange(date: DateValue) {\n    placeholder.value = date.copy();\n  },\n  closeOnSelect,\n});\n</script>\n\n<template>\n  <PopoverRoot v-model:open=\"open\" :default-open=\"defaultOpen\">\n    <slot />\n  </PopoverRoot>\n</template>\n"],"names":["_createBlock","_unref","PopoverRoot","_renderSlot"],"mappings":";;;;;;;;;;AAuEO,MAAM,CAAC,6BAA6B,4BAA4B,IACrE,cAAqC,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASvD,UAAM,QAAQ;AAkBd,UAAM,QAAQ;AACd,UAAM;AAAA,MACJ;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,gBAAgB;AAAA,MAChB,mBAAmB;AAAA,MACnB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,KAAK;AAAA,MACL;AAAA,MACA;AAAA,IAAA,IACE,OAAO,KAAK;AAEhB,UAAM,MAAM,aAAa,OAAO;AAEhC,UAAM,aAAa,UAAU,OAAO,cAAc,OAAO;AAAA,MACvD,cAAc,aAAa;AAAA,MAC3B,SAAU,MAAM,eAAe;AAAA,IAAA,CAChC;AAED,UAAM,cAAc;AAAA,MAAS,MAC3B,eAAe;AAAA,QACb,oBAAoB,MAAM;AAAA,QAC1B,aAAa,MAAM;AAAA,QACnB,cAAc,WAAW;AAAA,QACzB,QAAQ,MAAM;AAAA,MAAA,CACf;AAAA,IAAA;AAGH,UAAM,cAAc,UAAU,OAAO,eAAe,OAAO;AAAA,MACzD,cAAc,MAAM,sBAAsB,YAAY,MAAM,KAAA;AAAA,MAC5D,SAAU,MAAM,gBAAgB;AAAA,IAAA,CACjC;AAED,UAAM,OAAO,UAAU,OAAO,QAAQ,OAAO;AAAA,MAC3C,cAAc,YAAY;AAAA,MAC1B,SAAU,MAAM,SAAS;AAAA,IAAA,CAC1B;AAED,UAAM,eAAe,IAAA;AAErB,UAAM,YAAY,CAAC,UAAU;AAC3B,UAAI,SAAS,MAAM,QAAQ,YAAY,KAAK,MAAM,GAAG;AACnD,oBAAY,QAAQ,MAAM,KAAA;AAAA,MAC5B;AACA,UAAI,cAAc,OAAO;AACvB,aAAK,QAAQ;AAAA,MACf;AAAA,IACF,CAAC;AAED,iCAA6B;AAAA,MAC3B,mBAAmB,uBAAuB;AAAA,MAC1C,gBAAgB,oBAAoB;AAAA,MACpC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,aAAa,MAA6B;AACxC,YAAI,CAAC,QAAQ,CAAC,WAAW,OAAO;AAC9B,qBAAW,QAAQ,MAAM,KAAA,KAAU;AAAA,QACrC,WACE,CAAC,gBAAgB,SACjB,QACA,WAAW,MAAM,QAAQ,IAAI,MAAM,GACnC;AACA,qBAAW,QAAQ;AAAA,QACrB,OAAO;AACL,qBAAW,QAAQ,KAAK,KAAA;AAAA,QAC1B;AAAA,MACF;AAAA,MACA,oBAAoB,MAAiB;AACnC,oBAAY,QAAQ,KAAK,KAAA;AAAA,MAC3B;AAAA,MACA;AAAA,IAAA,CACD;;0BAICA,YAEcC,MAAAC,WAAA,GAAA;AAAA,QAFO,MAAMD,MAAA,IAAA;AAAA,6EAAA,KAAI,QAAA,SAAA;AAAA,QAAG,gBAAcA,MAAA,WAAA;AAAA,MAAA;yBAC9C,MAAQ;AAAA,UAARE,WAAQ,KAAA,QAAA,SAAA;AAAA,QAAA;;;;;;"}

package/dist/components/DatePicker/DatePickerRoot.vue2.js

@@ -0,0 +1,8 @@
+import _sfc_main from "./DatePickerRoot.vue.js";
+import { injectDatePickerRootContext, provideDatePickerRootContext } from "./DatePickerRoot.vue.js";
+export {
+  _sfc_main as default,
+  injectDatePickerRootContext,
+  provideDatePickerRootContext
+};
+//# sourceMappingURL=DatePickerRoot.vue2.js.map

package/dist/components/DatePicker/DatePickerRoot.vue2.js.map

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

package/dist/components/DatePicker/DatePickerTrigger.d.ts

@@ -0,0 +1,11 @@
+import { PopoverTriggerProps } from '../Popover';
+export type DatePickerTriggerProps = PopoverTriggerProps;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<import('../Primitive').PrimitiveProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('../Primitive').PrimitiveProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DatePicker/DatePickerTrigger.vue.js

@@ -0,0 +1,37 @@
+import { defineComponent, createBlock, openBlock, unref, mergeProps, withCtx, renderSlot } from "vue";
+import "../Primitive/Primitive.js";
+import "../Primitive/Slot.js";
+import "../Presence/Presence.js";
+import "../DismissableLayer/DismissableLayer.vue.js";
+import _sfc_main$1 from "../Popover/PopoverTrigger.vue.js";
+import { injectDatePickerRootContext } from "./DatePickerRoot.vue.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "DatePickerTrigger",
+  props: {
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const rootContext = injectDatePickerRootContext();
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), mergeProps({ "data-reka-date-field-segment": "trigger" }, props, {
+        disabled: unref(rootContext).disabled.value,
+        onFocusin: _cache[0] || (_cache[0] = (e) => {
+          unref(rootContext).dateFieldRef.value?.setFocusedElement(
+            e.target
+          );
+        })
+      }), {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 16, ["disabled"]);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=DatePickerTrigger.vue.js.map

package/dist/components/DatePicker/DatePickerTrigger.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatePickerTrigger.vue.js","sources":["../../../src/components/DatePicker/DatePickerTrigger.vue"],"sourcesContent":["<script lang=\"ts\">\nimport type { PopoverTriggerProps } from \"../Popover\";\nimport { PopoverTrigger } from \"../Popover\";\nimport { injectDatePickerRootContext } from \"./DatePickerRoot.vue\";\n\nexport type DatePickerTriggerProps = PopoverTriggerProps;\n</script>\n\n<script setup lang=\"ts\">\nconst props = defineProps<DatePickerTriggerProps>();\nconst rootContext = injectDatePickerRootContext();\n</script>\n\n<template>\n  <PopoverTrigger\n    data-reka-date-field-segment=\"trigger\"\n    v-bind=\"props\"\n    :disabled=\"rootContext.disabled.value\"\n    @focusin=\"\n      (e: FocusEvent) => {\n        rootContext.dateFieldRef.value?.setFocusedElement(\n          e.target as HTMLElement,\n        );\n      }\n    \"\n  >\n    <slot />\n  </PopoverTrigger>\n</template>\n"],"names":["_openBlock","_createBlock","_unref","_mergeProps","_renderSlot"],"mappings":";;;;;;;;;;;;;;AASA,UAAM,QAAQ;AACd,UAAM,cAAc,4BAAA;;AAIlB,aAAAA,UAAA,GAAAC,YAaiBC,oBAbjBC,WAaiB,EAZf,gCAA6B,UAAA,GACrB,OAAK;AAAA,QACZ,UAAUD,MAAA,WAAA,EAAY,SAAS;AAAA,QAC/B,WAAO,OAAA,CAAA,MAAA,OAAA,CAAA,KAAU,MAAa;AAAeA,gBAAA,WAAA,EAAY,aAAa,OAAO;AAAA,YAA6B,EAAE;AAAA,UAAA;AAAA;;yBAQ7G,MAAQ;AAAA,UAARE,WAAQ,KAAA,QAAA,SAAA;AAAA,QAAA;;;;;;"}

package/dist/components/DatePicker/DatePickerTrigger.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./DatePickerTrigger.vue.js";
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=DatePickerTrigger.vue2.js.map

package/dist/components/DatePicker/DatePickerTrigger.vue2.js.map

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

package/dist/components/DatePicker/DatePickerYearHeading.d.ts

@@ -0,0 +1,13 @@
+import { CalendarYearHeadingProps } from '../Calendar';
+export type DatePickerYearHeadingProps = CalendarYearHeadingProps;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<CalendarYearHeadingProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<CalendarYearHeadingProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {
+        disabled: boolean;
+    }): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DatePicker/DatePickerYearHeading.vue.js

@@ -0,0 +1,27 @@
+import { defineComponent, createBlock, openBlock, unref, normalizeProps, guardReactiveProps, withCtx, renderSlot } from "vue";
+import "../Primitive/Primitive.js";
+import "../Primitive/Slot.js";
+import _sfc_main$1 from "../Calendar/CalendarYearHeading.vue.js";
+import "../DismissableLayer/DismissableLayer.vue.js";
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "DatePickerYearHeading",
+  props: {
+    asChild: { type: Boolean },
+    as: {}
+  },
+  setup(__props) {
+    const props = __props;
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(_sfc_main$1), normalizeProps(guardReactiveProps(props)), {
+        default: withCtx((slotProps) => [
+          renderSlot(_ctx.$slots, "default", normalizeProps(guardReactiveProps(slotProps)))
+        ]),
+        _: 3
+      }, 16);
+    };
+  }
+});
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=DatePickerYearHeading.vue.js.map

package/dist/components/DatePicker/DatePickerYearHeading.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DatePickerYearHeading.vue.js","sources":["../../../src/components/DatePicker/DatePickerYearHeading.vue"],"sourcesContent":["<script lang=\"ts\">\nimport type { CalendarYearHeadingProps } from \"../Calendar\";\nimport { CalendarYearHeading } from \"../Calendar\";\n\nexport type DatePickerYearHeadingProps = CalendarYearHeadingProps;\n</script>\n\n<script setup lang=\"ts\">\nconst props = defineProps<CalendarYearHeadingProps>();\n\n// TODO\n// defineSlots<CalendarNextSlot>();\n</script>\n\n<template>\n  <CalendarYearHeading v-slot=\"slotProps\" v-bind=\"props\">\n    <slot v-bind=\"slotProps\" />\n  </CalendarYearHeading>\n</template>\n"],"names":["_openBlock","_createBlock","_unref","_withCtx","_renderSlot"],"mappings":";;;;;;;;;;;;AAQA,UAAM,QAAQ;;AAOZ,aAAAA,UAAA,GAAAC,YAEsBC,sDAF0B,KAAK,CAAA,GAAA;AAAA,QACnD,SAAAC,QAAA,CAD2B,cAAS;AAAA,UACpCC,WAA2B,0DAAb,SAAS,CAAA,CAAA;AAAA,QAAA;;;;;;"}

package/dist/components/DatePicker/DatePickerYearHeading.vue2.js

@@ -0,0 +1,5 @@
+import _sfc_main from "./DatePickerYearHeading.vue.js";
+export {
+  _sfc_main as default
+};
+//# sourceMappingURL=DatePickerYearHeading.vue2.js.map

package/dist/components/DatePicker/DatePickerYearHeading.vue2.js.map

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

package/dist/components/DatePicker/index.d.ts

@@ -0,0 +1,24 @@
+export { default as DatePickerAnchor } from './DatePickerAnchor';
+export { default as DatePickerArrow } from './DatePickerArrow';
+export { default as DatePickerCalendar } from './DatePickerCalendar';
+export { default as DatePickerCell, type DatePickerCellProps, } from './DatePickerCell';
+export { default as DatePickerCellTrigger, type DatePickerCellTriggerProps, } from './DatePickerCellTrigger';
+export { default as DatePickerClose } from './DatePickerClose';
+export { default as DatePickerContent, type DatePickerContentProps, } from './DatePickerContent';
+export { default as DatePickerField } from './DatePickerField';
+export { default as DatePickerGrid, type DatePickerGridProps, } from './DatePickerGrid';
+export { default as DatePickerGridBody, type DatePickerGridBodyProps, } from './DatePickerGridBody';
+export { default as DatePickerGridHead, type DatePickerGridHeadProps, } from './DatePickerGridHead';
+export { default as DatePickerGridRow, type DatePickerGridRowProps, } from './DatePickerGridRow';
+export { default as DatePickerHeadCell, type DatePickerHeadCellProps, } from './DatePickerHeadCell';
+export { default as DatePickerHeader, type DatePickerHeaderProps, } from './DatePickerHeader';
+export { default as DatePickerHeading, type DatePickerHeadingProps, } from './DatePickerHeading';
+export { default as DatePickerInput, type DatePickerInputProps, } from './DatePickerInput';
+export { default as DatePickerNext, type DatePickerNextProps, } from './DatePickerNext';
+export { default as DatePickerPrev, type DatePickerPrevProps, } from './DatePickerPrev';
+export { default as DatePickerRoot, type DatePickerRootEmits, type DatePickerRootProps, injectDatePickerRootContext, } from './DatePickerRoot';
+export { default as DatePickerTrigger, type DatePickerTriggerProps, } from './DatePickerTrigger';
+export { default as DatePickerMonthHeading, type DatePickerMonthHeadingProps, } from './DatePickerMonthHeading';
+export { default as DatePickerYearHeading, type DatePickerYearHeadingProps, } from './DatePickerYearHeading';
+export { default as DatePickerMonthYearOverlay, type DatePickerMonthYearOverlayProps, } from './DatePickerMonthYearOverlay';
+export { default as DatePickerOverlayItem, type DatePickerOverlayItemProps, } from './DatePickerOverlayItem';

package/dist/components/DismissableLayer/DismissableLayer.d.ts

@@ -0,0 +1,67 @@
+import { FocusOutsideEvent, PointerDownOutsideEvent } from './utils';
+import { PrimitiveProps } from '../Primitive';
+export interface DismissableLayerProps extends PrimitiveProps {
+    /**
+     * When `true`, hover/focus/click interactions will be disabled on elements outside
+     * the `DismissableLayer`. Users will need to click twice on outside elements to
+     * interact with them: once to close the `DismissableLayer`, and again to trigger the element.
+     */
+    disableOutsidePointerEvents?: boolean;
+}
+export type DismissableLayerEmits = {
+    /**
+     * Event handler called when the escape key is down.
+     * Can be prevented.
+     */
+    escapeKeyDown: [event: KeyboardEvent];
+    /**
+     * Event handler called when a `pointerdown` event happens outside of the `DismissableLayer`.
+     * Can be prevented.
+     */
+    pointerDownOutside: [event: PointerDownOutsideEvent];
+    /**
+     * Event handler called when the focus moves outside of the `DismissableLayer`.
+     * Can be prevented.
+     */
+    focusOutside: [event: FocusOutsideEvent];
+    /**
+     * Event handler called when an interaction happens outside the `DismissableLayer`.
+     * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.
+     * Can be prevented.
+     */
+    interactOutside: [event: PointerDownOutsideEvent | FocusOutsideEvent];
+};
+export type DismissableLayerPrivateEmits = DismissableLayerEmits & {
+    /**
+     * Handler called when the `DismissableLayer` should be dismissed
+     */
+    dismiss: [];
+};
+export declare const context: {
+    layersRoot: Set<HTMLElement> & Omit<Set<HTMLElement>, keyof Set<any>>;
+    layersWithOutsidePointerEventsDisabled: Set<HTMLElement> & Omit<Set<HTMLElement>, keyof Set<any>>;
+    branches: Set<HTMLElement> & Omit<Set<HTMLElement>, keyof Set<any>>;
+};
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<DismissableLayerProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    escapeKeyDown: (event: KeyboardEvent) => any;
+    pointerDownOutside: (event: PointerDownOutsideEvent) => any;
+    focusOutside: (event: FocusOutsideEvent) => any;
+    interactOutside: (event: PointerDownOutsideEvent | FocusOutsideEvent) => any;
+    dismiss: () => any;
+}, string, import('vue').PublicProps, Readonly<DismissableLayerProps> & Readonly<{
+    onEscapeKeyDown?: ((event: KeyboardEvent) => any) | undefined;
+    onPointerDownOutside?: ((event: PointerDownOutsideEvent) => any) | undefined;
+    onFocusOutside?: ((event: FocusOutsideEvent) => any) | undefined;
+    onInteractOutside?: ((event: PointerDownOutsideEvent | FocusOutsideEvent) => any) | undefined;
+    onDismiss?: (() => any) | undefined;
+}>, {
+    disableOutsidePointerEvents: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DismissableLayer/DismissableLayer.vue.js

@@ -0,0 +1,118 @@
+import { reactive, defineComponent, computed, watchEffect, createBlock, openBlock, unref, normalizeStyle, withCtx, renderSlot, nextTick } from "vue";
+import { onKeyStroke } from "../../node_modules/.pnpm/@vueuse_core@14.1.0_vue@3.5.26_typescript@5.9.3_/node_modules/@vueuse/core/dist/index.js";
+import { Primitive } from "../Primitive/Primitive.js";
+import "../Primitive/Slot.js";
+import { usePointerDownOutside, useFocusOutside } from "./utils.js";
+import { useForwardExpose } from "../../shared/useForwardExpose.js";
+const context = reactive({
+  layersRoot: /* @__PURE__ */ new Set(),
+  layersWithOutsidePointerEventsDisabled: /* @__PURE__ */ new Set(),
+  branches: /* @__PURE__ */ new Set()
+});
+const _sfc_main = /* @__PURE__ */ defineComponent({
+  __name: "DismissableLayer",
+  props: {
+    disableOutsidePointerEvents: { type: Boolean, default: false },
+    asChild: { type: Boolean },
+    as: {}
+  },
+  emits: ["escapeKeyDown", "pointerDownOutside", "focusOutside", "interactOutside", "dismiss"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emits = __emit;
+    const { forwardRef, currentElement: layerElement } = useForwardExpose();
+    const ownerDocument = computed(
+      () => layerElement.value?.ownerDocument ?? globalThis.document
+    );
+    const layers = computed(() => context.layersRoot);
+    const index = computed(() => {
+      return layerElement.value ? Array.from(layers.value).indexOf(layerElement.value) : -1;
+    });
+    const isBodyPointerEventsDisabled = computed(() => {
+      return context.layersWithOutsidePointerEventsDisabled.size > 0;
+    });
+    const isPointerEventsEnabled = computed(() => {
+      const localLayers = Array.from(layers.value);
+      const [highestLayerWithOutsidePointerEventsDisabled] = [
+        ...context.layersWithOutsidePointerEventsDisabled
+      ].slice(-1);
+      const highestLayerWithOutsidePointerEventsDisabledIndex = localLayers.indexOf(
+        highestLayerWithOutsidePointerEventsDisabled
+      );
+      return index.value >= highestLayerWithOutsidePointerEventsDisabledIndex;
+    });
+    const pointerDownOutside = usePointerDownOutside(async (event) => {
+      const isPointerDownOnBranch = [...context.branches].some(
+        (branch) => branch?.contains(event.target)
+      );
+      if (!isPointerEventsEnabled.value || isPointerDownOnBranch) return;
+      emits("pointerDownOutside", event);
+      emits("interactOutside", event);
+      await nextTick();
+      if (!event.defaultPrevented) emits("dismiss");
+    }, layerElement);
+    const focusOutside = useFocusOutside((event) => {
+      const isFocusInBranch = [...context.branches].some(
+        (branch) => branch?.contains(event.target)
+      );
+      if (isFocusInBranch) return;
+      emits("focusOutside", event);
+      emits("interactOutside", event);
+      if (!event.defaultPrevented) emits("dismiss");
+    }, layerElement);
+    onKeyStroke("Escape", (event) => {
+      const isHighestLayer = index.value === layers.value.size - 1;
+      if (!isHighestLayer) return;
+      emits("escapeKeyDown", event);
+      if (!event.defaultPrevented) emits("dismiss");
+    });
+    let originalBodyPointerEvents;
+    watchEffect((cleanupFn) => {
+      if (!layerElement.value) return;
+      if (props.disableOutsidePointerEvents) {
+        if (context.layersWithOutsidePointerEventsDisabled.size === 0) {
+          originalBodyPointerEvents = ownerDocument.value.body.style.pointerEvents;
+          ownerDocument.value.body.style.pointerEvents = "none";
+        }
+        context.layersWithOutsidePointerEventsDisabled.add(layerElement.value);
+      }
+      layers.value.add(layerElement.value);
+      cleanupFn(() => {
+        if (props.disableOutsidePointerEvents && context.layersWithOutsidePointerEventsDisabled.size === 1) {
+          ownerDocument.value.body.style.pointerEvents = originalBodyPointerEvents;
+        }
+      });
+    });
+    watchEffect((cleanupFn) => {
+      cleanupFn(() => {
+        if (!layerElement.value) return;
+        layers.value.delete(layerElement.value);
+        context.layersWithOutsidePointerEventsDisabled.delete(layerElement.value);
+      });
+    });
+    return (_ctx, _cache) => {
+      return openBlock(), createBlock(unref(Primitive), {
+        ref: unref(forwardRef),
+        "as-child": __props.asChild,
+        as: __props.as,
+        "data-dismissable-layer": "",
+        style: normalizeStyle({
+          pointerEvents: isBodyPointerEventsDisabled.value ? isPointerEventsEnabled.value ? "auto" : "none" : void 0
+        }),
+        onFocusCapture: unref(focusOutside).onFocusCapture,
+        onBlurCapture: unref(focusOutside).onBlurCapture,
+        onPointerdownCapture: unref(pointerDownOutside).onPointerDownCapture
+      }, {
+        default: withCtx(() => [
+          renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["as-child", "as", "style", "onFocusCapture", "onBlurCapture", "onPointerdownCapture"]);
+    };
+  }
+});
+export {
+  context,
+  _sfc_main as default
+};
+//# sourceMappingURL=DismissableLayer.vue.js.map

package/dist/components/DismissableLayer/DismissableLayer.vue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DismissableLayer.vue.js","sources":["../../../src/components/DismissableLayer/DismissableLayer.vue"],"sourcesContent":["<script lang=\"ts\">\nimport type { FocusOutsideEvent, PointerDownOutsideEvent } from \"./utils\";\n\nimport type { PrimitiveProps } from \"../Primitive\";\nimport { computed, nextTick, reactive, watchEffect } from \"vue\";\nimport { useForwardExpose } from \"../../shared\";\n\nexport interface DismissableLayerProps extends PrimitiveProps {\n  /**\n   * When `true`, hover/focus/click interactions will be disabled on elements outside\n   * the `DismissableLayer`. Users will need to click twice on outside elements to\n   * interact with them: once to close the `DismissableLayer`, and again to trigger the element.\n   */\n  disableOutsidePointerEvents?: boolean;\n}\n\nexport type DismissableLayerEmits = {\n  /**\n   * Event handler called when the escape key is down.\n   * Can be prevented.\n   */\n  escapeKeyDown: [event: KeyboardEvent];\n  /**\n   * Event handler called when a `pointerdown` event happens outside of the `DismissableLayer`.\n   * Can be prevented.\n   */\n  pointerDownOutside: [event: PointerDownOutsideEvent];\n  /**\n   * Event handler called when the focus moves outside of the `DismissableLayer`.\n   * Can be prevented.\n   */\n  focusOutside: [event: FocusOutsideEvent];\n  /**\n   * Event handler called when an interaction happens outside the `DismissableLayer`.\n   * Specifically, when a `pointerdown` event happens outside or focus moves outside of it.\n   * Can be prevented.\n   */\n  interactOutside: [event: PointerDownOutsideEvent | FocusOutsideEvent];\n};\n\nexport type DismissableLayerPrivateEmits = DismissableLayerEmits & {\n  /**\n   * Handler called when the `DismissableLayer` should be dismissed\n   */\n  dismiss: [];\n};\n\nexport const context = reactive({\n  layersRoot: new Set<HTMLElement>(),\n  layersWithOutsidePointerEventsDisabled: new Set<HTMLElement>(),\n  branches: new Set<HTMLElement>(),\n});\n</script>\n\n<script setup lang=\"ts\">\nimport { onKeyStroke } from \"@vueuse/core\";\nimport { Primitive } from \"../Primitive\";\nimport { useFocusOutside, usePointerDownOutside } from \"./utils\";\n\nconst props = withDefaults(defineProps<DismissableLayerProps>(), {\n  disableOutsidePointerEvents: false,\n});\n\nconst emits = defineEmits<DismissableLayerPrivateEmits>();\n\nconst { forwardRef, currentElement: layerElement } = useForwardExpose();\nconst ownerDocument = computed(\n  () => layerElement.value?.ownerDocument ?? globalThis.document,\n);\n\nconst layers = computed(() => context.layersRoot);\n\nconst index = computed(() => {\n  return layerElement.value\n    ? Array.from(layers.value).indexOf(layerElement.value)\n    : -1;\n});\n\nconst isBodyPointerEventsDisabled = computed(() => {\n  return context.layersWithOutsidePointerEventsDisabled.size > 0;\n});\n\nconst isPointerEventsEnabled = computed(() => {\n  const localLayers = Array.from(layers.value);\n  const [highestLayerWithOutsidePointerEventsDisabled] = [\n    ...context.layersWithOutsidePointerEventsDisabled,\n  ].slice(-1);\n  const highestLayerWithOutsidePointerEventsDisabledIndex = localLayers.indexOf(\n    highestLayerWithOutsidePointerEventsDisabled,\n  );\n\n  return index.value >= highestLayerWithOutsidePointerEventsDisabledIndex;\n});\n\nconst pointerDownOutside = usePointerDownOutside(async (event) => {\n  const isPointerDownOnBranch = [...context.branches].some((branch) =>\n    branch?.contains(event.target as HTMLElement),\n  );\n\n  if (!isPointerEventsEnabled.value || isPointerDownOnBranch) return;\n  emits(\"pointerDownOutside\", event);\n  emits(\"interactOutside\", event);\n  await nextTick();\n  if (!event.defaultPrevented) emits(\"dismiss\");\n}, layerElement);\n\nconst focusOutside = useFocusOutside((event) => {\n  const isFocusInBranch = [...context.branches].some((branch) =>\n    branch?.contains(event.target as HTMLElement),\n  );\n\n  if (isFocusInBranch) return;\n  emits(\"focusOutside\", event);\n  emits(\"interactOutside\", event);\n  if (!event.defaultPrevented) emits(\"dismiss\");\n}, layerElement);\n\nonKeyStroke(\"Escape\", (event) => {\n  const isHighestLayer = index.value === layers.value.size - 1;\n  if (!isHighestLayer) return;\n  emits(\"escapeKeyDown\", event);\n  if (!event.defaultPrevented) emits(\"dismiss\");\n});\n\nlet originalBodyPointerEvents: string;\nwatchEffect((cleanupFn) => {\n  if (!layerElement.value) return;\n  if (props.disableOutsidePointerEvents) {\n    if (context.layersWithOutsidePointerEventsDisabled.size === 0) {\n      originalBodyPointerEvents = ownerDocument.value.body.style.pointerEvents;\n      ownerDocument.value.body.style.pointerEvents = \"none\";\n    }\n    context.layersWithOutsidePointerEventsDisabled.add(layerElement.value);\n  }\n  layers.value.add(layerElement.value);\n\n  cleanupFn(() => {\n    if (\n      props.disableOutsidePointerEvents &&\n      context.layersWithOutsidePointerEventsDisabled.size === 1\n    ) {\n      ownerDocument.value.body.style.pointerEvents = originalBodyPointerEvents;\n    }\n  });\n});\n\nwatchEffect((cleanupFn) => {\n  cleanupFn(() => {\n    if (!layerElement.value) return;\n    layers.value.delete(layerElement.value);\n    context.layersWithOutsidePointerEventsDisabled.delete(layerElement.value);\n  });\n});\n</script>\n\n<template>\n  <Primitive\n    :ref=\"forwardRef\"\n    :as-child=\"asChild\"\n    :as=\"as\"\n    data-dismissable-layer\n    :style=\"{\n      pointerEvents: isBodyPointerEventsDisabled\n        ? isPointerEventsEnabled\n          ? 'auto'\n          : 'none'\n        : undefined,\n    }\"\n    @focus.capture=\"focusOutside.onFocusCapture\"\n    @blur.capture=\"focusOutside.onBlurCapture\"\n    @pointerdown.capture=\"pointerDownOutside.onPointerDownCapture\"\n  >\n    <slot />\n  </Primitive>\n</template>\n"],"names":["_createBlock","_unref","_normalizeStyle","_renderSlot"],"mappings":"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"}

package/dist/components/DismissableLayer/DismissableLayer.vue2.js

@@ -0,0 +1,7 @@
+import _sfc_main from "./DismissableLayer.vue.js";
+import { context } from "./DismissableLayer.vue.js";
+export {
+  context,
+  _sfc_main as default
+};
+//# sourceMappingURL=DismissableLayer.vue2.js.map

package/dist/components/DismissableLayer/DismissableLayer.vue2.js.map

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

package/dist/components/DismissableLayer/DismissableLayerBranch.d.ts

@@ -0,0 +1,11 @@
+import { PrimitiveProps } from '../Primitive';
+export type DismissableLayerBranchProps = PrimitiveProps;
+declare const _default: __VLS_WithTemplateSlots<import('vue').DefineComponent<PrimitiveProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<PrimitiveProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/DismissableLayer/index.d.ts

@@ -0,0 +1,3 @@
+export { default as DismissableLayer, type DismissableLayerEmits, type DismissableLayerProps, } from './DismissableLayer';
+export { default as DismissableLayerBranch } from './DismissableLayerBranch';
+export { type FocusOutsideEvent, type PointerDownOutsideEvent, useFocusOutside, usePointerDownOutside } from './utils';

package/dist/components/DismissableLayer/utils.d.ts

@@ -0,0 +1,28 @@
+import { MaybeRefOrGetter, Ref } from 'vue';
+export type PointerDownOutsideEvent = CustomEvent<{
+    originalEvent: PointerEvent;
+}>;
+export type FocusOutsideEvent = CustomEvent<{
+    originalEvent: FocusEvent;
+}>;
+export declare const DISMISSABLE_LAYER_NAME = "DismissableLayer";
+export declare const CONTEXT_UPDATE = "dismissableLayer.update";
+export declare const POINTER_DOWN_OUTSIDE = "dismissableLayer.pointerDownOutside";
+export declare const FOCUS_OUTSIDE = "dismissableLayer.focusOutside";
+/**
+ * Listens for `pointerdown` outside a DOM subtree. We use `pointerdown` rather than `pointerup`
+ * to mimic layer dismissing behaviour present in OS.
+ * Returns props to pass to the node we want to check for outside events.
+ */
+export declare function usePointerDownOutside(onPointerDownOutside?: (event: PointerDownOutsideEvent) => void, element?: Ref<HTMLElement | undefined>, enabled?: MaybeRefOrGetter<boolean>): {
+    onPointerDownCapture: () => void;
+};
+/**
+ * Listens for when focus happens outside a DOM subtree.
+ * Returns props to pass to the root (node) of the subtree we want to check.
+ */
+export declare function useFocusOutside(onFocusOutside?: (event: FocusOutsideEvent) => void, element?: Ref<HTMLElement | undefined>, enabled?: MaybeRefOrGetter<boolean>): {
+    onFocusCapture: () => void;
+    onBlurCapture: () => void;
+};
+export declare function dispatchUpdate(): void;