@silver-formily/vue 0.0.1-beta.0

package/esm/components/SchemaField.mjs

@@ -0,0 +1,106 @@
+import { Schema as F } from "@formily/json-schema";
+import { lazyMerge as R } from "@formily/shared";
+import { defineComponent as d, computed as u, provide as c, h as i, Fragment as f, inject as g, shallowRef as j, watch as I } from "vue";
+import "./ArrayField.mjs";
+import "./ExpressionScope.mjs";
+import "./Field.mjs";
+import "./FormConsumer.mjs";
+import "./FormProvider.mjs";
+import "./ObjectField.mjs";
+import M from "./RecursionField.mjs";
+import "./VoidField.mjs";
+import "@formily/core";
+import "@formily/reactive-vue";
+import { SchemaMarkupSymbol as h, SchemaOptionsSymbol as N, SchemaExpressionScopeSymbol as k } from "../shared/context.mjs";
+import { resolveSchemaProps as p } from "../utils/resolveSchemaProps.mjs";
+import { schemaFieldProps as D, markupSchemaProps as y } from "../utils/schemaFieldProps.mjs";
+const v = {
+  nonameId: 0
+};
+function P() {
+  return `NO_NAME_FIELD_$${v.nonameId++}`;
+}
+function K(l = {}) {
+  const b = d({
+    name: "SchemaField",
+    inheritAttrs: !1,
+    props: D,
+    setup(a, { slots: n }) {
+      const e = u(
+        () => F.isSchemaInstance(a.schema) ? a.schema : new F({
+          type: "object",
+          ...a.schema
+        })
+      ), o = u(
+        () => R({}, l.scope ?? {}, a.scope ?? {})
+      ), s = u(() => ({
+        ...l,
+        components: {
+          ...l.components,
+          ...a.components
+        }
+      }));
+      return c(h, e), c(N, s), c(k, o), () => {
+        v.nonameId = 0;
+        const r = n.default?.(), m = Array.isArray(r) ? r : r ? [r] : [], A = i(M, {
+          ...a,
+          schema: e.value
+        });
+        return i(f, null, [...m, A]);
+      };
+    }
+  }), S = d({
+    name: "MarkupField",
+    props: {
+      type: String,
+      ...y
+    },
+    setup(a, { slots: n }) {
+      const e = g(h, null);
+      if (!e || !e.value)
+        return () => null;
+      const o = a.name || P(), s = (m) => e.value.items ? e.value.addProperty(o, m) : e.value.setItems(p(a)), r = j();
+      return I(
+        e,
+        () => {
+          if (e.value.type === "object" || e.value.type === "void")
+            r.value = e.value.addProperty(o, p(a));
+          else if (e.value.type === "array") {
+            const m = s(p(a));
+            r.value = Array.isArray(m) ? m[0] : m;
+          }
+        },
+        { immediate: !0 }
+      ), c(h, r), () => i(f, null, n.default?.());
+    }
+  }), t = (a, n) => d({
+    name: n,
+    props: { ...y },
+    setup(e, { slots: o }) {
+      return () => i(
+        S,
+        {
+          ...e,
+          type: a
+        },
+        o
+      );
+    }
+  });
+  return {
+    SchemaField: b,
+    SchemaMarkupField: S,
+    SchemaStringField: t("string", "SchemaStringField"),
+    SchemaObjectField: t("object", "SchemaObjectField"),
+    SchemaArrayField: t("array", "SchemaArrayField"),
+    SchemaBooleanField: t("boolean", "SchemaBooleanField"),
+    SchemaDateField: t("date", "SchemaDateField"),
+    SchemaDateTimeField: t("datetime", "SchemaDatetimeField"),
+    SchemaVoidField: t("void", "SchemaVoidField"),
+    SchemaNumberField: t("number", "SchemaNumberField")
+  };
+}
+export {
+  K as createSchemaField
+};
+//# sourceMappingURL=SchemaField.mjs.map

