core-maugli 1.2.60 → 1.2.62

package/astro-image-resize.mjs

@@ -0,0 +1,25 @@
+// astro-image-resize.mjs - Astro integration for image processing and previews
+import { execSync } from 'child_process';
+
+export default function imageResize() {
+  return {
+    name: 'image-resize',
+    hooks: {
+      'astro:build:start': () => {
+        console.log('🖼️  Starting image processing for build...');
+        try {
+          execSync('node scripts/resize-for-build.cjs', { stdio: 'inherit' });
+        } catch (error) {
+          console.error('❌ Error during image resizing:', error.message);
+        }
+        
+        console.log('🎭 Starting preview generation for build...');
+        try {
+          execSync('BUILD_MODE=1 node scripts/generate-previews.js', { stdio: 'inherit' });
+        } catch (error) {
+          console.error('❌ Error during preview generation:', error.message);
+        }
+      }
+    }
+  };
+}

package/astro.config.mjs

@@ -0,0 +1,160 @@
+import mdx from '@astrojs/mdx';
+import sitemap from '@astrojs/sitemap';
+import tailwindcss from '@tailwindcss/vite';
+import { defineConfig } from 'astro/config';
+import remarkSlug from 'remark-slug';
+import { imagetools } from 'vite-imagetools';
+import { VitePWA } from 'vite-plugin-pwa';
+import imageResize from './astro-image-resize.mjs';
+import { maugliConfig } from './src/config/maugli.config';
+import siteConfig from './src/data/site-config';
+import customSlugify from './src/utils/remark-slugify';
+
+export const pwaOptions = {
+    registerType: 'autoUpdate',
+    includeAssets: ['favicon.svg', 'favicon.ico', 'robots.txt', 'apple-touch-icon.png'],
+    manifest: {
+        name: "Maugli Blog",
+        short_name: "Maugli",
+        start_url: "/",
+        display: "standalone",
+        background_color: maugliConfig.pwa?.backgroundColor ?? '#ffffff',
+        theme_color: maugliConfig.pwa?.themeColor ?? '#0cbf11',
+        icons: maugliConfig.pwa?.icons ?? [
+            {
+                src: "/icon-192.png",
+                sizes: "192x192",
+                type: "image/png",
+                purpose: "any maskable",
+            },
+            {
+                src: "/icon-512.png",
+                sizes: "512x512",
+                type: "image/png",
+            },
+        ],
+    },
+    workbox: {
+        navigateFallback: '/index.html',
+        cleanupOutdatedCaches: true,
+        navigateFallbackDenylist: [/^\/api\//],
+        clientsClaim: true,
+        globPatterns: ['**/*.{js,css,html,png,jpg,jpeg,webp,svg}'],
+        runtimeCaching: [
+            {
+                urlPattern: ({ request }) => request.destination === 'image',
+                handler: 'CacheFirst',
+                options: {
+                    cacheName: 'images-cache',
+                    expiration: {
+                        maxEntries: 50,
+                        maxAgeSeconds: 30 * 24 * 60 * 60 // 30 дней
+                    }
+                }
+            },
+            {
+                urlPattern: ({ request }) => request.destination === 'font',
+                handler: 'CacheFirst',
+                options: {
+                    cacheName: 'fonts-cache',
+                    expiration: {
+                        maxEntries: 20,
+                        maxAgeSeconds: 365 * 24 * 60 * 60 // 1 год
+                    }
+                }
+            }
+        ]
+    },
+    devOptions: {
+        enabled: true, // чтобы работал в деве
+        type: 'module',
+    }
+};
+
+// https://astro.build/config
+export default defineConfig({
+    site: siteConfig.website,
+    image: {
+        service: {
+            entrypoint: 'astro/assets/services/sharp',
+            config: {
+                limitInputPixels: false,
+                // Aggressive optimization for better performance
+                jpeg: { quality: 75, progressive: true },
+                webp: { quality: 75, effort: 6 },
+                avif: { quality: 65, effort: 6 },
+                png: { quality: 75, compressionLevel: 9 },
+            }
+        }
+    },
+    integrations: [
+        mdx(),
+        sitemap(),
+        imageResize()
+    ],
+    vite: {
+        plugins: [
+            tailwindcss(),
+            imagetools({
+                // Aggressive image optimization
+                defaultDirectives: () => {
+                    return new URLSearchParams({
+                        format: 'webp',
+                        quality: '75',
+                        progressive: 'true',
+                        // Enable compression
+                        effort: '6'
+                    });
+                },
+                // Additional formats for fallback
+                formats: ['webp', 'avif'],
+                // Disable for development to speed up build
+                disabled: process.env.NODE_ENV === 'development'
+            }),
+            VitePWA(pwaOptions)
+        ],
+        build: {
+            cssCodeSplit: true,
+            minify: 'esbuild',
+            target: 'es2020',
+            rollupOptions: {
+                output: {
+                    // Separate CSS chunks for better caching
+                    assetFileNames: (assetInfo) => {
+                        if (assetInfo.name && assetInfo.name.endsWith('.css')) {
+                            return 'assets/css/[name].[hash][extname]';
+                        }
+                        if (assetInfo.name && /\.(png|jpe?g|svg|gif|webp|avif)$/.test(assetInfo.name)) {
+                            return 'assets/img/[name].[hash][extname]';
+                        }
+                        return 'assets/[name].[hash][extname]';
+                    },
+                    chunkFileNames: 'assets/js/[name].[hash].js',
+                    manualChunks: {
+                        // Split vendor code for better caching - removed astro from manual chunks
+                    }
+                },
+                // Remove problematic external configuration
+            },
+            // Additional optimization settings
+            reportCompressedSize: false, // Faster build
+            chunkSizeWarningLimit: 1000
+        },
+        css: {
+            // Optimize CSS processing
+            preprocessorOptions: {
+                scss: {
+                    // Additional SCSS options if needed
+                }
+            }
+        },
+        optimizeDeps: {
+            // Improve dev performance - astro should not be excluded
+        }
+    },
+    markdown: {
+        remarkPlugins: [
+            [remarkSlug, { slug: customSlugify }]
+        ]
+    }
+});

package/package.json

@@ -2,7 +2,7 @@
     "name": "core-maugli",
     "description": "Astro & Tailwind CSS blog theme for Maugli.",
     "type": "module",
-    "version": "1.2.60",
+    "version": "1.2.62",
     "license": "GPL-3.0-or-later OR Commercial",
     "repository": {
         "type": "git",
@@ -76,6 +76,9 @@
     },
     "files": [
         "src",
+        "resize-all.cjs",
+        "astro-image-resize.mjs",
+        "typograf-batch.js",
         "public/favicon.svg",
         "public/icon-192.png",
         "public/icon-512.png",
@@ -89,6 +92,9 @@
         "public/blackbox*.webp",
         "scripts",
         "bin",
+        "astro.config.mjs",
+        "tsconfig.json",
+        "vite.config.js",
         ".gitignore",
         "netlify.toml"
     ],

package/resize-all.cjs

@@ -0,0 +1,79 @@
+// resize-all.cjs - рекурсивный ресайз изображений
+const fs = require('fs');
+const path = require('path');
+const sharp = require('sharp');
+
+// Размеры для генерации
+const sizes = [400, 800, 1200];
+
+const inputDir = './public';
+const processedFiles = new Set(); // Отслеживаем обработанные файлы
+
+// Рекурсивная функция для обхода папок
+function processDirectory(dir) {
+  if (!fs.existsSync(dir)) {
+    console.log(`Папка ${dir} не существует`);
+    return;
+  }
+
+  const items = fs.readdirSync(dir);
+  
+  items.forEach(item => {
+    const itemPath = path.join(dir, item);
+    const stat = fs.statSync(itemPath);
+    
+    if (stat.isDirectory()) {
+      // Рекурсивно обрабатываем подпапки
+      processDirectory(itemPath);
+    } else if (stat.isFile()) {
+      const ext = path.extname(item).toLowerCase();
+      const baseName = path.basename(item, ext);
+      
+      // Проверяем, что это изображение и не содержит размер в названии
+      if (['.jpg', '.jpeg', '.png', '.webp'].includes(ext)) {
+        // Исключаем PWA иконки и служебные файлы
+        const excludePatterns = [
+          'icon-192', 'icon-512', // PWA иконки
+          'favicon', // Фавиконки
+          'logo', // Логотипы (часто SVG, но на всякий случай)
+          'manifest' // Файлы манифеста
+        ];
+        
+        const shouldExclude = excludePatterns.some(pattern => baseName.includes(pattern));
+        
+        // Пропускаем файлы, которые уже содержат размер (например, image-400.webp, image-800-800.webp)
+        // Улучшенная проверка: пропускаем файлы с -400, -800, -1200 в любом месте названия
+        const hasResizeSuffix = sizes.some(size => baseName.includes(`-${size}`));
+        
+        if (!hasResizeSuffix && !shouldExclude && !processedFiles.has(itemPath)) {
+          processedFiles.add(itemPath);
+          
+          console.log(`Обрабатываем: ${itemPath}`);
+          
+          sizes.forEach(width => {
+            const outputPath = path.join(path.dirname(itemPath), `${baseName}-${width}${ext}`);
+            
+            // Проверяем, что файл еще не существует
+            if (!fs.existsSync(outputPath)) {
+              sharp(itemPath)
+                .resize(width)
+                .toFile(outputPath, (err) => {
+                  if (err) {
+                    console.error(`Ошибка при создании ${outputPath}:`, err.message);
+                  } else {
+                    console.log(`✅ Создан: ${path.relative('./public', outputPath)}`);
+                  }
+                });
+            } else {
+              console.log(`⏭️  Пропускаем (уже существует): ${path.relative('./public', outputPath)}`);
+            }
+          });
+        }
+      }
+    }
+  });
+}
+
+console.log('🔄 Начинаем ресайз всех изображений...');
+processDirectory(inputDir);
+console.log('✅ Обработка завершена!');

package/scripts/check-version.js

@@ -38,20 +38,35 @@ async function getMaugliConfig() {
     try {
         const configPath = path.join(process.cwd(), 'src/config/maugli.config.ts');
         if (!fs.existsSync(configPath)) {
+            console.log(colorize('⚠️  maugli.config.ts not found at src/config/maugli.config.ts', 'yellow'));
             return null;
         }
         
         // Простое чтение конфига через регулярные выражения
         const configContent = fs.readFileSync(configPath, 'utf8');
-        const forceUpdateMatch = configContent.match(/automation:\s*{[^}]*?forceUpdate:\s*(true|false)/s);
+        console.log(colorize('🔍 Reading maugli.config.ts...', 'cyan'));
+        
+        // Ищем forceUpdate в automation секции
+        const automationMatch = configContent.match(/automation\s*:\s*{([^}]+)}/s);
+        if (!automationMatch) {
+            console.log(colorize('⚠️  automation section not found in config', 'yellow'));
+            return null;
+        }
+        
+        const automationSection = automationMatch[1];
+        const forceUpdateMatch = automationSection.match(/forceUpdate\s*:\s*(true|false)/);
+        
+        const forceUpdate = forceUpdateMatch ? forceUpdateMatch[1] === 'true' : false;
+        
+        console.log(colorize(`📋 Config found - forceUpdate: ${forceUpdate}`, 'cyan'));
         
         return {
             automation: {
-                forceUpdate: forceUpdateMatch ? forceUpdateMatch[1] === 'true' : false
+                forceUpdate: forceUpdate
             }
         };
     } catch (error) {
-        console.warn(colorize('⚠️  Could not read maugli.config.ts', 'yellow'));
+        console.warn(colorize('⚠️  Could not read maugli.config.ts: ' + error.message, 'yellow'));
         return null;
     }
 }
