@vyr/pack-class-wrapper-plugin 0.0.4

package/index.js

@@ -0,0 +1,42 @@
+const { join, resolve } = require("path")
+
+class ClassWrapperPlugin {
+
+  constructor(rules = []) {
+    const handlers = [
+      { path: join(__dirname, '../../packages/universal/engine'), className: 'ObjectPool' },
+      { path: join(__dirname, '../../packages/universal/engine'), className: 'Descriptor' },
+      { path: join(__dirname, '../../packages/universal/engine'), className: 'InputSystem' },
+      { path: join(__dirname, '../../packages/universal/engine'), className: 'DynamicInterpreter' },
+    ]
+    this.rules = handlers.filter(handler => rules.includes(handler.className))
+  }
+
+  validate(path) {
+    for (const rule of this.rules) {
+      if (path.indexOf(rule.path) > -1 && path.indexOf(rule.className) > -1) return rule
+    }
+  }
+
+  wrapper(module, rule) {
+    const custom = {
+      loader: resolve(__dirname, './loaders/index'),
+      options: JSON.stringify({ className: rule.className })
+    }
+    module.loaders.push(custom)
+  }
+
+  compiler(module) {
+    if (!module.request) return
+    const rule = this.validate(module.request)
+    if (rule) return this.wrapper(module, rule)
+  }
+
+  apply(compiler) {
+    compiler.hooks.compilation.tap('class-wrapper-plugin', (compilation) => {
+      compilation.hooks.buildModule.tap('class-wrapper-plugin', (module) => this.compiler(module))
+    })
+  }
+}
+
+module.exports = ClassWrapperPlugin

package/loaders/descriptor.js

@@ -0,0 +1,89 @@
+const types = require('@babel/types');
+const { default: traverse } = require('@babel/traverse')
+const { vueImportDeclaration, wrapperDeclaration, wrapperIdentifier, wrapperCall, returnwrapper } = require('../utils')
+
+const pushRetuenStatement = (block) => {
+  // 假设block是一个BlockStatement节点  
+  if (!types.isBlockStatement(block)) return
+  // 获取BlockStatement的最后一个语句  
+  const lastStatement = block.body[block.body.length - 1];
+  // 检查这个语句是否是ReturnStatement  
+  if (types.isReturnStatement(lastStatement)) return
+  //添加 return 语句
+  block.body.push(returnwrapper)
+}
+const wrapperConstructor = (p) => {
+  p.traverse({
+    CallExpression(path) {
+      if (
+        types.isMemberExpression(path.node.callee) &&
+        path.node.callee.object.type === 'ThisExpression' &&
+        path.node.callee.property.name === 'add'
+      ) {
+
+        const newCallee = types.memberExpression(wrapperCall, types.identifier('add'));
+        path.node.callee = newCallee;
+      }
+    },
+    ReturnStatement(path) {
+      path.replaceWith(returnwrapper)
+    }
+  })
+  pushRetuenStatement(p.node.body)
+  p.stop()
+}
+const validateConstructor = (p, options) => {
+  if (types.isClassMethod(p.node) === false) return false
+  if (p.node.kind !== 'constructor') return false
+  return p.parentPath.parent.id.name === options.className
+}
+
+const wrapperMethod = (p) => {
+  const instance = p.node.params[0]
+  p.traverse({
+    MemberExpression(path) {
+      if (
+        path.node.object.type === 'Identifier' &&
+        path.node.object.name === 'instance' &&
+        !path.parentPath.isMemberExpression()
+      ) {
+        const vueCallInstance = types.callExpression(wrapperIdentifier, [instance]);
+        const newMemberExpression = types.memberExpression(vueCallInstance, path.node.property);
+        path.replaceWith(newMemberExpression);
+      }
+    }
+  })
+  p.stop()
+}
+const validateMethod = (p, options) => {
+  if (types.isClassMethod(p.node) === false) return false
+  if (p.node.kind !== 'method') return false
+  if (p.node.key.name !== 'beenInstantiated') return false
+  return p.parentPath.parent.id.name === options.className
+}
+
+const wrapperDescriptor = (ast, options) => {
+  //添加导入语句
+  ast.program.body.splice(2, 0, vueImportDeclaration)
+  ast.program.body.splice(3, 0, wrapperDeclaration)
+
+  traverse(ast, {
+    enter: (p) => {
+      if (validateConstructor(p, options)) wrapperConstructor(p)
+    }
+  })
+
+  traverse(ast, {
+    enter: (p) => {
+      if (validateMethod(p, options)) wrapperMethod(p)
+    }
+  })
+}
+const validateDescriptor = (options) => {
+  return options.className === 'Descriptor'
+}
+
+module.exports = {
+  wrapperDescriptor,
+  validateDescriptor,
+}

package/loaders/dynamic-interpreter.js

