@effect-app/vue-components 4.0.0-beta.23 → 4.0.0-beta.231

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
+}

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 }
+}

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

@@ -0,0 +1,134 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import * as Effect from "effect-app/Effect"
+import * as Option from "effect-app/Option"
+import * as S from "effect-app/Schema"
+import { isNullableOrUndefined, unwrapDeclaration } from "./createMeta"
+
+const extractDefaultFromLink = (link: any): unknown | undefined => {
+  if (!link?.transformation?.decode?.run) return undefined
+  try {
+    const result = Effect.runSync(link.transformation.decode.run(Option.none())) as Option.Option<unknown>
+    return Option.isSome(result) ? result.value : undefined
+  } catch {
+    return undefined
+  }
+}
+
+const getDefaultFromAst = (property: S.AST.AST) => {
+  // 1. Check withConstructorDefault (stored in context.defaultValue)
+  const constructorLink = property.context?.defaultValue?.[0]
+  const constructorDefault = extractDefaultFromLink(constructorLink)
+  if (constructorDefault !== undefined) return constructorDefault
+
+  // 2. Check withDecodingDefault (stored in encoding)
+  const encodingLink = property.encoding?.[0]
+  if (encodingLink && property.context?.isOptional) {
+    return extractDefaultFromLink(encodingLink)
+  }
+
+  return undefined
+}
+
+type SchemaWithMembers = {
+  members: readonly S.Schema<any>[]
+}
+
+function hasMembers(schema: any): schema is SchemaWithMembers {
+  return schema && "members" in schema && Array.isArray(schema.members)
+}
+
+// Internal implementation with WeakSet tracking
+export const defaultsValueFromSchema = (
+  schema: S.Schema<any>,
+  record: Record<string, any> = {}
+): any => {
+  const ast = schema.ast
+  const defaultValue = getDefaultFromAst(ast)
+
+  if (defaultValue !== undefined) {
+    return defaultValue
+  }
+
+  if (isNullableOrUndefined(schema.ast) === "null") {
+    return null
+  }
+  if (isNullableOrUndefined(schema.ast) === "undefined") {
+    return undefined
+  }
+
+  // Handle structs via AST (covers plain structs, transformed schemas like decodeTo, Class, etc.)
+  const objectsAst = S.AST.isObjects(ast)
+    ? ast
+    : S.AST.isDeclaration(ast)
+    ? unwrapDeclaration(ast)
+    : undefined
+  if (objectsAst && S.AST.isObjects(objectsAst)) {
+    const result: Record<string, any> = {}
+
+    for (const prop of objectsAst.propertySignatures) {
+      const key = prop.name.toString()
+      const propType = prop.type
+
+      const propDefault = getDefaultFromAst(propType)
+      if (propDefault !== undefined) {
+        result[key] = propDefault
+        continue
+      }
+
+      const propSchema = S.make(propType)
+      const propValue = defaultsValueFromSchema(propSchema, record[key] || {})
+
+      if (propValue !== undefined) {
+        result[key] = propValue
+      } else if (isNullableOrUndefined(propType) === "undefined") {
+        result[key] = undefined
+      }
+    }
+
+    return { ...result, ...record }
+  }
+
+  // Handle unions via AST or schema-level .members
+  const unionTypes = S.AST.isUnion(ast)
+    ? ast.types
+    : hasMembers(schema)
+    ? schema.members.map((m) => m.ast)
+    : undefined
+  if (unionTypes) {
+    const mergedFields: Record<string, { ast: S.AST.AST }> = {}
+
+    for (const memberAstRaw of unionTypes) {
+      const memberAst = unwrapDeclaration(memberAstRaw)
+      if (!S.AST.isObjects(memberAst)) continue
+
+      for (const prop of memberAst.propertySignatures) {
+        const key = prop.name.toString()
+        const fieldDefault = getDefaultFromAst(prop.type)
+        const existingDefault = mergedFields[key] ? getDefaultFromAst(mergedFields[key].ast) : undefined
+
+        if (!mergedFields[key] || (fieldDefault !== undefined && existingDefault === undefined)) {
+          mergedFields[key] = { ast: prop.type }
+        }
+      }
+    }
+
+    if (Object.keys(mergedFields).length === 0) {
+      return Object.keys(record).length > 0 ? record : undefined
+    }
+
+    return Object.entries(mergedFields).reduce((acc, [key, { ast: propAst }]) => {
+      acc[key] = defaultsValueFromSchema(S.make(propAst), record[key] || {})
+      return acc
+    }, record)
+  }
+
+  if (Object.keys(record).length === 0) {
+    if (S.AST.isString(ast)) {
+      return ""
+    }
+
+    if (S.AST.isBoolean(ast)) {
+      return false
+    }
+  }
+}

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

