@ithinkdt/ui 4.0.0-38 → 4.0.0-400

package/src/components/DataLocaleInput.jsx

@@ -1,121 +0,0 @@
-import { NButton, NIcon, NInput } from 'ithinkdt-ui'
-import { computed, defineComponent, ref, toRef, toValue, unref, watch } from 'vue'
-
-import { useFormModal } from '@ithinkdt/page'
-
-import { useI18n } from '../use-i18n.js'
-
-import { ILanguage } from './assets.jsx'
-
-export function useLocaleEdit(title, onSubmit, defaultRows = 1) {
-    const { t } = useI18n()
-
-    const readonly = ref(false)
-    let supports = []
-    const { open, reinit } = useFormModal({
-        title,
-        showColon: true,
-        submitText: t('common.confirm.defaultOk'),
-        items: ({ it }) => {
-            return supports.map((s) => {
-                return it(s.value, s.label, 'input', {
-                    span: 24,
-                    required: s.required,
-                    inputProps: {
-                        readonly,
-                        clearable: true,
-                        type: 'textarea',
-                        showCount: true,
-                        autosize: {
-                            minRows: unref(defaultRows),
-                            maxRows: Math.max(unref(defaultRows), 5),
-                        },
-                    },
-                })
-            })
-        },
-        onSubmit,
-    })
-
-    return {
-        open: (data, readonly0 = false) => {
-            readonly.value = readonly0
-            return open(data)
-        },
-        setSupports: (supports0) => {
-            supports = supports0
-            reinit()
-        },
-    }
-}
-
-export const DataLocaleInput = /* @__PURE__ */ defineComponent({
-    name: 'DataLocaleInput',
-    props: {
-        label: { type: [String, Function, Number, Boolean, Object] },
-        modelValue: Object,
-        supports: { type: Array, default: () => [] },
-        disabled: { type: Boolean, default: undefined },
-        defaultLang: { type: String, default: 'zh-CN' },
-        showLang: { type: String, default: undefined },
-        defaultRows: { type: Number, default: 1 },
-    },
-    emits: ['update:modelValue', 'updateModelValue'],
-    setup(props, { emit }) {
-        const onUpdateValue = (value) => {
-            value = {
-                ...props.modelValue,
-                [props.showLang ?? props.defaultLang]: value,
-            }
-            emit('update:modelValue', value)
-            emit('updateModelValue', value)
-        }
-
-        const { open, setSupports } = useLocaleEdit(
-            computed(() => toValue(props.label)),
-            (data) => {
-                emit('update:modelValue', data)
-                emit('updateModelValue', data)
-            },
-            toRef(props, 'defaultRows'),
-        )
-
-        watch(() => props.supports, setSupports, { immediate: true })
-
-        const slots = {
-            suffix: () => (
-                <NButton
-                    quaternary
-                    onClick={() => open(props.modelValue, props.disabled)}
-                    style="--n-padding: 0 8px"
-                >
-                    <NIcon size="20" depth="3">
-                        <ILanguage />
-                    </NIcon>
-                </NButton>
-            ),
-        }
-        const themeOverrides = {
-            '--n-padding-right': '0',
-        }
-
-        return () => {
-            return (
-                <NInput
-                    value={
-                        props.modelValue?.[props.showLang ?? props.defaultLang]
-                        ?? props.modelValue?.[props.defaultLang]
-                    }
-                    onUpdateValue={onUpdateValue}
-                    disabled={props.disabled}
-                    clearable
-                    style={themeOverrides}
-                    type={props.defaultRows > 1 ? 'textarea' : 'text'}
-                    rows={props.defaultRows}
-                >
-                    {slots}
-                </NInput>
-            )
-        }
-    },
-})

package/src/components/DataPagination.jsx

