cosey 0.9.4 → 0.10.0

package/components/editor/plugins/video.js

@@ -0,0 +1,40 @@
+import { h } from 'vue';
+import stdin_default from '../contents/content-video.js';
+import { useInheritRef } from 'slate-vue3';
+
+const insertVideo = (editor, url, width, height) => {
+  const video = { type: "video", url, width, height, children: [{ text: "" }] };
+  editor.insertNodes(video);
+  editor.move();
+};
+function withVideo(editor) {
+  const { isInline, isVoid, renderElement } = editor;
+  editor.isInline = (element) => {
+    return element.type === "video" ? true : isInline(element);
+  };
+  editor.isVoid = (element) => {
+    return element.type === "video" ? true : isVoid(element);
+  };
+  editor.renderElement = (props) => {
+    const { attributes, children, element } = props;
+    if (element.type === "video") {
+      return h(
+        stdin_default,
+        {
+          ...useInheritRef(attributes),
+          url: element.url,
+          width: element.width,
+          height: element.height
+        },
+        () => children
+      );
+    }
+    return renderElement(props);
+  };
+  editor.insertVideo = (url, width, height) => {
+    insertVideo(editor, url, width, height);
+  };
+  return editor;
+}
+
+export { withVideo };

package/components/editor/toolbar.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/components/editor/toolbar.js

@@ -0,0 +1,20 @@
+import { defineComponent, createVNode } from 'vue';
+import { useComponentConfig } from '../config-provider/config-provider.api.js';
+
+var stdin_default = defineComponent({
+  name: "CoEditorToolbar",
+  setup(props, {
+    slots
+  }) {
+    const {
+      prefixCls
+    } = useComponentConfig("editor-toolbar");
+    return () => {
+      return createVNode("div", {
+        "class": prefixCls.value
+      }, [slots.default?.()]);
+    };
+  }
+});
+
+export { stdin_default as default };

package/components/editor/types.d.ts

