@polagram/core 0.0.3 → 0.1.0

package/dist/src/config/schema.d.ts

@@ -1,182 +0,0 @@
-import { z } from 'zod';
-declare const LensSchema: z.ZodObject<{
-    name: z.ZodString;
-    suffix: z.ZodOptional<z.ZodString>;
-    layers: z.ZodArray<z.ZodObject<{
-        action: z.ZodEnum<{
-            resolve: "resolve";
-            focus: "focus";
-            remove: "remove";
-        }>;
-        selector: z.ZodDiscriminatedUnion<[z.ZodObject<{
-            kind: z.ZodLiteral<"fragment">;
-            condition: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                pattern: z.ZodString;
-                flags: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>]>>;
-            operator: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"participant">;
-            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                pattern: z.ZodString;
-                flags: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>]>>;
-            id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                pattern: z.ZodString;
-                flags: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>]>>;
-            stereotype: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                pattern: z.ZodString;
-                flags: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>]>>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"message">;
-            text: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                pattern: z.ZodString;
-                flags: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>]>>;
-            from: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                pattern: z.ZodString;
-                flags: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>]>>;
-            to: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                pattern: z.ZodString;
-                flags: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>]>>;
-        }, z.core.$strip>, z.ZodObject<{
-            kind: z.ZodLiteral<"group">;
-            name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                pattern: z.ZodString;
-                flags: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>]>>;
-        }, z.core.$strip>], "kind">;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-declare const TargetConfigSchema: z.ZodObject<{
-    input: z.ZodArray<z.ZodString>;
-    outputDir: z.ZodString;
-    ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    lenses: z.ZodArray<z.ZodObject<{
-        name: z.ZodString;
-        suffix: z.ZodOptional<z.ZodString>;
-        layers: z.ZodArray<z.ZodObject<{
-            action: z.ZodEnum<{
-                resolve: "resolve";
-                focus: "focus";
-                remove: "remove";
-            }>;
-            selector: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                kind: z.ZodLiteral<"fragment">;
-                condition: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                    pattern: z.ZodString;
-                    flags: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>]>>;
-                operator: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-            }, z.core.$strip>, z.ZodObject<{
-                kind: z.ZodLiteral<"participant">;
-                name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                    pattern: z.ZodString;
-                    flags: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>]>>;
-                id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                    pattern: z.ZodString;
-                    flags: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>]>>;
-                stereotype: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                    pattern: z.ZodString;
-                    flags: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>]>>;
-            }, z.core.$strip>, z.ZodObject<{
-                kind: z.ZodLiteral<"message">;
-                text: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                    pattern: z.ZodString;
-                    flags: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>]>>;
-                from: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                    pattern: z.ZodString;
-                    flags: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>]>>;
-                to: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                    pattern: z.ZodString;
-                    flags: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>]>>;
-            }, z.core.$strip>, z.ZodObject<{
-                kind: z.ZodLiteral<"group">;
-                name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                    pattern: z.ZodString;
-                    flags: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>]>>;
-            }, z.core.$strip>], "kind">;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const PolagramConfigSchema: z.ZodObject<{
-    version: z.ZodNumber;
-    targets: z.ZodArray<z.ZodObject<{
-        input: z.ZodArray<z.ZodString>;
-        outputDir: z.ZodString;
-        ignore: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        lenses: z.ZodArray<z.ZodObject<{
-            name: z.ZodString;
-            suffix: z.ZodOptional<z.ZodString>;
-            layers: z.ZodArray<z.ZodObject<{
-                action: z.ZodEnum<{
-                    resolve: "resolve";
-                    focus: "focus";
-                    remove: "remove";
-                }>;
-                selector: z.ZodDiscriminatedUnion<[z.ZodObject<{
-                    kind: z.ZodLiteral<"fragment">;
-                    condition: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                        pattern: z.ZodString;
-                        flags: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strip>]>>;
-                    operator: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-                }, z.core.$strip>, z.ZodObject<{
-                    kind: z.ZodLiteral<"participant">;
-                    name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                        pattern: z.ZodString;
-                        flags: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strip>]>>;
-                    id: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                        pattern: z.ZodString;
-                        flags: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strip>]>>;
-                    stereotype: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                        pattern: z.ZodString;
-                        flags: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strip>]>>;
-                }, z.core.$strip>, z.ZodObject<{
-                    kind: z.ZodLiteral<"message">;
-                    text: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                        pattern: z.ZodString;
-                        flags: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strip>]>>;
-                    from: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                        pattern: z.ZodString;
-                        flags: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strip>]>>;
-                    to: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                        pattern: z.ZodString;
-                        flags: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strip>]>>;
-                }, z.core.$strip>, z.ZodObject<{
-                    kind: z.ZodLiteral<"group">;
-                    name: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                        pattern: z.ZodString;
-                        flags: z.ZodOptional<z.ZodString>;
-                    }, z.core.$strip>]>>;
-                }, z.core.$strip>], "kind">;
-            }, z.core.$strip>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type PolagramConfig = z.infer<typeof PolagramConfigSchema>;
-export type TargetConfig = z.infer<typeof TargetConfigSchema>;
-export type LensConfig = z.infer<typeof LensSchema>;
-/**
- * Validates the input object against the Polagram Config Schema.
- * Throws a formatted error message if validation fails.
- */
-export declare function validateConfig(input: unknown): PolagramConfig;
-export {};

