Lines Matching refs:ts
16 import ts from 'typescript';
139 export function processComponentClass(node: ts.StructDeclaration, context: ts.TransformationContext,
140 log: LogInfo[], program: ts.Program): ts.ClassDeclaration {
141 const memberNode: ts.ClassElement[] =
143 return ts.factory.createClassDeclaration(undefined, node.modifiers, node.name,
147 function checkPreview(node: ts.ClassDeclaration) {
165 function processMembers(members: ts.NodeArray<ts.ClassElement>, parentComponentName: ts.Identifier,
166 …context: ts.TransformationContext, log: LogInfo[], program: ts.Program, hasPreview: boolean): ts.C…
169 const newMembers: ts.ClassElement[] = [];
170 const watchMap: Map<string, ts.Node> = new Map();
171 const updateParamsStatements: ts.Statement[] = [];
172 const stateVarsStatements: ts.Statement[] = [];
173 const purgeVariableDepStatements: ts.Statement[] = [];
174 const rerenderStatements: ts.Statement[] = [];
175 const deleteParamsStatements: ts.PropertyDeclaration[] = [];
178 const interfaceNode = ts.factory.createInterfaceDeclaration(undefined, undefined,
180 members.forEach((item: ts.ClassElement) => {
181 let updateItem: ts.ClassElement;
182 if (ts.isPropertyDeclaration(item)) {
219 if (ts.isMethodDeclaration(item) && item.name) {
244 function assignParams(parentComponentName: string): ts.Statement[] {
245 return [ts.factory.createIfStatement(
246 ts.factory.createBinaryExpression(
247 … ts.factory.createTypeOfExpression(ts.factory.createIdentifier(COMPONENT_PARAMS_LAMBDA_FUNCTION)),
248 ts.factory.createToken(ts.SyntaxKind.EqualsEqualsEqualsToken),
249 ts.factory.createStringLiteral(FUNCTION)
251 ts.factory.createBlock(
252 [ts.factory.createExpressionStatement(ts.factory.createBinaryExpression(
253 ts.factory.createPropertyAccessExpression(
254 ts.factory.createThis(),
255 ts.factory.createIdentifier(COMPONENT_PARAMS_FUNCTION)
257 ts.factory.createToken(ts.SyntaxKind.EqualsToken),
258 ts.factory.createIdentifier(COMPONENT_PARAMS_LAMBDA_FUNCTION)
265 function isStaticProperty(property: ts.PropertyDeclaration): boolean {
267 return modifier.kind === ts.SyntaxKind.StaticKeyword;
271 function validateDecorators(item: ts.ClassElement, log: LogInfo[]): void {
273 item.decorators.map((decorator: ts.Decorator) => {
288 purgeVariableDepStatements: ts.Statement[]
298 newMembers: ts.ClassElement[],
299 parentComponentName: ts.Identifier,
300 updateParamsStatements: ts.Statement[],
301 purgeVariableDepStatements: ts.Statement[],
302 rerenderStatements: ts.Statement[],
303 stateVarsStatements: ts.Statement[]
317 function addPropertyMember(item: ts.ClassElement, newMembers: ts.ClassElement[],
318 program: ts.Program, parentComponentName: string, log: LogInfo[]): void {
319 const propertyItem: ts.PropertyDeclaration = item as ts.PropertyDeclaration;
321 let updatePropertyItem: ts.PropertyDeclaration;
322 const type: ts.TypeNode = propertyItem.type;
328 let newType: ts.TypeNode;
357 function createPropertyDeclaration(propertyItem: ts.PropertyDeclaration, newType: ts.TypeNode | und…
358 …normalVar: boolean, isLocalStorage: boolean = false, parentComponentName: string = null): ts.Prope…
366 const privateM: ts.ModifierToken<ts.SyntaxKind.PrivateKeyword> =
367 ts.factory.createModifier(ts.SyntaxKind.PrivateKeyword);
368 return ts.factory.updatePropertyDeclaration(propertyItem, undefined,
375 function createLocalStroageCallExpression(node: ts.PropertyDeclaration, name: string,
376 parentComponentName: string): ts.CallExpression {
380 const localValue: ts.Expression[] = [
381 ts.factory.createStringLiteral(localStorageLink && !localStorageProp ?
384 …node.initializer ? node.initializer : ts.factory.createNumericLiteral(COMPONENT_CONSTRUCTOR_UNDEFI…
385 ts.factory.createThis(), ts.factory.createStringLiteral(name || COMPONENT_CONSTRUCTOR_UNDEFINED)
395 return ts.factory.createCallExpression(
396 ts.factory.createPropertyAccessExpression(
398 ts.factory.createPropertyAccessExpression(
399 ts.factory.createThis(),
400 ts.factory.createIdentifier(`${COMPONENT_CONSTRUCTOR_LOCALSTORAGE}_`)
401 ) : ts.factory.createThis(),
402 ts.factory.createIdentifier(localFuncName)
409 function processComponentMethod(node: ts.MethodDeclaration, parentComponentName: ts.Identifier,
410 context: ts.TransformationContext, log: LogInfo[], buildCount: BuildCount): ts.MethodDeclaration {
411 let updateItem: ts.MethodDeclaration = node;
413 const customBuilder: ts.Decorator[] = [];
423 const buildNode: ts.MethodDeclaration = processComponentBuild(node, log);
425 } else if (node.body && ts.isBlock(node.body)) {
427 updateItem = ts.factory.updateMethodDeclaration(node, node.decorators, node.modifiers,
434 …let parameters: ts.NodeArray<ts.ParameterDeclaration> = ts.factory.createNodeArray(Array.from(node…
436 … const builderNode: ts.MethodDeclaration = ts.factory.updateMethodDeclaration(node, customBuilder,
443 if (ts.isBlock(node.body) && node.body.statements && node.body.statements.length) {
462 export function createParentParameter(): ts.ParameterDeclaration {
463 return ts.factory.createParameterDeclaration(undefined, undefined, undefined,
464 ts.factory.createIdentifier(COMPONENT_CONSTRUCTOR_PARENT), undefined, undefined,
465 ts.factory.createIdentifier(NULL));
468 export function processBuildMember(node: ts.MethodDeclaration | ts.FunctionDeclaration, context: ts…
469 log: LogInfo[], isBuilder = false): ts.MethodDeclaration | ts.FunctionDeclaration {
470 return ts.visitNode(node, visitBuild);
471 function visitBuild(node: ts.Node): ts.Node {
473 node = processGeometryView(node as ts.ExpressionStatement, log);
476 node = createReference(node as ts.PropertyAssignment, log, isBuilder);
478 if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name) &&
479 …stateObjectCollection.has(checkStateName(node)) && node.parent && ts.isCallExpression(node.parent)…
480 ts.isPropertyAccessExpression(node.parent.expression) && node !== node.parent.expression &&
482 return ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
483 ts.factory.createIdentifier(FOREACH_OBSERVED_OBJECT),
484 ts.factory.createIdentifier(FOREACH_GET_RAW_OBJECT)), undefined, [node]);
486 return ts.visitEachChild(node, visitBuild, context);
488 function checkStateName(node: ts.PropertyAccessExpression): string {
489 if (node.expression && !node.expression.expression && node.name && ts.isIdentifier(node.name)) {
496 function isGeometryView(node: ts.Node): boolean {
497 if (ts.isExpressionStatement(node) && ts.isCallExpression(node.expression)) {
498 const call: ts.CallExpression = node.expression;
499 const exp: ts.Expression = call.expression;
500 const args: ts.NodeArray<ts.Expression> = call.arguments;
501 if (ts.isPropertyAccessExpression(exp) && ts.isIdentifier(exp.expression) &&
502 exp.expression.escapedText.toString() === GEOMETRY_VIEW && ts.isIdentifier(exp.name) &&
504 (ts.isArrowFunction(args[0]) || ts.isFunctionExpression(args[0]))) {
511 function processGeometryView(node: ts.ExpressionStatement,
512 log: LogInfo[]): ts.ExpressionStatement {
513 const exp: ts.CallExpression = node.expression as ts.CallExpression;
514 const arg: ts.ArrowFunction | ts.FunctionExpression =
515 exp.arguments[0] as ts.ArrowFunction | ts.FunctionExpression;
516 return ts.factory.updateExpressionStatement(node, ts.factory.updateCallExpression(exp,
517 exp.expression, undefined, [ts.factory.createArrowFunction(undefined, undefined, arg.parameters,
518 undefined, ts.factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
522 function getGeometryReaderFunctionBlock(node: ts.ArrowFunction | ts.FunctionExpression,
523 log: LogInfo[]): ts.Block {
524 let blockNode: ts.Block;
525 if (ts.isBlock(node.body)) {
527 } else if (ts.isArrowFunction(node) && ts.isCallExpression(node.body)) {
528 blockNode = ts.factory.createBlock([ts.factory.createExpressionStatement(node.body)]);
533 function updateHeritageClauses(node: ts.StructDeclaration, log: LogInfo[])
534 : ts.NodeArray<ts.HeritageClause> {
542 const result:ts.HeritageClause[] = [];
543 const heritageClause:ts.HeritageClause = createHeritageClause();
545 return ts.factory.createNodeArray(result);
548 function checkHeritageClauses(node: ts.StructDeclaration): boolean {
551 const expressionNode: ts.ExpressionWithTypeArguments = node.heritageClauses[0].types[0];
552 if (expressionNode.expression && ts.isIdentifier(expressionNode.expression) &&
560 export function isProperty(node: ts.Node): Boolean {
562 if (node.parent.parent.expression && ts.isIdentifier(node.parent.parent.expression) &&
567 } else if (ts.isPropertyAccessExpression(node.parent.parent.expression) &&
568 ts.isIdentifier(node.parent.parent.expression.expression) &&
577 function judgmentParentType(node: ts.Node): boolean {
578 return ts.isPropertyAssignment(node) && node.name && ts.isIdentifier(node.name) &&
579 node.parent && ts.isObjectLiteralExpression(node.parent) && node.parent.parent &&
580 (ts.isCallExpression(node.parent.parent) || ts.isEtsComponentExpression(node.parent.parent));
583 export function createReference(node: ts.PropertyAssignment, log: LogInfo[], isBuilder = false,
584 isParamsLambda: boolean = false, isRecycleComponent: boolean = false): ts.PropertyAssignment {
587 const propertyName: ts.Identifier = node.name as ts.Identifier;
590 if (isRecycleComponent && ts.isShorthandPropertyAssignment(node)) {
593 const initExpression: ts.Expression = node.initializer;
595 if (ts.isIdentifier(initExpression) &&
598 } else if (ts.isPropertyAccessExpression(initExpression) && initExpression.expression &&
599 initExpression.expression.kind === ts.SyntaxKind.ThisKeyword &&
600 …ts.isIdentifier(initExpression.name) && initExpression.name.escapedText.toString().match(LINK_REG)…
602 …} else if (isBuilder && ts.isPropertyAccessExpression(initExpression) && initExpression.expression…
603 …ts.isIdentifier(initExpression.expression) && initExpression.expression.escapedText.toString() ===…
604 …ts.isIdentifier(initExpression.name) && linkParentComponent.includes(propertyName.escapedText.toSt…
617 function isMatchInitExpression(initExpression: ts.Expression): boolean {
618 return ts.isPropertyAccessExpression(initExpression) &&
620 initExpression.expression.kind === ts.SyntaxKind.ThisKeyword &&
621 ts.isIdentifier(initExpression.name);
624 function addDoubleUnderline(node: ts.PropertyAssignment, propertyName: ts.Identifier,
625 …initText: string, is$$ = false, isParamsLambda: boolean, isRecycleComponent: boolean): ts.Property…
626 return ts.factory.updatePropertyAssignment(node, propertyName,
627 ts.factory.createPropertyAccessExpression(
628 …is$$ && partialUpdateConfig.partialUpdateMode ? ts.factory.createIdentifier($$) : ts.factory.creat…
629 …isParamsLambda || isRecycleComponent ? ts.factory.createIdentifier(initText) : ts.factory.createId…
632 function getParentNode(node: ts.PropertyAssignment, collection: Map<string, Set<string>>): string[]…
633 const grandparentNode: ts.NewExpression = node.parent.parent as ts.NewExpression;
634 const grandparentExpression: ts.Identifier | ts.PropertyAccessExpression =
635 grandparentNode.expression as ts.Identifier | ts.PropertyAccessExpression;
638 if (ts.isIdentifier(grandparentExpression)) {
641 } else if (ts.isPropertyAccessExpression(grandparentExpression)) {
653 function addUpdateParamsFunc(statements: ts.Statement[], parentComponentName: ts.Identifier):
654 ts.MethodDeclaration {
658 function addInitialParamsFunc(statements: ts.Statement[], parentComponentName: ts.Identifier): ts.M…
662 function addUpdateStateVarsFunc(statements: ts.Statement[], parentComponentName: ts.Identifier): ts…
666 function addPurgeVariableDepFunc(statements: ts.Statement[]): ts.MethodDeclaration {
667 return ts.factory.createMethodDeclaration(
669 ts.factory.createIdentifier(COMPONENT_CONSTRUCTOR_PURGE_VARIABLE_DEP),
670 undefined, undefined, [ts.factory.createParameterDeclaration(undefined, undefined, undefined,
671 ts.factory.createIdentifier(RMELMTID), undefined, undefined, undefined)], undefined,
672 ts.factory.createBlock(statements, true));
675 function addDeleteParamsFunc(statements: ts.PropertyDeclaration[],
676 updateRecyle: boolean = false): ts.MethodDeclaration {
677 const deleteStatements: ts.ExpressionStatement[] = [];
678 const updateStatements: ts.ExpressionStatement[] = [];
679 statements.forEach((statement: ts.PropertyDeclaration) => {
680 const name: ts.Identifier = statement.name as ts.Identifier;
681 let paramsStatement: ts.ExpressionStatement;
693 const defaultStatement: ts.ExpressionStatement =
694 ts.factory.createExpressionStatement(ts.factory.createCallExpression(
695 ts.factory.createPropertyAccessExpression(
696 ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
697 ts.factory.createIdentifier(CREATE_CONSTRUCTOR_SUBSCRIBER_MANAGER),
698 ts.factory.createIdentifier(CREATE_CONSTRUCTOR_GET_FUNCTION)), undefined, []),
699 ts.factory.createIdentifier(CREATE_CONSTRUCTOR_DELETE_FUNCTION)),
700 undefined, [ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
701 ts.factory.createThis(), ts.factory.createIdentifier(
707 …const aboutToBeDeletedInternalStatement: ts.ExpressionStatement = createDeletedInternalStatement();
710 const deleteParamsMethod: ts.MethodDeclaration =
715 function createRecycleElmt(statements: ts.Statement[]): ts.MethodDeclaration {
716 return ts.factory.createMethodDeclaration(undefined, undefined, undefined,
717 ts.factory.createIdentifier(UPDATE_RECYCLE_ELMT_ID), undefined, undefined, [
718 ts.factory.createParameterDeclaration(undefined, undefined, undefined,
719 ts.factory.createIdentifier(OLD_ELMT_ID)),
720 ts.factory.createParameterDeclaration(undefined, undefined, undefined,
721 ts.factory.createIdentifier(NEW_ELMT_ID))
722 ], undefined, ts.factory.createBlock(statements, true));
725 function createParamsWithUnderlineStatement(name: ts.Identifier): ts.ExpressionStatement {
726 return ts.factory.createExpressionStatement(
727 ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
728 ts.factory.createPropertyAccessExpression(ts.factory.createThis(),
729 ts.factory.createIdentifier(`__${name.escapedText.toString()}`)),
730 ts.factory.createIdentifier(COMPONENT_CONSTRUCTOR_DELETE_PARAMS)), undefined, []));
733 function createElmtIdWithUnderlineStatement(name: ts.Identifier): ts.ExpressionStatement {
734 return ts.factory.createExpressionStatement(
735 ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
736 ts.factory.createPropertyAccessExpression(ts.factory.createThis(),
737 ts.factory.createIdentifier(`__${name.escapedText.toString()}`)),
738 ts.factory.createIdentifier(COMPONENT_UPDATE_ELMT_ID)), undefined, [
739 ts.factory.createIdentifier(OLD_ELMT_ID), ts.factory.createIdentifier(NEW_ELMT_ID)
743 function createDeletedInternalStatement(): ts.ExpressionStatement {
744 return ts.factory.createExpressionStatement(ts.factory.createCallExpression(
745 ts.factory.createPropertyAccessExpression(ts.factory.createThis(),
746 ts.factory.createIdentifier(ABOUTTOBEDELETEDINTERNAL)), undefined, []));
749 function addRerenderFunc(statements: ts.Statement[]): ts.MethodDeclaration {
750 let updateDirtyElementStatement: ts.Statement = ts.factory.createExpressionStatement(
751 ts.factory.createCallExpression(ts.factory.createPropertyAccessExpression(
752 ts.factory.createThis(), ts.factory.createIdentifier(UPDATEDIRTYELEMENTS)), undefined, []));
754 return ts.factory.createMethodDeclaration(undefined, undefined, undefined,
755 ts.factory.createIdentifier(COMPONENT_RERENDER_FUNCTION), undefined, undefined, [], undefined,
756 ts.factory.createBlock(statements, true));
759 function createParamsInitBlock(express: string, statements: ts.Statement[],
760 parentComponentName?: ts.Identifier): ts.MethodDeclaration {
761 const methodDeclaration: ts.MethodDeclaration = ts.factory.createMethodDeclaration(undefined,
762 undefined, undefined, ts.factory.createIdentifier(express), undefined, undefined,
763 [ts.factory.createParameterDeclaration(undefined, undefined, undefined,
765 ts.factory.createIdentifier(CREATE_CONSTRUCTOR_PARAMS), undefined,
767 ts.factory.createTypeReferenceNode(
768 … ts.factory.createIdentifier(parentComponentName.getText() + INTERFACE_NAME_SUFFIX), undefined),
769 undefined)], undefined, ts.factory.createBlock(statements, true));
773 function validateBuildMethodCount(buildCount: BuildCount, parentComponentName: ts.Identifier,
784 function validateHasController(componentName: ts.Identifier, checkController: ControllerType,
795 function createHeritageClause(): ts.HeritageClause {
797 return ts.factory.createHeritageClause(
798 ts.SyntaxKind.ExtendsKeyword,
799 …[ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier(BASE_COMPONENT_NAME_PU),…
802 return ts.factory.createHeritageClause(
803 ts.SyntaxKind.ExtendsKeyword,
804 …[ts.factory.createExpressionWithTypeArguments(ts.factory.createIdentifier(BASE_COMPONENT_NAME), []…
808 function createTypeReference(decoratorName: string, type: ts.TypeNode, log: LogInfo[],
809 program: ts.Program): ts.TypeNode {
810 let newType: ts.TypeNode;
814 newType = ts.factory.createTypeReferenceNode(
818 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
823 newType = ts.factory.createTypeReferenceNode(
827 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
831 newType = ts.factory.createTypeReferenceNode(
833 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
837 newType = ts.factory.createTypeReferenceNode(
839 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
844 newType = ts.factory.createTypeReferenceNode(OBSERVED_PROPERTY_ABSTRACT, [
845 type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
850 newType = ts.factory.createTypeReferenceNode(OBSERVED_PROPERTY_ABSTRACT, [
851 type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
858 function createTypeReferencePU(decoratorName: string, type: ts.TypeNode, log: LogInfo[],
859 program: ts.Program): ts.TypeNode {
860 let newType: ts.TypeNode;
864 newType = ts.factory.createTypeReferenceNode(
868 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
872 newType = ts.factory.createTypeReferenceNode(
876 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
880 newType = ts.factory.createTypeReferenceNode(
882 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
886 newType = ts.factory.createTypeReferenceNode(
888 [type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword)]
894 newType = ts.factory.createTypeReferenceNode(OBSERVED_PROPERTY_ABSTRACT_PU, [
895 type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
900 newType = ts.factory.createTypeReferenceNode(OBSERVED_PROPERTY_ABSTRACT_PU, [
901 type || ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),