package/esm/components/SchemaField.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SchemaField.mjs","sources":["../../src/components/SchemaField.ts"],"sourcesContent":["import type { ISchema, SchemaTypes } from '@formily/json-schema'\nimport type {\n  ISchemaFieldProps,\n  ISchemaFieldVueFactoryOptions,\n  SchemaExpressionScope,\n  SchemaVueComponents,\n  // ISchemaMarkupFieldProps,\n  // ISchemaTypeFieldProps,\n} from '../types'\nimport type { MarkupSchemaProps } from '../utils/schemaFieldProps'\nimport { Schema } from '@formily/json-schema'\nimport { lazyMerge } from '@formily/shared'\nimport { computed, defineComponent, Fragment, h, inject, provide, shallowRef, watch } from 'vue'\nimport { RecursionField } from '../components'\nimport { SchemaExpressionScopeSymbol, SchemaMarkupSymbol, SchemaOptionsSymbol } from '../shared'\nimport { resolveSchemaProps } from '../utils/resolveSchemaProps'\nimport {\n  markupSchemaProps,\n\n  schemaFieldProps,\n} from '../utils/schemaFieldProps'\n\nconst env = {\n  nonameId: 0,\n}\n\nfunction getRandomName() {\n  return `NO_NAME_FIELD_$${env.nonameId++}`\n}\n\nexport function createSchemaField<Components extends SchemaVueComponents = SchemaVueComponents>(\n  options: ISchemaFieldVueFactoryOptions<Components> = {},\n) {\n  const SchemaField = defineComponent({\n    name: 'SchemaField',\n    inheritAttrs: false,\n    props: schemaFieldProps,\n    setup(props: ISchemaFieldProps, { slots }) {\n      const schemaRef = computed(() =>\n        Schema.isSchemaInstance(props.schema)\n          ? props.schema\n          : new Schema({\n            type: 'object',\n            ...props.schema,\n          }),\n      )\n\n      const scopeRef = computed<SchemaExpressionScope>(() =>\n        lazyMerge({} as SchemaExpressionScope, options.scope ?? {}, props.scope ?? {}),\n      )\n\n      const optionsRef = computed(() => ({\n        ...options,\n        components: {\n          ...options.components,\n          ...props.components,\n        },\n      }))\n\n      provide(SchemaMarkupSymbol, schemaRef)\n      provide(SchemaOptionsSymbol, optionsRef)\n      provide(SchemaExpressionScopeSymbol, scopeRef)\n\n      return () => {\n        env.nonameId = 0\n\n        const slotContent = slots.default?.()\n        const normalizedSlots = Array.isArray(slotContent)\n          ? slotContent\n          : slotContent\n            ? [slotContent]\n            : []\n\n        const recursionNode = h(RecursionField, {\n          ...props,\n          schema: schemaRef.value,\n        })\n\n        return h(Fragment, null, [...normalizedSlots, recursionNode])\n      }\n    },\n  })\n\n  const MarkupField = defineComponent({\n    name: 'MarkupField',\n    props: {\n      type: String,\n      ...markupSchemaProps,\n    },\n    setup(props: MarkupSchemaProps, { slots }) {\n      const parentRef = inject(SchemaMarkupSymbol, null)\n      if (!parentRef || !parentRef.value)\n        return () => null\n\n      const name = props.name || getRandomName()\n      const appendArraySchema = (schema: ISchema) => {\n        if (parentRef.value.items) {\n          return parentRef.value.addProperty(name, schema)\n        }\n        else {\n          return parentRef.value.setItems(resolveSchemaProps(props))\n        }\n      }\n\n      const schemaRef = shallowRef()\n\n      watch(\n        parentRef,\n        () => {\n          if (parentRef.value.type === 'object' || parentRef.value.type === 'void') {\n            schemaRef.value = parentRef.value.addProperty(name, resolveSchemaProps(props))\n          }\n          else if (parentRef.value.type === 'array') {\n            const schema = appendArraySchema(resolveSchemaProps(props))\n            schemaRef.value = Array.isArray(schema) ? schema[0] : schema\n          }\n        },\n        { immediate: true },\n      )\n      provide(SchemaMarkupSymbol, schemaRef)\n\n      return () => h(Fragment, null, slots.default?.())\n    },\n  })\n\n  const SchemaFieldFactory = (type: SchemaTypes, name: string) => {\n    return defineComponent({\n      name,\n      props: { ...markupSchemaProps },\n      setup(props, { slots }) {\n        return () =>\n          h(\n            MarkupField,\n            {\n              ...props,\n              type,\n            },\n            slots,\n          )\n      },\n    })\n  }\n\n  return {\n    SchemaField,\n    SchemaMarkupField: MarkupField,\n    SchemaStringField: SchemaFieldFactory('string', 'SchemaStringField'),\n    SchemaObjectField: SchemaFieldFactory('object', 'SchemaObjectField'),\n    SchemaArrayField: SchemaFieldFactory('array', 'SchemaArrayField'),\n    SchemaBooleanField: SchemaFieldFactory('boolean', 'SchemaBooleanField'),\n    SchemaDateField: SchemaFieldFactory('date', 'SchemaDateField'),\n    SchemaDateTimeField: SchemaFieldFactory('datetime', 'SchemaDatetimeField'),\n    SchemaVoidField: SchemaFieldFactory('void', 'SchemaVoidField'),\n    SchemaNumberField: SchemaFieldFactory('number', 'SchemaNumberField'),\n  }\n}\n"],"names":["env","getRandomName","createSchemaField","options","SchemaField","defineComponent","schemaFieldProps","props","slots","schemaRef","computed","Schema","scopeRef","lazyMerge","optionsRef","provide","SchemaMarkupSymbol","SchemaOptionsSymbol","SchemaExpressionScopeSymbol","slotContent","normalizedSlots","recursionNode","h","RecursionField","Fragment","MarkupField","markupSchemaProps","parentRef","inject","name","appendArraySchema","schema","resolveSchemaProps","shallowRef","watch","SchemaFieldFactory","type"],"mappings":"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"}

package/esm/components/VoidField.d.ts

@@ -0,0 +1,40 @@
+declare const _default: import('vue').DefineComponent<{
+    name: import('@formily/core').FormPathPattern;
+    basePath?: import('@formily/core').FormPathPattern;
+    title?: any;
+    description?: any;
+    display?: string;
+    pattern?: string;
+    hidden?: boolean;
+    visible?: boolean;
+    editable?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    readPretty?: boolean;
+    decorator?: import('@formily/core').FieldDecorator<import('vue').Component, any>;
+    component?: import('@formily/core').FieldComponent<import('vue').Component, any>;
+    reactions?: import('@formily/core').FieldReaction[] | import('@formily/core').FieldReaction;
+    content?: any;
+    data?: any;
+}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{
+    name: import('@formily/core').FormPathPattern;
+    basePath?: import('@formily/core').FormPathPattern;
+    title?: any;
+    description?: any;
+    display?: string;
+    pattern?: string;
+    hidden?: boolean;
+    visible?: boolean;
+    editable?: boolean;
+    disabled?: boolean;
+    readOnly?: boolean;
+    readPretty?: boolean;
+    decorator?: import('@formily/core').FieldDecorator<import('vue').Component, any>;
+    component?: import('@formily/core').FieldComponent<import('vue').Component, any>;
+    reactions?: import('@formily/core').FieldReaction[] | import('@formily/core').FieldReaction;
+    content?: any;
+    data?: any;
+}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/esm/components/VoidField.mjs

@@ -0,0 +1,24 @@
+import { defineComponent as t, h as r } from "vue";
+import { voidFieldProps as d } from "../utils/fieldProps.mjs";
+import { getRawComponent as m } from "../utils/getRawComponent.mjs";
+import n from "./ReactiveField.mjs";
+const s = t({
+  name: "VoidField",
+  props: d,
+  setup(o, { slots: e }) {
+    return () => {
+      const i = {
+        fieldType: "VoidField",
+        fieldProps: {
+          ...o,
+          ...m(o)
+        }
+      };
+      return r(n, i, e);
+    };
+  }
+});
+export {
+  s as default
+};
+//# sourceMappingURL=VoidField.mjs.map

package/esm/components/VoidField.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"VoidField.mjs","sources":["../../src/components/VoidField.ts"],"sourcesContent":["import type { IReactiveFieldProps, IVoidFieldProps } from '../types'\nimport { defineComponent, h } from 'vue'\nimport { voidFieldProps } from '../utils/fieldProps'\nimport { getRawComponent } from '../utils/getRawComponent'\nimport ReactiveField from './ReactiveField'\n\nexport default defineComponent({\n  name: 'VoidField',\n  props: voidFieldProps,\n  setup(props: IVoidFieldProps, { slots }) {\n    return () => {\n      const componentData: IReactiveFieldProps = {\n        fieldType: 'VoidField',\n        fieldProps: {\n          ...props,\n          ...getRawComponent(props),\n        },\n      }\n      return h(ReactiveField, componentData, slots)\n    }\n  },\n})\n"],"names":["VoidField","defineComponent","voidFieldProps","props","slots","componentData","getRawComponent","h","ReactiveField"],"mappings":";;;;AAMA,MAAAA,IAAeC,EAAgB;AAAA,EAC7B,MAAM;AAAA,EACN,OAAOC;AAAA,EACP,MAAMC,GAAwB,EAAE,OAAAC,KAAS;AACvC,WAAO,MAAM;AACX,YAAMC,IAAqC;AAAA,QACzC,WAAW;AAAA,QACX,YAAY;AAAA,UACV,GAAGF;AAAA,UACH,GAAGG,EAAgBH,CAAK;AAAA,QAAA;AAAA,MAC1B;AAEF,aAAOI,EAAEC,GAAeH,GAAeD,CAAK;AAAA,IAC9C;AAAA,EACF;AACF,CAAC;"}

