@silver-formily/vue 0.0.1-beta.0

package/esm/types/index.d.ts

@@ -0,0 +1,64 @@
+import { Field, FieldDisplayTypes, FieldValidator, Form, FormPatternTypes, GeneralField, IFieldFactoryProps, IVoidFieldFactoryProps } from '@formily/core';
+import { ISchema, Schema, SchemaKey } from '@formily/json-schema';
+import { FormPathPattern } from '@formily/shared';
+import { Validator as FormilyValidator } from '@formily/validator';
+import { Component } from 'vue';
+export interface VueComponentOptionsWithProps {
+    props: Record<string, unknown>;
+}
+type ComponentPropsOrRecord<T extends Component> = T extends VueComponentOptionsWithProps ? T['props'] : Record<string, unknown>;
+export type VueComponentProps<T extends Component> = ComponentPropsOrRecord<T> & Record<string, unknown>;
+export interface IProviderProps {
+    form: Form;
+}
+export type IFieldProps<D extends Component = Component, C extends Component = Component> = IFieldFactoryProps<D, C>;
+export type IVoidFieldProps<D extends Component = Component, C extends Component = Component> = IVoidFieldFactoryProps<D, C>;
+export type IArrayFieldProps = IFieldProps;
+export type IObjectFieldProps = IFieldProps;
+export interface IReactiveFieldProps {
+    fieldType: 'Field' | 'ArrayField' | 'ObjectField' | 'VoidField';
+    fieldProps: IFieldProps | IVoidFieldProps;
+}
+export interface IComponentMapper<T extends Component = Component> {
+    (target: T): Component;
+}
+export type IStateMapper<Props> = {
+    [key in keyof Field]?: keyof Props | boolean;
+} | ((props: Props, field: GeneralField) => Props);
+export type SchemaVueComponents = Record<string, Component>;
+export type SchemaExpressionScope = Record<string, unknown>;
+export interface ISchemaFieldVueFactoryOptions<Components extends SchemaVueComponents = SchemaVueComponents> {
+    components?: Components;
+    scope?: SchemaExpressionScope;
+}
+export interface ISchemaFieldProps extends Omit<IRecursionFieldProps, 'name' | 'schema'> {
+    schema?: ISchema;
+    components?: {
+        [key: string]: Component;
+    };
+    scope?: SchemaExpressionScope;
+    name?: SchemaKey;
+}
+export interface ISchemaMapper {
+    (schema: Schema, name: SchemaKey): Schema;
+}
+export interface ISchemaFilter {
+    (schema: Schema, name: SchemaKey): boolean;
+}
+export interface IRecursionFieldProps {
+    schema: Schema | ISchema;
+    name?: SchemaKey;
+    basePath?: FormPathPattern;
+    onlyRenderProperties?: boolean;
+    onlyRenderSelf?: boolean;
+    mapProperties?: ISchemaMapper;
+    filterProperties?: ISchemaFilter;
+}
+export type ComponentPath<T, Key extends keyof T = keyof T> = Key extends string ? Key : never;
+export type ComponentPropsByPathValue<T extends SchemaVueComponents, P extends ComponentPath<T>> = P extends keyof T ? VueComponentProps<T[P]> : never;
+export type ISchemaMarkupFieldProps<Components extends SchemaVueComponents = SchemaVueComponents, Decorator extends ComponentPath<Components> = ComponentPath<Components>, Component extends ComponentPath<Components> = ComponentPath<Components>> = ISchema<Decorator, Component, ComponentPropsByPathValue<Components, Decorator>, ComponentPropsByPathValue<Components, Component>, FormPatternTypes, FieldDisplayTypes, FieldValidator, string, GeneralField>;
+export type ISchemaTypeFieldProps<Components extends SchemaVueComponents = SchemaVueComponents, Decorator extends ComponentPath<Components> = ComponentPath<Components>, Component extends ComponentPath<Components> = ComponentPath<Components>> = Omit<ISchemaMarkupFieldProps<Components, Decorator, Component>, 'type'>;
+export interface IExpressionScopeProps {
+    value: SchemaExpressionScope;
+}
+export type { FormilyValidator };

package/esm/types/index.mjs

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=index.mjs.map

package/esm/types/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/esm/utils/fieldProps.d.ts

