@buoy-gg/env 1.7.2

package/lib/module/env/utils/envTypeDetector.js

@@ -0,0 +1,55 @@
+"use strict";
+
+/**
+ * Detects the type of an environment variable value
+ * First checks if useDynamicEnv already parsed it to the correct type,
+ * then analyzes string content to detect what type it represents
+ *
+ * @returns One of: "string", "number", "boolean", "array", "object"
+ */
+export function getEnvVarType(value) {
+  // Check the actual parsed value type from useDynamicEnv
+  const type = typeof value;
+  if (type === "boolean") return "boolean";
+  if (type === "number") return "number";
+  if (Array.isArray(value)) return "array";
+  if (type === "object" && value !== null) return "object";
+
+  // For strings, check if they look like other types
+  if (type === "string") {
+    const strValue = value;
+
+    // Check if it looks like JSON
+    if (strValue.startsWith("{") && strValue.endsWith("}") || strValue.startsWith("[") && strValue.endsWith("]")) {
+      try {
+        const parsed = JSON.parse(strValue);
+        return Array.isArray(parsed) ? "array" : "object";
+      } catch {
+        return "string";
+      }
+    }
+
+    // Check if it's a boolean string
+    const lowerStr = strValue.toLowerCase();
+    if (lowerStr === "true" || lowerStr === "false" || lowerStr === "enabled" || lowerStr === "disabled" || lowerStr === "yes" || lowerStr === "no" || lowerStr === "on" || lowerStr === "off") {
+      return "boolean";
+    }
+
+    // Check if it's a number string (including 1 and 0 as numbers, not booleans)
+    if (!isNaN(Number(strValue)) && strValue.trim() !== "") {
+      return "number";
+    }
+
+    // Check if it's a URL
+    if (strValue.startsWith("http://") || strValue.startsWith("https://")) {
+      return "url";
+    }
+
+    // Check if it's a comma-separated array
+    if (strValue.includes(",")) {
+      return "array";
+    }
+    return "string";
+  }
+  return "unknown";
+}

package/lib/module/env/utils/helpers.js

@@ -0,0 +1,114 @@
+"use strict";
+
+/**
+ * Helper to create a required env var configuration with type checking
+ *
+ * @example
+ * const config = envVar("EXPO_PUBLIC_API_URL")
+ *   .withType("string")
+ *   .withDescription("Backend API endpoint")
+ *   .build();
+ *
+ * @example
+ * const config = envVar("EXPO_PUBLIC_DEBUG_MODE")
+ *   .withDescription("Enable debug logging")
+ *   .withType("boolean")
+ *   .build();
+ */
+class EnvVarBuilder {
+  constructor(key) {
+    this.key = key;
+  }
+  /** Just check if the variable exists */
+  exists() {
+    return this.key;
+  }
+
+  /** Check for a specific value */
+  withValue(value) {
+    this.expectedValue = value;
+    delete this.expectedType; // Can't have both type and value
+    return this;
+  }
+
+  /** Check for a specific type */
+  withType(type) {
+    this.expectedType = type;
+    delete this.expectedValue; // Can't have both type and value
+    return this;
+  }
+
+  /** Add a description for documentation */
+  withDescription(desc) {
+    this.description = desc;
+    return this;
+  }
+
+  /** Build the final configuration */
+  build() {
+    if (this.expectedValue !== undefined) {
+      return this.description ? {
+        key: this.key,
+        expectedValue: this.expectedValue,
+        description: this.description
+      } : {
+        key: this.key,
+        expectedValue: this.expectedValue
+      };
+    }
+    if (this.expectedType !== undefined) {
+      return this.description ? {
+        key: this.key,
+        expectedType: this.expectedType,
+        description: this.description
+      } : {
+        key: this.key,
+        expectedType: this.expectedType
+      };
+    }
+
+    // If neither type nor value is specified, just check existence
+    return this.key;
+  }
+}
+
+/**
+ * Fluent builder for defining expected environment variables. Helps teams author readable
+ * `requiredEnvVars` arrays by chaining type/value/description requirements while keeping the
+ * final shape compatible with `EnvVarsModal` and related helpers.
+ *
+ * @param key - Environment variable name to validate.
+ * @returns Builder with convenience methods like `.withType()` and `.withValue()`.
+ */
+export function envVar(key) {
+  return new EnvVarBuilder(key);
+}
+
+/**
+ * Normalizes `requiredEnvVars` definitions while documenting intent in code. The helper simply
+ * returns the provided array, but allows teams to co-locate examples and benefit from IDE hovers.
+ *
+ * @param vars - Collection of required environment variable definitions created manually or via `envVar()`.
+ * @returns The original array, unchanged, for ergonomic chaining and inference.
+ *
+ * @example
+ * const requiredEnvVars = createEnvVarConfig([
+ *   // Simple existence check
+ *   "EXPO_PUBLIC_API_URL",
+ *
+ *   // Type checking
+ *   { key: "EXPO_PUBLIC_DEBUG_MODE", expectedType: "boolean" },
+ *
+ *   // Value checking
+ *   { key: "EXPO_PUBLIC_ENVIRONMENT", expectedValue: "development" },
+ *
+ *   // With descriptions
+ *   envVar("EXPO_PUBLIC_MAX_RETRIES")
+ *     .withType("number")
+ *     .withDescription("Maximum number of API retry attempts")
+ *     .build(),
+ * ]);
+ */
+export function createEnvVarConfig(vars) {
+  return vars;
+}

