@effect-app/vue-components 0.27.15 → 1.0.0-next.0

package/dist/types/components/OmegaForm/OmegaArray.vue.d.ts

@@ -1,7 +1,7 @@
 import { type DeepKeys, type DeepValue } from "@tanstack/vue-form";
 import { type OmegaInputProps } from "./OmegaFormStuff";
 declare const _default: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & (Omit<OmegaInputProps<From, To>, "label" | "type" | "options" | "validators" | "items"> & {
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & (Omit<OmegaInputProps<From, To>, "validators" | "options" | "label" | "type" | "items"> & {
         defaultItems?: DeepValue<From, DeepKeys<From>>;
         items?: "please use `defaultItems` instead";
     }) & {}> & import("vue").PublicProps;

package/dist/types/components/OmegaForm/OmegaErrorsContext.d.ts

@@ -8,9 +8,9 @@ export declare const OmegaErrorsKey: InjectionKey<{
     clearErrors: () => void;
     showErrors: Ref<boolean>;
     showErrorsOn: ShowErrorsOn;
-    generalErrors: Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>;
+    generalErrors: Readonly<Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>>;
 }>;
-export declare function provideOmegaErrors(formSubmissionAttempts: Ref<number>, generalErrors: Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>, showErrorsOn?: ShowErrorsOn): {
+export declare function buildOmegaErrors(formSubmissionAttempts: Ref<number>, generalErrors: Readonly<Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>>, showErrorsOn?: ShowErrorsOn): {
     errors: Readonly<Ref<readonly {
         readonly label: string;
         readonly inputId: string;
@@ -24,7 +24,7 @@ export declare function provideOmegaErrors(formSubmissionAttempts: Ref<number>,
     removeError: (inputId: string) => void;
     clearErrors: () => void;
     showErrors: import("vue").ComputedRef<boolean>;
-    generalErrors: Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined, (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>;
+    generalErrors: Readonly<Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined, (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>>;
     showErrorsOn: ShowErrorsOn;
 };
 export declare function useOmegaErrors(): {
@@ -34,5 +34,5 @@ export declare function useOmegaErrors(): {
     clearErrors: () => void;
     showErrors: Ref<boolean>;
     showErrorsOn: ShowErrorsOn;
-    generalErrors: Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>;
+    generalErrors: Readonly<Ref<(Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined>>;
 };

package/dist/types/components/OmegaForm/OmegaErrorsInternal.vue.d.ts

@@ -0,0 +1,22 @@
+import type { StandardSchemaV1Issue } from "@tanstack/vue-form";
+import { type OmegaError } from "./OmegaFormStuff";
+type __VLS_Props = {
+    errors: readonly OmegaError[];
+    generalErrors: (Record<string, StandardSchemaV1Issue[]> | undefined)[] | undefined;
+    showErrors: boolean;
+};
+declare var __VLS_6: {
+    errors: readonly OmegaError[];
+    showedGeneralErrors: string[];
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/OmegaForm/OmegaWrapper.vue.d.ts

@@ -1,45 +1,15 @@
-import { type S } from "effect-app";
-import { type FormProps, type OmegaFormState, type ShowErrorsOn } from "./OmegaFormStuff";
-import { type OmegaConfig, type OmegaFormReturn } from "./useOmegaForm";
-declare const _default: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, K extends keyof OmegaFormState<From, To> = keyof OmegaFormState<From, To>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
-    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & ({
-        omegaConfig?: OmegaConfig<From>;
+import { type OmegaFormState } from "./OmegaFormStuff";
+import { type DefaultInputProps, type OmegaFormReturn } from "./useOmegaForm";
+declare const _default: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, K extends keyof OmegaFormState<From, To> = keyof OmegaFormState<From, To>, Props = DefaultInputProps<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
+        form: OmegaFormReturn<From, To, Props>;
+        disabled?: boolean;
         subscribe?: K[];
-        showErrorsOn?: ShowErrorsOn;
-    } & Omit<FormProps<From, To>, "onSubmit"> & (({
-        form: OmegaFormReturn<From, To>;
-        schema?: undefined;
-    } | {
-        form?: undefined;
-        schema: S.Schema<To, From, never>;
-    }) & ({
-        isLoading: boolean;
-        onSubmit: (value: To, extra: Pick<{
-            formApi: import("./OmegaFormStuff").OmegaFormParams<From, To>;
-            meta: any;
-            value: To;
-        }, "formApi" | "meta">) => void;
-    } | {
-        isLoading?: undefined;
-        onSubmit?: (value: To, extra: Pick<{
-            formApi: import("./OmegaFormStuff").OmegaFormParams<From, To>;
-            meta: any;
-            value: To;
-        }, "formApi" | "meta">) => ReturnType<(props: {
-            formApi: import("./OmegaFormStuff").OmegaFormParams<From, To>;
-            meta: any;
-            value: To;
-        }) => Promise<any> | import("effect/Fiber").RuntimeFiber<any, any> | import("effect/Effect").Effect<import("effect/Fiber").RuntimeFiber<any, any>, any, never>>;
-    }))) & {}> & import("vue").PublicProps;
+    } & {}> & import("vue").PublicProps;
     expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
     attrs: any;
     slots: {
-        default(): void;
-        internalForm(props: {
-            form: OmegaFormReturn<From, To>;
-            subscribedValues: K[] extends undefined[] ? Record<string, never> : Pick<OmegaFormState<From, To>, K>;
-        }): void;
-        externalForm(props: {
+        default(props: {
             subscribedValues: K[] extends undefined[] ? Record<string, never> : Pick<OmegaFormState<From, To>, K>;
         }): void;
     };

package/dist/types/components/OmegaForm/index.d.ts

@@ -1,11 +1,5 @@
-import { default as OmegaArray } from "./OmegaArray.vue";
-import { default as OmegaAutoGen } from "./OmegaAutoGen.vue";
-import { default as OmegaErrors } from "./OmegaErrors.vue";
-import { default as OmegaFormInput } from "./OmegaFormInput.vue";
 import { default as OmegaInput } from "./OmegaInput.vue";
-import { default as OmegaForm } from "./OmegaWrapper.vue";
 export * as OmegaErrorsContext from "./OmegaErrorsContext";
 export * from "./OmegaFormStuff";
-export { default } from "./OmegaWrapper.vue";
 export { type OmegaFormReturn, useOmegaForm } from "./useOmegaForm";
-export { OmegaArray, OmegaAutoGen, OmegaErrors, OmegaForm, OmegaFormInput, OmegaInput };
+export { OmegaInput };

package/dist/types/components/OmegaForm/useOmegaForm.d.ts

@@ -1,8 +1,13 @@
 import { type DeepKeys } from "@tanstack/vue-form";
 import { S } from "effect-app";
 import { type InjectionKey } from "vue";
+import { getOmegaStore } from "./getOmegaStore";
 import { type InputProps } from "./InputProps";
-import { type FieldValidators, type FilterItems, type FormProps, type MetaRecord, type NestedKeyOf, type OmegaFormApi, type TypeOverride } from "./OmegaFormStuff";
+import OmegaArray from "./OmegaArray.vue";
+import OmegaAutoGen from "./OmegaAutoGen.vue";
+import OmegaErrorsInternal from "./OmegaErrorsInternal.vue";
+import { type FieldValidators, type FilterItems, type FormProps, type MetaRecord, type NestedKeyOf, type OmegaFormApi, OmegaFormState, ShowErrorsOn, type TypeOverride } from "./OmegaFormStuff";
+import OmegaForm from "./OmegaWrapper.vue";
 type keysRule<T> = {
     keys?: NestedKeyOf<T>[];
     banKeys?: "You should only use one of banKeys or keys, not both, moron";
@@ -12,6 +17,7 @@ type keysRule<T> = {
 };
 export type OmegaConfig<T> = {
     i18nNamespace?: string;
+    showErrorsOn?: ShowErrorsOn;
     persistency?: {
         /** Order of importance:
          * - "querystring": Highest priority when persisting
@@ -33,7 +39,7 @@ export declare const OmegaFormKey: InjectionKey<OF<any, any>>;
 type __VLS_PrettifyLocal<T> = {
     [K in keyof T]: T[K];
 } & {};
-type DefaultProps<From> = {
+export type DefaultInputProps<From> = {
     label?: string;
     validators?: FieldValidators<From>;
     options?: {
@@ -42,7 +48,7 @@ type DefaultProps<From> = {
     }[];
     type?: TypeOverride;
 };
-export interface OmegaFormReturn<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Props = DefaultProps<From>> extends OF<From, To> {
+export interface OmegaFormReturn<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Props = DefaultInputProps<From>> extends OF<From, To> {
     Input: <Name extends DeepKeys<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
         props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & {
             name: Name;
@@ -56,6 +62,64 @@ export interface OmegaFormReturn<From extends Record<PropertyKey, any>, To exten
     }>) => import("vue").VNode & {
         __ctx?: Awaited<typeof __VLS_setup>;
     };
+    Errors: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & Omit<ReturnType<typeof OmegaErrorsInternal["props"]>, "errors" | "generalErrors" | "showErrors"> & Partial<{}>> & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {};
+        emit: {};
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    Array: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & Omit<ReturnType<typeof OmegaArray<From, To>>["props"], "form"> & Partial<{}>> & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default(props: {
+                subField: any;
+                subState: any;
+                index: number;
+                field: any;
+            }): void;
+            preArray(props: {
+                field: any;
+                state: any;
+            }): void;
+            postArray(props: {
+                field: any;
+                state: any;
+            }): void;
+            field(props: {
+                field: any;
+            }): void;
+        };
+        emit: {};
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    AutoGen: (__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & Omit<ReturnType<typeof OmegaAutoGen<From, To>>["props"], "form"> & Partial<{}>> & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {};
+        emit: {};
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
+    Form: <K extends keyof OmegaFormState<To, From>, Props = DefaultInputProps<From>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+        props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, never> & ReturnType<typeof OmegaForm<From, To, K, Props>>["props"] & Partial<{}>> & import("vue").PublicProps;
+        expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default(props: {
+                subscribedValues: ReturnType<typeof getOmegaStore<To, From, K>>["value"];
+            }): void;
+        };
+        emit: {};
+    }>) => import("vue").VNode & {
+        __ctx?: Awaited<typeof __VLS_setup>;
+    };
 }
-export declare const useOmegaForm: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Props = DefaultProps<From>>(schema: S.Schema<To, From, never>, tanstackFormOptions?: NoInfer<FormProps<From, To>>, omegaConfig?: OmegaConfig<To>) => OmegaFormReturn<From, To, Props>;
+export declare const useOmegaForm: <From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Props = DefaultInputProps<From>>(schema: S.Schema<To, From, never>, tanstackFormOptions?: NoInfer<FormProps<From, To>>, omegaConfig?: OmegaConfig<To>) => OmegaFormReturn<From, To, Props>;
 export {};

package/dist/types/utils/index.d.ts

@@ -1,4 +1,5 @@
 import { type makeIntl } from "@effect-app/vue";
+import { type S } from "effect-app";
 import { type InjectionKey } from "vue";
 export declare const useIntlKey: InjectionKey<ReturnType<typeof makeIntl>["useIntl"]>;
 export declare const useIntl: () => {
@@ -8,3 +9,11 @@ export declare const useIntl: () => {
     readonly intl: import("@effect-app/vue").IntlShape<string>;
 };
 export declare const provideIntl: (intl: ReturnType<typeof makeIntl>["useIntl"]) => void;
+/**
+ * Recursively extracts the source AST from a transformation chain.
+ * If the provided AST is a transformation, it follows the chain to find the original source AST.
+ *
+ * @param ast - The AST node to extract the transformation source from
+ * @returns The source AST at the end of the transformation chain
+ */
+export declare function getTransformationFrom(ast: S.AST.AST): S.AST.Declaration | S.AST.Literal | S.AST.UniqueSymbol | S.AST.UndefinedKeyword | S.AST.VoidKeyword | S.AST.NeverKeyword | S.AST.UnknownKeyword | S.AST.AnyKeyword | S.AST.StringKeyword | S.AST.NumberKeyword | S.AST.BooleanKeyword | S.AST.BigIntKeyword | S.AST.SymbolKeyword | S.AST.ObjectKeyword | S.AST.Enums | S.AST.TemplateLiteral | S.AST.Refinement<S.AST.AST> | S.AST.TupleType | S.AST.TypeLiteral | S.AST.Union<S.AST.AST> | S.AST.Suspend;

package/dist/vue-components.es.js

@@ -1,14 +1,9 @@
 import * as o from "./vue-components.es2.js";
-import { provideIntl as l, useIntl as s, useIntlKey as u } from "./vue-components.es3.js";
+import { getTransformationFrom as f, provideIntl as l, useIntl as s, useIntlKey as i } from "./vue-components.es3.js";
 import { default as d } from "./vue-components.es4.js";
-import { default as i } from "./vue-components.es5.js";
-import { default as O } from "./vue-components.es6.js";
-import { default as y } from "./vue-components.es7.js";
-import * as m from "./vue-components.es8.js";
-import { useOmegaForm as h } from "./vue-components.es9.js";
-import { createMeta as b, duplicateSchema as M, generateInputStandardSchemaFromFieldMeta as j, generateMetaFromSchema as A, nullableInput as E } from "./vue-components.es10.js";
-import { default as v } from "./vue-components.es11.js";
-import { default as C } from "./vue-components.es12.js";
+import * as n from "./vue-components.es5.js";
+import { useOmegaForm as g } from "./vue-components.es6.js";
+import { createMeta as y, duplicateSchema as F, generateInputStandardSchemaFromFieldMeta as O, generateMetaFromSchema as h, nullableInput as S } from "./vue-components.es7.js";
 function a(r) {
   for (const e in o)
     if (Object.prototype.hasOwnProperty.call(o, e)) {
@@ -16,23 +11,19 @@ function a(r) {
       t && typeof t == "object" && r.component(e, t);
     }
 }
-const n = { install: a };
+const m = { install: a };
 export {
-  d as OmegaArray,
-  i as OmegaAutoGen,
-  v as OmegaErrors,
-  m as OmegaErrorsContext,
-  C as OmegaForm,
-  O as OmegaFormInput,
-  y as OmegaInput,
-  b as createMeta,
-  n as default,
-  M as duplicateSchema,
-  j as generateInputStandardSchemaFromFieldMeta,
-  A as generateMetaFromSchema,
-  E as nullableInput,
+  n as OmegaErrorsContext,
+  d as OmegaInput,
+  y as createMeta,
+  m as default,
+  F as duplicateSchema,
+  O as generateInputStandardSchemaFromFieldMeta,
+  h as generateMetaFromSchema,
+  f as getTransformationFrom,
+  S as nullableInput,
   l as provideIntl,
   s as useIntl,
-  u as useIntlKey,
-  h as useOmegaForm
+  i as useIntlKey,
+  g as useOmegaForm
 };

package/dist/vue-components.es10.js

@@ -1,335 +1,7 @@
-import { S as n, Option as c, pipe as L } from "effect-app";
-import { useIntl as U } from "./vue-components.es3.js";
-const N = n.NonEmptyArray(n.String), _ = (e) => n.AST.isUnion(e) && e.types.find((i) => i._tag === "UndefinedKeyword" || i === n.Null.ast), g = (e) => !e || !n.AST.isUnion(e) ? !1 : e.types.find((i) => i._tag === "UndefinedKeyword") ? "undefined" : e.types.find((i) => i === n.Null.ast) ? "null" : !1, m = ({ meta: e = {}, parent: i = "", property: t, propertySignatures: p }, o = {}) => {
-  if (t && t._tag === "Transformation")
-    return m({
-      parent: i,
-      meta: e,
-      property: t.from
-    });
-  if (t?._tag === "TypeLiteral" && "propertySignatures" in t)
-    return m({
-      meta: e,
-      propertySignatures: t.propertySignatures
-    });
-  if (p) {
-    for (const r of p) {
-      const l = i ? `${i}.${r.name.toString()}` : r.name.toString(), a = g(r.type), u = !a, A = r.type;
-      if (n.AST.isUnion(r.type)) {
-        const T = r.type.types.filter(
-          (s) => s._tag !== "UndefinedKeyword" && s !== n.Null.ast
-        ).map((s) => s._tag === "Transformation" ? s.from : s);
-        if (T.some(
-          (s) => "propertySignatures" in s
-        )) {
-          if (!a) {
-            const s = m({
-              parent: l,
-              property: r.type,
-              meta: { required: u, nullableOrUndefined: a }
-            });
-            o[l] = s;
-          }
-          for (const s of T)
-            "propertySignatures" in s && Object.assign(
-              o,
-              m({
-                parent: l,
-                propertySignatures: s.propertySignatures,
-                meta: { required: u, nullableOrUndefined: a }
-              })
-            );
-        } else {
-          const s = T.filter(n.AST.isTupleType);
-          if (s.length > 0) {
-            const f = s[0];
-            if (o[l] = {
-              type: "multiple",
-              members: f.elements,
-              rest: f.rest,
-              required: u,
-              nullableOrUndefined: a
-            }, f.rest && f.rest.length > 0) {
-              const d = f.rest[0];
-              if (d.type._tag === "TypeLiteral" && "propertySignatures" in d.type)
-                for (const y of d.type.propertySignatures) {
-                  const b = `${l}.${y.name.toString()}`, S = m({
-                    parent: b,
-                    property: y.type,
-                    meta: {
-                      required: !g(y.type),
-                      nullableOrUndefined: g(y.type)
-                    }
-                  });
-                  if (S && typeof S == "object" && "type" in S && (o[b] = S, S.type === "multiple" && n.AST.isTupleType(y.type) && y.type.rest && y.type.rest.length > 0)) {
-                    const O = y.type.rest[0];
-                    if (O.type._tag === "TypeLiteral" && "propertySignatures" in O.type)
-                      for (const v of O.type.propertySignatures) {
-                        const M = `${b}.${v.name.toString()}`, x = m({
-                          parent: M,
-                          property: v.type,
-                          meta: {
-                            required: !g(v.type),
-                            nullableOrUndefined: g(v.type)
-                          }
-                        });
-                        x && typeof x == "object" && "type" in x && (o[M] = x);
-                      }
-                  }
-                }
-            }
-          } else {
-            const f = m({
-              parent: l,
-              property: r.type,
-              meta: { required: u, nullableOrUndefined: a }
-            });
-            o[l] = f;
-          }
-        }
-      } else if ("propertySignatures" in A)
-        Object.assign(
-          o,
-          m({
-            parent: l,
-            propertySignatures: A.propertySignatures,
-            meta: { required: u, nullableOrUndefined: a }
-          })
-        );
-      else if (n.AST.isTupleType(r.type))
-        if (r.type.rest.length > 0 && r.type.rest[0].type._tag === "TypeLiteral" && "propertySignatures" in r.type.rest[0].type) {
-          const h = r.type.rest[0].type;
-          if (h._tag === "TypeLiteral" && "propertySignatures" in h)
-            for (const s of h.propertySignatures) {
-              const f = `${l}.${s.name.toString()}`;
-              if (n.AST.isTupleType(s.type) && s.type.rest.length > 0) {
-                const d = s.type.rest[0].type;
-                if (d._tag === "TypeLiteral" && "propertySignatures" in d)
-                  for (const y of d.propertySignatures) {
-                    const b = `${f}.${y.name.toString()}`, S = m({
-                      parent: b,
-                      property: y.type,
-                      meta: {
-                        required: !g(y.type),
-                        nullableOrUndefined: g(y.type)
-                      }
-                    });
-                    o[b] = S;
-                  }
-                else
-                  o[f] = {
-                    type: "multiple",
-                    members: s.type.elements,
-                    rest: s.type.rest,
-                    required: !g(s.type),
-                    nullableOrUndefined: g(s.type)
-                  };
-              } else {
-                const d = m({
-                  parent: f,
-                  property: s.type,
-                  meta: {
-                    required: !g(s.type),
-                    nullableOrUndefined: g(s.type)
-                  }
-                });
-                o[f] = d;
-              }
-            }
-        } else
-          o[l] = {
-            type: "multiple",
-            members: r.type.elements,
-            rest: r.type.rest,
-            required: u,
-            nullableOrUndefined: a
-          };
-      else {
-        const T = m({
-          parent: l,
-          property: r.type,
-          meta: { required: u, nullableOrUndefined: a }
-        });
-        o[l] = T;
-      }
-    }
-    return o;
-  }
-  if (t) {
-    const r = _(t);
-    if (Object.hasOwnProperty.call(e, "required") || (e.required = !r), n.AST.isUnion(t)) {
-      const a = t.types.find(
-        (u) => u._tag !== "UndefinedKeyword" && u !== n.Null.ast
-      );
-      return "propertySignatures" in a ? m({
-        propertySignatures: a.propertySignatures,
-        parent: i,
-        meta: e
-      }) : t.types.every(n.AST.isLiteral) ? {
-        ...e,
-        type: "select",
-        members: t.types.map((u) => u.literal)
-      } : {
-        ...e,
-        ...m({
-          parent: i,
-          meta: e,
-          property: a
-        })
-      };
-    }
-    if (n.AST.isTupleType(t))
-      return {
-        ...e,
-        type: "multiple",
-        members: t.elements,
-        rest: t.rest
-      };
-    const l = n.AST.getAnnotation(
-      t,
-      n.AST.JSONSchemaAnnotationId
-    ).pipe(c.getOrElse(() => ({})));
-    return e = { ...e, ...l }, "from" in t ? m({
-      parent: i,
-      meta: e,
-      property: t.from
-    }) : (e.type = n.AST.getAnnotation(
-      t,
-      n.AST.TitleAnnotationId
-    ).pipe(
-      c.getOrElse(() => "unknown")
-    ), e);
-  }
-  return o;
-}, q = (e) => {
-  const i = e.ast, t = {};
-  if (i._tag === "Transformation" || i._tag === "Refinement")
-    return q(n.make(i.from));
-  if ("propertySignatures" in i) {
-    const p = m({
-      propertySignatures: i.propertySignatures
-    });
-    if (Object.values(p).every((r) => r && "type" in r))
-      return p;
-    const o = (r, l = "") => {
-      for (const a in r) {
-        const u = l ? `${l}.${a}` : a;
-        r[a] && typeof r[a] == "object" && "type" in r[a] ? t[u] = r[a] : r[a] && typeof r[a] == "object" && o(r[a], u);
-      }
-    };
-    o(p);
-  }
-  return t;
-}, w = (e) => n.extend(e, n.Struct({})), $ = (e) => {
-  const i = q(e), t = L(
-    e.ast,
-    c.liftPredicate((p) => p._tag === "Refinement" && "filter" in p),
-    c.flatMap((p) => n.AST.getJSONSchemaAnnotation(p)),
-    c.filter((p) => "items" in p),
-    c.filterMap(({ items: p }) => n.decodeUnknownOption(N)(p)),
-    c.zipWith(
-      n.AST.getMessageAnnotation(e.ast),
-      (p, o) => ({
-        items: p,
-        message: o("")
-      })
-    ),
-    c.getOrUndefined
-  );
-  return { schema: e, meta: i, filterItems: t };
-}, K = (e) => {
-  const { trans: i } = U();
-  let t;
-  switch (e.type) {
-    case "string":
-      t = n.String.annotations({
-        message: () => i("validation.empty")
-      }), e.format === "email" && (t = n.compose(
-        t,
-        n.Email.annotations({
-          message: () => i("validation.email.invalid")
-        })
-      )), e.required && t.annotations({
-        message: () => i("validation.empty")
-      }), e.maxLength && (t = t.pipe(n.maxLength(e.maxLength)).annotations({
-        message: () => i("validation.string.maxLength", {
-          maxLength: e.maxLength
-        })
-      })), e.minLength && (t = t.pipe(n.minLength(e.minLength)).annotations({
-        message: () => i("validation.string.minLength", {
-          minLength: e.minLength
-        })
-      }));
-      break;
-    case "number":
-      t = n.Number.annotations({
-        message: () => i("validation.empty")
-      }), e.required && t.annotations({
-        message: () => i("validation.empty")
-      }), e.minimum && (t = t.pipe(n.greaterThanOrEqualTo(e.minimum)).annotations({
-        message: () => i("validation.number.min", {
-          minimum: e.minimum,
-          isExclusive: !0
-        })
-      })), e.maximum && (t = t.pipe(n.lessThanOrEqualTo(e.maximum)).annotations({
-        message: () => i("validation.number.max", {
-          maximum: e.maximum,
-          isExclusive: !0
-        })
-      })), e.exclusiveMinimum && (t = t.pipe(n.greaterThan(e.exclusiveMinimum)).annotations({
-        message: () => i("validation.number.min", {
-          minimum: e.exclusiveMinimum,
-          isExclusive: !1
-        })
-      })), e.exclusiveMaximum && (t = t.pipe(n.lessThan(e.exclusiveMaximum)).annotations({
-        message: () => i("validation.number.max", {
-          maximum: e.exclusiveMaximum,
-          isExclusive: !1
-        })
-      }));
-      break;
-    case "select":
-      t = n.Literal(...e.members).annotations({
-        message: () => ({
-          message: i("validation.not_a_valid", {
-            type: "select",
-            message: e.members.join(", ")
-          }),
-          override: !0
-        })
-      });
-      break;
-    case "multiple":
-      t = n.Array(n.String).annotations({
-        message: () => i("validation.not_a_valid", {
-          type: "multiple",
-          message: e.members.join(", ")
-        })
-      });
-      break;
-    case "boolean":
-      t = n.Boolean;
-      break;
-    // todo: switch must be exhaustive or have default case, otherwise falls through with schema undefined.
-    case "unknown":
-      t = n.Unknown;
-      break;
-  }
-  return e.required ? t.pipe(
-    n.annotations({
-      message: () => i("validation.empty")
-    })
-  ) : t = n.NullishOr(t), n.standardSchemaV1(t);
-}, P = (e, i) => n.NullOr(e).pipe(
-  n.transform(n.typeSchema(e), {
-    decode: (t) => t ?? i(),
-    encode: (t) => t
-  })
-);
+import { isFunction as c } from "./vue-components.es18.js";
+const s = c, t = (o) => typeof o == "object" && o !== null, i = (o) => t(o) || s(o);
 export {
-  m as createMeta,
-  w as duplicateSchema,
-  K as generateInputStandardSchemaFromFieldMeta,
-  $ as generateMetaFromSchema,
-  P as nullableInput
+  s as isFunction,
+  i as isObject,
+  t as isRecordOrArray
 };