@oxeo/visual 0.0.0-stage → 0.2.0

package/dist/cli/output.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeBuild = exports.firstLine = exports.log = void 0;
+const text_1 = require("../text");
+const time = () => new Date().toTimeString().slice(0, 8);
+const log = (message) => console.log(`${time()} [oxeo-visual] ${message}`);
+exports.log = log;
+const firstLine = (text) => text.split('\n')[0].replace(/^Error:\s*/, '');
+exports.firstLine = firstLine;
+const describeBuild = (metrics, ms) => `✓ карта собрана: ${(0, text_1.plural)(metrics.cards, ['коллекция', 'коллекции', 'коллекций'])}, ` +
+    `${(0, text_1.plural)(metrics.all.routes, ['связь', 'связи', 'связей'])}, карта ${metrics.width}×${metrics.height} · ` +
+    `${(ms / 1000).toFixed(1)} с`;
+exports.describeBuild = describeBuild;

package/dist/cli/run.d.ts

@@ -0,0 +1,7 @@
+import { type ChildProcess } from 'child_process';
+import type { WorkerMessage } from './worker';
+export interface BuildRun {
+    child: ChildProcess;
+    done: Promise<WorkerMessage>;
+}
+export declare const startBuild: (configPath: string) => BuildRun;

package/dist/cli/run.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startBuild = void 0;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const startBuild = (configPath) => {
+    const child = (0, child_process_1.fork)(path.join(__dirname, 'worker.js'), [configPath], {
+        stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
+        execArgv: []
+    });
+    const done = new Promise((resolve) => {
+        let message = null;
+        child.on('message', (m) => (message = m));
+        child.on('error', (error) => resolve({ type: 'error', message: error.message }));
+        child.on('exit', (code, signal) => resolve(message ?? {
+            type: 'error',
+            message: signal ? `сборка прервана (${signal})` : `сборка завершилась с кодом ${code}`
+        }));
+    });
+    return { child, done };
+};
+exports.startBuild = startBuild;

package/dist/cli/worker.d.ts

@@ -0,0 +1,20 @@
+import { type SchemeMapResult } from '../build';
+export interface BuildSettings {
+    configDir: string;
+    sourceDir: string;
+    watch: string[];
+    output: {
+        dir: string;
+        name: string;
+    };
+}
+export type WorkerMessage = {
+    type: 'result';
+    html: string;
+    svg: string;
+    metrics: SchemeMapResult['metrics'];
+    settings: BuildSettings;
+} | {
+    type: 'error';
+    message: string;
+};

package/dist/cli/worker.js

@@ -0,0 +1,94 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const build_1 = require("../build");
+const isTypeScript = (file) => /\.(c|m)?ts$/.test(file);
+const registerTypeScript = (configPath) => {
+    const dir = path.dirname(configPath);
+    let tsNode;
+    try {
+        tsNode = require.resolve('ts-node', { paths: [dir] });
+    }
+    catch {
+        throw new Error(`${path.basename(configPath)} написан на TypeScript, а ts-node в проекте не найден. Установите его: npm i -D ts-node`);
+    }
+    require(tsNode).register({
+        project: ts.findConfigFile(dir, ts.sys.fileExists),
+        transpileOnly: true,
+        compilerOptions: { module: 'commonjs' }
+    });
+};
+const run = async (configPath) => {
+    if (isTypeScript(configPath))
+        registerTypeScript(configPath);
+    const loaded = require(configPath);
+    const config = loaded?.default ?? loaded;
+    if (!config?.scheme) {
+        throw new Error(`${path.basename(configPath)}: не задана схема — экспортируйте defineConfig({ scheme, ... })`);
+    }
+    const dir = path.dirname(configPath);
+    const resolve = (p) => path.resolve(dir, p);
+    const sourceDir = resolve(config.sourceDir);
+    const tsconfig = config.tsconfig
+        ? resolve(config.tsconfig)
+        : ts.findConfigFile(dir, ts.sys.fileExists);
+    const result = await (0, build_1.buildSchemeMap)(config.scheme, { sourceDir, tsconfig, config });
+    return {
+        type: 'result',
+        html: result.html,
+        svg: result.svg,
+        metrics: result.metrics,
+        settings: {
+            configDir: dir,
+            sourceDir,
+            watch: [...new Set([dir, sourceDir, ...(config.watch ?? []).map(resolve)])],
+            output: { dir: resolve(config.output?.dir ?? '.'), name: config.output?.name ?? 'scheme-map' }
+        }
+    };
+};
+const send = (message) => {
+    if (process.send)
+        process.send(message, () => process.exit(message.type === 'result' ? 0 : 1));
+    else
+        process.exit(message.type === 'result' ? 0 : 1);
+};
+run(path.resolve(process.argv[2]))
+    .then(send)
+    .catch((error) => send({
+    type: 'error',
+    message: error instanceof Error ? (error.stack ?? error.message) : String(error)
+}));