package/dist/src/config/schema.js

@@ -1,78 +0,0 @@
-import { z } from 'zod';
-// -- Text Matcher --
-const TextMatcherSchema = z.union([
-    z.string(),
-    z.object({
-        pattern: z.string(),
-        flags: z.string().optional()
-    })
-]);
-// -- Selectors --
-// Explicitly requiring 'kind' for all selectors
-const FragmentSelectorSchema = z.object({
-    kind: z.literal('fragment'),
-    condition: TextMatcherSchema.optional(),
-    operator: z.union([z.string(), z.array(z.string())]).optional()
-    // Note: Operator types might need to be refined if we want strict enum validation, 
-    // but string is flexible for now.
-});
-const ParticipantSelectorSchema = z.object({
-    kind: z.literal('participant'),
-    name: TextMatcherSchema.optional(),
-    id: TextMatcherSchema.optional(),
-    stereotype: TextMatcherSchema.optional()
-});
-const MessageSelectorSchema = z.object({
-    kind: z.literal('message'),
-    text: TextMatcherSchema.optional(),
-    from: TextMatcherSchema.optional(),
-    to: TextMatcherSchema.optional()
-});
-const GroupSelectorSchema = z.object({
-    kind: z.literal('group'),
-    name: TextMatcherSchema.optional()
-});
-const SelectorSchema = z.discriminatedUnion('kind', [
-    FragmentSelectorSchema,
-    ParticipantSelectorSchema,
-    MessageSelectorSchema,
-    GroupSelectorSchema
-]);
-// -- Layers --
-const ActionSchema = z.enum(['focus', 'remove', 'resolve']);
-const LayerSchema = z.object({
-    action: ActionSchema,
-    selector: SelectorSchema
-});
-// -- Lens --
-const LensSchema = z.object({
-    name: z.string(),
-    suffix: z.string().optional(), // Defaults to .name in logic
-    layers: z.array(LayerSchema)
-});
-// -- Config --
-const TargetConfigSchema = z.object({
-    input: z.array(z.string()),
-    outputDir: z.string(),
-    ignore: z.array(z.string()).optional(),
-    lenses: z.array(LensSchema)
-});
-export const PolagramConfigSchema = z.object({
-    version: z.number(),
-    targets: z.array(TargetConfigSchema)
-});
-/**
- * Validates the input object against the Polagram Config Schema.
- * Throws a formatted error message if validation fails.
- */
-export function validateConfig(input) {
-    const result = PolagramConfigSchema.safeParse(input);
-    if (!result.success) {
-        const errorMessages = result.error.issues.map(issue => {
-            const path = issue.path.join('.');
-            return `[${path}]: ${issue.message}`;
-        }).join('\n');
-        throw new Error(`Invalid Polagram Configuration:\n${errorMessages}`);
-    }
-    return result.data;
-}

package/dist/src/config/schema.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/config/schema.test.js

