Opens in a new tab 
 /* update variables when header is on dark background*/
.on-dark-bg {
   --header-bg: var(--current-header-bg);
   --chevron-clr: white;
   --menu-item-clr: white;
   --menu-item-hover-bg: #172235;
   --menu-item-hover-clr: #bc92e6;
   --menu-toggle-clr: var(--menu-item-clr);
   --dropdown-content-border: solid 1px rgb(220 220 220 / 20%);
   --mobile-menu-bg: var(--header-bg);
 }

 .on-light-bg {
   --menu-item-clr: black;
   /* update variables when header is on light background*/
 }


 /* update variable when on dark or light background */
 .on-dark-bg,
 .on-light-bg {
   --overlay-header-bg-active: var(--current-header-bg);
   --dropdown-content-bg: var(--current-header-bg);
 }

 .on-video-section {
   /* update variables when header is on video section*/
   --menu-item-clr: white;
   --chevron-clr: white;
   --menu-item-hover-bg: rgb(0 0 0 / 30%);
   --menu-item-hover-clr: #bc92e6;
   --dropdown-content-bg: rgb(0 0 0 / 70%);
   --overlay-header-bg: rgb(0 0 0 / 25%);
   --overlay-header-bg-active: var(--dropdown-content-bg);
   --dropdown-content-border: solid 1px rgb(220 220 220 / 20%);
   --current-header-bg: rgb(0 0 0 / 14%) !important;
   --header-bg: rgb(0 0 0 / 70%);
   --menu-toggle-clr: white;
   --mobile-menu-bg: rgb(0 0 0 / 95%);
   --menu-cta-border: var(--dropdown-content-border)
 }


 .on-hero-section {
   /* update variables when header is on hero section*/
 }

 /* header bg blure when on video section */
 html:not(.dwc-mobile) .dwc-nest-header.on-video-section {
   backdrop-filter: blur(var(--overlay-header-blur));
 }

 /* overlay header border when on video section or dark background*/
 .dwc-nest-header:is(.on-dark-bg, .on-video-section)[data-overlay-header="true"] {
   border: 1px solid rgba(255, 255, 255, 0.2);
 }

 /* header bottom border when on dark background or video section*/
 .dwc-nest-header:is(.on-dark-bg, .on-video-section) {
   border-bottom: 1px solid rgba(255, 255, 255, 0.2);
 }


 /* logo color when on dark background*/
 .on-dark-bg .dwc-nest-menu__logo path {
   fill: white;
 }

 /* logo color when on light background*/
 .on-dark-bg .dwc-nest-menu__logo path {
   /*define svg fill when logo is on light background */
 }

 /* logo color when on video background*/
 .on-video-section .dwc-nest-menu__logo path {
   fill: white;
 }

/*custom */

.on-dark-bg .mega-menu-magic__menu-icon-large{
   background-color: var(--current-header-bg);
    fill: #bc92e6;
    color: #bc92e6;
}

.on-video-section .mega-menu-magic__menu-icon-large{
   background-color: var(--current-header-bg);
    fill: #bc92e6;
    color: #bc92e6;
}

.on-video-section .mega-menu-magic__dropdown-title,
.on-dark-bg .mega-menu-magic__dropdown-title{
    color: rgb(210 210 210);   
}
// Constants
const BREAKPOINT_DESKTOP = 0;
const DEBOUNCE_DELAY = 50;

// Configuration object for all header-related selectors
const HEADER_CONFIG = {
  // Main header element
  headerElement: '.dwc-nest-header',
  // Wrapper element selectors (can be classes, IDs, or data attributes)
  wrapperSelectors: [
    // '.dwc-nest-header__container'
  ],
  // Elements to monitor for header styling (can include any CSS selector)
  // Default monitors sections, but you can add footer, divs, or any element
  monitoredElements: 'section, [data-header-zone]',
  // Store original header background color
  originalHeaderBgColor: null
};

// Unified section type configuration
// Add new data attributes here - they will be automatically mapped to header classes
const SECTION_TYPES = {
  'data-hero': 'on-hero-section',
  'data-video': 'on-video-section',
  'data-custom': 'on-custom-section',
  'data-sticky': 'on-media-section'
  // Add new: 'data-feature': 'on-feature-section'
};

// Configuration for excluded sections
const EXCLUSION_CONFIG = {
  // Data attribute that identifies sections to exclude from header styling
  sectionAttribute: 'data-exclude-header'
};

