@romaintaillandier1978/dotenv-never-lies 1.1.1 → 1.3.0

package/dist/infer/rules/url.js

@@ -0,0 +1,143 @@
+import { looksLikeUrl, looksLikeHttpUrl, looksLikeDbUrl, looksLikeQueueUrl, looksLikeWsUrl, looksLikeStorageUrl, looksLikeOtherUrl, } from "../../schemas/urls.js";
+import { matchesEnvKey } from "../helpers.js";
+import { databaseUrlGenSchema, httpUrlGenSchema, otherUrlGenSchema, queueUrlGenSchema, storageUrlGenSchema, wsUrlSchemaGen } from "../generated/url.js";
+import { zUrlGenSchema } from "../generated/basic.js";
+export const URL_KEYS = ["URL", "URI", "LINK", "ENDPOINT", "API_URL", "API_ENDPOINT", "API_LINK", "API_URI"];
+const DB_KEYS = ["DB", "DATABASE", "DB_URL", "DATABASE_URL", "DB_URI", "DATABASE_URI"];
+const QUEUE_KEYS = ["QUEUE", "MESSAGE_QUEUE", "MESSAGE_QUEUE_URL", "MESSAGE_QUEUE_URI", "MESSAGE_QUEUE_LINK", "MESSAGE_QUEUE_ENDPOINT"];
+const WS_KEYS = ["WS", "WEBSOCKET", "WEBSOCKET_URL", "WEBSOCKET_URI", "WEBSOCKET_LINK", "WEBSOCKET_ENDPOINT"];
+const STORAGE_KEYS = ["STORAGE", "STORAGE_URL", "STORAGE_URI", "STORAGE_LINK", "STORAGE_ENDPOINT"];
+const OTHER_KEYS = ["OTHER", "MISC", "MISC_URL", "MISC_URI", "MISC_LINK", "MISC_ENDPOINT"];
+const subUrlRule = (input) => {
+    input.confidence += 2;
+    const reasons = [`Valid ${input.message} URL (+2)`];
+    const { matched, reason } = matchesEnvKey(input.name, input.keys);
+    if (matched) {
+        input.confidence += 2;
+        reasons.push(`${reason} (+2)`);
+    }
+    return {
+        generated: input.schema,
+        confidence: input.confidence,
+        reasons,
+    };
+};
+const subUrlRules = {
+    HTTP: (name) => {
+        return {
+            message: "HTTP",
+            keys: URL_KEYS,
+            schema: httpUrlGenSchema(name),
+        };
+    },
+    DATABASE: (name) => {
+        return {
+            message: "database",
+            keys: DB_KEYS,
+            schema: databaseUrlGenSchema(name),
+        };
+    },
+    QUEUE: (name) => {
+        return {
+            message: "queue",
+            keys: QUEUE_KEYS,
+            schema: queueUrlGenSchema(name),
+        };
+    },
+    WS: (name) => {
+        return {
+            message: "ws",
+            keys: WS_KEYS,
+            schema: wsUrlSchemaGen(name),
+        };
+    },
+    STORAGE: (name) => {
+        return {
+            message: "storage",
+            keys: STORAGE_KEYS,
+            schema: storageUrlGenSchema(name),
+        };
+    },
+    OTHER: (name) => {
+        return {
+            message: "other",
+            keys: OTHER_KEYS,
+            schema: otherUrlGenSchema(name),
+        };
+    },
+};
+export const urlRule = {
+    type: "url",
+    priority: 5,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeUrl(rawValue))
+            return null;
+        let confidence = 5;
+        const reasons = ["Valid URL (+5)"];
+        const { matched, reason } = matchesEnvKey(name, URL_KEYS);
+        if (matched) {
+            confidence += 2;
+            reasons.push(`${reason} (+2)`);
+        }
+        if (looksLikeHttpUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.HTTP(name),
+            });
+        }
+        if (looksLikeDbUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.DATABASE(name),
+            });
+        }
+        if (looksLikeQueueUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.QUEUE(name),
+            });
+        }
+        if (looksLikeWsUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.WS(name),
+            });
+        }
+        if (looksLikeStorageUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.STORAGE(name),
+            });
+        }
+        if (looksLikeOtherUrl(rawValue)) {
+            return subUrlRule({
+                name,
+                rawValue,
+                confidence,
+                reasons,
+                ...subUrlRules.OTHER(name),
+            });
+        }
+        return {
+            generated: zUrlGenSchema,
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer/rules/version.d.ts

@@ -0,0 +1,3 @@
+import { InferRule } from "../types.js";
+export declare const versionRule: InferRule;
+//# sourceMappingURL=version.d.ts.map

package/dist/infer/rules/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/infer/rules/version.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAOxC,eAAO,MAAM,WAAW,EAAE,SAsBzB,CAAC"}

package/dist/infer/rules/version.js

@@ -0,0 +1,26 @@
+import { looksLikeVersion } from "../../schemas/dotted.js";
+import { matchesEnvKey } from "../helpers.js";
+import { versionGenSchema } from "../generated/version.js";
+const VERSION_KEYS = ["VERSION", "SEMVER", "TAG", "RELEASE"];
+// Note : NEVER add 2 parts version (2.0), it will conflict with numberRules (numberSchema)
+export const versionRule = {
+    type: "version",
+    priority: 5.3,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeVersion(rawValue))
+            return null;
+        let confidence = 5;
+        const reasons = ["Value matches strict version format"];
+        const { matched, reason } = matchesEnvKey(name, VERSION_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            generated: versionGenSchema(name),
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer/types.d.ts

@@ -0,0 +1,87 @@
+/**
+ * represent an import in a generated env.dnl.ts file
+ */
+export type Import = {
+    /**
+     * exact name of the element to import at the top of the generated env.dnl.ts file, ex: "jsonSchema"
+     */
+    name: string;
+    /**
+     * exact name of the package to import, ex: "@romaintaillandier1978/dotenv-never-lies"
+     */
+    from: string;
+};
+/**
+ * represent a generated schema in a generated env.dnl.ts file, with associated import(s)
+ * ex: {
+ *     code: `jsonSchema("${name}")`,
+ *     imports: [{ name: "jsonSchema", from: "@romaintaillandier1978/dotenv-never-lies" }]
+ * }
+ */
+export type GeneratedSchema = {
+    /**
+     * The code that will be written in the dnl schema output, ex: "z.string()" or `jsonSchema("${name}")`
+     */
+    code: string;
+    /**
+     * What to import in dnl schema to support this schema. (set to [] to ignore zod imports.)
+     */
+    imports: Import[];
+};
+/**
+ * Result of an inference
+ */
+export type InferResult = {
+    /**
+     * Generated code and imports
+     */
+    generated: GeneratedSchema;
+    /**
+     * Confidence level (0–10 typically)
+     */
+    confidence: number;
+    /**
+     * for verbose mode
+     */
+    reasons: string[];
+    /**
+     * for warnings, to inject in dnl schema. (not too much)
+     */
+    warnings?: string[];
+};
+/**
+ * Input for an inference or one .env entry
+ */
+export type InferInput = {
+    /**
+     * Name of the .env entry
+     */
+    name: string;
+    /**
+     * Raw value of the .env entry
+     */
+    rawValue: string;
+};
+/**
+ * A reliable rule for an inference.
+ */
+export type InferRule = {
+    /**
+     * Logical identifier (json, boolean, duration, etc.)
+     */
+    type: string;
+    /**
+     * Global order (higher = higher priority)
+     */
+    priority: number;
+    /**
+     * Minimum threshold to accept this inference
+     */
+    threshold: number;
+    /**
+     * Tries to infer a schema for the input.
+     * Returns null if the rule does not apply at all.
+     */
+    tryInfer(input: InferInput): InferResult | null;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/infer/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/infer/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACjB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,MAAM,eAAe,GAAG;IAC1B;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IACtB;;OAEG;IACH,SAAS,EAAE,eAAe,CAAC;IAC3B;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACrB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACpB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,UAAU,GAAG,WAAW,GAAG,IAAI,CAAC;CACnD,CAAC"}

package/dist/infer/types.js

@@ -0,0 +1 @@
+export {};

package/dist/infer-rules/basic.d.ts

@@ -0,0 +1,5 @@
+import { InferencePass } from "./index.js";
+export declare const numberRule: InferencePass;
+export declare const emailRule: InferencePass;
+export declare const stringRule: InferencePass;
+//# sourceMappingURL=basic.d.ts.map

package/dist/infer-rules/basic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["../../src/infer-rules/basic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,UAAU,EAAE,aAqBxB,CAAC;AAEF,eAAO,MAAM,SAAS,EAAE,aAevB,CAAC;AACF,eAAO,MAAM,UAAU,EAAE,aAaxB,CAAC"}

package/dist/infer-rules/basic.js

@@ -0,0 +1,48 @@
+export const numberRule = {
+    type: "number",
+    priority: 4,
+    threshold: 5,
+    tryInfer({ rawValue }) {
+        const n = Number(rawValue);
+        if (Number.isNaN(n))
+            return null;
+        // float ou entier hors port
+        if (rawValue.includes(".") || n < 1 || n > 65535) {
+            return {
+                schema: "z.coerce.number()",
+                importedSchemas: [],
+                confidence: 6,
+                reasons: ["numeric value"],
+            };
+        }
+        return null;
+    },
+};
+export const emailRule = {
+    type: "email",
+    priority: 4,
+    threshold: 5,
+    tryInfer({ rawValue }) {
+        if (!/^[^@]+@[^@]+\.[^@]+$/.test(rawValue))
+            return null;
+        return {
+            schema: "z.email()",
+            importedSchemas: [],
+            confidence: 6,
+            reasons: ["Email-like value"],
+        };
+    },
+};
+export const stringRule = {
+    type: "string",
+    priority: 0,
+    threshold: 0,
+    tryInfer() {
+        return {
+            schema: "z.string()",
+            importedSchemas: [],
+            confidence: 0,
+            reasons: ["Fallback to string"],
+        };
+    },
+};

package/dist/infer-rules/boolean.d.ts

@@ -0,0 +1,3 @@
+import { InferencePass } from "./index.js";
+export declare const booleanRule: InferencePass;
+//# sourceMappingURL=boolean.d.ts.map

package/dist/infer-rules/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../src/infer-rules/boolean.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAiB,MAAM,YAAY,CAAC;AAI1D,eAAO,MAAM,WAAW,EAAE,aAqBzB,CAAC"}

package/dist/infer-rules/boolean.js

@@ -0,0 +1,25 @@
+import { looksLikeValidBoolean } from "../schemas/boolean.js";
+import { matchesEnvKey } from "./index.js";
+const BOOLEAN_KEYS = ["IS_", "HAS_", "ENABLE_", "DISABLE_", "_ENABLED", "_DISABLED", "ALLOW_", "DENY_"];
+export const booleanRule = {
+    type: "boolean",
+    priority: 6,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeValidBoolean(rawValue))
+            return null;
+        let confidence = 6; // valeur bool = signal fort
+        const reasons = ["Value matches strict boolean format"];
+        const { matched, reason } = matchesEnvKey(name, BOOLEAN_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            schema: `boolSchema("${name}")`,
+            importedSchemas: ["boolSchema"],
+            confidence: 10,
+            reasons,
+        };
+    },
+};

package/dist/infer-rules/dotted.d.ts

@@ -0,0 +1,4 @@
+import { InferencePass } from "./index.js";
+export declare const ipRule: InferencePass;
+export declare const versionRule: InferencePass;
+//# sourceMappingURL=dotted.d.ts.map

package/dist/infer-rules/dotted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dotted.d.ts","sourceRoot":"","sources":["../../src/infer-rules/dotted.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAiB,MAAM,YAAY,CAAC;AAI1D,eAAO,MAAM,MAAM,EAAE,aAuBpB,CAAC;AAIF,eAAO,MAAM,WAAW,EAAE,aAuBzB,CAAC"}

package/dist/infer-rules/dotted.js

@@ -0,0 +1,48 @@
+import { looksLikeIp, looksLikeVersion } from "../schemas/dotted.js";
+import { matchesEnvKey } from "./index.js";
+const IP_KEYS = ["_IP", "_ADDRESS", "_HOST", "_HOSTNAME"];
+export const ipRule = {
+    type: "ip",
+    priority: 5.5,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeIp(rawValue))
+            return null;
+        let confidence = 5;
+        const reasons = ["Value matches strict ip format"];
+        const { matched, reason } = matchesEnvKey(name, IP_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            schema: `ipSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["ipSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};
+const VERSION_KEYS = ["_VERSION", "_SEMVER", "_TAG", "_RELEASE"];
+export const versionRule = {
+    type: "version",
+    priority: 5.3,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeVersion(rawValue))
+            return null;
+        let confidence = 5;
+        const reasons = ["Value matches strict version format"];
+        const { matched, reason } = matchesEnvKey(name, VERSION_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            schema: `versionSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["versionSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer-rules/duration.d.ts

@@ -0,0 +1,3 @@
+import { InferencePass } from "./index.js";
+export declare const durationRule: InferencePass;
+//# sourceMappingURL=duration.d.ts.map

package/dist/infer-rules/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../src/infer-rules/duration.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAiB,MAAM,YAAY,CAAC;AAI1D,eAAO,MAAM,YAAY,EAAE,aAuB1B,CAAC"}

package/dist/infer-rules/duration.js

@@ -0,0 +1,25 @@
+import { looksLikeValidDuration } from "../schemas/duration.js";
+import { matchesEnvKey } from "./index.js";
+const DURATION_KEYS = ["_TIMEOUT", "_TTL", "_DELAY", "_DURATION", "_INTERVAL"];
+export const durationRule = {
+    type: "duration",
+    priority: 6,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        if (!looksLikeValidDuration(rawValue))
+            return null;
+        let confidence = 6;
+        const reasons = ["Value matches strict duration format"];
+        const { matched, reason } = matchesEnvKey(name, DURATION_KEYS);
+        if (matched) {
+            confidence += 1;
+            reasons.push(`${reason} (+1)`);
+        }
+        return {
+            schema: `durationSchema(${JSON.stringify(name)})`,
+            importedSchemas: ["durationSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer-rules/index.d.ts

@@ -0,0 +1,50 @@
+export type InferenceResult = {
+    /**
+     * Code TS sérialisé, ex:
+     * "z.string()"
+     * "jsonSchema(\"${name}\")"
+     */
+    schema: string;
+    /**
+    nom exact de l'élément à importer au top du fichier env.dnl.tsgénéré, ex: "jsonSchema"
+     */
+    importedSchemas: Array<string>;
+    /**
+     * Niveau de confiance (0–10 typiquement)
+     */
+    confidence: number;
+    /**
+     * Optionnel, pour debug / warnings futurs
+     */
+    reasons?: string[];
+};
+export type InferenceInput = {
+    name: string;
+    rawValue: string;
+};
+export type InferencePass = {
+    /**
+     * Identifiant logique (json, boolean, duration, etc.)
+     */
+    type: string;
+    /**
+     * Ordre global (plus haut = plus prioritaire)
+     */
+    priority: number;
+    /**
+     * Seuil minimum pour accepter cette inférence
+     */
+    threshold: number;
+    /**
+     * Tente une inférence.
+     * Retourne null si la règle ne s'applique pas du tout.
+     */
+    tryInfer(input: InferenceInput): InferenceResult | null;
+};
+export declare const inferencePasses: InferencePass[];
+export declare const listInferencePasses: InferencePass[];
+export declare const matchesEnvKey: (name: string, keys: string[]) => {
+    matched: boolean;
+    reason: string;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/infer-rules/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/infer-rules/index.ts"],"names":[],"mappings":"AASA,MAAM,MAAM,eAAe,GAAG;IAC1B;;;;OAIG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,eAAe,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC/B;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IACnB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IACxB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,eAAe,GAAG,IAAI,CAAC;CAC3D,CAAC;AAOF,eAAO,MAAM,eAAe,EAAE,aAAa,EAeF,CAAC;AAE1C,eAAO,MAAM,mBAAmB,EAAE,aAAa,EAA2D,CAAC;AAE3G,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,MAAM,MAAM,EAAE,KAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAa9F,CAAC"}

package/dist/infer-rules/index.js

@@ -0,0 +1,42 @@
+import { booleanRule } from "./boolean.js";
+import { durationRule } from "./duration.js";
+import { jsonRule } from "./json.js";
+import { keyValueListRule, keyValueRule, listRule } from "./list.js";
+import { portRule } from "./port.js";
+import { emailRule, numberRule, stringRule } from "./basic.js";
+import { urlRule } from "./url.js";
+import { ipRule, versionRule } from "./dotted.js";
+// ⚠️ Règle d’or :
+// JSON avant list,
+// duration avant number,
+// boolean avant enum,
+export const inferencePasses = [
+    jsonRule, // 10
+    keyValueListRule, // 9
+    keyValueRule, // 8
+    listRule, // 7
+    portRule, //7
+    durationRule, // 6
+    booleanRule, // 6
+    ipRule, // 5.5
+    versionRule, // 5
+    urlRule, // 5
+    emailRule, // 4
+    numberRule, // 3
+    stringRule, // 0 = fallback
+].sort((a, b) => b.priority - a.priority);
+export const listInferencePasses = [portRule, numberRule, emailRule, urlRule, stringRule];
+export const matchesEnvKey = (name, keys) => {
+    for (const key of keys) {
+        if (name.toUpperCase().includes(key.toUpperCase())) {
+            return {
+                matched: true,
+                reason: `Env name contains key: ${key}`,
+            };
+        }
+    }
+    return {
+        matched: false,
+        reason: "No hint in the Env name",
+    };
+};

package/dist/infer-rules/json.d.ts

@@ -0,0 +1,3 @@
+import { InferencePass } from "./index.js";
+export declare const jsonRule: InferencePass;
+//# sourceMappingURL=json.d.ts.map

package/dist/infer-rules/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/infer-rules/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,aAAa,EAAkC,MAAM,YAAY,CAAC;AAI3F,eAAO,MAAM,QAAQ,EAAE,aAiDtB,CAAC"}

package/dist/infer-rules/json.js

@@ -0,0 +1,50 @@
+import { matchesEnvKey } from "./index.js";
+const JSON_KEYS_HIGH = ["JSON"];
+const JSON_KEYS_LOW = ["_PAYLOAD", "_CONFIG", "_DATA", "_META"];
+export const jsonRule = {
+    type: "json",
+    priority: 10,
+    threshold: 5,
+    tryInfer({ name, rawValue }) {
+        let parsed;
+        const reasons = [];
+        try {
+            parsed = JSON.parse(rawValue);
+        }
+        catch {
+            return null;
+        }
+        let confidence = 0;
+        // si pas de {} ni de [], on se retrouve avec une valeur seule, genre "\"romain\"" ou "\"2\"". (avec des guillemets)
+        // Ce serait effectivement un json valie, mais peu de chance que ce soit _intentionnel_
+        // 🔥 structure JSON forte
+        if (rawValue.startsWith("{") || rawValue.startsWith("[")) {
+            confidence += 6;
+            reasons.push("JSON structure (+6)");
+        }
+        else {
+            // JSON primitif : valide mais suspect
+            confidence += 2;
+            reasons.push("JSON primitive (+2)");
+        }
+        // 🔤 heuristiques sur le nom
+        const { matched: matchedHigh, reason: reasonHigh } = matchesEnvKey(name, JSON_KEYS_HIGH);
+        if (matchedHigh) {
+            confidence += 2;
+            reasons.push(`${reasonHigh} (+2)`);
+        }
+        const { matched: matchedLow, reason: reasonLow } = matchesEnvKey(name, JSON_KEYS_LOW);
+        if (matchedLow) {
+            confidence += 1;
+            reasons.push(`${reasonLow} (+1)`);
+        }
+        if (confidence < this.threshold)
+            return null;
+        return {
+            schema: `jsonSchema("${name}")`,
+            importedSchemas: ["jsonSchema"],
+            confidence,
+            reasons,
+        };
+    },
+};

package/dist/infer-rules/list.d.ts

@@ -0,0 +1,5 @@
+import { InferencePass } from "./index.js";
+export declare const keyValueListRule: InferencePass;
+export declare const keyValueRule: InferencePass;
+export declare const listRule: InferencePass;
+//# sourceMappingURL=list.d.ts.map

package/dist/infer-rules/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/infer-rules/list.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAiB,MAAM,YAAY,CAAC;AAS1D,eAAO,MAAM,gBAAgB,EAAE,aAiC9B,CAAC;AAIF,eAAO,MAAM,YAAY,EAAE,aAwB1B,CAAC;AASF,eAAO,MAAM,QAAQ,EAAE,aAgGtB,CAAC"}