package/esm/components/index.d.ts

@@ -0,0 +1,9 @@
+export { default as ArrayField } from './ArrayField';
+export { default as ExpressionScope } from './ExpressionScope';
+export { default as Field } from './Field';
+export { default as FormConsumer } from './FormConsumer';
+export { default as FormProvider } from './FormProvider';
+export { default as ObjectField } from './ObjectField';
+export { default as RecursionField } from './RecursionField';
+export { createSchemaField } from './SchemaField';
+export { default as VoidField } from './VoidField';

package/esm/components/index.mjs

@@ -0,0 +1,21 @@
+import { default as o } from "./ArrayField.mjs";
+import { default as t } from "./ExpressionScope.mjs";
+import { default as d } from "./Field.mjs";
+import { default as m } from "./FormConsumer.mjs";
+import { default as p } from "./FormProvider.mjs";
+import { default as u } from "./ObjectField.mjs";
+import { default as F } from "./RecursionField.mjs";
+import { createSchemaField as n } from "./SchemaField.mjs";
+import { default as b } from "./VoidField.mjs";
+export {
+  o as ArrayField,
+  t as ExpressionScope,
+  d as Field,
+  m as FormConsumer,
+  p as FormProvider,
+  u as ObjectField,
+  F as RecursionField,
+  b as VoidField,
+  n as createSchemaField
+};
+//# sourceMappingURL=index.mjs.map

package/esm/components/index.mjs.map

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

package/esm/global.d.mjs

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

package/esm/global.d.mjs.map

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

package/esm/hooks/index.d.ts

@@ -0,0 +1,5 @@
+export * from './useField';
+export * from './useFieldSchema';
+export * from './useForm';
+export * from './useFormEffects';
+export * from './useParentForm';

package/esm/hooks/index.mjs

@@ -0,0 +1,13 @@
+import { useField as o } from "./useField.mjs";
+import { useFieldSchema as f } from "./useFieldSchema.mjs";
+import { useForm as s } from "./useForm.mjs";
+import { useFormEffects as u } from "./useFormEffects.mjs";
+import { useParentForm as F } from "./useParentForm.mjs";
+export {
+  o as useField,
+  f as useFieldSchema,
+  s as useForm,
+  u as useFormEffects,
+  F as useParentForm
+};
+//# sourceMappingURL=index.mjs.map

package/esm/hooks/index.mjs.map

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

package/esm/hooks/useAttach.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+interface IRecycleTarget {
+    onMount: () => void;
+    onUnmount: () => void;
+}
+export declare function useAttach<T extends IRecycleTarget>(target: Ref<T>): Ref<T>;
+export {};

package/esm/hooks/useAttach.mjs

@@ -0,0 +1,14 @@
+import { watch as m, nextTick as e, onMounted as c, onUnmounted as i } from "vue";
+function f(n) {
+  return m(n, (o, u, t) => {
+    o && o !== u && (u?.onUnmount(), e(() => o.onMount()), t(() => o.onUnmount()));
+  }), c(() => {
+    n.value?.onMount();
+  }), i(() => {
+    n.value?.onUnmount();
+  }), n;
+}
+export {
+  f as useAttach
+};
+//# sourceMappingURL=useAttach.mjs.map

