@flowuent-org/diagramming-core 1.0.5

package/packages/diagrams/src/lib/templates/cloud-arch/types/localization.ts

@@ -0,0 +1,369 @@
+// Localization Schema and Types for Cloud Architecture Diagram
+export interface LocalizationSchema {
+  locale: {
+    core: {
+      coordinate: {
+        x: string;
+        y: string;
+      };
+      size: {
+        width: string;
+        height: string;
+      };
+      common: {
+        title: string;
+        description: string;
+        cloudProvider: string;
+      };
+    };
+    ui: {
+      buttons: {
+        undo: string;
+        redo: string;
+        clear: string;
+        import: string;
+        export: string;
+        autoLayout: string;
+        refreshValidation: string;
+        clearSelection: string;
+      };
+      messages: {
+        success: {
+          nodeCreated: string;
+          nodePlaced: string;
+          nodesArranged: string;
+          validationRefreshed: string;
+        };
+        error: {
+          invalidPlacement: string;
+          invalidDrop: string;
+          validationFailed: string;
+          dropBlocked: string;
+        };
+        info: {
+          dropToPlace: string;
+          selectContainer: string;
+          willBePlacedIn: string;
+          willBePlacedAtRoot: string;
+        };
+      };
+      labels: {
+        selectedContainer: string;
+        dragState: string;
+        service: string;
+        cloud: string;
+        hoveredNode: string;
+        invalidOverlay: string;
+        message: string;
+        target: string;
+        servicesWillBePlacedHere: string;
+      };
+      containers: {
+        aws: {
+          account: string;
+          vpc: string;
+          subnet: string;
+          availabilityZone: string;
+          securityGroup: string;
+        };
+        azure: {
+          subscription: string;
+          resourceGroup: string;
+          virtualNetwork: string;
+          subnet: string;
+          networkSecurityGroup: string;
+        };
+        gcp: {
+          project: string;
+          folder: string;
+          vpc: string;
+          subnet: string;
+        };
+      };
+    };
+  };
+}
+
+// Default English localization
+export const defaultLocalization: LocalizationSchema = {
+  locale: {
+    core: {
+      coordinate: {
+        x: "X Coordinate",
+        y: "Y Coordinate"
+      },
+      size: {
+        width: "Width",
+        height: "Height"
+      },
+      common: {
+        title: "Title",
+        description: "Description",
+        cloudProvider: "Cloud Provider"
+      }
+    },
+    ui: {
+      buttons: {
+        undo: "Undo",
+        redo: "Redo",
+        clear: "Clear",
+        import: "Import",
+        export: "Export",
+        autoLayout: "Auto Layout",
+        refreshValidation: "Refresh Validation",
+        clearSelection: "Clear Selection"
+      },
+      messages: {
+        success: {
+          nodeCreated: "Node created successfully",
+          nodePlaced: "Service placed in: {container}",
+          nodesArranged: "{count} nodes arranged with proper spacing",
+          validationRefreshed: "Validation properties refreshed for all nodes!"
+        },
+        error: {
+          invalidPlacement: "Invalid placement - drop blocked",
+          invalidDrop: "Invalid drop location - drop blocked", 
+          validationFailed: "Validation failed - invalid drop target",
+          dropBlocked: "DROP BLOCKED"
+        },
+        info: {
+          dropToPlace: "Drop to place service",
+          selectContainer: "Drop to select container",
+          willBePlacedIn: "Will be placed in: {container}",
+          willBePlacedAtRoot: "Will be placed at root level"
+        }
+      },
+      labels: {
+        selectedContainer: "Selected Container",
+        dragState: "Debug: Drag State",
+        service: "Service",
+        cloud: "Cloud",
+        hoveredNode: "Hovered Node",
+        invalidOverlay: "Invalid Overlay",
+        message: "Message",
+        target: "Target",
+        servicesWillBePlacedHere: "Services will be placed here"
+      },
+      containers: {
+        aws: {
+          account: "AWS Account",
+          vpc: "Virtual Private Cloud",
+          subnet: "Subnet",
+          availabilityZone: "Availability Zone", 
+          securityGroup: "Security Group"
+        },
+        azure: {
+          subscription: "Azure Subscription",
+          resourceGroup: "Resource Group",
+          virtualNetwork: "Virtual Network",
+          subnet: "Subnet",
+          networkSecurityGroup: "Network Security Group"
+        },
+        gcp: {
+          project: "GCP Project",
+          folder: "Folder",
+          vpc: "VPC Network",
+          subnet: "Subnet"
+        }
+      }
+    }
+  }
+};
+
+// Example Spanish localization
+export const spanishLocalization: Partial<LocalizationSchema> = {
+  locale: {
+    core: {
+      coordinate: {
+        x: "Coordenada X",
+        y: "Coordenada Y"
+      },
+      size: {
+        width: "Ancho",
+        height: "Alto"
+      },
+      common: {
+        title: "Título",
+        description: "Descripción",
+        cloudProvider: "Proveedor de Nube"
+      }
+    },
+    ui: {
+      buttons: {
+        undo: "Deshacer",
+        redo: "Rehacer",
+        clear: "Limpiar",
+        import: "Importar",
+        export: "Exportar",
+        autoLayout: "Diseño Automático",
+        refreshValidation: "Actualizar Validación",
+        clearSelection: "Limpiar Selección"
+      },
+      messages: {
+        success: {
+          nodeCreated: "Nodo creado exitosamente",
+          nodePlaced: "Servicio colocado en: {container}",
+          nodesArranged: "{count} nodos organizados con espaciado adecuado",
+          validationRefreshed: "¡Propiedades de validación actualizadas para todos los nodos!"
+        },
+        error: {
+          invalidPlacement: "Colocación inválida - colocación bloqueada",
+          invalidDrop: "Ubicación de colocación inválida - colocación bloqueada",
+          validationFailed: "Validación falló - objetivo de colocación inválido",
+          dropBlocked: "COLOCACIÓN BLOQUEADA"
+        },
+        info: {
+          dropToPlace: "Soltar para colocar servicio",
+          selectContainer: "Soltar para seleccionar contenedor",
+          willBePlacedIn: "Será colocado en: {container}",
+          willBePlacedAtRoot: "Será colocado en el nivel raíz"
+        }
+      },
+      labels: {
+        selectedContainer: "Contenedor Seleccionado",
+        dragState: "Estado de Arrastre",
+        service: "Servicio",
+        cloud: "Nube",
+        hoveredNode: "Nodo Señalado",
+        invalidOverlay: "Superposición Inválida",
+        message: "Mensaje",
+        target: "Objetivo",
+        servicesWillBePlacedHere: "Los servicios se colocarán aquí"
+      },
+      containers: {
+        aws: {
+          account: "Cuenta AWS",
+          vpc: "Nube Privada Virtual",
+          subnet: "Subred",
+          availabilityZone: "Zona de Disponibilité",
+          securityGroup: "Grupo de Seguridad"
+        },
+        azure: {
+          subscription: "Suscripción Azure",
+          resourceGroup: "Grupo de Recursos",
+          virtualNetwork: "Red Virtual",
+          subnet: "Subred",
+          networkSecurityGroup: "Grupo de Seguridad de Red"
+        },
+        gcp: {
+          project: "Proyecto GCP",
+          folder: "Carpeta",
+          vpc: "Red VPC",
+          subnet: "Subred"
+        }
+      }
+    }
+  }
+};
+
+// Example French localization
+export const frenchLocalization: Partial<LocalizationSchema> = {
+  locale: {
+    core: {
+      coordinate: {
+        x: "Coordonnée X",
+        y: "Coordonnée Y"
+      },
+      size: {
+        width: "Largeur",
+        height: "Hauteur"
+      },
+      common: {
+        title: "Titre",
+        description: "Description",
+        cloudProvider: "Fournisseur Cloud"
+      }
+    },
+    ui: {
+      buttons: {
+        undo: "Annuler",
+        redo: "Refaire",
+        clear: "Effacer",
+        import: "Importer",
+        export: "Exporter",
+        autoLayout: "Disposition Automatique",
+        refreshValidation: "Actualiser la Validation",
+        clearSelection: "Effacer la Sélection"
+      },
+      messages: {
+        success: {
+          nodeCreated: "Nœud créé avec succès",
+          nodePlaced: "Service placé dans : {container}",
+          nodesArranged: "{count} nœuds arrangés avec un espacement approprié",
+          validationRefreshed: "Propriétés de validation actualisées pour tous les nœuds !"
+        },
+        error: {
+          invalidPlacement: "Placement invalide - dépôt bloqué",
+          invalidDrop: "Emplacement de dépôt invalide - dépôt bloqué",
+          validationFailed: "Validation échouée - cible de dépôt invalide",
+          dropBlocked: "DÉPÔT BLOQUÉ"
+        },
+        info: {
+          dropToPlace: "Déposer pour placer le service",
+          selectContainer: "Déposer pour sélectionner le conteneur",
+          willBePlacedIn: "Sera placé dans : {container}",
+          willBePlacedAtRoot: "Sera placé au niveau racine"
+        }
+      },
+      labels: {
+        selectedContainer: "Conteneur Sélectionné",
+        dragState: "État de Glissement",
+        service: "Service",
+        cloud: "Cloud",
+        hoveredNode: "Nœud Survolé",
+        invalidOverlay: "Superposition Invalide",
+        message: "Message",
+        target: "Cible",
+        servicesWillBePlacedHere: "Les services seront placés ici"
+      },
+      containers: {
+        aws: {
+          account: "Compte AWS",
+          vpc: "Cloud Privé Virtuel",
+          subnet: "Sous-réseau",
+          availabilityZone: "Zone de Disponibilité",
+          securityGroup: "Groupe de Sécurité"
+        },
+        azure: {
+          subscription: "Abonnement Azure",
+          resourceGroup: "Groupe de Ressources",
+          virtualNetwork: "Réseau Virtuel",
+          subnet: "Sous-réseau",
+          networkSecurityGroup: "Groupe de Sécurité Réseau"
+        },
+        gcp: {
+          project: "Projet GCP",
+          folder: "Dossier",
+          vpc: "Réseau VPC",
+          subnet: "Sous-réseau"
+        }
+      }
+    }
+  }
+};
+
+// Helper function to deep merge localization objects
+export const mergeLocalization = (
+  base: LocalizationSchema,
+  custom: Partial<LocalizationSchema>
+): LocalizationSchema => {
+  const mergeDeep = (target: any, source: any): any => {
+    const result = { ...target };
+    for (const key in source) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        result[key] = mergeDeep(target[key] || {}, source[key]);
+      } else {
+        result[key] = source[key];
+      }
+    }
+    return result;
+  };
+  
+  return mergeDeep(base, custom);
+};
+
+// Type for localization function
+export type LocalizationFunction = (
+  path: string, 
+  replacements?: Record<string, string | number>
+) => string; 