@@ -0,0 +1,49 @@
+import { ExtractPropTypes } from 'vue';
+export declare const fieldProps: {
+    readonly name: import('./runtimeProps').RuntimeProp<import('@formily/core').FormPathPattern>;
+    readonly title: import('./runtimeProps').RuntimeProp<any>;
+    readonly description: import('./runtimeProps').RuntimeProp<any>;
+    readonly value: import('./runtimeProps').RuntimeProp<any>;
+    readonly initialValue: import('./runtimeProps').RuntimeProp<any>;
+    readonly basePath: import('./runtimeProps').RuntimeProp<import('@formily/core').FormPathPattern>;
+    readonly decorator: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldDecorator<import('vue').Component, any>>;
+    readonly component: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldComponent<import('vue').Component, any>>;
+    readonly display: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldDisplayTypes>;
+    readonly pattern: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldPatternTypes>;
+    readonly required: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly validateFirst: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly hidden: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly visible: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly editable: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly disabled: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly readOnly: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly readPretty: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly dataSource: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldDataSource>;
+    readonly validatePattern: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldPatternTypes[]>;
+    readonly validateDisplay: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldDisplayTypes[]>;
+    readonly validator: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldValidator>;
+    readonly reactions: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldReaction | import('@formily/core').FieldReaction[]>;
+    readonly content: import('./runtimeProps').RuntimeProp<any>;
+    readonly data: import('./runtimeProps').RuntimeProp<any>;
+};
+export declare const voidFieldProps: {
+    readonly name: import('./runtimeProps').RuntimeProp<import('@formily/core').FormPathPattern>;
+    readonly title: import('./runtimeProps').RuntimeProp<any>;
+    readonly description: import('./runtimeProps').RuntimeProp<any>;
+    readonly basePath: import('./runtimeProps').RuntimeProp<import('@formily/core').FormPathPattern>;
+    readonly decorator: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldDecorator<import('vue').Component, any>>;
+    readonly component: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldComponent<import('vue').Component, any>>;
+    readonly display: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldDisplayTypes>;
+    readonly pattern: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldPatternTypes>;
+    readonly hidden: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly visible: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly editable: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly disabled: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly readOnly: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly readPretty: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly reactions: import('./runtimeProps').RuntimeProp<import('@formily/core').FieldReaction | import('@formily/core').FieldReaction[]>;
+    readonly content: import('./runtimeProps').RuntimeProp<any>;
+    readonly data: import('./runtimeProps').RuntimeProp<any>;
+};
+export type FieldProps = ExtractPropTypes<typeof fieldProps>;
+export type VoidFieldProps = ExtractPropTypes<typeof voidFieldProps>;

package/esm/utils/fieldProps.mjs

@@ -0,0 +1,51 @@
+import { createProp as e, createBooleanProp as t } from "./runtimeProps.mjs";
+const r = {
+  name: e({ required: !0 }),
+  title: e(),
+  description: e(),
+  value: e(),
+  initialValue: e(),
+  basePath: e(),
+  decorator: e(),
+  component: e(),
+  display: e(),
+  pattern: e(),
+  required: t(),
+  validateFirst: t(),
+  hidden: t(),
+  visible: t(),
+  editable: t(),
+  disabled: t(),
+  readOnly: t(),
+  readPretty: t(),
+  dataSource: e(),
+  validatePattern: e(),
+  validateDisplay: e(),
+  validator: e(),
+  reactions: e(),
+  content: e(),
+  data: e()
+}, i = {
+  name: e({ required: !0 }),
+  title: e(),
+  description: e(),
+  basePath: e(),
+  decorator: e(),
+  component: e(),
+  display: e(),
+  pattern: e(),
+  hidden: t(),
+  visible: t(),
+  editable: t(),
+  disabled: t(),
+  readOnly: t(),
+  readPretty: t(),
+  reactions: e(),
+  content: e(),
+  data: e()
+};
+export {
+  r as fieldProps,
+  i as voidFieldProps
+};
+//# sourceMappingURL=fieldProps.mjs.map

