@oxeo/visual 0.0.0-stage → 0.2.0

package/dist/layout/cards.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.relationRows = exports.rowCenter = exports.buildCard = exports.ownFieldsFirst = exports.textInset = exports.boxInset = exports.rowLevel = exports.textWidth = exports.BOX_PAD_AFTER = exports.BOX_GAP_BEFORE = exports.BOX_STEP = exports.HEADER_FONT = exports.ROW_FONT = exports.MONO_ADVANCE = void 0;
+exports.MONO_ADVANCE = 0.6;
+exports.ROW_FONT = 11;
+exports.HEADER_FONT = 13;
+exports.BOX_STEP = 6;
+exports.BOX_GAP_BEFORE = 5;
+exports.BOX_PAD_AFTER = 6;
+const textWidth = (text, size) => Math.ceil([...text].length * size * exports.MONO_ADVANCE);
+exports.textWidth = textWidth;
+const rowLevel = (row) => (row.kind === 'block' ? row.depth + 1 : row.depth);
+exports.rowLevel = rowLevel;
+const boxInset = (level) => level * exports.BOX_STEP;
+exports.boxInset = boxInset;
+const textInset = (level, spacing) => level === 0 ? spacing.cardPadX : (0, exports.boxInset)(level) + 8;
+exports.textInset = textInset;
+const truncate = (text, max) => text.length > max ? `${text.slice(0, max - 1)}…` : text;
+const detailOf = (field) => {
+    switch (field.kind) {
+        case 'id':
+            return `PK · ${field.type}`;
+        case 'ref':
+            return `→ ${field.target}`;
+        case 'set':
+            return `⇉ ${field.target}[]`;
+        case 'own':
+            return `◆ ${field.target}[]`;
+        case 'owner':
+            return `◆ ${field.target}`;
+        case 'embedded':
+            return field.type ?? 'embedded';
+    }
+    if (field.values?.length)
+        return truncate(field.values.join(' | '), 34);
+    const ts = field.tsType?.replace(/\s*\|\s*null$/, '');
+    return truncate(ts && ts !== field.type ? ts : (field.type ?? ''), 34);
+};
+const ownFieldsFirst = (fields) => [
+    ...fields.filter((f) => f.kind !== 'embedded'),
+    ...fields.filter((f) => f.kind === 'embedded')
+];
+exports.ownFieldsFirst = ownFieldsFirst;
+const buildCard = (entity, spacing) => {
+    const rows = [];
+    let y = spacing.cardHeader;
+    const push = (row) => {
+        rows.push({ ...row, y, h: spacing.cardRow });
+        y += spacing.cardRow;
+    };
+    const walk = (fields, depth, variant) => {
+        for (const field of (0, exports.ownFieldsFirst)(fields)) {
+            const row = {
+                path: field.path,
+                label: field.name,
+                detail: detailOf(field),
+                kind: field.kind === 'embedded' ? 'block' : field.kind,
+                depth,
+                target: field.target,
+                onDelete: field.onDelete,
+                nullable: field.nullable,
+                variant
+            };
+            if (field.kind !== 'embedded') {
+                push(row);
+                continue;
+            }
+            y += exports.BOX_GAP_BEFORE;
+            const index = rows.length;
+            push(row);
+            walk(field.fields ?? [], depth + 1, variant);
+            y += exports.BOX_PAD_AFTER;
+            rows[index].boxBottom = y;
+        }
+    };
+    walk(entity.fields, 0);
+    for (const v of entity.variants) {
+        y += exports.BOX_GAP_BEFORE;
+        push({
+            path: `@${v.value}`,
+            label: `${entity.discriminatorKey} = ${v.value}`,
+            detail: v.model,
+            kind: 'variant',
+            depth: 0,
+            variant: v.value
+        });
+        walk(v.fields, 0, v.value);
+    }
+    const rowWidth = (row) => (0, exports.textInset)((0, exports.rowLevel)(row), spacing) * 2 +
+        (0, exports.textWidth)(row.label + (row.nullable ? '?' : ''), exports.ROW_FONT) +
+        18 +
+        (0, exports.textWidth)(row.detail, exports.ROW_FONT);
+    const width = Math.max(spacing.cardMinWidth, (0, exports.textWidth)(entity.key, exports.HEADER_FONT) + 40, ...rows.map(rowWidth));
+    return {
+        key: entity.key,
+        entity,
+        rows,
+        width: Math.ceil(width / 2) * 2,
+        height: y + 4
+    };
+};
+exports.buildCard = buildCard;
+const rowCenter = (card, path, spacing) => {
+    const row = card.rows.find((r) => r.path === path);
+    return row ? row.y + row.h / 2 : spacing.cardHeader + spacing.cardRow / 2;
+};
+exports.rowCenter = rowCenter;
+const relationRows = (relation, cards) => {
+    const source = cards.get(relation.source);
+    const target = cards.get(relation.target);
+    if (relation.kind === 'own') {
+        return {
+            source,
+            sourcePath: relation.field,
+            target,
+            targetPath: relation.ownerField ?? target.entity.idKey
+        };
+    }
+    return { source, sourcePath: relation.field, target, targetPath: target.entity.idKey };
+};
+exports.relationRows = relationRows;

