@blocklet/pages-kit-runtime 0.1.1

package/lib/cjs/types/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PUBLISH_MODES = exports.STATE_MODES = void 0;
+exports.STATE_MODES = ['production', 'draft'];
+exports.PUBLISH_MODES = ['production'];

package/lib/cjs/utils/index.js

@@ -0,0 +1 @@
+"use strict";

package/lib/esm/block-studio/build-lib.js

@@ -0,0 +1,89 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-console */
+import chalk from 'chalk';
+import { execSync, spawn } from 'child_process';
+import { findComponentFiles } from './utils';
+export function buildLib(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        const workingDir = (options === null || options === void 0 ? void 0 : options.cwd) || process.cwd();
+        // Scan for all index files
+        const allBlocks = findComponentFiles({ cwd: workingDir }).map((entry) => {
+            return entry.blockName;
+        });
+        const filterModules = process.argv.includes('--filter')
+            ? (_a = process.argv[process.argv.indexOf('--filter') + 1]) === null || _a === void 0 ? void 0 : _a.split(',')
+            : ((_b = process.env.BLOCK_FILTER) === null || _b === void 0 ? void 0 : _b.split(',')) || null;
+        const ignoreViteLog = false; // process.argv.includes('--log') ? false : process.env.BLOCK_LOG !== 'true';
+        const multiMode = process.argv.includes('--multi') || process.env.BLOCK_MULTI === 'true';
+        const libDir = 'lib';
+        const blocks = allBlocks.filter((name) => !filterModules || filterModules.includes(name || ''));
+        if (!blocks.length) {
+            console.log(chalk.yellow('No blocks founds'));
+            return;
+        }
+        // Clean up the lib directory
+        yield execSync(`rm -rf ${libDir}`, { cwd: workingDir });
+        console.log(chalk.gray('Clean up the lib directory'));
+        // Start to build
+        console.log(chalk.cyan(`Start to build ${blocks.length} blocks in parallel\n`));
+        const canBuildBlocks = multiMode ? blocks : [blocks.join(',')];
+        const configFile = 'vite-lib.config';
+        const hasConfig = execSync(`ls ${configFile}.* 2>/dev/null || true`, {
+            cwd: workingDir,
+            encoding: 'utf-8',
+        }).trim() !== '';
+        try {
+            yield Promise.all(canBuildBlocks.map((blockName) => {
+                console.log(chalk.blue(`Building ${blockName} Block...`));
+                return new Promise((resolve, reject) => {
+                    const build = spawn('vite', [
+                        'build',
+                        '--filter',
+                        `"${blockName}"`,
+                        '--outDir',
+                        libDir,
+                        '--emptyOutDir=false',
+                        hasConfig ? `--config ${configFile}.*` : '',
+                        multiMode ? '--multi' : '',
+                    ], {
+                        stdio: ignoreViteLog ? ['inherit', 'ignore', 'ignore'] : 'inherit',
+                        shell: true,
+                        cwd: workingDir,
+                    });
+                    build.on('close', (code) => {
+                        if (code === 0) {
+                            console.log(chalk.green(`Build ${blockName} successfully`));
+                            resolve();
+                        }
+                        else {
+                            reject(new Error(`Build failed with code ${code}`));
+                        }
+                    });
+                });
+            }));
+            console.log(chalk.green(`\nBuild ${blocks.length} blocks successfully`));
+            console.log(chalk.gray(`Generate the ${libDir} directory successfully`));
+            process.exit(0);
+        }
+        catch (err) {
+            console.error(chalk.red('Build failed:'), err);
+            process.exit(1);
+        }
+    });
+}
+const cwdArg = process.argv.indexOf('--cwd');
+const cwd = cwdArg !== -1 ? process.argv[cwdArg + 1] : undefined;
+buildLib({ cwd }).catch((err) => {
+    console.error(chalk.red('Build failed:'), err);
+    process.exit(1);
+});

package/lib/esm/block-studio/generate-wrapper-code.js

