@hkdigital/lib-core 0.4.18 → 0.4.20

package/dist/util/sveltekit/env/parsers.js

@@ -0,0 +1,257 @@
+/**
+ * @fileoverview Environment variable parsing utilities
+ *
+ * Provides functions for parsing and transforming environment variables
+ * with type conversion, key transformation, and prefix handling.
+ *
+ * @example
+ * import { parseEnv, parseEnvByPrefix } from './parsers.js';
+ *
+ * const parsed = parseEnv(envObject, {
+ *   camelCase: true,
+ *   parseValues: true
+ * });
+ *
+ * const dbConfig = parseEnvByPrefix(envObject, 'DATABASE');
+ */
+
+/**
+ * Parse environment object with type conversion and key transformation
+ *
+ * @param {Object<string, string>} env - Raw environment variables
+ * @param {Object} [options={}] - Parsing options
+ * @param {boolean} [options.camelCase=true]
+ *   Convert env var names to camelCase object keys
+ * @param {boolean} [options.parseValues=true]
+ *   Parse string values to numbers/booleans when possible
+ * @param {string} [options.prefix] - Only include vars with this prefix
+ * @param {boolean} [options.removePrefix=true]
+ *   Remove prefix from resulting keys
+ *
+ * @returns {Object} Parsed environment object
+ */
+export function parseEnv(env, options = {}) {
+  const {
+    camelCase = true,
+    parseValues = true,
+    prefix,
+    removePrefix = true
+  } = options;
+
+  const result = {};
+
+  for (const [key, value] of Object.entries(env || {})) {
+    // Skip if prefix specified and key doesn't match
+    if (prefix && !key.startsWith(prefix)) {
+      continue;
+    }
+
+    // Determine final key name
+    let finalKey = key;
+    
+    if (prefix && removePrefix) {
+      finalKey = key.slice(prefix.length);
+      // Remove leading underscore if present
+      if (finalKey.startsWith('_')) {
+        finalKey = finalKey.slice(1);
+      }
+    }
+    
+    if (camelCase) {
+      finalKey = toCamelCase(finalKey);
+    } else {
+      finalKey = finalKey.toLowerCase();
+    }
+
+    // Parse value if requested
+    result[finalKey] = parseValues ? parseValue(value) : value;
+  }
+
+  return result;
+}
+
+/**
+ * Parse environment variables by prefix
+ *
+ * @param {Object<string, string>} env - Raw environment variables
+ * @param {string} prefix - Environment variable prefix (e.g., 'DATABASE')
+ * @param {Object} [options={}] - Parsing options
+ *
+ * @returns {Object} Parsed configuration object
+ */
+export function parseEnvByPrefix(env, prefix, options = {}) {
+  const prefixWithUnderscore = prefix.endsWith('_') ? prefix : `${prefix}_`;
+  
+  return parseEnv(env, {
+    ...options,
+    prefix: prefixWithUnderscore,
+    removePrefix: true
+  });
+}
+
+/**
+ * Convert SCREAMING_SNAKE_CASE to camelCase
+ *
+ * @param {string} str - String to convert
+ *
+ * @returns {string} camelCase string
+ */
+export function toCamelCase(str) {
+  return str
+    .toLowerCase()
+    .split('_')
+    .map((word, index) => 
+      index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)
+    )
+    .join('');
+}
+
+/**
+ * Parse string value to appropriate type
+ *
+ * @param {string} value - String value to parse
+ *
+ * @returns {*} Parsed value (string, number, boolean, or null)
+ */
+export function parseValue(value) {
+  if (value === 'true') return true;
+  if (value === 'false') return false;
+  if (value === 'null') return null;
+  if (value === 'undefined') return undefined;
+
+  // Try parsing as number
+  const num = Number(value);
+  if (!Number.isNaN(num) && value.trim() !== '') {
+    return num;
+  }
+
+  return value;
+}
+
+/**
+ * Auto-detect and group environment variables by prefixes
+ *
+ * Automatically detects prefixes from environment variable names and groups
+ * them into configuration objects. All variables with underscores are 
+ * grouped by their prefix (the part before the first underscore).
+ *
+ * @param {Object<string, string>} env - Raw environment variables
+ * @param {Object} [options={}] - Parsing options
+ * @param {boolean} [options.camelCase=true]
+ *   Convert env var names to camelCase object keys
+ * @param {boolean} [options.parseValues=true]
+ *   Parse string values to numbers/booleans when possible
+ *
+ * @returns {Object<string, Object>} Grouped environment variables
+ *
+ * @example
+ * // Input env vars:
+ * // DATABASE_HOST=localhost, DATABASE_PORT=5432
+ * // REDIS_HOST=cache, API_KEY=secret, SINGLE=value
+ *
+ * const grouped = autoGroupEnvByPrefix(env);
+ * // Returns: 
+ * // {
+ * //   database: { host: 'localhost', port: 5432 },
+ * //   redis: { host: 'cache' },
+ * //   api: { key: 'secret' },
+ * //   single: 'value'  // No underscore, stays top-level
+ * // }
+ */
+export function autoGroupEnvByPrefix(env, options = {}) {
+  const {
+    camelCase = true,
+    parseValues = true
+  } = options;
+
+  // Collect all prefixes from variables with underscores
+  const allPrefixes = new Set();
+
+  for (const key of Object.keys(env)) {
+    const parts = key.split('_');
+    if (parts.length > 1) {
+      const prefix = parts[0];
+      allPrefixes.add(prefix);
+    }
+  }
+
+  const result = {};
+  const usedKeys = new Set();
+
+  // Group by all detected prefixes
+  for (const prefix of allPrefixes) {
+    const groupKey = camelCase ? toCamelCase(prefix) : prefix.toLowerCase();
+    const groupConfig = parseEnvByPrefix(env, prefix, { camelCase, parseValues });
+    
+    if (Object.keys(groupConfig).length > 0) {
+      result[groupKey] = groupConfig;
+      
+      // Mark keys as used
+      for (const key of Object.keys(env)) {
+        if (key.startsWith(`${prefix}_`)) {
+          usedKeys.add(key);
+        }
+      }
+    }
+  }
+
+  // Add remaining variables (no underscore) as top-level properties
+  for (const [key, value] of Object.entries(env)) {
+    if (!usedKeys.has(key)) {
+      const finalKey = camelCase ? toCamelCase(key) : key.toLowerCase();
+      result[finalKey] = parseValues ? parseValue(value) : value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Group environment variables by specific prefixes
+ *
+ * @param {Object<string, string>} env - Raw environment variables
+ * @param {string[]} prefixes - Array of prefixes to group by
+ * @param {Object} [options={}] - Parsing options
+ *
+ * @returns {Object<string, Object>} Grouped environment variables
+ *
+ * @example
+ * const grouped = groupEnvByPrefixes(env, ['DATABASE', 'REDIS', 'JWT']);
+ * // Returns: { database: {...}, redis: {...}, jwt: {...} }
+ */
+export function groupEnvByPrefixes(env, prefixes, options = {}) {
+  const result = {};
+  
+  for (const prefix of prefixes) {
+    const groupKey = options.camelCase !== false ? 
+                     toCamelCase(prefix) : 
+                     prefix.toLowerCase();
+    
+    result[groupKey] = parseEnvByPrefix(env, prefix, options);
+  }
+  
+  return result;
+}
+
+/**
+ * Filter environment variables by pattern
+ *
+ * @param {Object<string, string>} env - Raw environment variables
+ * @param {RegExp|string} pattern - Pattern to match against keys
+ * @param {Object} [options={}] - Parsing options
+ *
+ * @returns {Object} Filtered and parsed environment variables
+ */
+export function filterEnvByPattern(env, pattern, options = {}) {
+  const regex = typeof pattern === 'string' ? new RegExp(pattern) : pattern;
+  /** @type {Object<string, string>} */
+  const filtered = {};
+  
+  for (const [key, value] of Object.entries(env || {})) {
+    if (regex.test(key)) {
+      filtered[key] = value;
+    }
+  }
+  
+  return parseEnv(filtered, options);
+}

package/dist/util/sveltekit/env/private.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Get all private environment variables with automatic prefix grouping
+ *
+ * Automatically detects common prefixes in private environment variables
+ * and groups them into configuration objects. This is perfect for organizing
+ * database connections, API keys, and other sensitive configuration.
+ *
+ * @param {Object} [options={}] - Parsing options
+ * @param {boolean} [options.camelCase=true]
+ *   Convert env var names to camelCase object keys
+ * @param {boolean} [options.parseValues=true]
+ *   Parse string values to numbers/booleans when possible
+ * @param {boolean} [options.autoGroup=true]
+ *   Enable automatic prefix grouping
+ *
+ * @returns {Object} Grouped and parsed private environment variables
+ *
+ * @example
+ * // Environment variables:
+ * // DATABASE_HOST=localhost
+ * // DATABASE_PORT=5432
+ * // DATABASE_NAME=myapp
+ * // REDIS_URL=redis://localhost:6379
+ * // JWT_SECRET=mysecret
+ * // JWT_EXPIRES_IN=24h
+ *
+ * const config = getPrivateEnv();
+ * // Returns:
+ * // {
+ * //   database: { host: 'localhost', port: 5432, name: 'myapp' },
+ * //   jwt: { secret: 'mysecret', expiresIn: '24h' },
+ * //   redisUrl: 'redis://localhost:6379'  // Single vars become top-level
+ * // }
+ */
+export function getPrivateEnv(options?: {
+    camelCase?: boolean;
+    parseValues?: boolean;
+    autoGroup?: boolean;
+}): any;
+/**
+ * Get private environment variables by prefix
+ *
+ * @param {string} prefix - Environment variable prefix (e.g., 'DATABASE')
+ * @param {Object} [options={}] - Parsing options
+ *
+ * @returns {Object} Parsed configuration object
+ */
+export function getPrivateEnvByPrefix(prefix: string, options?: any): any;
+/**
+ * Get raw private environment variables (no parsing)
+ *
+ * @returns {Object<string, string>} Raw private environment variables
+ */
+export function getRawPrivateEnv(): {
+    [x: string]: string;
+};

package/dist/util/sveltekit/env/private.js

@@ -0,0 +1,87 @@
+/**
+ * @fileoverview Private environment variables access (server-side only)
+ *
+ * Provides access to SvelteKit private environment variables with parsing.
+ * IMPORTANT: This module can only be imported on the server side.
+ * Attempting to import this on the client will cause a build error.
+ *
+ * @example
+ * import { getPrivateEnv } from './private.js';
+ *
+ * const privateVars = getPrivateEnv();
+ * const dbConfig = getPrivateEnv({ prefix: 'DATABASE' });
+ */
+
+import { env } from '$env/dynamic/private';
+import { autoGroupEnvByPrefix, parseEnv } from './parsers.js';
+
+/**
+ * Get all private environment variables with automatic prefix grouping
+ *
+ * Automatically detects common prefixes in private environment variables
+ * and groups them into configuration objects. This is perfect for organizing
+ * database connections, API keys, and other sensitive configuration.
+ *
+ * @param {Object} [options={}] - Parsing options
+ * @param {boolean} [options.camelCase=true]
+ *   Convert env var names to camelCase object keys
+ * @param {boolean} [options.parseValues=true]
+ *   Parse string values to numbers/booleans when possible
+ * @param {boolean} [options.autoGroup=true]
+ *   Enable automatic prefix grouping
+ *
+ * @returns {Object} Grouped and parsed private environment variables
+ *
+ * @example
+ * // Environment variables:
+ * // DATABASE_HOST=localhost
+ * // DATABASE_PORT=5432
+ * // DATABASE_NAME=myapp
+ * // REDIS_URL=redis://localhost:6379
+ * // JWT_SECRET=mysecret
+ * // JWT_EXPIRES_IN=24h
+ *
+ * const config = getPrivateEnv();
+ * // Returns:
+ * // {
+ * //   database: { host: 'localhost', port: 5432, name: 'myapp' },
+ * //   jwt: { secret: 'mysecret', expiresIn: '24h' },
+ * //   redisUrl: 'redis://localhost:6379'  // Single vars become top-level
+ * // }
+ */
+export function getPrivateEnv(options = {}) {
+  const { autoGroup = true, ...parseOptions } = options;
+  
+  if (autoGroup) {
+    return autoGroupEnvByPrefix(env, parseOptions);
+  }
+  
+  return parseEnv(env, parseOptions);
+}
+
+/**
+ * Get private environment variables by prefix
+ *
+ * @param {string} prefix - Environment variable prefix (e.g., 'DATABASE')
+ * @param {Object} [options={}] - Parsing options
+ *
+ * @returns {Object} Parsed configuration object
+ */
+export function getPrivateEnvByPrefix(prefix, options = {}) {
+  const prefixWithUnderscore = prefix.endsWith('_') ? prefix : `${prefix}_`;
+  
+  return parseEnv(env, {
+    ...options,
+    prefix: prefixWithUnderscore,
+    removePrefix: true
+  });
+}
+
+/**
+ * Get raw private environment variables (no parsing)
+ *
+ * @returns {Object<string, string>} Raw private environment variables
+ */
+export function getRawPrivateEnv() {
+  return { ...env };
+}

package/dist/util/sveltekit/env/public.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Get all public environment variables with automatic prefix grouping
+ *
+ * Automatically detects common prefixes in public environment variables
+ * and groups them into configuration objects. This makes it easy to
+ * organize related configuration values.
+ *
+ * @param {Object} [options={}] - Parsing options
+ * @param {boolean} [options.camelCase=true]
+ *   Convert env var names to camelCase object keys
+ * @param {boolean} [options.parseValues=true]
+ *   Parse string values to numbers/booleans when possible
+ * @param {boolean} [options.autoGroup=true]
+ *   Enable automatic prefix grouping
+ *
+ * @returns {Object} Grouped and parsed public environment variables
+ *
+ * @example
+ * // Environment variables:
+ * // PUBLIC_API_URL=https://api.example.com
+ * // PUBLIC_API_TIMEOUT=5000
+ * // PUBLIC_FEATURE_FLAGS=true
+ *
+ * const config = getPublicEnv();
+ * // Returns:
+ * // {
+ * //   publicApi: { url: 'https://api.example.com', timeout: 5000 },
+ * //   publicFeatureFlags: true
+ * // }
+ */
+export function getPublicEnv(options?: {
+    camelCase?: boolean;
+    parseValues?: boolean;
+    autoGroup?: boolean;
+}): any;
+/**
+ * Get public environment variables by prefix
+ *
+ * @param {string} prefix - Environment variable prefix (e.g., 'PUBLIC_API')
+ * @param {Object} [options={}] - Parsing options
+ *
+ * @returns {Object} Parsed configuration object
+ */
+export function getPublicEnvByPrefix(prefix: string, options?: any): any;
+/**
+ * Get raw public environment variables (no parsing)
+ *
+ * @returns {Object<string, string>} Raw public environment variables
+ */
+export function getRawPublicEnv(): {
+    [x: string]: string;
+};

package/dist/util/sveltekit/env/public.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview Public environment variables access
+ *
+ * Provides access to SvelteKit public environment variables with parsing.
+ * Safe to use on both client and server side.
+ *
+ * @example
+ * import { getPublicEnv } from './public.js';
+ *
+ * const publicVars = getPublicEnv();
+ * const apiConfig = getPublicEnv({ prefix: 'PUBLIC_API' });
+ */
+
+import { env } from '$env/dynamic/public';
+import { autoGroupEnvByPrefix, parseEnv } from './parsers.js';
+
+/**
+ * Get all public environment variables with automatic prefix grouping
+ *
+ * Automatically detects common prefixes in public environment variables
+ * and groups them into configuration objects. This makes it easy to
+ * organize related configuration values.
+ *
+ * @param {Object} [options={}] - Parsing options
+ * @param {boolean} [options.camelCase=true]
+ *   Convert env var names to camelCase object keys
+ * @param {boolean} [options.parseValues=true]
+ *   Parse string values to numbers/booleans when possible
+ * @param {boolean} [options.autoGroup=true]
+ *   Enable automatic prefix grouping
+ *
+ * @returns {Object} Grouped and parsed public environment variables
+ *
+ * @example
+ * // Environment variables:
+ * // PUBLIC_API_URL=https://api.example.com
+ * // PUBLIC_API_TIMEOUT=5000
+ * // PUBLIC_FEATURE_FLAGS=true
+ *
+ * const config = getPublicEnv();
+ * // Returns:
+ * // {
+ * //   publicApi: { url: 'https://api.example.com', timeout: 5000 },
+ * //   publicFeatureFlags: true
+ * // }
+ */
+export function getPublicEnv(options = {}) {
+  const { autoGroup = true, ...parseOptions } = options;
+  
+  if (autoGroup) {
+    return autoGroupEnvByPrefix(env, parseOptions);
+  }
+  
+  return parseEnv(env, parseOptions);
+}
+
+/**
+ * Get public environment variables by prefix
+ *
+ * @param {string} prefix - Environment variable prefix (e.g., 'PUBLIC_API')
+ * @param {Object} [options={}] - Parsing options
+ *
+ * @returns {Object} Parsed configuration object
+ */
+export function getPublicEnvByPrefix(prefix, options = {}) {
+  const prefixWithUnderscore = prefix.endsWith('_') ? prefix : `${prefix}_`;
+  
+  return parseEnv(env, {
+    ...options,
+    prefix: prefixWithUnderscore,
+    removePrefix: true
+  });
+}
+
+/**
+ * Get raw public environment variables (no parsing)
+ *
+ * @returns {Object<string, string>} Raw public environment variables
+ */
+export function getRawPublicEnv() {
+  return { ...env };
+}

package/dist/util/sveltekit/env-all.d.ts

@@ -0,0 +1 @@
+export { getAllEnv, getAllEnvByPrefix, getRawAllEnv } from "./env/all.js";

package/dist/util/sveltekit/env-all.js

@@ -0,0 +1,19 @@
+/**
+ * @fileoverview Combined environment variables export (server-side only)
+ *
+ * Re-exports combined environment utilities for convenient importing.
+ * IMPORTANT: This module can only be imported on the server side since it
+ * imports private environment variables.
+ *
+ * @example
+ * import { getAllEnv, getAllEnvByPrefix } from './env-all.js';
+ *
+ * const allVars = getAllEnv();
+ * const dbConfig = getAllEnvByPrefix('DATABASE');
+ */
+
+export {
+  getAllEnv,
+  getAllEnvByPrefix,
+  getRawAllEnv
+} from './env/all.js';

package/dist/util/sveltekit/env-private.d.ts

@@ -0,0 +1 @@
+export { getPrivateEnv, getPrivateEnvByPrefix, getRawPrivateEnv } from "./env/private.js";

package/dist/util/sveltekit/env-private.js

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Private environment variables export (server-side only)
+ *
+ * Re-exports private environment utilities for convenient importing.
+ * IMPORTANT: This module can only be imported on the server side.
+ *
+ * @example
+ * import { getPrivateEnv, getPrivateEnvByPrefix } from './env-private.js';
+ *
+ * const privateVars = getPrivateEnv();
+ * const dbConfig = getPrivateEnvByPrefix('DATABASE');
+ */
+
+export {
+  getPrivateEnv,
+  getPrivateEnvByPrefix,
+  getRawPrivateEnv
+} from './env/private.js';

package/dist/util/sveltekit/env-public.d.ts

@@ -0,0 +1 @@
+export { getPublicEnv, getPublicEnvByPrefix, getRawPublicEnv } from "./env/public.js";

package/dist/util/sveltekit/env-public.js

@@ -0,0 +1,18 @@
+/**
+ * @fileoverview Public environment variables export
+ *
+ * Re-exports public environment utilities for convenient importing.
+ * Safe to use on both client and server side.
+ *
+ * @example
+ * import { getPublicEnv, getPublicEnvByPrefix } from './env-public.js';
+ *
+ * const publicVars = getPublicEnv();
+ * const apiConfig = getPublicEnvByPrefix('PUBLIC_API');
+ */
+
+export {
+  getPublicEnv,
+  getPublicEnvByPrefix,
+  getRawPublicEnv
+} from './env/public.js';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@hkdigital/lib-core",
-	"version": "0.4.18",
+	"version": "0.4.20",
 	"author": {
 		"name": "HKdigital",
 		"url": "https://hkdigital.nl"

package/dist/util/index.js__

@@ -1,20 +0,0 @@
-export { rethrow } from './exceptions/index.js';
-
-import * as originalValibot from 'valibot';
-
-// Create a modified version of valibot with wrapped parse methods
-
-/** @type {typeof originalValibot & { _parse: any }} */
-const v = { ...originalValibot, _parse: originalValibot.parse };
-
-// Replace with wrappers for better stack trace detection
-v.parse = function valibotParseWrapper(schema, input, config) {
-  return this._parse(schema, input, config);
-};
-
-export { v };
-export * as expect from './expect/index.js';
-export * as is from './is/index.js';
-export * as object from './object/index.js';
-
-export * as singleton from './singleton/index.js';