@opentiny/vue-renderless 3.26.0 → 3.28.0

package/space/vue.js

@@ -0,0 +1,39 @@
+import "../chunk-G2ADBYYC.js";
+import { getGapStyle } from "./index";
+const api = ["state", "orderedChildren"];
+function isVNodeFn(node) {
+  return !!(node && (node.__v_isVNode || node.componentOptions));
+}
+const renderless = (props, hooks, { slots }) => {
+  const { reactive, computed } = hooks;
+  const state = reactive({
+    gapStyle: computed(() => getGapStyle(props))
+  });
+  const orderedChildren = computed(() => {
+    var _a, _b;
+    const children = ((_a = slots.default) == null ? void 0 : _a.call(slots)) || [];
+    const validChildren = children.filter((v) => {
+      if (!isVNodeFn(v))
+        return false;
+      const type = v.type;
+      return type !== "Comment" && type !== Symbol.for("v-comment");
+    });
+    if (!((_b = props.order) == null ? void 0 : _b.length))
+      return validChildren;
+    const map = {};
+    validChildren.forEach((child) => {
+      var _a2, _b2, _c;
+      const key = (_c = child.key) != null ? _c : Array.isArray((_a2 = child.props) == null ? void 0 : _a2.class) ? child.props.class.join(" ") : (_b2 = child.props) == null ? void 0 : _b2.class;
+      if (key)
+        map[String(key)] = child;
+    });
+    const sorted = props.order.map((k) => map[k]).filter(Boolean);
+    const rest = validChildren.filter((v) => !props.order.includes(String(v.key)));
+    return [...sorted, ...rest];
+  });
+  return { state, orderedChildren };
+};
+export {
+  api,
+  renderless
+};

package/switch/vue.js

