vlite3 1.4.31 → 1.4.33

package/components/Chart/GanttChartDependencyUtils.js

@@ -0,0 +1,109 @@
+import { GANTT_DEPENDENCY_TYPE_LABELS as f } from "./types.js";
+function D(e) {
+  return f[e];
+}
+function l(e) {
+  const i = /* @__PURE__ */ new Map(), r = (n, t) => {
+    !n || !t || n === t || i.set(p(n, t), {
+      predecessorId: n,
+      successorId: t
+    });
+  };
+  for (const n of e) {
+    for (const t of n.dependencies ?? [])
+      r(t, n.id);
+    for (const t of n.dependencyLinks ?? [])
+      t.type !== "related-to" && (t.type === "waiting-on" ? r(t.taskId, n.id) : t.type === "blocking" && r(n.id, t.taskId));
+  }
+  return [...i.values()];
+}
+function d(e, i, r) {
+  return l(e).some(
+    (n) => n.predecessorId === i && n.successorId === r
+  );
+}
+function h(e, i, r = 8) {
+  const n = e.y + i / 2;
+  if (e.milestone) {
+    const t = i * 0.4;
+    return { cx: e.x + e.fullW / 2 + t + r * 0.5, cy: n };
+  }
+  return { cx: e.x + e.fullW + r, cy: n };
+}
+function v(e, i, r, n, t = 4) {
+  for (let c = e.length - 1; c >= 0; c--) {
+    const o = e[c];
+    if (o.milestone) {
+      const s = o.x + o.fullW / 2, a = o.y + n / 2, u = n * 0.4 + t;
+      if (Math.abs(i - s) <= u && Math.abs(r - a) <= u) return o;
+      continue;
+    }
+    if (i >= o.x - t && i <= o.x + o.fullW + t && r >= o.y - t && r <= o.y + n + t)
+      return o;
+  }
+  return null;
+}
+function y(e, i, r) {
+  if (i === r) return !0;
+  const n = /* @__PURE__ */ new Map();
+  for (const o of l(e)) {
+    const s = n.get(o.successorId) ?? [];
+    s.push(o.predecessorId), n.set(o.successorId, s);
+  }
+  const t = /* @__PURE__ */ new Set(), c = [i];
+  for (; c.length; ) {
+    const o = c.shift();
+    if (t.has(o)) continue;
+    t.add(o);
+    const s = n.get(o);
+    if (s?.length)
+      for (const a of s) {
+        if (a === r) return !0;
+        t.has(a) || c.push(a);
+      }
+  }
+  return !1;
+}
+function $(e, i, r) {
+  if (i === r)
+    return { valid: !1, reason: "self" };
+  const n = e.find((c) => c.id === i), t = e.find((c) => c.id === r);
+  return n ? t ? d(e, i, r) ? { valid: !1, reason: "duplicate" } : y(e, i, r) ? { valid: !1, reason: "circular" } : { valid: !0 } : { valid: !1, reason: "missing-successor" } : { valid: !1, reason: "missing-predecessor" };
+}
+function k(e, i, r) {
+  if (e.valid === !0)
+    return `Dependency requested: ${r} waiting on ${i}`;
+  switch ("reason" in e ? e.reason : void 0) {
+    case "self":
+      return `Cannot create a dependency from ${i} to itself`;
+    case "duplicate":
+      return `${r} is already waiting on ${i}`;
+    case "circular":
+      return `Cannot link ${i} to ${r}: would create a circular dependency`;
+    case "missing-predecessor":
+      return "Predecessor task is not available";
+    case "missing-successor":
+      return "Successor task is not available";
+    default:
+      return "Invalid dependency target";
+  }
+}
+function p(e, i) {
+  return `${e}\0${i}`;
+}
+function x(e, i, r, n = 40, t = 14) {
+  let c = 0, o = 0;
+  return e < r.left + n ? c = -t : e > r.right - n && (c = t), i < r.top + n ? o = -t : i > r.bottom - n && (o = t), { dx: c, dy: o };
+}
+export {
+  k as describeGanttDependencyLinkValidation,
+  v as findGanttDependencyBarAtPoint,
+  p as ganttDependencyEdgeKey,
+  y as ganttDependencyReachable,
+  D as ganttDependencyTypeLabel,
+  h as getGanttDependencyConnectorPosition,
+  x as getGanttDependencyEdgeScrollDelta,
+  d as hasGanttScheduleDependency,
+  l as resolveGanttScheduleDependencyEdges,
+  $ as validateGanttDependencyLink
+};

