@rupe/v-datepicker 1.0.0-alpha.0

package/dist/shared/useFocusGuards.js

@@ -0,0 +1,39 @@
+import { isClient } from "../node_modules/.pnpm/@vueuse_shared@14.1.0_vue@3.5.26_typescript@5.9.3_/node_modules/@vueuse/shared/dist/index.js";
+import { watchEffect } from "vue";
+let count = 0;
+function useFocusGuards() {
+  watchEffect((cleanupFn) => {
+    if (!isClient)
+      return;
+    const edgeGuards = document.querySelectorAll("[data-reka-focus-guard]");
+    document.body.insertAdjacentElement(
+      "afterbegin",
+      edgeGuards[0] ?? createFocusGuard()
+    );
+    document.body.insertAdjacentElement(
+      "beforeend",
+      edgeGuards[1] ?? createFocusGuard()
+    );
+    count++;
+    cleanupFn(() => {
+      if (count === 1) {
+        document.querySelectorAll("[data-reka-focus-guard]").forEach((node) => node.remove());
+      }
+      count--;
+    });
+  });
+}
+function createFocusGuard() {
+  const element = document.createElement("span");
+  element.setAttribute("data-reka-focus-guard", "");
+  element.tabIndex = 0;
+  element.style.outline = "none";
+  element.style.opacity = "0";
+  element.style.position = "fixed";
+  element.style.pointerEvents = "none";
+  return element;
+}
+export {
+  useFocusGuards
+};
+//# sourceMappingURL=useFocusGuards.js.map

package/dist/shared/useFocusGuards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFocusGuards.js","sources":["../../src/shared/useFocusGuards.ts"],"sourcesContent":["import { isClient } from '@vueuse/shared'\nimport { watchEffect } from 'vue'\n\n/** Number of components which have requested interest to have focus guards */\nlet count = 0\n\n/**\n * Injects a pair of focus guards at the edges of the whole DOM tree\n * to ensure `focusin` & `focusout` events can be caught consistently.\n */\nexport function useFocusGuards() {\n  watchEffect((cleanupFn) => {\n    if (!isClient)\n      return\n    const edgeGuards = document.querySelectorAll('[data-reka-focus-guard]')\n    document.body.insertAdjacentElement(\n      'afterbegin',\n      edgeGuards[0] ?? createFocusGuard(),\n    )\n    document.body.insertAdjacentElement(\n      'beforeend',\n      edgeGuards[1] ?? createFocusGuard(),\n    )\n    count++\n\n    cleanupFn(() => {\n      if (count === 1) {\n        document\n          .querySelectorAll('[data-reka-focus-guard]')\n          .forEach(node => node.remove())\n      }\n      count--\n    })\n  })\n}\n\nfunction createFocusGuard() {\n  const element = document.createElement('span')\n  element.setAttribute('data-reka-focus-guard', '')\n  element.tabIndex = 0\n  element.style.outline = 'none'\n  element.style.opacity = '0'\n  element.style.position = 'fixed'\n  element.style.pointerEvents = 'none'\n  return element\n}\n"],"names":[],"mappings":";;AAIA,IAAI,QAAQ;AAML,SAAS,iBAAiB;AAC/B,cAAY,CAAC,cAAc;AACzB,QAAI,CAAC;AACH;AACF,UAAM,aAAa,SAAS,iBAAiB,yBAAyB;AACtE,aAAS,KAAK;AAAA,MACZ;AAAA,MACA,WAAW,CAAC,KAAK,iBAAA;AAAA,IAAiB;AAEpC,aAAS,KAAK;AAAA,MACZ;AAAA,MACA,WAAW,CAAC,KAAK,iBAAA;AAAA,IAAiB;AAEpC;AAEA,cAAU,MAAM;AACd,UAAI,UAAU,GAAG;AACf,iBACG,iBAAiB,yBAAyB,EAC1C,QAAQ,CAAA,SAAQ,KAAK,QAAQ;AAAA,MAClC;AACA;AAAA,IACF,CAAC;AAAA,EACH,CAAC;AACH;AAEA,SAAS,mBAAmB;AAC1B,QAAM,UAAU,SAAS,cAAc,MAAM;AAC7C,UAAQ,aAAa,yBAAyB,EAAE;AAChD,UAAQ,WAAW;AACnB,UAAQ,MAAM,UAAU;AACxB,UAAQ,MAAM,UAAU;AACxB,UAAQ,MAAM,WAAW;AACzB,UAAQ,MAAM,gBAAgB;AAC9B,SAAO;AACT;"}

package/dist/shared/useForwardExpose.d.ts

@@ -0,0 +1,6 @@
+import { ComponentPublicInstance } from 'vue';
+export declare function useForwardExpose<T extends ComponentPublicInstance>(): {
+    forwardRef: (ref: Element | T | null) => void;
+    currentRef: import('vue').Ref<Element | T | null | undefined, Element | T | null | undefined>;
+    currentElement: import('vue').ComputedRef<HTMLElement>;
+};

package/dist/shared/useForwardExpose.js

