@atomic-ehr/codegen 0.0.1-canary.20251006070905.fb6ed98 → 0.0.1-canary.20251006094042.7f0be72

package/dist/typeschema/core/nested-types.js

@@ -1,94 +0,0 @@
-/**
- * Nested Types (BackboneElement) Handling
- *
- * Functions for extracting and transforming nested types from FHIRSchema
- */
-import { isNestedElement, mkField, mkNestedField } from "./field-builder";
-import { mkNestedIdentifier } from "./identifier";
-function collectNestedElements(fhirSchema, parentPath, elements) {
-    const nested = [];
-    for (const [key, element] of Object.entries(elements)) {
-        const path = [...parentPath, key];
-        if (isNestedElement(element)) {
-            nested.push([path, element]);
-        }
-        if (element.elements) {
-            nested.push(...collectNestedElements(fhirSchema, path, element.elements));
-        }
-    }
-    return nested;
-}
-async function transformNestedElements(fhirSchema, parentPath, elements, register, _packageInfo) {
-    const fields = {};
-    for (const [key, element] of Object.entries(elements)) {
-        const path = [...parentPath, key];
-        if (isNestedElement(element)) {
-            fields[key] = mkNestedField(register, fhirSchema, path, element);
-        }
-        else {
-            fields[key] = mkField(register, fhirSchema, path, element);
-        }
-    }
-    return fields;
-}
-export async function mkNestedTypes(register, fhirSchema) {
-    if (!fhirSchema.elements)
-        return undefined;
-    const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
-    const actualNested = nestedElements.filter(([_, element]) => element.elements && Object.keys(element.elements).length > 0);
-    const nestedTypes = [];
-    for (const [path, element] of actualNested) {
-        const identifier = mkNestedIdentifier(fhirSchema, path);
-        // Base is usually BackboneElement - ensure all nested types have a base
-        // biome-ignore lint/suspicious/noImplicitAnyLet: <explanation>
-        let base;
-        if (element.type === "BackboneElement" || !element.type) {
-            // For BackboneElement or undefined type, always use BackboneElement as base
-            base = {
-                kind: "complex-type",
-                package: fhirSchema.package_meta.name,
-                version: fhirSchema.package_meta.version,
-                name: "BackboneElement",
-                url: "http://hl7.org/fhir/StructureDefinition/BackboneElement",
-            };
-        }
-        else {
-            // Use the specified type as base
-            base = {
-                kind: "complex-type",
-                package: fhirSchema.package_meta.name,
-                version: fhirSchema.package_meta.version,
-                name: element.type,
-                url: `http://hl7.org/fhir/StructureDefinition/${element.type}`,
-            };
-        }
-        // Transform sub-elements into fields
-        const fields = await transformNestedElements(fhirSchema, path, element.elements, register, fhirSchema.package_meta);
-        const nestedType = {
-            identifier,
-            base,
-            fields,
-        };
-        nestedTypes.push(nestedType);
-    }
-    // Sort by URL for consistent output
-    nestedTypes.sort((a, b) => a.identifier.url.localeCompare(b.identifier.url));
-    return nestedTypes.length === 0 ? undefined : nestedTypes;
-}
-export function extractNestedDependencies(nestedTypes) {
-    const deps = [];
-    for (const nested of nestedTypes) {
-        if (nested.base) {
-            deps.push(nested.base);
-        }
-        for (const field of Object.values(nested.fields || {})) {
-            if ("type" in field && field.type) {
-                deps.push(field.type);
-            }
-            if ("binding" in field && field.binding) {
-                deps.push(field.binding);
-            }
-        }
-    }
-    return deps;
-}

package/dist/typeschema/core/transformer.d.ts

@@ -1,11 +0,0 @@
-/**
- * Main FHIRSchema to TypeSchema Transformer
- *
- * Core transformation logic for converting FHIRSchema to TypeSchema format
- */
-import type { FHIRSchemaElement } from "@atomic-ehr/fhirschema";
-import { type Register } from "@typeschema/register";
-import type { Field, RichFHIRSchema, RichValueSet, TypeSchema, ValueSetTypeSchema } from "@typeschema/types";
-export declare function mkFields(register: Register, fhirSchema: RichFHIRSchema, parentPath: string[], elements: Record<string, FHIRSchemaElement> | undefined): Promise<Record<string, Field> | undefined>;
-export declare function transformValueSet(register: Register, valueSet: RichValueSet): Promise<ValueSetTypeSchema>;
-export declare function transformFHIRSchema(register: Register, fhirSchema: RichFHIRSchema): Promise<TypeSchema[]>;