@@ -0,0 +1,66 @@
+import * as S from "effect-app/Schema"
+
+/*
+ * Checks if an AST node is a S.Redacted Declaration without encoding.
+ * These need to be swapped to S.RedactedFromValue for form usage
+ * because S.Redacted expects Redacted objects, not plain strings.
+ */
+const isRedactedWithoutEncoding = (ast: S.AST.AST): boolean =>
+  S.AST.isDeclaration(ast)
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Effect Schema AST annotations are loosely typed
+  && (ast.annotations as any)?.typeConstructor?._tag === "effect/Redacted"
+  && !ast.encoding
+
+/*
+ * Creates a form-compatible schema by replacing S.Redacted(X) with
+ * S.RedactedFromValue(X). S.Redacted is a Declaration that expects
+ * Redacted<A> on both encoded and type sides, so form inputs (which
+ * produce plain strings) fail validation. S.RedactedFromValue accepts
+ * plain values on the encoded side and wraps them in Redacted on decode.
+ */
+export const toFormSchema = <From, To>(
+  schema: S.Codec<To, From>
+): S.Codec<To, From> => {
+  const ast = schema.ast
+  const objAst = S.AST.isObjects(ast)
+    ? ast
+    : S.AST.isDeclaration(ast)
+    ? S.AST.toEncoded(ast)
+    : null
+
+  if (!objAst || !("propertySignatures" in objAst)) return schema
+
+  let hasRedacted = false
+  const props: Record<string, S.Struct.Fields[string]> = {}
+
+  for (const p of objAst.propertySignatures) {
+    if (isRedactedWithoutEncoding(p.type)) {
+      hasRedacted = true
+      const innerSchema = S.make((p.type as S.AST.Declaration).typeParameters[0])
+      props[p.name as string] = S.RedactedFromValue(innerSchema)
+    } else if (S.AST.isUnion(p.type)) {
+      const types = p.type.types
+      const redactedType = types.find(isRedactedWithoutEncoding)
+      if (redactedType) {
+        hasRedacted = true
+        const innerSchema = S.make((redactedType as S.AST.Declaration).typeParameters[0])
+        const hasNull = types.some(S.AST.isNull)
+        const hasUndefined = types.some(S.AST.isUndefined)
+        const base = S.RedactedFromValue(innerSchema)
+        props[p.name as string] = hasNull && hasUndefined
+          ? S.NullishOr(base)
+          : hasNull
+          ? S.NullOr(base)
+          : hasUndefined
+          ? S.UndefinedOr(base)
+          : base
+      } else {
+        props[p.name as string] = S.make(p.type)
+      }
+    } else {
+      props[p.name as string] = S.make(p.type)
+    }
+  }
+
+  return hasRedacted ? S.Struct(props) as unknown as S.Codec<To, From> : schema
+}

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

@@ -0,0 +1,78 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { DeepKeys } from "@tanstack/vue-form"
+import type * as S from "effect-app/Schema"
+import type { Redacted } from "effect/Redacted"
+
+// Recursively replace Redacted<A> with its inner type so DeepKeys treats it as a leaf
+type StripRedacted<T> = T extends Redacted<any> ? string
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<StripRedacted<U>>
+  : T extends Record<string, any> ? { [K in keyof T]: StripRedacted<T[K]> }
+  : T
+
+export type NestedKeyOf<T> = DeepKeys<StripRedacted<T>>
+
+// Field metadata type definitions
+export type BaseFieldMeta = {
+  required: boolean
+  nullableOrUndefined?: false | "undefined" | "null"
+  /**
+   * True when the schema property is `S.optionalKey` (AST
+   * `context.isOptional`) — i.e. the key should be ABSENT from the submitted
+   * object when empty, not present with `undefined`. Distinct from
+   * `required: false`, which may also mean "empty string is valid" for
+   * unconstrained `S.String` fields.
+   */
+  isOptionalKey?: boolean
+}
+
+export type StringFieldMeta = BaseFieldMeta & {
+  type: "string"
+  maxLength?: number
+  minLength?: number
+  format?: string
+}
+
+export type NumberFieldMeta = BaseFieldMeta & {
+  type: "number"
+  minimum?: number
+  maximum?: number
+  exclusiveMinimum?: number
+  exclusiveMaximum?: number
+  refinement?: "int"
+}
+
+export type SelectFieldMeta = BaseFieldMeta & {
+  type: "select"
+  members: any[] // TODO: should be non empty array?
+}
+
+export type MultipleFieldMeta = BaseFieldMeta & {
+  type: "multiple"
+  members: any[] // TODO: should be non empty array?
+  rest: readonly S.AST.AST[]
+}
+
+export type BooleanFieldMeta = BaseFieldMeta & {
+  type: "boolean"
+}
+
+export type DateFieldMeta = BaseFieldMeta & {
+  type: "date"
+}
+
+export type UnknownFieldMeta = BaseFieldMeta & {
+  type: "unknown"
+}
+
+export type FieldMeta =
+  | StringFieldMeta
+  | NumberFieldMeta
+  | SelectFieldMeta
+  | MultipleFieldMeta
+  | BooleanFieldMeta
+  | DateFieldMeta
+  | UnknownFieldMeta
+
+export type MetaRecord<T = string> = {
+  [K in NestedKeyOf<T>]?: FieldMeta
+}