package/lib/module/env/utils/index.js

@@ -0,0 +1,5 @@
+"use strict";
+
+export * from "./envTypeDetector";
+export * from "./helpers";
+export * from "./utils";

package/lib/module/env/utils/utils.js

@@ -0,0 +1,116 @@
+"use strict";
+
+import { getEnvVarType } from "./envTypeDetector";
+
+/**
+ * Combines the auto-detected runtime environment values with the declared `requiredEnvVars`
+ * configuration and produces categorized metadata for rendering in the UI.
+ *
+ * @param autoCollectedEnvVars - Values discovered via `useDynamicEnv` (key/value string map).
+ * @param requiredEnvVars - Optional list of required variables describing expectations to validate.
+ * @returns Required and optional variable collections annotated with validation status.
+ */
+export const processEnvVars = (autoCollectedEnvVars, requiredEnvVars) => {
+  const requiredVarInfos = [];
+  const optionalVarInfos = [];
+  const processedKeys = new Set();
+
+  // Process required variables
+  requiredEnvVars?.forEach(envVar => {
+    const key = typeof envVar === "string" ? envVar : envVar.key;
+    const expectedValue = typeof envVar === "object" && "expectedValue" in envVar ? envVar.expectedValue : undefined;
+    const expectedType = typeof envVar === "object" && "expectedType" in envVar ? envVar.expectedType : undefined;
+    const description = typeof envVar === "object" && "description" in envVar ? envVar.description : undefined;
+    processedKeys.add(key);
+    const actualValue = autoCollectedEnvVars[key];
+    const isPresent = actualValue !== undefined;
+    let status;
+    if (!isPresent) {
+      status = "required_missing";
+    } else if (expectedValue) {
+      // Handle different expectedValue patterns
+      let valueMatches = false;
+      if (expectedValue === "sk_*") {
+        valueMatches = actualValue.startsWith("sk_");
+      } else if (expectedValue === "production or development") {
+        valueMatches = actualValue === "production" || actualValue === "development";
+      } else {
+        valueMatches = actualValue === expectedValue;
+      }
+      status = valueMatches ? "required_present" : "required_wrong_value";
+    } else if (expectedType && getEnvVarType(actualValue).toLowerCase() !== expectedType.toLowerCase()) {
+      status = "required_wrong_type";
+    } else {
+      status = "required_present";
+    }
+    requiredVarInfos.push({
+      key,
+      value: actualValue,
+      expectedValue,
+      expectedType,
+      description,
+      status,
+      category: "required"
+    });
+  });
+
+  // Process optional variables (those that exist but aren't required)
+  Object.entries(autoCollectedEnvVars).forEach(([key, value]) => {
+    if (!processedKeys.has(key)) {
+      optionalVarInfos.push({
+        key,
+        value,
+        status: "optional_present",
+        category: "optional"
+      });
+    }
+  });
+
+  // Sort each category
+  requiredVarInfos.sort((a, b) => {
+    const statusOrder = {
+      required_missing: 0,
+      required_wrong_value: 1,
+      required_wrong_type: 2,
+      required_present: 3,
+      optional_present: 4
+    };
+    if (statusOrder[a.status] !== statusOrder[b.status]) {
+      return statusOrder[a.status] - statusOrder[b.status];
+    }
+    return a.key.localeCompare(b.key);
+  });
+  optionalVarInfos.sort((a, b) => a.key.localeCompare(b.key));
+  return {
+    requiredVars: requiredVarInfos,
+    optionalVars: optionalVarInfos
+  };
+};
+
+/**
+ * Derives aggregate statistics from the processed environment variable lists for health badges
+ * and summary chips in the modal UI.
+ *
+ * @param requiredVars - Processed required variables with validation state.
+ * @param optionalVars - Processed optional variables discovered at runtime.
+ * @param totalEnvVars - Raw key/value map of every detected environment variable.
+ * @returns Counts related to overall env health for display purposes.
+ */
+export const calculateStats = (requiredVars, optionalVars, totalEnvVars) => {
+  const totalCount = Object.keys(totalEnvVars).length;
+  const requiredCount = requiredVars.length;
+  const missingCount = requiredVars.filter(v => v.status === "required_missing").length;
+  const wrongValueCount = requiredVars.filter(v => v.status === "required_wrong_value").length;
+  const wrongTypeCount = requiredVars.filter(v => v.status === "required_wrong_type").length;
+  const presentRequiredCount = requiredVars.filter(v => v.status === "required_present").length;
+  const optionalCount = optionalVars.length;
+  return {
+    totalCount,
+    requiredCount,
+    missingCount,
+    wrongValueCount,
+    wrongTypeCount,
+    presentRequiredCount,
+    optionalCount
+  };
+};