package/dist/typeschema/core/transformer.js

@@ -1,235 +0,0 @@
-/**
- * Main FHIRSchema to TypeSchema Transformer
- *
- * Core transformation logic for converting FHIRSchema to TypeSchema format
- */
-import { fsElementSnapshot, resolveFsElementGenealogy } from "@typeschema/register";
-import { transformProfile } from "../profile/processor";
-import { collectBindingSchemas, extractValueSetConceptsByUrl } from "./binding";
-import { isNestedElement, mkField, mkNestedField } from "./field-builder";
-import { mkIdentifier, mkValueSetIdentifierByUrl } from "./identifier";
-import { extractNestedDependencies, mkNestedTypes } from "./nested-types";
-export async function mkFields(register, fhirSchema, parentPath, elements) {
-    if (!elements)
-        return undefined;
-    const geneology = register.resolveFsGenealogy(fhirSchema.url);
-    const elems = {};
-    for (const [key, elem] of Object.entries(elements)) {
-        const path = [...parentPath, key];
-        const elemGeneology = resolveFsElementGenealogy(geneology, path);
-        const elemSnapshot = fsElementSnapshot(elemGeneology);
-        elems[key] = { elem, elemSnapshot, path };
-    }
-    for (const [_key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
-        for (const choiceKey of elem?.choices || []) {
-            if (!elems[choiceKey]) {
-                const path = [...parentPath, choiceKey];
-                const elemGeneology = resolveFsElementGenealogy(geneology, path);
-                const elemSnapshot = fsElementSnapshot(elemGeneology);
-                elems[choiceKey] = { elem: undefined, elemSnapshot, path };
-            }
-        }
-    }
-    const fields = {};
-    for (const [key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
-        if (isNestedElement(elemSnapshot)) {
-            fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
-        }
-        else {
-            fields[key] = mkField(register, fhirSchema, path, elemSnapshot);
-        }
-    }
-    return fields;
-}
-function extractFieldDependencies(fields) {
-    const deps = [];
-    for (const field of Object.values(fields)) {
-        if ("type" in field && field.type) {
-            deps.push(field.type);
-        }
-        if ("binding" in field && field.binding) {
-            deps.push(field.binding);
-        }
-    }
-    return deps;
-}
-function deduplicateDependencies(deps) {
-    const seen = new Set();
-    const unique = [];
-    for (const dep of deps) {
-        const key = dep.url;
-        if (!seen.has(key)) {
-            seen.add(key);
-            unique.push(dep);
-        }
-    }
-    // Sort by name for consistent output (matching Clojure implementation)
-    unique.sort((a, b) => a.name.localeCompare(b.name));
-    return unique;
-}
-/**
- * Check if a FHIR schema represents an extension
- */
-function isExtensionSchema(fhirSchema, _identifier) {
-    // Check if this is based on Extension
-    if (fhirSchema.base === "Extension" || fhirSchema.base === "http://hl7.org/fhir/StructureDefinition/Extension") {
-        return true;
-    }
-    // Check if the URL indicates this is an extension
-    if (fhirSchema.url?.includes("/extension/") || fhirSchema.url?.includes("-extension")) {
-        return true;
-    }
-    // Check if the name indicates this is an extension
-    if (fhirSchema.name?.toLowerCase().includes("extension")) {
-        return true;
-    }
-    // Check if the type is Extension
-    if (fhirSchema.type === "Extension") {
-        return true;
-    }
-    return false;
-}
-export async function transformValueSet(register, valueSet) {
-    if (!valueSet.url)
-        throw new Error("ValueSet URL is required");
-    const identifier = mkValueSetIdentifierByUrl(register, valueSet.url);
-    const concept = extractValueSetConceptsByUrl(register, valueSet.url);
-    return {
-        identifier: identifier,
-        description: valueSet.description,
-        concept: concept,
-        compose: !concept ? valueSet.compose : undefined,
-    };
-}
-/**
- * Transform an Extension FHIRSchema to TypeSchema with extension metadata
- */
-async function transformExtension(fhirSchema, register, _packageInfo) {
-    try {
-        const identifier = mkIdentifier(fhirSchema);
-        // Build base identifier if present
-        let base;
-        if (fhirSchema.base && fhirSchema.base !== "Extension") {
-            const baseUrl = fhirSchema.base.includes("/")
-                ? fhirSchema.base
-                : `http://hl7.org/fhir/StructureDefinition/${fhirSchema.base}`;
-            const baseName = fhirSchema.base.split("/").pop() || fhirSchema.base;
-            base = {
-                kind: "complex-type",
-                package: "hl7.fhir.r4.core",
-                version: "4.0.1",
-                name: baseName,
-                url: baseUrl,
-            };
-        }
-        else {
-            // Default to Extension base
-            base = {
-                kind: "complex-type",
-                package: "hl7.fhir.r4.core",
-                version: "4.0.1",
-                name: "Extension",
-                url: "http://hl7.org/fhir/StructureDefinition/Extension",
-            };
-        }
-        const extensionSchema = {
-            identifier,
-            base,
-            description: fhirSchema.description,
-            dependencies: [],
-            metadata: {
-                isExtension: true, // Mark as extension for file organization
-            },
-        };
-        // Add base to dependencies
-        if (base) {
-            extensionSchema.dependencies.push(base);
-        }
-        // Transform elements into fields if present
-        if (fhirSchema.elements) {
-            const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
-            if (fields && Object.keys(fields).length > 0) {
-                extensionSchema.fields = fields;
-                extensionSchema.dependencies.push(...extractFieldDependencies(fields));
-            }
-        }
-        // Build nested types
-        const nestedTypes = await mkNestedTypes(register, fhirSchema);
-        if (nestedTypes && nestedTypes.length > 0) {
-            extensionSchema.nested = nestedTypes;
-            extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
-        }
-        // Deduplicate and sort dependencies
-        extensionSchema.dependencies = deduplicateDependencies(extensionSchema.dependencies);
-        // Remove self-reference from dependencies
-        extensionSchema.dependencies = extensionSchema.dependencies.filter((dep) => dep.url !== identifier.url);
-        return extensionSchema;
-    }
-    catch (error) {
-        console.warn(`Failed to transform extension ${fhirSchema.name}: ${error}`);
-        return null;
-    }
-}
-function extractDependencies(identifier, base, fields, nestedTypes) {
-    const deps = [];
-    if (base)
-        deps.push(base);
-    if (fields)
-        deps.push(...extractFieldDependencies(fields));
-    if (nestedTypes)
-        deps.push(...extractNestedDependencies(nestedTypes));
-    const uniqDeps = {};
-    for (const dep of deps) {
-        if (dep.url === identifier.url)
-            continue;
-        uniqDeps[dep.url] = dep;
-    }
-    const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
-    const result = Object.values(uniqDeps)
-        .filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url)))
-        .sort((a, b) => a.url.localeCompare(b.url));
-    return result.length > 0 ? result : undefined;
-}
-async function transformResource(register, fhirSchema) {
-    const identifier = mkIdentifier(fhirSchema);
-    let base;
-    if (fhirSchema.base && fhirSchema.type !== "Element") {
-        const baseFs = register.resolveFs(register.ensureCanonicalUrl(fhirSchema.base));
-        if (!baseFs) {
-            throw new Error(`Base resource not found '${fhirSchema.base}' for '${fhirSchema.url}'`);
-        }
-        base = mkIdentifier(baseFs);
-    }
-    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
-    const nested = await mkNestedTypes(register, fhirSchema);
-    const dependencies = extractDependencies(identifier, base, fields, nested);
-    const typeSchema = {
-        identifier,
-        base,
-        fields,
-        nested,
-        description: fhirSchema.description,
-        dependencies,
-    };
-    const bindingSchemas = await collectBindingSchemas(register, fhirSchema);
-    return [typeSchema, ...bindingSchemas];
-}
-export async function transformFHIRSchema(register, fhirSchema) {
-    const results = [];
-    const identifier = mkIdentifier(fhirSchema);
-    if (identifier.kind === "profile") {
-        const profileSchema = await transformProfile(register, fhirSchema);
-        results.push(profileSchema);
-        const bindingSchemas = await collectBindingSchemas(register, fhirSchema);
-        results.push(...bindingSchemas);
-        return results;
-    }
-    if (isExtensionSchema(fhirSchema, identifier)) {
-        const extensionSchema = await transformExtension(fhirSchema, register, fhirSchema.package_meta);
-        if (extensionSchema) {
-            results.push(extensionSchema);
-        }
-        return results;
-    }
-    return await transformResource(register, fhirSchema);
-}