package/dist/layout/place.d.ts

@@ -0,0 +1,40 @@
+import type { Spacing, VisualConfig, ZoneConfig } from '../config';
+import type { SchemeModel } from '../model';
+import { type Card } from './cards';
+export interface Box {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export interface PlacedCard extends Box {
+    card: Card;
+    zone: string;
+}
+export interface FileBox extends Box {
+    file: string;
+    namespace?: string;
+    zone: string;
+}
+export interface ZoneBox extends Box {
+    zone: ZoneConfig;
+    meta: string;
+}
+export interface LabelBox extends Box {
+    kind: 'zone' | 'file';
+}
+export interface Placement {
+    width: number;
+    height: number;
+    cards: Map<string, PlacedCard>;
+    files: FileBox[];
+    zones: ZoneBox[];
+    labels: LabelBox[];
+}
+export declare const FALLBACK_ZONE = "?";
+export declare const ZONE_TITLE_FONT = 20;
+export declare const ZONE_META_FONT = 12;
+export declare const FILE_LABEL_FONT = 11;
+export declare const fileLabel: (file: string, namespace?: string) => string;
+export declare const uiTextWidth: (text: string, size: number) => number;
+export declare const place: (model: SchemeModel, cards: Map<string, Card>, config: VisualConfig, spacing: Spacing) => Placement;

package/dist/layout/place.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.place = exports.uiTextWidth = exports.fileLabel = exports.FILE_LABEL_FONT = exports.ZONE_META_FONT = exports.ZONE_TITLE_FONT = exports.FALLBACK_ZONE = void 0;
+const text_1 = require("../text");
+const cards_1 = require("./cards");
+exports.FALLBACK_ZONE = '?';
+exports.ZONE_TITLE_FONT = 20;
+exports.ZONE_META_FONT = 12;
+exports.FILE_LABEL_FONT = 11;
+const fileLabel = (file, namespace) => namespace ? `${file} · ${namespace}` : file;
+exports.fileLabel = fileLabel;
+const uiTextWidth = (text, size) => Math.ceil([...text].length * size * 0.62);
+exports.uiTextWidth = uiTextWidth;
+const offset = (block, dx, dy) => block.items.map((item) => ({ key: item.key, x: item.x + dx, y: item.y + dy }));
+const layoutFile = (keys, model, cards, spacing, aspect) => {
+    const inFile = new Set(keys);
+    const children = new Map();
+    const owned = new Set();
+    for (const relation of model.relations) {
+        if (relation.kind !== 'own' || !inFile.has(relation.source) || !inFile.has(relation.target))
+            continue;
+        if (owned.has(relation.target) || relation.source === relation.target)
+            continue;
+        owned.add(relation.target);
+        children.set(relation.source, [...(children.get(relation.source) ?? []), relation.target]);
+    }
+    const tree = (key) => {
+        const card = cards.get(key);
+        const kids = (children.get(key) ?? []).map(tree);
+        if (!kids.length)
+            return { w: card.width, h: card.height, items: [{ key, x: 0, y: 0 }] };
+        const x0 = card.width + spacing.cardGapX;
+        const items = [{ key, x: 0, y: 0 }];
+        let y = 0;
+        for (const kid of kids) {
+            items.push(...offset(kid, x0, y));
+            y += kid.h + spacing.cardGapY;
+        }
+        const kidsHeight = y - spacing.cardGapY;
+        return { w: x0 + Math.max(...kids.map((k) => k.w)), h: Math.max(card.height, kidsHeight), items };
+    };
+    const roots = keys.filter((key) => !owned.has(key)).map(tree);
+    const columns = (limit) => {
+        const placed = [];
+        let x = 0;
+        let y = 0;
+        let columnWidth = 0;
+        let width = 0;
+        let height = 0;
+        for (const block of roots) {
+            if (y > 0 && y + block.h > limit) {
+                x += columnWidth + spacing.cardGapX;
+                y = 0;
+                columnWidth = 0;
+            }
+            placed.push(...offset(block, x, y));
+            columnWidth = Math.max(columnWidth, block.w);
+            height = Math.max(height, y + block.h);
+            width = Math.max(width, x + block.w);
+            y += block.h + spacing.cardGapY;
+        }
+        return { w: width, h: height, items: placed };
+    };
+    const tallest = Math.max(...roots.map((b) => b.h));
+    const total = roots.reduce((sum, b) => sum + b.h + spacing.cardGapY, 0);
+    let best = null;
+    for (let limit = tallest; limit <= total + 1; limit += 20) {
+        const candidate = columns(limit);
+        const score = Math.abs(Math.log(candidate.w / candidate.h / aspect));
+        const bestScore = best ? Math.abs(Math.log(best.w / best.h / aspect)) : Infinity;
+        if (score < bestScore - 1e-6)
+            best = candidate;
+    }
+    return best ?? columns(total);
+};
+const place = (model, cards, config, spacing) => {
+    const byFile = new Map();
+    for (const entity of model.entities)
+        byFile.set(entity.file, [...(byFile.get(entity.file) ?? []), entity.key]);
+    const zones = config.zones.map((zone) => ({
+        ...zone,
+        files: zone.files.map((row) => row.filter((f) => byFile.has(f)))
+    }));
+    const assigned = new Set(zones.flatMap((z) => z.files.flat()));
+    const rest = model.files.map((f) => f.file).filter((file) => !assigned.has(file));
+    const bands = config.bands.map((band) => [...band]);
+    if (rest.length) {
+        console.warn(`  ! файлы без зоны в конфиге: ${rest.join(', ')}`);
+        zones.push({ id: exports.FALLBACK_ZONE, title: 'Без зоны', color: '#6b6b76', files: [rest] });
+        bands.push([exports.FALLBACK_ZONE]);
+    }
+    const namespaceOf = new Map(model.files.map((f) => [f.file, f.namespace]));
+    const zoneLayouts = new Map(zones.map((zone) => {
+        const rows = zone.files
+            .filter((row) => row.length)
+            .map((row) => row.map((file) => {
+            const block = layoutFile(byFile.get(file), model, cards, spacing, 1.5);
+            const label = (0, exports.fileLabel)(file, namespaceOf.get(file));
+            const w = Math.max(block.w, (0, cards_1.textWidth)(label, exports.FILE_LABEL_FONT) + 8) + spacing.filePadX * 2;
+            const h = block.h + spacing.filePadTop + spacing.filePadBottom;
+            return { file, block, w, h };
+        }));
+        const rowWidth = (row) => row.reduce((s, f) => s + f.w, 0) + spacing.fileGap * (row.length - 1);
+        const contentW = Math.max(...rows.map(rowWidth), (0, exports.uiTextWidth)(`${zone.id} · ${zone.title}`, exports.ZONE_TITLE_FONT));
+        const contentH = rows.reduce((s, row) => s + Math.max(...row.map((f) => f.h)), 0) +
+            spacing.fileGap * (rows.length - 1);
+        return [
+            zone.id,
+            {
+                zone,
+                rows,
+                rowWidth,
+                w: contentW + spacing.zonePadX * 2,
+                h: contentH + spacing.zonePadTop + spacing.zonePadBottom
+            }
+        ];
+    }));
+    const bandWidth = (band) => band.reduce((s, id) => s + zoneLayouts.get(id).w, 0) + spacing.zoneGap * (band.length - 1);
+    const validBands = bands
+        .map((band) => band.filter((id) => zoneLayouts.has(id)))
+        .filter((band) => band.length);
+    const mapWidth = Math.max(...validBands.map(bandWidth));
+    const placement = {
+        width: 0,
+        height: 0,
+        cards: new Map(),
+        files: [],
+        zones: [],
+        labels: []
+    };
+    let y = spacing.margin;
+    for (const band of validBands) {
+        const natural = bandWidth(band);
+        const naturalZones = band.reduce((s, id) => s + zoneLayouts.get(id).w, 0);
+        const bandHeight = Math.max(...band.map((id) => zoneLayouts.get(id).h));
+        let x = spacing.margin;
+        for (const id of band) {
+            const layout = zoneLayouts.get(id);
+            const w = layout.w + ((mapWidth - natural) * layout.w) / naturalZones;
+            const files = layout.rows.flat();
+            const count = files.reduce((s, f) => s + f.block.items.length, 0);
+            const meta = `${(0, text_1.plural)(files.length, ['файл', 'файла', 'файлов'])} · ${(0, text_1.plural)(count, ['коллекция', 'коллекции', 'коллекций'])}`;
+            placement.zones.push({ zone: layout.zone, meta, x, y, w, h: bandHeight });
+            placement.labels.push({
+                kind: 'zone',
+                x: x + spacing.zonePadX - 6,
+                y: y + 12,
+                w: (0, exports.uiTextWidth)(`${layout.zone.id} · ${layout.zone.title}`, exports.ZONE_TITLE_FONT) +
+                    24 +
+                    (0, exports.uiTextWidth)(meta, exports.ZONE_META_FONT),
+                h: 36
+            });
+            const contentWidth = Math.max(...layout.rows.map(layout.rowWidth));
+            let fy = y + spacing.zonePadTop;
+            for (const row of layout.rows) {
+                let fx = x + (w - contentWidth) / 2;
+                for (const file of row) {
+                    placement.files.push({
+                        file: file.file,
+                        namespace: namespaceOf.get(file.file),
+                        zone: id,
+                        x: fx,
+                        y: fy,
+                        w: file.w,
+                        h: file.h
+                    });
+                    placement.labels.push({
+                        kind: 'file',
+                        x: fx + spacing.filePadX - 4,
+                        y: fy - 12,
+                        w: (0, cards_1.textWidth)((0, exports.fileLabel)(file.file, namespaceOf.get(file.file)), exports.FILE_LABEL_FONT) + 8,
+                        h: 38
+                    });
+                    for (const item of file.block.items) {
+                        const card = cards.get(item.key);
+                        placement.cards.set(item.key, {
+                            card,
+                            zone: id,
+                            x: fx + spacing.filePadX + item.x,
+                            y: fy + spacing.filePadTop + item.y,
+                            w: card.width,
+                            h: card.height
+                        });
+                    }
+                    fx += file.w + spacing.fileGap;
+                }
+                fy += Math.max(...row.map((f) => f.h)) + spacing.fileGap;
+            }
+            x += w + spacing.zoneGap;
+        }
+        y += bandHeight + spacing.bandGap;
+    }
+    placement.width = mapWidth + spacing.margin * 2;
+    placement.height = y - spacing.bandGap + spacing.margin;
+    return placement;
+};
+exports.place = place;

package/dist/layout/route.d.ts

@@ -0,0 +1,30 @@
+import type { Spacing } from '../config';
+import type { Relation } from '../model';
+import { type Card } from './cards';
+import type { Placement } from './place';
+export type Point = [number, number];
+export interface Route {
+    relation: Relation;
+    points: Point[];
+}
+export interface RoutingMetrics {
+    routes: number;
+    failed: number;
+    hugging: number;
+    cleared: number;
+    cardHits: number;
+    crossings: number;
+    length: number;
+    ms: number;
+}
+export interface RoutingOptions {
+    shapeBuffer: number;
+    nudging: number;
+    segmentPenalty: number;
+    crossingPenalty: number;
+}
+export declare const DEFAULT_ROUTING: RoutingOptions;
+export declare const routeRelations: (relations: Relation[], placement: Placement, cards: Map<string, Card>, spacing: Spacing, options?: RoutingOptions) => Promise<{
+    routes: Route[];
+    metrics: RoutingMetrics;
+}>;

package/dist/layout/route.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeRelations = exports.DEFAULT_ROUTING = void 0;
+const cards_1 = require("./cards");
+exports.DEFAULT_ROUTING = {
+    shapeBuffer: 10,
+    nudging: 6,
+    segmentPenalty: 60,
+    crossingPenalty: 80
+};
+const importEsm = new Function('specifier', 'return import(specifier)');
+let avoidPromise = null;
+const loadAvoid = () => {
+    avoidPromise ??= importEsm('libavoid-js').then(async ({ AvoidLib }) => {
+        await AvoidLib.load();
+        return AvoidLib.getInstance();
+    });
+    return avoidPromise;
+};
+const segmentsOf = (points) => points.slice(1).map((p, i) => [points[i], p]);
+const hitsBox = ([a, b], box) => {
+    const inset = 1;
+    const x1 = Math.min(a[0], b[0]);
+    const x2 = Math.max(a[0], b[0]);
+    const y1 = Math.min(a[1], b[1]);
+    const y2 = Math.max(a[1], b[1]);
+    return (x2 > box.x + inset && x1 < box.x + box.w - inset && y2 > box.y + inset && y1 < box.y + box.h - inset);
+};
+const crosses = ([a, b], [c, d]) => {
+    const horizontal = a[1] === b[1];
+    const otherHorizontal = c[1] === d[1];
+    if (horizontal === otherHorizontal)
+        return false;
+    const [h1, h2, v1, v2] = horizontal ? [a, b, c, d] : [c, d, a, b];
+    const x = v1[0];
+    const y = h1[1];
+    const inside = (value, p, q) => value > Math.min(p, q) + 0.5 && value < Math.max(p, q) - 0.5;
+    return inside(x, h1[0], h2[0]) && inside(y, v1[1], v2[1]);
+};
+const BORDER_GAP = 8;
+const overlap = (a1, a2, b1, b2) => Math.min(Math.max(a1, a2), Math.max(b1, b2)) - Math.max(Math.min(a1, a2), Math.min(b1, b2));
+const bordersOf = (placement) => [...placement.zones, ...placement.files].flatMap((b) => [
+    { horizontal: true, at: b.y, from: b.x, to: b.x + b.w },
+    { horizontal: true, at: b.y + b.h, from: b.x, to: b.x + b.w },
+    { horizontal: false, at: b.x, from: b.y, to: b.y + b.h },
+    { horizontal: false, at: b.x + b.w, from: b.y, to: b.y + b.h }
+]);
+const clearBorders = (routes, placement, nudging) => {
+    const borders = bordersOf(placement);
+    const boxes = [...placement.cards.values()];
+    const huggingBorder = (horizontal, at, from, to) => borders.find((b) => b.horizontal === horizontal &&
+        Math.abs(b.at - at) < BORDER_GAP - 0.5 &&
+        overlap(from, to, b.from, b.to) > 10);
+    const tooClose = (route, horizontal, at, from, to) => routes.some((other) => other !== route &&
+        segmentsOf(other.points).some(([a, b]) => {
+            const parallel = horizontal ? Math.abs(a[1] - b[1]) < 0.5 : Math.abs(a[0] - b[0]) < 0.5;
+            if (!parallel)
+                return false;
+            const otherAt = horizontal ? a[1] : a[0];
+            const range = horizontal ? overlap(from, to, a[0], b[0]) : overlap(from, to, a[1], b[1]);
+            return Math.abs(otherAt - at) < nudging - 1 && range > 0;
+        }));
+    let hugging = 0;
+    let cleared = 0;
+    for (const route of routes) {
+        const p = route.points;
+        for (let i = 1; i < p.length - 2; i++) {
+            const [a, b] = [p[i], p[i + 1]];
+            const horizontal = Math.abs(a[1] - b[1]) < 0.5;
+            if (!horizontal && Math.abs(a[0] - b[0]) >= 0.5)
+                continue;
+            const axis = horizontal ? 1 : 0;
+            const at = a[axis];
+            const from = horizontal ? a[0] : a[1];
+            const to = horizontal ? b[0] : b[1];
+            const border = huggingBorder(horizontal, at, from, to);
+            if (!border)
+                continue;
+            hugging++;
+            const side = at >= border.at ? 1 : -1;
+            for (const target of [border.at + side * BORDER_GAP, border.at - side * BORDER_GAP]) {
+                const keeps = (q, edge) => Math.sign(at - q[axis]) === Math.sign(target - q[axis]) &&
+                    Math.abs(target - q[axis]) >= (edge ? 14 : 4);
+                if (!keeps(p[i - 1], i === 1) || !keeps(p[i + 2], i + 2 === p.length - 1))
+                    continue;
+                const moved = (q) => (horizontal ? [q[0], target] : [target, q[1]]);
+                const changed = [
+                    [p[i - 1], moved(a)],
+                    [moved(a), moved(b)],
+                    [moved(b), p[i + 2]]
+                ];
+                if (changed.some((segment) => boxes.some((box) => hitsBox(segment, box))))
+                    continue;
+                if (huggingBorder(horizontal, target, from, to) ||
+                    tooClose(route, horizontal, target, from, to))
+                    continue;
+                p[i] = moved(a);
+                p[i + 1] = moved(b);
+                cleared++;
+                break;
+            }
+        }
+    }
+    return { hugging, cleared };
+};
+const routeRelations = async (relations, placement, cards, spacing, options = exports.DEFAULT_ROUTING) => {
+    const started = Date.now();
+    const A = await loadAvoid();
+    const router = new A.Router(A.OrthogonalRouting);
+    router.setRoutingParameter(A.shapeBufferDistance, options.shapeBuffer);
+    router.setRoutingParameter(A.idealNudgingDistance, options.nudging);
+    router.setRoutingParameter(A.segmentPenalty, options.segmentPenalty);
+    if (options.crossingPenalty > 0)
+        router.setRoutingParameter(A.crossingPenalty, options.crossingPenalty);
+    router.setRoutingOption(A.nudgeOrthogonalSegmentsConnectedToShapes, false);
+    router.setRoutingOption(A.nudgeSharedPathsWithCommonEndPoint, true);
+    router.setRoutingOption(A.nudgeOrthogonalTouchingColinearSegments, true);
+    const rect = (box) => new A.ShapeRef(router, new A.Rectangle(new A.Point(box.x, box.y), new A.Point(box.x + box.w, box.y + box.h)));
+    const shapes = new Map();
+    for (const [key, placed] of placement.cards)
+        shapes.set(key, rect(placed));
+    for (const label of placement.labels)
+        rect(label);
+    const pinClasses = new Map();
+    const pinFor = (key, path, role) => {
+        const id = `${key}|${path}|${role}`;
+        const known = pinClasses.get(id);
+        if (known)
+            return known;
+        const classId = pinClasses.size + 1;
+        pinClasses.set(id, classId);
+        const card = cards.get(key);
+        const shape = shapes.get(key);
+        const y = (0, cards_1.rowCenter)(card, path, spacing) / card.height;
+        const pin = (x, py, dir) => new A.ShapeConnectionPin(shape, classId, x, py, true, 0, dir).setExclusive(false);
+        pin(0, y, A.ConnDirLeft);
+        pin(1, y, A.ConnDirRight);
+        if (role === 'key') {
+            pin(0.5, 0, A.ConnDirUp);
+            pin(0.5, 1, A.ConnDirDown);
+        }
+        return classId;
+    };
+    const connectors = relations
+        .filter((r) => placement.cards.has(r.source) && placement.cards.has(r.target))
+        .map((relation) => {
+        const { source, sourcePath, target, targetPath } = (0, cards_1.relationRows)(relation, cards);
+        const from = pinFor(source.key, sourcePath, 'out');
+        const to = pinFor(target.key, targetPath, relation.kind === 'own' ? 'in' : 'key');
+        const conn = new A.ConnRef(router, new A.ConnEnd(shapes.get(source.key), from), new A.ConnEnd(shapes.get(target.key), to));
+        return { relation, conn };
+    });
+    router.processTransaction();
+    const routes = connectors.map(({ relation, conn }) => {
+        const line = conn.displayRoute();
+        const points = [];
+        for (let i = 0; i < line.size(); i++) {
+            const p = line.get_ps(i);
+            points.push([Math.round(p.x * 10) / 10, Math.round(p.y * 10) / 10]);
+        }
+        return { relation, points };
+    });
+    const { hugging, cleared } = clearBorders(routes, placement, options.nudging);
+    const boxes = [...placement.cards.values()];
+    const segments = routes.map((r) => segmentsOf(r.points));
+    let cardHits = 0;
+    let crossings = 0;
+    segments.forEach((list, i) => {
+        for (const segment of list)
+            cardHits += boxes.filter((box) => hitsBox(segment, box)).length;
+        for (let j = i + 1; j < segments.length; j++) {
+            for (const a of list)
+                for (const b of segments[j])
+                    if (crosses(a, b))
+                        crossings++;
+        }
+    });
+    return {
+        routes,
+        metrics: {
+            routes: routes.length,
+            failed: routes.filter((r) => r.points.length < 2).length,
+            hugging,
+            cleared,
+            cardHits,
+            crossings,
+            length: Math.round(segments.flat().reduce((s, [a, b]) => s + Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1]), 0)),
+            ms: Date.now() - started
+        }
+    };
+};
+exports.routeRelations = routeRelations;

