@effect-app/vue-components 4.0.0-beta.29 → 4.0.0-beta.290

package/src/components/OmegaForm/errors.ts

@@ -0,0 +1,136 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { type Component, computed, type ComputedRef, type ConcreteComponent, h, onUnmounted, type Ref, ref, watch } from "vue"
+import { useIntl } from "../../utils"
+import type { OmegaError } from "./types"
+import type { OF } from "./useOmegaForm"
+
+export const useErrorLabel = (form: OF<any, any>) => {
+  const { formatMessage } = useIntl()
+  const humanize = (str: string) => {
+    return str
+      .replace(/([A-Z])/g, " $1") // Add space before capital letters
+      .replace(/^./, (char) => char.toUpperCase()) // Capitalize the first letter
+      .trim() // Remove leading/trailing spaces
+  }
+  const fallback = (propsName: string) =>
+    formatMessage
+      ? formatMessage({ id: `general.fields.${propsName}`, defaultMessage: humanize(propsName) })
+      : humanize(propsName)
+  const i18n = (propsName: string) =>
+    form.i18nNamespace
+      ? formatMessage({ id: `${form.i18nNamespace}.fields.${propsName}`, defaultMessage: fallback(propsName) })
+      : fallback(propsName)
+
+  return i18n
+}
+
+export const eHoc = (errorProps: {
+  form: OF<any, any>
+  fieldMap: Ref<Map<string, { id: string; label: string }>>
+}) => {
+  return function FormHoc<P>(
+    WrappedComponent: Component<P>
+  ): ConcreteComponent<P> {
+    return {
+      setup() {
+        const { fieldMap, form } = errorProps
+        const generalErrors = form.useStore((state) => state.errors)
+        const fieldMeta = form.useStore((state) => state.fieldMeta)
+        const errorMap = form.useStore((state) => state.errorMap)
+
+        const errorLabel = useErrorLabel(form)
+
+        const errors = computed(() => {
+          // Collect errors from fieldMeta (field-level errors for registered fields)
+          const fieldErrors = Object.entries(fieldMeta.value).reduce<OmegaError[]>((acc, [key, m]) => {
+            const fieldErrors = (m as { errors?: Array<{ message?: string }> } | undefined)?.errors ?? []
+            if (!fieldErrors.length) {
+              return acc
+            }
+
+            const fieldInfo = fieldMap.value.get(key)
+            if (!fieldInfo) {
+              return acc
+            }
+
+            acc.push({
+              label: fieldInfo.label,
+              inputId: fieldInfo.id,
+              errors: [fieldErrors[0]?.message].filter(Boolean) as string[]
+            })
+
+            return acc
+          }, [])
+
+          // Collect errors from errorMap.onDynamic / errorMap.onSubmit ONLY for fields that are NOT registered
+          // (registered fields already have their errors in fieldMeta).
+          // Our localized standard schema writes to onDynamic via validationLogic: revalidateLogic();
+          // caller-provided validators.onSubmit (via tanstackFormOptions spread) writes to onSubmit.
+          const submitErrors: OmegaError[] = []
+          const submitIssueMaps = [errorMap.value.onDynamic, errorMap.value.onSubmit].filter(
+            Boolean
+          ) as unknown as Array<
+            Record<string, unknown>
+          >
+          const seenPaths = new Set<string>()
+          for (const issuesByPath of submitIssueMaps) {
+            for (const [_, issues] of Object.entries(issuesByPath)) {
+              if (Array.isArray(issues) && issues.length) {
+                for (const issue of issues) {
+                  const issAny: any = issue
+                  if (issAny?.path && Array.isArray(issAny.path) && issAny.path.length) {
+                    const fieldPath = issAny.path.join(".")
+                    if (!fieldMap.value.has(fieldPath) && !seenPaths.has(fieldPath)) {
+                      seenPaths.add(fieldPath)
+                      submitErrors.push({
+                        label: errorLabel(fieldPath),
+                        inputId: fieldPath,
+                        errors: [issAny.message].filter(Boolean)
+                      })
+                      break
+                    }
+                  }
+                }
+              }
+            }
+          }
+
+          // Combine both error sources (no need to check for duplicates since they're mutually exclusive)
+          return [...fieldErrors, ...submitErrors]
+        })
+
+        return {
+          generalErrors,
+          errors
+        }
+      },
+      render({ errors, generalErrors }: any) {
+        return h(WrappedComponent, {
+          errors,
+          generalErrors,
+          ...this.$attrs
+        }, this.$slots)
+      }
+    }
+  }
+}
+
+export const makeFieldMap = () => {
+  const fieldMap = ref(new Map<string, { label: string; id: string }>())
+  const registerField = (field: ComputedRef<{ name: string; label: string; id: string }>) => {
+    watch(field, (f) => {
+      fieldMap.value.set(f.name, { label: f.label, id: f.id })
+    }, { immediate: true })
+    onUnmounted(() => {
+      // Only delete if we still own this entry (id matches)
+      // This prevents old components from deleting entries registered by new components
+      // during re-mount transitions (e.g., when :key changes)
+      const currentEntry = fieldMap.value.get(field.value.name)
+      if (currentEntry?.id === field.value.id) {
+        fieldMap.value.delete(field.value.name)
+      }
+    })
+  }
+  return { fieldMap, registerField }
+}