package/esm/utils/fieldProps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fieldProps.mjs","sources":["../../src/utils/fieldProps.ts"],"sourcesContent":["import type { ComponentObjectPropsOptions, ExtractPropTypes } from 'vue'\nimport type { IFieldProps, IVoidFieldProps } from '../types'\nimport { createBooleanProp, createProp } from './runtimeProps'\n\nexport const fieldProps = {\n  name: createProp<IFieldProps['name']>({ required: true }),\n  title: createProp<IFieldProps['title']>(),\n  description: createProp<IFieldProps['description']>(),\n  value: createProp<IFieldProps['value']>(),\n  initialValue: createProp<IFieldProps['initialValue']>(),\n  basePath: createProp<IFieldProps['basePath']>(),\n  decorator: createProp<IFieldProps['decorator']>(),\n  component: createProp<IFieldProps['component']>(),\n  display: createProp<IFieldProps['display']>(),\n  pattern: createProp<IFieldProps['pattern']>(),\n  required: createBooleanProp(),\n  validateFirst: createBooleanProp(),\n  hidden: createBooleanProp(),\n  visible: createBooleanProp(),\n  editable: createBooleanProp(),\n  disabled: createBooleanProp(),\n  readOnly: createBooleanProp(),\n  readPretty: createBooleanProp(),\n  dataSource: createProp<IFieldProps['dataSource']>(),\n  validatePattern: createProp<IFieldProps['validatePattern']>(),\n  validateDisplay: createProp<IFieldProps['validateDisplay']>(),\n  validator: createProp<IFieldProps['validator']>(),\n  reactions: createProp<IFieldProps['reactions']>(),\n  content: createProp<IFieldProps['content']>(),\n  data: createProp<IFieldProps['data']>(),\n} as const satisfies ComponentObjectPropsOptions<IFieldProps>\n\nexport const voidFieldProps = {\n  name: createProp<IVoidFieldProps['name']>({ required: true }),\n  title: createProp<IVoidFieldProps['title']>(),\n  description: createProp<IVoidFieldProps['description']>(),\n  basePath: createProp<IVoidFieldProps['basePath']>(),\n  decorator: createProp<IVoidFieldProps['decorator']>(),\n  component: createProp<IVoidFieldProps['component']>(),\n  display: createProp<IVoidFieldProps['display']>(),\n  pattern: createProp<IVoidFieldProps['pattern']>(),\n  hidden: createBooleanProp(),\n  visible: createBooleanProp(),\n  editable: createBooleanProp(),\n  disabled: createBooleanProp(),\n  readOnly: createBooleanProp(),\n  readPretty: createBooleanProp(),\n  reactions: createProp<IVoidFieldProps['reactions']>(),\n  content: createProp<IVoidFieldProps['content']>(),\n  data: createProp<IVoidFieldProps['data']>(),\n} as const satisfies ComponentObjectPropsOptions<IVoidFieldProps>\n\nexport type FieldProps = ExtractPropTypes<typeof fieldProps>\nexport type VoidFieldProps = ExtractPropTypes<typeof voidFieldProps>\n"],"names":["fieldProps","createProp","createBooleanProp","voidFieldProps"],"mappings":";AAIO,MAAMA,IAAa;AAAA,EACxB,MAAMC,EAAgC,EAAE,UAAU,IAAM;AAAA,EACxD,OAAOA,EAAA;AAAA,EACP,aAAaA,EAAA;AAAA,EACb,OAAOA,EAAA;AAAA,EACP,cAAcA,EAAA;AAAA,EACd,UAAUA,EAAA;AAAA,EACV,WAAWA,EAAA;AAAA,EACX,WAAWA,EAAA;AAAA,EACX,SAASA,EAAA;AAAA,EACT,SAASA,EAAA;AAAA,EACT,UAAUC,EAAA;AAAA,EACV,eAAeA,EAAA;AAAA,EACf,QAAQA,EAAA;AAAA,EACR,SAASA,EAAA;AAAA,EACT,UAAUA,EAAA;AAAA,EACV,UAAUA,EAAA;AAAA,EACV,UAAUA,EAAA;AAAA,EACV,YAAYA,EAAA;AAAA,EACZ,YAAYD,EAAA;AAAA,EACZ,iBAAiBA,EAAA;AAAA,EACjB,iBAAiBA,EAAA;AAAA,EACjB,WAAWA,EAAA;AAAA,EACX,WAAWA,EAAA;AAAA,EACX,SAASA,EAAA;AAAA,EACT,MAAMA,EAAA;AACR,GAEaE,IAAiB;AAAA,EAC5B,MAAMF,EAAoC,EAAE,UAAU,IAAM;AAAA,EAC5D,OAAOA,EAAA;AAAA,EACP,aAAaA,EAAA;AAAA,EACb,UAAUA,EAAA;AAAA,EACV,WAAWA,EAAA;AAAA,EACX,WAAWA,EAAA;AAAA,EACX,SAASA,EAAA;AAAA,EACT,SAASA,EAAA;AAAA,EACT,QAAQC,EAAA;AAAA,EACR,SAASA,EAAA;AAAA,EACT,UAAUA,EAAA;AAAA,EACV,UAAUA,EAAA;AAAA,EACV,UAAUA,EAAA;AAAA,EACV,YAAYA,EAAA;AAAA,EACZ,WAAWD,EAAA;AAAA,EACX,SAASA,EAAA;AAAA,EACT,MAAMA,EAAA;AACR;"}

package/esm/utils/getRawComponent.d.ts

@@ -0,0 +1,8 @@
+import { Component } from 'vue';
+import { IFieldProps } from '../types';
+type ComponentLikeProps = Pick<IFieldProps<Component, Component>, 'component' | 'decorator'>;
+export declare function getRawComponent(props: ComponentLikeProps): {
+    component: import('@formily/core').FieldComponent<Component, any>;
+    decorator: import('@formily/core').FieldDecorator<Component, any>;
+};
+export {};

package/esm/utils/getRawComponent.mjs

