@tdesign/uniapp 0.0.1-alpha.1 → 0.7.1

package/dist/tree-select/tree-select.vue

@@ -0,0 +1,319 @@
+<template>
+  <view
+    :class="classPrefix"
+    :style="tools._style(['height:' + tools.addUnit(height), customStyle])"
+  >
+    <t-scroll-view
+      v-for="(item, level) in treeOptions"
+      :key="level"
+      :t-class="getScrollViewTClass(level)"
+      :class="getScrollViewClass(level)"
+      :scroll-into-view="scrollIntoView && scrollIntoView[level] ? 'scroll-to-' + scrollIntoView[level] : ''"
+    >
+      <t-side-bar
+        v-if="level == 0"
+        :value="innerValue[level]"
+        :t-class="classPrefix + '-column ' + tClassLeftColumn"
+        style="width: 100%;height: auto;"
+        @change="onRootChange"
+      >
+        <t-side-bar-item
+          v-for="(sidebarItem, sidebarIndex) in treeOptions[level]"
+          :key="sidebarIndex"
+          :label="sidebarItem.label"
+          :value="sidebarItem.value"
+          :disabled="sidebarItem.disabled"
+          :t-id="'scroll-to-' + sidebarItem.value"
+          :t-class="'scroll-into-view ' + tClassLeftItem"
+        />
+      </t-side-bar>
+
+      <block v-else-if="level != leafLevel">
+        <view
+          v-for="(treeItem, index) in treeOptions[level]"
+          :key="`view-${level}-${index}`"
+          :data-level="level"
+          :data-value="treeItem.value"
+          :class="
+            tools.cls(classPrefix + '__item', [
+              ['active', treeItem.value === innerValue[level]],
+              ['disabled', treeItem.disabled]
+            ]) +
+              ' ' +
+              tClassMiddleItem +
+              ' scroll-into-view'
+          "
+          @click="handleTreeClick"
+        >
+          <view :id="'scroll-to-' + treeItem.value">
+            {{ treeItem.label }}
+          </view>
+        </view>
+      </block>
+
+      <t-radio-group
+        v-else-if="!multiple"
+        :t-class="classPrefix + '__radio ' + tClassRightColumn"
+        :data-level="level"
+        data-type="single"
+        :value="innerValue[level]"
+        @change="({value}) => handleChange({ value, level, type: 'single' })"
+      >
+        <t-radio
+          v-for="(treeItem, index) in treeOptions[level]"
+          :key="`radio-${innerValue[level-1]}-${level}-${index}`"
+          :t-id="'scroll-to-' + treeItem.value"
+          :t-class="'scroll-into-view ' + classPrefix + '__radio-item ' + tClassRightItem"
+          :t-class-label="tClassRightItemLabel"
+          icon="line"
+          :value="treeItem.value"
+          :disabled="treeItem.disabled"
+          :max-label-row="1"
+          borderless
+          placement="right"
+        >
+          {{ treeItem.label }}
+        </t-radio>
+      </t-radio-group>
+
+      <t-checkbox-group
+        v-else
+        :t-class="classPrefix + '__checkbox ' + tClassRightColumn"
+        :value="innerValue[level] || []"
+        :data-level="level"
+        data-type="multiple"
+        @change="({context}) => handleChange({ context, value: context.value, level, type: 'multiple' })"
+      >
+        <t-checkbox
+          v-for="(treeItem, index) in treeOptions[level]"
+          :key="`checkbox-${innerValue[level-1]}-${level}-${index}`"
+          :t-id="'scroll-to-' + treeItem.value"
+          :t-class="'scroll-into-view ' + tClassRightItem"
+          :t-class-label="tClassRightItemLabel"
+          placement="right"
+          icon="line"
+          :max-label-row="1"
+          :value="treeItem.value"
+          :disabled="treeItem.disabled"
+          borderless
+        >
+          {{ treeItem.label }}
+        </t-checkbox>
+      </t-checkbox-group>
+    </t-scroll-view>
+    <slot name="content" />
+  </view>
+</template>
+<script>
+import TRadio from '../radio/radio';
+import TRadioGroup from '../radio-group/radio-group';
+import TCheckbox from '../checkbox/checkbox';
+import TCheckboxGroup from '../checkbox-group/checkbox-group';
+import TSideBar from '../side-bar/side-bar';
+import TSideBarItem from '../side-bar-item/side-bar-item';
+import TScrollView from '../scroll-view/scroll-view.vue';
+
+import { uniComponent } from '../common/src/index';
+import { isDef } from '../common/validator';
+import { prefix } from '../common/config';
+import { getTreeDepth, coalesce, nextTick } from '../common/utils';
+import props from './props';
+import tools from '../common/utils.wxs';
+import { getTreeClass } from './computed.js';
+import { canUseVirtualHost } from '../common/version';
+
+const name = `${prefix}-tree-select`;
+
+export default uniComponent({
+  name,
+  options: {
+    styleIsolation: 'shared',
+  },
+  controlledProps: [
+    {
+      key: 'value',
+      event: 'change',
+    },
+  ],
+  externalClasses: [
+    `${prefix}-class`,
+    `${prefix}-class-left-column`,
+    `${prefix}-class-left-item`,
+    `${prefix}-class-middle-item`,
+    `${prefix}-class-right-column`,
+    `${prefix}-class-right-item`,
+    `${prefix}-class-right-item-label`,
+  ],
+  components: {
+    TRadio,
+    TRadioGroup,
+    TCheckbox,
+    TCheckboxGroup,
+    TSideBar,
+    TSideBarItem,
+    TScrollView,
+  },
+  props: {
+    ...props,
+  },
+  data() {
+    return {
+      prefix,
+      classPrefix: name,
+      scrollIntoView: null,
+      tools,
+
+      innerValue: coalesce(this.value, this.defaultValue),
+      treeOptions: [],
+    };
+  },
+  computed: {
+
+  },
+  watch: {
+    value: {
+      handler() {
+        this.buildTreeOptions();
+      },
+      deep: true,
+      immediate: true,
+    },
+    options: {
+      handler() {
+        this.buildTreeOptions();
+      },
+      deep: true,
+      immediate: true,
+    },
+    keys: {
+      handler() {
+        this.buildTreeOptions();
+      },
+      deep: true,
+      immediate: true,
+    },
+    multiple: 'buildTreeOptions',
+  },
+  mounted() {
+    nextTick().then(() => {
+      this.getScrollIntoView('init');
+    });
+  },
+  methods: {
+    getTreeClass,
+    buildTreeOptions() {
+      const { options, innerValue: value, customValue, multiple, keys } = this;
+
+      if (!options.length) return;
+
+      const treeOptions = [];
+
+      let level = -1;
+      let currentNode = { children: options };
+
+      while (currentNode?.children) {
+        level += 1;
+        const currentLevelOptions = currentNode.children.map(item => ({
+          label: item[keys?.label || 'label'],
+          value: item[keys?.value || 'value'],
+          disabled: item[keys?.disabled || 'disabled'],
+          children: item[keys?.children || 'children'],
+        }));
+
+        treeOptions.push(currentLevelOptions);
+
+        const currentValue = coalesce(customValue?.[level], value?.[level]);
+        currentNode = currentValue
+          ? coalesce(currentLevelOptions.find(child => child.value === currentValue), currentLevelOptions[0])
+          : currentLevelOptions[0];
+      }
+
+      const depth = getTreeDepth(options, keys?.children);
+
+      // 补齐 treeOptions 长度到 depth
+      while (treeOptions.length < depth) {
+        treeOptions.push([]);
+        level += 1;
+      }
+
+      const leafLevel = Math.max(0, level);
+      const innerValue = customValue
+        || treeOptions.map((levelOptions, idx) => {
+          const isLastLevel = idx === treeOptions.length - 1;
+          const defaultValue = isLastLevel && multiple ? [levelOptions[0]?.value] : levelOptions[0]?.value;
+          return coalesce(value?.[idx], defaultValue);
+        });
+
+      this.innerValue = innerValue;
+      this.leafLevel = leafLevel;
+      this.treeOptions = treeOptions;
+    },
+
+    getScrollIntoView(status) {
+      const { innerValue: value, customValue, scrollIntoView } = this;
+      if (status === 'init') {
+        const _value = customValue || value;
+        const scrollIntoView = Array.isArray(_value)
+          ? _value.map(item => (Array.isArray(item) ? item[0] : item))
+          : [_value];
+        // setTimeout(() => {
+        this.scrollIntoView = scrollIntoView;
+        // }, 1000);
+      } else {
+        if (scrollIntoView === null) return;
+        this.scrollIntoView = null;
+      }
+    },
+
+    onRootChange(e) {
+      const { innerValue } = this;
+      const { value: itemValue } = e;
+
+      this.getScrollIntoView('none');
+      innerValue[0] = itemValue;
+
+      this._trigger('change', { value: innerValue, level: 0 });
+    },
+
+    handleTreeClick(e) {
+      const { level, value: itemValue } = e.currentTarget.dataset;
+      const { innerValue } = this;
+
+      innerValue[level] = itemValue;
+      this.getScrollIntoView('none');
+      this._trigger('change', { value: innerValue, level: 1 });
+    },
+
+    handleChange({ level, type, value }) {
+      const { innerValue } = this;
+
+      if (type === 'multiple') {
+        if (!isDef(innerValue[level])) {
+          innerValue[level] = [];
+        }
+        const index = innerValue[level].indexOf(value);
+        index === -1 ? innerValue[level].push(value) : innerValue[level].splice(index, 1);
+      } else {
+        innerValue[level] = value;
+      }
+
+      this.getScrollIntoView('none');
+      this._trigger('change', { value: innerValue, level });
+    },
+
+    getScrollViewTClass(level) {
+      return canUseVirtualHost() ? this.getScrollViewRealClass(level) : '';
+    },
+    getScrollViewClass(level) {
+      return !canUseVirtualHost() ? this.getScrollViewRealClass(level) : '';
+    },
+    getScrollViewRealClass(level) {
+      const { classPrefix, leafLevel, treeOptions, tClass } = this;
+      return `${tools.cls(`${classPrefix}__column`, [getTreeClass(leafLevel - level, treeOptions.length)])} ${tClass}`;
+    },
+  },
+});
+</script>
+<style scoped>
+@import './tree-select.css';
+</style>

