@inizioevoke/veeva-astroclm-core 1.0.0

package/src/apps/veeva-config-manager/create.ts

@@ -0,0 +1,153 @@
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { join, resolve as resolvePath } from 'node:path';
+
+import { text, select, multiselect, note, spinner, outro } from '@clack/prompts';
+import { sleep, handleCanceled, cleanInput, generateRandomId, titleCase } from '../utils.js';
+
+import type { Actions, iOSResolution, CrmTarget } from '../../types';
+
+const __dirname = import.meta.dirname;
+
+
+
+export default async function(rootDir: string) {
+
+  const product = handleCanceled(await text({
+    message: 'Enter the product name',
+    validate: (value: string | undefined) => {
+      if (!value?.trim()) return 'Product name is required';
+      return undefined;
+    }
+  }));
+
+  const presentation = handleCanceled(await text({
+    message: 'Enter a presentation name',
+    validate: (value: string | undefined) => {
+      if (!value?.trim()) return 'Presentation name is required';
+      return undefined;
+    }
+  }));
+
+  const presentationId = handleCanceled(await text({
+    message: 'Enter a presentation ID',
+    initialValue: presentation.toString().toLowerCase().replace(/[^0-9a-z_]/g, '_'),
+    validate: (value: string | undefined) => {
+      if (!value?.trim()) return 'Presentation ID is required';
+      return undefined;
+    }
+  }));
+
+  const dimensions = handleCanceled(await select({
+    message: 'Select the IVA dimensions',
+    options: [{
+      label: '1024 x 768',
+      value: '1024_768'
+    }, {
+      label: '1366 x 1024',
+      value: '1366_1024'
+    }, {
+      label: '1376 x 1032',
+      value: '1376_1032'
+    }],
+    initialValue: '1366_1024'
+  }));
+  const [ width, height ] = dimensions.split('_');
+
+  const iosResolution = handleCanceled<iOSResolution>(await select({
+    message: 'Select the iOS resolution',
+    options: [{
+      label: 'Default For Device',
+      value: 'Default For Device'
+    }, {
+      label: 'Scale To Fit',
+      value: 'Scale To Fit'
+    }, {
+      label: 'Scale To 1024x768',
+      value: 'Scale To 1024x768'
+    }],
+    initialValue: 'Default For Device'
+  }));
+
+  const disableActions = handleCanceled<Actions[]>(await multiselect({
+    message: 'Select any actions you would like to disable globally',
+    required: false,
+    options: [{
+      label: 'History Buttons',
+      value: 'History Buttons'
+    }, {
+      label: 'Navigation Bar',
+      value: 'Navigation Bar'
+    }, {
+      label: 'Pinch to Exit',
+      value: 'Pinch to Exit'
+    }, {
+      label: 'Reactions',
+      value: 'Reactions'
+    }, {
+      label: 'Rotation Lock',
+      value: 'Rotation Lock'
+    }, {
+      label: 'Swipe',
+      value: 'Swipe'
+    }, {
+      label: 'Zoom',
+      value: 'Zoom'
+    }]
+  }));
+
+  const crmTarget = handleCanceled<CrmTarget>(await select({
+    message: 'Select the Veeva platform version',
+    options: [{
+      label: 'Salesforce',
+      value: 'Salesforce'
+    }, {
+      label: 'Vault',
+      value: 'Vault'
+    }],
+    initialValue: 'Salesforce'
+  }));
+
+  const spin = spinner();
+  spin.start('Generating config file...');
+  await sleep(); // make it seem like we're doing something
+
+  const slides = [];
+  const slideIds = new Set<string>();
+  const pages = await readdir(resolvePath(rootDir, 'src/pages'));
+  for (const page of pages) {
+    if (page.endsWith('.astro')) {
+      const p = page.slice(0, -6);
+      let slideId = generateRandomId();
+      while (slideIds.has(slideId)) {
+        slideId = generateRandomId();
+      }
+      slideIds.add(slideId);
+      slides.push(`{
+        path: '${p}',
+        title: '${titleCase(p)}',
+        externalId: formatExtId('${slideId}')
+      }`)
+    }
+  }
+
+  let template = await readFile(join(__dirname, 'templates/config.ts.txt'), 'utf8');
+  template = template
+    .replace(/##EXTERNAL_ID##/g, `${cleanInput(product).substring(0, 3).toUpperCase()}_${generateRandomId()}`)
+    .replace(/##PRODUCT##/g, cleanInput(product))
+    .replace(/##PRESENTATION_NAME##/g, cleanInput(presentation))
+    .replace(/##PRESENTATION_ID##/g, cleanInput(presentationId))
+    .replace(/##DIMENSIONS_WIDTH##/g, width)
+    .replace(/##DIMENSIONS_HEIGHT##/g, height)
+    .replace(/##IOS_RESOLUTION##/g, iosResolution)
+    .replace(/##DISABLE_ACTIONS##/g, `[${disableActions.map((a) => { return `'${a}'`}).join(', ')}]`)
+    .replace(/##CRM_TARGET##/g, crmTarget)
+    .replace(/##SLIDES##/g, `[${slides.join(', ')}]`)
+    .replace(/##SLIDE_IDS##/g, [...slideIds].join());
+  await writeFile(resolvePath(rootDir, 'veeva-config.ts'), template);
+
+  await sleep(); // make it seem like we're doing something
+  spin.stop('Config file generated!');
+
+  outro('Happy coding!');
+}
+

package/src/apps/veeva-config-manager/index.ts

@@ -0,0 +1,20 @@
+import { existsSync } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
+import { intro } from '@clack/prompts';
+
+
+export default async function({ root }: { root?: string } = {}) {
+  const rootDir = root ?? process.cwd();
+  const exists = existsSync(resolvePath(rootDir, 'veeva-config.ts'));
+
+  console.log('');
+  intro('Veeva Configuration Manager');
+
+  if (!exists) {
+    const create = await import('./create.js');
+    await create.default(rootDir);
+  } /* else {
+    const update = await import('../../../archive/update');
+    await update.default();
+  } */
+}

package/src/apps/veeva-config-manager/templates/config.ts.txt

@@ -0,0 +1,60 @@
+import type { IVeevaClmBinderFields, IVeevaConfig, VeevaEnv } from "@inizioevoke/veeva-astroclm-core/types";
+import { formatExtId as __formatExtId } from '@inizioevoke/veeva-astroclm-core/lib';
+
+interface IVeevaConfigArgs {
+  veevaEnv?: VeevaEnv;
+  isTraining?: boolean;
+}
+export default function ({ veevaEnv = 'client', isTraining = false }: IVeevaConfigArgs = {}): IVeevaConfig {
+  const isEvokeBuild = veevaEnv === 'evoke';
+  const EXT_ID = `##EXTERNAL_ID##${isTraining ? '_TRN' : ''}`;
+  const PRESENTATION_NAME = '##PRESENTATION_NAME##';
+
+  const formatExtId = (id: string) => {
+    return __formatExtId(EXT_ID, id);
+  };
+
+  const binderFields: IVeevaClmBinderFields = {
+    // language: isEvokeBuild ? undefined : 'English',
+    // crmOrg: isEvokeBuild ? undefined : { crmId: ['CRM_ORD_ID'] },
+    // crmProduct: isEvokeBuild ? undefined : { id: 'VEEVA_ID_FROM_URL' },
+    // crmDetailGroup: isEvokeBuild ? undefined : { id: 'VEEVA_ID_FROM_URL' },
+    // detailGroup: undefined
+  };
+
+  return {
+    dimensions: { width: ##DIMENSIONS_WIDTH##, height: ##DIMENSIONS_HEIGHT## },
+    thumbnails: {
+      default: {
+        queryStringParams: {
+          screenshots: true
+        }
+      }
+    },
+    presentation: {
+      externalId: EXT_ID,
+      presentationId: `##PRESENTATION_ID##${isTraining ? '_trn' : ''}`,
+      product: '##PRODUCT##',
+      name: `${PRESENTATION_NAME}${isTraining ? ' [Training]' : ''}`,
+      country: 'United States',
+      isTraining,
+      crmTarget: '##CRM_TARGET##',
+      ...binderFields,
+
+      shared: {
+        externalId: formatExtId('SHARED'),
+        ...binderFields
+      },
+
+      slideSettings: {
+        mediaType: 'HTML',
+        disableActions: ##DISABLE_ACTIONS##,
+        iosResolution: '##IOS_RESOLUTION##',
+        ...binderFields
+      },
+      slides: ##SLIDES##
+    }
+  };
+}
+
+// SLIDE_IDS: [##SLIDE_IDS##]

package/src/env/schema.ts

@@ -0,0 +1,43 @@
+import { envField } from 'astro/config';
+import { 
+  BUILD_TARGETS, WEB_ENVS, VEEVA_ENVS, VEEVA_PLATFORMS, LOG_LEVELS, LOG_TIMES, LOG_OUTPUTS,
+  DEFAULT_BUILD_TARGET, DEFAULT_WEB_ENV, DEFAULT_VEEVA_ENV, DEFAULT_VEEVA_PLATFORM, DEFAULT_LOG_LEVEL, DEFAULT_LOG_TIME, DEFAULT_LOG_OUTPUT,
+} from '../lib/const.js';
+
+const envPublicOptional: {
+  context: 'client',
+  access: 'public',
+  optional: true
+} = { 
+  context: 'client', 
+  access: 'public', 
+  optional: true 
+};
+
+type BooleanField = ReturnType<typeof envField.boolean>;
+type EnumField = ReturnType<typeof envField.enum>;
+
+export type EnvFieldName = 'BUILD_TARGET' | 'WEB_ENV' | 'WEB_SCALING' | 'VEEVA_TRAINING' | 'VEEVA_ENV' | 'VEEVA_PLATFORM' | 'LOG_LEVEL' | 'LOG_TIME' | 'LOG_OUTPUT'
+
+export const BUILD_TARGET: EnumField = envField.enum({ ...envPublicOptional, values: BUILD_TARGETS, default: DEFAULT_BUILD_TARGET });
+export const WEB_ENV: EnumField = envField.enum({ ...envPublicOptional, values: WEB_ENVS, default: DEFAULT_WEB_ENV });
+export const WEB_SCALING: BooleanField = envField.boolean({ ...envPublicOptional, default: false });
+export const VEEVA_TRAINING: BooleanField = envField.boolean({ ...envPublicOptional, default: false });
+export const VEEVA_ENV: EnumField = envField.enum({ ...envPublicOptional, values: VEEVA_ENVS, default: DEFAULT_VEEVA_ENV });
+export const VEEVA_PLATFORM: EnumField = envField.enum({ ...envPublicOptional, values: VEEVA_PLATFORMS, default: DEFAULT_VEEVA_PLATFORM });
+export const LOG_LEVEL: EnumField = envField.enum({ ...envPublicOptional, values: LOG_LEVELS, default: DEFAULT_LOG_LEVEL });
+export const LOG_TIME: EnumField = envField.enum({ ...envPublicOptional, values: LOG_TIMES, default: DEFAULT_LOG_TIME });
+export const LOG_OUTPUT: EnumField = envField.enum({ ...envPublicOptional, values: LOG_OUTPUTS, default: DEFAULT_LOG_OUTPUT});
+
+const schema: Record<EnvFieldName, BooleanField | EnumField> = {
+  BUILD_TARGET,
+  WEB_ENV,
+  WEB_SCALING,
+  VEEVA_TRAINING,
+  VEEVA_ENV,
+  VEEVA_PLATFORM,
+  LOG_LEVEL,
+  LOG_TIME,
+  LOG_OUTPUT
+};
+export default schema;

package/src/lib/const.ts

@@ -0,0 +1,17 @@
+import type { BuildTarget, WebEnv, VeevaEnv, VeevaPlatform, LogLevel, LogTime, LogOutput } from '../types';
+
+export const BUILD_TARGETS: BuildTarget[] = ['veeva', 'web'];
+export const WEB_ENVS: WebEnv[] = ['development', 'production'];
+export const VEEVA_ENVS: VeevaEnv[] = ['client', 'evoke'];
+export const VEEVA_PLATFORMS: VeevaPlatform[] = ['salesforce', 'vault'];
+export const LOG_LEVELS: LogLevel[] = ['disabled', 'error', 'debug'];
+export const LOG_TIMES: LogTime[] = ['none', 'date', 'time', 'datetime', 'performance'];
+export const LOG_OUTPUTS: LogOutput[] = ['console', 'screen'];
+
+export const DEFAULT_BUILD_TARGET: BuildTarget = 'web';
+export const DEFAULT_WEB_ENV: WebEnv = 'development';
+export const DEFAULT_VEEVA_ENV: VeevaEnv = 'client';
+export const DEFAULT_VEEVA_PLATFORM: VeevaPlatform = 'salesforce';
+export const DEFAULT_LOG_LEVEL: LogLevel = 'disabled';
+export const DEFAULT_LOG_TIME: LogTime = 'time';
+export const DEFAULT_LOG_OUTPUT: LogOutput = 'console';

package/src/lib/env.ts

@@ -0,0 +1,27 @@
+import type { BuildTarget, VeevaEnv, VeevaPlatform } from '../types';
+import * as Constants from './const.js';
+import parseEnv from "./parse-env.js";
+
+export interface Env {
+  BUILD_TARGET: BuildTarget;
+  VEEVA_ENV: VeevaEnv;
+  VEEVA_PLATFORM: VeevaPlatform;
+  VEEVA_TRAINING: boolean;
+}
+
+export default async function loadEnv(mode?: string): Promise<Env> {
+  const env = await parseEnv({
+    BUILD_TARGET: Constants.BUILD_TARGETS,
+    VEEVA_ENV: Constants.VEEVA_ENVS,
+    VEEVA_PLATFORM: Constants.VEEVA_PLATFORMS,
+    VEEVA_TRAINING: 'boolean'
+  }, { 
+    mode 
+  });
+  env.BUILD_TARGET = env.BUILD_TARGET ?? Constants.DEFAULT_BUILD_TARGET,
+  env.VEEVA_ENV = env.VEEVA_ENV ?? Constants.DEFAULT_VEEVA_ENV,
+  env.VEEVA_PLATFORM = env.VEEVA_PLATFORM ?? Constants.DEFAULT_VEEVA_PLATFORM,
+  env.VEEVA_TRAINING = env.VEEVA_TRAINING ?? false
+
+  return env as Env;
+}

package/src/lib/index.ts

@@ -0,0 +1,5 @@
+export * from './const.js';
+export { default as loadEnv } from './env.js';
+export { default as parseArgv } from './parse-argv.js';
+export { default as parseEnv } from './parse-env.js';
+export * from './utils.js';

package/src/lib/logger.ts

@@ -0,0 +1,84 @@
+const Style = Object.freeze({
+  Background: {
+    Black: '\x1b[40m',
+    Red: '\x1b[41m',
+    Green: '\x1b[42m',
+    Yellow: '\x1b[43m',
+    Blue: '\x1b[44m',
+    Magenta: '\x1b[45m',
+    Cyan: '\x1b[46m',
+    White: '\x1b[47m',
+    Gray: '\x1b[100m',
+    BrightRed: '\x1b[101m',
+    BrightGreen: '\x1b[102m',
+    BrightYellow: '\x1b[103m',
+    BrightBlue: '\x1b[104m',
+    BrightMagenta: '\x1b[105m',
+    BrightCyan: '\x1b[106m',
+    BrightWhite: '\x1b[107m'
+  },
+  Foreground: {
+    Black: '\x1b[30m',
+    Red: '\x1b[31m',
+    Green: '\x1b[32m',
+    Yellow: '\x1b[33m',
+    Blue: '\x1b[34m',
+    Magenta: '\x1b[35m',
+    Cyan: '\x1b[36m',
+    White: '\x1b[37m',
+    Gray: '\x1b[90m',
+    BrightRed: '\x1b[91m',
+    BrightGreen: '\x1b[92m',
+    BrightYellow: '\x1b[93m',
+    BrightBlue: '\x1b[94m',
+    BrightMagenta: '\x1b[95m',
+    BrightCyan: '\x1b[96m',
+    BrightWhite: '\x1b[97m'
+  },
+  Bold: '\x1b[1m',
+  Inverse: '\x1b[7m',
+  Reset: '\x1b[0m',
+  Underscore: '\x1b[4m'
+});
+
+interface LogMessage {
+  task?: string;
+  message: string;
+  data?: any;
+  style?: string;
+}
+function _log({ task, message, data, style }: LogMessage) {
+  const now = new Date();
+  const ts = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`;
+
+  const msg = [`${Style.Foreground.Gray}${ts}${Style.Reset}`];
+  if (task) {
+  msg.push(`${Style.Foreground.Cyan}[${task}]${Style.Reset}`);
+  }
+  msg.push(`${style ?? Style.Reset}${message}${Style.Reset}`);
+  if (data) {
+    msg.push(`${Style.Foreground.Yellow}${data}${Style.Reset}`)
+  }
+  console.log(msg.join(' '));
+}
+
+export function info(message: string) { // task: string, message: string, data?: any) {
+  _log({ message, style: Style.Foreground.White });
+  // _log({ task, message, data, style: Style.Foreground.White });
+}
+
+export function warn(message: string) { // task: string, message: string, data?: any) {
+  _log({ message, style: Style.Foreground.Yellow });
+  // _log({ task, message, data, style: Style.Foreground.Yellow });
+}
+
+export function error(message: string) { // task: string, message: string, data?: any) {
+  _log({ message, style: Style.Foreground.Red });
+  // _log({ task, message, data, style: Style.Foreground.Red });
+}
+
+export default {
+  info,
+  warn,
+  error
+};

package/src/lib/parse-argv.ts

@@ -0,0 +1,125 @@
+/**
+ * Parses process.argv or any string[] into an object with the given schema
+ * Properties should be prefixed with `--`
+ * Values should come immediately after the property and be separated by a space or `=`
+ * Type `array` can only be a array of `boolean`, `number`, or `string` types
+ * Type `boolean` will be `true` if present and not followed by `=[VALUE]`
+ * Type `object` property values can only by of `boolean`, `number`, or `string` types
+ * Schema entries may also be string‑literal arrays, which are treated as enum
+ * definitions; the resulting value will be typed as the union of the literals.
+ *
+ * @example
+ * const argv = parseArgv({ 
+ *   a: 'array',
+ *   b: 'boolean',
+ *   b2: 'boolean',
+ *   f: 'float',
+ *   n: 'number',
+ *   o: 'object',
+ *   s: 'string',
+ *   mode: ['dev','prod'] as const // enum-style union
+ * })
+ * 
+ * > npm run build -- --a [one,2,false] --b --b2=false --f 3.14 --n 123 --o {one:1,nope:false,hello:world} --s mystring --mode dev
+ *
+ */
+
+// primitive types that may be specified in the schema. enum definitions are
+// provided using string literal arrays directly on the schema entries.
+type Type = 'array' | 'boolean' | 'float' | 'number' | 'object' | 'string';
+
+type Schema<S extends Record<string, Type | readonly string[]>> = {
+  [K in keyof S]:
+    S[K] extends readonly (infer U)[] ? U | undefined
+    : S[K] extends 'array' ? any[] | undefined
+    : S[K] extends 'boolean' ? boolean | undefined
+    : S[K] extends 'float' ? number | undefined
+    : S[K] extends 'number' ? number | undefined
+    : S[K] extends 'object' ? Record<string, any> | undefined
+    : S[K] extends 'string' ? string | undefined
+    : string | undefined
+}
+
+export default function<S extends Record<string, Type | readonly string[]>>(schema: S, argv: string[] = process.argv.slice(2)): Schema<S> {
+  const data: Schema<S> = {} as Schema<S>;
+  const args = argv.slice()
+    .map((arg) => { return arg?.trim(); })
+    .filter(arg => typeof arg == 'string' && arg !== '');
+  for (let i=0; i<args.length; i++) {
+    if (args[i].startsWith('--')) {
+      const arg = args[i].slice(2);
+      if (arg.indexOf('=') !== -1) {
+        let [key, value] = arg.split('=') as [string, any];
+        if (schema[key]) {
+          value = parseValue(schema[key], value);
+          data[key as keyof Schema<S>] = value as any;
+        }
+      } else if (schema[arg] === 'boolean') {
+        data[arg as keyof Schema<S>] = true as any;
+      } else if (schema[arg]) {
+        let value: any = true;
+        if (i + 1 < args.length && !args[i+1].startsWith('--')) {
+          value = parseValue(schema[arg], args[++i]);
+        }
+        data[arg as keyof Schema<S>] = value as any;
+      }
+    }
+  }
+
+  return data;
+}
+
+function parseValue(type: Type | readonly string[], value: string): any {
+  if (typeof value != 'string') {
+    return undefined;
+  }
+  if (Array.isArray(type)) {
+    return (type.includes(value) ? value : value) as any;
+  }
+  switch (type) {
+    case 'array': {
+      if (value.startsWith('[')) {
+        value = value.substring(1);
+      }
+      if (value.endsWith(']')) {
+        value = value.slice(0, -1);
+      }
+      const items = value.split(',')
+        .map((v) => {
+          v = v.trim();
+          if (/(true|false|\d+(?:\.\d+)?)/i.test(v)) {
+            return JSON.parse(v);
+          } else {
+            return v;
+          }
+        });
+
+      return items;
+    }
+    case 'boolean':
+      return value.toLowerCase() === 'true' || value === '1';
+    case 'float':
+      return parseFloat(value);
+    case 'number':
+      return parseInt(value, 10);
+    case 'object':
+      if (value.startsWith('{') && value.endsWith('}')) {
+        const obj = value.substring(1, value.length - 1)
+          .split(',')
+          .filter(p => p.trim() !== '')
+          .map((pair) => {
+            let [key, val] = pair.split(':').map(s => s.trim());
+            if (/(true|false|\d+(?:\.\d+)?)/i.test(val)) {
+              val = JSON.parse(val);
+            }
+            return [key,val];
+          });
+        return Object.fromEntries(obj);
+      } else {
+        return {};
+      }
+    case 'string':
+    default:
+      return value;
+  }
+}

package/src/lib/parse-env.ts

@@ -0,0 +1,147 @@
+/**
+ * Parses a .env file into an object with the given schema
+ * Values should come immediately after the property and be separated by `=`
+ * Values can be quoted or unquoted
+ * Type `array` can only be a array of `boolean`, `number`, or `string` types
+ * Type `object` property values can only by of `boolean`, `number`, or `string` types
+ * Schema entries may also be string‑literal arrays, which are treated as enum
+ * definitions; the resulting value will be typed as the union of the literals.
+ *
+ * @example
+ * import parseEnv from './parse-env';
+ * 
+ * const env = parseEnv({ 
+ *   a: 'array',
+ *   b: 'boolean',
+ *   b2: 'boolean',
+ *   f: 'float',
+ *   n: 'number',
+ *   o: 'object',
+ *   s: 'string',
+ *   mode: ['dev','prod'] as const // enum-style union
+ * })
+ * 
+ * 
+ * // .env
+ * a="[1,2,3]"
+ * b=false
+ * b2="true"
+ * f="1.23"
+ * n=234
+ * o={"test":1}
+ * s="testing 1 2 3"
+ * mode=prod
+ */
+
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from 'node:path';
+
+// primitive types that can be declared in the schema
+// (enum definitions are represented by string literal arrays in the schema itself)
+export type EnvPropertyType = 'array' | 'boolean' | 'float' | 'number' | 'object' | 'string';
+
+// When the schema entry is an array of literals we treat it as an enum definition
+// and the resulting value is the union of those literals.
+// Otherwise we fall back to the primitive mapping that was already present.
+
+export type EnvSchema<S extends Record<string, EnvPropertyType | readonly string[]> = Record<string, any>> = {
+  [K in keyof S]:
+    S[K] extends readonly (infer U)[] ? U | undefined
+    : S[K] extends 'array' ? any[] | undefined
+    : S[K] extends 'boolean' ? boolean | undefined
+    : S[K] extends 'float' ? number | undefined
+    : S[K] extends 'number' ? number | undefined
+    : S[K] extends 'object' ? Record<string, any> | undefined
+    : S[K] extends 'string' ? string | undefined
+    : string | undefined
+}
+
+// parse reads a .env file according to the given schema.  In addition to
+// the primitive types listed above the schema may use a string-literal
+// array to describe an enum; the returned object will then have the property
+// typed as the union of those literals.
+async function parseEnv<S extends Record<string, EnvPropertyType | readonly string[]>>(schema: S, { mode, cwd, filePath, all = false }: { mode?: string, cwd?: string, filePath?: string, all?: boolean } = {}): Promise<EnvSchema<S>> {
+  const env: EnvSchema<S> = {} as EnvSchema<S>;
+
+  const fp = filePath ? cwd ? join(cwd, filePath) : filePath : join(cwd ?? process.cwd(), `.env${mode ? `.${mode}` : ''}`);
+  if (existsSync(fp)) {
+    const data: Record<string, string> = {};
+    const content = await readFile(fp, 'utf8');
+    const lines = content.split(/\r?\n/).filter(l => l.trim() !== '');
+    for (const line of lines) {
+      const [key, value] = line.split('=');
+      data[key.trim()] = value.trim().match(/['"']?([^'"]*)['"]?/)?.[1].trim() ?? '';
+    }
+    for (const [key, value] of Object.entries(data)) {
+      if (schema[key])  {
+        env[key as keyof EnvSchema<S>] = parseValue(schema[key], value);
+      } else if (all) {
+        env[key as keyof EnvSchema<S>] = value as any;
+      }
+    }
+  }
+
+  return env;
+};
+
+function parseValue(type: EnvPropertyType | readonly string[], value: string): any {
+  if (typeof value != 'string') {
+    return undefined;
+  }
+  // enums are defined as string literal arrays in the schema
+  if (Array.isArray(type)) {
+    // return the value directly; optionally we could validate, but at runtime
+    // we simply cast back to one of the allowed values (union type ensures
+    // callers only use valid strings at compile time if schema is const).
+    return (type.includes(value) ? value : value) as any;
+  }
+  switch (type) {
+    case 'array': {
+      if (value.startsWith('[')) {
+        value = value.substring(1);
+      }
+      if (value.endsWith(']')) {
+        value = value.slice(0, -1);
+      }
+      const items = value.split(',')
+        .map((v) => {
+          v = v.trim();
+          if (/(true|false|\d+(?:\.\d+)?)/i.test(v)) {
+            return JSON.parse(v);
+          } else {
+            return v;
+          }
+        });
+
+      return items;
+    }
+    case 'boolean':
+      return value.toLowerCase() === 'true' || value === '1';
+    case 'float':
+      return parseFloat(value);
+    case 'number':
+      return parseInt(value, 10);
+    case 'object':
+      if (value.startsWith('{') && value.endsWith('}')) {
+        const obj = value.substring(1, value.length - 1)
+          .split(',')
+          .filter(p => p.trim() !== '')
+          .map((pair) => {
+            let [key, val] = pair.split(':').map(s => s.trim());
+            if (/(true|false|\d+(?:\.\d+)?)/i.test(val)) {
+              val = JSON.parse(val);
+            }
+            return [key,val];
+          });
+        return Object.fromEntries(obj);
+      } else {
+        return {};
+      }
+    case 'string':
+    default:
+      return value;
+  }
+}
+
+export default parseEnv;