mbler 0.1.3-alpha → 0.1.3-alpha-r2

package/lib/mcx/compile-mcx/utils.node.js

@@ -1,207 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class NodeUtils {
-    static stringArrayToMemberExpression(stringArray) {
-        if (stringArray.length < 2) {
-            throw new Error('String array must contain at least 2 items');
-        }
-        let current = {
-            type: 'Identifier',
-            name: stringArray[0]
-        };
-        for (let i = 1; i < stringArray.length; i++) {
-            current = {
-                type: 'MemberExpression',
-                object: current,
-                property: {
-                    type: 'Identifier',
-                    name: stringArray[i]
-                },
-                computed: false
-            };
-        }
-        if (current.type !== 'MemberExpression') {
-            throw new Error('Internal error: expected MemberExpression');
-        }
-        return current;
-    }
-    static memberExpressionToStringArray(memberExpression, maxLength) {
-        const result = [];
-        let current = memberExpression;
-        while (current.type === 'MemberExpression' &&
-            result.length < maxLength) {
-            const prop = current.property;
-            if (!current.computed &&
-                prop.type === 'Identifier') {
-                result.unshift(prop.name);
-            }
-            current = current.object;
-        }
-        if (result.length >= maxLength) {
-            return result;
-        }
-        switch (current.type) {
-            case 'Identifier':
-                result.unshift(current.name);
-                break;
-            case 'ThisExpression':
-                result.unshift('this');
-                break;
-            case 'StringLiteral':
-            case 'NumericLiteral':
-            case 'BooleanLiteral':
-                result.unshift(String(current.value));
-                break;
-            case 'NullLiteral':
-                result.unshift('null');
-                break;
-        }
-        return result;
-    }
-    /**
-     * 计算表达式的值
-     * @param expression Babel AST 表达式节点
-     * @param currentContext 当前上下文变量
-     * @param topContext 顶层上下文变量
-     * @returns 计算结果 (string | number | symbol | object)
-     */
-    static evaluateExpression(expression, currentContext = {}, topContext = {}) {
-        const context = { ...topContext, ...currentContext };
-        const evaluate = (expr) => {
-            if (!expr)
-                return undefined;
-            switch (expr.type) {
-                case 'Identifier':
-                    if (!expr.name)
-                        return undefined;
-                    if (expr.name in context) {
-                        return evaluate(context[expr.name]);
-                    }
-                    if (expr.name === 'this') {
-                        return currentContext;
-                    }
-                    if (expr.name === 'global') {
-                        return topContext;
-                    }
-                    throw new Error(`Undefined variable: ${expr.name}`);
-                case 'StringLiteral':
-                    return expr.value;
-                case 'NumericLiteral':
-                    return expr.value;
-                case 'BooleanLiteral':
-                    return expr.value;
-                case 'NullLiteral':
-                    return null;
-                case 'MemberExpression':
-                    const objectValue = evaluate(expr.object);
-                    const property = expr.computed
-                        ? evaluate(expr.property)
-                        : expr.property.name;
-                    if (objectValue && typeof objectValue === 'object' && property in objectValue) {
-                        return objectValue[property];
-                    }
-                    throw new Error(`Cannot access property '${property}' of ${objectValue}`);
-                case 'ObjectExpression':
-                    const obj = {};
-                    for (const prop of expr.properties) {
-                        if (prop.type === 'ObjectProperty') {
-                            const key = prop.computed
-                                ? evaluate(prop.key)
-                                : prop.key.name;
-                            obj[key] = evaluate(prop.value);
-                        }
-                    }
-                    return obj;
-                case 'ArrayExpression':
-                    return expr.elements.map((element) => element && element.type !== 'SpreadElement'
-                        ? evaluate(element)
-                        : undefined);
-                case 'UnaryExpression':
-                    const argumentValue = evaluate(expr.argument);
-                    switch (expr.operator) {
-                        case '+': return +argumentValue;
-                        case '-': return -argumentValue;
-                        case '!': return !argumentValue;
-                        case '~': return ~argumentValue;
-                        case 'typeof': return typeof argumentValue;
-                        case 'void': return void argumentValue;
-                        default: throw new Error(`Unsupported unary operator: ${expr.operator}`);
-                    }
-                case "PrivateName":
-                    return evaluate(context[expr.id.name]);
-                case 'BinaryExpression':
-                    const leftValue = expr.left.type == evaluate(expr.left);
-                    const rightValue = evaluate(expr.right);
-                    const isNum = typeof leftValue == "number" && typeof rightValue == "number";
-                    switch (expr.operator) {
-                        case '+': return leftValue + rightValue;
-                        case '-': if (isNum) {
-                            return leftValue - rightValue;
-                        }
-                        else
-                            return 0;
-                        case '*': if (isNum) {
-                            return leftValue * rightValue;
-                        }
-                        else
-                            return 0;
-                        case '/': if (isNum) {
-                            return leftValue / rightValue;
-                        }
-                        else
-                            return 0;
-                        case '%': if (isNum) {
-                            return leftValue % rightValue;
-                        }
-                        else
-                            return 0;
-                        case '==': return leftValue == rightValue;
-                        case '!=': return leftValue != rightValue;
-                        case '===': return leftValue === rightValue;
-                        case '!==': return leftValue !== rightValue;
-                        case '<': return leftValue < rightValue;
-                        case '<=': return leftValue <= rightValue;
-                        case '>': return leftValue > rightValue;
-                        case '>=': return leftValue >= rightValue;
-                        case '|': return leftValue | rightValue;
-                        case '&': return leftValue & rightValue;
-                        case '^': return leftValue ^ rightValue;
-                        case '<<': return leftValue << rightValue;
-                        case '>>': return leftValue >> rightValue;
-                        case '>>>': return leftValue >>> rightValue;
-                        default: throw new Error(`Unsupported binary operator: ${expr.operator}`);
-                    }
-                case 'LogicalExpression':
-                    const left = evaluate(expr.left);
-                    switch (expr.operator) {
-                        case '&&': return left && evaluate(expr.right);
-                        case '||': return left || evaluate(expr.right);
-                        case '??': return left ?? evaluate(expr.right);
-                        default: throw new Error(`Unsupported logical operator: ${expr.operator}`);
-                    }
-                case 'ConditionalExpression':
-                    return evaluate(expr.test)
-                        ? evaluate(expr.consequent)
-                        : evaluate(expr.alternate);
-                case 'CallExpression':
-                    const callee = evaluate(expr.callee);
-                    if (typeof callee !== 'function') {
-                        throw new Error(`Cannot call non-function: ${callee}`);
-                    }
-                    const args = expr.arguments.map((arg) => arg.type === 'SpreadElement'
-                        ? evaluate(arg.argument)
-                        : evaluate(arg));
-                    return callee.apply(null, args);
-                default:
-                    throw new Error(`Unsupported expression type: ${expr.type}`);
-            }
-        };
-        try {
-            return evaluate(expression);
-        }
-        catch (error) {
-            throw new Error(`Expression evaluation failed: ${error.message}`);
-        }
-    }
-}
-exports.default = NodeUtils;
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});class NodeUtils{static stringArrayToMemberExpression(e){if(e.length<2)throw new Error("String array must contain at least 2 items");let r={type:"Identifier",name:e[0]};for(let t=1;t<e.length;t++)r={type:"MemberExpression",object:r,property:{type:"Identifier",name:e[t]},computed:!1};if("MemberExpression"!==r.type)throw new Error("Internal error: expected MemberExpression");return r}static memberExpressionToStringArray(e,r){const t=[];let n=e;for(;"MemberExpression"===n.type&&t.length<r;){const e=n.property;n.computed||"Identifier"!==e.type||t.unshift(e.name),n=n.object}if(t.length>=r)return t;switch(n.type){case"Identifier":t.unshift(n.name);break;case"ThisExpression":t.unshift("this");break;case"StringLiteral":case"NumericLiteral":case"BooleanLiteral":t.unshift(String(n.value));break;case"NullLiteral":t.unshift("null")}return t}static evaluateExpression(e,r={},t={}){const n={...t,...r},a=e=>{if(e)switch(e.type){case"Identifier":if(!e.name)return;if(e.name in n)return a(n[e.name]);if("this"===e.name)return r;if("global"===e.name)return t;throw new Error(`Undefined variable: ${e.name}`);case"StringLiteral":case"NumericLiteral":case"BooleanLiteral":return e.value;case"NullLiteral":return null;case"MemberExpression":const s=a(e.object),o=e.computed?a(e.property):e.property.name;if(s&&"object"==typeof s&&o in s)return s[o];throw new Error(`Cannot access property '${o}' of ${s}`);case"ObjectExpression":const i={};for(const r of e.properties)if("ObjectProperty"===r.type){i[r.computed?a(r.key):r.key.name]=a(r.value)}return i;case"ArrayExpression":return e.elements.map(e=>e&&"SpreadElement"!==e.type?a(e):void 0);case"UnaryExpression":const c=a(e.argument);switch(e.operator){case"+":return+c;case"-":return-c;case"!":return!c;case"~":return~c;case"typeof":return typeof c;case"void":return;default:throw new Error(`Unsupported unary operator: ${e.operator}`)}case"PrivateName":return a(n[e.id.name]);case"BinaryExpression":const u=e.left.type==a(e.left),p=a(e.right),l="number"==typeof u&&"number"==typeof p;switch(e.operator){case"+":return u+p;case"-":return l?u-p:0;case"*":return l?u*p:0;case"/":return l?u/p:0;case"%":return l?u%p:0;case"==":return u==p;case"!=":return u!=p;case"===":return u===p;case"!==":return u!==p;case"<":return u<p;case"<=":return u<=p;case">":return u>p;case">=":return u>=p;case"|":return u|p;case"&":return u&p;case"^":return u^p;case"<<":return u<<p;case">>":return u>>p;case">>>":return u>>>p;default:throw new Error(`Unsupported binary operator: ${e.operator}`)}case"LogicalExpression":const f=a(e.left);switch(e.operator){case"&&":return f&&a(e.right);case"||":return f||a(e.right);case"??":return f??a(e.right);default:throw new Error(`Unsupported logical operator: ${e.operator}`)}case"ConditionalExpression":return a(e.test)?a(e.consequent):a(e.alternate);case"CallExpression":const m=a(e.callee);if("function"!=typeof m)throw new Error(`Cannot call non-function: ${m}`);const y=e.arguments.map(e=>"SpreadElement"===e.type?a(e.argument):a(e));return m.apply(null,y);default:throw new Error(`Unsupported expression type: ${e.type}`)}};try{return a(e)}catch(e){throw new Error(`Expression evaluation failed: ${e.message}`)}}}exports.default=NodeUtils;