package/dist/config.d.ts

@@ -0,0 +1,33 @@
+export interface ZoneConfig {
+    id: string;
+    title: string;
+    color: string;
+    colorDark?: string;
+    files: string[][];
+}
+export interface Spacing {
+    cardHeader: number;
+    cardRow: number;
+    cardPadX: number;
+    cardMinWidth: number;
+    cardGapX: number;
+    cardGapY: number;
+    filePadTop: number;
+    filePadX: number;
+    filePadBottom: number;
+    fileGap: number;
+    zonePadTop: number;
+    zonePadX: number;
+    zonePadBottom: number;
+    zoneGap: number;
+    bandGap: number;
+    margin: number;
+}
+export declare const DEFAULT_SPACING: Spacing;
+export interface VisualConfig {
+    zones: ZoneConfig[];
+    bands: string[][];
+    hubMinSources?: number;
+    spacing?: Partial<Spacing>;
+}
+export declare const resolveSpacing: (config: VisualConfig) => Spacing;

package/dist/config.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveSpacing = exports.DEFAULT_SPACING = void 0;
+exports.DEFAULT_SPACING = {
+    cardHeader: 30,
+    cardRow: 20,
+    cardPadX: 10,
+    cardMinWidth: 200,
+    cardGapX: 56,
+    cardGapY: 24,
+    filePadTop: 44,
+    filePadX: 30,
+    filePadBottom: 30,
+    fileGap: 56,
+    zonePadTop: 80,
+    zonePadX: 24,
+    zonePadBottom: 24,
+    zoneGap: 96,
+    bandGap: 110,
+    margin: 40
+};
+const resolveSpacing = (config) => ({
+    ...exports.DEFAULT_SPACING,
+    ...config.spacing
+});
+exports.resolveSpacing = resolveSpacing;

package/dist/extract.d.ts

@@ -0,0 +1,8 @@
+import type { SchemeSource } from './scheme-meta';
+import type { SchemeModel } from './model';
+export interface ExtractOptions {
+    sourceDir: string;
+    tsconfig?: string;
+}
+export declare const reflow: (text: string) => string;
+export declare const extractScheme: (dataScheme: SchemeSource, options: ExtractOptions) => SchemeModel;

package/dist/extract.js

