juxscript 1.1.0 → 1.1.2

package/machinery/ast.js

@@ -0,0 +1,347 @@
+import fs from 'fs';
+import path from 'path';
+import * as acorn from 'acorn';
+import { simple } from 'acorn-walk';
+import { glob } from 'glob';
+import { loadAndStripTypes, isTypeScript } from './ts-shim.js';
+
+const vendors = new Set();
+const processedFiles = new Set();
+const rels = new Map();
+const allFiles = new Set();
+const cssFiles = new Set();
+const assetFiles = new Set();
+
+// ✅ Define asset extensions to track
+const ASSET_EXTENSIONS = [
+    '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.bmp', '.ico',
+    '.mp4', '.mov', '.avi', '.webm', '.ogv',
+    '.mp3', '.wav', '.ogg', '.m4a',
+    '.woff', '.woff2', '.ttf', '.otf', '.eot',
+    '.json', '.xml', '.csv', '.txt',
+    '.pdf', '.doc', '.docx', '.zip'
+];
+
+function countAllSourceFiles(directories) {
+    const allFiles = new Set();
+
+    for (const dir of directories) {
+        const dirPath = path.resolve(dir);
+        if (!fs.existsSync(dirPath)) {
+            console.warn(`⚠️  Directory not found: ${dirPath}`);
+            continue;
+        }
+
+        const files = findSourceFiles(dirPath);
+        files.forEach(f => allFiles.add(f));
+    }
+
+    return allFiles;
+}
+
+function findSourceFiles(dir, fileList = []) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+            if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                findSourceFiles(fullPath, fileList);
+            }
+        } else if (entry.isFile() && (entry.name.endsWith('.jux') || entry.name.endsWith('.js') || entry.name.endsWith('.ts'))) {
+            fileList.push(fullPath);
+        }
+    }
+
+    return fileList;
+}
+
+const getAllCode = (srcDir) => {
+    const pattern = path.join(srcDir, '**/*.{js,jux,ts}');
+    const files = glob.sync(pattern);
+    const codeMap = {};
+
+    files.forEach(filePath => {
+        const rawCode = fs.readFileSync(filePath, 'utf-8');
+        const code = loadAndStripTypes(filePath, rawCode);
+        codeMap[filePath] = code;
+    });
+
+    return codeMap;
+};
+
+const findAllRels = (code, sourceFile) => {
+    try {
+        const ast = acorn.parse(code, {
+            ecmaVersion: 'latest',
+            sourceType: 'module'
+        });
+
+        simple(ast, {
+            ImportDeclaration(node) {
+                const { value } = node.source;
+                if (/^[./]/.test(value)) {
+                    if (!rels.has(sourceFile)) {
+                        rels.set(sourceFile, new Set());
+                    }
+                    rels.get(sourceFile).add(value);
+                }
+            },
+            CallExpression(node) {
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.object.name === 'jux' &&
+                    node.callee.property.name === 'include' &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0].type === 'Literal') {
+
+                    const includePath = node.arguments[0].value;
+
+                    if (!rels.has(sourceFile)) {
+                        rels.set(sourceFile, new Set());
+                    }
+                    rels.get(sourceFile).add(includePath);
+                }
+            },
+            Literal(node) {
+                if (typeof node.value === 'string') {
+                    const val = node.value;
+
+                    if (/^[./]/.test(val)) {
+                        const ext = path.extname(val).toLowerCase();
+
+                        if (ASSET_EXTENSIONS.includes(ext)) {
+                            if (!rels.has(sourceFile)) {
+                                rels.set(sourceFile, new Set());
+                            }
+                            rels.get(sourceFile).add(val);
+                        }
+                    }
+                }
+            }
+        });
+    } catch (err) {
+        // Silent fail
+    }
+};
+
+const findVendors = (code) => {
+    try {
+        const ast = acorn.parse(code, {
+            ecmaVersion: 'latest',
+            sourceType: 'module'
+        });
+
+        simple(ast, {
+            ImportDeclaration(node) {
+                const { value } = node.source;
+                if (!/^[./]/.test(value)) {
+                    vendors.add(value);
+                }
+            }
+        });
+    } catch (err) {
+        // Silent fail
+    }
+};
+
+function processCodeDirs(directories) {
+    const allCodeMaps = {};
+    for (const dir of directories) {
+        const codeMap = getAllCode(dir);
+        Object.assign(allCodeMaps, codeMap);
+    }
+
+    Object.keys(allCodeMaps).forEach(filePath => {
+        allFiles.add(path.resolve(filePath));
+    });
+
+    for (const filePath in allCodeMaps) {
+        if (!processedFiles.has(filePath)) {
+            const code = allCodeMaps[filePath];
+            findVendors(code);
+            findAllRels(code, filePath);
+            processedFiles.add(filePath);
+        }
+    }
+
+    resolveAllRelativeImports();
+}
+
+function resolveAllRelativeImports() {
+    const visited = new Set();
+    const toProcess = Array.from(rels.keys());
+
+    while (toProcess.length > 0) {
+        const currentFile = toProcess.shift();
+
+        if (visited.has(currentFile)) continue;
+        visited.add(currentFile);
+
+        allFiles.add(currentFile);
+
+        const imports = rels.get(currentFile);
+        if (!imports) continue;
+
+        const sourceDir = path.dirname(currentFile);
+
+        imports.forEach(relImport => {
+            const basePath = path.resolve(sourceDir, relImport);
+
+            const ext = path.extname(relImport).toLowerCase();
+
+            if (ext === '.css') {
+                if (fs.existsSync(basePath)) {
+                    const absolutePath = path.resolve(basePath);
+                    allFiles.add(absolutePath);
+                    cssFiles.add(absolutePath);
+                }
+                return;
+            }
+
+            if (ASSET_EXTENSIONS.includes(ext)) {
+                if (fs.existsSync(basePath)) {
+                    const absolutePath = path.resolve(basePath);
+                    allFiles.add(absolutePath);
+                    assetFiles.add(absolutePath);
+                }
+                return;
+            }
+
+            const extensions = ['', '.js', '.jux', '.ts'];
+
+            for (const extSuffix of extensions) {
+                const fullPath = basePath + extSuffix;
+
+                if (fs.existsSync(fullPath)) {
+                    const absolutePath = path.resolve(fullPath);
+                    allFiles.add(absolutePath);
+
+                    if (!visited.has(fullPath) && !processedFiles.has(fullPath)) {
+                        try {
+                            const content = fs.readFileSync(fullPath, 'utf-8');
+                            const code = loadAndStripTypes(fullPath, content);
+
+                            findVendors(code);
+                            findAllRels(code, fullPath);
+                            processedFiles.add(fullPath);
+
+                            if (rels.has(fullPath)) {
+                                toProcess.push(fullPath);
+                            }
+                        } catch (err) {
+                            // Silent fail
+                        }
+                    }
+
+                    break;
+                }
+            }
+        });
+    }
+}
+
+// ✅ LEGACY EXPORTS (for backward compatibility)
+export const analyzeVendors = (files) => {
+    vendors.clear();
+    for (const filePath in files) {
+        if (filePath.endsWith('.js') || filePath.endsWith('.jux') || filePath.endsWith('.ts')) {
+            const rawCode = files[filePath];
+            const code = loadAndStripTypes(filePath, rawCode);
+            findVendors(code);
+        }
+    }
+    return Array.from(vendors);
+}
+
+export const clearVendors = () => {
+    vendors.clear();
+}
+
+export const getVendors = () => {
+    return Array.from(vendors);
+}
+
+// ✅ NEW: Main analysis function that returns everything
+export function analyzeProject(directories = ['./jux', './lib']) {
+    // Clear previous state
+    vendors.clear();
+    processedFiles.clear();
+    rels.clear();
+    allFiles.clear();
+    cssFiles.clear();
+    assetFiles.clear();
+
+    // Run analysis
+    processCodeDirs(directories);
+
+    // Return comprehensive analysis results
+    return {
+        vendors: Array.from(vendors),
+        allFiles: Array.from(allFiles),
+        cssFiles: Array.from(cssFiles),
+        assetFiles: Array.from(assetFiles),
+        relativeImports: rels,
+
+        // Categorized files
+        juxFiles: Array.from(allFiles).filter(f => f.endsWith('.jux')),
+        jsFiles: Array.from(allFiles).filter(f => f.endsWith('.js')),
+        tsFiles: Array.from(allFiles).filter(f => f.endsWith('.ts')),
+
+        // Asset breakdown
+        assets: {
+            images: Array.from(assetFiles).filter(f => {
+                const ext = path.extname(f).toLowerCase();
+                return ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.bmp', '.ico'].includes(ext);
+            }),
+            videos: Array.from(assetFiles).filter(f => {
+                const ext = path.extname(f).toLowerCase();
+                return ['.mp4', '.mov', '.avi', '.webm', '.ogv'].includes(ext);
+            }),
+            audio: Array.from(assetFiles).filter(f => {
+                const ext = path.extname(f).toLowerCase();
+                return ['.mp3', '.wav', '.ogg', '.m4a'].includes(ext);
+            }),
+            fonts: Array.from(assetFiles).filter(f => {
+                const ext = path.extname(f).toLowerCase();
+                return ['.woff', '.woff2', '.ttf', '.otf', '.eot'].includes(ext);
+            }),
+            data: Array.from(assetFiles).filter(f => {
+                const ext = path.extname(f).toLowerCase();
+                return ['.json', '.xml', '.csv', '.txt'].includes(ext);
+            })
+        },
+
+        // Summary stats
+        stats: {
+            totalFiles: allFiles.size,
+            totalVendors: vendors.size,
+            totalCSS: cssFiles.size,
+            totalAssets: assetFiles.size,
+            filesWithImports: rels.size
+        }
+    };
+}
+
+// ✅ Export constants
+export { ASSET_EXTENSIONS };
+
+export default {
+    analyzeProject,
+    analyzeVendors,
+    clearVendors,
+    getVendors,
+    ASSET_EXTENSIONS
+};
+
+function main() {
+    const analysis = analyzeProject(['./jux', './lib']);
+
+    console.log('External vendors:', analysis.vendors);
+    console.log('Total files:', analysis.stats.totalFiles);
+}
+
+// Only run main if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main();
+}