svelte-reflector 1.1.4 → 1.1.6

package/dist/core/method/generators/MethodApiCallBuilder.js

@@ -47,11 +47,6 @@ export class MethodApiCallBuilder {
         const outside = [];
         if (hasData) {
             outside.push(`const data = this.forms.${method.name}.bundle()`);
-            //   outside.push(`    try{
-            //   isFormValid(this.forms.create)
-            // } finally {
-            //   this.loading = false
-            // }`);
         }
         if (hasHeaders) {
             outside.push(`const headers = this.headers.bundle()`);

package/dist/core/method/generators/MethodGenerator.d.ts

@@ -4,6 +4,7 @@ export declare class MethodGenerator {
     private readonly apiCallBuilder;
     private readonly propsBuilder;
     generate(method: Method): string;
+    private buildParamsType;
     private buildDescription;
     private buildMethodReturn;
     private buildAdditionalMethod;

package/dist/core/method/generators/MethodGenerator.js

@@ -11,13 +11,17 @@ export class MethodGenerator {
         const { inside, outside } = this.apiCallBuilder.build(method);
         const props = this.propsBuilder.build(method);
         const methodReturn = this.buildMethodReturn(method);
-        const additionalMethod = this.buildAdditionalMethod(method);
+        // const additionalMethod = this.buildAdditionalMethod(method);
+        const pathsInfo = this.propsBuilder.getPaths(method);
+        const paramsType = this.buildParamsType(method, pathsInfo);
         return `
       ${description}
-      async ${method.name}(behavior: Behavior<${method.responseTypeInterface}, ApiErrorResponse> = new Behavior()) {
-        const {onError, onSuccess} = behavior
+      async ${method.name}(params?: ${paramsType}) {
 
-        this.loading = true
+        const behavior = params?.behavior ?? new Behavior();
+        const { onError, onSuccess } = behavior;
+
+        this.loading = true;
         ${props}
         const endpoint = ${endpoint}
 
@@ -25,19 +29,29 @@ export class MethodGenerator {
 
         try {
           ${inside}
-          await onSuccess?.(response)
+          await onSuccess?.(response);
 
-          return ${methodReturn}
-        } catch(e) {
+          return ${methodReturn};
+        } catch (e) {
           const parsedError = JSON.parse((e as Error).message) as ApiErrorResponse;
           return await onError?.(parsedError);
         } finally {
-          this.loading = false
+          this.loading = false;
         }
       }
 
-      ${additionalMethod}
-    `.trim();
+    `;
+    }
+    buildParamsType(method, paramsPaths) {
+        const behaviorType = `Behavior<${method.responseTypeInterface}, ApiErrorResponse>`;
+        if (paramsPaths) {
+            return `{
+        behavior?: ${behaviorType};${paramsPaths}
+      }`;
+        }
+        return `{
+      behavior?: ${behaviorType};
+    }`;
     }
     buildDescription(method) {
         return `/** ${method.description ?? ""} */`;
@@ -62,7 +76,7 @@ export class MethodGenerator {
         }
         return `
       async ${method.name}AndClear(behavior: Behavior = new Behavior()) {
-        const data = await this.${method.name}(behavior)
+        const data = await this.${method.name}({behavior})
 
         if (data) {
           this.clearForms()

package/dist/core/method/generators/MethodPropsBuilder.d.ts

@@ -1,5 +1,6 @@
 import type { Method } from "../Method.js";
 export declare class MethodPropsBuilder {
     build(method: Method): string;
+    getPaths(method: Method): string | undefined;
     private joinNames;
 }

package/dist/core/method/generators/MethodPropsBuilder.js

@@ -6,13 +6,28 @@ export class MethodPropsBuilder {
             lines.push(`const { ${this.joinNames(querys)} } = this.querys.bundle()`);
         }
         if (paths.length > 0) {
-            lines.push(`const { ${this.joinNames(paths)} } = this.paths`);
+            lines.push(`const { ${this.joinNames(paths)} } = params?.paths ?? this.paths`);
         }
         if (cookies.length > 0) {
             lines.push(`const cookies = this.cookies`);
         }
         return lines.join("\n");
     }
+    getPaths(method) {
+        const { paths } = method.analyzers.props;
+        if (paths.length === 0)
+            return;
+        const paramsPaths = `
+    paths?: {
+      ${paths
+            .map((path) => {
+            const type = path.rawType ?? path.type;
+            return `${path.name}: ${type}`;
+        })
+            .join("\n")}
+    }`;
+        return paramsPaths;
+    }
     joinNames(props) {
         return props.map((x) => x.name).join(", ");
     }

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

@@ -6,7 +6,7 @@ export declare class PrimitiveProp {
     isSpecial: boolean;
     isParam: boolean;
     private readonly required;
-    private readonly rawType;
+    readonly rawType: string;
     private readonly buildedConst;
     private readonly emptyExample;
     constructor(params: {

package/dist/schema.js

@@ -48,12 +48,9 @@ export class Schema {
             keys.push(prop.classBuild());
             bundleParams.push(prop.bundleBuild());
         });
-        const hasAttributes = keys.length > 0;
-        const constructorCode = hasAttributes
-            ? `constructor(params?: { data?: ${this.name}Interface | undefined, empty?: boolean }) { 
+        const constructorCode = `constructor(params?: { data?: ${this.name}Interface | undefined, empty?: boolean }) { 
         ${constructorThis.join(";\n")}
-      }`
-            : "";
+      }`;
         this.schema = `
     export class ${this.name} {
       ${keys.join(";")}

package/package.json

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