@blocklet/pages-kit-block-studio 0.6.13 → 0.6.15

package/lib/esm/middlewares/init-resource-router.js

@@ -1,53 +1,13 @@
 import { getResourceExportDir } from '@blocklet/sdk/lib/component';
-import { getMediaKitFileStream } from '@blocklet/uploader-server';
 import { spawn } from 'child_process';
 import { Router } from 'express';
-import fs from 'fs';
-import get from 'lodash/get';
-import set from 'lodash/set';
-import path, { join, basename } from 'path';
-import ts from 'typescript';
-import { findComponentFiles, libDir, getPreviewImageRelativePath, generateYaml, logger, getComponentScriptName, getEditComponentBlockName, getAigneOutputValueSchemaBlockName, getPropertiesSchemaBlockName, getGetServerSidePropsBlockName, } from '../utils/helper';
+import { join } from 'path';
+import { findComponentFiles } from '../utils/helper';
+const allTag = '@ALL_COMPONENTS';
 const DID = 'z2qa7BQdkEb3TwYyEYC1psK6uvmGnHSUHt5RM';
 const RESOURCE_TYPE = 'page';
-const allTag = '@ALL_COMPONENTS';
 // use for tracking build process
 let currentBuildProcess = null;
-export function copyFile(src, dest) {
-    return new Promise((resolve, reject) => {
-        const readStream = fs.createReadStream(src);
-        const writeStream = fs.createWriteStream(dest);
-        readStream.on('error', reject);
-        writeStream.on('error', reject);
-        writeStream.on('finish', resolve);
-        readStream.pipe(writeStream);
-    });
-}
-export async function copyDirectory(src, dest) {
-    await fs.promises.mkdir(dest, { recursive: true });
-    const entries = await fs.promises.readdir(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()) {
-            // eslint-disable-next-line no-await-in-loop
-            await copyDirectory(srcPath, destPath);
-        }
-        else {
-            // eslint-disable-next-line no-await-in-loop
-            await copyFile(srcPath, destPath);
-        }
-    }
-}
-export async function copyRecursive(src, dest) {
-    const srcStats = await fs.promises.stat(src);
-    if (srcStats.isDirectory()) {
-        await copyDirectory(src, dest);
-    }
-    else {
-        await copyFile(src, dest);
-    }
-}
 const getExportDir = (projectId, releaseId) => {
     const exportDir = getResourceExportDir({ projectId, releaseId });
     const dir = join(exportDir, DID, RESOURCE_TYPE);
@@ -59,8 +19,6 @@ initResourceRouter.get('/', async (_req, res) => {
     const rootDir = process.cwd();
     const files = findComponentFiles({ cwd: rootDir, strictExistMetadata: true });
     for (const file of files) {
-        // const filePath = path.join(rootDir, file);
-        // const fileContent = fs.readFileSync(filePath, 'utf8');
         const { blockName } = file;
         resources.push({
             id: blockName,
@@ -94,9 +52,11 @@ initResourceRouter.post('/', async (req, res) => {
             currentBuildProcess = null;
         }
         if (componentIds.length === 0) {
-            throw new Error('No components founds, please check has any component been selected');
+            throw new Error('No components found, please check has any component been selected');
         }
-        // Execute build command with filtered components
+        // Get export directory
+        const exportDir = getExportDir(projectId, releaseId);
+        // Execute build command with export directory
         const buildProcess = spawn('pnpm', ['run', 'build-lib'], {
             stdio: 'inherit',
             shell: true,
@@ -104,6 +64,7 @@ initResourceRouter.post('/', async (req, res) => {
                 ...process.env,
                 FORCE_COLOR: '1',
                 BLOCK_FILTER: componentIds.join(','),
+                EXPORT_DIR: exportDir,
                 NODE_OPTIONS: '--max_old_space_size=16384',
                 NODE_ENV: 'production',
             },
@@ -122,183 +83,6 @@ initResourceRouter.post('/', async (req, res) => {
                 reject(error);
             });
         });
-        const dir = getExportDir(projectId, releaseId);
-        fs.rmSync(dir, { recursive: true, force: true });
-        fs.mkdirSync(dir, { recursive: true });
-        const rootDir = process.cwd();
-        const distDir = join(rootDir, libDir);
-        const codeDir = join(distDir, 'es');
-        const tmpPackage = join(distDir, 'resource-blocklet');
-        fs.mkdirSync(tmpPackage, { recursive: true });
-        const pagesDir = join(tmpPackage, 'pages');
-        fs.mkdirSync(pagesDir, { recursive: true });
-        const componentsDir = join(tmpPackage, 'components');
-        fs.mkdirSync(componentsDir, { recursive: true });
-        const chunksDir = join(tmpPackage, 'chunks');
-        fs.mkdirSync(chunksDir, { recursive: true });
-        const chunksMapPath = join(codeDir, 'chunks-map.json');
-        const chunksMap = JSON.parse(fs.readFileSync(chunksMapPath, 'utf8'));
-        // get @metadata.json by glob
-        const canUseComponents = findComponentFiles({ cwd: rootDir, filter: componentIds, strictExistMetadata: true });
-        // Filter and process metadata files
-        const metadataList = await Promise.all(canUseComponents.map(async ({ fullPath, blockName, metadata: _metadata }) => {
-            // get metadata
-            const metadata = _metadata;
-            const jsName = `${blockName}.js`;
-            // set version to 2
-            set(metadata, 'version', 2);
-            // get code to metadata
-            const code = fs.readFileSync(join(codeDir, `${getComponentScriptName(blockName, 'esm')}.js`), 'utf8');
-            if (code) {
-                set(metadata, 'renderer.script', code);
-                set(metadata, 'renderer.type', 'react-component');
-                set(metadata, 'renderer.chunks', chunksMap[jsName] || []);
-            }
-            // get cjs by code with transpileModule
-            try {
-                const cjsCode = ts.transpileModule(code, {
-                    compilerOptions: {
-                        jsx: ts.JsxEmit.React,
-                        target: ts.ScriptTarget.ES2016,
-                        module: ts.ModuleKind.CommonJS,
-                        moduleResolution: ts.ModuleResolutionKind.Node16,
-                    },
-                }).outputText;
-                if (cjsCode) {
-                    set(metadata, 'renderer.cjsScript', cjsCode);
-                }
-            }
-            catch (error) {
-                // ignore error
-            }
-            // get edit component code
-            try {
-                const editComponentJsName = `${getEditComponentBlockName(blockName)}.js`;
-                const editComponentCode = fs.readFileSync(join(codeDir, editComponentJsName), 'utf8');
-                if (editComponentCode) {
-                    // add edit component code
-                    set(metadata, 'renderer.editComponent', editComponentCode);
-                    // append edit component chunks
-                    set(metadata, 'renderer.chunks', Array.from(new Set([...get(metadata, 'renderer.chunks', []), ...(chunksMap[editComponentJsName] || [])])));
-                }
-            }
-            catch (error) {
-                // ignore error
-            }
-            // get aigne output value schema
-            try {
-                const aigneOutputValueSchemaJsName = `${getAigneOutputValueSchemaBlockName(blockName)}.js`;
-                const aigneOutputValueSchemaCode = fs.readFileSync(join(codeDir, aigneOutputValueSchemaJsName), 'utf8');
-                if (aigneOutputValueSchemaCode) {
-                    set(metadata, 'renderer.aigneOutputValueSchema', aigneOutputValueSchemaCode);
-                }
-            }
-            catch (error) {
-                // ignore error
-            }
-            // get properties schema
-            try {
-                const propertiesSchemaJsName = `${getPropertiesSchemaBlockName(blockName)}.js`;
-                const propertiesSchemaCode = fs.readFileSync(join(codeDir, propertiesSchemaJsName), 'utf8');
-                if (propertiesSchemaCode) {
-                    set(metadata, 'renderer.PROPERTIES_SCHEMA', propertiesSchemaCode);
-                }
-            }
-            catch (error) {
-                // ignore error
-            }
-            // get getServerSideProps
-            try {
-                const getServerSidePropsJsName = `${getGetServerSidePropsBlockName(blockName)}.js`;
-                const getServerSidePropsCode = fs.readFileSync(join(codeDir, getServerSidePropsJsName), 'utf8');
-                if (getServerSidePropsCode) {
-                    set(metadata, 'renderer.getServerSideProps', getServerSidePropsCode);
-                }
-            }
-            catch (error) {
-                // ignore error
-            }
-            // Handle preview image if exists
-            if (metadata.previewImage) {
-                const imagePath = path.join(path.dirname(fullPath), getPreviewImageRelativePath(metadata.previewImage));
-                const imageDestPath = path.join(componentsDir, metadata.previewImage);
-                if (fs.existsSync(imagePath)) {
-                    fs.copyFileSync(imagePath, imageDestPath);
-                }
-            }
-            // Handle type:url properties url
-            if (metadata.properties) {
-                const downloadPromises = [];
-                Object.keys(metadata.properties).forEach((key) => {
-                    const property = metadata.properties[key].data;
-                    if (property.type === 'url') {
-                        // 如果每个 locales 的默认值里面，存在 mediaKitUrl 的值，需要把图片下载放到 imagePath 里面
-                        Object.keys(property.locales).forEach((locale) => {
-                            if (property.locales[locale].defaultValue?.mediaKitUrl?.startsWith('mediakit://')) {
-                                const downloadPromise = (async () => {
-                                    try {
-                                        const fileName = basename(property.locales[locale].defaultValue.mediaKitUrl);
-                                        const targetPath = path.join(componentsDir, fileName);
-                                        // Check if file already exists to avoid redundant downloads
-                                        if (fs.existsSync(targetPath)) {
-                                            return;
-                                        }
-                                        const resWithStream = await getMediaKitFileStream(property.locales[locale].defaultValue.mediaKitUrl);
-                                        if (!resWithStream.data) {
-                                            return;
-                                        }
-                                        // create write stream
-                                        const writeStream = fs.createWriteStream(targetPath);
-                                        resWithStream.data.pipe(writeStream);
-                                        // wait for write stream to finish
-                                        await new Promise((resolve, reject) => {
-                                            writeStream.on('finish', () => {
-                                                // 修改 property.locales[locale].defaultValue.url 变为 mediakit:// 开头
-                                                property.locales[locale].defaultValue.url = property.locales[locale].defaultValue.mediaKitUrl;
-                                                resolve();
-                                            });
-                                            writeStream.on('error', reject);
-                                        });
-                                    }
-                                    catch (error) {
-                                        console.error('Download media kit file failed:', error.message);
-                                    }
-                                })();
-                                downloadPromises.push(downloadPromise);
-                            }
-                        });
-                    }
-                });
-                // Wait for all downloads to complete for this metadata
-                if (downloadPromises.length > 0) {
-                    await Promise.allSettled(downloadPromises);
-                }
-            }
-            // write metadata to metadataPath
-            const metadataYmlPath = path.join(componentsDir, `${metadata.name || 'unnamed'}.${metadata.id}.yml`);
-            fs.writeFileSync(metadataYmlPath, generateYaml(metadata));
-            return metadata;
-        }));
-        // cp chunks dir
-        await copyRecursive(join(codeDir, 'chunks'), chunksDir);
-        // write pages.config.yml
-        const pagesConfigPath = path.join(tmpPackage, '.blocklet/pages/pages.config.yml');
-        fs.mkdirSync(path.dirname(pagesConfigPath), { recursive: true });
-        const pagesConfig = {
-            version: 2,
-            pages: [],
-            components: metadataList.map((metadata) => ({
-                id: metadata.id,
-                name: metadata.name,
-            })),
-            supportedLocales: [],
-            config: {},
-        };
-        fs.writeFileSync(pagesConfigPath, generateYaml(pagesConfig));
-        logger.info('generate resource blocklet block count:', metadataList.length);
-        await copyRecursive(tmpPackage, dir);
-        // remove tmpPackage
-        // fs.rmSync(tmpPackage, { recursive: true, force: true });
         res.json({ success: true });
     }
     catch (error) {