@baseplate-dev/sync/dist/generators/build-generator-entry.js

Library for syncing Baseplate descriptions

import { findGeneratorPackageName } from './find-generator-package-name.js';
async function buildGeneratorEntryRecursive(id, bundle, packageNameCache) {
    const { children, scopes, tasks, directory, name, instanceName, preRegisteredPhases, } = bundle;
    // Get the package name for this generator
    const packageName = await findGeneratorPackageName(directory, packageNameCache);
    const prefixedName = `${packageName}#${name}`;
    const generatorInfo = {
        name: prefixedName,
        baseDirectory: directory,
        instanceName,
    };
    const taskEntries = Object.entries(tasks)
        .filter(([, task]) => task !== undefined)
        .map(([taskName, task]) => ({
        id: `${id}#${taskName}`,
        name: taskName,
        task: task,
        generatorId: id,
        generatorInfo,
    }));
    // recursively build children generator entries
    const builtChildEntries = await Promise.all(Object.entries(children).map(async ([key, value]) => {
        const childId = `${id}.${key}`;
        const isMultiple = Array.isArray(value);
        const children = isMultiple ? value : [value];
        const childEntries = await Promise.all(children
            .filter((child) => child !== undefined)
            .map(async (child, idx) => {
            if (isMultiple && !child.instanceName) {
                throw new Error(`Child generator ${id}.${key}.${idx} of type ${child.name} must have an instance name if in a list of children`);
            }
            const subChildId = isMultiple
                ? `${id}.${key}.${child.instanceName}`
                : childId;
            return buildGeneratorEntryRecursive(subChildId, child, packageNameCache);
        }));
        // check if any child entries have the same id
        const entryIds = childEntries.map((entry) => entry.id);
        const uniqueEntryIds = new Set(entryIds);
        if (uniqueEntryIds.size !== entryIds.length) {
            throw new Error(`Duplicate child generator IDs found (likely duplicate generator instance names): ${entryIds.join(', ')}`);
        }
        return childEntries;
    }));
    return {
        id,
        scopes,
        children: builtChildEntries.flat(),
        tasks: taskEntries,
        generatorInfo,
        preRegisteredPhases: preRegisteredPhases ?? [],
    };
}
export async function buildGeneratorEntry(bundle) {
    const packageNameCache = new Map();
    return buildGeneratorEntryRecursive('root', bundle, packageNameCache);
}
//# sourceMappingURL=build-generator-entry.js.map