vxe-pc-ui 4.20.32 → 4.20.34

package/es/timeline/index.d.ts

@@ -5,13 +5,35 @@ export declare const VxeTimeline: {
             type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Size>;
             default: () => import("@vxe-ui/core").VxeComponentSizeType;
         };
+        options: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Options>;
+        reverse: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Reverse>;
+            default: () => boolean | undefined;
+        };
+        vertical: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Vertical>;
+            default: () => boolean | undefined;
+        };
+        optionProps: import("vue").PropType<import("../../types").VxeTimelinePropTypes.OptionProps>;
     }>> & {}, import("../../types").VxeTimelineConstructor & import("../../types").VxeTimelinePrivateMethods, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, [], import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
         size: {
             type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Size>;
             default: () => import("@vxe-ui/core").VxeComponentSizeType;
         };
+        options: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Options>;
+        reverse: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Reverse>;
+            default: () => boolean | undefined;
+        };
+        vertical: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Vertical>;
+            default: () => boolean | undefined;
+        };
+        optionProps: import("vue").PropType<import("../../types").VxeTimelinePropTypes.OptionProps>;
     }>> & {}, {
+        reverse: boolean;
         size: import("@vxe-ui/core").VxeComponentSizeType;
+        vertical: boolean;
     }, true, {}, {}, {
         P: {};
         B: {};
@@ -24,8 +46,20 @@ export declare const VxeTimeline: {
             type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Size>;
             default: () => import("@vxe-ui/core").VxeComponentSizeType;
         };
+        options: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Options>;
+        reverse: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Reverse>;
+            default: () => boolean | undefined;
+        };
+        vertical: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Vertical>;
+            default: () => boolean | undefined;
+        };
+        optionProps: import("vue").PropType<import("../../types").VxeTimelinePropTypes.OptionProps>;
     }>> & {}, import("../../types").VxeTimelineConstructor & import("../../types").VxeTimelinePrivateMethods, {}, {}, {}, {
+        reverse: boolean;
         size: import("@vxe-ui/core").VxeComponentSizeType;
+        vertical: boolean;
     }>;
     __isFragment?: never;
     __isTeleport?: never;
@@ -35,8 +69,20 @@ export declare const VxeTimeline: {
         type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Size>;
         default: () => import("@vxe-ui/core").VxeComponentSizeType;
     };
+    options: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Options>;
+    reverse: {
+        type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Reverse>;
+        default: () => boolean | undefined;
+    };
+    vertical: {
+        type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Vertical>;
+        default: () => boolean | undefined;
+    };
+    optionProps: import("vue").PropType<import("../../types").VxeTimelinePropTypes.OptionProps>;
 }>> & {}, import("../../types").VxeTimelineConstructor & import("../../types").VxeTimelinePrivateMethods, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, [], never, {
+    reverse: boolean;
     size: import("@vxe-ui/core").VxeComponentSizeType;
+    vertical: boolean;
 }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     install(app: App): void;
 };
@@ -46,13 +92,35 @@ export declare const Timeline: {
             type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Size>;
             default: () => import("@vxe-ui/core").VxeComponentSizeType;
         };
+        options: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Options>;
+        reverse: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Reverse>;
+            default: () => boolean | undefined;
+        };
+        vertical: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Vertical>;
+            default: () => boolean | undefined;
+        };
+        optionProps: import("vue").PropType<import("../../types").VxeTimelinePropTypes.OptionProps>;
     }>> & {}, import("../../types").VxeTimelineConstructor & import("../../types").VxeTimelinePrivateMethods, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, [], import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & Readonly<import("vue").ExtractPropTypes<{
         size: {
             type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Size>;
             default: () => import("@vxe-ui/core").VxeComponentSizeType;
         };
+        options: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Options>;
+        reverse: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Reverse>;
+            default: () => boolean | undefined;
+        };
+        vertical: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Vertical>;
+            default: () => boolean | undefined;
+        };
+        optionProps: import("vue").PropType<import("../../types").VxeTimelinePropTypes.OptionProps>;
     }>> & {}, {
+        reverse: boolean;
         size: import("@vxe-ui/core").VxeComponentSizeType;
+        vertical: boolean;
     }, true, {}, {}, {
         P: {};
         B: {};
@@ -65,8 +133,20 @@ export declare const Timeline: {
             type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Size>;
             default: () => import("@vxe-ui/core").VxeComponentSizeType;
         };
+        options: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Options>;
+        reverse: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Reverse>;
+            default: () => boolean | undefined;
+        };
+        vertical: {
+            type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Vertical>;
+            default: () => boolean | undefined;
+        };
+        optionProps: import("vue").PropType<import("../../types").VxeTimelinePropTypes.OptionProps>;
     }>> & {}, import("../../types").VxeTimelineConstructor & import("../../types").VxeTimelinePrivateMethods, {}, {}, {}, {
+        reverse: boolean;
         size: import("@vxe-ui/core").VxeComponentSizeType;
+        vertical: boolean;
     }>;
     __isFragment?: never;
     __isTeleport?: never;