package/src/components/OmegaForm/getOmegaStore.ts

@@ -1,6 +1,6 @@
 import { useStore } from "@tanstack/vue-form"
 import { computed, type Ref } from "vue"
-import type { OmegaFormApi, OmegaFormState } from "./OmegaFormStuff"
+import type { OmegaFormApi, OmegaFormState } from "./types"
 
 export function getOmegaStore<
   To,

package/src/components/OmegaForm/hocs.ts

@@ -0,0 +1,19 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { type Component, type ConcreteComponent, h } from "vue"
+import type { OF } from "./useOmegaForm"
+
+export const fHoc = (form: OF<any, any>) => {
+  return function FormHoc<P>(
+    WrappedComponent: Component<P>
+  ): ConcreteComponent<P> {
+    return {
+      render() {
+        return h(WrappedComponent, {
+          form,
+          ...this.$attrs
+        }, this.$slots)
+      }
+    }
+  }
+}

package/src/components/OmegaForm/index.ts

@@ -1,7 +1,20 @@
-export * from "./OmegaFormStuff"
-export { type OmegaConfig, type OmegaFormReturn, useOmegaForm } from "./useOmegaForm"
+import type * as S from "effect-app/Schema"
+
+export { getInputType, type SupportedInputs } from "./inputs"
+export { createMeta, generateMetaFromSchema, isNullableOrUndefined, metadataFromAst } from "./meta/createMeta"
+export type { CreateMeta, FilterItems } from "./meta/createMeta"
+export { defaultsValueFromSchema } from "./meta/defaults"
+export { toFormSchema } from "./meta/redacted"
+export type { BaseFieldMeta, BooleanFieldMeta, DateFieldMeta, FieldMeta, MetaRecord, MultipleFieldMeta, NestedKeyOf, NumberFieldMeta, SelectFieldMeta, StringFieldMeta, UnknownFieldMeta } from "./meta/types"
+export { deepMerge } from "./persistency"
+export type { BaseProps, DefaultTypeProps, FieldPath, FieldPath_, FieldValidators, FormComponent, FormProps, FormType, OmegaArrayProps, OmegaAutoGenMeta, OmegaError, OmegaFormApi, OmegaFormParams, OmegaFormState, OmegaInputProps, OmegaInputPropsBase, PrefixFromDepth, TypeOverride, TypesWithOptions } from "./types"
+export { makeStandardSchemaV1Hooks, toLocalizedStandardSchemaV1 } from "./validation/localized"
+
+export { FormErrors, OmegaFormKey, useErrorLabel, useOmegaForm } from "./useOmegaForm"
+export type { defaultValuesPriorityUnion, OF, OmegaConfig, OmegaFormReturn, Policies } from "./useOmegaForm"
 
 export { type ExtractTagValue, type ExtractUnionBranch, type InputProps, type MergedInputProps, type TaggedUnionOption, type TaggedUnionOptionsArray, type TaggedUnionProps } from "./InputProps"
+export type { VuetifyInputProps, VuetifyInputProps as OmegaRendererProps } from "./InputProps"
 export { default as OmegaInput } from "./OmegaInput.vue"
 export { default as OmegaVuetifyInput } from "./OmegaInternalInput.vue"
 export { default as OmegaTaggedUnion } from "./OmegaTaggedUnion.vue"
