xhs-mp-compiler-cli 1.0.2-beta.0 → 1.0.2

package/dist/webpack-config/loaders/sjs-loader/index.js

@@ -0,0 +1,609 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SJS_HELPER = void 0;
+const lodash_1 = require("lodash");
+const tranform_1 = require("./tranform");
+const scope_1 = require("./scope");
+exports.SJS_HELPER = '_sjs$';
+const SETTER = `${exports.SJS_HELPER}.s`;
+const GETTER = `${exports.SJS_HELPER}.g`;
+const CALLER = `${exports.SJS_HELPER}.c`;
+function sjsCompiler(code, onRequire) {
+    var _a;
+    const errors = [];
+    const offset = 1;
+    // scan 阶段只是对整个树的遍历，会对作用域进行收集，禁止修改语法树
+    // generate 阶段会生成 helper形式代码
+    // legacyGenerate 阶段 只生成一份修改 .constructor 访问的代码
+    let mode = 'scan';
+    // 普通变量作用域管理
+    const scopeManager = new scope_1.ScopeManager();
+    // require语句
+    const requireCallee = [];
+    // 找到对应行
+    function emitCompilerError(msg, span) {
+        if (mode !== 'scan')
+            return;
+        const message = msg.trim().split(/\s+/).length > 1 ? msg : `${msg} is disallowed`;
+        errors.push({ message, span: Object.assign({}, span) });
+    }
+    function handlePattern(pattern) {
+        // console.log(pattern.type, pattern)
+        switch (pattern.type) {
+            case "RestElement":
+                // function f(...a) {}
+                handlePattern(pattern.argument);
+                if (pattern.argument.type === "Identifier") {
+                    scopeManager.pushIdentifier(pattern.argument);
+                }
+                break;
+            case "AssignmentPattern":
+                // 默认值语法 function f(a = 1) {}
+                handleExpression(pattern.right);
+                if (pattern.left.type === "Identifier") {
+                    scopeManager.pushIdentifier(pattern.left);
+                }
+                break;
+            case 'Identifier':
+                // function f(a) {}
+                scopeManager.pushIdentifier(pattern);
+                break;
+            case "MemberExpression":
+                handleExpression(pattern);
+                break;
+            case "ArrayPattern":
+                emitCompilerError("Destructuring assignment like const [a, b] = array; is disallowed ", pattern.span);
+                break;
+            case "ObjectPattern":
+                emitCompilerError("Destructuring assignment like const {a, b} = obj; is disallowed ", pattern.span);
+                break;
+            default:
+                // @ts-ignore
+                emitCompilerError(pattern.type, pattern.span);
+                break;
+        }
+    }
+    function handleParam(p) {
+        var _a;
+        // 参数不支持装饰器
+        if ((_a = p === null || p === void 0 ? void 0 : p.decorators) === null || _a === void 0 ? void 0 : _a.length) {
+            emitCompilerError(p.type, p.span);
+        }
+        if (p.pat) {
+            handlePattern(p.pat);
+        }
+    }
+    function handleStatement(e) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        switch (e.type) {
+            case "BlockStatement":
+                scopeManager.enterScope();
+                (_a = e.stmts) === null || _a === void 0 ? void 0 : _a.forEach(handleStatement);
+                scopeManager.exitScope();
+                break;
+            case "TryStatement":
+                if (e.block) {
+                    handleStatement(e.block);
+                }
+                // catch 部分是有参数的
+                scopeManager.enterScope();
+                if ((_b = e.handler) === null || _b === void 0 ? void 0 : _b.param) {
+                    handlePattern((_c = e.handler) === null || _c === void 0 ? void 0 : _c.param);
+                }
+                if (((_e = (_d = e.handler) === null || _d === void 0 ? void 0 : _d.body) === null || _e === void 0 ? void 0 : _e.type) === "BlockStatement") {
+                    (_g = (_f = e.handler) === null || _f === void 0 ? void 0 : _f.body) === null || _g === void 0 ? void 0 : _g.stmts.forEach(handleStatement);
+                }
+                scopeManager.exitScope();
+                if (e.finalizer) {
+                    handleStatement(e.finalizer);
+                }
+                break;
+            case "ForStatement":
+                scopeManager.enterScope();
+                if (e.init) {
+                    switch (e.init.type) {
+                        case "VariableDeclaration":
+                            handleStatement(e.init);
+                            break;
+                        default:
+                            handleExpression(e.init);
+                            break;
+                    }
+                }
+                if (e.test) {
+                    handleExpression(e.test);
+                }
+                if (e.update) {
+                    handleExpression(e.update);
+                }
+                if (e.body.type === "BlockStatement") {
+                    (_h = e.body.stmts) === null || _h === void 0 ? void 0 : _h.forEach(handleStatement);
+                }
+                else {
+                    handleStatement(e.body);
+                }
+                scopeManager.exitScope();
+                break;
+            case "SwitchStatement":
+                // 处理switch条件
+                handleExpression(e.discriminant);
+                // 处理case条件
+                (_j = e.cases) === null || _j === void 0 ? void 0 : _j.forEach((case_) => {
+                    var _a;
+                    if (case_.test) {
+                        handleExpression(case_.test);
+                    }
+                    (_a = case_.consequent) === null || _a === void 0 ? void 0 : _a.forEach(handleStatement);
+                });
+                break;
+            case "DoWhileStatement":
+            case "WhileStatement":
+                handleExpression(e.test);
+                handleStatement(e.body);
+                break;
+            case "IfStatement":
+                handleExpression(e.test);
+                handleStatement(e.consequent);
+                if (e.alternate) {
+                    handleStatement(e.alternate);
+                }
+                break;
+            case "ExpressionStatement":
+                handleExpression(e.expression);
+                break;
+            case "FunctionDeclaration":
+                checkFunction(e);
+                scopeManager.pushIdentifier(e.identifier);
+                scopeManager.enterScope();
+                e.params.forEach(handleParam);
+                if (((_k = e === null || e === void 0 ? void 0 : e.body) === null || _k === void 0 ? void 0 : _k.type) === "BlockStatement") {
+                    (_l = e.body.stmts) === null || _l === void 0 ? void 0 : _l.forEach(handleStatement);
+                }
+                scopeManager.exitScope();
+                break;
+            case "ReturnStatement":
+                if (e.argument) {
+                    handleExpression(e.argument);
+                }
+                break;
+            case "VariableDeclaration":
+                for (const declaration of e.declarations) {
+                    switch (declaration.id.type) {
+                        case "Identifier":
+                            scopeManager.pushIdentifier(declaration.id);
+                            break;
+                        default:
+                            // @ts-ignore
+                            emitCompilerError(declaration.id.type, declaration.id.span);
+                            break;
+                    }
+                    if (declaration.init) {
+                        handleExpression(declaration.init);
+                    }
+                }
+                break;
+            case "BreakStatement":
+            case "DebuggerStatement":
+            case "ContinueStatement":
+            case "EmptyStatement":
+                break;
+            default:
+                emitCompilerError(e.type, e.span);
+                break;
+        }
+    }
+    function handleProperty(p) {
+        switch (p.type) {
+            case "Computed":
+                {
+                    const expression = p.expression;
+                    handleExpression(expression);
+                }
+                break;
+            case "Identifier":
+                break;
+            default:
+                emitCompilerError(p.type, p.span);
+                break;
+        }
+    }
+    function handleObjectPropertyName(key) {
+        switch (key.type) {
+            case "Computed":
+                {
+                    const expression = key.expression;
+                    handleExpression(expression);
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    function handleObjectProperty(i) {
+        var _a, _b, _c;
+        switch (i.type) {
+            case "KeyValueProperty":
+                handleObjectPropertyName(i.key);
+                handleExpression(i.value);
+                break;
+            case "GetterProperty":
+                handleObjectPropertyName(i.key);
+                scopeManager.enterScope();
+                if (((_a = i.body) === null || _a === void 0 ? void 0 : _a.type) === "BlockStatement") {
+                    i.body.stmts.forEach(handleStatement);
+                }
+                scopeManager.exitScope();
+                break;
+            case "SetterProperty":
+                handleObjectPropertyName(i.key);
+                scopeManager.enterScope();
+                handlePattern(i.param);
+                if (((_b = i.body) === null || _b === void 0 ? void 0 : _b.type) === "BlockStatement") {
+                    i.body.stmts.forEach(handleStatement);
+                }
+                scopeManager.exitScope();
+                break;
+            case "Identifier":
+                scopeManager.pushAccess(i);
+                fixSpecialVarWhenGenerate(i);
+                break;
+            case "MethodProperty":
+                handleObjectPropertyName(i.key);
+                checkFunction(i);
+                scopeManager.enterScope();
+                i.params.forEach(handleParam);
+                if (((_c = i.body) === null || _c === void 0 ? void 0 : _c.type) === "BlockStatement") {
+                    i.body.stmts.forEach(handleStatement);
+                }
+                scopeManager.exitScope();
+                break;
+            case "SpreadElement":
+                handleExpression(i.arguments);
+                break;
+            default:
+                // @ts-ignore
+                emitCompilerError(i.type, i.span);
+                break;
+        }
+    }
+    function modifyProperty(p) {
+        if (p.type === "Computed") {
+            handleExpression(p.expression);
+            return p.expression;
+        }
+        if (p.type === "Identifier") {
+            return {
+                type: 'StringLiteral',
+                span: p.span,
+                value: p.value,
+                raw: JSON.stringify(p.value)
+            };
+        }
+        if (p.type === "PrivateName") {
+            return { type: 'NullLiteral' };
+        }
+    }
+    function checkFunction(e) {
+        // 不允许使用 async 或者 generator 语法
+        if (e.async || e.generator) {
+            emitCompilerError(e.type, e.span);
+        }
+    }
+    function collectRequireWhenScan(c) {
+        if (mode !== 'scan') {
+            return;
+        }
+        requireCallee.push(c);
+        // 标记作用域
+        if (c.callee.type === 'Identifier') {
+            c.callee._xhsScope = scopeManager.getCurrentScope();
+        }
+    }
+    function fixSpecialVarWhenGenerate(id) {
+        var _a;
+        if (mode !== 'generate') {
+            return;
+        }
+        // 发现调用全局特殊变量
+        if (scope_1.SPECIFY_VAR.includes(id.value) && ((_a = id._xhsScope) === null || _a === void 0 ? void 0 : _a.checkGlobal(id.value))) {
+            //  生成阶段判断是否是调用全局环境
+            id.value = `${exports.SJS_HELPER}.${id.value}`;
+        }
+    }
+    function handleExpression(e) {
+        var _a, _b, _c, _d, _e;
+        switch (e.type) {
+            case "FunctionExpression":
+                checkFunction(e);
+                if (e.identifier) {
+                    scopeManager.pushIdentifier(e.identifier);
+                }
+                scopeManager.enterScope();
+                e.params.forEach(handleParam);
+                if (((_a = e.body) === null || _a === void 0 ? void 0 : _a.type) === "BlockStatement") {
+                    (_b = e.body.stmts) === null || _b === void 0 ? void 0 : _b.forEach(handleStatement);
+                }
+                scopeManager.exitScope();
+                break;
+            case "ArrowFunctionExpression":
+                checkFunction(e);
+                scopeManager.enterScope();
+                e.params.forEach(handlePattern);
+                if (e.body.type === "BlockStatement") {
+                    (_c = e.body.stmts) === null || _c === void 0 ? void 0 : _c.forEach(handleStatement);
+                }
+                else {
+                    handleExpression(e.body);
+                }
+                scopeManager.exitScope();
+                break;
+            case "CallExpression":
+                switch (e.callee.type) {
+                    case "Import":
+                    case "Super":
+                        emitCompilerError(e.callee.type, e.span);
+                        break;
+                    default:
+                        if (e.callee.type === "MemberExpression" && mode === 'generate') {
+                            const oldCallee = e.callee;
+                            const NewCallExpression = e;
+                            NewCallExpression.type = "CallExpression";
+                            NewCallExpression.callee = {
+                                type: 'Identifier',
+                                span: e.span,
+                                value: CALLER,
+                                optional: false
+                            };
+                            handleExpression(oldCallee.object);
+                            e.arguments.forEach(i => handleExpression(i.expression));
+                            NewCallExpression.arguments = [
+                                { expression: modifyProperty(oldCallee.property) },
+                                { expression: oldCallee.object },
+                                {
+                                    expression: {
+                                        type: "ArrayExpression",
+                                        elements: e.arguments,
+                                        span: e.span
+                                    }
+                                },
+                            ];
+                        }
+                        else if (e.callee.type === "MemberExpression"
+                            && mode === 'legacyGenerate'
+                            && e.callee.property.type === "Identifier"
+                            && e.callee.property.value === "constructor") {
+                            e.callee.property.value = `${e.callee.property.value}.name`;
+                            handleExpression(e.callee.object);
+                            e.arguments.forEach(i => handleExpression(i.expression));
+                        }
+                        else {
+                            if (e.callee.type === "Identifier") {
+                                if (e.callee.value === "require") {
+                                    collectRequireWhenScan(e);
+                                }
+                                // 需要后置处理，否则callee.value会被修改
+                                fixSpecialVarWhenGenerate(e.callee);
+                            }
+                            handleExpression(e.callee);
+                            e.arguments.forEach(i => handleExpression(i.expression));
+                        }
+                        break;
+                }
+                break;
+            case "ArrayExpression":
+                (_d = e.elements) === null || _d === void 0 ? void 0 : _d.forEach(i => {
+                    if (i) {
+                        handleExpression(i.expression);
+                    }
+                });
+                break;
+            case "ObjectExpression":
+                e.properties.forEach(handleObjectProperty);
+                break;
+            case "TemplateLiteral":
+                // 当中会有表达式
+                e.expressions.forEach(handleExpression);
+                break;
+            case "UpdateExpression":
+                if (e.argument.type === "MemberExpression" && mode === 'generate') {
+                    const NewUpdateExpression = e;
+                    NewUpdateExpression.type = "CallExpression";
+                    NewUpdateExpression.callee = {
+                        type: 'Identifier',
+                        span: e.span,
+                        value: SETTER,
+                        optional: false
+                    };
+                    handleExpression(e.argument.object);
+                    NewUpdateExpression.arguments = [
+                        { expression: modifyProperty(e.argument.property) },
+                        { expression: e.argument.object },
+                        {
+                            expression: {
+                                type: 'StringLiteral',
+                                span: e.span,
+                                value: e.operator,
+                                raw: JSON.stringify(e.operator)
+                            }
+                        },
+                    ];
+                    Reflect.deleteProperty(e, 'prefix');
+                    Reflect.deleteProperty(e, 'operator');
+                    Reflect.deleteProperty(e, 'argument');
+                }
+                else {
+                    handleExpression(e.argument);
+                }
+                break;
+            case "UnaryExpression":
+                handleExpression(e.argument);
+                break;
+            case "AssignmentExpression":
+                if (e.left.type === 'MemberExpression' && mode === 'generate') {
+                    const NewAssignmentExpression = e;
+                    NewAssignmentExpression.type = "CallExpression";
+                    NewAssignmentExpression.callee = {
+                        type: 'Identifier',
+                        span: e.span,
+                        value: SETTER,
+                        optional: false
+                    };
+                    handleExpression(e.right);
+                    handleExpression(e.left.object);
+                    NewAssignmentExpression.arguments = [
+                        { expression: modifyProperty(e.left.property) },
+                        { expression: e.left.object },
+                        {
+                            expression: {
+                                type: 'StringLiteral',
+                                span: e.span,
+                                value: e.operator,
+                                raw: JSON.stringify(e.operator)
+                            }
+                        },
+                        { expression: e.right }
+                    ];
+                    Reflect.deleteProperty(e, 'left');
+                    Reflect.deleteProperty(e, 'right');
+                    Reflect.deleteProperty(e, 'operator');
+                }
+                else {
+                    handlePattern(e.left);
+                    handleExpression(e.right);
+                }
+                break;
+            case "BinaryExpression":
+                handleExpression(e.left);
+                handleExpression(e.right);
+                break;
+            case "ConditionalExpression":
+                handleExpression(e.test);
+                handleExpression(e.consequent);
+                handleExpression(e.alternate);
+                break;
+            case "MemberExpression":
+                if (mode === 'generate') {
+                    const NewMemberExpression = e;
+                    NewMemberExpression.type = "CallExpression";
+                    NewMemberExpression.callee = {
+                        type: 'Identifier',
+                        span: e.span,
+                        value: GETTER,
+                        optional: false
+                    };
+                    handleExpression(e.object);
+                    NewMemberExpression.arguments = [
+                        { expression: modifyProperty(e.property) },
+                        { expression: e.object }
+                    ];
+                    // 清除语法树
+                    Reflect.deleteProperty(e, 'object');
+                    Reflect.deleteProperty(e, 'property');
+                }
+                else if (mode === 'legacyGenerate' && e.property.type === "Identifier" && e.property.value === "constructor") {
+                    e.property.value = `${e.property.value}.name`;
+                    handleExpression(e.object);
+                }
+                else {
+                    // 只遍历
+                    handleExpression(e.object);
+                    handleProperty(e.property);
+                }
+                break;
+            case "ParenthesisExpression":
+                handleExpression(e.expression);
+                break;
+            case "SequenceExpression":
+                (_e = e.expressions) === null || _e === void 0 ? void 0 : _e.forEach(handleExpression);
+                break;
+            case "Identifier":
+                scopeManager.pushAccess(e);
+                fixSpecialVarWhenGenerate(e);
+                break;
+            // 以下都是字面量无需处理
+            case "BigIntLiteral":
+            case "NullLiteral":
+            case "StringLiteral":
+            case "BooleanLiteral":
+            case "NumericLiteral":
+            case "ThisExpression":
+            case "RegExpLiteral":
+                break;
+            default:
+                // @ts-ignore
+                emitCompilerError(e.type, e.span);
+                break;
+        }
+    }
+    function getSourceCode(span) {
+        return code.slice(span.start - offset, span.end - offset);
+    }
+    let legacyModule;
+    const result = (0, tranform_1.transform)(code, (module) => {
+        // 1. 校验基本语法错误，收集变量作用域，构建作用域表
+        mode = "scan";
+        scopeManager.enterScope();
+        module.body.forEach(handleStatement);
+        scopeManager.exitScope();
+        scopeManager.stop();
+        // 2. 分析作用域表 找出不是sjs 标准的模块进行屏蔽
+        // 2.2 从最小作用域向上分析
+        const validResult = scopeManager.getDFSScope().map(i => i.anlysis()).filter(Boolean);
+        validResult.forEach(i => {
+            if (i) {
+                emitCompilerError(`identifier(${i.variable}) is undefined`, i.span);
+            }
+        });
+        // 2.1 require语句校验以及处理path
+        requireCallee.forEach(i => {
+            var _a, _b, _c;
+            // 调用全局环境 require
+            if (i.callee.type === "Identifier" && ((_a = i.callee._xhsScope) === null || _a === void 0 ? void 0 : _a.checkGlobal(i.callee.value))) {
+                const requirePath = (_c = (_b = i.arguments) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.expression;
+                if (requirePath && (requirePath === null || requirePath === void 0 ? void 0 : requirePath.type) === 'StringLiteral' && (requirePath === null || requirePath === void 0 ? void 0 : requirePath.value)) {
+                    try {
+                        const formatPath = onRequire === null || onRequire === void 0 ? void 0 : onRequire(requirePath === null || requirePath === void 0 ? void 0 : requirePath.value);
+                        requirePath.value = formatPath;
+                        requirePath.raw = JSON.stringify(formatPath);
+                    }
+                    catch (error) {
+                        // 校验path 地址是否正确不正确进行报错
+                        emitCompilerError(error.message, i.span);
+                    }
+                }
+                else {
+                    emitCompilerError('require() must provide static path, dynamic or empty path is disallowed', i.span);
+                }
+            }
+        });
+        // 3. 抛出前面检查出来的错误
+        if (errors.length) {
+            module.body = [];
+            return module;
+        }
+        // 上面的没出错，拷贝一份语法树用于生成兼容代码
+        legacyModule = (0, lodash_1.cloneDeep)(module);
+        // 4. 修改语法树生成 set get call 语法
+        mode = "generate";
+        module.body.forEach(handleStatement);
+        return module;
+    });
+    mode = 'legacyGenerate';
+    // 生成老版本的兼容代码
+    const legacyCode = ((_a = legacyModule === null || legacyModule === void 0 ? void 0 : legacyModule.body) === null || _a === void 0 ? void 0 : _a.length)
+        ? (0, tranform_1.transform)('var magic;', () => {
+            legacyModule.body.forEach(handleStatement);
+            return legacyModule;
+        }, 'es2015', true).code
+        : '';
+    return {
+        code: result.code,
+        map: result.map,
+        legacyCode,
+        errors,
+    };
+}
+exports.default = sjsCompiler;
+// console.time('sjs',111)
+// const data = sjsCompiler(code, (s) => s)
+// console.timeEnd('sjs')

package/dist/webpack-config/loaders/sjs-loader/scope.d.ts

@@ -0,0 +1,36 @@
+import type { Span, Identifier } from '@swc/core';
+export declare const SPECIFY_VAR: string[];
+declare module "@swc/core" {
+    interface Identifier {
+        _xhsScope?: Scope;
+    }
+}
+export declare class Scope {
+    private parentScope;
+    private defines;
+    private access;
+    toString(): string;
+    /**
+     * @returns
+     */
+    anlysis(): {
+        variable: string;
+        span: Span;
+    } | undefined;
+    checkGlobal(key: string): boolean;
+    setAccess(key: string, value: Span): void;
+    setDefines(key: string, value: Span): void;
+    setParentScope(scope: Scope | undefined): void;
+}
+export declare class ScopeManager {
+    private _scopeStack;
+    private _scopeTables;
+    private _stop;
+    stop(): void;
+    enterScope(): void;
+    exitScope(): void;
+    getCurrentScope(): Scope | undefined;
+    pushIdentifier(id: Identifier): void;
+    pushAccess(id: Identifier): void;
+    getDFSScope(): Scope[];
+}