@@ -0,0 +1,49 @@
+import { unrefElement } 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 { getCurrentInstance, ref, computed } from "vue";
+function useForwardExpose() {
+  const instance = getCurrentInstance();
+  const currentRef = ref();
+  const currentElement = computed(() => {
+    return ["#text", "#comment"].includes(currentRef.value?.$el.nodeName) ? currentRef.value?.$el.nextElementSibling : unrefElement(currentRef);
+  });
+  const localExpose = Object.assign({}, instance.exposed);
+  const ret = {};
+  for (const key in instance.props) {
+    Object.defineProperty(ret, key, {
+      enumerable: true,
+      configurable: true,
+      get: () => instance.props[key]
+    });
+  }
+  if (Object.keys(localExpose).length > 0) {
+    for (const key in localExpose) {
+      Object.defineProperty(ret, key, {
+        enumerable: true,
+        configurable: true,
+        get: () => localExpose[key]
+      });
+    }
+  }
+  Object.defineProperty(ret, "$el", {
+    enumerable: true,
+    configurable: true,
+    get: () => instance.vnode.el
+  });
+  instance.exposed = ret;
+  function forwardRef(ref2) {
+    currentRef.value = ref2;
+    if (!ref2)
+      return;
+    Object.defineProperty(ret, "$el", {
+      enumerable: true,
+      configurable: true,
+      get: () => ref2 instanceof Element ? ref2 : ref2.$el
+    });
+    instance.exposed = ret;
+  }
+  return { forwardRef, currentRef, currentElement };
+}
+export {
+  useForwardExpose
+};
+//# sourceMappingURL=useForwardExpose.js.map

package/dist/shared/useForwardExpose.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useForwardExpose.js","sources":["../../src/shared/useForwardExpose.ts"],"sourcesContent":["import type { ComponentPublicInstance } from 'vue'\n// reference: https://github.com/vuejs/rfcs/issues/258#issuecomment-1068697672\nimport { unrefElement } from '@vueuse/core'\nimport { computed, getCurrentInstance, ref } from 'vue'\n\nexport function useForwardExpose<T extends ComponentPublicInstance>() {\n  const instance = getCurrentInstance()!\n\n  const currentRef = ref<Element | T | null>()\n  const currentElement = computed<HTMLElement>(() => {\n    // $el could be text/comment for non-single root normal or text root, thus we retrieve the nextElementSibling\n    // @ts-expect-error ignore ts error\n    return ['#text', '#comment'].includes(currentRef.value?.$el.nodeName) ? currentRef.value?.$el.nextElementSibling : unrefElement(currentRef)\n  })\n\n  // Do give us credit if you reference our code :D\n  // localExpose should only be assigned once else will create infinite loop\n  const localExpose: Record<string, any> | null = Object.assign({}, instance.exposed)\n  const ret: Record<string, any> = {}\n\n  // retrieve props for current instance\n  for (const key in instance.props) {\n    Object.defineProperty(ret, key, {\n      enumerable: true,\n      configurable: true,\n      get: () => instance.props[key],\n    })\n  }\n\n  // retrieve default exposed value\n  if (Object.keys(localExpose).length > 0) {\n    for (const key in localExpose) {\n      Object.defineProperty(ret, key, {\n        enumerable: true,\n        configurable: true,\n        get: () => localExpose![key],\n      })\n    }\n  }\n\n  // retrieve original first root element\n  Object.defineProperty(ret, '$el', {\n    enumerable: true,\n    configurable: true,\n    get: () => instance.vnode.el,\n  })\n  instance.exposed = ret\n\n  function forwardRef(ref: Element | T | null) {\n    currentRef.value = ref\n\n    if (!ref)\n      return\n\n    // retrieve the forwarded element\n    Object.defineProperty(ret, '$el', {\n      enumerable: true,\n      configurable: true,\n      get: () => (ref instanceof Element ? ref : ref.$el),\n    })\n\n    instance.exposed = ret\n  }\n\n  return { forwardRef, currentRef, currentElement }\n}\n"],"names":["ref"],"mappings":";;AAKO,SAAS,mBAAsD;AACpE,QAAM,WAAW,mBAAA;AAEjB,QAAM,aAAa,IAAA;AACnB,QAAM,iBAAiB,SAAsB,MAAM;AAGjD,WAAO,CAAC,SAAS,UAAU,EAAE,SAAS,WAAW,OAAO,IAAI,QAAQ,IAAI,WAAW,OAAO,IAAI,qBAAqB,aAAa,UAAU;AAAA,EAC5I,CAAC;AAID,QAAM,cAA0C,OAAO,OAAO,CAAA,GAAI,SAAS,OAAO;AAClF,QAAM,MAA2B,CAAA;AAGjC,aAAW,OAAO,SAAS,OAAO;AAChC,WAAO,eAAe,KAAK,KAAK;AAAA,MAC9B,YAAY;AAAA,MACZ,cAAc;AAAA,MACd,KAAK,MAAM,SAAS,MAAM,GAAG;AAAA,IAAA,CAC9B;AAAA,EACH;AAGA,MAAI,OAAO,KAAK,WAAW,EAAE,SAAS,GAAG;AACvC,eAAW,OAAO,aAAa;AAC7B,aAAO,eAAe,KAAK,KAAK;AAAA,QAC9B,YAAY;AAAA,QACZ,cAAc;AAAA,QACd,KAAK,MAAM,YAAa,GAAG;AAAA,MAAA,CAC5B;AAAA,IACH;AAAA,EACF;AAGA,SAAO,eAAe,KAAK,OAAO;AAAA,IAChC,YAAY;AAAA,IACZ,cAAc;AAAA,IACd,KAAK,MAAM,SAAS,MAAM;AAAA,EAAA,CAC3B;AACD,WAAS,UAAU;AAEnB,WAAS,WAAWA,MAAyB;AAC3C,eAAW,QAAQA;AAEnB,QAAI,CAACA;AACH;AAGF,WAAO,eAAe,KAAK,OAAO;AAAA,MAChC,YAAY;AAAA,MACZ,cAAc;AAAA,MACd,KAAK,MAAOA,gBAAe,UAAUA,OAAMA,KAAI;AAAA,IAAA,CAChD;AAED,aAAS,UAAU;AAAA,EACrB;AAEA,SAAO,EAAE,YAAY,YAAY,eAAA;AACnC;"}

package/dist/shared/useForwardProps.d.ts