package/lib/mcx/index.js

@@ -1,13 +1 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = __importDefault(require("./ast/index.js"));
-const index_js_2 = __importDefault(require("./compile-mcx/index.js"));
-const utils_js_1 = __importDefault(require("./utils.js"));
-exports.default = {
-    load: index_js_2.default,
-    AST: index_js_1.default,
-    utils: utils_js_1.default,
-};
+"use strict";var __importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0});const index_js_1=__importDefault(require("./ast/index.js")),index_js_2=__importDefault(require("./compile-mcx/index.js")),utils_js_1=__importDefault(require("./utils.js"));exports.default={load:index_js_2.default,AST:index_js_1.default,utils:utils_js_1.default};

package/lib/mcx/test/index.js

@@ -1,7 +1 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const app_mcx_1 = __importDefault(require("./app.mcx"));
-app_mcx_1.default.start();
+"use strict";var __importDefault=this&&this.__importDefault||function(t){return t&&t.__esModule?t:{default:t}};Object.defineProperty(exports,"__esModule",{value:!0});const app_mcx_1=__importDefault(require("./app.mcx"));app_mcx_1.default.start();

package/lib/mcx/test.js

@@ -1,21 +1 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = test;
-const _1 = __importDefault(require("."));
-const node_path_1 = __importDefault(require("node:path"));
-async function test() {
-    const testPath = node_path_1.default.join(__dirname, "./tezt");
-    await _1.default.load({
-        ProjectDir: testPath,
-        cacheDir: node_path_1.default.join(testPath, ".cache"),
-        isCache: true,
-        moduleDir: node_path_1.default.join(testPath, "node_modules"),
-        output: node_path_1.default.join(testPath, "dist"),
-        moduleList: [],
-        config: {},
-        main: "./main.js"
-    });
-}
+"use strict";var __importDefault=this&&this.__importDefault||function(e){return e&&e.__esModule?e:{default:e}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.default=test;const _1=__importDefault(require(".")),node_path_1=__importDefault(require("node:path"));async function test(){const e=node_path_1.default.join(__dirname,"./tezt");await _1.default.load({ProjectDir:e,cacheDir:node_path_1.default.join(e,".cache"),isCache:!0,moduleDir:node_path_1.default.join(e,"node_modules"),output:node_path_1.default.join(e,"dist"),moduleList:[],config:{},main:"./main.js"})}

package/lib/mcx/types.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});

