eventmodeler 0.5.0 → 0.6.0

package/dist/slices/create-state-change-slice/index.js

@@ -1,263 +0,0 @@
-import { appendEvent } from '../../lib/file-loader.js';
-import { STATE_CHANGE_SLICE, SLICE_GAP, calculateSlicePosition, validateSliceNameUnique, inferFieldMappings, parseFieldsFromXml, getSlicesToShift, fieldInputToField, } from '../../lib/slice-utils.js';
-function getAttr(attrs, name) {
-    const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
-    return match ? match[1] : undefined;
-}
-function parseXmlInput(xml) {
-    // Parse <state-change-slice name="..." after="..." before="...">
-    const sliceMatch = xml.match(/<state-change-slice([^>]*)>/);
-    if (!sliceMatch) {
-        throw new Error('Invalid XML: missing <state-change-slice> tag');
-    }
-    const sliceName = getAttr(sliceMatch[1], 'name');
-    if (!sliceName) {
-        throw new Error('Invalid XML: state-change-slice must have a name attribute');
-    }
-    const after = getAttr(sliceMatch[1], 'after');
-    const before = getAttr(sliceMatch[1], 'before');
-    // Parse screen
-    const screenMatch = xml.match(/<screen([^>]*)>([\s\S]*?)<\/screen>/);
-    if (!screenMatch) {
-        throw new Error('Invalid XML: missing <screen> element');
-    }
-    const screenName = getAttr(screenMatch[1], 'name');
-    if (!screenName) {
-        throw new Error('Invalid XML: screen must have a name attribute');
-    }
-    const screenFields = parseFieldsFromXml(screenMatch[2]);
-    // Parse command
-    const commandMatch = xml.match(/<command([^>]*)>([\s\S]*?)<\/command>/);
-    if (!commandMatch) {
-        throw new Error('Invalid XML: missing <command> element');
-    }
-    const commandName = getAttr(commandMatch[1], 'name');
-    if (!commandName) {
-        throw new Error('Invalid XML: command must have a name attribute');
-    }
-    const commandFields = parseFieldsFromXml(commandMatch[2]);
-    // Parse event
-    const eventMatch = xml.match(/<event([^>]*)>([\s\S]*?)<\/event>/);
-    if (!eventMatch) {
-        throw new Error('Invalid XML: missing <event> element');
-    }
-    const eventName = getAttr(eventMatch[1], 'name');
-    if (!eventName) {
-        throw new Error('Invalid XML: event must have a name attribute');
-    }
-    const eventFields = parseFieldsFromXml(eventMatch[2]);
-    return {
-        sliceName,
-        after,
-        before,
-        screen: { name: screenName, fields: screenFields },
-        command: { name: commandName, fields: commandFields },
-        event: { name: eventName, fields: eventFields },
-    };
-}
-export function createStateChangeSlice(model, filePath, xmlInput) {
-    // Parse input
-    let input;
-    try {
-        input = parseXmlInput(xmlInput);
-    }
-    catch (err) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
-    }
-    // Validate slice name is unique
-    try {
-        validateSliceNameUnique(model, input.sliceName);
-    }
-    catch (err) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
-    }
-    // Calculate position
-    let slicePosition;
-    try {
-        slicePosition = calculateSlicePosition(model, STATE_CHANGE_SLICE.width, {
-            after: input.after,
-            before: input.before,
-        });
-    }
-    catch (err) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
-    }
-    // Handle "before" positioning - shift existing slices
-    if (input.before) {
-        const shiftAmount = STATE_CHANGE_SLICE.width + SLICE_GAP;
-        const toShift = getSlicesToShift(model, slicePosition.x, shiftAmount);
-        for (const { sliceId, newX, currentY } of toShift) {
-            appendEvent(filePath, {
-                type: 'SliceMoved',
-                data: {
-                    sliceId,
-                    position: { x: newX, y: currentY },
-                    timestamp: Date.now(),
-                },
-            });
-        }
-    }
-    // Generate IDs
-    const sliceId = crypto.randomUUID();
-    const screenId = crypto.randomUUID();
-    const commandId = crypto.randomUUID();
-    const eventId = crypto.randomUUID();
-    const screenToCommandFlowId = crypto.randomUUID();
-    const commandToEventFlowId = crypto.randomUUID();
-    // Convert field inputs to fields with IDs
-    const screenFields = input.screen.fields.map(fieldInputToField);
-    const commandFields = input.command.fields.map(fieldInputToField);
-    const eventFields = input.event.fields.map(fieldInputToField);
-    // Infer field mappings
-    const screenToCommandMappings = inferFieldMappings(screenFields, commandFields);
-    const commandToEventMappings = inferFieldMappings(commandFields, eventFields);
-    // Calculate absolute positions for components within the slice
-    const screenPosition = {
-        x: slicePosition.x + STATE_CHANGE_SLICE.screen.offsetX,
-        y: slicePosition.y + STATE_CHANGE_SLICE.screen.offsetY,
-    };
-    const commandPosition = {
-        x: slicePosition.x + STATE_CHANGE_SLICE.command.offsetX,
-        y: slicePosition.y + STATE_CHANGE_SLICE.command.offsetY,
-    };
-    const eventPosition = {
-        x: slicePosition.x + STATE_CHANGE_SLICE.event.offsetX,
-        y: slicePosition.y + STATE_CHANGE_SLICE.event.offsetY,
-    };
-    // Emit atomic events in sequence
-    // 1. Create the slice
-    appendEvent(filePath, {
-        type: 'SlicePlaced',
-        data: {
-            sliceId,
-            name: input.sliceName,
-            position: slicePosition,
-            size: { width: STATE_CHANGE_SLICE.width, height: STATE_CHANGE_SLICE.height },
-            timestamp: Date.now(),
-        },
-    });
-    // 2. Create the screen
-    appendEvent(filePath, {
-        type: 'ScreenPlaced',
-        data: {
-            screenId,
-            name: input.screen.name,
-            position: screenPosition,
-            width: STATE_CHANGE_SLICE.screen.width,
-            height: STATE_CHANGE_SLICE.screen.height,
-            timestamp: Date.now(),
-        },
-    });
-    // 3. Add screen fields
-    for (const field of screenFields) {
-        appendEvent(filePath, {
-            type: 'ScreenFieldAdded',
-            data: {
-                screenId,
-                field,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // 4. Create the command
-    appendEvent(filePath, {
-        type: 'CommandStickyPlaced',
-        data: {
-            commandStickyId: commandId,
-            name: input.command.name,
-            position: commandPosition,
-            width: STATE_CHANGE_SLICE.command.width,
-            height: STATE_CHANGE_SLICE.command.height,
-            timestamp: Date.now(),
-        },
-    });
-    // 5. Add command fields
-    for (const field of commandFields) {
-        appendEvent(filePath, {
-            type: 'CommandFieldAdded',
-            data: {
-                commandStickyId: commandId,
-                field,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // 6. Create the event
-    appendEvent(filePath, {
-        type: 'EventStickyPlaced',
-        data: {
-            eventStickyId: eventId,
-            name: input.event.name,
-            position: eventPosition,
-            width: STATE_CHANGE_SLICE.event.width,
-            height: STATE_CHANGE_SLICE.event.height,
-            timestamp: Date.now(),
-        },
-    });
-    // 7. Add event fields
-    for (const field of eventFields) {
-        appendEvent(filePath, {
-            type: 'EventFieldAdded',
-            data: {
-                eventStickyId: eventId,
-                field,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // 8. Create screen -> command flow
-    appendEvent(filePath, {
-        type: 'ScreenToCommandFlowSpecified',
-        data: {
-            flowId: screenToCommandFlowId,
-            screenId,
-            commandStickyId: commandId,
-            sourceHandle: 'bottom-source',
-            targetHandle: 'top-target',
-            timestamp: Date.now(),
-        },
-    });
-    // 9. Add screen -> command field mappings
-    if (screenToCommandMappings.length > 0) {
-        appendEvent(filePath, {
-            type: 'FieldMappingSpecified',
-            data: {
-                flowId: screenToCommandFlowId,
-                mappings: screenToCommandMappings,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    // 10. Create command -> event flow
-    appendEvent(filePath, {
-        type: 'CommandToEventFlowSpecified',
-        data: {
-            flowId: commandToEventFlowId,
-            commandStickyId: commandId,
-            eventStickyId: eventId,
-            sourceHandle: 'bottom-source',
-            targetHandle: 'top-target',
-            timestamp: Date.now(),
-        },
-    });
-    // 11. Add command -> event field mappings
-    if (commandToEventMappings.length > 0) {
-        appendEvent(filePath, {
-            type: 'FieldMappingSpecified',
-            data: {
-                flowId: commandToEventFlowId,
-                mappings: commandToEventMappings,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    console.log(`Created state-change slice "${input.sliceName}"`);
-    console.log(`  Screen: ${input.screen.name} (${screenFields.length} fields)`);
-    console.log(`  Command: ${input.command.name} (${commandFields.length} fields)`);
-    console.log(`  Event: ${input.event.name} (${eventFields.length} fields)`);
-    console.log(`  Screen -> Command mappings: ${screenToCommandMappings.length}`);
-    console.log(`  Command -> Event mappings: ${commandToEventMappings.length}`);
-}

package/dist/slices/create-state-view-slice/index.d.ts

@@ -1,2 +0,0 @@
-import type { EventModel } from '../../types.js';
-export declare function createStateViewSlice(model: EventModel, filePath: string, xmlInput: string): void;

package/dist/slices/create-state-view-slice/index.js

@@ -1,128 +0,0 @@
-import { appendEvent } from '../../lib/file-loader.js';
-import { STATE_VIEW_SLICE, SLICE_GAP, calculateSlicePosition, validateSliceNameUnique, parseFieldsFromXml, getSlicesToShift, fieldInputToField, } from '../../lib/slice-utils.js';
-function getAttr(attrs, name) {
-    const match = attrs.match(new RegExp(`${name}="([^"]*)"`));
-    return match ? match[1] : undefined;
-}
-function parseXmlInput(xml) {
-    // Parse <state-view-slice name="..." after="..." before="...">
-    const sliceMatch = xml.match(/<state-view-slice([^>]*)>/);
-    if (!sliceMatch) {
-        throw new Error('Invalid XML: missing <state-view-slice> tag');
-    }
-    const sliceName = getAttr(sliceMatch[1], 'name');
-    if (!sliceName) {
-        throw new Error('Invalid XML: state-view-slice must have a name attribute');
-    }
-    const after = getAttr(sliceMatch[1], 'after');
-    const before = getAttr(sliceMatch[1], 'before');
-    // Parse read-model
-    const readModelMatch = xml.match(/<read-model([^>]*)>([\s\S]*?)<\/read-model>/);
-    if (!readModelMatch) {
-        throw new Error('Invalid XML: missing <read-model> element');
-    }
-    const readModelName = getAttr(readModelMatch[1], 'name');
-    if (!readModelName) {
-        throw new Error('Invalid XML: read-model must have a name attribute');
-    }
-    const readModelFields = parseFieldsFromXml(readModelMatch[2]);
-    return {
-        sliceName,
-        after,
-        before,
-        readModel: { name: readModelName, fields: readModelFields },
-    };
-}
-export function createStateViewSlice(model, filePath, xmlInput) {
-    // Parse input
-    let input;
-    try {
-        input = parseXmlInput(xmlInput);
-    }
-    catch (err) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
-    }
-    // Validate slice name is unique
-    try {
-        validateSliceNameUnique(model, input.sliceName);
-    }
-    catch (err) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
-    }
-    // Calculate position
-    let slicePosition;
-    try {
-        slicePosition = calculateSlicePosition(model, STATE_VIEW_SLICE.width, {
-            after: input.after,
-            before: input.before,
-        });
-    }
-    catch (err) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
-    }
-    // Handle "before" positioning - shift existing slices
-    if (input.before) {
-        const shiftAmount = STATE_VIEW_SLICE.width + SLICE_GAP;
-        const toShift = getSlicesToShift(model, slicePosition.x, shiftAmount);
-        for (const { sliceId, newX, currentY } of toShift) {
-            appendEvent(filePath, {
-                type: 'SliceMoved',
-                data: {
-                    sliceId,
-                    position: { x: newX, y: currentY },
-                    timestamp: Date.now(),
-                },
-            });
-        }
-    }
-    // Generate IDs
-    const sliceId = crypto.randomUUID();
-    const readModelId = crypto.randomUUID();
-    // Convert field inputs to fields with IDs
-    const readModelFields = input.readModel.fields.map(fieldInputToField);
-    // Calculate absolute position for read model within the slice
-    const readModelPosition = {
-        x: slicePosition.x + STATE_VIEW_SLICE.readModel.offsetX,
-        y: slicePosition.y + STATE_VIEW_SLICE.readModel.offsetY,
-    };
-    // Emit atomic events in sequence
-    // 1. Create the slice
-    appendEvent(filePath, {
-        type: 'SlicePlaced',
-        data: {
-            sliceId,
-            name: input.sliceName,
-            position: slicePosition,
-            size: { width: STATE_VIEW_SLICE.width, height: STATE_VIEW_SLICE.height },
-            timestamp: Date.now(),
-        },
-    });
-    // 2. Create the read model
-    appendEvent(filePath, {
-        type: 'ReadModelStickyPlaced',
-        data: {
-            readModelStickyId: readModelId,
-            name: input.readModel.name,
-            position: readModelPosition,
-            width: STATE_VIEW_SLICE.readModel.width,
-            height: STATE_VIEW_SLICE.readModel.height,
-            timestamp: Date.now(),
-        },
-    });
-    // 3. Add read model fields
-    for (const field of readModelFields) {
-        appendEvent(filePath, {
-            type: 'ReadModelFieldAdded',
-            data: {
-                readModelStickyId: readModelId,
-                field,
-                timestamp: Date.now(),
-            },
-        });
-    }
-    console.log(`Created state-view slice "${input.sliceName}"`);
-    console.log(`  ReadModel: ${input.readModel.name} (${readModelFields.length} fields)`);
-}

package/dist/slices/diff/index.d.ts

@@ -1,11 +0,0 @@
-import type { OutputFormat } from '../../lib/format.js';
-type DiffOutputFormat = OutputFormat | 'text';
-/**
- * Diff two eventmodel files or compare a file against a git ref.
- *
- * Usage:
- *   diff(file1, file2, format)           - Compare two files
- *   diff(file1, undefined, format, ref)  - Compare file against git ref (default: HEAD)
- */
-export declare function diff(basePath: string, comparePath: string | undefined, format: DiffOutputFormat, gitRef?: string): void;
-export {};