eventmodeler 0.5.0 → 0.6.1

package/dist/slices/show-actor/index.js

@@ -1,115 +0,0 @@
-import { escapeXml, outputJson } from '../../lib/format.js';
-import { findElementOrExit } from '../../lib/element-lookup.js';
-// Get screens whose center point is inside the actor bounds
-function getScreensInActor(model, actor) {
-    const bounds = {
-        left: actor.position.x,
-        right: actor.position.x + actor.size.width,
-        top: actor.position.y,
-        bottom: actor.position.y + actor.size.height,
-    };
-    function isInActor(pos, width, height) {
-        const centerX = pos.x + width / 2;
-        const centerY = pos.y + height / 2;
-        return centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
-    }
-    return [...model.screens.values()].filter(s => isInActor(s.position, s.width, s.height));
-}
-// Find which slice contains a screen
-function findSliceForScreen(model, screen) {
-    for (const slice of model.slices.values()) {
-        const centerX = screen.position.x + screen.width / 2;
-        const centerY = screen.position.y + screen.height / 2;
-        if (centerX >= slice.position.x &&
-            centerX <= slice.position.x + slice.size.width &&
-            centerY >= slice.position.y &&
-            centerY <= slice.position.y + slice.size.height) {
-            return slice.name;
-        }
-    }
-    return null;
-}
-export function showActor(model, actorName, format) {
-    // Find the actor
-    const actor = findElementOrExit(model.actors, actorName, 'actor');
-    // Get screens dynamically based on position (center point inside actor bounds)
-    const screensInActor = getScreensInActor(model, actor);
-    if (format === 'json') {
-        outputJson({
-            id: actor.id,
-            name: actor.name,
-            screensCount: screensInActor.length,
-            screens: screensInActor.map(screen => {
-                const result = {
-                    id: screen.id,
-                    name: screen.name,
-                    fields: screen.fields.length
-                };
-                if (screen.originalNodeId) {
-                    result.linkedCopy = true;
-                    const original = model.screens.get(screen.originalNodeId);
-                    const originSlice = original ? findSliceForScreen(model, original) : null;
-                    if (originSlice)
-                        result.originSlice = originSlice;
-                }
-                return result;
-            })
-        });
-        return;
-    }
-    console.log(`<actor id="${actor.id}" name="${escapeXml(actor.name)}">`);
-    console.log(`  <screens-count>${screensInActor.length}</screens-count>`);
-    if (screensInActor.length > 0) {
-        console.log('  <screens>');
-        for (const screen of screensInActor) {
-            const fieldCount = screen.fields.length;
-            if (screen.originalNodeId) {
-                // This is a linked copy - show origin info
-                const original = model.screens.get(screen.originalNodeId);
-                const originSlice = original ? findSliceForScreen(model, original) : null;
-                const originAttr = originSlice ? ` origin-slice="${escapeXml(originSlice)}"` : '';
-                console.log(`    <screen id="${screen.id}" name="${escapeXml(screen.name)}" fields="${fieldCount}" linked-copy="true"${originAttr}/>`);
-            }
-            else {
-                console.log(`    <screen id="${screen.id}" name="${escapeXml(screen.name)}" fields="${fieldCount}"/>`);
-            }
-        }
-        console.log('  </screens>');
-    }
-    console.log('</actor>');
-}
-export function listActors(model, format) {
-    const actors = [...model.actors.values()];
-    if (format === 'json') {
-        outputJson({
-            actors: actors.map(actor => {
-                const screensInActor = getScreensInActor(model, actor);
-                const originalCount = screensInActor.filter(s => !s.originalNodeId).length;
-                const copyCount = screensInActor.filter(s => s.originalNodeId).length;
-                const result = {
-                    id: actor.id,
-                    name: actor.name,
-                    screens: originalCount
-                };
-                if (copyCount > 0)
-                    result.copies = copyCount;
-                return result;
-            })
-        });
-        return;
-    }
-    if (actors.length === 0) {
-        console.log('<actors/>');
-        return;
-    }
-    console.log('<actors>');
-    for (const actor of actors) {
-        // Calculate screens dynamically based on position
-        const screensInActor = getScreensInActor(model, actor);
-        const originalCount = screensInActor.filter(s => !s.originalNodeId).length;
-        const copyCount = screensInActor.filter(s => s.originalNodeId).length;
-        const copiesAttr = copyCount > 0 ? ` copies="${copyCount}"` : '';
-        console.log(`  <actor id="${actor.id}" name="${escapeXml(actor.name)}" screens="${originalCount}"${copiesAttr}/>`);
-    }
-    console.log('</actors>');
-}