@@ -0,0 +1,300 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractScheme = exports.reflow = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ts = __importStar(require("typescript"));
+const types_1 = require("./types");
+const oneLine = (text) => text
+    .replace(/\s+/g, ' ')
+    .replace(/([([]) /g, '$1')
+    .replace(/ ([)\]])/g, '$1');
+const LIST_ITEM = /^([-*•]|\d+[.)])\s/;
+const reflow = (text) => text
+    .split(/\n[ \t]*\n/)
+    .map((paragraph) => {
+    let out = '';
+    for (const line of paragraph.split('\n').map((l) => l.trim())) {
+        if (!line)
+            continue;
+        out = !out ? line : LIST_ITEM.test(line) ? `${out}\n${line}` : `${out} ${line}`;
+    }
+    return out;
+})
+    .filter(Boolean)
+    .join('\n\n');
+exports.reflow = reflow;
+const jsDoc = (node) => {
+    const text = (0, exports.reflow)(ts
+        .getJSDocCommentsAndTags(node)
+        .filter(ts.isJSDoc)
+        .map((d) => ts.getTextOfJSDocComment(d.comment) ?? '')
+        .join('\n\n'));
+    return text || undefined;
+};
+const schemeFiles = (sourceDir) => fs.readdirSync(sourceDir).filter((f) => f.endsWith('.ts') && !f.endsWith('.d.ts'));
+const parseSources = (sourceDir, program) => {
+    const classes = new Map();
+    for (const file of schemeFiles(sourceDir)) {
+        const source = program.getSourceFile(path.join(sourceDir, file));
+        if (!source)
+            continue;
+        const visit = (node, namespace) => {
+            if (ts.isModuleDeclaration(node) && ts.isIdentifier(node.name)) {
+                ts.forEachChild(node, (child) => visit(child, node.name.getText(source)));
+                return;
+            }
+            if (ts.isClassDeclaration(node) && node.name) {
+                const decorator = (ts.getDecorators(node) ?? [])
+                    .map((d) => ts.isCallExpression(d.expression) ? d.expression.expression.getText(source) : null)
+                    .find((name) => name !== null);
+                const props = new Map();
+                node.members.forEach((member, order) => {
+                    if (ts.isPropertyDeclaration(member) && member.name) {
+                        props.set(member.name.getText(source), {
+                            doc: jsDoc(member),
+                            order,
+                            tsType: member.type?.getText(source).replace(/\s+/g, ' '),
+                            typeNode: member.type,
+                            decorators: (ts.getDecorators(member) ?? []).map((d) => oneLine(d.getText(source)))
+                        });
+                    }
+                });
+                const list = classes.get(node.name.text) ?? [];
+                list.push({
+                    file,
+                    namespace,
+                    decorator: decorator ?? null,
+                    decorators: (ts.getDecorators(node) ?? []).map((d) => oneLine(d.getText(source))),
+                    doc: jsDoc(node),
+                    props
+                });
+                classes.set(node.name.text, list);
+            }
+            ts.forEachChild(node, (child) => visit(child, namespace));
+        };
+        visit(source);
+    }
+    return (target, embedded) => {
+        const list = classes.get(target.name);
+        if (!list)
+            return undefined;
+        return list.find((c) => (c.decorator === 'Embedded') === embedded) ?? list[0];
+    };
+};
+const extractScheme = (dataScheme, options) => {
+    const collections = dataScheme.collectionsScheme;
+    const models = dataScheme.models;
+    const keyByModel = new Map(Object.entries(collections).map(([key, info]) => [info.name, key]));
+    const program = ts.createProgram(schemeFiles(options.sourceDir).map((f) => path.join(options.sourceDir, f)), (0, types_1.compilerOptions)(options.tsconfig));
+    const catalog = new types_1.TypeCatalog(program);
+    const findSource = parseSources(options.sourceDir, program);
+    const onDeleteOf = (consumerModel, address, targetModel) => {
+        const inverse = models[targetModel]?.refscheme.inverseRefs.find((ref) => ref.model === consumerModel && ref.modelConsumerProperty === address);
+        return inverse?.onDeleteBehavior ?? 'restrict';
+    };
+    const typeOf = (primitive) => primitive.type === 'array' ? `array<${primitive.itemType}>` : primitive.type;
+    const buildFields = (props, prefix, refs, modelName) => {
+        const ordered = [];
+        const sourceOf = (target, key) => {
+            const prop = findSource(target, prefix !== '')?.props.get(key);
+            return {
+                doc: prop?.doc,
+                tsType: prop?.tsType,
+                typeNode: prop?.typeNode,
+                decorators: prop?.decorators.length ? prop.decorators : undefined,
+                order: prop?.order ?? Number.MAX_SAFE_INTEGER
+            };
+        };
+        for (const prop of props.properties) {
+            const address = prefix + prop.propertyKey;
+            const { doc, tsType, typeNode, decorators, order } = sourceOf(prop.target, prop.propertyKey);
+            const primitive = prop.primitive;
+            if (primitive.type === 'embedded') {
+                const inner = [...primitive.properties, ...primitive.references][0]?.target;
+                const classDoc = inner && findSource(inner, true)?.doc;
+                ordered.push({
+                    order,
+                    field: {
+                        name: prop.propertyKey,
+                        path: address,
+                        kind: 'embedded',
+                        type: inner?.name,
+                        decorators,
+                        doc: [doc, classDoc].filter(Boolean).join('\n\n') || undefined,
+                        fields: buildFields(primitive, address + '.', refs, modelName)
+                    }
+                });
+                continue;
+            }
+            ordered.push({
+                order,
+                field: {
+                    name: prop.propertyKey,
+                    path: address,
+                    kind: 'prop',
+                    type: typeOf(primitive),
+                    tsType,
+                    decorators,
+                    typeRefs: primitive.type === 'json' || (primitive.type === 'array' && primitive.itemType === 'json')
+                        ? catalog.refsOf(typeNode)
+                        : undefined,
+                    nullable: 'nullable' in primitive ? primitive.nullable : undefined,
+                    values: 'values' in primitive ? primitive.values : undefined,
+                    doc
+                }
+            });
+        }
+        for (const relation of props.references) {
+            const address = prefix + relation.propertyKey;
+            const { doc, decorators, order } = sourceOf(relation.target, relation.propertyKey);
+            const ref = refs[address];
+            const targetModel = ref?.model ?? relation.referenceModel().name;
+            const base = {
+                name: relation.propertyKey,
+                path: address,
+                target: keyByModel.get(targetModel),
+                decorators,
+                doc
+            };
+            if (ref?.refType === 'reference-to') {
+                ordered.push({
+                    order,
+                    field: {
+                        ...base,
+                        kind: 'ref',
+                        nullable: ref.nullable,
+                        onDelete: onDeleteOf(modelName, address, targetModel)
+                    }
+                });
+            }
+            else if (ref?.refType === 'reference-set') {
+                ordered.push({
+                    order,
+                    field: { ...base, kind: 'set', onDelete: onDeleteOf(modelName, address, targetModel) }
+                });
+            }
+            else if (ref?.refType === 'has-many') {
+                ordered.push({
+                    order,
+                    field: {
+                        ...base,
+                        kind: 'own',
+                        onDelete: ref.cleanupBehavior ?? 'cascade',
+                        ownerField: ref.modelBelongsToProperty
+                    }
+                });
+            }
+            else if (ref?.refType === 'belongs-to') {
+                ordered.push({ order, field: { ...base, kind: 'owner' } });
+            }
+            else {
+                console.warn(`  ! ${modelName}.${address}: связь ${ref?.refType ?? relation.refType} не отображается`);
+            }
+        }
+        return ordered.sort((a, b) => a.order - b.order).map((item) => item.field);
+    };
+    const entities = Object.keys(collections).map((key, order) => {
+        const { name } = collections[key];
+        const { scheme, refscheme } = models[name];
+        const source = findSource(scheme.target, false);
+        const entity = {
+            key,
+            model: name,
+            file: source?.file ?? '?',
+            namespace: source?.namespace,
+            order,
+            idKey: scheme.identifier.propertyKey,
+            idType: scheme.identifier.options.type,
+            doc: source?.doc,
+            decorators: source?.decorators,
+            fields: [
+                {
+                    name: scheme.identifier.propertyKey,
+                    path: scheme.identifier.propertyKey,
+                    kind: 'id',
+                    type: scheme.identifier.options.type,
+                    decorators: source?.props.get(scheme.identifier.propertyKey)?.decorators,
+                    doc: source?.props.get(scheme.identifier.propertyKey)?.doc
+                },
+                ...buildFields(scheme, '', refscheme.commonRefs, name)
+            ],
+            variants: []
+        };
+        if (scheme.type === 'discriminated') {
+            entity.discriminatorKey = scheme.discriminatorKey;
+            entity.variants = scheme.discriminators.map((d) => ({
+                value: d.value,
+                model: d.name,
+                doc: findSource(d.target, false)?.doc,
+                decorators: findSource(d.target, false)?.decorators,
+                fields: buildFields(d, '', refscheme.discriminatorRefs?.[d.value] ?? {}, name)
+            }));
+        }
+        return entity;
+    });
+    const relations = [];
+    for (const entity of entities) {
+        const walk = (fields, variant) => {
+            for (const field of fields) {
+                if (field.fields)
+                    walk(field.fields, variant);
+                if ((field.kind === 'ref' || field.kind === 'set' || field.kind === 'own') && field.target) {
+                    relations.push({
+                        id: `${entity.key}.${field.path}${variant ? `@${variant}` : ''}`,
+                        source: entity.key,
+                        target: field.target,
+                        kind: field.kind,
+                        field: field.path,
+                        ownerField: field.ownerField,
+                        onDelete: field.onDelete ?? 'restrict',
+                        nullable: field.nullable ?? false,
+                        variant
+                    });
+                }
+            }
+        };
+        walk(entity.fields);
+        entity.variants.forEach((v) => walk(v.fields, v.value));
+    }
+    const files = [];
+    for (const entity of entities) {
+        if (!files.some((f) => f.file === entity.file))
+            files.push({ file: entity.file, namespace: entity.namespace });
+    }
+    return { entities, relations, files, types: catalog.types };
+};
+exports.extractScheme = extractScheme;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './config';
+export * from './model';
+export * from './project';
+export type { SchemeSource } from './scheme-meta';
+export { extractScheme, type ExtractOptions } from './extract';
+export { buildSchemeMap, type SchemeMapOptions, type SchemeMapResult } from './build';

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSchemeMap = exports.extractScheme = void 0;
+__exportStar(require("./config"), exports);
+__exportStar(require("./model"), exports);
+__exportStar(require("./project"), exports);
+var extract_1 = require("./extract");
+Object.defineProperty(exports, "extractScheme", { enumerable: true, get: function () { return extract_1.extractScheme; } });
+var build_1 = require("./build");
+Object.defineProperty(exports, "buildSchemeMap", { enumerable: true, get: function () { return build_1.buildSchemeMap; } });