package/dist/tree-select/type.ts

@@ -0,0 +1,49 @@
+/* eslint-disable */
+
+/**
+ * 该文件为脚本自动生成文件，请勿随意修改。如需修改请联系 PMC
+ * */
+
+import type { TreeOptionData, TreeKeysType } from '../common/common';
+
+export interface TdTreeSelectProps<DataOption extends TreeOptionData = TreeOptionData> {
+  /**
+   * 自定义选中值，优先级高于 `value`
+   */
+  customValue?: TreeSelectValue;
+  /**
+   * 高度，默认单位为 px
+   * @default 336
+   */
+  height?: string | number;
+  /**
+   * 用来定义 `value / label / disabled / children` 在 `options` 数据中对应的字段别名，示例：`{ value: 'key', label: 'name', children: 'list' }`
+   */
+  keys?: TreeKeysType;
+  /**
+   * 是否允许多选
+   * @default false
+   */
+  multiple?: boolean;
+  /**
+   * 选项
+   * @default []
+   */
+  options?: Array<DataOption>;
+  /**
+   * 选中值
+   */
+  value?: TreeSelectValue;
+  /**
+   * 选中值，非受控属性
+   */
+  defaultValue?: TreeSelectValue;
+  /**
+   * 点击任何节点均会触发；level 代表当前点击的层级，0 代表最左侧，依次递进
+   */
+  onChange?: (context: { value: TreeSelectValue; level: TreeLevel }) => void;
+}
+
+export type TreeSelectValue = string | number | Array<TreeSelectValue>;
+
+export type TreeLevel = 0 | 1 | 2;

