@expcat/tigercat-vue 2.1.2 → 2.1.4

package/dist/chunk-7C7SG3SS.mjs

@@ -1,269 +0,0 @@
-import {
-  FORM_ITEM_CONTROL_INJECTION_KEY
-} from "./chunk-P2LZ2MR5.mjs";
-import {
-  useTigerConfig
-} from "./chunk-UOJOJBEU.mjs";
-
-// src/components/MaskInput.ts
-import { computed, defineComponent, h, inject, nextTick, ref, watch } from "vue";
-import {
-  applyMaskInput,
-  classNames,
-  coerceClassValue,
-  formatMaskValue,
-  getInputClasses,
-  getInputClearButtonClasses,
-  getInputErrorClasses,
-  getInputWrapperClasses,
-  injectShakeStyle,
-  mergeStyleValues,
-  parseMask,
-  SHAKE_CLASS
-} from "@expcat/tigercat-core";
-var maskInputIdCounter = 0;
-var MaskInput = defineComponent({
-  name: "TigerMaskInput",
-  inheritAttrs: false,
-  props: {
-    /**
-     * Raw (unmasked) value for v-model
-     */
-    modelValue: { type: String, default: void 0 },
-    /**
-     * Default raw value (for uncontrolled mode)
-     */
-    defaultValue: { type: String, default: "" },
-    /**
-     * Mask template. Built-in tokens: `#` digit, `a` letter, `*` alphanumeric,
-     * `!` escapes the next character to a literal
-     */
-    mask: { type: String, required: true },
-    /**
-     * Custom tokens merged over the built-ins
-     */
-    tokens: { type: Object, default: void 0 },
-    /**
-     * Input size
-     * @default 'md'
-     */
-    size: { type: String, default: "md" },
-    /**
-     * Validation status
-     * @default 'default'
-     */
-    status: { type: String, default: "default" },
-    /** Error message to display */
-    errorMessage: String,
-    /** Placeholder text */
-    placeholder: { type: String, default: "" },
-    /** Whether the input is disabled */
-    disabled: Boolean,
-    /** Whether the input is readonly */
-    readonly: Boolean,
-    /** Whether to show a clear button when the input has value */
-    clearable: Boolean,
-    /**
-     * Input name attribute. When set, a hidden input with this name submits the
-     * raw (unmasked) value; the visible field displays the mask and has no name.
-     */
-    name: String,
-    /** Input id attribute */
-    id: String,
-    /** Autocomplete attribute */
-    autoComplete: String,
-    /** Whether to autofocus on mount */
-    autoFocus: Boolean,
-    /**
-     * Internal shake trigger counter (used by FormItem)
-     * @internal
-     */
-    _shakeTrigger: { type: Number, default: void 0 },
-    /** Additional CSS classes */
-    className: String,
-    /** Inline styles */
-    style: { type: Object, default: void 0 }
-  },
-  emits: {
-    "update:modelValue": null,
-    change: null,
-    complete: null,
-    focus: null,
-    blur: null,
-    clear: null
-  },
-  setup(props, { emit, attrs }) {
-    injectShakeStyle();
-    const formItemControl = inject(
-      FORM_ITEM_CONTROL_INJECTION_KEY,
-      null
-    );
-    useTigerConfig();
-    const effectiveStatus = computed(
-      () => props.status !== "default" ? props.status : formItemControl?.status.value ?? props.status
-    );
-    const effectiveErrorMessage = computed(
-      () => props.errorMessage ?? formItemControl?.errorMessage.value
-    );
-    const effectiveShakeTrigger = computed(
-      () => props._shakeTrigger ?? formItemControl?.shakeTrigger.value
-    );
-    const instanceId = ++maskInputIdCounter;
-    const errorMsgId = `tiger-mask-input-error-${instanceId}`;
-    const wrapperRef = ref(null);
-    const inputRef = ref(null);
-    const isComposing = ref(false);
-    const spec = computed(() => parseMask(props.mask, props.tokens));
-    const isControlled = computed(() => props.modelValue !== void 0);
-    const innerRaw = ref(props.defaultValue ?? "");
-    const rawValue = computed(
-      () => isControlled.value ? props.modelValue ?? "" : innerRaw.value
-    );
-    const formatted = computed(() => formatMaskValue(rawValue.value, spec.value));
-    const maskedValue = computed(() => formatted.value.maskedValue);
-    watch([effectiveStatus, effectiveShakeTrigger], ([newStatus]) => {
-      if (newStatus === "error" && wrapperRef.value) {
-        const el = wrapperRef.value;
-        el.classList.remove(SHAKE_CLASS);
-        void el.offsetWidth;
-        el.classList.add(SHAKE_CLASS);
-      }
-    });
-    const commit = (raw, detail, previousMasked) => {
-      if (!isControlled.value) innerRaw.value = raw;
-      emit("update:modelValue", raw);
-      emit("change", raw, detail);
-      if (detail.completed && !formatMaskValue(previousMasked, spec.value).completed) {
-        emit("complete", raw, detail.maskedValue);
-      }
-    };
-    const applyValue = (inputValue, caret) => {
-      const previousMasked = maskedValue.value;
-      const result = applyMaskInput(inputValue, caret, spec.value, previousMasked);
-      if (inputRef.value) inputRef.value.value = result.maskedValue;
-      commit(
-        result.rawValue,
-        { maskedValue: result.maskedValue, completed: result.completed },
-        previousMasked
-      );
-      nextTick(() => {
-        if (inputRef.value) inputRef.value.setSelectionRange(result.caret, result.caret);
-      });
-    };
-    const processInput = (target) => {
-      applyValue(target.value, target.selectionStart ?? target.value.length);
-    };
-    const handleInput = (event) => {
-      if (isComposing.value) return;
-      processInput(event.target);
-    };
-    const handlePaste = (event) => {
-      if (props.disabled || props.readonly) return;
-      event.preventDefault();
-      const input = event.target;
-      const text = event.clipboardData?.getData("text") ?? "";
-      const start = input.selectionStart ?? input.value.length;
-      const end = input.selectionEnd ?? input.value.length;
-      applyValue(input.value.slice(0, start) + text + input.value.slice(end), start + text.length);
-    };
-    const handleCompositionStart = () => {
-      isComposing.value = true;
-    };
-    const handleCompositionEnd = (event) => {
-      isComposing.value = false;
-      processInput(event.target);
-    };
-    const handleClear = () => {
-      if (!isControlled.value) innerRaw.value = "";
-      emit("update:modelValue", "");
-      emit("change", "", { maskedValue: "", completed: false });
-      emit("clear");
-      inputRef.value?.focus();
-    };
-    const handleFocus = (event) => emit("focus", event);
-    const handleBlur = (event) => emit("blur", event);
-    return () => {
-      const { class: attrClass, style: attrStyle, ...restAttrs } = attrs;
-      const activeError = effectiveStatus.value === "error" && !!effectiveErrorMessage.value;
-      const hasSuffix = props.clearable;
-      const showClear = props.clearable && !props.disabled && !props.readonly && rawValue.value.length > 0;
-      const inputClasses = getInputClasses({
-        size: props.size,
-        status: effectiveStatus.value,
-        hasPrefix: false,
-        hasSuffix
-      });
-      const children = [
-        h("input", {
-          ...restAttrs,
-          ref: inputRef,
-          class: inputClasses,
-          type: "text",
-          value: maskedValue.value,
-          placeholder: props.placeholder,
-          disabled: props.disabled,
-          readonly: props.readonly,
-          id: props.id,
-          autocomplete: props.autoComplete,
-          autofocus: props.autoFocus,
-          ...effectiveStatus.value === "error" ? { "aria-invalid": true } : {},
-          ...activeError ? { "aria-describedby": errorMsgId } : {},
-          onInput: handleInput,
-          onPaste: handlePaste,
-          onCompositionstart: handleCompositionStart,
-          onCompositionend: handleCompositionEnd,
-          onFocus: handleFocus,
-          onBlur: handleBlur
-        })
-      ];
-      if (props.name) {
-        children.push(
-          h("input", {
-            key: "hidden",
-            type: "hidden",
-            name: props.name,
-            value: rawValue.value
-          })
-        );
-      }
-      if (activeError) {
-        children.push(
-          h(
-            "div",
-            { id: errorMsgId, class: getInputErrorClasses(props.size), "aria-live": "polite" },
-            effectiveErrorMessage.value
-          )
-        );
-      } else if (showClear) {
-        children.push(
-          h(
-            "button",
-            {
-              type: "button",
-              class: getInputClearButtonClasses(props.size),
-              onClick: handleClear,
-              "aria-label": "Clear input",
-              tabindex: -1
-            },
-            "\u2715"
-          )
-        );
-      }
-      return h(
-        "div",
-        {
-          ref: wrapperRef,
-          class: classNames(getInputWrapperClasses(), props.className, coerceClassValue(attrClass)),
-          style: mergeStyleValues(props.style, attrStyle)
-        },
-        children
-      );
-    };
-  }
-});
-var MaskInput_default = MaskInput;
-
-export {
-  MaskInput,
-  MaskInput_default
-};

