svelte-reflector 1.0.14 → 1.0.15

package/dist/helpers/helpers.d.ts

@@ -4,6 +4,7 @@ export declare function sanitizeNumber(texto: string): string;
 export declare function capitalizeFirstLetter(text: string): string;
 export declare function splitByUppercase(text: string): string[];
 export declare function treatByUppercase(text?: string): string;
+export declare function treatAndUpper(text: string): string;
 export declare function createDangerMessage(text: string): void;
 export declare function getFilteredEntities(rawEndpoint: string): string[];
 export declare function getEndpointAndModuleName(rawEndpoint: string): {

package/dist/helpers/helpers.js

@@ -7,7 +7,19 @@
 //   if (!lhs) return "";
 //   return `${lhs.trim()} = ${cleaned}`;
 // }
-const trashWords = new Set(["Kyc", "Get", "Customer", "Response", "Res", "Self", "Admin"]);
+const trashWords = new Set([
+    "Kyc",
+    "Get",
+    "Customer",
+    "Response",
+    "Res",
+    "Self",
+    "Admin",
+    "Default",
+    "Owner",
+    "Member",
+    "Public",
+]);
 export function toCamelCase(str) {
     return str
         .split("-")
@@ -58,6 +70,9 @@ export function treatByUppercase(text) {
     }
     return out.length > 0 ? out : "entity";
 }
+export function treatAndUpper(text) {
+    return capitalizeFirstLetter(treatByUppercase(text));
+}
 export function createDangerMessage(text) {
     console.log("\x1b[31m%s\x1b[0m", `[!] ${text}`);
 }

package/dist/main.js

@@ -81,10 +81,12 @@ export class Reflector {
         return modules;
     }
     build() {
+        const enums = new Set();
         const treatedSchemas = this.schemas.map((s) => {
+            s.enums.forEach((en) => enums.add(en));
             return s.schema;
         });
-        const teste = `
+        const buildFunction = `
       function build<T>(params: { key?: T; example: T; required: boolean }) {
         const { example, required, key } = params;
 
@@ -96,7 +98,12 @@ export class Reflector {
         } as FieldSetup<T>
       }
     `;
-        this.schemaFile.changeData(["import type { FieldSetup } from '$repository/types';", teste, ...treatedSchemas].join("\n\n"));
+        this.schemaFile.changeData([
+            "import type { FieldSetup } from '$repository/types';",
+            buildFunction,
+            // ...Array.from(enums),
+            ...treatedSchemas,
+        ].join("\n\n"));
         this.schemaFile.save();
         this.typesSrc.changeData("export class Behavior { onError?: (e) => void; onSuccess?: () => void }");
         this.typesSrc.save();

package/dist/method.js

@@ -74,7 +74,7 @@ export class Method {
         // const props = this.getProps();
         if (this.request.apiType === "get") {
             if (this.request.attributeType === "list") {
-                beforeResponse.push(`const {data: { data, ...params }} = response`, "\n\n", `this.list = data`, "repo.intercept.rebuild(this.querys, params)");
+                beforeResponse.push(`const {data: { data }} = response`, "\n\n", `this.list = data`);
                 const inside = `
           const response = await repo.api.get<{data: ${this.request.responseType}}, unknown>({
             endpoint,

package/dist/module.d.ts

@@ -21,6 +21,7 @@ export declare class Module {
         path: string;
         dir: string;
     });
+    private buildZObject;
     private creator;
     private getPath;
     private getAdditionalMethod;

package/dist/module.js

@@ -55,34 +55,38 @@ export class Module {
             data: this.buildFile({ moduleAttributes, moduleTypes, moduleInit, moduleClear }),
         });
     }
-    // private buildZObject(props: SchemaProp[]) {
-    //   const teste = `z.object({${props.map((p) => p.buildedProp)}})`;
-    //   return teste;
-    // }
+    buildZObject(props) {
+        const teste = props
+            .map((prop) => {
+            return `${prop.name} = $state(${prop.emptyExample})`;
+        })
+            .join(";");
+        return teste;
+    }
     creator() {
         const buildedModuleTypes = [];
         const moduleAttributes = new Set().add("loading = $state<boolean>(false)");
         const moduleInit = new Set([]);
         const moduleClear = new Set([]);
-        const getXablau = (params) => {
+        const getParams = (params) => {
             const { name, objets } = params;
             const capitalizedName = capitalizeFirstLetter(name);
-            // buildedModuleTypes.push(`const ${capitalizedName}Schema = ${this.buildZObject(objets)}`);
-            moduleAttributes.add(`${name} = $state(repo.newForm(${capitalizedName}Schema))`);
+            buildedModuleTypes.push(`class ${capitalizedName}Schema { ${this.buildZObject(objets)} }`);
+            moduleAttributes.add(`${name} = $state(new ${capitalizedName}Schema())`);
             moduleInit.add(`this.clear${capitalizeFirstLetter(capitalizedName)}()`);
             moduleClear.add(`clear${capitalizedName}() { this.${name} = new ${capitalizedName}Schema() }`);
         };
         if (this.querys.length > 0) {
-            getXablau({ name: "querys", objets: this.querys });
+            getParams({ name: "querys", objets: this.querys });
         }
         if (this.headers.length > 0) {
-            getXablau({ name: "headers", objets: this.headers });
+            getParams({ name: "headers", objets: this.headers });
         }
         if (this.paths.length > 0) {
-            getXablau({ name: "paths", objets: this.paths });
+            getParams({ name: "paths", objets: this.paths });
         }
         if (this.cookies.length > 0) {
-            getXablau({ name: "cookies", objets: this.cookies });
+            getParams({ name: "cookies", objets: this.cookies });
         }
         const form = [];
         for (const method of this.methods) {
@@ -192,10 +196,7 @@ export class Module {
                 entries.add(`${bodyType}`);
             }
             if (responseType) {
-                if (apiType === "delete") {
-                    entries.add(`${responseType}`);
-                }
-                entries.add(`type ${responseType}`);
+                entries.add(`${responseType}`);
             }
         }
         const cleanEntries = Array.from(entries).filter((x) => x != "type any");

package/dist/property.d.ts

@@ -1,13 +1,15 @@
 import { type ParameterLocation, type SchemaObject } from "./types/open-api-spec.interface.js";
 import { type Example, type ReflectorParamType } from "./types/types.js";
 export declare class SchemaProp {
+    inParam: ParameterLocation;
     example: string;
     emptyExample: string;
     name: string;
     bType: string;
     isRequired: boolean;
-    paramType: ReflectorParamType;
+    reflectorType: ReflectorParamType;
     buildedValue: string;
+    enums?: string;
     constructor(params: {
         schemaName?: string;
         name: string;
@@ -20,10 +22,12 @@ export declare class SchemaProp {
         inParam: ParameterLocation;
     });
     private getBuildedValue;
-    getEmptyExample(type: ReflectorParamType): false | 0 | "''";
+    getEmptyExample(params: {
+        type: ReflectorParamType;
+        schemaObject: SchemaObject;
+    }): string | false | 0;
     private getExample;
     private deepValidator;
-    private isNullable;
     private treatName;
     private getType;
 }

package/dist/property.js

@@ -1,4 +1,3 @@
-import { sanitizeNumber, treatenEnum } from "./helpers/helpers.js";
 import { ReflectorInput } from "./helpers/input.js";
 import {} from "./types/open-api-spec.interface.js";
 import {} from "./types/types.js";
@@ -11,7 +10,7 @@ export class SchemaProp {
     // buildedProp: string;
     // description?: string;
     // required: boolean;
-    // inParam: ParameterLocation;
+    inParam;
     // isEnum: boolean = false;
     // enums: string[] = [];
     example;
@@ -19,64 +18,84 @@ export class SchemaProp {
     name;
     bType;
     isRequired;
-    paramType;
+    reflectorType;
     buildedValue;
+    enums;
     constructor(params) {
         const { schemaName, name, schemaObject, type, example, required, description, isEmpty, inParam } = params;
+        if (schemaObject.enum) {
+            this.enums = schemaObject.enum.map((e) => `'${e}'`).join("|");
+        }
         // this.inParam = inParam;
         // this.isEnum = false;
-        this.paramType = type;
+        this.inParam = inParam;
+        this.reflectorType = schemaObject.enum ? "enum" : type;
         this.isRequired = required;
         this.name = this.treatName(name);
-        this.bType = this.getType({ type, schemaName });
-        this.example = `${this.getExample({ example, type })}`;
-        this.emptyExample = `${this.getEmptyExample(type)}`;
+        this.bType = this.getType({ type, schemaName, schemaObject });
+        this.example = `${this.getExample({ example, type, schemaObject })}`;
+        this.emptyExample = `${this.getEmptyExample({ schemaObject, type: this.reflectorType })}`;
         this.buildedValue = this.getBuildedValue({
             example: this.example,
             isRequired: this.isRequired,
-            name: this.name,
             type,
             bType: this.bType,
+            enums: this.enums,
+            schemaObject,
         });
     }
     getBuildedValue(params) {
-        const { example, isRequired, name, type, bType } = params;
+        const { example, isRequired, type, bType, enums, schemaObject } = params;
         let content = "";
-        // let emptyContent: string = "";
+        const diamondType = enums ? `<${enums}>` : "";
         if (type === "number" || type === "string" || type === "boolean") {
-            content = `build({key: ${this.getEmptyExample(type)}, example: ${example}, required: ${isRequired}})`;
+            content = `build${diamondType}({key: ${this.getEmptyExample({ type, schemaObject })}, example: ${example}, required: ${isRequired}})`;
         }
         else if (type === "object") {
             content = `new ${bType}()`;
-            // emptyContent = `new ${bType}()`;
         }
         else if (type === "array") {
             content = "[]";
-            // emptyContent = "[]";
         }
         return content;
     }
-    // private getDtoName(ref: string) {
-    //   const splittedRef = ref.split("/");
-    //   const dto = splittedRef[splittedRef.length - 1];
-    //   return dto;
-    // }
-    getEmptyExample(type) {
+    getEmptyExample(params) {
+        const { schemaObject, type } = params;
         if (type === "number") {
             return 0;
         }
         else if (type === "boolean") {
             return false;
         }
+        else if (schemaObject.enum) {
+            return `'${schemaObject.enum[0]}'`;
+        }
         else {
             return "''";
         }
     }
     getExample(params) {
-        const { example, type } = params;
+        const { example, type, schemaObject } = params;
+        // if (schemaObject.enum) {
+        //   return `'${schemaObject.enum[0]}'`;
+        // }
         const sanitizedExample = type === "boolean" || type === "number" ? example : `"${example}"`;
-        return example ? sanitizedExample : this.getEmptyExample(type);
+        return example ? sanitizedExample : this.getEmptyExample({ schemaObject, type });
     }
+    // private getExample(params: { example: Example | undefined; type: ReflectorParamType; schemaObject: SchemaObject }) {
+    //   const { example, type, schemaObject } = params;
+    //   const sanitizedExample = () => {
+    //     if (!example || type === "enum") {
+    //       return this.getEmptyExample({ schemaObject, type });
+    //     } else if (type === "boolean" || type === "number") {
+    //       return example;
+    //     } else {
+    //       return `"${example}"`;
+    //     }
+    //   };
+    //   console.log(sanitizedExample());
+    //   return sanitizedExample();
+    // }
     deepValidator(params) {
         const { name } = params;
         if (name === "email") {
@@ -93,19 +112,26 @@ export class SchemaProp {
             return false;
         }
     }
-    isNullable(isRequired) {
-        return isRequired ? "" : " | null";
-    }
     treatName(name) {
-        return name;
+        let newName = name;
+        if (name.split("-").length > 1) {
+            newName = `['${name}']`;
+        }
+        return newName;
     }
     getType(params) {
-        const { type, schemaName } = params;
+        const { type, schemaName, schemaObject } = params;
         if (type === "object") {
             return `${schemaName}`;
         }
         else if (type === "array") {
-            return `${schemaName}[]`;
+            let name = schemaName;
+            const teste = schemaObject.items;
+            if (teste && "$ref" in teste) {
+                const a = teste.$ref;
+                name = a.split("/").at(-1);
+            }
+            return `${name}[]`;
         }
         else {
             return type;

package/dist/schema.js

@@ -1,3 +1,4 @@
+import { capitalizeFirstLetter, splitByUppercase, treatAndUpper, treatByUppercase } from "./helpers/helpers.js";
 import { SchemaProp } from "./property.js";
 export class Schema {
     name;
@@ -20,6 +21,7 @@ export class Schema {
             }
             const required = requireds.includes(key);
             const teste = value.items;
+            // const enumName = `Enum${treatAndUpper(name)}${capitalizeFirstLetter(key)}`;
             if (teste && !("$ref" in teste) && teste.enum) {
                 this.enums.add(this.getEnumConst({ enums: teste.enum, schemaName: key }));
             }
@@ -41,10 +43,10 @@ export class Schema {
             .map((p) => {
             const keyName = `${p.name}${p.isRequired ? "" : "?"}`;
             let state;
-            if (p.paramType === "object") {
+            if (p.reflectorType === "object") {
                 state = `$state<${p.bType}>()`;
             }
-            else if (p.paramType === "array") {
+            else if (p.reflectorType === "array") {
                 state = `$state<${p.bType}>([])`;
             }
             else {
@@ -58,10 +60,6 @@ export class Schema {
             return `${k} = $state(new ${v}())`;
         })
             .join(";\n");
-        // const builded = this.properties.map((p) => ).join(";\n\n\n");
-        if (this.name === "OwnerFinishSignUpDataDto") {
-            console.log(properties);
-        }
         this.schema = `export class ${this.name} {
       ${keys}
       ${this.properties.length > 0 ? ";" : ""}
@@ -70,7 +68,7 @@ export class Schema {
     }
     getEnumConst(params) {
         const { enums, schemaName } = params;
-        const enumList = enums.map((en) => `'${en}'`);
-        return `export const ${schemaName}EnumSchema = z.enum([${enumList}])`;
+        const enumList = enums.map((en) => `'${en}'`).join("|");
+        return `export type Enum${capitalizeFirstLetter(schemaName)} = ${enumList}`;
     }
 }

package/dist/types/types.d.ts

@@ -1,5 +1,5 @@
 import type { OperationObject } from "./open-api-spec.interface.js";
-export type ReflectorParamType = "string" | "boolean" | "number" | "array" | "object";
+export type ReflectorParamType = "string" | "boolean" | "number" | "array" | "object" | "enum";
 export type ApiType = "get" | "post" | "delete" | "patch" | "put";
 export type ReflectorOperation = OperationObject & {
     apiMethod: ApiType;

package/package.json

@@ -1,32 +1,32 @@
-{
-  "name": "svelte-reflector",
-  "version": "1.0.14",
-  "description": "Reflects zod types from openAPI schemas",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "bin": {
-    "reflect": "./dist/cli.js"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "build": "tsc"
-  },
-  "dependencies": {
-    "axios": "^1.12.2",
-    "dotenv": "^16.4.5"
-  },
-  "devDependencies": {
-    "@types/node": "^24.8.1",
-    "prettier": "^3.6.2",
-    "typescript": "^5.9.3"
-  }
-}
+{
+  "name": "svelte-reflector",
+  "version": "1.0.15",
+  "description": "Reflects zod types from openAPI schemas",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "bin": {
+    "reflect": "./dist/cli.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "axios": "^1.12.2",
+    "dotenv": "^16.4.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.8.1",
+    "prettier": "^3.6.2",
+    "typescript": "^5.9.3"
+  }
+}