@@ -0,0 +1,194 @@
+import { Descendant, BaseEditor, BaseRange } from 'slate-vue3/core';
+import type { DOMEditor } from 'slate-vue3/dom';
+import { type FormatAlign } from './plugins/align';
+export type ListType = 'numbered-list' | 'bulleted-list';
+export type NestedListType = 'nested-numbered-list' | 'nested-bulleted-list';
+export declare const HEADING_TYPES: readonly ["heading-one", "heading-two", "heading-three", "heading-four", "heading-five", "heading-six"];
+export declare const HEADING_WITH_PARA_TYPES: readonly ["paragraph", "heading-one", "heading-two", "heading-three", "heading-four", "heading-five", "heading-six"];
+export type HeadingParagraphType = (typeof HEADING_WITH_PARA_TYPES)[number];
+export type HeadingType = (typeof HEADING_TYPES)[number];
+export declare const NORMAL_BLOCK_TYPES: readonly ["paragraph", "heading-one", "heading-two", "heading-three", "heading-four", "heading-five", "heading-six", "block-quote"];
+export type NormalBlockType = (typeof NORMAL_BLOCK_TYPES)[number];
+export declare const mapElementTypeTagName: Record<string, string>;
+export declare const tagToElementTypeMap: {
+    P: string;
+    BLOCKQUOTE: string;
+    H1: string;
+    H2: string;
+    H3: string;
+    H4: string;
+    H5: string;
+    H6: string;
+    UL: string;
+    OL: string;
+    LI: string;
+    PRE: string;
+    TABLE: string;
+    THEAD: string;
+    TBODY: string;
+    TR: string;
+    TD: string;
+    TH: string;
+};
+export type ParagraphElement = {
+    type: 'paragraph';
+    children: Descendant[];
+    align?: FormatAlign;
+    indent?: number;
+};
+export type HeadingOneElement = {
+    type: 'heading-one';
+    children: Descendant[];
+    align?: FormatAlign;
+    indent?: number;
+};
+export type HeadingTwoElement = {
+    type: 'heading-two';
+    children: Descendant[];
+    align?: FormatAlign;
+    indent?: number;
+};
+export type HeadingThreeElement = {
+    type: 'heading-three';
+    children: Descendant[];
+    align?: FormatAlign;
+    indent?: number;
+};
+export type HeadingFourElement = {
+    type: 'heading-four';
+    children: Descendant[];
+    align?: FormatAlign;
+    indent?: number;
+};
+export type HeadingFiveElement = {
+    type: 'heading-five';
+    children: Descendant[];
+    align?: FormatAlign;
+    indent?: number;
+};
+export type HeadingSixElement = {
+    type: 'heading-six';
+    children: Descendant[];
+    align?: FormatAlign;
+    indent?: number;
+};
+export type BlockQuoteElement = {
+    type: 'block-quote';
+    children: Descendant[];
+    align?: FormatAlign;
+    indent?: number;
+};
+export type BulletedListElement = {
+    type: 'bulleted-list';
+    children: ListItemElement[];
+};
+export type NumberedListElement = {
+    type: 'numbered-list';
+    children: ListItemElement[];
+};
+export type ListItemElement = {
+    type: 'list-item';
+    listType: 'bulleted-list' | 'numbered-list';
+    children: Descendant[];
+    level: number;
+};
+export type NestedBulletedListElement = {
+    type: 'nested-bulleted-list';
+    children: NestedListItemElement[];
+    parent: NestedListItemElement | null;
+};
+export type NestedNumberedListElement = {
+    type: 'nested-numbered-list';
+    children: NestedListItemElement[];
+    parent: NestedListItemElement | null;
+};
+export type NestedListItemElement = {
+    type: 'nested-list-item';
+    children: Descendant[];
+    parent: NestedBulletedListElement | NestedNumberedListElement | null;
+};
+export type TableElement = {
+    type: 'table';
+    children: Descendant[];
+};
+export type TableHeadElement = {
+    type: 'table-head';
+    children: Descendant[];
+};
+export type TableBodyElement = {
+    type: 'table-body';
+    children: Descendant[];
+};
+export type TableRowElement = {
+    type: 'table-row';
+    children: Descendant[];
+};
+export type TableCellElement = {
+    type: 'table-cell';
+    children: Descendant[];
+};
+export type ImageElement = {
+    type: 'image';
+    url: string;
+    width?: string | number;
+    height?: string | number;
+    file?: File;
+    children: EmptyText[];
+};
+export type VideoElement = {
+    type: 'video';
+    url: string;
+    width?: string | number;
+    height?: string | number;
+    children: EmptyText[];
+};
+export type LinkElement = {
+    type: 'link';
+    url: string;
+    target: string;
+    children: Descendant[];
+};
+export type FormulaElement = {
+    type: 'formula';
+    formula: string;
+    children: EmptyText[];
+};
+export type CodeBlockElement = {
+    type: 'code-block';
+    language: string;
+    children: Descendant[];
+};
+export type CodeLineElement = {
+    type: 'code-line';
+    children: Descendant[];
+};
+export type HeadingElement = HeadingOneElement | HeadingTwoElement | HeadingThreeElement | HeadingFourElement | HeadingFiveElement | HeadingSixElement;
+export type CustomElement = ParagraphElement | HeadingOneElement | HeadingTwoElement | HeadingThreeElement | HeadingFourElement | HeadingFiveElement | HeadingSixElement | BlockQuoteElement | BulletedListElement | NumberedListElement | ListItemElement | NestedBulletedListElement | NestedNumberedListElement | NestedListItemElement | ImageElement | VideoElement | LinkElement | FormulaElement | TableElement | TableHeadElement | TableBodyElement | TableRowElement | TableCellElement | CodeBlockElement | CodeLineElement;
+export type CustomText = {
+    text: string;
+    bold?: boolean;
+    italic?: boolean;
+    underline?: boolean;
+    strikethrough?: boolean;
+    code?: boolean;
+    superscript?: boolean;
+    subscript?: boolean;
+    font?: string;
+    size?: string;
+    color?: string;
+    background?: string;
+};
+export type EmptyText = {
+    text: string;
+} & CustomText;
+export type CustomEditor = BaseEditor & DOMEditor;
+declare module 'slate-vue3/core' {
+    interface CustomTypes {
+        Editor: CustomEditor;
+        Element: CustomElement;
+        Text: CustomText | EmptyText;
+        Range: BaseRange & {
+            [key: string]: unknown;
+        };
+    }
+}

package/components/editor/types.js

