@vyr/cli 0.0.1

package/pack/auto-provider-plugin/index.js

@@ -0,0 +1,38 @@
+const { resolve, join } = require("path")
+
+class AutoProviderPlugin {
+
+    constructor(entrys) {
+        this.entrys = entrys.map(entry => join(process.cwd(), entry))
+    }
+
+    validate(path) {
+        for (const entry of this.entrys) {
+            if (path.indexOf(entry) > -1) return true
+        }
+
+        return false
+    }
+
+    provider(module) {
+        const custom = {
+            loader: resolve(__dirname, './loader'),
+            options: JSON.stringify({})
+        }
+        module.loaders.push(custom)
+    }
+
+    compiler(module) {
+        if (!module.request) return
+        if (this.validate(module.request) === false) return
+        this.provider(module)
+    }
+
+    apply(compiler) {
+        compiler.hooks.compilation.tap('auto-provider-plugin', (compilation) => {
+            compilation.hooks.buildModule.tap('auto-provider-plugin', (module) => this.compiler(module))
+        })
+    }
+}
+
+module.exports = AutoProviderPlugin

package/pack/auto-provider-plugin/loader.js

@@ -0,0 +1,53 @@
+const editorConfig = require('../../editor.config.json')
+
+const extensions = [
+    editorConfig.browser.runtime,
+    ...editorConfig.browser.extensions,
+    ...editorConfig.browser.remote,
+    ...editorConfig.browser.services.map(service => service.name),
+]
+
+module.exports = function (source) {
+    const options = this.getOptions()
+
+    const imports = [
+        `import axios from 'axios'`,
+        `import { Locale } from '@vyr/locale'`,
+        `const libs = [`,
+    ]
+    for (let i = 0; i < extensions.length; i++) {
+        const extension = extensions[i]
+        imports.push(`  { name:'__VYR_RUNTIME_${extension}',load:async () => import('${extension}')},`)
+    }
+    imports.push(`]`)
+
+    const codes = [
+        `const getConfig = async()=> {`,
+        `    const res = await axios.get('/cli/getConfig')`,
+        `    return res.data`,
+        `}`,
+        `const extensions = {}`,
+    ]
+
+    codes.push(
+        `const loadExtensions = async () => {`,
+        `     const config = await getConfig()`,
+        `     for(const provider of config.languageProviders) Locale.register(provider)`,
+        `     Locale.use(config.language)`,
+        `     const tasks = []`,
+        `     for (const lib of libs) {`,
+        `        const task = lib.load().then(res => window[lib.name] = res)`,
+        `        tasks.push(task)`,
+        `    } `,
+        `    await Promise.all(tasks)`,
+        `    return config`,
+        `}`,
+    )
+
+    const code = source
+        .replace('//__VYR_IMPORT', imports.join('\n'))
+        .replace('//__VYR_DEFINE', codes.join('\n'))
+        .replace('//__VYR_CONFIG', `const config = await loadExtensions()`)
+
+    return code
+}

package/pack/auto-provider-plugin/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@vyr/pack-auto-provider-plugin",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./index.js",
+  "author": "",
+  "license": "ISC"
+}

package/pack/class-wrapper-plugin/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/pack/class-wrapper-plugin/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/pack/class-wrapper-plugin/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/pack/class-wrapper-plugin/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/pack/class-wrapper-plugin/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/pack/class-wrapper-plugin/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/pack/class-wrapper-plugin/package.json

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

package/pack/class-wrapper-plugin/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,
+}

package/pack/rollup-config-plugin/build/index.d.ts

@@ -0,0 +1,3 @@
+declare const getRollupConfigContent: (outputFile: string, input: string, outputPath: string, external: string[]) => string;
+declare const createRollupConfigFactory: (config: string) => Function;
+export { getRollupConfigContent, createRollupConfigFactory, };

package/pack/rollup-config-plugin/build/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRollupConfigFactory = exports.getRollupConfigContent = void 0;
+const fs = require('fs-extra');
+const getRollupConfigContent = (outputFile, input, outputPath, external) => {
+    const configObj = {};
+    const config = [
+        `{`,
+        `    input: ${JSON.stringify(input)},`,
+        `    output: {`,
+        `        file: ${JSON.stringify(outputPath)},`,
+        `        format: 'cjs',`,
+        `        inlineDynamicImports: true,`,
+        `    },`,
+        `    external: ${JSON.stringify(external)},`,
+        `    plugins: [`,
+        `        nodeResolve({ preferBuiltins: true}),`,
+        `        commonjs({ ignoreDynamicRequires: true }),`,
+        `        esbuild(${JSON.stringify(configObj)}),`,
+        `        varRename(${JSON.stringify(external)}, ${JSON.stringify(outputFile)}),`,
+        `        json(),`,
+        `        postcss({ extract: false, minimize: true })`,
+        `    ],`,
+        `    treeshake: false,`,
+        `}`,
+    ].join('\n');
+    return config;
+};
+exports.getRollupConfigContent = getRollupConfigContent;
+const createRollupConfigFactory = (config) => {
+    const factory = new Function('nodeResolve', 'commonjs', 'json', 'postcss', 'esbuild', 'varRename', `return ${config}`);
+    return factory;
+};
+exports.createRollupConfigFactory = createRollupConfigFactory;

package/pack/rollup-config-plugin/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@vyr/pack-rollup-config-plugin",
+  "version": "0.0.1",
+  "description": "",
+  "main": "./build/index.js",
+  "author": "",
+  "license": "ISC"
+}

package/pack/rollup-config-plugin/src/index.ts

@@ -0,0 +1,47 @@
+const fs = require('fs-extra')
+
+const getRollupConfigContent = (outputFile: string, input: string, outputPath: string, external: string[]) => {
+    const configObj = {
+    }
+
+    const config = [
+        `{`,
+        `    input: ${JSON.stringify(input)},`,
+        `    output: {`,
+        `        file: ${JSON.stringify(outputPath)},`,
+        `        format: 'cjs',`,
+        `        inlineDynamicImports: true,`,
+        `    },`,
+        `    external: ${JSON.stringify(external)},`,
+        `    plugins: [`,
+        `        nodeResolve({ preferBuiltins: true}),`,
+        `        commonjs({ ignoreDynamicRequires: true }),`,
+        `        esbuild(${JSON.stringify(configObj)}),`,
+        `        varRename(${JSON.stringify(external)}, ${JSON.stringify(outputFile)}),`,
+        `        json(),`,
+        `        postcss({ extract: false, minimize: true })`,
+        `    ],`,
+        `    treeshake: false,`,
+        `}`,
+    ].join('\n')
+
+    return config
+}
+
+const createRollupConfigFactory = (config: string) => {
+    const factory = new Function(
+        'nodeResolve',
+        'commonjs',
+        'json',
+        'postcss',
+        'esbuild',
+        'varRename',
+        `return ${config}`)
+
+    return factory
+}
+
+export {
+    getRollupConfigContent,
+    createRollupConfigFactory,
+}

package/pack/rollup-config-plugin/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "lib": [
+      "ESNext",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "outDir": "build",
+    "strict": true,
+    "jsx": "preserve",
+    "declaration": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "useDefineForClassFields": true,
+    "sourceMap": false,
+    "baseUrl": "",
+    "types": [
+      "webpack-env"
+    ],
+    "paths": {}
+  },
+  "include": [
+    "src/**/*.ts",
+  ],
+  "exclude": []
+}