svelte-reflector 1.0.24 → 1.0.26

package/dist/array.property.d.ts

@@ -2,6 +2,7 @@ import type { SchemaObject } from "./types/open-api-spec.interface.js";
 export declare class ArrayProp {
     name: string;
     type: string;
+    isSpecial: boolean;
     constructor(params: {
         name: string;
         schemaObject: SchemaObject;
@@ -13,4 +14,5 @@ export declare class ArrayProp {
     classBuild(): string;
     interfaceBuild(): string;
     bundleBuild(): string;
+    staticBuild(): string;
 }

package/dist/array.property.js

@@ -1,6 +1,7 @@
 export class ArrayProp {
     name;
     type;
+    isSpecial = false;
     constructor(params) {
         const { name, schemaObject, schemaName } = params;
         this.name = this.treatName(name);
@@ -17,22 +18,36 @@ export class ArrayProp {
         const { schemaObject, schemaName } = params;
         let name = schemaName;
         const teste = schemaObject.items;
-        if (teste && "$ref" in teste) {
-            const a = teste.$ref;
-            name = a.split("/").at(-1);
+        if (!teste)
+            return name;
+        if ("$ref" in teste) {
+            return teste.$ref.split("/").at(-1);
         }
-        return name;
+        this.isSpecial = true;
+        return teste.type || "string";
     }
     constructorBuild() {
-        return `this.${this.name} = params?.${this.name}.map((param) => new ${this.type}(param)) ?? []`;
+        const result = this.isSpecial ? "" : `.map((param) => new ${this.type}(param))`;
+        return `this.${this.name} = params?.${this.name}${result} ?? []`;
     }
     classBuild() {
         return `${this.name}: ${this.type}[]`;
     }
     interfaceBuild() {
-        return `${this.name}: ${this.type}Interface[]`;
+        const aType = this.isSpecial ? this.type : `${this.type}Interface`;
+        return `${this.name}: ${aType}[]`;
     }
     bundleBuild() {
-        return `${this.name}: this.${this.name}.map((obj) => obj.bundle())`;
+        const result = this.isSpecial ? "" : ".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`;
+        return `
+      static from(data: ${aType}[]) {
+        return data.map((obj) => ${result});
+      }
+    `;
     }
 }

package/dist/helpers/helpers.js

@@ -91,13 +91,19 @@ export function getEndpoint(rawEndpoint) {
     return filteredEntitys.join("/");
 }
 export function getFullEndpoint(rawEndpoint) {
-    const teste = rawEndpoint.split("/");
-    const a = teste
-        .filter((t) => t !== "")
+    return rawEndpoint
+        .split("/")
+        .filter(Boolean)
         .map((str) => {
-        return str.includes("}") ? `$${str}` : str;
-    });
-    return a.join("/");
+        // pega somente params no formato "{algumaCoisa}"
+        const match = new RegExp(/^\{(.+)\}$/).exec(str);
+        if (match) {
+            const key = match[1]; // sem { }
+            return `\${paths.${key}}`; // gera "${paths.key}" como texto
+        }
+        return str;
+    })
+        .join("/");
 }
 export function treatenEnum(enums) {
     const a = enums.map((e) => `"${e}"`);

package/dist/method.js

@@ -55,9 +55,9 @@ export class Method {
         const paths = this.gee(this.paths);
         const cookies = this.gee(this.cookies);
         return `
-      ${querys.length > 0 ? `const {${querys}} = this.querys.bundle()` : ""};
-      ${paths.length > 0 ? `const {${paths}} = this.paths.bundle()` : ""};
-      ${cookies.length > 0 ? `const {${cookies}} = this.cookies.bundle()` : ""};
+      ${querys.length > 0 ? `const querys = this.querys.bundle()` : ""};
+      ${paths.length > 0 ? `const paths = this.paths.bundle()` : ""};
+      ${cookies.length > 0 ? `const cookies = this.cookies.bundle()` : ""};
     `;
     }
     buildCallMethod() {
@@ -66,7 +66,7 @@ export class Method {
         const diamond = this.request.responseType ? `${this.request.responseType}Interface` : "null";
         if (this.request.apiType === "get") {
             if (this.request.attributeType === "list") {
-                beforeResponse.push(`const {data: { data }} = response`, "\n\n", `this.list = data`);
+                beforeResponse.push(`const {data: { data }} = response`, "\n\n", `this.list = ${this.request.responseType}.from(data)`);
                 const inside = `
           const response = await repo.api.get<{data: ${diamond}}, unknown>({
             endpoint,
@@ -130,7 +130,12 @@ export class Method {
         // }
         const description = this.buildDescription();
         const a = "`";
-        const methodReturn = this.request.responseType ? `new ${this.request.responseType}(response)` : "null";
+        const methodReturn = () => {
+            if (this.request.attributeType === "list") {
+                return "this.list";
+            }
+            return this.request.responseType ? `new ${this.request.responseType}(response)` : "null";
+        };
         return `
       ${description}
       async ${this.name}(behavior: Behavior = new Behavior()) {
@@ -144,7 +149,7 @@ export class Method {
           ${inside}
           onSuccess?.()
 
-          return ${methodReturn}
+          return ${methodReturn()}
         } catch(e) {
           onError?.(e)
         } finally {

package/dist/primitive-property.js

@@ -7,7 +7,9 @@ export class PrimitiveProp {
     buildedConst;
     constructor(params) {
         const { name, schemaObject, required } = params;
-        const { example, type } = schemaObject;
+        const { example: rawExample, type: rawType } = schemaObject;
+        const type = rawType ?? "string";
+        const example = rawExample ?? this.getEmptyExample({ type, schemaObject });
         this.name = this.treatName(name);
         this.rawType = type ?? "any";
         this.type = `BuildedInput<${type}>`;

package/dist/property.js

@@ -1,5 +1,6 @@
-import {} from "./types/open-api-spec.interface.js";
-import {} from "./types/types.js";
+// import { type ParameterLocation, type ReferenceObject, type SchemaObject } from "./types/open-api-spec.interface.js";
+// import { type Example, type ReflectorParamType } from "./types/types.js";
+export {};
 // export class SchemaProp {
 //   inParam?: ParameterLocation | undefined;
 //   reflectorType: ReflectorParamType;

package/dist/schema.js

@@ -52,6 +52,7 @@ export class Schema {
         const constructorThis = [];
         const keys = [];
         const bundleParams = [];
+        let staticMethod = "";
         this.primitiveProps.forEach((prop) => {
             constructorThis.push(prop.constructorBuild());
             bundleParams.push(prop.bundleBuild());
@@ -61,6 +62,7 @@ export class Schema {
             constructorThis.push(prop.constructorBuild());
             keys.push(prop.classBuild());
             bundleParams.push(prop.bundleBuild());
+            staticMethod = prop.staticBuild();
         });
         this.objectProps.forEach((prop) => {
             constructorThis.push(prop.constructorBuild());
@@ -75,6 +77,8 @@ export class Schema {
         ${constructorThis.join(";\n")}
       }
 
+      ${staticMethod}
+
       bundle(){
         return { ${bundleParams.join(",")} }
       }

package/package.json

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