@@ -1,94 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { validateConfig } from './schema';
-describe('Config Schema Validation', () => {
-    it('should validate a correct configuration', () => {
-        const input = {
-            version: 1,
-            targets: [
-                {
-                    input: ['src/*.mmd'],
-                    outputDir: 'dist',
-                    lenses: [
-                        {
-                            name: 'Success',
-                            layers: [
-                                {
-                                    action: 'resolve',
-                                    selector: { kind: 'fragment', condition: 'Success' }
-                                }
-                            ]
-                        }
-                    ]
-                }
-            ]
-        };
-        const config = validateConfig(input);
-        expect(config.version).toBe(1);
-        expect(config.targets[0].lenses[0].name).toBe('Success');
-    });
-    it('should throw error for missing required fields', () => {
-        const input = {
-            // missing version
-            targets: []
-        };
-        expect(() => validateConfig(input)).toThrow('Invalid Polagram Configuration');
-        // Zod message might vary, just checking it fails is often enough, 
-        // but let's check for the path at least.
-        expect(() => validateConfig(input)).toThrow('[version]:');
-    });
-    it('should validate fragment selector correctly', () => {
-        const input = {
-            version: 1,
-            targets: [{
-                    input: ['src/*.mmd'],
-                    outputDir: 'dist',
-                    lenses: [{
-                            name: 'Test',
-                            layers: [{
-                                    action: 'focus',
-                                    selector: { kind: 'fragment', condition: 'Success' }
-                                }]
-                        }]
-                }]
-        };
-        expect(() => validateConfig(input)).not.toThrow();
-    });
-    it('should fail if selector kind is missing', () => {
-        const input = {
-            version: 1,
-            targets: [{
-                    input: ['src/*.mmd'],
-                    outputDir: 'dist',
-                    lenses: [{
-                            name: 'Test',
-                            layers: [{
-                                    action: 'focus',
-                                    selector: { condition: 'Success' } // Missing kind: 'fragment'
-                                }]
-                        }]
-                }]
-        };
-        // Expect failure because checking against union requires discrimination
-        expect(() => validateConfig(input)).toThrow();
-    });
-    it('should validate participant selector with complex matcher', () => {
-        const input = {
-            version: 1,
-            targets: [{
-                    input: ['src/*.mmd'],
-                    outputDir: 'dist',
-                    lenses: [{
-                            name: 'Test',
-                            layers: [{
-                                    action: 'focus',
-                                    selector: {
-                                        kind: 'participant',
-                                        name: { pattern: 'User.*', flags: 'i' }
-                                    }
-                                }]
-                        }]
-                }]
-        };
-        expect(() => validateConfig(input)).not.toThrow();
-    });
-});

package/dist/src/generator/base/walker.d.ts

@@ -1,19 +0,0 @@
-import { EventNode, PolagramRoot } from '../../ast';
-import { PolagramVisitor } from '../interface';
-/**
- * Helper class to traverse AST nodes and dispatch to the visitor.
- */
-export declare class Traverser {
-    private visitor;
-    constructor(visitor: PolagramVisitor);
-    traverse(root: PolagramRoot): void;
-    /**
-     * Dispatches a single event node to the appropriate visitor method.
-     * This is public so Visitors can call it recursively (e.g. inside Fragments/Groups).
-     */
-    dispatchEvent(node: EventNode): void;
-    /**
-     * Helper to iterate over a list of events.
-     */
-    dispatchEvents(events: EventNode[]): void;
-}

package/dist/src/generator/base/walker.js

