@polagram/core 0.0.4 → 0.1.1

package/dist/index.d.ts

@@ -12,15 +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';
 
 /**
- * Supported diagram formats
+ * Generator interface that all generators must implement.
  */
-export declare type DiagramFormat = 'mermaid' | 'plantuml';
+export declare interface DiagramGenerator {
+    generate(ast: PolagramRoot): string;
+}
 
 /**
  * Strategy Interface for Diagram Parsing.
@@ -38,17 +39,6 @@ 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;
@@ -58,15 +48,7 @@ export declare interface FocusLayer {
  * Format detection utilities for diagram source code.
  * Detects diagram format based on file extension and content analysis.
  */
-export declare class FormatDetector {
-    /**
-     * File extensions mapped to their diagram formats
-     */
-    private static readonly EXTENSION_MAP;
-    /**
-     * Content patterns for format detection
-     */
-    private static readonly CONTENT_PATTERNS;
+export declare const FormatDetector: {
     /**
      * Detect diagram format from file path and content.
      *
@@ -82,29 +64,29 @@ export declare class FormatDetector {
      * }
      * ```
      */
-    static detect(filePath: string, content: string): DiagramFormat | null;
+    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
      */
-    static detectByExtension(filePath: string): DiagramFormat | null;
+    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
      */
-    static detectByContent(content: string): DiagramFormat | null;
+    detectByContent(content: string): DiagramFormat | null;
     /**
      * Get file extension for a given format.
      *
      * @param format - Diagram format
      * @returns Default file extension for the format
      */
-    static getDefaultExtension(format: DiagramFormat): string;
-}
+    getDefaultExtension(format: DiagramFormat): string;
+};
 
 export declare interface FragmentBranch {
     id: string;
@@ -122,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;
 }
 
@@ -147,9 +166,9 @@ declare const LensSchema: z.ZodObject<{
     suffix: z.ZodOptional<z.ZodString>;
     layers: z.ZodArray<z.ZodObject<{
         action: z.ZodEnum<{
+            resolve: "resolve";
             focus: "focus";
             remove: "remove";
-            resolve: "resolve";
         }>;
         selector: z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"fragment">;
@@ -196,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.
  */
@@ -252,7 +263,7 @@ export declare interface MessageNode {
 }
 
 export declare interface MessageSelector {
-    kind?: 'message';
+    kind: 'message';
     text?: TextMatcher;
     from?: TextMatcher;
     to?: TextMatcher;
@@ -278,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;
@@ -303,7 +313,7 @@ export declare interface ParticipantGroup {
 }
 
 export declare interface ParticipantSelector {
-    kind?: 'participant';
+    kind: 'participant';
     name?: TextMatcher;
     id?: TextMatcher;
     stereotype?: TextMatcher;
@@ -311,20 +321,27 @@ 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): string;
-    visitParticipant(node: Participant): string;
-    visitGroup(node: ParticipantGroup, context?: Map<string, Participant>): string;
-    visitMessage(node: MessageNode): string;
-    visitFragment(node: FragmentNode): string;
-    private visitEvent;
-    visitNote(node: NoteNode): string;
-    visitActivation(node: ActivationNode): string;
-    visitParticipantGroup(_node: ParticipantGroup): string;
-    visitDivider(_node: DividerNode): string;
-    visitSpacer(_node: SpacerNode): string;
-    visitReference(_node: ReferenceNode): 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;
 }
 
 /**
@@ -424,9 +441,9 @@ export declare const PolagramConfigSchema: z.ZodObject<{
             suffix: z.ZodOptional<z.ZodString>;
             layers: z.ZodArray<z.ZodObject<{
                 action: z.ZodEnum<{
+                    resolve: "resolve";
                     focus: "focus";
                     remove: "remove";
-                    resolve: "resolve";
                 }>;
                 selector: z.ZodDiscriminatedUnion<[z.ZodObject<{
                     kind: z.ZodLiteral<"fragment">;
@@ -529,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;
@@ -563,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;
@@ -588,9 +580,9 @@ declare const TargetConfigSchema: z.ZodObject<{
         suffix: z.ZodOptional<z.ZodString>;
         layers: z.ZodArray<z.ZodObject<{
             action: z.ZodEnum<{
+                resolve: "resolve";
                 focus: "focus";
                 remove: "remove";
-                resolve: "resolve";
             }>;
             selector: z.ZodDiscriminatedUnion<[z.ZodObject<{
                 kind: z.ZodLiteral<"fragment">;
@@ -660,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;
@@ -689,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 { }