create-nativecore 0.1.1 → 0.2.0

package/template/public/robots.txt

@@ -0,0 +1,13 @@
+# robots.txt for nativeCore Framework
+
+User-agent: *
+Allow: /
+
+# Disallow admin/private areas if any
+# Disallow: /admin/
+
+# Sitemap location
+Sitemap: https://yourdomain.com/sitemap.xml
+
+# Crawl-delay (optional, adjust as needed)
+Crawl-delay: 1

package/template/public/sitemap.xml

@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+    <url>
+        <loc>https://yourdomain.com/</loc>
+        <lastmod>2026-01-22</lastmod>
+        <changefreq>weekly</changefreq>
+        <priority>1.0</priority>
+    </url>
+    <url>
+        <loc>https://yourdomain.com/about</loc>
+        <lastmod>2026-01-22</lastmod>
+        <changefreq>monthly</changefreq>
+        <priority>0.8</priority>
+    </url>
+    <url>
+        <loc>https://yourdomain.com/components</loc>
+        <lastmod>2026-01-22</lastmod>
+        <changefreq>weekly</changefreq>
+        <priority>0.8</priority>
+    </url>
+    <url>
+        <loc>https://yourdomain.com/login</loc>
+        <lastmod>2026-01-22</lastmod>
+        <changefreq>monthly</changefreq>
+        <priority>0.5</priority>
+    </url>
+</urlset>

package/template/scripts/build-for-bots.mjs