// Text color classes
const TEXT_CLASSES = {
  light: 'on-dark-bg',
  dark: 'on-light-bg'
};

// Generate classes to remove dynamically from SECTION_TYPES and text classes
const ALL_CLASSES_TO_REMOVE = [
  // Add all header classes from section types
  ...Object.values(SECTION_TYPES),
  // Add text color classes
  TEXT_CLASSES.light,
  TEXT_CLASSES.dark
];

// Performance optimization: Cache DOM elements and computed values
const CACHE = {
  headerElement: null,
  wrapperElement: null,
  sections: [],
  sectionsData: new Map(),
  colorCache: new Map(),
  tempColorElement: null,
  lastKnownSection: null,
  isUpdating: false,
  pendingColorUpdate: false
};

// Initialize cache
function initializeCache() {
  // Cache header elements
  CACHE.headerElement = document.querySelector(HEADER_CONFIG.headerElement);
  
  // Try each wrapper selector until one is found
  for (const selector of HEADER_CONFIG.wrapperSelectors) {
    CACHE.wrapperElement = document.querySelector(selector);
    if (CACHE.wrapperElement) break;
  }
  
  // Cache sections and their positions
  CACHE.sections = Array.from(document.querySelectorAll(HEADER_CONFIG.monitoredElements));
  
  // Create reusable element for color calculations
  CACHE.tempColorElement = document.createElement('div');
  CACHE.tempColorElement.style.position = 'absolute';
  CACHE.tempColorElement.style.visibility = 'hidden';
  CACHE.tempColorElement.style.pointerEvents = 'none';
  document.body.appendChild(CACHE.tempColorElement);
  
  // Cache section metadata
  updateSectionsCache();
}

// Update sections cache (call when DOM changes)
function updateSectionsCache() {
  CACHE.sections = Array.from(document.querySelectorAll(HEADER_CONFIG.monitoredElements));
  CACHE.sectionsData.clear();
  
  CACHE.sections.forEach((section, index) => {
    const sectionData = {
      index,
      isExcluded: section.hasAttribute(EXCLUSION_CONFIG.sectionAttribute)
    };
    
    // Dynamically check for all section types defined in SECTION_TYPES
    Object.keys(SECTION_TYPES).forEach(attribute => {
      sectionData[attribute] = section.hasAttribute(attribute);
    });
    
    CACHE.sectionsData.set(section, sectionData);
  });
}

// Function to remove all section classes from :root only
function removeAllSectionClasses() {
  const rootElement = document.documentElement;
  
  // Remove classes from :root only
  rootElement.classList.remove(...ALL_CLASSES_TO_REMOVE);
}

// Function to update the CSS variable on :root
function updateRootBackgroundVariable(color) {
  document.documentElement.style.setProperty('--current-header-bg', color);
}

// Function to apply classes to :root only
function applyClassesToRoot(headerClass, textClass) {
  const rootElement = document.documentElement;
  
  // Apply header class to :root only
  if (headerClass) {
    rootElement.classList.add(headerClass);
  }
  
  // Apply text class to :root only
  if (textClass) {
    rootElement.classList.add(textClass);
  }
}

// Optimized color conversion using cached temp element
function getRGBValues(color) {
  const cacheKey = color;
  if (CACHE.colorCache.has(cacheKey)) {
    return CACHE.colorCache.get(cacheKey);
  }
  
  CACHE.tempColorElement.style.color = color;
  const computedColor = window.getComputedStyle(CACHE.tempColorElement).color;
  
  // Extract RGB values
  const match = computedColor.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
  const result = match ? {
    r: parseInt(match[1]),
    g: parseInt(match[2]),
    b: parseInt(match[3])
  } : { r: 255, g: 255, b: 255 };
  
  // Cache the result
  CACHE.colorCache.set(cacheKey, result);
  return result;
}

// Function to check if a background color is transparent or empty
function isBackgroundTransparent(color) {
  if (!color) return true;
  
  const transparentValues = [
    'transparent',
    'rgba(0, 0, 0, 0)',
    'rgba(0,0,0,0)',
    'initial',
    'inherit',
    ''
  ];
  
  return transparentValues.includes(color.toLowerCase().replace(/\s/g, ''));
}

