@atomic-ehr/codegen 0.0.1-canary.20250821160126.c552195 → 0.0.1-canary.20250822150706.c3b8669

package/dist/typeschema/value-set/processor.js

@@ -0,0 +1,168 @@
+/**
+ * Value Set Processing
+ *
+ * Functions for transforming FHIR ValueSets into TypeSchema format
+ */
+import { buildValueSetIdentifier } from "../core/identifier.js";
+/**
+ * Extract concepts from a CodeSystem
+ */
+async function extractCodeSystemConcepts(codeSystemUrl, manager) {
+    try {
+        const codeSystem = await manager.resolve(codeSystemUrl);
+        if (!codeSystem || codeSystem.resourceType !== "CodeSystem") {
+            return undefined;
+        }
+        const concepts = [];
+        // Recursive function to extract concepts (including nested ones)
+        const extractConcepts = (conceptList, system) => {
+            for (const concept of conceptList) {
+                concepts.push({
+                    system,
+                    code: concept.code,
+                    display: concept.display,
+                });
+                // Handle nested concepts
+                if (concept.concept) {
+                    extractConcepts(concept.concept, system);
+                }
+            }
+        };
+        if (codeSystem.concept) {
+            extractConcepts(codeSystem.concept, codeSystemUrl);
+        }
+        return concepts;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Process ValueSet compose include/exclude
+ */
+async function processComposeItem(item, manager) {
+    const concepts = [];
+    // Direct concept list
+    if (item.concept) {
+        for (const concept of item.concept) {
+            concepts.push({
+                system: item.system,
+                code: concept.code,
+                display: concept.display,
+            });
+        }
+        return concepts;
+    }
+    // Include all from CodeSystem (no filter)
+    if (item.system && !item.filter) {
+        const csConcepts = await extractCodeSystemConcepts(item.system, manager);
+        if (csConcepts) {
+            concepts.push(...csConcepts);
+        }
+    }
+    // Include from another ValueSet
+    if (item.valueSet) {
+        for (const vsUrl of item.valueSet) {
+            try {
+                const vs = await manager.resolve(vsUrl);
+                if (vs) {
+                    const vsConcepts = await extractValueSetConcepts(vs, manager);
+                    if (vsConcepts) {
+                        concepts.push(...vsConcepts);
+                    }
+                }
+            }
+            catch {
+                // Ignore if we can't resolve
+            }
+        }
+    }
+    return concepts;
+}
+/**
+ * Extract all concepts from a ValueSet
+ */
+export async function extractValueSetConcepts(valueSet, manager) {
+    try {
+        const concepts = [];
+        if (valueSet.compose) {
+            // Process includes
+            if (valueSet.compose.include) {
+                for (const include of valueSet.compose.include) {
+                    const includeConcepts = await processComposeItem(include, manager);
+                    concepts.push(...includeConcepts);
+                }
+            }
+            // Process excludes (remove them from the list)
+            if (valueSet.compose.exclude) {
+                const excludeConcepts = new Set();
+                for (const exclude of valueSet.compose.exclude) {
+                    const excludeList = await processComposeItem(exclude, manager);
+                    for (const concept of excludeList) {
+                        excludeConcepts.add(`${concept.system}|${concept.code}`);
+                    }
+                }
+                // Filter out excluded concepts
+                return concepts.filter((c) => !excludeConcepts.has(`${c.system}|${c.code}`));
+            }
+        }
+        return concepts.length > 0 ? concepts : undefined;
+    }
+    catch (error) {
+        console.error("Error extracting ValueSet concepts:", error);
+        return undefined;
+    }
+}
+/**
+ * Transform a FHIR ValueSet to TypeSchema format
+ */
+export async function transformValueSet(valueSet, manager, packageInfo) {
+    const identifier = buildValueSetIdentifier(valueSet.url, valueSet, packageInfo);
+    const typeSchemaValueSet = {
+        identifier,
+    };
+    // Add description if present
+    if (valueSet.description) {
+        typeSchemaValueSet.description = valueSet.description;
+    }
+    // Try to extract concepts
+    const concepts = await extractValueSetConcepts(valueSet, manager);
+    if (concepts && concepts.length > 0) {
+        // If we can expand, include the concepts
+        typeSchemaValueSet.concept = concepts;
+    }
+    else if (valueSet.compose) {
+        // If we can't expand, include the compose structure
+        typeSchemaValueSet.compose = valueSet.compose;
+    }
+    // Extract dependencies from compose
+    if (valueSet.compose) {
+        const deps = [];
+        // Helper to process include/exclude
+        const processCompose = (items) => {
+            for (const item of items) {
+                if (item.system) {
+                    deps.push({
+                        kind: "value-set",
+                        package: packageInfo?.name || "undefined",
+                        version: packageInfo?.version || "undefined",
+                        name: item.system.split("/").pop() || "unknown",
+                        url: item.system,
+                    });
+                }
+                if (item.valueSet) {
+                    for (const vsUrl of item.valueSet) {
+                        deps.push(buildValueSetIdentifier(vsUrl, undefined, packageInfo));
+                    }
+                }
+            }
+        };
+        if (valueSet.compose.include) {
+            processCompose(valueSet.compose.include);
+        }
+        if (valueSet.compose.exclude) {
+            processCompose(valueSet.compose.exclude);
+        }
+    }
+    return typeSchemaValueSet;
+}

package/dist/utils/codegen-logger.js

@@ -0,0 +1,204 @@
+/**
+ * CodeGen Logger
+ *
+ * Clean, colorful logging designed for code generation tools
+ */
+import pc from "picocolors";
+/**
+ * Simple code generation logger with pretty colors and clean formatting
+ */
+export class CodegenLogger {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            timestamp: false,
+            verbose: false,
+            ...options,
+        };
+    }
+    formatMessage(level, message, color) {
+        const timestamp = this.options.timestamp
+            ? `${pc.gray(new Date().toLocaleTimeString())} `
+            : "";
+        const prefix = this.options.prefix
+            ? `${pc.cyan(`[${this.options.prefix}]`)} `
+            : "";
+        return `${timestamp}${color(level)} ${prefix}${message}`;
+    }
+    /**
+     * Success message with checkmark
+     */
+    success(message) {
+        console.log(this.formatMessage("✅", message, pc.green));
+    }
+    /**
+     * Error message with X mark
+     */
+    error(message, error) {
+        console.error(this.formatMessage("❌", message, pc.red));
+        if (error && this.options.verbose) {
+            console.error(pc.red(`   ${error.message}`));
+            if (error.stack) {
+                console.error(pc.gray(error.stack));
+            }
+        }
+    }
+    /**
+     * Warning message with warning sign
+     */
+    warn(message) {
+        console.warn(this.formatMessage("⚠️", message, pc.yellow));
+    }
+    /**
+     * Info message with info icon
+     */
+    info(message) {
+        console.log(this.formatMessage("ℹ️", message, pc.blue));
+    }
+    /**
+     * Debug message (only shows in verbose mode)
+     */
+    debug(message) {
+        if (this.options.verbose) {
+            console.log(this.formatMessage("🐛", message, pc.magenta));
+        }
+    }
+    /**
+     * Step message with rocket
+     */
+    step(message) {
+        console.log(this.formatMessage("🚀", message, pc.cyan));
+    }
+    /**
+     * Progress message with clock
+     */
+    progress(message) {
+        console.log(this.formatMessage("⏳", message, pc.blue));
+    }
+    /**
+     * Plain message (no icon, just colored text)
+     */
+    plain(message, color = (s) => s) {
+        const timestamp = this.options.timestamp
+            ? `${pc.gray(new Date().toLocaleTimeString())} `
+            : "";
+        const prefix = this.options.prefix
+            ? `${pc.cyan(`[${this.options.prefix}]`)} `
+            : "";
+        console.log(`${timestamp}${prefix}${color(message)}`);
+    }
+    /**
+     * Dimmed/gray text for less important info
+     */
+    dim(message) {
+        this.plain(message, pc.gray);
+    }
+    /**
+     * Create a child logger with a prefix
+     */
+    child(prefix) {
+        return new CodegenLogger({
+            ...this.options,
+            prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix,
+        });
+    }
+    /**
+     * Update options
+     */
+    configure(options) {
+        this.options = { ...this.options, ...options };
+    }
+}
+/**
+ * Quick logging functions for simple usage
+ */
+const defaultLogger = new CodegenLogger();
+export function success(message) {
+    defaultLogger.success(message);
+}
+export function error(message, err) {
+    defaultLogger.error(message, err);
+}
+export function warn(message) {
+    defaultLogger.warn(message);
+}
+export function info(message) {
+    defaultLogger.info(message);
+}
+export function debug(message) {
+    defaultLogger.debug(message);
+}
+export function step(message) {
+    defaultLogger.step(message);
+}
+export function progress(message) {
+    defaultLogger.progress(message);
+}
+export function plain(message, color) {
+    defaultLogger.plain(message, color);
+}
+export function dim(message) {
+    defaultLogger.dim(message);
+}
+/**
+ * Configure the default logger
+ */
+export function configure(options) {
+    defaultLogger.configure(options);
+}
+/**
+ * Create a new logger instance
+ */
+export function createLogger(options = {}) {
+    return new CodegenLogger(options);
+}
+/**
+ * Convenience functions for common CLI patterns
+ */
+/**
+ * Show a command header with separator
+ */
+export function header(title) {
+    console.log();
+    console.log(pc.cyan(pc.bold(`━━━ ${title} ━━━`)));
+}
+/**
+ * Show a section break
+ */
+export function section(title) {
+    console.log();
+    console.log(pc.bold(title));
+}
+/**
+ * Show completion message with stats
+ */
+export function complete(message, duration, stats) {
+    let msg = message;
+    if (duration) {
+        msg += ` ${pc.gray(`(${duration}ms)`)}`;
+    }
+    success(msg);
+    if (stats) {
+        Object.entries(stats).forEach(([key, value]) => {
+            dim(`  ${key}: ${value}`);
+        });
+    }
+}
+/**
+ * Show a list of items
+ */
+export function list(items, bullet = "•") {
+    items.forEach((item) => {
+        console.log(pc.gray(`  ${bullet} ${item}`));
+    });
+}
+/**
+ * Show key-value pairs
+ */
+export function table(data) {
+    const maxKeyLength = Math.max(...Object.keys(data).map((k) => k.length));
+    Object.entries(data).forEach(([key, value]) => {
+        const paddedKey = key.padEnd(maxKeyLength);
+        console.log(`  ${pc.blue(paddedKey)} ${pc.gray("─")} ${value}`);
+    });
+}

