@effect-app/vue-components 4.0.0-beta.26 → 4.0.0-beta.261

package/src/components/OmegaForm/OmegaInput.vue

@@ -1,19 +1,21 @@
 <template>
   <component
     :is="form.Field"
-    :key="fieldKey"
     :name="name"
-    :validators="{
-      onChange: schema,
-      ...validators
-    }"
+    :validators="validators"
   >
-    <template #default="{ field, state }">
+    <!--
+      Read `state` from `field.state`, not the Field slot's `state` prop.
+      Since @tanstack/vue-form 1.32 the slot `state` is a one-time snapshot
+      taken when the field mounts and never updates, whereas `field.state`
+      is a reactive getter backed by the field store.
+    -->
+    <template #default="{ field }">
       <OmegaInternalInput
         v-if="meta"
         v-bind="{ ...$attrs, ...$props, inputClass: computedClass }"
-        :field="field"
-        :state="state"
+        :field="field as any"
+        :state="field.state"
         :register="form.registerField"
         :label="label ?? errori18n(propsName)"
         :meta="meta"
@@ -40,12 +42,13 @@
   lang="ts"
   generic="From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>"
 >
+/* eslint-disable @typescript-eslint/no-explicit-any -- TanStack Form Field generic interop and slot prop typing */
 import { type DeepKeys } from "@tanstack/vue-form"
 import { computed, inject, type Ref, useAttrs } from "vue"
-import { useIntl } from "../../utils"
-import { type FieldMeta, generateInputStandardSchemaFromFieldMeta, type OmegaInputPropsBase } from "./OmegaFormStuff"
+import { useErrorLabel } from "./errors"
+import { type FieldMeta } from "./meta/types"
 import OmegaInternalInput from "./OmegaInternalInput.vue"
-import { useErrorLabel } from "./useOmegaForm"
+import { type OmegaInputPropsBase } from "./types"
 
 const props = defineProps<OmegaInputPropsBase<From, To, Name>>()
 
@@ -57,13 +60,10 @@ defineSlots<{
   default?: (props: any) => any
 }>()
 
-defineOptions({
-  inheritAttrs: false
-})
+defineOptions({ inheritAttrs: false })
 
 const attrs = useAttrs()
 
