eventmodeler 0.5.0 → 0.6.1

package/dist/lib/diff/merge-rules.js

@@ -1,210 +0,0 @@
-/**
- * Merge rules for Event Model conflicts.
- *
- * Based on analysis of user workflows, these rules define how to handle
- * different types of conflicts when merging two branches.
- */
-/**
- * Slice status priority order.
- * Higher priority wins in auto-resolution.
- */
-const SLICE_STATUS_PRIORITY = {
-    'done': 4,
-    'in-progress': 3,
-    'blocked': 2,
-    'created': 1,
-};
-/**
- * Properties that can be auto-resolved with last-write-wins.
- * These are layout/visual properties that don't affect semantics.
- */
-const LAYOUT_PROPERTIES = new Set([
-    'position',
-    'width',
-    'height',
-    'size',
-    'x',
-    'y',
-]);
-/**
- * Determine how to resolve a property conflict.
- */
-export function resolvePropertyConflict(property, oursValue, theirsValue, entityType) {
-    // Layout properties: auto-resolve with theirs (last-write-wins)
-    if (LAYOUT_PROPERTIES.has(property)) {
-        return { type: 'auto', action: 'layout-use-theirs' };
-    }
-    // Slice status: use priority order
-    if (property === 'status' && entityType === 'slice') {
-        const oursPriority = SLICE_STATUS_PRIORITY[oursValue] ?? 0;
-        const theirsPriority = SLICE_STATUS_PRIORITY[theirsValue] ?? 0;
-        if (oursPriority >= theirsPriority) {
-            return { type: 'auto', action: 'status-priority-ours' };
-        }
-        else {
-            return { type: 'auto', action: 'status-priority-theirs' };
-        }
-    }
-    // Name conflicts: hard conflict
-    if (property === 'name') {
-        return { type: 'hard', reason: `Both renamed to different values` };
-    }
-    // nodeIds/eventIds/screenIds: can merge (include both)
-    if (property === 'nodeIds' || property === 'eventIds' || property === 'screenIds') {
-        return { type: 'auto', action: 'merge-arrays' };
-    }
-    // Scenario parts: hard conflict
-    if (property === 'givenEvents' || property === 'whenCommand' || property === 'then' || property === 'description') {
-        return { type: 'hard', reason: `Both modified ${property}` };
-    }
-    // Default: hard conflict
-    return { type: 'hard', reason: `Both modified ${property}` };
-}
-/**
- * Determine how to resolve a field conflict.
- */
-export function resolveFieldConflict(oursChange, theirsChange) {
-    const fieldPath = oursChange.fieldPath;
-    // Both added same field
-    if (oursChange.changeType === 'added' && theirsChange.changeType === 'added') {
-        const oursField = oursChange.newValue;
-        const theirsField = theirsChange.newValue;
-        // Same type: auto-resolve (keep one)
-        if (oursField && theirsField && fieldsCompatible(oursField, theirsField)) {
-            return { type: 'auto', action: 'both-added-compatible' };
-        }
-        // Different types: hard conflict
-        return { type: 'hard', reason: `Both added field "${fieldPath}" with different types` };
-    }
-    // Both removed same field
-    if (oursChange.changeType === 'removed' && theirsChange.changeType === 'removed') {
-        return { type: 'auto', action: 'both-removed' };
-    }
-    // One removed, other modified
-    if ((oursChange.changeType === 'removed' && theirsChange.changeType === 'modified') ||
-        (oursChange.changeType === 'modified' && theirsChange.changeType === 'removed')) {
-        return { type: 'hard', reason: `Field "${fieldPath}": one removed, other modified` };
-    }
-    // Both modified same field
-    if (oursChange.changeType === 'modified' && theirsChange.changeType === 'modified') {
-        const oursField = oursChange.newValue;
-        const theirsField = theirsChange.newValue;
-        // Same change: auto-resolve
-        if (oursField && theirsField && fieldsEqual(oursField, theirsField)) {
-            return { type: 'auto', action: 'both-modified-identically' };
-        }
-        // Different changes: hard conflict
-        return { type: 'hard', reason: `Both modified field "${fieldPath}" differently` };
-    }
-    return { type: 'hard', reason: `Unexpected field conflict on "${fieldPath}"` };
-}
-/**
- * Check if two fields are semantically equal.
- */
-function fieldsEqual(a, b) {
-    if (a.name !== b.name)
-        return false;
-    if (a.fieldType !== b.fieldType)
-        return false;
-    if (a.isList !== b.isList)
-        return false;
-    if (a.isGenerated !== b.isGenerated)
-        return false;
-    if (a.isOptional !== b.isOptional)
-        return false;
-    if (a.isUserInput !== b.isUserInput)
-        return false;
-    // Compare subfields
-    const aSubfields = a.subfields ?? [];
-    const bSubfields = b.subfields ?? [];
-    if (aSubfields.length !== bSubfields.length)
-        return false;
-    for (let i = 0; i < aSubfields.length; i++) {
-        if (!fieldsEqual(aSubfields[i], bSubfields[i]))
-            return false;
-    }
-    return true;
-}
-/**
- * Check if two fields are compatible (can be merged).
- * Compatible means same name and type, even if other properties differ.
- */
-function fieldsCompatible(a, b) {
-    if (a.name !== b.name)
-        return false;
-    if (a.fieldType !== b.fieldType)
-        return false;
-    if (a.isList !== b.isList)
-        return false;
-    return true;
-}
-/**
- * Merge two arrays (e.g., nodeIds) removing duplicates.
- */
-export function mergeArrays(base, ours, theirs) {
-    const baseSet = new Set(base);
-    const result = new Set(base);
-    // Add items from ours that weren't in base
-    for (const item of ours) {
-        if (!baseSet.has(item)) {
-            result.add(item);
-        }
-    }
-    // Add items from theirs that weren't in base
-    for (const item of theirs) {
-        if (!baseSet.has(item)) {
-            result.add(item);
-        }
-    }
-    // Remove items deleted in ours
-    for (const item of base) {
-        if (!ours.includes(item)) {
-            result.delete(item);
-        }
-    }
-    // Remove items deleted in theirs
-    for (const item of base) {
-        if (!theirs.includes(item)) {
-            result.delete(item);
-        }
-    }
-    return [...result];
-}
-/**
- * Check if an entity change affects only layout properties.
- */
-export function isLayoutOnlyChange(change) {
-    if (change.changeType !== 'modified')
-        return false;
-    if (change.fieldChanges && change.fieldChanges.length > 0)
-        return false;
-    if (!change.propertyChanges)
-        return true;
-    return change.propertyChanges.every(p => LAYOUT_PROPERTIES.has(p.property));
-}
-/**
- * Categorize fields changes for merge.
- */
-export function categorizeFieldChanges(oursChanges, theirsChanges) {
-    const oursMap = new Map(oursChanges.map(c => [c.fieldPath, c]));
-    const theirsMap = new Map(theirsChanges.map(c => [c.fieldPath, c]));
-    const oursOnly = [];
-    const theirsOnly = [];
-    const conflicts = [];
-    for (const [path, oursChange] of oursMap) {
-        const theirsChange = theirsMap.get(path);
-        if (theirsChange) {
-            const resolution = resolveFieldConflict(oursChange, theirsChange);
-            conflicts.push({ ours: oursChange, theirs: theirsChange, resolution });
-        }
-        else {
-            oursOnly.push(oursChange);
-        }
-    }
-    for (const [path, theirsChange] of theirsMap) {
-        if (!oursMap.has(path)) {
-            theirsOnly.push(theirsChange);
-        }
-    }
-    return { oursOnly, theirsOnly, conflicts };
-}

package/dist/lib/diff/model-differ.d.ts

@@ -1,8 +0,0 @@
-import type { EventModel } from '../../types.js';
-import type { DiffResult, EntityChange, FieldChange, FlowChange } from './types.js';
-/**
- * Compare two EventModels and return semantic differences.
- * Ignores layout properties (position, size) and linked copies.
- */
-export declare function diffModels(baseModel: EventModel, compareModel: EventModel): DiffResult;
-export type { DiffResult, EntityChange, FieldChange, FlowChange };