@effect-app/vue-components 4.0.0-beta.2 → 4.0.0-beta.200

package/src/components/OmegaForm/validation/localized.ts

@@ -0,0 +1,202 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { StandardSchemaV1 } from "@tanstack/vue-form"
+import { Option, S } from "effect-app"
+import type { useIntl } from "../../../utils"
+
+export type TransFn = ReturnType<typeof useIntl>["trans"]
+
+type FilterMeta =
+  | { readonly _tag: "isMinLength"; readonly minLength: number }
+  | { readonly _tag: "isMaxLength"; readonly maxLength: number }
+  | { readonly _tag: "isInt" }
+  | { readonly _tag: "isGreaterThanOrEqualTo"; readonly minimum: number }
+  | { readonly _tag: "isGreaterThan"; readonly exclusiveMinimum: number }
+  | { readonly _tag: "isLessThanOrEqualTo"; readonly maximum: number }
+  | { readonly _tag: "isLessThan"; readonly exclusiveMaximum: number }
+  | { readonly _tag?: undefined }
+
+export const makeStandardSchemaV1Hooks = (
+  trans: TransFn
+): {
+  leafHook: S.SchemaIssue.LeafHook
+  checkHook: S.SchemaIssue.CheckHook
+} => {
+  const leafHook: S.SchemaIssue.LeafHook = (issue) => {
+    const override = (issue as { annotations?: { message?: unknown } }).annotations?.message
+    if (override !== undefined) return String(override)
+    switch (issue._tag) {
+      case "MissingKey":
+        return trans("validation.empty")
+      case "InvalidType": {
+        const ast = issue.ast
+        // Detect undefined/missing actual values across required leaves and return a uniform empty message.
+        const actualUndefined = Option.isNone(issue.actual)
+          || (Option.isSome(issue.actual) && issue.actual.value === undefined)
+        if (actualUndefined) return trans("validation.empty")
+        if (S.AST.isString(ast)) return trans("validation.empty")
+        if (S.AST.isBoolean(ast)) return trans("validation.not_a_valid", { type: "boolean" })
+        if (S.AST.isNumber(ast)) {
+          const actual = Option.isSome(issue.actual) ? String(issue.actual.value) : "NaN"
+          return trans("validation.number.expected", { actualValue: actual })
+        }
+        return trans("validation.not_a_valid")
+      }
+      default:
+        return trans("validation.not_a_valid")
+    }
+  }
+
+  const checkHook: S.SchemaIssue.CheckHook = (issue) => {
+    // S.Email's `refine(isValidEmail, ...)` has no `meta._tag` but carries
+    // `identifier: "Email"`. Localize it explicitly — otherwise the
+    // formatter falls back to the generic "Expected <filter>, got <actual>".
+    if (issue.filter.annotations?.identifier === "Email") {
+      return trans("validation.email.invalid")
+    }
+    const meta = (issue.filter.annotations?.meta ?? {}) as FilterMeta
+    switch (meta._tag) {
+      case "isMinLength":
+        return meta.minLength === 1
+          ? trans("validation.empty")
+          : trans("validation.string.minLength", { minLength: meta.minLength })
+      case "isMaxLength":
+        return trans("validation.string.maxLength", { maxLength: meta.maxLength })
+      case "isInt": {
+        const actual = issue.actual !== undefined ? String(issue.actual) : "NaN"
+        return trans("validation.integer.expected", { actualValue: actual })
+      }
+      case "isGreaterThanOrEqualTo":
+        return trans(
+          meta.minimum === 0 ? "validation.number.positive" : "validation.number.min",
+          { minimum: meta.minimum, isExclusive: true }
+        )
+      case "isGreaterThan":
+        return trans(
+          meta.exclusiveMinimum === 0 ? "validation.number.positive" : "validation.number.min",
+          { minimum: meta.exclusiveMinimum, isExclusive: false }
+        )
+      case "isLessThanOrEqualTo":
+        return trans("validation.number.max", { maximum: meta.maximum, isExclusive: true })
+      case "isLessThan":
+        return trans("validation.number.max", { maximum: meta.exclusiveMaximum, isExclusive: false })
+      default:
+        // Fall back to the default check hook so custom S.makeFilter messages
+        // (which surface as InvalidValue.annotations.message on issue.issue)
+        // are returned verbatim instead of getting the generic
+        // "Expected <filter>, got <actual>" formatter output.
+        return S.SchemaIssue.defaultCheckHook(issue)
+    }
+  }
+
+  return { leafHook, checkHook }
+}
+
+export const toLocalizedStandardSchemaV1 = <To, From>(
+  schema: S.Codec<To, From>,
+  trans: TransFn
+): StandardSchemaV1<From, To> => {
+  const { checkHook, leafHook } = makeStandardSchemaV1Hooks(trans)
+  return S.toStandardSchemaV1(schema, { leafHook, checkHook })
+}
+
+/*
+ * Effect's Standard Schema formatter handles `AnyOf` issues (produced by
+ * `S.Literals(...)` failures and by `S.Array` of literal unions when the
+ * top-level value isn't an array) by generating the message directly via
+ * `getExpectedMessage(...)` — *without* invoking `leafHook` / `checkHook`.
+ * The only override path is `findMessage(issue)`, which reads the AST's
+ * `message` annotation. So we walk the schema AST once at form setup and
+ * stamp a localized `message` annotation on:
+ *   - Union AST whose every member is a Literal      → "select"
+ *   - Arrays AST whose `rest` is a Union of Literals → "multiple"
+ * Existing `message` annotations are preserved.
+ */
+const isLiteralUnion = (ast: S.AST.AST): ast is S.AST.Union<S.AST.Literal> =>
+  S.AST.isUnion(ast) && ast.types.every(S.AST.isLiteral)
+
+const walkAst = (ast: S.AST.AST, trans: TransFn): S.AST.AST => {
+  if (isLiteralUnion(ast)) {
+    if (ast.annotations?.message !== undefined) return ast
+    const members = ast.types.map((t) => t.literal)
+    return new S.AST.Union(
+      ast.types,
+      ast.mode,
+      {
+        ...ast.annotations,
+        message: trans("validation.not_a_valid", { type: "select", message: members.join(", ") })
+      },
+      ast.checks,
+      ast.encoding,
+      ast.context
+    )
+  }
+  // Mixed unions (e.g. `S.NullOr(S.Literals(...))` → Union<Null, Union<Literals>>)
+  // need recursion so the inner literal-union still gets annotated. We don't
+  // touch the outer mixed Union's own annotations.
+  if (S.AST.isUnion(ast)) {
+    const newTypes = ast.types.map((t) => walkAst(t, trans))
+    const changed = newTypes.some((t, i) => t !== ast.types[i])
+    if (!changed) return ast
+    return new S.AST.Union(
+      newTypes,
+      ast.mode,
+      ast.annotations,
+      ast.checks,
+      ast.encoding,
+      ast.context
+    )
+  }
+  if (S.AST.isArrays(ast)) {
+    const newRest = ast.rest.map((e) => walkAst(e, trans))
+    const newElements = ast.elements.map((e) => walkAst(e, trans))
+    let annotations = ast.annotations
+    if (
+      ast.annotations?.message === undefined
+      && ast.rest.length === 1
+      && isLiteralUnion(ast.rest[0])
+    ) {
+      const members = ast.rest[0].types.map((t) => t.literal)
+      annotations = {
+        ...ast.annotations,
+        message: trans("validation.not_a_valid", { type: "multiple", message: members.join(", ") })
+      }
+    }
+    const restChanged = newRest.some((r, i) => r !== ast.rest[i])
+    const elemsChanged = newElements.some((e, i) => e !== ast.elements[i])
+    if (!restChanged && !elemsChanged && annotations === ast.annotations) return ast
+    return new S.AST.Arrays(
+      ast.isMutable,
+      newElements,
+      newRest,
+      annotations,
+      ast.checks,
+      ast.encoding,
+      ast.context
+    )
+  }
+  if (S.AST.isObjects(ast)) {
+    const newProps = ast.propertySignatures.map((p) => {
+      const newType = walkAst(p.type, trans)
+      return newType === p.type ? p : new S.AST.PropertySignature(p.name, newType)
+    })
+    const changed = newProps.some((p, i) => p !== ast.propertySignatures[i])
+    if (!changed) return ast
+    return new S.AST.Objects(
+      newProps,
+      ast.indexSignatures,
+      ast.annotations,
+      ast.checks,
+      ast.encoding,
+      ast.context
+    )
+  }
+  return ast
+}
+
+export const annotateLiteralUnionMessages = <To, From>(
+  schema: S.Codec<To, From>,
+  trans: TransFn
+): S.Codec<To, From> => {
+  const newAst = walkAst(schema.ast, trans)
+  return newAst === schema.ast ? schema : S.make(newAst)
+}

