@vunk/form 1.2.2 → 1.3.1

package/components/monaco-editor/index.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var formItem = require('@vunk/form/components/form-item');
+var monacoEditor = require('@vunk/plus/components/monaco-editor');
+var vue = require('vue');
+var composables = require('@vunk/form/composables');
+var _pluginVue_exportHelper = require('../_plugin-vue_export-helper.cjs');
+
+const props = {
+  ...formItem._VkfFormItemCtx.props,
+  ...monacoEditor._VkMonacoEditorCtx.props,
+  readonly: {
+    type: Boolean,
+    default: void 0
+  },
+  height: {
+    type: String,
+    default: "200px"
+  }
+};
+const emits = {
+  ...monacoEditor._VkMonacoEditorCtx.emits
+};
+
+var _sfc_main = vue.defineComponent({
+  name: "VkfMonacoEditor",
+  components: {
+    VkMonacoEditor: monacoEditor.VkMonacoEditor,
+    VkfFormItem: formItem.VkfFormItem
+  },
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const coreProps = monacoEditor._VkMonacoEditorCtx.createBindProps(props2, ["readOnly"]);
+    const coreEmits = monacoEditor._VkMonacoEditorCtx.createOnEmits(emit);
+    const formItemBindProps = formItem._VkfFormItemCtx.createBindProps(props2);
+    const readonly = composables.useComputedReadonly(props2);
+    return {
+      formItemBindProps,
+      readonly,
+      coreProps,
+      coreEmits
+    };
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkMonacoEditor = vue.resolveComponent("VkMonacoEditor");
+  const _component_VkfFormItem = vue.resolveComponent("VkfFormItem");
+  return vue.openBlock(), vue.createBlock(
+    _component_VkfFormItem,
+    vue.normalizeProps(vue.guardReactiveProps(_ctx.formItemBindProps)),
+    {
+      default: vue.withCtx(() => [
+        vue.createVNode(_component_VkMonacoEditor, vue.mergeProps({
+          style: {
+            height: _ctx.height
+          },
+          "read-only": _ctx.readonly
+        }, _ctx.coreProps, vue.toHandlers(_ctx.coreEmits)), null, 16, ["style", "read-only"])
+      ]),
+      _: 1
+      /* STABLE */
+    },
+    16
+    /* FULL_PROPS */
+  );
+}
+var VkfMonacoEditor = /* @__PURE__ */ _pluginVue_exportHelper._export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/monaco-editor/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfMonacoEditor.install = (app) => {
+  app.component(VkfMonacoEditor.name || "VkfMonacoEditor", VkfMonacoEditor);
+};
+
+exports.VkfMonacoEditor = VkfMonacoEditor;
+exports.__VkfMonacoEditor = types;
+exports.default = VkfMonacoEditor;

package/components/monaco-editor/index.css

@@ -0,0 +1,3 @@
+.vkf-form-item .vk-monaco-editor{
+  margin-top: 0.5em;
+}

package/components/monaco-editor/index.d.ts

@@ -0,0 +1,4 @@
+import VkfMonacoEditor from './src/index.vue';
+export * as __VkfMonacoEditor from './src/types';
+export { VkfMonacoEditor, };
+export default VkfMonacoEditor;

package/components/monaco-editor/index.mjs

@@ -0,0 +1,77 @@
+import { _VkfFormItemCtx, VkfFormItem } from '@vunk/form/components/form-item';
+import { _VkMonacoEditorCtx, VkMonacoEditor } from '@vunk/plus/components/monaco-editor';
+import { defineComponent, resolveComponent, openBlock, createBlock, normalizeProps, guardReactiveProps, withCtx, createVNode, mergeProps, toHandlers } from 'vue';
+import { useComputedReadonly } from '@vunk/form/composables';
+import { _ as _export_sfc } from '../_plugin-vue_export-helper.mjs';
+
+const props = {
+  ..._VkfFormItemCtx.props,
+  ..._VkMonacoEditorCtx.props,
+  readonly: {
+    type: Boolean,
+    default: void 0
+  },
+  height: {
+    type: String,
+    default: "200px"
+  }
+};
+const emits = {
+  ..._VkMonacoEditorCtx.emits
+};
+
+var _sfc_main = defineComponent({
+  name: "VkfMonacoEditor",
+  components: {
+    VkMonacoEditor,
+    VkfFormItem
+  },
+  props,
+  emits,
+  setup(props2, { emit }) {
+    const coreProps = _VkMonacoEditorCtx.createBindProps(props2, ["readOnly"]);
+    const coreEmits = _VkMonacoEditorCtx.createOnEmits(emit);
+    const formItemBindProps = _VkfFormItemCtx.createBindProps(props2);
+    const readonly = useComputedReadonly(props2);
+    return {
+      formItemBindProps,
+      readonly,
+      coreProps,
+      coreEmits
+    };
+  }
+});
+
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_VkMonacoEditor = resolveComponent("VkMonacoEditor");
+  const _component_VkfFormItem = resolveComponent("VkfFormItem");
+  return openBlock(), createBlock(
+    _component_VkfFormItem,
+    normalizeProps(guardReactiveProps(_ctx.formItemBindProps)),
+    {
+      default: withCtx(() => [
+        createVNode(_component_VkMonacoEditor, mergeProps({
+          style: {
+            height: _ctx.height
+          },
+          "read-only": _ctx.readonly
+        }, _ctx.coreProps, toHandlers(_ctx.coreEmits)), null, 16, ["style", "read-only"])
+      ]),
+      _: 1
+      /* STABLE */
+    },
+    16
+    /* FULL_PROPS */
+  );
+}
+var VkfMonacoEditor = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "/home/runner/work/private-vunk-form/private-vunk-form/packages/components/monaco-editor/src/index.vue"]]);
+
+var types = /*#__PURE__*/Object.freeze({
+  __proto__: null
+});
+
+VkfMonacoEditor.install = (app) => {
+  app.component(VkfMonacoEditor.name || "VkfMonacoEditor", VkfMonacoEditor);
+};
+
+export { VkfMonacoEditor, types as __VkfMonacoEditor, VkfMonacoEditor as default };