@@ -0,0 +1,9 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * The `useForwardProps` function in TypeScript takes in a set of props and returns a computed value
+ * that combines default props with assigned props from the current instance.
+ * @param {T} props - The `props` parameter is an object that represents the props passed to a
+ * component.
+ * @returns computed value that combines the default props, preserved props, and assigned props.
+ */
+export declare function useForwardProps<T extends Record<string, any>>(props: MaybeRefOrGetter<T>): import('vue').ComputedRef<T>;

package/dist/shared/useForwardProps.js

@@ -0,0 +1,27 @@
+import { getCurrentInstance, toRef, computed, camelize } from "vue";
+function useForwardProps(props) {
+  const vm = getCurrentInstance();
+  const defaultProps = Object.keys(vm?.type.props ?? {}).reduce((prev, curr) => {
+    const defaultValue = (vm?.type.props[curr]).default;
+    if (defaultValue !== void 0)
+      prev[curr] = defaultValue;
+    return prev;
+  }, {});
+  const refProps = toRef(props);
+  return computed(() => {
+    const preservedProps = {};
+    const assignedProps = vm?.vnode.props ?? {};
+    Object.keys(assignedProps).forEach((key) => {
+      preservedProps[camelize(key)] = assignedProps[key];
+    });
+    return Object.keys({ ...defaultProps, ...preservedProps }).reduce((prev, curr) => {
+      if (refProps.value[curr] !== void 0)
+        prev[curr] = refProps.value[curr];
+      return prev;
+    }, {});
+  });
+}
+export {
+  useForwardProps
+};
+//# sourceMappingURL=useForwardProps.js.map

