@love-sqjm/magic 2026.4.15

package/script/module/compiler/step/1.js

@@ -0,0 +1,253 @@
+import { parse } from 'node-html-parser';
+import path from "node:path";
+import { app } from "../../../../app.js";
+import { printf } from "../../../global/printf.js";
+import { ProjectBuildConfig, ProjectBuildConfigContrast } from "../../../global/project-build-config.js";
+import { macroReplace } from "../macro-replace.js";
+import { _2 } from "./2.js";
+import { bunFS } from "../../../util/bun-fs.js";
+
+function parseModuleImportFile( filePath ) {
+    if ( !bunFS.existsSync( filePath ) ) {
+        throw `module-import 文件不存在 [path:${ filePath }]`;
+    }
+    const content = bunFS.readFileSync( filePath );
+    const lines = content.split( '\n' );
+    const result = {
+        js : [],
+        css : [],
+        link : [],
+        file : []
+    };
+
+    let currentSection = null;
+
+    for ( const line of lines ) {
+        const trimmed = line.trim();
+        if ( trimmed === "" || trimmed.startsWith( "#" ) ) continue;
+
+        if ( trimmed === "js" ) {
+            currentSection = "js";
+        } else if ( trimmed === "css" ) {
+            currentSection = "css";
+        } else if ( trimmed === "link" ) {
+            currentSection = "link";
+        } else if ( trimmed === "file" ) {
+            currentSection = "file";
+        } else if ( trimmed.startsWith( "-" ) && currentSection ) {
+            let item = trimmed.substring( 1 ).trim();
+            let load = "begin";
+
+            const loadMatch = item.match( /^\[load:(\w+)\]\s*(.+)/ );
+            if ( loadMatch ) {
+                load = loadMatch[ 1 ];
+                item = loadMatch[ 2 ].trim();
+            }
+
+            result[ currentSection ].push( { file : item, load : load } );
+        }
+    }
+
+    return result;
+}
+
+export function examine_BuildConfig( root ) {
+    printf.outFile.info( `检查项目配置文件` );
+
+    const build_config = root [ "default" ];
+    if ( build_config.build.platform.target === "module" ) {
+        ProjectBuildConfigContrast( ProjectBuildConfig.base_module, build_config );
+        return build_config;
+    }
+    const result = ProjectBuildConfigContrast( ProjectBuildConfig.base, build_config );
+    if ( result ) {
+        if ( !bunFS.existsSync( app.project.dir + build_config.config.src + "/" + build_config.config.main + ".m" ) )
+            throw `缺少入口文件! 请确保 ${ build_config.config.main }.m 在 ${ build_config.config.src } 源目录下创建`;
+        return build_config;
+    }
+}
+
+// group -dir
+// css -src -load:begin|end -...(cover)
+// js -src -load:begin|end -...(cover)
+// link -href -...(cover)
+// file -path
+function examine_AppConfig_parserImport( $import, srcDir ) {
+    if ( !$import ) return [];
+    !$import.hasAttribute( "dir" ) && $import.setAttribute( "dir", "" );
+    const list = [];
+
+    function initDefault( tagName, element ) {
+        if ( tagName === "js" ) {
+            !element.hasAttribute( "src" ) && element.setAttribute( "src", "" );
+            !element.hasAttribute( "load" ) && element.setAttribute( "load", "begin" );
+        } else if ( tagName === "css" ) {
+            !element.hasAttribute( "src" ) && element.setAttribute( "src", "" );
+        } else if ( tagName === "link" ) {
+            !element.hasAttribute( "href" ) && element.setAttribute( "href", "" );
+        } else if ( tagName === "group" ) {
+            !element.hasAttribute( "dir" ) && element.setAttribute( "dir", "" );
+        } else if ( tagName === "file" ) {
+            !element.hasAttribute( "path" ) && element.setAttribute( "path", "" );
+            !element.hasAttribute( "load" ) && element.setAttribute( "load", "begin" );
+        }
+    }
+
+    function generateTag( dir, tagName, attribs ) {
+        let attrsString = "";
+        for ( const attr in attribs ) {
+            if ( attr === "src" || attr === "href" || attr === "load" ) continue;
+            attrsString += `${ attr.substring( 1 ) }="${ path.normalize( attribs[ attr ] ) }" `.replaceAll( '\n', "" );
+        }
+        dir = dir.replace( /\\/g, '/' );
+
+        if ( tagName === "js" ) {
+            return `<script src="${ dir }/${ attribs[ "src" ] }" type="text/javascript" ${ attrsString }></script>`;
+        } else if ( tagName === "css" ) {
+            return `<link rel="stylesheet" type="text/css" href="${ dir }/${ attribs[ "src" ] }" ${ attrsString }/>`;
+        } else if ( tagName === "link" ) {
+            return `<link href="${ dir }/${ attribs[ "href" ] }" ${ attrsString }/>`;
+        }
+        return "";
+    }
+
+    function itGroup( group ) {
+        !group.hasAttribute( "dir" ) && group.setAttribute( "dir", "" );
+        let dir = group.getAttribute( "dir" );
+        const attrs = group.attrs;
+        delete attrs?.["dir"];
+        group.childNodes.forEach( ( element ) => {
+            if ( element.nodeType === 3 ) return;
+            const tagName = element.rawTagName.toLowerCase();
+            if ( tagName === "group" ) return itGroup( element );
+
+            if ( tagName === "module-import" ) {
+                const src = element.getAttribute( "src" );
+                if ( !src ) throw `module-import 缺少 src 属性`;
+                const moduleDir = path.normalize( srcDir + "/" + dir + "/" + src ).replace( /\\/g, '/' );
+                const moduleImportFile = moduleDir + "/.module-import";
+                const parsed = parseModuleImportFile( moduleImportFile );
+                const moduleRelativeDir = "./" + moduleDir.substring( srcDir.replace( /\\/g, '/' ).length + 1 );
+
+                parsed.js.forEach( item => {
+                    list.push( {
+                        o : {
+                            element : generateTag( moduleRelativeDir, "js", { "src" : item.file } ),
+                            load : item.load
+                        }
+                    } );
+                } );
+
+                parsed.css.forEach( item => {
+                    list.push( {
+                        o : {
+                            element : generateTag( moduleRelativeDir, "css", { "src" : item.file } ),
+                            load : item.load
+                        }
+                    } );
+                } );
+
+                parsed.link.forEach( item => {
+                    list.push( {
+                        o : {
+                            element : generateTag( moduleRelativeDir, "link", { "href" : item.file } ),
+                            load : item.load
+                        }
+                    } );
+                } );
+
+                parsed.file.forEach( item => {
+                    const filePath = path.normalize( moduleDir + "/" + item.file );
+                    if ( !bunFS.existsSync( filePath ) ) throw `module-import 文件不存在 [path:${ filePath }]`;
+                    const content = bunFS.readFileSync( filePath );
+                    list.push( {
+                        o : {
+                            element : content,
+                            load : item.load
+                        }
+                    } );
+                } );
+                return;
+            }
+
+            if ( tagName === "js" || tagName === "css" || tagName === "link" || tagName === "file" ) {
+                initDefault( tagName, element );
+            } else return;
+
+            if ( tagName === "js" || tagName === "css" || tagName === "link" ) {
+                for ( const attr in attrs ) {
+                    if ( !element.hasAttribute( attr ) ) element.setAttribute( attr, attrs[ attr ] );
+                }
+            }
+
+            const load = element.getAttribute( "load" );
+            element.removeAttribute( "load" );
+
+            if ( tagName === "file" ) {
+                const content = () => {
+                    const ep = element.getAttribute( "path" );
+                    if ( ep.length > 1 ) {
+                        if ( !bunFS.existsSync( ep ) ) throw `导入的文件不存在 [path:${ ep }]`;
+                        return bunFS.readFileSync( ep );
+                    }
+                    return "";
+                }
+                list.push( {
+                    o : {
+                        element : content(),
+                        load : load
+                    }
+                } );
+            } else {
+                list.push( {
+                    o : {
+                        element : generateTag( dir, tagName, element.attrs ),
+                        load : load
+                    }
+                } );
+            }
+        } );
+
+    }
+
+    itGroup( $import );
+
+    return list;
+}
+
+function examine_AppConfig( build_config ) {
+    const fp = path.normalize( app.project.dir + build_config.config.src + "/app.xml" );
+    printf.outFile.info( `预处理 app.xml 配置文件 [path:${ fp }]` );
+
+    if ( !bunFS.existsSync( fp ) ) {
+        throw `源码目录不存在 app.xml`;
+    }
+    const content = bunFS.readFileSync( fp );
+    if ( content.length === 0 ) {
+        throw `app.xml 内容是空的`;
+    }
+
+    // 检查 app.xml
+    const $app = parse( content );
+    if ( $app.childNodes.length === 0 ) throw "app.xml 是空的";
+
+    return {
+        title : $app.querySelector( "app>title" ) ? $app.querySelector( "app>title" ).text : "magic",
+        lang : $app.attrs.lang || "zh",
+        icon : $app.attrs.icon || false,
+        initScript : $app.querySelector( "app>init-script" ) ? $app.querySelector( "app>init-script" ).text.trim() : null,
+        import : examine_AppConfig_parserImport( $app.querySelector( "app>import" ), app.project.dir + build_config.config.src )
+    }
+}
+
+export function _1( root ) {
+    const config = examine_BuildConfig( root );
+    if ( config ) {
+        printf.outFile.info( `Build 配置 :`, JSON.stringify( config ) );
+        if ( config.build.platform.target === "module" ) {
+            _2( config );
+        } else {
+            _2( config, macroReplace( examine_AppConfig( config ) ) );
+        }
+    }
+}