@@ -0,0 +1,54 @@
+const types = require('@babel/types');
+const { parse } = require('@babel/parser')
+const { default: traverse } = require('@babel/traverse')
+
+const wrapperMethod = (p) => {
+    const newCode = `
+        function checkCode(){
+            if (this._currentDepth > 3000) {
+                observer.trigger('__VYR_RUNTIME@remote', { type: 'Dynamic', uuid: this.unit.uuid })
+                return
+            }
+        }
+        `;
+
+    // 解析新代码为AST
+    const newAst = parse(newCode, {
+        sourceType: 'module',
+    });
+
+    // 获取函数声明中的函数体语句
+    const functionDeclaration = newAst.program.body[0];
+    const functionBodyStatements = functionDeclaration.body.body;
+
+    // 获取目标方法体的语句数组
+    const methodBody = p.node.body.body;
+
+    // 将函数体中的语句插入到目标方法体的开头
+    methodBody.unshift(...functionBodyStatements);
+
+    p.stop()
+}
+
+const validateMethod = (p, options) => {
+    if (types.isClassMethod(p.node) === false) return false
+    if (p.node.kind !== 'method') return false
+    if (p.node.key.name !== '_markSubDynamic') return false
+    return p.parentPath.parent.id.name === options.className
+}
+
+const wrapperDynamicInterpreter = (ast, options) => {
+    traverse(ast, {
+        enter: (p) => {
+            if (validateMethod(p, options)) wrapperMethod(p)
+        }
+    })
+}
+const validateDynamicInterpreter = (options) => {
+    return options.className === 'DynamicInterpreter'
+}
+
+module.exports = {
+    wrapperDynamicInterpreter,
+    validateDynamicInterpreter,
+}

package/loaders/index.js

@@ -0,0 +1,30 @@
+const { parse } = require('@babel/parser')
+const { default: generate } = require('@babel/generator');
+const { validateObjectPool, wrapperObjectPool } = require('./object-pool');
+const { validateDescriptor, wrapperDescriptor } = require('./descriptor');
+const { validateInputSystem, wrapperInputSystem } = require('./input-system');
+const { validateDynamicInterpreter, wrapperDynamicInterpreter } = require('./dynamic-interpreter')
+
+const wrappers = [
+  { validate: validateObjectPool, executor: wrapperObjectPool },
+  { validate: validateDescriptor, executor: wrapperDescriptor },
+  { validate: validateInputSystem, executor: wrapperInputSystem },
+  { validate: validateDynamicInterpreter, executor: wrapperDynamicInterpreter },
+]
+
+module.exports = function (source) {
+  const options = this.getOptions()
+
+  const ast = parse(source, { sourceType: 'module', plugins: ['typescript'] })
+
+  for (const wrapper of wrappers) {
+    if (wrapper.validate(options)) {
+      wrapper.executor(ast, options)
+      break
+    }
+  }
+
+  const { code } = generate(ast, { retainLines: false, concise: false, jsescOption: { minimal: true, sourceType: 'module' } })
+
+  return code
+}

package/loaders/input-system.js

@@ -0,0 +1,31 @@
+const types = require("@babel/types");
+const { default: traverse } = require("@babel/traverse");
+const { ifInputSystemStatement } = require("../utils");
+
+const wrapperMethod = (p) => {
+  p.node.body.body.unshift(ifInputSystemStatement);
+  p.stop();
+};
+
+const validateMethod = (p, options) => {
+  if (types.isClassMethod(p.node) === false) return false;
+  if (p.node.kind !== "method") return false;
+  if (p.node.key.name !== "listen") return false;
+  return p.parentPath.parent.id.name === options.className;
+};
+
+const wrapperInputSystem = (ast, options) => {
+  const onEnter = (p) => {
+    if (validateMethod(p, options)) wrapperMethod(p);
+  };
+
+  traverse(ast, { enter: onEnter });
+};
+const validateInputSystem = (options) => {
+  return options.className === "InputSystem";
+};
+
+module.exports = {
+  wrapperInputSystem,
+  validateInputSystem,
+};

package/loaders/object-pool.js