// Function to determine if a color is dark or light
function isColorDark(color) {
  if (color === 'transparent' || color === 'rgba(0, 0, 0, 0)') {
    return false;
  }
  
  const rgb = getRGBValues(color);
  const luminance = (0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b) / 255;
  return luminance < 0.5;
}

// Optimized section detection using cached data
function getCurrentSection() {
  if (!CACHE.headerElement || CACHE.sections.length === 0) return null;
  
  const headerHeight = CACHE.headerElement.offsetHeight;
  
  // Quick check if we're still in the same section
  if (CACHE.lastKnownSection) {
    const rect = CACHE.lastKnownSection.getBoundingClientRect();
    if (rect.top <= headerHeight && rect.bottom > headerHeight) {
      return CACHE.lastKnownSection;
    }
  }
  
  // Binary search would be ideal here, but simple loop is sufficient for most cases
  for (const section of CACHE.sections) {
    const rect = section.getBoundingClientRect();
    if (rect.top <= headerHeight && rect.bottom > headerHeight) {
      CACHE.lastKnownSection = section;
      return section;
    }
  }
  
  const firstSection = CACHE.sections[0] || null;
  CACHE.lastKnownSection = firstSection;
  return firstSection;
}

// Function to get computed background color with caching
function getComputedBackgroundColor(element) {
  const cacheKey = element;
  if (CACHE.colorCache.has(cacheKey)) {
    return CACHE.colorCache.get(cacheKey);
  }
  
  const bgColor = window.getComputedStyle(element).backgroundColor;
  CACHE.colorCache.set(cacheKey, bgColor);
  return bgColor;
}

// Function to initialize original header background color
function initializeOriginalHeaderBgColor() {
  if (CACHE.headerElement) {
    HEADER_CONFIG.originalHeaderBgColor = window.getComputedStyle(CACHE.headerElement).backgroundColor;
  }
}

// Function to determine header style configuration based on section
function determineHeaderConfig(section) {
  if (!section) return null;
  
  const sectionData = CACHE.sectionsData.get(section);
  if (!sectionData) return null;
  
  // If section is excluded, return null to skip styling
  if (sectionData.isExcluded) {
    return null;
  }
  
  // Dynamically check for any section type defined in SECTION_TYPES
  for (const [attribute, headerClass] of Object.entries(SECTION_TYPES)) {
    if (sectionData[attribute]) {
      return {
        backgroundColor: null,
        headerClass: headerClass,
        needsWhiteText: null,
        isSpecialSection: true
      };
    }
  }
  
  // Get the actual background color of the section
  const sectionBgColor = getComputedBackgroundColor(section);
  
  if (isBackgroundTransparent(sectionBgColor)) {
    return {
      backgroundColor: HEADER_CONFIG.originalHeaderBgColor || 'rgb(255, 255, 255)',
      headerClass: null,
      needsWhiteText: isColorDark(HEADER_CONFIG.originalHeaderBgColor || 'rgb(255, 255, 255)'),
      isSpecialSection: false
    };
  }
  
  const needsWhiteText = isColorDark(sectionBgColor);
  
  return {
    backgroundColor: sectionBgColor,
    headerClass: null,
    needsWhiteText: needsWhiteText,
    isSpecialSection: false
  };
}

// Function to apply styles (background color to header, classes to :root only)
function applyHeaderStyles(config) {
  if (!CACHE.headerElement || !config) return;
  
  const elementsToStyle = [CACHE.headerElement, CACHE.wrapperElement].filter(Boolean);
  
  // Use requestAnimationFrame for smooth visual updates
  requestAnimationFrame(() => {
    // First, remove all section classes and text classes from :root only
    removeAllSectionClasses();
    
    // Update the root CSS variable with background color
    if (config.backgroundColor !== null) {
      const appliedBgColor = config.backgroundColor || '';
      updateRootBackgroundVariable(appliedBgColor);
    } else {
      updateRootBackgroundVariable('');
    }
    
    // Determine text class to apply
    const textClass = config.needsWhiteText !== null 
      ? (config.needsWhiteText ? TEXT_CLASSES.light : TEXT_CLASSES.dark)
      : null;
    
    // Apply classes to :root only
    applyClassesToRoot(config.headerClass, textClass);
    
    // Handle background color on header elements only
    elementsToStyle.forEach(element => {
      if (config.backgroundColor !== null) {
        const appliedBgColor = config.backgroundColor || '';
        element.style.backgroundColor = appliedBgColor;
      } else {
        element.style.backgroundColor = '';
      }
    });
    
    // For special sections, allow CSS to apply first, then get computed background color
    if (config.isSpecialSection && config.headerClass) {
      // Use setTimeout(0) to ensure CSS has been applied, but batch multiple calls
      if (!CACHE.pendingColorUpdate) {
        CACHE.pendingColorUpdate = true;
        setTimeout(() => {
          // Process all elements that need color updates in this batch
          elementsToStyle.forEach(el => {
            // Check if element has any of the section classes (though they're not applied anymore)
            const hasSectionClass = Object.values(SECTION_TYPES).some(className => 
              el.classList.contains(className)
            );
            
            if (hasSectionClass) {
              const computedBgColor = getComputedBackgroundColor(el);
              updateRootBackgroundVariable(computedBgColor);
            }
          });
          CACHE.pendingColorUpdate = false;
        }, 50);
      }
    }
    
    CACHE.isUpdating = false;
  });
}

