svelte-reflector 1.0.35 → 1.0.37

package/dist/array.property.d.ts

@@ -2,11 +2,15 @@ import type { SchemaObject } from "./types/open-api-spec.interface.js";
 export declare class ArrayProp {
     name: string;
     type: string;
-    isSpecial: boolean;
+    isRequired: boolean;
+    isParam: boolean;
+    private isPrimitiveType;
     constructor(params: {
         name: string;
         schemaObject: SchemaObject;
         schemaName: string;
+        required: boolean;
+        isParam?: boolean;
     });
     private treatName;
     private getType;

package/dist/array.property.js

@@ -1,11 +1,15 @@
 export class ArrayProp {
     name;
     type;
-    isSpecial = false;
+    isRequired;
+    isParam;
+    isPrimitiveType = false;
     constructor(params) {
-        const { name, schemaObject, schemaName } = params;
+        const { name, schemaObject, schemaName, required, isParam } = params;
         this.name = this.treatName(name);
         this.type = this.getType({ schemaObject, schemaName });
+        this.isRequired = required;
+        this.isParam = !!isParam;
     }
     treatName(name) {
         let newName = name;
@@ -16,37 +20,45 @@ export class ArrayProp {
     }
     getType(params) {
         const { schemaObject, schemaName } = params;
-        const teste = schemaObject.items;
-        if (!teste)
+        const items = schemaObject.items;
+        if (!items)
             return schemaName;
-        this.isSpecial = true;
-        if ("$ref" in teste) {
-            return teste.$ref.split("/").at(-1);
+        if ("$ref" in items) {
+            const theType = items.$ref.split("/").at(-1);
+            return theType;
         }
-        if (teste.enum && teste.type === "string") {
-            return "string";
-        }
-        return teste.type ?? "string";
+        this.isPrimitiveType = true;
+        // if (teste.enum && teste.type === "string") {
+        //   return "string";
+        // }
+        return "string";
     }
     constructorBuild() {
-        const result = this.isSpecial ? "" : `.map((param) => new ${this.type}(param))`;
-        return `this.${this.name} = params?.${this.name}${result} ?? []`;
+        const result = this.isPrimitiveType ? "" : `.map((param) => new ${this.type}({ data: param }))`;
+        return `this.${this.name} = params?.data?.${this.name}${result} ?? []`;
     }
     classBuild() {
-        const sanitizedType = this.isSpecial ? this.type : `${this.type}[]`;
-        return `${this.name}: ${sanitizedType}[]`;
+        const required = this.isRequired ? "" : "?";
+        const sanitizedType = this.isPrimitiveType ? this.type : `${this.type}`;
+        return `${this.name}${required}: ${sanitizedType}[]`;
     }
     interfaceBuild() {
-        const sanitizedType = this.isSpecial ? this.type : `${this.type}Interface`;
-        return `${this.name}: ${sanitizedType}[]`;
+        const required = this.isRequired ? "" : "?";
+        const sanitizedType = this.isPrimitiveType ? this.type : `${this.type}Interface`;
+        return `${this.name}${required}: ${sanitizedType}[]`;
     }
+    // toInterfaceArrayBuild() {
+    //   const required = this.isRequired ? "" : "?";
+    //   const sanitizedType = this.isPrimitiveType ? this.type : `${this.type}Interface`;
+    //   return `${this.name}${required}: ${sanitizedType}[]`;
+    // }
     bundleBuild() {
-        const result = this.isSpecial ? "" : ".map((obj) => obj.bundle())";
+        const result = this.isPrimitiveType ? "" : ".map((obj) => obj.bundle())";
         return `${this.name}: this.${this.name}${result}`;
     }
     staticBuild() {
-        const result = this.isSpecial ? "obj" : `new ${this.type}(obj)`;
-        const aType = this.isSpecial ? this.type : `${this.type}Interface`;
+        const result = this.isPrimitiveType ? "obj" : `new ${this.type}({ data: obj })`;
+        const aType = this.isPrimitiveType ? this.type : `${this.type}Interface`;
         return `
       static from(data: ${aType}[]) {
         return data.map((obj) => ${result});

package/dist/main.js

@@ -5,6 +5,7 @@ import { getEndpoint, splitByUppercase } from "./helpers/helpers.js";
 import { Schema } from "./schema.js";
 import { Module } from "./module.js";
 import { baseDir, generatedDir } from "./vars.global.js";
+import { ReflectorFile } from "./reflector.js";
 // import { Module } from "./module.js";
 export class Reflector {
     components;
@@ -106,73 +107,7 @@ export class Reflector {
             ...treatedSchemas,
         ].join("\n\n"));
         this.schemaFile.save();
-        const buildFunctions = `
-      import toast from "$lib/utils/toast.svelte";
-
-      type ValidatorResult = string | null;
-      type ValidatorFn<T> = (v: T) => ValidatorResult;
-      type Partial<T> = {
-        [K in Exclude<keyof T, 'bundle'>]?: BuildedInput<T[K]>;
-      } & {
-        bundle: unknown;
-      };
-
-      export class Behavior<TSuccess = unknown, TError = unknown> {
-        onError?: (e: TError) => void;
-        onSuccess?: (v: TSuccess) => void;
-      }
-
-      export class BuildedInput<T> {
-        value = $state<T>(null as any);
-        display = $state<T>(null as any);
-        required: boolean;
-        placeholder: T;
-        readonly validator?: ValidatorFn<T>;
-
-        constructor(params: { key?: T | undefined; example: T; required: boolean; validator?: ValidatorFn<T> }) {
-          const { example, required, key, validator } = params;
-
-          const initial = key ?? example;
-
-          this.value = initial;
-          this.display = initial;
-          this.required = required;
-          this.placeholder = example;
-
-          if (validator) {
-            this.validator = validator;
-          }
-        }
-
-        validate(): ValidatorResult {
-          if (!this.validator) return null;
-          return this.validator(this.value);
-        }
-      }
-
-      export function build<T>(params: {
-        key?: T | undefined;
-        example: T;
-        required: boolean;
-        validator?: ValidatorFn<T>;
-      }): BuildedInput<T> {
-        return new BuildedInput(params);
-      }
-
-      export function isFormValid<T>(schema: Partial<T>): boolean {
-        delete schema.bundle;
-
-        const arrayOfBuildedInputs = Object.values(schema) as BuildedInput<unknown>[];
-
-        const isValid = arrayOfBuildedInputs.every((a) => a.validate() === null);
-
-        if (!isValid) {
-          toast.error('Erro ao fazer a requisição', 'Um ou mais campos preenchidos estão incorretos.');
-        }
-
-        return isValid;
-      }
-    `;
+        const buildFunctions = new ReflectorFile().fileContent;
         this.typesSrc.changeData(buildFunctions);
         this.typesSrc.save();
         this.fieldsFile.changeData(`

package/dist/method.js

@@ -39,10 +39,10 @@ export class Method {
             const { required, name, description, schema, in: inParam } = object;
             if ("$ref" in schema)
                 continue;
-            const properties = { name, required: !!required, schemaObject: schema, validator: undefined };
+            const properties = { name, required: !!required, schemaObject: schema, validator: undefined, isParam: true };
             if (inParam === "query") {
                 if (schema.type === "array") {
-                    this.querys.push(new ArrayProp({ name, schemaObject: schema, schemaName: "" }));
+                    this.querys.push(new ArrayProp({ name, schemaObject: schema, schemaName: "", isParam: true, required: !!required }));
                 }
                 else {
                     this.querys.push(new PrimitiveProp(properties));
@@ -91,7 +91,7 @@ export class Method {
         else if (this.request.attributeType === "entity") {
             if (this.request.responseType) {
                 const entityName = treatByUppercase(this.request.responseType);
-                beforeResponse.push(`this.${entityName} = new ${this.request.responseType}(response)`);
+                beforeResponse.push(`this.${entityName} = new ${this.request.responseType}({ data: response })`);
             }
             let querys = this.querys.length > 0 ? `queryData: {${this.querys.map((q) => q.name).join(",")}}` : "";
             const inside = `
@@ -114,7 +114,7 @@ export class Method {
             if (hasHeaders) {
                 headers = `const headers = this.headers.bundle()`;
             }
-            const outside = ["this.loading = true", data, headers].join("\n");
+            const outside = [data, headers].join("\n");
             const inside = `
         const response = await api.${this.request.apiType}<${responseType}>({
           endpoint,
@@ -142,7 +142,7 @@ export class Method {
         if (!this.request.responseType) {
             // this.isValid = false;
         }
-        return this.request.responseType ? `new ${this.request.responseType}(response)` : "null";
+        return this.request.responseType ? `new ${this.request.responseType}({ data: response })` : "null";
     };
     getAdditionalMethod(params) {
         const { attributeType, name } = params;
@@ -179,6 +179,8 @@ export class Method {
       ${description}
       async ${this.name}(behavior: Behavior<${this.responseTypeInterface}> = new Behavior()) {
         const {onError, onSuccess} = behavior
+
+        this.loading = true
         ${this.getProps()}
         const endpoint = ${endpoint}
 

package/dist/module.js

@@ -26,7 +26,6 @@ export class Module {
                 moduleName: this.name,
             });
         });
-        // const { cookies, headers, paths, querys } = this.getParameters();
         const allBuilded = this.masterBuilder({
             methods: this.methods,
         });
@@ -58,7 +57,7 @@ export class Module {
       class ${name} {
         ${attributes.join(";")}
 
-        constructor(params?: ${name}Interface){
+        constructor(params?: { data?: ${name}Interface, empty?: boolean }){
           ${constructorThis.join(";")}
         }
 
@@ -150,6 +149,8 @@ export class Module {
             }
             else if (attributeType === "list") {
                 methodsAttributes.add(`list = $state<${responseType}['data']>([])`);
+                this.reflectorImports.add("genericArrayBundler");
+                methodsAttributes.add(`bundledList = $derived(genericArrayBundler(this.list))`);
                 methodsInit.add("this.clearList()");
                 methodsClear.add(`clearList() { this.list = [] }`);
             }
@@ -249,7 +250,7 @@ export class Module {
         if(isEmpty) return this.forms
 
         return {
-          ${form.map((f) => `${f.name}: new ${f.type}()`)}
+          ${form.map((f) => `${f.name}: new ${f.type}({ empty: true })`)}
         }
       }
     `;

package/dist/object.property.js

@@ -9,7 +9,7 @@ export class ObjectProp {
         this.required = isRequired ?? true; // tem que ver isso daí
     }
     constructorBuild() {
-        return `this.${this.name} = new ${this.type}(params?.${this.name})`;
+        return `this.${this.name} = new ${this.type}({ data: params?.data?.${this.name}, empty: params?.empty ?? false })`;
     }
     classBuild() {
         const req = this.required ? "" : "?";

package/dist/primitive-property.d.ts

@@ -1,23 +1,28 @@
 import type { SchemaObject } from "./types/open-api-spec.interface.js";
+type AbstractType = string | boolean | Date | number | undefined;
 export declare class PrimitiveProp {
     name: string;
-    type: string;
+    type: AbstractType;
     isSpecial: boolean;
+    isParam: boolean;
     private readonly required;
     private readonly rawType;
     private readonly buildedConst;
+    private readonly emptyExample;
     constructor(params: {
         name: string;
         schemaObject: SchemaObject;
         required: boolean;
         validator: string | undefined;
+        isParam?: boolean;
     });
     private treatName;
-    private buildConst;
     private getEmptyExample;
+    private buildConst;
     private thisDot;
     constructorBuild(): string;
     classBuild(): string;
     interfaceBuild(): string;
     bundleBuild(): string;
 }
+export {};

package/dist/primitive-property.js

@@ -1,22 +1,26 @@
+const emptyString = "''";
 export class PrimitiveProp {
     name;
     type;
     isSpecial = false;
+    isParam;
     required;
     rawType;
     buildedConst;
+    emptyExample;
     constructor(params) {
-        const { name, schemaObject, required, validator } = params;
+        const { name, schemaObject, required, validator, isParam } = params;
         const { example: rawExample, type: rawType } = schemaObject;
         const type = rawType ?? "string";
-        const example = rawExample ?? this.getEmptyExample({ type, schemaObject });
-        // const buildedType = required ? type : `${type} | undefined`;
+        this.emptyExample = this.getEmptyExample({ type, schemaObject });
+        const example = rawExample;
         const buildedType = type;
         this.name = this.treatName(name);
         this.rawType = type ?? "any";
         this.type = `BuildedInput<${buildedType}>`;
         this.required = required;
-        this.buildedConst = this.buildConst({ example, name: this.name, required, type, validator });
+        this.isParam = !!isParam;
+        this.buildedConst = this.buildConst({ example, name: this.name, required, type, validator, emptyExample: this.emptyExample });
     }
     treatName(name) {
         let newName = name;
@@ -26,8 +30,23 @@ export class PrimitiveProp {
         }
         return newName;
     }
+    getEmptyExample(params) {
+        const { schemaObject, type } = params;
+        if (type === "number") {
+            return 1;
+        }
+        else if (type === "boolean") {
+            return false;
+        }
+        else if (schemaObject.enum) {
+            return `"${schemaObject.enum[0]}"`;
+        }
+        else {
+            return "''";
+        }
+    }
     buildConst(params) {
-        const { example, name, required, type, validator } = params;
+        const { example, name, required, type, validator, emptyExample } = params;
         const getValidator = (type) => {
             if (type === "string") {
                 return "emptyString";
@@ -44,26 +63,25 @@ export class PrimitiveProp {
             }
             return "";
         };
-        const sanitizedExample = type === "boolean" || type === "number" ? example : `"${example}"`;
+        const sanitizedExample = () => {
+            if (this.isParam || !example) {
+                return emptyExample;
+            }
+            if (type === "string") {
+                return `"${example}"`;
+            }
+            return example;
+        };
+        const buildedExample = () => {
+            if (this.emptyExample === sanitizedExample()) {
+                return sanitizedExample();
+            }
+            return `params?.empty ? ${this.emptyExample} : ${sanitizedExample()}`;
+        };
         return `
-      build({ key: params?.${name}, example: ${sanitizedExample}, required: ${required}, ${buildedValidator()}})
+      build({ key: params?.data?.${name}, example: ${buildedExample()}, required: ${required}, ${buildedValidator()}})
     `;
     }
-    getEmptyExample(params) {
-        const { schemaObject, type } = params;
-        if (type === "number") {
-            return 1;
-        }
-        else if (type === "boolean") {
-            return false;
-        }
-        else if (schemaObject.enum) {
-            return `'${schemaObject.enum[0]}'`;
-        }
-        else {
-            return "";
-        }
-    }
     thisDot() {
         return `this${this.isSpecial ? "" : "."}`;
     }
@@ -82,12 +100,3 @@ export class PrimitiveProp {
         return `${this.name}: ${this.thisDot()}${this.name}?.value`;
     }
 }
-// class Teste {
-//   ["x-two-factor-code"]: string;
-//   constructor() {
-//     this["x-two-factor-code"] = "aaaaaaa";
-//   }
-//   bundle() {
-//     return { ["x-two-factor-code"]: this["x-two-factor-code"] };
-//   }
-// }

package/dist/reflector.d.ts

@@ -0,0 +1,7 @@
+export declare class ReflectorFile {
+    private readonly imports;
+    private readonly types;
+    private readonly classes;
+    private readonly functions;
+    fileContent: string;
+}

package/dist/reflector.js

@@ -0,0 +1,86 @@
+export class ReflectorFile {
+    imports = ['import toast from "$lib/utils/toast.svelte"'].join(";");
+    types = [
+        "type ValidatorResult = string | null",
+        "type ValidatorFn<T> = (v: T) => ValidatorResult",
+        "type BundleResult<T> = T extends { bundle: () => infer R } ? R : T;",
+        `type Partial<T> = {
+          [K in Exclude<keyof T, "bundle">]?: BuildedInput<T[K]>;
+        } & {
+          bundle: unknown;
+        }`,
+    ].join(";");
+    classes = [
+        `export class Behavior<TSuccess = unknown, TError = unknown> {
+      onError?: (e: TError) => void;
+      onSuccess?: (v: TSuccess) => void;
+    }`,
+        `export class BuildedInput<T> {
+      value = $state<T>(null as any);
+      display = $state<T>(null as any);
+      required: boolean;
+      placeholder: T;
+      readonly validator?: ValidatorFn<T>;
+
+      constructor(params: { key?: T | undefined; example: T; required: boolean; validator?: ValidatorFn<T> }) {
+        const { example, required, key, validator } = params;
+
+        const initial = key ?? example;
+
+        this.value = initial;
+        this.display = initial;
+        this.required = required;
+        this.placeholder = example;
+
+        if (validator) {
+          this.validator = validator;
+        }
+      }
+
+      validate(): ValidatorResult {
+        if (!this.validator) return null;
+        return this.validator(this.value);
+      }
+    }`,
+    ].join(";");
+    functions = [
+        `export function build<T>(params: {
+      key?: T | undefined;
+      example: T;
+      required: boolean;
+      validator?: ValidatorFn<T>;
+    }): BuildedInput<T> {
+      return new BuildedInput(params);
+    }`,
+        `export function isFormValid<T>(schema: Partial<T>): boolean {
+      delete schema.bundle;
+
+      const arrayOfBuildedInputs = Object.values(schema) as BuildedInput<unknown>[];
+
+      const isValid = arrayOfBuildedInputs.every((a) => a.validate() === null);
+
+      if (!isValid) {
+        toast.error('Erro ao fazer a requisição', 'Um ou mais campos preenchidos estão incorretos.');
+      }
+
+      return isValid;
+    }`,
+        `export function genericArrayBundler<T>(data: T[]): BundleResult<T>[] {
+      return data.map((item) => {
+        if (typeof (item as any)?.bundle === 'function') {
+          return (item as any).bundle();
+        }
+        return item;
+      });
+    }`,
+    ].join(";");
+    fileContent = `
+    ${this.imports}
+
+    ${this.types}
+
+    ${this.classes}
+
+    ${this.functions}
+  `;
+}

package/dist/schema.js

@@ -43,7 +43,7 @@ export class Schema {
             if (type === "object")
                 continue;
             if (type === "array") {
-                this.arrayProps.push(new ArrayProp({ schemaObject: value, schemaName: this.name, name: key }));
+                this.arrayProps.push(new ArrayProp({ schemaObject: value, schemaName: this.name, name: key, required }));
             }
             else {
                 this.primitiveProps.push(new PrimitiveProp({ name: key, schemaObject: value, required, validator }));
@@ -80,7 +80,7 @@ export class Schema {
     export class ${this.name} {
       ${keys.join(";")}
 
-      constructor(params?: ${this.name}Interface) { 
+      constructor(params?: { data?: ${this.name}Interface | undefined, empty?: boolean }) { 
         ${constructorThis.join(";\n")}
       }
 

package/package.json

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