@@ -0,0 +1,87 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export function generateWrapperCode(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ project, state }) {
+        const projectName = (project.name || project.id).toLowerCase().replaceAll(/[^a-z0-9]/g, '_');
+        const packageName = `@pages-kit-project/${projectName}`;
+        const packageJson = JSON.stringify({
+            name: packageName,
+            version: '0.0.1',
+            main: 'index.cjs',
+            module: 'index.js',
+            types: 'index.d.ts',
+            peerDependencies: {
+                '@blocklet/pages-kit-runtime': 'latest',
+            },
+            dependencies: {
+                '@blocklet/pages-kit-runtime': 'latest',
+                '@blocklet/pages-kit': 'latest',
+            },
+            exports: {
+                '.': {
+                    require: './index.cjs',
+                    import: './index.js',
+                    types: './index.d.ts',
+                },
+                './client': {
+                    require: './client.cjs',
+                    import: './client.js',
+                    types: './client.d.ts',
+                },
+            },
+        }, null, 2);
+        const index = `\
+import { ProjectRuntime } from '@blocklet/pages-kit-runtime/client';
+
+window.__PAGE_STATE__ = ${JSON.stringify(state, null, 2)};
+window.__PROJECT_ID__ = "${project.id}";
+
+
+const ${projectName} = new ProjectRuntime({
+  state: window.__PAGE_STATE__,
+  projectId: window.__PROJECT_ID__,
+});
+
+export default ${projectName}
+`;
+        const client = index;
+        const tsFiles = [
+            { fileName: 'index.ts', content: index },
+            { fileName: 'client.ts', content: client },
+        ];
+        const ts = yield import('typescript');
+        const result = (yield Promise.all(tsFiles.map((_a) => __awaiter(this, [_a], void 0, function* ({ fileName, content }) {
+            const cjs = ts.transpileModule(content, {
+                fileName,
+                compilerOptions: { module: ts.ModuleKind.CommonJS },
+            });
+            const esm = ts.transpileModule(content, {
+                fileName,
+                compilerOptions: { module: ts.ModuleKind.ESNext },
+            });
+            return [
+                {
+                    fileName: fileName.replace(/\.ts$/, '.cjs'),
+                    content: cjs.outputText,
+                },
+                {
+                    fileName: fileName.replace(/\.ts$/, '.js'),
+                    content: esm.outputText,
+                },
+                {
+                    fileName: fileName.replace(/\.ts$/, '.d.ts'),
+                    content,
+                },
+            ];
+        })))).flat();
+        return [...result, { fileName: 'package.json', content: packageJson }];
+    });
+}
+export default generateWrapperCode;

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