package/script/module/compiler/step/2.js

@@ -0,0 +1,79 @@
+import path from "node:path";
+import { app } from "../../../../app.js";
+import { printf } from "../../../global/printf.js";
+import { fileUtil } from "../../../util/file-util.js";
+import { filtrationFile } from "../../../util/filtration-file.js";
+import { project } from "../global.js";
+import { _3 } from "./3.js";
+import { bunFS, computeHash } from "../../../util/bun-fs.js";
+
+class source {
+    #relativePath;
+    #absolutePath;
+    #buildPath;
+    #contentHash;
+
+    constructor( file, ext, contentHash = null ) {
+        this.ext = ext;
+        this.#relativePath = path.normalize( file );
+        this.#absolutePath = path.normalize( app.project.dir + project.build_config.config.src + '/' + file );
+        this.#buildPath = path.normalize( app.project.dir + project.build_config.build.out + '/' + file );
+        this.#contentHash = contentHash;
+    }
+
+    build() {
+        return this.#buildPath;
+    }
+
+    relative() {
+        return this.#relativePath;
+    }
+
+    absolute() {
+        return this.#absolutePath;
+    }
+
+    get contentHash() {
+        return this.#contentHash;
+    }
+}
+
+export function _2( build_config, app_config ) {
+    printf.outFile.info( `处理源文件` );
+    const rootDir = app.project.dir + build_config.config.src;
+
+    build_config.build.exclude.file.push( "app.xml" );
+    build_config.build.exclude.dir.push( "magic" );
+
+    const files = filtrationFile(
+        rootDir,
+        build_config.build.exclude
+    );
+
+    project[ "build_config" ] = build_config;
+    project[ "app_config" ] = app_config;
+    project[ "source_file" ] = ( () => {
+        const obj = {};
+        files.forEach( file => {
+            const ext = fileUtil.getExtensionName( file );
+            if ( !obj[ ext ] ) obj[ ext ] = [];
+            const hash = computeHash( bunFS.readFileSync( path.normalize( rootDir + '/' + file ) ) );
+            obj[ ext ].push( new source( file, ext, hash ) );
+        } );
+        return {
+            ...obj,
+            "*it" : () => {
+                const result = [];
+                for ( const key in obj ) {
+                    result.push( ...obj[ key ] );
+                }
+                return result;
+            }
+        };
+    } )();
+    project[ "outDir" ] = path.normalize( app.project.dir + project.build_config.build.out + '/' );
+    project[ "outDirMagic" ] = path.normalize( project[ "outDir" ] + "magic/" );
+    project[ "srcDir" ] = path.normalize( app.project.dir + project.build_config.config.src + '/' );
+
+    _3();
+}

