svelte-reflector 1.1.3 → 1.1.5

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}
-          onSuccess?.(response)
+          await onSuccess?.(response);
 
-          return ${methodReturn}
-        } catch(e) {
+          return ${methodReturn};
+        } catch (e) {
           const parsedError = JSON.parse((e as Error).message) as ApiErrorResponse;
-          return onError?.(parsedError);
+          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/reflector.js

@@ -8,11 +8,12 @@ export class ReflectorFile {
         "type ValidatorResult = string | null",
         "type ValidatorFn<T> = (v: T) => ValidatorResult",
         "type BundleResult<T> = T extends { bundle: () => infer R } ? R : T;",
-        `type Partial<T> = {
-        [K in Exclude<keyof T, "bundle">]?: BuildedInput<T[K]>;
+        `type PartialBuildedInput<T> = {
+        [K in Exclude<keyof T, 'bundle'>]?: BuildedInput<T[K]>;
       } & {
         bundle: unknown;
-      }`,
+      }
+    `,
         `export interface QueryContract {
       event: SvelteEvent;
       key: string;
@@ -27,14 +28,15 @@ export class ReflectorFile {
       message: string;
     }`,
         `export class Behavior<TSuccess = unknown, TError = unknown> {
-      onError?: (e: TError) => void;
-      onSuccess?: (v: TSuccess) => void;
+      onError?: (e: TError) => Promise<void> | void;
+      onSuccess?: (v: TSuccess) => Promise<void> | void;
     }`,
         `export class BuildedInput<T> {
       value = $state<T>(null as any);
       display = $state<T>(null as any);
       required: boolean;
       placeholder: T;
+      readonly kind = 'builded';
       readonly validator?: ValidatorFn<T>;
 
       constructor(params: {
@@ -102,7 +104,7 @@ export class ReflectorFile {
     }): BuildedInput<T> {
       return new BuildedInput(params);
     }`,
-        `export function isFormValid<T>(schema: Partial<T>): boolean {
+        `export function isFormValid<T>(schema: PartialBuildedInput<T>): boolean {
       delete schema.bundle;
 
       const arrayOfBuildedInputs = Object.values(schema) as BuildedInput<unknown>[];
@@ -154,6 +156,7 @@ export class ReflectorFile {
     export class QueryBuilder<T> {
       private readonly key: string = '';
       value = $state<T | null>(null);
+      readonly kind = 'query';
 
       constructor(params: { key: string; value: T | null }) {
         const { key, value } = 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.3",
+  "version": "1.1.5",
   "description": "Reflects zod types from openAPI schemas",
   "type": "module",
   "main": "./dist/index.js",