// Throttled update function using requestAnimationFrame
function updateHeaderStyles() {
  // Prevent multiple updates in the same frame
  if (CACHE.isUpdating) return;
  
  // Apply only on screens larger than the breakpoint
  if (window.innerWidth <= BREAKPOINT_DESKTOP) {
    return;
  }
  
  CACHE.isUpdating = true;
  
  const currentSection = getCurrentSection();
  if (!currentSection) {
    CACHE.isUpdating = false;
    return;
  }
  
  const headerConfig = determineHeaderConfig(currentSection);
  if (!headerConfig) {
    CACHE.isUpdating = false;
    return;
  }
  
  applyHeaderStyles(headerConfig);
}

// Debounce function for resize events (less frequent)
function debounce(func, wait) {
  let timeout;
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout);
      func(...args);
    };
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
}

// RAF-based throttle for scroll events
let rafId = null;
function throttleWithRAF(func) {
  return function(...args) {
    if (rafId) return;
    
    rafId = requestAnimationFrame(() => {
      func.apply(this, args);
      rafId = null;
    });
  };
}

// Initialize everything
function initialize() {
  initializeCache();
  initializeOriginalHeaderBgColor();
  updateHeaderStyles();
}

// Cleanup function
function cleanup() {
  if (CACHE.tempColorElement && CACHE.tempColorElement.parentNode) {
    CACHE.tempColorElement.parentNode.removeChild(CACHE.tempColorElement);
  }
  if (rafId) {
    cancelAnimationFrame(rafId);
  }
}

// Initialize on page load
if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', initialize);
} else {
  initialize();
}

// Create optimized event handlers
const throttledUpdateHeaderStyles = throttleWithRAF(updateHeaderStyles);
const debouncedUpdateHeaderStyles = debounce(() => {
  updateSectionsCache(); // Refresh cache on resize
  updateHeaderStyles();
}, DEBOUNCE_DELAY);

// Add event listeners with passive option for better performance
window.addEventListener('scroll', throttledUpdateHeaderStyles, { passive: true });
window.addEventListener('resize', debouncedUpdateHeaderStyles, { passive: true });

// Cleanup on page unload
window.addEventListener('beforeunload', cleanup);

Creșa, Grădinița și Școala NANNY

DESPRE NOI

Nanny in imagini H

Viziunea noastră

Nanny este o instituție de învățământ privată din Galați care însoțește copilul în parcursul său educațional, de la primii ani de viață până la vârsta școlară. Am creat un mediu în care grija autentică pentru copii se îmbină cu profesionalismul, astfel încât fiecare etapă – creșă, grădiniță, școală – să fie trăită cu bucurie, încredere și sentimentul de siguranță.

Credem într-o educație care pune în centru copilul și nevoile lui reale: dezvoltare emoțională sănătoasă, relații bazate pe respect și colaborare, dar și un ritm de învățare adaptat fiecărei personalități. Activitățile noastre îmbină jocul, descoperirea, proiectele creative și învățarea structurată, astfel încât copiii să își dezvolte treptat autonomia, gândirea critică și dorința de a învăța.