package/lib/mcx/utils.js

@@ -1,86 +1 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const promises_1 = __importDefault(require("node:fs/promises"));
-const node_path_1 = __importDefault(require("node:path"));
-class McxUtlis {
-    /**
-     * 检查文件是否存在
-     * @param path 文件路径
-     * @returns 是否存在
-     */
-    static async FileExsit(path) {
-        try {
-            await promises_1.default.access(path);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * 读取文件内容，支持返回 string 或 object，带重试机制
-     * @param filePath 文件路径
-     * @param opt 配置选项
-     * @returns 文件内容（string | object），出错时返回 {}
-     */
-    static async readFile(filePath, opt = {}) {
-        // 补全必填字段，确保类型安全
-        const opts = {
-            delay: 200, // 默认延迟
-            maxRetries: 3, // 默认最大重试次数
-            want: 'string', // 默认返回字符串
-            ...opt, // 用户传入的配置覆盖默认值
-        };
-        for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
-            try {
-                const buffer = await promises_1.default.readFile(filePath);
-                let text;
-                if (opts.want === 'string') {
-                    text = buffer.toString(); // Buffer -> string
-                }
-                else if (opts.want === 'object') {
-                    try {
-                        text = JSON.parse(buffer.toString()); // Buffer -> string -> object
-                    }
-                    catch (parseErr) {
-                        // JSON 解析失败时返回空对象
-                        text = {};
-                    }
-                }
-                else {
-                    // 默认情况也返回字符串
-                    text = buffer.toString();
-                }
-                return text;
-            }
-            catch (err) {
-                // 如果不是最后一次尝试，则等待后重试
-                if (attempt < opts.maxRetries - 1) {
-                    await McxUtlis.sleep(opts.delay);
-                }
-            }
-        }
-        return opts.want === 'object' ? {} : '';
-    }
-    static sleep(time) {
-        return new Promise((resolve) => setTimeout(resolve, time));
-    }
-    // 在运行时进行对象类型验证
-    static TypeVerify(obj, types) {
-        for (const item of Object.entries(types)) {
-            const [key, ShouldType] = item;
-            if (!(typeof obj[key] === ShouldType))
-                return false;
-        }
-        return true;
-    }
-    static AbsoluteJoin(baseDir, inputPath) {
-        return node_path_1.default.isAbsolute(inputPath) ?
-            inputPath :
-            node_path_1.default.join(baseDir, inputPath);
-    }
-}
-exports.default = McxUtlis;
+"use strict";var __importDefault=this&&this.__importDefault||function(t){return t&&t.__esModule?t:{default:t}};Object.defineProperty(exports,"__esModule",{value:!0});const promises_1=__importDefault(require("node:fs/promises")),node_path_1=__importDefault(require("node:path"));class McxUtlis{static async FileExsit(t){try{return await promises_1.default.access(t),!0}catch{return!1}}static async readFile(t,e={}){const r={delay:200,maxRetries:3,want:"string",...e};for(let e=0;e<r.maxRetries;e++)try{const e=await promises_1.default.readFile(t);let s;if("string"===r.want)s=e.toString();else if("object"===r.want)try{s=JSON.parse(e.toString())}catch(t){s={}}else s=e.toString();return s}catch(t){e<r.maxRetries-1&&await McxUtlis.sleep(r.delay)}return"object"===r.want?{}:""}static sleep(t){return new Promise(e=>setTimeout(e,t))}static TypeVerify(t,e){for(const r of Object.entries(e)){const[e,s]=r;if(typeof t[e]!==s)return!1}return!0}static AbsoluteJoin(t,e){return node_path_1.default.isAbsolute(e)?e:node_path_1.default.join(t,e)}}exports.default=McxUtlis;