package/components/Chart/GanttChartResizePreviewUtils.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Pure resize/move preview math for GanttChart.
+ * Preview snapping must match the values emitted on pointer release.
+ */
+export type GanttInteractionMode = 'move' | 'resize-left' | 'resize-right';
+export type GanttInteractionPreview = {
+    /** Half-day-snapped day delta applied to the interaction */
+    snappedDays: number;
+    /** Pixel delta after min-duration clamp (pre-snap) */
+    clampedPxDelta: number;
+    start: Date;
+    end: Date;
+};
+/** Same snap used on drag end — half-day increments */
+export declare function snapGanttDayDelta(daysDelta: number): number;
+/**
+ * Clamp a resize pixel delta so the task never shrinks below min duration.
+ */
+export declare function clampGanttResizePxDelta(input: {
+    mode: 'resize-left' | 'resize-right';
+    pxDelta: number;
+    origDurationDays: number;
+    pxToDays: (px: number) => number;
+    daysToPx: (days: number) => number;
+    minDurationDays?: number;
+}): number;
+/**
+ * Compute temporary preview dates for move/resize.
+ * Uses the same half-day snap and min-duration rules as the final emission.
+ */
+export declare function computeGanttInteractionPreview(input: {
+    mode: GanttInteractionMode;
+    pxDelta: number;
+    origStart: Date;
+    origEnd: Date;
+    origDurationDays: number;
+    pxToDays: (px: number) => number;
+    daysToPx: (days: number) => number;
+    addDays: (d: Date, n: number) => Date;
+    minDurationDays?: number;
+}): GanttInteractionPreview;
+/** Pixel geometry for a temporary preview bar derived from preview dates */
+export declare function ganttPreviewBarGeometry(input: {
+    start: Date;
+    end: Date;
+    dateToX: (d: Date) => number;
+    minWidthPx?: number;
+}): {
+    x: number;
+    fullW: number;
+    xEnd: number;
+};

package/components/Chart/GanttChartResizePreviewUtils.js

@@ -0,0 +1,53 @@
+function D(a) {
+  return Math.round(a * 2) / 2;
+}
+function d(a) {
+  const o = a.minDurationDays ?? 0.5, r = a.pxToDays(a.pxDelta), e = a.origDurationDays;
+  return a.mode === "resize-left" && r >= e - o ? a.daysToPx(e - o) : a.mode === "resize-right" && -r >= e - o ? -a.daysToPx(e - o) : a.pxDelta;
+}
+function n(a) {
+  const o = a.minDurationDays ?? 0.5;
+  let r = a.pxDelta;
+  (a.mode === "resize-left" || a.mode === "resize-right") && (r = d({
+    mode: a.mode,
+    pxDelta: a.pxDelta,
+    origDurationDays: a.origDurationDays,
+    pxToDays: a.pxToDays,
+    daysToPx: a.daysToPx,
+    minDurationDays: o
+  }));
+  let e = D(a.pxToDays(r));
+  if (a.mode === "move")
+    return {
+      snappedDays: e,
+      clampedPxDelta: r,
+      start: a.addDays(a.origStart, e),
+      end: a.addDays(a.origEnd, e)
+    };
+  if (a.mode === "resize-left") {
+    const s = a.origDurationDays - o;
+    return e = Math.min(e, s), {
+      snappedDays: e,
+      clampedPxDelta: r,
+      start: a.addDays(a.origStart, e),
+      end: new Date(a.origEnd.getTime())
+    };
+  }
+  const t = -(a.origDurationDays - o);
+  return e = Math.max(e, t), {
+    snappedDays: e,
+    clampedPxDelta: r,
+    start: new Date(a.origStart.getTime()),
+    end: a.addDays(a.origEnd, e)
+  };
+}
+function m(a) {
+  const o = a.dateToX(a.start), r = a.dateToX(a.end), e = Math.max(a.minWidthPx ?? 8, r - o);
+  return { x: o, fullW: e, xEnd: o + e };
+}
+export {
+  d as clampGanttResizePxDelta,
+  n as computeGanttInteractionPreview,
+  m as ganttPreviewBarGeometry,
+  D as snapGanttDayDelta
+};

