@cocojs/compiler 0.1.0-beta.202601082201 → 0.1.0-beta.202601082202

package/dist/index.esm.js

@@ -0,0 +1,513 @@
+import * as ts from 'typescript';
+
+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.isTypeLiteralNode(type);
+}
+// []
+function isTupleArray(type) {
+  return !!type && ts.isTupleTypeNode(type);
+}
+// () => {}
+function isFunctionType(type) {
+  return !!type && ts.isFunctionTypeNode(type);
+}
+function isDecoratorExp(decorator, decoratorName) {
+  var expr = decorator.expression;
+  return ts.isCallExpression(expr) && ts.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.isDecorator(modifier);
+  }));
+}
+function extractIdentifierFromType(type) {
+  if (ts.isTypeReferenceNode(type)) {
+    if (ts.isIdentifier(type.typeName)) {
+      if (wrapperClassName.includes(type.typeName.text) || innerClassName.includes(type.typeName.text)) {
+        return ts.factory.createIdentifier('undefined');
+      }
+      return ts.factory.createIdentifier(type.typeName.text);
+    }
+  } else if (type.kind === ts.SyntaxKind.StringKeyword || type.kind === ts.SyntaxKind.NumberKeyword || type.kind === ts.SyntaxKind.BooleanKeyword || type.kind === ts.SyntaxKind.ObjectKeyword || type && ts.isLiteralTypeNode(type) && type.literal.kind === ts.SyntaxKind.NullKeyword || type.kind === ts.SyntaxKind.UndefinedKeyword || type.kind === ts.SyntaxKind.SymbolKeyword) {
+    return ts.factory.createIdentifier('undefined');
+  } else if (isObjectType(type) || isTupleArray(type) || isFunctionType(type)) {
+    return ts.factory.createIdentifier('undefined');
+  }
+  return undefined;
+}
+function createNamedImport(className, importPath) {
+  return ts.factory.createImportDeclaration(undefined,
+  // modifiers
+  ts.factory.createImportClause(false, undefined, ts.factory.createNamedImports([ts.factory.createImportSpecifier(false, undefined, ts.factory.createIdentifier(className))])), ts.factory.createStringLiteral(importPath), undefined);
+}
+function createImport(className, importPath) {
+  return ts.factory.createImportDeclaration(undefined, ts.factory.createImportClause(undefined, ts.factory.createIdentifier(className), undefined), ts.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.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.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.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.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.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.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.factory.createArrayLiteralExpression(identifiers, false);
+  var newModifiers = modifiers.map(function (m) {
+    return ts.isDecorator(m) && m === constructParams ? ts.factory.createDecorator(ts.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.isPropertyDeclaration(member)) {
+    return member;
+  }
+  var modifiers = member.modifiers;
+  if (!modifiers) {
+    return member;
+  }
+  var decorators = modifiers.filter(ts.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.isDecorator(m) && m === autowired ? ts.factory.createDecorator(ts.factory.updateCallExpression(call, call.expression, call.typeArguments, [identifier])) : m;
+  });
+  return ts.factory.updatePropertyDeclaration(member, newModifiers, member.name, ts.factory.createToken(ts.SyntaxKind.ExclamationToken), member.type, member.initializer);
+}
+
+function isComponentDecorator(decorator) {
+  return isDecoratorExp(decorator, 'component');
+}
+function updateComponentDecorator(member, markUpdate) {
+  if (!ts.isMethodDeclaration(member)) {
+    return member;
+  }
+  var modifiers = member.modifiers;
+  if (!modifiers) {
+    return member;
+  }
+  var decorators = modifiers.filter(ts.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.isDecorator(m) && m === component ? ts.factory.createDecorator(ts.factory.updateCallExpression(call, call.expression, call.typeArguments, [identifier])) : m;
+  });
+  return ts.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.isPropertyDeclaration(member) && ((_member$modifiers = member.modifiers) === null || _member$modifiers === void 0 ? void 0 : _member$modifiers.some(function (modify) {
+      return modify.kind === ts.SyntaxKind.StaticKeyword;
+    })) && ts.isIdentifier(member.name) && member.name.text === '$$id';
+  });
+  if ($$idProperties.length === 0) {
+    return ts.factory.createPropertyDeclaration([ts.factory.createModifier(ts.SyntaxKind.StaticKeyword)], innerIdName, undefined, undefined, ts.factory.createStringLiteral("".concat(prefix).concat(className)));
+  } else if ($$idProperties.length === 1) {
+    var property = $$idProperties[0];
+    if (property.initializer && ts.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.isPropertyDeclaration(member)) {
+      return updateAutowiredDecorator(member, updateAutowired);
+    } else if (ts.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.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.factory.updateClassDeclaration(node, modifiers, node.name, node.typeParameters, node.heritageClauses, $$idProperty ? [$$idProperty].concat(_toConsumableArray(members)) : members);
+          }
+        }
+        return node;
+      } else {
+        return ts.visitEachChild(node, _visit, context);
+      }
+    };
+    // @ts-ignore
+    return function (sourceFile) {
+      var updatedSourceFile = ts.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.ScriptTarget.ESNext,
+  module: ts.ModuleKind.ESNext,
+  emitDecoratorMetadata: false
+};
+function compileOneFile(code, fileName) {
+  var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : '';
+  var result = ts.transpileModule(code, {
+    fileName: fileName,
+    compilerOptions: _objectSpread2(_objectSpread2({}, commonCompilerOptions), {}, {
+      sourceMap: true
+    }),
+    transformers: {
+      before: [transformerFactory(prefix)]
+    }
+  });
+  return {
+    code: result.outputText,
+    map: result.sourceMapText
+  };
+}
+
+export { commonCompilerOptions, compileOneFile, transformerFactory };

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@cocojs/compiler",
-  "version": "0.1.0-beta.202601082201",
+  "version": "0.1.0-beta.202601082202",
   "description": "A Coco component transpiler built on the TypeScript compiler API.",
   "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
   "types": "dist/index.d.ts",
   "files": [
     "dist"