@@ -1,62 +0,0 @@
-import { NPagination } from 'ithinkdt-ui'
-import { defineComponent } from 'vue'
-
-import { useI18n } from '../use-i18n.js'
-
-export const DataPagination = /* @__PURE__ */ defineComponent({
-    name: 'DataPagination',
-    props: {
-        total: {
-            type: Number,
-            default: 0,
-        },
-        currentPage: {
-            type: Number,
-        },
-        pageSize: {
-            type: Number,
-        },
-        page: {
-            type: Object,
-        },
-        pageSizes: {
-            type: Array,
-            default: () => [10, 20, 30, 50],
-        },
-    },
-    emits: {
-        change: () => true,
-    },
-    setup(props, { emit }) {
-        const { t } = useI18n()
-
-        const onUpdatePage = page => emit('change', {
-            pageSize: props.pageSize ?? props.page?.pageSize ?? 0,
-            currentPage: page,
-        })
-        const onUpdatePageSize = pageSize => emit('change', {
-            pageSize,
-            currentPage: props.currentPage ?? props.page?.currentPage ?? 0,
-        })
-        return () => {
-            return (
-                <NPagination
-                    page={props.currentPage ?? props.page?.currentPage}
-                    itemCount={props.total}
-                    pageSize={props.pageSize ?? props.page?.pageSize}
-                    onUpdatePage={onUpdatePage}
-                    onUpdatePageSize={onUpdatePageSize}
-                    pageSizes={props.pageSizes}
-                    showQuickJumper
-                    showSizePicker
-                    style="justify-content: flex-end"
-                >
-                    {{
-                        prefix: () => t('common.page.pagination.prefix', { total: props.total }),
-                        suffix: () => t('common.page.pagination.suffix'),
-                    }}
-                </NPagination>
-            )
-        }
-    },
-})

package/src/components/DataSelection.jsx

@@ -1,57 +0,0 @@
-import { NButton, NFlex } from 'ithinkdt-ui'
-import { defineComponent } from 'vue'
-
-import { useI18n } from '../use-i18n.js'
-
-export const DataSelection = /* @__PURE__ */ defineComponent({
-    name: 'DataSelection',
-    props: {
-        modelValue: {
-            type: String,
-            required: true,
-        },
-        count: {
-            type: Number,
-            default: 0,
-        },
-    },
-    emits: {
-        'update:modelValue': () => true,
-        'clear': () => true,
-    },
-    setup(props, { emit }) {
-        const { t } = useI18n()
-
-        return () => {
-            if (props.modelValue !== 'selection' && props.count === 0) return <div />
-
-            return (
-                <div>
-                    <NFlex align="center" wrap-item={false}>
-                        <span>
-                            {t('common.page.selection.countText', { count: props.count }) }
-                        </span>
-                        <NButton
-                            text
-                            type="primary"
-                            onClick={() => {
-                                emit('update:modelValue', props.modelValue === 'all' ? 'selection' : 'all')
-                            }}
-                        >
-                            {props.modelValue === 'all' ? t('common.page.selection.view') : t('common.page.selection.back') }
-                        </NButton>
-                        <NButton
-                            text
-                            onClick={() => {
-                                emit('clear')
-                                emit('update:modelValue', 'all')
-                            }}
-                        >
-                            {t('common.page.selection.clear') }
-                        </NButton>
-                    </NFlex>
-                </div>
-            )
-        }
-    },
-})

package/src/components/DataTable.jsx