package/dist/shared/useForwardProps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useForwardProps.js","sources":["../../src/shared/useForwardProps.ts"],"sourcesContent":["import type { MaybeRefOrGetter } from 'vue'\nimport { camelize, computed, getCurrentInstance, toRef } from 'vue'\n\ninterface PropOptions {\n  type?: any\n  required?: boolean\n  default?: any\n}\n\n/**\n * The `useForwardProps` function in TypeScript takes in a set of props and returns a computed value\n * that combines default props with assigned props from the current instance.\n * @param {T} props - The `props` parameter is an object that represents the props passed to a\n * component.\n * @returns computed value that combines the default props, preserved props, and assigned props.\n */\nexport function useForwardProps<T extends Record<string, any>>(props: MaybeRefOrGetter<T>) {\n  const vm = getCurrentInstance()\n  // Default value for declared props\n  const defaultProps = Object.keys(vm?.type.props ?? {}).reduce((prev, curr) => {\n    const defaultValue = (vm?.type.props[curr] as PropOptions).default\n    if (defaultValue !== undefined)\n      prev[curr as keyof T] = defaultValue\n    return prev\n  }, {} as T)\n\n  const refProps = toRef(props)\n  return computed(() => {\n    const preservedProps = {} as T\n    const assignedProps = vm?.vnode.props ?? {}\n\n    Object.keys(assignedProps).forEach((key) => {\n      preservedProps[camelize(key) as keyof T] = assignedProps[key]\n    })\n\n    // Only return value from the props parameter\n    return Object.keys({ ...defaultProps, ...preservedProps }).reduce((prev, curr) => {\n      if (refProps.value[curr] !== undefined)\n        prev[curr as keyof T] = refProps.value[curr]\n      return prev\n    }, {} as T)\n  })\n}\n"],"names":[],"mappings":";AAgBO,SAAS,gBAA+C,OAA4B;AACzF,QAAM,KAAK,mBAAA;AAEX,QAAM,eAAe,OAAO,KAAK,IAAI,KAAK,SAAS,CAAA,CAAE,EAAE,OAAO,CAAC,MAAM,SAAS;AAC5E,UAAM,gBAAgB,IAAI,KAAK,MAAM,IAAI,GAAkB;AAC3D,QAAI,iBAAiB;AACnB,WAAK,IAAe,IAAI;AAC1B,WAAO;AAAA,EACT,GAAG,CAAA,CAAO;AAEV,QAAM,WAAW,MAAM,KAAK;AAC5B,SAAO,SAAS,MAAM;AACpB,UAAM,iBAAiB,CAAA;AACvB,UAAM,gBAAgB,IAAI,MAAM,SAAS,CAAA;AAEzC,WAAO,KAAK,aAAa,EAAE,QAAQ,CAAC,QAAQ;AAC1C,qBAAe,SAAS,GAAG,CAAY,IAAI,cAAc,GAAG;AAAA,IAC9D,CAAC;AAGD,WAAO,OAAO,KAAK,EAAE,GAAG,cAAc,GAAG,eAAA,CAAgB,EAAE,OAAO,CAAC,MAAM,SAAS;AAChF,UAAI,SAAS,MAAM,IAAI,MAAM;AAC3B,aAAK,IAAe,IAAI,SAAS,MAAM,IAAI;AAC7C,aAAO;AAAA,IACT,GAAG,CAAA,CAAO;AAAA,EACZ,CAAC;AACH;"}

package/dist/shared/useForwardPropsEmits.d.ts

@@ -0,0 +1,14 @@
+import { MaybeRefOrGetter } from 'vue';
+/**
+ * The function `useForwardPropsEmits` takes in props and an optional emit function, and returns a
+ * computed object that combines the parsed props and emits as props.
+ * @param {T} props - The `props` parameter is of type `T`, which is a generic type that extends the
+ * parameters of the `useForwardProps` function. It represents the props object that is passed to the
+ * `useForwardProps` function.
+ * @param [emit] - The `emit` parameter is a function that can be used to emit events. It takes two
+ * arguments: `name`, which is the name of the event to be emitted, and `args`, which are the arguments
+ * to be passed along with the event.
+ * @returns a computed property that combines the parsed
+ * props and emits as props.
+ */
+export declare function useForwardPropsEmits<T extends Record<string, any>, Name extends string>(props: MaybeRefOrGetter<T>, emit?: (name: Name, ...args: any[]) => void): import('vue').ComputedRef<T & Record<string, any>>;

package/dist/shared/useForwardPropsEmits.js

@@ -0,0 +1,15 @@
+import { computed } from "vue";
+import { useEmitAsProps } from "./useEmitAsProps.js";
+import { useForwardProps } from "./useForwardProps.js";
+function useForwardPropsEmits(props, emit) {
+  const parsedProps = useForwardProps(props);
+  const emitsAsProps = emit ? useEmitAsProps(emit) : {};
+  return computed(() => ({
+    ...parsedProps.value,
+    ...emitsAsProps
+  }));
+}
+export {
+  useForwardPropsEmits
+};
+//# sourceMappingURL=useForwardPropsEmits.js.map

package/dist/shared/useForwardPropsEmits.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useForwardPropsEmits.js","sources":["../../src/shared/useForwardPropsEmits.ts"],"sourcesContent":["import type { MaybeRefOrGetter } from 'vue'\nimport { computed } from 'vue'\nimport { useEmitAsProps } from './useEmitAsProps'\nimport { useForwardProps } from './useForwardProps'\n\n/**\n * The function `useForwardPropsEmits` takes in props and an optional emit function, and returns a\n * computed object that combines the parsed props and emits as props.\n * @param {T} props - The `props` parameter is of type `T`, which is a generic type that extends the\n * parameters of the `useForwardProps` function. It represents the props object that is passed to the\n * `useForwardProps` function.\n * @param [emit] - The `emit` parameter is a function that can be used to emit events. It takes two\n * arguments: `name`, which is the name of the event to be emitted, and `args`, which are the arguments\n * to be passed along with the event.\n * @returns a computed property that combines the parsed\n * props and emits as props.\n */\nexport function useForwardPropsEmits<T extends Record<string, any>, Name extends string>(props: MaybeRefOrGetter<T>, emit?: (name: Name, ...args: any[]) => void) {\n  const parsedProps = useForwardProps(props)\n  const emitsAsProps = emit ? useEmitAsProps(emit) : {}\n\n  return computed(() => ({\n    ...parsedProps.value,\n    ...emitsAsProps,\n  }))\n}\n"],"names":[],"mappings":";;;AAiBO,SAAS,qBAAyE,OAA4B,MAA6C;AAChK,QAAM,cAAc,gBAAgB,KAAK;AACzC,QAAM,eAAe,OAAO,eAAe,IAAI,IAAI,CAAA;AAEnD,SAAO,SAAS,OAAO;AAAA,IACrB,GAAG,YAAY;AAAA,IACf,GAAG;AAAA,EAAA,EACH;AACJ;"}

package/dist/shared/useId.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The `useId` function generates a unique identifier using a provided deterministic ID or a default
+ * one prefixed with "reka-", or the provided one via `useId` props from `<ConfigProvider>`.
+ * @param {string | null | undefined} [deterministicId] - The `useId` function you provided takes an
+ * optional parameter `deterministicId`, which can be a string, null, or undefined. If
+ * `deterministicId` is provided, the function will return it. Otherwise, it will generate an id using
+ * the `useId` function obtained
+ */
+export declare function useId(deterministicId?: string | null | undefined, prefix?: string): string;

package/dist/shared/useId.js

@@ -0,0 +1,19 @@
+import * as vue from "vue";
+import { injectConfigProviderContext } from "../components/ConfigProvider/ConfigProvider.vue.js";
+let count = 0;
+function useId(deterministicId, prefix = "reka") {
+  if ("useId" in vue) {
+    return `${prefix}-${vue.useId?.()}`;
+  }
+  const configProviderContext = injectConfigProviderContext({
+    useId: void 0
+  });
+  if (configProviderContext.useId) {
+    return `${prefix}-${configProviderContext.useId()}`;
+  }
+  return `${prefix}-${++count}`;
+}
+export {
+  useId
+};
+//# sourceMappingURL=useId.js.map

package/dist/shared/useId.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useId.js","sources":["../../src/shared/useId.ts"],"sourcesContent":["import * as vue from \"vue\";\n// Inspired from https://github.com/tailwindlabs/headlessui/issues/2913\n// as the alternative, and a fallback for Vue version < 3.5\nimport { injectConfigProviderContext } from \"../components/ConfigProvider/ConfigProvider.vue\";\n\nlet count = 0;\n/**\n * The `useId` function generates a unique identifier using a provided deterministic ID or a default\n * one prefixed with \"reka-\", or the provided one via `useId` props from `<ConfigProvider>`.\n * @param {string | null | undefined} [deterministicId] - The `useId` function you provided takes an\n * optional parameter `deterministicId`, which can be a string, null, or undefined. If\n * `deterministicId` is provided, the function will return it. Otherwise, it will generate an id using\n * the `useId` function obtained\n */\nexport function useId(\n  deterministicId?: string | null | undefined,\n  prefix = \"reka\",\n) {\n  if (deterministicId) return deterministicId;\n\n  if (\"useId\" in vue) {\n    return `${prefix}-${vue.useId?.()}`;\n  }\n\n  const configProviderContext = injectConfigProviderContext({\n    useId: undefined,\n  });\n\n  if (configProviderContext.useId) {\n    return `${prefix}-${configProviderContext.useId()}`;\n  }\n\n  return `${prefix}-${++count}`;\n}\n"],"names":[],"mappings":";;AAKA,IAAI,QAAQ;AASL,SAAS,MACd,iBACA,SAAS,QACT;AAGA,MAAI,WAAW,KAAK;AAClB,WAAO,GAAG,MAAM,IAAI,IAAI,SAAS;AAAA,EACnC;AAEA,QAAM,wBAAwB,4BAA4B;AAAA,IACxD,OAAO;AAAA,EAAA,CACR;AAED,MAAI,sBAAsB,OAAO;AAC/B,WAAO,GAAG,MAAM,IAAI,sBAAsB,OAAO;AAAA,EACnD;AAEA,SAAO,GAAG,MAAM,IAAI,EAAE,KAAK;AAC7B;"}