@@ -0,0 +1,13 @@
+import { toRaw as n } from "vue";
+function i(a) {
+  const { component: o, decorator: r } = a;
+  let t, e;
+  return Array.isArray(o) && (t = [n(o[0]), o[1]]), Array.isArray(r) && (e = [n(r[0]), r[1]]), {
+    component: t ?? o,
+    decorator: e ?? r
+  };
+}
+export {
+  i as getRawComponent
+};
+//# sourceMappingURL=getRawComponent.mjs.map

package/esm/utils/getRawComponent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRawComponent.mjs","sources":["../../src/utils/getRawComponent.ts"],"sourcesContent":["import type { Component } from 'vue'\nimport type { IFieldProps } from '../types'\nimport { toRaw } from 'vue'\n\ntype ComponentLikeProps = Pick<IFieldProps<Component, Component>, 'component' | 'decorator'>\n\nexport function getRawComponent(props: ComponentLikeProps) {\n  const { component, decorator } = props\n  let newComponent: typeof component | undefined\n  let newDecorator: typeof decorator | undefined\n  if (Array.isArray(component)) {\n    newComponent = [toRaw(component[0]), component[1]]\n  }\n  if (Array.isArray(decorator)) {\n    newDecorator = [toRaw(decorator[0]), decorator[1]]\n  }\n  return {\n    component: newComponent ?? component,\n    decorator: newDecorator ?? decorator,\n  }\n}\n"],"names":["getRawComponent","props","component","decorator","newComponent","newDecorator","toRaw"],"mappings":";AAMO,SAASA,EAAgBC,GAA2B;AACzD,QAAM,EAAE,WAAAC,GAAW,WAAAC,EAAA,IAAcF;AACjC,MAAIG,GACAC;AACJ,SAAI,MAAM,QAAQH,CAAS,MACzBE,IAAe,CAACE,EAAMJ,EAAU,CAAC,CAAC,GAAGA,EAAU,CAAC,CAAC,IAE/C,MAAM,QAAQC,CAAS,MACzBE,IAAe,CAACC,EAAMH,EAAU,CAAC,CAAC,GAAGA,EAAU,CAAC,CAAC,IAE5C;AAAA,IACL,WAAWC,KAAgBF;AAAA,IAC3B,WAAWG,KAAgBF;AAAA,EAAA;AAE/B;"}

package/esm/utils/reactiveFieldHelpers.d.ts

@@ -0,0 +1,16 @@
+import { GeneralField } from '@formily/core';
+import { Component, Slots, VNode } from 'vue';
+type SlotContent = string | Component | null | undefined;
+type SlotContentMap = Record<string, SlotContent>;
+type FieldContent = SlotContent | SlotContentMap | null | undefined;
+type EventHandler = (...args: unknown[]) => unknown;
+type EventMap = Partial<Record<string, EventHandler>>;
+type Attrs = Record<string, unknown>;
+export declare function wrapFragment(childNodes?: VNode[] | VNode | null): VNode | null;
+export declare function mergeSlots(field: GeneralField, slots: Slots, content: FieldContent): Slots;
+export declare function extractAttrsAndEvents(rawAttrs?: Attrs): {
+    attrs: Attrs;
+    events: EventMap;
+};
+export declare function createVNodeProps(attrs: Attrs, events: EventMap): Attrs;
+export {};

package/esm/utils/reactiveFieldHelpers.mjs