package/src/index.ts

@@ -17,5 +17,4 @@ function install(app: App) {
 export default { install }
 
 export * from "./components"
-export * from "./constants"
 export * from "./utils"

package/src/reset.css

@@ -0,0 +1,52 @@
+/*
+ * Supplemental CSS reset for Vuetify 4.
+ * Vuetify 4 removed the aggressive global reset that v3 included.
+ * Import this file to restore equivalent behavior:
+ *   import '@effect-app/vue-components/reset.css'
+ */
+@layer vuetify-reset {
+  body {
+    margin: 0;
+  }
+
+  ul,
+  ol {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+  }
+
+  h1,
+  h2,
+  h3,
+  h4,
+  h5,
+  h6 {
+    margin: 0;
+    font-size: inherit;
+    font-weight: inherit;
+  }
+
+  p {
+    margin: 0;
+  }
+
+  input,
+  textarea,
+  select {
+    border: 0;
+    background: transparent;
+  }
+
+  a {
+    text-decoration: none;
+    color: inherit;
+  }
+
+  figure,
+  details,
+  summary {
+    margin: 0;
+    padding: 0;
+  }
+}

package/src/utils/index.ts

@@ -1,5 +1,5 @@
 import { type makeIntl } from "@effect-app/vue"
-import { type S } from "effect-app"
+import type { S } from "effect-app"
 import { inject, type InjectionKey, provide } from "vue"
 
 export const useIntlKey = Symbol() as InjectionKey<
@@ -17,16 +17,15 @@ export const provideIntl = (
 ) => provide(useIntlKey, intl)
 
 /**
- * Recursively extracts the source AST from a transformation chain.
- * In v4, transformations are stored in the `encoding` property, not as wrapped AST nodes.
- * This function returns the encoded form if an encoding chain exists, otherwise returns the AST itself.
- *
- * @param ast - The AST node to extract the transformation source from
- * @returns The source AST (the decoded/type form, which is the AST itself in v4)
+ * Walks the encoding chain of the given AST node to its source (encoded)
+ * side. Shallow — does not recurse into children, so inner prop-level
+ * transformations (e.g. `FiniteFromString`) keep their decoded shape
+ * while struct-level `decodeTo` transformations are unwrapped to their
+ * input side (e.g. `NonNegativeInt` rather than the decoded `PositiveInt`).
  */
 export function getTransformationFrom(ast: S.AST.AST) {
-  // In v4, the AST itself is the decoded (type) form
-  // The encoding chain points to the encoded (wire) form via ast.encoding
-  // For most metadata extraction purposes, we want the decoded form, so just return the ast
+  while (ast.encoding) {
+    ast = ast.encoding[0].to
+  }
   return ast
 }

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

@@ -1,157 +0,0 @@
-import type * as Effect from "effect/Effect";
-import * as AST from "effect/SchemaAST";
-import { type DeepKeys, type DeepValue, type FieldAsyncValidateOrFn, type FieldValidateOrFn, type FormApi, type FormAsyncValidateOrFn, type FormOptions, type FormState, type FormValidateOrFn, type StandardSchemaV1, type VueFormApi } from "@tanstack/vue-form";
-import * as S from "effect/Schema";
-import { useIntl } from "../../utils";
-import { type OmegaFieldInternalApi } from "./InputProps";
-import { type OF, type OmegaFormReturn } from "./useOmegaForm";
-export type FieldPath<T> = unknown extends T ? string : T extends string | boolean | number | null | undefined | symbol | bigint ? "" : T extends ReadonlyArray<infer U> ? FieldPath_<U, `[${number}]`> : {
-    [K in keyof T]: FieldPath_<T[K], `${K & string}`>;
-}[keyof T];
-export type FieldPath_<T, Path extends string> = unknown extends T ? string : T extends string | boolean | number | null | undefined | symbol | bigint ? Path : T extends ReadonlyArray<infer U> ? FieldPath_<U, `${Path}[${number}]`> | Path : {
-    [K in keyof T]: FieldPath_<T[K], `${Path}.${K & string}`>;
-}[keyof T];
-export type BaseProps<From, TName extends FieldPath<From>> = {
-    /**
-     * Will fallback to i18n when not specified.
-     * Can also be provided via #label slot for custom HTML labels.
-     * When using the slot, it receives bindings: { required, id, label }
-     */
-    label?: string;
-    validators?: FieldValidators<From>;
-    name: TName;
-    /**
-     * Optional class to apply to the input element.
-     * - If a string is provided, it will be used instead of the general class
-     * - If null is provided, no class will be applied (neither inputClass nor general class)
-     * - If undefined (not provided), the general class will be used
-     */
-    inputClass?: string | null;
-};
-export type TypesWithOptions = "radio" | "select" | "multiple" | "autocomplete" | "autocompletemultiple";
-export type DefaultTypeProps = {
-    type?: TypeOverride;
-    options?: undefined;
-} | {
-    type?: TypesWithOptions;
-    options?: {
-        title: string;
-        value: unknown;
-    }[];
-};
-export type OmegaInputPropsBase<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>> = {
-    form: OF<From, To> & {
-        meta: MetaRecord<From>;
-        i18nNamespace?: string;
-    };
-} & BaseProps<From, Name>;
-export type OmegaInputProps<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>, TypeProps = DefaultTypeProps> = {
-    form: OmegaFormReturn<From, To, TypeProps> & {
-        meta: MetaRecord<From>;
-        i18nNamespace?: string;
-    };
-} & BaseProps<From, Name>;
-export type OmegaArrayProps<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>> = Omit<OmegaInputProps<From, To, Name>, "validators" | "options" | "label" | "type" | "items" | "name"> & {
-    name: DeepKeys<From>;
-    defaultItems?: DeepValue<From, DeepKeys<From>>;
-    items?: "please use `defaultItems` instead";
-};
-export type TypeOverride = "string" | "text" | "number" | "select" | "multiple" | "boolean" | "radio" | "autocomplete" | "autocompletemultiple" | "switch" | "range" | "password" | "email" | "date";
-export interface OmegaError {
-    label: string;
-    inputId: string;
-    errors: readonly string[];
-}
-export type FormProps<From, To> = Omit<FormOptions<From, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, Record<string, any> | undefined>, "onSubmit" | "defaultValues"> & {
-    defaultValues?: Partial<From>;
-    onSubmit?: (props: {
-        formApi: OmegaFormParams<From, To>;
-        meta: any;
-        value: To;
-    }) => Promise<any> | Effect.Effect<unknown, any, never>;
-};
-export type OmegaFormParams<From, To> = FormApi<From, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, Record<string, any> | undefined>;
-export type OmegaFormState<From, To> = FormState<From, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined>;
-export type OmegaFormApi<From, To, TSubmitMeta = Record<string, any> | undefined> = OmegaFormParams<From, To> & VueFormApi<From, FormValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, StandardSchemaV1<From, To>, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, FormAsyncValidateOrFn<From> | undefined, TSubmitMeta>;
-export type FormComponent<T, S> = VueFormApi<T, FormValidateOrFn<T> | undefined, FormValidateOrFn<T> | undefined, StandardSchemaV1<T, S>, FormValidateOrFn<T> | undefined, FormAsyncValidateOrFn<T> | undefined, FormValidateOrFn<T> | undefined, FormAsyncValidateOrFn<T> | undefined, FormValidateOrFn<T> | undefined, FormAsyncValidateOrFn<T> | undefined, FormAsyncValidateOrFn<T> | undefined, Record<string, any> | undefined>;
-export type FormType<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>> = OmegaFormApi<From, To> & {
-    Field: OmegaFieldInternalApi<From, Name>;
-};
-export type PrefixFromDepth<K extends string | number, _TDepth extends any[]> = K;
-export type NestedKeyOf<T> = DeepKeys<T>;
-export type FieldValidators<T> = {
-    onChangeAsync?: FieldAsyncValidateOrFn<T, any, any>;
-    onChange?: FieldValidateOrFn<T, any, any>;
-    onBlur?: FieldValidateOrFn<T, any, any>;
-    onBlurAsync?: FieldAsyncValidateOrFn<T, any, any>;
-};
-export type BaseFieldMeta = {
-    required: boolean;
-    nullableOrUndefined?: false | "undefined" | "null";
-};
-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[];
-};
-export type MultipleFieldMeta = BaseFieldMeta & {
-    type: "multiple";
-    members: any[];
-    rest: readonly AST.AST[];
-};
-export type BooleanFieldMeta = BaseFieldMeta & {
-    type: "boolean";
-};
-export type UnknownFieldMeta = BaseFieldMeta & {
-    type: "unknown";
-};
-export type FieldMeta = StringFieldMeta | NumberFieldMeta | SelectFieldMeta | MultipleFieldMeta | BooleanFieldMeta | UnknownFieldMeta;
-export type MetaRecord<T = string> = {
-    [K in NestedKeyOf<T>]?: FieldMeta;
-};
-export type FilterItems = {
-    items: readonly [string, ...string[]];
-    message: string | Effect.Effect<string, never, never> | {
-        readonly message: string | Effect.Effect<string>;
-    };
-};
-export type CreateMeta = {
-    parent?: string;
-    meta?: Record<string, any>;
-    nullableOrUndefined?: false | "undefined" | "null";
-} & ({
-    propertySignatures: readonly AST.PropertySignature[];
-    property?: never;
-} | {
-    propertySignatures?: never;
-    property: AST.AST;
-});
-export declare const isNullableOrUndefined: (property: false | AST.AST | undefined) => false | "undefined" | "null";
-export declare const createMeta: <T = any>({ meta, parent, property, propertySignatures }: CreateMeta, acc?: Partial<MetaRecord<T>>) => MetaRecord<T> | FieldMeta;
-export declare const duplicateSchema: <From, To>(schema: S.Codec<To, From, never>) => S.Codec<To, From, never, never>;
-export declare const generateMetaFromSchema: <_From, To>(schema: any) => {
-    schema: any;
-    meta: MetaRecord<To>;
-    unionMeta: Record<string, MetaRecord<To>>;
-};
-export declare const generateInputStandardSchemaFromFieldMeta: (meta: FieldMeta, trans?: ReturnType<typeof useIntl>["trans"]) => StandardSchemaV1<any, any>;
-export type OmegaAutoGenMeta<From extends Record<PropertyKey, any>, To extends Record<PropertyKey, any>, Name extends DeepKeys<From>> = Omit<OmegaInputProps<From, To, Name>, "form">;
-declare const supportedInputs: readonly ["button", "checkbox", "color", "date", "email", "number", "password", "radio", "range", "search", "submit", "tel", "text", "time", "url"];
-export type SupportedInputs = typeof supportedInputs[number];
-export declare const getInputType: (input: string) => SupportedInputs;
-export declare function deepMerge(target: any, source: any): any;
-export declare const defaultsValueFromSchema: (schema: S.Codec<any>, record?: Record<string, any>) => any;
-export {};

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

@@ -1 +0,0 @@
-export {};