package/esm/hooks/useAttach.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAttach.mjs","sources":["../../src/hooks/useAttach.ts"],"sourcesContent":["import type { Ref } from 'vue'\nimport { nextTick, onMounted, onUnmounted, watch } from 'vue'\n\ninterface IRecycleTarget {\n  onMount: () => void\n  onUnmount: () => void\n}\n\nexport function useAttach<T extends IRecycleTarget>(target: Ref<T>): Ref<T> {\n  watch(target, (v, old, onInvalidate) => {\n    if (v && v !== old) {\n      old?.onUnmount()\n      nextTick(() => v.onMount())\n      onInvalidate(() => v.onUnmount())\n    }\n  })\n  onMounted(() => {\n    target.value?.onMount()\n  })\n  onUnmounted(() => {\n    target.value?.onUnmount()\n  })\n  return target\n}\n"],"names":["useAttach","target","watch","v","old","onInvalidate","nextTick","onMounted","onUnmounted"],"mappings":";AAQO,SAASA,EAAoCC,GAAwB;AAC1E,SAAAC,EAAMD,GAAQ,CAACE,GAAGC,GAAKC,MAAiB;AACtC,IAAIF,KAAKA,MAAMC,MACbA,GAAK,UAAA,GACLE,EAAS,MAAMH,EAAE,SAAS,GAC1BE,EAAa,MAAMF,EAAE,WAAW;AAAA,EAEpC,CAAC,GACDI,EAAU,MAAM;AACd,IAAAN,EAAO,OAAO,QAAA;AAAA,EAChB,CAAC,GACDO,EAAY,MAAM;AAChB,IAAAP,EAAO,OAAO,UAAA;AAAA,EAChB,CAAC,GACMA;AACT;"}

package/esm/hooks/useField.d.ts

@@ -0,0 +1,3 @@
+import { GeneralField } from '@formily/core';
+import { Ref } from 'vue';
+export declare function useField<T = GeneralField>(): Ref<T>;

package/esm/hooks/useField.mjs

@@ -0,0 +1,9 @@
+import { inject as r, ref as e } from "vue";
+import { FieldSymbol as o } from "../shared/context.mjs";
+function m() {
+  return r(o, e());
+}
+export {
+  m as useField
+};
+//# sourceMappingURL=useField.mjs.map

package/esm/hooks/useField.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useField.mjs","sources":["../../src/hooks/useField.ts"],"sourcesContent":["import type { GeneralField } from '@formily/core'\nimport type { Ref } from 'vue'\nimport { inject, ref } from 'vue'\nimport { FieldSymbol } from '../shared/context'\n\nexport function useField<T = GeneralField>() {\n  return inject(FieldSymbol, ref()) as Ref<T>\n}\n"],"names":["useField","inject","FieldSymbol","ref"],"mappings":";;AAKO,SAASA,IAA6B;AAC3C,SAAOC,EAAOC,GAAaC,GAAK;AAClC;"}

package/esm/hooks/useFieldSchema.d.ts

@@ -0,0 +1 @@
+export declare function useFieldSchema(): import('vue').Ref<import('@formily/json-schema').Schema<any, any, any, any, any, any, any, any, any>, import('@formily/json-schema').Schema<any, any, any, any, any, any, any, any, any>>;

package/esm/hooks/useFieldSchema.mjs

@@ -0,0 +1,9 @@
+import { inject as e, ref as r } from "vue";
+import { SchemaSymbol as m } from "../shared/context.mjs";
+function i() {
+  return e(m, r());
+}
+export {
+  i as useFieldSchema
+};
+//# sourceMappingURL=useFieldSchema.mjs.map

package/esm/hooks/useFieldSchema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFieldSchema.mjs","sources":["../../src/hooks/useFieldSchema.ts"],"sourcesContent":["import { inject, ref } from 'vue'\nimport { SchemaSymbol } from '../shared/context'\n\nexport function useFieldSchema() {\n  return inject(SchemaSymbol, ref())\n}\n"],"names":["useFieldSchema","inject","SchemaSymbol","ref"],"mappings":";;AAGO,SAASA,IAAiB;AAC/B,SAAOC,EAAOC,GAAcC,GAAK;AACnC;"}

package/esm/hooks/useForm.d.ts

@@ -0,0 +1,3 @@
+import { Form } from '@formily/core';
+import { Ref } from 'vue';
+export declare function useForm(): Ref<Form>;

package/esm/hooks/useForm.mjs

@@ -0,0 +1,9 @@
+import { inject as o, ref as r } from "vue";
+import { FormSymbol as m } from "../shared/context.mjs";
+function n() {
+  return o(m, r());
+}
+export {
+  n as useForm
+};
+//# sourceMappingURL=useForm.mjs.map

package/esm/hooks/useForm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useForm.mjs","sources":["../../src/hooks/useForm.ts"],"sourcesContent":["import type { Form } from '@formily/core'\nimport type { Ref } from 'vue'\nimport { inject, ref } from 'vue'\nimport { FormSymbol } from '../shared/context'\n\nexport function useForm() {\n  const form = inject(FormSymbol, ref())\n  return form as Ref<Form>\n}\n"],"names":["useForm","inject","FormSymbol","ref"],"mappings":";;AAKO,SAASA,IAAU;AAExB,SADaC,EAAOC,GAAYC,EAAA,CAAK;AAEvC;"}

package/esm/hooks/useFormEffects.d.ts

@@ -0,0 +1,2 @@
+import { Form } from '@formily/core';
+export declare function useFormEffects(effects?: (form: Form) => void): void;

package/esm/hooks/useFormEffects.mjs

@@ -0,0 +1,16 @@
+import { uid as m } from "@formily/shared";
+import { watchEffect as c, onBeforeUnmount as s } from "vue";
+import { useForm as n } from "./useForm.mjs";
+function a(t) {
+  const o = n(), e = c((r) => {
+    const f = m();
+    o.value.addEffects(f, t), r(() => {
+      o.value.removeEffects(f);
+    });
+  });
+  s(() => e());
+}
+export {
+  a as useFormEffects
+};
+//# sourceMappingURL=useFormEffects.mjs.map