@@ -0,0 +1,124 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { getResourceExportDir } from '@blocklet/sdk/lib/component';
+import { spawn } from 'child_process';
+import { Router } from 'express';
+import fs from 'fs';
+import path, { join } from 'path';
+import { findComponentFiles } from './utils';
+const DID = 'z2qa7rr3eUyVnWp2PCxEVARuUfLFh6cE5V2xV';
+const RESOURCE_TYPE = 'block';
+const allTag = '@ALL_COMPONENTS';
+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 function copyDirectory(src, dest) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield fs.promises.mkdir(dest, { recursive: true });
+        const entries = yield 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()) {
+                yield copyDirectory(srcPath, destPath);
+            }
+            else {
+                yield copyFile(srcPath, destPath);
+            }
+        }
+    });
+}
+export function copyRecursive(src, dest) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const srcStats = yield fs.promises.stat(src);
+        if (srcStats.isDirectory()) {
+            yield copyDirectory(src, dest);
+        }
+        else {
+            yield copyFile(src, dest);
+        }
+    });
+}
+const getExportDir = (projectId, releaseId) => {
+    const exportDir = getResourceExportDir({ projectId, releaseId });
+    const dir = join(exportDir, DID, RESOURCE_TYPE);
+    return dir;
+};
+export const initResourceRouter = Router();
+initResourceRouter.get('/resources', (_req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const resources = [];
+    const rootDir = process.cwd();
+    const files = findComponentFiles({ cwd: rootDir });
+    for (const file of files) {
+        // const filePath = path.join(rootDir, file);
+        // const fileContent = fs.readFileSync(filePath, 'utf8');
+        const { blockName } = file;
+        resources.push({
+            id: blockName,
+            name: blockName,
+            description: '',
+            images: [],
+            url: '',
+        });
+    }
+    res.json({
+        resources: [
+            {
+                id: allTag,
+                name: 'All Blocks',
+                description: 'Select All Blocks',
+                images: [],
+                url: '',
+                children: resources,
+            },
+        ],
+    });
+}));
+initResourceRouter.post('/resources', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const { resources, projectId, releaseId } = req.body;
+    // ignore all tag
+    const componentIds = resources.filter((resource) => resource.id !== allTag);
+    try {
+        // Execute build command with filtered components
+        const buildProcess = spawn('pnpm', ['run', 'build-lib'], {
+            stdio: 'inherit',
+            shell: true,
+            env: Object.assign(Object.assign({}, process.env), { FORCE_COLOR: '1', BLOCK_FILTER: componentIds.join(',') }),
+        });
+        yield new Promise((resolve, reject) => {
+            buildProcess.on('close', (code) => {
+                if (code === 0)
+                    resolve(null);
+                else
+                    reject(new Error(`Build process exited with code ${code}`));
+            });
+        });
+        const dir = getExportDir(projectId, releaseId);
+        fs.rmSync(dir, { recursive: true, force: true });
+        fs.mkdirSync(dir, { recursive: true });
+        const rootDir = process.cwd();
+        const tmpPackage = join(rootDir, 'lib');
+        yield copyRecursive(tmpPackage, dir);
+        fs.rmSync(tmpPackage, { recursive: true, force: true });
+        res.json({ success: true });
+    }
+    catch (error) {
+        console.error('Build failed:', error);
+        res.status(500).json({ error: 'Build failed' });
+    }
+}));
+export default initResourceRouter;

package/lib/esm/block-studio/plugins/_theme.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+export default function Theme() {
+    return _jsx("div", { children: "Theme" });
+}

package/lib/esm/block-studio/plugins/index.js

@@ -0,0 +1,3 @@
+export * from './vite-plugin-block-studio';
+export * from './vite-plugin-html-transform';
+export * from './vite-plugin-remote-script-localizer';

package/lib/esm/block-studio/plugins/vite-plugin-block-studio.js

