svelte-reflector 2.5.1 → 2.5.3

package/dist/core/schema/SchemaClassRenderer.js

@@ -22,6 +22,15 @@ export class SchemaClassRenderer {
         const keys = [];
         const bundleParams = [];
         let staticMethod = "";
+        // Optional, always-instantiated sub-DTOs (`nome? = $state<T>(new T)`): the
+        // runtime gate reads this set to skip an empty optional block instead of
+        // flagging its inner `required` fields. Emitted only when non-empty.
+        const optionalDtoNames = objectProps
+            .map((prop) => prop.optionalGateName())
+            .filter((name) => name !== null);
+        const optionalDtosDecl = optionalDtoNames.length
+            ? `readonly _optionalDtos = new Set<string>([${optionalDtoNames.map((name) => `"${name}"`).join(", ")}])`
+            : "";
         primitiveProps.forEach((prop) => {
             constructorThis.push(prop.constructorBuild());
             bundleParams.push(prop.bundleBuild());
@@ -93,7 +102,7 @@ export class SchemaClassRenderer {
             : responseBundle;
         const schema = `
     export class ${name} {
-      ${keys.join(";")}
+      ${[...keys, optionalDtosDecl].filter(Boolean).join(";\n      ")}
 
       ${constructorCode}
 

package/dist/core/schema/SchemaPropertyClassifier.js

@@ -31,7 +31,7 @@ export class SchemaPropertyClassifier {
                     isNullable: value.nullable,
                 });
             }
-            return SchemaPropertyClassifier.classifyObject({ key, value });
+            return SchemaPropertyClassifier.classifyObject({ key, value, requireds });
         }
         const required = requireds.includes(key);
         const items = value.items;
@@ -107,10 +107,10 @@ export class SchemaPropertyClassifier {
         });
     }
     static classifyObject(params) {
-        const { value, key } = params;
+        const { value, key, requireds } = params;
         if ("allOf" in value) {
             const ref = value.allOf?.[0];
-            const isRequired = !!value.nullable;
+            const isRequired = requireds.includes(key);
             const nullable = !!value.nullable;
             if (ref && isReferenceObject(ref)) {
                 return new ObjectProp({ name: key, referenceObject: ref, isRequired, isNullable: nullable });
@@ -118,7 +118,7 @@ export class SchemaPropertyClassifier {
             return null;
         }
         if (isReferenceObject(value)) {
-            return new ObjectProp({ name: key, referenceObject: value });
+            return new ObjectProp({ name: key, referenceObject: value, isRequired: requireds.includes(key) });
         }
         return null;
     }

package/dist/props/object.property.d.ts

@@ -14,5 +14,14 @@ export declare class ObjectProp {
     classBuild(): string;
     interfaceBuild(): string;
     bundleBuild(): string;
+    /**
+     * Field name when this sub-DTO is emitted as optional AND always-instantiated
+     * (`nome? = $state<T>(new T)` — `!required && !nullable`), so the client-side
+     * gate (`validateForm`) must skip it when empty instead of validating its inner
+     * `required` fields as mandatory. `null` for required or nullable sub-DTOs (the
+     * latter defaults to `null` and is already skipped at runtime). Mirrors the `?`
+     * modifier `classBuild` emits, keeping the runtime gate consistent with the type.
+     */
+    optionalGateName(): string | null;
     hydrateBuild(): string;
 }

package/dist/props/object.property.js

@@ -7,7 +7,7 @@ export class ObjectProp {
         const { referenceObject, name, isRequired, isNullable } = params;
         this.name = name;
         this.type = referenceObject.$ref.split("/").at(-1) ?? "";
-        this.required = isRequired ?? true; // tem que ver isso daí
+        this.required = isRequired ?? false;
         this.isNullable = !!isNullable;
     }
     constructorBuild() {
@@ -31,6 +31,17 @@ export class ObjectProp {
         const nullable = this.isNullable ? "?? null" : "";
         return `${this.name}: this.${this.name}?.bundle() ${nullable}`;
     }
+    /**
+     * Field name when this sub-DTO is emitted as optional AND always-instantiated
+     * (`nome? = $state<T>(new T)` — `!required && !nullable`), so the client-side
+     * gate (`validateForm`) must skip it when empty instead of validating its inner
+     * `required` fields as mandatory. `null` for required or nullable sub-DTOs (the
+     * latter defaults to `null` and is already skipped at runtime). Mirrors the `?`
+     * modifier `classBuild` emits, keeping the runtime gate consistent with the type.
+     */
+    optionalGateName() {
+        return !this.required && !this.isNullable ? this.name : null;
+    }
     hydrateBuild() {
         if (this.isNullable) {
             return `if (data.${this.name} !== undefined) {

package/dist/runtime/reflector.svelte.ts

@@ -74,6 +74,7 @@ export class BuildedInput<T> {
   private _value = $state<T>(null as any);
   private serverErrorMessage = $state<string | null>(null);
   private serverErrorValue = $state.raw<T | null>(null);
+  showError = $state(false);
   sanitizer?: Sanitizer;
   required: boolean;
   nullable: boolean;
@@ -180,6 +181,14 @@ export class BuildedInput<T> {
     return this.validator(this.value);
   }
 
+  touch(): void {
+    this.showError = true;
+  }
+
+  untouch(): void {
+    this.showError = false;
+  }
+
   setServerError(message: string) {
     this.serverErrorMessage = message;
     this.serverErrorValue = this.value;
@@ -241,6 +250,11 @@ export function build<T>(params: {
   return new BuildedInput(params);
 }
 
+/**
+ * @deprecated Use `validateForm` — `isFormValid` faz `throw` no primeiro campo
+ * inválido (nunca retorna `false`), ignora o flag `required` e muta o schema
+ * (`delete schema.bundle`). Remoção real fica para o próximo major.
+ */
 export function isFormValid<T>(schema: PartialBuildedInput<T>): boolean {
   delete (schema as { bundle?: unknown }).bundle;
 
@@ -266,6 +280,93 @@ export function isFormValid<T>(schema: PartialBuildedInput<T>): boolean {
   return isValid;
 }
 
+function isNestedDto(v: unknown): v is Record<string, unknown> {
+  return v != null && typeof v === "object" && typeof (v as { bundle?: unknown }).bundle === "function";
+}
+
+function isInputEmpty(input: BuildedInput<unknown>): boolean {
+  return input.value === "" || input.value === null || input.value === undefined;
+}
+
+/**
+ * Visita os `BuildedInput` do schema, recursando em DTO aninhado (campo com
+ * `.bundle()`) e em array de DTOs — simétrico ao `bundleInputs`/`bundle`, que
+ * também recursam. Sem short-circuit: aplica `fn` em cada campo.
+ *
+ * `skipOptionalEmpty`: pula um sub-DTO listado no `_optionalDtos` do pai cujos
+ * campos estão TODOS vazios. O codegen marca os sub-DTOs **opcionais
+ * always-instantiated** (`nome? = $state<T>(new T)`); sem isso o gate validaria
+ * o `required` interno de um bloco opcional em branco e bloquearia o submit.
+ */
+function forEachBuildedInput(
+  schema: object,
+  fn: (input: BuildedInput<unknown>) => void,
+  skipOptionalEmpty: boolean,
+): void {
+  const optional = skipOptionalEmpty
+    ? (schema as { _optionalDtos?: Set<string> })._optionalDtos
+    : undefined;
+  for (const [key, v] of Object.entries(schema)) {
+    if (isBuildedInput(v)) {
+      fn(v);
+    } else if (Array.isArray(v)) {
+      for (const item of v) {
+        if (isBuildedInput(item)) fn(item);
+        else if (isNestedDto(item)) forEachBuildedInput(item, fn, skipOptionalEmpty);
+      }
+    } else if (isNestedDto(v)) {
+      if (optional?.has(key) && isEmptyDto(v)) continue;
+      forEachBuildedInput(v, fn, skipOptionalEmpty);
+    }
+  }
+}
+
+function isEmptyDto(dto: object): boolean {
+  let empty = true;
+  forEachBuildedInput(
+    dto,
+    (input) => {
+      if (!isInputEmpty(input)) empty = false;
+    },
+    false,
+  );
+  return empty;
+}
+
+/**
+ * Gate de validação client-side honesto: percorre os campos `BuildedInput` do
+ * schema (recursando em DTO aninhado e array de DTOs), chama `touch()` em cada um
+ * (acende o erro por-campo no submit) e retorna `true` só se todos forem válidos.
+ * Campo vazio é inválido quando `required`; caso contrário consulta o `validator`.
+ * Sub-DTO opcional inteiramente vazio é pulado (não bloqueia bloco em branco).
+ * Sem `throw`, sem `toast`, sem mutar o schema. Tocar todos é de propósito (não
+ * `.every`, que short-circuita e deixaria campos sem acender).
+ */
+export function validateForm(schema: object): boolean {
+  let valid = true;
+  forEachBuildedInput(
+    schema,
+    (input) => {
+      input.touch();
+      const fieldValid = isInputEmpty(input) ? !input.required : input.validate() === null;
+      if (!fieldValid) valid = false;
+    },
+    true,
+  );
+  return valid;
+}
+
+/**
+ * Simétrico do `validateForm`: apaga `showError` de todos os campos do schema
+ * (incl. aninhados, sem pular opcional). Usar no `onClose`/reset de modal que
+ * reusa a instância do form. (Quando o endpoint faz `reset()` → `new Dto()`,
+ * `showError` já volta `false` de graça; o untouch só é necessário pra instância
+ * reutilizada.)
+ */
+export function untouchForm(schema: object): void {
+  forEachBuildedInput(schema, (input) => input.untouch(), false);
+}
+
 export function genericArrayBundler(data: string[]): string[];
 export function genericArrayBundler<T extends { bundle: () => BundleResult<T> }>(
   data: T[],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-reflector",
-  "version": "2.5.1",
+  "version": "2.5.3",
   "description": "Reflects types from openAPI schemas",
   "type": "module",
   "main": "./dist/index.js",