@@ -0,0 +1,106 @@
+import { createTextVNode as y, h as p, Fragment as h } from "vue";
+const l = () => [];
+function m(t) {
+  return t ? Array.isArray(t) ? t.map((n) => String(n)) : typeof t == "object" ? Object.keys(t) : null : null;
+}
+function b(t) {
+  return !t || typeof t == "string" ? null : m(t.props);
+}
+function j(t, n) {
+  if (!t)
+    return;
+  if (!n || !n.length)
+    return t;
+  const r = {};
+  if (n.forEach((e) => {
+    e in t && (r[e] = t[e]);
+  }), !!Object.keys(r).length)
+    return r;
+}
+function g(t) {
+  if (typeof t != "object" || t === null)
+    return !1;
+  const n = t;
+  return typeof n.template == "string" || typeof n.render == "function" || typeof n.setup == "function";
+}
+function E(t) {
+  return typeof t != "object" || t === null ? !1 : !g(t);
+}
+function A(t) {
+  return t ? Array.isArray(t) ? t.length === 0 ? null : t.length === 1 ? t[0] ?? null : p(h, null, t) : t : null;
+}
+function a(t, n) {
+  if (n == null)
+    return t;
+  if (typeof n == "string")
+    return () => [...t(), y(n)];
+  const r = n, e = b(r);
+  return typeof r == "function" && r.length > 1 || g(r) && typeof r.render == "function" && r.render.length > 1 || !!(e && e.length) ? (u) => [
+    ...t(),
+    p(r, j(u, e) ?? {})
+  ] : () => [...t(), p(r)];
+}
+function P(t, n, r) {
+  const e = Object.keys(n);
+  if (!e.length) {
+    if (!r)
+      return {};
+    if (typeof r == "string")
+      return {
+        default: a(l, r)
+      };
+  }
+  const s = (o) => (...f) => {
+    const i = f[0], c = typeof i == "object" && i !== null ? i : {};
+    return n[o]?.({ field: t, form: t.form, ...c }) ?? [];
+  }, u = {};
+  return e.forEach((o) => {
+    u[o] = s(o);
+  }), E(r) ? (Object.keys(r).forEach((o) => {
+    const f = r[o], i = u[o] ?? l;
+    u[o] = a(i, f);
+  }), u) : (u.default = a(u.default ?? l, r), u);
+}
+function d(t) {
+  if (t.length <= 2)
+    return "";
+  const n = t.slice(2);
+  return n.charAt(0).toLowerCase() + n.slice(1);
+}
+function O(t) {
+  return t ? `on${t.charAt(0).toUpperCase()}${t.slice(1)}` : "";
+}
+function C(t = {}) {
+  const n = { ...t }, r = {};
+  return Object.keys(t).forEach((e) => {
+    const s = t[e], u = e.startsWith("on"), o = e.startsWith("@");
+    if (!u && !o)
+      return;
+    if (o) {
+      const i = e.slice(1);
+      delete n[e], typeof s == "function" && (r[i] = s);
+      return;
+    }
+    const f = d(e);
+    f && (!r[f] && typeof s == "function" && (r[f] = s), delete n[e]);
+  }), { attrs: n, events: r };
+}
+function k(t, n) {
+  const { style: r, class: e, ...s } = t, u = Object.keys(n).reduce((o, f) => {
+    const i = O(f), c = n[f];
+    return i && c && (o[i] = c), o;
+  }, {});
+  return {
+    ...s,
+    style: r,
+    class: e,
+    ...u
+  };
+}
+export {
+  k as createVNodeProps,
+  C as extractAttrsAndEvents,
+  P as mergeSlots,
+  A as wrapFragment
+};
+//# sourceMappingURL=reactiveFieldHelpers.mjs.map