package/dist/model.d.ts

@@ -0,0 +1,60 @@
+export type OnDelete = 'cascade' | 'restrict' | 'set-null' | 'unlink';
+export type FieldKind = 'id' | 'prop' | 'embedded' | 'ref' | 'set' | 'own' | 'owner';
+export interface Field {
+    name: string;
+    path: string;
+    kind: FieldKind;
+    type?: string;
+    tsType?: string;
+    decorators?: string[];
+    typeRefs?: string[];
+    nullable?: boolean;
+    values?: (string | number)[];
+    target?: string;
+    onDelete?: OnDelete;
+    ownerField?: string;
+    doc?: string;
+    fields?: Field[];
+}
+export interface Variant {
+    value: string;
+    model: string;
+    doc?: string;
+    decorators?: string[];
+    fields: Field[];
+}
+export interface Entity {
+    key: string;
+    model: string;
+    file: string;
+    namespace?: string;
+    order: number;
+    idKey: string;
+    idType: string;
+    discriminatorKey?: string;
+    doc?: string;
+    decorators?: string[];
+    fields: Field[];
+    variants: Variant[];
+}
+export type RelationKind = 'own' | 'ref' | 'set';
+export interface Relation {
+    id: string;
+    source: string;
+    target: string;
+    kind: RelationKind;
+    field: string;
+    ownerField?: string;
+    onDelete: OnDelete;
+    nullable: boolean;
+    variant?: string;
+}
+export interface SchemeModel {
+    entities: Entity[];
+    relations: Relation[];
+    files: {
+        file: string;
+        namespace?: string;
+    }[];
+    types: Record<string, string>;
+}

package/dist/model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/project.d.ts

@@ -0,0 +1,14 @@
+import type { VisualConfig } from './config';
+import type { SchemeSource } from './scheme-meta';
+export interface OxeoVisualConfig extends VisualConfig {
+    scheme: SchemeSource;
+    sourceDir: string;
+    tsconfig?: string;
+    watch?: string[];
+    output?: {
+        dir?: string;
+        name?: string;
+    };
+}
+export declare const defineConfig: (config: OxeoVisualConfig) => OxeoVisualConfig;
+export declare const CONFIG_FILES: string[];

package/dist/project.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG_FILES = exports.defineConfig = void 0;
+const defineConfig = (config) => config;
+exports.defineConfig = defineConfig;
+exports.CONFIG_FILES = [
+    'oxeo-visual.config.ts',
+    'oxeo-visual.config.cts',
+    'oxeo-visual.config.js',
+    'oxeo-visual.config.cjs'
+];