@@ -0,0 +1,55 @@
+const HEADING_TYPES = [
+  "heading-one",
+  "heading-two",
+  "heading-three",
+  "heading-four",
+  "heading-five",
+  "heading-six"
+];
+const HEADING_WITH_PARA_TYPES = ["paragraph", ...HEADING_TYPES];
+const NORMAL_BLOCK_TYPES = [...HEADING_WITH_PARA_TYPES, "block-quote"];
+const mapElementTypeTagName = {
+  paragraph: "p",
+  "heading-one": "h1",
+  "heading-two": "h2",
+  "heading-three": "h3",
+  "heading-four": "h4",
+  "heading-five": "h5",
+  "heading-six": "h6",
+  "block-quote": "blockquote",
+  "bulleted-list": "ul",
+  "numbered-list": "ol",
+  "list-item": "li",
+  "nested-bulleted-list": "ul",
+  "nested-numbered-list": "ol",
+  "nested-list-item": "li",
+  "code-block": "pre",
+  table: "table",
+  "table-head": "thead",
+  "table-body": "tbody",
+  "table-row": "tr",
+  "table-cell": "td",
+  formula: "math"
+};
+const tagToElementTypeMap = {
+  P: "paragraph",
+  BLOCKQUOTE: "block-quote",
+  H1: "heading-one",
+  H2: "heading-two",
+  H3: "heading-three",
+  H4: "heading-four",
+  H5: "heading-five",
+  H6: "heading-six",
+  UL: "bulleted-list",
+  OL: "numbered-list",
+  LI: "list-item",
+  PRE: "code-block",
+  TABLE: "table",
+  THEAD: "table-head",
+  TBODY: "table-body",
+  TR: "table-row",
+  TD: "table-cell",
+  TH: "table-cell"
+};
+
+export { HEADING_TYPES, HEADING_WITH_PARA_TYPES, NORMAL_BLOCK_TYPES, mapElementTypeTagName, tagToElementTypeMap };

package/components/editor/usePopoverContainer.d.ts

@@ -0,0 +1,8 @@
+import { InjectionKey } from 'vue';
+export interface PopoverContainerContext {
+    popoverWrapper: HTMLDivElement;
+}
+export declare const popoverContainerContextKey: InjectionKey<PopoverContainerContext>;
+export declare function usePopoverContainer(): {
+    mountPoint: import("vue").ShallowRef<HTMLDivElement | undefined, HTMLDivElement | undefined>;
+};

package/components/editor/usePopoverContainer.js

@@ -0,0 +1,31 @@
+import { shallowRef, onMounted, provide } from 'vue';
+
+const popoverContainerContextKey = Symbol(
+  "editorContext"
+);
+function usePopoverContainer() {
+  const popoverContainer = document.createElement("div");
+  const popoverWrapper = document.createElement("div");
+  popoverContainer.append(popoverWrapper);
+  Object.assign(popoverContainer.style, {
+    position: "absolute",
+    inset: 0,
+    overflow: "hidden",
+    pointerEvents: "none"
+  });
+  Object.assign(popoverWrapper.style, {
+    pointerEvents: "auto"
+  });
+  const mountPoint = shallowRef();
+  onMounted(() => {
+    mountPoint.value.append(popoverContainer);
+  });
+  provide(popoverContainerContextKey, {
+    popoverWrapper
+  });
+  return {
+    mountPoint
+  };
+}
+
+export { popoverContainerContextKey, usePopoverContainer };

package/components/editor/utils.d.ts