package/lib/module/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+// Export preset configuration (easiest way to add to FloatingDevTools!)
+export { envToolPreset, createEnvTool } from "./preset";
+
+// Export main modal component
+export { EnvVarsModal } from "./env/components/EnvVarsModal";
+
+// Export types (Environment, UserRole, RequiredEnvVar, etc.)
+export * from "./env/types";
+
+// Export utilities (createEnvVarConfig, envVar, etc.)
+export * from "./env/utils";

package/lib/module/preset.js

@@ -0,0 +1,85 @@
+"use strict";
+
+/**
+ * Pre-configured environment variables tool for FloatingDevTools
+ *
+ * This preset provides a zero-config way to add env var inspection to your dev tools.
+ * Just import and add it to your apps array!
+ *
+ * @example
+ * ```tsx
+ * import { envToolPreset } from '@buoy-gg/env';
+ *
+ * const installedApps = [
+ *   envToolPreset, // That's it!
+ *   // ...other tools
+ * ];
+ * ```
+ */
+
+import { EnvIcon } from "@buoy-gg/floating-tools-core";
+import { EnvVarsModal } from "./env/components/EnvVarsModal";
+import { jsx as _jsx } from "react/jsx-runtime";
+/**
+ * Pre-configured environment variables tool for FloatingDevTools.
+ * Includes:
+ * - Automatic env var discovery
+ * - Required variable validation
+ * - Search and filtering
+ * - Copy functionality
+ */
+export const envToolPreset = {
+  id: "env",
+  name: "ENV",
+  description: "Environment variables debugger",
+  slot: "both",
+  icon: ({
+    size
+  }) => /*#__PURE__*/_jsx(EnvIcon, {
+    size: size
+  }),
+  component: EnvVarsModal,
+  props: {
+    requiredEnvVars: [],
+    enableSharedModalDimensions: true
+  }
+};
+
+/**
+ * Create a custom environment variables tool configuration.
+ * Use this if you want to override default settings or provide required env vars.
+ *
+ * @example
+ * ```tsx
+ * import { createEnvTool, envVar, createEnvVarConfig } from '@buoy-gg/env';
+ *
+ * const requiredEnvVars = createEnvVarConfig([
+ *   envVar("EXPO_PUBLIC_API_URL").exists(),
+ *   envVar("EXPO_PUBLIC_DEBUG_MODE").withType("boolean").build(),
+ * ]);
+ *
+ * const myEnvTool = createEnvTool({
+ *   requiredEnvVars,
+ *   colorPreset: "cyan",
+ *   enableSharedModalDimensions: true,
+ * });
+ * ```
+ */
+export function createEnvTool(options) {
+  return {
+    id: options?.id || "env",
+    name: options?.name || "ENV",
+    description: options?.description || "Environment variables debugger",
+    slot: "both",
+    icon: ({
+      size
+    }) => /*#__PURE__*/_jsx(EnvIcon, {
+      size: size
+    }),
+    component: EnvVarsModal,
+    props: {
+      requiredEnvVars: options?.requiredEnvVars || [],
+      enableSharedModalDimensions: options?.enableSharedModalDimensions !== undefined ? options.enableSharedModalDimensions : true
+    }
+  };
+}

