@macle-community/simulator-web 0.0.0-stage → 1.0.0

package/src/compiler.js

@@ -0,0 +1,117 @@
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+/**
+ * Search candidates for official @macle/compiler
+ */
+function findMacleCompiler() {
+  const candidates = [
+    path.join(__dirname, '../../DevToolkit_26.6.0/DevToolkit_26.6.0-LG0001/Macle_26.6.0-LG0001_Engine_Compiler/node_modules/@macle/compiler'),
+    path.join(__dirname, '../../../DevToolkit_26.6.0/DevToolkit_26.6.0-LG0001/Macle_26.6.0-LG0001_Engine_Compiler/node_modules/@macle/compiler'),
+    path.join(__dirname, '../../DevToolkit_25.9.0/Macle_25.9.0_DevSuite_IDE/macle-miniprogram-tools-25.9.0-file/extension/node_modules/@macle/compiler'),
+    path.join(__dirname, '../node_modules/@macle/compiler')
+  ];
+
+  for (const cand of candidates) {
+    if (fs.existsSync(cand)) {
+      try {
+        const compiler = require(cand);
+        return { compiler, path: cand };
+      } catch (err) {
+        console.warn(`[Compiler] Notice: Candidate found at ${cand} but could not be loaded:`, err.message);
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * Compile or prepare project assets for web simulator
+ */
+async function compileProject(sourceDir, projectName) {
+  const compilerInfo = findMacleCompiler();
+  const outComposeDir = path.join(os.homedir(), '.macle/target/compose', projectName, 'root/debug/app');
+
+  // Check if sourceDir is already compiled (e.g. contains app-service.js)
+  const isAlreadyCompiled = fs.existsSync(path.join(sourceDir, 'app-service.js')) ||
+                            fs.existsSync(path.join(sourceDir, 'app-config.json'));
+
+  fs.mkdirSync(outComposeDir, { recursive: true });
+
+  if (isAlreadyCompiled) {
+    // Copy compiled files directly
+    copyDirectory(sourceDir, outComposeDir);
+    return {
+      success: true,
+      mode: 'precompiled',
+      outDir: outComposeDir
+    };
+  }
+
+  // Needs compilation via @macle/compiler
+  if (!compilerInfo) {
+    console.warn('[Compiler] Warning: @macle/compiler not found; copying source files directly.');
+    copyDirectory(sourceDir, outComposeDir);
+    return {
+      success: false,
+      mode: 'raw-copy',
+      outDir: outComposeDir,
+      error: '@macle/compiler not found'
+    };
+  }
+
+  try {
+    const startTime = Date.now();
+    console.log(`[Compiler] Pre-compiling Macle source (${sourceDir})...`);
+    await compilerInfo.compiler.compile(sourceDir, outComposeDir, { debug: true, es5: false });
+
+    // Sync project config if available
+    const projConf = path.join(sourceDir, 'project.config.json');
+    if (fs.existsSync(projConf)) {
+      fs.copyFileSync(projConf, path.join(outComposeDir, 'project.config.json'));
+    }
+
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+    console.log(`[Compiler] Pre-compilation successful -> ${outComposeDir} (${elapsed}s)`);
+
+    return {
+      success: true,
+      mode: 'compiled',
+      outDir: outComposeDir,
+      compilerPath: compilerInfo.path,
+      elapsed
+    };
+  } catch (err) {
+    console.error('[Compiler] Compilation error:', err.message);
+    return {
+      success: false,
+      mode: 'error',
+      outDir: outComposeDir,
+      error: err.message
+    };
+  }
+}
+
+function copyDirectory(src, dest) {
+  if (!fs.existsSync(src)) return;
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name !== 'node_modules' && entry.name !== '.git') {
+        copyDirectory(srcPath, destPath);
+      }
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+module.exports = {
+  findMacleCompiler,
+  compileProject,
+  copyDirectory
+};

package/src/mock-backend.js

@@ -0,0 +1,225 @@
+const path = require('path');
+const fs = require('fs');
+const http = require('http');
+const https = require('https');
+const crypto = require('crypto');
+const url = require('url');
+
+/**
+ * Native Macle MCSS Simulator Backend
+ * Handles /mcss/simulate/* endpoints
+ */
+function createMockBackend(appDir) {
+  const storeDir = path.join(appDir, 'store');
+  const tmpDir = path.join(appDir, 'tmp');
+  fs.mkdirSync(storeDir, { recursive: true });
+  fs.mkdirSync(tmpDir, { recursive: true });
+
+  return {
+    handleRequestData(req, res, body) {
+      try {
+        const data = body.data || {};
+        const params = data.mockType ? data.inputParams : (typeof data.inputParams === 'string' ? JSON.parse(data.inputParams) : data.inputParams);
+        const targetUrl = params.url;
+        const method = (params.method || 'GET').toUpperCase();
+        const headers = params.header || {};
+        const postData = params.data ? (typeof params.data === 'string' ? params.data : JSON.stringify(params.data)) : null;
+
+        if (!targetUrl) {
+          res.writeHead(400, { 'Content-Type': 'application/json' });
+          return res.end(JSON.stringify({ errMsg: 'requestData:fail missing url' }));
+        }
+
+        const parsedUrl = new URL(targetUrl);
+        const isHttps = parsedUrl.protocol === 'https:';
+        const client = isHttps ? https : http;
+
+        if (postData && !headers['Content-Type']) {
+          headers['Content-Type'] = 'application/json';
+        }
+        if (postData) {
+          headers['Content-Length'] = Buffer.byteLength(postData);
+        }
+
+        const requestOptions = {
+          hostname: parsedUrl.hostname,
+          port: parsedUrl.port || (isHttps ? 443 : 80),
+          path: parsedUrl.pathname + parsedUrl.search,
+          method: method,
+          headers: headers,
+          timeout: params.timeout || 10000
+        };
+
+        const proxyReq = client.request(requestOptions, (proxyRes) => {
+          let chunks = [];
+          proxyRes.on('data', chunk => chunks.push(chunk));
+          proxyRes.on('end', () => {
+            const buffer = Buffer.concat(chunks);
+            const contentType = proxyRes.headers['content-type'] || '';
+            let responseData;
+
+            if (contentType.includes('application/json')) {
+              try {
+                responseData = JSON.parse(buffer.toString('utf8'));
+              } catch (e) {
+                responseData = buffer.toString('utf8');
+              }
+            } else {
+              responseData = buffer.toString('utf8');
+            }
+
+            res.writeHead(proxyRes.statusCode || 200, {
+              'Content-Type': 'application/json',
+              'Access-Control-Allow-Origin': '*'
+            });
+            res.end(JSON.stringify(responseData));
+          });
+        });
+
+        proxyReq.on('error', (err) => {
+          res.writeHead(502, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ errMsg: `requestData:fail ${err.message}` }));
+        });
+
+        proxyReq.on('timeout', () => {
+          proxyReq.destroy();
+          res.writeHead(504, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ errMsg: 'requestData:fail timeout' }));
+        });
+
+        if (postData) {
+          proxyReq.write(postData);
+        }
+        proxyReq.end();
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ errMsg: `requestData:error ${err.message}` }));
+      }
+    },
+
+    handleSaveFile(req, res, body) {
+      try {
+        const data = body.data || {};
+        const params = typeof data.inputParams === 'string' ? JSON.parse(data.inputParams) : (data.inputParams || {});
+        const tempPath = params.tempFilePath || '';
+        const fileName = path.basename(tempPath);
+        const sourceFile = path.join(tmpDir, fileName);
+        const targetFile = path.join(storeDir, fileName);
+
+        if (!fileName || !fs.existsSync(sourceFile)) {
+          // If file not in tmpDir, create a mock saved file
+          const mockContent = 'mock-saved-content';
+          fs.writeFileSync(targetFile, mockContent);
+        } else {
+          fs.copyFileSync(sourceFile, targetFile);
+        }
+
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          errMsg: 'savedFile:ok',
+          savedFilePath: `/store/${fileName}`
+        }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ errMsg: `saveFile:fail ${err.message}` }));
+      }
+    },
+
+    handleRemoveSaved(req, res, body) {
+      try {
+        const data = body.data || {};
+        const params = typeof data.inputParams === 'string' ? JSON.parse(data.inputParams) : (data.inputParams || {});
+        const filePath = params.filePath || '';
+        const fileName = path.basename(filePath);
+        const targetFile = path.join(storeDir, fileName);
+
+        if (fs.existsSync(targetFile)) {
+          fs.unlinkSync(targetFile);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ errMsg: 'removeSavedFile:ok' }));
+        } else {
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ errMsg: 'removeSavedFile:fail file not exist' }));
+        }
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ errMsg: `removeSaved:fail ${err.message}` }));
+      }
+    },
+
+    handleFileInfo(req, res, query) {
+      try {
+        const dataStr = query.data;
+        const params = typeof dataStr === 'string' ? JSON.parse(dataStr) : (dataStr || {});
+        const filePath = params.filePath || '';
+        const algorithm = (params.digestAlgorithm || 'sha256').toLowerCase();
+        const targetFile = path.resolve(appDir, filePath.replace(/^\//, ''));
+
+        if (fs.existsSync(targetFile)) {
+          const content = fs.readFileSync(targetFile);
+          const hash = crypto.createHash(algorithm).update(content).digest('hex');
+          const stat = fs.statSync(targetFile);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({
+            errMsg: 'getFileInfo:ok',
+            digest: hash,
+            size: stat.size
+          }));
+        } else {
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ errMsg: 'getFileInfo:fail file not exist' }));
+        }
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ errMsg: `getFileInfo:fail ${err.message}` }));
+      }
+    },
+
+    handleSavedFileList(req, res) {
+      try {
+        const files = fs.readdirSync(storeDir);
+        const fileList = files.map(file => {
+          const p = path.join(storeDir, file);
+          const stat = fs.statSync(p);
+          return {
+            filePath: `/store/${file}`,
+            size: stat.size,
+            creatTime: stat.ctimeMs
+          };
+        });
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ errMsg: 'getSavedFileList:ok', fileList }));
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ errMsg: `getSavedFileList:fail ${err.message}` }));
+      }
+    },
+
+    handleSavedFileInfo(req, res, query) {
+      try {
+        const dataStr = query.data;
+        const params = typeof dataStr === 'string' ? JSON.parse(dataStr) : (dataStr || {});
+        const fileName = path.basename(params.filePath || '');
+        const targetFile = path.join(storeDir, fileName);
+
+        if (fs.existsSync(targetFile)) {
+          const stat = fs.statSync(targetFile);
+          res.writeHead(200, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({
+            errMsg: 'getSavedFileInfo:ok',
+            size: stat.size,
+            createTime: stat.ctimeMs
+          }));
+        } else {
+          res.writeHead(404, { 'Content-Type': 'application/json' });
+          res.end(JSON.stringify({ errMsg: 'getSavedFileInfo:fail file not find' }));
+        }
+      } catch (err) {
+        res.writeHead(500, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ errMsg: `getSavedFileInfo:fail ${err.message}` }));
+      }
+    }
+  };
+}
+
+module.exports = { createMockBackend };

