@scalar/components 0.12.76 → 0.13.1

package/dist/components/ScalarToggle/ScalarToggle.vue.js

@@ -1,54 +1,43 @@
-import { defineComponent as b, openBlock as p, createElementBlock as m, normalizeClass as d, unref as o, withKeys as i, withModifiers as t, createElementVNode as r } from "vue";
-import { cva as h, cx as f } from "../../cva.js";
-const y = ["onKeydown"], g = ["id", "aria-checked", "aria-disabled", "aria-label", "aria-labelledby", "checked", "disabled"], v = /* @__PURE__ */ b({
+import { defineComponent as u, openBlock as t, createElementBlock as l, normalizeClass as o, unref as n, createElementVNode as m, toDisplayString as p, createCommentVNode as b } from "vue";
+import { cva as f, cx as h } from "../../cva.js";
+const V = ["aria-checked", "aria-disabled"], g = {
+  key: 0,
+  class: "sr-only"
+}, w = /* @__PURE__ */ u({
   __name: "ScalarToggle",
   props: {
     modelValue: { type: Boolean },
     disabled: { type: Boolean },
-    id: {},
-    ariaLabel: {},
-    ariaLabelledBy: {}
+    label: {}
   },
   emits: ["update:modelValue"],
-  setup(n, { emit: s }) {
-    const a = n, c = s;
-    function l() {
-      a.disabled || c("update:modelValue", !a.modelValue);
+  setup(r, { emit: s }) {
+    const a = r, d = s;
+    function i() {
+      a.disabled || d("update:modelValue", !a.modelValue);
     }
-    const u = h({
+    const c = f({
       base: "relative h-3.5 w-6 cursor-pointer rounded-full bg-b-3 transition-colors duration-300",
       variants: {
         checked: { true: "bg-c-accent" },
         disabled: { true: "cursor-not-allowed opacity-40" }
       }
     });
-    return (e, k) => (p(), m("div", {
-      class: d(o(f)(o(u)({ checked: e.modelValue, disabled: e.disabled }))),
+    return (e, k) => (t(), l("button", {
+      "aria-checked": e.modelValue,
+      "aria-disabled": e.disabled,
+      class: o(n(h)(n(c)({ checked: e.modelValue, disabled: e.disabled }))),
       role: "switch",
-      tabindex: "0",
-      onKeydown: [
-        i(t(l, ["prevent"]), ["enter"]),
-        i(t(l, ["prevent"]), ["space"])
-      ]
+      type: "button",
+      onClick: i
     }, [
-      r("input", {
-        id: a.id,
-        "aria-checked": e.modelValue,
-        "aria-disabled": e.disabled,
-        "aria-label": a.ariaLabel,
-        "aria-labelledby": a.ariaLabelledBy,
-        checked: e.modelValue,
-        class: "hidden",
-        disabled: e.disabled,
-        type: "checkbox",
-        onChange: l
-      }, null, 40, g),
-      r("div", {
-        class: d(["absolute left-px top-px flex h-3 w-3 items-center justify-center rounded-full bg-white text-c-accent transition-transform duration-300", { "translate-x-2.5": e.modelValue }])
-      }, null, 2)
-    ], 42, y));
+      m("div", {
+        class: o(["absolute left-px top-px flex h-3 w-3 items-center justify-center rounded-full bg-white text-c-accent transition-transform duration-300", { "translate-x-2.5": e.modelValue }])
+      }, null, 2),
+      e.label ? (t(), l("span", g, p(e.label), 1)) : b("", !0)
+    ], 10, V));
   }
 });
 export {
-  v as default
+  w as default
 };

package/dist/components/ScalarTooltip/ScalarTooltip.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ScalarTooltip.test.d.ts.map

package/dist/components/ScalarTooltip/ScalarTooltip.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarTooltip.test.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarTooltip/ScalarTooltip.test.ts"],"names":[],"mappings":""}

package/dist/components/ScalarVirtualText/ScalarVirtualText.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ScalarVirtualText.test.d.ts.map

package/dist/components/ScalarVirtualText/ScalarVirtualText.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ScalarVirtualText.test.d.ts","sourceRoot":"","sources":["../../../src/components/ScalarVirtualText/ScalarVirtualText.test.ts"],"names":[],"mappings":""}

package/dist/cva.js

@@ -1,19 +1,19 @@
 import { defineConfig as e } from "cva";
 import { extendTailwindMerge as t } from "tailwind-merge";
-const n = t({
+const s = t({
   extend: {
     classGroups: {
-      "font-size": ["text-xxs"]
+      "font-size": ["text-3xs", "text-xxs"]
     }
   }
-}), { cva: r, cx: x, compose: c } = e({
+}), { cva: i, cx: r, compose: c } = e({
   hooks: {
-    onComplete: (o) => n(o)
+    onComplete: (o) => s(o)
   }
 });
 export {
   c as compose,
-  r as cva,
-  x as cx,
-  n as tw
+  i as cva,
+  r as cx,
+  s as tw
 };

package/dist/cva.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=cva.test.d.ts.map

package/dist/cva.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cva.test.d.ts","sourceRoot":"","sources":["../src/cva.test.ts"],"names":[],"mappings":""}

package/dist/hooks/useBindCx.d.ts

@@ -0,0 +1,51 @@
+import type { CXOptions } from 'cva';
+/**
+ * Provides a wrapper around the `cx` function that merges the
+ * component's class attribute with the provided classes and binds the
+ * remaining attributes
+ *
+ * @see https://beta.cva.style/api-reference#cx
+ *
+ * @example
+ * <script setup>
+ * import { useBindCx, cva } from '@scalar/components'
+ *
+ * defineProps<{ active?: boolean }>()
+ *
+ * // Important: disable inheritance of attributes
+ * defineOptions({ inheritAttrs: false })
+ *
+ * const { cx } = useBindCx()
+ *
+ * const variants = cva({
+ *   base: 'border rounded p-2 bg-b-1',
+ *   variants: { active: { true: 'bg-b-2' } },
+ * })
+ * </script>
+ * <template>
+ *   <div v-bind="cx(variants({ active }))">MockComponent</div>
+ * </template>
+ */
+export declare function useBindCx(): {
+    /**
+     * Provides a wrapper around the `cx` function that merges the
+     * component's class attribute with the provided classes and binds the
+     * remaining attributes
+     *
+     * @example
+     * <script setup>
+     * ...
+     * const { cx } = useBindCx()
+     * </script>
+     * <template>
+     *   <div v-bind="cx(...)">...</div>
+     * </template>
+     */
+    cx: (...args: CXOptions) => {
+        /** The merged class attribute */
+        class: string;
+        /** The remaining attributes */
+        [key: string]: any;
+    };
+};
+//# sourceMappingURL=useBindCx.d.ts.map

package/dist/hooks/useBindCx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBindCx.d.ts","sourceRoot":"","sources":["../../src/hooks/useBindCx.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,KAAK,CAAA;AAKpC;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,SAAS;IAqBrB;;;;;;;;;;;;;OAaG;kBA1BoB,SAAS,KAAG;QACnC,iCAAiC;QACjC,KAAK,EAAE,MAAM,CAAA;QACb,+BAA+B;QAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KACnB;EAwBF"}

package/dist/hooks/useBindCx.js

@@ -0,0 +1,34 @@
+import { useAttrs as n, computed as u } from "vue";
+import { cx as o } from "../cva.js";
+function i() {
+  const r = n(), t = u(() => {
+    const { class: s, ...e } = r;
+    return { class: s || "", rest: e };
+  });
+  function c(...s) {
+    return {
+      class: o(...s, t.value.class),
+      ...t.value.rest
+    };
+  }
+  return {
+    /**
+     * Provides a wrapper around the `cx` function that merges the
+     * component's class attribute with the provided classes and binds the
+     * remaining attributes
+     *
+     * @example
+     * <script setup>
+     * ...
+     * const { cx } = useBindCx()
+     * <\/script>
+     * <template>
+     *   <div v-bind="cx(...)">...</div>
+     * </template>
+     */
+    cx: c
+  };
+}
+export {
+  i as useBindCx
+};

package/dist/hooks/useBindCx.stories.d.ts

@@ -0,0 +1,430 @@
+import type { StoryObj } from '@storybook/vue3';
+/**
+ * Provides a wrapper around the `cx` function that merges the
+ * component's class attribute with the provided classes.
+ *
+ * This allows you to override tailwind classes from the parent component and `cx`
+ * will intelligently merge them while passing through other attributes.
+ *
+ * ### Example
+ *
+ * Scroll down for a working playground which mounts `MockComponent`.
+ *
+ * ```html
+ * <script setup>
+ * import { useBindCx, cva } from '@scalar/components'
+ *
+ * defineProps<{ active?: boolean }>()
+ *
+ * // Important: disable inheritance of attributes
+ * defineOptions({ inheritAttrs: false })
+ *
+ * const { cx } = useBindCx()
+ *
+ * const variants = cva({
+ *   base: 'border rounded p-2 bg-b-1',
+ *   variants: { active: { true: 'bg-b-2' } },
+ * })
+ * </script>
+ * <template>
+ *   <div v-bind="cx(variants({ active }))">MockComponent</div>
+ * </template>
+ * ```
+ */
+declare const meta: {
+    tags: string[];
+    argTypes: {
+        active: {
+            control: "boolean";
+            description: string;
+        };
+        class: {
+            control: "text";
+            description: string;
+        };
+        attrs: {
+            control: "object";
+            description: string;
+        };
+    };
+    render: (args: import("@storybook/vue3").Args) => {
+        components: {
+            MockComponent: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+                active: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>, {
+                cx: (...args: import("cva").CXOptions) => {
+                    class: string;
+                    [key: string]: any;
+                };
+                variants: (props?: ({
+                    active?: boolean | undefined;
+                } & ({
+                    class?: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined;
+                    className?: never;
+                } | {
+                    class?: never;
+                    className?: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined;
+                })) | undefined) => string;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+                active: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                active: boolean;
+            }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+        };
+        setup(this: void): {
+            bind: import("vue").ComputedRef<any>;
+            passedIn: import("vue").ComputedRef<string>;
+            rendered: import("vue").Ref<string, string>;
+            mock: import("vue").Ref<import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                active: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                cx: (...args: import("cva").CXOptions) => {
+                    class: string;
+                    [key: string]: any;
+                };
+                variants: (props?: ({
+                    active?: boolean | undefined;
+                } & ({
+                    class?: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined;
+                    className?: never;
+                } | {
+                    class?: never;
+                    className?: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined;
+                })) | undefined) => string;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                active: boolean;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                active: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                cx: (...args: import("cva").CXOptions) => {
+                    class: string;
+                    [key: string]: any;
+                };
+                variants: (props?: ({
+                    active?: boolean | undefined;
+                } & ({
+                    class?: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined;
+                    className?: never;
+                } | {
+                    class?: never;
+                    className?: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined;
+                })) | undefined) => string;
+            }, {}, {}, {}, {
+                active: boolean;
+            }> | undefined, import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+                active: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                cx: (...args: import("cva").CXOptions) => {
+                    class: string;
+                    [key: string]: any;
+                };
+                variants: (props?: ({
+                    active?: boolean | undefined;
+                } & ({
+                    class?: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined;
+                    className?: never;
+                } | {
+                    class?: never;
+                    className?: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined;
+                })) | undefined) => string;
+            }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+                active: boolean;
+            }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+                P: {};
+                B: {};
+                D: {};
+                C: {};
+                M: {};
+                Defaults: {};
+            }, Readonly<import("vue").ExtractPropTypes<{
+                active: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & Readonly<{}>, {
+                cx: (...args: import("cva").CXOptions) => {
+                    class: string;
+                    [key: string]: any;
+                };
+                variants: (props?: ({
+                    active?: boolean | undefined;
+                } & ({
+                    class?: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined;
+                    className?: never;
+                } | {
+                    class?: never;
+                    className?: string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | (string | number | boolean | any | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined)[] | {
+                        [x: string]: any;
+                    } | null | undefined;
+                })) | undefined) => string;
+            }, {}, {}, {}, {
+                active: boolean;
+            }> | undefined>;
+        };
+        template: string;
+    };
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+export declare const Base: Story;
+//# sourceMappingURL=useBindCx.stories.d.ts.map

package/dist/hooks/useBindCx.stories.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBindCx.stories.d.ts","sourceRoot":"","sources":["../../src/hooks/useBindCx.stories.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,QAAQ,EAAE,MAAM,iBAAiB,CAAA;AA8BrD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDM,CAAA;AAEhB,eAAe,IAAI,CAAA;AACnB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAA;AAElC,eAAO,MAAM,IAAI,EAAE,KAAU,CAAA"}

package/dist/hooks/useBindCx.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=useBindCx.test.d.ts.map

package/dist/hooks/useBindCx.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBindCx.test.d.ts","sourceRoot":"","sources":["../../src/hooks/useBindCx.test.ts"],"names":[],"mappings":""}