@vunk/form 0.0.0-alpha.1 → 0.0.0-alpha.10

package/components/form-item/index.d.ts

@@ -0,0 +1,5 @@
+import VkfFormItem from './src/index.vue';
+export * as __VkfFormItem from './src/types';
+export * as _VkfFormItemCtx from './src/ctx';
+export { VkfFormItem, };
+export default VkfFormItem;

package/components/form-item/index.js

@@ -0,0 +1,89 @@
+import { formItemProps, ElFormItem } from 'element-plus';
+import { bindPropsFactory } from 'vunk/shared/utils-vue';
+import { defineComponent, resolveComponent, openBlock, createBlock, mergeProps, createSlots, withCtx, renderSlot, renderList, resolveDynamicComponent } from 'vue';
+import { createFormItemBindProps } from '@vunk/form/shared/element-plus/ctx';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const _props = __spreadProps(__spreadValues({}, formItemProps), {
+  formItemSize: {
+    type: String,
+    default: "default"
+  },
+  formItemSlots: {
+    type: Object,
+    default: void 0
+  }
+});
+Reflect.deleteProperty(_props, "size");
+const props = _props;
+const createBindProps = bindPropsFactory(props);
+
+var ctx = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  props: props,
+  createBindProps: createBindProps
+});
+
+var script = defineComponent({
+  name: "VkfFormItem",
+  components: {
+    ElFormItem
+  },
+  props,
+  setup(props2) {
+    const formItemBindProps = createFormItemBindProps(props2);
+    return {
+      formItemBindProps
+    };
+  }
+});
+
+function render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_ElFormItem = resolveComponent("ElFormItem");
+  return openBlock(), createBlock(_component_ElFormItem, mergeProps(_ctx.formItemBindProps, { size: _ctx.formItemSize }), createSlots({
+    default: withCtx(() => [
+      renderSlot(_ctx.$slots, "default")
+    ]),
+    _: 2
+  }, [
+    renderList(_ctx.formItemSlots, (item, key) => {
+      return {
+        name: key,
+        fn: withCtx((e) => [
+          (openBlock(), createBlock(resolveDynamicComponent(item == null ? void 0 : item(e))))
+        ])
+      };
+    })
+  ]), 1040, ["size"]);
+}
+
+script.render = render;
+script.__file = "form-item/src/index.vue";
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+script.install = (app) => {
+  app.component(script.name, script);
+};
+
+export { script as VkfFormItem, ctx as _VkfFormItemCtx, types as __VkfFormItem, script as default };

package/components/form-item/src/ctx.d.ts

@@ -0,0 +1,44 @@
+import { FormItemSlots } from './types';
+import { PropType } from 'vue';
+export declare const props: Omit<{
+    formItemSize: {
+        type: PropType<"default" | "small" | "large">;
+        default: string;
+    };
+    formItemSlots: {
+        type: PropType<FormItemSlots>;
+        default: any;
+    };
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    prop: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    rules: {
+        readonly type: PropType<unknown>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    size: {
+        readonly type: PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+}, "size">;
+export declare const createBindProps: <T2 extends Record<string, any>, EX extends ("required" | "label" | "labelWidth" | "prop" | "rules" | "error" | "validateStatus" | "for" | "inlineMessage" | "showMessage" | "formItemSize" | "formItemSlots")[], K extends Extract<EX extends (infer V)[] ? Exclude<keyof T2, V> : keyof T2, "required" | "label" | "labelWidth" | "prop" | "rules" | "error" | "validateStatus" | "for" | "inlineMessage" | "showMessage" | "formItemSize" | "formItemSlots">>(propsArg: T2, excludes?: EX) => import("vue").ComputedRef<{ [k in K]: T2[k]; }>;

package/components/form-item/src/index.vue.d.ts

@@ -0,0 +1,91 @@
+declare const _default: import("vue").DefineComponent<Omit<{
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: string;
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("./types").FormItemSlots>;
+        default: any;
+    };
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    rules: {
+        readonly type: import("vue").PropType<unknown>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+}, "size">, {
+    formItemBindProps: import("vue").ComputedRef<{}>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<Omit<{
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: string;
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("./types").FormItemSlots>;
+        default: any;
+    };
+    label: StringConstructor;
+    labelWidth: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, NumberConstructor], unknown, unknown, "", boolean>;
+    prop: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp) | ((new (...args: any[]) => import("element-plus").FormItemProp & {}) | (() => import("element-plus").FormItemProp))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    rules: {
+        readonly type: import("vue").PropType<unknown>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "error" | "success" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+    for: StringConstructor;
+    inlineMessage: import("element-plus/es/utils").EpPropFinalized<readonly [StringConstructor, BooleanConstructor], unknown, unknown, "", boolean>;
+    showMessage: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, true, boolean>;
+    size: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "default" | "small" | "large", unknown>>;
+        readonly required: false;
+        readonly validator: (val: unknown) => boolean;
+        __epPropKey: true;
+    };
+}, "size">>>, {
+    required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    labelWidth: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, NumberConstructor], unknown, unknown>;
+    inlineMessage: import("element-plus/es/utils").EpPropMergeType<readonly [StringConstructor, BooleanConstructor], unknown, unknown>;
+    showMessage: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    formItemSize: "default" | "small" | "large";
+    formItemSlots: import("./types").FormItemSlots;
+}>;
+export default _default;