@@ -0,0 +1,77 @@
+import { Editor, Location, MaximizeMode, Node, NodeEntry, NodeMatch, Path, Point, Range } from 'slate-vue3/core';
+import { CustomElement, HeadingElement } from './types';
+export declare function isParagraph(n: unknown): n is CustomElement;
+export declare function isNormalBlock(n: unknown): boolean;
+export declare function isHeading(n: unknown): n is HeadingElement;
+export declare function isBlockElement(editor: Editor, n: unknown): n is CustomElement;
+export declare function getPointingOptions(editor: Editor, type: CustomElement['type']): {
+    at?: Location;
+    match?: NodeMatch<CustomElement>;
+    mode?: MaximizeMode;
+};
+export declare function isPointingAt(editor: Editor, type: CustomElement['type']): boolean;
+export declare function toggleBlockAttr(editor: Editor, key: string, value: string): void;
+/**
+ * 判断光标是否指向某个块元素的最后
+ * @param editor 编辑器实例对象
+ * @param type 元素类型
+ * @param callback 可选的回调，在满足条件时调用，并接收此元素和其路径
+ * @returns
+ */
+export declare function isPointAtEndOfElement(editor: Editor, type: CustomElement['type'], callback?: (match: NodeEntry) => void): boolean;
+/**
+ * 判断两范围是否相等
+ *
+ * 不像 Range.equals 需要anchor和focus的位置相同；此函数在anchor和focus相反时也能返回真。
+ *
+ *
+ */
+export declare function isRangeEqual(r1: Range, r2: Range): boolean;
+/**
+ * 判断某个 point 是否在指定块元素的首行
+ */
+export declare function isPointAtFirstLine(editor: Editor, elementPath: Path, point: Point): boolean;
+/**
+ * 判断某个 point 是否在指定块元素的尾行
+ */
+export declare function isPointAtLastLine(editor: Editor, elementPath: Path, point: Point): boolean;
+/**
+ * 接收 range，返回排序后的 range
+ */
+export declare function getSortedRange(range: Range): Range;
+export declare enum RangePosition {
+    BEFORE = 2340,
+    BEFORE_BEGIN = 2324,
+    INTERSECT_BEGIN = 2316,
+    AFTER_BEGIN = 1292,
+    CONTAIN = 780,
+    BEFORE_END = 778,
+    INTERSECT_END = 777,
+    AFTER_END = 649,
+    AFTER = 585,
+    COVER = 1290,
+    COVER_BEGIN = 2314,
+    COVER_END = 1289,
+    COVER_BOTH = 2313,
+    BEGIN = 1300,
+    END = 650
+}
+/**
+ * 获取目标相较于当前范围的位置
+ */
+export declare function getRangePosition(range: Range, target: Range): RangePosition;
+/**
+ * 获取上一个同级节点，找不到则返回 undefined
+ */
+export declare function getPreviousSibling<T extends Node>(editor: Editor, path: Path, options?: {
+    quit?: (node: Node, path: Path) => boolean;
+    match?: NodeMatch<T>;
+}): NodeEntry<T> | undefined;
+/**
+ * 获取下一个同级节点，找不到则返回 undefined
+ */
+export declare function getNextSibling<T extends Node>(editor: Editor, path: Path, options?: {
+    quit?: (node: Node, path: Path) => boolean;
+    match?: (node: Node, path: Path) => boolean;
+}): NodeEntry<T> | undefined;
+export declare function isEdgesEqual(edges: [Point, Point], another: [Point, Point]): boolean;

package/components/editor/utils.js