package/lib/typescript/env/EnvVariables.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Main entry point for the Environment Variables feature
+ * This component orchestrates all env-related functionality
+ */
+export type { RequiredEnvVar, EnvVarInfo, EnvVarStats, EnvVarType, } from "./types";
+export { envVar, createEnvVarConfig } from "./utils/helpers";
+export { EnvVarsModal } from "./components/EnvVarsModal";
+//# sourceMappingURL=EnvVariables.d.ts.map

package/lib/typescript/env/EnvVariables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvVariables.d.ts","sourceRoot":"","sources":["../../../src/env/EnvVariables.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,YAAY,EACV,cAAc,EACd,UAAU,EACV,WAAW,EACX,UAAU,GACX,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC"}

package/lib/typescript/env/components/EnvStatsOverview.d.ts

@@ -0,0 +1,20 @@
+export type EnvFilterType = "all" | "missing" | "issues";
+interface EnvStatsOverviewProps {
+    stats: {
+        totalCount: number;
+        requiredCount: number;
+        optionalCount: number;
+        presentRequiredCount: number;
+        missingCount: number;
+        wrongValueCount: number;
+        wrongTypeCount: number;
+    };
+    healthPercentage: number;
+    healthStatus: string;
+    healthColor: string;
+    activeFilter?: EnvFilterType;
+    onFilterChange?: (filter: EnvFilterType) => void;
+}
+export declare function EnvStatsOverview({ stats, healthPercentage, healthStatus, healthColor, activeFilter, onFilterChange, }: EnvStatsOverviewProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=EnvStatsOverview.d.ts.map

package/lib/typescript/env/components/EnvStatsOverview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvStatsOverview.d.ts","sourceRoot":"","sources":["../../../../src/env/components/EnvStatsOverview.tsx"],"names":[],"mappings":"AAGA,MAAM,MAAM,aAAa,GAAG,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAC;AAEzD,UAAU,qBAAqB;IAC7B,KAAK,EAAE;QACL,UAAU,EAAE,MAAM,CAAC;QACnB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,YAAY,EAAE,MAAM,CAAC;QACrB,eAAe,EAAE,MAAM,CAAC;QACxB,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;IACF,gBAAgB,EAAE,MAAM,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,aAAa,CAAC;IAC7B,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,IAAI,CAAC;CAClD;AAED,wBAAgB,gBAAgB,CAAC,EAC/B,KAAK,EACL,gBAAgB,EAChB,YAAY,EACZ,WAAW,EACX,YAAoB,EACpB,cAAc,GACf,EAAE,qBAAqB,+BA+GvB"}

package/lib/typescript/env/components/EnvVarRow.d.ts

@@ -0,0 +1,9 @@
+import { EnvVarInfo } from "../types";
+interface EnvVarRowProps {
+    envVar: EnvVarInfo;
+    isExpanded?: boolean;
+    onPress?: (envVar: EnvVarInfo) => void;
+}
+export declare function EnvVarRow({ envVar, isExpanded, onPress }: EnvVarRowProps): import("react").JSX.Element;
+export {};
+//# sourceMappingURL=EnvVarRow.d.ts.map

package/lib/typescript/env/components/EnvVarRow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvVarRow.d.ts","sourceRoot":"","sources":["../../../../src/env/components/EnvVarRow.tsx"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAItC,UAAU,cAAc;IACtB,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,CAAC;CACxC;AAkDD,wBAAgB,SAAS,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,cAAc,+BAgExE"}

package/lib/typescript/env/components/EnvVarSection.d.ts

@@ -0,0 +1,10 @@
+import { EnvVarInfo } from "../types";
+interface EnvVarSectionProps {
+    title: string;
+    count: number;
+    vars: EnvVarInfo[];
+    emptyMessage: string;
+}
+export declare function EnvVarSection({ title, count, vars, emptyMessage, }: EnvVarSectionProps): import("react").JSX.Element | null;
+export {};
+//# sourceMappingURL=EnvVarSection.d.ts.map

package/lib/typescript/env/components/EnvVarSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvVarSection.d.ts","sourceRoot":"","sources":["../../../../src/env/components/EnvVarSection.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAItC,UAAU,kBAAkB;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,aAAa,CAAC,EAC5B,KAAK,EACL,KAAK,EACL,IAAI,EACJ,YAAY,GACb,EAAE,kBAAkB,sCA2CpB"}

package/lib/typescript/env/components/EnvVarsModal.d.ts