package/src/project-parser.js

@@ -0,0 +1,87 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Discovers and parses Macle miniprogram project configuration
+ */
+function parseProject(projectDir) {
+  const resolvedDir = path.resolve(projectDir);
+  let appConfig = null;
+  let projectConfig = null;
+  let isCompiled = false;
+  let appDir = resolvedDir;
+
+  // Check if projectDir is already a compiled dist folder
+  const appServiceCandidates = [
+    path.join(resolvedDir, 'app-service.js'),
+    path.join(resolvedDir, 'root/debug/app/app-service.js')
+  ];
+
+  for (const cand of appServiceCandidates) {
+    if (fs.existsSync(cand)) {
+      isCompiled = true;
+      appDir = path.dirname(cand);
+      break;
+    }
+  }
+
+  // Look for app-config.json or app.json
+  const configCandidates = [
+    path.join(appDir, 'app-config.json'),
+    path.join(resolvedDir, 'app-config.json'),
+    path.join(resolvedDir, 'app.json'),
+    path.join(appDir, 'app.json')
+  ];
+
+  for (const cand of configCandidates) {
+    if (fs.existsSync(cand)) {
+      try {
+        appConfig = JSON.parse(fs.readFileSync(cand, 'utf8'));
+        break;
+      } catch (err) {
+        console.warn(`[Parser] Warning: Failed to parse ${cand}:`, err.message);
+      }
+    }
+  }
+
+  // Look for project.config.json
+  const projCandidates = [
+    path.join(resolvedDir, 'project.config.json'),
+    path.join(path.dirname(resolvedDir), 'project.config.json')
+  ];
+
+  for (const cand of projCandidates) {
+    if (fs.existsSync(cand)) {
+      try {
+        projectConfig = JSON.parse(fs.readFileSync(cand, 'utf8'));
+        break;
+      } catch (e) {}
+    }
+  }
+
+  const projectName = (projectConfig && projectConfig.projectname) ||
+                      path.basename(resolvedDir);
+
+  const pages = (appConfig && Array.isArray(appConfig.pages)) ? appConfig.pages : ['pages/index/index'];
+  const entryPagePath = (appConfig && appConfig.entryPagePath) || pages[0] || 'pages/index/index';
+  const windowConfig = (appConfig && appConfig.window) || {
+    navigationBarTitleText: projectName,
+    navigationBarBackgroundColor: '#000000',
+    navigationBarTextStyle: 'white'
+  };
+
+  return {
+    sourceDir: resolvedDir,
+    appDir,
+    isCompiled,
+    projectName,
+    pages,
+    entryPagePath,
+    window: windowConfig,
+    tabBar: (appConfig && appConfig.tabBar) || null,
+    appConfig,
+    projectConfig
+  };
+}
+
+module.exports = { parseProject };