package/dist/shared/useIsUsingKeyboard.d.ts

@@ -0,0 +1,3 @@
+declare function useIsUsingKeyboardImpl(): import('vue').Ref<boolean, boolean>;
+export declare const useIsUsingKeyboard: typeof useIsUsingKeyboardImpl;
+export {};

package/dist/shared/useKbd.d.ts

@@ -0,0 +1,78 @@
+export declare function useKbd(): {
+    ALT: string;
+    ARROW_DOWN: string;
+    ARROW_LEFT: string;
+    ARROW_RIGHT: string;
+    ARROW_UP: string;
+    BACKSPACE: string;
+    CAPS_LOCK: string;
+    CONTROL: string;
+    DELETE: string;
+    END: string;
+    ENTER: string;
+    ESCAPE: string;
+    F1: string;
+    F10: string;
+    F11: string;
+    F12: string;
+    F2: string;
+    F3: string;
+    F4: string;
+    F5: string;
+    F6: string;
+    F7: string;
+    F8: string;
+    F9: string;
+    HOME: string;
+    META: string;
+    PAGE_DOWN: string;
+    PAGE_UP: string;
+    SHIFT: string;
+    SPACE: string;
+    TAB: string;
+    CTRL: string;
+    ASTERISK: string;
+    SPACE_CODE: string;
+};
+/**
+ * A wrapper around the internal kbd object to make it easier to use in tests
+ * which require the key names to be wrapped in curly braces.
+ */
+export type KbdKeys = keyof ReturnType<typeof useKbd>;
+export declare function useTestKbd(): {
+    SHIFT_TAB: string;
+    F1: string;
+    F10: string;
+    F11: string;
+    F12: string;
+    F2: string;
+    F3: string;
+    F4: string;
+    F5: string;
+    F6: string;
+    F7: string;
+    F8: string;
+    F9: string;
+    ALT: string;
+    ARROW_DOWN: string;
+    ARROW_LEFT: string;
+    ARROW_RIGHT: string;
+    ARROW_UP: string;
+    BACKSPACE: string;
+    CAPS_LOCK: string;
+    CONTROL: string;
+    DELETE: string;
+    END: string;
+    ENTER: string;
+    ESCAPE: string;
+    HOME: string;
+    META: string;
+    PAGE_DOWN: string;
+    PAGE_UP: string;
+    SHIFT: string;
+    SPACE: string;
+    TAB: string;
+    CTRL: string;
+    ASTERISK: string;
+    SPACE_CODE: string;
+};

package/dist/shared/useKbd.js

@@ -0,0 +1,42 @@
+function useKbd() {
+  return {
+    ALT: "Alt",
+    ARROW_DOWN: "ArrowDown",
+    ARROW_LEFT: "ArrowLeft",
+    ARROW_RIGHT: "ArrowRight",
+    ARROW_UP: "ArrowUp",
+    BACKSPACE: "Backspace",
+    CAPS_LOCK: "CapsLock",
+    CONTROL: "Control",
+    DELETE: "Delete",
+    END: "End",
+    ENTER: "Enter",
+    ESCAPE: "Escape",
+    F1: "F1",
+    F10: "F10",
+    F11: "F11",
+    F12: "F12",
+    F2: "F2",
+    F3: "F3",
+    F4: "F4",
+    F5: "F5",
+    F6: "F6",
+    F7: "F7",
+    F8: "F8",
+    F9: "F9",
+    HOME: "Home",
+    META: "Meta",
+    PAGE_DOWN: "PageDown",
+    PAGE_UP: "PageUp",
+    SHIFT: "Shift",
+    SPACE: " ",
+    TAB: "Tab",
+    CTRL: "Control",
+    ASTERISK: "*",
+    SPACE_CODE: "Space"
+  };
+}
+export {
+  useKbd
+};
+//# sourceMappingURL=useKbd.js.map

