@config-bound/schema-export 0.1.2 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @config-bound/schema-export
 
+## 0.1.3
+
+### Patch Changes
+
+- Updated dependencies [87d2ab6]
+  - @config-bound/core@1.0.0
+
 ## 0.1.2
 
 ### Patch Changes

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Robert Keyser
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -11,7 +11,7 @@ npm install @config-bound/schema-export
 ## Usage
 
 ```typescript
-import { ConfigBound } from '@config-bound/config-bound';
+import { ConfigBound } from '@config-bound/core';
 import {
   exportSchema,
   formatAsJSON,

package/package.json

@@ -1,25 +1,32 @@
 {
   "name": "@config-bound/schema-export",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Schema export utilities for ConfigBound configuration library",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "require": "./dist/index.js",
-      "import": "./dist/index.js"
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
     }
   },
-  "scripts": {
-    "build": "tsc",
-    "clean": "rimraf dist",
-    "test": "jest",
-    "lint": "eslint src/**/*.ts --fix",
-    "lint:ci": "eslint src/**/*.ts",
-    "format": "prettier --write --config ../../.config/.prettierrc --ignore-path ../../.config/.prettierignore src/**/*.ts",
-    "format:ci": "prettier --check --config ../../.config/.prettierrc --ignore-path ../../.config/.prettierignore src/**/*.ts"
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "engines": {
+    "node": ">=20"
   },
   "keywords": [
     "config",
@@ -32,13 +39,14 @@
   ],
   "author": "Robert Keyser",
   "license": "MIT",
+  "peerDependencies": {
+    "zod": "^4.4.1"
+  },
   "dependencies": {
-    "@config-bound/config-bound": "0.3.0",
     "js-yaml": "^4.1.0",
-    "zod": "^4.4.1"
+    "@config-bound/core": "1.0.0"
   },
   "devDependencies": {
-    "@config-bound/eslint-config": "*",
     "@types/jest": "^30.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^24.10.0",
@@ -46,14 +54,36 @@
     "jest": "^30.2.0",
     "rimraf": "^6.1.0",
     "ts-jest": "^29.4.5",
-    "typescript": "^6.0.0"
+    "typescript": "^6.0.0",
+    "zod": "^4.4.1",
+    "@config-bound/eslint-config": "0.0.0",
+    "@config-bound/typescript-config": "0.0.0"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
+  "typedocOptions": {
+    "entryPoints": [
+      "./src/index.ts"
+    ],
+    "tsconfig": "./tsconfig.typedoc.json",
+    "exclude": [
+      "**/*.spec.ts"
+    ]
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/notr-ai/ConfigBound"
+    "url": "git+https://github.com/notr-ai/ConfigBound.git"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist",
+    "test": "jest",
+    "lint": "eslint src/**/*.ts --fix",
+    "lint:ci": "eslint src/**/*.ts",
+    "format": "prettier --write --config ../../.config/.prettierrc --ignore-path ../../.config/.prettierignore src/**/*.ts",
+    "format:ci": "prettier --check --config ../../.config/.prettierrc --ignore-path ../../.config/.prettierignore src/**/*.ts"
   }
-}
+}

package/eslint.config.mjs

@@ -1,3 +0,0 @@
-import configBoundConfig from '@config-bound/eslint-config/package.eslint.mjs';
-
-export default configBoundConfig;

package/jest.config.js

@@ -1,26 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-
-/** @type {import('ts-jest').JestConfigWithTsJest} **/
-export default {
-  testEnvironment: 'node',
-  rootDir: './src',
-  testMatch: ['**/*.spec.ts'],
-  extensionsToTreatAsEsm: ['.ts'],
-  moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.js$': '$1'
-  },
-  transform: {
-    '^.+\\.tsx?$': [
-      'ts-jest',
-      {
-        useESM: true,
-        tsconfig: {
-          isolatedModules: false
-        },
-        diagnostics: {
-          ignoreCodes: [151002]
-        }
-      }
-    ]
-  }
-};

package/src/index.ts

@@ -1,14 +0,0 @@
-export {
-  exportElement,
-  exportSection,
-  exportSchema,
-  type ExportedElement,
-  type ExportedSection,
-  type ExportedSchema
-} from './schemaExporter.js';
-
-export {
-  formatAsJSON,
-  formatAsYAML,
-  formatAsEnvExample
-} from './schemaFormatters.js';

package/src/schemaExporter.spec.ts

@@ -1,285 +0,0 @@
-import { Section } from '@config-bound/config-bound/section';
-import { Element } from '@config-bound/config-bound/element';
-import { z } from 'zod';
-import {
-  exportElement,
-  exportSection,
-  exportSchema
-} from './schemaExporter.js';
-
-describe('Schema Exporter', () => {
-  describe('exportElement', () => {
-    it('should export a basic element', () => {
-      const element = new Element<string>(
-        'testElement',
-        'A test element',
-        'default-value',
-        'example-value',
-        false,
-        false,
-        z.string()
-      );
-
-      const exported = exportElement(element);
-
-      expect(exported.name).toBe('testElement');
-      expect(exported.description).toBe('A test element');
-      expect(exported.type).toBe('string');
-      expect(exported.default).toBe('default-value');
-      expect(exported.example).toBe('example-value');
-      expect(exported.required).toBe(true);
-      expect(exported.sensitive).toBe(false);
-    });
-
-    it('should handle required elements', () => {
-      const element = new Element<number>(
-        'requiredElement',
-        'A required element',
-        undefined,
-        42,
-        false,
-        false,
-        z.number()
-      );
-
-      const exported = exportElement(element);
-
-      expect(exported.required).toBe(true);
-    });
-
-    it('should handle sensitive elements', () => {
-      const element = new Element<string>(
-        'secretKey',
-        'API secret key',
-        undefined,
-        'sk_test_123',
-        true,
-        false,
-        z.string()
-      );
-
-      const exported = exportElement(element);
-
-      expect(exported.sensitive).toBe(true);
-    });
-
-    it('should handle elements with omitFromSchema', () => {
-      const element = new Element<string>(
-        'privateKey',
-        'Private configuration key',
-        'default',
-        'example',
-        false,
-        true,
-        z.string()
-      );
-
-      expect(element.omitFromSchema).toBe(true);
-    });
-
-    it('should extract zod validation object', () => {
-      const element = new Element<number>(
-        'port',
-        'Server port',
-        3000,
-        undefined,
-        false,
-        false,
-        z.number().min(1).max(65535)
-      );
-
-      const exported = exportElement(element);
-
-      expect(exported.zodValidation).toBeDefined();
-      expect((exported.zodValidation as any).type).toBe('number');
-    });
-
-    it('should handle enum types', () => {
-      const element = new Element<string>(
-        'environment',
-        'Runtime environment',
-        'development',
-        undefined,
-        false,
-        false,
-        z.enum(['development', 'staging', 'production'])
-      );
-
-      const exported = exportElement(element);
-
-      expect(exported.type).toContain('development');
-      expect(exported.type).toContain('staging');
-      expect(exported.type).toContain('production');
-    });
-  });
-
-  describe('exportSection', () => {
-    it('should export a section with elements', () => {
-      const elements = [
-        new Element<string>('host', 'Database host', 'localhost'),
-        new Element<number>('port', 'Database port', 5432)
-      ];
-
-      const section = new Section(
-        'database',
-        elements,
-        'Database configuration'
-      );
-
-      const exported = exportSection(section);
-
-      expect(exported.name).toBe('database');
-      expect(exported.description).toBe('Database configuration');
-      expect(exported.elements).toHaveLength(2);
-      expect(exported.elements[0].name).toBe('host');
-      expect(exported.elements[1].name).toBe('port');
-    });
-
-    it('should handle empty sections', () => {
-      const section = new Section('empty', [], 'Empty section');
-
-      const exported = exportSection(section);
-
-      expect(exported.name).toBe('empty');
-      expect(exported.elements).toHaveLength(0);
-    });
-
-    it('should filter out elements with omitFromSchema: true', () => {
-      const publicElement = new Element<string>(
-        'appName',
-        'Application name',
-        'myApp',
-        'exampleApp',
-        false,
-        false,
-        z.string()
-      );
-      const privateElement = new Element<string>(
-        'internalKey',
-        'Internal configuration key',
-        'secret',
-        'example',
-        false,
-        true,
-        z.string()
-      );
-
-      const section = new Section(
-        'app',
-        [publicElement, privateElement],
-        'Application settings'
-      );
-      const exported = exportSection(section);
-
-      expect(exported.name).toBe('app');
-      expect(exported.description).toBe('Application settings');
-      expect(exported.elements).toHaveLength(1);
-      expect(exported.elements[0].name).toBe('appName');
-      expect(
-        exported.elements.find(
-          (e: { name: string }) => e.name === 'internalKey'
-        )
-      ).toBeUndefined();
-    });
-
-    it('should include omitted elements when includeOmitted is true', () => {
-      const publicElement = new Element<string>(
-        'appName',
-        'Application name',
-        'myApp',
-        'exampleApp',
-        false,
-        false,
-        z.string()
-      );
-      const privateElement = new Element<string>(
-        'internalKey',
-        'Internal configuration key',
-        'secret',
-        'example',
-        false,
-        true,
-        z.string()
-      );
-
-      const section = new Section(
-        'app',
-        [publicElement, privateElement],
-        'Application settings'
-      );
-      const exported = exportSection(section, true);
-
-      expect(exported.name).toBe('app');
-      expect(exported.description).toBe('Application settings');
-      expect(exported.elements).toHaveLength(2);
-      expect(exported.elements[0].name).toBe('appName');
-      expect(exported.elements[1].name).toBe('internalKey');
-    });
-  });
-
-  describe('exportSchema', () => {
-    it('should export a complete schema', () => {
-      const appElements = [
-        new Element<number>('port', 'Application port', 3000),
-        new Element<string>('host', 'Application host', 'localhost')
-      ];
-
-      const dbElements = [
-        new Element<string>(
-          'connectionString',
-          'Database connection',
-          undefined
-        )
-      ];
-
-      const sections = [
-        new Section('app', appElements, 'Application settings'),
-        new Section('database', dbElements, 'Database settings')
-      ];
-
-      const schema = exportSchema('myApp', sections);
-
-      expect(schema.name).toBe('myApp');
-      expect(schema.sections).toHaveLength(2);
-      expect(schema.sections[0].name).toBe('app');
-      expect(schema.sections[1].name).toBe('database');
-    });
-
-    it('should include omitted elements when includeOmitted is true', () => {
-      const publicElement = new Element<string>(
-        'appName',
-        'Application name',
-        'myApp',
-        'exampleApp',
-        false,
-        false,
-        z.string()
-      );
-      const privateElement = new Element<string>(
-        'internalKey',
-        'Internal configuration key',
-        'secret',
-        'example',
-        false,
-        true,
-        z.string()
-      );
-
-      const sections = [
-        new Section(
-          'app',
-          [publicElement, privateElement],
-          'Application settings'
-        )
-      ];
-
-      const schema = exportSchema('myApp', sections, true);
-
-      expect(schema.name).toBe('myApp');
-      expect(schema.sections).toHaveLength(1);
-      expect(schema.sections[0].elements).toHaveLength(2);
-      expect(schema.sections[0].elements[0].name).toBe('appName');
-      expect(schema.sections[0].elements[1].name).toBe('internalKey');
-    });
-  });
-});

package/src/schemaExporter.ts

@@ -1,162 +0,0 @@
-import { Section } from '@config-bound/config-bound/section';
-import { Element } from '@config-bound/config-bound/element';
-import { z } from 'zod';
-
-/**
- * Represents a single configuration element in the exported schema
- */
-export interface ExportedElement {
-  name: string;
-  description?: string;
-  type: string;
-  default?: unknown;
-  example?: unknown;
-  required: boolean;
-  sensitive: boolean;
-  zodValidation: unknown;
-}
-
-/**
- * Represents a configuration section in the exported schema
- */
-export interface ExportedSection {
-  name: string;
-  description?: string;
-  elements: ExportedElement[];
-}
-
-/**
- * The complete exported configuration schema
- */
-export interface ExportedSchema {
-  name: string;
-  sections: ExportedSection[];
-}
-
-/**
- * Extracts a human-readable type string from a Zod schema.
- *
- * @param validator - Zod validator to inspect.
- * @returns Human-readable type string.
- */
-function extractZodType(validator: z.ZodType): string {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const typeName = (validator as any)._def?.type;
-
-  // Handle ZodOptional and ZodNullable wrappers
-  if (typeName === 'optional' || typeName === 'nullable') {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return extractZodType((validator as any)._def.innerType);
-  }
-
-  // Map common Zod type names to readable types
-  switch (typeName) {
-    case 'string':
-      return 'string';
-    case 'number':
-      return 'number';
-    case 'boolean':
-      return 'boolean';
-    case 'enum': {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const enumValues = Object.values((validator as any)._def.entries ?? {});
-      return enumValues.map((v) => String(v)).join(' | ');
-    }
-    case 'literal':
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      return String((validator as any)._def.value);
-    case 'array':
-      return 'array';
-    case 'object':
-      return 'object';
-    case 'union':
-    case 'discriminatedUnion': {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      const options = (validator as any)._def.options;
-      if (options) {
-        return options.map((opt: z.ZodType) => extractZodType(opt)).join(' | ');
-      }
-      return 'union';
-    }
-    case 'any':
-      return 'any';
-    case 'unknown':
-      return 'unknown';
-    default:
-      return typeName || 'unknown';
-  }
-}
-
-/**
- * Converts a Zod validator to a JSON Schema representation.
- *
- * @param validator - Zod validator to convert.
- * @returns JSON Schema object.
- */
-function extractZodValidation(validator: z.ZodType): unknown {
-  return z.toJSONSchema(validator, {
-    target: 'openapi-3.0',
-    reused: 'inline'
-  });
-}
-
-/**
- * Exports an Element to the external schema format.
- *
- * @param element - Element to export.
- * @returns Exported element representation.
- */
-export function exportElement(element: Element<unknown>): ExportedElement {
-  return {
-    name: element.name,
-    description: element.description,
-    type: extractZodType(element.validator),
-    default: element.default,
-    example: element.example,
-    required: element.isRequired(),
-    sensitive: element.sensitive,
-    zodValidation: extractZodValidation(element.validator)
-  };
-}
-
-/**
- * Exports a Section to the external schema format.
- *
- * @param section - The section to export.
- * @param includeOmitted - Whether to include elements marked with omitFromSchema (default: false).
- * @returns Exported section representation.
- */
-export function exportSection(
-  section: Section,
-  includeOmitted: boolean = false
-): ExportedSection {
-  return {
-    name: section.name,
-    description: section.description,
-    elements: section
-      .getElements()
-      .filter(
-        (element: Element<unknown>) => includeOmitted || !element.omitFromSchema
-      )
-      .map(exportElement)
-  };
-}
-
-/**
- * Exports the complete schema to a structured format.
- *
- * @param name - Name of the configuration.
- * @param sections - Sections to include in the export.
- * @param includeOmitted - Whether to include elements marked with omitFromSchema (default: false).
- * @returns Exported schema representation.
- */
-export function exportSchema(
-  name: string,
-  sections: Section[],
-  includeOmitted: boolean = false
-): ExportedSchema {
-  return {
-    name,
-    sections: sections.map((section) => exportSection(section, includeOmitted))
-  };
-}

package/src/schemaFormatters.spec.ts

@@ -1,188 +0,0 @@
-import {
-  formatAsJSON,
-  formatAsYAML,
-  formatAsEnvExample
-} from './schemaFormatters.js';
-import { ExportedSchema } from './schemaExporter.js';
-
-describe('Schema Formatters', () => {
-  const mockSchema: ExportedSchema = {
-    name: 'testApp',
-    sections: [
-      {
-        name: 'app',
-        description: 'Application settings',
-        elements: [
-          {
-            name: 'port',
-            description: 'Server port',
-            type: 'number',
-            default: 3000,
-            example: 8080,
-            required: false,
-            sensitive: false,
-            zodValidation: {
-              type: 'number',
-              rules: [
-                { name: 'min', args: { limit: 1 } },
-                { name: 'max', args: { limit: 65535 } }
-              ]
-            }
-          },
-          {
-            name: 'apiKey',
-            description: 'API key',
-            type: 'string',
-            default: undefined,
-            example: 'sk_test_123',
-            required: true,
-            sensitive: true,
-            zodValidation: { type: 'string', flags: { presence: 'required' } }
-          }
-        ]
-      },
-      {
-        name: 'database',
-        description: 'Database configuration',
-        elements: [
-          {
-            name: 'host',
-            description: 'Database host',
-            type: 'string',
-            default: 'localhost',
-            example: undefined,
-            required: false,
-            sensitive: false,
-            zodValidation: { type: 'string' }
-          }
-        ]
-      }
-    ]
-  };
-
-  describe('formatAsJSON', () => {
-    it('should format schema as pretty JSON', () => {
-      const result = formatAsJSON(mockSchema, true);
-
-      expect(result).toContain('"name": "testApp"');
-      expect(result).toContain('"port"');
-      expect(result).toContain('"database"');
-      expect(JSON.parse(result)).toEqual(mockSchema);
-    });
-
-    it('should format schema as compact JSON', () => {
-      const result = formatAsJSON(mockSchema, false);
-
-      expect(result).not.toContain('\n');
-      expect(JSON.parse(result)).toEqual(mockSchema);
-    });
-  });
-
-  describe('formatAsYAML', () => {
-    it('should format schema as YAML', () => {
-      const result = formatAsYAML(mockSchema);
-
-      expect(result).toContain('name: testApp');
-      expect(result).toContain('- name: port');
-      expect(result).toContain('- name: database');
-      expect(result).toBeTruthy();
-    });
-  });
-
-  describe('formatAsEnvExample', () => {
-    it('should format schema as .env.example without prefix', () => {
-      const result = formatAsEnvExample(mockSchema);
-
-      expect(result).toContain('# testApp Configuration');
-      expect(result).toContain('# Generated from schema export');
-      expect(result).toContain('APP_PORT=');
-      expect(result).toContain('APP_APIKEY=');
-      expect(result).toContain('DATABASE_HOST=');
-      expect(result).toContain('# Server port');
-      expect(result).toContain('# API key');
-      expect(result).toContain('# Database host');
-    });
-
-    it('should format schema as .env.example with prefix', () => {
-      const result = formatAsEnvExample(mockSchema, 'MYAPP');
-
-      expect(result).toContain('MYAPP_APP_PORT=');
-      expect(result).toContain('MYAPP_APP_APIKEY=');
-      expect(result).toContain('MYAPP_DATABASE_HOST=');
-    });
-
-    it('should include example values when available', () => {
-      const result = formatAsEnvExample(mockSchema);
-
-      expect(result).toContain('APP_PORT=8080');
-    });
-
-    it('should include default values when example is not available', () => {
-      const result = formatAsEnvExample(mockSchema);
-
-      expect(result).toContain('DATABASE_HOST=localhost');
-    });
-
-    it('should use placeholder for sensitive values', () => {
-      const result = formatAsEnvExample(mockSchema);
-
-      expect(result).toContain('APP_APIKEY=your-example-value');
-    });
-
-    it('should mark required fields', () => {
-      const result = formatAsEnvExample(mockSchema);
-
-      expect(result).toContain('# API key (required)');
-    });
-
-    it('should handle sections without descriptions', () => {
-      const schemaWithoutDesc: ExportedSchema = {
-        name: 'test',
-        sections: [
-          {
-            name: 'app',
-            elements: [
-              {
-                name: 'port',
-                type: 'number',
-                default: 3000,
-                required: false,
-                sensitive: false,
-                zodValidation: {}
-              }
-            ]
-          }
-        ]
-      };
-
-      const result = formatAsEnvExample(schemaWithoutDesc);
-      expect(result).toContain('APP_PORT=3000');
-    });
-
-    it('should handle elements without descriptions', () => {
-      const schemaWithoutElementDesc: ExportedSchema = {
-        name: 'test',
-        sections: [
-          {
-            name: 'app',
-            description: 'App config',
-            elements: [
-              {
-                name: 'port',
-                type: 'number',
-                default: 3000,
-                required: false,
-                sensitive: false,
-                zodValidation: {}
-              }
-            ]
-          }
-        ]
-      };
-
-      const result = formatAsEnvExample(schemaWithoutElementDesc);
-      expect(result).toContain('# App config');
-      expect(result).toContain('APP_PORT=3000');
-    });
-  });
-});

package/src/schemaFormatters.ts

@@ -1,124 +0,0 @@
-import yaml from 'js-yaml';
-import { ExportedSchema, ExportedElement } from './schemaExporter.js';
-
-/**
- * Formats the schema as JSON string
- * @param schema - The schema to format
- * @param pretty - Whether to pretty print the JSON
- * @returns The configuration schema as a JSON string
- */
-export function formatAsJSON(
-  schema: ExportedSchema,
-  pretty: boolean = true
-): string {
-  return JSON.stringify(schema, null, pretty ? 2 : 0);
-}
-
-/**
- * Formats the schema as YAML string
- * @param schema - The schema to format
- * @returns The configuration schema as a YAML string
- */
-export function formatAsYAML(schema: ExportedSchema): string {
-  return yaml.dump(schema, {
-    indent: 2,
-    lineWidth: 80,
-    noRefs: true
-  });
-}
-
-/**
- * Generates an environment variable name from section and element names
- * @param sectionName - The name of the section
- * @param elementName - The name of the element
- * @param prefix - Optional prefix for the environment variable name
- * @returns The environment variable name
- */
-function generateEnvVarName(
-  sectionName: string,
-  elementName: string,
-  prefix?: string
-): string {
-  let name = `${sectionName}_${elementName}`.replace(/\./g, '_');
-  if (prefix) {
-    name = `${prefix}_${name}`;
-  }
-  return name.toUpperCase();
-}
-
-/**
- * Formats a value for display in .env.example file
- * @param element - The element to format
- * @returns The formatted value
- */
-function formatEnvValue(element: ExportedElement): string {
-  if (element.sensitive) {
-    if (element.example !== undefined) {
-      return 'your-example-value';
-    }
-    return 'your-secret-value';
-  }
-
-  if (element.example !== undefined) {
-    return String(element.example);
-  }
-
-  if (element.default !== undefined) {
-    return String(element.default);
-  }
-
-  switch (element.type) {
-    case 'string':
-      return 'your-value';
-    case 'number':
-      return '0';
-    case 'boolean':
-      return 'true';
-    case 'array':
-      return 'value1,value2';
-    default:
-      return 'your-value';
-  }
-}
-
-/**
- * Formats the schema as a .env.example file
- * @param schema - The exported schema
- * @param prefix - Optional prefix for environment variable names (e.g., 'MYAPP')
- * @returns The .env.example file content as a string
- */
-export function formatAsEnvExample(
-  schema: ExportedSchema,
-  prefix?: string
-): string {
-  const lines: string[] = [];
-
-  lines.push(`# ${schema.name} Configuration`);
-  lines.push('# Generated from schema export');
-  lines.push('');
-
-  for (const section of schema.sections) {
-    if (section.description) {
-      lines.push(`# ${section.description}`);
-    }
-
-    for (const element of section.elements) {
-      const envVarName = generateEnvVarName(section.name, element.name, prefix);
-      const value = formatEnvValue(element);
-      const isRequired = element.required && element.default === undefined;
-
-      if (element.description) {
-        lines.push(
-          `# ${element.description}${isRequired ? ' (required)' : ''}`
-        );
-      } else if (isRequired) {
-        lines.push('# Required');
-      }
-
-      lines.push(`${envVarName}=${value}`);
-      lines.push('');
-    }
-  }
-
-  return lines.join('\n');
-}

package/tsconfig.json

@@ -1,12 +0,0 @@
-{
-  "extends": "@config-bound/typescript-config/package.tsconfig.json",
-  "compilerOptions": {
-    "target": "ES2024",
-    "lib": ["ES2024"],
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*", "src/**/*.spec.ts"]
-}