@polagram/core 0.0.3 → 0.1.0

package/dist/index.d.ts

@@ -12,10 +12,16 @@ export declare interface ActivationNode {
 }
 
 /**
- * Apply a lens object to the AST.
- * Facade for the TransformationEngine.
+ * Supported diagram formats
  */
-export declare function applyLens(root: PolagramRoot, lens: Lens): PolagramRoot;
+export declare type DiagramFormat = 'mermaid' | 'plantuml';
+
+/**
+ * Generator interface that all generators must implement.
+ */
+export declare interface DiagramGenerator {
+    generate(ast: PolagramRoot): string;
+}
 
 /**
  * Strategy Interface for Diagram Parsing.
@@ -33,22 +39,55 @@ export declare interface DividerNode {
 
 export declare type EventNode = MessageNode | FragmentNode | NoteNode | DividerNode | ActivationNode | ReferenceNode | SpacerNode;
 
-export declare class FocusFilter extends Walker {
-    private layer;
-    private matcher;
-    private targetParticipantIds;
-    constructor(layer: FocusLayer);
-    transform(root: PolagramRoot): PolagramRoot;
-    private resolveTargetParticipants;
-    protected visitEvent(node: EventNode): EventNode[];
-    private isRelatedToParticipant;
-}
-
 export declare interface FocusLayer {
     action: 'focus';
     selector: ParticipantSelector;
 }
 
+/**
+ * Format detection utilities for diagram source code.
+ * Detects diagram format based on file extension and content analysis.
+ */
+export declare const FormatDetector: {
+    /**
+     * Detect diagram format from file path and content.
+     *
+     * @param filePath - Path to the diagram file
+     * @param content - Content of the diagram file
+     * @returns Detected format, or null if format cannot be determined
+     *
+     * @example
+     * ```typescript
+     * const format = FormatDetector.detect('diagram.puml', content);
+     * if (format === 'plantuml') {
+     *   // Process as PlantUML
+     * }
+     * ```
+     */
+    detect(filePath: string, content: string): DiagramFormat | null;
+    /**
+     * Detect format based on file extension.
+     *
+     * @param filePath - Path to the diagram file
+     * @returns Detected format, or null if extension is not recognized
+     */
+    detectByExtension(filePath: string): DiagramFormat | null;
+    /**
+     * Detect format based on content patterns.
+     *
+     * @param content - Content of the diagram file
+     * @returns Detected format, or null if no pattern matches
+     */
+    detectByContent(content: string): DiagramFormat | null;
+    /**
+     * Get file extension for a given format.
+     *
+     * @param format - Diagram format
+     * @returns Default file extension for the format
+     */
+    getDefaultExtension(format: DiagramFormat): string;
+};
+
 export declare interface FragmentBranch {
     id: string;
     condition?: string;
@@ -65,13 +104,50 @@ export declare interface FragmentNode {
 export declare type FragmentOperator = 'alt' | 'opt' | 'loop' | 'par' | 'break' | 'critical' | 'rect' | 'group';
 
 export declare interface FragmentSelector {
-    kind?: 'fragment';
+    kind: 'fragment';
     condition?: TextMatcher;
     operator?: FragmentOperator | FragmentOperator[];
 }
 
+declare type GeneratorConstructor = () => PolagramVisitor & DiagramGenerator;
+
+/**
+ * Generator Factory
+ * Centralizes retrieval of generator strategies.
+ * Mirrors the ParserFactory pattern for consistency.
+ *
+ * @example
+ * ```typescript
+ * const generator = GeneratorFactory.getGenerator('mermaid');
+ * const code = generator.generate(ast);
+ * ```
+ */
+export declare const GeneratorFactory: {
+    /**
+     * Register a custom generator.
+     * @param language - Language identifier (e.g., 'mermaid', 'plantuml')
+     * @param factory - Factory function that creates a generator instance
+     */
+    register(language: string, factory: GeneratorConstructor): void;
+    /**
+     * Get a generator for the specified language.
+     * @param language - Language identifier
+     * @returns A generator instance
+     * @throws Error if no generator is registered for the language
+     */
+    getGenerator(language: string): PolagramVisitor & DiagramGenerator;
+    /**
+     * Check if a generator is registered for the given language.
+     */
+    hasGenerator(language: string): boolean;
+    /**
+     * Get list of registered languages.
+     */
+    getLanguages(): string[];
+};
+
 export declare interface GroupSelector {
-    kind?: 'group';
+    kind: 'group';
     name?: TextMatcher;
 }
 
@@ -139,14 +215,6 @@ declare const LensSchema: z.ZodObject<{
     }, z.core.$strip>>;
 }, z.core.$strip>;
 
-export declare class Matcher {
-    matchBranch(branch: FragmentBranch, selector: FragmentSelector, parentOperator: FragmentOperator): boolean;
-    matchParticipant(node: Participant, selector: ParticipantSelector): boolean;
-    matchMessage(node: MessageNode, selector: MessageSelector): boolean;
-    matchGroup(node: ParticipantGroup, selector: GroupSelector): boolean;
-    private matchText;
-}
-
 /**
  * Visitor implementation that generates Mermaid code.
  */
@@ -195,7 +263,7 @@ export declare interface MessageNode {
 }
 
 export declare interface MessageSelector {
-    kind?: 'message';
+    kind: 'message';
     text?: TextMatcher;
     from?: TextMatcher;
     to?: TextMatcher;
@@ -221,11 +289,10 @@ export declare interface NoteNode {
  * Parser Factory
  * Centralizes retrieval of parser strategies.
  */
-export declare class ParserFactory {
-    private static parsers;
-    static register(language: string, parser: DiagramParser): void;
-    static getParser(language: string): DiagramParser;
-}
+export declare const ParserFactory: {
+    register(language: string, parser: DiagramParser): void;
+    getParser(language: string): DiagramParser;
+};
 
 export declare interface Participant {
     id: string;
@@ -246,7 +313,7 @@ export declare interface ParticipantGroup {
 }
 
 export declare interface ParticipantSelector {
-    kind?: 'participant';
+    kind: 'participant';
     name?: TextMatcher;
     id?: TextMatcher;
     stereotype?: TextMatcher;
@@ -254,6 +321,29 @@ export declare interface ParticipantSelector {
 
 export declare type ParticipantType = 'participant' | 'actor' | 'boundary' | 'control' | 'entity' | 'database' | 'collections' | 'queue';
 
+/**
+ * Visitor implementation that generates PlantUML code.
+ * Uses the same Traverser pattern as MermaidGeneratorVisitor for consistency.
+ */
+export declare class PlantUMLGeneratorVisitor implements PolagramVisitor {
+    private lines;
+    private traverser;
+    constructor();
+    generate(root: PolagramRoot): string;
+    visitRoot(node: PolagramRoot): void;
+    visitParticipant(node: Participant): void;
+    visitParticipantGroup(_node: ParticipantGroup): void;
+    private visitGroup;
+    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;
+}
+
 /**
  * Polagram Fluent API
  *
@@ -270,9 +360,9 @@ export declare class Polagram {
     /**
      * Initialize a new Polagram transformation pipeline.
      * @param code Source diagram code
-     * @param format Input format (currently only 'mermaid' is supported)
+     * @param format Input format ('mermaid' or 'plantuml')
      */
-    static init(code: string, format?: 'mermaid'): PolagramBuilder;
+    static init(code: string, format?: 'mermaid' | 'plantuml'): PolagramBuilder;
 }
 
 /**
@@ -281,7 +371,8 @@ export declare class Polagram {
 export declare class PolagramBuilder {
     private ast;
     private layers;
-    constructor(ast: PolagramRoot);
+    private sourceFormat;
+    constructor(ast: PolagramRoot, sourceFormat?: 'mermaid' | 'plantuml');
     /**
      * Focus on specific participants.
      * Keeps only interactions involving the matched participants.
@@ -318,10 +409,18 @@ export declare class PolagramBuilder {
      * Generate Mermaid code from the transformed AST.
      */
     toMermaid(): string;
+    /**
+     * Generate PlantUML code from the transformed AST.
+     */
+    toPlantUML(): string;
     /**
      * Get the transformed AST (for advanced use cases).
      */
     toAST(): PolagramRoot;
+    /**
+     * Get the source format detected/specified during init.
+     */
+    getSourceFormat(): 'mermaid' | 'plantuml';
     private normalizeParticipantSelector;
     private normalizeMessageSelector;
     private normalizeGroupSelector;
@@ -390,6 +489,14 @@ export declare const PolagramConfigSchema: z.ZodObject<{
                 }, z.core.$strip>], "kind">;
             }, z.core.$strip>>;
         }, z.core.$strip>>;
+        format: z.ZodOptional<z.ZodEnum<{
+            mermaid: "mermaid";
+            plantuml: "plantuml";
+        }>>;
+        outputFormat: z.ZodOptional<z.ZodEnum<{
+            mermaid: "mermaid";
+            plantuml: "plantuml";
+        }>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 
@@ -439,28 +546,11 @@ export declare interface ReferenceNode {
     link?: string;
 }
 
-export declare class RemoveFilter extends Walker {
-    private layer;
-    private matcher;
-    private removedParticipantIds;
-    constructor(layer: RemoveLayer);
-    transform(root: PolagramRoot): PolagramRoot;
-    protected visitEvent(node: EventNode): EventNode[];
-    private isRelatedToRemovedParticipant;
-}
-
 export declare interface RemoveLayer {
     action: 'remove';
     selector: ParticipantSelector | MessageSelector | GroupSelector;
 }
 
-export declare class ResolveFilter extends Walker {
-    private layer;
-    private matcher;
-    constructor(layer: ResolveLayer);
-    protected visitFragment(node: FragmentNode): EventNode[];
-}
-
 export declare interface ResolveLayer {
     action: 'resolve';
     selector: FragmentSelector;
@@ -473,14 +563,6 @@ export declare interface SpacerNode {
     text?: string;
 }
 
-/**
- * Cleaner that removes empty fragments and branches from the AST.
- * This runs after filters to ensure the AST structure remains valid/clean.
- */
-export declare class StructureCleaner extends Walker {
-    protected visitFragment(node: FragmentNode): EventNode[];
-}
-
 export declare interface StyleProps {
     color?: string;
     backgroundColor?: string;
@@ -546,6 +628,14 @@ declare const TargetConfigSchema: z.ZodObject<{
             }, z.core.$strip>], "kind">;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    format: z.ZodOptional<z.ZodEnum<{
+        mermaid: "mermaid";
+        plantuml: "plantuml";
+    }>>;
+    outputFormat: z.ZodOptional<z.ZodEnum<{
+        mermaid: "mermaid";
+        plantuml: "plantuml";
+    }>>;
 }, z.core.$strip>;
 
 export declare type TextMatcher = string | RegExp | {
@@ -562,13 +652,35 @@ declare interface Transformer_2 {
 }
 export { Transformer_2 as Transformer }
 
-declare type TransformerFactory = (layer: Layer) => Transformer_2;
+/**
+ * Type-safe factory function type for creating transformers.
+ */
+declare type TransformerFactory<T extends Layer = Layer> = (layer: T) => Transformer_2;
 
+/**
+ * Registry for transformer factories.
+ * Provides type-safe registration and retrieval of transformers.
+ */
 declare class TransformerRegistry {
     private factories;
     constructor();
+    /**
+     * Type-safe registration for a specific layer type.
+     */
+    private registerTyped;
+    /**
+     * Register a custom transformer factory.
+     */
     register(action: string, factory: TransformerFactory): void;
+    /**
+     * Get a transformer for the given layer.
+     * @returns Transformer instance or null if no factory is registered
+     */
     get(layer: Layer): Transformer_2 | null;
+    /**
+     * Check if a transformer is registered for the given action.
+     */
+    has(action: string): boolean;
 }
 
 export declare const transformerRegistry: TransformerRegistry;
@@ -591,35 +703,10 @@ export declare class Traverser {
     dispatchEvents(events: EventNode[]): void;
 }
 
-export declare class UnusedCleaner {
-    transform(root: PolagramRoot): PolagramRoot;
-    private collectUsedParticipants;
-}
-
 /**
  * Validates the input object against the Polagram Config Schema.
  * Throws a formatted error message if validation fails.
  */
 export declare function validateConfig(input: unknown): PolagramConfig;
 
-/**
- * Type Guard to validate if an object is a valid Lens.
- * Acts as an Anti-Corruption Layer.
- */
-export declare function validateLens(lens: unknown): lens is Lens;
-
-/**
- * Abstract base class for tree transformations.
- * Implements the "Updating Visitor" pattern with Copy-on-Write immutability.
- *
- * Subclasses should override `visitEvent` to apply specific logic.
- */
-declare abstract class Walker {
-    transform(root: PolagramRoot): PolagramRoot;
-    protected mapEvents(events: EventNode[]): EventNode[];
-    protected visitEvent(node: EventNode): EventNode[];
-    protected visitFragment(node: FragmentNode): EventNode[];
-    protected visitBranch(branch: FragmentBranch): FragmentBranch;
-}
-
 export { }