package/dist/shared/useKbd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKbd.js","sources":["../../src/shared/useKbd.ts"],"sourcesContent":["export function useKbd() {\n  return {\n    ALT: 'Alt',\n    ARROW_DOWN: 'ArrowDown',\n    ARROW_LEFT: 'ArrowLeft',\n    ARROW_RIGHT: 'ArrowRight',\n    ARROW_UP: 'ArrowUp',\n    BACKSPACE: 'Backspace',\n    CAPS_LOCK: 'CapsLock',\n    CONTROL: 'Control',\n    DELETE: 'Delete',\n    END: 'End',\n    ENTER: 'Enter',\n    ESCAPE: 'Escape',\n    F1: 'F1',\n    F10: 'F10',\n    F11: 'F11',\n    F12: 'F12',\n    F2: 'F2',\n    F3: 'F3',\n    F4: 'F4',\n    F5: 'F5',\n    F6: 'F6',\n    F7: 'F7',\n    F8: 'F8',\n    F9: 'F9',\n    HOME: 'Home',\n    META: 'Meta',\n    PAGE_DOWN: 'PageDown',\n    PAGE_UP: 'PageUp',\n    SHIFT: 'Shift',\n    SPACE: ' ',\n    TAB: 'Tab',\n    CTRL: 'Control',\n    ASTERISK: '*',\n    SPACE_CODE: 'Space',\n  }\n}\n\n/**\n * A wrapper around the internal kbd object to make it easier to use in tests\n * which require the key names to be wrapped in curly braces.\n */\nexport type KbdKeys = keyof ReturnType<typeof useKbd>\n\nexport function useTestKbd() {\n  const kbd = useKbd()\n\n  const initTestKbd: Record<KbdKeys, string> = Object.entries(kbd).reduce((acc, [key, value]) => {\n    acc[key as KbdKeys] = `{${value}}`\n    return acc\n  }, {} as Record<KbdKeys, string>)\n\n  return {\n    ...initTestKbd,\n    SHIFT_TAB: `{Shift>}{${kbd.TAB}}`,\n  }\n}\n"],"names":[],"mappings":"AAAO,SAAS,SAAS;AACvB,SAAO;AAAA,IACL,KAAK;AAAA,IACL,YAAY;AAAA,IACZ,YAAY;AAAA,IACZ,aAAa;AAAA,IACb,UAAU;AAAA,IACV,WAAW;AAAA,IACX,WAAW;AAAA,IACX,SAAS;AAAA,IACT,QAAQ;AAAA,IACR,KAAK;AAAA,IACL,OAAO;AAAA,IACP,QAAQ;AAAA,IACR,IAAI;AAAA,IACJ,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,IAAI;AAAA,IACJ,MAAM;AAAA,IACN,MAAM;AAAA,IACN,WAAW;AAAA,IACX,SAAS;AAAA,IACT,OAAO;AAAA,IACP,OAAO;AAAA,IACP,KAAK;AAAA,IACL,MAAM;AAAA,IACN,UAAU;AAAA,IACV,YAAY;AAAA,EAAA;AAEhB;"}

package/dist/shared/useLocale.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+/**
+ * The `useLocale` function provides a way to access the current locale in your application.
+ * @param {Ref<string | undefined>} [locale] - An optional ref containing the locale.
+ * @returns A computed ref holding the resolved locale.
+ */
+export declare function useLocale(locale?: Ref<string | undefined>): import('vue').ComputedRef<string>;

package/dist/shared/useLocale.js

@@ -0,0 +1,12 @@
+import { ref, computed } from "vue";
+import { injectConfigProviderContext } from "../components/ConfigProvider/ConfigProvider.vue.js";
+function useLocale(locale) {
+  const context = injectConfigProviderContext({
+    locale: ref("en")
+  });
+  return computed(() => locale?.value || context.locale?.value || "en");
+}
+export {
+  useLocale
+};
+//# sourceMappingURL=useLocale.js.map

package/dist/shared/useLocale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocale.js","sources":["../../src/shared/useLocale.ts"],"sourcesContent":["import type { Ref } from \"vue\";\nimport { computed, ref } from \"vue\";\nimport { injectConfigProviderContext } from \"../components/ConfigProvider/ConfigProvider.vue\";\n\n/**\n * The `useLocale` function provides a way to access the current locale in your application.\n * @param {Ref<string | undefined>} [locale] - An optional ref containing the locale.\n * @returns A computed ref holding the resolved locale.\n */\nexport function useLocale(locale?: Ref<string | undefined>) {\n  const context = injectConfigProviderContext({\n    locale: ref(\"en\"),\n  });\n  return computed(() => locale?.value || context.locale?.value || \"en\");\n}\n"],"names":[],"mappings":";;AASO,SAAS,UAAU,QAAkC;AAC1D,QAAM,UAAU,4BAA4B;AAAA,IAC1C,QAAQ,IAAI,IAAI;AAAA,EAAA,CACjB;AACD,SAAO,SAAS,MAAM,QAAQ,SAAS,QAAQ,QAAQ,SAAS,IAAI;AACtE;"}

package/dist/shared/useNonce.d.ts

@@ -0,0 +1,2 @@
+import { Ref } from 'vue';
+export declare function useNonce(nonce?: Ref<string | undefined>): import('vue').ComputedRef<string | undefined>;

package/dist/shared/useSize.d.ts

@@ -0,0 +1,5 @@
+import { MaybeElementRef } from '@vueuse/core';
+export declare function useSize(element: MaybeElementRef): {
+    width: import('vue').ComputedRef<number>;
+    height: import('vue').ComputedRef<number>;
+};

package/dist/shared/useSize.js

@@ -0,0 +1,44 @@
+import { unrefElement } 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 { ref, computed, onMounted } from "vue";
+function useSize(element) {
+  const size = ref();
+  const width = computed(() => size.value?.width ?? 0);
+  const height = computed(() => size.value?.height ?? 0);
+  onMounted(() => {
+    const el = unrefElement(element);
+    if (el) {
+      size.value = { width: el.offsetWidth, height: el.offsetHeight };
+      const resizeObserver = new ResizeObserver((entries) => {
+        if (!Array.isArray(entries))
+          return;
+        if (!entries.length)
+          return;
+        const entry = entries[0];
+        let width2;
+        let height2;
+        if ("borderBoxSize" in entry) {
+          const borderSizeEntry = entry.borderBoxSize;
+          const borderSize = Array.isArray(borderSizeEntry) ? borderSizeEntry[0] : borderSizeEntry;
+          width2 = borderSize.inlineSize;
+          height2 = borderSize.blockSize;
+        } else {
+          width2 = el.offsetWidth;
+          height2 = el.offsetHeight;
+        }
+        size.value = { width: width2, height: height2 };
+      });
+      resizeObserver.observe(el, { box: "border-box" });
+      return () => resizeObserver.unobserve(el);
+    } else {
+      size.value = void 0;
+    }
+  });
+  return {
+    width,
+    height
+  };
+}
+export {
+  useSize
+};
+//# sourceMappingURL=useSize.js.map

