svelte-reflector 2.1.0 → 2.1.2

package/dist/core/generators/ApiCallStrategy.js

@@ -1,3 +1,4 @@
+import { queryOverrideTypeLiteral } from "./queryOverride.js";
 export class ApiCallStrategy {
     listStateAccess(_method) {
         return "this.data";
@@ -15,6 +16,11 @@ export class ApiCallStrategy {
     buildParamsType(method) {
         const responseType = method.responseTypeInterface;
         const pathsBlock = this.buildPathsInfo(method);
+        const queryBlock = queryOverrideTypeLiteral(method.analyzers.props.querys);
+        if (queryBlock) {
+            const pathsArg = pathsBlock ?? "void";
+            return `ApiCallParams<${responseType}, ${pathsArg}, ${queryBlock}>`;
+        }
         if (pathsBlock) {
             return `ApiCallParams<${responseType}, ${pathsBlock}>`;
         }

package/dist/core/generators/CallMethodGenerator.js

@@ -8,36 +8,36 @@ export class CallMethodGenerator {
         const { inside, outside } = this.buildApiCall(method, strategy);
         const methodReturn = this.buildMethodReturn(method, strategy);
         const signature = strategy.buildSignature(method);
-        return `
-      ${description}
-      ${signature} {
-
-        const behavior = params?.behavior ?? new Behavior();
-        const { onError, onSuccess } = behavior;
-
-        this.loading = true;
-        ${props}
-        const endpoint = ${endpoint}
-
-        ${outside}
-
-        try {
-          ${inside}
-          await onSuccess?.(response);
-
-          return ${methodReturn};
-        } catch (e) {
-          let parsedError: ApiErrorResponse;
-          try {
-            parsedError = JSON.parse((e as Error).message) as ApiErrorResponse;
-          } catch {
-            parsedError = { error: 'unknown', message: (e as Error).message ?? String(e) };
-          }
-          return await onError?.(parsedError);
-        } finally {
-          this.loading = false;
-        }
-      }
+        return `
+      ${description}
+      ${signature} {
+
+        const behavior = params?.behavior ?? new Behavior();
+        const { onError, onSuccess } = behavior;
+
+        this.loading = true;
+        ${props}
+        const endpoint = ${endpoint}
+
+        ${outside}
+
+        try {
+          ${inside}
+          await onSuccess?.(response);
+
+          return ${methodReturn};
+        } catch (e) {
+          let parsedError: ApiErrorResponse;
+          try {
+            parsedError = JSON.parse((e as Error).message) as ApiErrorResponse;
+          } catch {
+            parsedError = { error: 'unknown', message: (e as Error).message ?? String(e) };
+          }
+          return await onError?.(parsedError);
+        } finally {
+          this.loading = false;
+        }
+      }
     `;
     }
     buildProps(method) {
@@ -73,13 +73,13 @@ export class CallMethodGenerator {
     }
     buildListCall(method, responseType, strategy) {
         const querys = this.joinNames(method.analyzers.props.querys);
-        const inside = `
-      const response = await api.get<${responseType}, unknown>({
-        endpoint,
-        queryData: { ${querys} }
-      })
-      ${strategy.listStateAccess(method)} = ${method.analyzers.request.responseType}.from(response.data);
-      this.totalPages = response.totalPages;
+        const inside = `
+      const response = await api.get<${responseType}, unknown>({
+        endpoint,
+        queryData: { ${querys} }
+      })
+      ${strategy.listStateAccess(method)} = ${method.analyzers.request.responseType}.from(response.data);
+      this.totalPages = response.totalPages;
     `;
         return { inside, outside: "" };
     }
@@ -90,13 +90,13 @@ export class CallMethodGenerator {
         const assignment = rType && !isPrimitive
             ? `${strategy.entityStateAccess(method)} = new ${rType}({ data: response })`
             : "";
-        const inside = `
-      const response = await api.get<${responseType}, unknown>({
-        endpoint,
-        ${querys}
-      })
-
-      ${assignment}
+        const inside = `
+      const response = await api.get<${responseType}, unknown>({
+        endpoint,
+        ${querys}
+      })
+
+      ${assignment}
     `;
         return { inside, outside: "" };
     }
@@ -111,23 +111,23 @@ export class CallMethodGenerator {
         if (hasHeaders) {
             outside.push(`const headers = this.headers.bundle()`);
         }
-        const inside = `
-      const response = await api.${apiType}<${responseType}>({
-        endpoint,
-        ${hasData ? "data," : ""}
-        ${hasHeaders ? "headers," : ""}
-      })
+        const inside = `
+      const response = await api.${apiType}<${responseType}>({
+        endpoint,
+        ${hasData ? "data," : ""}
+        ${hasHeaders ? "headers," : ""}
+      })
     `;
         return { inside, outside: outside.join("\n") };
     }
     buildDeleteCall(method, responseType, bodyType, strategy) {
         const hasData = !!bodyType;
         const outside = hasData ? `const data = ${strategy.formStateAccess(method)}.bundle()` : "";
-        const inside = `
-      const response = await api.delete<${responseType}, unknown>({
-        endpoint,
-        ${hasData ? "data," : ""}
-      })
+        const inside = `
+      const response = await api.delete<${responseType}, unknown>({
+        endpoint,
+        ${hasData ? "data," : ""}
+      })
     `;
         return { inside, outside };
     }

package/dist/core/generators/ModuleCallStrategy.d.ts

@@ -7,5 +7,4 @@ export declare class ModuleCallStrategy implements CallStrategy {
     private buildParamsType;
     private buildPathsBlock;
     private buildQueryOverrideBlock;
-    private queryOverrideType;
 }

package/dist/core/generators/ModuleCallStrategy.js

@@ -1,4 +1,5 @@
 import { treatByUppercase } from "../../helpers/helpers.js";
+import { queryOverrideEntryType } from "./queryOverride.js";
 export class ModuleCallStrategy {
     listStateAccess(method) {
         return `this.list${method.stateSuffix}`;
@@ -21,21 +22,21 @@ export class ModuleCallStrategy {
         const blocks = [`behavior?: ${behaviorType};`, pathsBlock, queryBlock]
             .filter((b) => !!b)
             .join("\n");
-        return `{
-      ${blocks}
+        return `{
+      ${blocks}
     }`;
     }
     buildPathsBlock(method) {
         const paths = method.analyzers.props.paths;
         if (paths.length === 0)
             return undefined;
-        return `paths?: {
+        return `paths?: {
       ${paths
             .map((p) => {
             const type = p.rawType ?? p.type;
             return `${p.name}: ${type}`;
         })
-            .join("\n")}
+            .join("\n")}
     };`;
     }
     buildQueryOverrideBlock(method) {
@@ -43,17 +44,10 @@ export class ModuleCallStrategy {
         if (querys.length === 0)
             return undefined;
         const fields = querys
-            .map((q) => `${q.name}?: ${this.queryOverrideType(q)}`)
+            .map((q) => `${q.name}?: ${queryOverrideEntryType(q)}`)
             .join("\n");
-        return `queryOverride?: {
-      ${fields}
+        return `queryOverride?: {
+      ${fields}
     };`;
     }
-    queryOverrideType(q) {
-        if ("isEnum" in q && q.isEnum)
-            return `${q.type}[]`;
-        if (!("rawType" in q) && !("enumName" in q))
-            return "string[]";
-        return "string | null";
-    }
 }

package/dist/core/generators/queryOverride.d.ts

@@ -0,0 +1,12 @@
+import type { AttributeProp } from "../../types/types.js";
+/** TS type literal for a single query override entry. Mirrors the
+ *  shape produced by each Prop's bundle entry:
+ *    PrimitiveProp / EnumProp     → `string | null`
+ *    ArrayProp (enum)             → `${type}[]`
+ *    ArrayProp (non-enum, raro)   → `string[]`
+ */
+export declare function queryOverrideEntryType(q: AttributeProp): string;
+/** Inline TS object type literal for the full queryOverride bag,
+ *  derived from the method's query props. Returns undefined when there
+ *  are no query params (caller should skip emitting the slot). */
+export declare function queryOverrideTypeLiteral(querys: AttributeProp[]): string | undefined;

package/dist/core/generators/queryOverride.js

@@ -0,0 +1,22 @@
+/** TS type literal for a single query override entry. Mirrors the
+ *  shape produced by each Prop's bundle entry:
+ *    PrimitiveProp / EnumProp     → `string | null`
+ *    ArrayProp (enum)             → `${type}[]`
+ *    ArrayProp (non-enum, raro)   → `string[]`
+ */
+export function queryOverrideEntryType(q) {
+    if ("isEnum" in q && q.isEnum)
+        return `${q.type}[]`;
+    if (!("rawType" in q) && !("enumName" in q))
+        return "string[]";
+    return "string | null";
+}
+/** Inline TS object type literal for the full queryOverride bag,
+ *  derived from the method's query props. Returns undefined when there
+ *  are no query params (caller should skip emitting the slot). */
+export function queryOverrideTypeLiteral(querys) {
+    if (querys.length === 0)
+        return undefined;
+    const fields = querys.map((q) => `${q.name}?: ${queryOverrideEntryType(q)}`).join("; ");
+    return `{ ${fields} }`;
+}

package/package.json

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