svelte-reflector 1.1.7 → 1.1.9

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

@@ -1,14 +1,16 @@
 import type { SchemaObject } from "../types/open-api-spec.interface.js";
-type AbstractType = string | boolean | Date | number | undefined;
+import type { ReflectorParamType } from "../types/types.js";
+type AbstractType = string | boolean | number | undefined;
 export declare class PrimitiveProp {
     name: string;
     type: AbstractType;
     isSpecial: boolean;
     isParam: boolean;
     private readonly required;
-    readonly rawType: string;
+    readonly rawType: ReflectorParamType;
     private readonly buildedConst;
-    private readonly emptyExample;
+    private readonly example;
+    private readonly fallbackExample;
     constructor(params: {
         name: string;
         schemaObject: SchemaObject;
@@ -18,6 +20,7 @@ export declare class PrimitiveProp {
     });
     private treatName;
     private getEmptyExample;
+    private getExampleAndFallback;
     private buildConst;
     private thisDot;
     constructorBuild(): string;

package/dist/props/primitive.property.js

@@ -1,3 +1,4 @@
+// type FallbackExample = string | false | number;
 export class PrimitiveProp {
     name;
     type;
@@ -6,25 +7,28 @@ export class PrimitiveProp {
     required;
     rawType;
     buildedConst;
-    emptyExample;
+    example;
+    fallbackExample;
     constructor(params) {
         const { name, schemaObject, required, validator, isParam } = params;
         const { type: rawType } = schemaObject;
         const type = rawType ?? "string";
-        this.emptyExample = this.getEmptyExample({ type, schemaObject });
-        const example = schemaObject.example ?? schemaObject.default;
-        if (isParam) {
-            if (name === "limit") {
-                console.log(example);
-            }
-        }
+        const { emptyExample, example } = this.getExampleAndFallback({ schemaObject, type });
+        this.example = example;
+        this.fallbackExample = emptyExample;
         const buildedType = type;
+        // if (name === "limit") {
+        //   console.log(example);
+        // }
+        // if (isParam) {
+        //   console.log(name, example);
+        // }
         this.name = this.treatName(name);
         this.rawType = type ?? "any";
         this.type = `BuildedInput<${buildedType}>`;
         this.required = required;
         this.isParam = !!isParam;
-        this.buildedConst = this.buildConst({ example, name: this.name, required, type, validator, emptyExample: this.emptyExample });
+        this.buildedConst = this.buildConst({ example, name: this.name, required, type, validator, emptyExample: this.example });
     }
     treatName(name) {
         let newName = name;
@@ -49,8 +53,27 @@ export class PrimitiveProp {
             return "''";
         }
     }
+    getExampleAndFallback(params) {
+        const { schemaObject, type } = params;
+        const example = schemaObject.example ?? schemaObject.default;
+        const emptyExample = this.getEmptyExample({ type, schemaObject });
+        if (!example)
+            return {
+                example: emptyExample,
+                emptyExample,
+            };
+        if (type === "string")
+            return {
+                example: `"${example}"`,
+                emptyExample,
+            };
+        return {
+            example,
+            emptyExample,
+        };
+    }
     buildConst(params) {
-        const { example, name, required, type, validator, emptyExample } = params;
+        const { name, required, type, validator } = params;
         const getValidator = (type) => {
             if (type === "string") {
                 return "emptyString";
@@ -67,23 +90,9 @@ export class PrimitiveProp {
             }
             return "";
         };
-        const sanitizedExample = () => {
-            if (this.isParam || !example) {
-                return emptyExample;
-            }
-            if (type === "string") {
-                return `"${example}"`;
-            }
-            return example;
-        };
-        const buildedExample = () => {
-            if (this.emptyExample === sanitizedExample()) {
-                return sanitizedExample();
-            }
-            return `params?.empty || isEmpty ? ${this.emptyExample} : ${sanitizedExample()}`;
-        };
+        const buildedExample = `params?.empty || isEmpty ? ${this.example} : ${this.fallbackExample}`;
         return `
-      build({ key: params?.data?.${name}, placeholder: ${sanitizedExample()}, example: ${buildedExample()}, required: ${required}, ${buildedValidator()}})
+      build({ key: params?.data?.${name}, placeholder: ${this.fallbackExample}, example: ${buildedExample}, required: ${required}, ${buildedValidator()}})
     `;
     }
     thisDot() {
@@ -104,7 +113,9 @@ export class PrimitiveProp {
         return `readonly ${this.name} = $derived.by(() => '${this.name}' in page.params ? page.params.${this.name} : mockedParams.${this.name}) as string | null;`;
     }
     queryBuild() {
-        return `readonly ${this.name} = $derived(new QueryBuilder({ key: '${this.name}', value: ${this.emptyExample} }))`;
+        const example = this.rawType === "string" ? this.fallbackExample : this.example;
+        console.log(example);
+        return `readonly ${this.name} = $derived(new QueryBuilder({ key: '${this.name}', value: ${example} }))`;
     }
     updateQueryBuild() {
         return `${this.name}: (event: SvelteEvent) => changeParam({ key: '${this.name}', event })`;

package/dist/types/types.d.ts

@@ -2,7 +2,7 @@ import type { ArrayProp } from "../props/array.property.js";
 import type { EnumProp } from "../props/enum.property.js";
 import type { PrimitiveProp } from "../props/primitive.property.js";
 import type { OperationObject } from "./open-api-spec.interface.js";
-export type ReflectorParamType = "string" | "boolean" | "number" | "array" | "object" | "enum";
+export type ReflectorParamType = "string" | "boolean" | "number" | "array" | "object" | "enum" | "any";
 export type ApiType = "get" | "post" | "delete" | "patch" | "put";
 export type ReflectorOperation = OperationObject & {
     apiMethod: ApiType;

package/package.json

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