package/dist/layout/cards.d.ts

@@ -0,0 +1,43 @@
+import type { Spacing } from '../config';
+import type { Entity, Field, FieldKind, OnDelete, Relation } from '../model';
+export declare const MONO_ADVANCE = 0.6;
+export declare const ROW_FONT = 11;
+export declare const HEADER_FONT = 13;
+export declare const BOX_STEP = 6;
+export declare const BOX_GAP_BEFORE = 5;
+export declare const BOX_PAD_AFTER = 6;
+export declare const textWidth: (text: string, size: number) => number;
+export type RowKind = Exclude<FieldKind, 'embedded'> | 'block' | 'variant';
+export interface CardRow {
+    path: string;
+    label: string;
+    detail: string;
+    kind: RowKind;
+    depth: number;
+    y: number;
+    h: number;
+    boxBottom?: number;
+    target?: string;
+    onDelete?: OnDelete;
+    nullable?: boolean;
+    variant?: string;
+}
+export interface Card {
+    key: string;
+    entity: Entity;
+    rows: CardRow[];
+    width: number;
+    height: number;
+}
+export declare const rowLevel: (row: CardRow) => number;
+export declare const boxInset: (level: number) => number;
+export declare const textInset: (level: number, spacing: Spacing) => number;
+export declare const ownFieldsFirst: (fields: Field[]) => Field[];
+export declare const buildCard: (entity: Entity, spacing: Spacing) => Card;
+export declare const rowCenter: (card: Card, path: string, spacing: Spacing) => number;
+export declare const relationRows: (relation: Relation, cards: Map<string, Card>) => {
+    source: Card;
+    sourcePath: string;
+    target: Card;
+    targetPath: string;
+};