package/components/monaco-editor/src/ctx.d.ts

@@ -0,0 +1,70 @@
+export declare const props: {
+    readonly: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultOptions: {
+        type: import("vue").PropType<import("monaco-editor").editor.IStandaloneEditorConstructionOptions>;
+        default: () => {};
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: "default" | "small" | "large";
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("@vunk/form/components/form-item/src/types").FormItemSlots>;
+        default: any;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelPosition: {
+        type: import("vue").PropType<"right">;
+        default: string;
+    };
+    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) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "success" | "error" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __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>;
+};
+export declare const emits: {
+    'update:modelValue': any;
+};

package/components/monaco-editor/src/index.vue.d.ts

@@ -0,0 +1,209 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultOptions: {
+        type: import("vue").PropType<import("monaco-editor").editor.IStandaloneEditorConstructionOptions>;
+        default: () => {};
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: "default" | "small" | "large";
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("@vunk/form/components/form-item/src/types").FormItemSlots>;
+        default: any;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelPosition: {
+        type: import("vue").PropType<"right">;
+        default: string;
+    };
+    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) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "success" | "error" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __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>;
+}>, {
+    formItemBindProps: import("vue").ComputedRef<{}>;
+    readonly: import("vue").ComputedRef<boolean>;
+    coreProps: import("vue").ComputedRef<{
+        modelValue: string;
+        defaultOptions: import("monaco-editor").editor.IStandaloneEditorConstructionOptions;
+    }>;
+    coreEmits: {};
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    'update:modelValue': any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    height: {
+        type: StringConstructor;
+        default: string;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultOptions: {
+        type: import("vue").PropType<import("monaco-editor").editor.IStandaloneEditorConstructionOptions>;
+        default: () => {};
+    };
+    readOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    required: import("element-plus/es/utils").EpPropFinalized<BooleanConstructor, unknown, unknown, undefined, boolean>;
+    formItemSize: {
+        type: import("vue").PropType<"default" | "small" | "large">;
+        default: "default" | "small" | "large";
+    };
+    formItemSlots: {
+        type: import("vue").PropType<import("@vunk/form/components/form-item/src/types").FormItemSlots>;
+        default: any;
+    };
+    elRef: {
+        type: import("vue").PropType<any>;
+        required: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    labelPosition: {
+        type: import("vue").PropType<"right">;
+        default: string;
+    };
+    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) | undefined;
+        __epPropKey: true;
+    };
+    rules: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<(new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>) | ((new (...args: any[]) => import("element-plus").FormItemRule | import("element-plus").FormItemRule[]) | (() => import("element-plus/es/utils").Arrayable<import("element-plus").FormItemRule>))[], unknown, unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __epPropKey: true;
+    };
+    error: StringConstructor;
+    validateStatus: {
+        readonly type: import("vue").PropType<import("element-plus/es/utils").EpPropMergeType<StringConstructor, "" | "success" | "error" | "validating", unknown>>;
+        readonly required: false;
+        readonly validator: ((val: unknown) => boolean) | undefined;
+        __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>;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
+}>, {
+    required: import("element-plus/es/utils").EpPropMergeType<BooleanConstructor, unknown, unknown>;
+    formItemSize: "default" | "small" | "large";
+    formItemSlots: import("@vunk/form/components/form-item/src/types").FormItemSlots;
+    inline: boolean;
+    readonly: boolean;
+    labelPosition: "right";
+    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>;
+    modelValue: string;
+    defaultOptions: import("monaco-editor").editor.IStandaloneEditorConstructionOptions;
+    readOnly: boolean;
+    height: string;
+}, {}, {
+    VkMonacoEditor: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        modelValue: {
+            type: StringConstructor;
+            default: string;
+        };
+        defaultOptions: {
+            type: import("vue").PropType<import("monaco-editor").editor.IStandaloneEditorConstructionOptions>;
+            default: () => {};
+        };
+        readOnly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>, {
+        editorNode: import("vue").Ref<HTMLDivElement, HTMLDivElement>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        'update:modelValue': any;
+    }, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        modelValue: {
+            type: StringConstructor;
+            default: string;
+        };
+        defaultOptions: {
+            type: import("vue").PropType<import("monaco-editor").editor.IStandaloneEditorConstructionOptions>;
+            default: () => {};
+        };
+        readOnly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: (...args: any[] | unknown[]) => any;
+    }>, {
+        modelValue: string;
+        defaultOptions: import("monaco-editor").editor.IStandaloneEditorConstructionOptions;
+        readOnly: boolean;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    VkfFormItem: {
+        new (...args: any[]): any;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<Record<string | symbol, any>>>, Record<string | symbol, any>, any, import("vue").ComputedOptions, import("vue").MethodOptions, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+        [x: string]: any;
+        [x: symbol]: any;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+        install(app: import("vue").App): void;
+    };
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/monaco-editor/src/types.d.ts

@@ -0,0 +1,7 @@
+import { VueComponentPropsType } from '@vunk/shared';
+import Core from './index.vue';
+import { BasicSource } from '@vunk/form/shared';
+export interface Source<P extends string = string> extends VueComponentPropsType<typeof Core>, BasicSource {
+    prop?: P;
+    templateType: 'VkfMonacoEditor';
+}