@@ -0,0 +1,165 @@
+import { Element, Path, Editor, Range, Point } from 'slate-vue3/core';
+import { NORMAL_BLOCK_TYPES, HEADING_TYPES } from './types.js';
+
+function isParagraph(n) {
+  return Element.isElementType(n, "paragraph");
+}
+function isNormalBlock(n) {
+  return Element.isElement(n) && NORMAL_BLOCK_TYPES.includes(n.type);
+}
+function isHeading(n) {
+  return Element.isElement(n) && HEADING_TYPES.includes(n.type);
+}
+function isBlockElement(editor, n) {
+  return Element.isElement(n) && editor.isBlock(n);
+}
+function getPointingOptions(editor, type) {
+  const selection = editor.selection;
+  return {
+    at: selection,
+    match: (n, path) => Element.isElementType(n, type) && Path.isAncestor(path, selection.anchor.path) && Path.isAncestor(path, selection.focus.path),
+    mode: "lowest"
+  };
+}
+function isPointingAt(editor, type) {
+  if (!editor.selection) return false;
+  const nodes = editor.nodes(getPointingOptions(editor, type));
+  return !nodes.next().done;
+}
+function toggleBlockAttr(editor, key, value) {
+  if (!editor.selection) return;
+  const [match] = Array.from(
+    editor.nodes({
+      at: Editor.unhangRange(editor, editor.selection),
+      match: (n) => {
+        return !Editor.isEditor(n) && Element.isElement(n) && n[key] === value;
+      }
+    })
+  );
+  const active = !!match;
+  editor.setNodes({
+    [key]: active ? void 0 : value
+  });
+}
+function isPointAtEndOfElement(editor, type, callback) {
+  const selection = editor.selection;
+  if (!selection || !Range.isCollapsed(selection)) {
+    return false;
+  }
+  const [match] = Array.from(
+    editor.nodes({
+      match: (n) => Element.isElement(n) && n.type === type
+    })
+  );
+  const result = !!(match && Point.equals(Editor.end(editor, match[1]), selection.focus));
+  if (result && callback) {
+    callback(match);
+  }
+  return result;
+}
+function isRangeEqual(r1, r2) {
+  return Point.equals(r1.anchor, r2.anchor) && Point.equals(r1.focus, r2.focus) || Point.equals(r1.anchor, r2.focus) && Point.equals(r1.focus, r2.anchor);
+}
+function isPointAtFirstLine(editor, elementPath, point) {
+  const [currentBlock] = editor.nodes({
+    at: point,
+    mode: "lowest",
+    match: (n) => isBlockElement(editor, n)
+  });
+  const previousBlock = editor.previous({
+    at: currentBlock[1],
+    match: (n, path) => isBlockElement(editor, n) && Path.isAncestor(elementPath, path)
+  });
+  return !previousBlock;
+}
+function isPointAtLastLine(editor, elementPath, point) {
+  const [currentBlock] = editor.nodes({
+    at: point,
+    mode: "lowest",
+    match: (n) => isBlockElement(editor, n)
+  });
+  const nextBlock = editor.next({
+    at: currentBlock[1],
+    match: (n, path) => isBlockElement(editor, n) && Path.isAncestor(elementPath, path)
+  });
+  return !nextBlock;
+}
+function getSortedRange(range) {
+  return Range.isBackward(range) ? {
+    anchor: range.focus,
+    focus: range.anchor
+  } : range;
+}
+function pathCompare(path, another) {
+  const min = Math.min(path.length, another.length);
+  for (let i = 0; i < min; i++) {
+    if (path[i] < another[i]) return 4;
+    if (path[i] > another[i]) return 1;
+  }
+  return 2;
+}
+function pointCompare(point, another) {
+  const result = pathCompare(point.path, another.path);
+  if (result === 2) {
+    if (point.offset < another.offset) return 4;
+    if (point.offset > another.offset) return 1;
+    return 2;
+  }
+  return result;
+}
+var RangePosition = /* @__PURE__ */ ((RangePosition2) => {
+  RangePosition2[RangePosition2["BEFORE"] = 2340] = "BEFORE";
+  RangePosition2[RangePosition2["BEFORE_BEGIN"] = 2324] = "BEFORE_BEGIN";
+  RangePosition2[RangePosition2["INTERSECT_BEGIN"] = 2316] = "INTERSECT_BEGIN";
+  RangePosition2[RangePosition2["AFTER_BEGIN"] = 1292] = "AFTER_BEGIN";
+  RangePosition2[RangePosition2["CONTAIN"] = 780] = "CONTAIN";
+  RangePosition2[RangePosition2["BEFORE_END"] = 778] = "BEFORE_END";
+  RangePosition2[RangePosition2["INTERSECT_END"] = 777] = "INTERSECT_END";
+  RangePosition2[RangePosition2["AFTER_END"] = 649] = "AFTER_END";
+  RangePosition2[RangePosition2["AFTER"] = 585] = "AFTER";
+  RangePosition2[RangePosition2["COVER"] = 1290] = "COVER";
+  RangePosition2[RangePosition2["COVER_BEGIN"] = 2314] = "COVER_BEGIN";
+  RangePosition2[RangePosition2["COVER_END"] = 1289] = "COVER_END";
+  RangePosition2[RangePosition2["COVER_BOTH"] = 2313] = "COVER_BOTH";
+  RangePosition2[RangePosition2["BEGIN"] = 1300] = "BEGIN";
+  RangePosition2[RangePosition2["END"] = 650] = "END";
+  return RangePosition2;
+})(RangePosition || {});
+function getRangePosition(range, target) {
+  const ss = pointCompare(target.anchor, range.anchor);
+  const se = pointCompare(target.anchor, range.focus);
+  const es = pointCompare(target.focus, range.anchor);
+  const ee = pointCompare(target.focus, range.focus);
+  return ss << 9 | se << 6 | es << 3 | ee;
+}
+function getPreviousSibling(editor, path, options = {}) {
+  const { match, quit } = options;
+  const [parentNode, parentPath] = editor.parent(path);
+  for (let i = path[path.length - 1] - 1; i >= 0; i--) {
+    const childNode = parentNode.children[i];
+    const childPath = [...parentPath, i];
+    if (!childNode) return;
+    if (quit && quit(childNode, childPath)) return;
+    if (!match || match(childNode, childPath)) {
+      return [childNode, childPath];
+    }
+  }
+}
+function getNextSibling(editor, path, options = {}) {
+  const { match = () => true, quit } = options;
+  const [parentNode, parentPath] = editor.parent(path);
+  for (let i = path[path.length - 1] + 1; i < parentNode.children.length; i++) {
+    const childNode = parentNode.children[i];
+    const childPath = [...parentPath, i];
+    if (!childNode) return;
+    if (quit && quit(childNode, childPath)) return;
+    if (match(childNode, childPath)) {
+      return [childNode, childPath];
+    }
+  }
+}
+function isEdgesEqual(edges, another) {
+  return Point.equals(edges[0], another[0]) && Point.equals(edges[1], another[1]);
+}
+
+export { RangePosition, getNextSibling, getPointingOptions, getPreviousSibling, getRangePosition, getSortedRange, isBlockElement, isEdgesEqual, isHeading, isNormalBlock, isParagraph, isPointAtEndOfElement, isPointAtFirstLine, isPointAtLastLine, isPointingAt, isRangeEqual, toggleBlockAttr };