package/packages/diagrams/src/lib/templates/cloud-arch/types/validation.ts

@@ -0,0 +1,73 @@
+// Basic validation types - simplified from schema types
+// Only contains what's needed for validation, not schema creation
+
+export type CloudProvider = 'aws' | 'azure' | 'gcp';
+
+export interface RestrictionEntry {
+  type: 'mustBeIn' | 'cannotContain' | 'canContain' | 'quota' | 'custom';
+  target?: string | string[];
+  condition?: string;
+  validationMessage: string;
+  metadata: {
+    severity: 'error' | 'warning' | 'info';
+    category: 'hierarchy' | 'quota' | 'security' | 'networking' | 'cost' | 'compliance';
+  };
+}
+
+export interface PartialRestriction {
+  id: string;
+  name: string;
+  description: string;
+  template: {
+    type: string;
+    validationMessage: string;
+    metadata: {
+      severity: string;
+      category: string;
+    };
+  };
+  variables: Record<string, {
+    type: string;
+    description: string;
+  }>;
+}
+
+export interface ResourceRestrictions {
+  [key: string]: RestrictionEntry[];
+}
+
+export interface RestrictionRule {
+  id: string;
+  name: string;
+  description: string;
+  condition: string;
+  message: string;
+  severity: 'error' | 'warning' | 'info';
+}
+
+export interface RestrictionEvaluationContext {
+  node: any;
+  parent: any;
+  siblings: any[];
+  allNodes: any[];
+  cloudProvider: CloudProvider;
+}
+
+export interface RestrictionEvaluationResult {
+  isValid: boolean;
+  message?: string;
+  severity: 'error' | 'warning' | 'info';
+  category: string;
+}
+
+export interface ResolvedRestriction {
+  id: string;
+  type: string;
+  target?: string | string[];
+  condition?: string;
+  validationMessage: string;
+  metadata: {
+    severity: 'error' | 'warning' | 'info';
+    category: string;
+  };
+}