Povestea NANNY

  • În anul 2007, căutând grădiniță pentru fiul meu, s-a născut dorința de a avea propria grădiniță, deoarece tot ce era la acel moment nu corespundea ideii mele de grădiniță.

    În căutările mele îmi doream să găsesc oameni pe care să-i simt alături de mine în procesul creșterii fiului meu, să simt că valorile lor corespund sau se intersectează cu parte din valorile mele, că sunt transparenți în ceea ce fac și spun. Îmi doream să îi simt parteneri…

    De asemenea, era foarte important pentru mine să existe curte (ținând cont că aș fi ales să rămână la program lung), să aibă bucătărie proprie și personal, pe cât posibil, stabil, să acorde atenție curățeniei și igienei.

    Am vizitat toate grădinițele private de la acel moment și nu am găsit nici una care să îndeplinească, măcar în parte, dorințele mele.

    Scoala Nanny Galati

  • Astfel că, în 2008 am început să caut spații care să se preteze unei grădinițe, am pornit demersul pentru autorizarea ei de către Ministerul Educației, am ales oamenii care să rezoneze cu ideea mea despre educație și grijă.

    Scoala Nanny Galati

  • La 1 septembrie 2009, când am făcut inaugurarea Grădiniței Nanny, aveam deja 33 de copii înscriși, 3 educatoare, 2 bucătărese și 2 îngrijitoare. Aveam o clădire frumoasă, spațioasă cu 5 săli de grupă, o sală de mese, bucătărie proprie pentru orice mofturos și o curte generoasă cu multă iarbă verde și vegetație, așa cum îmi doream pentru fiul meu.

    În primul an de funcționare mi-am dat seama că pentru a ajuta părinții în procesul creșterii copiilor e nevoie să găsesc soluții pentru a le veni în sprijin. Astfel, am decis ca pe lângă tot ce ofeream să avem programul grădiniței până la 18, pentru ca orice părinte să poată ajunge în liniște să ia copilul. Tot în primul an am observat necesitatea de a înființa o grupă cu copii de 2 ani pentru că mamele, așa cum știm, erau nevoite să se întoarcă la serviciu, iar grădinițele de stat primeau în acei ani doar de la 3 ani copiii. Grădinița Nanny a fost prima grădiniță care a creat grupă pentru copii de 2 ani și a format cadre capabile să adapteze programa care era adresată doar copiilor peste 3 ani.

    Un alt lucru extrem de important încă din prima zi a fost alimentația copiilor din familia Nanny. Încă din prima zi am pus accent pe formarea unor meniuri sănătoase, integral preparate de noi cu alimente proaspete, păstrând permanent o rigoare a procedurilor privind igiena și siguranța alimentelor.
    Pentru Nanny fiecare provocare a fost motiv de creștere.

    Scoala Nanny Galati

  • În 2010 a început să prindă contur și prezența noastră în online, născându-se prima pagină de facebook (nannykids).
    Tot în 2010 s-a născut și dorința de a crea o școală pentru copiii noștri, având foarte multe solicitări din partea părinților care terminau anii de grădiniță și își doreau să continue cu noi.

    Scoala Nanny Galati

  • În 2011 a prins contur o primă inițiativă caritabilă care se menține până în ziua de azi, Târgul de caritate “Mic, dar cu suflet mare”. Împreună cu comunitatea Nanny am început să facem bine, ajutând copii din grădinițe defavorizate și copii cu afecțiuni medicale.

    Scoala Nanny Galati

  • În anul 2012 aveam deja 5 grupe de copii, 5 educatoare, 3 bucătărese, 3 îngrijitoare și multe recomandări pozitive din partea celor care ne treceau pragul.

    Scoala Nanny Galati

  • Începând cu anul 2013 am introdus un alt bun obicei cu ajutorul căruia am creat minunate amintiri și experiențe pentru copiii din Școala Nanny – taberele de schi și taberele de vară.

    Ne-am bucurat an de an să descoperim că educația este extrem de importantă și crează copii autonomi, curioși, care știu să se bucure de fiecare lucru mărunt din jur și au curajul de a păși către independență. Experiențele taberelor de schi cu copiii din grădiniță au fost uluitoare și ne-au dat curaj să continuăm.

    O altă preocupare a fost aceea de a face din grădinița Nanny un loc unde bacteriile, virușii nu locuiesc mult timp și ce este mai important, nu se transmit.

    În anul 2013, la sugestia medicului cu care colaborăm am început să citesc și să mă documentez despre niște lămpi care se folosesc în sălile de operație, industria farmaceutică, industria alimentară, centre de înfrumusețare, în încăperi cu încărcătură microbiană mare. După documentare, am achiziționat trei lămpi bactericide care, prin comparație cu anii anteriori, și-au dovedit eficiența, crescând astfel prezența la grupă, implicit scăzând frecvența îmbolnăvirilor copiilor noștri.

    Scoala Nanny Galati

  • În 2014, când au ajuns la școală copiii primei noastre generații am aflat despre ei că sunt copii care știu să se exprime cu încredere, că știu să-și argumenteze părerile și că, în sens pozitiv, nu trec neobservați. Am fost tare bucuroși de rezultat și ne-am dorit să facem mai mult și mai bine.

    Așa că am început să caut un alt spațiu unde visele să prindă contur deoarece sediul unde ne aflam nu a mai fost suficient.

    Scoala Nanny Galati

  • În septembrie 2016 ne-am schimbat sediul din dorința de a dezvolta și partea de școală.

    Scoala Nanny Galati

  • În 2019 am inițiat o primă autorizare a școlii, însă perioada pandemiei Covid ne-a pus pe pauză planurile făcându-ne să ne concentrăm pe înțelegerea și depășirea perioadei cu cât mai puține daune. A fost o perioadă plină de emoții, tensiuni și provocări, însă ne putem lăuda cu faptul că părinții ne-au fost alături și ne-au susținut financiar pentru a ne permite să menținem întreg personalul de la acel moment. Sprijinul obținut ne-a demonstrat că au înțeles cât de importanți sunt oamenii din echipă, cât de prețioși sunt.

    În perioada în care nu ne-am putut îmbrățișa copiii decât virtual, am făcut tot ce am putut ca să fim prezenți în viețile lor prin prezența online. A fost un alt mod de a îi descoperi pe ei și pe părinți, au fost momente emoționante în care tot ce doream era să eliminăm din tensiunea necunoscutului, și să diminuăm pericolul care își făcea simțită prezența într-un mod atât de agresiv.

    Odată cu planurile noastre puse pe pauză și proprietarul clădirii unde ne aflam la acel moment și-a schimbat planurile, astfel că am fost nevoiți să ne regândim drumul și să căutăm o clădire unde să putem deschide și școala.

    După un an petrecut pe șantier pentru a pregăti noua casă Nanny, în septembrie 2021 am reușit să inaugurăm sediul din strada Basarabiei care are 2 corpuri, unul creșa și grădinița, unul școala. Avem spații diferite pentru fiecare nivel de vârstă, săli de mese separate, avem curți diferite amenajate pe niveluri de vârstă, blocul alimentar la demisolul clădirii, astfel că mirosurile apetisante de mâncare nu rămân în incinta clădirii (un mare of al meu la celelalte sedii) și zone de relaxare, conectare și mișcare pentru școlarii noștri.

    Pentru că în perioada pandemiei am observat că îmbolnăvirile sunt diminuate datorită faptului că nu mixam grupele, am ales ca noul sediu să respecte spații diferite în funcție de vârstă. Am făcut în așa fel încât cei mici, cu o imunitate încă neformată, să nu se intersecteze deloc cu cei peste 3 ani, iar toate grupele de creșă și grădiniță să aibă zone total diferite de școală.

    Scoala Nanny Galati

  • În sept 2022 am autorizat nivelul primar și am început încrezători și plini de energie să punem câte o cărămidă la visul de a avea cât mai mulți ani copiii în grija noastră.

    Scoala Nanny Galati

  • În anul 2025 am ajuns să avem 4 clase la școală, 8 învățătoare care să acopere programul de dimineață, dar și cel destinat temelor, o grupă de creșă și 4 grupe de grădiniță cu un efectiv în medie de 15-18 copii/ grupă, 8 educatoare calificate și 2 cadre specializate pentru partea de creșă. Pe lângă cadrele specializate avem 5 cadre de sprijin pentru educatoare și învățătoare, 5 doamne pe partea de curățenie, asistent medical permanent și 4 furnicuțe care ne asigură hrana noastră cea de toate zilele, extrem de importantă pentru dezvoltarea copiilor noștri.

    Scoala Nanny Galati

Contact

Hai să ne cunoaștem

Suntem la un mesaj distanță

LOGO Nanny

Școala NANNY

Răspundem, de obicei, în 3 minute.

  • Școala NANNY

    Salut,
    Cu ce te pot ajuta?

  • Școala NANNY

    Ia legătura cu noi chiar acum!

Start chat