package/esm/hooks/useFormEffects.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useFormEffects.mjs","sources":["../../src/hooks/useFormEffects.ts"],"sourcesContent":["import type { Form } from '@formily/core'\nimport { uid } from '@formily/shared'\nimport { onBeforeUnmount, watchEffect } from 'vue'\nimport { useForm } from './useForm'\n\nexport function useFormEffects(effects?: (form: Form) => void): void {\n  const formRef = useForm()\n\n  const stop = watchEffect((onCleanup) => {\n    const id = uid()\n    formRef.value.addEffects(id, effects)\n\n    onCleanup(() => {\n      formRef.value.removeEffects(id)\n    })\n  })\n\n  onBeforeUnmount(() => stop())\n}\n"],"names":["useFormEffects","effects","formRef","useForm","stop","watchEffect","onCleanup","id","uid","onBeforeUnmount"],"mappings":";;;AAKO,SAASA,EAAeC,GAAsC;AACnE,QAAMC,IAAUC,EAAA,GAEVC,IAAOC,EAAY,CAACC,MAAc;AACtC,UAAMC,IAAKC,EAAA;AACX,IAAAN,EAAQ,MAAM,WAAWK,GAAIN,CAAO,GAEpCK,EAAU,MAAM;AACd,MAAAJ,EAAQ,MAAM,cAAcK,CAAE;AAAA,IAChC,CAAC;AAAA,EACH,CAAC;AAED,EAAAE,EAAgB,MAAML,GAAM;AAC9B;"}

package/esm/hooks/useInjectionCleaner.d.ts

@@ -0,0 +1,2 @@
+import { InjectionKey, Ref } from 'vue';
+export declare function useInjectionCleaner(injectionKeys: InjectionKey<Ref<unknown>>[]): void;

package/esm/hooks/useInjectionCleaner.mjs

@@ -0,0 +1,8 @@
+import { provide as r, ref as n } from "vue";
+function i(e) {
+  e.forEach((o) => r(o, n()));
+}
+export {
+  i as useInjectionCleaner
+};
+//# sourceMappingURL=useInjectionCleaner.mjs.map

package/esm/hooks/useInjectionCleaner.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useInjectionCleaner.mjs","sources":["../../src/hooks/useInjectionCleaner.ts"],"sourcesContent":["import type { InjectionKey, Ref } from 'vue'\nimport { provide, ref } from 'vue'\n\nexport function useInjectionCleaner(injectionKeys: InjectionKey<Ref<unknown>>[]) {\n  injectionKeys.forEach(key => provide(key, ref()))\n}\n"],"names":["useInjectionCleaner","injectionKeys","key","provide","ref"],"mappings":";AAGO,SAASA,EAAoBC,GAA6C;AAC/E,EAAAA,EAAc,QAAQ,CAAAC,MAAOC,EAAQD,GAAKE,EAAA,CAAK,CAAC;AAClD;"}

package/esm/hooks/useParentForm.d.ts

@@ -0,0 +1,3 @@
+import { Form, ObjectField } from '@formily/core';
+import { Ref } from 'vue';
+export declare function useParentForm(): Ref<Form | ObjectField>;

package/esm/hooks/useParentForm.mjs

@@ -0,0 +1,12 @@
+import { isObjectField as n } from "@formily/core";
+import { computed as m } from "vue";
+import { useField as u } from "./useField.mjs";
+import { useForm as i } from "./useForm.mjs";
+function a() {
+  const o = u(), e = i(), t = (r) => r ? n(r) ? r : t(r?.parent) : e.value;
+  return m(() => t(o.value));
+}
+export {
+  a as useParentForm
+};
+//# sourceMappingURL=useParentForm.mjs.map

package/esm/hooks/useParentForm.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"useParentForm.mjs","sources":["../../src/hooks/useParentForm.ts"],"sourcesContent":["import type { Form, GeneralField, ObjectField } from '@formily/core'\nimport type { Ref } from 'vue'\nimport { isObjectField } from '@formily/core'\nimport { computed } from 'vue'\nimport { useField } from './useField'\nimport { useForm } from './useForm'\n\nexport function useParentForm(): Ref<Form | ObjectField> {\n  const field = useField()\n  const form = useForm()\n  const findObjectParent = (field: GeneralField) => {\n    if (!field)\n      return form.value\n    if (isObjectField(field))\n      return field\n    return findObjectParent(field?.parent)\n  }\n  return computed(() => findObjectParent(field.value))\n}\n"],"names":["useParentForm","field","useField","form","useForm","findObjectParent","isObjectField","computed"],"mappings":";;;;AAOO,SAASA,IAAyC;AACvD,QAAMC,IAAQC,EAAA,GACRC,IAAOC,EAAA,GACPC,IAAmB,CAACJ,MACnBA,IAEDK,EAAcL,CAAK,IACdA,IACFI,EAAiBJ,GAAO,MAAM,IAH5BE,EAAK;AAKhB,SAAOI,EAAS,MAAMF,EAAiBJ,EAAM,KAAK,CAAC;AACrD;"}

package/esm/index.d.ts

@@ -0,0 +1,4 @@
+export * from './components';
+export * from './hooks';
+export * from './shared';
+export * from './types';

package/esm/index.mjs