package/dist/slices/show-aggregate/index.d.ts

@@ -1,3 +0,0 @@
-import type { EventModel } from '../../types.js';
-import { type OutputFormat } from '../../lib/format.js';
-export declare function showAggregate(model: EventModel, name: string, format: OutputFormat): void;

package/dist/slices/show-aggregate/index.js

@@ -1,108 +0,0 @@
-import { escapeXml, outputJson } from '../../lib/format.js';
-import { findElementOrExit } from '../../lib/element-lookup.js';
-// Get events whose center point is inside the aggregate bounds
-function getEventsInAggregate(model, aggregate) {
-    const bounds = {
-        left: aggregate.position.x,
-        right: aggregate.position.x + aggregate.size.width,
-        top: aggregate.position.y,
-        bottom: aggregate.position.y + aggregate.size.height,
-    };
-    function isInAggregate(pos, width, height) {
-        const centerX = pos.x + width / 2;
-        const centerY = pos.y + height / 2;
-        return centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
-    }
-    // Filter out linked copies
-    return [...model.events.values()].filter(e => !e.originalNodeId && isInAggregate(e.position, e.width, e.height));
-}
-// Check if an event has the aggregate's ID field
-function hasIdField(event, aggregate) {
-    if (!aggregate.aggregateIdFieldName) {
-        return { has: false };
-    }
-    const field = event.fields.find(f => f.name === aggregate.aggregateIdFieldName);
-    if (!field) {
-        return { has: false };
-    }
-    // Check if field type matches (if aggregate has a configured type)
-    if (aggregate.aggregateIdFieldType && field.fieldType !== aggregate.aggregateIdFieldType) {
-        return { has: true, fieldType: field.fieldType };
-    }
-    return { has: true, fieldType: field.fieldType };
-}
-export function showAggregate(model, name, format) {
-    const aggregate = findElementOrExit(model.aggregates, name, 'aggregate');
-    const events = getEventsInAggregate(model, aggregate);
-    // Check ID field status for each event
-    const eventsWithStatus = events.map(event => {
-        const idStatus = hasIdField(event, aggregate);
-        return {
-            event,
-            hasIdField: idStatus.has,
-            fieldType: idStatus.fieldType
-        };
-    });
-    // Calculate overall ID field completeness
-    const hasIdFieldConfig = !!aggregate.aggregateIdFieldName;
-    const eventsWithId = eventsWithStatus.filter(e => e.hasIdField).length;
-    const completeness = hasIdFieldConfig && events.length > 0
-        ? `${eventsWithId}/${events.length}`
-        : undefined;
-    if (format === 'json') {
-        const result = {
-            id: aggregate.id,
-            name: aggregate.name,
-            eventsCount: events.length
-        };
-        if (aggregate.aggregateIdFieldName) {
-            result.idField = {
-                name: aggregate.aggregateIdFieldName,
-                type: aggregate.aggregateIdFieldType ?? 'any'
-            };
-            result.idFieldCompleteness = completeness;
-        }
-        result.events = eventsWithStatus.map(({ event, hasIdField, fieldType }) => {
-            const eventResult = {
-                id: event.id,
-                name: event.name,
-                fieldsCount: event.fields.length
-            };
-            if (hasIdFieldConfig) {
-                eventResult.hasIdField = hasIdField;
-                if (hasIdField && fieldType && fieldType !== aggregate.aggregateIdFieldType) {
-                    eventResult.idFieldType = fieldType;
-                    eventResult.typeMatch = false;
-                }
-            }
-            return eventResult;
-        });
-        outputJson(result);
-        return;
-    }
-    // XML output
-    console.log(`<aggregate id="${aggregate.id}" name="${escapeXml(aggregate.name)}">`);
-    console.log(`  <events-count>${events.length}</events-count>`);
-    if (aggregate.aggregateIdFieldName) {
-        const typeAttr = aggregate.aggregateIdFieldType ? ` type="${aggregate.aggregateIdFieldType}"` : '';
-        console.log(`  <id-field name="${escapeXml(aggregate.aggregateIdFieldName)}"${typeAttr}/>`);
-        if (completeness) {
-            console.log(`  <id-field-completeness>${completeness}</id-field-completeness>`);
-        }
-    }
-    if (events.length > 0) {
-        console.log('  <events>');
-        for (const { event, hasIdField, fieldType } of eventsWithStatus) {
-            let attrs = `id="${event.id}" name="${escapeXml(event.name)}" fields="${event.fields.length}"`;
-            if (hasIdFieldConfig) {
-                attrs += ` has-id-field="${hasIdField}"`;
-                if (hasIdField && fieldType && fieldType !== aggregate.aggregateIdFieldType) {
-                    attrs += ` id-field-type="${fieldType}" type-match="false"`;
-                }
-            }
-            console.log(`    <event ${attrs}/>`);
-        }
-        console.log('  </events>');
-    }
-    console.log('</aggregate>');
-}