package/dist/types/action-sheet.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdActionSheetProps } from '../action-sheet/type';
+
+export type ActionSheetProps = ExtractNonOnProps<TdActionSheetProps>;
+export type ActionSheetEmits = TransformEventHandlers<TdActionSheetProps, true>;
+declare const ActionSheetComponent: import('vue').DefineComponent<ActionSheetProps, {}, {}, {}, {}, {}, {}, ActionSheetEmits, any>;
+export default ActionSheetComponent;

package/dist/types/avatar-group.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdAvatarGroupProps } from '../avatar-group/type';
+
+export type AvatarGroupProps = ExtractNonOnProps<TdAvatarGroupProps>;
+export type AvatarGroupEmits = TransformEventHandlers<TdAvatarGroupProps, true>;
+declare const AvatarGroupComponent: import('vue').DefineComponent<AvatarGroupProps, {}, {}, {}, {}, {}, {}, AvatarGroupEmits, any>;
+export default AvatarGroupComponent;

package/dist/types/avatar.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdAvatarProps } from '../avatar/type';
+
+export type AvatarProps = ExtractNonOnProps<TdAvatarProps>;
+export type AvatarEmits = TransformEventHandlers<TdAvatarProps, true>;
+declare const AvatarComponent: import('vue').DefineComponent<AvatarProps, {}, {}, {}, {}, {}, {}, AvatarEmits, any>;
+export default AvatarComponent;