package/components/Chart/GanttChartTooltipUtils.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Pure tooltip placement helpers for GanttChart.
+ * Keeps task tooltips clear of the dependency connector and viewport edges.
+ */
+/** Axis-aligned screen rect to steer the tooltip away from */
+export type GanttTooltipAvoidRect = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+export type GanttTooltipPlaceInput = {
+    pointerX: number;
+    pointerY: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    /** Estimated tooltip box — used only for collision / clamping */
+    estimatedWidth?: number;
+    estimatedHeight?: number;
+    /** Optional region to avoid (e.g. dependency connector hit area in screen space) */
+    avoid?: GanttTooltipAvoidRect | null;
+    gap?: number;
+    /** Extra shift below the pointer (positive moves tooltip down) */
+    offsetBottom?: number;
+    margin?: number;
+};
+export type GanttTooltipPlaceResult = {
+    left: number;
+    top: number;
+};
+/**
+ * Place a Gantt task tooltip near the pointer while avoiding an optional
+ * connector rect and staying inside the viewport.
+ * Prefers sitting just below the task/pointer so it does not cover the connector.
+ */
+export declare function placeGanttTaskTooltip(input: GanttTooltipPlaceInput): GanttTooltipPlaceResult;
+/**
+ * Whether a pointer in SVG space is inside the connector clear zone
+ * (hide tooltip rather than fighting overlap).
+ */
+export declare function isGanttPointerNearConnector(pointerSvgX: number, pointerSvgY: number, connectorSvgX: number, connectorSvgY: number, radius?: number): boolean;

package/components/Chart/GanttChartTooltipUtils.js

@@ -0,0 +1,63 @@
+function d(f, t, a, s, p) {
+  const o = f + a, e = t + s;
+  return !(o < p.left || f > p.right || e < p.top || t > p.bottom);
+}
+function m(f, t, a, s, p, o, e) {
+  return {
+    left: Math.max(e, Math.min(f, Math.max(e, p - a - e))),
+    top: Math.max(e, Math.min(t, Math.max(e, o - s - e)))
+  };
+}
+function x(f) {
+  const {
+    pointerX: t,
+    pointerY: a,
+    viewportWidth: s,
+    viewportHeight: p,
+    estimatedWidth: o = 200,
+    estimatedHeight: e = 120,
+    avoid: i = null,
+    gap: n = 12,
+    offsetBottom: M = 16,
+    margin: u = 8
+  } = f, l = a + M, h = [];
+  i && (h.push({
+    left: t + n,
+    top: Math.max(l, i.bottom + n)
+  }), h.push({
+    left: i.left - o - n,
+    top: Math.max(l, i.bottom + n)
+  }), h.push({
+    left: Math.min(t, i.left) - o - n,
+    top: l
+  })), h.push({ left: t + n, top: l }), h.push({ left: t - o - n, top: l }), h.push({ left: t - o / 2, top: l }), h.push({ left: t + n, top: a - n }), h.push({ left: t - o / 2, top: a - e - n });
+  for (const c of h) {
+    const r = m(
+      c.left,
+      c.top,
+      o,
+      e,
+      s,
+      p,
+      u
+    );
+    if (!i || !d(r.left, r.top, o, e, i))
+      return r;
+  }
+  return m(
+    t - o - n,
+    l,
+    o,
+    e,
+    s,
+    p,
+    u
+  );
+}
+function b(f, t, a, s, p = 16) {
+  return Math.hypot(f - a, t - s) <= p;
+}
+export {
+  b as isGanttPointerNearConnector,
+  x as placeGanttTaskTooltip
+};

package/components/Chart/index.d.ts

@@ -9,5 +9,7 @@ export { default as SegmentBarChart } from './SegmentBarChart.vue';
 export { default as StatCardChart } from './StatCardChart.vue';
 export { default as WaffleChart } from './WaffleChart.vue';
 export { default as GanttChart } from './GanttChart.vue';