@@ -0,0 +1,42 @@
+import { default as r } from "./components/ArrayField.mjs";
+import { default as t } from "./components/ExpressionScope.mjs";
+import { default as f } from "./components/Field.mjs";
+import { default as l } from "./components/FormConsumer.mjs";
+import { default as d } from "./components/FormProvider.mjs";
+import { default as u } from "./components/ObjectField.mjs";
+import { default as F } from "./components/RecursionField.mjs";
+import { createSchemaField as S } from "./components/SchemaField.mjs";
+import { default as y } from "./components/VoidField.mjs";
+import { useField as h } from "./hooks/useField.mjs";
+import { useFieldSchema as E } from "./hooks/useFieldSchema.mjs";
+import { useForm as R } from "./hooks/useForm.mjs";
+import { useFormEffects as k } from "./hooks/useFormEffects.mjs";
+import { useParentForm as A } from "./hooks/useParentForm.mjs";
+import { connect as M, mapProps as V, mapReadPretty as g } from "./shared/connect.mjs";
+import { FieldSymbol as w, FormSymbol as z, SchemaExpressionScopeSymbol as B, SchemaMarkupSymbol as D, SchemaOptionsSymbol as G, SchemaSymbol as H } from "./shared/context.mjs";
+export {
+  r as ArrayField,
+  t as ExpressionScope,
+  f as Field,
+  w as FieldSymbol,
+  l as FormConsumer,
+  d as FormProvider,
+  z as FormSymbol,
+  u as ObjectField,
+  F as RecursionField,
+  B as SchemaExpressionScopeSymbol,
+  D as SchemaMarkupSymbol,
+  G as SchemaOptionsSymbol,
+  H as SchemaSymbol,
+  y as VoidField,
+  M as connect,
+  S as createSchemaField,
+  V as mapProps,
+  g as mapReadPretty,
+  h as useField,
+  E as useFieldSchema,
+  R as useForm,
+  k as useFormEffects,
+  A as useParentForm
+};
+//# sourceMappingURL=index.mjs.map

package/esm/index.mjs.map

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

package/esm/shared/connect.d.ts

@@ -0,0 +1,9 @@
+import { Component } from 'vue';
+import { IComponentMapper, IStateMapper, VueComponentProps } from '../types';
+export declare function mapProps<T extends Component = Component>(...args: IStateMapper<VueComponentProps<T>>[]): (target: T) => import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export declare function mapReadPretty<T extends Component, C extends Component>(component: C, readPrettyProps?: Record<string, any>): (target: T) => import('vue').DefineComponent<{}, () => import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export declare function connect<T extends Component>(target: T, ...args: IComponentMapper[]): T;

package/esm/shared/connect.mjs

@@ -0,0 +1,66 @@
+import { isVoidField as P } from "@formily/core";
+import { observer as R } from "@formily/reactive-vue";
+import { isFn as p, each as F, FormPath as d, isStr as b, isValid as C } from "@formily/shared";
+import { defineComponent as f, h as l, markRaw as h } from "vue";
+import { useField as V } from "../hooks/useField.mjs";
+import { extractAttrsAndEvents as v, createVNodeProps as A } from "../utils/reactiveFieldHelpers.mjs";
+function j(...u) {
+  const m = (t, i) => u.reduce((e, r) => (p(r) ? e = Object.assign(e, r(e, i)) : F(r, (o, n) => {
+    const s = d.getIn(i, n), a = b(o) ? o : n, c = d.getIn(e, a);
+    n === "value" && o !== n && delete e.value, !(C(c) && !C(s)) && d.setIn(e, a, s);
+  }), e), t);
+  return (t) => R(
+    f({
+      name: t.name ? `Connected${t.name}` : "ConnectedComponent",
+      setup(i, { attrs: e, slots: r }) {
+        const o = V();
+        return () => {
+          const { attrs: n, events: s } = v(e), a = { ...n }, c = o.value ? m(a, o.value) : a;
+          return l(t, A(c, s), r);
+        };
+      }
+    })
+  );
+}
+function k(u, m) {
+  return (t) => R(
+    f({
+      name: t.name ? `Read${t.name}` : "ReadComponent",
+      setup(i, { attrs: e, slots: r }) {
+        const o = V();
+        return () => {
+          const n = o.value, { attrs: s, events: a } = v(e);
+          return l(
+            n && !P(n) && n.pattern === "readPretty" ? u : t,
+            A(
+              {
+                ...m,
+                ...s
+              },
+              a
+            ),
+            r
+          );
+        };
+      }
+    })
+  );
+}
+function E(u, ...m) {
+  const t = m.reduce((e, r) => r(e), u), i = f({
+    name: u.name,
+    setup(e, { attrs: r, slots: o }) {
+      return () => {
+        const { attrs: n, events: s } = v(r);
+        return l(t, A(n, s), o);
+      };
+    }
+  });
+  return h(i);
+}
+export {
+  E as connect,
+  j as mapProps,
+  k as mapReadPretty
+};
+//# sourceMappingURL=connect.mjs.map

