@romaintaillandier1978/dotenv-never-lies 1.1.1 → 1.3.0

package/dist/infer/__tests__/rules/ip.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { ipRule } from "../../rules/ip.js";
+describe("Inference rules – ip", () => {
+    it("ipRule should match a valid IP address", () => {
+        const validIps = ["192.168.0.1", "2001:0db8:85a3:0000:0000:8a2e:0370:7334"];
+        for (const rawValue of validIps) {
+            const result = ipRule.tryInfer({
+                name: "HOST_IP",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+        }
+    });
+    it("ipRule should ignore invalid IP addresses", () => {
+        const invalidIps = ["999.999.999.999", "666.666.666", "192.168.0.1.1", "::ffff:192.0.2.1", "::1"];
+        for (const rawValue of invalidIps) {
+            const result = ipRule.tryInfer({
+                name: "HOST_IP",
+                rawValue,
+            });
+            expect(result).toBeNull();
+        }
+    });
+});

package/dist/infer/__tests__/rules/json.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=json.test.d.ts.map

package/dist/infer/__tests__/rules/json.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.test.d.ts","sourceRoot":"","sources":["../../../../src/infer/__tests__/rules/json.test.ts"],"names":[],"mappings":""}

package/dist/infer/__tests__/rules/json.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from "vitest";
+import { jsonRule } from "../../rules/json.js";
+import { jsonGenSchemaNoName } from "../../generated/json.js";
+describe("Inference rules – json", () => {
+    it("jsonRule should match JSON objects", () => {
+        const jsonObjects = ['{"key":"value"}', '["value1","value2"]'];
+        for (const rawValue of jsonObjects) {
+            const result = jsonRule.tryInfer({
+                name: "CONFIG_JSON",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+        }
+    });
+    it("jsonRule should match JSON primitives, with low confidence", () => {
+        const jsonPrimitives = ['"key"', "123", '"true"', '"false"', '"null"'];
+        for (const rawValue of jsonPrimitives) {
+            const result3 = jsonRule.tryInfer({
+                name: "SOMETHING",
+                rawValue,
+            });
+            expect(result3).not.toBeNull();
+            expect(result3?.generated.imports[0].name).toBe(jsonGenSchemaNoName.imports[0].name);
+            expect(result3.confidence).toBeLessThan(jsonRule.threshold);
+            expect(result3?.reasons?.some((r) => r.includes("primitive"))).toBe(true);
+        }
+    });
+    it("jsonRule should ignore invalid JSON", () => {
+        const invalidJson = ['{"key":}', '["value1","value2"}'];
+        for (const rawValue of invalidJson) {
+            const result = jsonRule.tryInfer({
+                name: "CONFIG_JSON",
+                rawValue,
+            });
+            expect(result).toBeNull();
+        }
+    });
+});

package/dist/infer/__tests__/rules/list.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=list.test.d.ts.map

package/dist/infer/__tests__/rules/list.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.test.d.ts","sourceRoot":"","sources":["../../../../src/infer/__tests__/rules/list.test.ts"],"names":[],"mappings":""}

package/dist/infer/__tests__/rules/list.test.js

@@ -0,0 +1,130 @@
+import { describe, it, expect } from "vitest";
+import { keyValueListRule, keyValueRule, listRule } from "../../rules/list.js";
+describe("Inference rules – list", () => {
+    it("keyValueListRule should match multiple key-value pairs", () => {
+        const keyValueList = [
+            "env=prod;region=eu",
+            "env=prod,region=eu",
+            "env=prod&region=eu",
+            "env:prod&region:eu",
+            "a=b;c=d",
+            "a=b;c=d;e=f",
+            "a:b;c:d",
+            "a:b;c:d;e:f",
+        ];
+        for (const rawValue of keyValueList) {
+            const result = keyValueListRule.tryInfer({
+                name: "APP_LABELS",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+        }
+    });
+    it("keyValueListRule should match multiple key=value strange with various splitters", () => {
+        const keyValueList = ["a=b,c=d;e=f", "a=b;e=f,c=d", "a=b&c=d,e=f", "a=b,e=f&c=d", "a=b;c=d,e"];
+        for (const rawValue of keyValueList) {
+            const result = keyValueListRule.tryInfer({
+                name: "APP_LABELS",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+        }
+    });
+    it("keyValueListRule should not match multiple ambigous key=value strange with various splitters", () => {
+        const keyValueList = ["a=b;c=d,e=f&g=h", "a:b;c:d,e:f&g:h", "a=b;c:d", "a:b;c=d", "a=b,c:d", "a=b;c", "a,b,c", "a;b;c", "abc", "1;2;3"];
+        for (const rawValue of keyValueList) {
+            const result = keyValueListRule.tryInfer({
+                name: "APP_LABELS",
+                rawValue,
+            });
+            expect(result).toBeNull();
+        }
+    });
+    it("keyValueListRule should not match multiple ambigous key=value strange with various splitters", () => {
+        const keyValueList = ["a=b;c=d,e=f&g=h", "a:b;c:d,e:f&g:h", "a=b;c:d", "a:b;c=d", "a=b,c:d", "a=b;c", "a,b,c", "a;b;c", "abc", "1;2;3"];
+        for (const rawValue of keyValueList) {
+            const result = keyValueListRule.tryInfer({
+                name: "APP_LABELS",
+                rawValue,
+            });
+            expect(result).toBeNull();
+        }
+    });
+    it("keyValueRule should match incomplete key=value pair", () => {
+        const keyValue = ["a=b;;c=d", "a=b,&c=d", "a=b;", ";a=b"];
+        for (const rawValue of keyValue) {
+            const result = keyValueRule.tryInfer({
+                name: "APP_CONFIG",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+        }
+    });
+    it("listRule should match comma-separated values", () => {
+        const list = [
+            "a;b",
+            "a;b;c",
+            "1;2;3",
+            "foo;bar;baz",
+            "8080;8081;8082",
+            "red;green;blue",
+            "https://google.com;https://github.com;https://www.npmjs.com/package/@romaintaillandier1978/dotenv-never-lies?activeTab=readme",
+            "user@mail.com;admin@mail.com",
+            "a,b",
+            "a,b,c",
+            "1,2,3",
+            "foo,bar,baz",
+            "8080,8081,8082",
+            "red,green,blue",
+            "http://a.com,http://b.com",
+            "user@mail.com,admin@mail.com",
+        ];
+        for (const rawValue of list) {
+            const result = listRule.tryInfer({
+                name: "ALLOWED_LIST",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+        }
+    });
+    it("listRule should prioritize ';' over ',' when both are present", () => {
+        const list = ["a,b;c,d", "1,2;3,4", "foo,bar;baz", "http://a.com,http://b.com;http://c.com"];
+        for (const rawValue of list) {
+            const result = listRule.tryInfer({
+                name: "MIXED_LIST",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+        }
+    });
+    it("listRule should not match something that is not a list (not a list)", () => {
+        const list = ["a", "1", "true", "false", "listRule should not match something that is not a list (not a list)", ""];
+        for (const rawValue of list) {
+            const result = listRule.tryInfer({
+                name: "MIXED_LIST",
+                rawValue,
+            });
+            expect(result).toBeNull();
+        }
+    });
+    it("listRule should match border cases of list with empty values, or containing space", () => {
+        const list = ["a,,b", "a;;b", "a;;b;;", ",a,b", ";a;b", "a; b ;c", "a , b , c"];
+        for (const rawValue of list) {
+            const result = listRule.tryInfer({
+                name: "MIXED_LIST",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+        }
+    });
+    it("listRule should match border casesonly empt values", () => {
+        const list = [";;;;"];
+        for (const rawValue of list) {
+            const result = listRule.tryInfer({
+                name: "MIXED_LIST",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+        }
+    });
+});

package/dist/infer/__tests__/rules/port.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=port.test.d.ts.map

package/dist/infer/__tests__/rules/port.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port.test.d.ts","sourceRoot":"","sources":["../../../../src/infer/__tests__/rules/port.test.ts"],"names":[],"mappings":""}

package/dist/infer/__tests__/rules/port.test.js

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { portRule } from "../../rules/port.js";
+describe("Inference rules – port", () => {
+    it("portRule should match a valid port number", () => {
+        const validPorts = ["5432", "8080", "3000"];
+        for (const rawValue of validPorts) {
+            const result = portRule.tryInfer({
+                name: "DB_PORT",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+        }
+    });
+    it("portRule should ignore invalid port numbers", () => {
+        const invalidPorts = ["70000", "0", "-1", "65536"];
+        for (const rawValue of invalidPorts) {
+            const result = portRule.tryInfer({
+                name: "PORT",
+                rawValue,
+            });
+            expect(result).toBeNull();
+        }
+    });
+});

package/dist/infer/__tests__/rules/url.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=url.test.d.ts.map

package/dist/infer/__tests__/rules/url.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.test.d.ts","sourceRoot":"","sources":["../../../../src/infer/__tests__/rules/url.test.ts"],"names":[],"mappings":""}

package/dist/infer/__tests__/rules/url.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect } from "vitest";
+import { urlRule } from "../../rules/url.js";
+import { databaseUrlGenSchema, httpUrlGenSchema } from "../../generated/url.js";
+describe("Inference rules – url", () => {
+    it("urlRule should match an HTTP URL", () => {
+        const httpUrls = ["https://example.com", "http://example.com"];
+        for (const rawValue of httpUrls) {
+            const result = urlRule.tryInfer({
+                name: "HTTP_URL",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+            expect(result?.generated.imports[0].name).toBe(httpUrlGenSchema(rawValue).imports[0].name);
+            expect(result.confidence).toBeGreaterThanOrEqual(urlRule.threshold);
+        }
+    });
+    it("urlRule should match a database URL", () => {
+        const databaseUrls = ["postgres://user:pass@localhost:5432/app"];
+        for (const rawValue of databaseUrls) {
+            const result = urlRule.tryInfer({
+                name: "DATABASE_URL",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+            expect(result?.generated.imports[0].name).toBe(databaseUrlGenSchema(rawValue).imports[0].name);
+            expect(result.confidence).toBeGreaterThanOrEqual(urlRule.threshold);
+        }
+    });
+    it("urlRule should ignore invalid URLs", () => {
+        const invalidUrls = ["not-a-url", "https://", "not-a-url but contains a valid URL: https://example.com/path"];
+        for (const rawValue of invalidUrls) {
+            const result = urlRule.tryInfer({
+                name: "API_URL",
+                rawValue,
+            });
+            expect(result).toBeNull();
+        }
+    });
+});

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=version.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"version.test.d.ts","sourceRoot":"","sources":["../../../../src/infer/__tests__/rules/version.test.ts"],"names":[],"mappings":""}

package/dist/infer/__tests__/rules/version.test.js

@@ -0,0 +1,37 @@
+import { describe, it, expect } from "vitest";
+import { versionRule } from "../../rules/version.js";
+import { versionGenSchema } from "../../generated/version.js";
+describe("Inference rules – version", () => {
+    it("versionRule should match a strict semver value", () => {
+        const validVersions = ["1.2.3", "123.345.567336"];
+        for (const rawValue of validVersions) {
+            const result = versionRule.tryInfer({
+                name: "APP_VERSION",
+                rawValue,
+            });
+            expect(result).not.toBeNull();
+            expect(result?.generated.imports[0].name).toBe(versionGenSchema(rawValue).imports[0].name);
+            expect(result.confidence).toBeGreaterThanOrEqual(versionRule.threshold);
+        }
+    });
+    it("versionRule should ignore two-part versions", () => {
+        const invalidVersions = ["2.0"];
+        for (const rawValue of invalidVersions) {
+            const result = versionRule.tryInfer({
+                name: "APP_VERSION",
+                rawValue,
+            });
+            expect(result).toBeNull();
+        }
+    });
+    it("versionRule should ignore invalid versions", () => {
+        const invalidVersions = ["v3.0", "v1.2.3", "3.0.0-rc", "123.345.A", "1.2.3A"];
+        for (const rawValue of invalidVersions) {
+            const result = versionRule.tryInfer({
+                name: "APP_VERSION",
+                rawValue,
+            });
+            expect(result).toBeNull();
+        }
+    });
+});

package/dist/infer/generated/basic.d.ts

@@ -0,0 +1,8 @@
+import { GeneratedSchema } from "../types.js";
+export declare const zUnknownGenSchema: GeneratedSchema;
+export declare const zArrayOfUnknownGenSchema: GeneratedSchema;
+export declare const zUrlGenSchema: GeneratedSchema;
+export declare const zStringGenSchema: GeneratedSchema;
+export declare const zNumberGenSchema: GeneratedSchema;
+export declare const zEmailGenSchema: GeneratedSchema;
+//# sourceMappingURL=basic.d.ts.map

package/dist/infer/generated/basic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basic.d.ts","sourceRoot":"","sources":["../../../src/infer/generated/basic.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,iBAAiB,EAAE,eAG/B,CAAC;AACF,eAAO,MAAM,wBAAwB,EAAE,eAGtC,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,eAG3B,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,eAG9B,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,eAG9B,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eAG7B,CAAC"}

package/dist/infer/generated/basic.js

@@ -0,0 +1,24 @@
+export const zUnknownGenSchema = {
+    code: "z.unknown()",
+    imports: [],
+};
+export const zArrayOfUnknownGenSchema = {
+    code: "z.array(z.unknown())",
+    imports: [],
+};
+export const zUrlGenSchema = {
+    code: "z.url()",
+    imports: [],
+};
+export const zStringGenSchema = {
+    code: "z.string()",
+    imports: [],
+};
+export const zNumberGenSchema = {
+    code: "z.coerce.number()",
+    imports: [],
+};
+export const zEmailGenSchema = {
+    code: "z.email()",
+    imports: [],
+};

package/dist/infer/generated/boolean.d.ts

@@ -0,0 +1,3 @@
+import { GeneratedSchema } from "../types.js";
+export declare const boolGenSchema: (name: string) => GeneratedSchema;
+//# sourceMappingURL=boolean.d.ts.map

package/dist/infer/generated/boolean.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boolean.d.ts","sourceRoot":"","sources":["../../../src/infer/generated/boolean.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,eAQ3C,CAAC"}

package/dist/infer/generated/boolean.js

@@ -0,0 +1,9 @@
+export const boolGenSchema = (name) => ({
+    code: `boolSchema(${JSON.stringify(name)})`,
+    imports: [
+        {
+            name: "boolSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});

package/dist/infer/generated/duration.d.ts

@@ -0,0 +1,3 @@
+import { GeneratedSchema } from "../types.js";
+export declare const durationGenSchema: (name: string) => GeneratedSchema;
+//# sourceMappingURL=duration.d.ts.map

package/dist/infer/generated/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../src/infer/generated/duration.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,eAQ/C,CAAC"}

package/dist/infer/generated/duration.js

@@ -0,0 +1,9 @@
+export const durationGenSchema = (name) => ({
+    code: `durationSchema(${JSON.stringify(name)})`,
+    imports: [
+        {
+            name: "durationSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});

package/dist/infer/generated/ip.d.ts

@@ -0,0 +1,3 @@
+import { GeneratedSchema } from "../types.js";
+export declare const ipGenSchema: (name: string) => GeneratedSchema;
+//# sourceMappingURL=ip.d.ts.map

package/dist/infer/generated/ip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip.d.ts","sourceRoot":"","sources":["../../../src/infer/generated/ip.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,eAQzC,CAAC"}

package/dist/infer/generated/ip.js

@@ -0,0 +1,9 @@
+export const ipGenSchema = (name) => ({
+    code: `ipSchema(${JSON.stringify(name)})`,
+    imports: [
+        {
+            name: "ipSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});

package/dist/infer/generated/json.d.ts

@@ -0,0 +1,4 @@
+import { GeneratedSchema } from "../types.js";
+export declare const jsonGenSchema: (name: string, of?: GeneratedSchema) => GeneratedSchema;
+export declare const jsonGenSchemaNoName: GeneratedSchema;
+//# sourceMappingURL=json.d.ts.map

package/dist/infer/generated/json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../src/infer/generated/json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,KAAK,eAAe,KAAG,eAQjE,CAAC;AAEH,eAAO,MAAM,mBAAmB,iBAAoB,CAAC"}

package/dist/infer/generated/json.js

@@ -0,0 +1,10 @@
+export const jsonGenSchema = (name, of) => ({
+    code: `jsonSchema(${JSON.stringify(name)}${of ? `, ${of.code}` : ""})`,
+    imports: [
+        {
+            name: "jsonSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});
+export const jsonGenSchemaNoName = jsonGenSchema("");

package/dist/infer/generated/list.d.ts

@@ -0,0 +1,8 @@
+import { GeneratedSchema } from "../types.js";
+export declare const listSchemaGen: (name: string) => GeneratedSchema;
+export declare const keyValueSchemaGen: (name: string) => GeneratedSchema;
+export declare const keyValueListSchemaGen: (name: string) => GeneratedSchema;
+export declare const urlListSchemaGen: (name: string) => GeneratedSchema;
+export declare const emailListSchemaGen: (name: string) => GeneratedSchema;
+export declare const listOfSchemaGen: (name: string, of: GeneratedSchema) => GeneratedSchema;
+//# sourceMappingURL=list.d.ts.map

package/dist/infer/generated/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../../src/infer/generated/list.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,eAQ3C,CAAC;AAEH,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,eAQ/C,CAAC;AACH,eAAO,MAAM,qBAAqB,GAAI,MAAM,MAAM,KAAG,eAQnD,CAAC;AAEH,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,eAQ9C,CAAC;AAEH,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,KAAG,eAQhD,CAAC;AAEH,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,EAAE,IAAI,eAAe,KAAG,eAGlE,CAAC"}

package/dist/infer/generated/list.js

@@ -0,0 +1,49 @@
+export const listSchemaGen = (name) => ({
+    code: `listSchema(${JSON.stringify(name)})`,
+    imports: [
+        {
+            name: "listSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});
+export const keyValueSchemaGen = (name) => ({
+    code: `keyValueSchema("${JSON.stringify(name)}")`,
+    imports: [
+        {
+            name: "keyValueSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});
+export const keyValueListSchemaGen = (name) => ({
+    code: `keyValueListSchema(${JSON.stringify(name)})`,
+    imports: [
+        {
+            name: "keyValueListSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});
+export const urlListSchemaGen = (name) => ({
+    code: `urlListSchema(${JSON.stringify(name)})`,
+    imports: [
+        {
+            name: "urlListSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});
+export const emailListSchemaGen = (name) => ({
+    code: `emailListSchema(${JSON.stringify(name)})`,
+    imports: [
+        {
+            name: "emailListSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});
+export const listOfSchemaGen = (name, of) => ({
+    code: `listSchema(${JSON.stringify(name)}, { of: ${of.code} })`,
+    imports: [{ name: "listSchema", from: "@romaintaillandier1978/dotenv-never-lies" }, ...of.imports],
+});

package/dist/infer/generated/port.d.ts

@@ -0,0 +1,4 @@
+import { GeneratedSchema } from "../types.js";
+export declare const portGenSchema: (name: string) => GeneratedSchema;
+export declare const portGenSchemaNoName: GeneratedSchema;
+//# sourceMappingURL=port.d.ts.map

package/dist/infer/generated/port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port.d.ts","sourceRoot":"","sources":["../../../src/infer/generated/port.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,eAQ3C,CAAC;AAEH,eAAO,MAAM,mBAAmB,iBAAoB,CAAC"}

package/dist/infer/generated/port.js

@@ -0,0 +1,10 @@
+export const portGenSchema = (name) => ({
+    code: `portSchema(${JSON.stringify(name)})`,
+    imports: [
+        {
+            name: "portSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});
+export const portGenSchemaNoName = portGenSchema("");

package/dist/infer/generated/url.d.ts

@@ -0,0 +1,14 @@
+import { GeneratedSchema } from "../types.js";
+export declare const httpUrlGenSchema: (name: string) => GeneratedSchema;
+export declare const httpUrlGenSchemaNoName: GeneratedSchema;
+export declare const databaseUrlGenSchema: (name: string) => GeneratedSchema;
+export declare const databaseUrlGenSchemaNoName: GeneratedSchema;
+export declare const queueUrlGenSchema: (name: string) => GeneratedSchema;
+export declare const queueUrlGenSchemaNoName: GeneratedSchema;
+export declare const wsUrlSchemaGen: (name: string) => GeneratedSchema;
+export declare const wsUrlGenSchemaNoName: GeneratedSchema;
+export declare const storageUrlGenSchema: (name: string) => GeneratedSchema;
+export declare const storageUrlGenSchemaNoName: GeneratedSchema;
+export declare const otherUrlGenSchema: (name: string) => GeneratedSchema;
+export declare const otherUrlGenSchemaNoName: GeneratedSchema;
+//# sourceMappingURL=url.d.ts.map

package/dist/infer/generated/url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url.d.ts","sourceRoot":"","sources":["../../../src/infer/generated/url.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,eAG9C,CAAC;AAEH,eAAO,MAAM,sBAAsB,iBAAuB,CAAC;AAE3D,eAAO,MAAM,oBAAoB,GAAI,MAAM,MAAM,KAAG,eAGlD,CAAC;AAEH,eAAO,MAAM,0BAA0B,iBAA2B,CAAC;AAEnE,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,eAG/C,CAAC;AAEH,eAAO,MAAM,uBAAuB,iBAAwB,CAAC;AAE7D,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,eAG5C,CAAC;AAEH,eAAO,MAAM,oBAAoB,iBAAqB,CAAC;AAEvD,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,KAAG,eAGjD,CAAC;AAEH,eAAO,MAAM,yBAAyB,iBAA0B,CAAC;AAEjE,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,eAG/C,CAAC;AAEH,eAAO,MAAM,uBAAuB,iBAAwB,CAAC"}

package/dist/infer/generated/url.js

@@ -0,0 +1,30 @@
+export const httpUrlGenSchema = (name) => ({
+    code: `httpUrlSchema(${JSON.stringify(name)})`,
+    imports: [{ name: "httpUrlSchema", from: "@romaintaillandier1978/dotenv-never-lies" }],
+});
+export const httpUrlGenSchemaNoName = httpUrlGenSchema("");
+export const databaseUrlGenSchema = (name) => ({
+    code: `databaseUrlSchema(${JSON.stringify(name)})`,
+    imports: [{ name: "databaseUrlSchema", from: "@romaintaillandier1978/dotenv-never-lies" }],
+});
+export const databaseUrlGenSchemaNoName = databaseUrlGenSchema("");
+export const queueUrlGenSchema = (name) => ({
+    code: `queueUrlSchema(${JSON.stringify(name)})`,
+    imports: [{ name: "queueUrlSchema", from: "@romaintaillandier1978/dotenv-never-lies" }],
+});
+export const queueUrlGenSchemaNoName = queueUrlGenSchema("");
+export const wsUrlSchemaGen = (name) => ({
+    code: `wsUrlSchema(${JSON.stringify(name)})`,
+    imports: [{ name: "wsUrlSchema", from: "@romaintaillandier1978/dotenv-never-lies" }],
+});
+export const wsUrlGenSchemaNoName = wsUrlSchemaGen("");
+export const storageUrlGenSchema = (name) => ({
+    code: `storageUrlSchema(${JSON.stringify(name)})`,
+    imports: [{ name: "storageUrlSchema", from: "@romaintaillandier1978/dotenv-never-lies" }],
+});
+export const storageUrlGenSchemaNoName = storageUrlGenSchema("");
+export const otherUrlGenSchema = (name) => ({
+    code: `otherUrlSchema(${JSON.stringify(name)})`,
+    imports: [{ name: "otherUrlSchema", from: "@romaintaillandier1978/dotenv-never-lies" }],
+});
+export const otherUrlGenSchemaNoName = otherUrlGenSchema("");

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

@@ -0,0 +1,4 @@
+import { GeneratedSchema } from "../types.js";
+export declare const versionGenSchema: (name: string) => GeneratedSchema;
+export declare const versionGenSchemaNoName: GeneratedSchema;
+//# sourceMappingURL=version.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/infer/generated/version.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,KAAG,eAQ9C,CAAC;AACH,eAAO,MAAM,sBAAsB,iBAAuB,CAAC"}

package/dist/infer/generated/version.js

@@ -0,0 +1,10 @@
+export const versionGenSchema = (name) => ({
+    code: `versionSchema(${JSON.stringify(name)})`,
+    imports: [
+        {
+            name: "versionSchema",
+            from: "@romaintaillandier1978/dotenv-never-lies",
+        },
+    ],
+});
+export const versionGenSchemaNoName = versionGenSchema("");

package/dist/infer/helpers.d.ts

@@ -0,0 +1,11 @@
+import { GeneratedSchema } from "./types.js";
+export declare const inferSimpleSchemaForListItem: (rawValue: string) => GeneratedSchema;
+export type MatchesEnvKeyResult = {
+    matched: boolean;
+    reason: string;
+};
+export declare const matchesEnvKey: (name: string, keys: string[]) => MatchesEnvKeyResult;
+export declare const guessSecret: (name: string) => boolean;
+export declare const areAllSameGenSchemas: (elements: GeneratedSchema[]) => boolean;
+export declare const areSameGenSchemas: (a: GeneratedSchema, b: GeneratedSchema) => boolean;
+//# sourceMappingURL=helpers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/infer/helpers.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAE7C,eAAO,MAAM,4BAA4B,GAAI,UAAU,MAAM,KAAG,eAY/D,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAIvE,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,EAAE,MAAM,MAAM,EAAE,KAAG,mBAW5D,CAAC;AAIF,eAAO,MAAM,WAAW,GAAI,MAAM,MAAM,KAAG,OAE1C,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,UAAU,eAAe,EAAE,KAAG,OAGlE,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,GAAG,eAAe,EAAE,GAAG,eAAe,KAAG,OAK1E,CAAC"}