package/dist/chunk-7FWNN6PO.mjs

@@ -1,296 +0,0 @@
-import {
-  useTigerConfig
-} from "./chunk-UOJOJBEU.mjs";
-
-// src/components/CronEditor.ts
-import { computed, defineComponent, h, ref } from "vue";
-import {
-  buildCronFieldValue,
-  classNames,
-  coerceClassValue,
-  cronEditorBaseClasses,
-  cronEditorErrorClasses,
-  cronEditorFieldClasses,
-  cronEditorFieldsClasses,
-  cronEditorLabelClasses,
-  cronFieldMetas,
-  defaultCronExpression,
-  getCronEditorControlClasses,
-  getCronEditorLabels,
-  getCronFieldIssue,
-  getCronFieldValue,
-  mergeTigerLocale,
-  normalizeCronExpression,
-  parseCronFieldControl,
-  updateCronExpressionField,
-  validateCronExpressionWithLabels
-} from "@expcat/tigercat-core";
-var modeOptions = [
-  { label: "Any", value: "any" },
-  { label: "Every", value: "every" },
-  { label: "Specific", value: "specific" },
-  { label: "Range", value: "range" },
-  { label: "Custom", value: "custom" }
-];
-function formatCronControlLabel(template, field) {
-  return template.replace("{field}", field);
-}
-var CronEditor = defineComponent({
-  name: "TigerCronEditor",
-  props: {
-    modelValue: { type: String, default: void 0 },
-    defaultValue: { type: String, default: defaultCronExpression },
-    disabled: { type: Boolean, default: false },
-    readonly: { type: Boolean, default: false },
-    size: { type: String, default: "md" },
-    presets: { type: Array, default: void 0 },
-    ariaLabel: { type: String, default: void 0 },
-    locale: { type: Object, default: void 0 },
-    labels: { type: Object, default: void 0 }
-  },
-  emits: ["update:modelValue", "change", "validate"],
-  setup(props, { attrs, emit }) {
-    const config = useTigerConfig();
-    const innerValue = ref(props.defaultValue);
-    const expression = computed(() => props.modelValue ?? innerValue.value);
-    const mergedLocale = computed(() => mergeTigerLocale(config.value.locale, props.locale));
-    const labels = computed(() => getCronEditorLabels(mergedLocale.value, props.labels));
-    const fieldLabels = computed(() => ({
-      minute: labels.value.minuteLabel,
-      hour: labels.value.hourLabel,
-      dayOfMonth: labels.value.dayOfMonthLabel,
-      month: labels.value.monthLabel,
-      dayOfWeek: labels.value.dayOfWeekLabel
-    }));
-    const validation = computed(
-      () => validateCronExpressionWithLabels(expression.value, labels.value, fieldLabels.value)
-    );
-    const inactive = computed(() => props.disabled || props.readonly);
-    const localizedMetas = computed(
-      () => cronFieldMetas.map((meta) => ({ ...meta, label: fieldLabels.value[meta.key] }))
-    );
-    const resolvedPresets = computed(
-      () => props.presets ?? [
-        { label: labels.value.everyMinutePreset, value: "* * * * *" },
-        { label: labels.value.hourlyPreset, value: "0 * * * *" },
-        { label: labels.value.dailyPreset, value: "0 0 * * *" },
-        { label: labels.value.weeklyPreset, value: "0 0 * * 1" },
-        { label: labels.value.monthlyPreset, value: "0 0 1 * *" }
-      ]
-    );
-    const modeLabels = computed(() => ({
-      any: labels.value.modeAnyLabel,
-      every: labels.value.modeEveryLabel,
-      specific: labels.value.modeSpecificLabel,
-      range: labels.value.modeRangeLabel,
-      custom: labels.value.modeCustomLabel
-    }));
-    function commit(nextValue) {
-      const normalized = normalizeCronExpression(nextValue);
-      const nextValidation = validateCronExpressionWithLabels(
-        normalized,
-        labels.value,
-        fieldLabels.value
-      );
-      if (props.modelValue === void 0) innerValue.value = normalized;
-      emit("update:modelValue", normalized);
-      emit("change", normalized, nextValidation);
-      emit("validate", nextValidation);
-    }
-    function handleRawExpressionChange(nextValue) {
-      const nextValidation = validateCronExpressionWithLabels(
-        nextValue,
-        labels.value,
-        fieldLabels.value
-      );
-      if (props.modelValue === void 0) innerValue.value = nextValue;
-      emit("update:modelValue", nextValue);
-      emit("change", nextValue, nextValidation);
-      emit("validate", nextValidation);
-    }
-    function handleFieldRawChange(meta, raw) {
-      commit(updateCronExpressionField(expression.value, meta.key, raw));
-    }
-    function handleModeChange(meta, control, mode) {
-      const nextControl = {
-        ...control,
-        mode,
-        value: control.value ?? meta.min,
-        start: control.start ?? meta.min,
-        end: control.end ?? meta.max,
-        step: control.step ?? 1
-      };
-      handleFieldRawChange(meta, buildCronFieldValue(nextControl, meta));
-    }
-    function renderFieldControl(meta, control) {
-      if (control.mode === "any") return void 0;
-      if (control.mode === "every") {
-        return h("input", {
-          type: "number",
-          min: 1,
-          max: meta.max,
-          class: getCronEditorControlClasses(props.size),
-          value: control.step ?? 1,
-          disabled: inactive.value,
-          "aria-label": formatCronControlLabel(labels.value.stepAriaLabel, meta.label),
-          onInput: (event) => handleFieldRawChange(
-            meta,
-            buildCronFieldValue(
-              { ...control, step: Number(event.target.value) },
-              meta
-            )
-          )
-        });
-      }
-      if (control.mode === "specific") {
-        return h("input", {
-          type: "number",
-          min: meta.min,
-          max: meta.max,
-          class: getCronEditorControlClasses(props.size),
-          value: control.value ?? meta.min,
-          disabled: inactive.value,
-          "aria-label": formatCronControlLabel(labels.value.valueAriaLabel, meta.label),
-          onInput: (event) => handleFieldRawChange(
-            meta,
-            buildCronFieldValue(
-              { ...control, value: Number(event.target.value) },
-              meta
-            )
-          )
-        });
-      }
-      if (control.mode === "range") {
-        return h("div", { class: "grid grid-cols-2 gap-1" }, [
-          h("input", {
-            type: "number",
-            min: meta.min,
-            max: meta.max,
-            class: getCronEditorControlClasses(props.size),
-            value: control.start ?? meta.min,
-            disabled: inactive.value,
-            "aria-label": formatCronControlLabel(labels.value.rangeStartAriaLabel, meta.label),
-            onInput: (event) => handleFieldRawChange(
-              meta,
-              buildCronFieldValue(
-                { ...control, start: Number(event.target.value) },
-                meta
-              )
-            )
-          }),
-          h("input", {
-            type: "number",
-            min: meta.min,
-            max: meta.max,
-            class: getCronEditorControlClasses(props.size),
-            value: control.end ?? meta.max,
-            disabled: inactive.value,
-            "aria-label": formatCronControlLabel(labels.value.rangeEndAriaLabel, meta.label),
-            onInput: (event) => handleFieldRawChange(
-              meta,
-              buildCronFieldValue(
-                { ...control, end: Number(event.target.value) },
-                meta
-              )
-            )
-          })
-        ]);
-      }
-      return h("input", {
-        type: "text",
-        class: getCronEditorControlClasses(props.size),
-        value: control.raw,
-        disabled: inactive.value,
-        "aria-label": formatCronControlLabel(labels.value.customValueAriaLabel, meta.label),
-        onInput: (event) => handleFieldRawChange(meta, event.target.value)
-      });
-    }
-    return () => h(
-      "div",
-      {
-        class: classNames(cronEditorBaseClasses, coerceClassValue(attrs.class)),
-        role: "group",
-        "aria-label": props.ariaLabel ?? labels.value.ariaLabel
-      },
-      [
-        h("div", { class: "flex flex-col gap-2 sm:flex-row" }, [
-          h("input", {
-            type: "text",
-            class: classNames(
-              getCronEditorControlClasses(props.size, !validation.value.valid),
-              "flex-1"
-            ),
-            value: expression.value,
-            disabled: props.disabled,
-            readonly: props.readonly,
-            "aria-label": labels.value.expressionAriaLabel,
-            onInput: (event) => handleRawExpressionChange(event.target.value)
-          }),
-          resolvedPresets.value.length > 0 ? h(
-            "select",
-            {
-              class: getCronEditorControlClasses(props.size),
-              value: resolvedPresets.value.some((preset) => preset.value === expression.value) ? expression.value : "",
-              disabled: inactive.value,
-              "aria-label": labels.value.presetAriaLabel,
-              onChange: (event) => {
-                const nextValue = event.target.value;
-                if (nextValue) commit(nextValue);
-              }
-            },
-            [
-              h("option", { value: "" }, labels.value.presetPlaceholder),
-              ...resolvedPresets.value.map(
-                (preset) => h("option", { key: preset.value, value: preset.value }, preset.label)
-              )
-            ]
-          ) : void 0
-        ]),
-        ...validation.value.issues.filter((issue) => issue.field === "expression").map(
-          (issue) => h("div", { key: issue.message, class: cronEditorErrorClasses }, issue.message)
-        ),
-        h(
-          "div",
-          { class: cronEditorFieldsClasses },
-          localizedMetas.value.map((meta) => {
-            const raw = getCronFieldValue(expression.value, meta.key);
-            const control = parseCronFieldControl(raw);
-            const issue = getCronFieldIssue(validation.value, meta.key);
-            return h("div", { key: meta.key, class: cronEditorFieldClasses }, [
-              h("label", { class: cronEditorLabelClasses }, meta.label),
-              h(
-                "select",
-                {
-                  class: getCronEditorControlClasses(props.size, !!issue),
-                  value: control.mode,
-                  disabled: inactive.value,
-                  "aria-label": formatCronControlLabel(labels.value.modeAriaLabel, meta.label),
-                  onChange: (event) => handleModeChange(
-                    meta,
-                    control,
-                    event.target.value
-                  )
-                },
-                modeOptions.map(
-                  (mode) => h(
-                    "option",
-                    { key: mode.value, value: mode.value },
-                    modeLabels.value[mode.value]
-                  )
-                )
-              ),
-              renderFieldControl(meta, control),
-              issue ? h("div", { class: cronEditorErrorClasses }, issue.message) : void 0
-            ]);
-          })
-        )
-      ]
-    );
-  }
-});
-var CronEditor_default = CronEditor;
-
-export {
-  CronEditor,
-  CronEditor_default
-};