@@ -9,6 +22,6 @@ export { default as OmegaTaggedUnionInternal } from "./OmegaTaggedUnionInternal.
 
 export { useOnClose, usePreventClose } from "./blockDialog"
 
-export { getInputType } from "./OmegaFormStuff"
-
 export { createUseFormWithCustomInput } from "./createUseFormWithCustomInput"
+
+export const duplicateSchema = <From, To>(schema: S.Codec<To, From>) => schema

package/src/components/OmegaForm/inputs.ts

@@ -0,0 +1,22 @@
+const supportedInputs = [
+  "button",
+  "checkbox",
+  "color",
+  "date",
+  "email",
+  "number",
+  "password",
+  "radio",
+  "range",
+  "search",
+  "submit",
+  "tel",
+  "text",
+  "time",
+  "url"
+] as const
+
+export type SupportedInputs = typeof supportedInputs[number]
+
+export const getInputType = (input: string): SupportedInputs =>
+  (supportedInputs as readonly string[]).includes(input) ? input as SupportedInputs : "text"

package/src/components/OmegaForm/meta/checks.ts

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as S from "effect-app/Schema"
+import type * as Record from "effect/Record"
+import type { FieldMeta } from "./types"
+
+export const getCheckMetas = (property: S.AST.AST): Array<Record<string, any>> => {
+  const checks = property.checks ?? []
+
+  return checks.flatMap((check) => {
+    if (check._tag === "FilterGroup") {
+      return check.checks.flatMap((inner) => {
+        const meta = inner.annotations?.meta
+        return meta && typeof meta === "object" ? [meta as Record<string, any>] : []
+      })
+    }
+
+    const meta = check.annotations?.meta
+    return meta && typeof meta === "object" ? [meta as Record<string, any>] : []
+  })
+}
+
+export const getFieldMetadataFromAst = (property: S.AST.AST) => {
+  const base: Partial<FieldMeta> & Record<string, unknown> = {
+    description: S.AST.resolveDescription(property)
+  }
+  const checks = getCheckMetas(property)
+
+  if (S.AST.isString(property)) {
+    base.type = "string"
+    for (const check of checks) {
+      switch (check._tag) {
+        case "isMinLength":
+          base.minLength = check.minLength
+          break
+        case "isMaxLength":
+          base.maxLength = check.maxLength
+          break
+      }
+    }
+
+    const format = property.annotations?.["format"]
+    if (format === "email") {
+      base.format = "email"
+    }
+  } else if (S.AST.isNumber(property)) {
+    base.type = "number"
+    for (const check of checks) {
+      switch (check._tag) {
+        case "isInt":
+          base.refinement = "int"
+          break
+        case "isGreaterThanOrEqualTo":
+          base.minimum = check.minimum
+          break
+        case "isLessThanOrEqualTo":
+          base.maximum = check.maximum
+          break
+        case "isBetween":
+          base.minimum = check.minimum
+          base.maximum = check.maximum
+          break
+        case "isGreaterThan":
+          base.exclusiveMinimum = check.exclusiveMinimum
+          break
+        case "isLessThan":
+          base.exclusiveMaximum = check.exclusiveMaximum
+          break
+      }
+    }
+  } else if (S.AST.isBoolean(property)) {
+    base.type = "boolean"
+  } else if (
+    S.AST.isDeclaration(property)
+    && (property.annotations as any)?.typeConstructor?._tag === "Date"
+  ) {
+    base.type = "date"
+  } else {
+    base.type = "unknown"
+  }
+
+  return base
+}

package/src/components/OmegaForm/meta/createMeta.ts