package/dist/types/back-top.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdBackTopProps } from '../back-top/type';
+
+export type BackTopProps = ExtractNonOnProps<TdBackTopProps>;
+export type BackTopEmits = TransformEventHandlers<TdBackTopProps, true>;
+declare const BackTopComponent: import('vue').DefineComponent<BackTopProps, {}, {}, {}, {}, {}, {}, BackTopEmits, any>;
+export default BackTopComponent;

package/dist/types/badge.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdBadgeProps } from '../badge/type';
+
+export type BadgeProps = ExtractNonOnProps<TdBadgeProps>;
+export type BadgeEmits = TransformEventHandlers<TdBadgeProps, true>;
+declare const BadgeComponent: import('vue').DefineComponent<BadgeProps, {}, {}, {}, {}, {}, {}, BadgeEmits, any>;
+export default BadgeComponent;

package/dist/types/button.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdButtonProps } from '../button/type';
+
+export type ButtonProps = ExtractNonOnProps<TdButtonProps>;
+export type ButtonEmits = TransformEventHandlers<TdButtonProps, true>;
+declare const ButtonComponent: import('vue').DefineComponent<ButtonProps, {}, {}, {}, {}, {}, {}, ButtonEmits, any>;
+export default ButtonComponent;

package/dist/types/calendar.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdCalendarProps } from '../calendar/type';
+
+export type CalendarProps = ExtractNonOnProps<TdCalendarProps>;
+export type CalendarEmits = TransformEventHandlers<TdCalendarProps, true>;
+declare const CalendarComponent: import('vue').DefineComponent<CalendarProps, {}, {}, {}, {}, {}, {}, CalendarEmits, any>;
+export default CalendarComponent;

package/dist/types/cascader.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdCascaderProps } from '../cascader/type';
+
+export type CascaderProps = ExtractNonOnProps<TdCascaderProps>;
+export type CascaderEmits = TransformEventHandlers<TdCascaderProps, true>;
+declare const CascaderComponent: import('vue').DefineComponent<CascaderProps, {}, {}, {}, {}, {}, {}, CascaderEmits, any>;
+export default CascaderComponent;

package/dist/types/cell-group.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdCellGroupProps } from '../cell-group/type';
+
+export type CellGroupProps = ExtractNonOnProps<TdCellGroupProps>;
+export type CellGroupEmits = TransformEventHandlers<TdCellGroupProps, true>;
+declare const CellGroupComponent: import('vue').DefineComponent<CellGroupProps, {}, {}, {}, {}, {}, {}, CellGroupEmits, any>;
+export default CellGroupComponent;

package/dist/types/cell.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdCellProps } from '../cell/type';
+
+export type CellProps = ExtractNonOnProps<TdCellProps>;
+export type CellEmits = TransformEventHandlers<TdCellProps, true>;
+declare const CellComponent: import('vue').DefineComponent<CellProps, {}, {}, {}, {}, {}, {}, CellEmits, any>;
+export default CellComponent;

package/dist/types/check-tag.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdCheckTagProps } from '../check-tag/type';
+
+export type CheckTagProps = ExtractNonOnProps<TdCheckTagProps>;
+export type CheckTagEmits = TransformEventHandlers<TdCheckTagProps, true>;
+declare const CheckTagComponent: import('vue').DefineComponent<CheckTagProps, {}, {}, {}, {}, {}, {}, CheckTagEmits, any>;
+export default CheckTagComponent;

package/dist/types/checkbox-group.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdCheckboxGroupProps } from '../checkbox-group/type';
+
+export type CheckboxGroupProps = ExtractNonOnProps<TdCheckboxGroupProps>;
+export type CheckboxGroupEmits = TransformEventHandlers<TdCheckboxGroupProps, true>;
+declare const CheckboxGroupComponent: import('vue').DefineComponent<CheckboxGroupProps, {}, {}, {}, {}, {}, {}, CheckboxGroupEmits, any>;
+export default CheckboxGroupComponent;