package/esm/utils/reactiveFieldHelpers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactiveFieldHelpers.mjs","sources":["../../src/utils/reactiveFieldHelpers.ts"],"sourcesContent":["import type { GeneralField } from '@formily/core'\nimport type { Component, Slot, Slots, VNode } from 'vue'\nimport { createTextVNode, Fragment, h } from 'vue'\n\ninterface VueLikeOptions {\n  template?: string\n  render?: (...args: unknown[]) => unknown\n  setup?: (...args: unknown[]) => unknown\n}\n\ntype SlotContent = string | Component | null | undefined\ntype SlotContentMap = Record<string, SlotContent>\ntype FieldContent = SlotContent | SlotContentMap | null | undefined\n\ntype EventHandler = (...args: unknown[]) => unknown\ntype EventMap = Partial<Record<string, EventHandler>>\ntype Attrs = Record<string, unknown>\n\nconst EMPTY_SLOT: Slot = () => []\n\ntype ComponentWithProps = Component & { props?: unknown }\n\nfunction normalizePropKeys(propsDef: unknown): string[] | null {\n  if (!propsDef)\n    return null\n  if (Array.isArray(propsDef))\n    return propsDef.map(key => String(key))\n  if (typeof propsDef === 'object')\n    return Object.keys(propsDef as Record<string, unknown>)\n  return null\n}\n\nfunction extractComponentPropKeys(component: SlotContent): string[] | null {\n  if (!component || typeof component === 'string')\n    return null\n  const target = component as ComponentWithProps\n  return normalizePropKeys(target.props)\n}\n\nfunction pickScopedProps(\n  scopedProps: Record<string, unknown> | undefined,\n  propKeys: string[] | null | undefined,\n) {\n  if (!scopedProps)\n    return undefined\n  if (!propKeys || !propKeys.length)\n    return scopedProps\n  const picked: Record<string, unknown> = {}\n  propKeys.forEach((key) => {\n    if (key in scopedProps)\n      picked[key] = scopedProps[key]\n  })\n  if (!Object.keys(picked).length)\n    return undefined\n  return picked\n}\n\nfunction isVueOptions(options: unknown): options is VueLikeOptions {\n  if (typeof options !== 'object' || options === null) {\n    return false\n  }\n  const candidates = options as Record<string, unknown>\n  return (\n    typeof candidates.template === 'string'\n    || typeof candidates.render === 'function'\n    || typeof candidates.setup === 'function'\n  )\n}\n\nfunction isSlotContentMap(content: unknown): content is SlotContentMap {\n  if (typeof content !== 'object' || content === null) {\n    return false\n  }\n  return !isVueOptions(content)\n}\n\nexport function wrapFragment(childNodes?: VNode[] | VNode | null): VNode | null {\n  if (!childNodes) {\n    return null\n  }\n  if (!Array.isArray(childNodes)) {\n    return childNodes\n  }\n  if (childNodes.length === 0) {\n    return null\n  }\n  if (childNodes.length === 1) {\n    return childNodes[0] ?? null\n  }\n  return h(Fragment, null, childNodes)\n}\n\nfunction resolveComponent(render: Slot, extra?: SlotContent): Slot {\n  if (extra === undefined || extra === null) {\n    return render\n  }\n  if (typeof extra === 'string') {\n    return () => [...render(), createTextVNode(extra)]\n  }\n\n  const component = extra\n  const propKeys = extractComponentPropKeys(component)\n  const needsScopedProps\n    = (typeof component === 'function' && component.length > 1)\n      || (isVueOptions(component)\n        && typeof component.render === 'function'\n        && component.render.length > 1)\n      || !!(propKeys && propKeys.length)\n\n  if (needsScopedProps) {\n    return (scopedProps?: Record<string, unknown>) => [\n      ...render(),\n      h(component, pickScopedProps(scopedProps, propKeys) ?? {}),\n    ]\n  }\n\n  return () => [...render(), h(component)]\n}\n\nexport function mergeSlots(field: GeneralField, slots: Slots, content: FieldContent): Slots {\n  const slotNames = Object.keys(slots)\n  if (!slotNames.length) {\n    if (!content) {\n      return {}\n    }\n    if (typeof content === 'string') {\n      return {\n        default: resolveComponent(EMPTY_SLOT, content),\n      }\n    }\n  }\n  const patchSlot\n    = (slotName: string): Slot =>\n      (...originArgs: Parameters<Slot>) => {\n        const firstArg = originArgs[0]\n        const scopedProps\n          = typeof firstArg === 'object' && firstArg !== null\n            ? (firstArg as Record<string, unknown>)\n            : {}\n        return slots[slotName]?.({ field, form: field.form, ...scopedProps }) ?? []\n      }\n\n  const patchedSlots: Record<string, Slot> = {}\n  slotNames.forEach((name) => {\n    patchedSlots[name] = patchSlot(name)\n  })\n\n  if (isSlotContentMap(content)) {\n    Object.keys(content).forEach((key) => {\n      const child = content[key]\n      const slot = patchedSlots[key] ?? EMPTY_SLOT\n      patchedSlots[key] = resolveComponent(slot, child)\n    })\n    return patchedSlots\n  }\n  patchedSlots.default = resolveComponent(patchedSlots.default ?? EMPTY_SLOT, content)\n  return patchedSlots\n}\n\nfunction normalizeOnEventName(eventKey: string) {\n  if (eventKey.length <= 2)\n    return ''\n  const rawName = eventKey.slice(2)\n  return rawName.charAt(0).toLowerCase() + rawName.slice(1)\n}\n\nfunction toEventPropKey(eventName: string) {\n  if (!eventName)\n    return ''\n  return `on${eventName.charAt(0).toUpperCase()}${eventName.slice(1)}`\n}\n\nexport function extractAttrsAndEvents(rawAttrs: Attrs = {}): { attrs: Attrs, events: EventMap } {\n  const normalizedAttrs: Attrs = { ...rawAttrs }\n  const events: EventMap = {}\n\n  Object.keys(rawAttrs).forEach((eventKey) => {\n    const value = rawAttrs[eventKey]\n    const onEvent = eventKey.startsWith('on')\n    const atEvent = eventKey.startsWith('@')\n    if (!onEvent && !atEvent)\n      return\n    if (atEvent) {\n      const eventName = eventKey.slice(1)\n      delete normalizedAttrs[eventKey]\n      if (typeof value === 'function') {\n        events[eventName] = value as EventHandler\n      }\n      return\n    }\n    const eventName = normalizeOnEventName(eventKey)\n    if (!eventName)\n      return\n    if (!events[eventName] && typeof value === 'function') {\n      events[eventName] = value as EventHandler\n    }\n    delete normalizedAttrs[eventKey]\n  })\n\n  return { attrs: normalizedAttrs, events }\n}\n\nexport function createVNodeProps(attrs: Attrs, events: EventMap): Attrs {\n  const { style, class: className, ...rest } = attrs\n  const eventProps = Object.keys(events).reduce<Record<string, EventHandler>>((acc, eventName) => {\n    const propKey = toEventPropKey(eventName)\n    const handler = events[eventName]\n    if (propKey && handler) {\n      acc[propKey] = handler\n    }\n    return acc\n  }, {})\n\n  return {\n    ...rest,\n    style,\n    class: className,\n    ...eventProps,\n  }\n}\n"],"names":["EMPTY_SLOT","normalizePropKeys","propsDef","key","extractComponentPropKeys","component","pickScopedProps","scopedProps","propKeys","picked","isVueOptions","options","candidates","isSlotContentMap","content","wrapFragment","childNodes","h","Fragment","resolveComponent","render","extra","createTextVNode","mergeSlots","field","slots","slotNames","patchSlot","slotName","originArgs","firstArg","patchedSlots","name","child","slot","normalizeOnEventName","eventKey","rawName","toEventPropKey","eventName","extractAttrsAndEvents","rawAttrs","normalizedAttrs","events","value","onEvent","atEvent","createVNodeProps","attrs","style","className","rest","eventProps","acc","propKey","handler"],"mappings":"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"}

