svelte-reflector 1.0.13 → 1.0.15

package/dist/constructor.d.ts

@@ -0,0 +1,2 @@
+export declare class SchemaConstructor {
+}

package/dist/constructor.js

@@ -0,0 +1,2 @@
+export class SchemaConstructor {
+}

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

@@ -1,9 +1,10 @@
 import * as path from "node:path";
 import * as fs from "node:fs";
 import { Source } from "./file.js";
-import { getEndpoint, splitByUppercase, testeEndpoint } from "./helpers/helpers.js";
+import { getEndpoint, splitByUppercase } from "./helpers/helpers.js";
 import { Schema } from "./schema.js";
 import { Module } from "./module.js";
+// import { Module } from "./module.js";
 export class Reflector {
     components;
     paths;
@@ -12,7 +13,7 @@ export class Reflector {
     localDoc = new Source({ path: path.resolve(process.cwd(), `${this.dir}/backup.json`) });
     src = new Source({ path: path.resolve(process.cwd(), `${this.generatedDir}/controllers`) });
     typesSrc = new Source({ path: path.resolve(process.cwd(), `${this.generatedDir}/reflector.types.ts`) });
-    schemaFile = new Source({ path: path.resolve(process.cwd(), `${this.generatedDir}/schemas.ts`) });
+    schemaFile = new Source({ path: path.resolve(process.cwd(), `${this.generatedDir}/schemas.svelte.ts`) });
     files;
     schemas;
     modules;
@@ -39,7 +40,7 @@ export class Reflector {
                 name: key,
                 requireds: object.required || [],
             };
-            schemas.push(new Schema({ ...schema, isEmpty: false }), new Schema({ ...schema, isEmpty: true }));
+            schemas.push(new Schema({ ...schema, isEmpty: false }));
         }
         console.log(`${schemas.length} schemas gerados com sucesso.`);
         return schemas;
@@ -80,10 +81,29 @@ export class Reflector {
         return modules;
     }
     build() {
+        const enums = new Set();
         const treatedSchemas = this.schemas.map((s) => {
-            return `${s.schema} ${s.type}`;
+            s.enums.forEach((en) => enums.add(en));
+            return s.schema;
         });
-        this.schemaFile.changeData([`import z from 'zod';`, ...treatedSchemas].join("\n\n"));
+        const buildFunction = `
+      function build<T>(params: { key?: T; example: T; required: boolean }) {
+        const { example, required, key } = params;
+
+        return {
+          value: key ?? example,
+          display: key ?? example,
+          required,
+          placeholder: example,
+        } as FieldSetup<T>
+      }
+    `;
+        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.d.ts

@@ -1,15 +1,15 @@
 import { Request } from "./request.js";
-import { ZodProperty } from "./zodProperty.js";
 import type { ReflectorOperation } from "./types/types.js";
+import { SchemaProp } from "./property.js";
 export declare class Method {
     name: string;
     description: string | undefined;
     endpoint: string;
     request: Request;
-    paths: ZodProperty[];
-    headers: ZodProperty[];
-    querys: ZodProperty[];
-    cookies: ZodProperty[];
+    paths: SchemaProp[];
+    headers: SchemaProp[];
+    querys: SchemaProp[];
+    cookies: SchemaProp[];
     constructor(params: {
         operation: ReflectorOperation;
         moduleName: string;

package/dist/method.js

@@ -1,9 +1,9 @@
 import { Request } from "./request.js";
-import { ZodProperty } from "./zodProperty.js";
-import { createDangerMessage, getEndpoint, testeEndpoint, treatByUppercase } from "./helpers/helpers.js";
+import { createDangerMessage, testeEndpoint, treatByUppercase } from "./helpers/helpers.js";
+import { SchemaProp } from "./property.js";
 export class Method {
     name;
-    // zodProperties: ZodProperty[];
+    // zodProperties: Property[];
     description;
     endpoint;
     request;
@@ -42,16 +42,16 @@ export class Method {
                 inParam,
             };
             if (inParam === "query") {
-                this.querys.push(new ZodProperty(zodPropertie));
+                this.querys.push(new SchemaProp(zodPropertie));
             }
             else if (inParam === "header") {
-                this.headers.push(new ZodProperty(zodPropertie));
+                this.headers.push(new SchemaProp(zodPropertie));
             }
             else if (inParam === "path") {
-                this.paths.push(new ZodProperty(zodPropertie));
+                this.paths.push(new SchemaProp(zodPropertie));
             }
             else if (inParam === "cookie") {
-                this.paths.push(new ZodProperty(zodPropertie));
+                this.paths.push(new SchemaProp(zodPropertie));
             }
         }
     }
@@ -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

@@ -1,7 +1,7 @@
 import { Source } from "./file.js";
 import { Method } from "./method.js";
 import type { ReflectorOperation } from "./types/types.js";
-import { ZodProperty } from "./zodProperty.js";
+import type { SchemaProp } from "./property.js";
 export declare class Module {
     readonly name: string;
     readonly path: string;
@@ -9,10 +9,10 @@ export declare class Module {
     readonly src: Source;
     imports: Set<string>;
     methods: Method[];
-    querys: ZodProperty[];
-    paths: ZodProperty[];
-    headers: ZodProperty[];
-    cookies: ZodProperty[];
+    querys: SchemaProp[];
+    paths: SchemaProp[];
+    headers: SchemaProp[];
+    cookies: SchemaProp[];
     moduleConstructor: string;
     constructor(params: {
         name: string;

package/dist/module.js

@@ -3,7 +3,6 @@ import * as fs from "node:fs";
 import { Source } from "./file.js";
 import { capitalizeFirstLetter, createDangerMessage, treatByUppercase } from "./helpers/helpers.js";
 import { Method } from "./method.js";
-import { ZodProperty } from "./zodProperty.js";
 export class Module {
     name;
     path;
@@ -24,7 +23,6 @@ export class Module {
             'import repo from "$repository/main"',
             'import { Behavior } from "$reflector/reflector.types";',
             'import { PUBLIC_ENVIRONMENT } from "$env/static/public";',
-            'import z from "zod";',
         ]);
         this.name = capitalizeFirstLetter(name);
         this.path = path;
@@ -58,7 +56,11 @@ export class Module {
         });
     }
     buildZObject(props) {
-        const teste = `z.object({${props.map((p) => p.buildedProp)}})`;
+        const teste = props
+            .map((prop) => {
+            return `${prop.name} = $state(${prop.emptyExample})`;
+        })
+            .join(";");
         return teste;
     }
     creator() {
@@ -66,25 +68,25 @@ export class Module {
         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} = repo.newForm(${capitalizedName}Schema) }`);
+            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) {
@@ -106,13 +108,10 @@ export class Module {
                 moduleInit.add("this.clearList()");
                 moduleClear.add(`clearList() { this.list = [] }`);
             }
-            if (attributeType === "list" || this.querys.length > 0 || this.headers.length > 0) {
-                this.imports.add(`import z from "zod";`);
-            }
         }
         const formSet = new Set();
         for (const f of form) {
-            formSet.add(`${f.name}: repo.newForm(Empty${f.type}Schema)`);
+            formSet.add(`${f.name}: new ${f.type}()`);
         }
         if (formSet.size > 0) {
             moduleAttributes.add(`
@@ -194,20 +193,16 @@ export class Module {
         for (const method of this.methods) {
             const { bodyType, responseType, apiType } = method.request;
             if (bodyType) {
-                entries.add(`${bodyType}Schema`);
-                entries.add(`Empty${bodyType}Schema`);
+                entries.add(`${bodyType}`);
             }
             if (responseType) {
-                if (apiType === "delete") {
-                    entries.add(`${responseType}Schema`);
-                }
-                entries.add(`type ${responseType}`);
+                entries.add(`${responseType}`);
             }
         }
         const cleanEntries = Array.from(entries).filter((x) => x != "type any");
         if (cleanEntries.length === 0)
             return "";
-        return `import { ${cleanEntries} } from '$reflector/schemas';`;
+        return `import { ${cleanEntries} } from '$reflector/schemas.svelte';`;
     }
     buildClass(params) {
         const { moduleInit, moduleAttributes, moduleClear } = params;
@@ -220,7 +215,7 @@ export class Module {
         ${this.buildMethods().join("\n")}
 
         ${moduleClear.join("\n\n")}
-        
+
         reset() {
           ${moduleInit.join(";")}
         }
@@ -230,7 +225,7 @@ export class Module {
     buildConstructor(form) {
         if (form.length === 0)
             return "";
-        const teste = `        
+        const teste = `
       constructor(params?: { empty: boolean }) {
         const isEmpty = params?.empty || PUBLIC_ENVIRONMENT != 'DEV'
 
@@ -241,7 +236,7 @@ export class Module {
         if(isEmpty) return this.forms
 
         return {
-          ${form.map((f) => `${f.name}: repo.newForm(${f.type}Schema)`)}
+          ${form.map((f) => `${f.name}: new ${f.type}()`)}
         }
       }
     `;

package/dist/property.d.ts

@@ -1,14 +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 ZodProperty {
-    schemaName?: string;
-    name: string;
-    example: Example | undefined;
-    type: ReflectorParamType;
-    buildedProp: string;
-    description?: string;
-    required: boolean;
+export declare class SchemaProp {
     inParam: ParameterLocation;
+    example: string;
+    emptyExample: string;
+    name: string;
+    bType: string;
+    isRequired: boolean;
+    reflectorType: ReflectorParamType;
+    buildedValue: string;
+    enums?: string;
     constructor(params: {
         schemaName?: string;
         name: string;
@@ -20,11 +21,13 @@ export declare class ZodProperty {
         isEmpty: boolean;
         inParam: ParameterLocation;
     });
-    private getDtoName;
-    private getEmptyExample;
+    private getBuildedValue;
+    getEmptyExample(params: {
+        type: ReflectorParamType;
+        schemaObject: SchemaObject;
+    }): string | false | 0;
     private getExample;
     private deepValidator;
-    private isNullable;
     private treatName;
-    private build;
+    private getType;
 }

package/dist/property.js

@@ -1,116 +1,140 @@
-import { sanitizeNumber, splitByUppercase } from "./helpers/helpers.js";
 import { ReflectorInput } from "./helpers/input.js";
 import {} from "./types/open-api-spec.interface.js";
 import {} from "./types/types.js";
 const inputs = new ReflectorInput();
-export class ZodProperty {
-    schemaName;
-    name;
-    example;
-    type;
-    buildedProp;
-    description;
-    required;
+export class SchemaProp {
+    // schemaName?: string;
+    // name: string;
+    // example: Example | undefined;
+    // type: ReflectorParamType;
+    // buildedProp: string;
+    // description?: string;
+    // required: boolean;
     inParam;
+    // isEnum: boolean = false;
+    // enums: string[] = [];
+    example;
+    emptyExample;
+    name;
+    bType;
+    isRequired;
+    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.inParam = inParam;
-        if (schemaName) {
-            this.schemaName = schemaName;
+        this.reflectorType = schemaObject.enum ? "enum" : type;
+        this.isRequired = required;
+        this.name = this.treatName(name);
+        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,
+            type,
+            bType: this.bType,
+            enums: this.enums,
+            schemaObject,
+        });
+    }
+    getBuildedValue(params) {
+        const { example, isRequired, type, bType, enums, schemaObject } = params;
+        let content = "";
+        const diamondType = enums ? `<${enums}>` : "";
+        if (type === "number" || type === "string" || type === "boolean") {
+            content = `build${diamondType}({key: ${this.getEmptyExample({ type, schemaObject })}, example: ${example}, required: ${isRequired}})`;
         }
-        if (name.split("-").length > 1) {
-            this.name = `['${name}']`;
+        else if (type === "object") {
+            content = `new ${bType}()`;
         }
-        else {
-            this.name = name;
+        else if (type === "array") {
+            content = "[]";
         }
-        this.required = required;
-        this.type = type;
-        this.example = isEmpty ? this.getEmptyExample() : this.getExample(example);
-        this.buildedProp = this.build(schemaObject);
-        if (description)
-            this.description = description;
-    }
-    getDtoName(ref) {
-        const cavalos = ref.split("/");
-        const dto = cavalos[cavalos.length - 1];
-        return dto;
+        return content;
     }
-    getEmptyExample() {
-        switch (this.type) {
-            case "number":
-                return 0;
-            case "boolean":
-                return false;
-            case "string":
-                return "";
-            default:
-                return "";
+    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(example) {
-        if (example)
-            return example;
-        return this.getEmptyExample();
+    getExample(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({ schemaObject, type });
     }
-    deepValidator() {
-        if (this.name === "email") {
-            return `z.email().default('${this.example}')`;
+    // 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") {
+            // return `z.email().default('${this.example}')`;
+            return "Email";
         }
-        else if (this.name === "password") {
-            return inputs.password;
+        else if (name === "password") {
+            return "Password";
         }
+        // else if (this.isEnum) {
+        //   return `${treatenEnum(this.enums)}.default('${this.enums[0]}')`;
+        // }
         else {
             return false;
         }
     }
-    isNullable() {
-        return this.required ? "" : ".nullable()";
-    }
     treatName(name) {
-        return name;
+        let newName = name;
+        if (name.split("-").length > 1) {
+            newName = `['${name}']`;
+        }
+        return newName;
     }
-    build(schemaObject) {
-        const name = this.treatName(this.name);
-        const x = `${name}: z.${this.type}()${this.isNullable()}`;
-        switch (this.type) {
-            case "string": {
-                // if (name === "role") {
-                //   console.log(schemaObject.enum);
-                // }
-                console.log(schemaObject.enum);
-                const deepValidation = this.deepValidator();
-                return deepValidation ? `${name}: ${deepValidation}` : `${x}.default('${this.example}')`;
-            }
-            case "boolean":
-                return `${x}.default(${this.example})`;
-            case "number": {
-                const number = JSON.stringify(this.example) ?? 0;
-                return `${x}.default(${sanitizeNumber(number)})`;
-            }
-            case "array": {
-                if (!schemaObject.items || !("$ref" in schemaObject.items)) {
-                    let zodType = "z.string()";
-                    if (schemaObject.items?.enum) {
-                        if (this.schemaName) {
-                            const teste = splitByUppercase(this.schemaName)
-                                .filter((name) => name !== "Empty")
-                                .join("");
-                            zodType = `${teste}EnumSchema`;
-                        }
-                    }
-                    else if (schemaObject.items?.type) {
-                        zodType = `z.${schemaObject.items.type}()`;
-                    }
-                    return `${name}: z.${this.type}(${zodType})${this.isNullable()}.default([])`;
-                }
-                const dto = this.getDtoName(schemaObject.items.$ref);
-                return `${name}: z.array(${dto}Schema).default(new Array(10).fill(${dto}Schema.parse({})))`;
+    getType(params) {
+        const { type, schemaName, schemaObject } = params;
+        if (type === "object") {
+            return `${schemaName}`;
+        }
+        else if (type === "array") {
+            let name = schemaName;
+            const teste = schemaObject.items;
+            if (teste && "$ref" in teste) {
+                const a = teste.$ref;
+                name = a.split("/").at(-1);
             }
-            case "object":
-                return `${name}: z.any()`;
-            default:
-                return `${name}: z.any()`;
+            return `${name}[]`;
+        }
+        else {
+            return type;
         }
     }
 }

package/dist/schema.d.ts

@@ -1,9 +1,8 @@
-import { ZodProperty } from "./zodProperty.js";
+import { SchemaProp } from "./property.js";
 import type { SchemaObject, ReferenceObject } from "./types/open-api-spec.interface.js";
 export declare class Schema {
     name: string;
-    properties: ZodProperty[];
-    type: string;
+    properties: SchemaProp[];
     schema: string;
     enums: Set<string>;
     objects: Map<string, string>;

package/dist/schema.js

@@ -1,8 +1,9 @@
-import { ZodProperty } from "./zodProperty.js";
+import { capitalizeFirstLetter, splitByUppercase, treatAndUpper, treatByUppercase } from "./helpers/helpers.js";
+import { SchemaProp } from "./property.js";
 export class Schema {
     name;
     properties = [];
-    type;
+    // type: string;
     schema;
     enums = new Set();
     objects = new Map();
@@ -14,19 +15,20 @@ export class Schema {
                 if ("$ref" in value) {
                     const teste = value.$ref;
                     const object = teste.split("/").at(-1);
-                    this.objects.set(key, `${object}Schema`);
+                    this.objects.set(key, `${object}`);
                 }
                 continue;
             }
             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 }));
             }
             else if (value.enum) {
                 this.enums.add(this.getEnumConst({ enums: value.enum, schemaName: key }));
             }
-            this.properties.push(new ZodProperty({
+            this.properties.push(new SchemaProp({
                 schemaName: this.name,
                 name: key,
                 schemaObject: value,
@@ -37,20 +39,36 @@ export class Schema {
                 inParam: "path",
             }));
         }
-        this.type = `export type ${this.name} = z.infer<typeof ${this.name}Schema>;`;
-        this.schema = `export const ${this.name}Schema = z.object({
-      ${this.properties.map((p) => {
-            return p.buildedProp;
-        })}
-      ${this.properties.length > 0 ? "," : ""}
-      ${Array.from(this.objects).map(([k, v]) => {
-            return `${k}: z.object(${v})`;
-        })}
-    });`;
+        const keys = this.properties
+            .map((p) => {
+            const keyName = `${p.name}${p.isRequired ? "" : "?"}`;
+            let state;
+            if (p.reflectorType === "object") {
+                state = `$state<${p.bType}>()`;
+            }
+            else if (p.reflectorType === "array") {
+                state = `$state<${p.bType}>([])`;
+            }
+            else {
+                state = `$state(${p.buildedValue})`;
+            }
+            return `${keyName} = ${state}`;
+        })
+            .join(";\n");
+        const buildedObjects = Array.from(this.objects)
+            .map(([k, v]) => {
+            return `${k} = $state(new ${v}())`;
+        })
+            .join(";\n");
+        this.schema = `export class ${this.name} {
+      ${keys}
+      ${this.properties.length > 0 ? ";" : ""}
+      ${buildedObjects}
+    };`;
     }
     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.13",
-  "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"
+  }
+}