@@ -0,0 +1,140 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+// eslint-disable-next-line import/no-unresolved
+// import typescript from '@rollup/plugin-typescript';
+import { readFileSync, existsSync } from 'fs';
+import * as path from 'path';
+import pages, { DefaultPageStrategy } from 'vite-plugin-react-pages';
+import { findComponentFiles, setBlockEntryFilesPattern, getBlockEntryFilesPattern, getBlockName, logger, } from '../utils';
+import { initHtmlPreviewTransformPlugin, VIRTUAL_MODULE_ID } from './vite-plugin-html-transform';
+// import initRemoteScriptLocalizerPlugin from './vite-plugin-remote-script-localizer';
+export function initBlockStudioPlugins(options) {
+    const workingDir = (options === null || options === void 0 ? void 0 : options.cwd) || process.cwd();
+    const entryFilesPattern = (options === null || options === void 0 ? void 0 : options.entryFilesPattern) || getBlockEntryFilesPattern();
+    setBlockEntryFilesPattern(entryFilesPattern);
+    // fallback to __dirname if _theme.tsx not exists
+    const pagesDir = existsSync(path.join(workingDir, '_theme.tsx')) ? workingDir : __dirname.replace('cjs', 'esm');
+    logger.log('initBlockStudioPlugins options', {
+        cwd: workingDir,
+        entryFilesPattern: getBlockEntryFilesPattern(),
+        pagesDir,
+    });
+    return [
+        // {
+        //   name: 'vite-plugin-block-studio-dev',
+        //   enforce: 'pre',
+        //   transformIndexHtml(html) {
+        //     // Ensure required content exists in index.html
+        //     if (!html.includes('<div id="root"></div>')) {
+        //       html = html.replace(/<body[^>]*>/, '$&<div id="root"></div>');
+        //     }
+        //     if (!html.includes('/@pages-infra/main.js')) {
+        //       html = html.replace('</body>', '<script type="module" src="/@pages-infra/main.js"></script></body>');
+        //     }
+        //     return html;
+        //   },
+        // },
+        {
+            name: 'vite-plugin-block-studio-build',
+            enforce: 'pre',
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            config(_config) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    var _a;
+                    const filterModules = process.argv.includes('--filter')
+                        ? (_a = process.argv[process.argv.indexOf('--filter') + 1]) === null || _a === void 0 ? void 0 : _a.split(',')
+                        : null;
+                    const multiMode = !!process.argv.includes('--multi');
+                    const name = yield import(`${workingDir}/package.json`).then((res) => res.name).catch(() => 'MyLib');
+                    return {
+                        build: {
+                            cssCodeSplit: false,
+                            lib: {
+                                name,
+                                entry: Object.assign({}, Object.fromEntries(findComponentFiles({ cwd: workingDir })
+                                    .map((entry) => {
+                                    const { blockName } = entry;
+                                    const { isHtml } = entry;
+                                    const { file } = entry;
+                                    if (isHtml) {
+                                        return [blockName, `${VIRTUAL_MODULE_ID}?dir=${path.dirname(file)}`];
+                                    }
+                                    return [blockName, path.resolve(workingDir, file)];
+                                })
+                                    .filter(Boolean)
+                                    .filter(([blockName]) => !filterModules || filterModules.includes(blockName || '')))),
+                                // multiMode not support umd
+                                formats: ['es', multiMode ? 'umd' : 'cjs'],
+                                fileName: (format, entryName) => `${format}/${entryName}.js`,
+                            },
+                            rollupOptions: {
+                                // make sure to externalize deps that shouldn't be bundled
+                                // into your library
+                                external: ['react', 'crypto'],
+                                output: {
+                                    // Provide global variables to use in the UMD build
+                                    globals: {
+                                        react: 'React',
+                                    },
+                                    paths: {
+                                    // Redirect 'react' imports to '@blocklet/pages-kit/builtin/react'
+                                    // react: '@blocklet/pages-kit/builtin/react',
+                                    },
+                                },
+                            },
+                        },
+                    };
+                });
+            },
+        },
+        // @ts-ignore
+        pages({
+            pagesDir,
+            pageStrategy: new DefaultPageStrategy({
+                extraFindPages: (_pagesDir, helpers) => __awaiter(this, void 0, void 0, function* () {
+                    helpers.watchFiles(workingDir, getBlockEntryFilesPattern(), function fileHandler(file, api) {
+                        return __awaiter(this, void 0, void 0, function* () {
+                            const { relative, path: filePath } = file;
+                            const isHtml = relative.endsWith('.html');
+                            const blockName = getBlockName(relative);
+                            const pageId = `/${blockName}`;
+                            api.addPageData({
+                                pageId,
+                                dataPath: isHtml ? `${VIRTUAL_MODULE_ID}?dir=${path.dirname(filePath)}` : filePath,
+                                staticData: isHtml
+                                    ? {
+                                        isHtmlPreview: true,
+                                        dataPath: filePath,
+                                        blockName,
+                                    }
+                                    : Object.assign(Object.assign({}, (yield helpers.extractStaticData(file))), { code: readFileSync(file.path, 'utf-8'), dataPath: filePath, blockName }),
+                            });
+                        });
+                    });
+                }),
+            }),
+        }),
+        // https://github.com/rollup/plugins/tree/master/packages/typescript#noforceemit
+        // typescript({
+        //   declaration: true,
+        //   emitDeclarationOnly: true,
+        //   noForceEmit: true,
+        //   declarationDir: path.resolve(workingDir, 'lib/types'),
+        //   rootDir: path.resolve(workingDir),
+        // }),
+        initHtmlPreviewTransformPlugin(),
+        // initRemoteScriptLocalizerPlugin({
+        //   tempDir: 'temp/remote-scripts', // 可选，默认值
+        //   maxConcurrent: 5, // 可选，默认值
+        //   timeout: 30 * 1000, // 可选，默认值 30 秒
+        // }),
+    ];
+}
+export default initBlockStudioPlugins;