package/dist/shared/useSize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSize.js","sources":["../../src/shared/useSize.ts"],"sourcesContent":["import type { MaybeElementRef } from '@vueuse/core'\nimport { unrefElement } from '@vueuse/core'\nimport { computed, onMounted, ref } from 'vue'\n\nexport function useSize(element: MaybeElementRef) {\n  const size = ref<{ width: number, height: number }>()\n  const width = computed(() => size.value?.width ?? 0)\n  const height = computed(() => size.value?.height ?? 0)\n\n  onMounted(() => {\n    const el = unrefElement(element) as HTMLElement\n    if (el) {\n      // provide size as early as possible\n      size.value = { width: el.offsetWidth, height: el.offsetHeight }\n\n      const resizeObserver = new ResizeObserver((entries) => {\n        if (!Array.isArray(entries))\n          return\n\n        // Since we only observe the one element, we don't need to loop over the\n        // array\n        if (!entries.length)\n          return\n\n        const entry = entries[0]\n        let width: number\n        let height: number\n\n        if ('borderBoxSize' in entry) {\n          const borderSizeEntry = entry.borderBoxSize\n          // iron out differences between browsers\n          const borderSize = Array.isArray(borderSizeEntry)\n            ? borderSizeEntry[0]\n            : borderSizeEntry\n          width = borderSize.inlineSize\n          height = borderSize.blockSize\n        }\n        else {\n          // for browsers that don't support `borderBoxSize`\n          // we calculate it ourselves to get the correct border box.\n          width = el.offsetWidth\n          height = el.offsetHeight\n        }\n\n        // temporary disable width/height from resize observer. borderSizeEntry seems to be incorrect\n        size.value = { width, height }\n      })\n\n      resizeObserver.observe(el, { box: 'border-box' })\n\n      return () => resizeObserver.unobserve(el)\n    }\n    else {\n      // We only want to reset to `undefined` when the element becomes `null`,\n      // not if it changes to another element.\n      size.value = undefined\n    }\n  })\n\n  return {\n    width,\n    height,\n  }\n}\n"],"names":["width","height"],"mappings":";;AAIO,SAAS,QAAQ,SAA0B;AAChD,QAAM,OAAO,IAAA;AACb,QAAM,QAAQ,SAAS,MAAM,KAAK,OAAO,SAAS,CAAC;AACnD,QAAM,SAAS,SAAS,MAAM,KAAK,OAAO,UAAU,CAAC;AAErD,YAAU,MAAM;AACd,UAAM,KAAK,aAAa,OAAO;AAC/B,QAAI,IAAI;AAEN,WAAK,QAAQ,EAAE,OAAO,GAAG,aAAa,QAAQ,GAAG,aAAA;AAEjD,YAAM,iBAAiB,IAAI,eAAe,CAAC,YAAY;AACrD,YAAI,CAAC,MAAM,QAAQ,OAAO;AACxB;AAIF,YAAI,CAAC,QAAQ;AACX;AAEF,cAAM,QAAQ,QAAQ,CAAC;AACvB,YAAIA;AACJ,YAAIC;AAEJ,YAAI,mBAAmB,OAAO;AAC5B,gBAAM,kBAAkB,MAAM;AAE9B,gBAAM,aAAa,MAAM,QAAQ,eAAe,IAC5C,gBAAgB,CAAC,IACjB;AACJD,mBAAQ,WAAW;AACnBC,oBAAS,WAAW;AAAA,QACtB,OACK;AAGHD,mBAAQ,GAAG;AACXC,oBAAS,GAAG;AAAA,QACd;AAGA,aAAK,QAAQ,EAAE,OAAAD,QAAO,QAAAC,QAAAA;AAAAA,MACxB,CAAC;AAED,qBAAe,QAAQ,IAAI,EAAE,KAAK,cAAc;AAEhD,aAAO,MAAM,eAAe,UAAU,EAAE;AAAA,IAC1C,OACK;AAGH,WAAK,QAAQ;AAAA,IACf;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EAAA;AAEJ;"}

package/dist/shared/useStateMachine.d.ts

@@ -0,0 +1,25 @@
+import { Ref } from 'vue';
+interface Machine<S> {
+    [k: string]: {
+        [k: string]: S;
+    };
+}
+type MachineState<T> = keyof T;
+type MachineEvent<T> = keyof UnionToIntersection<T[keyof T]>;
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+/**
+ * The `useStateMachine` function is a TypeScript function that creates a state machine and returns the
+ * current state and a dispatch function to update the state based on events.
+ * @param initialState - The `initialState` parameter is the initial state of the state machine. It
+ * represents the starting point of the state machine's state.
+ * @param machine - The `machine` parameter is an object that represents a state machine. It should
+ * have keys that correspond to the possible states of the machine, and the values should be objects
+ * that represent the possible events and their corresponding next states.
+ * @returns The `useStateMachine` function returns an object with two properties: `state` and
+ * `dispatch`.
+ */
+export declare function useStateMachine<M>(initialState: MachineState<M>, machine: M & Machine<MachineState<M>>): {
+    state: Ref<keyof M, keyof M>;
+    dispatch: (event: MachineEvent<M>) => void;
+};
+export {};

package/dist/shared/useStateMachine.js

@@ -0,0 +1,19 @@
+import { ref } from "vue";
+function useStateMachine(initialState, machine) {
+  const state = ref(initialState);
+  function reducer(event) {
+    const nextState = machine[state.value][event];
+    return nextState ?? state.value;
+  }
+  const dispatch = (event) => {
+    state.value = reducer(event);
+  };
+  return {
+    state,
+    dispatch
+  };
+}
+export {
+  useStateMachine
+};
+//# sourceMappingURL=useStateMachine.js.map

package/dist/shared/useStateMachine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useStateMachine.js","sources":["../../src/shared/useStateMachine.ts"],"sourcesContent":["import type { Ref } from 'vue'\nimport { ref } from 'vue'\n\ninterface Machine<S> {\n  [k: string]: { [k: string]: S }\n}\ntype MachineState<T> = keyof T\ntype MachineEvent<T> = keyof UnionToIntersection<T[keyof T]>\n\n// 🤯 https://fettblog.eu/typescript-union-to-intersection/\ntype UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (\n  x: infer R\n) => any\n  ? R\n  : never\n\n/**\n * The `useStateMachine` function is a TypeScript function that creates a state machine and returns the\n * current state and a dispatch function to update the state based on events.\n * @param initialState - The `initialState` parameter is the initial state of the state machine. It\n * represents the starting point of the state machine's state.\n * @param machine - The `machine` parameter is an object that represents a state machine. It should\n * have keys that correspond to the possible states of the machine, and the values should be objects\n * that represent the possible events and their corresponding next states.\n * @returns The `useStateMachine` function returns an object with two properties: `state` and\n * `dispatch`.\n */\nexport function useStateMachine<M>(\n  initialState: MachineState<M>,\n  machine: M & Machine<MachineState<M>>,\n) {\n  const state = ref(initialState) as Ref<MachineState<M>>\n\n  function reducer(event: MachineEvent<M>) {\n    // @ts-expect-error  state.value is keyof M\n    const nextState = machine[state.value][event]\n    return nextState ?? state.value\n  }\n\n  const dispatch = (event: MachineEvent<M>) => {\n    state.value = reducer(event)\n  }\n\n  return {\n    state,\n    dispatch,\n  }\n}\n"],"names":[],"mappings":";AA2BO,SAAS,gBACd,cACA,SACA;AACA,QAAM,QAAQ,IAAI,YAAY;AAE9B,WAAS,QAAQ,OAAwB;AAEvC,UAAM,YAAY,QAAQ,MAAM,KAAK,EAAE,KAAK;AAC5C,WAAO,aAAa,MAAM;AAAA,EAC5B;AAEA,QAAM,WAAW,CAAC,UAA2B;AAC3C,UAAM,QAAQ,QAAQ,KAAK;AAAA,EAC7B;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,EAAA;AAEJ;"}

package/dist/shared/withDefault.d.ts

@@ -0,0 +1,22 @@
+import { DefineComponent, VNodeProps } from 'vue';
+import { ComponentProps } from 'vue-component-type-helpers';
+type RawProps = VNodeProps & {
+    __v_isVNode?: never;
+    [Symbol.iterator]?: never;
+} & Record<string, any>;
+interface MountingOptions<Props> {
+    /**
+     * Default props for the component
+     */
+    props?: (RawProps & Props) | ({} extends Props ? null : never) | ((attrs: Record<string, any>) => (RawProps & Props));
+    /**
+     * Pass attributes into the component
+     */
+    attrs?: Record<string, unknown>;
+}
+export declare function withDefault<T, C = T extends ((...args: any) => any) | (new (...args: any) => any) ? T : T extends {
+    props?: infer Props;
+} ? DefineComponent<Props extends Readonly<(infer PropNames)[]> | (infer PropNames)[] ? {
+    [key in PropNames extends string ? PropNames : string]?: any;
+} : Props> : DefineComponent, P extends ComponentProps<C> = ComponentProps<C>>(originalComponent: T, options?: MountingOptions<P>): T;
+export {};

package/package.json

@@ -0,0 +1,72 @@
+{
+  "name": "@rupe/v-datepicker",
+  "type": "module",
+  "version": "1.0.0-alpha.0",
+  "description": "A Vue 3 datepicker component",
+  "packageManager": "pnpm@10.13.1",
+  "author": "Anja Rupnik",
+  "license": "MIT",
+  "repository": "anjarupnik/v-datepicker",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!src/**/*.story.vue",
+    "!src/**/*.test.*",
+    "!src/**/_*.vue",
+    "!src/**/stories",
+    "!src/**/story"
+  ],
+  "scripts": {
+    "dev": "pnpm --filter playground dev",
+    "build": "vite build",
+    "playground:install": "pnpm --filter playground install",
+    "preview": "vite preview",
+    "lint": "eslint . --fix",
+    "format": "prettier --write \"src/**/*.{js,ts,vue,css,scss}\""
+  },
+  "keywords": [
+    "vue",
+    "datepicker"
+  ],
+  "peerDependencies": {
+    "vue": ">= 3.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "24.1.0",
+    "@typescript-eslint/eslint-plugin": "8.52.0 ",
+    "@typescript-eslint/parser": "8.52.0",
+    "@vitejs/plugin-vue": "6.0.3",
+    "@vue/eslint-config-prettier": "10.2.0",
+    "@vue/eslint-config-typescript": "14.6.0",
+    "@vue/tsconfig": "0.8.1",
+    "eslint": "9.39.2",
+    "eslint-plugin-vue": "10.6.2",
+    "prettier": "3.7.4",
+    "typescript": "5.9.3",
+    "vite": "7.3.1",
+    "vite-plugin-dts": "^4.5.4",
+    "vue": "3.5.26",
+    "vue-tsc": "3.2.2"
+  },
+  "volta": {
+    "node": "24.12.0"
+  },
+  "dependencies": {
+    "@floating-ui/vue": "^1.1.9",
+    "@internationalized/date": "^3.10.1",
+    "@vueuse/core": "^14.1.0",
+    "@vueuse/shared": "^14.1.0",
+    "defu": "^6.1.4",
+    "ohash": "^2.0.11"
+  }
+}