package/dist/types/checkbox.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdCheckboxProps } from '../checkbox/type';
+
+export type CheckboxProps = ExtractNonOnProps<TdCheckboxProps>;
+export type CheckboxEmits = TransformEventHandlers<TdCheckboxProps, true>;
+declare const CheckboxComponent: import('vue').DefineComponent<CheckboxProps, {}, {}, {}, {}, {}, {}, CheckboxEmits, any>;
+export default CheckboxComponent;

package/dist/types/col.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdColProps } from '../col/type';
+
+export type ColProps = ExtractNonOnProps<TdColProps>;
+export type ColEmits = TransformEventHandlers<TdColProps, true>;
+declare const ColComponent: import('vue').DefineComponent<ColProps, {}, {}, {}, {}, {}, {}, ColEmits, any>;
+export default ColComponent;

package/dist/types/collapse-panel.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdCollapsePanelProps } from '../collapse-panel/type';
+
+export type CollapsePanelProps = ExtractNonOnProps<TdCollapsePanelProps>;
+export type CollapsePanelEmits = TransformEventHandlers<TdCollapsePanelProps, true>;
+declare const CollapsePanelComponent: import('vue').DefineComponent<CollapsePanelProps, {}, {}, {}, {}, {}, {}, CollapsePanelEmits, any>;
+export default CollapsePanelComponent;

package/dist/types/collapse.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdCollapseProps } from '../collapse/type';
+
+export type CollapseProps = ExtractNonOnProps<TdCollapseProps>;
+export type CollapseEmits = TransformEventHandlers<TdCollapseProps, true>;
+declare const CollapseComponent: import('vue').DefineComponent<CollapseProps, {}, {}, {}, {}, {}, {}, CollapseEmits, any>;
+export default CollapseComponent;

package/dist/types/color-picker.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdColorPickerProps } from '../color-picker/type';
+
+export type ColorPickerProps = ExtractNonOnProps<TdColorPickerProps>;
+export type ColorPickerEmits = TransformEventHandlers<TdColorPickerProps, true>;
+declare const ColorPickerComponent: import('vue').DefineComponent<ColorPickerProps, {}, {}, {}, {}, {}, {}, ColorPickerEmits, any>;
+export default ColorPickerComponent;

package/dist/types/count-down.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdCountDownProps } from '../count-down/type';
+
+export type CountDownProps = ExtractNonOnProps<TdCountDownProps>;
+export type CountDownEmits = TransformEventHandlers<TdCountDownProps, true>;
+declare const CountDownComponent: import('vue').DefineComponent<CountDownProps, {}, {}, {}, {}, {}, {}, CountDownEmits, any>;
+export default CountDownComponent;

package/dist/types/date-time-picker.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdDateTimePickerProps } from '../date-time-picker/type';
+
+export type DateTimePickerProps = ExtractNonOnProps<TdDateTimePickerProps>;
+export type DateTimePickerEmits = TransformEventHandlers<TdDateTimePickerProps, true>;
+declare const DateTimePickerComponent: import('vue').DefineComponent<DateTimePickerProps, {}, {}, {}, {}, {}, {}, DateTimePickerEmits, any>;
+export default DateTimePickerComponent;

package/dist/types/dialog.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdDialogProps } from '../dialog/type';
+
+export type DialogProps = ExtractNonOnProps<TdDialogProps>;
+export type DialogEmits = TransformEventHandlers<TdDialogProps, true>;
+declare const DialogComponent: import('vue').DefineComponent<DialogProps, {}, {}, {}, {}, {}, {}, DialogEmits, any>;
+export default DialogComponent;

package/dist/types/divider.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdDividerProps } from '../divider/type';
+
+export type DividerProps = ExtractNonOnProps<TdDividerProps>;
+export type DividerEmits = TransformEventHandlers<TdDividerProps, true>;
+declare const DividerComponent: import('vue').DefineComponent<DividerProps, {}, {}, {}, {}, {}, {}, DividerEmits, any>;
+export default DividerComponent;

package/dist/types/drawer.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdDrawerProps } from '../drawer/type';
+
+export type DrawerProps = ExtractNonOnProps<TdDrawerProps>;
+export type DrawerEmits = TransformEventHandlers<TdDrawerProps, true>;
+declare const DrawerComponent: import('vue').DefineComponent<DrawerProps, {}, {}, {}, {}, {}, {}, DrawerEmits, any>;
+export default DrawerComponent;