@@ -76,8 +156,20 @@ export declare const Timeline: {
         type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Size>;
         default: () => import("@vxe-ui/core").VxeComponentSizeType;
     };
+    options: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Options>;
+    reverse: {
+        type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Reverse>;
+        default: () => boolean | undefined;
+    };
+    vertical: {
+        type: import("vue").PropType<import("../../types").VxeTimelinePropTypes.Vertical>;
+        default: () => boolean | undefined;
+    };
+    optionProps: import("vue").PropType<import("../../types").VxeTimelinePropTypes.OptionProps>;
 }>> & {}, import("../../types").VxeTimelineConstructor & import("../../types").VxeTimelinePrivateMethods, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, [], never, {
+    reverse: boolean;
     size: import("@vxe-ui/core").VxeComponentSizeType;
+    vertical: boolean;
 }, {}, string, {}> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
     install(app: App): void;
 };

package/es/timeline/src/timeline-info.d.ts

@@ -0,0 +1,6 @@
+export declare class TimelineItemInfo {
+    id: string;
+    constructor($xeTimeline: any, _vm: any);
+    update(name: any, value: any): void;
+    [key: string]: any;
+}

package/es/timeline/src/timeline-info.js

@@ -0,0 +1,19 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import XEUtils from "xe-utils";
+class TimelineItemInfo {
+  constructor($xeTimeline, _vm) {
+    __publicField(this, "id", XEUtils.uniqueId("timeline_item_"));
+    Object.assign(this, {
+      title: _vm.title,
+      content: _vm.content
+    });
+  }
+  update(name, value) {
+    this[name] = value;
+  }
+}
+export {
+  TimelineItemInfo
+};

package/es/timeline/src/timeline-item.d.ts

@@ -1,9 +1,12 @@
-import type { VxeTimelineItemConstructor, VxeTimelineItemPrivateMethods } from '../../../types';
-declare const _default: import("vue").DefineComponent<Readonly<import("vue").ComponentPropsOptions<{
-    [x: string]: unknown;
-}>>, VxeTimelineItemConstructor & VxeTimelineItemPrivateMethods, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, [], never, import("vue").PublicProps, Readonly<readonly string[] | import("vue").ExtractPropTypes<Readonly<import("vue").ComponentObjectPropsOptions<{
-    [x: string]: unknown;
-}>>>> & {}, {
-    readonly [x: number]: string;
-} | {}, {}>;
+import { PropType } from 'vue';
+import type { VxeTimelineItemPropTypes } from '../../../types';
+declare const _default: import("vue").DefineComponent<{
+    title: PropType<VxeTimelineItemPropTypes.Title>;
+    content: PropType<VxeTimelineItemPropTypes.Content>;
+}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    title: PropType<VxeTimelineItemPropTypes.Title>;
+    content: PropType<VxeTimelineItemPropTypes.Content>;
+}>>, {}, {}>;
 export default _default;

package/es/timeline/src/timeline-item.js

@@ -1,50 +1,38 @@
-import { ref, h, reactive } from "vue";
+import { ref, h, inject, onMounted, onUnmounted } from "vue";
 import { defineVxeComponent } from "../../ui/src/comp";