package/dist/utils.js

@@ -0,0 +1,42 @@
+/**
+ * Convert a string into PascalCase.
+ * Examples:
+ *  - "patient-name" -> "PatientName"
+ *  - "Patient name" -> "PatientName"
+ *  - "patient_name" -> "PatientName"
+ *  - "patientName" -> "PatientName"
+ */
+export function toPascalCase(input) {
+    const parts = input
+        .replace(/[^A-Za-z0-9]+/g, " ")
+        .split(" ")
+        .map((p) => p.trim())
+        .filter(Boolean);
+    if (parts.length === 0)
+        return "";
+    return parts.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}
+/**
+ * Split an array into chunks of a given size.
+ *
+ * Examples:
+ *  - chunkArray([1,2,3,4,5], 2) -> [[1,2],[3,4],[5]]
+ *  - chunkArray([], 3) -> []
+ *
+ * @param arr - The array to split.
+ * @param size - The maximum size of each chunk (must be >= 1).
+ * @returns An array of chunks (each chunk is an array of T).
+ * @throws RangeError if size is less than 1.
+ */
+export function chunkArray(arr, size) {
+    if (!Number.isInteger(size) || size < 1) {
+        throw new RangeError("chunk size must be an integer greater than 0");
+    }
+    const result = [];
+    if (!arr || arr.length === 0)
+        return result;
+    for (let i = 0; i < arr.length; i += size) {
+        result.push(arr.slice(i, i + size));
+    }
+    return result;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomic-ehr/codegen",
-  "version": "0.0.1-canary.20250821160126.c552195",
+  "version": "0.0.1-canary.20250822150706.c3b8669",
   "description": "Code generation tools for FHIR resources and TypeSchema definitions",
   "keywords": [
     "fhir",
@@ -10,9 +10,20 @@
     "ehr",
     "typeschema"
   ],
-  "module": "./dist/index.js",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./cli": {
+      "types": "./dist/cli/index.d.ts",
+      "import": "./dist/cli/index.js",
+      "default": "./dist/cli/index.js"
+    }
+  },
   "type": "module",
   "bin": {
     "atomic-codegen": "./dist/cli/index.js"
@@ -31,9 +42,9 @@
     "test:verbose": "bun test --verbose",
     "test:helpers": "bun test test/helpers/",
     "test:quick": "bun test test/unit/ --timeout 5000",
-    "build": "rm -rf dist && bun build src/index.ts src/cli/index.ts --outdir dist --target node --format esm --splitting --external typescript && bunx tsc --project tsconfig.build.json && chmod +x dist/cli/index.js",
+    "build": "rm -rf dist && bunx tsc --project tsconfig.build.json && chmod +x dist/cli/index.js",
     "typecheck": "bunx tsc --noEmit",
-    "lint": "biome check --write ./src",
+    "lint": "biome check --write",
     "quality": "bun run typecheck && bun run lint && bun run test:unit",
     "cli": "bun run src/cli/index.ts",
     "codegen": "bun run src/cli/index.ts",