package/dist/slices/show-aggregate-completeness/index.d.ts

@@ -1,4 +0,0 @@
-import type { EventModel } from '../../types.js';
-import { type OutputFormat } from '../../lib/format.js';
-export declare function showAggregateCompleteness(model: EventModel, aggregateName: string, format: OutputFormat): void;
-export declare function listAggregates(model: EventModel, format: OutputFormat): void;

package/dist/slices/show-aggregate-completeness/index.js

@@ -1,181 +0,0 @@
-import { escapeXml, outputJson } from '../../lib/format.js';
-import { findElementOrExit } from '../../lib/element-lookup.js';
-function findMatchingField(fields, targetName, targetType) {
-    for (const field of fields) {
-        // Check if name and type match
-        if (field.name.toLowerCase() === targetName.toLowerCase() && field.fieldType === targetType) {
-            return field;
-        }
-        // Check nested subfields
-        if (field.fieldType === 'Custom' && field.subfields) {
-            const nested = findMatchingField(field.subfields, targetName, targetType);
-            if (nested)
-                return nested;
-        }
-    }
-    return undefined;
-}
-// Get events whose center point is inside the aggregate bounds
-// Only returns original events, not linked copies (linked copies have originalNodeId set)
-function getEventsInAggregate(model, aggregate) {
-    const bounds = {
-        left: aggregate.position.x,
-        right: aggregate.position.x + aggregate.size.width,
-        top: aggregate.position.y,
-        bottom: aggregate.position.y + aggregate.size.height,
-    };
-    function isInAggregate(pos, width, height) {
-        const centerX = pos.x + width / 2;
-        const centerY = pos.y + height / 2;
-        return centerX >= bounds.left && centerX <= bounds.right && centerY >= bounds.top && centerY <= bounds.bottom;
-    }
-    // Filter out linked copies - only return original events
-    // Linked copies have originalNodeId set, originals do not
-    return [...model.events.values()].filter(e => !e.originalNodeId && isInAggregate(e.position, e.width, e.height));
-}
-export function showAggregateCompleteness(model, aggregateName, format) {
-    // Find the aggregate
-    const aggregate = findElementOrExit(model.aggregates, aggregateName, 'aggregate');
-    // Get events dynamically based on position (center point inside aggregate bounds)
-    const eventsInAggregate = getEventsInAggregate(model, aggregate);
-    // Check if aggregate has ID field configured
-    if (!aggregate.aggregateIdFieldName || !aggregate.aggregateIdFieldType) {
-        if (format === 'json') {
-            outputJson({
-                aggregate: aggregate.name,
-                status: 'unconfigured',
-                eventsCount: eventsInAggregate.length,
-                events: eventsInAggregate.map(e => ({ id: e.id, name: e.name })),
-                message: 'Aggregate ID field not configured. Set aggregateIdFieldName and aggregateIdFieldType.'
-            });
-            return;
-        }
-        console.log(`<aggregate-completeness aggregate="${escapeXml(aggregate.name)}" status="unconfigured">`);
-        console.log(`  <events-count>${eventsInAggregate.length}</events-count>`);
-        console.log('  <events>');
-        for (const event of eventsInAggregate) {
-            console.log(`    <event id="${event.id}" name="${escapeXml(event.name)}"/>`);
-        }
-        console.log('  </events>');
-        console.log('  <message>Aggregate ID field not configured. Set aggregateIdFieldName and aggregateIdFieldType.</message>');
-        console.log('</aggregate-completeness>');
-        return;
-    }
-    const idFieldName = aggregate.aggregateIdFieldName;
-    const idFieldType = aggregate.aggregateIdFieldType;
-    if (eventsInAggregate.length === 0) {
-        if (format === 'json') {
-            outputJson({
-                aggregate: aggregate.name,
-                status: 'empty',
-                idField: { name: idFieldName, type: idFieldType },
-                message: 'No events in this aggregate.'
-            });
-            return;
-        }
-        console.log(`<aggregate-completeness aggregate="${escapeXml(aggregate.name)}" status="empty">`);
-        console.log(`  <id-field name="${escapeXml(idFieldName)}" type="${idFieldType}"/>`);
-        console.log('  <message>No events in this aggregate.</message>');
-        console.log('</aggregate-completeness>');
-        return;
-    }
-    // Check each event for the ID field
-    const eventResults = [];
-    for (const event of eventsInAggregate) {
-        const matchingField = findMatchingField(event.fields, idFieldName, idFieldType);
-        eventResults.push({
-            eventId: event.id,
-            eventName: event.name,
-            hasIdField: !!matchingField,
-            matchingField: matchingField ? {
-                fieldId: matchingField.id,
-                fieldName: matchingField.name,
-                fieldType: matchingField.fieldType,
-            } : undefined,
-        });
-    }
-    const completeEvents = eventResults.filter(e => e.hasIdField);
-    const incompleteEvents = eventResults.filter(e => !e.hasIdField);
-    const isComplete = incompleteEvents.length === 0;
-    const overallStatus = isComplete ? 'complete' : 'incomplete';
-    const completionPercent = eventResults.length > 0
-        ? Math.round((completeEvents.length / eventResults.length) * 100)
-        : 100;
-    if (format === 'json') {
-        outputJson({
-            aggregate: aggregate.name,
-            status: overallStatus,
-            completion: `${completionPercent}%`,
-            idField: { name: idFieldName, type: idFieldType },
-            summary: {
-                total: eventResults.length,
-                complete: completeEvents.length,
-                incomplete: incompleteEvents.length
-            },
-            incompleteEvents: incompleteEvents.map(e => ({ id: e.eventId, name: e.eventName })),
-            completeEvents: completeEvents.map(e => ({
-                id: e.eventId,
-                name: e.eventName,
-                fieldId: e.matchingField?.fieldId
-            }))
-        });
-        return;
-    }
-    console.log(`<aggregate-completeness aggregate="${escapeXml(aggregate.name)}" status="${overallStatus}" completion="${completionPercent}%">`);
-    console.log(`  <id-field name="${escapeXml(idFieldName)}" type="${idFieldType}"/>`);
-    console.log(`  <summary total="${eventResults.length}" complete="${completeEvents.length}" incomplete="${incompleteEvents.length}"/>`);
-    if (incompleteEvents.length > 0) {
-        console.log('  <incomplete-events>');
-        for (const event of incompleteEvents) {
-            console.log(`    <event id="${event.eventId}" name="${escapeXml(event.eventName)}"/>`);
-        }
-        console.log('  </incomplete-events>');
-    }
-    if (completeEvents.length > 0) {
-        console.log('  <complete-events>');
-        for (const event of completeEvents) {
-            const fieldAttr = event.matchingField
-                ? ` field-id="${event.matchingField.fieldId}"`
-                : '';
-            console.log(`    <event id="${event.eventId}" name="${escapeXml(event.eventName)}"${fieldAttr}/>`);
-        }
-        console.log('  </complete-events>');
-    }
-    console.log('</aggregate-completeness>');
-}
-export function listAggregates(model, format) {
-    const aggregates = [...model.aggregates.values()];
-    if (format === 'json') {
-        outputJson({
-            aggregates: aggregates.map(aggregate => {
-                const eventsInAggregate = getEventsInAggregate(model, aggregate);
-                const result = {
-                    id: aggregate.id,
-                    name: aggregate.name,
-                    events: eventsInAggregate.length
-                };
-                if (aggregate.aggregateIdFieldName) {
-                    result.idField = aggregate.aggregateIdFieldName;
-                    result.idType = aggregate.aggregateIdFieldType ?? 'Unknown';
-                }
-                return result;
-            })
-        });
-        return;
-    }
-    if (aggregates.length === 0) {
-        console.log('<aggregates/>');
-        return;
-    }
-    console.log('<aggregates>');
-    for (const aggregate of aggregates) {
-        // Calculate events dynamically based on position
-        const eventsInAggregate = getEventsInAggregate(model, aggregate);
-        const eventCount = eventsInAggregate.length;
-        const idFieldAttr = aggregate.aggregateIdFieldName
-            ? ` idField="${escapeXml(aggregate.aggregateIdFieldName)}" idType="${aggregate.aggregateIdFieldType ?? 'Unknown'}"`
-            : '';
-        console.log(`  <aggregate id="${aggregate.id}" name="${escapeXml(aggregate.name)}" events="${eventCount}"${idFieldAttr}/>`);
-    }
-    console.log('</aggregates>');
-}