package/esm/utils/recursionFieldProps.d.ts

@@ -0,0 +1,67 @@
+import { ExtractPropTypes } from 'vue';
+export declare const recursionFieldProps: {
+    readonly schema: import('./runtimeProps').RuntimeProp<import('@formily/json-schema').Stringify<{
+        [key: symbol]: any;
+        [key: `x-${string}`]: any;
+        [key: `x-${number}`]: any;
+        version?: string;
+        name?: import('@formily/json-schema').SchemaKey;
+        title?: any;
+        description?: any;
+        default?: any;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        type?: import('@formily/json-schema').SchemaTypes;
+        enum?: import('@formily/json-schema').SchemaEnum<any>;
+        const?: any;
+        multipleOf?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string | RegExp;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string[] | boolean | string;
+        format?: string;
+        $ref?: string;
+        $namespace?: string;
+        definitions?: import('@formily/json-schema').SchemaProperties<any, any, any, any, any, any, any, any>;
+        properties?: import('@formily/json-schema').SchemaProperties<any, any, any, any, any, any, any, any>;
+        items?: import('@formily/json-schema').SchemaItems<any, any, any, any, any, any, any, any>;
+        additionalItems?: import('@formily/json-schema').Stringify</*elided*/ any>;
+        patternProperties?: import('@formily/json-schema').SchemaProperties<any, any, any, any, any, any, any, any>;
+        additionalProperties?: import('@formily/json-schema').Stringify</*elided*/ any>;
+        "x-value"?: any;
+        "x-index"?: number;
+        "x-pattern"?: any;
+        "x-display"?: any;
+        "x-validator"?: any;
+        "x-decorator"?: any;
+        "x-decorator-props"?: any;
+        "x-component"?: any;
+        "x-component-props"?: any;
+        "x-reactions"?: import('@formily/json-schema').SchemaReactions<any>;
+        "x-content"?: any;
+        "x-data"?: any;
+        "x-visible"?: boolean;
+        "x-hidden"?: boolean;
+        "x-disabled"?: boolean;
+        "x-editable"?: boolean;
+        "x-read-only"?: boolean;
+        "x-read-pretty"?: boolean;
+        "x-compile-omitted"?: string[];
+    }> | import('@formily/json-schema').Schema<any, any, any, any, any, any, any, any, any>>;
+    readonly name: import('./runtimeProps').RuntimeProp<import('@formily/json-schema').SchemaKey>;
+    readonly basePath: import('./runtimeProps').RuntimeProp<import('@formily/shared').FormPathPattern>;
+    readonly onlyRenderProperties: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly onlyRenderSelf: import('./runtimeProps').RuntimeProp<boolean>;
+    readonly mapProperties: import('./runtimeProps').RuntimeProp<import('..').ISchemaMapper>;
+    readonly filterProperties: import('./runtimeProps').RuntimeProp<import('..').ISchemaFilter>;
+};
+export type RecursionFieldProps = ExtractPropTypes<typeof recursionFieldProps>;

package/esm/utils/recursionFieldProps.mjs

@@ -0,0 +1,14 @@
+import { createProp as e, createBooleanProp as r } from "./runtimeProps.mjs";
+const t = {
+  schema: e({ required: !0 }),
+  name: e(),
+  basePath: e(),
+  onlyRenderProperties: r(),
+  onlyRenderSelf: r(),
+  mapProperties: e(),
+  filterProperties: e()
+};
+export {
+  t as recursionFieldProps
+};
+//# sourceMappingURL=recursionFieldProps.mjs.map

package/esm/utils/recursionFieldProps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"recursionFieldProps.mjs","sources":["../../src/utils/recursionFieldProps.ts"],"sourcesContent":["import type { ComponentObjectPropsOptions, ExtractPropTypes } from 'vue'\nimport type { IRecursionFieldProps } from '../types'\nimport { createBooleanProp, createProp } from './runtimeProps'\n\nexport const recursionFieldProps = {\n  schema: createProp<IRecursionFieldProps['schema']>({ required: true }),\n  name: createProp<IRecursionFieldProps['name']>(),\n  basePath: createProp<IRecursionFieldProps['basePath']>(),\n  onlyRenderProperties: createBooleanProp(),\n  onlyRenderSelf: createBooleanProp(),\n  mapProperties: createProp<IRecursionFieldProps['mapProperties']>(),\n  filterProperties: createProp<IRecursionFieldProps['filterProperties']>(),\n} as const satisfies ComponentObjectPropsOptions<IRecursionFieldProps>\n\nexport type RecursionFieldProps = ExtractPropTypes<typeof recursionFieldProps>\n"],"names":["recursionFieldProps","createProp","createBooleanProp"],"mappings":";AAIO,MAAMA,IAAsB;AAAA,EACjC,QAAQC,EAA2C,EAAE,UAAU,IAAM;AAAA,EACrE,MAAMA,EAAA;AAAA,EACN,UAAUA,EAAA;AAAA,EACV,sBAAsBC,EAAA;AAAA,EACtB,gBAAgBA,EAAA;AAAA,EAChB,eAAeD,EAAA;AAAA,EACf,kBAAkBA,EAAA;AACpB;"}