@@ -0,0 +1,140 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type * as Effect from "effect-app/Effect"
+import * as S from "effect-app/Schema"
+import type * as Record from "effect/Record"
+import { getTransformationFrom } from "../../../utils"
+import type { FieldMeta, MetaRecord } from "./types"
+import { classifyAndWalkUnion, leafMetaForAst, type ParentMeta, type WalkerContext, walkStruct } from "./walker"
+
+export type FilterItems = {
+  items: readonly [string, ...string[]]
+  message:
+    | string
+    | Effect.Effect<string>
+    | { readonly message: string | Effect.Effect<string> }
+}
+
+export type CreateMeta =
+  & {
+    parent?: string
+    meta?: Record<string, any>
+    nullableOrUndefined?: false | "undefined" | "null"
+  }
+  & (
+    | {
+      propertySignatures: readonly S.AST.PropertySignature[]
+      property?: never
+    }
+    | {
+      propertySignatures?: never
+      property: S.AST.AST
+    }
+  )
+
+export const unwrapDeclaration = (property: S.AST.AST): S.AST.AST => {
+  let current = getTransformationFrom(property)
+
+  while (S.AST.isDeclaration(current) && current.typeParameters.length > 0) {
+    current = getTransformationFrom(current.typeParameters[0])
+  }
+
+  return current
+}
+
+export const isNullableOrUndefined = (property: false | S.AST.AST | undefined) => {
+  if (!property || !S.AST.isUnion(property)) return false
+  if (property.types.find((_) => S.AST.isUndefined(_))) {
+    return "undefined"
+  }
+  if (property.types.find((_) => S.AST.isNull(_))) return "null"
+  return false
+}
+
+export const createMeta = <T = any>(
+  { meta = {}, parent = "", property, propertySignatures }: CreateMeta,
+  acc: Partial<MetaRecord<T>> = {}
+): MetaRecord<T> | FieldMeta => {
+  const ctx: WalkerContext<T> = { acc, unionMeta: {} }
+
+  if (propertySignatures) {
+    const parentMeta: ParentMeta = {
+      required: meta.required !== false,
+      nullableOrUndefined: meta.nullableOrUndefined ?? false
+    }
+    walkStruct(propertySignatures, parent, parentMeta, ctx)
+    return acc
+  }
+
+  if (property) {
+    const nullableOrUndefined = isNullableOrUndefined(property)
+    const unwrapped = unwrapDeclaration(property)
+    const required = !Object.hasOwnProperty.call(meta, "required")
+      ? !nullableOrUndefined
+      : (meta.required as boolean)
+
+    const parentMeta: ParentMeta = {
+      required,
+      nullableOrUndefined: (meta.nullableOrUndefined ?? nullableOrUndefined) as false | "null" | "undefined"
+    }
+
+    if (S.AST.isObjects(unwrapped)) {
+      walkStruct(unwrapped.propertySignatures, parent, parentMeta, ctx)
+      return acc
+    }
+
+    if (S.AST.isUnion(unwrapped)) {
+      // For property-mode, return a FieldMeta by running through classifyAndWalkUnion
+      // and then pulling out the result at `parent` key
+      const leafCtx: WalkerContext<T> = { acc: {}, unionMeta: {} }
+      classifyAndWalkUnion(unwrapped, parent, parentMeta, leafCtx)
+      const result = (leafCtx.acc as any)[parent]
+      if (result) return result as FieldMeta
+    }
+
+    return leafMetaForAst(unwrapped, parentMeta)
+  }
+
+  return acc
+}
+
+export const metadataFromAst = <From, To>(
+  schema: S.Codec<To, From>
+): {
+  meta: MetaRecord<To>
+  defaultValues: Record<string, any>
+  unionMeta: Record<string, MetaRecord<To>>
+} => {
+  const ast = unwrapDeclaration(schema.ast)
+  const newMeta: Partial<MetaRecord<To>> = {}
+  const defaultValues: Record<string, any> = {}
+  const unionMeta: Record<string, MetaRecord<To>> = {}
+
+  const ctx: WalkerContext<To> = { acc: newMeta, unionMeta }
+
+  if (S.AST.isUnion(ast)) {
+    // Root-level discriminated union
+    classifyAndWalkUnion(ast, "", { required: true, nullableOrUndefined: false }, ctx)
+
+    return { meta: newMeta as MetaRecord<To>, defaultValues, unionMeta }
+  }
+
+  if (S.AST.isObjects(ast)) {
+    walkStruct(ast.propertySignatures, "", { required: true, nullableOrUndefined: false }, ctx)
+
+    return { meta: newMeta as MetaRecord<To>, defaultValues, unionMeta }
+  }
+
+  return { meta: newMeta as MetaRecord<To>, defaultValues, unionMeta }
+}
+
+export const generateMetaFromSchema = <From, To>(
+  schema: S.Codec<To, From>
+): {
+  schema: S.Codec<To, From>
+  meta: MetaRecord<To>
+  unionMeta: Record<string, MetaRecord<To>>
+} => {
+  const { meta, unionMeta } = metadataFromAst(schema)
+
+  return { schema, meta, unionMeta }
+}