package/dist/slices/show-chapter/index.d.ts

@@ -1,3 +0,0 @@
-import type { EventModel } from '../../types.js';
-import { type OutputFormat } from '../../lib/format.js';
-export declare function showChapter(model: EventModel, name: string, format: OutputFormat): void;

package/dist/slices/show-chapter/index.js

@@ -1,195 +0,0 @@
-import { escapeXml, outputJson } from '../../lib/format.js';
-import { findElementOrExit } from '../../lib/element-lookup.js';
-import { getChapterHierarchy, findChapterForSlice } from '../../lib/chapter-utils.js';
-import { findSliceToSliceFlows, findChapterInboundFlows, findChapterOutboundFlows, } from '../../lib/flow-utils.js';
-function getSlicesUnderChapter(model, chapter) {
-    // A slice is "under" a chapter if its horizontal center falls within the chapter's x range
-    const chapterLeft = chapter.position.x;
-    const chapterRight = chapter.position.x + chapter.size.width;
-    return [...model.slices.values()].filter(slice => {
-        const sliceCenterX = slice.position.x + slice.size.width / 2;
-        return sliceCenterX >= chapterLeft && sliceCenterX <= chapterRight;
-    }).sort((a, b) => a.position.x - b.position.x);
-}
-function formatSliceFlowXml(sliceFlow) {
-    let xml = `    <slice-flow from="${escapeXml(sliceFlow.fromSlice.name)}" to="${escapeXml(sliceFlow.toSlice.name)}">\n`;
-    for (const flow of sliceFlow.flows) {
-        xml += `      <via type="${flow.flowType}">\n`;
-        xml += `        <source element="${escapeXml(flow.source.name)}" type="${flow.source.type}"/>\n`;
-        xml += `        <target element="${escapeXml(flow.target.name)}" type="${flow.target.type}"/>\n`;
-        if (flow.fieldMappings.length > 0) {
-            xml += '        <mappings>\n';
-            for (const mapping of flow.fieldMappings) {
-                xml += `          <map from="${escapeXml(mapping.from)}" to="${escapeXml(mapping.to)}"/>\n`;
-            }
-            xml += '        </mappings>\n';
-        }
-        xml += '      </via>\n';
-    }
-    xml += '    </slice-flow>\n';
-    return xml;
-}
-function formatExternalFlowXml(flow, direction, model) {
-    let xml = `      <flow ${direction === 'inbound' ? `to-slice="${escapeXml(flow.targetSlice?.name ?? 'unknown')}"` : `from-slice="${escapeXml(flow.sourceSlice?.name ?? 'unknown')}"`} type="${flow.flowType}">\n`;
-    // For inbound: source is external, for outbound: target is external
-    if (direction === 'inbound') {
-        // Find the chapter of the external source
-        const sourceSlice = flow.sourceSlice;
-        let chapterInfo = '';
-        if (sourceSlice) {
-            const sourceSliceObj = model.slices.get(sourceSlice.id);
-            if (sourceSliceObj) {
-                const sourceChapter = findChapterForSlice(model, sourceSliceObj);
-                if (sourceChapter) {
-                    chapterInfo = ` chapter="${escapeXml(sourceChapter.name)}"`;
-                }
-            }
-        }
-        xml += `        <from external="true"${chapterInfo}>${escapeXml(flow.source.name)} (${flow.source.type})</from>\n`;
-        xml += `        <to>${escapeXml(flow.target.name)} (${flow.target.type})</to>\n`;
-    }
-    else {
-        xml += `        <from>${escapeXml(flow.source.name)} (${flow.source.type})</from>\n`;
-        // Find the chapter of the external target
-        const targetSlice = flow.targetSlice;
-        let chapterInfo = '';
-        if (targetSlice) {
-            const targetSliceObj = model.slices.get(targetSlice.id);
-            if (targetSliceObj) {
-                const targetChapter = findChapterForSlice(model, targetSliceObj);
-                if (targetChapter) {
-                    chapterInfo = ` chapter="${escapeXml(targetChapter.name)}"`;
-                }
-            }
-        }
-        xml += `        <to external="true"${chapterInfo}>${escapeXml(flow.target.name)} (${flow.target.type})</to>\n`;
-    }
-    if (flow.fieldMappings.length > 0) {
-        xml += '        <mappings>\n';
-        for (const mapping of flow.fieldMappings) {
-            xml += `          <map from="${escapeXml(mapping.from)}" to="${escapeXml(mapping.to)}"/>\n`;
-        }
-        xml += '        </mappings>\n';
-    }
-    xml += '      </flow>\n';
-    return xml;
-}
-export function showChapter(model, name, format) {
-    const chapter = findElementOrExit(model.chapters, name, 'chapter');
-    const slices = getSlicesUnderChapter(model, chapter);
-    // Get flow information
-    const sliceToSliceFlows = findSliceToSliceFlows(model, slices);
-    const chapterInboundFlows = findChapterInboundFlows(model, slices);
-    const chapterOutboundFlows = findChapterOutboundFlows(model, slices);
-    if (format === 'json') {
-        const result = {
-            id: chapter.id,
-            name: chapter.name,
-            parent: chapter ? getChapterHierarchy(model, chapter).parent : undefined,
-            slices: slices.map(s => ({ id: s.id, name: s.name, status: s.status }))
-        };
-        // Add flow graph if there are slice-to-slice flows
-        if (sliceToSliceFlows.length > 0) {
-            result.flowGraph = sliceToSliceFlows.map(sf => ({
-                from: sf.fromSlice.name,
-                to: sf.toSlice.name,
-                flows: sf.flows.map(f => ({
-                    type: f.flowType,
-                    source: { element: f.source.name, type: f.source.type },
-                    target: { element: f.target.name, type: f.target.type },
-                    ...(f.fieldMappings.length > 0 && {
-                        mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
-                    })
-                }))
-            }));
-        }
-        // Add external dependencies
-        if (chapterInboundFlows.length > 0 || chapterOutboundFlows.length > 0) {
-            result.externalDependencies = {
-                ...(chapterInboundFlows.length > 0 && {
-                    inbound: chapterInboundFlows.map(f => {
-                        const sourceSliceObj = f.sourceSlice ? model.slices.get(f.sourceSlice.id) : null;
-                        const sourceChapter = sourceSliceObj ? findChapterForSlice(model, sourceSliceObj) : null;
-                        return {
-                            toSlice: f.targetSlice?.name,
-                            type: f.flowType,
-                            from: {
-                                element: f.source.name,
-                                type: f.source.type,
-                                slice: f.sourceSlice?.name,
-                                chapter: sourceChapter?.name
-                            },
-                            to: { element: f.target.name, type: f.target.type },
-                            ...(f.fieldMappings.length > 0 && {
-                                mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
-                            })
-                        };
-                    })
-                }),
-                ...(chapterOutboundFlows.length > 0 && {
-                    outbound: chapterOutboundFlows.map(f => {
-                        const targetSliceObj = f.targetSlice ? model.slices.get(f.targetSlice.id) : null;
-                        const targetChapter = targetSliceObj ? findChapterForSlice(model, targetSliceObj) : null;
-                        return {
-                            fromSlice: f.sourceSlice?.name,
-                            type: f.flowType,
-                            from: { element: f.source.name, type: f.source.type },
-                            to: {
-                                element: f.target.name,
-                                type: f.target.type,
-                                slice: f.targetSlice?.name,
-                                chapter: targetChapter?.name
-                            },
-                            ...(f.fieldMappings.length > 0 && {
-                                mappings: f.fieldMappings.map(m => ({ from: m.from, to: m.to }))
-                            })
-                        };
-                    })
-                })
-            };
-        }
-        outputJson(result);
-        return;
-    }
-    // XML format
-    console.log(`<chapter id="${chapter.id}" name="${escapeXml(chapter.name)}">`);
-    // Slices section
-    if (slices.length === 0) {
-        console.log('  <slices/>');
-    }
-    else {
-        console.log('  <slices>');
-        for (const slice of slices) {
-            console.log(`    <slice id="${slice.id}" name="${escapeXml(slice.name)}" status="${slice.status}"/>`);
-        }
-        console.log('  </slices>');
-    }
-    // Flow graph section
-    if (sliceToSliceFlows.length > 0) {
-        console.log('  <flow-graph>');
-        for (const sliceFlow of sliceToSliceFlows) {
-            process.stdout.write(formatSliceFlowXml(sliceFlow));
-        }
-        console.log('  </flow-graph>');
-    }
-    // External dependencies section
-    if (chapterInboundFlows.length > 0 || chapterOutboundFlows.length > 0) {
-        console.log('  <external-dependencies>');
-        if (chapterInboundFlows.length > 0) {
-            console.log('    <inbound>');
-            for (const flow of chapterInboundFlows) {
-                process.stdout.write(formatExternalFlowXml(flow, 'inbound', model));
-            }
-            console.log('    </inbound>');
-        }
-        if (chapterOutboundFlows.length > 0) {
-            console.log('    <outbound>');
-            for (const flow of chapterOutboundFlows) {
-                process.stdout.write(formatExternalFlowXml(flow, 'outbound', model));
-            }
-            console.log('    </outbound>');
-        }
-        console.log('  </external-dependencies>');
-    }
-    console.log('</chapter>');
-}

package/dist/slices/show-command/index.d.ts

@@ -1,3 +0,0 @@
-import type { EventModel } from '../../types.js';
-import { type OutputFormat } from '../../lib/format.js';
-export declare function showCommand(model: EventModel, name: string, format: OutputFormat): void;