-export type { ChartDataPoint, ChartDataset, ChartLegendsVariant, LegendPosition, LineChartProps, BarChartProps, PieChartProps, CircleChartProps, GaugeChartProps, GaugeVariant, GaugeZone, SpeedometerChartProps, SpeedometerVariant, TimelineChartProps, TimelineTask, SegmentBarChartProps, StatCardChartProps, StatCardItem, WaffleChartProps, GanttChartProps, GanttTask, GanttViewMode, } from './types';
+export type { ChartDataPoint, ChartDataset, ChartLegendsVariant, LegendPosition, LineChartProps, BarChartProps, PieChartProps, CircleChartProps, GaugeChartProps, GaugeVariant, GaugeZone, SpeedometerChartProps, SpeedometerVariant, TimelineChartProps, TimelineTask, SegmentBarChartProps, StatCardChartProps, StatCardItem, WaffleChartProps, GanttChartProps, GanttTask, GanttViewMode, GanttDependencyType, GanttTaskDependencyLink, GanttDependencyCreatePayload, GanttDependencyDeletePayload, } from './types';
+export { GANTT_DEPENDENCY_TYPE_LABELS } from './types';
+export { formatGanttLocalDate, parseGanttDate, ganttDateToX, ganttCalendarDaysBetween, } from './GanttChartDateUtils';
 export { default as ChartLegend } from './ChartLegend.vue';

package/components/Chart/types.d.ts

@@ -362,6 +362,30 @@ export interface WaffleChartProps {
 }
 /** View granularity for the Gantt time axis */
 export type GanttViewMode = 'day' | 'week' | 'month';
