vft 0.0.48 → 0.0.51

package/es/components/checkbox/composables/use-checkbox-event.js

@@ -0,0 +1,52 @@
+import { inject as d, getCurrentInstance as L, computed as C, watch as E, nextTick as k } from "vue";
+import "../../form/index.js";
+import "@vft/utils";
+import { debugWarn as x } from "../../../utils/error.js";
+import "lodash";
+import "@vueuse/core";
+import "../../../utils/ns-cover.js";
+import { checkboxGroupContextKey as T } from "../constants.js";
+import { useFormItem as p } from "../../form/hooks/use-form-item.js";
+const P = (t, {
+  model: n,
+  isLimitExceeded: u,
+  hasOwnLabel: l,
+  isDisabled: v,
+  isLabeledByFormItem: m
+}) => {
+  const o = d(T, void 0), { formItem: c } = p(), { emit: i } = L();
+  function r(e) {
+    return e === t.trueLabel || e === !0 ? t.trueLabel ?? !0 : t.falseLabel ?? !1;
+  }
+  function s(e, a) {
+    i("change", r(e), a);
+  }
+  function f(e) {
+    if (u.value)
+      return;
+    const a = e.target;
+    i("change", r(a.checked), e);
+  }
+  async function g(e) {
+    u.value || !l.value && !v.value && m.value && (e.composedPath().some(
+      (b) => b.tagName === "LABEL"
+    ) || (n.value = r(
+      [!1, t.falseLabel].includes(n.value)
+    ), await k(), s(n.value, e)));
+  }
+  const h = C(
+    () => (o == null ? void 0 : o.validateEvent) || t.validateEvent
+  );
+  return E(
+    () => t.modelValue,
+    () => {
+      h.value && (c == null || c.validate("change").catch((e) => x(e)));
+    }
+  ), {
+    handleChange: f,
+    onClickRoot: g
+  };
+};
+export {
+  P as useCheckboxEvent
+};

package/es/components/checkbox/composables/use-checkbox-model.d.ts

@@ -0,0 +1,7 @@
+import type { CheckboxProps } from '../checkbox.vue';
+export declare const useCheckboxModel: (props: CheckboxProps) => {
+    model: import("vue").WritableComputedRef<any>;
+    isGroup: import("vue").ComputedRef<boolean>;
+    isLimitExceeded: import("vue").Ref<boolean>;
+};
+export type CheckboxModel = ReturnType<typeof useCheckboxModel>;

package/es/components/checkbox/composables/use-checkbox-model.js

@@ -0,0 +1,24 @@
+import { ref as i, getCurrentInstance as r, inject as u, computed as d } from "vue";
+import { isUndefined as v, isArray as E } from "@vft/utils";
+import { UPDATE_MODEL_EVENT as g } from "../../../constants/event.js";
+import { checkboxGroupContextKey as C } from "../constants.js";
+const L = (f) => {
+  const n = i(!1), { emit: o } = r(), e = u(C, void 0), l = d(() => v(e) === !1), s = i(!1);
+  return {
+    model: d({
+      get() {
+        var t;
+        return l.value ? (t = e == null ? void 0 : e.modelValue) == null ? void 0 : t.value : f.modelValue ?? n.value;
+      },
+      set(t) {
+        var m, a;
+        l.value && E(t) ? (s.value = ((m = e == null ? void 0 : e.max) == null ? void 0 : m.value) !== void 0 && t.length > (e == null ? void 0 : e.max.value), s.value === !1 && ((a = e == null ? void 0 : e.changeEvent) == null || a.call(e, t))) : (o(g, t), n.value = t);
+      }
+    }),
+    isGroup: l,
+    isLimitExceeded: s
+  };
+};
+export {
+  L as useCheckboxModel
+};

package/es/components/checkbox/composables/use-checkbox-status.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentInternalInstance } from 'vue';
+import type { CheckboxProps } from '../checkbox.vue';
+import type { CheckboxModel } from '../composables';
+export declare const useCheckboxStatus: (props: CheckboxProps, slots: ComponentInternalInstance['slots'], { model }: Pick<CheckboxModel, 'model'>) => {
+    checkboxButtonSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+    isChecked: import("vue").ComputedRef<boolean>;
+    isFocused: import("vue").Ref<boolean>;
+    checkboxSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+    hasOwnLabel: import("vue").ComputedRef<boolean>;
+};
+export type CheckboxStatus = ReturnType<typeof useCheckboxStatus>;

package/es/components/checkbox/composables/use-checkbox-status.js