package/script/module/compiler/step/3.js

@@ -0,0 +1,37 @@
+import path from "node:path";
+import { app } from "../../../../app.js";
+import { printf } from "../../../global/printf.js";
+import { project } from "../global.js";
+import { _4 } from "./4.js";
+import { bunFS } from "../../../util/bun-fs.js";
+
+export function _3() {
+    printf.outFile.info( `初始化构建项目` );
+
+    const outDir = project.outDir;
+    const outDirMagic = project.outDirMagic;
+    const isModule = project.build_config.build.platform.target === "module";
+
+    try {
+        bunFS.rmSync( outDir, {
+            recursive : true,
+            force : true
+        } );
+    } catch {}
+
+    if ( !bunFS.existsSync( outDir ) ) {
+        bunFS.mkdirSync( outDir, { recursive : true } );
+    }
+
+    if ( isModule ) {
+        project.outDirMagic = outDir;
+    } else {
+        if ( !bunFS.existsSync( outDirMagic ) ) {
+            bunFS.mkdirSync( outDirMagic, { recursive : true } );
+        }
+
+        bunFS.writeFileSync( `${ outDirMagic }/runtime.js`, `window[ "magic_version" ] = "${ app.version }";\n` + app.templateDir.runtime.get( "runtime.js" ) );
+        bunFS.writeFileSync( `${ outDirMagic }/runtime.css`, app.templateDir.runtime.get( "runtime.css" ) );
+    }
+    _4();
+}

package/script/module/compiler/step/4.js

@@ -0,0 +1,20 @@
+import { printf } from "../../../global/printf.js";
+import { project } from "../global.js";
+import { _5 } from "./5.js";
+import { bunFS } from "../../../util/bun-fs.js";
+
+export function _4() {
+    printf.outFile.info( `操作源文件` );
+
+    const m = [];
+
+    project.source_file[ "*it" ]().forEach( s => {
+        if ( s.ext === "m" ) {
+            m.push( s );
+        } else {
+            bunFS.cpSync( s.absolute(), s.build(), { recursive : true } );
+        }
+    } );
+
+    _5( m );
+}