@blocklet/pages-kit-block-studio 0.6.14 → 0.6.16

package/lib/cjs/utils/build-lib.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -6,25 +39,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildLib = buildLib;
 /* eslint-disable no-await-in-loop */
 /* eslint-disable no-console */
+const uploader_server_1 = require("@blocklet/uploader-server");
 const chalk_1 = __importDefault(require("chalk"));
 const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const get_1 = __importDefault(require("lodash/get"));
+const set_1 = __importDefault(require("lodash/set"));
+const path_1 = __importStar(require("path"));
+const typescript_1 = __importDefault(require("typescript"));
 const helper_1 = require("./helper");
-async function buildLib(options) {
-    const workingDir = options?.cwd || process.cwd();
+async function performBuild(workingDir, componentIds) {
     // Scan for all index files
     const allBlocks = (0, helper_1.findComponentFiles)({ cwd: workingDir }).map((entry) => {
         return entry.blockName;
     });
-    const filterModules = process.argv.includes('--filter')
-        ? process.argv[process.argv.indexOf('--filter') + 1]?.split(',')
-        : process.env.BLOCK_FILTER?.split(',') || null;
     const ignoreViteLog = process.argv.includes('--log') ? false : process.env.BLOCK_LOG !== 'true';
     const multiMode = process.argv.includes('--multi') || process.env.BLOCK_MULTI === 'true';
-    const blocks = allBlocks.filter((name) => !filterModules || filterModules.includes(name || ''));
+    const blocks = allBlocks.filter((name) => !componentIds || componentIds.includes(name || ''));
     if (!blocks.length) {
-        console.log(chalk_1.default.yellow('No components founds, please check has any component been selected'));
-        throw new Error('No components founds, please check has any component been selected');
-        return;
+        console.log(chalk_1.default.yellow('No components found, please check has any component been selected'));
+        throw new Error('No components found, please check has any component been selected');
     }
     // Clean up the lib directory
     await (0, child_process_1.execSync)(`rm -rf ${helper_1.libDir}`, { cwd: workingDir });
@@ -32,51 +66,266 @@ async function buildLib(options) {
     // Start to build
     console.log(chalk_1.default.cyan(`Start to build ${blocks.length} blocks in parallel\n`));
     const canBuildBlocks = multiMode ? blocks : [blocks.join(',')];
-    const configFile = 'vite-lib.config';
-    const hasConfig = (0, child_process_1.execSync)(`ls ${configFile}.* 2>/dev/null || true`, {
+    const configFile = 'vite-lib.config.ts';
+    const hasConfig = (0, child_process_1.execSync)(`ls ${configFile} 2>/dev/null || true`, {
         cwd: workingDir,
         encoding: 'utf-8',
     }).trim() !== '';
+    await Promise.all(canBuildBlocks.map((blockName) => {
+        console.log(chalk_1.default.blue(`Building ${blockName} Block...`));
+        return new Promise((resolve, reject) => {
+            const build = (0, child_process_1.spawn)('vite', [
+                'build',
+                '--filter',
+                `"${blockName}"`,
+                '--outDir',
+                helper_1.libDir,
+                '--emptyOutDir=false',
+                hasConfig ? `--config ${configFile}.*` : '',
+            ], {
+                stdio: ignoreViteLog ? ['inherit', 'ignore', 'ignore'] : 'inherit',
+                shell: true,
+                cwd: workingDir,
+            });
+            build.on('close', (code) => {
+                if (code === 0) {
+                    console.log(chalk_1.default.green(`Build ${blockName} successfully`));
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Build failed with code ${code}`));
+                }
+            });
+        });
+    }));
+    console.log(chalk_1.default.green(`\nBuild ${blocks.length} blocks successfully`));
+    console.log(chalk_1.default.gray(`Generate the ${helper_1.libDir} directory successfully`));
+}
+async function performPackaging({ exportDir, componentIds, workingDir }) {
+    if (exportDir) {
+        // Clear and create export directory
+        fs_1.default.rmSync(exportDir, { recursive: true, force: true });
+        fs_1.default.mkdirSync(exportDir, { recursive: true });
+    }
+    const distDir = (0, path_1.join)(workingDir, helper_1.libDir);
+    const codeDir = (0, path_1.join)(distDir, 'es');
+    const tmpPackage = (0, path_1.join)(distDir, 'resource-blocklet');
+    fs_1.default.mkdirSync(tmpPackage, { recursive: true });
+    const pagesDir = (0, path_1.join)(tmpPackage, 'pages');
+    fs_1.default.mkdirSync(pagesDir, { recursive: true });
+    const componentsDir = (0, path_1.join)(tmpPackage, 'components');
+    fs_1.default.mkdirSync(componentsDir, { recursive: true });
+    const chunksDir = (0, path_1.join)(tmpPackage, 'chunks');
+    fs_1.default.mkdirSync(chunksDir, { recursive: true });
+    const chunksMapPath = (0, path_1.join)(codeDir, 'chunks-map.json');
+    const chunksMap = JSON.parse(fs_1.default.readFileSync(chunksMapPath, 'utf8'));
+    // Get components with metadata
+    const canUseComponents = (0, helper_1.findComponentFiles)({
+        cwd: workingDir,
+        filter: componentIds,
+        strictExistMetadata: true,
+    });
+    // Process metadata files
+    const metadataList = await Promise.all(canUseComponents.map(async ({ fullPath, blockName, metadata: _metadata }) => {
+        const metadata = _metadata;
+        const jsName = `${blockName}.js`;
+        // Set version to 2
+        (0, set_1.default)(metadata, 'version', 2);
+        // Get main component code
+        const code = fs_1.default.readFileSync((0, path_1.join)(codeDir, `${(0, helper_1.getComponentScriptName)(blockName, 'esm')}.js`), 'utf8');
+        if (code) {
+            (0, set_1.default)(metadata, 'renderer.script', code);
+            (0, set_1.default)(metadata, 'renderer.type', 'react-component');
+            (0, set_1.default)(metadata, 'renderer.chunks', chunksMap[jsName] || []);
+        }
+        // Transpile to CJS
+        try {
+            const cjsCode = typescript_1.default.transpileModule(code, {
+                compilerOptions: {
+                    jsx: typescript_1.default.JsxEmit.React,
+                    target: typescript_1.default.ScriptTarget.ES2016,
+                    module: typescript_1.default.ModuleKind.CommonJS,
+                    moduleResolution: typescript_1.default.ModuleResolutionKind.Node16,
+                },
+            }).outputText;
+            if (cjsCode) {
+                (0, set_1.default)(metadata, 'renderer.cjsScript', cjsCode);
+            }
+        }
+        catch (error) {
+            // ignore error
+        }
+        // Handle edit component code
+        try {
+            const editComponentJsName = `${(0, helper_1.getEditComponentBlockName)(blockName)}.js`;
+            const editComponentCode = fs_1.default.readFileSync((0, path_1.join)(codeDir, editComponentJsName), 'utf8');
+            if (editComponentCode) {
+                (0, set_1.default)(metadata, 'renderer.editComponent', editComponentCode);
+                (0, set_1.default)(metadata, 'renderer.chunks', Array.from(new Set([...(0, get_1.default)(metadata, 'renderer.chunks', []), ...(chunksMap[editComponentJsName] || [])])));
+            }
+        }
+        catch (error) {
+            // ignore error
+        }
+        // Handle aigne output value schema
+        try {
+            const aigneOutputValueSchemaJsName = `${(0, helper_1.getAigneOutputValueSchemaBlockName)(blockName)}.js`;
+            const aigneOutputValueSchemaCode = fs_1.default.readFileSync((0, path_1.join)(codeDir, aigneOutputValueSchemaJsName), 'utf8');
+            if (aigneOutputValueSchemaCode) {
+                (0, set_1.default)(metadata, 'renderer.aigneOutputValueSchema', aigneOutputValueSchemaCode);
+            }
+        }
+        catch (error) {
+            // ignore error
+        }
+        // Handle properties schema
+        try {
+            const propertiesSchemaJsName = `${(0, helper_1.getPropertiesSchemaBlockName)(blockName)}.js`;
+            const propertiesSchemaCode = fs_1.default.readFileSync((0, path_1.join)(codeDir, propertiesSchemaJsName), 'utf8');
+            if (propertiesSchemaCode) {
+                (0, set_1.default)(metadata, 'renderer.PROPERTIES_SCHEMA', propertiesSchemaCode);
+            }
+        }
+        catch (error) {
+            // ignore error
+        }
+        // Handle getServerSideProps
+        try {
+            const getServerSidePropsJsName = `${(0, helper_1.getGetServerSidePropsBlockName)(blockName)}.js`;
+            const getServerSidePropsCode = fs_1.default.readFileSync((0, path_1.join)(codeDir, getServerSidePropsJsName), 'utf8');
+            if (getServerSidePropsCode) {
+                (0, set_1.default)(metadata, 'renderer.getServerSideProps', getServerSidePropsCode);
+            }
+        }
+        catch (error) {
+            // ignore error
+        }
+        // Handle preview image
+        if (metadata.previewImage) {
+            const imagePath = path_1.default.join(path_1.default.dirname(fullPath), (0, helper_1.getPreviewImageRelativePath)(metadata.previewImage));
+            const imageDestPath = path_1.default.join(componentsDir, metadata.previewImage);
+            if (fs_1.default.existsSync(imagePath)) {
+                fs_1.default.copyFileSync(imagePath, imageDestPath);
+            }
+        }
+        // Handle type:url properties
+        if (metadata.properties) {
+            const downloadPromises = [];
+            Object.keys(metadata.properties).forEach((key) => {
+                const property = metadata.properties[key].data;
+                if (property.type === 'url') {
+                    Object.keys(property.locales).forEach((locale) => {
+                        if (property.locales[locale].defaultValue?.mediaKitUrl?.startsWith('mediakit://')) {
+                            const downloadPromise = (async () => {
+                                try {
+                                    const fileName = (0, path_1.basename)(property.locales[locale].defaultValue.mediaKitUrl);
+                                    const targetPath = path_1.default.join(componentsDir, fileName);
+                                    if (fs_1.default.existsSync(targetPath)) {
+                                        return;
+                                    }
+                                    // try to get image from preview image
+                                    const imagePathInPreview = path_1.default.join(path_1.default.dirname(fullPath), (0, helper_1.getPreviewImageRelativePath)(fileName));
+                                    if (fs_1.default.existsSync(imagePathInPreview)) {
+                                        fs_1.default.copyFileSync(imagePathInPreview, targetPath);
+                                        return;
+                                    }
+                                    const resWithStream = await (0, uploader_server_1.getMediaKitFileStream)(property.locales[locale].defaultValue.mediaKitUrl);
+                                    if (!resWithStream.data) {
+                                        return;
+                                    }
+                                    const writeStream = fs_1.default.createWriteStream(targetPath);
+                                    resWithStream.data.pipe(writeStream);
+                                    await new Promise((resolve, reject) => {
+                                        writeStream.on('finish', () => {
+                                            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);
+                        }
+                    });
+                }
+            });
+            if (downloadPromises.length > 0) {
+                await Promise.allSettled(downloadPromises);
+            }
+        }
+        // Write metadata file
+        const metadataYmlPath = path_1.default.join(componentsDir, `${metadata.name || 'unnamed'}.${metadata.id}.yml`);
+        fs_1.default.writeFileSync(metadataYmlPath, (0, helper_1.generateYaml)(metadata));
+        return metadata;
+    }));
+    // Copy chunks directory
+    await (0, helper_1.copyRecursive)((0, path_1.join)(codeDir, 'chunks'), chunksDir);
+    // Generate pages.config.yml
+    const pagesConfigPath = path_1.default.join(tmpPackage, '.blocklet/pages/pages.config.yml');
+    fs_1.default.mkdirSync(path_1.default.dirname(pagesConfigPath), { recursive: true });
+    const pagesConfig = {
+        version: 2,
+        pages: [],
+        components: metadataList.map((metadata) => ({
+            id: metadata.id,
+            name: metadata.name,
+        })),
+        supportedLocales: [],
+        config: {},
+    };
+    fs_1.default.writeFileSync(pagesConfigPath, (0, helper_1.generateYaml)(pagesConfig));
+    helper_1.logger.info('generate resource blocklet block count:', metadataList.length);
+    if (exportDir) {
+        // Copy to target directory
+        await (0, helper_1.copyRecursive)(tmpPackage, exportDir);
+        console.log(chalk_1.default.green(`Package exported to: ${exportDir}`));
+    }
+}
+async function buildLib(options = {}) {
+    const workingDir = options?.cwd || process.cwd();
+    const filterModules = process.argv.includes('--filter')
+        ? process.argv[process.argv.indexOf('--filter') + 1]?.split(',')
+        : process.env.BLOCK_FILTER?.split(',');
+    // Get parameters from environment variables
+    const componentIds = filterModules ?? null;
+    const exportDir = process.argv.includes('--export-dir')
+        ? process.argv[process.argv.indexOf('--export-dir') + 1]
+        : process.env.EXPORT_DIR;
     try {
-        await Promise.all(canBuildBlocks.map((blockName) => {
-            console.log(chalk_1.default.blue(`Building ${blockName} Block...`));
-            return new Promise((resolve, reject) => {
-                const build = (0, child_process_1.spawn)('vite', [
-                    'build',
-                    '--filter',
-                    `"${blockName}"`,
-                    '--outDir',
-                    helper_1.libDir,
-                    '--emptyOutDir=false',
-                    hasConfig ? `--config ${configFile}.*` : '',
-                ], {
-                    stdio: ignoreViteLog ? ['inherit', 'ignore', 'ignore'] : 'inherit',
-                    shell: true,
-                    cwd: workingDir,
-                });
-                build.on('close', (code) => {
-                    if (code === 0) {
-                        console.log(chalk_1.default.green(`Build ${blockName} successfully`));
-                        resolve();
-                    }
-                    else {
-                        reject(new Error(`Build failed with code ${code}`));
-                    }
-                });
+        // Phase 1: Build components
+        await performBuild(workingDir, componentIds);
+        console.log(chalk_1.default.green('Build completed successfully'));
+        // Phase 2: Package resources (if export directory is specified)
+        if (exportDir) {
+            await performPackaging({
+                exportDir,
+                componentIds,
+                workingDir,
             });
-        }));
-        console.log(chalk_1.default.green(`\nBuild ${blocks.length} blocks successfully`));
-        console.log(chalk_1.default.gray(`Generate the ${helper_1.libDir} directory successfully`));
-        process.exit(0);
+            console.log(chalk_1.default.green('Package completed successfully'));
+        }
     }
     catch (err) {
         console.error(chalk_1.default.red('Build failed:'), err);
-        process.exit(1);
+        if (process.env.NODE_ENV !== 'test') {
+            process.exit(1);
+        }
+        throw err;
+    }
+    finally {
+        process.exit(0);
     }
 }
 const cwdArg = process.argv.indexOf('--cwd');
 const cwd = cwdArg !== -1 ? process.argv[cwdArg + 1] : undefined;
-buildLib({ cwd }).catch((err) => {
+buildLib({ cwd })
+    .catch((err) => {
     console.error(chalk_1.default.red('Build failed:'), err);
     process.exit(1);
+})
+    .finally(() => {
+    process.exit(0);
 });

package/lib/cjs/utils/helper.js

@@ -48,6 +48,9 @@ exports.getBlockName = getBlockName;
 exports.initializeMetadata = initializeMetadata;
 exports.generateYaml = generateYaml;
 exports.getBlockStudioInfo = getBlockStudioInfo;
+exports.copyFile = copyFile;
+exports.copyDirectory = copyDirectory;
+exports.copyRecursive = copyRecursive;
 const component_1 = require("@blocklet/sdk/lib/component");
 const config_1 = __importDefault(require("@blocklet/sdk/lib/config"));
 const fs_1 = __importDefault(require("fs"));
@@ -263,3 +266,38 @@ const getGetServerSidePropsBlockName = (blockName) => {
     return `${blockName}(${exports.GET_SERVER_SIDE_PROPS_NAME})`;
 };
 exports.getGetServerSidePropsBlockName = getGetServerSidePropsBlockName;
+function copyFile(src, dest) {
+    return new Promise((resolve, reject) => {
+        const readStream = fs_1.default.createReadStream(src);
+        const writeStream = fs_1.default.createWriteStream(dest);
+        readStream.on('error', reject);
+        writeStream.on('error', reject);
+        writeStream.on('finish', resolve);
+        readStream.pipe(writeStream);
+    });
+}
+async function copyDirectory(src, dest) {
+    await fs_1.default.promises.mkdir(dest, { recursive: true });
+    const entries = await fs_1.default.promises.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path_1.default.join(src, entry.name);
+        const destPath = path_1.default.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);
+        }
+    }
+}
+async function copyRecursive(src, dest) {
+    const srcStats = await fs_1.default.promises.stat(src);
+    if (srcStats.isDirectory()) {
+        await copyDirectory(src, dest);
+    }
+    else {
+        await copyFile(src, dest);
+    }
+}

package/lib/esm/middlewares/init-block-studio-router.js

@@ -159,6 +159,40 @@ initBlockStudioRouter.post('/', async (req, res) => {
                 });
             }
         }
+        // check if the properties has mediaKitUrl
+        if (isMetadataFile(filePath) && content.properties) {
+            const downloadPromises = [];
+            Object.keys(content.properties).forEach((key) => {
+                const property = content.properties[key].data;
+                if (property.type === 'url') {
+                    Object.keys(property.locales).forEach((locale) => {
+                        if (property.locales[locale].defaultValue?.mediaKitUrl?.startsWith('mediakit://')) {
+                            const downloadPromise = (async () => {
+                                try {
+                                    const fileName = path.basename(property.locales[locale].defaultValue.mediaKitUrl);
+                                    const targetPath = path.join(dir, getPreviewImageRelativePath(fileName));
+                                    if (fs.existsSync(targetPath)) {
+                                        return;
+                                    }
+                                    await downloadAsset({
+                                        asset: fileName,
+                                        savePath: targetPath,
+                                        componentDid: process.env.BLOCKLET_COMPONENT_DID || '',
+                                    });
+                                }
+                                catch (error) {
+                                    console.error('Download media kit file failed:', error.message);
+                                }
+                            })();
+                            downloadPromises.push(downloadPromise);
+                        }
+                    });
+                }
+            });
+            if (downloadPromises.length > 0) {
+                await Promise.allSettled(downloadPromises);
+            }
+        }
         fs.writeFileSync(filePath, JSON.stringify(mergedContent, null, 2));
         return res.json({ success: true, content: mergedContent, message: 'Updated' });
     }