yarramate 1.41.0 → 1.41.1

package/dist/canvas-scene.js

@@ -1,6 +1,6 @@
 import { foldGraph, foldTree } from './fold-tree.js';
-import { spansNesting } from './visual-app/nesting-span.js';
-import { subjectMatchesQuickFilter } from './visual-app/subject-filter.js';
+import { spansNesting } from './nesting-span.js';
+import { subjectMatchesQuickFilter } from './subject-filter.js';
 /** The drawn relationships: what nesting did not consume, and RACI only if shown. */
 export function drawnCanvasEdges(graph, tree, showResponsibility) {
     return graph.edges.filter((edge) => !tree.consumedEdgeIds.has(edge.id) &&

package/dist/nesting-span.js

@@ -0,0 +1,29 @@
+/**
+ * Whether an edge's two ends are nested one inside the other (#439, ADR 0139).
+ *
+ * Composition maps onto cytoscape's compound `parent`, so a pair that also
+ * carries any OTHER relationship produces an edge from a container to its own
+ * child. ELK cannot lay that out: measured on a five-concept model, the
+ * container and its child render and every unrelated node loses its geometry.
+ *
+ * Its own module rather than a helper inside `graph-canvas.tsx`, following
+ * `subject-filter.ts`: the canvas is type-checked with JSX and a test that
+ * imports it is not, so pure rules live where a test can reach them.
+ */
+export function spansNesting(from, to, parentOf) {
+    const climbs = (start, target) => {
+        // `resolveNestingParents` already refuses to nest a composition cycle, so
+        // a cycle should be unreachable here. Guarded anyway: the cost of being
+        // wrong is a frozen canvas rather than a bad picture.
+        const seen = new Set();
+        let at = parentOf.get(start);
+        while (at !== undefined && !seen.has(at)) {
+            if (at === target)
+                return true;
+            seen.add(at);
+            at = parentOf.get(at);
+        }
+        return false;
+    };
+    return climbs(from, to) || climbs(to, from);
+}

package/dist/{visual-app-lib/types/visual-app/subject-filter.d.ts → subject-filter.d.ts}

@@ -10,7 +10,7 @@
  * the canvas module registers cytoscape-elk. So the predicate lives in this
  * small pure module and both surfaces import it from here.
  */
-import type { CanvasNode } from "../graph-projection.js";
+import type { CanvasNode } from "./graph-projection.js";
 /**
  * The slice of a subject the predicate reads — the render data both the
  * canvas and the rail already hold.

package/dist/subject-filter.js

@@ -0,0 +1,31 @@
+/**
+ * Typed filter text made comparable: trimmed and lowercased, once, so every
+ * surface trims the same way before matching.
+ */
+export const normalizeFilterText = (text) => text.trim().toLowerCase();
+/**
+ * Whether a subject survives the typed text: case-insensitive, against its
+ * id, name, and kind label. `name` and `kindLabel` are `unknown` because the
+ * canvas reads them out of cytoscape data, which types nothing.
+ */
+export function subjectMatchesQuickFilter(trimmedLowerFilter, id, name, kindLabel) {
+    if (trimmedLowerFilter === "")
+        return true;
+    if (id.toLowerCase().includes(trimmedLowerFilter))
+        return true;
+    if (typeof name === "string" &&
+        name.toLowerCase().includes(trimmedLowerFilter)) {
+        return true;
+    }
+    return (typeof kindLabel === "string" &&
+        kindLabel.toLowerCase().includes(trimmedLowerFilter));
+}
+/**
+ * How many of these subjects survive the typed text — the number a tree row
+ * shows while the filter narrows (#317). With no text every subject
+ * survives, so this is also the plain length.
+ */
+export const countMatchingSubjects = (subjects, filterText) => {
+    const needle = normalizeFilterText(filterText);
+    return subjects.filter((subject) => subjectMatchesQuickFilter(needle, subject.id, subject.name, subject.kindLabel)).length;
+};

package/dist/visual-app-lib/editor.js

@@ -27210,7 +27210,7 @@ qh.use = function(e) {
 	return Tn(e);
 }, qh.version = qee, qh.stylesheet = qh.Stylesheet = Gh;
 //#endregion
-//#region src/visual-app/nesting-span.ts
+//#region src/nesting-span.ts
 function Jh(e, t, n) {
 	let r = (e, t) => {
 		let r = /* @__PURE__ */ new Set(), i = n.get(e);
@@ -27372,7 +27372,7 @@ function ote(e, t, n) {
 	};
 }
 //#endregion
-//#region src/visual-app/subject-filter.ts
+//#region src/subject-filter.ts
 var Xh = (e) => e.trim().toLowerCase();
 function Zh(e, t, n, r) {
 	return e === "" || t.toLowerCase().includes(e) || typeof n == "string" && n.toLowerCase().includes(e) ? !0 : typeof r == "string" && r.toLowerCase().includes(e);

package/dist/visual-app-lib/types/nesting-span.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Whether an edge's two ends are nested one inside the other (#439, ADR 0139).
+ *
+ * Composition maps onto cytoscape's compound `parent`, so a pair that also
+ * carries any OTHER relationship produces an edge from a container to its own
+ * child. ELK cannot lay that out: measured on a five-concept model, the
+ * container and its child render and every unrelated node loses its geometry.
+ *
+ * Its own module rather than a helper inside `graph-canvas.tsx`, following
+ * `subject-filter.ts`: the canvas is type-checked with JSX and a test that
+ * imports it is not, so pure rules live where a test can reach them.
+ */
+export declare function spansNesting(from: string, to: string, parentOf: ReadonlyMap<string, string>): boolean;

package/dist/visual-app-lib/types/subject-filter.d.ts

@@ -0,0 +1,35 @@
+/**
+ * The one substring judgement every surface that filters subjects by typed
+ * text shares.
+ *
+ * #307 extracted the predicate inside `graph-canvas.tsx` so the canvas pass
+ * and the shell's empty-state honesty could not drift; #317 lifts it here so
+ * the rail's tree filter can share it too. It cannot simply be imported from
+ * `graph-canvas.tsx`: the rail's tree model (`view-tree-model.ts`) keeps a
+ * zero-dependency discipline — no React, no cytoscape — and merely loading
+ * the canvas module registers cytoscape-elk. So the predicate lives in this
+ * small pure module and both surfaces import it from here.
+ */
+import type { CanvasNode } from "./graph-projection.js";
+/**
+ * The slice of a subject the predicate reads — the render data both the
+ * canvas and the rail already hold.
+ */
+export type FilterableSubject = Pick<CanvasNode, "id" | "name" | "kindLabel">;
+/**
+ * Typed filter text made comparable: trimmed and lowercased, once, so every
+ * surface trims the same way before matching.
+ */
+export declare const normalizeFilterText: (text: string) => string;
+/**
+ * Whether a subject survives the typed text: case-insensitive, against its
+ * id, name, and kind label. `name` and `kindLabel` are `unknown` because the
+ * canvas reads them out of cytoscape data, which types nothing.
+ */
+export declare function subjectMatchesQuickFilter(trimmedLowerFilter: string, id: string, name: unknown, kindLabel: unknown): boolean;
+/**
+ * How many of these subjects survive the typed text — the number a tree row
+ * shows while the filter narrows (#317). With no text every subject
+ * survives, so this is also the plain length.
+ */
+export declare const countMatchingSubjects: (subjects: readonly FilterableSubject[], filterText: string) => number;

package/dist/visual-app-lib/types/visual-app/view-tree-model.d.ts

@@ -15,7 +15,7 @@
 import type { CanvasNode } from "../graph-projection.js";
 import type { Layer } from "../profile.js";
 import type { VisualViewOperation, VisualViewSummary } from "../adapters/visual/protocol-contract.js";
-import { type FilterableSubject } from "./subject-filter.js";
+import { type FilterableSubject } from "../subject-filter.js";
 export declare const VIEWS_ROOT_KEY = "views";
 export declare const MODEL_ROOT_KEY = "model";
 /** Collapse keys are strings so one set holds every branch of both trees. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yarramate",
-  "version": "1.41.0",
+  "version": "1.41.1",
   "description": "Tool-neutral semantic architecture engine and guided methodology",
   "license": "MIT",
   "repository": {