@@ -0,0 +1,79 @@
+const types = require('@babel/types');
+const { default: traverse } = require('@babel/traverse')
+const { vueImportDeclaration, wrapperDeclaration, wrapperIdentifier } = require('../utils')
+
+const replaceMethodGet = (path) => {
+    const left = path.node.argument.left;
+    const right = path.node.argument.right;
+    if (types.isNullLiteral(right)) {
+        // 提取 instance.deref() 表达式
+        const derefCall = left;
+        // 创建 const ref = instance.deref(); 语句
+        const refDeclaration = types.variableDeclaration('const', [
+            types.variableDeclarator(
+                types.identifier('ref'),
+                derefCall
+            )
+        ]);
+        // 创建 ref? v(ref) : null; 表达式
+        const conditionalExpression = types.conditionalExpression(
+            types.identifier('ref'),
+            types.callExpression(wrapperIdentifier, [types.identifier('ref')]),
+            types.nullLiteral()
+        );
+        // 替换原语句
+        path.replaceWith(refDeclaration);
+        path.insertAfter(types.returnStatement(conditionalExpression))
+    }
+}
+
+const wrapperMethod = (p, method) => {
+    p.traverse({
+        CallExpression(path) {
+            const { node } = path;
+
+            // 检查是否是 instance.deref() 调用
+            if (types.isMemberExpression(node.callee) &&
+                types.isIdentifier(node.callee.property, { name: "deref" }) &&
+                types.isIdentifier(node.callee.object, { name: "instance" }) &&
+                node.arguments.length === 0) {
+
+                const wrappedCall = types.callExpression(
+                    wrapperIdentifier,
+                    [node]
+                );
+                path.replaceWith(wrappedCall);
+
+                path.skip();
+            }
+        }
+    })
+}
+const validateMethod = (p, options) => {
+    if (types.isClassMethod(p.node) === false) return false
+    if (p.node.static === false) return false
+    if (p.parentPath.parent.id.name !== options.className) return
+    return ['get'].includes(p.node.key.name) ? p.node.key.name : false
+}
+
+const wrapperObjectPool = (ast, options) => {
+    //添加导入语句
+    ast.program.body.splice(2, 0, vueImportDeclaration)
+    ast.program.body.splice(3, 0, wrapperDeclaration)
+
+    traverse(ast, {
+        enter: (p) => {
+            const result = validateMethod(p, options)
+            if (result === false) return
+            wrapperMethod(p, result)
+        }
+    })
+}
+const validateObjectPool = (options) => {
+    return options.className === 'ObjectPool'
+}
+
+module.exports = {
+    wrapperObjectPool,
+    validateObjectPool,
+}

package/package.json

@@ -0,0 +1 @@
+{"name":"@vyr/pack-class-wrapper-plugin","version":"0.0.4","description":"","main":"./index.js","author":"","license":"ISC"}

package/utils.js

@@ -0,0 +1,79 @@
+const types = require('@babel/types');
+
+// 创建具名导入的标识符
+const reactiveIdentifier = types.identifier("reactive")
+
+// 构建 import { reactive } from 'vue'
+const vueImportDeclaration = types.importDeclaration(
+    [
+        types.importSpecifier(
+            reactiveIdentifier, // 导入的变量名
+            reactiveIdentifier  // 如果重命名，可以用 types.identifier('newName')
+        )
+    ],
+    types.stringLiteral('vue')
+);
+
+// 1. 构建条件表达式 (window['Runtime'] === 'editor')
+const windowRuntime = types.memberExpression(
+    types.identifier('window'),
+    types.stringLiteral('__VYR_RUNTIME_MODE'),
+    true // computed: true 因使用方括号访问
+);
+const runtimeCheck = types.binaryExpression(
+    '===',
+    windowRuntime,
+    types.stringLiteral('editor')
+);
+
+// 2. 构建 reactive 调用 (reactive(raw))
+const reactiveCall = types.callExpression(reactiveIdentifier, [types.identifier('raw')])
+
+// 3. 组装三元表达式
+const conditionalExpr = types.conditionalExpression(
+    runtimeCheck,
+    reactiveCall,
+    types.identifier('raw') // 直接返回 raw
+);
+
+// 4. 构建箭头函数体
+const returnStatement = types.returnStatement(conditionalExpr);
+const functionBody = types.blockStatement([returnStatement]);
+
+// 5. 创建箭头函数表达式
+const arrowFunction = types.arrowFunctionExpression(
+    [types.identifier('raw')], // 参数列表
+    functionBody
+);
+
+// 6. 组装变量声明
+const wrapperIdentifier = types.identifier('wrapper');
+const wrapperDeclarator = types.variableDeclarator(wrapperIdentifier, arrowFunction)
+const wrapperDeclaration = types.variableDeclaration('const', [wrapperDeclarator])
+const wrapperCall = types.callExpression(wrapperIdentifier, [types.thisExpression()])
+const returnwrapper = types.returnStatement(wrapperCall);
+
+const inputRuntime = types.memberExpression(
+    types.identifier('window'),
+    types.stringLiteral('__VYR_RUNTIME.DISABLED_INPUT'),
+    true
+);
+const disabledInputSystem = types.binaryExpression(
+    "===",
+    inputRuntime,
+    types.booleanLiteral(true)
+)
+const ifInputSystemStatement = types.ifStatement(
+    disabledInputSystem,
+    types.returnStatement(),
+    null
+)
+
+module.exports = {
+    vueImportDeclaration,
+    wrapperDeclaration,
+    wrapperIdentifier,
+    wrapperCall,
+    returnwrapper,
+    ifInputSystemStatement,
+}