@@ -18,6 +18,25 @@ const renderless = (props, { computed, watch, reactive, inject }, { parent, cons
       } else {
         return props.showText;
       }
+    }),
+    // 添加 switchStyle 计算属性
+    switchStyle: computed(() => {
+      if (props.width) {
+        return {
+          width: typeof props.width === "number" ? `${props.width}px` : props.width
+        };
+      }
+      return {};
+    }),
+    // 添加 displayOnlyStyle 计算属性
+    displayOnlyStyle: computed(() => {
+      if (props.width) {
+        return {
+          width: typeof props.width === "number" ? `${props.width}px` : props.width,
+          display: "inline-block"
+        };
+      }
+      return {};
     })
   });
   const api2 = {

package/tab-nav/index.js

@@ -301,11 +301,11 @@ const watchCurrentName = ({ nextTick, vm, state }) => () => {
   });
 };
 const handleTitleMouseenter = ({ state, vm, props }) => (e, title) => {
-  const dom = e.target;
-  const el = title == null ? void 0 : title.el;
   if (props.tooltipConfig) {
     return;
   }
+  const dom = e.target;
+  const el = title == null ? void 0 : title.el;
   if (dom && el && el.scrollWidth > el.offsetWidth) {
     const tooltip = vm.$refs.tooltip;
     tooltip.state.referenceElm = dom;

package/tabs-mf/index.js

@@ -96,16 +96,24 @@ const clickMore = (api) => (name) => {
   api.setActive(name);
   api.scrollTo(name);
 };
-const removeItem = ({ props, state, emit }) => (name, silent = false) => {
+const removeItem = ({ props, state, emit, api }) => (name, silent = false) => {
   const itemIndex = state.items.findIndex((item) => item.name === name);
   const navIndex = state.navs.findIndex((item) => item.name === name);
+  const isCurrent = state.currentItem && state.currentItem.name === name;
+  const nextNav = state.navs[navIndex - 1] || state.navs[navIndex + 1];
   if (!~itemIndex)
     return;
   const emitEvent = () => {
+    var _a;
     state.items.splice(itemIndex, 1);
     state.items = [...state.items];
     state.navs.splice(navIndex, 1);
     state.navs = [...state.navs];
+    if (isCurrent) {
+      const nextName = nextNav ? nextNav.name : ((_a = state.items[0]) == null ? void 0 : _a.name) || "";
+      api.changeCurrentName(nextName);
+      state.currentItem = state.items.find((item) => item.name === nextName) || null;
+    }
     if (!silent) {
       emit("edit", name, "remove");
       emit("close", name);

package/tabs-mf/vue-nav.js

@@ -1,42 +1,90 @@
 import "../chunk-G2ADBYYC.js";
 const api = ["state"];
-const renderless = (props, { reactive, inject, computed, onMounted, onBeforeUnmount }, { vm }) => {
+const renderless = (props, { reactive, inject, computed, onMounted, onBeforeUnmount, watch, nextTick }, { vm }) => {
   const tabs = inject("tabs", null);
   const state = reactive({
     navItems: computed(() => tabs.state.items),
     currentNav: computed(() => tabs.state.navs[state.currentIndex]),
     currentIndex: computed(
-      () => tabs.state.navs.findIndex((item) => tabs.state.currentItem && tabs.state.currentItem.name === item.name)
+      () => tabs.state.navs.findIndex((item) => tabs.state.cacheCurrentItem && tabs.state.cacheCurrentItem.name === item.name)
     ),
     currentWidth: 0,
     currentPosition: 0
   });
-  let rafId, observer;
+  const updateSliderBar = () => {
+    const nav = state.currentNav;
+    if (nav && nav.$el) {
+      state.currentWidth = nav.$el.offsetWidth || 0;
+      state.currentPosition = nav.$el.offsetLeft || 0;
+    }
+  };
+  let mutationObserver;
+  let resizeObserver;
   onMounted(() => {
-    observer = new MutationObserver((mutationsList) => {
-      for (let mutation of mutationsList) {
-        if (mutation.type === "attributes") {
-          if (rafId) {
-            cancelAnimationFrame(rafId);
-          }
-          rafId = requestAnimationFrame(() => {
-            const nav = state.currentNav;
-            state.currentWidth = nav && nav.$el.offsetWidth || 0;
-            state.currentPosition = nav && nav.$el.offsetLeft || 0;
-          });
-        }
-      }
+    mutationObserver = new MutationObserver(() => {
+      nextTick(() => {
+        updateSliderBar();
+      });
+    });
+    mutationObserver.observe(vm.$el, { attributes: true, subtree: true, childList: true });
+    if (typeof ResizeObserver !== "undefined") {
+      resizeObserver = new ResizeObserver(() => {
+        nextTick(() => {
+          updateSliderBar();
+        });
+      });
+      const navItems = vm.$el.querySelectorAll('[data-tag="tiny-tab-nav-item"]');
+      navItems.forEach((item) => {
+        resizeObserver.observe(item);
+      });
+    }
+    nextTick(() => {
+      updateSliderBar();
     });
-    observer.observe(vm.$el, { attributes: true, subtree: true });
   });
+  watch(
+    () => state.currentNav,
+    () => {
+      nextTick(() => {
+        updateSliderBar();
+      });
+    },
+    { immediate: true }
+  );
+  watch(
+    () => state.navItems,
+    () => {
+      if (resizeObserver) {
+        resizeObserver.disconnect();
+        nextTick(() => {
+          const navItems = vm.$el.querySelectorAll('[data-tag="tiny-tab-nav-item"]');
+          navItems.forEach((item) => {
+            resizeObserver.observe(item);
+          });
+          updateSliderBar();
+        });
+      } else {
+        nextTick(() => {
+          updateSliderBar();
+        });
+      }
+    },
+    { deep: true }
+  );
   onBeforeUnmount(() => {
-    if (rafId) {
-      cancelAnimationFrame(rafId);
+    if (mutationObserver) {
+      mutationObserver.disconnect();
+      mutationObserver = null;
     }
-    observer.disconnect();
-    observer = null;
+    if (resizeObserver) {
+      resizeObserver.disconnect();
+      resizeObserver = null;
+    }
+  });
+  Object.assign(api, {
+    state
   });
-  return { state };
+  return api;
 };
 export {
   api,

package/tabs-mf/vue-slider-bar.js

@@ -0,0 +1,24 @@
+import "../chunk-G2ADBYYC.js";
+const api = ["state"];
+const renderless = (props, { reactive, inject, computed, onMounted, onUnmounted, onUpdated }, { vm, emit }) => {
+  const tabs = inject("tabs", null);
+  const state = reactive({
+    currentNav: computed(() => props.currentNav || null),
+    currentWidth: computed(() => props.currentWidth + "px"),
+    currentPosition: computed(() => props.currentPosition + "px")
+  });
+  const handleTransitionEnd = () => {
+    tabs.state.currentItem = tabs.state.cacheCurrentItem;
+  };
+  onMounted(() => {
+    vm.$el.addEventListener("transitionend", handleTransitionEnd);
+  });
+  onUnmounted(() => {
+    vm.$el.removeEventListener("transitionend", handleTransitionEnd);
+  });
+  return { state };
+};
+export {
+  api,
+  renderless
+};

package/tabs-mf/vue.js

@@ -37,7 +37,8 @@ const renderless = (props, hooks, { vm, emit, nextTick }) => {
   const state = reactive({
     items: [],
     navs: [],
-    currentItem: computed(() => state.items.find((item) => item.selected)),
+    currentItem: null,
+    cacheCurrentItem: computed(() => state.items.find((item) => item.selected)),
     key: computed(() => state.currentItem ? state.currentItem.name : random()),
     separator: props.separator,
     swipeable: computed(() => api2.computedSwipeable()),
@@ -52,7 +53,7 @@ const renderless = (props, hooks, { vm, emit, nextTick }) => {
     addItem: addItem(state),
     addNav: addNav(state),
     scrollTo: scrollTo({ vm, state }),
-    removeItem: removeItem({ props, state, emit }),
+    removeItem: removeItem({ props, state, emit, api: api2 }),
     changeCurrentName: changeCurrentName({ state, emit }),
     clickMore: clickMore(api2),
     beforeCarouselSwipe: beforeCarouselSwipe({ api: api2, state, vm }),
@@ -81,10 +82,27 @@ const renderless = (props, hooks, { vm, emit, nextTick }) => {
     () => props.modelValue,
     (name) => name && api2.setActive(name)
   );
+  watch(
+    () => state.cacheCurrentItem,
+    (newItem) => {
+      if (newItem && newItem !== state.currentItem) {
+        state.currentItem = newItem;
+      }
+    },
+    { immediate: true }
+  );
   onMounted(() => {
-    nextTick(() => api2.observeTabSwipeSize());
-    props.activeName && api2.scrollTo(props.activeName);
-    props.modelValue && api2.scrollTo(props.modelValue);
+    nextTick(() => {
+      api2.observeTabSwipeSize();
+      if (!state.currentItem && state.cacheCurrentItem) {
+        state.currentItem = state.cacheCurrentItem;
+      }
+      if (!props.activeName && !props.modelValue && state.items.length > 0 && !state.cacheCurrentItem) {
+        api2.changeCurrentName(state.items[0].name);
+      }
+      props.activeName && api2.scrollTo(props.activeName);
+      props.modelValue && api2.scrollTo(props.modelValue);
+    });
   });
   onBeforeUnmount(() => {
     api2.unobserveTabSwipeSize();

package/tag/index.js

@@ -8,7 +8,7 @@ const handleClose = ({ emit, props, state }) => (event) => {
   props.beforeDelete ? props.beforeDelete(close) : close();
 };
 const handleClick = ({ emit, props, parent, state }) => (event) => {
-  if (props.selectable || props.disabled)
+  if (props.disabled)
     return;
   parent.$parent && parent.$parent.tagSelectable && event.stopPropagation();
   state.selected = !state.selected;

package/transfer-panel/index.js

@@ -39,10 +39,11 @@ const getFilterData = ({ api, props, state, Table, Tree }) => () => {
     return showFilterData(api.getFilterTreeData(copyArray(props.data)), "visible");
   } else {
     return props.data.filter((item) => {
+      var _a;
       if (typeof props.filterMethod === "function") {
         return props.filterMethod(state.query, item);
       } else {
-        const label = item[state.labelProp] || item[state.keyProp].toString();
+        const label = item[state.labelProp] || ((_a = item[state.keyProp]) == null ? void 0 : _a.toString()) || "";
         return label.toLowerCase().includes(state.query.toLowerCase());
       }
     });

package/tree-menu/index.js

@@ -56,6 +56,9 @@ const watchFilterText = ({ vm }) => (value) => {
 const nodeDragStart = (emit) => (node, event) => {
   emit("node-drag-start", node, event);
 };
+const inputChange = ({ emit, state }) => () => {
+  emit("input-change", state.filterText);
+};
 const nodeDragEnter = (emit) => (dragNode, dropNode, event) => {
   emit("node-drag-enter", dragNode, dropNode, event);
 };
@@ -155,6 +158,7 @@ export {
   getTree,
   handleToggleMenu,
   initData,
+  inputChange,
   nodeClick,
   nodeCollapse,
   nodeDragEnd,

package/tree-menu/vue.js

@@ -6,6 +6,7 @@ import {
   watchFilterText,
   nodeDragStart,
   nodeDragEnter,
+  inputChange,
   nodeDragOver,
   nodeDragEnd,
   nodeDrop,
@@ -35,6 +36,7 @@ const api = [
   "filterNode",
   "nodeDragStart",
   "nodeDragEnter",
+  "inputChange",
   "nodeDragOver",
   "nodeDragEnd",
   "nodeDrop",
@@ -86,6 +88,7 @@ const renderless = (props, { computed, watch, reactive, onMounted }, { t, servic
     nodeDragOver: nodeDragOver(emit),
     nodeDragStart: nodeDragStart(emit),
     nodeDragEnter: nodeDragEnter(emit),
+    inputChange: inputChange({ emit, state }),
     currentChange: currentChange(emit),
     watchFilterText: watchFilterText({ vm }),
     getTitle: getTitle(props),

package/tree-select/index.js

@@ -87,16 +87,20 @@ const getChildValue = () => (childNodes, key) => {
   return ids;
 };
 const mounted = ({ api, state, props, vm }) => () => {
-  if (!state.modelValue || state.modelValue.length === 0)
+  if (!state.modelValue || Array.isArray(state.modelValue) && state.modelValue.length === 0)
     return;
   if (props.multiple) {
     let initialNodes = [];
     if (Array.isArray(state.modelValue)) {
       state.modelValue.forEach((value) => {
         const option = api.getPluginOption(value);
-        initialNodes = initialNodes.concat(option);
+        if (option && option.length > 0) {
+          initialNodes = initialNodes.concat(option);
+        }
       });
     }
+    if (initialNodes.length === 0)
+      return;
     const selected = initialNodes.map((node) => {
       return __spreadProps(__spreadValues({}, node), {
         currentLabel: node[props.textField],
@@ -106,7 +110,10 @@ const mounted = ({ api, state, props, vm }) => () => {
     vm.$refs.baseSelectRef.updateSelectedData(selected);
     state.defaultCheckedKeys = api.getCheckedData(selected);
   } else {
-    const data = api.getPluginOption(state.modelValue)[0];
+    const options = api.getPluginOption(state.modelValue);
+    const data = options && options.length > 0 ? options[0] : null;
+    if (!data)
+      return;
     vm.$refs.baseSelectRef.updateSelectedData(__spreadProps(__spreadValues({}, data), {
       currentLabel: data[props.textField],
       value: data[props.valueField],
@@ -138,7 +145,9 @@ const watchValue = ({ api, props, vm, state }) => (newValue, oldValue) => {
     if (Array.isArray(checkedKeys)) {
       checkedKeys.forEach((value) => {
         const option = api.getPluginOption(value);
-        initialNodes = initialNodes.concat(option);
+        if (option && option.length > 0) {
+          initialNodes = initialNodes.concat(option);
+        }
       });
     }
     const selected = initialNodes.map((node) => {

package/tree-select/vue.js

@@ -13,12 +13,21 @@ import {
 const api = ["state", "check", "filter", "nodeClick"];
 const renderless = (props, { reactive, computed, watch, onMounted }, { vm, emit }) => {
   const api2 = {};
+  const resolveTreeData = () => {
+    if (Array.isArray(props.treeOp)) {
+      return props.treeOp;
+    }
+    if (props.treeOp && Array.isArray(props.treeOp.data)) {
+      return props.treeOp.data;
+    }
+    return [];
+  };
   const state = reactive({
     childrenName: computed(() => props.treeOp.props && props.treeOp.props.children || "children"),
     currentKey: props.modelValue,
     defaultCheckedKeys: [],
     remoteData: [],
-    treeData: props.treeOp.data,
+    treeData: resolveTreeData(),
     modelValue: []
   });
   Object.assign(api2, {
@@ -34,8 +43,15 @@ const renderless = (props, { reactive, computed, watch, onMounted }, { vm, emit
     getChildValue: getChildValue()
   });
   watch(
-    () => props.treeOp.data,
-    (data) => data && (state.treeData = data),
+    () => {
+      var _a;
+      return Array.isArray(props.treeOp) ? props.treeOp : (_a = props.treeOp) == null ? void 0 : _a.data;
+    },
+    (data) => {
+      if (Array.isArray(data)) {
+        state.treeData = data;
+      }
+    },
     { immediate: true, deep: true }
   );
   watch(

package/types/autocomplete.type.d.ts

@@ -160,9 +160,10 @@ declare const highlight: ({ constants, vm, state }: {
 declare const watchVisible: ({ suggestionState, vm }: {
     suggestionState: IAutoCompleteApi['suggestionState'];
 }) => (val: any) => void;
-declare const mounted: ({ vm, state, suggestionState }: {
+declare const mounted: ({ vm, state, suggestionState, props }: {
     state: IAutoCompleteState;
     suggestionState: IAutoCompleteApi['suggestionState'];
+    props: IAutoCompleteProps;
 }) => () => void;
 
 interface IAutoCompleteState {

package/types/color-select-panel.type.d.ts

@@ -1,3 +1,78 @@
+import { ComputedRef, Ref } from 'vue';
+
+interface LinearGradientState {
+    linearGradientBarBackground: string;
+}
+interface ColorOptions {
+    enableAlpha: boolean;
+    format: string;
+    value?: string;
+}
+interface HSVColor {
+    h: number;
+    s: number;
+    v: number;
+}
+interface RGBColor {
+    r: number;
+    g: number;
+    b: number;
+}
+interface HSLColor {
+    hue: number;
+    sat: number;
+    light: number;
+}
+interface IColor {
+    enableAlpha: boolean;
+    format: string;
+    value: string;
+    selected?: boolean;
+    get(prop: string): number;
+    set(props: {
+        [key: string]: any;
+    }): void;
+    set(prop: string, value: number): void;
+    compare(color: IColor): boolean;
+    isHSL(value: string): boolean;
+    isHsv(value: string): boolean;
+    isRgb(value: string): boolean;
+    isHex(value: string): boolean;
+    onHsv(value: string): void;
+    onRgb(value: string): void;
+    onHex(value: string): void;
+    onHsl(value: string): void;
+    fromHSV(hsv: HSVColor): void;
+    fromString(value: string): void;
+    toRgb(): RGBColor;
+    onChange(): void;
+}
+interface ColorUtils {
+    rgb2hsv(rgb: RGBColor): HSVColor;
+    hsv2rgb(hsv: HSVColor): RGBColor;
+    hsv2hsl(hsv: {
+        hue: number;
+        sat: number;
+        val: number;
+    }): [number, number, number];
+    hsl2hsv(hsl: HSLColor): HSVColor;
+    toHex(rgb: RGBColor): string;
+    parseHex(hex: string): number;
+    hexOne(value: number): string;
+}
+interface IColorPoint {
+    color: IColor;
+    cursorLeft: number;
+}
+interface ColorPanelContext {
+    colorMode: ComputedRef<IColorSelectPanelProps['colorMode']>;
+    activeColor: Ref<IColorPoint>;
+    bar: Ref<HTMLElement | null>;
+    colorPoints: Ref<IColorPoint[]>;
+    linearGardientValue: Ref<string>;
+    deg: Ref<number>;
+}
+type IColorSelectPanelMaybeRef<T> = IColorSelectPanelRef<T> | T;
 interface IColorSelectPanelRef<T> {
     value: T;
 }
@@ -7,6 +82,7 @@ interface IColorSelectPanelProps {
     history: string[];
     predefine: string[];
     format: ('hsl' | 'hsv' | 'hex' | 'rgb')[];
+    colorMode: 'linear-gradient' | 'monochrome';
     modelValue: string;
     enableHistory: boolean;
     enablePredefineColor: boolean;
@@ -23,5 +99,125 @@ interface IColorSelectPanelHueProps<C> {
 interface IColorSelectPanelAlphaPanel<C> {
     color: C;
 }
+interface UseColorPointsRet {
+    onClick: (element: Element, point: IColorPoint) => void;
+    linearGradientValue: Readonly<Ref<string>>;
+    updateDeg: (_deg: number) => void;
+    removePoint: (point: IColorPoint) => void;
+    addPoint: (point: IColorPoint) => void;
+    setActivePoint: (point: IColorPoint) => void;
+    getActviePoint: () => Ref<IColorPoint>;
+}
+interface ColorSelectPanelExtends {
+    parse: parse;
+}
+interface LinearGradientNode {
+    type: 'linear-gradient';
+    orientation?: DirectionalNode | AngularNode | undefined;
+    colorStops: ColorStop[];
+}
+interface RepeatingLinearGradientNode {
+    type: 'repeating-linear-gradient';
+    orientation?: DirectionalNode | AngularNode | undefined;
+    colorStops: ColorStop[];
+}
+interface RadialGradientNode {
+    type: 'radial-gradient';
+    orientation?: Array<ShapeNode | DefaultRadialNode | ExtentKeywordNode> | undefined;
+    colorStops: ColorStop[];
+}
+interface RepeatingRadialGradientNode {
+    type: 'repeating-radial-gradient';
+    orientation?: Array<ShapeNode | DefaultRadialNode | ExtentKeywordNode> | undefined;
+    colorStops: ColorStop[];
+}
+interface DirectionalNode {
+    type: 'directional';
+    value: 'left' | 'top' | 'bottom' | 'right' | 'left top' | 'top left' | 'left bottom' | 'bottom left' | 'right top' | 'top right' | 'right bottom' | 'bottom right';
+}
+interface AngularNode {
+    type: 'angular';
+    value: string;
+}
+interface LiteralNode {
+    type: 'literal';
+    value: string;
+    length?: PxNode | EmNode | PercentNode | CalcNode | undefined;
+}
+interface HexNode {
+    type: 'hex';
+    value: string;
+    length?: PxNode | EmNode | PercentNode | CalcNode | undefined;
+}
+interface RgbNode {
+    type: 'rgb';
+    value: [string, string, string];
+    length?: PxNode | EmNode | PercentNode | CalcNode | undefined;
+}
+interface RgbaNode {
+    type: 'rgba';
+    value: [string, string, string, string?];
+    length?: PxNode | EmNode | PercentNode | CalcNode | undefined;
+}
+interface HslNode {
+    type: 'hsl';
+    value: [string, string, string];
+    length?: PxNode | EmNode | PercentNode | CalcNode | undefined;
+}
+interface HslaNode {
+    type: 'hsla';
+    value: [string, string, string, string?];
+    length?: PxNode | EmNode | PercentNode | CalcNode | undefined;
+}
+interface VarNode {
+    type: 'var';
+    value: string;
+    length?: PxNode | EmNode | PercentNode | CalcNode | undefined;
+}
+interface ShapeNode {
+    type: 'shape';
+    style?: ExtentKeywordNode | PxNode | EmNode | PercentNode | PositionKeywordNode | CalcNode | undefined;
+    value: 'ellipse' | 'circle';
+    at?: PositionNode | undefined;
+}
+interface DefaultRadialNode {
+    type: 'default-radial';
+    at: PositionNode;
+}
+interface PositionKeywordNode {
+    type: 'position-keyword';
+    value: 'center' | 'left' | 'top' | 'bottom' | 'right';
+}
+interface PositionNode {
+    type: 'position';
+    value: {
+        x: ExtentKeywordNode | PxNode | EmNode | PercentNode | PositionKeywordNode | CalcNode;
+        y: ExtentKeywordNode | PxNode | EmNode | PercentNode | PositionKeywordNode | CalcNode;
+    };
+}
+interface ExtentKeywordNode {
+    type: 'extent-keyword';
+    value: 'closest-side' | 'closest-corner' | 'farthest-side' | 'farthest-corner' | 'contain' | 'cover';
+    at?: PositionNode | undefined;
+}
+interface PxNode {
+    type: 'px';
+    value: string;
+}
+interface EmNode {
+    type: 'em';
+    value: string;
+}
+interface PercentNode {
+    type: '%';
+    value: string;
+}
+interface CalcNode {
+    type: 'calc';
+    value: string;
+}
+type ColorStop = LiteralNode | HexNode | RgbNode | RgbaNode | HslNode | HslaNode | VarNode;
+type GradientNode = LinearGradientNode | RepeatingLinearGradientNode | RadialGradientNode | RepeatingRadialGradientNode;
+type parse = (value: string) => GradientNode[];
 
-export { IColorSelectPanelAlphProps, IColorSelectPanelAlphaPanel, IColorSelectPanelHueProps, IColorSelectPanelProps, IColorSelectPanelRef, IColorSelectPanelSVProps };
+export { AngularNode, CalcNode, ColorOptions, ColorPanelContext, ColorSelectPanelExtends, ColorStop, ColorUtils, DefaultRadialNode, DirectionalNode, EmNode, ExtentKeywordNode, GradientNode, HSLColor, HSVColor, HexNode, HslNode, HslaNode, IColor, IColorPoint, IColorSelectPanelAlphProps, IColorSelectPanelAlphaPanel, IColorSelectPanelHueProps, IColorSelectPanelMaybeRef, IColorSelectPanelProps, IColorSelectPanelRef, IColorSelectPanelSVProps, LinearGradientNode, LinearGradientState, LiteralNode, PercentNode, PositionKeywordNode, PositionNode, PxNode, RGBColor, RadialGradientNode, RepeatingLinearGradientNode, RepeatingRadialGradientNode, RgbNode, RgbaNode, ShapeNode, UseColorPointsRet, VarNode, parse };