package/dist/types/dropdown-item.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdDropdownItemProps } from '../dropdown-item/type';
+
+export type DropdownItemProps = ExtractNonOnProps<TdDropdownItemProps>;
+export type DropdownItemEmits = TransformEventHandlers<TdDropdownItemProps, true>;
+declare const DropdownItemComponent: import('vue').DefineComponent<DropdownItemProps, {}, {}, {}, {}, {}, {}, DropdownItemEmits, any>;
+export default DropdownItemComponent;

package/dist/types/dropdown-menu.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdDropdownMenuProps } from '../dropdown-menu/type';
+
+export type DropdownMenuProps = ExtractNonOnProps<TdDropdownMenuProps>;
+export type DropdownMenuEmits = TransformEventHandlers<TdDropdownMenuProps, true>;
+declare const DropdownMenuComponent: import('vue').DefineComponent<DropdownMenuProps, {}, {}, {}, {}, {}, {}, DropdownMenuEmits, any>;
+export default DropdownMenuComponent;

package/dist/types/empty.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdEmptyProps } from '../empty/type';
+
+export type EmptyProps = ExtractNonOnProps<TdEmptyProps>;
+export type EmptyEmits = TransformEventHandlers<TdEmptyProps, true>;
+declare const EmptyComponent: import('vue').DefineComponent<EmptyProps, {}, {}, {}, {}, {}, {}, EmptyEmits, any>;
+export default EmptyComponent;

package/dist/types/fab.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdFabProps } from '../fab/type';
+
+export type FabProps = ExtractNonOnProps<TdFabProps>;
+export type FabEmits = TransformEventHandlers<TdFabProps, true>;
+declare const FabComponent: import('vue').DefineComponent<FabProps, {}, {}, {}, {}, {}, {}, FabEmits, any>;
+export default FabComponent;

package/dist/types/footer.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdFooterProps } from '../footer/type';
+
+export type FooterProps = ExtractNonOnProps<TdFooterProps>;
+export type FooterEmits = TransformEventHandlers<TdFooterProps, true>;
+declare const FooterComponent: import('vue').DefineComponent<FooterProps, {}, {}, {}, {}, {}, {}, FooterEmits, any>;
+export default FooterComponent;

package/dist/types/form-item.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdFormItemProps } from '../form-item/type';
+
+export type FormItemProps = ExtractNonOnProps<TdFormItemProps>;
+export type FormItemEmits = TransformEventHandlers<TdFormItemProps, true>;
+declare const FormItemComponent: import('vue').DefineComponent<FormItemProps, {}, {}, {}, {}, {}, {}, FormItemEmits, any>;
+export default FormItemComponent;

package/dist/types/form.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdFormProps } from '../form/type';
+
+export type FormProps = ExtractNonOnProps<TdFormProps>;
+export type FormEmits = TransformEventHandlers<TdFormProps, true>;
+declare const FormComponent: import('vue').DefineComponent<FormProps, {}, {}, {}, {}, {}, {}, FormEmits, any>;
+export default FormComponent;

package/dist/types/grid-item.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdGridItemProps } from '../grid-item/type';
+
+export type GridItemProps = ExtractNonOnProps<TdGridItemProps>;
+export type GridItemEmits = TransformEventHandlers<TdGridItemProps, true>;
+declare const GridItemComponent: import('vue').DefineComponent<GridItemProps, {}, {}, {}, {}, {}, {}, GridItemEmits, any>;
+export default GridItemComponent;

package/dist/types/grid.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdGridProps } from '../grid/type';
+
+export type GridProps = ExtractNonOnProps<TdGridProps>;
+export type GridEmits = TransformEventHandlers<TdGridProps, true>;
+declare const GridComponent: import('vue').DefineComponent<GridProps, {}, {}, {}, {}, {}, {}, GridEmits, any>;
+export default GridComponent;

package/dist/types/guide.d.ts

@@ -0,0 +1,7 @@
+import type { TransformEventHandlers, ExtractNonOnProps } from '../common/common';
+import type { TdGuideProps } from '../guide/type';
+
+export type GuideProps = ExtractNonOnProps<TdGuideProps>;
+export type GuideEmits = TransformEventHandlers<TdGuideProps, true>;
+declare const GuideComponent: import('vue').DefineComponent<GuideProps, {}, {}, {}, {}, {}, {}, GuideEmits, any>;
+export default GuideComponent;