@cocojs/compiler 0.1.0-beta.202601082201

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) jiangchenguang.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

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

package/dist/index.cjs.js

@@ -0,0 +1,536 @@
+'use strict';
+
+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 createNamedImport(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 createImport(className, importPath) {
+  return ts__namespace.factory.createImportDeclaration(undefined, ts__namespace.factory.createImportClause(undefined, ts__namespace.factory.createIdentifier(className), undefined), 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(importNames),
+    _step;
+  try {
+    var _loop = function _loop() {
+      var name = _step.value;
+      var _iterator2 = _createForOfIteratorHelper(sourceFile.statements),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var stmt = _step2.value;
+          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 match = stmt.importClause.namedBindings.elements.find(function (e) {
+                return name === e.name.text;
+              });
+              if (match) {
+                var importPath = stmt.moduleSpecifier.text;
+                newStatements.push(createNamedImport(name, importPath));
+                break;
+              }
+            }
+            if (stmt.importClause.name && ts__namespace.isIdentifier(stmt.importClause.name)) {
+              if (stmt.importClause.name.text === name) {
+                var _importPath = stmt.moduleSpecifier.text;
+                newStatements.push(createImport(name, _importPath));
+                break;
+              }
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+    };
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      _loop();
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return ts__namespace.factory.updateSourceFile(sourceFile, [].concat(newStatements, _toConsumableArray(sourceFile.statements)));
+}
+
+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(identifier);
+  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(identifier);
+  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 autowiredList = [];
+  var componentList = [];
+  var updateAutowired = function updateAutowired(identifier) {
+    autowiredList.push(identifier);
+    updated = true;
+  };
+  var updateComponent = function updateComponent(identifier) {
+    componentList.push(identifier);
+    updated = true;
+  };
+  var members = classDeclaration.members.map(function (member) {
+    if (ts__namespace.isPropertyDeclaration(member)) {
+      return updateAutowiredDecorator(member, updateAutowired);
+    } else if (ts__namespace.isMethodDeclaration(member)) {
+      return updateComponentDecorator(member, updateComponent);
+    } else {
+      return member;
+    }
+  });
+  return {
+    updated: updated,
+    members: updated ? members : classDeclaration.members,
+    autowiredList: autowiredList,
+    componentList: componentList
+  };
+}
+function transformerFactory() {
+  var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
+  return function (context) {
+    var constructorParamList = [];
+    var autowiredList = [];
+    var componentList = [];
+    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,
+            _autowiredList = _updateMembers.autowiredList,
+            _componentList = _updateMembers.componentList;
+          var _updateConstructorPar = updateConstructorParamDecorator(node),
+            modifiers = _updateConstructorPar.modifiers,
+            constructorParamsUpdated = _updateConstructorPar.updated,
+            _constructorParamTypeList = _updateConstructorPar.constructorParamTypeList;
+          if (!membersUpdated && !constructorParamsUpdated && !$$idProperty) {
+            return node;
+          } else {
+            if (_autowiredList) {
+              autowiredList = _autowiredList;
+            }
+            if (_componentList) {
+              componentList = _componentList;
+            }
+            if (constructorParamsUpdated) {
+              constructorParamList = _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 updatedSourceFile = ts__namespace.visitNode(sourceFile, _visit);
+      if (!constructorParamList.length && !autowiredList.length && !componentList.length) {
+        return updatedSourceFile;
+      }
+      return updateTypeImports(updatedSourceFile, [].concat(_toConsumableArray(constructorParamList), _toConsumableArray(autowiredList), _toConsumableArray(componentList)));
+    };
+  };
+}
+
+var commonCompilerOptions = {
+  target: ts__namespace.ScriptTarget.ESNext,
+  module: ts__namespace.ModuleKind.ESNext,
+  emitDecoratorMetadata: false
+};
+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.transformerFactory = transformerFactory;

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+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;
+};
+
+export declare function transformerFactory(prefix?: string): ts.TransformerFactory<ts.SourceFile>;
+
+export { }

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@cocojs/compiler",
+  "version": "0.1.0-beta.202601082201",
+  "description": "A Coco component transpiler built on the TypeScript compiler API.",
+  "main": "dist/index.cjs.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "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"
+  },
+  "dependencies": {
+    "typescript": "5.3.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "jest": "jest"
+  }
+}