-import XEUtils from "xe-utils";
-import { VxeUI } from "@vxe-ui/core";
-const { createEvent } = VxeUI;
-var timeline_item_default = defineVxeComponent({
-  name: "VxeTimelineItem",
-  props: {},
-  emits: [],
-  setup(props, context) {
-    const { emit } = context;
-    const xID = XEUtils.uniqueId();
-    const refElem = ref();
-    const reactData = reactive({});
-    const refMaps = {
-      refElem
-    };
-    const computeMaps = {};
-    const $xeTimelineItem = {
-      xID,
-      props,
-      context,
-      reactData,
-      getRefMaps: () => refMaps,
-      getComputeMaps: () => computeMaps
-    };
-    const dispatchEvent = (type, params, evnt) => {
-      emit(type, createEvent(evnt, { $timelineItem: $xeTimelineItem }, params));
-    };
-    const tagMethods = {
-      dispatchEvent
-    };
-    const tagPrivateMethods = {};
-    Object.assign($xeTimelineItem, tagMethods, tagPrivateMethods);
-    const renderVN = () => {
-      return h("div", {
-        ref: refElem,
-        class: "vxe-timeline-item"
+import { createTimelineItem, watchTimelineItem, assembleTimelineItem, destroyTimelineItem } from "./util";
+var timeline_item_default = (
+  /* define-vxe-component start */
+  defineVxeComponent({
+    name: "VxeTimelineItem",
+    props: {
+      title: [String, Number],
+      content: [String, Number]
+    },
+    setup(props, context) {
+      const { slots } = context;
+      const refElem = ref();
+      const $xeTimeline = inject("$xeTimeline", {});
+      const itemConfig = createTimelineItem($xeTimeline, props);
+      itemConfig.slots = slots;
+      watchTimelineItem(props, itemConfig);
+      onMounted(() => {
+        const el = refElem.value;
+        if (el) {
+          assembleTimelineItem($xeTimeline, el, itemConfig);
+        }
       });
-    };
-    $xeTimelineItem.renderVN = renderVN;
-    return $xeTimelineItem;
-  },
-  render() {
-    return this.renderVN();
-  }
-});
+      onUnmounted(() => {
+        destroyTimelineItem($xeTimeline, itemConfig);
+      });
+      return () => {
+        return h("div", {
+          ref: refElem
+        });
+      };
+    }
+  })
+);
 export {
   timeline_item_default as default
 };

package/es/timeline/src/timeline.d.ts

@@ -5,12 +5,34 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<VxeTimelinePropTypes.Size>;
         default: () => import("@vxe-ui/core").VxeComponentSizeType;
     };
+    options: PropType<VxeTimelinePropTypes.Options>;
+    reverse: {
+        type: PropType<VxeTimelinePropTypes.Reverse>;
+        default: () => boolean | undefined;
+    };
+    vertical: {
+        type: PropType<VxeTimelinePropTypes.Vertical>;
+        default: () => boolean | undefined;
+    };
+    optionProps: PropType<VxeTimelinePropTypes.OptionProps>;
 }, VxeTimelineConstructor & VxeTimelinePrivateMethods, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, [], never, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     size: {
         type: PropType<VxeTimelinePropTypes.Size>;
         default: () => import("@vxe-ui/core").VxeComponentSizeType;
     };
+    options: PropType<VxeTimelinePropTypes.Options>;
+    reverse: {
+        type: PropType<VxeTimelinePropTypes.Reverse>;
+        default: () => boolean | undefined;
+    };
+    vertical: {
+        type: PropType<VxeTimelinePropTypes.Vertical>;
+        default: () => boolean | undefined;
+    };
+    optionProps: PropType<VxeTimelinePropTypes.OptionProps>;
 }>> & {}, {
+    reverse: boolean;
     size: import("@vxe-ui/core").VxeComponentSizeType;
+    vertical: boolean;
 }, {}>;
 export default _default;

package/es/timeline/src/timeline.js

@@ -1,55 +1,189 @@
-import { ref, h, reactive } from "vue";
+import { ref, h, reactive, computed, watch, provide, onMounted, onBeforeUnmount } from "vue";
 import { defineVxeComponent } from "../../ui/src/comp";
 import XEUtils from "xe-utils";
 import { VxeUI } from "@vxe-ui/core";