@@ -0,0 +1,33 @@
+import { inject as d, ref as v, computed as r, toRaw as i } from "vue";
+import { isEqual as z } from "lodash";
+import "../../form/index.js";
+import { isBoolean as S, isArray as h, isObject as x } from "@vft/utils";
+import { checkboxGroupContextKey as C } from "../constants.js";
+import { useFormSize as l } from "../../form/hooks/use-form-common-props.js";
+const F = (o, s, { model: n }) => {
+  const t = d(C, void 0), u = v(!1), a = r(() => {
+    const e = n.value;
+    return S(e) ? e : h(e) ? x(o.label) ? e.map(i).some((b) => z(b, o.label)) : e.map(i).includes(o.label) : e != null ? e === o.trueLabel : !!e;
+  }), m = l(
+    r(() => {
+      var e;
+      return (e = t == null ? void 0 : t.size) == null ? void 0 : e.value;
+    }),
+    {
+      prop: !0
+    }
+  ), c = l(r(() => {
+    var e;
+    return (e = t == null ? void 0 : t.size) == null ? void 0 : e.value;
+  })), f = r(() => !!(s.default || o.label));
+  return {
+    checkboxButtonSize: m,
+    isChecked: a,
+    isFocused: u,
+    checkboxSize: c,
+    hasOwnLabel: f
+  };
+};
+export {
+  F as useCheckboxStatus
+};

package/es/components/checkbox/composables/use-checkbox.d.ts

@@ -0,0 +1,15 @@
+import type { ComponentInternalInstance } from 'vue';
+import type { CheckboxProps } from '../checkbox.vue';
+export declare const useCheckbox: (props: CheckboxProps, slots: ComponentInternalInstance['slots']) => {
+    inputId: import("vue").Ref<string | undefined>;
+    isLabeledByFormItem: import("vue").ComputedRef<boolean>;
+    isChecked: import("vue").ComputedRef<boolean>;
+    isDisabled: import("vue").ComputedRef<boolean>;
+    isFocused: import("vue").Ref<boolean>;
+    checkboxButtonSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+    checkboxSize: import("vue").ComputedRef<"" | "default" | "small" | "large">;
+    hasOwnLabel: import("vue").ComputedRef<boolean>;
+    model: import("vue").WritableComputedRef<any>;
+    handleChange: (e: Event) => void;
+    onClickRoot: (e: MouseEvent) => Promise<void>;
+};

package/es/components/checkbox/composables/use-checkbox.js

@@ -0,0 +1,47 @@
+import "../../form/index.js";
+import { isArray as f } from "@vft/utils";
+import { useCheckboxDisabled as k } from "./use-checkbox-disabled.js";
+import { useCheckboxEvent as x } from "./use-checkbox-event.js";
+import { useCheckboxModel as C } from "./use-checkbox-model.js";
+import { useCheckboxStatus as v } from "./use-checkbox-status.js";
+import { useFormItem as F, useFormItemInputId as S } from "../../form/hooks/use-form-item.js";
+const L = (e, { model: t }) => {
+  function i() {
+    f(t.value) && !t.value.includes(e.label) ? t.value.push(e.label) : t.value = e.trueLabel || !0;
+  }
+  e.checked && i();
+}, M = (e, t) => {
+  const { formItem: i } = F(), { model: o, isGroup: u, isLimitExceeded: a } = C(e), {
+    isFocused: r,
+    isChecked: c,
+    checkboxButtonSize: l,
+    checkboxSize: d,
+    hasOwnLabel: s
+  } = v(e, t, { model: o }), { isDisabled: m } = k({ model: o, isChecked: c }), { inputId: b, isLabeledByFormItem: n } = S(e, {
+    formItemContext: i,
+    disableIdGeneration: s,
+    disableIdManagement: u
+  }), { handleChange: h, onClickRoot: I } = x(e, {
+    model: o,
+    isLimitExceeded: a,
+    hasOwnLabel: s,
+    isDisabled: m,
+    isLabeledByFormItem: n
+  });
+  return L(e, { model: o }), {
+    inputId: b,
+    isLabeledByFormItem: n,
+    isChecked: c,
+    isDisabled: m,
+    isFocused: r,
+    checkboxButtonSize: l,
+    checkboxSize: d,
+    hasOwnLabel: s,
+    model: o,
+    handleChange: h,
+    onClickRoot: I
+  };
+};
+export {
+  M as useCheckbox
+};

package/es/components/checkbox/constants.d.ts

@@ -0,0 +1,8 @@
+import type { InjectionKey, ToRefs, WritableComputedRef } from 'vue';
+import type { CheckboxGroupProps } from './checkbox-group.vue';
+type CheckboxGroupContext = {
+    modelValue?: WritableComputedRef<any>;
+    changeEvent?: (...args: any) => any;
+} & ToRefs<Pick<CheckboxGroupProps, 'size' | 'min' | 'max' | 'disabled' | 'validateEvent' | 'fill' | 'textColor'>>;
+export declare const checkboxGroupContextKey: InjectionKey<CheckboxGroupContext>;
+export {};

package/es/components/checkbox/constants.js

@@ -0,0 +1,4 @@
+const o = Symbol("checkboxGroupContextKey");
+export {
+  o as checkboxGroupContextKey
+};