package/components/form-item/src/types.d.ts

@@ -0,0 +1,6 @@
+import { Func } from '@vunk/form/shared/types';
+export declare type FormItemSlots = {
+    label: Func<{
+        label: string;
+    }>;
+};

package/components/form-item-renderer/index.js

@@ -1,4 +1,4 @@
-import { defineComponent, shallowReactive, provide, h } from 'vue';
+import { defineComponent, shallowReactive, provide, h, nextTick } from 'vue';
 
 const props = {
   source: {
@@ -17,11 +17,28 @@ const props = {
 
 const S_TEMPLATE_INSTANCES = Symbol("templateInstances");
 
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
 const VkfFormItemRenderer = defineComponent({
   name: "VkfFormItemRenderer",
   props: props,
   setup(props$1, ctx) {
-    const templateInstances = props$1.templateInstances ?? shallowReactive({});
+    var _a;
+    const templateInstances = (_a = props$1.templateInstances) != null ? _a : shallowReactive({});
     provide(S_TEMPLATE_INSTANCES, templateInstances);
     const Renderer = defineComponent({
       props: props,
@@ -35,19 +52,25 @@ const VkfFormItemRenderer = defineComponent({
     });
     const renderFormItems = (data, pK = []) => {
       return data.reduce((a, c, index) => {
+        var _a2, _b, _c;
         const currentK = [...props$1.k, ...pK, index];
         if (c.templateType && templateInstances[c.templateType]) {
-          const slotData = { ...c };
+          const slotData = __spreadValues({}, c);
           Reflect.deleteProperty(slotData, "templateType");
           Reflect.deleteProperty(slotData, "templateSlots");
-          const nodes = templateInstances[c.templateType].slots.default?.({
+          const nodes = (_b = (_a2 = templateInstances[c.templateType].slots).default) == null ? void 0 : _b.call(_a2, {
             data: slotData,
             raw: c,
             Renderer,
             k: currentK
           });
           nodes && a.push(nodes);
-        } else if (c.templateSlots?.default) {
+        } else if ((_c = c.templateSlots) == null ? void 0 : _c.default) {
+          nextTick(() => {
+            if (c.templateType && !templateInstances[c.templateType]) {
+              console.warn(c.templateType, "templateType\u4E0D\u5B58\u5728\u5C06\u8DF3\u8FC7");
+            }
+          });
           currentK.push("templateSlots", "default");
           return renderFormItems(c.templateSlots.default, currentK);
         }
@@ -55,7 +78,8 @@ const VkfFormItemRenderer = defineComponent({
       }, []);
     };
     return () => {
-      const tempSlots = ctx.slots.default?.();
+      var _a2, _b;
+      const tempSlots = (_b = (_a2 = ctx.slots).default) == null ? void 0 : _b.call(_a2);
       return [
         tempSlots,
         renderFormItems(props$1.source)

package/components/form-item-renderer/src/ctx.d.ts

@@ -3,14 +3,14 @@ import { RendererTreeData } from './types';
 export declare const props: {
     source: {
         type: PropType<RendererTreeData[]>;
-        default: () => never[];
+        default: () => any[];
     };
     templateInstances: {
         type: PropType<Record<string, ComponentInternalInstance>>;
-        default: undefined;
+        default: any;
     };
     k: {
         type: PropType<(string | number)[]>;
-        default: () => never[];
+        default: () => any[];
     };
 };

package/components/form-item-renderer/src/index.vue.d.ts

@@ -3,36 +3,36 @@ import { RendererTreeData } from './types';
 declare const VkfFormItemRenderer: import("vue").DefineComponent<{
     source: {
         type: import("vue").PropType<RendererTreeData[]>;
-        default: () => never[];
+        default: () => any[];
     };
     templateInstances: {
         type: import("vue").PropType<Record<string, ComponentInternalInstance>>;
-        default: undefined;
+        default: any;
     };
     k: {
         type: import("vue").PropType<(string | number)[]>;
-        default: () => never[];
+        default: () => any[];
     };
 }, () => (VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
-}>[] | (VNode<import("vue").RendererNode, import("vue").RendererElement, {
+}>[] | VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
-}> | undefined)[][] | undefined)[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}>[][])[], unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     source: {
         type: import("vue").PropType<RendererTreeData[]>;
-        default: () => never[];
+        default: () => any[];
     };
     templateInstances: {
         type: import("vue").PropType<Record<string, ComponentInternalInstance>>;
-        default: undefined;
+        default: any;
     };
     k: {
         type: import("vue").PropType<(string | number)[]>;
-        default: () => never[];
+        default: () => any[];
     };
 }>>, {
-    source: RendererTreeData[];
     templateInstances: Record<string, ComponentInternalInstance>;
+    source: RendererTreeData[];
     k: (string | number)[];
 }>;
 export default VkfFormItemRenderer;

package/components/form-item-renderer-template/src/index.vue.d.ts

@@ -4,7 +4,7 @@ declare const _default: import("vue").DefineComponent<{
         required: boolean;
         default: string;
     };
-}, () => null, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+}, () => any, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, Record<string, any>, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
     type: {
         type: StringConstructor;
         required: boolean;

package/components/ground/index.css

@@ -1,17 +1,34 @@
 
-.vkf-ground{
+.vkf-ground {
   display: flex;
 }
-.vkf-ground-widget-x{
+
+.vkf-ground-widget-x {
   width: 15em;
   height: 100%;
 }
-.vkf-ground-main-x{
+
+.vkf-ground-main-x {
   flex: 3;
+}
+
+.vkf-ground-main-x .vkf-ground-main-card {
+  height: 100%;
+}
+
+.vkf-ground-main-card>.vk-card-title {
+  display: flex;
+  justify-content: end;
+  margin-bottom: var(--gap-xxs);
+}
+
+.vkf-ground-main-card>.vk-card-body {
+  height: 100%;
   border: 2px var(--el-border-color) dashed;
   overflow: auto;
 }
-.vkf-ground-config-x{
+
+.vkf-ground-config-x {
   padding: 0 1em;
   flex: 1;
 }
@@ -20,25 +37,28 @@
   min-height: 100%;
   padding: .5em;
 }
+
 .vkf-ground-end.is-dragover-prev {
   border-top: 2px var(--el-color-primary) solid;
 }
-.vkf-gm-form-item-x.vk-tab-item{
+
+.vkf-gm-form-item-x.vk-tab-item {
   cursor: initial;
 }
-.vkf-gm-form-item-x.is-active{
+
+.vkf-gm-form-item-x.is-active {
   border: 2px var(--el-color-primary) dashed;
   /* margin-bottom: .5em; */
 }
+
 .vkf-gm-form-item-x .el-form-item {
   transition: all .3s ease;
 }
-.vkf-gm-form-item-x.is-active .el-form-item{
+
+.vkf-gm-form-item-x.is-active .el-form-item {
   padding: 1em .5em 0;
 }
 
-
- 
 .vkf-widget-tab{
   position: relative;
   width: 100%;
@@ -66,16 +86,34 @@
   border-radius: 4px;
 }
 
-.vkf-gmew-drag-wrapper{
-  cursor: move;
+.vkf-ground-main-editing-wrapper{
+  overflow: hidden;
+  position: relative;
+}
+
+.vkf-gmew-tools{
   background: var(--el-color-primary);
   color: var(--el-color-white);
   opacity: .7;
+}
+
+.vkf-gmew-drag-wrapper{
+  cursor: move;
   font-size: .8em;
 }
-.vkf-ground-main-editing-wrapper{
-  overflow: hidden;
+
+.vkf-gmew-rb-x{
+  position: absolute;
+  right: 0;
+  bottom: 0;
+  z-index: 2;
+  padding: 0 .2em;
+}
+.vkf-gmew-rb-x .el-icon {
+  cursor: pointer;
 }
+
+
 .vkf-ground-main-editing-wrapper.is-dragover-next{
   border-bottom: 2px solid var(--el-color-primary);
 }