package/dist/typeschema/generator.d.ts

@@ -1,43 +0,0 @@
-/**
- * TypeSchema Generator
- *
- * Generates TypeSchema documents from FHIR packages using fhrischema.
- * Provides high-level API for converting FHIR Structure Definitions to TypeSchema format.
- */
-import type { FHIRSchema, StructureDefinition } from "@atomic-ehr/fhirschema";
-import type { TypeSchemaConfig } from "@root/config";
-import type { Register } from "@typeschema/register";
-import type { PackageMeta, TypeSchema, TypeschemaGeneratorOptions } from "./types";
-/**
- * TypeSchema Generator class
- *
- * Main class for generating TypeSchema documents from FHIR packages.
- * Leverages fhrischema for FHIR parsing and canonical manager for dependency resolution.
- */
-export declare class TypeSchemaGenerator {
-    private manager;
-    private options;
-    private cacheConfig?;
-    private cache?;
-    private logger;
-    constructor(options?: TypeschemaGeneratorOptions, cacheConfig?: TypeSchemaConfig);
-    private initializeCache;
-    registerFromPackageMetas(packageMetas: PackageMeta[]): Promise<Register>;
-    generateFhirSchemas(structureDefinitions: StructureDefinition[]): FHIRSchema[];
-    generateValueSetSchemas(valueSets: any[], _packageInfo: PackageMeta): Promise<TypeSchema[]>;
-    generateFromPackage(packageName: string, packageVersion?: string): Promise<TypeSchema[]>;
-    /**
-     * Apply treeshaking to StructureDefinitions before FHIR schema transformation
-     * This is more efficient and includes smart reference handling
-     */
-    private applyStructureDefinitionTreeshaking;
-    /**
-     * Extract dependencies from StructureDefinition with smart reference handling
-     * Returns both real dependencies and reference targets separately
-     */
-    private extractStructureDefinitionDependenciesWithReferences;
-    /**
-     * Extract resource name from FHIR URL
-     */
-    private extractResourceNameFromUrl;
-}

