svelte-reflector 1.2.1 → 1.3.0

package/dist/generate-doc.js

@@ -4,7 +4,7 @@ import * as path from "node:path";
 import * as fs from "node:fs";
 import { Reflector } from "./main.js";
 import { Source } from "./file.js";
-import { parseValidatorFieldsFromConfig } from "./helpers/generate-doc.helper.js";
+import { parseFieldConfigsFromConfig, parseTypeImportsFromTypesFile } from "./helpers/generate-doc.helper.js";
 //
 /** ajuda a pegar a 1ª env definida dentre várias chaves possíveis */
 function pickEnv(...keys) {
@@ -43,11 +43,12 @@ export async function reflector(manual = false) {
     }
     const DOC_URL = `${BACKEND_URL}openapi.json`;
     let data;
-    let validators = new Map();
+    let fieldConfigs = new Map();
+    let typeImports = new Map();
     try {
         const documentation = await axios.get(DOC_URL, { timeout: 15000 });
         data = documentation.data;
-        const backup = new Source({ path: "src/backup.json", data: JSON.stringify(data) });
+        const backup = new Source({ path: "src/reflector/backup.json", data: JSON.stringify(data) });
         await backup.save();
     }
     catch (e) {
@@ -56,18 +57,31 @@ export async function reflector(manual = false) {
         data = JSON.parse(fs.readFileSync(backupPath, "utf8"));
     }
     try {
-        const fieldsConfig = path.resolve(process.cwd(), "src/reflector.config.ts");
-        const configText = fs.readFileSync(fieldsConfig, "utf8");
-        const parsedRelations = parseValidatorFieldsFromConfig(configText);
-        parsedRelations.forEach((rel) => {
+        const configPath = path.resolve(process.cwd(), "src/reflector.config.ts");
+        const configText = fs.readFileSync(configPath, "utf8");
+        const parsedConfigs = parseFieldConfigsFromConfig(configText);
+        parsedConfigs.forEach((rel) => {
             rel.fields.forEach((field) => {
-                validators.set(field, rel.validator);
+                const config = {};
+                if (rel.validator)
+                    config.validator = rel.validator;
+                if (rel.type)
+                    config.type = rel.type;
+                fieldConfigs.set(field, config);
             });
         });
     }
     catch (e) {
         console.warn("[reflector] Não consegui ler/parsear reflector.config.ts", e);
     }
+    try {
+        const typesPath = path.resolve(process.cwd(), "src/reflector.types.ts");
+        const typesText = fs.readFileSync(typesPath, "utf8");
+        typeImports = parseTypeImportsFromTypesFile(typesText);
+    }
+    catch {
+        // reflector.types.ts não encontrado — tipos customizados não terão imports
+    }
     // Lê reflector.json do projeto consumidor (opcional)
     let apiImport = "$lib/api";
     try {
@@ -85,7 +99,7 @@ export async function reflector(manual = false) {
         console.warn("[reflector] OpenAPI sem components; abortando.");
         return breakReflector();
     }
-    const r = new Reflector({ components, paths, validators, apiImport });
+    const r = new Reflector({ components, paths, fieldConfigs, typeImports, apiImport });
     await r.build();
     await r.localSave(data);
     return breakReflector();

package/dist/helpers/generate-doc.helper.d.ts

@@ -1,6 +1,8 @@
-interface LooseValidatorField {
+interface LooseFieldConfig {
     fields: string[];
-    validator: string;
+    validator?: string;
+    type?: string;
 }
-export declare function parseValidatorFieldsFromConfig(code: string): LooseValidatorField[];
+export declare function parseFieldConfigsFromConfig(code: string): LooseFieldConfig[];
+export declare function parseTypeImportsFromTypesFile(code: string): Map<string, string>;
 export {};

package/dist/helpers/generate-doc.helper.js

@@ -2,10 +2,10 @@ function stripComments(code) {
     // remove //... e /* ... */
     return code.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|\s)\/\/.*$/gm, "");
 }
-function extractValidatorsArraySource(code) {
-    // tenta achar: export const validators ... = [ ... ];
+function extractFieldConfigsArraySource(code) {
+    // tenta achar: export const fieldConfigs ... = [ ... ];
     const cleaned = stripComments(code);
-    const startIdx = cleaned.search(/\bexport\s+const\s+validators\b/);
+    const startIdx = cleaned.search(/\bexport\s+const\s+fieldConfigs\b/);
     if (startIdx < 0)
         return null;
     const fromStart = cleaned.slice(startIdx);
@@ -52,27 +52,74 @@ function extractValidatorsArraySource(code) {
     }
     return null;
 }
-export function parseValidatorFieldsFromConfig(code) {
-    const arrSrc = extractValidatorsArraySource(code);
+function extractObjectBlocks(arrSrc) {
+    const blocks = [];
+    let depth = 0;
+    let start = -1;
+    for (let i = 0; i < arrSrc.length; i++) {
+        const ch = arrSrc[i];
+        if (ch === "{") {
+            if (depth === 0)
+                start = i;
+            depth++;
+        }
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0 && start >= 0) {
+                blocks.push(arrSrc.slice(start, i + 1));
+                start = -1;
+            }
+        }
+    }
+    return blocks;
+}
+export function parseFieldConfigsFromConfig(code) {
+    const arrSrc = extractFieldConfigsArraySource(code);
     if (!arrSrc)
         return [];
-    // captura objetos do tipo:
-    // { fields: ['email'], validator: validateInputs.email, }
-    const objRegex = /\{\s*fields\s*:\s*\[([\s\S]*?)\]\s*,\s*validator\s*:\s*([A-Za-z0-9_$.]+)\s*,?\s*\}/g;
+    const blocks = extractObjectBlocks(arrSrc);
     const results = [];
-    let m;
-    while ((m = objRegex.exec(arrSrc))) {
-        const fieldsRaw = m[1] ?? "";
-        const validatorRaw = (m[2] ?? "").trim();
-        // pega strings dentro do array de fields (aceita ' " `)
+    for (const block of blocks) {
+        // extrai fields: [...]
+        const fieldsMatch = block.match(/fields\s*:\s*\[([\s\S]*?)\]/);
+        if (!fieldsMatch)
+            continue;
         const fields = [];
         const strRegex = /['"`]([^'"`]+)['"`]/g;
         let sm;
-        while ((sm = strRegex.exec(fieldsRaw))) {
+        while ((sm = strRegex.exec(fieldsMatch[1] ?? ""))) {
             if (sm[1])
                 fields.push(sm[1]);
         }
-        results.push({ fields, validator: validatorRaw });
+        if (fields.length === 0)
+            continue;
+        // extrai validator (referência sem aspas, ex: validateInputs.email)
+        const validatorMatch = block.match(/validator\s*:\s*([A-Za-z0-9_$.]+)/);
+        const validator = validatorMatch?.[1]?.trim();
+        // extrai type (string literal com aspas, ex: 'IconName')
+        const typeMatch = block.match(/type\s*:\s*['"`]([^'"`]+)['"`]/);
+        const type = typeMatch?.[1]?.trim();
+        const config = { fields };
+        if (validator)
+            config.validator = validator;
+        if (type)
+            config.type = type;
+        results.push(config);
     }
     return results;
 }
+export function parseTypeImportsFromTypesFile(code) {
+    const result = new Map();
+    const importRegex = /import\s+type\s*\{([^}]+)\}\s*from\s*['"`]([^'"`]+)['"`]/g;
+    let m;
+    while ((m = importRegex.exec(code))) {
+        const names = (m[1] ?? "").split(",").map((n) => n.trim()).filter(Boolean);
+        const source = m[2] ?? "";
+        if (!source)
+            continue;
+        for (const name of names) {
+            result.set(name, `import type { ${name} } from '${source}'`);
+        }
+    }
+    return result;
+}

package/dist/main.d.ts

@@ -1,7 +1,7 @@
 import { Source } from "./file.js";
 import { Schema } from "./schema.js";
 import type { ComponentsObject, PathsObject, OpenAPIObject } from "./types/open-api-spec.interface.js";
-import type { FieldValidators } from "./types/types.js";
+import type { FieldConfigs, TypeImports } from "./types/types.js";
 import { Module } from "./module.js";
 export declare const enumTypes: Map<string, string>;
 export declare const mockedParams: Set<string>;
@@ -13,6 +13,7 @@ export declare class Reflector {
     readonly src: Source;
     readonly typesSrc: Source;
     private readonly schemaMap;
+    private readonly typeImports;
     readonly fieldsFile: Source;
     readonly enumFile: Source;
     readonly mockedParamsFile: Source;
@@ -23,7 +24,8 @@ export declare class Reflector {
     constructor(params: {
         components: ComponentsObject;
         paths: PathsObject;
-        validators: FieldValidators;
+        fieldConfigs: FieldConfigs;
+        typeImports: TypeImports;
         apiImport: string;
     });
     private getSchemas;

package/dist/main.js

@@ -4,18 +4,19 @@ import { Source } from "./file.js";
 import { getEndpoint, isReferenceObject, splitByUppercase } from "./helpers/helpers.js";
 import { Schema } from "./schema.js";
 import { Module } from "./module.js";
-import { baseDir, generatedDir } from "./vars.global.js";
+import { generatedDir } from "./vars.global.js";
 import { ReflectorFile } from "./reflector.js";
 export const enumTypes = new Map();
 export const mockedParams = new Set();
 export class Reflector {
     components;
     paths;
-    localDoc = new Source({ path: path.resolve(process.cwd(), `${baseDir}/backup.json`) });
+    localDoc = new Source({ path: path.resolve(process.cwd(), `${generatedDir}/backup.json`) });
     propertiesNames = new Set();
     src = new Source({ path: path.resolve(process.cwd(), `${generatedDir}/controllers`) });
     typesSrc = new Source({ path: path.resolve(process.cwd(), `${generatedDir}/reflector.svelte.ts`) });
     schemaMap = new Map();
+    typeImports;
     fieldsFile = new Source({ path: path.resolve(process.cwd(), `${generatedDir}/fields.ts`) });
     enumFile = new Source({ path: path.resolve(process.cwd(), `${generatedDir}/enums.ts`) });
     mockedParamsFile = new Source({ path: path.resolve(process.cwd(), `${generatedDir}/mocked-params.svelte.ts`) });
@@ -24,8 +25,9 @@ export class Reflector {
     modules;
     apiImport;
     constructor(params) {
-        const { components, paths, validators, apiImport } = params;
+        const { components, paths, fieldConfigs, typeImports, apiImport } = params;
         this.apiImport = apiImport;
+        this.typeImports = typeImports;
         // Limpa estado global entre execuções
         enumTypes.clear();
         mockedParams.clear();
@@ -34,12 +36,12 @@ export class Reflector {
         this.paths = paths;
         this.files = [];
         this.modules = this.getModules();
-        const { propertiesNames, schemas } = this.getSchemas({ validators });
+        const { propertiesNames, schemas } = this.getSchemas({ fieldConfigs });
         this.propertiesNames = propertiesNames;
         this.schemas = schemas;
     }
     getSchemas(params) {
-        const { validators } = params;
+        const { fieldConfigs } = params;
         const componentSchemas = this.components.schemas;
         const schemas = [];
         const propertiesNames = new Set();
@@ -57,7 +59,7 @@ export class Reflector {
             Object.keys(properties).forEach((prop) => {
                 propertiesNames.add(prop);
             });
-            schemas.push(new Schema({ ...schema, isEmpty: false, validators }));
+            schemas.push(new Schema({ ...schema, isEmpty: false, fieldConfigs }));
         }
         // Build schema lookup map for per-module splitting
         for (const schema of schemas) {
@@ -183,10 +185,14 @@ export class Reflector {
     buildSchemaFileContent(schemas) {
         // Collect enum deps from all schemas in this file
         const enumDeps = new Set();
+        const customTypeDeps = new Set();
         for (const s of schemas) {
             for (const e of s.enumDeps) {
                 enumDeps.add(e);
             }
+            for (const t of s.customTypeDeps) {
+                customTypeDeps.add(t);
+            }
         }
         const treatedSchemas = schemas.map((s) => `${s.interface};\n${s.schema};`);
         const imports = [
@@ -196,6 +202,12 @@ export class Reflector {
         if (enumDeps.size > 0) {
             imports.push(`import type { ${[...enumDeps].join(", ")} } from "$reflector/enums"`);
         }
+        for (const typeName of customTypeDeps) {
+            const importStatement = this.typeImports.get(typeName);
+            if (importStatement) {
+                imports.push(importStatement + ";");
+            }
+        }
         imports.push("import { PUBLIC_ENVIRONMENT } from '$env/static/public';");
         imports.push("const isEmpty = PUBLIC_ENVIRONMENT !== 'DEV';");
         return imports.join("\n") + "\n" + treatedSchemas.join("\n");

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

@@ -10,14 +10,17 @@ export declare class PrimitiveProp {
     private readonly required;
     private readonly isNullable;
     readonly rawType: ReflectorParamType;
+    readonly customType: string | undefined;
     private readonly buildedConst;
     private readonly example;
     private readonly fallbackExample;
+    private get effectiveType();
     constructor(params: {
         name: string;
         schemaObject: SchemaObject;
         required: boolean;
         validator: string | undefined;
+        customType?: string | undefined;
         isParam: boolean | undefined;
         isNullable?: boolean | undefined;
     });

package/dist/props/primitive.property.js

@@ -7,20 +7,25 @@ export class PrimitiveProp {
     required;
     isNullable;
     rawType;
+    customType;
     buildedConst;
     example;
     fallbackExample;
+    get effectiveType() {
+        return this.customType ?? this.rawType;
+    }
     constructor(params) {
-        const { name, schemaObject, required, validator, isParam, isNullable } = params;
+        const { name, schemaObject, required, validator, customType, isParam, isNullable } = params;
         const { type: rawType } = schemaObject;
         this.isNullable = !!isNullable;
         const type = rawType ?? "string";
         const { emptyExample, example } = this.getExampleAndFallback({ schemaObject, type, name });
         this.example = example;
         this.fallbackExample = emptyExample;
-        const buildedType = type;
+        const buildedType = customType ?? type;
         this.name = this.treatName(name);
         this.rawType = type ?? "any";
+        this.customType = customType;
         this.type = `BuildedInput<${buildedType}>`;
         this.required = required;
         this.isParam = !!isParam;
@@ -90,7 +95,7 @@ export class PrimitiveProp {
         };
         const buildedExample = `params?.empty || isEmpty ? ${this.fallbackExample} : ${this.example}`;
         const keyExpr = this.isNullable ? `params?.data?.${name} ?? null` : `params?.data?.${name}`;
-        const typeParam = this.isNullable ? `<${this.rawType} | null>` : "";
+        const typeParam = this.isNullable ? `<${this.effectiveType} | null>` : "";
         return `
       build${typeParam}({ key: ${keyExpr}, placeholder: ${this.example}, example: ${buildedExample}, required: ${required}, ${buildedValidator()}})
     `;
@@ -104,12 +109,12 @@ export class PrimitiveProp {
     classBuild() {
         const req = (this.required || this.isNullable) ? "" : "?";
         const nullable = this.isNullable ? " | null" : "";
-        return `${this.name}${req}: BuildedInput<${this.rawType}${nullable}>`;
+        return `${this.name}${req}: BuildedInput<${this.effectiveType}${nullable}>`;
     }
     interfaceBuild() {
         const req = this.required ? "" : "?";
         const nullable = this.isNullable ? " | null" : "";
-        return `${this.name}${req}: ${this.rawType}${nullable}`;
+        return `${this.name}${req}: ${this.effectiveType}${nullable}`;
     }
     patchBuild() {
         return `readonly ${this.name} = $derived.by(() => '${this.name}' in page.params ? page.params.${this.name} : mockedParams.${this.name}) as string | null;`;

package/dist/schema.d.ts

@@ -3,7 +3,7 @@ import { EnumProp } from "./props/enum.property.js";
 import { ObjectProp } from "./props/object.property.js";
 import { PrimitiveProp } from "./props/primitive.property.js";
 import type { SchemaObject, ReferenceObject } from "./types/open-api-spec.interface.js";
-import type { FieldValidators } from "./types/types.js";
+import type { FieldConfigs } from "./types/types.js";
 export declare class Schema {
     name: string;
     primitiveProps: PrimitiveProp[];
@@ -14,6 +14,8 @@ export declare class Schema {
     readonly schemaDeps: string[];
     /** Enum type names used by this schema */
     readonly enumDeps: string[];
+    /** Custom type names used by this schema (from fieldConfigs) */
+    readonly customTypeDeps: string[];
     schema: string;
     interface: string;
     constructor(params: {
@@ -21,7 +23,7 @@ export declare class Schema {
         name: string;
         requireds: string[];
         isEmpty: boolean;
-        validators: FieldValidators;
+        fieldConfigs: FieldConfigs;
     });
     private processObject;
     private processEntities;

package/dist/schema.js

@@ -14,6 +14,8 @@ export class Schema {
     schemaDeps;
     /** Enum type names used by this schema */
     enumDeps;
+    /** Custom type names used by this schema (from fieldConfigs) */
+    customTypeDeps;
     schema;
     interface;
     constructor(params) {
@@ -41,6 +43,12 @@ export class Schema {
                 enumDepsSet.add(prop.type);
         }
         this.enumDeps = [...enumDepsSet];
+        const customTypeDepsSet = new Set();
+        for (const prop of this.primitiveProps) {
+            if (prop.customType)
+                customTypeDepsSet.add(prop.customType);
+        }
+        this.customTypeDeps = [...customTypeDepsSet];
         const reflectorInterface = new ReflectorInterface({
             name: this.name,
             arrayProps: this.arrayProps,
@@ -105,12 +113,13 @@ export class Schema {
         }
     }
     processEntities(params) {
-        const { properties, requireds, validators } = params;
+        const { properties, requireds, fieldConfigs } = params;
         for (const [key, value] of Object.entries(properties)) {
             if (isReferenceObject(value) || !value?.type) {
                 if (!isReferenceObject(value) && value.additionalProperties) {
                     const fakeStringSchema = { ...value, type: "string" };
-                    this.primitiveProps.push(new PrimitiveProp({ name: key, schemaObject: fakeStringSchema, required: requireds.includes(key), validator: validators.get(key), isParam: undefined, isNullable: value.nullable }));
+                    const config = fieldConfigs.get(key);
+                    this.primitiveProps.push(new PrimitiveProp({ name: key, schemaObject: fakeStringSchema, required: requireds.includes(key), validator: config?.validator, customType: config?.type, isParam: undefined, isNullable: value.nullable }));
                 }
                 else {
                     this.processObject({ key, value });
@@ -130,12 +139,14 @@ export class Schema {
                 this.enumProps.push(new EnumProp({ enums: value.enum, name, required, isParam: undefined, entityName: schemaName }));
                 continue;
             }
-            const validator = validators.get(key);
+            const config = fieldConfigs.get(key);
+            const validator = config?.validator;
+            const customType = config?.type;
             const type = value.type;
             if (type === "object") {
                 if (schemaObject.additionalProperties) {
                     const fakeStringSchema = { ...schemaObject, type: "string" };
-                    this.primitiveProps.push(new PrimitiveProp({ name, schemaObject: fakeStringSchema, required, validator, isParam: undefined, isNullable: schemaObject.nullable }));
+                    this.primitiveProps.push(new PrimitiveProp({ name, schemaObject: fakeStringSchema, required, validator, customType, isParam: undefined, isNullable: schemaObject.nullable }));
                 }
                 continue;
             }
@@ -143,7 +154,7 @@ export class Schema {
                 this.arrayProps.push(new ArrayProp({ schemaObject, schemaName, name, required, isParam: undefined, isEnum: false, isNullable: schemaObject.nullable }));
                 continue;
             }
-            this.primitiveProps.push(new PrimitiveProp({ name, schemaObject, required, validator, isParam: undefined, isNullable: schemaObject.nullable }));
+            this.primitiveProps.push(new PrimitiveProp({ name, schemaObject, required, validator, customType, isParam: undefined, isNullable: schemaObject.nullable }));
         }
     }
 }

package/dist/types/types.d.ts

@@ -15,10 +15,15 @@ export type Info = {
     moduleName: string;
 };
 export type Example = string | boolean | number;
-export interface ValidatorField {
-    fields: string[];
-    validator: string;
+export interface FieldConfig {
+    validator?: string;
+    type?: string;
 }
-export type FieldValidators = Map<string, string>;
+export type FieldConfigs = Map<string, FieldConfig>;
+/**
+ * Maps custom type names (e.g. "IconName") to their full import statements
+ * (e.g. "import type { IconName } from '$lib/utils/icons/icons.type.svelte'")
+ */
+export type TypeImports = Map<string, string>;
 export type AttributeProp = PrimitiveProp | ArrayProp | EnumProp;
 export type ParamType = "Paths" | "Querys" | "Headers";

package/package.json

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