svelte-reflector 1.0.50 → 1.0.52

package/dist/helpers/helpers.d.ts

@@ -13,4 +13,3 @@ export declare function getEndpointAndModuleName(rawEndpoint: string): {
 };
 export declare function getEndpoint(rawEndpoint: string): string;
 export declare function getFullEndpoint(rawEndpoint: string): string;
-export declare function treatenEnum(enums: string[]): string;

package/dist/helpers/helpers.js

@@ -10,6 +10,12 @@
 const trashWords = new Set([
     "Kyc",
     "Get",
+    "Update",
+    "Close",
+    "Find",
+    "Change",
+    "List",
+    "Create",
     "Customer",
     "Response",
     "Res",
@@ -17,7 +23,10 @@ const trashWords = new Set([
     "Admin",
     "Default",
     "Owner",
+    "Repo",
+    "Formatted",
     "Member",
+    "Dto",
     "Public",
 ]);
 export function toCamelCase(str) {
@@ -105,7 +114,7 @@ export function getFullEndpoint(rawEndpoint) {
     })
         .join("/");
 }
-export function treatenEnum(enums) {
-    const a = enums.map((e) => `"${e}"`);
-    return ` z.literal([${a}])`;
-}
+// export function treatenEnum(enums: string[]) {
+//   const a = enums.map((e) => `"${e}"`);
+//   return ` z.literal([${a}])`;
+// }

package/dist/main.d.ts

@@ -3,6 +3,7 @@ import { Schema } from "./schema.js";
 import type { ComponentsObject, PathsObject, OpenAPIObject } from "./types/open-api-spec.interface.js";
 import type { FieldValidators } from "./types/types.js";
 import { Module } from "./module.js";
+export declare const enumTypes: Map<string, string>;
 export declare class Reflector {
     readonly components: ComponentsObject;
     readonly paths: PathsObject;
@@ -12,6 +13,7 @@ export declare class Reflector {
     readonly typesSrc: Source;
     readonly schemaFile: Source;
     readonly fieldsFile: Source;
+    readonly enumFile: Source;
     files: Source[];
     schemas: Schema[];
     modules: Module[];

package/dist/main.js

@@ -7,6 +7,7 @@ import { Module } from "./module.js";
 import { baseDir, generatedDir } from "./vars.global.js";
 import { ReflectorFile } from "./reflector.js";
 // import { Module } from "./module.js";
+export const enumTypes = new Map();
 export class Reflector {
     components;
     paths;
@@ -16,6 +17,7 @@ export class Reflector {
     typesSrc = new Source({ path: path.resolve(process.cwd(), `${generatedDir}/reflector.svelte.ts`) });
     schemaFile = new Source({ path: path.resolve(process.cwd(), `${generatedDir}/schemas.svelte.ts`) });
     fieldsFile = new Source({ path: path.resolve(process.cwd(), `${generatedDir}/fields.ts`) });
+    enumFile = new Source({ path: path.resolve(process.cwd(), `${generatedDir}/enums.ts`) });
     files;
     schemas;
     modules;
@@ -103,6 +105,7 @@ export class Reflector {
         this.schemaFile.changeData([
             'import { build, BuildedInput } from "$reflector/reflector.svelte";',
             'import { validateInputs } from "$lib/sanitizers/validateFormats";',
+            `import {${Array.from(enumTypes.values())}} from "$reflector/enums"`,
             // ...Array.from(enums),
             ...treatedSchemas,
         ].join("\n\n"));
@@ -122,6 +125,13 @@ export class Reflector {
                 continue;
             module.src.save();
         }
+        const enumss = Array.from(enumTypes)
+            .map(([types, key]) => {
+            return `export enum ${key} { ${types} }`;
+        })
+            .join(";");
+        this.enumFile.changeData(enumss);
+        this.enumFile.save();
         return {};
     }
     localSave(data) {

package/dist/props/array.property.js

@@ -26,7 +26,7 @@ export class ArrayProp {
             return schemaName;
         if (items && !("$ref" in items) && items.enum) {
             this.isPrimitiveType = true;
-            const enumType = new EnumProp({ enums: items.enum, name: this.name, required: true }).type;
+            const enumType = new EnumProp({ enums: items.enum, name: this.name, required: true, entityName: schemaName }).type;
             return `(${enumType})`;
         }
         if ("$ref" in items) {

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

@@ -2,6 +2,7 @@ export declare class EnumProp {
     name: string;
     isParam: boolean;
     readonly type: string;
+    enumName: string;
     private readonly isRequired;
     private readonly example;
     constructor(params: {
@@ -9,6 +10,7 @@ export declare class EnumProp {
         enums: string[];
         required: boolean;
         isParam?: boolean;
+        entityName: string;
     });
     classBuild(): string;
     constructorBuild(): string;

package/dist/props/enum.property.js

@@ -1,27 +1,38 @@
+import { splitByUppercase, treatByUppercase } from "../helpers/helpers.js";
+import { enumTypes } from "../main.js";
 export class EnumProp {
     name;
     isParam;
     type;
+    enumName;
     isRequired;
     example;
     constructor(params) {
-        const { name, required, isParam, enums } = params;
+        const { name, required, isParam, enums, entityName } = params;
         this.name = name;
         this.isParam = !!isParam;
         this.isRequired = required;
         this.type = enums.map((e) => `'${e}'`).join("|");
+        const types = enumTypes.get(enums.join(","));
+        if (!types) {
+            const teste = splitByUppercase(treatByUppercase(entityName)).map((x) => x.toUpperCase());
+            const naaa = `ENUM_${teste.join("_")}_${this.name.toUpperCase()}`.split("_");
+            const aaa = [...new Set(naaa)].join("_");
+            enumTypes.set(enums.join(","), aaa);
+        }
         this.example = enums[0];
+        this.enumName = enumTypes.get(enums.join(",")) ?? "";
     }
     classBuild() {
         const req = this.isRequired ? "" : "?";
-        return `${this.name}${req}: BuildedInput<${this.type}>`;
+        return `${this.name}${req}: BuildedInput<${this.enumName}>`;
     }
     constructorBuild() {
-        return `this.${this.name} = build({ key: params?.data?.${this.name}, placeholder: '${this.example}', example: '${this.example}', required: ${this.isRequired}})`;
+        return `this.${this.name} = build({ key: params?.data?.${this.name}, placeholder: ${this.enumName}.${this.example}, example: ${this.enumName}.${this.example}, required: ${this.isRequired}})`;
     }
     interfaceBuild() {
         const req = this.isRequired ? "" : "?";
-        return `${this.name}${req}: ${this.type}`;
+        return `${this.name}${req}: ${this.enumName}`;
     }
     bundleBuild() {
         return `${this.name}: this.${this.name}?.value`;

package/dist/props/object.property.js

@@ -19,7 +19,8 @@ export class ObjectProp {
     classBuild() {
         const req = this.required ? "" : "?";
         const nullable = this.isNullable ? "| null" : "";
-        return `${this.name}${req}: ${this.type} ${nullable}`;
+        const defaultVar = this.isNullable ? "null" : `new ${this.type}`;
+        return `${this.name}${req} = $state<${this.type} ${nullable}>(${defaultVar})`;
     }
     interfaceBuild() {
         const req = this.required ? "" : "?";

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

@@ -25,4 +25,7 @@ export declare class PrimitiveProp {
     interfaceBuild(): string;
     bundleBuild(): string;
 }
+export declare class PrimitivePropParam extends PrimitiveProp {
+    classBuild(): string;
+}
 export {};

package/dist/props/primitive.property.js

@@ -100,3 +100,8 @@ export class PrimitiveProp {
         return `${this.name}: ${this.thisDot()}${this.name}?.value`;
     }
 }
+export class PrimitivePropParam extends PrimitiveProp {
+    classBuild() {
+        return `${this.name} = $derived.by(() => page.params.${this.name})`;
+    }
+}

package/dist/schema.js

@@ -95,7 +95,7 @@ export class Schema {
                 continue;
             }
             else if (value.enum) {
-                this.enumProps.push(new EnumProp({ enums: value.enum, name, required }));
+                this.enumProps.push(new EnumProp({ enums: value.enum, name, required, entityName: schemaName }));
                 continue;
             }
             const validator = validators.get(key);

package/package.json

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