-const { getConfig, createEvent } = VxeUI;
-var timeline_default = defineVxeComponent({
-  name: "VxeTimeline",
-  props: {
-    size: {
-      type: String,
-      default: () => getConfig().timeline.size || getConfig().size
+import { getText } from "../../ui/src/utils";
+const { getConfig, useFns, createEvent } = VxeUI;
+function createInternalData() {
+  return {
+    fullData: []
+  };
+}
+function createReactData() {
+  return {
+    itemList: [],
+    staticItems: [],
+    isOptConf: false
+  };
+}
+var timeline_default = (
+  /* define-vxe-component start */
+  defineVxeComponent({
+    name: "VxeTimeline",
+    props: {
+      size: {
+        type: String,
+        default: () => getConfig().timeline.size || getConfig().size
+      },
+      options: Array,
+      reverse: {
+        type: Boolean,
+        default: () => getConfig().timeline.reverse
+      },
+      vertical: {
+        type: Boolean,
+        default: () => getConfig().timeline.vertical
+      },
+      optionProps: Object
+    },
+    emits: [],
+    setup(props, context) {
+      const { slots, emit } = context;
+      const xID = XEUtils.uniqueId();
+      const { computeSize } = useFns.useSize(props);
+      const refElem = ref();
+      const reactData = reactive(createReactData());
+      const internalData = createInternalData();
+      const refMaps = {
+        refElem
+      };
+      const computeMaps = {};
+      const $xeTimeline = {
+        xID,
+        props,
+        context,
+        reactData,
+        internalData,
+        getRefMaps: () => refMaps,
+        getComputeMaps: () => computeMaps
+      };
+      const computePropsOpts = computed(() => {
+        return Object.assign({}, getConfig().timeline.optionProps, props.optionProps);
+      });
+      const computeTitleField = computed(() => {
+        const propsOpts = computePropsOpts.value;
+        return propsOpts.title || "title";
+      });
+      const computeContentField = computed(() => {
+        const propsOpts = computePropsOpts.value;
+        return propsOpts.content || "content";
+      });
+      const dispatchEvent = (type, params, evnt) => {
+        emit(type, createEvent(evnt, { $timeline: $xeTimeline }, params));
+      };
+      const loadData = (opts, isOptConf) => {
+        reactData.isOptConf = isOptConf;
+        internalData.fullData = opts || [];
+        updateItems();
+      };
+      const updateItems = () => {
+        const { reverse } = props;
+        const { fullData } = internalData;
+        reactData.itemList = reverse ? fullData.slice(0).reverse() : fullData.slice(0);
+      };
+      const timelineMethods = {
+        dispatchEvent
+      };
+      const timelinePrivateMethods = {};
+      Object.assign($xeTimeline, timelineMethods, timelinePrivateMethods);
+      const renderItem = (item, index) => {
+        const { itemList, isOptConf } = reactData;
+        const titleField = computeTitleField.value;
+        const contentField = computeContentField.value;
+        const titleVal = getText(isOptConf ? item[titleField] : item.title);
+        const contentVal = getText(isOptConf ? item[contentField] : item.content);
+        const titleSlot = slots.title;
+        const contentSlot = slots.content;
+        return h(
+          "div",
+          {
+            key: index,
+            class: ["vxe-timeline--item", {
+              "is--last": index === itemList.length - 1
+            }]
+          },
+          [
+            h("div", {
+              class: "vxe-timeline--item-line"
+            }),
+            h("div", {
+              class: "vxe-timeline--item-node"
+            }),
+            h("div", {
+              class: "vxe-timeline--item-wrapper"
+            }, [
+              h("div", {
+                class: "vxe-timeline--item-title"
+              }, titleSlot ? titleSlot({ item }) : titleVal),
+              h("div", {
+                class: "vxe-timeline--item-content"
+              }, contentSlot ? contentSlot({ item }) : contentVal)
+            ])
+          ]
+        );
+      };
+      const renderVN = () => {
+        const { vertical } = props;
+        const { itemList } = reactData;
+        const vSize = computeSize.value;
+        const defaultSlot = slots.default;
+        return h(
+          "div",
+          {
+            ref: refElem,
+            class: ["vxe-timeline", {
+              [`size--${vSize}`]: vSize,
+              "is--vertical": vertical,
+              "is--horizontal": !vertical
+            }]
+          },
+          [
+            h("div", {
+              class: "vxe-timeline--slots"
+            }, defaultSlot ? defaultSlot({}) : []),
+            h("div", {
+              class: "vxe-timeline--body"
+            }, itemList.map((item, index) => renderItem(item, index)))
+          ]
+        );
+      };
+      watch(() => reactData.staticItems, (val) => {
+        loadData(val, false);
+      });
+      const refOptsFlag = ref(0);
+      watch(() => props.options, () => {
+        refOptsFlag.value++;
+      });
+      watch(() => props.options ? props.options.length : -1, () => {
+        refOptsFlag.value++;
+      });
+      watch(refOptsFlag, () => {
+        loadData(props.options || [], true);
+      });
+      watch(() => props.reverse, () => {
+        updateItems();
+      });
+      onMounted(() => {
+        const { staticItems } = reactData;
+        if (staticItems.length) {
+          loadData(staticItems, false);
+        } else {
+          loadData(props.options || [], true);
+        }
+      });
+      onBeforeUnmount(() => {
+        XEUtils.assign(reactData, createReactData());
+        XEUtils.assign(internalData, createInternalData());
+      });
+      provide("$xeTimeline", $xeTimeline);
+      $xeTimeline.renderVN = renderVN;
+      return $xeTimeline;
+    },
+    render() {
+      return this.renderVN();
     }
-  },
-  emits: [],
-  setup(props, context) {
-    const { emit } = context;
-    const xID = XEUtils.uniqueId();
-    const refElem = ref();
-    const reactData = reactive({});
-    const refMaps = {
-      refElem
-    };
-    const computeMaps = {};
-    const $xeTimeline = {
-      xID,
-      props,
-      context,
-      reactData,
-      getRefMaps: () => refMaps,
-      getComputeMaps: () => computeMaps
-    };
-    const dispatchEvent = (type, params, evnt) => {
-      emit(type, createEvent(evnt, { $timeline: $xeTimeline }, params));
-    };
-    const tagMethods = {
-      dispatchEvent
-    };
-    const tagPrivateMethods = {};
-    Object.assign($xeTimeline, tagMethods, tagPrivateMethods);
-    const renderVN = () => {
-      return h("div", {
-        ref: refElem,
-        class: "vxe-timeline"
-      });
-    };
-    $xeTimeline.renderVN = renderVN;
-    return $xeTimeline;
-  },
-  render() {
-    return this.renderVN();
-  }
-});
+  })
+);
 export {
   timeline_default as default
 };

package/es/timeline/src/util.d.ts

@@ -0,0 +1,7 @@
+import { TimelineItemInfo } from './timeline-info';
+import type { VxeTimelineConstructor } from '../../../types';
+export declare function isTimelineItem(item: any): item is TimelineItemInfo;
+export declare function createTimelineItem($xeTimeline: VxeTimelineConstructor, _vm: any): TimelineItemInfo;
+export declare function watchTimelineItem(props: any, itemInfo: TimelineItemInfo): void;
+export declare function assembleTimelineItem($xeTimeline: VxeTimelineConstructor, el: HTMLDivElement, itemInfo: TimelineItemInfo): void;
+export declare function destroyTimelineItem($xeTimeline: VxeTimelineConstructor, itemInfo: TimelineItemInfo): void;

package/es/timeline/src/util.js

@@ -0,0 +1,41 @@
+import { watch } from "vue";
+import XEUtils from "xe-utils";
+import { TimelineItemInfo } from "./timeline-info";
+function isTimelineItem(item) {
+  return item instanceof TimelineItemInfo;
+}
+function createTimelineItem($xeTimeline, _vm) {
+  return isTimelineItem(_vm) ? _vm : new TimelineItemInfo($xeTimeline, _vm);
+}
+function watchTimelineItem(props, itemInfo) {
+  Object.keys(props).forEach((name) => {
+    watch(() => props[name], (value) => {
+      itemInfo.update(name, value);
+    });
+  });
+}
+function assembleTimelineItem($xeTimeline, el, itemInfo) {
+  const { reactData } = $xeTimeline;
+  const { staticItems } = reactData;
+  const parentElem = el.parentNode;
+  if (parentElem && staticItems) {
+    staticItems.splice(XEUtils.arrayIndexOf(parentElem.children, el), 0, itemInfo);
+    reactData.staticItems = staticItems.slice(0);
+  }
+}
+function destroyTimelineItem($xeTimeline, itemInfo) {
+  const { reactData } = $xeTimeline;
+  const { staticItems } = reactData;
+  const index = XEUtils.findIndexOf(staticItems, (item) => item.id === itemInfo.id);
+  if (index > -1) {
+    staticItems.splice(index, 1);
+  }
+  reactData.staticItems = staticItems.slice(0);
+}
+export {
+  assembleTimelineItem,
+  createTimelineItem,
+  destroyTimelineItem,
+  isTimelineItem,
+  watchTimelineItem
+};