@@ -0,0 +1,26 @@
+import { RequiredEnvVar } from "../types";
+interface EnvVarsModalProps {
+    /** Controls the visibility of the modal. */
+    visible: boolean;
+    /** Callback executed when the modal is dismissed. */
+    onClose: () => void;
+    /** List of required environment variables to validate against the runtime values. */
+    requiredEnvVars: RequiredEnvVar[];
+    /** Optional handler fired when navigating back to the parent surface. */
+    onBack?: () => void;
+    /** Optional handler fired when the modal is minimized. */
+    onMinimize?: (modalState: any) => void;
+    /**
+     * When true, reuse the shared modal sizing keys so multiple dev tools can
+     * persist their window dimensions in a single location.
+     */
+    enableSharedModalDimensions?: boolean;
+}
+/**
+ * Full-screen modal for inspecting required environment variables. Handles automatic
+ * discovery, validation, filtering, and rich search so teams can quickly spot missing
+ * or misconfigured values during development sessions.
+ */
+export declare function EnvVarsModal({ visible, onClose, requiredEnvVars, onBack, onMinimize, enableSharedModalDimensions, }: EnvVarsModalProps): import("react").JSX.Element | null;
+export {};
+//# sourceMappingURL=EnvVarsModal.d.ts.map

package/lib/typescript/env/components/EnvVarsModal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EnvVarsModal.d.ts","sourceRoot":"","sources":["../../../../src/env/components/EnvVarsModal.tsx"],"names":[],"mappings":"AAWA,OAAO,EAAE,cAAc,EAAc,MAAM,UAAU,CAAC;AAUtD,UAAU,iBAAiB;IACzB,4CAA4C;IAC5C,OAAO,EAAE,OAAO,CAAC;IACjB,qDAAqD;IACrD,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,qFAAqF;IACrF,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,IAAI,CAAC;IACpB,0DAA0D;IAC1D,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,GAAG,KAAK,IAAI,CAAC;IACvC;;;OAGG;IACH,2BAA2B,CAAC,EAAE,OAAO,CAAC;CACvC;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,EAC3B,OAAO,EACP,OAAO,EACP,eAAe,EACf,MAAM,EACN,UAAU,EACV,2BAAmC,GACpC,EAAE,iBAAiB,sCAgPnB"}

package/lib/typescript/env/hooks/useDynamicEnv.d.ts

@@ -0,0 +1,39 @@
+interface UseDynamicEnvOptions {
+    /**
+     * Optional filter function to determine which env vars to include
+     * Note: Only EXPO_PUBLIC_ prefixed variables are available in process.env
+     */
+    envFilter?: (key: string, value: string | undefined) => boolean;
+}
+interface EnvResult {
+    key: string;
+    data: unknown;
+}
+/**
+ * Hook that returns all available environment variables with parsed values
+ * Includes all available environment variables by default (only EXPO_PUBLIC_ prefixed vars are loaded by Expo)
+ *
+ * @example
+ * // Get all available environment variables (only EXPO_PUBLIC_ prefixed)
+ * const envVars = useDynamicEnv();
+ * // Returns: [
+ * //   { key: 'EXPO_PUBLIC_API_URL', data: 'https://api.example.com' },
+ * //   { key: 'EXPO_PUBLIC_APP_NAME', data: 'MyApp' },
+ * //   ...
+ * // ]
+ *
+ * @example
+ * // Filter to specific variables
+ * const envVars = useDynamicEnv({
+ *   envFilter: (key) => key.includes('API') || key.includes('URL')
+ * });
+ *
+ * @example
+ * // Filter by value content
+ * const envVars = useDynamicEnv({
+ *   envFilter: (key, value) => value !== undefined && value.length > 0
+ * });
+ */
+export declare function useDynamicEnv({ envFilter, }?: UseDynamicEnvOptions): EnvResult[];
+export {};
+//# sourceMappingURL=useDynamicEnv.d.ts.map

package/lib/typescript/env/hooks/useDynamicEnv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDynamicEnv.d.ts","sourceRoot":"","sources":["../../../../src/env/hooks/useDynamicEnv.ts"],"names":[],"mappings":"AAEA,UAAU,oBAAoB;IAC5B;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,KAAK,OAAO,CAAC;CACjE;AAED,UAAU,SAAS;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,aAAa,CAAC,EAC5B,SAAsB,GACvB,GAAE,oBAAyB,GAAG,SAAS,EAAE,CAyDzC"}