package/esm/utils/resolveSchemaProps.d.ts

@@ -0,0 +1 @@
+export declare function resolveSchemaProps(props: Record<string, unknown>): Record<string, unknown>;

package/esm/utils/resolveSchemaProps.mjs

@@ -0,0 +1,11 @@
+import { paramCase as o } from "@formily/shared";
+function s(r) {
+  const n = {};
+  return Object.keys(r).forEach((e) => {
+    e.indexOf("x") === 0 && !e.includes("x-") ? n[o(e)] = r[e] : n[e] = r[e];
+  }), n;
+}
+export {
+  s as resolveSchemaProps
+};
+//# sourceMappingURL=resolveSchemaProps.mjs.map

package/esm/utils/resolveSchemaProps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolveSchemaProps.mjs","sources":["../../src/utils/resolveSchemaProps.ts"],"sourcesContent":["import { paramCase } from '@formily/shared'\n\nexport function resolveSchemaProps(props: Record<string, unknown>) {\n  const newProps = {} as Record<string, unknown>\n  Object.keys(props).forEach((key) => {\n    if (key.indexOf('x') === 0 && !key.includes('x-')) {\n      newProps[paramCase(key)] = props[key]\n    }\n    else {\n      newProps[key] = props[key]\n    }\n  })\n  return newProps\n}\n"],"names":["resolveSchemaProps","props","newProps","key","paramCase"],"mappings":";AAEO,SAASA,EAAmBC,GAAgC;AACjE,QAAMC,IAAW,CAAA;AACjB,gBAAO,KAAKD,CAAK,EAAE,QAAQ,CAACE,MAAQ;AAClC,IAAIA,EAAI,QAAQ,GAAG,MAAM,KAAK,CAACA,EAAI,SAAS,IAAI,IAC9CD,EAASE,EAAUD,CAAG,CAAC,IAAIF,EAAME,CAAG,IAGpCD,EAASC,CAAG,IAAIF,EAAME,CAAG;AAAA,EAE7B,CAAC,GACMD;AACT;"}

package/esm/utils/runtimeProps.d.ts

@@ -0,0 +1,8 @@
+import { PropType } from 'vue';
+export interface RuntimeProp<T> {
+    type: PropType<T> | null;
+    required?: boolean;
+    default?: T | (() => T);
+}
+export declare function createProp<T>(options?: Partial<RuntimeProp<T>>): RuntimeProp<T>;
+export declare function createBooleanProp(): RuntimeProp<boolean>;

package/esm/utils/runtimeProps.mjs

@@ -0,0 +1,17 @@
+function t(e = {}) {
+  return {
+    type: e.type ?? null,
+    ...e
+  };
+}
+function r() {
+  return t({
+    type: Boolean,
+    default: void 0
+  });
+}
+export {
+  r as createBooleanProp,
+  t as createProp
+};
+//# sourceMappingURL=runtimeProps.mjs.map

package/esm/utils/runtimeProps.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeProps.mjs","sources":["../../src/utils/runtimeProps.ts"],"sourcesContent":["import type { PropType } from 'vue'\n\nexport interface RuntimeProp<T> {\n  type: PropType<T> | null\n  required?: boolean\n  default?: T | (() => T)\n}\n\nexport function createProp<T>(options: Partial<RuntimeProp<T>> = {}): RuntimeProp<T> {\n  return {\n    type: options.type ?? (null as unknown as PropType<T>),\n    ...options,\n  }\n}\n\nexport function createBooleanProp() {\n  return createProp<boolean>({\n    type: Boolean as PropType<boolean>,\n    default: undefined,\n  })\n}\n"],"names":["createProp","options","createBooleanProp"],"mappings":"AAQO,SAASA,EAAcC,IAAmC,IAAoB;AACnF,SAAO;AAAA,IACL,MAAMA,EAAQ,QAAS;AAAA,IACvB,GAAGA;AAAA,EAAA;AAEP;AAEO,SAASC,IAAoB;AAClC,SAAOF,EAAoB;AAAA,IACzB,MAAM;AAAA,IACN,SAAS;AAAA,EAAA,CACV;AACH;"}