@@ -1,56 +0,0 @@
-/**
- * Helper class to traverse AST nodes and dispatch to the visitor.
- */
-export class Traverser {
-    constructor(visitor) {
-        Object.defineProperty(this, "visitor", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: visitor
-        });
-    }
-    traverse(root) {
-        this.visitor.visitRoot(root);
-    }
-    /**
-     * Dispatches a single event node to the appropriate visitor method.
-     * This is public so Visitors can call it recursively (e.g. inside Fragments/Groups).
-     */
-    dispatchEvent(node) {
-        switch (node.kind) {
-            case 'message':
-                this.visitor.visitMessage(node);
-                break;
-            case 'fragment':
-                this.visitor.visitFragment(node);
-                break;
-            case 'note':
-                this.visitor.visitNote(node);
-                break;
-            case 'activation':
-                this.visitor.visitActivation(node);
-                break;
-            case 'divider':
-                this.visitor.visitDivider(node);
-                break;
-            case 'spacer':
-                this.visitor.visitSpacer(node);
-                break;
-            case 'ref':
-                this.visitor.visitReference(node);
-                break;
-            default:
-                // Unknown node type
-                break;
-        }
-    }
-    /**
-     * Helper to iterate over a list of events.
-     */
-    dispatchEvents(events) {
-        for (const event of events) {
-            this.dispatchEvent(event);
-        }
-    }
-}

package/dist/src/generator/base/walker.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/generator/base/walker.test.js

@@ -1,49 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { Traverser } from './walker';
-describe('Traverser', () => {
-    it('should dispatch visitRoot', () => {
-        const mockVisitor = {
-            visitRoot: vi.fn(),
-            visitParticipant: vi.fn(),
-            visitParticipantGroup: vi.fn(),
-            visitMessage: vi.fn(),
-            visitFragment: vi.fn(),
-            visitNote: vi.fn(),
-            visitActivation: vi.fn(),
-            visitDivider: vi.fn(),
-            visitSpacer: vi.fn(),
-            visitReference: vi.fn()
-        };
-        const traverser = new Traverser(mockVisitor);
-        const root = { kind: 'root', meta: { version: '1.0.0', source: 'unknown' }, participants: [], groups: [], events: [] };
-        traverser.traverse(root);
-        expect(mockVisitor.visitRoot).toHaveBeenCalledWith(root);
-    });
-    it('should dispatch events based on kind', () => {
-        const mockVisitor = {
-            visitRoot: vi.fn(), // Root visitor might internally call dispatchEvents
-            visitParticipant: vi.fn(),
-            visitParticipantGroup: vi.fn(),
-            visitMessage: vi.fn(),
-            visitFragment: vi.fn(),
-            visitNote: vi.fn(),
-            visitActivation: vi.fn(),
-            visitDivider: vi.fn(),
-            visitSpacer: vi.fn(),
-            visitReference: vi.fn()
-        };
-        const traverser = new Traverser(mockVisitor);
-        const msg = {
-            kind: 'message',
-            id: '1',
-            from: 'A',
-            to: 'B',
-            text: 'hi',
-            type: 'sync',
-            style: { line: 'solid', head: 'arrow' }
-        };
-        // Directly call dispatchEvents (as if called from visitRoot implementation)
-        traverser.dispatchEvents([msg]);
-        expect(mockVisitor.visitMessage).toHaveBeenCalledWith(msg);
-    });
-});

package/dist/src/generator/generators/mermaid.d.ts

@@ -1,24 +0,0 @@
-import { ActivationNode, DividerNode, FragmentNode, MessageNode, NoteNode, Participant, ParticipantGroup, PolagramRoot, ReferenceNode, SpacerNode } from '../../ast';
-import { PolagramVisitor } from '../interface';
-/**
- * Visitor implementation that generates Mermaid code.
- */
-export declare class MermaidGeneratorVisitor implements PolagramVisitor {
-    private lines;
-    private indentLevel;
-    private traverser;
-    constructor();
-    generate(ast: PolagramRoot): string;
-    visitRoot(node: PolagramRoot): void;
-    visitParticipant(node: Participant): void;
-    visitParticipantGroup(node: ParticipantGroup): void;
-    visitMessage(node: MessageNode): void;
-    visitFragment(node: FragmentNode): void;
-    visitNote(node: NoteNode): void;
-    visitActivation(node: ActivationNode): void;
-    visitDivider(node: DividerNode): void;
-    visitSpacer(node: SpacerNode): void;
-    visitReference(node: ReferenceNode): void;
-    private add;
-    private indent;
-}

package/dist/src/generator/generators/mermaid.js