-// Compute the class to use based on inputClass prop
 const computedClass = computed(() => {
   if (props.inputClass === null) return undefined
   if (props.inputClass !== undefined) return props.inputClass
@@ -82,28 +82,5 @@ const meta = computed(() => {
   return props.form.meta[propsName.value]
 })
 
-// Key to force Field re-mount when meta type changes (for TaggedUnion support)
-const fieldKey = computed(() => {
-  const m = meta.value
-  if (!m) return propsName.value
-  // Include type and key constraints in the key so Field re-mounts when validation rules change
-  // Cast to any since not all FieldMeta variants have these properties
-  const fm = m as any
-  return `${propsName.value}-${fm.type}-${fm.minLength ?? ""}-${fm.maxLength ?? ""}-${fm.minimum ?? ""}-${
-    fm.maximum ?? ""
-  }`
-})
-
-// Call useIntl during setup to avoid issues when computed re-evaluates
-const { trans } = useIntl()
-
-const schema = computed(() => {
-  if (!meta.value) {
-    console.log(props.name, Object.keys(props.form.meta), props.form.meta)
-    throw new Error("Meta is undefined")
-  }
-  return generateInputStandardSchemaFromFieldMeta(meta.value, trans)
-})
-
 const errori18n = useErrorLabel(props.form)
 </script>

package/src/components/OmegaForm/OmegaInputVuetify.vue

@@ -1,7 +1,10 @@
 <template>
   <div
     class="omega-input"
-    @focusout="$emit('blur', $event)"
+    @focusout="(e) => {
+      $emit('blur', e)
+      field.handleBlur()
+    }"
     @focusin="$emit('focus', $event)"
   >
     <component
@@ -204,8 +207,8 @@
   generic="From extends Record<PropertyKey, any>, Name extends DeepKeys<From>"
 >
 import { type DeepKeys } from "@tanstack/vue-form"
-import { getInputType } from "../OmegaForm/OmegaFormStuff"
 import type { VuetifyInputProps } from "./InputProps"
+import { getInputType } from "./inputs"
 
 defineProps<VuetifyInputProps<From, Name>>()
 

package/src/components/OmegaForm/OmegaInternalInput.vue

@@ -24,11 +24,13 @@
   lang="ts"
   generic="From extends Record<PropertyKey, any>, Name extends DeepKeys<From>"
 >
+/* eslint-disable @typescript-eslint/no-explicit-any -- TanStack Form / Vue attrs interop */
 import { type DeepKeys, useStore } from "@tanstack/vue-form"
 import { computed, type ComputedRef, getCurrentInstance, useAttrs, useId, useSlots } from "vue"
 import type { InputProps, OmegaFieldInternalApi } from "./InputProps"
-import type { FieldValidators, MetaRecord, NestedKeyOf, TypeOverride } from "./OmegaFormStuff"
+import type { MetaRecord, NestedKeyOf } from "./meta/types"
 import OmegaInputVuetify from "./OmegaInputVuetify.vue"
+import type { FieldValidators, TypeOverride } from "./types"
 
 defineOptions({
   inheritAttrs: false
@@ -84,7 +86,8 @@ const id = useId()
 
 const fieldApi = props.field
 
-const fieldState = useStore(fieldApi.store, (state) => state)
+// Subscribed for side-effect: keeps component reactive to fieldApi.store changes
+const _fieldState = useStore(fieldApi.store, (state) => state)
 
 // Get errors from form-level fieldMeta (persists across Field re-mounts)
 const formFieldMeta = useStore(fieldApi.form.store, (state) => state.fieldMeta)
@@ -128,6 +131,13 @@ const handleChange: OmegaFieldInternalApi<From, Name>["handleChange"] = (value)
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
           : null as any
       )
+    } else if (props.meta?.isOptionalKey) {
+      // `S.optionalKey` expects the key to be ABSENT from the submitted
+      // object, not present-with-undefined. Remove it from form state
+      // rather than setting it to `undefined`. Note: this is distinct
+      // from `required: false`, which may also just mean "empty string
+      // is valid" for unconstrained `S.String` fields.
+      props.field.form.deleteField(props.field.name)
     } else {
       // Keep the actual value (e.g., empty string for S.String fields)
       props.field.handleChange(value)
@@ -136,9 +146,11 @@ const handleChange: OmegaFieldInternalApi<From, Name>["handleChange"] = (value)
     props.field.handleChange(value)
   }
 
-  // whenever we change the field, regardless if we set it to null, we should reset onSubmit.
-  // not sure why this is not the case in tanstack form.
-  props.field.setMeta((m) => ({ ...m, errorMap: { ...m.errorMap, onSubmit: undefined } }))
+  // A change here may have materialised a nullable struct (this field is one
+  // of its children); backfill the untouched siblings so the live `values`
+  // matches what validation and decoding see.
+  const form = props.field.form as { normalizeNullableStructs?: () => void }
+  form.normalizeNullableStructs?.()
 }
 
 // Note: Default value normalization (converting empty strings to null/undefined for nullable fields)

package/src/components/OmegaForm/OmegaTaggedUnion.vue

@@ -8,8 +8,8 @@
 import { type DeepKeys } from "@tanstack/vue-form"
 import { computed, provide, ref, watch } from "vue"
 import { type TaggedUnionOption } from "./InputProps"
-import { type FieldPath } from "./OmegaFormStuff"
 import OmegaTaggedUnionInternal from "./OmegaTaggedUnionInternal.vue"
