@cocojs/compiler 0.1.0-beta202601082200

package/README.md

@@ -0,0 +1,10 @@
+# @cocojs/ts-compiler
+
+基于ts api 的转译程序。
+
+✨ **功能**
+- 组件添加`static $$id`属性
+- `@constructorParams()`装饰器添加入参
+- `@autowired()`装饰器添加入参
+- `@component()`装饰器添加入参
+

package/dist/index.cjs.js

@@ -0,0 +1,522 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ts = require('typescript');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ts__namespace = /*#__PURE__*/_interopNamespaceDefault(ts);
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: true
+          } : {
+            done: false,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = true,
+    u = false;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = true, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function (r) {
+      return Object.getOwnPropertyDescriptor(e, r).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
+      _defineProperty(e, r, t[r]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
+      Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+    });
+  }
+  return e;
+}
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+var wrapperClassName = ['String', 'Number', 'Boolean'];
+var innerClassName = ['Object', 'Symbol', 'Array', 'Map', 'Set', 'Function'];
+// {}
+function isObjectType(type) {
+  return !!type && ts__namespace.isTypeLiteralNode(type);
+}
+// []
+function isTupleArray(type) {
+  return !!type && ts__namespace.isTupleTypeNode(type);
+}
+// () => {}
+function isFunctionType(type) {
+  return !!type && ts__namespace.isFunctionTypeNode(type);
+}
+function isDecoratorExp(decorator, decoratorName) {
+  var expr = decorator.expression;
+  return ts__namespace.isCallExpression(expr) && ts__namespace.isIdentifier(expr.expression) && expr.expression.text === decoratorName;
+}
+function hasClassKindDecorator(classDeclaration) {
+  var _classDeclaration$mod;
+  return !!((_classDeclaration$mod = classDeclaration.modifiers) !== null && _classDeclaration$mod !== void 0 && _classDeclaration$mod.find(function (modifier) {
+    return ts__namespace.isDecorator(modifier);
+  }));
+}
+function extractIdentifierFromType(type) {
+  if (ts__namespace.isTypeReferenceNode(type)) {
+    if (ts__namespace.isIdentifier(type.typeName)) {
+      if (wrapperClassName.includes(type.typeName.text) || innerClassName.includes(type.typeName.text)) {
+        return ts__namespace.factory.createIdentifier('undefined');
+      }
+      return ts__namespace.factory.createIdentifier(type.typeName.text);
+    }
+  } else if (type.kind === ts__namespace.SyntaxKind.StringKeyword || type.kind === ts__namespace.SyntaxKind.NumberKeyword || type.kind === ts__namespace.SyntaxKind.BooleanKeyword || type.kind === ts__namespace.SyntaxKind.ObjectKeyword || type && ts__namespace.isLiteralTypeNode(type) && type.literal.kind === ts__namespace.SyntaxKind.NullKeyword || type.kind === ts__namespace.SyntaxKind.UndefinedKeyword || type.kind === ts__namespace.SyntaxKind.SymbolKeyword) {
+    return ts__namespace.factory.createIdentifier('undefined');
+  } else if (isObjectType(type) || isTupleArray(type) || isFunctionType(type)) {
+    return ts__namespace.factory.createIdentifier('undefined');
+  }
+  return undefined;
+}
+function createImport(className, importPath) {
+  return ts__namespace.factory.createImportDeclaration(undefined,
+  // modifiers
+  ts__namespace.factory.createImportClause(false, undefined, ts__namespace.factory.createNamedImports([ts__namespace.factory.createImportSpecifier(false, undefined, ts__namespace.factory.createIdentifier(className))])), ts__namespace.factory.createStringLiteral(importPath),
+  // 路径
+  undefined);
+}
+function updateTypeImports(sourceFile) {
+  var identifyList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  if (!identifyList.length) {
+    return sourceFile;
+  }
+  var importNames = new Set();
+  identifyList.forEach(function (iden) {
+    return importNames.add(iden.text);
+  });
+  var newStatements = [];
+  var _iterator = _createForOfIteratorHelper(sourceFile.statements),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var stmt = _step.value;
+      if (importNames.size === 0) {
+        newStatements.push(stmt);
+        continue;
+      }
+      if (ts__namespace.isImportDeclaration(stmt)) {
+        var _stmt$importClause$na;
+        if (((_stmt$importClause$na = stmt.importClause.namedBindings) === null || _stmt$importClause$na === void 0 ? void 0 : _stmt$importClause$na.kind) === ts__namespace.SyntaxKind.NamedImports) {
+          var findImport = stmt.importClause.namedBindings.elements.find(function (e) {
+            return importNames.has(e.name.text);
+          });
+          if (findImport) {
+            var name = findImport.name.text;
+            var importPath = stmt.moduleSpecifier.text;
+            newStatements.push(createImport('Render', 'coco-render'));
+            importNames["delete"](name);
+          }
+        }
+      }
+      newStatements.push(stmt);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return ts__namespace.factory.updateSourceFile(sourceFile, newStatements);
+}
+
+function isConstructParamsDecorator(decorator) {
+  return isDecoratorExp(decorator, 'constructorParam');
+}
+function extractIdentifiersFromConstructor(ctor) {
+  var identifiers = [];
+  var _iterator = _createForOfIteratorHelper(ctor.parameters),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var param = _step.value;
+      if (!param.type) {
+        return [];
+      }
+      var id = extractIdentifierFromType(param.type);
+      if (!id) {
+        return [];
+      }
+      identifiers.push(id);
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return identifiers;
+}
+function updateConstructorParamDecorator(classDeclaration) {
+  var modifiers = classDeclaration.modifiers;
+  if (!modifiers) {
+    return {
+      updated: false,
+      modifiers: classDeclaration.modifiers
+    };
+  }
+  var decorators = modifiers.filter(ts__namespace.isDecorator);
+  if (!decorators.length) {
+    return {
+      updated: false,
+      modifiers: classDeclaration.modifiers
+    };
+  }
+  var constructParams = decorators.find(isConstructParamsDecorator);
+  if (!constructParams) {
+    return {
+      updated: false,
+      modifiers: classDeclaration.modifiers
+    };
+  }
+  var call = constructParams.expression;
+  // 已有参数，不处理
+  if (call.arguments.length > 0) {
+    return {
+      updated: false,
+      modifiers: classDeclaration.modifiers
+    };
+  }
+  // 找 constructor
+  var ctor = classDeclaration.members.find(function (m) {
+    return ts__namespace.isConstructorDeclaration(m);
+  });
+  if (!ctor) {
+    return {
+      updated: false,
+      modifiers: classDeclaration.modifiers
+    };
+  }
+  var identifiers = extractIdentifiersFromConstructor(ctor);
+  if (!identifiers.length) {
+    return {
+      updated: false,
+      modifiers: classDeclaration.modifiers
+    };
+  }
+  // 构造数组：[Api, User]
+  var arrayLiteral = ts__namespace.factory.createArrayLiteralExpression(identifiers, false);
+  var newModifiers = modifiers.map(function (m) {
+    return ts__namespace.isDecorator(m) && m === constructParams ? ts__namespace.factory.createDecorator(ts__namespace.factory.updateCallExpression(call, call.expression, call.typeArguments, [arrayLiteral])) : m;
+  });
+  return {
+    updated: true,
+    modifiers: newModifiers,
+    constructorParamTypeList: identifiers
+  };
+}
+
+function isAutowiredDecorator(decorator) {
+  return isDecoratorExp(decorator, 'autowired');
+}
+function updateAutowiredDecorator(member, markUpdate) {
+  if (!ts__namespace.isPropertyDeclaration(member)) {
+    return member;
+  }
+  var modifiers = member.modifiers;
+  if (!modifiers) {
+    return member;
+  }
+  var decorators = modifiers.filter(ts__namespace.isDecorator);
+  if (!decorators.length) {
+    return member;
+  }
+  var autowired = decorators.find(isAutowiredDecorator);
+  if (!autowired) {
+    return member;
+  }
+  var call = autowired.expression;
+  // 已经有参数，不处理
+  if (call.arguments.length > 0) {
+    return member;
+  }
+  if (!member.type) {
+    return member;
+  }
+  var identifier = extractIdentifierFromType(member.type);
+  if (!identifier) {
+    return member;
+  }
+  markUpdate();
+  var newModifiers = modifiers.map(function (m) {
+    return ts__namespace.isDecorator(m) && m === autowired ? ts__namespace.factory.createDecorator(ts__namespace.factory.updateCallExpression(call, call.expression, call.typeArguments, [identifier])) : m;
+  });
+  return ts__namespace.factory.updatePropertyDeclaration(member, newModifiers, member.name, ts__namespace.factory.createToken(ts__namespace.SyntaxKind.ExclamationToken), member.type, member.initializer);
+}
+
+function isComponentDecorator(decorator) {
+  return isDecoratorExp(decorator, 'component');
+}
+function updateComponentDecorator(member, markUpdate) {
+  if (!ts__namespace.isMethodDeclaration(member)) {
+    return member;
+  }
+  var modifiers = member.modifiers;
+  if (!modifiers) {
+    return member;
+  }
+  var decorators = modifiers.filter(ts__namespace.isDecorator);
+  if (!decorators.length) {
+    return member;
+  }
+  var component = decorators.find(isComponentDecorator);
+  if (!component) {
+    return member;
+  }
+  var call = component.expression;
+  // 已有参数，不处理
+  if (call.arguments.length > 0) {
+    return member;
+  }
+  // 没有返回类型，无法补全
+  if (!member.type) {
+    return member;
+  }
+  var identifier = extractIdentifierFromType(member.type);
+  if (!identifier) {
+    return member;
+  }
+  markUpdate();
+  var newModifiers = modifiers.map(function (m) {
+    return ts__namespace.isDecorator(m) && m === component ? ts__namespace.factory.createDecorator(ts__namespace.factory.updateCallExpression(call, call.expression, call.typeArguments, [identifier])) : m;
+  });
+  return ts__namespace.factory.updateMethodDeclaration(member, newModifiers, member.asteriskToken, member.name, member.questionToken, member.typeParameters, member.parameters, member.type, member.body);
+}
+
+var innerIdName = '$$id';
+function ifNeedAdd$$idProperty(classDecorator, prefix) {
+  var className = classDecorator.name.text;
+  var $$idProperties = classDecorator.members.filter(function (member) {
+    var _member$modifiers;
+    return ts__namespace.isPropertyDeclaration(member) && ((_member$modifiers = member.modifiers) === null || _member$modifiers === void 0 ? void 0 : _member$modifiers.some(function (modify) {
+      return modify.kind === ts__namespace.SyntaxKind.StaticKeyword;
+    })) && ts__namespace.isIdentifier(member.name) && member.name.text === '$$id';
+  });
+  if ($$idProperties.length === 0) {
+    return ts__namespace.factory.createPropertyDeclaration([ts__namespace.factory.createModifier(ts__namespace.SyntaxKind.StaticKeyword)], innerIdName, undefined, undefined, ts__namespace.factory.createStringLiteral("".concat(prefix).concat(className)));
+  } else if ($$idProperties.length === 1) {
+    var property = $$idProperties[0];
+    if (property.initializer && ts__namespace.isStringLiteral(property.initializer)) {
+      if (!property.initializer.text.trim()) {
+        throw new Error("\u60F3\u8981\u4E3A\u7C7B".concat(className, "\u81EA\u5B9A\u4E49\"").concat(innerIdName, "\"\uFF0C\u503C\u4E0D\u80FD\u662F\u7A7A\u5B57\u7B26\u4E32"));
+      } else {
+        return null;
+      }
+    } else {
+      throw new Error("\u60F3\u8981\u4E3A\u7C7B".concat(className, "\u81EA\u5B9A\u4E49\"").concat(innerIdName, "\"\uFF0C\u503C\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u5B57\u9762\u91CF"));
+    }
+  } else {
+    throw new Error("\u7C7B".concat(className, "\u5B58\u5728\u591A\u4E2A\"").concat(innerIdName, "\"\uFF0C\u6700\u591A\u53EA\u80FD\u6709\u4E00\u4E2A\uFF01"));
+  }
+}
+
+function updateMembers(classDeclaration) {
+  var updated = false;
+  var markUpdate = function markUpdate() {
+    updated = true;
+  };
+  var members = classDeclaration.members.map(function (member) {
+    if (ts__namespace.isPropertyDeclaration(member)) {
+      return updateAutowiredDecorator(member, markUpdate);
+    } else if (ts__namespace.isMethodDeclaration(member)) {
+      return updateComponentDecorator(member, markUpdate);
+    } else {
+      return member;
+    }
+  });
+  return {
+    updated: updated,
+    members: updated ? members : classDeclaration.members
+  };
+}
+function transformerFactory() {
+  var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return function (context) {
+    var constructorParamTypeList;
+    var _visit = function visit(node) {
+      if (ts__namespace.isClassDeclaration(node)) {
+        if (hasClassKindDecorator(node)) {
+          var $$idProperty = ifNeedAdd$$idProperty(node, prefix);
+          var _updateMembers = updateMembers(node),
+            members = _updateMembers.members,
+            membersUpdated = _updateMembers.updated;
+          var _updateConstructorPar = updateConstructorParamDecorator(node),
+            modifiers = _updateConstructorPar.modifiers,
+            constructorParamsUpdated = _updateConstructorPar.updated,
+            _constructorParamTypeList = _updateConstructorPar.constructorParamTypeList;
+          if (!membersUpdated && !constructorParamsUpdated && !$$idProperty) {
+            return node;
+          } else {
+            if (constructorParamsUpdated) {
+              constructorParamTypeList = _constructorParamTypeList;
+            }
+            return ts__namespace.factory.updateClassDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, $$idProperty ? [$$idProperty].concat(_toConsumableArray(members)) : members);
+          }
+        }
+        return node;
+      } else {
+        return ts__namespace.visitEachChild(node, _visit, context);
+      }
+    };
+    // @ts-ignore
+    return function (sourceFile) {
+      var _constructorParamType;
+      var updatedSourceFile = ts__namespace.visitNode(sourceFile, _visit);
+      if (!((_constructorParamType = constructorParamTypeList) !== null && _constructorParamType !== void 0 && _constructorParamType.length)) {
+        return updatedSourceFile;
+      }
+      // TODO: @autowired和@component应该也要导入的。
+      return updateTypeImports(updatedSourceFile, constructorParamTypeList);
+    };
+  };
+}
+
+var commonCompilerOptions = {
+  target: ts__namespace.ScriptTarget.ESNext,
+  module: ts__namespace.ModuleKind.ESNext,
+  emitDecoratorMetadata: false
+};
+function compiler(files, outDir) {
+  var tsOptions = _objectSpread2(_objectSpread2({}, commonCompilerOptions), {}, {
+    outDir: outDir
+  });
+  var host = ts__namespace.createCompilerHost(tsOptions);
+  var program = ts__namespace.createProgram({
+    rootNames: files,
+    options: tsOptions,
+    host: host
+  });
+  var emitResult = program.emit(undefined, undefined, undefined, undefined, {
+    before: [transformerFactory()]
+  });
+  var diagnostics = ts__namespace.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  return diagnostics;
+}
+function compileOneFile(code, fileName) {
+  var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  var result = ts__namespace.transpileModule(code, {
+    fileName: fileName,
+    compilerOptions: _objectSpread2(_objectSpread2({}, commonCompilerOptions), {}, {
+      sourceMap: true
+    }),
+    transformers: {
+      before: [transformerFactory(prefix)]
+    }
+  });
+  return {
+    code: result.outputText,
+    map: result.sourceMapText
+  };
+}
+
+exports.commonCompilerOptions = commonCompilerOptions;
+exports.compileOneFile = compileOneFile;
+exports.default = compiler;
+exports.transformerFactory = transformerFactory;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import * as ts from 'typescript';
+
+export declare const commonCompilerOptions: ts.CompilerOptions;
+
+export declare function compileOneFile(code: string, fileName: string, prefix?: string): {
+    code: string;
+    map?: string;
+};
+
+declare function compiler(files: string[], outDir: string): ts.Diagnostic[];
+export default compiler;
+
+export declare function transformerFactory(prefix?: string): ts.TransformerFactory<ts.SourceFile>;
+
+export { }

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "@cocojs/compiler",
+    "version": "0.1.0-beta202601082200",
+    "description": "A Coco component transpiler built on the TypeScript compiler API.",
+    "main": "dist/index.cjs.js",
+    "types": "dist/index.d.ts",
+    "files": [
+        "dist"
+    ],
+    "scripts": {
+        "build": "tsc",
+        "jest": "jest"
+    },
+    "keywords": [],
+    "author": "jiangchenguang",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/cocojs-org/coconut-framework/issues"
+    },
+    "homepage": "https://github.com/cocojs-org/coconut-framework",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/cocojs-org/coconut-framework.git"
+    },
+    "devDependencies": {
+        "@types/jest": "^29.5.14",
+        "@types/node": "^22.13.1",
+        "jest": "^29.7.0",
+        "typescript": "5.3.3"
+    },
+    "peerDependencies": {
+        "typescript": "5.3.3"
+    }
+}