@@ -1,302 +0,0 @@
-import { toReactive, unrefElement, until } from '@vueuse/core'
-import { NButton, NDataTable, NFlex, NIcon, NPerformantEllipsis, NTooltip, dataTableProps } from 'ithinkdt-ui'
-import { Sortable } from 'sortablejs'
-import { computed, defineComponent, inject, mergeProps, nextTick, ref, shallowRef, toValue, useTemplateRef, watch, withDirectives } from 'vue'
-
-import { PAGE_INJECTION } from '@ithinkdt/page'
-
-import { vTooltip } from '../directives/index.js'
-import useStyle, { c, cB, cE, useClsPrefix } from '../use-style.js'
-
-import { IHelp } from './assets.jsx'
-
-function _map(columns, width) {
-    return (columns ?? [])
-        .map((col) => {
-            const column = {
-                csvTitle: col.exportTitle,
-                ...col,
-                title: () => {
-                    const title0 = toValue(col.title)
-                    const title = title0
-                        ? withDirectives(<span>{title0}</span>, [[vTooltip, () => toValue(col.title), undefined, { auto: true }]])
-                        : title0
-                    if (!col.tooltip) return title
-                    return (
-                        <NFlex size={3} wrap={false} inline style="max-width: 100%">
-                            {title}
-
-                            <NTooltip>
-                                {{
-                                    default: toValue(col.tooltip),
-                                    trigger: () => (
-                                        <NButton text style="font-size: 1.25em; opacity: 0.8">
-                                            <NIcon>
-                                                <IHelp />
-                                            </NIcon>
-                                        </NButton>
-                                    ),
-                                }}
-                            </NTooltip>
-                        </NFlex>
-                    )
-                },
-            }
-
-            if (col.children?.length) {
-                column.children = _map(col.children, width)
-            } else {
-                if (col.hidden !== true) {
-                    column.width ??= 100
-                    width.value += Number(column.width)
-                }
-
-                const render0 = col.render ?? (v => v)
-                if (col.ellipsis !== false) {
-                    column.ellipsis = false
-                    column.render = (...params) => {
-                        const vnode = render0(...params)
-                        return (
-                            <NPerformantEllipsis
-                                {...mergeProps(
-                                    {
-                                        expandTrigger: 'click',
-                                        lineClamp: 1,
-                                        tooltip: {
-                                            style: {
-                                                maxWidth: '61.8vw',
-                                                wordBreak: 'break-all',
-                                            },
-                                        },
-                                    },
-                                    typeof col.ellipsis === 'boolean' ? {} : col.ellipsis,
-                                )}
-                            >
-                                {
-                                    vnode
-                                }
-                            </NPerformantEllipsis>
-                        )
-                    }
-
-                    if (col.ellipsisTooltip === true) {
-                        column.ellipsisTooltip ??= render0
-                    }
-                }
-
-                Object.assign(column, {
-                    resizable: col.resizable !== false,
-                    sorter: col.sortable,
-                    type: ['selection', 'expand'].includes(col.type) ? col.type : undefined,
-                    disabled: col.selectable ? model => col.selectable(model) === false : undefined,
-                })
-            }
-
-            if (column.key === '$actions') {
-                column.cellProps ??= () => {
-                    return { style: { padding: '0 2px' } }
-                }
-            }
-
-            return column
-        })
-        .filter(it => it?.hidden !== true)
-}
-
-export const DataTable = /* @__PURE__ */ defineComponent({
-    name: 'DataTable',
-    props: {
-        data: {
-            type: Array,
-            default: () => [],
-        },
-        columns: {
-            type: Array,
-            default: () => [],
-        },
-        keyField: {
-            type: String,
-        },
-        sorter: {
-            type: Object,
-            default: () => ({}),
-        },
-        selectedKeys: {
-            type: Array,
-        },
-        highlight: {
-            type: [Boolean, String, Number, Object],
-            default: true,
-        },
-        rowClassName: dataTableProps.rowClassName,
-        rowProps: dataTableProps.rowProps,
-    },
-    emits: ['sort', 'select', 'custom', 'highlight'],
-    setup(props, { slots, emit, expose }) {
-        const { keyField } = inject(PAGE_INJECTION)
-
-        const clsPrefix = useClsPrefix()
-        const cls = `${clsPrefix.value}-datatable`
-        useStyle('-datatable', style, clsPrefix)
-
-        const tableRef = useTemplateRef('table-ref')
-
-        const handleSort = ({ sortField, sortOrder } = {}, oSort) => {
-            if (sortField == oSort?.sortField && sortOrder == oSort?.sortOrder) return
-            tableRef.value?.sort(sortField, sortOrder ? sortOrder + 'end' : false)
-        }
-
-        watch(() => ({ ...props.sorter }), handleSort, { deep: true })
-
-        const rowKey = computed(() => {
-            const keyField0 = props.keyField || keyField || 'key'
-            return row => row[keyField0]
-        })
-
-        const exposed = shallowRef({
-            cache: [],
-            scrollToView(...params) {
-                this.cache.push(params)
-            },
-        })
-        until(tableRef)
-            .changed()
-            .then(() => {
-                handleSort(props.sorter)
-
-                const cache = exposed.value.cache
-                exposed.value = tableRef.value
-                exposed.value.scrollToView = (key) => {
-                    const index = props.data.findIndex(row => rowKey.value(row) === key)
-                    if (index === -1) return
-                    const row = tableRef.value.$el.querySelector(`.${cls}__row-marker:nth-child(${index + 1})`)
-                    tableRef.value.scrollTo({
-                        top: row.offsetTop,
-                        behavior: 'smooth',
-                    })
-                }
-                for (const params of cache) exposed.value.scrollToView(...params)
-            })
-
-        expose(toReactive(exposed))
-
-        const width = ref(0)
-        const columns = shallowRef([])
-
-        watch(() => props.columns, () => {
-            width.value = 0
-            columns.value = _map(props.columns, width)
-        }, { immediate: true, deep: 1 })
-
-        const highlightKey = ref()
-        watch(() => props.highlight, (val) => {
-            highlightKey.value = typeof val === 'boolean' ? null : (val ?? null)
-        }, { immediate: true })
-        const rowClassName = computed(() => {
-            return (row, i) => {
-                return [
-                    props.rowClassName?.(row, i) || '',
-                    `${cls}__row-marker`,
-                    (highlightKey.value != null && rowKey.value(row) === highlightKey.value) ? `${cls}__row-highlight` : '',
-                ].join(' ')
-            }
-        })
-        const rowProps = computed(() => {
-            return (row, i) => {
-                const props2 = props.rowProps?.(row, i)
-                return {
-                    ...props2,
-                    onClick: (e) => {
-                        const key = rowKey.value(row)
-                        if (props.highlight === true) {
-                            highlightKey.value = key
-                        }
-                        emit('highlight', key)
-                        props2?.onClick?.(e)
-                    },
-                }
-            }
-        })
-
-        const onUpdateSorter = (e) => {
-            if (props.sorter) {
-                const { sortField, sortOrder } = props.sorter
-                if (e?.columnKey == sortField && (e?.order ? e.order === sortOrder + 'end' : !sortOrder)) return
-            }
-
-            emit('sort', {
-                sortField: e?.order ? e?.columnKey : undefined,
-                sortOrder: e?.order ? e.order.replace('end', '') : undefined,
-            })
-        }
-
-        const onUpdateCheckedRowKeys = (keys) => {
-            emit('select', keys)
-        }
-
-        const onColumnResize = (resizedWidth, limitedWidth, column) => {
-            emit('custom', {
-                key: column.key,
-                width: resizedWidth,
-            })
-        }
-
-        return () => (
-            <NDataTable
-                class={cls}
-                data={props.data}
-                columns={columns.value}
-                rowKey={rowKey.value}
-                tableLayout="fixed"
-                ref="table-ref"
-                scrollX={width.value}
-                rowClassName={rowClassName.value}
-                rowProps={rowProps.value}
-                checkedRowKeys={props.selectedKeys}
-                onUpdateSorter={onUpdateSorter}
-                onUpdateCheckedRowKeys={onUpdateCheckedRowKeys}
-                onUnstableColumnResize={onColumnResize}
-            >
-                {slots}
-            </NDataTable>
-        )
-    },
-})
-
-const style = /* @__PURE__ */ cB(
-    'datatable',
-    [
-        cE('row-highlight', [
-            c('& > td', {
-                backgroundColor: 'var(--n-tr-highlight-color, var(--n-merged-border-color)) !important',
-            }),
-        ]),
-    ],
-)
-
-export function useDataTableDrag(
-    tableRef,
-    { data, onSort, ...options }) {
-    watch([ref(data), tableRef], async ([data, inst]) => {
-        if (data.length === 0)
-            return
-
-        await nextTick()
-        const tableEl = unrefElement(inst)
-        const tbodyEl = tableEl?.querySelector('.n-data-table-base-table-body .n-data-table-tbody')
-
-        if (!tbodyEl) return
-
-        const sortable = Sortable.create(tbodyEl, {
-            animation: 150,
-            ...options,
-            onSort(evt) {
-                onSort({ from: evt.oldIndex, to: evt.newIndex })
-            },
-        })
-
-        return () => {
-            sortable.destroy()
-        }
-    }, { immediate: true })
-}