package/esm/shared/connect.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.mjs","sources":["../../src/shared/connect.ts"],"sourcesContent":["import type { GeneralField } from '@formily/core'\nimport type { Component } from 'vue'\nimport type { IComponentMapper, IStateMapper, VueComponentProps } from '../types'\nimport { isVoidField } from '@formily/core'\nimport { observer } from '@formily/reactive-vue'\nimport { each, FormPath, isFn, isStr, isValid } from '@formily/shared'\nimport { defineComponent, h, markRaw } from 'vue'\nimport { useField } from '../hooks/useField'\n\nimport { createVNodeProps, extractAttrsAndEvents } from '../utils/reactiveFieldHelpers'\n\nexport function mapProps<T extends Component = Component>(\n  ...args: IStateMapper<VueComponentProps<T>>[]\n) {\n  const transform = (input: VueComponentProps<T>, field: GeneralField) =>\n    args.reduce((props, mapper) => {\n      if (isFn(mapper)) {\n        props = Object.assign(props, mapper(props, field))\n      }\n      else {\n        each(mapper, (to, extract) => {\n          const extractValue = FormPath.getIn(field, extract)\n          const targetValue = isStr(to) ? to : extract\n          const originalValue = FormPath.getIn(props, targetValue)\n          if (extract === 'value') {\n            if (to !== extract) {\n              delete props.value\n            }\n          }\n          if (isValid(originalValue) && !isValid(extractValue))\n            return\n          FormPath.setIn(props, targetValue, extractValue)\n        })\n      }\n      return props\n    }, input)\n\n  return (target: T) => {\n    return observer(\n      defineComponent({\n        name: target.name ? `Connected${target.name}` : `ConnectedComponent`,\n        setup(_, { attrs, slots }) {\n          const fieldRef = useField()\n          return () => {\n            const { attrs: normalizedAttrs, events } = extractAttrsAndEvents(attrs)\n            const baseAttrs = { ...normalizedAttrs } as VueComponentProps<T>\n            const newAttrs = fieldRef.value ? transform(baseAttrs, fieldRef.value) : baseAttrs\n            return h(target, createVNodeProps(newAttrs, events), slots)\n          }\n        },\n      }),\n    )\n  }\n}\n\nexport function mapReadPretty<T extends Component, C extends Component>(\n  component: C,\n  readPrettyProps?: Record<string, any>,\n) {\n  return (target: T) => {\n    return observer(\n      defineComponent({\n        name: target.name ? `Read${target.name}` : `ReadComponent`,\n        setup(_, { attrs, slots }) {\n          const fieldRef = useField()\n          return () => {\n            const field = fieldRef.value\n            const { attrs: normalizedAttrs, events } = extractAttrsAndEvents(attrs)\n            return h(\n              field && !isVoidField(field) && field.pattern === 'readPretty' ? component : target,\n              createVNodeProps(\n                {\n                  ...readPrettyProps,\n                  ...normalizedAttrs,\n                },\n                events,\n              ),\n              slots,\n            )\n          }\n        },\n      }),\n    )\n  }\n}\n\nexport function connect<T extends Component>(target: T, ...args: IComponentMapper[]): T {\n  const Component = args.reduce((target: Component, mapper) => {\n    return mapper(target)\n  }, target)\n\n  const functionalComponent = defineComponent({\n    name: target.name,\n    setup(_, { attrs, slots }) {\n      return () => {\n        const { attrs: normalizedAttrs, events } = extractAttrsAndEvents(attrs)\n        return h(Component, createVNodeProps(normalizedAttrs, events), slots)\n      }\n    },\n  })\n\n  return markRaw(functionalComponent) as unknown as T\n}\n"],"names":["mapProps","args","transform","input","field","props","mapper","isFn","each","to","extract","extractValue","FormPath","targetValue","isStr","originalValue","isValid","target","observer","defineComponent","_","attrs","slots","fieldRef","useField","normalizedAttrs","events","extractAttrsAndEvents","baseAttrs","newAttrs","h","createVNodeProps","mapReadPretty","component","readPrettyProps","isVoidField","connect","Component","functionalComponent","markRaw"],"mappings":";;;;;;AAWO,SAASA,KACXC,GACH;AACA,QAAMC,IAAY,CAACC,GAA6BC,MAC9CH,EAAK,OAAO,CAACI,GAAOC,OACdC,EAAKD,CAAM,IACbD,IAAQ,OAAO,OAAOA,GAAOC,EAAOD,GAAOD,CAAK,CAAC,IAGjDI,EAAKF,GAAQ,CAACG,GAAIC,MAAY;AAC5B,UAAMC,IAAeC,EAAS,MAAMR,GAAOM,CAAO,GAC5CG,IAAcC,EAAML,CAAE,IAAIA,IAAKC,GAC/BK,IAAgBH,EAAS,MAAMP,GAAOQ,CAAW;AAMvD,IALIH,MAAY,WACVD,MAAOC,KACT,OAAOL,EAAM,OAGb,EAAAW,EAAQD,CAAa,KAAK,CAACC,EAAQL,CAAY,MAEnDC,EAAS,MAAMP,GAAOQ,GAAaF,CAAY;AAAA,EACjD,CAAC,GAEIN,IACNF,CAAK;AAEV,SAAO,CAACc,MACCC;AAAA,IACLC,EAAgB;AAAA,MACd,MAAMF,EAAO,OAAO,YAAYA,EAAO,IAAI,KAAK;AAAA,MAChD,MAAMG,GAAG,EAAE,OAAAC,GAAO,OAAAC,KAAS;AACzB,cAAMC,IAAWC,EAAA;AACjB,eAAO,MAAM;AACX,gBAAM,EAAE,OAAOC,GAAiB,QAAAC,EAAA,IAAWC,EAAsBN,CAAK,GAChEO,IAAY,EAAE,GAAGH,EAAA,GACjBI,IAAWN,EAAS,QAAQrB,EAAU0B,GAAWL,EAAS,KAAK,IAAIK;AACzE,iBAAOE,EAAEb,GAAQc,EAAiBF,GAAUH,CAAM,GAAGJ,CAAK;AAAA,QAC5D;AAAA,MACF;AAAA,IAAA,CACD;AAAA,EAAA;AAGP;AAEO,SAASU,EACdC,GACAC,GACA;AACA,SAAO,CAACjB,MACCC;AAAA,IACLC,EAAgB;AAAA,MACd,MAAMF,EAAO,OAAO,OAAOA,EAAO,IAAI,KAAK;AAAA,MAC3C,MAAMG,GAAG,EAAE,OAAAC,GAAO,OAAAC,KAAS;AACzB,cAAMC,IAAWC,EAAA;AACjB,eAAO,MAAM;AACX,gBAAMpB,IAAQmB,EAAS,OACjB,EAAE,OAAOE,GAAiB,QAAAC,EAAA,IAAWC,EAAsBN,CAAK;AACtE,iBAAOS;AAAA,YACL1B,KAAS,CAAC+B,EAAY/B,CAAK,KAAKA,EAAM,YAAY,eAAe6B,IAAYhB;AAAA,YAC7Ec;AAAA,cACE;AAAA,gBACE,GAAGG;AAAA,gBACH,GAAGT;AAAA,cAAA;AAAA,cAELC;AAAA,YAAA;AAAA,YAEFJ;AAAA,UAAA;AAAA,QAEJ;AAAA,MACF;AAAA,IAAA,CACD;AAAA,EAAA;AAGP;AAEO,SAASc,EAA6BnB,MAAchB,GAA6B;AACtF,QAAMoC,IAAYpC,EAAK,OAAO,CAACgB,GAAmBX,MACzCA,EAAOW,CAAM,GACnBA,CAAM,GAEHqB,IAAsBnB,EAAgB;AAAA,IAC1C,MAAMF,EAAO;AAAA,IACb,MAAMG,GAAG,EAAE,OAAAC,GAAO,OAAAC,KAAS;AACzB,aAAO,MAAM;AACX,cAAM,EAAE,OAAOG,GAAiB,QAAAC,EAAA,IAAWC,EAAsBN,CAAK;AACtE,eAAOS,EAAEO,GAAWN,EAAiBN,GAAiBC,CAAM,GAAGJ,CAAK;AAAA,MACtE;AAAA,IACF;AAAA,EAAA,CACD;AAED,SAAOiB,EAAQD,CAAmB;AACpC;"}