package/dist/typeschema/generator.js

@@ -1,264 +0,0 @@
-/**
- * TypeSchema Generator
- *
- * Generates TypeSchema documents from FHIR packages using fhrischema.
- * Provides high-level API for converting FHIR Structure Definitions to TypeSchema format.
- */
-import { CanonicalManager } from "@atomic-ehr/fhir-canonical-manager";
-import * as fhirschema from "@atomic-ehr/fhirschema";
-import { createLogger } from "@root/utils/codegen-logger";
-import { registerFromManager } from "@typeschema/register";
-import { TypeSchemaCache } from "./cache";
-import { transformFHIRSchema, transformValueSet } from "./core/transformer";
-/**
- * TypeSchema Generator class
- *
- * Main class for generating TypeSchema documents from FHIR packages.
- * Leverages fhrischema for FHIR parsing and canonical manager for dependency resolution.
- */
-export class TypeSchemaGenerator {
-    manager;
-    options;
-    cacheConfig;
-    cache;
-    logger;
-    constructor(options = {}, cacheConfig) {
-        this.options = { verbose: false, ...options };
-        this.manager = options.manager || CanonicalManager({ packages: [], workingDir: "tmp/fhir" });
-        this.cacheConfig = cacheConfig;
-        this.logger =
-            options.logger ||
-                createLogger({
-                    verbose: this.options.verbose,
-                    prefix: "TypeSchema",
-                });
-    }
-    async initializeCache() {
-        if (this.cacheConfig && !this.cache) {
-            this.cache = new TypeSchemaCache(this.cacheConfig);
-            await this.cache.initialize();
-        }
-    }
-    async registerFromPackageMetas(packageMetas) {
-        const packageNames = packageMetas.map((meta) => `${meta.name}${meta.version}`);
-        this.logger.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
-        await this.manager.init();
-        return registerFromManager(this.manager);
-    }
-    generateFhirSchemas(structureDefinitions) {
-        this.logger.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
-        // TODO: do it on the TypeSchema?
-        const filteredStructureDefinitions = this.applyStructureDefinitionTreeshaking(structureDefinitions);
-        const fhirSchemas = [];
-        let convertedCount = 0;
-        let failedCount = 0;
-        for (const sd of filteredStructureDefinitions) {
-            try {
-                const fhirSchema = fhirschema.translate(sd);
-                fhirSchemas.push(fhirSchema);
-                convertedCount++;
-                this.logger.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
-            }
-            catch (error) {
-                failedCount++;
-                this.logger.warn(`Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        this.logger.success(`FHIR Schema conversion completed: ${convertedCount}/${filteredStructureDefinitions.length} successful, ${failedCount} failed`);
-        return fhirSchemas;
-    }
-    async generateValueSetSchemas(valueSets, _packageInfo) {
-        if (valueSets.length > 0) {
-            this.logger.debug(`${valueSets.length} ValueSets available for enum extraction`);
-        }
-        // Process ValueSets separately to add to TypeSchema output
-        const valueSetSchemas = [];
-        if (valueSets.length > 0) {
-            this.logger.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
-            let valueSetConvertedCount = 0;
-            let valueSetFailedCount = 0;
-            for (const vs of valueSets) {
-                try {
-                    const valueSetSchema = await transformValueSet(await registerFromManager(this.manager), vs);
-                    if (valueSetSchema) {
-                        valueSetSchemas.push(valueSetSchema);
-                        valueSetConvertedCount++;
-                        this.logger.debug(`Converted ValueSet: ${vs.name || vs.id}`);
-                    }
-                }
-                catch (error) {
-                    valueSetFailedCount++;
-                    this.logger.warn(`Failed to convert ValueSet ${vs.name || vs.id}: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-            this.logger.success(`ValueSet conversion completed: ${valueSetConvertedCount}/${valueSets.length} successful, ${valueSetFailedCount} failed`);
-        }
-        return valueSetSchemas;
-    }
-    async generateFromPackage(packageName, packageVersion) {
-        await this.initializeCache();
-        if (this.cache && !(this.cacheConfig?.forceRegenerate ?? false)) {
-            const cachedSchemas = this.cache.getByPackage(packageName);
-            if (cachedSchemas.length > 0) {
-                this.logger.info(`Using cached TypeSchemas for package: ${packageName} (${cachedSchemas.length} schemas)`);
-                return cachedSchemas;
-            }
-        }
-        const packageInfo = {
-            name: packageName,
-            version: packageVersion || "latest",
-        };
-        const register = await this.registerFromPackageMetas([packageInfo]);
-        const allSchemas = [
-            ...(await Promise.all(register.allFs().map(async (fs) => await transformFHIRSchema(register, fs)))).flat(),
-            ...(await this.generateValueSetSchemas(register.allVs(), packageInfo)),
-        ];
-        if (this.cache) {
-            for (const schema of allSchemas) {
-                await this.cache.set(schema);
-            }
-        }
-        return allSchemas;
-    }
-    // async generateResourceTypeSchemas(
-    //   fhirSchemas: RichFHIRSchema[],
-    // ): Promise<TypeSchema[]> {
-    //   this.logger.info(
-    //     `Transforming ${fhirSchemas.length} FHIR schemas to Type Schema`,
-    //   );
-    //   const typeSchemas: TypeSchema[] = [];
-    //   for (const fhirSchema of fhirSchemas) {
-    //     typeSchemas.push(
-    //       ...(await transformFHIRSchema(this.manager, fhirSchema)),
-    //     );
-    //   }
-    //   return typeSchemas;
-    // }
-    /**
-     * Apply treeshaking to StructureDefinitions before FHIR schema transformation
-     * This is more efficient and includes smart reference handling
-     */
-    applyStructureDefinitionTreeshaking(structureDefinitions) {
-        const treeshakeList = this.options.treeshake;
-        if (!treeshakeList || treeshakeList.length === 0) {
-            return structureDefinitions;
-        }
-        this.logger.info(`Applying treeshaking filter for ResourceTypes: ${treeshakeList.join(", ")}`);
-        const allStructureDefinitions = new Map();
-        const realDependencies = new Map();
-        const referenceTargets = new Map();
-        for (const sd of structureDefinitions) {
-            const name = sd.name || sd.id;
-            if (name) {
-                allStructureDefinitions.set(name, sd);
-                realDependencies.set(name, new Set());
-                referenceTargets.set(name, new Set());
-            }
-        }
-        for (const sd of structureDefinitions) {
-            const name = sd.name || sd.id;
-            if (!name)
-                continue;
-            const { realDeps, refTargets } = this.extractStructureDefinitionDependenciesWithReferences(sd);
-            realDependencies.set(name, new Set(realDeps));
-            referenceTargets.set(name, new Set(refTargets));
-        }
-        const structureDefinitionsToKeep = new Set();
-        for (const resourceType of treeshakeList) {
-            if (allStructureDefinitions.has(resourceType)) {
-                structureDefinitionsToKeep.add(resourceType);
-            }
-            else {
-                this.logger.warn(`ResourceType '${resourceType}' not found in structure definitions`);
-            }
-        }
-        const addRealDependenciesRecursively = (name, visited = new Set()) => {
-            if (visited.has(name) || !realDependencies.has(name)) {
-                return;
-            }
-            visited.add(name);
-            const deps = realDependencies.get(name) || new Set();
-            for (const dep of Array.from(deps)) {
-                if (allStructureDefinitions.has(dep)) {
-                    structureDefinitionsToKeep.add(dep);
-                    addRealDependenciesRecursively(dep, visited);
-                }
-            }
-        };
-        for (const resourceType of Array.from(structureDefinitionsToKeep)) {
-            addRealDependenciesRecursively(resourceType);
-        }
-        const filteredStructureDefinitions = structureDefinitions.filter((sd) => {
-            const name = sd.name || sd.id;
-            return name && structureDefinitionsToKeep.has(name);
-        });
-        const excludedReferenceTargets = new Set();
-        for (const sd of structureDefinitions) {
-            const name = sd.name || sd.id;
-            if (name && !structureDefinitionsToKeep.has(name)) {
-                const isOnlyReferenceTarget = Array.from(referenceTargets.values()).some((targets) => targets.has(name));
-                if (isOnlyReferenceTarget) {
-                    excludedReferenceTargets.add(name);
-                }
-            }
-        }
-        if (excludedReferenceTargets.size > 0) {
-            this.logger.info(`Excluded reference-only targets: ${Array.from(excludedReferenceTargets).join(", ")}`);
-        }
-        this.logger.success(`Treeshaking completed: kept ${filteredStructureDefinitions.length}/${structureDefinitions.length} structure definitions`);
-        return filteredStructureDefinitions;
-    }
-    /**
-     * Extract dependencies from StructureDefinition with smart reference handling
-     * Returns both real dependencies and reference targets separately
-     */
-    extractStructureDefinitionDependenciesWithReferences(sd) {
-        const realDeps = new Set();
-        const refTargets = new Set();
-        if (sd.baseDefinition) {
-            const baseName = this.extractResourceNameFromUrl(sd.baseDefinition);
-            if (baseName) {
-                realDeps.add(baseName);
-            }
-        }
-        if (sd.snapshot?.element || sd.differential?.element) {
-            const elements = sd.snapshot?.element || sd.differential?.element;
-            for (const element of elements) {
-                if (element.type) {
-                    for (const type of element.type) {
-                        if (type.code) {
-                            realDeps.add(type.code);
-                            if (type.code === "Reference" && type.targetProfile) {
-                                for (const targetProfile of type.targetProfile) {
-                                    const targetName = this.extractResourceNameFromUrl(targetProfile);
-                                    if (targetName) {
-                                        refTargets.add(targetName);
-                                    }
-                                }
-                            }
-                        }
-                        if (type.profile) {
-                            for (const profile of type.profile) {
-                                const profileName = this.extractResourceNameFromUrl(profile);
-                                if (profileName) {
-                                    realDeps.add(profileName);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return {
-            realDeps: Array.from(realDeps),
-            refTargets: Array.from(refTargets),
-        };
-    }
-    /**
-     * Extract resource name from FHIR URL
-     */
-    extractResourceNameFromUrl(url) {
-        const match = url.match(/\/([^/]+)$/);
-        return match ? (match[1] ?? null) : null;
-    }
-}

package/dist/typeschema/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * TypeSchema Core Module
- *
- * Main entry point for the TypeSchema library providing core functions
- * for FHIR-to-TypeSchema generation, parsing, and validation.
- *
- * This module focuses on:
- * - Converting FHIR to TypeSchema format
- * - Reading TypeSchema documents
- * - Validating TypeSchema documents
- */
-export { TypeSchemaCache } from "./cache";
-export { TypeSchemaGenerator } from "./generator";
-export { TypeSchemaParser } from "./parser";
-export type { Identifier, TypeSchema } from "./types";

package/dist/typeschema/index.js

@@ -1,15 +0,0 @@
-/**
- * TypeSchema Core Module
- *
- * Main entry point for the TypeSchema library providing core functions
- * for FHIR-to-TypeSchema generation, parsing, and validation.
- *
- * This module focuses on:
- * - Converting FHIR to TypeSchema format
- * - Reading TypeSchema documents
- * - Validating TypeSchema documents
- */
-// Re-export core dependencies
-export { TypeSchemaCache } from "./cache";
-export { TypeSchemaGenerator } from "./generator";
-export { TypeSchemaParser } from "./parser";