package/components/field/components/checkbox-group/checkbox-group.vue.js

@@ -4,8 +4,8 @@ import { fieldCheckboxGroupOmitKeys } from './checkbox-group.js';
 import stdin_default$1 from './panel.vue.js';
 import { omit } from 'lodash-es';
 import { useProps } from '../../../../hooks/useProps.js';
-import { isNumber, isFunction } from '../../../../utils/is.js';
 import { getLabelByValue } from '../../../../utils/collection.js';
+import { isNumber, isFunction } from '../../../../utils/is.js';
 import { addNullablePlaceholder } from '../../../../utils/vue.js';
 
 var stdin_default = defineComponent((props, {

package/components/field/components/editor/editor.d.ts

@@ -0,0 +1,16 @@
+import { type FieldComponentCommonProps } from '../common';
+import type { EditorEmits, EditorProps } from '../../../editor';
+export interface FieldEditorProps extends FieldComponentCommonProps {
+    componentProps?: Partial<EditorProps> & {
+        'onUpdate:modelValue'?: (value: string) => void;
+        onChange?: (value: string) => void;
+        [key: PropertyKey]: any;
+    };
+    componentSlots?: Partial<FieldEditorSlots>;
+}
+export interface FieldEditorSlots {
+}
+export interface FieldEditorEmits extends EditorEmits {
+}
+export interface FieldEditorExpose {
+}

package/components/field/components/editor/editor.vue.d.ts

@@ -0,0 +1,4 @@
+import { type SlotsType } from 'vue';
+import { type FieldEditorProps, type FieldEditorSlots } from './editor';
+declare const _default: import("vue").DefineSetupFnComponent<FieldEditorProps, {}, SlotsType<FieldEditorSlots>, FieldEditorProps & {}, import("vue").PublicProps>;
+export default _default;

package/components/field/components/editor/editor.vue.js

@@ -0,0 +1,21 @@
+import { defineComponent, h } from 'vue';
+import { Editor as _Editor } from '../../../editor/index.js';
+import { addNullablePlaceholder } from '../../../../utils/vue.js';
+
+var stdin_default = defineComponent((props, {
+  slots
+}) => {
+  return () => {
+    if (props.readonly) {
+      return addNullablePlaceholder(props.componentProps?.modelValue);
+    }
+    return h(_Editor, props.componentProps, slots);
+  };
+}, {
+  name: "CoFieldEditor",
+  inheritAttrs: false,
+  props: ["componentProps", "componentSlots", "readonly"],
+  slots: {}
+});
+
+export { stdin_default as default };

package/components/field/components/password/password.vue.js

@@ -1,4 +1,4 @@
-import { useNamespace, ElInput, ElIcon } from 'element-plus';
+import { useNamespace, ElIcon, ElInput } from 'element-plus';
 import { defineComponent, ref, computed, h, mergeProps } from 'vue';
 import { View, Hide } from '@element-plus/icons-vue';
 import { useLocale } from '../../../../hooks/useLocale.js';

package/components/field/components/select/select.vue.js

@@ -5,8 +5,8 @@ import { omit } from 'lodash-es';
 import { useLocale } from '../../../../hooks/useLocale.js';
 import { useProps } from '../../../../hooks/useProps.js';
 import { addNullablePlaceholder } from '../../../../utils/vue.js';
-import { isFunction } from '../../../../utils/is.js';
 import { getLabelByValue } from '../../../../utils/collection.js';
+import { isFunction } from '../../../../utils/is.js';
 
 var stdin_default = defineComponent((props, {
   slots