package/esm/shared/context.d.ts

@@ -0,0 +1,10 @@
+import { Form, GeneralField } from '@formily/core';
+import { Schema } from '@formily/json-schema';
+import { InjectionKey, Ref } from 'vue';
+import { ISchemaFieldVueFactoryOptions, SchemaExpressionScope } from '../types';
+export declare const FormSymbol: InjectionKey<Ref<Form>>;
+export declare const FieldSymbol: InjectionKey<Ref<GeneralField>>;
+export declare const SchemaMarkupSymbol: InjectionKey<Ref<Schema>>;
+export declare const SchemaSymbol: InjectionKey<Ref<Schema>>;
+export declare const SchemaExpressionScopeSymbol: InjectionKey<Ref<SchemaExpressionScope>>;
+export declare const SchemaOptionsSymbol: InjectionKey<Ref<ISchemaFieldVueFactoryOptions>>;

package/esm/shared/context.mjs

@@ -0,0 +1,10 @@
+const o = /* @__PURE__ */ Symbol("form"), m = /* @__PURE__ */ Symbol("field"), S = /* @__PURE__ */ Symbol("schemaMarkup"), s = /* @__PURE__ */ Symbol("schema"), c = /* @__PURE__ */ Symbol("schemaExpression"), e = /* @__PURE__ */ Symbol("schemaOptions");
+export {
+  m as FieldSymbol,
+  o as FormSymbol,
+  c as SchemaExpressionScopeSymbol,
+  S as SchemaMarkupSymbol,
+  e as SchemaOptionsSymbol,
+  s as SchemaSymbol
+};
+//# sourceMappingURL=context.mjs.map

package/esm/shared/context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.mjs","sources":["../../src/shared/context.ts"],"sourcesContent":["import type { Form, GeneralField } from '@formily/core'\nimport type { Schema } from '@formily/json-schema'\nimport type { InjectionKey, Ref } from 'vue'\nimport type { ISchemaFieldVueFactoryOptions, SchemaExpressionScope } from '../types'\n\nexport const FormSymbol: InjectionKey<Ref<Form>> = Symbol('form')\nexport const FieldSymbol: InjectionKey<Ref<GeneralField>> = Symbol('field')\nexport const SchemaMarkupSymbol: InjectionKey<Ref<Schema>> = Symbol('schemaMarkup')\nexport const SchemaSymbol: InjectionKey<Ref<Schema>> = Symbol('schema')\nexport const SchemaExpressionScopeSymbol: InjectionKey<Ref<SchemaExpressionScope>>\n  = Symbol('schemaExpression')\nexport const SchemaOptionsSymbol: InjectionKey<Ref<ISchemaFieldVueFactoryOptions>>\n  = Symbol('schemaOptions')\n"],"names":["FormSymbol","FieldSymbol","SchemaMarkupSymbol","SchemaSymbol","SchemaExpressionScopeSymbol","SchemaOptionsSymbol"],"mappings":"AAKO,MAAMA,2BAA6C,MAAM,GACnDC,2BAAsD,OAAO,GAC7DC,2BAAuD,cAAc,GACrEC,2BAAiD,QAAQ,GACzDC,2BACF,kBAAkB,GAChBC,2BACF,eAAe;"}

package/esm/shared/index.d.ts

@@ -0,0 +1,2 @@
+export * from './connect';
+export * from './context';

package/esm/shared/index.mjs

@@ -0,0 +1,14 @@
+import { connect as e, mapProps as S, mapReadPretty as p } from "./connect.mjs";
+import { FieldSymbol as a, FormSymbol as c, SchemaExpressionScopeSymbol as l, SchemaMarkupSymbol as y, SchemaOptionsSymbol as b, SchemaSymbol as t } from "./context.mjs";
+export {
+  a as FieldSymbol,
+  c as FormSymbol,
+  l as SchemaExpressionScopeSymbol,
+  y as SchemaMarkupSymbol,
+  b as SchemaOptionsSymbol,
+  t as SchemaSymbol,
+  e as connect,
+  S as mapProps,
+  p as mapReadPretty
+};
+//# sourceMappingURL=index.mjs.map

package/esm/shared/index.mjs.map

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