+import { type FieldPath } from "./types"
 import { type useOmegaForm } from "./useOmegaForm"
 
 const props = defineProps<{
@@ -30,6 +30,7 @@ watch(
   () => {
     const path = tagPath.value
     // Navigate to the nested value
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- traversing arbitrary nested values
     return path.split(".").reduce((acc: any, key) => acc?.[key], formValues.value) as string | null
   },
   (newTag) => {
@@ -74,9 +75,15 @@ provide("getMetaFromArray", getMetaFromArray)
         />
       </slot>
       <slot />
+      <!--
+        Drive the branch off `currentTag`: the tag is read from the form store
+        (the canonical state), the same single source of truth that feeds
+        `getMetaFromArray` above — rather than the `Field` slot's `state`,
+        which is only a projection of it.
+      -->
       <OmegaTaggedUnionInternal
         :field="inputProps.field as any"
-        :state="inputProps.state.value"
+        :tag="currentTag"
         :name="name"
         :form="form"
       >
@@ -91,7 +98,7 @@ provide("getMetaFromArray", getMetaFromArray)
         </template>
       </OmegaTaggedUnionInternal>
       <slot
-        v-if="inputProps.state.value"
+        v-if="currentTag"
         name="OmegaCommon"
       />
     </template>

package/src/components/OmegaForm/OmegaTaggedUnionInternal.vue

@@ -1,8 +1,8 @@
 <template>
   <slot
-    v-if="state"
-    :name="`${name ? `${name}.` : ''}${state}`"
-    v-bind="{ field, state }"
+    v-if="tag"
+    :name="`${name ? `${name}.` : ''}${tag}`"
+    v-bind="{ field, tag }"
   />
 </template>
 
@@ -17,7 +17,7 @@ import { type OmegaFieldInternalApi } from "./InputProps"
 import { type useOmegaForm } from "./useOmegaForm"
 
 const props = defineProps<{
-  state: DeepValue<From, Name>
+  tag: string | null
   field: OmegaFieldInternalApi<From, Name>
   name?: DeepKeys<From>
   form: ReturnType<typeof useOmegaForm<From, To>>
@@ -26,7 +26,7 @@ const props = defineProps<{
 const values = props.form.useStore(({ values }) => values)
 
 // Watch for _tag changes
-watch(() => props.state, (newTag, oldTag) => {
+watch(() => props.tag, (newTag, oldTag) => {
   if (newTag === null) {
     props.field.setValue(null as DeepValue<From, Name>)
   }
@@ -34,7 +34,7 @@ watch(() => props.state, (newTag, oldTag) => {
   if (newTag !== oldTag) {
     props.form.reset(values.value)
     setTimeout(() => {
-      props.field.validate("change")
+      void props.field.validate("change")
     }, 0)
   }
 }, { immediate: true })

package/src/components/OmegaForm/OmegaWrapper.vue

@@ -30,7 +30,7 @@
 import { useStore } from "@tanstack/vue-form"
 import { usePreventClose } from "./blockDialog"
 import { getOmegaStore } from "./getOmegaStore"
-import { type DefaultTypeProps, type OmegaFormApi, type OmegaFormState } from "./OmegaFormStuff"
+import { type DefaultTypeProps, type OmegaFormApi, type OmegaFormState } from "./types"
 import { type OmegaFormReturn } from "./useOmegaForm"
 
 type OmegaWrapperProps = {

package/src/components/OmegaForm/blockDialog.ts

@@ -1,5 +1,6 @@
 import mitt from "mitt"
 import { inject, type InjectionKey, provide, type Ref } from "vue"
+import { useIntl } from "../../utils"
 import { onMountedWithCleanup } from "./onMountedWithCleanup"
 
 export type DialogClosing = { prevent?: boolean | Promise<boolean> }
@@ -19,11 +20,19 @@ export const usePreventClose = (mkIsDirty: () => Ref<boolean>) => {
   if (!bus) {
     return
   }
+  const { formatMessage, trans } = useIntl()
   const isDirty = mkIsDirty()
+  const defaultMessage = "There are unsaved changes. Are you sure you want to close?"
   onMountedWithCleanup(() => {
     const onDialogClosing = (evt: DialogClosing) => {
       if (isDirty.value) {
-        if (!confirm("Es sind ungespeicherte Änderungen vorhanden. Wirklich schließen?")) {
+        // Mirror the guard pattern in errors.ts: a custom `useIntl` mock may
+        // only provide `trans`, so fall back through trans → defaultMessage.
+        const message = formatMessage
+          ? formatMessage({ id: "form.unsaved_changes_confirm", defaultMessage })
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any -- key may not be registered in the locale catalog
+          : trans?.("form.unsaved_changes_confirm" as any) ?? defaultMessage
+        if (!confirm(message)) {
           evt.prevent = true
         }
       }
@@ -46,11 +55,14 @@ export const useOnClose = (close: () => void) => {
     bus.emit("dialog-closing", evt)
     if (evt.prevent) {
       if (typeof evt.prevent === "object" && "then" in evt.prevent) {
-        evt.prevent.then((r) => {
-          if (r !== false) {
-            close()
-          }
-        })
+        evt
+          .prevent
+          .then((r) => {
+            if (r) {
+              close()
+            }
+          })
+          .catch(console.error)
       }
     } else {
       close()

package/src/components/OmegaForm/createUseFormWithCustomInput.ts

@@ -1,8 +1,9 @@
+/* eslint-disable @typescript-eslint/no-explicit-any -- TanStack Form / Vue render-fn slot interop */
 import type { DeepKeys } from "@tanstack/vue-form"
 import { type Component, h } from "vue"
 import type { MergedInputProps } from "./InputProps"
-import { type DefaultTypeProps } from "./OmegaFormStuff"
 import OmegaInput from "./OmegaInput.vue"
+import { type DefaultTypeProps } from "./types"
 import { useOmegaForm } from "./useOmegaForm"
 
 export const createUseFormWithCustomInput = <

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,5 +1,17 @@
-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 { default as OmegaInput } from "./OmegaInput.vue"
@@ -9,6 +21,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
+}