@@ -1,140 +0,0 @@
-import { getArrowString } from '../../parser/languages/mermaid/constants';
-import { Traverser } from '../base/walker';
-/**
- * Visitor implementation that generates Mermaid code.
- */
-export class MermaidGeneratorVisitor {
-    constructor() {
-        Object.defineProperty(this, "lines", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        Object.defineProperty(this, "indentLevel", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 0
-        });
-        Object.defineProperty(this, "traverser", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.traverser = new Traverser(this);
-    }
-    generate(ast) {
-        this.lines = [];
-        this.indentLevel = 0;
-        this.traverser.traverse(ast);
-        return this.lines.join('\n');
-    }
-    visitRoot(node) {
-        this.lines.push('sequenceDiagram');
-        this.indentLevel++;
-        if (node.meta?.title) {
-            this.add(`title ${node.meta.title}`);
-        }
-        // Participants
-        // Note: We iterate participants in defined order. 
-        // Currently, AST does not preserve the interleaving of Box definitions and Participants,
-        // so we cannot reliably reconstruct Box blocks wrapping specific ordered participants
-        // without potentially reordering them. 
-        // For now, we revert to simple iteration (ignoring boxes) to preserve order and existing behavior.
-        for (const p of node.participants) {
-            this.visitParticipant(p);
-        }
-        // Events
-        this.traverser.dispatchEvents(node.events);
-    }
-    visitParticipant(node) {
-        const typeKeyword = node.type === 'actor' ? 'actor' : 'participant';
-        const safeName = node.name;
-        if (node.id === node.name) {
-            this.add(`${typeKeyword} ${node.id}`);
-        }
-        else {
-            this.add(`${typeKeyword} ${node.id} as ${safeName}`);
-        }
-    }
-    visitParticipantGroup(node) {
-        let line = `box`;
-        if (node.style?.backgroundColor) {
-            line += ` ${node.style.backgroundColor}`;
-        }
-        if (node.name) {
-            line += ` ${node.name}`;
-        }
-        this.add(line);
-    }
-    visitMessage(node) {
-        const from = node.from ?? '[*]';
-        const to = node.to ?? '[*]';
-        const arrow = getArrowString(node.type, node.style);
-        let suffix = '';
-        if (node.lifecycle?.activateTarget) {
-            suffix += '+';
-        }
-        if (node.lifecycle?.deactivateSource) {
-            suffix += '-';
-        }
-        this.add(`${from}${arrow}${suffix}${to}: ${node.text}`);
-    }
-    visitFragment(node) {
-        if (node.branches.length === 0)
-            return;
-        const first = node.branches[0];
-        const firstCondition = first.condition ? ` ${first.condition}` : '';
-        this.add(`${node.operator}${firstCondition}`);
-        this.indent(() => {
-            this.traverser.dispatchEvents(first.events);
-        });
-        for (let i = 1; i < node.branches.length; i++) {
-            const b = node.branches[i];
-            const cond = b.condition ? ` ${b.condition}` : '';
-            this.add(`else${cond}`);
-            this.indent(() => {
-                this.traverser.dispatchEvents(b.events);
-            });
-        }
-        this.add('end');
-    }
-    visitNote(node) {
-        const pos = node.position;
-        let target = '';
-        if (node.participantIds.length > 0) {
-            target = node.participantIds.join(',');
-            if (pos !== 'over') {
-                target = ` of ${target}`;
-            }
-            else {
-                target = ` ${target}`;
-            }
-        }
-        this.add(`note ${pos}${target}: ${node.text}`);
-    }
-    visitActivation(node) {
-        this.add(`${node.action} ${node.participantId}`);
-    }
-    visitDivider(node) {
-        this.add(`%% == ${node.text || ''} ==`);
-    }
-    visitSpacer(node) {
-        this.add(`...${node.text || ''}...`);
-    }
-    visitReference(node) {
-        this.add(`%% ref: ${node.text}`);
-    }
-    // --- Helpers ---
-    add(line) {
-        const spaces = '    '.repeat(this.indentLevel);
-        this.lines.push(`${spaces}${line}`);
-    }
-    indent(fn) {
-        this.indentLevel++;
-        fn();
-        this.indentLevel--;
-    }
-}

package/dist/src/generator/generators/mermaid.test.d.ts

@@ -1 +0,0 @@
-export {};