@@ -257,6 +272,11 @@ async function main() {
     // Check forceUpdate setting from maugli.config.ts
     const forceUpdate = maugliConfig?.automation?.forceUpdate || false;
     
+    console.log(colorize(`\n🔧 Configuration check:`, 'cyan'));
+    console.log(colorize(`   • maugli.config.ts found: ${maugliConfig ? 'Yes' : 'No'}`, 'white'));
+    console.log(colorize(`   • forceUpdate setting: ${forceUpdate}`, 'white'));
+    console.log(colorize(`   • CI/CD detected: ${isCI}`, 'white'));
+    
     if (isCI) {
         console.log(colorize('\n🤖 CI/CD environment detected. Updating automatically...', 'cyan'));
         const success = await performUpdate();

package/src/i18n/ru.json

@@ -34,7 +34,7 @@
       "title": "Рубрики",
       "description": "Все статьи по рубрикам",
       "blogRubrics": "Рубрики блога",
-      "moreTags": "Дополнительные теги"
+      "moreTags": "Теги"
     },
     "index": {
       "title": "<Блог>",

package/src/utils/image-utils.ts

@@ -1,9 +1,9 @@
 // src/utils/image-utils.ts - Утилиты для работы с изображениями
 
 /**
- * Определяет правильный путь к изображению в зависимости от типа контента
- * Все пользовательские изображения должны находиться в /img/page-images/
- * Системные файлы остаются в /img/default/ и /img/examples/
+ * Определяет правильный путь к изображению
+ * Все пользовательские изображения находятся в /img/ и подпапках
+ * Автоматическая оптимизация применяется ко всем изображениям в public/img/
  */
 export function getImagePath(imageName: string, contentType?: 'blog' | 'author' | 'product' | 'project' | 'tag'): string {
   // Если путь уже абсолютный (начинается с /), возвращаем как есть
@@ -11,30 +11,26 @@ export function getImagePath(imageName: string, contentType?: 'blog' | 'author'
     return imageName;
   }
   
-  // Если это системные папки, не меняем путь
-  if (imageName.startsWith('default/') || imageName.startsWith('examples/')) {
-    return `/img/${imageName}`;
-  }
-  
-  // Все остальные изображения ищем в page-images
-  return `/img/page-images/${imageName}`;
+  // Все изображения идут в /img/
+  return `/img/${imageName}`;
 }
 
 /**
  * Получает путь к изображению для конкретного типа контента
- * Добавляет префикс типа если его нет
+ * Все файлы просто в /img/ без подпапок
  */
 export function getContentImagePath(slug: string, contentType: 'blog' | 'author' | 'product' | 'project' | 'tag', extension: string = '.webp'): string {
   const fileName = `${contentType}_${slug}${extension}`;
-  return getImagePath(fileName);
+  return `/img/${fileName}`;
 }
 
 /**
  * Получает путь к превью изображению
+ * Все файлы просто в /img/ без подпапок
  */
 export function getPreviewImagePath(slug: string, contentType: 'blog' | 'author' | 'product' | 'project' | 'tag', extension: string = '.webp'): string {
   const fileName = `previews_${contentType}_${slug}${extension}`;
-  return getImagePath(fileName);
+  return `/img/${fileName}`;
 }
 
 /**
@@ -54,22 +50,12 @@ export function getDefaultImagePath(contentType: 'blog' | 'author' | 'product' |
 
 /**
  * Конвертирует старые пути к новой структуре
- * Для обратной совместимости
+ * Все изображения теперь просто в /img/ и подпапках
  */
 export function convertLegacyImagePath(imagePath: string): string {
-  // Конвертируем старые пути в новые
-  const conversions = [
-    { from: '/img/blog/', to: '/img/page-images/' },
-    { from: '/img/authors/', to: '/img/page-images/' },
-    { from: '/img/products/', to: '/img/page-images/' },
-    { from: '/img/projects/', to: '/img/page-images/' },
-    { from: '/img/uploads/', to: '/img/page-images/' }
-  ];
-  
-  for (const conversion of conversions) {
-    if (imagePath.startsWith(conversion.from)) {
-      return imagePath.replace(conversion.from, conversion.to);
-    }
+  // Убираем page-images из пути - теперь всё просто в /img/
+  if (imagePath.includes('/img/page-images/')) {
+    return imagePath.replace('/img/page-images/', '/img/');
   }
   
   return imagePath;

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "astro/tsconfigs/strict",
+  "include": [".astro/types.d.ts", "**/*"],
+  "exclude": ["dist"],
+  "compilerOptions": {
+    "strictNullChecks": true
+  }
+}

package/typograf-batch.js

@@ -0,0 +1,49 @@
+import Typograf from 'typograf';
+import { readFileSync, writeFileSync, readdirSync, statSync, existsSync } from 'fs';
+import yaml from 'js-yaml';
+
+const tp = new Typograf({ locale: ['ru', 'en-US'] });
+const dir = './src/content/blog';
+const cacheFile = './.typograf-cache.json';
+
+let cache = {};
+if (existsSync(cacheFile)) {
+  cache = JSON.parse(readFileSync(cacheFile, 'utf8'));
+}
+
+let cacheUpdated = false;
+
+readdirSync(dir)
+  .filter(f => f.endsWith('.md'))
+  .forEach(f => {
+    const file = dir + '/' + f;
+    const stats = statSync(file);
+    const mtime = stats.mtimeMs;
+
+    // Если не изменялся — скипаем
+    if (cache[f] === mtime) return;
+
+    const data = readFileSync(file, 'utf8');
+    const parts = data.split('---');
+    if (parts.length < 3) return;
+    let fm = yaml.load(parts[1]);
+    if (fm.title) fm.title = tp.execute(fm.title);
+    if (fm.description) fm.description = tp.execute(fm.description);
+
+    const newData = [
+      '---',
+      yaml.dump(fm).trim(),
+      '---',
+      tp.execute(parts.slice(2).join('---'))
+    ].join('\n');
+
+    writeFileSync(file, newData);
+    cache[f] = mtime;
+    cacheUpdated = true;
+    console.log(`Typografed: ${file}`);
+  });
+
+// Сохраняем кеш только если были изменения
+if (cacheUpdated) {
+  writeFileSync(cacheFile, JSON.stringify(cache, null, 2));
+}

package/vite.config.js

@@ -0,0 +1,11 @@
+import { defineConfig } from 'vite';
+import { imagetools } from 'vite-imagetools';
+import { VitePWA } from 'vite-plugin-pwa';
+import { pwaOptions } from './astro.config.mjs';
+
+export default defineConfig({
+  plugins: [
+    imagetools(),
+    VitePWA(pwaOptions)
+  ]
+});