+/**
+ * User-facing dependency type from the **owning task's** perspective.
+ *
+ * - `waiting-on` — this task cannot proceed until `taskId` is completed
+ * - `blocking` — this task prevents `taskId` from proceeding
+ * - `related-to` — connected, but does not schedule-block (no Gantt arrow)
+ *
+ * `waiting-on` and `blocking` are opposite views of one schedule edge:
+ * "B waiting on A" === "A blocking B". Parents should persist one canonical
+ * record (e.g. BLOCKS with blockingTaskId=A, waitingTaskId=B).
+ */
+export type GanttDependencyType = 'waiting-on' | 'blocking' | 'related-to';
+/** Display labels for the Type | Task selector pattern */
+export declare const GANTT_DEPENDENCY_TYPE_LABELS: Record<GanttDependencyType, string>;
+/**
+ * Typed dependency link on a Gantt task.
+ * Only `waiting-on` / `blocking` contribute to schedule arrows; `related-to` does not.
+ */
+export interface GanttTaskDependencyLink {
+    /** The other task in this relationship */
+    taskId: string;
+    /** Relationship from THIS task's perspective */
+    type: GanttDependencyType;
+}
 /** A single task (or milestone) on the Gantt chart */
 export interface GanttTask {
     /** Unique identifier for this task */
@@ -378,10 +402,28 @@ export interface GanttTask {
     color?: string;
     /** Group label — tasks sharing the same group are visually grouped */
     group?: string;
-    /** IDs of tasks this task depends on. Renders dependency arrows */
+    /**
+     * Legacy / shorthand: IDs of tasks this task is **waiting on** (predecessors).
+     * Renders finish-to-start dependency arrows. Equivalent to
+     * `dependencyLinks: [{ taskId, type: 'waiting-on' }, ...]`.
+     */
     dependencies?: string[];
+    /**
+     * Typed user-facing dependency links (Waiting on / Blocking / Related to).
+     * Schedule arrows are drawn only for waiting-on / blocking edges.
+     * `related-to` is retained for parent UIs and never draws an arrow.
+     */
+    dependencyLinks?: GanttTaskDependencyLink[];
     /** If true, renders as a diamond milestone marker instead of a bar */
     milestone?: boolean;
+    /**
+     * Presentational blocked state (e.g. waiting on incomplete work or manually
+     * blocked). Renders a hatched overlay + lock marker on the bar and a
+     * blocked line in the tooltip. Purely visual — parents own the rule.
+     */
+    blocked?: boolean;
+    /** Short human-readable reason shown in the tooltip when `blocked` */
+    blockedReason?: string;
 }
 export interface GanttChartProps {
     /** Array of task objects */
@@ -422,8 +464,56 @@ export interface GanttChartProps {
     locale?: string;
     /** Allow drag-and-drop to move/resize tasks */
     draggable?: boolean;
-    /** When moving a task, also shift all dependent tasks recursively */
+    /**
+     * Opt-in: show dependency connectors and allow creating links by drag
+     * (or keyboard). Independent of `showDependencies` (which only controls
+     * rendering of existing arrows). Default `false` for backward compatibility.
+     */
+    editableDependencies?: boolean;
+    /**
+     * When moving a task, dependent tasks visually FOLLOW during the drag as a
+     * preview. On release only ONE `task-update` is emitted (the root task) —
+     * the parent/server owns the authoritative cascade and passes the final
+     * dates back through `tasks`. (The pre-1.x behavior of emitting one update
+     * per dependent task is removed: it produced N independent writes with no
+     * transactional guarantee.)
+     */
     cascadeDependencies?: boolean;
     /** Show zoom controls and enable Ctrl/Meta + wheel zoom */
     zoom?: boolean;
 }
+/**
+ * Payload emitted by GanttChart `@dependency-create`.
+ * Parent should persist one canonical schedule edge
+ * (successor waiting on predecessor / predecessor blocking successor)
+ * and pass updated `tasks` back — the chart never mutates tasks.
+ */
+export interface GanttDependencyCreatePayload {
+    /** Task that must finish first (source / arrow origin) */
+    predecessorId: string;
+    /** Task that waits on the predecessor */
+    successorId: string;
+    predecessor: GanttTask;
+    successor: GanttTask;
+    /**
+     * User-facing type from the **successor's** perspective.
+     * Connector linking always emits `waiting-on`
+     * (successor Waiting on | predecessor).
+     */
+    type: Extract<GanttDependencyType, 'waiting-on'>;
+    /** Localized-ready label, e.g. "Waiting on" */
+    typeLabel: string;
+}
+/**
+ * Payload emitted by GanttChart `@dependency-delete`.
+ * Parent should remove the canonical schedule edge and update `tasks`.
+ */
+export interface GanttDependencyDeletePayload {
+    predecessorId: string;
+    successorId: string;
+    predecessor: GanttTask;
+    successor: GanttTask;
+    /** Same semantics as create — schedule edge from successor's view */
+    type: Extract<GanttDependencyType, 'waiting-on'>;
+    typeLabel: string;
+}

package/components/Chart/types.js

@@ -0,0 +1,8 @@
+const o = {
+  "waiting-on": "Waiting on",
+  blocking: "Blocking",
+  "related-to": "Related to"
+};
+export {
+  o as GANTT_DEPENDENCY_TYPE_LABELS
+};

package/components/ColorPicker/ColorIro.vue2.js

@@ -0,0 +1,155 @@
+import { defineComponent as T, ref as x, computed as _, watch as u, onMounted as B, onUnmounted as P, openBlock as a, createElementBlock as b, createVNode as R, unref as S, createBlock as z, createCommentVNode as p, createElementVNode as L, normalizeStyle as V, renderSlot as I, nextTick as M } from "vue";
+import c from "@jaames/iro";
+import { useEyeDropper as N } from "@vueuse/core";
+import d from "../Button.vue.js";
+import { COLOR_PICKER_RESET_VALUE as $ } from "./constants.js";
+const D = { class: "space-y-3 w-max" }, F = {
+  key: 0,
+  class: "flex gap-2 mb-2.5 -text-fs-3 pr-0.5"
+}, j = /* @__PURE__ */ T({
+  __name: "ColorIro",
+  props: {
+    color: {},
+    showHeader: { type: Boolean, default: !0 },
+    size: { default: "md" }
+  },
+  emits: ["update:color", "close"],
+  setup(l, { emit: E }) {
+    const n = l, s = E, t = x(), o = x(null);
+    let i = !1;
+    const { isSupported: f, open: w, sRGBHex: H } = N(), m = (e) => {
+      const r = (e || "").toLowerCase();
+      return r === $ || r === "#00000000";
+    }, C = (e) => m(e) || !e ? "#000000" : e, v = _(() => {
+      switch (n.size) {
+        case "sm":
+          return 140;
+        case "lg":
+          return 170;
+        default:
+          return 162;
+      }
+    }), y = {
+      sm: 120,
+      md: 140,
+      lg: 150
+    }, h = async () => {
+      if (!(!t.value || o.value)) {
+        await M();
+        try {
+          o.value && (o.value.off("color:change"), o.value = null), t.value && (t.value.innerHTML = ""), o.value = c.ColorPicker(t.value, {
+            width: v.value,
+            color: C(n.color),
+            margin: 9,
+            boxHeight: y[n.size],
+            sliderSize: 14,
+            layout: [
+              {
+                component: c.ui.Box
+              },
+              {
+                component: c.ui.Slider,
+                options: {
+                  sliderType: "hue"
+                }
+              },
+              {
+                component: c.ui.Slider,
+                options: {
+                  sliderType: "saturation"
+                }
+              },
+              {
+                component: c.ui.Slider,
+                options: {
+                  sliderType: "value"
+                }
+              }
+            ]
+          }), o.value.on("color:change", (e) => {
+            i || s("update:color", e.hexString);
+          });
+        } catch (e) {
+          console.error("Failed to initialize color picker:", e);
+        }
+      }
+    }, k = () => {
+      o.value && (o.value.off("color:change"), o.value = null), t.value && (t.value.innerHTML = "");
+    };
+    u(
+      () => n.color,
+      (e) => {
+        if (o.value && !m(e) && o.value.color.hexString !== e) {
+          i = !0;
+          try {
+            o.value.color.hexString = e;
+          } catch (r) {
+            console.error("Error updating color:", r);
+          } finally {
+            i = !1;
+          }
+        }
+      }
+    ), u(
+      () => n.size,
+      () => {
+        k(), h();
+      }
+    ), u(H, (e) => {
+      if (e && (s("update:color", e), o.value)) {
+        i = !0;
+        try {
+          o.value.color.hexString = e;
+        } catch (r) {
+          console.error("Error updating color from eyedropper:", r);
+        } finally {
+          i = !1;
+        }
+      }
+    });
+    const g = async () => {
+      try {
+        await w();
+      } catch (e) {
+        console.error("Error opening eyedropper:", e);
+      }
+    };
+    return B(() => {
+      h();
+    }), P(() => {
+      k();
+    }), (e, r) => (a(), b("div", D, [
+      l.showHeader ? (a(), b("div", F, [
+        R(d, {
+          icon: "typcn:arrow-back",
+          onClick: r[0] || (r[0] = (O) => s("close")),
+          class: "flex-1 px-2 py-1 bg-background hover:bg-accent rounded text-xs border border-border transition-colors"
+        }),
+        S(f) ? (a(), z(d, {
+          key: 0,
+          onClick: g,
+          icon: "pepicons-pop:color-picker",
+          class: "flex-1 px-2 py-1 bg-background hover:bg-accent rounded text-xs border border-border transition-colors"
+        })) : p("", !0)
+      ])) : p("", !0),
+      L("div", {
+        ref_key: "pickerRef",
+        ref: t,
+        style: V({ width: v.value + "px", minHeight: y[l.size] + "px" })
+      }, null, 4),
+      I(e.$slots, "bottom", {}, () => [
+        S(f) && !l.showHeader ? (a(), z(d, {
+          key: 0,
+          onClick: g,
+          icon: "pepicons-pop:color-picker",
+          variant: "outline",
+          size: "sm",
+          class: "w-full"
+        })) : p("", !0)
+      ])
+    ]));
+  }
+});
+export {
+  j as default
+};

package/components/ColorPicker/ColorIro.vue3.js

@@ -1,5 +1,5 @@
-import o from "./ColorIro.vue.js";
-/* empty css              */
+import o from "./ColorIro.vue2.js";
+/* empty css             */
 export {
   o as default
 };

package/components/ColorPicker/ColorPicker.vue.d.ts

@@ -10,6 +10,8 @@ interface Props {
     btnProps?: ButtonProps;
     showInput?: boolean;
     trigger?: 'input' | 'button' | 'swatch';
+    /** When true, shows a reset control that sets the value to `#0000` (transparent). */
+    allowReset?: boolean;
 }
 declare function __VLS_template(): {
     attrs: Partial<{}>;
@@ -23,9 +25,11 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    reset: (value: string) => any;
     change: (value: string) => any;
     "update:modelValue": (value: string) => any;
 }, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onReset?: (value: string) => any;
     onChange?: (value: string) => any;
     "onUpdate:modelValue"?: (value: string) => any;
 }>, {
@@ -37,6 +41,7 @@ declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {},
     trigger: "input" | "button" | "swatch";
     position: TooltTipPlacement;
     showInput: boolean;
+    allowReset: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;