svelte-reflector 2.1.0 → 2.1.3

package/dist/core/Reflector.js

@@ -54,6 +54,7 @@ export class Reflector {
         const runtimeFiles = RuntimeFilesEmitter.build({
             propertiesNames: this.propertiesNames,
             context: this.context,
+            config: this.config,
         });
         await Promise.all([
             ...moduleSchemaFiles.map((f) => f.save()),

package/dist/core/config/ReflectorConfig.d.ts

@@ -12,6 +12,8 @@ export interface ReflectorConfig {
     environmentImport: string;
     /** Name of the exported environment flag — values other than `DEV` are treated as prod. */
     environmentFlag: string;
+    /** Full import path to the toast module (default export must expose `.error({ title, description })`). */
+    toastImport: string;
 }
 export declare const DEFAULT_REFLECTOR_CONFIG: ReflectorConfig;
 export declare function resolveReflectorConfig(partial?: Partial<ReflectorConfig>): ReflectorConfig;

package/dist/core/config/ReflectorConfig.js

@@ -3,6 +3,7 @@ export const DEFAULT_REFLECTOR_CONFIG = {
     validatorsImport: "$lib/sanitizers/validateFormats",
     environmentImport: "$env/static/public",
     environmentFlag: "PUBLIC_ENVIRONMENT",
+    toastImport: "$lib/utils/toast.svelte",
 };
 export function resolveReflectorConfig(partial) {
     return { ...DEFAULT_REFLECTOR_CONFIG, ...(partial ?? {}) };

package/dist/core/emit/RuntimeFilesEmitter.d.ts

@@ -1,5 +1,6 @@
 import { Source } from "../../file.js";
 import type { CodegenContext } from "../CodegenContext.js";
+import type { ReflectorConfig } from "../config/ReflectorConfig.js";
 /**
  * Emits the shared runtime-support files that sit alongside the generated
  * module files: the reflector runtime template, the FIELD_NAMES list, the
@@ -9,5 +10,6 @@ export declare class RuntimeFilesEmitter {
     static build(params: {
         propertiesNames: Set<string>;
         context: CodegenContext;
+        config: ReflectorConfig;
     }): Source[];
 }

package/dist/core/emit/RuntimeFilesEmitter.js

@@ -4,6 +4,7 @@ import { Source } from "../../file.js";
 import { loadReflectorTemplate } from "../../loadTemplate.js";
 import { generatedDir } from "../../vars.global.js";
 import { dedent } from "../../helpers/codegen.js";
+import { DEFAULT_REFLECTOR_CONFIG } from "../config/ReflectorConfig.js";
 function generated(relPath) {
     return path.resolve(process.cwd(), `${generatedDir}/${relPath}`);
 }
@@ -14,19 +15,23 @@ function generated(relPath) {
  */
 export class RuntimeFilesEmitter {
     static build(params) {
-        const { propertiesNames, context } = params;
+        const { propertiesNames, context, config } = params;
+        let templateData = loadReflectorTemplate();
+        if (config.toastImport !== DEFAULT_REFLECTOR_CONFIG.toastImport) {
+            templateData = templateData.replace(`from "${DEFAULT_REFLECTOR_CONFIG.toastImport}"`, `from "${config.toastImport}"`);
+        }
         const typesSrc = new Source({
             path: generated("reflector.svelte.ts"),
-            data: loadReflectorTemplate(),
+            data: templateData,
         });
         const fieldLiterals = Array.from(propertiesNames).map((p) => `'${p}'`);
         const fieldsFile = new Source({
             path: generated("fields.ts"),
-            data: dedent `
-        export const FIELD_NAMES = [
-          ${fieldLiterals}
-        ] as const;
-        export type FieldName = (typeof FIELD_NAMES)[number]
+            data: dedent `
+        export const FIELD_NAMES = [
+          ${fieldLiterals}
+        ] as const;
+        export type FieldName = (typeof FIELD_NAMES)[number]
       `,
         });
         const enumss = Array.from(context.enumTypes)
@@ -41,13 +46,13 @@ export class RuntimeFilesEmitter {
             .join(";");
         const mockedFile = new Source({
             path: generated("mocked-params.svelte.ts"),
-            data: dedent `
-        class MockedParams {
-          ${mockedFields}
-        }
-
-        const mockedParams = new MockedParams()
-        export default mockedParams
+            data: dedent `
+        class MockedParams {
+          ${mockedFields}
+        }
+
+        const mockedParams = new MockedParams()
+        export default mockedParams
       `,
         });
         return [typesSrc, fieldsFile, enumFile, mockedFile];

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.3",
   "description": "Reflects zod types from openAPI schemas",
   "type": "module",
   "main": "./dist/index.js",