package/lib/typescript/env/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./EnvVariables";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/env/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/env/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC"}

package/lib/typescript/env/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./types";
+export * from "./userTypes";
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/env/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/env/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC"}

package/lib/typescript/env/types/types.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Supported environment variable types that can be automatically detected
+ */
+export type EnvVarType = "string" | "number" | "boolean" | "array" | "object" | "url";
+/**
+ * Configuration for a required environment variable
+ *
+ * @example
+ * // Simple string check (just check if it exists)
+ * "EXPO_PUBLIC_API_URL"
+ *
+ * @example
+ * // Check for specific value
+ * { key: "EXPO_PUBLIC_ENVIRONMENT", expectedValue: "development" }
+ *
+ * @example
+ * // Check for specific type
+ * { key: "EXPO_PUBLIC_DEBUG_MODE", expectedType: "boolean" }
+ *
+ * @example
+ * // With description for documentation
+ * {
+ *   key: "EXPO_PUBLIC_API_URL",
+ *   expectedType: "string",
+ *   description: "Backend API endpoint URL"
+ * }
+ */
+export type RequiredEnvVar = string | {
+    /** The environment variable key/name */
+    key: string;
+    /** Expected exact value for this variable */
+    expectedValue: string;
+    /** Optional description for documentation */
+    description?: string;
+} | {
+    /** The environment variable key/name */
+    key: string;
+    /** Expected type for this variable */
+    expectedType: EnvVarType;
+    /** Optional description for documentation */
+    description?: string;
+};
+/**
+ * Internal representation of environment variable information
+ */
+export interface EnvVarInfo {
+    key: string;
+    value: unknown;
+    expectedValue?: string;
+    expectedType?: EnvVarType;
+    description?: string;
+    status: "required_present" | "required_missing" | "required_wrong_value" | "required_wrong_type" | "optional_present";
+    category: "required" | "optional";
+}
+/**
+ * Statistics about environment variables
+ */
+export interface EnvVarStats {
+    totalCount: number;
+    requiredCount: number;
+    missingCount: number;
+    wrongValueCount: number;
+    wrongTypeCount: number;
+    presentRequiredCount: number;
+    optionalCount: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/env/types/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/env/types/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,UAAU,GAClB,QAAQ,GACR,QAAQ,GACR,SAAS,GACT,OAAO,GACP,QAAQ,GACR,KAAK,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,cAAc,GACtB,MAAM,GACN;IACE,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,6CAA6C;IAC7C,aAAa,EAAE,MAAM,CAAC;IACtB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,GACD;IACE,wCAAwC;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,sCAAsC;IACtC,YAAY,EAAE,UAAU,CAAC;IACzB,6CAA6C;IAC7C,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEN;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,OAAO,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,UAAU,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,EACF,kBAAkB,GAClB,kBAAkB,GAClB,sBAAsB,GACtB,qBAAqB,GACrB,kBAAkB,CAAC;IACvB,QAAQ,EAAE,UAAU,GAAG,UAAU,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,cAAc,EAAE,MAAM,CAAC;IACvB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;CACvB"}

package/lib/typescript/env/types/userTypes.d.ts

@@ -0,0 +1,3 @@
+export type UserRole = 'admin' | 'user' | 'guest' | 'developer' | 'moderator';
+export type Environment = 'local' | 'development' | 'staging' | 'production' | 'test';
+//# sourceMappingURL=userTypes.d.ts.map

package/lib/typescript/env/types/userTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"userTypes.d.ts","sourceRoot":"","sources":["../../../../src/env/types/userTypes.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,WAAW,GAAG,WAAW,CAAC;AAE9E,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,aAAa,GAAG,SAAS,GAAG,YAAY,GAAG,MAAM,CAAC"}

package/lib/typescript/env/utils/envTypeDetector.d.ts

@@ -0,0 +1,10 @@
+import { EnvVarType } from "../types";
+/**
+ * Detects the type of an environment variable value
+ * First checks if useDynamicEnv already parsed it to the correct type,
+ * then analyzes string content to detect what type it represents
+ *
+ * @returns One of: "string", "number", "boolean", "array", "object"
+ */
+export declare function getEnvVarType(value: unknown): EnvVarType | "unknown";
+//# sourceMappingURL=envTypeDetector.d.ts.map

package/lib/typescript/env/utils/envTypeDetector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envTypeDetector.d.ts","sourceRoot":"","sources":["../../../../src/env/utils/envTypeDetector.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,UAAU,GAAG,SAAS,CA4DpE"}