@@ -0,0 +1,121 @@
+import puppeteer from 'puppeteer';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const distPath = path.join(__dirname, '../dist');
+const botDistPath = path.join(distPath, 'bot');
+
+// Routes to pre-render for bots. Keep this to publicly reachable marketing/docs pages.
+const routes = [
+    '/',
+    '/docs',
+    '/components',
+    '/login'
+];
+
+function sanitizeBotHtml(html) {
+    return html
+    .replace(/<style>\s*html\[data-public-route="pending"\] body \{[\s\S]*?<\/style>/, '<style>html[data-public-route] body { visibility: visible; opacity: 1; }</style>')
+    .replace(/data-public-route="pending"/g, 'data-public-route="ready"')
+        .replace(/<script>\s*\(function\(\) \{[\s\S]*?document\.documentElement\.setAttribute\('data-public-route', 'ready'\);\s*\}\)\(\);\s*<\/script>/, '')
+        .replace(/<script>\s*\(function\(\) \{[\s\S]*?document\.write\(`<link rel="stylesheet" href="\/src\/styles\/main\.css\?v=\$\{version\}">`\);\s*\}\)\(\);\s*<\/script>/, '')
+        .replace(/<script type="module">\s*\(function\(\) \{[\s\S]*?import\(`\/dist\/app\.js\?v=\$\{version\}`\);\s*\}\)\(\);\s*<\/script>/, '')
+        .replace(/<script defer="" src="https:\/\/static\.cloudflareinsights\.com\/beacon[^>]*><\/script>/g, '');
+}
+
+async function buildForBots() {
+    console.log('🤖 Building bot-optimized HTML...\n');
+
+    fs.rmSync(botDistPath, { recursive: true, force: true });
+    fs.mkdirSync(botDistPath, { recursive: true });
+    
+    let browser;
+    
+    try {
+        // Launch headless browser
+        console.log('🚀 Starting headless browser...');
+        browser = await puppeteer.launch({
+            headless: 'new',
+            args: ['--no-sandbox', '--disable-setuid-sandbox']
+        });
+        
+        const page = await browser.newPage();
+        
+        // Process each route
+        for (const route of routes) {
+            console.log(`📄 Rendering ${route}...`);
+            
+            try {
+                // Navigate to the page
+                await page.goto(`http://localhost:8000${route}`, {
+                    waitUntil: 'networkidle0',
+                    timeout: 30000
+                });
+                
+                // Wait a bit for any animations/dynamic content
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                
+                // Get the rendered HTML
+                const html = sanitizeBotHtml(await page.content());
+                
+                // Determine output path
+                let outputPath;
+                if (route === '/') {
+                    outputPath = path.join(botDistPath, 'index.html');
+                } else {
+                    // Create directory for route
+                    const routeDir = path.join(botDistPath, route);
+                    if (!fs.existsSync(routeDir)) {
+                        fs.mkdirSync(routeDir, { recursive: true });
+                    }
+                    outputPath = path.join(routeDir, 'index.html');
+                }
+                
+                // Write HTML file
+                fs.writeFileSync(outputPath, html);
+                
+                console.log(`   ✅ Saved to ${outputPath.replace(distPath, 'dist')}`);
+            } catch (error) {
+                console.error(`   ❌ Failed to render ${route}:`, error.message);
+            }
+        }
+        
+        console.log('\n✨ Bot build complete!');
+        console.log(`📦 Bot-optimized files in: dist/bot/`);
+        console.log(`📦 Publishable bot files will be copied into: _deploy/bot/ during prepare-static-assets`);
+        console.log(`🔍 Search engines will now see pre-rendered HTML\n`);
+        
+    } catch (error) {
+        console.error('❌ Bot build failed:', error);
+        process.exit(1);
+    } finally {
+        if (browser) {
+            await browser.close();
+        }
+    }
+}
+
+// Check if dev server is running
+async function checkDevServer() {
+    try {
+        const response = await fetch('http://localhost:8000');
+        return response.ok;
+    } catch {
+        return false;
+    }
+}
+
+// Main execution
+(async () => {
+    const serverRunning = await checkDevServer();
+    
+    if (!serverRunning) {
+        console.error('❌ Dev server is not running on http://localhost:8000');
+        console.error('💡 Please run `npm start` in another terminal first\n');
+        process.exit(1);
+    }
+    
+    await buildForBots();
+})();

package/template/scripts/convert-to-ts.mjs

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+/**
+ * TypeScript Conversion Helper
+ * Converts all remaining .js files to .ts with basic type annotations
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const srcDir = path.join(__dirname, '..', 'src');
+
+// Files to skip (already converted or special cases)
+const skipFiles = new Set([
+    'state.ts', 'component.ts', 'router.ts', 'http.ts',
+    'auth.service.ts', 'api.service.ts', 'storage.service.ts'
+]);
+
+// Basic type inference rules
+const typeInference = {
+    'const.*=.*\\[\\]': 'any[]',
+    'const.*=.*\\{\\}': 'Record<string, any>',
+    'const.*=.*useState\\(': 'State',
+    'const.*=.*computed\\(': 'ComputedState',
+};
+
+function convertJsToTs(content) {
+    let tsContent = content;
+    
+    // Remove .js extensions from imports
+    tsContent = tsContent.replace(/from ['"](.*)\.js['"]/g, "from '$1'");
+    
+    // Add basic type annotations to function parameters
+    tsContent = tsContent.replace(
+        /function\s+(\w+)\s*\(([^)]*)\)/g,
+        (match, funcName, params) => {
+            const typedParams = params
+                .split(',')
+                .map(p => p.trim())
+                .filter(p => p)
+                .map(p => {
+                    if (p.includes('=')) {
+                        const [name, defaultValue] = p.split('=').map(s => s.trim());
+                        return `${name}: any = ${defaultValue}`;
+                    }
+                    return `${p}: any`;
+                })
+                .join(', ');
+            return `function ${funcName}(${typedParams})`;
+        }
+    );
+    
+    // Add void return types to functions without returns
+    tsContent = tsContent.replace(
+        /(function\s+\w+\([^)]*\))\s*\{/g,
+        '$1: void {'
+    );
+    
+    return tsContent;
+}
+
+function processFile(filePath) {
+    const ext = path.extname(filePath);
+    const basename = path.basename(filePath);
+    
+    if (ext !== '.js' || skipFiles.has(basename)) {
+        return;
+    }
+    
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const tsContent = convertJsToTs(content);
+    const tsPath = filePath.replace(/\.js$/, '.ts');
+    
+    fs.writeFileSync(tsPath, tsContent, 'utf-8');
+    console.log(`✅ Converted: ${path.relative(srcDir, filePath)} → ${path.basename(tsPath)}`);
+    
+    // Delete old .js file
+    fs.unlinkSync(filePath);
+    console.log(`🗑️  Deleted: ${path.relative(srcDir, filePath)}`);
+}
+
+function walkDir(dir) {
+    const files = fs.readdirSync(dir);
+    
+    for (const file of files) {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+        
+        if (stat.isDirectory()) {
+            walkDir(filePath);
+        } else if (stat.isFile()) {
+            processFile(filePath);
+        }
+    }
+}
+
+console.log('🚀 Starting TypeScript conversion...\n');
+walkDir(srcDir);
+console.log('\n✨ Conversion complete!');
+console.log('\n📝 Next steps:');
+console.log('   1. Run: npm run typecheck');
+console.log('   2. Fix any type errors');
+console.log('   3. Add proper type annotations to converted files');

package/template/scripts/fix-encoding.mjs

@@ -0,0 +1,38 @@
+import { readFileSync, writeFileSync } from 'fs';
+
+// Map: corrupted string → correct character/entity
+// These are Windows-1252 bytes re-interpreted as UTF-8 mojibake
+const fixes = [
+  // Special HTML chars — use entities so files stay ASCII-safe
+  ['src/components/ui/nc-alert.ts',      '\u00c3\u00b7',     '×'],
+  ['src/components/ui/nc-modal.ts',      '\u00c3\u00b7',     '×'],
+  ['src/components/ui/nc-pagination.ts', '\u00c2\u00ab',     '«'],
+  ['src/components/ui/nc-pagination.ts', '\u00e2\u20ac\u00b9','‹'],
+  ['src/components/ui/nc-pagination.ts', '\u00e2\u20ac\u00a6','…'],
+  ['src/components/ui/nc-pagination.ts', '\u00e2\u20ac\u00ba','›'],
+  ['src/components/ui/nc-pagination.ts', '\u00c2\u00bb',     '»'],
+  // em dash in comment
+  ['src/components/core/app-sidebar.ts', '\u00e2\u20ac\u201c', '\u2014'],
+  // Dashboard emojis — restore real UTF-8 emoji codepoints
+  ['src/views/protected/dashboard.html', '\u00f0\u0178\u201c\u201c', '\uD83D\uDD04'], // 🔄
+  ['src/views/protected/dashboard.html', '\u00e2\u017e\u2022',       '\u2795'],       // ➕
+  ['src/views/protected/dashboard.html', '\u00f0\u0178\u201c\u0160', '\uD83D\uDCCA'], // 📊
+  ['src/views/protected/dashboard.html', '\u00e2\u0161\u2122\u00ef\u00b8\u008f', '\u2699\uFE0F'], // ⚙️
+  ['src/views/protected/dashboard.html', '\u00f0\u0178\u2019\u00a5', '\uD83D\uDC65'], // 👥
+  ['src/views/protected/dashboard.html', '\u00f0\u0178\u201c\u02c6', '\uD83D\uDCC8'], // 📈
+  ['src/views/protected/dashboard.html', '\u00e2\u0153\u2026',       '\u2705'],       // ✅
+  // Components page emojis
+  ['src/views/public/components.html',   '\u00f0\u0178\u201c\u00a7', '\uD83D\uDD27'], // 🔧
+  ['src/views/public/components.html',   '\u00e2\u00ad\u00ad',       '\u2B50'],       // ⭐
+  ['src/views/public/components.html',   '\u00f0\u0178\u201c\u00a4', '\uD83D\uDCE4'], // 📤
+  ['src/views/public/components.html',   '\u00f0\u0178\u2014\u2018\u00ef\u00b8\u008f', '\uD83D\uDDD1\uFE0F'], // 🗑️
+];
+
+for (const [file, bad, good] of fixes) {
+  const content = readFileSync(file, 'utf8');
+  if (content.includes(bad)) {
+    writeFileSync(file, content.split(bad).join(good), 'utf8');
+    console.log(`Fixed ${file}  ${JSON.stringify(bad)} -> ${JSON.stringify(good)}`);
+  }
+}
+console.log('Encoding fix complete.');

package/template/scripts/fix-svg-paths.mjs

@@ -0,0 +1,32 @@
+import { readFileSync, writeFileSync } from 'fs';
+
+const files = [
+  'src/components/ui/nc-fab.ts',
+  'src/components/ui/nc-file-upload.ts',
+  'src/components/ui/nc-icon-button.ts',
+  'src/components/ui/nc-icon.ts',
+  'src/components/ui/nc-menu-item.ts',
+  'src/dev/outline-panel.ts',
+];
+
+const svgCtxMarkers = [' d=', '<path', '<polyline', '<polygon', '<svg', '"M', "'M"];
+
+for (const file of files) {
+  const orig = readFileSync(file, 'utf8');
+  let c = orig;
+
+  // Replace digit/space + nc- + digit back to v- only in SVG path contexts
+  c = c.replace(/([0-9 ])nc-([0-9])/g, (match, before, after, offset) => {
+    const ctx = orig.substring(Math.max(0, offset - 80), offset + 80);
+    const inSvg = svgCtxMarkers.some(m => ctx.includes(m));
+    return inSvg ? before + 'v-' + after : match;
+  });
+
+  if (c !== orig) {
+    writeFileSync(file, c, 'utf8');
+    console.log('Fixed:', file);
+  } else {
+    console.log('No change:', file);
+  }
+}
+console.log('Done');

package/template/scripts/generate-cf-router.mjs

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const routesPath = path.resolve(__dirname, '..', 'src', 'routes', 'routes.ts');
+const redirectsPath = path.resolve(__dirname, '..', 'public', '_redirects');
+
+export function extractProtectedRoutes(routesSource) {
+    const match = routesSource.match(/export const protectedRoutes = \[(.*?)\];/s);
+
+    if (!match) {
+        throw new Error('Could not find protectedRoutes export in src/routes/routes.ts');
+    }
+
+    return Array.from(match[1].matchAll(/['"]([^'"]+)['"]/g), routeMatch => routeMatch[1]);
+}
+
+export function extractRegisteredRoutes(routesSource) {
+    return Array.from(routesSource.matchAll(/\.register\(\s*['"]([^'"]+)['"]/g), match => match[1]);
+}
+
+export function renderCfRouter(protectedRoutes, registeredRoutes) {
+    const routeRules = registeredRoutes
+        .filter(route => route !== '/')
+        .flatMap(route => {
+            const variants = route.endsWith('/') ? [route] : [route, `${route}/`];
+            return variants.map(routeVariant => `${routeVariant} / 200`);
+        });
+
+    return [
+        ...routeRules
+    ].join('\n') + '\n';
+}
+
+export function generateCfRouter() {
+    const routesSource = fs.readFileSync(routesPath, 'utf8');
+    const protectedRoutes = extractProtectedRoutes(routesSource);
+    const registeredRoutes = extractRegisteredRoutes(routesSource);
+    const output = renderCfRouter(protectedRoutes, registeredRoutes);
+
+    fs.writeFileSync(redirectsPath, output);
+    console.log(`Updated: ${path.relative(path.resolve(__dirname, '..'), redirectsPath).replace(/\\/g, '/')}`);
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === __filename) {
+    generateCfRouter();
+}

package/template/scripts/inject-dev-tools.mjs

@@ -0,0 +1,41 @@
+// scripts/inject-denc-tools.mjs
+// Inject denc-tools script into HTML files for development
+import { readFile, writeFile } from 'fs/promises';
+import { resolve } from 'path';
+
+const files = ['index.html'];
+const devScripts = `    <!-- DEnc-ONLY-START -->
+    <!-- Hot Module Replacement (HMR) - Development Only -->
+    <script type="module" src="/src/dev/hmr.js"></script>
+    <script type="module" src="/dist/dev/denc-tools.js"></script>
+    <!-- DEnc-ONLY-END -->`;
+
+async function injectDevTools(file) {
+  try {
+    const path = resolve(process.cwd(), file);
+    let html = await readFile(path, 'utf8');
+    
+    // Check if denc-tools already injected
+    if (html.includes('dist/dev/denc-tools.js')) {
+      console.log(`✓ Dev scripts already injected in ${file}`);
+      return;
+    }
+    
+    // Find the injection marker
+    const marker = '<!--- inject here --->';
+    if (html.includes(marker)) {
+      html = html.replace(marker, devScripts);
+      await writeFile(path, html, 'utf8');
+      console.log(`✓ Injected dev scripts (HMR + denc-tools) into ${file}`);
+    } else {
+      console.warn(`⚠️  No injection marker found in ${file}`);
+    }
+  } catch (error) {
+    console.error(`✗ Failed to inject denc-tools into ${file}:`, error.message);
+  }
+}
+
+(async () => {
+  console.log('🔧 Injecting dev scripts (HMR + denc-tools) for development...\n');
+  await Promise.all(files.map(injectDevTools));
+})();

package/template/scripts/inject-version.mjs

@@ -0,0 +1,65 @@
+/**
+ * Version Injection Script
+ * Automatically injects package.json version into cache buster
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Read package.json
+const packageJson = JSON.parse(
+    fs.readFileSync(path.join(__dirname, '../package.json'), 'utf-8')
+);
+
+const packageVersion = packageJson.version;
+const githubRunId = process.env.GITHUB_RUN_ID;
+const githubRunAttempt = process.env.GITHUB_RUN_ATTEMPT;
+const gitSha = process.env.GITHUB_SHA?.slice(0, 8);
+const timestamp = new Date().toISOString().replace(/[-:TZ.]/g, '').slice(0, 14);
+const deployVersion = githubRunId
+    ? `${packageVersion}-${githubRunId}-${githubRunAttempt || '1'}`
+    : gitSha
+        ? `${packageVersion}-${gitSha}`
+        : `${packageVersion}-${timestamp}`;
+
+function replaceOrThrow(content, pattern, replacement, fileLabel) {
+    const matched = content.match(pattern);
+
+    if (!matched) {
+        throw new Error(`Failed to inject deploy version into ${fileLabel}`);
+    }
+
+    return content.replace(pattern, replacement);
+}
+
+// Update cacheBuster.ts
+const cacheBusterPath = path.join(__dirname, '../src/utils/cacheBuster.ts');
+let cacheBusterContent = fs.readFileSync(cacheBusterPath, 'utf-8');
+
+cacheBusterContent = replaceOrThrow(
+    cacheBusterContent,
+    /export const cacheVersion = isDevelopment[\s\S]*?;/,
+    `export const cacheVersion = isDevelopment\n    ? Date.now()\n    : '${deployVersion}';`,
+    'src/utils/cacheBuster.ts'
+);
+
+fs.writeFileSync(cacheBusterPath, cacheBusterContent);
+
+for (const htmlFileName of ['index.html']) {
+    const htmlPath = path.join(__dirname, `../${htmlFileName}`);
+    let htmlContent = fs.readFileSync(htmlPath, 'utf-8');
+
+    htmlContent = replaceOrThrow(
+        htmlContent,
+        /const version = isDev \? Date\.now\(\) : '[^']+';/g,
+        `const version = isDev ? Date.now() : '${deployVersion}';`,
+        htmlFileName
+    );
+
+    fs.writeFileSync(htmlPath, htmlContent);
+}
+
+console.log(`Deploy version ${deployVersion} injected successfully!`);