emviz 0.1.5 → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -2
- package/dist/app/assets/{index-DU8hLB5X.css → index-BRyuPKFs.css} +1 -1
- package/dist/app/assets/index-DzoC5xh1.js +171 -0
- package/dist/app/index.html +2 -2
- package/dist/index.js +370 -12
- package/dist/index.js.map +3 -3
- package/package.json +3 -3
- package/dist/app/assets/index-C1fC7Lb6.js +0 -166
package/dist/app/index.html
CHANGED
|
@@ -4,8 +4,8 @@
|
|
|
4
4
|
<meta charset="UTF-8" />
|
|
5
5
|
<meta name="viewport" content="width=device-width, initial-scale=1.0" />
|
|
6
6
|
<title>emviz</title>
|
|
7
|
-
<script type="module" crossorigin src="/assets/index-
|
|
8
|
-
<link rel="stylesheet" crossorigin href="/assets/index-
|
|
7
|
+
<script type="module" crossorigin src="/assets/index-DzoC5xh1.js"></script>
|
|
8
|
+
<link rel="stylesheet" crossorigin href="/assets/index-BRyuPKFs.css">
|
|
9
9
|
</head>
|
|
10
10
|
<body>
|
|
11
11
|
<div id="root"></div>
|
package/dist/index.js
CHANGED
|
@@ -104,9 +104,9 @@ var require_path = __commonJS({
|
|
|
104
104
|
"use strict";
|
|
105
105
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
106
106
|
exports.convertPosixPathToPattern = exports.convertWindowsPathToPattern = exports.convertPathToPattern = exports.escapePosixPath = exports.escapeWindowsPath = exports.escape = exports.removeLeadingDotSegment = exports.makeAbsolute = exports.unixify = void 0;
|
|
107
|
-
var
|
|
107
|
+
var os2 = __require("os");
|
|
108
108
|
var path6 = __require("path");
|
|
109
|
-
var IS_WINDOWS_PLATFORM =
|
|
109
|
+
var IS_WINDOWS_PLATFORM = os2.platform() === "win32";
|
|
110
110
|
var LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2;
|
|
111
111
|
var POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
|
|
112
112
|
var WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()[\]{}]|^!|[!+@](?=\())/g;
|
|
@@ -5624,8 +5624,8 @@ var require_settings4 = __commonJS({
|
|
|
5624
5624
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
5625
5625
|
exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
|
|
5626
5626
|
var fs6 = __require("fs");
|
|
5627
|
-
var
|
|
5628
|
-
var CPU_COUNT = Math.max(
|
|
5627
|
+
var os2 = __require("os");
|
|
5628
|
+
var CPU_COUNT = Math.max(os2.cpus().length, 1);
|
|
5629
5629
|
exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
|
|
5630
5630
|
lstat: fs6.lstat,
|
|
5631
5631
|
lstatSync: fs6.lstatSync,
|
|
@@ -13108,7 +13108,9 @@ var require_dist = __commonJS({
|
|
|
13108
13108
|
// src/index.ts
|
|
13109
13109
|
import fs5 from "node:fs";
|
|
13110
13110
|
import http from "node:http";
|
|
13111
|
+
import os from "node:os";
|
|
13111
13112
|
import path5 from "node:path";
|
|
13113
|
+
import { execFileSync } from "node:child_process";
|
|
13112
13114
|
import { fileURLToPath } from "node:url";
|
|
13113
13115
|
|
|
13114
13116
|
// ../parser/dist/index.js
|
|
@@ -13503,6 +13505,144 @@ function generatedNodes(project) {
|
|
|
13503
13505
|
}
|
|
13504
13506
|
]));
|
|
13505
13507
|
}
|
|
13508
|
+
function semanticNodeType(node) {
|
|
13509
|
+
return node.type === "processor" ? "screen" : node.type;
|
|
13510
|
+
}
|
|
13511
|
+
function nodeKey(node) {
|
|
13512
|
+
return nodeSelectorKey({
|
|
13513
|
+
type: semanticNodeType(node),
|
|
13514
|
+
selector: selectorForNode(node)
|
|
13515
|
+
});
|
|
13516
|
+
}
|
|
13517
|
+
function stableJson(value) {
|
|
13518
|
+
if (Array.isArray(value))
|
|
13519
|
+
return `[${value.map(stableJson).join(",")}]`;
|
|
13520
|
+
if (value && typeof value === "object") {
|
|
13521
|
+
return `{${Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, entry]) => `${JSON.stringify(key)}:${stableJson(entry)}`).join(",")}}`;
|
|
13522
|
+
}
|
|
13523
|
+
return JSON.stringify(value);
|
|
13524
|
+
}
|
|
13525
|
+
function comparableNode(node) {
|
|
13526
|
+
return {
|
|
13527
|
+
type: node.type,
|
|
13528
|
+
label: node.label,
|
|
13529
|
+
storyName: node.storyName,
|
|
13530
|
+
sliceTitle: node.sliceTitle,
|
|
13531
|
+
sourceName: node.sourceName,
|
|
13532
|
+
actors: node.actors,
|
|
13533
|
+
screenType: node.screenType,
|
|
13534
|
+
fields: node.fields,
|
|
13535
|
+
description: node.description,
|
|
13536
|
+
given: node.given,
|
|
13537
|
+
when: node.when,
|
|
13538
|
+
then: node.then
|
|
13539
|
+
};
|
|
13540
|
+
}
|
|
13541
|
+
function edgeKey(edge, nodeKeys) {
|
|
13542
|
+
return stableJson({
|
|
13543
|
+
kind: edge.kind,
|
|
13544
|
+
source: nodeKeys.get(edge.source) ?? edge.source,
|
|
13545
|
+
target: nodeKeys.get(edge.target) ?? edge.target,
|
|
13546
|
+
label: edge.label
|
|
13547
|
+
});
|
|
13548
|
+
}
|
|
13549
|
+
function comparableEdge(edge, nodeKeys) {
|
|
13550
|
+
return {
|
|
13551
|
+
kind: edge.kind,
|
|
13552
|
+
source: nodeKeys.get(edge.source) ?? edge.source,
|
|
13553
|
+
target: nodeKeys.get(edge.target) ?? edge.target,
|
|
13554
|
+
label: edge.label
|
|
13555
|
+
};
|
|
13556
|
+
}
|
|
13557
|
+
function summarize(statuses) {
|
|
13558
|
+
const summary = { added: 0, removed: 0, changed: 0, unchanged: 0 };
|
|
13559
|
+
for (const status of statuses)
|
|
13560
|
+
summary[status] += 1;
|
|
13561
|
+
return summary;
|
|
13562
|
+
}
|
|
13563
|
+
function cloneProject(project) {
|
|
13564
|
+
return {
|
|
13565
|
+
...project,
|
|
13566
|
+
events: project.events.map((event) => ({ ...event })),
|
|
13567
|
+
stories: project.stories.map((story) => ({ ...story, slices: [...story.slices] })),
|
|
13568
|
+
slices: project.slices.map((slice) => ({
|
|
13569
|
+
...slice,
|
|
13570
|
+
screen: { ...slice.screen, actors: [...slice.screen.actors], reads: [...slice.screen.reads], executes: [...slice.screen.executes] },
|
|
13571
|
+
commands: slice.commands.map((command2) => ({ ...command2, produces: [...command2.produces] })),
|
|
13572
|
+
queries: slice.queries.map((query) => ({ ...query, fromEvents: [...query.fromEvents] })),
|
|
13573
|
+
gwt: slice.gwt.map((scenario) => ({
|
|
13574
|
+
...scenario,
|
|
13575
|
+
given: [...scenario.given],
|
|
13576
|
+
when: [...scenario.when],
|
|
13577
|
+
then: [...scenario.then]
|
|
13578
|
+
}))
|
|
13579
|
+
})),
|
|
13580
|
+
nodes: project.nodes.map((node) => ({ ...node })),
|
|
13581
|
+
edges: project.edges.map((edge) => ({ ...edge }))
|
|
13582
|
+
};
|
|
13583
|
+
}
|
|
13584
|
+
function uniqueNodeId(existingIds, id) {
|
|
13585
|
+
if (!existingIds.has(id)) {
|
|
13586
|
+
existingIds.add(id);
|
|
13587
|
+
return id;
|
|
13588
|
+
}
|
|
13589
|
+
let index = 1;
|
|
13590
|
+
let next = `removed:${id}`;
|
|
13591
|
+
while (existingIds.has(next)) {
|
|
13592
|
+
index += 1;
|
|
13593
|
+
next = `removed:${index}:${id}`;
|
|
13594
|
+
}
|
|
13595
|
+
existingIds.add(next);
|
|
13596
|
+
return next;
|
|
13597
|
+
}
|
|
13598
|
+
function uniqueEdgeId(existingIds, id) {
|
|
13599
|
+
if (!existingIds.has(id)) {
|
|
13600
|
+
existingIds.add(id);
|
|
13601
|
+
return id;
|
|
13602
|
+
}
|
|
13603
|
+
let index = 1;
|
|
13604
|
+
let next = `removed:${id}`;
|
|
13605
|
+
while (existingIds.has(next)) {
|
|
13606
|
+
index += 1;
|
|
13607
|
+
next = `removed:${index}:${id}`;
|
|
13608
|
+
}
|
|
13609
|
+
existingIds.add(next);
|
|
13610
|
+
return next;
|
|
13611
|
+
}
|
|
13612
|
+
function mergeRemovedModelContainers(merged, base) {
|
|
13613
|
+
const storyNames = new Set(merged.stories.map((story) => story.name));
|
|
13614
|
+
const slicePaths = new Set(merged.slices.map((slice) => slice.path));
|
|
13615
|
+
const eventNames = new Set(merged.events.map((event) => event.name));
|
|
13616
|
+
for (const story of base.stories) {
|
|
13617
|
+
if (storyNames.has(story.name))
|
|
13618
|
+
continue;
|
|
13619
|
+
merged.stories.push({ ...story, slices: [...story.slices] });
|
|
13620
|
+
storyNames.add(story.name);
|
|
13621
|
+
}
|
|
13622
|
+
for (const slice of base.slices) {
|
|
13623
|
+
if (slicePaths.has(slice.path))
|
|
13624
|
+
continue;
|
|
13625
|
+
merged.slices.push({
|
|
13626
|
+
...slice,
|
|
13627
|
+
screen: { ...slice.screen, actors: [...slice.screen.actors], reads: [...slice.screen.reads], executes: [...slice.screen.executes] },
|
|
13628
|
+
commands: slice.commands.map((command2) => ({ ...command2, produces: [...command2.produces] })),
|
|
13629
|
+
queries: slice.queries.map((query) => ({ ...query, fromEvents: [...query.fromEvents] })),
|
|
13630
|
+
gwt: slice.gwt.map((scenario) => ({
|
|
13631
|
+
...scenario,
|
|
13632
|
+
given: [...scenario.given],
|
|
13633
|
+
when: [...scenario.when],
|
|
13634
|
+
then: [...scenario.then]
|
|
13635
|
+
}))
|
|
13636
|
+
});
|
|
13637
|
+
slicePaths.add(slice.path);
|
|
13638
|
+
}
|
|
13639
|
+
for (const event of base.events) {
|
|
13640
|
+
if (eventNames.has(event.name))
|
|
13641
|
+
continue;
|
|
13642
|
+
merged.events.push({ ...event });
|
|
13643
|
+
eventNames.add(event.name);
|
|
13644
|
+
}
|
|
13645
|
+
}
|
|
13506
13646
|
function buildGraphSidecar(project, existing) {
|
|
13507
13647
|
const generated = generatedNodes(project);
|
|
13508
13648
|
const generatedSelectorKeys = new Set(Object.values(generated).map(nodeSelectorKey));
|
|
@@ -13538,6 +13678,71 @@ function buildGraphSidecar(project, existing) {
|
|
|
13538
13678
|
}))
|
|
13539
13679
|
};
|
|
13540
13680
|
}
|
|
13681
|
+
function diffEventModelProjects(base, target, labels = {}) {
|
|
13682
|
+
const merged = cloneProject(target);
|
|
13683
|
+
const existingNodeIds = new Set(merged.nodes.map((node) => node.id));
|
|
13684
|
+
const existingEdgeIds = new Set(merged.edges.map((edge) => edge.id));
|
|
13685
|
+
const baseNodesByKey = new Map(base.nodes.map((node) => [nodeKey(node), node]));
|
|
13686
|
+
const targetNodesByKey = new Map(target.nodes.map((node) => [nodeKey(node), node]));
|
|
13687
|
+
const baseNodeKeysById = new Map(base.nodes.map((node) => [node.id, nodeKey(node)]));
|
|
13688
|
+
const targetNodeKeysById = new Map(target.nodes.map((node) => [node.id, nodeKey(node)]));
|
|
13689
|
+
const nodeStatus = {};
|
|
13690
|
+
const mergedNodeIdByBaseId = /* @__PURE__ */ new Map();
|
|
13691
|
+
mergeRemovedModelContainers(merged, base);
|
|
13692
|
+
for (const targetNode of target.nodes) {
|
|
13693
|
+
const key = nodeKey(targetNode);
|
|
13694
|
+
const baseNode = baseNodesByKey.get(key);
|
|
13695
|
+
if (!baseNode) {
|
|
13696
|
+
nodeStatus[targetNode.id] = "added";
|
|
13697
|
+
continue;
|
|
13698
|
+
}
|
|
13699
|
+
nodeStatus[targetNode.id] = stableJson(comparableNode(baseNode)) === stableJson(comparableNode(targetNode)) ? "unchanged" : "changed";
|
|
13700
|
+
}
|
|
13701
|
+
for (const baseNode of base.nodes) {
|
|
13702
|
+
const key = nodeKey(baseNode);
|
|
13703
|
+
if (targetNodesByKey.has(key))
|
|
13704
|
+
continue;
|
|
13705
|
+
const id = uniqueNodeId(existingNodeIds, baseNode.id);
|
|
13706
|
+
mergedNodeIdByBaseId.set(baseNode.id, id);
|
|
13707
|
+
merged.nodes.push({ ...baseNode, id });
|
|
13708
|
+
nodeStatus[id] = "removed";
|
|
13709
|
+
}
|
|
13710
|
+
const baseEdgesByKey = new Map(base.edges.map((edge) => [edgeKey(edge, baseNodeKeysById), edge]));
|
|
13711
|
+
const targetEdgesByKey = new Map(target.edges.map((edge) => [edgeKey(edge, targetNodeKeysById), edge]));
|
|
13712
|
+
const edgeStatus = {};
|
|
13713
|
+
for (const targetEdge of target.edges) {
|
|
13714
|
+
const key = edgeKey(targetEdge, targetNodeKeysById);
|
|
13715
|
+
const baseEdge = baseEdgesByKey.get(key);
|
|
13716
|
+
if (!baseEdge) {
|
|
13717
|
+
edgeStatus[targetEdge.id] = "added";
|
|
13718
|
+
continue;
|
|
13719
|
+
}
|
|
13720
|
+
edgeStatus[targetEdge.id] = stableJson(comparableEdge(baseEdge, baseNodeKeysById)) === stableJson(comparableEdge(targetEdge, targetNodeKeysById)) ? "unchanged" : "changed";
|
|
13721
|
+
}
|
|
13722
|
+
for (const baseEdge of base.edges) {
|
|
13723
|
+
const key = edgeKey(baseEdge, baseNodeKeysById);
|
|
13724
|
+
if (targetEdgesByKey.has(key))
|
|
13725
|
+
continue;
|
|
13726
|
+
const source = mergedNodeIdByBaseId.get(baseEdge.source) ?? targetNodesByKey.get(baseNodeKeysById.get(baseEdge.source) ?? "")?.id ?? baseEdge.source;
|
|
13727
|
+
const targetId = mergedNodeIdByBaseId.get(baseEdge.target) ?? targetNodesByKey.get(baseNodeKeysById.get(baseEdge.target) ?? "")?.id ?? baseEdge.target;
|
|
13728
|
+
const id = uniqueEdgeId(existingEdgeIds, baseEdge.id);
|
|
13729
|
+
merged.edges.push({ ...baseEdge, id, source, target: targetId });
|
|
13730
|
+
edgeStatus[id] = "removed";
|
|
13731
|
+
}
|
|
13732
|
+
return {
|
|
13733
|
+
project: merged,
|
|
13734
|
+
diff: {
|
|
13735
|
+
base: { label: labels.base ?? "base" },
|
|
13736
|
+
target: { label: labels.target ?? "target" },
|
|
13737
|
+
nodeStatus,
|
|
13738
|
+
edgeStatus,
|
|
13739
|
+
summary: {
|
|
13740
|
+
nodes: summarize(Object.values(nodeStatus)),
|
|
13741
|
+
edges: summarize(Object.values(edgeStatus))
|
|
13742
|
+
}
|
|
13743
|
+
}
|
|
13744
|
+
};
|
|
13745
|
+
}
|
|
13541
13746
|
function readGraphSidecar(projectRoot) {
|
|
13542
13747
|
const sidecarPath = path3.join(projectRoot, ".event-modeling", "graph.json");
|
|
13543
13748
|
if (!fs3.existsSync(sidecarPath))
|
|
@@ -13601,8 +13806,31 @@ function duplicates(values) {
|
|
|
13601
13806
|
}
|
|
13602
13807
|
return [...duplicate];
|
|
13603
13808
|
}
|
|
13809
|
+
var pastTenseTokens = /* @__PURE__ */ new Set([
|
|
13810
|
+
"sent",
|
|
13811
|
+
"built",
|
|
13812
|
+
"made",
|
|
13813
|
+
"paid",
|
|
13814
|
+
"booked",
|
|
13815
|
+
"cancelled",
|
|
13816
|
+
"canceled",
|
|
13817
|
+
"submitted",
|
|
13818
|
+
"recorded",
|
|
13819
|
+
"created",
|
|
13820
|
+
"updated",
|
|
13821
|
+
"deleted",
|
|
13822
|
+
"placed",
|
|
13823
|
+
"notified"
|
|
13824
|
+
]);
|
|
13825
|
+
function pascalCaseTokens(name) {
|
|
13826
|
+
return name.match(/[A-Z]+(?=[A-Z][a-z]|$)|[A-Z]?[a-z]+|\d+/g) ?? [name];
|
|
13827
|
+
}
|
|
13828
|
+
function looksLikePastTenseToken(token) {
|
|
13829
|
+
const normalized = token.toLowerCase();
|
|
13830
|
+
return pastTenseTokens.has(normalized) || /(ed|en|d)$/i.test(token);
|
|
13831
|
+
}
|
|
13604
13832
|
function looksLikePastTenseEvent(name) {
|
|
13605
|
-
return
|
|
13833
|
+
return pascalCaseTokens(name).some(looksLikePastTenseToken);
|
|
13606
13834
|
}
|
|
13607
13835
|
function isDispatchEvent(name) {
|
|
13608
13836
|
return /(Requested|Triggered|Scheduled|Enqueued|Dispatched|Required)$/.test(name);
|
|
@@ -13825,14 +14053,113 @@ function loadApiModel(targetDir) {
|
|
|
13825
14053
|
graphSidecar: readGraphSidecar(project.root)
|
|
13826
14054
|
};
|
|
13827
14055
|
}
|
|
13828
|
-
|
|
13829
|
-
|
|
13830
|
-
|
|
14056
|
+
function isGitRef(value) {
|
|
14057
|
+
try {
|
|
14058
|
+
execFileSync("git", ["rev-parse", "--verify", `${value}^{commit}`], {
|
|
14059
|
+
cwd: process.cwd(),
|
|
14060
|
+
stdio: "ignore"
|
|
14061
|
+
});
|
|
14062
|
+
return true;
|
|
14063
|
+
} catch {
|
|
14064
|
+
return false;
|
|
14065
|
+
}
|
|
14066
|
+
}
|
|
14067
|
+
function materializeGitRef(ref) {
|
|
14068
|
+
const tempRoot = fs5.mkdtempSync(path5.join(os.tmpdir(), "emviz-diff-"));
|
|
14069
|
+
const files = execFileSync("git", ["ls-tree", "-r", "--name-only", ref, "--", ".event-modeling", "event-model"], {
|
|
14070
|
+
cwd: process.cwd(),
|
|
14071
|
+
encoding: "utf8"
|
|
14072
|
+
}).split("\n").filter(Boolean);
|
|
14073
|
+
if (files.length === 0) throw new Error(`Git ref "${ref}" does not contain .event-modeling or event-model files.`);
|
|
14074
|
+
for (const file of files) {
|
|
14075
|
+
const content = execFileSync("git", ["show", `${ref}:${file}`], {
|
|
14076
|
+
cwd: process.cwd(),
|
|
14077
|
+
encoding: "utf8",
|
|
14078
|
+
maxBuffer: 20 * 1024 * 1024
|
|
14079
|
+
});
|
|
14080
|
+
const outputPath = path5.join(tempRoot, file);
|
|
14081
|
+
fs5.mkdirSync(path5.dirname(outputPath), { recursive: true });
|
|
14082
|
+
fs5.writeFileSync(outputPath, content);
|
|
14083
|
+
}
|
|
14084
|
+
return tempRoot;
|
|
14085
|
+
}
|
|
14086
|
+
function loadDiffSource(value, fallback) {
|
|
14087
|
+
const raw = value ?? fallback;
|
|
14088
|
+
const resolved = path5.resolve(process.cwd(), raw);
|
|
14089
|
+
if (fs5.existsSync(resolved)) {
|
|
14090
|
+
if (fs5.statSync(resolved).isFile()) {
|
|
14091
|
+
throw new Error(`Diff source must be an event-modeling project directory, not a file: ${raw}`);
|
|
14092
|
+
}
|
|
14093
|
+
return {
|
|
14094
|
+
project: loadEventModelProject(resolved),
|
|
14095
|
+
label: path5.relative(process.cwd(), resolved) || "."
|
|
14096
|
+
};
|
|
14097
|
+
}
|
|
14098
|
+
if (isGitRef(raw)) {
|
|
14099
|
+
const root = materializeGitRef(raw);
|
|
14100
|
+
return {
|
|
14101
|
+
project: loadEventModelProject(root),
|
|
14102
|
+
label: raw
|
|
14103
|
+
};
|
|
14104
|
+
}
|
|
14105
|
+
throw new Error(`Diff source not found as a path or git ref: ${raw}`);
|
|
14106
|
+
}
|
|
14107
|
+
function parseDiffArgs(values) {
|
|
14108
|
+
let base;
|
|
14109
|
+
let target;
|
|
14110
|
+
const positional = [];
|
|
14111
|
+
for (let index = 0; index < values.length; index += 1) {
|
|
14112
|
+
const value = values[index];
|
|
14113
|
+
if (value === "--from") {
|
|
14114
|
+
base = values[index + 1];
|
|
14115
|
+
index += 1;
|
|
14116
|
+
continue;
|
|
14117
|
+
}
|
|
14118
|
+
if (value === "--to") {
|
|
14119
|
+
target = values[index + 1];
|
|
14120
|
+
index += 1;
|
|
14121
|
+
continue;
|
|
14122
|
+
}
|
|
14123
|
+
positional.push(value);
|
|
14124
|
+
}
|
|
14125
|
+
return {
|
|
14126
|
+
base: base ?? positional[0] ?? "HEAD~1",
|
|
14127
|
+
target: target ?? positional[1] ?? "."
|
|
14128
|
+
};
|
|
14129
|
+
}
|
|
14130
|
+
function loadDiffServerState(baseValue, targetValue) {
|
|
14131
|
+
const base = loadDiffSource(baseValue, "HEAD~1");
|
|
14132
|
+
const target = loadDiffSource(targetValue, ".");
|
|
14133
|
+
const result = diffEventModelProjects(base.project, target.project, {
|
|
14134
|
+
base: base.label,
|
|
14135
|
+
target: target.label
|
|
14136
|
+
});
|
|
14137
|
+
return {
|
|
14138
|
+
model: {
|
|
14139
|
+
...result.project,
|
|
14140
|
+
graphSidecar: readGraphSidecar(target.project.root)
|
|
14141
|
+
},
|
|
14142
|
+
validation: validateEventModelProject(target.project),
|
|
14143
|
+
diff: result.diff
|
|
14144
|
+
};
|
|
14145
|
+
}
|
|
14146
|
+
function printSyncResult(result) {
|
|
13831
14147
|
console.log(`Wrote ${path5.relative(process.cwd(), result.path)}`);
|
|
13832
14148
|
console.log(`Added: ${result.added.length}`);
|
|
13833
14149
|
console.log(`Preserved: ${result.preserved.length}`);
|
|
13834
14150
|
console.log(`Stale: ${result.stale.length}`);
|
|
13835
14151
|
}
|
|
14152
|
+
async function runSync(targetDir) {
|
|
14153
|
+
const project = loadEventModelProject(targetDir);
|
|
14154
|
+
const result = writeGraphSidecar(project);
|
|
14155
|
+
printSyncResult(result);
|
|
14156
|
+
}
|
|
14157
|
+
function syncMissingGraphSidecar(targetDir) {
|
|
14158
|
+
const project = loadEventModelProject(targetDir);
|
|
14159
|
+
if (readGraphSidecar(project.root)) return;
|
|
14160
|
+
console.log("Missing .event-modeling/graph.json; running initial sync...");
|
|
14161
|
+
printSyncResult(writeGraphSidecar(project));
|
|
14162
|
+
}
|
|
13836
14163
|
var contentTypes = {
|
|
13837
14164
|
".css": "text/css; charset=utf-8",
|
|
13838
14165
|
".html": "text/html; charset=utf-8",
|
|
@@ -13890,10 +14217,23 @@ function listenWithFallback(server, port) {
|
|
|
13890
14217
|
tryListen(port);
|
|
13891
14218
|
});
|
|
13892
14219
|
}
|
|
13893
|
-
async function runServer(targetDir) {
|
|
14220
|
+
async function runServer(targetDir, diffState) {
|
|
14221
|
+
if (targetDir) syncMissingGraphSidecar(targetDir);
|
|
13894
14222
|
const appRoot = path5.resolve(path5.dirname(fileURLToPath(import.meta.url)), "app");
|
|
13895
14223
|
const server = http.createServer((req, res) => {
|
|
13896
14224
|
const url = new URL(req.url ?? "/", "http://localhost");
|
|
14225
|
+
if (diffState && url.pathname === "/api/model") {
|
|
14226
|
+
sendJson(res, diffState.model);
|
|
14227
|
+
return;
|
|
14228
|
+
}
|
|
14229
|
+
if (diffState && url.pathname === "/api/diff") {
|
|
14230
|
+
sendJson(res, diffState.diff);
|
|
14231
|
+
return;
|
|
14232
|
+
}
|
|
14233
|
+
if (diffState && url.pathname === "/api/validation") {
|
|
14234
|
+
sendJson(res, diffState.validation);
|
|
14235
|
+
return;
|
|
14236
|
+
}
|
|
13897
14237
|
if (targetDir && url.pathname === "/api/model") {
|
|
13898
14238
|
try {
|
|
13899
14239
|
sendJson(res, loadApiModel(targetDir));
|
|
@@ -13917,16 +14257,34 @@ async function runServer(targetDir) {
|
|
|
13917
14257
|
});
|
|
13918
14258
|
const port = await listenWithFallback(server, 5173);
|
|
13919
14259
|
console.log(` \u279C Local: http://localhost:${port}/`);
|
|
13920
|
-
|
|
14260
|
+
if (diffState) {
|
|
14261
|
+
console.log(`Diff: ${diffState.diff.base.label} -> ${diffState.diff.target.label}`);
|
|
14262
|
+
} else {
|
|
14263
|
+
console.log(targetDir ? `Project: ${targetDir}` : "Mode: manual import");
|
|
14264
|
+
}
|
|
13921
14265
|
}
|
|
13922
14266
|
async function main() {
|
|
14267
|
+
if (command === "sync") {
|
|
14268
|
+
await runSync(resolveTarget(args[1]));
|
|
14269
|
+
return;
|
|
14270
|
+
}
|
|
13923
14271
|
if (command === "init") {
|
|
13924
|
-
|
|
14272
|
+
console.warn("`emviz init` is deprecated. Use `emviz sync` instead.");
|
|
14273
|
+
await runSync(resolveTarget(args[1]));
|
|
14274
|
+
return;
|
|
14275
|
+
}
|
|
14276
|
+
if (command === "diff") {
|
|
14277
|
+
const diffArgs = parseDiffArgs(args.slice(1));
|
|
14278
|
+
const diffState = loadDiffServerState(diffArgs.base, diffArgs.target);
|
|
14279
|
+
await runServer(void 0, diffState);
|
|
13925
14280
|
return;
|
|
13926
14281
|
}
|
|
13927
14282
|
if (command === "--help" || command === "-h") {
|
|
13928
14283
|
console.log("Usage: emviz [project-dir]");
|
|
13929
|
-
console.log(" emviz
|
|
14284
|
+
console.log(" emviz sync [project-dir]");
|
|
14285
|
+
console.log(" emviz diff [base-ref-or-dir] [project-dir]");
|
|
14286
|
+
console.log(" emviz diff --from <base-ref-or-dir> --to <project-dir>");
|
|
14287
|
+
console.log(" emviz init [project-dir] (deprecated alias for sync)");
|
|
13930
14288
|
return;
|
|
13931
14289
|
}
|
|
13932
14290
|
await runServer(command ? resolveTarget(command) : void 0);
|