@vyr/element-plus 0.0.1

package/src/preset/execute/ElPagination/reset.ts

@@ -0,0 +1,46 @@
+import { Asset, Descriptor, Graphics, RoutineNode, Scriptable, UpdateArgs } from "@vyr/engine"
+import { language } from '../../../locale'
+import { ElPaginationDescriptor } from "../../../descriptor"
+
+const scriptable = Asset.createVirtualUrl('preset/ElPagination/reset.ts')
+class RoutineScriptable extends Scriptable {
+    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
+        //@ts-ignore
+        const { input } = args
+        const pagination = input?.user?.pagination.value ?? input.default.pagination.value
+
+        const paginationDescriptor = Descriptor.get<ElPaginationDescriptor>(pagination)
+        if (paginationDescriptor instanceof ElPaginationDescriptor) {
+            paginationDescriptor.reset(graphics)
+        }
+    }
+}
+Asset.provider(scriptable, async () => ({ default: RoutineScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        pagination: { value: args.pagination ?? '' },
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: RoutineNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        routine: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/src/preset/execute/ElTable/create.ts

@@ -0,0 +1,38 @@
+import { Asset, Descriptor, Graphics, RoutineNode, Scriptable, UpdateArgs } from "@vyr/engine"
+import { language } from '../../../locale'
+
+const scriptable = Asset.createVirtualUrl('preset/ElTable/create.ts')
+class RoutineScriptable extends Scriptable {
+    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
+        //@ts-ignore
+
+        return {}
+    }
+}
+Asset.provider(scriptable, async () => ({ default: RoutineScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: RoutineNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        routine: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+

package/src/preset/execute/ElTable/delete.ts

@@ -0,0 +1,53 @@
+import { ElMessageBox } from "element-plus"
+import { Asset, Descriptor, Graphics, RoutineNode, Scriptable, UpdateArgs } from "@vyr/engine"
+import { ElTableColumnDescriptor } from "../../../descriptor"
+import { language } from '../../../locale'
+
+const scriptable = Asset.createVirtualUrl('preset/ElTable/delete.ts')
+class RoutineScriptable extends Scriptable {
+    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
+        //@ts-ignore
+        const { VYR_STORE, trigger } = args
+
+        return new Promise((resolve, reject) => {
+            const { parent } = trigger.traceAncestor(false)
+            if (parent instanceof ElTableColumnDescriptor) {
+                ElMessageBox.confirm(language.get('preset.ElTable.delete.message'), { type: 'warning', title: language.get('preset.ElMessageBox.title'), }).then(() => {
+                    resolve(VYR_STORE.slot.row)
+                }).catch(err => {
+                    reject(err)
+                })
+            } else {
+                reject()
+            }
+        })
+    }
+}
+Asset.provider(scriptable, async () => ({ default: RoutineScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: RoutineNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: 20, y: 20 },
+        routine: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+
+

package/src/preset/execute/ElTable/edit.ts

@@ -0,0 +1,38 @@
+import { Asset, Descriptor, Graphics, RoutineNode, Scriptable, UpdateArgs } from "@vyr/engine"
+import { language } from '../../../locale'
+
+const scriptable = Asset.createVirtualUrl('preset/ElTable/edit.ts')
+class RoutineScriptable extends Scriptable {
+    async execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
+        //@ts-ignore
+        const { VYR_STORE } = args
+        return VYR_STORE.slot.row
+    }
+}
+Asset.provider(scriptable, async () => ({ default: RoutineScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: RoutineNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        routine: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+

package/src/preset/execute/ElTable/index.ts

@@ -0,0 +1,3 @@
+export * as create from './create'
+export * as edit from './edit'
+export * as delete from './delete'

package/src/preset/execute/ElTableColumn/formatter.ts

@@ -0,0 +1,74 @@
+import { Asset, Category, DatasetDescriptor, Descriptor, Graphics, RoutineNode, Scriptable, UpdateArgs } from "@vyr/engine"
+import { language } from '../../../locale'
+import { ElTableColumnDescriptor } from "../../../descriptor"
+
+const scriptable = Asset.createVirtualUrl('preset/ElTableColumn/formatter.ts')
+class RoutineScriptable extends Scriptable {
+    traverseData = (options: any[], col: ElTableColumnDescriptor, cache: Map<string, any>) => {
+        for (const option of options) {
+            cache.set(option[col.formattingValue], option[col.formattingLabel])
+            if (Array.isArray(option.children)) this.traverseData(option.children, col, cache)
+        }
+    }
+
+    transformValue = (value: any, col: ElTableColumnDescriptor, cache: Map<string, any>) => {
+        if (value === undefined || value === null) return '-'
+
+        if (typeof value === 'boolean') {
+            return value ? '是' : '否'
+        }
+
+        const labels: string[] = []
+        for (const clip of value.split(',')) {
+            const label = cache.get(clip)
+            if (label) labels.push(label)
+        }
+
+        return labels.join(col.formattingSeparator)
+    }
+
+    execute(descriptor: Descriptor, graphics: Graphics, args: UpdateArgs) {
+        //@ts-ignore
+        const { trigger, input, result } = args
+        const dataset = input?.user?.dataset.value
+
+        const collection = DatasetDescriptor.getCollection(dataset)
+        if (collection.length === 0) {
+            return null
+        } else {
+            const cellValue = result.get(input.previous)
+            const cache = new Map()
+            this.traverseData(collection, trigger, cache)
+
+            return this.transformValue(cellValue, trigger, cache)
+        }
+    }
+}
+Asset.provider(scriptable, async () => ({ default: RoutineScriptable }))
+
+const createExecuteInput = (args: any = {}) => {
+    const input = {
+        dataset: { value: args.dataset ?? '', type: Category.dataset }
+    }
+
+    return input
+}
+
+const createExecuteNode = (options: { id: string; position?: any; input?: any }) => {
+    const executeNode: RoutineNode = {
+        id: options.id,
+        label: language.get(scriptable as any),
+        position: { x: options?.position?.x ?? 20, y: options?.position?.y ?? 20 },
+        routine: 'Execute',
+        url: scriptable,
+        input: createExecuteInput(options.input)
+    }
+    return executeNode
+}
+
+export {
+    scriptable,
+    createExecuteInput,
+    createExecuteNode,
+}
+

package/src/preset/execute/ElTableColumn/index.ts

@@ -0,0 +1 @@
+export * as formatter from './formatter'

package/src/preset/execute/index.ts

@@ -0,0 +1,5 @@
+export * as ElForm from './ElForm'
+export * as ElPagination from './ElPagination'
+export * as ElTable from './ElTable'
+export * as ElTableColumn from './ElTableColumn'
+export * as ElDialog from './ElDialog'

package/src/preset/index.ts

@@ -0,0 +1,7 @@
+import * as executePreset from './execute'
+import * as routinePreset from './routine'
+
+export {
+    executePreset,
+    routinePreset
+}

package/src/preset/routine/ElDialog/close.ts

@@ -0,0 +1,26 @@
+import { Asset, RoutineDescriptor } from "@vyr/engine"
+import { ElDialog } from '../../execute'
+
+const url = Asset.createVirtualUrl('preset/ElDialog/close.routine.json')
+const nodes = {
+    dialog: 'dialog',
+}
+let _currentRoutine: RoutineDescriptor | null = null
+const routineProvider = async () => {
+    if (_currentRoutine === null) {
+        _currentRoutine = new RoutineDescriptor()
+        const dialogNode = ElDialog.close.createExecuteNode({ id: nodes.dialog })
+        _currentRoutine.addNode([dialogNode])
+        _currentRoutine.roots.push(dialogNode.id)
+    }
+    return _currentRoutine
+}
+
+Asset.provider(url, routineProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/routine/ElDialog/index.ts

@@ -0,0 +1 @@
+export * as close from './close'

package/src/preset/routine/ElTable/create.ts

@@ -0,0 +1,31 @@
+import { Asset, RoutineDescriptor, executePreset } from "@vyr/engine"
+import { ElDialog, ElTable } from '../../execute'
+
+const url = Asset.createVirtualUrl('preset/ElTable/create.routine.json')
+const nodes = {
+    create: 'create',
+    dataset: 'dataset',
+    dialog: 'dialog',
+}
+let _currentRoutine: RoutineDescriptor | null = null
+const routineProvider = async () => {
+    if (_currentRoutine === null) {
+        _currentRoutine = new RoutineDescriptor()
+        const createNode = ElTable.create.createExecuteNode({ id: nodes.create })
+        const datasetNode = executePreset.dataset.update.createExecuteNode({ id: nodes.dataset, position: { x: 250, y: 20 } })
+        const dialogNode = ElDialog.open.createExecuteNode({ id: nodes.dialog, position: { x: 500, y: 20 } })
+
+        _currentRoutine.addNode([createNode, datasetNode, dialogNode])
+        _currentRoutine.roots.push(createNode.id)
+    }
+    return _currentRoutine
+}
+
+Asset.provider(url, routineProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/routine/ElTable/delete.ts

@@ -0,0 +1,31 @@
+import { Asset, RoutineDescriptor, executePreset } from "@vyr/engine"
+import { ElTable } from '../../execute'
+
+const url = Asset.createVirtualUrl('preset/ElTable/delete.routine.json')
+const nodes = {
+    delete: 'delete',
+    request: 'request',
+    refresh: 'refresh',
+}
+let _currentRoutine: RoutineDescriptor | null = null
+const routineProvider = async () => {
+    if (_currentRoutine === null) {
+        _currentRoutine = new RoutineDescriptor()
+        const deleteNode = ElTable.delete.createExecuteNode({ id: nodes.delete })
+        const requestNode = executePreset.net.request.createExecuteNode({ id: nodes.request, position: { x: 250, y: 20 } })
+        const refreshNode = executePreset.graphics.invoke.createExecuteNode({ id: nodes.refresh, position: { x: 500, y: 20 } })
+
+        _currentRoutine.addNode([deleteNode, requestNode, refreshNode])
+        _currentRoutine.roots.push(deleteNode.id)
+    }
+    return _currentRoutine
+}
+
+Asset.provider(url, routineProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/routine/ElTable/edit.ts

@@ -0,0 +1,33 @@
+import { Asset, RoutineDescriptor, executePreset } from "@vyr/engine"
+import { ElDialog, ElTable } from '../../execute'
+
+const url = Asset.createVirtualUrl('preset/ElTable/edit.routine.json')
+const nodes = {
+    edit: 'edit',
+    request: 'request',
+    dataset: 'dataset',
+    dialog: 'dialog',
+}
+let _currentRoutine: RoutineDescriptor | null = null
+const routineProvider = async () => {
+    if (_currentRoutine === null) {
+        _currentRoutine = new RoutineDescriptor()
+        const editNode = ElTable.edit.createExecuteNode({ id: nodes.edit })
+        const requestNode = executePreset.net.request.createExecuteNode({ id: nodes.request, position: { x: 250, y: 20 } })
+        const datasetNode = executePreset.dataset.update.createExecuteNode({ id: nodes.dataset, position: { x: 500, y: 20 } })
+        const dialogNode = ElDialog.open.createExecuteNode({ id: nodes.dialog, position: { x: 750, y: 20 } })
+
+        _currentRoutine.addNode([editNode, requestNode, datasetNode, dialogNode])
+        _currentRoutine.roots.push(editNode.id)
+    }
+    return _currentRoutine
+}
+
+Asset.provider(url, routineProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/routine/ElTable/index.ts

@@ -0,0 +1,6 @@
+export * as list from './list'
+export * as reset from './reset'
+export * as create from './create'
+export * as edit from './edit'
+export * as submit from './submit'
+export * as delete from './delete'

package/src/preset/routine/ElTable/list.ts

@@ -0,0 +1,32 @@
+import { Asset, RoutineDescriptor, executePreset } from "@vyr/engine"
+import { ElForm, ElPagination } from '../../execute'
+
+const url = Asset.createVirtualUrl('preset/ElTable/list.routine.json')
+const nodes = {
+    form: 'form',
+    pagination: 'pagination',
+    request: 'request',
+    dataset: 'dataset',
+}
+let _currentRoutine: RoutineDescriptor | null = null
+const routineProvider = async () => {
+    if (_currentRoutine === null) {
+        _currentRoutine = new RoutineDescriptor()
+        const formNode = ElForm.getData.createExecuteNode({ id: nodes.form })
+        const paginationNode = ElPagination.getData.createExecuteNode({ id: nodes.pagination, position: { x: 250, y: 20 } })
+        const requestNode = executePreset.net.request.createExecuteNode({ id: nodes.request, position: { x: 500, y: 20 } })
+        const datasetNode = executePreset.dataset.update.createExecuteNode({ id: nodes.dataset, position: { x: 750, y: 20 } })
+        _currentRoutine.addNode([formNode, paginationNode, requestNode, datasetNode])
+        _currentRoutine.roots.push(formNode.id)
+    }
+    return _currentRoutine
+}
+
+Asset.provider(url, routineProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/routine/ElTable/reset.ts

@@ -0,0 +1,31 @@
+import { Asset, RoutineDescriptor, executePreset } from "@vyr/engine"
+import { ElPagination, ElForm } from '../../execute'
+
+const url = Asset.createVirtualUrl('preset/ElTable/reset.routine.json')
+const nodes = {
+    pagination: 'pagination',
+    form: 'form',
+    refresh: 'refresh',
+}
+let _currentRoutine: RoutineDescriptor | null = null
+const routineProvider = async () => {
+    if (_currentRoutine === null) {
+        _currentRoutine = new RoutineDescriptor()
+        const formNode = ElForm.reset.createExecuteNode({ id: nodes.form, })
+        const paginationNode = ElPagination.reset.createExecuteNode({ id: nodes.pagination, position: { x: 250, y: 20 } })
+        const refreshNode = executePreset.graphics.invoke.createExecuteNode({ id: nodes.refresh, position: { x: 500, y: 20 } })
+
+        _currentRoutine.addNode([formNode, paginationNode, refreshNode])
+        _currentRoutine.roots.push(formNode.id)
+    }
+    return _currentRoutine
+}
+
+Asset.provider(url, routineProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/routine/ElTable/submit.ts

@@ -0,0 +1,45 @@
+import { Asset, RoutineDescriptor, executePreset } from "@vyr/engine"
+import { ElDialog, ElForm } from '../../execute'
+
+const url = Asset.createVirtualUrl('preset/ElTable/submit.routine.json')
+const nodes = {
+    form: 'form',
+    branch: 'branch',
+    create: 'create',
+    edit: 'edit',
+    createRequest: 'createRequest',
+    editRequest: 'editRequest',
+    dialog: 'dialog',
+    refresh: 'refresh',
+}
+let _currentRoutine: RoutineDescriptor | null = null
+const routineProvider = async () => {
+    if (_currentRoutine === null) {
+        _currentRoutine = new RoutineDescriptor()
+        const formNode = ElForm.getData.createExecuteNode({ id: nodes.form })
+        const branchNode = ElForm.branch.createExecuteNode({ id: nodes.branch, position: { x: 250, y: 20 } })
+        const createNode = ElForm.create.createExecuteNode({ id: nodes.create, position: { x: 500, y: 20 } })
+        const editNode = ElForm.edit.createExecuteNode({ id: nodes.edit, position: { x: 500, y: 140 } })
+        const createRequestNode = executePreset.net.request.createExecuteNode({ id: nodes.createRequest, position: { x: 750, y: 20 } })
+        const editRequestNode = executePreset.net.request.createExecuteNode({ id: nodes.editRequest, position: { x: 750, y: 140 } })
+        const dialogNode = ElDialog.close.createExecuteNode({ id: nodes.dialog, position: { x: 1000, y: 20 } })
+        const refreshNode = executePreset.graphics.invoke.createExecuteNode({ id: nodes.refresh, position: { x: 1250, y: 20 } })
+        _currentRoutine.addNode([formNode, branchNode, createNode, createRequestNode, dialogNode, refreshNode])
+        _currentRoutine.addNode([editNode, editRequestNode])
+        _currentRoutine.mappers.push(
+            { source: branchNode.id, target: editNode.id },
+            { source: editRequestNode.id, target: dialogNode.id },
+        )
+        _currentRoutine.roots.push(formNode.id)
+    }
+    return _currentRoutine
+}
+
+Asset.provider(url, routineProvider)
+
+export {
+    url,
+    nodes,
+}
+
+

package/src/preset/routine/index.ts

@@ -0,0 +1,2 @@
+export * as ElTable from './ElTable'
+export * as ElDialog from './ElDialog'

package/src/shims-vue.d.ts

@@ -0,0 +1,5 @@
+/* eslint-disable */
+declare module '*.vue' {
+  const component: DefineComponent<{}, {}, any>
+  export default component
+}

package/src/utils/form.ts

@@ -0,0 +1,72 @@
+import { DatasetDescriptor, Descriptor } from "@vyr/engine"
+import { ElCascaderDescriptor, ElCheckboxDescriptor, ElFormItemDescriptor, ElRadioDescriptor, ElSelectDescriptor, ElSwitchDescriptor } from "../descriptor"
+
+interface Option extends ElFormItemDescriptor {
+    label: string
+    value: string
+}
+
+const isOption = (option: ElFormItemDescriptor): option is Option => {
+    return [ElCascaderDescriptor.type, ElCheckboxDescriptor.type, ElRadioDescriptor.type, ElSelectDescriptor.type].includes(option.type)
+}
+
+const traverseOptions = (options: any[], col: Option, cache: Map<string, any>) => {
+    for (const option of options) {
+        cache.set(option[col.value], option[col.label])
+        if (Array.isArray(option.children)) traverseOptions(option.children, col, cache)
+    }
+}
+
+const useFormUtils = (descriptor: Descriptor) => {
+    const items: ElFormItemDescriptor[] = []
+    const dataCache = new Map<string, Map<string, any>>()
+
+    descriptor.traverse(item => {
+        if (item instanceof ElFormItemDescriptor) {
+            items.push(item)
+            if (isOption(item)) {
+                const options = DatasetDescriptor.getCollection(item.dataset)
+                if (options.length === 0) return
+                const cache = new Map()
+                traverseOptions(options, item, cache)
+                dataCache.set(item.columnName, cache)
+            }
+        }
+    })
+
+    const transformValue = (value: any, item: ElFormItemDescriptor) => {
+        if (value === undefined || value === null) return '-'
+
+        if (item.type === ElSwitchDescriptor.type) {
+            return value ? '是' : '否'
+        }
+
+        const cache = dataCache.get(item.columnName)
+        if (cache === undefined) return value
+
+        const labels: string[] = []
+        for (const clip of value.split(',')) {
+            const label = cache.get(clip)
+            if (label) labels.push(label)
+        }
+
+        if ([ElCascaderDescriptor.type].includes(item.type)) {
+            return labels.join('/')
+        } else if ([ElSelectDescriptor.type, ElCheckboxDescriptor.type, ElRadioDescriptor.type].includes(item.type)) {
+            return labels.join('、')
+        } else {
+            return labels.join('、')
+        }
+    }
+
+    return {
+        items,
+        dataCache,
+        transformValue,
+    }
+}
+
+export {
+    traverseOptions,
+    useFormUtils,
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './validator'
+export * from './style'
+export * from './form'

package/src/utils/style.ts

@@ -0,0 +1,9 @@
+import { HTMLStyle } from "@vyr/engine"
+
+const mergeStyle = (style: HTMLStyle, attrs: any) => {
+    if (attrs.style === undefined) attrs.style = {}
+
+    Object.assign(attrs.style, style)
+}
+
+export { mergeStyle }

package/src/utils/validator.ts

@@ -0,0 +1,30 @@
+import { language } from '../locale'
+import { ElFormItemDescriptor } from "../descriptor"
+import { ElFormItemActor } from "../actor"
+
+const requiredValidator = (descriptor: ElFormItemDescriptor, actor: ElFormItemActor) => {
+    const validator = (rule: any, value: any, callback: any) => {
+        const modelValue = actor.getModelValue()
+        if (modelValue === undefined || modelValue === null || modelValue === '' || (Array.isArray(modelValue) && modelValue.length === 0)) {
+            callback(new Error(language.get('utils.validator.required', { name: descriptor.columnComment })))
+        } else {
+            callback()
+        }
+    }
+    return validator
+}
+
+const getValidators = (descriptor: ElFormItemDescriptor, actor: ElFormItemActor) => {
+    const rules: { validator: (rule: any, value: any, callback: any) => void }[] = []
+
+    if (descriptor.visible === false) return rules
+
+    if (descriptor.required) rules.push({ validator: requiredValidator(descriptor, actor) })
+
+    return rules
+}
+
+export {
+    requiredValidator,
+    getValidators,
+}