package/src/components/Radios.jsx

@@ -1,134 +0,0 @@
-import { NFlex, NRadio, NRadioButton, NRadioGroup, NTooltip } from 'ithinkdt-ui'
-import { computed, defineComponent } from 'vue'
-
-import { useI18n } from '../use-i18n.js'
-
-export const NRadios = defineComponent({
-    name: 'Radios',
-    props: {
-        options: {
-            type: Array,
-            default: () => [],
-        },
-        vertical: {
-            type: Boolean,
-            default: false,
-        },
-        type: {
-            type: String,
-            default: 'radio',
-        },
-        default: {
-            type: [Boolean, String, Object],
-            default: false,
-        },
-        padding: {
-            type: String,
-            default: undefined,
-        },
-        labelField: {
-            type: String,
-            default: 'label',
-        },
-        valueField: {
-            type: String,
-            default: 'value',
-        },
-        disabledField: {
-            type: String,
-            default: 'disabled',
-        },
-        modelValue: {
-            type: [String, Number, Boolean],
-            default: undefined,
-        },
-    },
-    emits: {
-        'update:modelValue': () => true,
-        'updateModelValue': () => true,
-    },
-
-    setup(props, { emit }) {
-        const { t } = useI18n()
-
-        const defaultLabel = computed(() => {
-            if (props.default === false) return ''
-            if (props.default === true) return t('common.all')
-            if (typeof props.default === 'string') return props.default
-            return props.default?.[props.labelField] ?? t('common.all')
-        })
-
-        const groupStyle = computed(() => props.type === 'button-primary'
-            ? {
-                    '--n-button-color-active': 'var(--color-primary)',
-                    '--n-button-text-color-active': 'var(--color-base)',
-                }
-            : {})
-
-        const emitValue = (v) => {
-            emit('update:modelValue', v)
-            emit('updateModelValue', v)
-        }
-
-        return () => {
-            const Comp = props.type === 'button' ? NRadioButton : NRadio
-
-            const content = (
-                <>
-                    {props.default
-                        ? (
-
-                                <Comp value={typeof props.default === 'object' ? props.default?.[props.valueField] : null}>
-                                    {defaultLabel.value}
-                                </Comp>
-                            )
-                        : undefined}
-                    {props.options?.map((op) => {
-                        const label
-                            = typeof op[props.labelField] === 'string' ? op[props.labelField] : op[props.labelField]?.()
-                        return (
-                            <Comp
-                                value={op[props.valueField]}
-                                disabled={op[props.disabledField]}
-                                style={
-                                    props.padding
-                                        ? {
-                                                paddingLeft: props.padding,
-                                                paddingRight: props.padding,
-                                            }
-                                        : {}
-                                }
-                            >
-                                {op.tip
-                                    ? (
-                                            <NTooltip>
-                                                {{
-                                                    default: () => op.tip,
-                                                    trigger: () => label,
-                                                }}
-                                            </NTooltip>
-                                        )
-                                    : (
-                                            label
-                                        )}
-                            </Comp>
-                        )
-                    })}
-                </>
-            )
-            return (
-                <NRadioGroup style={props.vertical ? { ...groupStyle.value, padding: '6px 0 0' } : groupStyle.value} value={props.modelValue} onUpdateValue={emitValue}>
-                    {props.type === 'radio'
-                        ? (
-                                <NFlex size={props.vertical ? undefined : 'small'} vertical={props.vertical}>
-                                    {content}
-                                </NFlex>
-                            )
-                        : (
-                                content
-                            )}
-                </NRadioGroup>
-            )
-        }
-    },
-})